chore: add benchmark and docs

0PrashantYadav0 · 0PrashantYadav0 · commit cee7aedb23cc · 2025-03-01T19:19:15.000+05:30
diff --git a/lib/node_modules/@stdlib/blas/ext/base/dnansumkbn2/manifest.json b/lib/node_modules/@stdlib/blas/ext/base/dnansumkbn2/manifest.json
@@ -1,6 +1,7 @@
 {
   "options": {
-    "task": "build"
+    "task": "build",
+    "wasm": false
   },
   "fields": [
     {
@@ -27,6 +28,7 @@
   "confs": [
     {
       "task": "build",
+      "wasm": false,
       "src": [
         "./src/main.c"
       ],
@@ -49,6 +51,7 @@
     },
     {
       "task": "benchmark",
+      "wasm": false,
       "src": [
         "./src/main.c"
       ],
@@ -66,6 +69,24 @@
     },
     {
       "task": "examples",
+      "wasm": false,
+      "src": [
+        "./src/main.c"
+      ],
+      "include": [
+        "./include"
+      ],
+      "libraries": [],
+      "libpath": [],
+      "dependencies": [
+        "@stdlib/math/base/special/abs",
+        "@stdlib/blas/base/shared",
+        "@stdlib/strided/base/stride2offset"
+      ]
+    },
+    {
+      "task": "build",
+      "wasm": true,
       "src": [
         "./src/main.c"
       ],
diff --git a/lib/node_modules/@stdlib/blas/ext/base/wasm/dapxsumkbn2/README.md b/lib/node_modules/@stdlib/blas/ext/base/wasm/dapxsumkbn2/README.md
@@ -20,7 +20,7 @@ limitations under the License.
 
 # dapxsumkbn2
 
-> Add a scalar constant to each double-precision floating-point strided array element and compute the sum using an improved Kahan–Babuška algorithm.
+> Adds a scalar constant to each double-precision floating-point strided array element and computes the sum using a second-order iterative Kahan–Babuška algorithm.
 
 <section class="usage">
 
@@ -32,7 +32,7 @@ var dapxsumkbn2 = require( '@stdlib/blas/ext/base/wasm/dapxsumkbn2' );
 
 #### dapxsumkbn2.main( N, alpha, x, strideX )
 
-Adds a scalar constant to each double-precision floating-point strided array element and computes the sum using an improved Kahan–Babuška algorithm.
+Adds a scalar constant to each double-precision floating-point strided array element and computes the sum using a second-order iterative Kahan–Babuška algorithm.
 
 ```javascript
 var Float64Array = require( '@stdlib/array/float64' );
@@ -77,7 +77,7 @@ var sum = dapxsumkbn2.main( 4, 5.0, x1, 2 );
 
 #### dapxsumkbn2.ndarray( N, alpha, x, strideX, offsetX )
 
-Adds a scalar constant to each double-precision floating-point strided array element and computes the sum using an improved Kahan–Babuška algorithm and alternative indexing semantics.
+Adds a scalar constant to each double-precision floating-point strided array element and computes the sum using a second-order iterative Kahan–Babuška algorithm and alternative indexing semantics.
 
 ```javascript
 var Float64Array = require( '@stdlib/array/float64' );
@@ -132,7 +132,7 @@ mod.initializeSync();
 
 #### dapxsumkbn2.Module.prototype.main( N, alpha, xp, sx )
 
-Adds a scalar constant to each double-precision floating-point strided array element and computes the sum using an improved Kahan–Babuška algorithm.
+Adds a scalar constant to each double-precision floating-point strided array element and computes the sum using a second-order iterative Kahan–Babuška algorithm.
 
 <!-- eslint-disable node/no-sync -->
 
@@ -180,7 +180,7 @@ The function has the following parameters:
 
 #### dapxsumkbn2.Module.prototype.ndarray( N, alpha, xp, sx, ox )
 
-Adds a scalar constant to each double-precision floating-point strided array element and computes the sum using an improved Kahan–Babuška algorithm and alternative indexing semantics.
+Adds a scalar constant to each double-precision floating-point strided array element and computes the sum using a second-order iterative Kahan–Babuška algorithm and alternative indexing semantics.
 
 <!-- eslint-disable node/no-sync -->
 
diff --git a/lib/node_modules/@stdlib/blas/ext/base/wasm/dapxsumkbn2/benchmark/benchmark.js b/lib/node_modules/@stdlib/blas/ext/base/wasm/dapxsumkbn2/benchmark/benchmark.js
@@ -26,7 +26,7 @@ var uniform = require( '@stdlib/random/array/uniform' );
 var isnan = require( '@stdlib/math/base/assert/is-nan' );
 var pow = require( '@stdlib/math/base/special/pow' );
 var pkg = require( './../package.json' ).name;
-var dapxsumkbn = require( './../lib' );
+var dapxsumkbn2 = require( './../lib' );
 
 
 // VARIABLES //
@@ -64,7 +64,7 @@ function createBenchmark( len ) {
 
 		b.tic();
 		for ( i = 0; i < b.iterations; i++ ) {
-			sum = dapxsumkbn.main( x.length, 5.0, x, 1 );
+			sum = dapxsumkbn2.main( x.length, 5.0, x, 1 );
 			if ( isnan( sum ) ) {
 				b.fail( 'should not return NaN' );
 			}
diff --git a/lib/node_modules/@stdlib/blas/ext/base/wasm/dapxsumkbn2/benchmark/benchmark.module.js b/lib/node_modules/@stdlib/blas/ext/base/wasm/dapxsumkbn2/benchmark/benchmark.module.js
@@ -24,7 +24,7 @@ var bench = require( '@stdlib/bench' );
 var hasWebAssemblySupport = require( '@stdlib/assert/has-wasm-support' );
 var Memory = require( '@stdlib/wasm/memory' );
 var pkg = require( './../package.json' ).name;
-var dapxsumkbn = require( './../lib' );
+var dapxsumkbn2 = require( './../lib' );
 
 
 // VARIABLES //
@@ -52,7 +52,7 @@ bench( pkg+':Module:constructor', opts, function benchmark( b ) {
 
 	b.tic();
 	for ( i = 0; i < b.iterations; i++ ) {
-		v = new dapxsumkbn.Module( values[ i%values.length ] );
+		v = new dapxsumkbn2.Module( values[ i%values.length ] );
 		if ( typeof v !== 'object' ) {
 			b.fail( 'should return an object' );
 		}
diff --git a/lib/node_modules/@stdlib/blas/ext/base/wasm/dapxsumkbn2/benchmark/benchmark.module.main.js b/lib/node_modules/@stdlib/blas/ext/base/wasm/dapxsumkbn2/benchmark/benchmark.module.main.js
@@ -28,7 +28,7 @@ var uniform = require( '@stdlib/random/array/uniform' );
 var isnan = require( '@stdlib/math/base/assert/is-nan' );
 var pow = require( '@stdlib/math/base/special/pow' );
 var pkg = require( './../package.json' ).name;
-var dapxsumkbn = require( './../lib' );
+var dapxsumkbn2 = require( './../lib' );
 
 
 // VARIABLES //
@@ -71,7 +71,7 @@ function createBenchmark( len ) {
 		mem = new Memory({
 			'initial': 0
 		});
-		mod = new dapxsumkbn.Module( mem );
+		mod = new dapxsumkbn2.Module( mem );
 
 		// Initialize the module:
 		mod.initializeSync(); // eslint-disable-line node/no-sync
diff --git a/lib/node_modules/@stdlib/blas/ext/base/wasm/dapxsumkbn2/benchmark/benchmark.module.ndarray.js b/lib/node_modules/@stdlib/blas/ext/base/wasm/dapxsumkbn2/benchmark/benchmark.module.ndarray.js
@@ -28,7 +28,7 @@ var uniform = require( '@stdlib/random/array/uniform' );
 var isnan = require( '@stdlib/math/base/assert/is-nan' );
 var pow = require( '@stdlib/math/base/special/pow' );
 var pkg = require( './../package.json' ).name;
-var dapxsumkbn = require( './../lib' );
+var dapxsumkbn2 = require( './../lib' );
 
 
 // VARIABLES //
@@ -71,7 +71,7 @@ function createBenchmark( len ) {
 		mem = new Memory({
 			'initial': 0
 		});
-		mod = new dapxsumkbn.Module( mem );
+		mod = new dapxsumkbn2.Module( mem );
 
 		// Initialize the module:
 		mod.initializeSync(); // eslint-disable-line node/no-sync
diff --git a/lib/node_modules/@stdlib/blas/ext/base/wasm/dapxsumkbn2/benchmark/benchmark.ndarray.js b/lib/node_modules/@stdlib/blas/ext/base/wasm/dapxsumkbn2/benchmark/benchmark.ndarray.js
@@ -26,7 +26,7 @@ var uniform = require( '@stdlib/random/array/uniform' );
 var isnan = require( '@stdlib/math/base/assert/is-nan' );
 var pow = require( '@stdlib/math/base/special/pow' );
 var pkg = require( './../package.json' ).name;
-var dapxsumkbn = require( './../lib' );
+var dapxsumkbn2 = require( './../lib' );
 
 
 // VARIABLES //
@@ -64,7 +64,7 @@ function createBenchmark( len ) {
 
 		b.tic();
 		for ( i = 0; i < b.iterations; i++ ) {
-			sum = dapxsumkbn.ndarray( x.length, 5.0, x, 1, 0 );
+			sum = dapxsumkbn2.ndarray( x.length, 5.0, x, 1, 0 );
 			if ( isnan( sum ) ) {
 				b.fail( 'should not return NaN' );
 			}
diff --git a/lib/node_modules/@stdlib/blas/ext/base/wasm/dapxsumkbn2/docs/repl.txt b/lib/node_modules/@stdlib/blas/ext/base/wasm/dapxsumkbn2/docs/repl.txt
@@ -1,8 +1,8 @@
 
 {{alias}}.main( N, alpha, x, strideX )
     Adds a scalar constant to each double-precision floating-point strided
-    array element and computes the sum using an improved Kahan–Babuška
-    algorithm.
+    array element and computes the sum using a second-order iterative
+    Kahan–Babuška algorithm.
 
     The `N` and stride parameters determine which elements in the strided array
     are accessed at runtime.
@@ -51,9 +51,9 @@
 
 
 {{alias}}.ndarray( N, alpha, x, strideX, offsetX )
-    Adds a scalar constant to each double-precision floating-point strided array
-    element and computes the sum using an improved Kahan–Babuška algorithm and
-    alternative indexing semantics.
+    Adds a scalar constant to each double-precision floating-point strided
+    array element and computes the sum using a second-order iterative
+    Kahan–Babuška algorithm and alternative indexing semantics.
 
     While typed array views mandate a view offset based on the underlying
     buffer, the offset parameter supports indexing semantics based on a starting
diff --git a/lib/node_modules/@stdlib/blas/ext/base/wasm/dapxsumkbn2/docs/types/index.d.ts b/lib/node_modules/@stdlib/blas/ext/base/wasm/dapxsumkbn2/docs/types/index.d.ts
@@ -43,7 +43,7 @@ interface ModuleConstructor {
 	* });
 	*
 	* // Create a BLAS routine:
-	* var mod = new dapxsumkbn.Module( mem );
+	* var mod = new dapxsumkbn2.Module( mem );
 	* // returns <Module>
 	*
 	* // Initialize the routine:
@@ -84,7 +84,7 @@ interface ModuleConstructor {
 	* });
 	*
 	* // Create a BLAS routine:
-	* var mod = dapxsumkbn.Module( mem );
+	* var mod = dapxsumkbn2.Module( mem );
 	* // returns <Module>
 	*
 	* // Initialize the routine:
@@ -110,11 +110,11 @@ interface ModuleConstructor {
 }
 
 /**
-* Interface describing a `dapxsumkbn` WebAssembly module.
+* Interface describing a `dapxsumkbn2` WebAssembly module.
 */
 interface Module extends ModuleWrapper {
 	/**
-	* Adds a scalar constant to each double-precision floating-point strided array element and computes the sum using an improved Kahan–Babuška algorithm.
+	* Adds a scalar constant to each double-precision floating-point strided array element and computes the sum using a second-order iterative Kahan–Babuška algorithm.
 	*
 	* @param N - number of indexed elements
 	* @param alpha - scalar constant
@@ -133,7 +133,7 @@ interface Module extends ModuleWrapper {
 	* });
 	*
 	* // Create a BLAS routine:
-	* var mod = new dapxsumkbn.Module( mem );
+	* var mod = new dapxsumkbn2.Module( mem );
 	* // returns <Module>
 	*
 	* // Initialize the routine:
@@ -158,7 +158,7 @@ interface Module extends ModuleWrapper {
 	main( N: number, alpha: number, xptr: number, strideX: number ): number;
 
 	/**
-	* Adds a scalar constant to each double-precision floating-point strided array element and computes the sum using an improved Kahan–Babuška algorithm and alternative indexing semantics.
+	* Adds a scalar constant to each double-precision floating-point strided array element and computes the sum using a second-order iterative Kahan–Babuška algorithm and alternative indexing semantics.
 	*
 	* @param N - number of indexed elements
 	* @param alpha - scalar constant
@@ -178,7 +178,7 @@ interface Module extends ModuleWrapper {
 	* });
 	*
 	* // Create a BLAS routine:
-	* var mod = new dapxsumkbn.Module( mem );
+	* var mod = new dapxsumkbn2.Module( mem );
 	* // returns <Module>
 	*
 	* // Initialize the routine:
@@ -204,11 +204,11 @@ interface Module extends ModuleWrapper {
 }
 
 /**
-* Interface describing `dapxsumkbn`.
+* Interface describing `dapxsumkbn2`.
 */
 interface Routine extends ModuleWrapper {
 	/**
-	* Adds a scalar constant to each double-precision floating-point strided array element and computes the sum using an improved Kahan–Babuška algorithm.
+	* Adds a scalar constant to each double-precision floating-point strided array element and computes the sum using a second-order iterative Kahan–Babuška algorithm.
 	*
 	* @param N - number of indexed elements
 	* @param alpha - scalar constant
@@ -221,13 +221,13 @@ interface Routine extends ModuleWrapper {
 	*
 	* var x = new Float64Array( [ 1.0, -2.0, 2.0 ] );
 	*
-	* var out = dapxsumkbn.main( 3, 5.0, x, 1 );
+	* var out = dapxsumkbn2.main( 3, 5.0, x, 1 );
 	* // returns 16.0
 	*/
 	main( N: number, alpha: number, x: Float64Array, strideX: number ): number;
 
 	/**
-	* Adds a scalar constant to each double-precision floating-point strided array element and computes the sum using an improved Kahan–Babuška algorithm and alternative indexing semantics.
+	* Adds a scalar constant to each double-precision floating-point strided array element and computes the sum using a second-order iterative Kahan–Babuška algorithm and alternative indexing semantics.
 	*
 	* @param N - number of indexed elements
 	* @param alpha - scalar constant
@@ -241,7 +241,7 @@ interface Routine extends ModuleWrapper {
 	*
 	* var x = new Float64Array( [ 2.0, 1.0, 2.0, -2.0, -2.0, 2.0, 3.0, 4.0 ] );
 	*
-	* var out = dapxsumkbn.ndarray( 4, 5.0, x, 2, 1 );
+	* var out = dapxsumkbn2.ndarray( 4, 5.0, x, 2, 1 );
 	* // returns 25.0
 	*/
 	ndarray( N: number, alpha: number, x: Float64Array, strideX: number, offsetX: number ): number;
@@ -263,7 +263,7 @@ interface Routine extends ModuleWrapper {
 	* });
 	*
 	* // Create a BLAS routine:
-	* var mod = new dapxsumkbn.Module( mem );
+	* var mod = new dapxsumkbn2.Module( mem );
 	* // returns <Module>
 	*
 	* // Initialize the routine:
@@ -289,7 +289,7 @@ interface Routine extends ModuleWrapper {
 }
 
 /**
-* Adds a scalar constant to each double-precision floating-point strided array element and computes the sum using an improved Kahan–Babuška algorithm.
+* Adds a scalar constant to each double-precision floating-point strided array element and computes the sum using a second-order iterative Kahan–Babuška algorithm.
 *
 * @param N - number of indexed elements
 * @param alpha - scalar constant
@@ -302,20 +302,20 @@ interface Routine extends ModuleWrapper {
 *
 * var x = new Float64Array( [ 1.0, -2.0, 2.0 ] );
 *
-* var out = dapxsumkbn.main( 3, 5.0, x, 1 );
+* var out = dapxsumkbn2.main( 3, 5.0, x, 1 );
 * // returns 16.0
 *
 * @example
 * var Float64Array = require( '@stdlib/array/float64' );
 *
 * var x = new Float64Array( [ 2.0, 1.0, 2.0, -2.0, -2.0, 2.0, 3.0, 4.0 ] );
 *
-* var out = dapxsumkbn.ndarray( 4, 5.0, x, 2, 1 );
+* var out = dapxsumkbn2.ndarray( 4, 5.0, x, 2, 1 );
 * // returns 25.0
 */
-declare var dapxsumkbn: Routine;
+declare var dapxsumkbn2: Routine;
 
 
 // EXPORTS //
 
-export = dapxsumkbn;
+export = dapxsumkbn2;
diff --git a/lib/node_modules/@stdlib/blas/ext/base/wasm/dapxsumkbn2/docs/types/test.ts b/lib/node_modules/@stdlib/blas/ext/base/wasm/dapxsumkbn2/docs/types/test.ts
diff --git a/lib/node_modules/@stdlib/blas/ext/base/wasm/dapxsumkbn2/examples/index.js b/lib/node_modules/@stdlib/blas/ext/base/wasm/dapxsumkbn2/examples/index.js
diff --git a/lib/node_modules/@stdlib/blas/ext/base/wasm/dapxsumkbn2/examples/little_endian_arrays.js b/lib/node_modules/@stdlib/blas/ext/base/wasm/dapxsumkbn2/examples/little_endian_arrays.js
diff --git a/lib/node_modules/@stdlib/blas/ext/base/wasm/dapxsumkbn2/examples/module.js b/lib/node_modules/@stdlib/blas/ext/base/wasm/dapxsumkbn2/examples/module.js

Original file line number	Diff line number	Diff line change
`@@ -43,7 +43,7 @@ interface ModuleConstructor {`
`43`	`43`	`* });`
`44`	`44`	`*`
`45`	`45`	`* // Create a BLAS routine:`
`46`		`- * var mod = new dapxsumkbn.Module( mem );`
	`46`	`+ * var mod = new dapxsumkbn2.Module( mem );`
`47`	`47`	`* // returns <Module>`
`48`	`48`	`*`
`49`	`49`	`* // Initialize the routine:`
`@@ -84,7 +84,7 @@ interface ModuleConstructor {`
`84`	`84`	`* });`
`85`	`85`	`*`
`86`	`86`	`* // Create a BLAS routine:`
`87`		`- * var mod = dapxsumkbn.Module( mem );`
	`87`	`+ * var mod = dapxsumkbn2.Module( mem );`
`88`	`88`	`* // returns <Module>`
`89`	`89`	`*`
`90`	`90`	`* // Initialize the routine:`
`@@ -110,11 +110,11 @@ interface ModuleConstructor {`
`110`	`110`	`}`
`111`	`111`
`112`	`112`	`/**`
`113`		-* Interface describing a `dapxsumkbn` WebAssembly module.
	`113`	+* Interface describing a `dapxsumkbn2` WebAssembly module.
`114`	`114`	`*/`
`115`	`115`	`interface Module extends ModuleWrapper {`
`116`	`116`	`/**`
`117`		`- * Adds a scalar constant to each double-precision floating-point strided array element and computes the sum using an improved Kahan–Babuška algorithm.`
	`117`	`+ * Adds a scalar constant to each double-precision floating-point strided array element and computes the sum using a second-order iterative Kahan–Babuška algorithm.`
`118`	`118`	`*`
`119`	`119`	`* @param N - number of indexed elements`
`120`	`120`	`* @param alpha - scalar constant`
`@@ -133,7 +133,7 @@ interface Module extends ModuleWrapper {`
`133`	`133`	`* });`
`134`	`134`	`*`
`135`	`135`	`* // Create a BLAS routine:`
`136`		`- * var mod = new dapxsumkbn.Module( mem );`
	`136`	`+ * var mod = new dapxsumkbn2.Module( mem );`
`137`	`137`	`* // returns <Module>`
`138`	`138`	`*`
`139`	`139`	`* // Initialize the routine:`
`@@ -158,7 +158,7 @@ interface Module extends ModuleWrapper {`
`158`	`158`	`main( N: number, alpha: number, xptr: number, strideX: number ): number;`
`159`	`159`
`160`	`160`	`/**`
`161`		`- * Adds a scalar constant to each double-precision floating-point strided array element and computes the sum using an improved Kahan–Babuška algorithm and alternative indexing semantics.`
	`161`	`+ * Adds a scalar constant to each double-precision floating-point strided array element and computes the sum using a second-order iterative Kahan–Babuška algorithm and alternative indexing semantics.`
`162`	`162`	`*`
`163`	`163`	`* @param N - number of indexed elements`
`164`	`164`	`* @param alpha - scalar constant`
`@@ -178,7 +178,7 @@ interface Module extends ModuleWrapper {`
`178`	`178`	`* });`
`179`	`179`	`*`
`180`	`180`	`* // Create a BLAS routine:`
`181`		`- * var mod = new dapxsumkbn.Module( mem );`
	`181`	`+ * var mod = new dapxsumkbn2.Module( mem );`
`182`	`182`	`* // returns <Module>`
`183`	`183`	`*`
`184`	`184`	`* // Initialize the routine:`
`@@ -204,11 +204,11 @@ interface Module extends ModuleWrapper {`
`204`	`204`	`}`
`205`	`205`
`206`	`206`	`/**`
`207`		-* Interface describing `dapxsumkbn`.
	`207`	+* Interface describing `dapxsumkbn2`.
`208`	`208`	`*/`
`209`	`209`	`interface Routine extends ModuleWrapper {`
`210`	`210`	`/**`
`211`		`- * Adds a scalar constant to each double-precision floating-point strided array element and computes the sum using an improved Kahan–Babuška algorithm.`
	`211`	`+ * Adds a scalar constant to each double-precision floating-point strided array element and computes the sum using a second-order iterative Kahan–Babuška algorithm.`
`212`	`212`	`*`
`213`	`213`	`* @param N - number of indexed elements`
`214`	`214`	`* @param alpha - scalar constant`
`@@ -221,13 +221,13 @@ interface Routine extends ModuleWrapper {`
`221`	`221`	`*`
`222`	`222`	`* var x = new Float64Array( [ 1.0, -2.0, 2.0 ] );`
`223`	`223`	`*`
`224`		`- * var out = dapxsumkbn.main( 3, 5.0, x, 1 );`
	`224`	`+ * var out = dapxsumkbn2.main( 3, 5.0, x, 1 );`
`225`	`225`	`* // returns 16.0`
`226`	`226`	`*/`
`227`	`227`	`main( N: number, alpha: number, x: Float64Array, strideX: number ): number;`
`228`	`228`
`229`	`229`	`/**`
`230`		`- * Adds a scalar constant to each double-precision floating-point strided array element and computes the sum using an improved Kahan–Babuška algorithm and alternative indexing semantics.`
	`230`	`+ * Adds a scalar constant to each double-precision floating-point strided array element and computes the sum using a second-order iterative Kahan–Babuška algorithm and alternative indexing semantics.`
`231`	`231`	`*`
`232`	`232`	`* @param N - number of indexed elements`
`233`	`233`	`* @param alpha - scalar constant`
`@@ -241,7 +241,7 @@ interface Routine extends ModuleWrapper {`
`241`	`241`	`*`
`242`	`242`	`* var x = new Float64Array( [ 2.0, 1.0, 2.0, -2.0, -2.0, 2.0, 3.0, 4.0 ] );`
`243`	`243`	`*`
`244`		`- * var out = dapxsumkbn.ndarray( 4, 5.0, x, 2, 1 );`
	`244`	`+ * var out = dapxsumkbn2.ndarray( 4, 5.0, x, 2, 1 );`
`245`	`245`	`* // returns 25.0`
`246`	`246`	`*/`
`247`	`247`	`ndarray( N: number, alpha: number, x: Float64Array, strideX: number, offsetX: number ): number;`
`@@ -263,7 +263,7 @@ interface Routine extends ModuleWrapper {`
`263`	`263`	`* });`
`264`	`264`	`*`
`265`	`265`	`* // Create a BLAS routine:`
`266`		`- * var mod = new dapxsumkbn.Module( mem );`
	`266`	`+ * var mod = new dapxsumkbn2.Module( mem );`
`267`	`267`	`* // returns <Module>`
`268`	`268`	`*`
`269`	`269`	`* // Initialize the routine:`
`@@ -289,7 +289,7 @@ interface Routine extends ModuleWrapper {`
`289`	`289`	`}`
`290`	`290`
`291`	`291`	`/**`
`292`		`-* Adds a scalar constant to each double-precision floating-point strided array element and computes the sum using an improved Kahan–Babuška algorithm.`
	`292`	`+* Adds a scalar constant to each double-precision floating-point strided array element and computes the sum using a second-order iterative Kahan–Babuška algorithm.`
`293`	`293`	`*`
`294`	`294`	`* @param N - number of indexed elements`
`295`	`295`	`* @param alpha - scalar constant`
`@@ -302,20 +302,20 @@ interface Routine extends ModuleWrapper {`
`302`	`302`	`*`
`303`	`303`	`* var x = new Float64Array( [ 1.0, -2.0, 2.0 ] );`
`304`	`304`	`*`
`305`		`-* var out = dapxsumkbn.main( 3, 5.0, x, 1 );`
	`305`	`+* var out = dapxsumkbn2.main( 3, 5.0, x, 1 );`
`306`	`306`	`* // returns 16.0`
`307`	`307`	`*`
`308`	`308`	`* @example`
`309`	`309`	`* var Float64Array = require( '@stdlib/array/float64' );`
`310`	`310`	`*`
`311`	`311`	`* var x = new Float64Array( [ 2.0, 1.0, 2.0, -2.0, -2.0, 2.0, 3.0, 4.0 ] );`
`312`	`312`	`*`
`313`		`-* var out = dapxsumkbn.ndarray( 4, 5.0, x, 2, 1 );`
	`313`	`+* var out = dapxsumkbn2.ndarray( 4, 5.0, x, 2, 1 );`
`314`	`314`	`* // returns 25.0`
`315`	`315`	`*/`
`316`		`-declare var dapxsumkbn: Routine;`
	`316`	`+declare var dapxsumkbn2: Routine;`
`317`	`317`
`318`	`318`
`319`	`319`	`// EXPORTS //`
`320`	`320`
`321`		`-export = dapxsumkbn;`
	`321`	`+export = dapxsumkbn2;`