@stdlib/blas-base-wasm-ddot 0.1.0

package/dist/index.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../lib/binary.js", "../lib/module.js", "../lib/routine.js", "../lib/main.js", "../lib/index.js"],
+  "sourcesContent": ["/**\n* @license Apache-2.0\n*\n* Copyright (c) 2024 The Stdlib Authors.\n*\n* Licensed under the Apache License, Version 2.0 (the \"License\");\n* you may not use this file except in compliance with the License.\n* You may obtain a copy of the License at\n*\n*    http://www.apache.org/licenses/LICENSE-2.0\n*\n* Unless required by applicable law or agreed to in writing, software\n* distributed under the License is distributed on an \"AS IS\" BASIS,\n* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n* See the License for the specific language governing permissions and\n* limitations under the License.\n*/\n\n'use strict';\n\n// MODULES //\n\nvar resolve = require( 'path' ).resolve;\nvar readWASM = require( '@stdlib/fs-read-wasm' ).sync;\n\n\n// MAIN //\n\nvar wasm = readWASM( resolve( __dirname, '..', 'src', 'main.wasm' ) );\n\n\n// EXPORTS //\n\nmodule.exports = wasm;\n", "/**\n* @license Apache-2.0\n*\n* Copyright (c) 2024 The Stdlib Authors.\n*\n* Licensed under the Apache License, Version 2.0 (the \"License\");\n* you may not use this file except in compliance with the License.\n* You may obtain a copy of the License at\n*\n*    http://www.apache.org/licenses/LICENSE-2.0\n*\n* Unless required by applicable law or agreed to in writing, software\n* distributed under the License is distributed on an \"AS IS\" BASIS,\n* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n* See the License for the specific language governing permissions and\n* limitations under the License.\n*/\n\n/* eslint-disable no-restricted-syntax, no-invalid-this */\n\n'use strict';\n\n// MODULES //\n\nvar isWebAssemblyMemory = require( '@stdlib/assert-is-wasm-memory' );\nvar setReadOnly = require( '@stdlib/utils-define-nonenumerable-read-only-property' );\nvar inherits = require( '@stdlib/utils-inherit' );\nvar WasmModule = require( '@stdlib/wasm-module-wrapper' );\nvar format = require( '@stdlib/string-format' );\nvar wasmBinary = require( './binary.js' );\n\n\n// MAIN //\n\n/**\n* BLAS routine WebAssembly module wrapper constructor.\n*\n* @constructor\n* @param {Object} memory - WebAssembly memory instance\n* @throws {TypeError} must provide a WebAssembly memory instance\n* @returns {Module} module instance\n*\n* @example\n* var Memory = require( '@stdlib/wasm-memory' );\n* var oneTo = require( '@stdlib/array-one-to' );\n* var ones = require( '@stdlib/array-ones' );\n* var zeros = require( '@stdlib/array-zeros' );\n* var bytesPerElement = require( '@stdlib/ndarray-base-bytes-per-element' );\n*\n* // Create a new memory instance with an initial size of 10 pages (640KiB) and a maximum size of 100 pages (6.4MiB):\n* var mem = new Memory({\n*     'initial': 10,\n*     'maximum': 100\n* });\n*\n* // Create a BLAS routine:\n* var ddot = new Module( mem );\n* // returns <Module>\n*\n* // Initialize the routine:\n* ddot.initializeSync();\n*\n* // Define a vector data type:\n* var dtype = 'float64';\n*\n* // Specify a vector length:\n* var N = 5;\n*\n* // Define pointers (i.e., byte offsets) for storing two vectors:\n* var xptr = 0;\n* var yptr = N * bytesPerElement( dtype );\n*\n* // Write vector values to module memory:\n* ddot.write( xptr, oneTo( N, dtype ) );\n* ddot.write( yptr, ones( N, dtype ) );\n*\n* // Perform computation:\n* var dot = ddot.main( N, xptr, 1, yptr, 1 );\n* // returns 15.0\n*/\nfunction Module( memory ) {\n\tif ( !( this instanceof Module ) ) {\n\t\treturn new Module( memory );\n\t}\n\tif ( !isWebAssemblyMemory( memory ) ) {\n\t\tthrow new TypeError( format( 'invalid argument. Must provide a WebAssembly memory instance. Value: `%s`.', memory ) );\n\t}\n\t// Call the parent constructor:\n\tWasmModule.call( this, wasmBinary, memory, {\n\t\t'env': {\n\t\t\t'memory': memory\n\t\t}\n\t});\n\n\treturn this;\n}\n\n// Inherit from the parent constructor:\ninherits( Module, WasmModule );\n\n/**\n* Computes the dot product of `x` and `y`.\n*\n* @name main\n* @memberof Module.prototype\n* @readonly\n* @type {Function}\n* @param {PositiveInteger} N - number of indexed elements\n* @param {NonNegativeInteger} xptr - first input array pointer (i.e., byte offset)\n* @param {integer} strideX - `x` stride length\n* @param {NonNegativeInteger} yptr - second input array pointer (i.e., byte offset)\n* @param {integer} strideY - `y` stride length\n* @returns {number} dot product\n*\n* @example\n* var Memory = require( '@stdlib/wasm-memory' );\n* var oneTo = require( '@stdlib/array-one-to' );\n* var ones = require( '@stdlib/array-ones' );\n* var zeros = require( '@stdlib/array-zeros' );\n* var bytesPerElement = require( '@stdlib/ndarray-base-bytes-per-element' );\n*\n* // Create a new memory instance with an initial size of 10 pages (640KiB) and a maximum size of 100 pages (6.4MiB):\n* var mem = new Memory({\n*     'initial': 10,\n*     'maximum': 100\n* });\n*\n* // Create a BLAS routine:\n* var ddot = new Module( mem );\n* // returns <Module>\n*\n* // Initialize the routine:\n* ddot.initializeSync();\n*\n* // Define a vector data type:\n* var dtype = 'float64';\n*\n* // Specify a vector length:\n* var N = 5;\n*\n* // Define pointers (i.e., byte offsets) for storing two vectors:\n* var xptr = 0;\n* var yptr = N * bytesPerElement( dtype );\n*\n* // Write vector values to module memory:\n* ddot.write( xptr, oneTo( N, dtype ) );\n* ddot.write( yptr, ones( N, dtype ) );\n*\n* // Perform computation:\n* var dot = ddot.main( N, xptr, 1, yptr, 1 );\n* // returns 15.0\n*/\nsetReadOnly( Module.prototype, 'main', function ddot( N, xptr, strideX, yptr, strideY ) {\n\treturn this._instance.exports.c_ddot( N, xptr, strideX, yptr, strideY );\n});\n\n/**\n* Computes the dot product of `x` and `y` using alternative indexing semantics.\n*\n* @name ndarray\n* @memberof Module.prototype\n* @readonly\n* @type {Function}\n* @param {PositiveInteger} N - number of indexed elements\n* @param {NonNegativeInteger} xptr - first input array pointer (i.e., byte offset)\n* @param {integer} strideX - `x` stride length\n* @param {NonNegativeInteger} offsetX - starting `x` index\n* @param {NonNegativeInteger} yptr - second input array pointer (i.e., byte offset)\n* @param {integer} strideY - `y` stride length\n* @param {NonNegativeInteger} offsetY - starting `y` index\n* @returns {number} dot product\n*\n* @example\n* var Memory = require( '@stdlib/wasm-memory' );\n* var oneTo = require( '@stdlib/array-one-to' );\n* var ones = require( '@stdlib/array-ones' );\n* var zeros = require( '@stdlib/array-zeros' );\n* var bytesPerElement = require( '@stdlib/ndarray-base-bytes-per-element' );\n*\n* // Create a new memory instance with an initial size of 10 pages (640KiB) and a maximum size of 100 pages (6.4MiB):\n* var mem = new Memory({\n*     'initial': 10,\n*     'maximum': 100\n* });\n*\n* // Create a BLAS routine:\n* var ddot = new Module( mem );\n* // returns <Module>\n*\n* // Initialize the routine:\n* ddot.initializeSync();\n*\n* // Define a vector data type:\n* var dtype = 'float64';\n*\n* // Specify a vector length:\n* var N = 5;\n*\n* // Define pointers (i.e., byte offsets) for storing two vectors:\n* var xptr = 0;\n* var yptr = N * bytesPerElement( dtype );\n*\n* // Write vector values to module memory:\n* ddot.write( xptr, oneTo( N, dtype ) );\n* ddot.write( yptr, ones( N, dtype ) );\n*\n* // Perform computation:\n* var ddot = ddot.ndarray( N, xptr, 1, 0, yptr, 1, 0 );\n* // returns 15.0\n*/\nsetReadOnly( Module.prototype, 'ndarray', function ddot( N, xptr, strideX, offsetX, yptr, strideY, offsetY ) {\n\treturn this._instance.exports.c_ddot_ndarray( N, xptr, strideX, offsetX, yptr, strideY, offsetY ); // eslint-disable-line max-len\n});\n\n\n// EXPORTS //\n\nmodule.exports = Module;\n", "/**\n* @license Apache-2.0\n*\n* Copyright (c) 2024 The Stdlib Authors.\n*\n* Licensed under the Apache License, Version 2.0 (the \"License\");\n* you may not use this file except in compliance with the License.\n* You may obtain a copy of the License at\n*\n*    http://www.apache.org/licenses/LICENSE-2.0\n*\n* Unless required by applicable law or agreed to in writing, software\n* distributed under the License is distributed on an \"AS IS\" BASIS,\n* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n* See the License for the specific language governing permissions and\n* limitations under the License.\n*/\n\n/* eslint-disable no-restricted-syntax, no-invalid-this */\n\n'use strict';\n\n// MODULES //\n\nvar setReadOnly = require( '@stdlib/utils-define-nonenumerable-read-only-property' );\nvar inherits = require( '@stdlib/utils-inherit' );\nvar stride2offset = require( '@stdlib/strided-base-stride2offset' );\nvar Memory = require( '@stdlib/wasm-memory' );\nvar arrays2ptrs = require( '@stdlib/wasm-base-arrays2ptrs' );\nvar strided2object = require( '@stdlib/wasm-base-strided2object' );\nvar Module = require( './module.js' );\n\n\n// MAIN //\n\n/**\n* Routine constructor.\n*\n* @private\n* @constructor\n* @returns {Routine} routine instance\n*\n* @example\n* var Float64Array = require( '@stdlib/array-float64' );\n*\n* // Create a new routine:\n* var ddot = new Routine();\n*\n* // Initialize the module:\n* ddot.initializeSync();\n*\n* // Define strided arrays:\n* var x = new Float64Array( [ 1.0, 2.0, 3.0, 4.0, 5.0 ] );\n* var y = new Float64Array( [ 1.0, 1.0, 1.0, 1.0, 1.0 ] );\n*\n* // Perform operation:\n* var dot = ddot.main( x.length, x, 1, y, 1 );\n* // returns 15.0\n*\n* @example\n* var Float64Array = require( '@stdlib/array-float64' );\n*\n* // Create a new routine:\n* var ddot = new Routine();\n*\n* // Initialize the module:\n* ddot.initializeSync();\n*\n* // Define strided arrays:\n* var x = new Float64Array( [ 1.0, 2.0, 3.0, 4.0, 5.0 ] );\n* var y = new Float64Array( [ 1.0, 1.0, 1.0, 1.0, 1.0 ] );\n*\n* // Perform operation:\n* var dot = ddot.ndarray( x.length, x, 1, 0, y, 1, 0 );\n* // returns 15.0\n*/\nfunction Routine() {\n\tif ( !( this instanceof Routine ) ) {\n\t\treturn new Routine();\n\t}\n\tModule.call( this, new Memory({\n\t\t'initial': 0\n\t}));\n\treturn this;\n}\n\n// Inherit from the parent constructor:\ninherits( Routine, Module );\n\n/**\n* Computes the dot product of `x` and `y`.\n*\n* @name main\n* @memberof Routine.prototype\n* @readonly\n* @type {Function}\n* @param {PositiveInteger} N - number of indexed elements\n* @param {Float64Array} x - first input array\n* @param {integer} strideX - `x` stride length\n* @param {Float64Array} y - second input array\n* @param {integer} strideY - `y` stride length\n* @returns {number} dot product\n*\n* @example\n* var Float64Array = require( '@stdlib/array-float64' );\n*\n* // Create a new routine:\n* var ddot = new Routine();\n*\n* // Initialize the module:\n* ddot.initializeSync();\n*\n* // Define strided arrays:\n* var x = new Float64Array( [ 1.0, 2.0, 3.0, 4.0, 5.0 ] );\n* var y = new Float64Array( [ 1.0, 1.0, 1.0, 1.0, 1.0 ] );\n*\n* // Perform operation:\n* var dot = ddot.main( x.length, x, 1, y, 1 );\n* // returns 15.0\n*/\nsetReadOnly( Routine.prototype, 'main', function ddot( N, x, strideX, y, strideY ) {\n\treturn this.ndarray( N, x, strideX, stride2offset( N, strideX ), y, strideY, stride2offset( N, strideY ) ); // eslint-disable-line max-len\n});\n\n/**\n* Computes the dot product of `x` and `y` using alternative indexing semantics.\n*\n* @name ndarray\n* @memberof Routine.prototype\n* @readonly\n* @type {Function}\n* @param {PositiveInteger} N - number of indexed elements\n* @param {Float64Array} x - first input array\n* @param {integer} strideX - `x` stride length\n* @param {NonNegativeInteger} offsetX - starting `x` index\n* @param {Float64Array} y - second input array\n* @param {integer} strideY - `y` stride length\n* @param {NonNegativeInteger} offsetY - starting `y` index\n* @returns {number} dot product\n*\n* @example\n* var Float64Array = require( '@stdlib/array-float64' );\n*\n* // Create a new routine:\n* var ddot = new Routine();\n*\n* // Initialize the module:\n* ddot.initializeSync();\n*\n* // Define strided arrays:\n* var x = new Float64Array( [ 1.0, 2.0, 3.0, 4.0, 5.0 ] );\n* var y = new Float64Array( [ 1.0, 1.0, 1.0, 1.0, 1.0 ] );\n*\n* // Perform operation:\n* var dot = ddot.ndarray( x.length, x, 1, 0, y, 1, 0 );\n* // returns 15.0\n*/\nsetReadOnly( Routine.prototype, 'ndarray', function ddot( N, x, strideX, offsetX, y, strideY, offsetY ) {\n\tvar ptrs;\n\tvar p0;\n\tvar p1;\n\n\t// Convert the input arrays to \"pointers\" in the module's memory:\n\tptrs = arrays2ptrs( this, [\n\t\tstrided2object( N, x, strideX, offsetX ),\n\t\tstrided2object( N, y, strideY, offsetY )\n\t]);\n\tp0 = ptrs[ 0 ];\n\tp1 = ptrs[ 1 ];\n\n\t// Perform computation by calling the corresponding parent method:\n\treturn Module.prototype.ndarray.call( this, N, p0.ptr, p0.stride, p0.offset, p1.ptr, p1.stride, p1.offset ); // eslint-disable-line max-len\n});\n\n\n// EXPORTS //\n\nmodule.exports = Routine;\n", "/**\n* @license Apache-2.0\n*\n* Copyright (c) 2024 The Stdlib Authors.\n*\n* Licensed under the Apache License, Version 2.0 (the \"License\");\n* you may not use this file except in compliance with the License.\n* You may obtain a copy of the License at\n*\n*    http://www.apache.org/licenses/LICENSE-2.0\n*\n* Unless required by applicable law or agreed to in writing, software\n* distributed under the License is distributed on an \"AS IS\" BASIS,\n* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n* See the License for the specific language governing permissions and\n* limitations under the License.\n*/\n\n'use strict';\n\n// MODULES //\n\nvar setReadOnly = require( '@stdlib/utils-define-nonenumerable-read-only-property' );\nvar Routine = require( './routine.js' );\nvar Module = require( './module.js' );\n\n\n// MAIN //\n\n/**\n* WebAssembly module to compute the dot product of `x` and `y`.\n*\n* @name ddot\n* @type {Routine}\n*\n* @example\n* var Float64Array = require( '@stdlib/array-float64' );\n*\n* // Define strided arrays:\n* var x = new Float64Array( [ 1.0, 2.0, 3.0, 4.0, 5.0 ] );\n* var y = new Float64Array( [ 1.0, 1.0, 1.0, 1.0, 1.0 ] );\n*\n* // Perform operation:\n* var dot = ddot.main( x.length, x, 1, y, 1 );\n* // returns 15.0\n*\n* @example\n* var Float64Array = require( '@stdlib/array-float64' );\n*\n* // Define strided arrays:\n* var x = new Float64Array( [ 1.0, 2.0, 3.0, 4.0, 5.0 ] );\n* var y = new Float64Array( [ 1.0, 1.0, 1.0, 1.0, 1.0 ] );\n*\n* // Perform operation:\n* var dot = ddot.ndarray( x.length, x, 1, 0, y, 1, 0 );\n* // returns 15.0\n*/\nvar ddot = new Routine();\nddot.initializeSync(); // eslint-disable-line node/no-sync\nsetReadOnly( ddot, 'Module', Module.bind( null ) );\n\n\n// EXPORTS //\n\nmodule.exports = ddot;\n", "/**\n* @license Apache-2.0\n*\n* Copyright (c) 2024 The Stdlib Authors.\n*\n* Licensed under the Apache License, Version 2.0 (the \"License\");\n* you may not use this file except in compliance with the License.\n* You may obtain a copy of the License at\n*\n*    http://www.apache.org/licenses/LICENSE-2.0\n*\n* Unless required by applicable law or agreed to in writing, software\n* distributed under the License is distributed on an \"AS IS\" BASIS,\n* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n* See the License for the specific language governing permissions and\n* limitations under the License.\n*/\n\n'use strict';\n\n/**\n* WebAssembly routine to compute the dot product of `x` and `y`.\n*\n* @module @stdlib/blas-base-wasm-ddot\n*\n* @example\n* var Float64Array = require( '@stdlib/array-float64' );\n* var ddot = require( '@stdlib/blas-base-wasm-ddot' );\n*\n* // Define strided arrays:\n* var x = new Float64Array( [ 1.0, 2.0, 3.0, 4.0, 5.0 ] );\n* var y = new Float64Array( [ 1.0, 1.0, 1.0, 1.0, 1.0 ] );\n*\n* // Perform operation:\n* var dot = ddot.main( x.length, x, 1, y, 1 );\n* // returns 15.0\n*\n* @example\n* var Float64Array = require( '@stdlib/array-float64' );\n* var ddot = require( '@stdlib/blas-base-wasm-ddot' );\n*\n* // Define strided arrays:\n* var x = new Float64Array( [ 1.0, 2.0, 3.0, 4.0, 5.0 ] );\n* var y = new Float64Array( [ 1.0, 1.0, 1.0, 1.0, 1.0 ] );\n*\n* // Perform operation:\n* var dot = ddot.ndarray( x.length, x, 1, 0, y, 1, 0 );\n* // returns 15.0\n*\n* @example\n* var Memory = require( '@stdlib/wasm-memory' );\n* var oneTo = require( '@stdlib/array-one-to' );\n* var ones = require( '@stdlib/array-ones' );\n* var zeros = require( '@stdlib/array-zeros' );\n* var bytesPerElement = require( '@stdlib/ndarray-base-bytes-per-element' );\n* var ddot = require( '@stdlib/blas-base-wasm-ddot' );\n*\n* // Create a new memory instance with an initial size of 10 pages (640KiB) and a maximum size of 100 pages (6.4MiB):\n* var mem = new Memory({\n*     'initial': 10,\n*     'maximum': 100\n* });\n*\n* // Create a BLAS routine:\n* var mod = new ddot.Module( mem );\n* // returns <Module>\n*\n* // Initialize the routine:\n* mod.initializeSync();\n*\n* // Define a vector data type:\n* var dtype = 'float64';\n*\n* // Specify a vector length:\n* var N = 5;\n*\n* // Define pointers (i.e., byte offsets) for storing two vectors:\n* var xptr = 0;\n* var yptr = N * bytesPerElement( dtype );\n*\n* // Write vector values to module memory:\n* mod.write( xptr, oneTo( N, dtype ) );\n* mod.write( yptr, ones( N, dtype ) );\n*\n* // Perform computation:\n* var dot = mod.main( N, xptr, 1, yptr, 1 );\n*\n* console.log( dot );\n* // returns 15.0\n*/\n\n// MODULES //\n\nvar main = require( './main.js' );\n\n\n// EXPORTS //\n\nmodule.exports = main;\n\n// exports: { \"Module\": \"main.Module\" }\n"],
+  "mappings": "uGAAA,IAAAA,EAAAC,EAAA,SAAAC,EAAAC,EAAA,cAsBA,IAAIC,EAAU,QAAS,MAAO,EAAE,QAC5BC,EAAW,QAAS,sBAAuB,EAAE,KAK7CC,EAAOD,EAAUD,EAAS,UAAW,KAAM,MAAO,WAAY,CAAE,EAKpED,EAAO,QAAUG,ICjCjB,IAAAC,EAAAC,EAAA,SAAAC,EAAAC,EAAA,cAwBA,IAAIC,EAAsB,QAAS,+BAAgC,EAC/DC,EAAc,QAAS,uDAAwD,EAC/EC,EAAW,QAAS,uBAAwB,EAC5CC,EAAa,QAAS,6BAA8B,EACpDC,EAAS,QAAS,uBAAwB,EAC1CC,EAAa,IAmDjB,SAASC,EAAQC,EAAS,CACzB,GAAK,EAAG,gBAAgBD,GACvB,OAAO,IAAIA,EAAQC,CAAO,EAE3B,GAAK,CAACP,EAAqBO,CAAO,EACjC,MAAM,IAAI,UAAWH,EAAQ,6EAA8EG,CAAO,CAAE,EAGrH,OAAAJ,EAAW,KAAM,KAAME,EAAYE,EAAQ,CAC1C,IAAO,CACN,OAAUA,CACX,CACD,CAAC,EAEM,IACR,CAGAL,EAAUI,EAAQH,CAAW,EAsD7BF,EAAaK,EAAO,UAAW,OAAQ,SAAeE,EAAGC,EAAMC,EAASC,EAAMC,EAAU,CACvF,OAAO,KAAK,UAAU,QAAQ,OAAQJ,EAAGC,EAAMC,EAASC,EAAMC,CAAQ,CACvE,CAAC,EAwDDX,EAAaK,EAAO,UAAW,UAAW,SAAeE,EAAGC,EAAMC,EAASG,EAASF,EAAMC,EAASE,EAAU,CAC5G,OAAO,KAAK,UAAU,QAAQ,eAAgBN,EAAGC,EAAMC,EAASG,EAASF,EAAMC,EAASE,CAAQ,CACjG,CAAC,EAKDf,EAAO,QAAUO,ICzNjB,IAAAS,EAAAC,EAAA,SAAAC,EAAAC,EAAA,cAwBA,IAAIC,EAAc,QAAS,uDAAwD,EAC/EC,EAAW,QAAS,uBAAwB,EAC5CC,EAAgB,QAAS,oCAAqC,EAC9DC,EAAS,QAAS,qBAAsB,EACxCC,EAAc,QAAS,+BAAgC,EACvDC,EAAiB,QAAS,kCAAmC,EAC7DC,EAAS,IA8Cb,SAASC,GAAU,CAClB,OAAQ,gBAAgBA,GAGxBD,EAAO,KAAM,KAAM,IAAIH,EAAO,CAC7B,QAAW,CACZ,CAAC,CAAC,EACK,MALC,IAAII,CAMb,CAGAN,EAAUM,EAASD,CAAO,EAiC1BN,EAAaO,EAAQ,UAAW,OAAQ,SAAeC,EAAGC,EAAGC,EAASC,EAAGC,EAAU,CAClF,OAAO,KAAK,QAASJ,EAAGC,EAAGC,EAASR,EAAeM,EAAGE,CAAQ,EAAGC,EAAGC,EAASV,EAAeM,EAAGI,CAAQ,CAAE,CAC1G,CAAC,EAmCDZ,EAAaO,EAAQ,UAAW,UAAW,SAAeC,EAAGC,EAAGC,EAASG,EAASF,EAAGC,EAASE,EAAU,CACvG,IAAIC,EACAC,EACAC,EAGJ,OAAAF,EAAOX,EAAa,KAAM,CACzBC,EAAgBG,EAAGC,EAAGC,EAASG,CAAQ,EACvCR,EAAgBG,EAAGG,EAAGC,EAASE,CAAQ,CACxC,CAAC,EACDE,EAAKD,EAAM,CAAE,EACbE,EAAKF,EAAM,CAAE,EAGNT,EAAO,UAAU,QAAQ,KAAM,KAAME,EAAGQ,EAAG,IAAKA,EAAG,OAAQA,EAAG,OAAQC,EAAG,IAAKA,EAAG,OAAQA,EAAG,MAAO,CAC3G,CAAC,EAKDlB,EAAO,QAAUQ,ICjLjB,IAAAW,EAAAC,EAAA,SAAAC,EAAAC,EAAA,cAsBA,IAAIC,EAAc,QAAS,uDAAwD,EAC/EC,EAAU,IACVC,EAAS,IAiCTC,EAAO,IAAIF,EACfE,EAAK,eAAe,EACpBH,EAAaG,EAAM,SAAUD,EAAO,KAAM,IAAK,CAAE,EAKjDH,EAAO,QAAUI,IC6BjB,IAAIC,EAAO,IAKX,OAAO,QAAUA",
+  "names": ["require_binary", "__commonJSMin", "exports", "module", "resolve", "readWASM", "wasm", "require_module", "__commonJSMin", "exports", "module", "isWebAssemblyMemory", "setReadOnly", "inherits", "WasmModule", "format", "wasmBinary", "Module", "memory", "N", "xptr", "strideX", "yptr", "strideY", "offsetX", "offsetY", "require_routine", "__commonJSMin", "exports", "module", "setReadOnly", "inherits", "stride2offset", "Memory", "arrays2ptrs", "strided2object", "Module", "Routine", "N", "x", "strideX", "y", "strideY", "offsetX", "offsetY", "ptrs", "p0", "p1", "require_main", "__commonJSMin", "exports", "module", "setReadOnly", "Routine", "Module", "ddot", "main"]
+}

