Merge branch 'stdlib-js:develop' into feat/gammainc-c

Author: anandkaranubc

lib/node_modules/@stdlib/_tools/pkgs/repl-help/lib/config.json

@@ -1,5 +1,5 @@
 {
-	"pattern": "**/package.json",
-	"filename": "docs/repl.txt",
-	"ignore": []
+  "pattern": "**/package.json",
+  "filename": "docs/repl.txt",
+  "ignore": []
 }

lib/node_modules/@stdlib/blas/base/README.md

@@ -88,7 +88,7 @@ var o = blas;
 -   <span class="signature">[`zaxpy( N, alpha, x, strideX, y, strideY )`][@stdlib/blas/base/zaxpy]</span><span class="delimiter">: </span><span class="description">scale a double-precision complex floating-point vector by a double-precision complex floating-point constant and add the result to a double-precision complex floating-point vector.</span>
 -   <span class="signature">[`zcopy( N, x, strideX, y, strideY )`][@stdlib/blas/base/zcopy]</span><span class="delimiter">: </span><span class="description">copy values from one complex double-precision floating-point vector to another complex double-precision floating-point vector.</span>
 -   <span class="signature">[`zdrot( N, x, strideX, y, strideY, c, s )`][@stdlib/blas/base/zdrot]</span><span class="delimiter">: </span><span class="description">apply a plane rotation.</span>
--   <span class="signature">[`zdscal( N, da, zx, strideZX )`][@stdlib/blas/base/zdscal]</span><span class="delimiter">: </span><span class="description">scale a double-precision complex floating-point vector by a double-precision floating-point constant.</span>
+-   <span class="signature">[`zdscal( N, alpha, x, strideX )`][@stdlib/blas/base/zdscal]</span><span class="delimiter">: </span><span class="description">scale a double-precision complex floating-point vector by a double-precision floating-point constant.</span>
 -   <span class="signature">[`zscal( N, alpha, x, strideX )`][@stdlib/blas/base/zscal]</span><span class="delimiter">: </span><span class="description">scales a double-precision complex floating-point vector by a double-precision complex floating-point constant.</span>
 -   <span class="signature">[`zswap( N, x, strideX, y, strideY )`][@stdlib/blas/base/zswap]</span><span class="delimiter">: </span><span class="description">interchange two complex double-precision floating-point vectors.</span>
 

lib/node_modules/@stdlib/blas/base/csscal/lib/csscal.js

@@ -30,7 +30,7 @@ var ndarray = require( './ndarray.js' );
 * Scales a single-precision complex floating-point vector by a single-precision floating-point constant.
 *
 * @param {PositiveInteger} N - number of indexed elements
-* @param {number} alpha - constant
+* @param {number} alpha - scalar constant
 * @param {Complex64Array} x - input array
 * @param {integer} strideX - `x` stride length
 * @returns {Complex64Array} input array

lib/node_modules/@stdlib/blas/base/csscal/lib/ndarray.js

@@ -30,7 +30,7 @@ var scale = require( '@stdlib/complex/float32/base/scale' ).strided;
 * Scales a single-precision complex floating-point vector by a single-precision floating-point constant.
 *
 * @param {PositiveInteger} N - number of indexed elements
-* @param {number} alpha - constant
+* @param {number} alpha - scalar constant
 * @param {Complex64Array} x - input array
 * @param {integer} strideX - `x` stride length
 * @param {NonNegativeInteger} offsetX - starting `x` index

lib/node_modules/@stdlib/blas/base/sgemm/lib/ndarray.js

