fix: update dapx ndarray API following dcusum pattern

Amansingh0807 · Amansingh0807 · commit 15d54c7f766f · 2025-12-20T10:35:49.000+05:30
diff --git a/lib/node_modules/@stdlib/blas/ext/base/ndarray/dapx/README.md b/lib/node_modules/@stdlib/blas/ext/base/ndarray/dapx/README.md
@@ -30,40 +30,52 @@ limitations under the License.
 var dapx = require( '@stdlib/blas/ext/base/ndarray/dapx' );
 ```
 
-#### dapx( x, alpha )
+#### dapx( arrays )
 
 Adds a scalar constant to each element in a double-precision floating-point ndarray.
 
 ```javascript
 var Float64Array = require( '@stdlib/array/float64' );
 var ndarray = require( '@stdlib/ndarray/ctor' );
+var scalar2ndarray = require( '@stdlib/ndarray/from-scalar' );
 
 var xbuf = new Float64Array( [ 1.0, 2.0, 3.0, 4.0 ] );
 var x = new ndarray( 'float64', xbuf, [ 4 ], [ 1 ], 0, 'row-major' );
 
-var out = dapx( x, 5.0 );
-// returns <ndarray>[ 6.0, 7.0, 8.0, 9.0 ]
+var alpha = scalar2ndarray( 5.0, {
+    'dtype': 'float64'
+});
+
+var out = dapx( [ x, alpha ] );
+// returns <ndarray>
+
+var bool = ( out === x );
+// returns true
 ```
 
 The function has the following parameters:
 
--   **x**: input ndarray.
--   **alpha**: scalar constant.
+-   **arrays**: array-like object containing an input ndarray and a zero-dimensional ndarray containing the scalar constant.
 
 Note that indexing is relative to the first index. To introduce an offset, use [`ndarray`][@stdlib/ndarray/ctor] view creation.
 
 ```javascript
 var Float64Array = require( '@stdlib/array/float64' );
 var ndarray = require( '@stdlib/ndarray/ctor' );
+var scalar2ndarray = require( '@stdlib/ndarray/from-scalar' );
 
 // Initial array:
 var xbuf = new Float64Array( [ 1.0, 2.0, 3.0, 4.0, 5.0 ] );
 
 // Create an ndarray view:
 var x = new ndarray( 'float64', xbuf, [ 3 ], [ 1 ], 2, 'row-major' );
 
-var out = dapx( x, 5.0 );
-// returns <ndarray>[ 8.0, 9.0, 10.0 ]
+var alpha = scalar2ndarray( 5.0, {
+    'dtype': 'float64'
+});
+
+var out = dapx( [ x, alpha ] );
+// returns <ndarray>
 ```
 
 </section>
@@ -89,6 +101,7 @@ var out = dapx( x, 5.0 );
 ```javascript
 var discreteUniform = require( '@stdlib/random/array/discrete-uniform' );
 var ndarray = require( '@stdlib/ndarray/ctor' );