package/docs/types/index.d.ts

@@ -0,0 +1,357 @@
+/*
+* @license Apache-2.0
+*
+* Copyright (c) 2024 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.
+*/
+
+// TypeScript Version: 4.1
+
+/// <reference types="@stdlib/types"/>
+
+import { ModuleWrapper, Memory } from '@stdlib/types/wasm';
+
+/**
+* Interface defining a module constructor which is both "newable" and "callable".
+*/
+interface ModuleConstructor {
+	/**
+	* Returns a new WebAssembly module wrapper instance which uses the provided WebAssembly memory instance as its underlying memory.
+	*
+	* @param mem - WebAssembly memory instance
+	* @returns module wrapper instance
+	*
+	* @example
+	* var Memory = require( '@stdlib/wasm-memory' );
+	* var oneTo = require( '@stdlib/array-one-to' );
+	* var ones = require( '@stdlib/array-ones' );
+	* var zeros = require( '@stdlib/array-zeros' );
+	* var bytesPerElement = require( '@stdlib/ndarray-base-bytes-per-element' );
+	*
+	* // Create a new memory instance with an initial size of 10 pages (640KiB) and a maximum size of 100 pages (6.4MiB):
+	* var mem = new Memory({
+	*     'initial': 10,
+	*     'maximum': 100
+	* });
+	*
+	* // Create a BLAS routine:
+	* var mod = new ddot.Module( mem );
+	* // returns <Module>
+	*
+	* // Initialize the routine:
+	* mod.initializeSync();
+	*
+	* // Define a vector data type:
+	* var dtype = 'float64';
+	*
+	* // Specify a vector length:
+	* var N = 5;
+	*
+	* // Define pointers (i.e., byte offsets) for storing two vectors:
+	* var xptr = 0;
+	* var yptr = N * bytesPerElement( dtype );
+	*
+	* // Write vector values to module memory:
+	* mod.write( xptr, oneTo( N, dtype ) );
+	* mod.write( yptr, ones( N, dtype ) );
+	*
+	* // Perform computation:
+	* var dot = mod.main( N, xptr, 1, yptr, 1 );
+	* // returns 15.0
+	*/
+	new( mem: Memory ): Module; // newable
+
+	/**
+	* Returns a new WebAssembly module wrapper instance which uses the provided WebAssembly memory instance as its underlying memory.
+	*
+	* @param mem - WebAssembly memory instance
+	* @returns module wrapper instance
+	*
+	* @example
+	* var Memory = require( '@stdlib/wasm-memory' );
+	* var oneTo = require( '@stdlib/array-one-to' );
+	* var ones = require( '@stdlib/array-ones' );
+	* var zeros = require( '@stdlib/array-zeros' );
+	* var bytesPerElement = require( '@stdlib/ndarray-base-bytes-per-element' );
+	*
+	* // Create a new memory instance with an initial size of 10 pages (640KiB) and a maximum size of 100 pages (6.4MiB):
+	* var mem = new Memory({
+	*     'initial': 10,
+	*     'maximum': 100
+	* });
+	*
+	* // Create a BLAS routine:
+	* var mod = ddot.Module( mem );
+	* // returns <Module>
+	*
+	* // Initialize the routine:
+	* mod.initializeSync();
+	*
+	* // Define a vector data type:
+	* var dtype = 'float64';
+	*
+	* // Specify a vector length:
+	* var N = 5;
+	*
+	* // Define pointers (i.e., byte offsets) for storing two vectors:
+	* var xptr = 0;
+	* var yptr = N * bytesPerElement( dtype );
+	*
+	* // Write vector values to module memory:
+	* mod.write( xptr, oneTo( N, dtype ) );
+	* mod.write( yptr, ones( N, dtype ) );
+	*
+	* // Perform computation:
+	* var dot = mod.main( N, xptr, 1, yptr, 1 );
+	* // returns 15.0
+	*/
+	( mem: Memory ): Module; // callable
+}
+
+/**
+* Interface describing a `ddot` WebAssembly module.
+*/
+interface Module extends ModuleWrapper {
+	/**
+	* Computes the dot product of `x` and `y`.
+	*
+	* @param N - number of indexed elements
+	* @param xptr - first input array pointer (i.e., byte offset)
+	* @param strideX - `x` stride length
+	* @param yptr - second input array pointer (i.e., byte offset)
+	* @param strideY - `y` stride length
+	* @returns dot product
+	*
+	* @example
+	* var Memory = require( '@stdlib/wasm-memory' );
+	* var oneTo = require( '@stdlib/array-one-to' );
+	* var ones = require( '@stdlib/array-ones' );
+	* var zeros = require( '@stdlib/array-zeros' );
+	* var bytesPerElement = require( '@stdlib/ndarray-base-bytes-per-element' );
+	*
+	* // Create a new memory instance with an initial size of 10 pages (640KiB) and a maximum size of 100 pages (6.4MiB):
+	* var mem = new Memory({
+	*     'initial': 10,
+	*     'maximum': 100
+	* });
+	*
+	* // Create a BLAS routine:
+	* var mod = new ddot.Module( mem );
+	* // returns <Module>
+	*
+	* // Initialize the routine:
+	* mod.initializeSync();
+	*
+	* // Define a vector data type:
+	* var dtype = 'float64';
+	*
+	* // Specify a vector length:
+	* var N = 5;
+	*
+	* // Define pointers (i.e., byte offsets) for storing two vectors:
+	* var xptr = 0;
+	* var yptr = N * bytesPerElement( dtype );
+	*
+	* // Write vector values to module memory:
+	* mod.write( xptr, oneTo( N, dtype ) );
+	* mod.write( yptr, ones( N, dtype ) );
+	*
+	* // Perform computation:
+	* var dot = mod.main( N, xptr, 1, yptr, 1 );
+	* // returns 15.0
+	*/
+	main( N: number, xptr: number, strideX: number, yptr: number, strideY: number ): number;
+
+	/**
+	* Computes the dot product of `x` and `y` using alternative indexing semantics.
+	*
+	* @param N - number of indexed elements
+	* @param xptr - first input array pointer (i.e., byte offset)
+	* @param strideX - `x` stride length
+	* @param offsetX - starting index for `x`
+	* @param yptr - second input array pointer (i.e., byte offset)
+	* @param strideY - `y` stride length
+	* @param offsetY - starting index for `y`
+	* @returns dot product
+	*
+	* @example
+	* var Memory = require( '@stdlib/wasm-memory' );
+	* var oneTo = require( '@stdlib/array-one-to' );
+	* var ones = require( '@stdlib/array-ones' );
+	* var zeros = require( '@stdlib/array-zeros' );
+	* var bytesPerElement = require( '@stdlib/ndarray-base-bytes-per-element' );
+	*
+	* // Create a new memory instance with an initial size of 10 pages (640KiB) and a maximum size of 100 pages (6.4MiB):
+	* var mem = new Memory({
+	*     'initial': 10,
+	*     'maximum': 100
+	* });
+	*
+	* // Create a BLAS routine:
+	* var mod = new ddot.Module( mem );
+	* // returns <Module>
+	*
+	* // Initialize the routine:
+	* mod.initializeSync();
+	*
+	* // Define a vector data type:
+	* var dtype = 'float64';
+	*
+	* // Specify a vector length:
+	* var N = 5;
+	*
+	* // Define pointers (i.e., byte offsets) for storing two vectors:
+	* var xptr = 0;
+	* var yptr = N * bytesPerElement( dtype );
+	*
+	* // Write vector values to module memory:
+	* mod.write( xptr, oneTo( N, dtype ) );
+	* mod.write( yptr, ones( N, dtype ) );
+	*
+	* // Perform computation:
+	* var dot = mod.ndarray( N, xptr, 1, 0, yptr, 1, 0 );
+	* // returns 15.0
+	*/
+	ndarray( N: number, xptr: number, strideX: number, offsetX: number, yptr: number, strideY: number, offsetY: number ): number;
+}
+
+/**
+* Interface describing `ddot`.
+*/
+interface Routine extends ModuleWrapper {
+	/**
+	* Computes the dot product of `x` and `y`.
+	*
+	* @param N - number of indexed elements
+	* @param x - first input array
+	* @param strideX - `x` stride length
+	* @param y - second input array
+	* @param strideY - `y` stride length
+	* @returns dot product
+	*
+	* @example
+	* var Float64Array = require( '@stdlib/array-float64' );
+	*
+	* var x = new Float64Array( [ 1.0, 2.0, 3.0, 4.0, 5.0 ] );
+	* var y = new Float64Array( [ 1.0, 1.0, 1.0, 1.0, 1.0 ] );
+	*
+	* var dot = ddot.main( x.length, x, 1, y, 1 );
+	* // returns 15.0
+	*/
+	main( N: number, x: Float64Array, strideX: number, y: Float64Array, strideY: number ): number;
+
+	/**
+	* Computes the dot product of `x` and `y` using alternative indexing semantics.
+	*
+	* @param N - number of indexed elements
+	* @param x - first input array
+	* @param strideX - `x` stride length
+	* @param offsetX - starting index for `x`
+	* @param y - second input array
+	* @param strideY - `y` stride length
+	* @param offsetY - starting index for `y`
+	* @returns dot product
+	*
+	* @example
+	* var Float64Array = require( '@stdlib/array-float64' );
+	*
+	* var x = new Float64Array( [ 1.0, 2.0, 3.0, 4.0, 5.0 ] );
+	* var y = new Float64Array( [ 1.0, 1.0, 1.0, 1.0, 1.0 ] );
+	*
+	* var dot = ddot.ndarray( x.length, x, 1, 0, y, 1, 0 );
+	* // returns 15.0
+	*/
+	ndarray( N: number, x: Float64Array, strideX: number, offsetX: number, y: Float64Array, strideY: number, offsetY: number ): number;
+
+	/**
+	* Returns a new WebAssembly module wrapper instance which uses the provided WebAssembly memory instance as its underlying memory.
+	*
+	* @param mem - WebAssembly memory instance
+	* @returns module wrapper instance
+	*
+	* @example
+	* var Memory = require( '@stdlib/wasm-memory' );
+	* var oneTo = require( '@stdlib/array-one-to' );
+	* var ones = require( '@stdlib/array-ones' );
+	* var zeros = require( '@stdlib/array-zeros' );
+	* var bytesPerElement = require( '@stdlib/ndarray-base-bytes-per-element' );
+	*
+	* // Create a new memory instance with an initial size of 10 pages (640KiB) and a maximum size of 100 pages (6.4MiB):
+	* var mem = new Memory({
+	*     'initial': 10,
+	*     'maximum': 100
+	* });
+	*
+	* // Create a BLAS routine:
+	* var mod = new ddot.Module( mem );
+	* // returns <Module>
+	*
+	* // Initialize the routine:
+	* mod.initializeSync();
+	*
+	* // Define a vector data type:
+	* var dtype = 'float64';
+	*
+	* // Specify a vector length:
+	* var N = 5;
+	*
+	* // Define pointers (i.e., byte offsets) for storing two vectors:
+	* var xptr = 0;
+	* var yptr = N * bytesPerElement( dtype );
+	*
+	* // Write vector values to module memory:
+	* mod.write( xptr, oneTo( N, dtype ) );
+	* mod.write( yptr, ones( N, dtype ) );
+	*
+	* // Perform computation:
+	* var dot = mod.main( N, xptr, 1, yptr, 1 );
+	* // returns 15.0
+	*/
+	Module: ModuleConstructor;
+}
+
+/**
+* Computes the dot product of `x` and `y`.
+*
+* @param N - number of indexed elements
+* @param x - first input array
+* @param strideX - `x` stride length
+* @param y - second input array
+* @param strideY - `y` stride length
+* @returns dot product
+*
+* @example
+* var Float64Array = require( '@stdlib/array-float64' );
+*
+* var x = new Float64Array( [ 1.0, 2.0, 3.0, 4.0, 5.0 ] );
+* var y = new Float64Array( [ 1.0, 1.0, 1.0, 1.0, 1.0 ] );
+*
+* var dot = ddot.main( x.length, x, 1, y, 1 );
+* // returns 15.0
+*
+* @example
+* var Float64Array = require( '@stdlib/array-float64' );
+*
+* var x = new Float64Array( [ 1.0, 2.0, 3.0, 4.0, 5.0 ] );
+* var y = new Float64Array( [ 1.0, 1.0, 1.0, 1.0, 1.0 ] );
+*
+* var dot = ddot.ndarray( x.length, x, 1, 0, y, 1, 0 );
+* // returns 15.0
+*/
+declare var ddot: Routine;
+
+
+// EXPORTS //
+
+export = ddot;

