refactor: change stride and offset parameter names

Author: gunjjoshi

lib/node_modules/@stdlib/fft/base/fftpack/decompose/README.md

@@ -40,7 +40,7 @@ limitations under the License.
 var decompose = require( '@stdlib/fft/base/fftpack/decompose' );
 ```
 
-#### decompose( N, M, initial, strideInitial, offsetInitial, out, strideOut, offsetOut )
+#### decompose( N, M, initial, si, oi, out, so, oo )
 
 Factorizes a sequence length into a product of integers.
 
@@ -61,11 +61,11 @@ The function accepts the following arguments:
 -   **N**: length of the sequence.
 -   **M**: number of trial divisors.
 -   **initial**: array of initial trial divisors.
--   **strideInitial**: stride length for `initial`.
--   **offsetInitial**: starting index for `initial`.
+-   **si**: stride length for `initial`.
+-   **oi**: starting index for `initial`.
 -   **out**: output array for storing factorization results.
--   **strideOut**: stride length for `out`.
--   **offsetOut**: starting index for `out`.
+-   **so**: stride length for `out`.
+-   **oo**: starting index for `out`.
 
 The function returns the number of factors into which `N` was decomposed.
 

lib/node_modules/@stdlib/fft/base/fftpack/decompose/docs/repl.txt

@@ -1,5 +1,5 @@
 
-{{alias}}( N, M, initial, strideInitial, offsetInitial, out, strideOut, offsetOut )
+{{alias}}( N, M, initial, si, oi, out, so, oo )
     Factorizes a sequence length into a product of integers.
 
     Factorization results are stored in the output array sequentially, where
@@ -20,19 +20,19 @@
     initial: Collection<number>
         Array of initial trial divisors.
 
-    strideInitial: number
+    si: number
         Stride length for `initial`.
 
-    offsetInitial: number
+    oi: number
         Starting index for `initial`.
 
     out: Collection<number>
         Output array for storing factorization results.
 
-    strideOut: number
+    so: number
         Stride length for `out`.
 
-    offsetOut: number
+    oo: number
         Starting index for `out`.
 
     Returns

lib/node_modules/@stdlib/fft/base/fftpack/decompose/docs/types/index.d.ts

@@ -28,11 +28,11 @@ import { Collection } from '@stdlib/types/array';
 * @param N - length of the sequence
 * @param M - number of trial divisors
 * @param initial - array of initial trial divisors
-* @param strideInitial - stride length for `initial`
-* @param offsetInitial - starting index for `initial`
+* @param si - stride length for `initial`
+* @param oi - starting index for `initial`
 * @param out - output array for storing factorization results
-* @param strideOut - stride length for `out`
-* @param offsetOut - starting index for `out`
+* @param so - stride length for `out`
+* @param oo - starting index for `out`
 * @returns number of factors into which `N` was decomposed
 *
 * @example
@@ -42,7 +42,7 @@ import { Collection } from '@stdlib/types/array';
 * var numFactors = decompose( 12, 4, initial, 1, 0, factors, 1, 0 );
 * // returns 2
 */
-declare function decompose( N: number, M: number, initial: Collection<number>, strideInitial: number, offsetInitial: number, out: Collection<number>, strideOut: number, offsetOut: number ): number;
+declare function decompose( N: number, M: number, initial: Collection<number>, si: number, oi: number, out: Collection<number>, so: number, oo: number ): number;
 
 
 // EXPORTS //

lib/node_modules/@stdlib/fft/base/fftpack/decompose/lib/main.js

@@ -80,11 +80,11 @@ var floor = require( '@stdlib/math/base/special/floor' );
 * @param {NonNegativeInteger} N - length of the sequence
 * @param {NonNegativeInteger} M - number of trial divisors
 * @param {NonNegativeIntegerArray} initial - strided array of initial trial divisors
-* @param {integer} strideInitial - stride length for `initial`
-* @param {NonNegativeInteger} offsetInitial - starting index for `initial`
+* @param {integer} si - stride length for `initial`
+* @param {NonNegativeInteger} oi - starting index for `initial`
 * @param {Collection} out - output array for storing factorization results
-* @param {integer} strideOut - stride length for `out`
-* @param {NonNegativeInteger} offsetOut - starting index for `out`
+* @param {integer} so - stride length for `out`
+* @param {NonNegativeInteger} oo - starting index for `out`
 * @returns {NonNegativeInteger} number of factors into which `N` was decomposed
 *
 * @example
@@ -109,7 +109,7 @@ var floor = require( '@stdlib/math/base/special/floor' );
 * var f = factors.slice();
 * // returns [ 8, 2, 2, 4 ]
 */
-function decompose( N, M, initial, strideInitial, offsetInitial, out, strideOut, offsetOut ) { // eslint-disable-line max-len
+function decompose( N, M, initial, si, oi, out, so, oo ) { // eslint-disable-line max-len
 	var divisor;
 	var ntrials;
 	var nl;
@@ -121,8 +121,8 @@ function decompose( N, M, initial, strideInitial, offsetInitial, out, strideOut,
 	var j;
 
 	if ( N === 0 ) {
-		out[ offsetOut ] = N;
-		out[ offsetOut+strideOut ] = 0;
+		out[ oo ] = N;
+		out[ oo+so ] = 0;
 		return 0;
 	}
 
@@ -141,7 +141,7 @@ function decompose( N, M, initial, strideInitial, offsetInitial, out, strideOut,
 	j = 0;
 	do {
 		if ( j < ntrials ) {
-			divisor = initial[ offsetInitial + (j * strideInitial) ];
+			divisor = initial[ oi + (j * si) ];
 		} else {
 			divisor += 2;
 		}
@@ -164,15 +164,15 @@ function decompose( N, M, initial, strideInitial, offsetInitial, out, strideOut,
 			nl = nq;
 
 			// Store the factor in the output array:
-			out[ offsetOut+((nf+1)*strideOut) ] = divisor;
+			out[ oo+((nf+1)*so) ] = divisor;
 
 			// When the divisor is `2` and we've already found other factors, shift the other factors right to make room for the most recent `2` factor...
 			if ( divisor === 2 && nf !== 1 ) {
 				for ( i = 2; i <= nf; i++ ) {
 					ib = nf - i + 2;
-					out[ offsetOut+((ib+1)*strideOut) ] = out[ offsetOut + (ib*strideOut) ]; // eslint-disable-line max-len
+					out[ oo+((ib+1)*so) ] = out[ oo + (ib*so) ]; // eslint-disable-line max-len
 				}
-				out[ offsetOut+(2*strideOut) ] = 2;
+				out[ oo+(2*so) ] = 2;
 			}
 			// If we cannot further divide the sequence length into smaller sub-sequences, we're done...
 			if ( nl === 1 ) {
@@ -182,10 +182,10 @@ function decompose( N, M, initial, strideInitial, offsetInitial, out, strideOut,
 	} while ( nl !== 1 );
 
 	// Store the sequence length:
-	out[ offsetOut ] = N;
+	out[ oo ] = N;
 
 	// Store the number of factors:
-	out[ offsetOut+strideOut ] = nf;
+	out[ oo+so ] = nf;
 
 	// Return the number of factors:
 	return nf;

lib/node_modules/@stdlib/fft/base/fftpack/decompose/test/test.js

@@ -109,19 +109,19 @@ tape( 'the function returns expected results when provided a sequence length of
 });
 
 tape( 'the function correctly handles stride and offset parameters', function test( t ) {
-	var strideOut = 2;
-	var offsetOut = 1;
 	var factors;
+	var so = 2;
+	var oo = 1;
 	var nf;
 
 	factors = [ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 ];
-	nf = decompose( 12, 4, INITIAL, 1, 0, factors, strideOut, offsetOut );
+	nf = decompose( 12, 4, INITIAL, 1, 0, factors, so, oo );
 
 	t.strictEqual( nf, 2, 'returns expected number of factors' );
-	t.strictEqual( factors[ offsetOut ], 12, 'stores sequence length at offset' );
-	t.strictEqual( factors[ offsetOut+strideOut ], 2, 'stores number of factors at offset + stride' );
-	t.strictEqual( factors[ offsetOut+(2*strideOut) ], 3, 'stores first factor at offset + 2*stride' );
-	t.strictEqual( factors[ offsetOut+(3*strideOut) ], 4, 'stores second factor at offset + 3*stride' );
+	t.strictEqual( factors[ oo ], 12, 'stores sequence length at offset' );
+	t.strictEqual( factors[ oo+so ], 2, 'stores number of factors at offset + stride' );
+	t.strictEqual( factors[ oo+(2*so) ], 3, 'stores first factor at offset + 2*stride' );
+	t.strictEqual( factors[ oo+(3*so) ], 4, 'stores second factor at offset + 3*stride' );
 
 	t.end();
 });