Merge branch 'develop' into blas/cindex-of-row

Author: headlessNode

lib/node_modules/@stdlib/array/base/falses/docs/types/test.ts

@@ -29,9 +29,9 @@ import falses = require( './index' );
 // The compiler throws an error if the function is provided an argument which is not a number...
 {
 	falses( 'abc' ); // $ExpectError
+	falses( true ); // $ExpectError
 	falses( false ); // $ExpectError
-	falses( false ); // $ExpectError
-	falses( false ); // $ExpectError
+	falses( null ); // $ExpectError
 	falses( [] ); // $ExpectError
 	falses( {} ); // $ExpectError
 	falses( ( x: number ): number => x ); // $ExpectError

lib/node_modules/@stdlib/array/base/trues/docs/types/test.ts

@@ -31,7 +31,7 @@ import trues = require( './index' );
 	trues( 'abc' ); // $ExpectError
 	trues( true ); // $ExpectError
 	trues( false ); // $ExpectError
-	trues( true ); // $ExpectError
+	trues( null ); // $ExpectError
 	trues( [] ); // $ExpectError
 	trues( {} ); // $ExpectError
 	trues( ( x: number ): number => x ); // $ExpectError

lib/node_modules/@stdlib/array/docs/types/index.d.ts

@@ -62,6 +62,7 @@ import mskreject = require( '@stdlib/array/mskreject' );
 import nans = require( '@stdlib/array/nans' );
 import nansLike = require( '@stdlib/array/nans-like' );
 import nextDataType = require( '@stdlib/array/next-dtype' );
+import nulls = require( '@stdlib/array/nulls' );
 import oneTo = require( '@stdlib/array/one-to' );
 import oneToLike = require( '@stdlib/array/one-to-like' );
 import ones = require( '@stdlib/array/ones' );
@@ -1008,6 +1009,27 @@ interface Namespace {
 	*/
 	nextDataType: typeof nextDataType;
 
+	/**
+	* Creates an array filled with nulls and having a specified length.
+	*
+	* The function recognizes the following data types:
+	*
+	* -   `generic`: generic JavaScript values
+	*
+	* @param length - array length
+	* @param dtype - data type (default: 'generic')
+	* @returns filled array
+	*
+	* @example
+	* var arr = ns.nulls( 2 );
+	* // returns [ null, null ]
+	*
+	* @example
+	* var arr = ns.nulls( 2, 'generic' );
+	* // returns [ null, null ]
+	*/
+	nulls: typeof nulls;
+
 	/**
 	* Generates a linearly spaced numeric array whose elements increment by 1 starting from one.
 	*

lib/node_modules/@stdlib/array/nulls/benchmark/benchmark.js

@@ -41,7 +41,7 @@ bench( pkg, function benchmark( b ) {
 	}
 	b.toc();
 	if ( !isCollection( arr ) ) {
-		b.fail( 'should return a typed array' );
+		b.fail( 'should return an array' );
 	}
 	b.pass( 'benchmark finished' );
 	b.end();

lib/node_modules/@stdlib/assert/has-dataview-support/test/test.js

@@ -71,9 +71,9 @@ tape( 'if `DataView` is supported, detection result is `true`', function test( t
 		}
 		out = {};
 		out.buffer = buf;
-		out._buffer = new Array( byteLength ); // eslint-disable-line no-underscore-dangle
+		out._buffer = []; // eslint-disable-line no-underscore-dangle
 		for ( i = 0; i < byteLength; i++ ) {
-			out._buffer[ i ] = 0; // eslint-disable-line no-underscore-dangle
+			out._buffer.push( 0 ); // eslint-disable-line no-underscore-dangle
 		}
 		out.byteLength = byteLength;
 		out.byteOffset = byteOffset;

lib/node_modules/@stdlib/blas/base/docs/types/index.d.ts

@@ -83,6 +83,7 @@ import matrixTriangleResolveEnum = require( '@stdlib/blas/base/matrix-triangle-r
 import matrixTriangleResolveStr = require( '@stdlib/blas/base/matrix-triangle-resolve-str' );
 import matrixTriangleStr2Enum = require( '@stdlib/blas/base/matrix-triangle-str2enum' );
 import matrixTriangles = require( '@stdlib/blas/base/matrix-triangles' );
+import ndarray = require( '@stdlib/blas/base/ndarray' );
 import operationSideEnum2Str = require( '@stdlib/blas/base/operation-side-enum2str' );
 import operationSideResolveEnum = require( '@stdlib/blas/base/operation-side-resolve-enum' );
 import operationSideResolveStr = require( '@stdlib/blas/base/operation-side-resolve-str' );
@@ -1705,6 +1706,11 @@ interface Namespace {
 	*/
 	matrixTriangles: typeof matrixTriangles;
 
+	/**
+	* Base ndarray BLAS functions.
+	*/
+	ndarray: typeof ndarray;
+
 	/**
 	* Returns the BLAS operation side string associated with a BLAS operation side enumeration constant.
 	*

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

@@ -47,7 +47,9 @@ The namespace exposes the following APIs:
 
 -   <span class="signature">[`dasum( arrays )`][@stdlib/blas/base/ndarray/dasum]</span><span class="delimiter">: </span><span class="description">calculate the sum of absolute values for all elements in a one-dimensional double-precision floating-point ndarray.</span>
 -   <span class="signature">[`ddot( arrays )`][@stdlib/blas/base/ndarray/ddot]</span><span class="delimiter">: </span><span class="description">calculate the dot product of two one-dimensional double-precision floating-point ndarrays.</span>
+-   <span class="signature">[`gasum( arrays )`][@stdlib/blas/base/ndarray/gasum]</span><span class="delimiter">: </span><span class="description">calculate the sum of absolute values for all elements in a one-dimensional ndarray.</span>
 -   <span class="signature">[`gdot( arrays )`][@stdlib/blas/base/ndarray/gdot]</span><span class="delimiter">: </span><span class="description">calculate the dot product of two one-dimensional ndarrays.</span>
+-   <span class="signature">[`sasum( arrays )`][@stdlib/blas/base/ndarray/sasum]</span><span class="delimiter">: </span><span class="description">calculate the sum of absolute values for all elements in a one-dimensional single-precision floating-point ndarray.</span>
 -   <span class="signature">[`sdot( arrays )`][@stdlib/blas/base/ndarray/sdot]</span><span class="delimiter">: </span><span class="description">calculate the dot product of two one-dimensional single-precision floating-point ndarrays.</span>
 
 </div>
@@ -95,8 +97,12 @@ console.log( objectKeys( ns ) );
 
 [@stdlib/blas/base/ndarray/ddot]: https://github.com/stdlib-js/stdlib/tree/develop/lib/node_modules/%40stdlib/blas/base/ndarray/ddot
 
+[@stdlib/blas/base/ndarray/gasum]: https://github.com/stdlib-js/stdlib/tree/develop/lib/node_modules/%40stdlib/blas/base/ndarray/gasum
+
 [@stdlib/blas/base/ndarray/gdot]: https://github.com/stdlib-js/stdlib/tree/develop/lib/node_modules/%40stdlib/blas/base/ndarray/gdot
 
+[@stdlib/blas/base/ndarray/sasum]: https://github.com/stdlib-js/stdlib/tree/develop/lib/node_modules/%40stdlib/blas/base/ndarray/sasum
+
 [@stdlib/blas/base/ndarray/sdot]: https://github.com/stdlib-js/stdlib/tree/develop/lib/node_modules/%40stdlib/blas/base/ndarray/sdot
 
 <!-- </toc-links> -->

lib/node_modules/@stdlib/blas/base/ndarray/docs/types/index.d.ts

@@ -20,16 +20,131 @@
 
 /* eslint-disable max-lines */
 
+import dasum = require( '@stdlib/blas/base/ndarray/dasum' );
 import ddot = require( '@stdlib/blas/base/ndarray/ddot' );
+import gasum = require( '@stdlib/blas/base/ndarray/gasum' );
+import gdot = require( '@stdlib/blas/base/ndarray/gdot' );
+import sasum = require( '@stdlib/blas/base/ndarray/sasum' );
+import sdot = require( '@stdlib/blas/base/ndarray/sdot' );
 
 /**
 * Interface describing the `ndarray` namespace.
 */
 interface Namespace {
 	/**
-	* TODO
+	* Computes the sum of absolute values for all elements in a one-dimensional double-precision floating-point ndarray.
+	*
+	* @param arrays - array-like object containing a one-dimensional input ndarray
+	* @returns sum
+	*
+	* @example
+	* var Float64Array = require( '@stdlib/array/float64' );
+	* var ndarray = require( '@stdlib/ndarray/base/ctor' );
+	*
+	* var xbuf = new Float64Array( [ 1.0, -2.0, 3.0, -4.0, 5.0 ] );
+	* var x = new ndarray( 'float64', xbuf, [ 5 ], [ 1 ], 0, 'row-major' );
+	*
+	* var y = ns.dasum( [ x ] );
+	* // returns 15.0
+	*/
+	dasum: typeof dasum;
+
+	/**
+	* Computes the dot product of two one-dimensional double-precision floating-point ndarrays.
+	*
+	* @param arrays - array-like object containing two one-dimensional input ndarrays
+	* @returns dot product
+	*
+	* @example
+	* var Float64Array = require( '@stdlib/array/float64' );
+	* var ndarray = require( '@stdlib/ndarray/base/ctor' );
+	*
+	* var xbuf = new Float64Array( [ 4.0, 2.0, -3.0, 5.0, -1.0 ] );
+	* var x = new ndarray( 'float64', xbuf, [ 5 ], [ 1 ], 0, 'row-major' );
+	*
+	* var ybuf = new Float64Array( [ 2.0, 6.0, -1.0, -4.0, 8.0 ] );
+	* var y = new ndarray( 'float64', ybuf, [ 5 ], [ 1 ], 0, 'row-major' );
+	*
+	* var z = ns.ddot( [ x, y ] );
+	* // returns -5.0
 	*/
 	ddot: typeof ddot;
+
+	/**
+	* Computes the sum of absolute values for all elements in a one-dimensional ndarray.
+	*
+	* @param arrays - array-like object containing a one-dimensional input ndarray
+	* @returns sum
+	*
+	* @example
+	* var ndarray = require( '@stdlib/ndarray/base/ctor' );
+	*
+	* var xbuf = [ 1.0, -2.0, 3.0, -4.0, 5.0 ];
+	* var x = new ndarray( 'generic', xbuf, [ 5 ], [ 1 ], 0, 'row-major' );
+	*
+	* var y = ns.gasum( [ x ] );
+	* // returns 15.0
+	*/
+	gasum: typeof gasum;
+
+	/**
+	* Computes the dot product of two one-dimensional ndarrays.
+	*
+	* @param arrays - array-like object containing two one-dimensional input ndarrays
+	* @returns dot product
+	*
+	* @example
+	* var ndarray = require( '@stdlib/ndarray/base/ctor' );
+	*
+	* var xbuf = [ 4.0, 2.0, -3.0, 5.0, -1.0 ];
+	* var x = new ndarray( 'generic', xbuf, [ 5 ], [ 1 ], 0, 'row-major' );
+	*
+	* var ybuf = [ 2.0, 6.0, -1.0, -4.0, 8.0 ];
+	* var y = new ndarray( 'generic', ybuf, [ 5 ], [ 1 ], 0, 'row-major' );
+	*
+	* var z = ns.gdot( [ x, y ] );
+	* // returns -5.0
+	*/
+	gdot: typeof gdot;
+
+	/**
+	* Computes the sum of absolute values for all elements in a one-dimensional single-precision floating-point ndarray.
+	*
+	* @param arrays - array-like object containing a one-dimensional input ndarray
+	* @returns sum
+	*
+	* @example
+	* var Float32Array = require( '@stdlib/array/float32' );
+	* var ndarray = require( '@stdlib/ndarray/base/ctor' );
+	*
+	* var xbuf = new Float32Array( [ 1.0, -2.0, 3.0, -4.0, 5.0 ] );
+	* var x = new ndarray( 'float32', xbuf, [ 5 ], [ 1 ], 0, 'row-major' );
+	*
+	* var y = ns.sasum( [ x ] );
+	* // returns 15.0
+	*/
+	sasum: typeof sasum;
+
+	/**
+	* Computes the dot product of two one-dimensional single-precision floating-point ndarrays.
+	*
+	* @param arrays - array-like object containing two one-dimensional input ndarrays
+	* @returns dot product
+	*
+	* @example
+	* var Float32Array = require( '@stdlib/array/float32' );
+	* var ndarray = require( '@stdlib/ndarray/base/ctor' );
+	*
+	* var xbuf = new Float32Array( [ 4.0, 2.0, -3.0, 5.0, -1.0 ] );
+	* var x = new ndarray( 'float32', xbuf, [ 5 ], [ 1 ], 0, 'row-major' );
+	*
+	* var ybuf = new Float32Array( [ 2.0, 6.0, -1.0, -4.0, 8.0 ] );
+	* var y = new ndarray( 'float32', ybuf, [ 5 ], [ 1 ], 0, 'row-major' );
+	*
+	* var z = ns.sdot( [ x, y ] );
+	* // returns -5.0
+	*/
+	sdot: typeof sdot;
 }
 
 /**

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

@@ -0,0 +1,126 @@
+<!--
+
+@license Apache-2.0
+
+Copyright (c) 2026 The Stdlib Authors.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+   http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+
+-->
+
+# gasum
+
+> Calculate the sum of absolute values for all elements in a one-dimensional ndarray.
+
+<section class="intro">
+
+The [_L1_ norm][l1norm] is defined as
+
+<!-- <equation class="equation" label="eq:l1norm" align="center" raw="\|\mathbf{x}\|_1 = \sum_{i=0}^{n-1} \vert x_i \vert" alt="L1 norm definition."> -->
+
+```math
+\|\mathbf{x}\|_1 = \sum_{i=0}^{n-1} \vert x_i \vert
+```
+
+<!-- <div class="equation" align="center" data-raw-text="\|\mathbf{x}\|_1 = \sum_{i=0}^{n-1} \vert x_i \vert" data-equation="eq:l1norm">
+    <img src="https://cdn.jsdelivr.net/gh/stdlib-js/stdlib@30de397fadee10fa175a8332ae1447737f201818/lib/node_modules/@stdlib/blas/base/gasum/docs/img/equation_l1norm.svg" alt="L1 norm definition.">
+    <br>
+</div> -->
+
+<!-- </equation> -->
+
+</section>
+
+<!-- /.intro -->
+
+<section class="usage">
+
+## Usage
+
+```javascript
+var gasum = require( '@stdlib/blas/base/ndarray/gasum' );
+```
+
+#### gasum( arrays )
+
+Computes the sum of absolute values for all elements in a one-dimensional ndarray.
+
+```javascript
+var ndarray = require( '@stdlib/ndarray/base/ctor' );
+
+var xbuf = [ 1.0, -2.0, 3.0, -4.0, 5.0 ];
+var x = new ndarray( 'generic', xbuf, [ 5 ], [ 1 ], 0, 'row-major' );
+
+var y = gasum( [ x ] );
+// returns 15.0
+```
+
+The function has the following parameters:
+
+-   **arrays**: array-like object containing a one-dimensional input ndarray.
+
+</section>
+
+<!-- /.usage -->
+
+<section class="notes">
+
+</section>
+
+<!-- /.notes -->
+
+<section class="examples">
+
+## Examples
+
+<!-- eslint no-undef: "error" -->
+
+```javascript
+var discreteUniform = require( '@stdlib/random/array/discrete-uniform' );
+var ndarray = require( '@stdlib/ndarray/base/ctor' );
+var ndarray2array = require( '@stdlib/ndarray/to-array' );
+var gasum = require( '@stdlib/blas/base/ndarray/gasum' );
+
+var opts = {
+    'dtype': 'generic'
+};
+
+var xbuf = discreteUniform( 10, -500, 500, opts );
+var x = new ndarray( opts.dtype, xbuf, [ xbuf.length ], [ 1 ], 0, 'row-major' );
+console.log( ndarray2array( x ) );
+
+var out = gasum( [ x ] );
+console.log( out );
+```
+
+</section>
+
+<!-- /.examples -->
+
+<!-- Section for related `stdlib` packages. Do not manually edit this section, as it is automatically populated. -->
+
+<section class="related">
+
+</section>
+
+<!-- /.related -->
+
+<!-- Section for all links. Make sure to keep an empty line after the `section` element and another before the `/section` close. -->
+
+<section class="links">
+
+[l1norm]: https://en.wikipedia.org/wiki/Norm_%28mathematics%29
+
+</section>
+
+<!-- /.links -->