package/lib/binary.browser.js

@@ -0,0 +1,33 @@
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2024 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.
+*/
+
+'use strict';
+
+// MODULES //
+
+var base64ToUint8Array = require( '@stdlib/string-base-base64-to-uint8array' );
+
+
+// MAIN //
+
+var wasm = base64ToUint8Array( 'AGFzbQEAAAAADwhkeWxpbmsuMAEEAAAAAAEYA2AAAGAFf39/f38BfGAHf39/f39/fwF8Ag8BA2VudgZtZW1vcnkCAAADBAMAAQIHSgQRX193YXNtX2NhbGxfY3RvcnMAABhfX3dhc21fYXBwbHlfZGF0YV9yZWxvY3MAAAZjX2Rkb3QAAQ5jX2Rkb3RfbmRhcnJheQACCtsCAwMAAQstACAAIAEgAkEBIABrIgAgAmxBACACQQBMGyADIAQgACAEbEEAIARBAEwbEAILpgICAX8BfAJAIABBAEwEQAwBCyACQQFHIAVBAUdyRQRAAkAgAEEFcCIFRQ0AA0AgBSAHRg0BIAEgA0EDdGorAwAgBCAGQQN0aisDAKIgCKAhCCAHQQFqIQcgBkEBaiEGIANBAWohAwwACwALIABBBUgNAQNAIAAgBUwNAiAIIAEgA0EDdGoiAisDICAEIAZBA3RqIgcrAyCiIAIrAxggBysDGKIgAisDECAHKwMQoiACKwMAIAcrAwCiIAIrAwggBysDCKKgoKCgoCEIIAVBBWohBSAGQQVqIQYgA0EFaiEDDAALAAsDQCAAIAdGDQEgASADQQN0aisDACAEIAZBA3RqKwMAoiAIoCEIIAdBAWohByAFIAZqIQYgAiADaiEDDAALAAsgCAs=' );
+
+
+// EXPORTS //
+
+module.exports = wasm;

