Fix dapx implementation per maintainer review

- Add 'one-dimensional' to all descriptions
- Use ndarray2array to show expected values
- Remove dimension check from main function
- Update TypeScript types to tuple syntax
- Use getData instead of .data in tests
- Remove uninformative test cases
- Add VARIABLES section in benchmark
- Use options parameterization
- Change isnanf to isnan for double precision
- Remove Notes section from README
- Update all documentation with expected outputs

Author: Amansingh0807

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

@@ -20,7 +20,7 @@ limitations under the License.
 
 # dapx
 
-> Add a scalar constant to each element in a double-precision floating-point ndarray.
+> Add a scalar constant to each element in a one-dimensional double-precision floating-point ndarray.
 
 <section class="usage">
 
@@ -32,12 +32,13 @@ var dapx = require( '@stdlib/blas/ext/base/ndarray/dapx' );
 
 #### dapx( arrays )
 
-Adds a scalar constant to each element in a double-precision floating-point ndarray.
+Adds a scalar constant to each element in a one-dimensional 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 ndarray2array = require( '@stdlib/ndarray/to-array' );
 
 var xbuf = new Float64Array( [ 1.0, 2.0, 3.0, 4.0 ] );
 var x = new ndarray( 'float64', xbuf, [ 4 ], [ 1 ], 0, 'row-major' );
@@ -51,13 +52,14 @@ var out = dapx( [ x, alpha ] );
 
 var bool = ( out === x );
 // returns true
+
+var arr = ndarray2array( out );
+// returns [ 6.0, 7.0, 8.0, 9.0 ]
 ```
 
 The function has the following parameters:
 
--   **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.
+-   **arrays**: array-like object containing a one-dimensional input ndarray and a zero-dimensional ndarray containing a scalar constant.
 
 ```javascript
 var Float64Array = require( '@stdlib/array/float64' );
@@ -69,11 +71,9 @@ 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 alpha = scalar2ndarray( 5.0, {
     'dtype': 'float64'
 });
-
 var out = dapx( [ x, alpha ] );
 // returns <ndarray>
 ```
@@ -82,16 +82,6 @@ var out = dapx( [ x, alpha ] );
 
 <!-- /.usage -->
 
-<section class="notes">
-
-## Notes
-
--   The function **mutates** the input ndarray.
-
-</section>
-
-<!-- /.notes -->
-
 <section class="examples">
 
 ## Examples
@@ -102,22 +92,21 @@ var out = dapx( [ x, alpha ] );
 var discreteUniform = require( '@stdlib/random/array/discrete-uniform' );
 var ndarray = require( '@stdlib/ndarray/ctor' );
 var scalar2ndarray = require( '@stdlib/ndarray/from-scalar' );
+var ndarray2array = require( '@stdlib/ndarray/to-array' );
 var dapx = require( '@stdlib/blas/ext/base/ndarray/dapx' );
 
 var xbuf = discreteUniform( 10, 0, 100, {
     'dtype': 'float64'
 });
 var x = new ndarray( 'float64', xbuf, [ 10 ], [ 1 ], 0, 'row-major' );
-
-console.log( x.data );
+console.log( ndarray2array( x ) );
 
 var alpha = scalar2ndarray( 5.0, {
     'dtype': 'float64'
 });
 
 dapx( [ x, alpha ] );
-
-console.log( x.data );
+console.log( ndarray2array( x ) );
 ```
 
 </section>
@@ -136,8 +125,6 @@ console.log( x.data );
 
 <section class="links">
 
-[@stdlib/ndarray/ctor]: https://github.com/stdlib-js/ndarray-ctor
-
 </section>
 
 <!-- /.links -->

lib/node_modules/@stdlib/blas/ext/base/ndarray/dapx/benchmark/benchmark.js

@@ -22,14 +22,21 @@
 
 var bench = require( '@stdlib/bench' );
 var discreteUniform = require( '@stdlib/random/array/discrete-uniform' );
-var isnanf = require( '@stdlib/math/base/assert/is-nanf' );
+var isnan = require( '@stdlib/math/base/assert/is-nan' );
 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' );
 
 