+var scalar2ndarray = require( '@stdlib/ndarray/from-scalar' );
 var dapx = require( '@stdlib/blas/ext/base/ndarray/dapx' );
 
 var xbuf = discreteUniform( 10, 0, 100, {
@@ -98,7 +111,11 @@ var x = new ndarray( 'float64', xbuf, [ 10 ], [ 1 ], 0, 'row-major' );
 
 console.log( x.data );
 
-dapx( x, 5.0 );
+var alpha = scalar2ndarray( 5.0, {
+    'dtype': 'float64'
+});
+
+dapx( [ x, alpha ] );
 
 console.log( x.data );
 ```
diff --git a/lib/node_modules/@stdlib/blas/ext/base/ndarray/dapx/benchmark/benchmark.js b/lib/node_modules/@stdlib/blas/ext/base/ndarray/dapx/benchmark/benchmark.js
@@ -25,6 +25,7 @@ var discreteUniform = require( '@stdlib/random/array/discrete-uniform' );
 var isnanf = require( '@stdlib/math/base/assert/is-nanf' );
 var pow = require( '@stdlib/math/base/special/pow' );
 var ndarray = require( '@stdlib/ndarray/ctor' );
+var scalar2ndarray = require( '@stdlib/ndarray/from-scalar' );
 var pkg = require( './../package.json' ).name;
 var dapx = require( './../lib' );
 
@@ -39,11 +40,17 @@ var dapx = require( './../lib' );
 * @returns {Function} benchmark function
 */
 function createBenchmark( len ) {
+	var alpha;
+	var xbuf;
 	var x;
 
-	x = new ndarray( 'float64', discreteUniform( len, -100, 100, {
+	xbuf = discreteUniform( len, -100, 100, {
 		'dtype': 'float64'
-	}), [ len ], [ 1 ], 0, 'row-major' );
+	});
+	x = new ndarray( 'float64', xbuf, [ len ], [ 1 ], 0, 'row-major' );
+	alpha = scalar2ndarray( 5.0, {
+		'dtype': 'float64'
+	});
 
 	return benchmark;
 
@@ -59,7 +66,7 @@ function createBenchmark( len ) {
 
 		b.tic();
 		for ( i = 0; i < b.iterations; i++ ) {
-			z = dapx( x, 5.0 );
+			z = dapx( [ x, alpha ] );
 			if ( isnanf( z.data[ i % len ] ) ) {
 				b.fail( 'should not return NaN' );
 			}
diff --git a/lib/node_modules/@stdlib/blas/ext/base/ndarray/dapx/docs/repl.txt b/lib/node_modules/@stdlib/blas/ext/base/ndarray/dapx/docs/repl.txt
@@ -1,26 +1,26 @@
-{{alias}}( x, alpha )
+{{alias}}( arrays )
+
     Adds a scalar constant to each element in a double-precision floating-
     point ndarray.
 
     Parameters
     ----------
-    x: float64ndarray
-        Input ndarray.
-
-    alpha: number
-        Scalar constant.
+    arrays: ArrayLikeObject<ndarray>
+        Array-like object containing an input ndarray and a zero-dimensional
+        ndarray containing the scalar constant.
 
     Returns
     -------
-    out: float64ndarray
+    out: ndarray
         Input ndarray.
 
     Examples
     --------
     > var xbuf = new {{alias:@stdlib/array/float64}}( [ 1.0, 2.0, 3.0, 4.0 ] );
     > var x = {{alias:@stdlib/ndarray/ctor}}( 'float64', xbuf, [ 4 ], [ 1 ], 0, 'row-major' );
-    > {{alias}}( x, 5.0 )
-    <ndarray>[ 6.0, 7.0, 8.0, 9.0 ]
+    > var alpha = {{alias:@stdlib/ndarray/from-scalar}}( 5.0, 'float64', 'row-major' );
+    > {{alias}}( [ x, alpha ] )
+    <ndarray>
 
     See Also
     --------
diff --git a/lib/node_modules/@stdlib/blas/ext/base/ndarray/dapx/docs/types/index.d.ts b/lib/node_modules/@stdlib/blas/ext/base/ndarray/dapx/docs/types/index.d.ts
@@ -25,21 +25,25 @@ import { float64ndarray } from '@stdlib/types/ndarray';
 /**
 * Adds a scalar constant to each element in a double-precision floating-point ndarray.
 *
-* @param x - input ndarray
-* @param alpha - scalar constant
+* @param arrays - array-like object containing an input ndarray and a zero-dimensional ndarray containing the scalar constant
 * @returns input ndarray
 *
 * @example
 * var Float64Array = require( '@stdlib/array/float64' );
 * var ndarray = require( '@stdlib/ndarray/ctor' );
+* var scalar2ndarray = require( '@stdlib/ndarray/from-scalar' );
 *
 * var xbuf = new Float64Array( [ 1.0, 2.0, 3.0, 4.0 ] );
 * var x = new ndarray( 'float64', xbuf, [ 4 ], [ 1 ], 0, 'row-major' );
 *
-* var out = dapx( x, 5.0 );
-* // returns <ndarray>[ 6.0, 7.0, 8.0, 9.0 ]
+* var alpha = scalar2ndarray( 5.0, {
+*     'dtype': 'float64'
+* });
+*
+* var out = dapx( [ x, alpha ] );
+* // returns <ndarray>
 */
-declare function dapx( x: float64ndarray, alpha: number ): float64ndarray;
+declare function dapx( arrays: ArrayLike<float64ndarray> ): float64ndarray;
 
 
 // EXPORTS //
diff --git a/lib/node_modules/@stdlib/blas/ext/base/ndarray/dapx/docs/types/test.ts b/lib/node_modules/@stdlib/blas/ext/base/ndarray/dapx/docs/types/test.ts
@@ -16,47 +16,46 @@
 * limitations under the License.
 */
 
+import zeros = require( '@stdlib/ndarray/zeros' );
 import dapx = require( './index' );
 
 
 // TESTS //
 
 // The function returns an ndarray...
 {
-	const x: any = null;
-	dapx( x, 5.0 ); // $ExpectType float64ndarray
-}
+	const x = zeros( [ 10 ], {
+		'dtype': 'float64'
+	});
+	const alpha = zeros( [], {
+		'dtype': 'float64'
+	});
 
-// The compiler throws an error if the function is provided a first argument which is not an ndarray...
-{
-	dapx( 123, 5.0 ); // $ExpectError
-	dapx( true, 5.0 ); // $ExpectError
-	dapx( false, 5.0 ); // $ExpectError
-	dapx( null, 5.0 ); // $ExpectError
-	dapx( undefined, 5.0 ); // $ExpectError
-	dapx( '5', 5.0 ); // $ExpectError
-	dapx( [ '1', '2' ], 5.0 ); // $ExpectError
-	dapx( {}, 5.0 ); // $ExpectError
-	dapx( ( x: number ): number => x, 5.0 ); // $ExpectError
+	dapx( [ x, alpha ] ); // $ExpectType float64ndarray
 }
 
-// The compiler throws an error if the function is provided a second argument which is not a number...
+// The compiler throws an error if the function is provided a first argument which is not an array of ndarrays...
 {
-	const x: any = null;
-	dapx( x, '5' ); // $ExpectError
-	dapx( x, true ); // $ExpectError
-	dapx( x, false ); // $ExpectError
-	dapx( x, null ); // $ExpectError
-	dapx( x, undefined ); // $ExpectError
-	dapx( x, [ '1' ] ); // $ExpectError
-	dapx( x, {} ); // $ExpectError
-	dapx( x, ( x: number ): number => x ); // $ExpectError
+	dapx( '10' ); // $ExpectError
+	dapx( 10 ); // $ExpectError
+	dapx( true ); // $ExpectError
+	dapx( false ); // $ExpectError
+	dapx( null ); // $ExpectError
+	dapx( undefined ); // $ExpectError
+	dapx( [] ); // $ExpectError
+	dapx( {} ); // $ExpectError
+	dapx( ( x: number ): number => x ); // $ExpectError
 }
 
 // The compiler throws an error if the function is provided an unsupported number of arguments...
 {
-	const x: any = null;
+	const x = zeros( [ 10 ], {
+		'dtype': 'float64'
+	});
+	const alpha = zeros( [], {
+		'dtype': 'float64'
+	});
+
 	dapx(); // $ExpectError
-	dapx( x ); // $ExpectError
-	dapx( x, 5.0, 10 ); // $ExpectError
+	dapx( [ x, alpha ], {} ); // $ExpectError
 }
diff --git a/lib/node_modules/@stdlib/blas/ext/base/ndarray/dapx/examples/index.js b/lib/node_modules/@stdlib/blas/ext/base/ndarray/dapx/examples/index.js
@@ -20,6 +20,7 @@
 
 var discreteUniform = require( '@stdlib/random/array/discrete-uniform' );
 var ndarray = require( '@stdlib/ndarray/ctor' );
+var scalar2ndarray = require( '@stdlib/ndarray/from-scalar' );
 var dapx = require( './../lib' );
 
 var xbuf = discreteUniform( 10, 0, 100, {
@@ -29,6 +30,10 @@ var x = new ndarray( 'float64', xbuf, [ 10 ], [ 1 ], 0, 'row-major' );
 
 console.log( x.data );
 
-dapx( x, 5.0 );
+var alpha = scalar2ndarray( 5.0, {
+	'dtype': 'float64'
+});
+
+dapx( [ x, alpha ] );
 
 console.log( x.data );
diff --git a/lib/node_modules/@stdlib/blas/ext/base/ndarray/dapx/lib/main.js b/lib/node_modules/@stdlib/blas/ext/base/ndarray/dapx/lib/main.js
@@ -25,34 +25,40 @@ var strided = require( '@stdlib/blas/ext/base/dapx' ).ndarray;
 var getStride = require( '@stdlib/ndarray/base/stride' );
 var getOffset = require( '@stdlib/ndarray/base/offset' );
 var getData = require( '@stdlib/ndarray/base/data-buffer' );
+var ndarraylike2scalar = require( '@stdlib/ndarray/base/ndarraylike2scalar' );
 
 
 // MAIN //
 
 /**
 * Adds a scalar constant to each element in a double-precision floating-point ndarray.
 *
-* @param {float64ndarray} x - input ndarray
-* @param {number} alpha - scalar constant
-* @returns {float64ndarray} input ndarray
+* @param {ArrayLikeObject<Object>} arrays - array-like object containing an input ndarray and a zero-dimensional ndarray containing the scalar constant
+* @returns {Object} input ndarray
 *
 * @example
 * var Float64Array = require( '@stdlib/array/float64' );
 * var ndarray = require( '@stdlib/ndarray/ctor' );
+* var scalar2ndarray = require( '@stdlib/ndarray/from-scalar' );
 *
 * var xbuf = new Float64Array( [ 1.0, 2.0, 3.0, 4.0 ] );
 * var x = new ndarray( 'float64', xbuf, [ 4 ], [ 1 ], 0, 'row-major' );
 *
-* dapx( x, 5.0 );
+* var alpha = scalar2ndarray( 5.0, {
+*     'dtype': 'float64'
+* });
 *
-* var y = x.data;
-* // returns <Float64Array>[ 6.0, 7.0, 8.0, 9.0 ]
+* dapx( [ x, alpha ] );
+* // returns <ndarray>
 */
-function dapx( x, alpha ) {
+function dapx( arrays ) {
 	var buf;
 	var sx;
 	var ox;
 	var N;
+	var x;
+
+	x = arrays[ 0 ];
 
 	N = numelDimension( x, 0 );
 	if ( N <= 0 ) {
@@ -62,7 +68,7 @@ function dapx( x, alpha ) {
 	sx = getStride( x, 0 );
 	ox = getOffset( x );
 
-	strided( N, alpha, buf, sx, ox );
+	strided( N, ndarraylike2scalar( arrays[ 1 ] ), buf, sx, ox );
 	return x;
 }
 
diff --git a/lib/node_modules/@stdlib/blas/ext/base/ndarray/dapx/test/test.js b/lib/node_modules/@stdlib/blas/ext/base/ndarray/dapx/test/test.js