package/lib/binary.js

@@ -0,0 +1,34 @@
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2024 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.
+*/
+
+'use strict';
+
+// MODULES //
+
+var resolve = require( 'path' ).resolve;
+var readWASM = require( '@stdlib/fs-read-wasm' ).sync;
+
+
+// MAIN //
+
+var wasm = readWASM( resolve( __dirname, '..', 'src', 'main.wasm' ) );
+
+
+// EXPORTS //
+
+module.exports = wasm;

package/lib/index.js

@@ -0,0 +1,101 @@
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2024 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.
+*/
+
+'use strict';
+
+/**
+* WebAssembly routine to compute the dot product of `x` and `y`.
+*
+* @module @stdlib/blas-base-wasm-ddot
+*
+* @example
+* var Float64Array = require( '@stdlib/array-float64' );
+* var ddot = require( '@stdlib/blas-base-wasm-ddot' );
+*
+* // Define strided arrays:
+* var x = new Float64Array( [ 1.0, 2.0, 3.0, 4.0, 5.0 ] );
+* var y = new Float64Array( [ 1.0, 1.0, 1.0, 1.0, 1.0 ] );
+*
+* // Perform operation:
+* var dot = ddot.main( x.length, x, 1, y, 1 );
+* // returns 15.0
+*
+* @example
+* var Float64Array = require( '@stdlib/array-float64' );
+* var ddot = require( '@stdlib/blas-base-wasm-ddot' );
+*
+* // Define strided arrays:
+* var x = new Float64Array( [ 1.0, 2.0, 3.0, 4.0, 5.0 ] );
+* var y = new Float64Array( [ 1.0, 1.0, 1.0, 1.0, 1.0 ] );
+*
+* // Perform operation:
+* var dot = ddot.ndarray( x.length, x, 1, 0, y, 1, 0 );
+* // returns 15.0
+*
+* @example
+* var Memory = require( '@stdlib/wasm-memory' );
+* var oneTo = require( '@stdlib/array-one-to' );
+* var ones = require( '@stdlib/array-ones' );
+* var zeros = require( '@stdlib/array-zeros' );
+* var bytesPerElement = require( '@stdlib/ndarray-base-bytes-per-element' );
+* var ddot = require( '@stdlib/blas-base-wasm-ddot' );
+*
+* // Create a new memory instance with an initial size of 10 pages (640KiB) and a maximum size of 100 pages (6.4MiB):
+* var mem = new Memory({
+*     'initial': 10,
+*     'maximum': 100
+* });
+*
+* // Create a BLAS routine:
+* var mod = new ddot.Module( mem );
+* // returns <Module>
+*
+* // Initialize the routine:
+* mod.initializeSync();
+*
+* // Define a vector data type:
+* var dtype = 'float64';
+*
+* // Specify a vector length:
+* var N = 5;
+*
+* // Define pointers (i.e., byte offsets) for storing two vectors:
+* var xptr = 0;
+* var yptr = N * bytesPerElement( dtype );
+*
+* // Write vector values to module memory:
+* mod.write( xptr, oneTo( N, dtype ) );
+* mod.write( yptr, ones( N, dtype ) );
+*
+* // Perform computation:
+* var dot = mod.main( N, xptr, 1, yptr, 1 );
+*
+* console.log( dot );
+* // returns 15.0
+*/
+
+// MODULES //
+
+var main = require( './main.js' );
+
+
+// EXPORTS //
+
+module.exports = main;
+
+// exports: { "Module": "main.Module" }