+// VARIABLES //
+
+var options = {
+	'dtype': 'float64'
+};
+
+
 // FUNCTIONS //
 
 /**
@@ -44,13 +51,9 @@ function createBenchmark( len ) {
 	var xbuf;
 	var x;
 
-	xbuf = discreteUniform( len, -100, 100, {
-		'dtype': 'float64'
-	});
-	x = new ndarray( 'float64', xbuf, [ len ], [ 1 ], 0, 'row-major' );
-	alpha = scalar2ndarray( 5.0, {
-		'dtype': 'float64'
-	});
+	xbuf = discreteUniform( len, -100, 100, options );
+	x = new ndarray( options.dtype, xbuf, [ len ], [ 1 ], 0, 'row-major' );
+	alpha = scalar2ndarray( 5.0, options );
 
 	return benchmark;
 
@@ -67,12 +70,12 @@ function createBenchmark( len ) {
 		b.tic();
 		for ( i = 0; i < b.iterations; i++ ) {
 			z = dapx( [ x, alpha ] );
-			if ( isnanf( z.data[ i % len ] ) ) {
+			if ( isnan( z.data[ i % len ] ) ) {
 				b.fail( 'should not return NaN' );
 			}
 		}
 		b.toc();
-		if ( isnanf( z.data[ i % len ] ) ) {
+		if ( isnan( z.data[ i % len ] ) ) {
 			b.fail( 'should not return NaN' );
 		}
 		b.pass( 'benchmark finished' );

lib/node_modules/@stdlib/blas/ext/base/ndarray/dapx/docs/repl.txt

@@ -1,13 +1,12 @@
 {{alias}}( arrays )
-
-    Adds a scalar constant to each element in a double-precision floating-
-    point ndarray.
+    Adds a scalar constant to each element in a one-dimensional double-
+    precision floating-point ndarray.
 
     Parameters
     ----------
     arrays: ArrayLikeObject<ndarray>
-        Array-like object containing an input ndarray and a zero-dimensional
-        ndarray containing the scalar constant.
+        Array-like object containing a one-dimensional input ndarray and a
+        zero-dimensional ndarray containing a scalar constant.
 
     Returns
     -------
@@ -21,6 +20,8 @@
     > var alpha = {{alias:@stdlib/ndarray/from-scalar}}( 5.0, { 'dtype': 'float64' } );
     > {{alias}}( [ x, alpha ] )
     <ndarray>
+    > var data = x.data
+    <Float64Array>[ 6.0, 7.0, 8.0, 9.0 ]
 
     See Also
     --------

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

@@ -23,15 +23,16 @@
 import { float64ndarray } from '@stdlib/types/ndarray';
 
 /**
-* Adds a scalar constant to each element in a double-precision floating-point ndarray.
+* Adds a scalar constant to each element in a one-dimensional double-precision floating-point ndarray.
 *
-* @param arrays - array-like object containing an input ndarray and a zero-dimensional ndarray containing the scalar constant
+* @param arrays - array-like object containing a one-dimensional input ndarray and a zero-dimensional ndarray containing a 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 ndarray2array = require( '@stdlib/ndarray/to-array' );
 *
 * var xbuf = new Float64Array( [ 1.0, 2.0, 3.0, 4.0 ] );
 * var x = new ndarray( 'float64', xbuf, [ 4 ], [ 1 ], 0, 'row-major' );
@@ -42,8 +43,11 @@ import { float64ndarray } from '@stdlib/types/ndarray';
 *
 * var out = dapx( [ x, alpha ] );
 * // returns <ndarray>
+*
+* var arr = ndarray2array( out );
+* // returns [ 6.0, 7.0, 8.0, 9.0 ]
 */
-declare function dapx( arrays: ArrayLike<float64ndarray> ): float64ndarray;
+declare function dapx( arrays: [ float64ndarray, float64ndarray ] ): float64ndarray;
 
 
 // EXPORTS //

lib/node_modules/@stdlib/blas/ext/base/ndarray/dapx/examples/index.js

@@ -21,19 +21,18 @@
 var discreteUniform = require( '@stdlib/random/array/discrete-uniform' );
 var ndarray = require( '@stdlib/ndarray/ctor' );
 var scalar2ndarray = require( '@stdlib/ndarray/from-scalar' );