@@ -79,7 +79,7 @@ function sgemm( transA, transB, M, N, K, alpha, A, strideA1, strideA2, offsetA,
 		throw new RangeError( format( 'invalid argument. Third argument must be a nonnegative integer. Value: `%d`.', M ) );
 	}
 	if ( N < 0 ) {
-		throw new RangeError( format( 'invalid argument. Fourth argument must be a nonnegative integer. Value: `%d`.', M ) );
+		throw new RangeError( format( 'invalid argument. Fourth argument must be a nonnegative integer. Value: `%d`.', N ) );
 	}
 	if ( K < 0 ) {
 		throw new RangeError( format( 'invalid argument. Fifth argument must be a nonnegative integer. Value: `%d`.', K ) );

lib/node_modules/@stdlib/blas/base/sgemm/lib/sgemm.js

@@ -95,7 +95,7 @@ function sgemm( order, transA, transB, M, N, K, alpha, A, LDA, B, LDB, beta, C,
 		throw new RangeError( format( 'invalid argument. Fourth argument must be a nonnegative integer. Value: `%d`.', M ) );
 	}
 	if ( N < 0 ) {
-		throw new RangeError( format( 'invalid argument. Fifth argument must be a nonnegative integer. Value: `%d`.', M ) );
+		throw new RangeError( format( 'invalid argument. Fifth argument must be a nonnegative integer. Value: `%d`.', N ) );
 	}
 	if ( K < 0 ) {
 		throw new RangeError( format( 'invalid argument. Sixth argument must be a nonnegative integer. Value: `%d`.', K ) );

lib/node_modules/@stdlib/blas/base/zdscal/README.md

@@ -30,35 +30,35 @@ limitations under the License.
 var zdscal = require( '@stdlib/blas/base/zdscal' );
 ```
 
-#### zdscal( N, da, zx, strideZX )
+#### zdscal( N, alpha, x, strideX )
 
 Scales a double-precision complex floating-point vector by a double-precision floating-point constant.
 
 ```javascript
 var Complex128Array = require( '@stdlib/array/complex128' );
 
-var zx = new Complex128Array( [ 1.0, 1.0, 1.0, 1.0, 1.0, 1.0 ] );
+var x = new Complex128Array( [ 1.0, 1.0, 1.0, 1.0, 1.0, 1.0 ] );
 
-zdscal( 3, 2.0, zx, 1 );
-// zx => <Complex128Array>[ 2.0, 2.0, 2.0, 2.0, 2.0, 2.0 ]
+zdscal( 3, 2.0, x, 1 );
+// x => <Complex128Array>[ 2.0, 2.0, 2.0, 2.0, 2.0, 2.0 ]
 ```
 
 The function has the following parameters:
 
 -   **N**: number of indexed elements.
--   **da**: scalar constant.
--   **zx**: input [`Complex128Array`][@stdlib/array/complex128].
--   **strideZX**: stride length for `zx`.
+-   **alpha**: scalar constant.
+-   **x**: input [`Complex128Array`][@stdlib/array/complex128].
+-   **strideX**: stride length for `x`.
 
-The `N` and stride parameters determine which elements in `zx` are scaled by `da`. For example, to scale every other element in `zx` by `da`,
+The `N` and stride parameters determine which elements in `x` are scaled by `alpha`. For example, to scale every other element in `x` by `alpha`,
 
 ```javascript
 var Complex128Array = require( '@stdlib/array/complex128' );
 
-var zx = new Complex128Array( [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0 ] );
+var x = new Complex128Array( [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0 ] );
 
-zdscal( 2, 2.0, zx, 2 );
-// zx => <Complex128Array>[ 2.0, 4.0, 3.0, 4.0, 10.0, 12.0, 7.0, 8.0 ]
+zdscal( 2, 2.0, x, 2 );
+// x => <Complex128Array>[ 2.0, 4.0, 3.0, 4.0, 10.0, 12.0, 7.0, 8.0 ]
 ```
 
 Note that indexing is relative to the first index. To introduce an offset, use [`typed array`][mdn-typed-array] views.
@@ -69,42 +69,42 @@ Note that indexing is relative to the first index. To introduce an offset, use [
 var Complex128Array = require( '@stdlib/array/complex128' );
 
 // Initial array:
-var zx0 = new Complex128Array( [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0 ] );
+var x0 = new Complex128Array( [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0 ] );
 
 // Create an offset view:
-var zx1 = new Complex128Array( zx0.buffer, zx0.BYTES_PER_ELEMENT*1 ); // start at 2nd element
+var x1 = new Complex128Array( x0.buffer, x0.BYTES_PER_ELEMENT*1 ); // start at 2nd element
 
-// Scale every element in `zx1`:
-zdscal( 3, 2.0, zx1, 1 );
-// zx0 => <Complex128Array>[ 1.0, 2.0, 6.0, 8.0, 10.0, 12.0, 14.0, 16.0 ]
+// Scale every element in `x1`:
+zdscal( 3, 2.0, x1, 1 );
+// x0 => <Complex128Array>[ 1.0, 2.0, 6.0, 8.0, 10.0, 12.0, 14.0, 16.0 ]
 ```
 
-#### zdscal.ndarray( N, da, zx, strideZX, offsetZX )
+#### zdscal.ndarray( N, alpha, x, strideX, offsetX )
 
 Scales a double-precision complex floating-point vector by a double-precision floating-point constant using alternative indexing semantics.
 
 ```javascript
 var Complex128Array = require( '@stdlib/array/complex128' );
 
-var zx = new Complex128Array( [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0 ] );
+var x = new Complex128Array( [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0 ] );
 
-zdscal.ndarray( 3, 2.0, zx, 1, 0 );
-// zx => <Complex128Array>[ 2.0, 4.0, 6.0, 8.0, 10.0, 12.0 ]
+zdscal.ndarray( 3, 2.0, x, 1, 0 );
+// x => <Complex128Array>[ 2.0, 4.0, 6.0, 8.0, 10.0, 12.0 ]
 ```
 
 The function has the following additional parameters:
 
--   **offsetZX**: starting index for `zx`.
+-   **offsetX**: starting index for `x`.
 
 While [`typed array`][mdn-typed-array] views mandate a view offset based on the underlying buffer, the offset parameter supports indexing semantics based on a starting index. For example, to scale every other element in the input strided array starting from the second element,
 
 ```javascript
 var Complex128Array = require( '@stdlib/array/complex128' );
 
-var zx = new Complex128Array( [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0 ] );
+var x = new Complex128Array( [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0 ] );
 
-zdscal.ndarray( 2, 2.0, zx, 2, 1 );
-// zx => <Complex128Array>[ 1.0, 2.0, 6.0, 8.0, 5.0, 6.0, 14.0, 16.0 ]
+zdscal.ndarray( 2, 2.0, x, 2, 1 );
+// x => <Complex128Array>[ 1.0, 2.0, 6.0, 8.0, 5.0, 6.0, 14.0, 16.0 ]
 ```
 
 </section>
@@ -115,7 +115,7 @@ zdscal.ndarray( 2, 2.0, zx, 2, 1 );
 
 ## Notes
 
--   If `N <= 0`, both functions return `zx` unchanged.
+-   If `N <= 0`, both functions return `x` unchanged.
 -   `zdscal()` corresponds to the [BLAS][blas] level 1 function [`zdscal`][zdscal].
 
 </section>
@@ -138,11 +138,11 @@ function rand() {
     return new Complex128( discreteUniform( 0, 10 ), discreteUniform( -5, 5 ) );
 }
 
-var zx = filledarrayBy( 10, 'complex128', rand );
-console.log( zx.toString() );
+var x = filledarrayBy( 10, 'complex128', rand );
+console.log( x.toString() );
 
-zdscal( zx.length, 2.0, zx, 1 );
-console.log( zx.toString() );
+zdscal( x.length, 2.0, x, 1 );
+console.log( x.toString() );
 ```
 
 </section>

lib/node_modules/@stdlib/blas/base/zdscal/benchmark/benchmark.js

@@ -46,11 +46,11 @@ var options = {
 * @returns {Function} benchmark function
 */
 function createBenchmark( len ) {
-	var zxbuf;
-	var zx;
+	var xbuf;
+	var x;
 
-	zxbuf = uniform( len*2, -100.0, 100.0, options );
-	zx = new Complex128Array( zxbuf.buffer );
+	xbuf = uniform( len*2, -100.0, 100.0, options );
+	x = new Complex128Array( xbuf.buffer );
 
 	return benchmark;
 
@@ -65,13 +65,13 @@ function createBenchmark( len ) {
 
 		b.tic();
 		for ( i = 0; i < b.iterations; i++ ) {
-			zdscal( zx.length, 2.0, zx, 1 );
-			if ( isnan( zxbuf[ i%(len*2) ] ) ) {
+			zdscal( x.length, 2.0, x, 1 );
+			if ( isnan( xbuf[ i%(len*2) ] ) ) {
 				b.fail( 'should not return NaN' );
 			}
 		}
 		b.toc();
-		if ( isnan( zxbuf[ i%(len*2) ] ) ) {
+		if ( isnan( xbuf[ i%(len*2) ] ) ) {
 			b.fail( 'should not return NaN' );
 		}
 		b.pass( 'benchmark finished' );

lib/node_modules/@stdlib/blas/base/zdscal/benchmark/benchmark.ndarray.js

@@ -46,11 +46,11 @@ var options = {
 * @returns {Function} benchmark function
 */
 function createBenchmark( len ) {
-	var zxbuf;
-	var zx;
+	var xbuf;
+	var x;
 
-	zxbuf = uniform( len*2, -100.0, 100.0, options );
-	zx = new Complex128Array( zxbuf.buffer );
+	xbuf = uniform( len*2, -100.0, 100.0, options );
+	x = new Complex128Array( xbuf.buffer );
 
 	return benchmark;
 
@@ -65,13 +65,13 @@ function createBenchmark( len ) {
 
 		b.tic();
 		for ( i = 0; i < b.iterations; i++ ) {
-			zdscal( zx.length, 2.0, zx, 1, 0 );
-			if ( isnan( zxbuf[ i%(len*2) ] ) ) {
+			zdscal( x.length, 2.0, x, 1, 0 );
+			if ( isnan( xbuf[ i%(len*2) ] ) ) {
 				b.fail( 'should not return NaN' );
 			}
 		}
 		b.toc();
-		if ( isnan( zxbuf[ i%(len*2) ] ) ) {
+		if ( isnan( xbuf[ i%(len*2) ] ) ) {
 			b.fail( 'should not return NaN' );
 		}
 		b.pass( 'benchmark finished' );

lib/node_modules/@stdlib/blas/base/zdscal/docs/repl.txt

@@ -1,58 +1,58 @@
 
-{{alias}}( N, da, zx, strideZX )
+{{alias}}( N, alpha, x, strideX )
     Scales a double-precision complex floating-point vector by a double-
     precision floating-point constant.
 
-    The `N` and stride parameters determine which elements in `zx` are scaled by
-    `da`.
+    The `N` and stride parameters determine which elements in `x` are scaled by
+    `alpha`.
 
     Indexing is relative to the first index. To introduce an offset, use typed
     array views.
 
-    If `N` is less than or equal to `0`, the function returns `zx` unchanged.
+    If `N` is less than or equal to `0`, the function returns `x` unchanged.
 
 
     Parameters
     ----------
     N: integer
         Number of indexed elements.
 
-    da: double
+    alpha: double
         Scalar constant.
 
-    zx: Complex128Array
+    x: Complex128Array
         Input array.
 
-    strideZX: integer
-        Stride length for `zx`.
+    strideX: integer
+        Stride length for `x`.
 
     Returns
     -------
-    zx: Complex128Array
+    x: Complex128Array
         Input array.
 
     Examples
     --------
     // Standard usage:
-    > var zx = new {{alias:@stdlib/array/complex128}}( [ 1.0, 2.0, 3.0, 4.0 ] );
-    > {{alias}}( 2, 2.0, zx, 1 )
+    > var x = new {{alias:@stdlib/array/complex128}}( [ 1.0, 2.0, 3.0, 4.0 ] );
+    > {{alias}}( 2, 2.0, x, 1 )
     <Complex128Array>[ 2.0, 4.0, 6.0, 8.0 ]
 
     // N and stride parameters:
-    > zx = new {{alias:@stdlib/array/complex128}}( [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0 ] );
-    > {{alias}}( 2, 2.0, zx, 2 )
+    > x = new {{alias:@stdlib/array/complex128}}( [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0 ] );
+    > {{alias}}( 2, 2.0, x, 2 )
     <Complex128Array>[ 2.0, 4.0, 3.0, 4.0, 10.0, 12.0 ]
 
     // Using typed array views:
-    > var zx0 = new {{alias:@stdlib/array/complex128}}( [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0 ] );
-    > var zx1 = new {{alias:@stdlib/array/complex128}}( zx0.buffer, zx0.BYTES_PER_ELEMENT*1 );
-    > {{alias}}( 2, 2.0, zx1, 1 )
+    > var x0 = new {{alias:@stdlib/array/complex128}}( [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0 ] );
+    > var x1 = new {{alias:@stdlib/array/complex128}}( x0.buffer, x0.BYTES_PER_ELEMENT*1 );
+    > {{alias}}( 2, 2.0, x1, 1 )
     <Complex128Array>[ 6.0, 8.0, 10.0, 12.0 ]
-    > zx0
+    > x0
     <Complex128Array>[ 1.0, 2.0, 6.0, 8.0, 10.0, 12.0 ]
 
 
-{{alias}}.ndarray( N, da, zx, strideZX, offsetZX )
+{{alias}}.ndarray( N, alpha, x, strideX, offsetX )
     Scales a double-precision complex floating-point vector by a double-
     precision floating-point constant using alternative indexing semantics.
 
@@ -65,33 +65,33 @@
     N: integer
         Number of indexed elements.
 
-    da: number
+    alpha: number
         Scalar constant.
 
-    zx: Complex128Array
+    x: Complex128Array
         Input array.
 
-    strideZX: integer
-        Stride length for `zx`.
+    strideX: integer
+        Stride length for `x`.
 
-    offsetZX: integer
-        Starting index for `zx`.
+    offsetX: integer
+        Starting index for `x`.
 
     Returns
     -------
-    zx: Complex128Array
+    x: Complex128Array
         Input array.
 
     Examples
     --------
     // Standard usage:
-    > var zx = new {{alias:@stdlib/array/complex128}}( [ 1.0, 2.0, 3.0, 4.0 ] );
-    > {{alias}}.ndarray( 2, 2.0, zx, 1, 0 )
+    > var x = new {{alias:@stdlib/array/complex128}}( [ 1.0, 2.0, 3.0, 4.0 ] );
+    > {{alias}}.ndarray( 2, 2.0, x, 1, 0 )
     <Complex128Array>[ 2.0, 4.0, 6.0, 8.0 ]
 
     // Advanced indexing:
-    > zx = new {{alias:@stdlib/array/complex128}}( [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0 ] );
-    > {{alias}}.ndarray( 2, 2.0, zx, 1, 2 )
+    > x = new {{alias:@stdlib/array/complex128}}( [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0 ] );
+    > {{alias}}.ndarray( 2, 2.0, x, 1, 2 )
     <Complex128Array>[ 1.0, 2.0, 3.0, 4.0, 10.0, 12.0, 14.0, 16.0 ]
 
     See Also