package/lib/main.js

@@ -0,0 +1,65 @@
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2024 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.
+*/
+
+'use strict';
+
+// MODULES //
+
+var setReadOnly = require( '@stdlib/utils-define-nonenumerable-read-only-property' );
+var Routine = require( './routine.js' );
+var Module = require( './module.js' );
+
+
+// MAIN //
+
+/**
+* WebAssembly module to compute the dot product of `x` and `y`.
+*
+* @name ddot
+* @type {Routine}
+*
+* @example
+* var Float64Array = require( '@stdlib/array-float64' );
+*
+* // Define strided arrays:
+* var x = new Float64Array( [ 1.0, 2.0, 3.0, 4.0, 5.0 ] );
+* var y = new Float64Array( [ 1.0, 1.0, 1.0, 1.0, 1.0 ] );
+*
+* // Perform operation:
+* var dot = ddot.main( x.length, x, 1, y, 1 );
+* // returns 15.0
+*
+* @example
+* var Float64Array = require( '@stdlib/array-float64' );
+*
+* // Define strided arrays:
+* var x = new Float64Array( [ 1.0, 2.0, 3.0, 4.0, 5.0 ] );
+* var y = new Float64Array( [ 1.0, 1.0, 1.0, 1.0, 1.0 ] );
+*
+* // Perform operation:
+* var dot = ddot.ndarray( x.length, x, 1, 0, y, 1, 0 );
+* // returns 15.0
+*/
+var ddot = new Routine();
+ddot.initializeSync(); // eslint-disable-line node/no-sync
+setReadOnly( ddot, 'Module', Module.bind( null ) );
+
+
+// EXPORTS //
+
+module.exports = ddot;