+var ndarray2array = require( '@stdlib/ndarray/to-array' );
 var dapx = require( './../lib' );
 
 var xbuf = discreteUniform( 10, 0, 100, {
 	'dtype': 'float64'
 });
 var x = new ndarray( 'float64', xbuf, [ 10 ], [ 1 ], 0, 'row-major' );
-
-console.log( x.data );
+console.log( ndarray2array( x ) );
 
 var alpha = scalar2ndarray( 5.0, {
 	'dtype': 'float64'
 });
 
 dapx( [ x, alpha ] );
-
-console.log( x.data );
+console.log( ndarray2array( x ) );

lib/node_modules/@stdlib/blas/ext/base/ndarray/dapx/lib/index.js

@@ -19,14 +19,15 @@
 'use strict';
 
 /**
-* Add a scalar constant to each element in a double-precision floating-point ndarray.
+* Add a scalar constant to each element in a one-dimensional double-precision floating-point ndarray.
 *
 * @module @stdlib/blas/ext/base/ndarray/dapx
 *
 * @example
 * var Float64Array = require( '@stdlib/array/float64' );
 * var ndarray = require( '@stdlib/ndarray/ctor' );
 * var scalar2ndarray = require( '@stdlib/ndarray/from-scalar' );
+* var ndarray2array = require( '@stdlib/ndarray/to-array' );
 * var dapx = require( '@stdlib/blas/ext/base/ndarray/dapx' );
 *
 * var xbuf = new Float64Array( [ 1.0, 2.0, 3.0, 4.0 ] );
@@ -38,6 +39,9 @@
 *
 * var out = dapx( [ x, alpha ] );
 * // returns <ndarray>
+*
+* var arr = ndarray2array( out );
+* // returns [ 6.0, 7.0, 8.0, 9.0 ]
 */
 
 // MODULES //

lib/node_modules/@stdlib/blas/ext/base/ndarray/dapx/lib/main.js

@@ -31,15 +31,16 @@ var ndarraylike2scalar = require( '@stdlib/ndarray/base/ndarraylike2scalar' );
 // MAIN //
 
 /**
-* Adds a scalar constant to each element in a double-precision floating-point ndarray.
+* Adds a scalar constant to each element in a one-dimensional double-precision floating-point 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
+* @param {ArrayLikeObject<Object>} arrays - array-like object containing a one-dimensional input ndarray and a zero-dimensional ndarray containing a scalar constant
+* @returns {ndarray} input ndarray
 *
 * @example
 * var Float64Array = require( '@stdlib/array/float64' );
 * var ndarray = require( '@stdlib/ndarray/ctor' );
 * var scalar2ndarray = require( '@stdlib/ndarray/from-scalar' );
+* var ndarray2array = require( '@stdlib/ndarray/to-array' );
 *
 * var xbuf = new Float64Array( [ 1.0, 2.0, 3.0, 4.0 ] );
 * var x = new ndarray( 'float64', xbuf, [ 4 ], [ 1 ], 0, 'row-major' );
@@ -50,13 +51,13 @@ var ndarraylike2scalar = require( '@stdlib/ndarray/base/ndarraylike2scalar' );
 *
 * var out = dapx( [ x, alpha ] );
 * // returns <ndarray>
+*
+* var arr = ndarray2array( out );
+* // returns [ 6.0, 7.0, 8.0, 9.0 ]
 */
 function dapx( arrays ) {
 	var x = arrays[ 0 ];
 
-	if ( numelDimension( x, 0 ) <= 0 ) {
-		return x;
-	}
 	strided( numelDimension( x, 0 ), ndarraylike2scalar( arrays[ 1 ] ), getData( x ), getStride( x, 0 ), getOffset( x ) ); // eslint-disable-line max-len
 	return x;
 }

lib/node_modules/@stdlib/blas/ext/base/ndarray/dapx/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@stdlib/blas/ext/base/ndarray/dapx",
   "version": "0.0.0",
-  "description": "Add a scalar constant to each element in a double-precision floating-point ndarray.",
+  "description": "Add a scalar constant to each element in a one-dimensional double-precision floating-point ndarray.",
   "license": "Apache-2.0",
   "author": {
     "name": "The Stdlib Authors",
@@ -64,10 +64,8 @@
     "array",
     "multidimensional",
     "add",
-    "constant",
     "plus",
     "increment",
-    "augment",
     "float64",
     "double",
     "float64array"