From 2790554da3cad84a20d0674050b8885b5ab3a556 Mon Sep 17 00:00:00 2001 From: gururaj1512 Date: Tue, 8 Apr 2025 20:40:22 +0000 Subject: [PATCH 1/8] feat: add `blas/base/zdotu` --- type: pre_commit_static_analysis_report description: Results of running static analysis checks when committing changes. report: - task: lint_filenames status: passed - task: lint_editorconfig status: passed - task: lint_markdown status: passed - task: lint_package_json status: passed - task: lint_repl_help status: passed - task: lint_javascript_src status: passed - task: lint_javascript_cli status: na - task: lint_javascript_examples status: passed - task: lint_javascript_tests status: passed - task: lint_javascript_benchmarks status: passed - task: lint_python status: na - task: lint_r status: na - task: lint_c_src status: na - task: lint_c_examples status: na - task: lint_c_benchmarks status: na - task: lint_c_tests_fixtures status: na - task: lint_shell status: na - task: lint_typescript_declarations status: passed - task: lint_typescript_tests status: passed - task: lint_license_headers status: passed --- --- .../@stdlib/blas/base/zdotu/README.md | 251 ++++++++++++++++++ .../blas/base/zdotu/benchmark/benchmark.js | 107 ++++++++ .../base/zdotu/benchmark/benchmark.ndarray.js | 107 ++++++++ .../@stdlib/blas/base/zdotu/docs/repl.txt | 124 +++++++++ .../blas/base/zdotu/docs/types/index.d.ts | 140 ++++++++++ .../blas/base/zdotu/docs/types/test.ts | 249 +++++++++++++++++ .../@stdlib/blas/base/zdotu/examples/index.js | 37 +++ .../@stdlib/blas/base/zdotu/lib/index.js | 86 ++++++ .../@stdlib/blas/base/zdotu/lib/main.js | 35 +++ .../@stdlib/blas/base/zdotu/lib/ndarray.js | 81 ++++++ .../@stdlib/blas/base/zdotu/lib/zdotu.js | 65 +++++ .../@stdlib/blas/base/zdotu/package.json | 82 ++++++ .../@stdlib/blas/base/zdotu/test/test.js | 82 ++++++ .../blas/base/zdotu/test/test.ndarray.js | 239 +++++++++++++++++ .../blas/base/zdotu/test/test.zdotu.js | 217 +++++++++++++++ 15 files changed, 1902 insertions(+) create mode 100644 lib/node_modules/@stdlib/blas/base/zdotu/README.md create mode 100644 lib/node_modules/@stdlib/blas/base/zdotu/benchmark/benchmark.js create mode 100644 lib/node_modules/@stdlib/blas/base/zdotu/benchmark/benchmark.ndarray.js create mode 100644 lib/node_modules/@stdlib/blas/base/zdotu/docs/repl.txt create mode 100644 lib/node_modules/@stdlib/blas/base/zdotu/docs/types/index.d.ts create mode 100644 lib/node_modules/@stdlib/blas/base/zdotu/docs/types/test.ts create mode 100644 lib/node_modules/@stdlib/blas/base/zdotu/examples/index.js create mode 100644 lib/node_modules/@stdlib/blas/base/zdotu/lib/index.js create mode 100644 lib/node_modules/@stdlib/blas/base/zdotu/lib/main.js create mode 100644 lib/node_modules/@stdlib/blas/base/zdotu/lib/ndarray.js create mode 100644 lib/node_modules/@stdlib/blas/base/zdotu/lib/zdotu.js create mode 100644 lib/node_modules/@stdlib/blas/base/zdotu/package.json create mode 100644 lib/node_modules/@stdlib/blas/base/zdotu/test/test.js create mode 100644 lib/node_modules/@stdlib/blas/base/zdotu/test/test.ndarray.js create mode 100644 lib/node_modules/@stdlib/blas/base/zdotu/test/test.zdotu.js diff --git a/lib/node_modules/@stdlib/blas/base/zdotu/README.md b/lib/node_modules/@stdlib/blas/base/zdotu/README.md new file mode 100644 index 000000000000..694f5d6f47f1 --- /dev/null +++ b/lib/node_modules/@stdlib/blas/base/zdotu/README.md @@ -0,0 +1,251 @@ + + +# zdotu + +> Calculate the dot product of two double-precision complex floating-point vectors. + +
+ +The [dot product][dot-product] (or scalar product) is defined as + + + +```math +\mathbf{zx}\cdot\mathbf{zy} = \sum_{i=0}^{N-1} zx_i zy_i = zx_0 zy_0 + zx_1 zy_1 + \ldots + zx_{N-1} zy_{N-1} +``` + + + + + +
+ + + +
+ +## Usage + +```javascript +var zdotu = require( '@stdlib/blas/base/zdotu' ); +``` + +#### zdotu( N, zx, strideX, zy, strideY ) + +Calculates the dot product of vectors `zx` and `zy`. + +```javascript +var Complex128Array = require( '@stdlib/array/complex128' ); +var real = require( '@stdlib/complex/float64/real' ); +var imag = require( '@stdlib/complex/float64/imag' ); + +var zx = new Complex128Array( [ 4.0, 2.0, -3.0, 5.0, -1.0, 7.0 ] ); +var zy = new Complex128Array( [ 2.0, 6.0, -1.0, -4.0, 8.0, 9.0 ] ); + +var z = zdotu( 3, zx, 1, zy, 1 ); +// returns + +var re = real( z ); +// returns -52.0 + +var im = imag( z ); +// returns 82.0 +``` + +The function has the following parameters: + +- **N**: number of indexed elements. +- **zx**: input [`Complex128Array`][@stdlib/array/complex128]. +- **strideX**: index increment for `zx`. +- **zy**: input [`Complex128Array`][@stdlib/array/complex128]. +- **strideY**: index increment for `zy`. + +The `N` and strides parameters determine which elements in the strided arrays are accessed at runtime. For example, to calculate the dot product of every other value in `zx` and the first `N` elements of `zy` in reverse order, + +```javascript +var Complex128Array = require( '@stdlib/array/complex128' ); +var real = require( '@stdlib/complex/float64/real' ); +var imag = require( '@stdlib/complex/float64/imag' ); + +var zx = new Complex128Array( [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0 ] ); +var zy = new Complex128Array( [ 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0 ] ); + +var z = zdotu( 2, zx, 2, zy, -1 ); +// returns + +var re = real( z ); +// returns -2.0 + +var im = imag( z ); +// returns 14.0 +``` + +Note that indexing is relative to the first index. To introduce an offset, use [`typed array`][mdn-typed-array] views. + + + +```javascript +var Complex128Array = require( '@stdlib/array/complex128' ); +var real = require( '@stdlib/complex/float64/real' ); +var imag = require( '@stdlib/complex/float64/imag' ); + +// Initial arrays... +var zx0 = new Complex128Array( [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0 ] ); +var zy0 = new Complex128Array( [ 7.0, 8.0, 9.0, 10.0, 11.0, 12.0 ] ); + +// Create offset views... +var zx1 = new Complex128Array( zx0.buffer, zx0.BYTES_PER_ELEMENT*1 ); // start at 2nd element +var zy1 = new Complex128Array( zy0.buffer, zy0.BYTES_PER_ELEMENT*2 ); // start at 3th element + +var z = zdotu( 1, zx1, 1, zy1, 1 ); +// returns + +var re = real( z ); +// returns -15.0 + +var im = imag( z ); +// returns 80.0 +``` + +#### zdotu.ndarray( N, zx, strideX, offsetX, zy, strideY, offsetY ) + +Calculates the dot product of `zx` and `zy` using alternative indexing semantics. + +```javascript +var Complex128Array = require( '@stdlib/array/complex128' ); +var real = require( '@stdlib/complex/float64/real' ); +var imag = require( '@stdlib/complex/float64/imag' ); + +var zx = new Complex128Array( [ 4.0, 2.0, -3.0, 5.0, -1.0, 7.0 ] ); +var zy = new Complex128Array( [ 2.0, 6.0, -1.0, -4.0, 8.0, 9.0 ] ); + +var z = zdotu.ndarray( zx.length, zx, 1, 0, zy, 1, 0 ); +// returns + +var re = real( z ); +// returns -52.0 + +var im = imag( z ); +// returns 82.0 +``` + +The function has the following additional parameters: + +- **offsetX**: starting index for `zx`. +- **offsetY**: starting index for `zy`. + +While [`typed array`][mdn-typed-array] views mandate a view offset based on the underlying buffer, the offset parameters support indexing semantics based on starting indices. For example, to calculate the dot product of every other value in `zx` starting from the second value with the last 2 elements in `zy` in reverse order + +```javascript +var Complex128Array = require( '@stdlib/array/complex128' ); +var real = require( '@stdlib/complex/float64/real' ); +var imag = require( '@stdlib/complex/float64/imag' ); + +var zx = new Complex128Array( [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0 ] ); +var zy = new Complex128Array( [ 9.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0 ] ); // eslint-disable-line max-len + +var z = zdotu.ndarray( 2, zx, 2, 1, zy, -1, zy.length-1 ); +// returns + +var re = real( z ); +// returns -40.0 + +var im = imag( z ); +// returns 310.0 +``` + +
+ + + +
+ +## Notes + +- If `N <= 0`, both functions return `0.0 + 0.0i`. +- `zdotu()` corresponds to the [BLAS][blas] level 1 function [`zdotu`][zdotu]. + +
+ + + +
+ +## Examples + + + +```javascript +var discreteUniform = require( '@stdlib/random/base/discrete-uniform' ); +var Complex128 = require( '@stdlib/complex/float64/ctor' ); +var filledarrayBy = require( '@stdlib/array/filled-by' ); +var zdotu = require( '@stdlib/blas/base/zdotu' ); + +function rand() { + return new Complex128( discreteUniform( 0, 10 ), discreteUniform( -5, 5 ) ); +} + +var zx = filledarrayBy( 10, 'complex128', rand ); +console.log( zx.toString() ); + +var zy = filledarrayBy( 10, 'complex128', rand ); +console.log( zy.toString() ); + +var out = zdotu.ndarray( zx.length, zx, 1, 0, zy, -1, zy.length-1 ); +console.log( out.toString() ); +``` + +
+ + + + + +
+ +
+ + + + + +
+ +[dot-product]: https://en.wikipedia.org/wiki/Dot_product + +[blas]: http://www.netlib.org/blas + +[zdotu]: https://www.netlib.org/lapack/explore-html/d1/dcc/group__dot_ga6b0b69474b384d45fc4c7b1f7ec5959f.html#ga6b0b69474b384d45fc4c7b1f7ec5959f + +[@stdlib/array/complex128]: https://github.com/stdlib-js/stdlib/tree/develop/lib/node_modules/%40stdlib/array/complex128 + +[mdn-typed-array]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray + + + + + +
+ + diff --git a/lib/node_modules/@stdlib/blas/base/zdotu/benchmark/benchmark.js b/lib/node_modules/@stdlib/blas/base/zdotu/benchmark/benchmark.js new file mode 100644 index 000000000000..35291f033e06 --- /dev/null +++ b/lib/node_modules/@stdlib/blas/base/zdotu/benchmark/benchmark.js @@ -0,0 +1,107 @@ +/** +* @license Apache-2.0 +* +* Copyright (c) 2025 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 bench = require( '@stdlib/bench' ); +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 Complex128Array = require( '@stdlib/array/complex128' ); +var pkg = require( './../package.json' ).name; +var zdotu = require( './../lib/zdotu.js' ); + + +// VARIABLES // + +var options = { + 'dtype': 'float64' +}; + + +// FUNCTIONS // + +/** +* Creates a benchmark function. +* +* @private +* @param {PositiveInteger} len - array length +* @returns {Function} benchmark function +*/ +function createBenchmark( len ) { + var zx; + var zy; + + zx = new Complex128Array( uniform( len*2, -100.0, 100.0, options ) ); + zy = new Complex128Array( uniform( len*2, -100.0, 100.0, options ) ); + return benchmark; + + /** + * Benchmark function. + * + * @private + * @param {Benchmark} b - benchmark instance + */ + function benchmark( b ) { + var d; + var i; + + b.tic(); + for ( i = 0; i < b.iterations; i++ ) { + d = zdotu( zx.length, zx, 1, zy, 1 ); + if ( isnan( d ) ) { + b.fail( 'should not return NaN' ); + } + } + b.toc(); + if ( isnan( d ) ) { + b.fail( 'should not return NaN' ); + } + b.pass( 'benchmark finished' ); + b.end(); + } +} + + +// MAIN // + +/** +* Main execution sequence. +* +* @private +*/ +function main() { + var len; + var min; + var max; + var f; + var i; + + min = 1; // 10^min + max = 5; // 10^max + + for ( i = min; i <= max; i++ ) { + len = pow( 10, i ); + f = createBenchmark( len ); + bench( pkg+':len='+len, f ); + } +} + +main(); diff --git a/lib/node_modules/@stdlib/blas/base/zdotu/benchmark/benchmark.ndarray.js b/lib/node_modules/@stdlib/blas/base/zdotu/benchmark/benchmark.ndarray.js new file mode 100644 index 000000000000..f1f1ca860db2 --- /dev/null +++ b/lib/node_modules/@stdlib/blas/base/zdotu/benchmark/benchmark.ndarray.js @@ -0,0 +1,107 @@ +/** +* @license Apache-2.0 +* +* Copyright (c) 2025 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 bench = require( '@stdlib/bench' ); +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 Complex128Array = require( '@stdlib/array/complex128' ); +var pkg = require( './../package.json' ).name; +var zdotu = require( './../lib/ndarray.js' ); + + +// VARIABLES // + +var options = { + 'dtype': 'float64' +}; + + +// FUNCTIONS // + +/** +* Creates a benchmark function. +* +* @private +* @param {PositiveInteger} len - array length +* @returns {Function} benchmark function +*/ +function createBenchmark( len ) { + var zx; + var zy; + + zx = new Complex128Array( uniform( len*2, -100.0, 100.0, options ) ); + zy = new Complex128Array( uniform( len*2, -100.0, 100.0, options ) ); + return benchmark; + + /** + * Benchmark function. + * + * @private + * @param {Benchmark} b - benchmark instance + */ + function benchmark( b ) { + var d; + var i; + + b.tic(); + for ( i = 0; i < b.iterations; i++ ) { + d = zdotu( zx.length, zx, 1, 0, zy, 1, 0 ); + if ( isnan( d ) ) { + b.fail( 'should not return NaN' ); + } + } + b.toc(); + if ( isnan( d ) ) { + b.fail( 'should not return NaN' ); + } + b.pass( 'benchmark finished' ); + b.end(); + } +} + + +// MAIN // + +/** +* Main execution sequence. +* +* @private +*/ +function main() { + var len; + var min; + var max; + var f; + var i; + + min = 1; // 10^min + max = 5; // 10^max + + for ( i = min; i <= max; i++ ) { + len = pow( 10, i ); + f = createBenchmark( len ); + bench( pkg+':ndarray:len='+len, f ); + } +} + +main(); diff --git a/lib/node_modules/@stdlib/blas/base/zdotu/docs/repl.txt b/lib/node_modules/@stdlib/blas/base/zdotu/docs/repl.txt new file mode 100644 index 000000000000..f05d4cf51b8e --- /dev/null +++ b/lib/node_modules/@stdlib/blas/base/zdotu/docs/repl.txt @@ -0,0 +1,124 @@ + +{{alias}}( N, zx, strideX, zy, strideY ) + Calculate the dot product of two double-precision complex floating-point + vectors. + + The `N` and stride parameters determine which elements in the strided + arrays are accessed at runtime. + + Indexing is relative to the first index. To introduce an offset, use a + typed array view. + + If `N <= 0`, the function returns `0 + 0i`. + + Parameters + ---------- + N: integer + Number of indexed elements. + + zx: Complex128Array + First input array. + + strideX: integer + Index increment for `zx`. + + zy: Complex128Array + Second input array. + + strideY: integer + Index increment for `zy`. + + Returns + ------- + out: Complex128 + Scalar constant. + + Examples + -------- + // Standard usage: + > var zx = new {{alias:@stdlib/array/complex128}}( [ 1.0, 2.0, 3.0, 4.0 ] ); + > var zy = new {{alias:@stdlib/array/complex128}}( [ 6.0, 7.0, 8.0, 9.0 ] ); + > var z = {{alias}}( zx.length, zx, 1, zy, 1 ); + > var re = {{alias:@stdlib/complex/float64/real}}( z ) + -20.0 + > var im = {{alias:@stdlib/complex/float64/imag}}( z ) + 78.0 + + // Advanced indexing: + > var zx = new {{alias:@stdlib/array/complex128}}( [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0 ] ); + > var zy = new {{alias:@stdlib/array/complex128}}( [ 1.0, 1.0, 1.0, 1.0, 1.0, 1.0 ] ); + > var z = {{alias}}( 2, zx, 2, zy, -1 ); + > var re = {{alias:@stdlib/complex/float64/real}}( z ) + -2.0 + > var im = {{alias:@stdlib/complex/float64/imag}}( z ) + 14.0 + + // Using typed array views: + > var zx0 = new {{alias:@stdlib/array/complex128}}( [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0 ] ); + > var zy0 = new {{alias:@stdlib/array/complex128}}( [ 7.0, 8.0, 9.0, 10.0, 11.0, 12.0 ] ); + > var zx1 = new {{alias:@stdlib/array/complex128}}( zx0.buffer, zx0.BYTES_PER_ELEMENT*1 ); + > var zy1 = new {{alias:@stdlib/array/complex128}}( zy0.buffer, zy0.BYTES_PER_ELEMENT*2 ); + > var z = {{alias}}( 1, zx1, 1, zy1, 1 ); + > var re = {{alias:@stdlib/complex/float64/real}}( z ) + -15.0 + > var im = {{alias:@stdlib/complex/float64/imag}}( z ) + 80.0 + + +{{alias}}.ndarray( N, zx, strideX, offsetX, zy, strideY, offsetY ) + Computes the dot product of two double-precision complex floating-point + vectors using alternative indexing semantics. + + While typed array views mandate a view offset based on the underlying + buffer, the offset parameters support indexing based on a starting index. + + Parameters + ---------- + N: integer + Number of indexed elements. + + zx: Complex128Array + First input array. + + strideX: integer + Index increment for `zx`. + + offsetX: integer + Starting index for `zx`. + + zy: Complex128Array + Second input array. + + strideY: integer + Index increment for `zy`. + + offsetY: integer + Starting index for `zy`. + + Returns + ------- + out: Complex128 + Second input array. + + Examples + -------- + // Standard usage: + > var zx = new {{alias:@stdlib/array/complex128}}( [ 1.0, 2.0, 3.0, 4.0 ] ); + > var zy = new {{alias:@stdlib/array/complex128}}( [ 6.0, 7.0, 8.0, 9.0 ] ); + > var z = {{alias}}.ndarray( zx.length, zx, 1, 0, zy, 1, 0 ); + > var re = {{alias:@stdlib/complex/float64/real}}( z ) + -20.0 + > var im = {{alias:@stdlib/complex/float64/imag}}( z ) + 78.0 + + // Advanced indexing: + > var zx = new {{alias:@stdlib/array/complex128}}( [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0 ] ); + > var zy = new {{alias:@stdlib/array/complex128}}( [ 1.0, 1.0, 1.0, 1.0, 1.0, 1.0 ] ); + > var z = {{alias}}.ndarray( 1, zx, 2, 1, zy, -1, zy.length-1 ); + > var re = {{alias:@stdlib/complex/float64/real}}( z ) + -1.0 + > var im = {{alias:@stdlib/complex/float64/imag}}( z ) + 7.0 + + See Also + -------- diff --git a/lib/node_modules/@stdlib/blas/base/zdotu/docs/types/index.d.ts b/lib/node_modules/@stdlib/blas/base/zdotu/docs/types/index.d.ts new file mode 100644 index 000000000000..8029480bd329 --- /dev/null +++ b/lib/node_modules/@stdlib/blas/base/zdotu/docs/types/index.d.ts @@ -0,0 +1,140 @@ +/* +* @license Apache-2.0 +* +* Copyright (c) 2025 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 + +/// + +import { Complex128Array } from '@stdlib/types/array'; +import { Complex128 } from '@stdlib/types/complex'; + +/** +* Interface describing `zdotu`. +*/ +interface Routine { + /** + * Calculates the dot product of vectors `zx` and `zy`. + * + * @param N - number of indexed elements + * @param zx - first input array + * @param strideX - `zx` stride length + * @param zy - second input array + * @param strideY - `zy` stride length + * @returns dot product + * + * @example + * var Complex128Array = require( '@stdlib/array/complex128' ); + * var real = require( '@stdlib/complex/float64/real' ); + * var imag = require( '@stdlib/complex/float64/imag' ); + * + * var zx = new Complex128Array( [ 4.0, 2.0, -3.0, 5.0, -1.0, 7.0 ] ); + * var zy = new Complex128Array( [ 2.0, 6.0, -1.0, -4.0, 8.0, 9.0 ] ); + * + * var z = zdotu( 3, zx, 1, zy, 1 ); + * // returns + * + * var re = real( z ); + * // returns -52.0 + * + * var im = imag( z ); + * // returns 82.0 + */ + ( N: number, zx: Complex128Array, strideX: number, zy: Complex128Array, strideY: number ): Complex128; + + /** + * Calculates the dot product of vectors `zx` and `zy` using alternative indexing semantics. + * + * @param N - number of indexed elements + * @param zx - first input array + * @param strideX - `zx` stride length + * @param offsetX - starting index for `zx` + * @param zy - second input array + * @param strideY - `zy` stride length + * @param offsetY - starting index for `zy` + * @returns dot product + * + * @example + * var Complex128Array = require( '@stdlib/array/complex128' ); + * var real = require( '@stdlib/complex/float64/real' ); + * var imag = require( '@stdlib/complex/float64/imag' ); + * + * var zx = new Complex128Array( [ 4.0, 2.0, -3.0, 5.0, -1.0, 7.0 ] ); + * var zy = new Complex128Array( [ 2.0, 6.0, -1.0, -4.0, 8.0, 9.0 ] ); + * + * var z = zdotu.ndarray( zx.length, zx, 1, 0, zy, 1, 0 ); + * // returns + * + * var re = real( z ); + * // returns -52.0 + * + * var im = imag( z ); + * // returns 82.0 + */ + ndarray( N: number, zx: Complex128Array, strideX: number, offsetX: number, zy: Complex128Array, strideY: number, offsetY: number ): Complex128; +} + +/** +* Computes the dot product of two double-precision complex floating-point vectors. +* +* @param N - number of indexed elements +* @param zx - first input array +* @param strideX - `zx` stride length +* @param zy - second input array +* @param strideY - `zy` stride length +* @returns dot product +* +* @example +* var Complex128Array = require( '@stdlib/array/complex128' ); +* var real = require( '@stdlib/complex/float64/real' ); +* var imag = require( '@stdlib/complex/float64/imag' ); +* +* var zx = new Complex128Array( [ 4.0, 2.0, -3.0, 5.0, -1.0, 7.0 ] ); +* var zy = new Complex128Array( [ 2.0, 6.0, -1.0, -4.0, 8.0, 9.0 ] ); +* +* var z = zdotu( 3, zx, 1, zy, 1 ); +* // returns +* +* var re = real( z ); +* // returns -52.0 +* +* var im = imag( z ); +* // returns 82.0 +* +* @example +* var Complex128Array = require( '@stdlib/array/complex128' ); +* var real = require( '@stdlib/complex/float64/real' ); +* var imag = require( '@stdlib/complex/float64/imag' ); +* +* var zx = new Complex128Array( [ 4.0, 2.0, -3.0, 5.0, -1.0, 7.0 ] ); +* var zy = new Complex128Array( [ 2.0, 6.0, -1.0, -4.0, 8.0, 9.0 ] ); +* +* var z = zdotu.ndarray( zx.length, zx, 1, 0, zy, 1, 0 ); +* // returns +* +* var re = real( z ); +* // returns -52.0 +* +* var im = imag( z ); +* // returns 82.0 +*/ +declare var zdotu: Routine; + + +// EXPORTS // + +export = zdotu; diff --git a/lib/node_modules/@stdlib/blas/base/zdotu/docs/types/test.ts b/lib/node_modules/@stdlib/blas/base/zdotu/docs/types/test.ts new file mode 100644 index 000000000000..5f71f5886c3e --- /dev/null +++ b/lib/node_modules/@stdlib/blas/base/zdotu/docs/types/test.ts @@ -0,0 +1,249 @@ +/* +* @license Apache-2.0 +* +* Copyright (c) 2025 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. +*/ + +import Complex128Array = require( '@stdlib/array/complex128' ); +import zdotu = require( './index' ); + + +// TESTS // + +// The function returns Complex128... +{ + const zx = new Complex128Array( 10 ); + const zy = new Complex128Array( 10 ); + + zdotu( zx.length, zx, 1, zy, 1 ); // $ExpectType Complex128 +} + +// The compiler throws an error if the function is provided a first argument which is not a number... +{ + const zx = new Complex128Array( 10 ); + const zy = new Complex128Array( 10 ); + + zdotu( '10', zx, 1, zy, 1 ); // $ExpectError + zdotu( true, zx, 1, zy, 1 ); // $ExpectError + zdotu( false, zx, 1, zy, 1 ); // $ExpectError + zdotu( null, zx, 1, zy, 1 ); // $ExpectError + zdotu( undefined, zx, 1, zy, 1 ); // $ExpectError + zdotu( [], zx, 1, zy, 1 ); // $ExpectError + zdotu( {}, zx, 1, zy, 1 ); // $ExpectError + zdotu( ( zx: number ): number => zx, zx, 1, zy, 1 ); // $ExpectError +} + +// The compiler throws an error if the function is provided a second argument which is not a Complex128Array... +{ + const zx = new Complex128Array( 10 ); + const zy = new Complex128Array( 10 ); + + zdotu( zx.length, 10, 1, zy, 1 ); // $ExpectError + zdotu( zx.length, '10', 1, zy, 1 ); // $ExpectError + zdotu( zx.length, true, 1, zy, 1 ); // $ExpectError + zdotu( zx.length, false, 1, zy, 1 ); // $ExpectError + zdotu( zx.length, null, 1, zy, 1 ); // $ExpectError + zdotu( zx.length, undefined, 1, zy, 1 ); // $ExpectError + zdotu( zx.length, [ '1' ], 1, zy, 1 ); // $ExpectError + zdotu( zx.length, {}, 1, zy, 1 ); // $ExpectError + zdotu( zx.length, ( zx: number ): number => zx, 1, zy, 1 ); // $ExpectError +} + +// The compiler throws an error if the function is provided a third argument which is not a number... +{ + const zx = new Complex128Array( 10 ); + const zy = new Complex128Array( 10 ); + + zdotu( zx.length, zx, '10', zy, 1 ); // $ExpectError + zdotu( zx.length, zx, true, zy, 1 ); // $ExpectError + zdotu( zx.length, zx, false, zy, 1 ); // $ExpectError + zdotu( zx.length, zx, null, zy, 1 ); // $ExpectError + zdotu( zx.length, zx, undefined, zy, 1 ); // $ExpectError + zdotu( zx.length, zx, [], zy, 1 ); // $ExpectError + zdotu( zx.length, zx, {}, zy, 1 ); // $ExpectError + zdotu( zx.length, zx, ( zx: number ): number => zx, zy, 1 ); // $ExpectError +} + +// The compiler throws an error if the function is provided a fourth argument which is not a Complex128Array... +{ + const zx = new Complex128Array( 10 ); + + zdotu( zx.length, zx, 1, 10, 1 ); // $ExpectError + zdotu( zx.length, zx, 1, '10', 1 ); // $ExpectError + zdotu( zx.length, zx, 1, true, 1 ); // $ExpectError + zdotu( zx.length, zx, 1, false, 1 ); // $ExpectError + zdotu( zx.length, zx, 1, null, 1 ); // $ExpectError + zdotu( zx.length, zx, 1, undefined, 1 ); // $ExpectError + zdotu( zx.length, zx, 1, [], 1 ); // $ExpectError + zdotu( zx.length, zx, 1, {}, 1 ); // $ExpectError + zdotu( zx.length, zx, 1, ( zx: number ): number => zx, 1 ); // $ExpectError +} + +// The compiler throws an error if the function is provided a fifth argument which is not a number... +{ + const zx = new Complex128Array( 10 ); + const zy = new Complex128Array( 10 ); + + zdotu( zx.length, zx, 1, zy, '10' ); // $ExpectError + zdotu( zx.length, zx, 1, zy, true ); // $ExpectError + zdotu( zx.length, zx, 1, zy, false ); // $ExpectError + zdotu( zx.length, zx, 1, zy, null ); // $ExpectError + zdotu( zx.length, zx, 1, zy, undefined ); // $ExpectError + zdotu( zx.length, zx, 1, zy, [] ); // $ExpectError + zdotu( zx.length, zx, 1, zy, {} ); // $ExpectError + zdotu( zx.length, zx, 1, zy, ( zx: number ): number => zx ); // $ExpectError +} + +// The compiler throws an error if the function is provided an unsupported number of arguments... +{ + const zx = new Complex128Array( 10 ); + const zy = new Complex128Array( 10 ); + + zdotu(); // $ExpectError + zdotu( zx.length ); // $ExpectError + zdotu( zx.length, zx ); // $ExpectError + zdotu( zx.length, zx, 1 ); // $ExpectError + zdotu( zx.length, zx, 1, zy ); // $ExpectError + zdotu( zx.length, zx, 1, zy, 1, 10 ); // $ExpectError +} + +// Attached to main export is an `ndarray` method which returns a Complex128... +{ + const zx = new Complex128Array( 10 ); + const zy = new Complex128Array( 10 ); + + zdotu.ndarray( zx.length, zx, 1, 0, zy, 1, 0 ); // $ExpectType Complex128 +} + +// The compiler throws an error if the `ndarray` method is provided a first argument which is not a number... +{ + const zx = new Complex128Array( 10 ); + const zy = new Complex128Array( 10 ); + + zdotu.ndarray( '10', zx, 1, 0, zy, 1, 0 ); // $ExpectError + zdotu.ndarray( true, zx, 1, 0, zy, 1, 0 ); // $ExpectError + zdotu.ndarray( false, zx, 1, 0, zy, 1, 0 ); // $ExpectError + zdotu.ndarray( null, zx, 1, 0, zy, 1, 0 ); // $ExpectError + zdotu.ndarray( undefined, zx, 1, 0, zy, 1, 0 ); // $ExpectError + zdotu.ndarray( [], zx, 1, 0, zy, 1, 0 ); // $ExpectError + zdotu.ndarray( {}, zx, 1, 0, zy, 1, 0 ); // $ExpectError + zdotu.ndarray( ( zx: number ): number => zx, zx, 1, 0, zy, 1, 0 ); // $ExpectError +} + +// The compiler throws an error if the `ndarray` method is provided a second argument which is not a Complex128Array... +{ + const zx = new Complex128Array( 10 ); + const zy = new Complex128Array( 10 ); + + zdotu.ndarray( zx.length, 10, 1, 0, zy, 1, 0 ); // $ExpectError + zdotu.ndarray( zx.length, '10', 1, 0, zy, 1, 0 ); // $ExpectError + zdotu.ndarray( zx.length, true, 1, 0, zy, 1, 0 ); // $ExpectError + zdotu.ndarray( zx.length, false, 1, 0, zy, 1, 0 ); // $ExpectError + zdotu.ndarray( zx.length, null, 1, 0, zy, 1, 0 ); // $ExpectError + zdotu.ndarray( zx.length, undefined, 1, 0, zy, 1, 0 ); // $ExpectError + zdotu.ndarray( zx.length, [], 1, 0, zy, 1, 0 ); // $ExpectError + zdotu.ndarray( zx.length, {}, 1, 0, zy, 1, 0 ); // $ExpectError + zdotu.ndarray( zx.length, ( zx: number ): number => zx, 1, 0, zy, 1, 0 ); // $ExpectError +} + +// The compiler throws an error if the `ndarray` method is provided a third argument which is not a number... +{ + const zx = new Complex128Array( 10 ); + const zy = new Complex128Array( 10 ); + + zdotu.ndarray( zx.length, zx, '10', 0, zy, 1, 0 ); // $ExpectError + zdotu.ndarray( zx.length, zx, true, 0, zy, 1, 0 ); // $ExpectError + zdotu.ndarray( zx.length, zx, false, 0, zy, 1, 0 ); // $ExpectError + zdotu.ndarray( zx.length, zx, null, 0, zy, 1, 0 ); // $ExpectError + zdotu.ndarray( zx.length, zx, undefined, 0, zy, 1, 0 ); // $ExpectError + zdotu.ndarray( zx.length, zx, [], 0, zy, 1, 0 ); // $ExpectError + zdotu.ndarray( zx.length, zx, {}, 0, zy, 1, 0 ); // $ExpectError + zdotu.ndarray( zx.length, zx, ( zx: number ): number => zx, 0, zy, 1, 0 ); // $ExpectError +} + +// The compiler throws an error if the `ndarray` method is provided a fourth argument which is not a number... +{ + const zx = new Complex128Array( 10 ); + const zy = new Complex128Array( 10 ); + + zdotu.ndarray( zx.length, zx, 1, '10', zy, 1, 0 ); // $ExpectError + zdotu.ndarray( zx.length, zx, 1, true, zy, 1, 0 ); // $ExpectError + zdotu.ndarray( zx.length, zx, 1, false, zy, 1, 0 ); // $ExpectError + zdotu.ndarray( zx.length, zx, 1, null, zy, 1, 0 ); // $ExpectError + zdotu.ndarray( zx.length, zx, 1, undefined, zy, 1, 0 ); // $ExpectError + zdotu.ndarray( zx.length, zx, 1, [], zy, 1, 0 ); // $ExpectError + zdotu.ndarray( zx.length, zx, 1, {}, zy, 1, 0 ); // $ExpectError + zdotu.ndarray( zx.length, zx, 1, ( zx: number ): number => zx, zy, 1, 0 ); // $ExpectError +} + +// The compiler throws an error if the `ndarray` method is provided a fifth argument which is not a Complex128Array... +{ + const zx = new Complex128Array( 10 ); + + zdotu.ndarray( zx.length, zx, 1, 0, 10, 1, 0 ); // $ExpectError + zdotu.ndarray( zx.length, zx, 1, 0, '10', 1, 0 ); // $ExpectError + zdotu.ndarray( zx.length, zx, 1, 0, true, 1, 0 ); // $ExpectError + zdotu.ndarray( zx.length, zx, 1, 0, false, 1, 0 ); // $ExpectError + zdotu.ndarray( zx.length, zx, 1, 0, null, 1, 0 ); // $ExpectError + zdotu.ndarray( zx.length, zx, 1, 0, undefined, 1, 0 ); // $ExpectError + zdotu.ndarray( zx.length, zx, 1, 0, [], 1, 0 ); // $ExpectError + zdotu.ndarray( zx.length, zx, 1, 0, {}, 1, 0 ); // $ExpectError + zdotu.ndarray( zx.length, zx, 1, 0, ( zx: number ): number => zx, 1, 0 ); // $ExpectError +} + +// The compiler throws an error if the `ndarray` method is provided a sixth argument which is not a number... +{ + const zx = new Complex128Array( 10 ); + const zy = new Complex128Array( 10 ); + + zdotu.ndarray( zx.length, zx, 1, 0, zy, '10', 0 ); // $ExpectError + zdotu.ndarray( zx.length, zx, 1, 0, zy, true, 0 ); // $ExpectError + zdotu.ndarray( zx.length, zx, 1, 0, zy, false, 0 ); // $ExpectError + zdotu.ndarray( zx.length, zx, 1, 0, zy, null, 0 ); // $ExpectError + zdotu.ndarray( zx.length, zx, 1, 0, zy, undefined, 0 ); // $ExpectError + zdotu.ndarray( zx.length, zx, 1, 0, zy, [], 0 ); // $ExpectError + zdotu.ndarray( zx.length, zx, 1, 0, zy, {}, 0 ); // $ExpectError + zdotu.ndarray( zx.length, zx, 1, 0, zy, ( zx: number ): number => zx, 0 ); // $ExpectError +} + +// The compiler throws an error if the `ndarray` method is provided a seventh argument which is not a number... +{ + const zx = new Complex128Array( 10 ); + const zy = new Complex128Array( 10 ); + + zdotu.ndarray( zx.length, zx, 1, 0, zy, 1, '10' ); // $ExpectError + zdotu.ndarray( zx.length, zx, 1, 0, zy, 1, true ); // $ExpectError + zdotu.ndarray( zx.length, zx, 1, 0, zy, 1, false ); // $ExpectError + zdotu.ndarray( zx.length, zx, 1, 0, zy, 1, null ); // $ExpectError + zdotu.ndarray( zx.length, zx, 1, 0, zy, 1, undefined ); // $ExpectError + zdotu.ndarray( zx.length, zx, 1, 0, zy, 1, [] ); // $ExpectError + zdotu.ndarray( zx.length, zx, 1, 0, zy, 1, {} ); // $ExpectError + zdotu.ndarray( zx.length, zx, 1, 0, zy, 1, ( zx: number ): number => zx ); // $ExpectError +} + +// The compiler throws an error if the `ndarray` method is provided an unsupported number of arguments... +{ + const zx = new Complex128Array( 10 ); + const zy = new Complex128Array( 10 ); + + zdotu.ndarray(); // $ExpectError + zdotu.ndarray( zx.length ); // $ExpectError + zdotu.ndarray( zx.length, zx ); // $ExpectError + zdotu.ndarray( zx.length, zx, 1 ); // $ExpectError + zdotu.ndarray( zx.length, zx, 1, 0 ); // $ExpectError + zdotu.ndarray( zx.length, zx, 1, 0, zy ); // $ExpectError + zdotu.ndarray( zx.length, zx, 1, 0, zy, 1 ); // $ExpectError + zdotu.ndarray( zx.length, zx, 1, 0, zy, 1, 0, 10 ); // $ExpectError +} diff --git a/lib/node_modules/@stdlib/blas/base/zdotu/examples/index.js b/lib/node_modules/@stdlib/blas/base/zdotu/examples/index.js new file mode 100644 index 000000000000..cd368556be2d --- /dev/null +++ b/lib/node_modules/@stdlib/blas/base/zdotu/examples/index.js @@ -0,0 +1,37 @@ +/** +* @license Apache-2.0 +* +* Copyright (c) 2025 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'; + +var discreteUniform = require( '@stdlib/random/base/discrete-uniform' ); +var Complex128 = require( '@stdlib/complex/float64/ctor' ); +var filledarrayBy = require( '@stdlib/array/filled-by' ); +var zdotu = require( './../lib' ); + +function rand() { + return new Complex128( discreteUniform( 0, 10 ), discreteUniform( -5, 5 ) ); +} + +var zx = filledarrayBy( 10, 'complex128', rand ); +console.log( zx.toString() ); + +var zy = filledarrayBy( 10, 'complex128', rand ); +console.log( zy.toString() ); + +var out = zdotu.ndarray( zx.length, zx, 1, 0, zy, -1, zy.length-1 ); +console.log( out.toString() ); diff --git a/lib/node_modules/@stdlib/blas/base/zdotu/lib/index.js b/lib/node_modules/@stdlib/blas/base/zdotu/lib/index.js new file mode 100644 index 000000000000..bf00abdd169a --- /dev/null +++ b/lib/node_modules/@stdlib/blas/base/zdotu/lib/index.js @@ -0,0 +1,86 @@ +/** +* @license Apache-2.0 +* +* Copyright (c) 2025 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'; + +/** +* BLAS level 1 routine to compute the dot product of two double-precision complex floating-point vectors. +* +* @module @stdlib/blas/base/zdotu +* +* @example +* var Complex128Array = require( '@stdlib/array/complex128' ); +* var real = require( '@stdlib/complex/float64/real' ); +* var imag = require( '@stdlib/complex/float64/imag' ); +* var zdotu = require( '@stdlib/blas/base/zdotu' ); +* +* var zx = new Complex128Array( [ 4.0, 2.0, -3.0, 5.0, -1.0, 7.0 ] ); +* var zy = new Complex128Array( [ 2.0, 6.0, -1.0, -4.0, 8.0, 9.0 ] ); +* +* var z = zdotu( 3, zx, 1, zy, 1 ); +* // returns +* +* var re = real( z ); +* // returns -52.0 +* +* var im = imag( z ); +* // returns 82.0 +* +* @example +* var Complex128Array = require( '@stdlib/array/complex128' ); +* var real = require( '@stdlib/complex/float64/real' ); +* var imag = require( '@stdlib/complex/float64/imag' ); +* var zdotu = require( '@stdlib/blas/base/zdotu' ); +* +* var zx = new Complex128Array( [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0 ] ); +* var zy = new Complex128Array( [ 9.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0 ] ); +* +* var z = zdotu.ndarray( 2, zx, 2, 1, zy, -1, zy.length-1 ); +* // returns +* +* var re = real( z ); +* // returns -40.0 +* +* var im = imag( z ); +* // returns 310.0 +*/ + +// MODULES // + +var join = require( 'path' ).join; +var tryRequire = require( '@stdlib/utils/try-require' ); +var isError = require( '@stdlib/assert/is-error' ); +var main = require( './main.js' ); + + +// MAIN // + +var zdotu; +var tmp = tryRequire( join( __dirname, './native.js' ) ); +if ( isError( tmp ) ) { + zdotu = main; +} else { + zdotu = tmp; +} + + +// EXPORTS // + +module.exports = zdotu; + +// exports: { "ndarray": "zdotu.ndarray" } diff --git a/lib/node_modules/@stdlib/blas/base/zdotu/lib/main.js b/lib/node_modules/@stdlib/blas/base/zdotu/lib/main.js new file mode 100644 index 000000000000..d4a91228eca1 --- /dev/null +++ b/lib/node_modules/@stdlib/blas/base/zdotu/lib/main.js @@ -0,0 +1,35 @@ +/** +* @license Apache-2.0 +* +* Copyright (c) 2025 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 zdotu = require( './zdotu.js' ); +var ndarray = require( './ndarray.js' ); + + +// MAIN // + +setReadOnly( zdotu, 'ndarray', ndarray ); + + +// EXPORTS // + +module.exports = zdotu; diff --git a/lib/node_modules/@stdlib/blas/base/zdotu/lib/ndarray.js b/lib/node_modules/@stdlib/blas/base/zdotu/lib/ndarray.js new file mode 100644 index 000000000000..304689fc3316 --- /dev/null +++ b/lib/node_modules/@stdlib/blas/base/zdotu/lib/ndarray.js @@ -0,0 +1,81 @@ +/** +* @license Apache-2.0 +* +* Copyright (c) 2025 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 Complex128 = require( '@stdlib/complex/float64/ctor' ); +var muladd = require( '@stdlib/complex/float64/base/mul-add' ); + + +// MAIN // + +/** +* Calculates the dot product of two double-precision complex floating-point vectors. +* +* @param {integer} N - number of indexed elements +* @param {Complex128Array} zx - first input array +* @param {integer} strideX - `zx` stride length +* @param {NonNegativeInteger} offsetX - starting index for `zx` +* @param {Complex128Array} zy - second input array +* @param {integer} strideY - `zy` stride length +* @param {NonNegativeInteger} offsetY - starting index for `zy` +* @returns {Complex128} dot product +* +* @example +* var Complex128Array = require( '@stdlib/array/complex128' ); +* var real = require( '@stdlib/complex/float64/real' ); +* var imag = require( '@stdlib/complex/float64/imag' ); +* +* var zx = new Complex128Array( [ 4.0, 2.0, -3.0, 5.0, -1.0, 7.0 ] ); +* var zy = new Complex128Array( [ 2.0, 6.0, -1.0, -4.0, 8.0, 9.0 ] ); +* +* var z = zdotu( 3, zx, 1, 0, zy, 1, 0 ); +* // returns +* +* var re = real( z ); +* // returns -52.0 +* +* var im = imag( z ); +* // returns 82.0 +*/ +function zdotu( N, zx, strideX, offsetX, zy, strideY, offsetY ) { + var dot; + var ix; + var iy; + var i; + + dot = new Complex128( 0.0, 0.0 ); + if ( N <= 0 ) { + return dot; + } + ix = offsetX; + iy = offsetY; + for ( i = 0; i < N; i++ ) { + dot = muladd( zx.get( ix ), zy.get( iy ), dot ); + ix += strideX; + iy += strideY; + } + return dot; +} + + +// EXPORTS // + +module.exports = zdotu; diff --git a/lib/node_modules/@stdlib/blas/base/zdotu/lib/zdotu.js b/lib/node_modules/@stdlib/blas/base/zdotu/lib/zdotu.js new file mode 100644 index 000000000000..5119654eea9f --- /dev/null +++ b/lib/node_modules/@stdlib/blas/base/zdotu/lib/zdotu.js @@ -0,0 +1,65 @@ +/** +* @license Apache-2.0 +* +* Copyright (c) 2025 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 stride2offset = require( '@stdlib/strided/base/stride2offset' ); +var ndarray = require( './ndarray.js' ); + + +// MAIN // + +/** +* Calculates the dot product of two double-precision complex floating-point vectors. +* +* @param {PositiveInteger} N - number of indexed elements +* @param {Complex128Array} zx - first input array +* @param {integer} strideX - `zx` stride length +* @param {Complex128Array} zy - second input array +* @param {integer} strideY - `zy` stride length +* @returns {Complex128} dot product +* +* @example +* var Complex128Array = require( '@stdlib/array/complex128' ); +* var real = require( '@stdlib/complex/float64/real' ); +* var imag = require( '@stdlib/complex/float64/imag' ); +* +* var zx = new Complex128Array( [ 4.0, 2.0, -3.0, 5.0, -1.0, 7.0 ] ); +* var zy = new Complex128Array( [ 2.0, 6.0, -1.0, -4.0, 8.0, 9.0 ] ); +* +* var z = zdotu( 3, zx, 1, zy, 1 ); +* // returns +* +* var re = real( z ); +* // returns -52.0 +* +* var im = imag( z ); +* // returns 82.0 +*/ +function zdotu( N, zx, strideX, zy, strideY ) { + var ix = stride2offset( N, strideX ); + var iy = stride2offset( N, strideY ); + return ndarray( N, zx, strideX, ix, zy, strideY, iy ); +} + + +// EXPORTS // + +module.exports = zdotu; diff --git a/lib/node_modules/@stdlib/blas/base/zdotu/package.json b/lib/node_modules/@stdlib/blas/base/zdotu/package.json new file mode 100644 index 000000000000..c61886a6aaa6 --- /dev/null +++ b/lib/node_modules/@stdlib/blas/base/zdotu/package.json @@ -0,0 +1,82 @@ +{ + "name": "@stdlib/blas/base/zdotu", + "version": "0.0.0", + "description": "Calculate the dot product of two double-precision complex floating-point vectors.", + "license": "Apache-2.0", + "author": { + "name": "The Stdlib Authors", + "url": "https://github.com/stdlib-js/stdlib/graphs/contributors" + }, + "contributors": [ + { + "name": "The Stdlib Authors", + "url": "https://github.com/stdlib-js/stdlib/graphs/contributors" + } + ], + "main": "./lib", + "directories": { + "benchmark": "./benchmark", + "doc": "./docs", + "example": "./examples", + "lib": "./lib", + "test": "./test" + }, + "types": "./docs/types", + "scripts": {}, + "homepage": "https://github.com/stdlib-js/stdlib", + "repository": { + "type": "git", + "url": "git://github.com/stdlib-js/stdlib.git" + }, + "bugs": { + "url": "https://github.com/stdlib-js/stdlib/issues" + }, + "dependencies": {}, + "devDependencies": {}, + "engines": { + "node": ">=0.10.0", + "npm": ">2.7.0" + }, + "os": [ + "aix", + "darwin", + "freebsd", + "linux", + "macos", + "openbsd", + "sunos", + "win32", + "windows" + ], + "keywords": [ + "stdlib", + "stdmath", + "mathematics", + "math", + "blas", + "level 1", + "linear", + "algebra", + "subroutines", + "zdotu", + "dot", + "product", + "dot product", + "scalar", + "scalar product", + "inner", + "inner product", + "vector", + "typed", + "array", + "ndarray", + "complex", + "complex128", + "double", + "float64", + "float64array" + ], + "__stdlib__": { + "wasm": false + } +} diff --git a/lib/node_modules/@stdlib/blas/base/zdotu/test/test.js b/lib/node_modules/@stdlib/blas/base/zdotu/test/test.js new file mode 100644 index 000000000000..31ca4e686e59 --- /dev/null +++ b/lib/node_modules/@stdlib/blas/base/zdotu/test/test.js @@ -0,0 +1,82 @@ +/** +* @license Apache-2.0 +* +* Copyright (c) 2025 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 tape = require( 'tape' ); +var proxyquire = require( 'proxyquire' ); +var IS_BROWSER = require( '@stdlib/assert/is-browser' ); +var zdotu = require( './../lib' ); + + +// VARIABLES // + +var opts = { + 'skip': IS_BROWSER +}; + + +// TESTS // + +tape( 'main export is a function', function test( t ) { + t.ok( true, __filename ); + t.strictEqual( typeof zdotu, 'function', 'main export is a function' ); + t.end(); +}); + +tape( 'attached to the main export is a method providing an ndarray interface', function test( t ) { + t.strictEqual( typeof zdotu.ndarray, 'function', 'method is a function' ); + t.end(); +}); + +tape( 'if a native implementation is available, the main export is the native implementation', opts, function test( t ) { + var zdotu = proxyquire( './../lib', { + '@stdlib/utils/try-require': tryRequire + }); + + t.strictEqual( zdotu, mock, 'returns expected value' ); + t.end(); + + function tryRequire() { + return mock; + } + + function mock() { + // Mock... + } +}); + +tape( 'if a native implementation is not available, the main export is a JavaScript implementation', opts, function test( t ) { + var zdotu; + var main; + + main = require( './../lib/zdotu.js' ); + + zdotu = proxyquire( './../lib', { + '@stdlib/utils/try-require': tryRequire + }); + + t.strictEqual( zdotu, main, 'returns expected value' ); + t.end(); + + function tryRequire() { + return new Error( 'Cannot find module' ); + } +}); diff --git a/lib/node_modules/@stdlib/blas/base/zdotu/test/test.ndarray.js b/lib/node_modules/@stdlib/blas/base/zdotu/test/test.ndarray.js new file mode 100644 index 000000000000..a5b6b7918f90 --- /dev/null +++ b/lib/node_modules/@stdlib/blas/base/zdotu/test/test.ndarray.js @@ -0,0 +1,239 @@ +/** +* @license Apache-2.0 +* +* Copyright (c) 2025 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 tape = require( 'tape' ); +var Complex128 = require( '@stdlib/complex/float64/ctor' ); +var Complex128Array = require( '@stdlib/array/complex128' ); +var isSameComplex128 = require( '@stdlib/assert/is-same-complex128' ); +var zdotu = require( './../lib/ndarray.js' ); + + +// TESTS // + +tape( 'main export is a function', function test( t ) { + t.ok( true, __filename ); + t.strictEqual( typeof zdotu, 'function', 'main export is a function' ); + t.end(); +}); + +tape( 'the function has an arity of 7', function test( t ) { + t.strictEqual( zdotu.length, 7, 'returns expected value' ); + t.end(); +}); + +tape( 'the function calculates the dot product of two double-precision complex floating-point vectors `zx` and `zy`', function test( t ) { + var dot; + var zx; + var zy; + + zx = new Complex128Array( [ 4.0, 2.0, -3.0, 5.0, -1.0, 2.0, -5.0, 6.0 ] ); + zy = new Complex128Array( [ 2.0, 6.0, -1.0, -4.0, 8.0, 8.0, 2.0, -3.0 ] ); + + dot = zdotu( zx.length, zx, 1, 0, zy, 1, 0 ); + t.strictEqual(isSameComplex128( dot, new Complex128( 3, 70 ) ), true, 'returns expected value' ); + + zx = new Complex128Array( [ 3.0, -4.0, 1.0, 2.0 ] ); + zy = new Complex128Array( [ 1.0, -2.0, 3.0, 8.0 ] ); + + dot = zdotu( zx.length, zx, 1, 0, zy, 1, 0 ); + t.strictEqual( isSameComplex128( dot, new Complex128( -18, 4 ) ), true, 'returns expected value' ); + + t.end(); +}); + +tape( 'if provided an `N` parameter less than or equal to `0`, the function returns `0`', function test( t ) { + var dot; + var zx; + var zy; + + zx = new Complex128Array( [ 3.0, -4.0, 1.0, 7.0 ] ); + zy = new Complex128Array( [ 1.0, -2.0, 3.0, -3.0 ] ); + + dot = zdotu( 0, zx, 1, 0, zy, 1, 0 ); + t.strictEqual( isSameComplex128( dot, new Complex128( 0, 0 ) ), true, 'returns expected value' ); + + dot = zdotu( -4, zx, 1, 0, zy, 1, 0 ); + t.strictEqual( isSameComplex128( dot, new Complex128( 0, 0 ) ), true, 'returns expected value' ); + t.end(); +}); + +tape( 'the function supports an `zx` stride', function test( t ) { + var dot; + var zx; + var zy; + + zx = new Complex128Array([ + 2.0, // 0 + -3.0, // 0 + -5.0, + 6.0, + 7.0, // 1 + 6.0 // 1 + ]); + zy = new Complex128Array([ + 8.0, // 0 + 2.0, // 0 + -3.0, // 1 + 3.0, // 1 + -4.0, + 1.0 + ]); + + dot = zdotu( 2, zx, 2, 0, zy, 1, 0 ); + t.strictEqual( isSameComplex128( dot, new Complex128( -17, -17 ) ), true, 'returns expected value' ); + t.end(); +}); + +tape( 'the function supports an `zx` offset', function test( t ) { + var dot; + var zx; + var zy; + + zx = new Complex128Array([ + 2.0, + -3.0, + -5.0, // 0 + 6.0, // 0 + 7.0, // 1 + 6.0 // 1 + ]); + zy = new Complex128Array([ + 8.0, // 0 + 2.0, // 0 + -3.0, // 1 + 3.0, // 1 + -4.0, + 1.0 + ]); + + dot = zdotu( 2, zx, 1, 1, zy, 1, 0 ); + t.strictEqual( isSameComplex128( dot, new Complex128( -91, 41 ) ), true, 'returns expected value' ); + t.end(); +}); + +tape( 'the function supports a `zy` stride', function test( t ) { + var dot; + var zx; + var zy; + + zx = new Complex128Array([ + 2.0, // 0 + -3.0, // 0 + -5.0, // 1 + 6.0, // 1 + 7.0, + 6.0 + ]); + zy = new Complex128Array([ + 8.0, // 0 + 2.0, // 0 + -3.0, + 3.0, + -4.0, // 1 + 1.0 // 1 + ]); + + dot = zdotu( 2, zx, 1, 0, zy, 2, 0 ); + t.strictEqual( isSameComplex128( dot, new Complex128( 36, -49 ) ), true, 'returns expected value' ); + t.end(); +}); + +tape( 'the function supports a `zy` offset', function test( t ) { + var dot; + var zx; + var zy; + + zx = new Complex128Array([ + 1.0, // 0 + 2.0, // 0 + 3.0, + 4.0, + 5.0, // 1 + 6.0 // 1 + ]); + zy = new Complex128Array([ + 7.0, + 8.0, + 9.0, // 0 + 10.0, // 0 + 11.0, // 1 + 12.0 // 1 + ]); + + dot = zdotu( 2, zx, 2, 0, zy, 1, 1 ); + t.strictEqual( isSameComplex128( dot, new Complex128( -28, 154 ) ), true, 'returns expected value' ); + t.end(); +}); + +tape( 'the function supports negative strides', function test( t ) { + var dot; + var zx; + var zy; + + zx = new Complex128Array([ + 1.0, // 1 + 2.0, // 1 + 3.0, + 4.0, + 5.0, // 0 + 6.0 // 0 + ]); + zy = new Complex128Array([ + 7.0, + 8.0, + 9.0, // 1 + 10.0, // 1 + 11.0, // 0 + 12.0 // 0 + ]); + + dot = zdotu( 2, zx, -2, zx.length-1, zy, -1, 2 ); + t.strictEqual( isSameComplex128( dot, new Complex128( -28, 154 ) ), true, 'returns expected value' ); + t.end(); +}); + +tape( 'the function supports complex access patterns', function test( t ) { + var dot; + var zx; + var zy; + + zx = new Complex128Array([ + 1.0, // 0 + 2.0, // 0 + 3.0, + 4.0, + 5.0, // 1 + 6.0 // 1 + ]); + zy = new Complex128Array([ + 7.0, // 0 + 8.0, // 0 + 9.0, // 1 + 10.0, // 1 + 11.0, + 12.0 + ]); + + dot = zdotu( 2, zx, 2, 0, zy, -1, zy.length-2 ); + t.strictEqual( isSameComplex128( dot, new Complex128( -24, 110 ) ), true, 'returns expected value' ); + t.end(); +}); diff --git a/lib/node_modules/@stdlib/blas/base/zdotu/test/test.zdotu.js b/lib/node_modules/@stdlib/blas/base/zdotu/test/test.zdotu.js new file mode 100644 index 000000000000..cb2561065b25 --- /dev/null +++ b/lib/node_modules/@stdlib/blas/base/zdotu/test/test.zdotu.js @@ -0,0 +1,217 @@ +/** +* @license Apache-2.0 +* +* Copyright (c) 2025 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 tape = require( 'tape' ); +var Complex128 = require( '@stdlib/complex/float64/ctor' ); +var Complex128Array = require( '@stdlib/array/complex128' ); +var isSameComplex128 = require( '@stdlib/assert/is-same-complex128' ); +var zdotu = require( './../lib/zdotu.js' ); + + +// TESTS // + +tape( 'main export is a function', function test( t ) { + t.ok( true, __filename ); + t.strictEqual( typeof zdotu, 'function', 'main export is a function' ); + t.end(); +}); + +tape( 'the function has an arity of 5', function test( t ) { + t.strictEqual( zdotu.length, 5, 'returns expected value' ); + t.end(); +}); + +tape( 'the function calculates the dot product of two double-precision complex floating-point vectors `zx` and `zy`', function test( t ) { + var dot; + var zx; + var zy; + + zx = new Complex128Array( [ 4.0, 2.0, -3.0, 5.0, -1.0, 2.0, -5.0, 6.0 ] ); + zy = new Complex128Array( [ 2.0, 6.0, -1.0, -4.0, 8.0, 8.0, 2.0, -3.0 ] ); + + dot = zdotu( 4, zx, 1, zy, 1 ); + t.strictEqual( isSameComplex128( dot, new Complex128( 3, 70 ) ), true, 'returns expected value' ); + + zx = new Complex128Array( [ 3.0, -4.0, 1.0, 2.0 ] ); + zy = new Complex128Array( [ 1.0, -2.0, 3.0, 8.0 ] ); + + dot = zdotu( 2, zx, 1, zy, 1 ); + t.strictEqual( isSameComplex128( dot, new Complex128( -18, 4 ) ), true, 'returns expected value' ); + + t.end(); +}); + +tape( 'if provided an `N` parameter less than or equal to `0`, the function returns `0 + 0i`', function test( t ) { + var dot; + var zx; + var zy; + + zx = new Complex128Array( [ 3.0, -4.0, 1.0, 7.0 ] ); + zy = new Complex128Array( [ 1.0, -2.0, 3.0, -3.0 ] ); + + dot = zdotu( 0, zx, 1, zy, 1 ); + t.strictEqual( isSameComplex128( dot, new Complex128( 0, 0 ) ), true, 'returns expected value' ); + + dot = zdotu( -4, zx, 1, zy, 1 ); + t.strictEqual( isSameComplex128( dot, new Complex128( 0, 0 ) ), true, 'returns expected value' ); + t.end(); +}); + +tape( 'the function supports an `zx` stride', function test( t ) { + var dot; + var zx; + var zy; + + zx = new Complex128Array([ + 2.0, // 0 + -3.0, // 0 + -5.0, + 6.0, + 7.0, // 1 + 6.0 // 1 + ]); + zy = new Complex128Array([ + 8.0, // 0 + 2.0, // 0 + -3.0, // 1 + 3.0, // 1 + -4.0, + 1.0 + ]); + + dot = zdotu( 2, zx, 2, zy, 1 ); + t.strictEqual( isSameComplex128( dot, new Complex128( -17, -17 ) ), true, 'returns expected value' ); + t.end(); +}); + +tape( 'the function supports a `zy` stride', function test( t ) { + var dot; + var zx; + var zy; + + zx = new Complex128Array([ + 2.0, // 0 + -3.0, // 0 + -5.0, // 1 + 7.0, // 1 + 6.0, + -2.0 + ]); + zy = new Complex128Array([ + 8.0, // 0 + 2.0, // 0 + -3.0, + 3.0, + -4.0, // 1 + 1.0 // 1 + ]); + + dot = zdotu( 2, zx, 1, zy, 2 ); + t.strictEqual( isSameComplex128( dot, new Complex128( 35, -53 ) ), true, 'returns expected value' ); + t.end(); +}); + +tape( 'the function supports negative strides', function test( t ) { + var dot; + var zx; + var zy; + + zx = new Complex128Array([ + 1.0, // 1 + 2.0, // 1 + 3.0, + 4.0, + 5.0, // 0 + 6.0 // 0 + ]); + zy = new Complex128Array([ + 7.0, // 1 + 8.0, // 1 + 9.0, // 0 + 10.0, // 0 + 11.0, + 12.0 + ]); + + dot = zdotu( 2, zx, -2, zy, -1 ); + t.strictEqual( isSameComplex128( dot, new Complex128( -24, 126 ) ), true, 'returns expected value' ); + t.end(); +}); + +tape( 'the function supports complex access patterns', function test( t ) { + var dot; + var zx; + var zy; + + zx = new Complex128Array([ + 1.0, // 0 + 2.0, // 0 + 3.0, + 4.0, + 5.0, // 1 + 6.0 // 1 + ]); + zy = new Complex128Array([ + 7.0, // 0 + 8.0, // 0 + 9.0, // 1 + 10.0, // 1 + 11.0, + 12.0 + ]); + + dot = zdotu( 2, zx, 2, zy, -1 ); + t.strictEqual( isSameComplex128( dot, new Complex128( -24, 110 ) ), true, 'returns expected value' ); + t.end(); +}); + +tape( 'the function supports view offsets', function test( t ) { + var dot; + var x0; + var y0; + var x1; + var y1; + + x0 = new Complex128Array([ + 1.0, // 0 + 2.0, // 0 + 3.0, + 4.0, + 5.0, // 1 + 6.0 // 1 + ]); + y0 = new Complex128Array([ + 7.0, + 8.0, + 9.0, // 0 + 10.0, // 0 + 11.0, // 1 + 12.0 // 1 + ]); + + x1 = new Complex128Array( x0.buffer, x0.BYTES_PER_ELEMENT*0 ); + y1 = new Complex128Array( y0.buffer, y0.BYTES_PER_ELEMENT*1 ); + + dot = zdotu( 2, x1, 2, y1, 1 ); + t.strictEqual( isSameComplex128( dot, new Complex128( -28, 154 ) ), true, 'returns expected value' ); + t.end(); +}); From b0cc290ceb3b4aa29738441e04c4f7ebb3bf9d1c Mon Sep 17 00:00:00 2001 From: ShabiShett07 Date: Mon, 7 Jul 2025 17:27:24 +0530 Subject: [PATCH 2/8] bench: change variable naming --- type: pre_commit_static_analysis_report description: Results of running static analysis checks when committing changes. report: - task: lint_filenames status: passed - task: lint_editorconfig status: passed - task: lint_markdown status: na - task: lint_package_json status: na - task: lint_repl_help status: na - task: lint_javascript_src status: na - task: lint_javascript_cli status: na - task: lint_javascript_examples status: na - task: lint_javascript_tests status: na - task: lint_javascript_benchmarks status: passed - task: lint_python status: na - task: lint_r status: na - task: lint_c_src status: na - task: lint_c_examples status: na - task: lint_c_benchmarks status: na - task: lint_c_tests_fixtures status: na - task: lint_shell status: na - task: lint_typescript_declarations status: na - task: lint_typescript_tests status: na - task: lint_license_headers status: passed --- --- .../blas/base/zdotu/benchmark/benchmark.js | 22 +++++++++---------- .../base/zdotu/benchmark/benchmark.ndarray.js | 22 +++++++++---------- 2 files changed, 22 insertions(+), 22 deletions(-) diff --git a/lib/node_modules/@stdlib/blas/base/zdotu/benchmark/benchmark.js b/lib/node_modules/@stdlib/blas/base/zdotu/benchmark/benchmark.js index 35291f033e06..7af8eca78568 100644 --- a/lib/node_modules/@stdlib/blas/base/zdotu/benchmark/benchmark.js +++ b/lib/node_modules/@stdlib/blas/base/zdotu/benchmark/benchmark.js @@ -42,15 +42,15 @@ var options = { * Creates a benchmark function. * * @private -* @param {PositiveInteger} len - array length +* @param {PositiveInteger} N - array length * @returns {Function} benchmark function */ -function createBenchmark( len ) { - var zx; - var zy; +function createBenchmark( N ) { + var x; + var y; - zx = new Complex128Array( uniform( len*2, -100.0, 100.0, options ) ); - zy = new Complex128Array( uniform( len*2, -100.0, 100.0, options ) ); + x = new Complex128Array( uniform( N*2, -100.0, 100.0, options ) ); + y = new Complex128Array( uniform( N*2, -100.0, 100.0, options ) ); return benchmark; /** @@ -65,7 +65,7 @@ function createBenchmark( len ) { b.tic(); for ( i = 0; i < b.iterations; i++ ) { - d = zdotu( zx.length, zx, 1, zy, 1 ); + d = zdotu( x.length, x, 1, y, 1 ); if ( isnan( d ) ) { b.fail( 'should not return NaN' ); } @@ -88,9 +88,9 @@ function createBenchmark( len ) { * @private */ function main() { - var len; var min; var max; + var N; var f; var i; @@ -98,9 +98,9 @@ function main() { max = 5; // 10^max for ( i = min; i <= max; i++ ) { - len = pow( 10, i ); - f = createBenchmark( len ); - bench( pkg+':len='+len, f ); + N = pow( 10, i ); + f = createBenchmark( N ); + bench( pkg+':size='+N, f ); } } diff --git a/lib/node_modules/@stdlib/blas/base/zdotu/benchmark/benchmark.ndarray.js b/lib/node_modules/@stdlib/blas/base/zdotu/benchmark/benchmark.ndarray.js index f1f1ca860db2..9909434edaff 100644 --- a/lib/node_modules/@stdlib/blas/base/zdotu/benchmark/benchmark.ndarray.js +++ b/lib/node_modules/@stdlib/blas/base/zdotu/benchmark/benchmark.ndarray.js @@ -42,15 +42,15 @@ var options = { * Creates a benchmark function. * * @private -* @param {PositiveInteger} len - array length +* @param {PositiveInteger} N - array length * @returns {Function} benchmark function */ -function createBenchmark( len ) { - var zx; - var zy; +function createBenchmark( N ) { + var x; + var y; - zx = new Complex128Array( uniform( len*2, -100.0, 100.0, options ) ); - zy = new Complex128Array( uniform( len*2, -100.0, 100.0, options ) ); + x = new Complex128Array( uniform( N*2, -100.0, 100.0, options ) ); + y = new Complex128Array( uniform( N*2, -100.0, 100.0, options ) ); return benchmark; /** @@ -65,7 +65,7 @@ function createBenchmark( len ) { b.tic(); for ( i = 0; i < b.iterations; i++ ) { - d = zdotu( zx.length, zx, 1, 0, zy, 1, 0 ); + d = zdotu( x.length, x, 1, 0, y, 1, 0 ); if ( isnan( d ) ) { b.fail( 'should not return NaN' ); } @@ -88,9 +88,9 @@ function createBenchmark( len ) { * @private */ function main() { - var len; var min; var max; + var N; var f; var i; @@ -98,9 +98,9 @@ function main() { max = 5; // 10^max for ( i = min; i <= max; i++ ) { - len = pow( 10, i ); - f = createBenchmark( len ); - bench( pkg+':ndarray:len='+len, f ); + N = pow( 10, i ); + f = createBenchmark( N ); + bench( pkg+':ndarray:size='+N, f ); } } From afa917ac2dcc22c491990318e1d7f68bcd27bd9f Mon Sep 17 00:00:00 2001 From: ShabiShett07 Date: Mon, 7 Jul 2025 17:33:02 +0530 Subject: [PATCH 3/8] docs: improve jsdoc and change variable naming --- type: pre_commit_static_analysis_report description: Results of running static analysis checks when committing changes. report: - task: lint_filenames status: passed - task: lint_editorconfig status: passed - task: lint_markdown status: na - task: lint_package_json status: na - task: lint_repl_help status: na - task: lint_javascript_src status: passed - task: lint_javascript_cli status: na - task: lint_javascript_examples status: na - task: lint_javascript_tests status: na - task: lint_javascript_benchmarks status: na - task: lint_python status: na - task: lint_r status: na - task: lint_c_src status: na - task: lint_c_examples status: na - task: lint_c_benchmarks status: na - task: lint_c_tests_fixtures status: na - task: lint_shell status: na - task: lint_typescript_declarations status: passed - task: lint_typescript_tests status: passed - task: lint_license_headers status: passed --- --- .../blas/base/zdotu/docs/types/index.d.ts | 100 +++--- .../blas/base/zdotu/docs/types/test.ts | 288 +++++++++--------- .../@stdlib/blas/base/zdotu/lib/index.js | 32 +- .../@stdlib/blas/base/zdotu/lib/ndarray.js | 32 +- .../@stdlib/blas/base/zdotu/lib/zdotu.js | 28 +- 5 files changed, 208 insertions(+), 272 deletions(-) diff --git a/lib/node_modules/@stdlib/blas/base/zdotu/docs/types/index.d.ts b/lib/node_modules/@stdlib/blas/base/zdotu/docs/types/index.d.ts index 8029480bd329..e5e409ec02a1 100644 --- a/lib/node_modules/@stdlib/blas/base/zdotu/docs/types/index.d.ts +++ b/lib/node_modules/@stdlib/blas/base/zdotu/docs/types/index.d.ts @@ -28,109 +28,77 @@ import { Complex128 } from '@stdlib/types/complex'; */ interface Routine { /** - * Calculates the dot product of vectors `zx` and `zy`. + * Calculates the dot product of vectors `x` and `y`. * * @param N - number of indexed elements - * @param zx - first input array - * @param strideX - `zx` stride length - * @param zy - second input array - * @param strideY - `zy` stride length + * @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 Complex128Array = require( '@stdlib/array/complex128' ); - * var real = require( '@stdlib/complex/float64/real' ); - * var imag = require( '@stdlib/complex/float64/imag' ); * - * var zx = new Complex128Array( [ 4.0, 2.0, -3.0, 5.0, -1.0, 7.0 ] ); - * var zy = new Complex128Array( [ 2.0, 6.0, -1.0, -4.0, 8.0, 9.0 ] ); + * var x = new Complex128Array( [ 4.0, 2.0, -3.0, 5.0, -1.0, 7.0 ] ); + * var y = new Complex128Array( [ 2.0, 6.0, -1.0, -4.0, 8.0, 9.0 ] ); * - * var z = zdotu( 3, zx, 1, zy, 1 ); - * // returns - * - * var re = real( z ); - * // returns -52.0 - * - * var im = imag( z ); - * // returns 82.0 + * var z = zdotu( 3, x, 1, y, 1 ); + * // returns [ -52.0, 82.0 ] */ - ( N: number, zx: Complex128Array, strideX: number, zy: Complex128Array, strideY: number ): Complex128; + ( N: number, x: Complex128Array, strideX: number, y: Complex128Array, strideY: number ): Complex128; /** - * Calculates the dot product of vectors `zx` and `zy` using alternative indexing semantics. + * Calculates the dot product of vectors `x` and `y` using alternative indexing semantics. * * @param N - number of indexed elements - * @param zx - first input array - * @param strideX - `zx` stride length - * @param offsetX - starting index for `zx` - * @param zy - second input array - * @param strideY - `zy` stride length - * @param offsetY - starting index for `zy` + * @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 Complex128Array = require( '@stdlib/array/complex128' ); - * var real = require( '@stdlib/complex/float64/real' ); - * var imag = require( '@stdlib/complex/float64/imag' ); - * - * var zx = new Complex128Array( [ 4.0, 2.0, -3.0, 5.0, -1.0, 7.0 ] ); - * var zy = new Complex128Array( [ 2.0, 6.0, -1.0, -4.0, 8.0, 9.0 ] ); - * - * var z = zdotu.ndarray( zx.length, zx, 1, 0, zy, 1, 0 ); - * // returns * - * var re = real( z ); - * // returns -52.0 + * var x = new Complex128Array( [ 4.0, 2.0, -3.0, 5.0, -1.0, 7.0 ] ); + * var y = new Complex128Array( [ 2.0, 6.0, -1.0, -4.0, 8.0, 9.0 ] ); * - * var im = imag( z ); - * // returns 82.0 + * var z = zdotu.ndarray( x.length, x, 1, 0, y, 1, 0 ); + * // returns [ -52.0, 82.0 ] */ - ndarray( N: number, zx: Complex128Array, strideX: number, offsetX: number, zy: Complex128Array, strideY: number, offsetY: number ): Complex128; + ndarray( N: number, x: Complex128Array, strideX: number, offsetX: number, y: Complex128Array, strideY: number, offsetY: number ): Complex128; } /** * Computes the dot product of two double-precision complex floating-point vectors. * * @param N - number of indexed elements -* @param zx - first input array -* @param strideX - `zx` stride length -* @param zy - second input array -* @param strideY - `zy` stride length +* @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 Complex128Array = require( '@stdlib/array/complex128' ); -* var real = require( '@stdlib/complex/float64/real' ); -* var imag = require( '@stdlib/complex/float64/imag' ); * -* var zx = new Complex128Array( [ 4.0, 2.0, -3.0, 5.0, -1.0, 7.0 ] ); -* var zy = new Complex128Array( [ 2.0, 6.0, -1.0, -4.0, 8.0, 9.0 ] ); +* var x = new Complex128Array( [ 4.0, 2.0, -3.0, 5.0, -1.0, 7.0 ] ); +* var y = new Complex128Array( [ 2.0, 6.0, -1.0, -4.0, 8.0, 9.0 ] ); * -* var z = zdotu( 3, zx, 1, zy, 1 ); -* // returns -* -* var re = real( z ); -* // returns -52.0 -* -* var im = imag( z ); -* // returns 82.0 +* var z = zdotu( 3, x, 1, y, 1 ); +* // returns [ -52.0, 82.0 ] * * @example * var Complex128Array = require( '@stdlib/array/complex128' ); -* var real = require( '@stdlib/complex/float64/real' ); -* var imag = require( '@stdlib/complex/float64/imag' ); -* -* var zx = new Complex128Array( [ 4.0, 2.0, -3.0, 5.0, -1.0, 7.0 ] ); -* var zy = new Complex128Array( [ 2.0, 6.0, -1.0, -4.0, 8.0, 9.0 ] ); -* -* var z = zdotu.ndarray( zx.length, zx, 1, 0, zy, 1, 0 ); -* // returns * -* var re = real( z ); -* // returns -52.0 +* var x = new Complex128Array( [ 4.0, 2.0, -3.0, 5.0, -1.0, 7.0 ] ); +* var y = new Complex128Array( [ 2.0, 6.0, -1.0, -4.0, 8.0, 9.0 ] ); * -* var im = imag( z ); -* // returns 82.0 +* var z = zdotu.ndarray( x.length, x, 1, 0, y, 1, 0 ); +* // returns [ -52.0, 82.0 ] */ declare var zdotu: Routine; diff --git a/lib/node_modules/@stdlib/blas/base/zdotu/docs/types/test.ts b/lib/node_modules/@stdlib/blas/base/zdotu/docs/types/test.ts index 5f71f5886c3e..13ad5d3d526e 100644 --- a/lib/node_modules/@stdlib/blas/base/zdotu/docs/types/test.ts +++ b/lib/node_modules/@stdlib/blas/base/zdotu/docs/types/test.ts @@ -24,226 +24,226 @@ import zdotu = require( './index' ); // The function returns Complex128... { - const zx = new Complex128Array( 10 ); - const zy = new Complex128Array( 10 ); + const x = new Complex128Array( 10 ); + const y = new Complex128Array( 10 ); - zdotu( zx.length, zx, 1, zy, 1 ); // $ExpectType Complex128 + zdotu( x.length, x, 1, y, 1 ); // $ExpectType Complex128 } // The compiler throws an error if the function is provided a first argument which is not a number... { - const zx = new Complex128Array( 10 ); - const zy = new Complex128Array( 10 ); + const x = new Complex128Array( 10 ); + const y = new Complex128Array( 10 ); - zdotu( '10', zx, 1, zy, 1 ); // $ExpectError - zdotu( true, zx, 1, zy, 1 ); // $ExpectError - zdotu( false, zx, 1, zy, 1 ); // $ExpectError - zdotu( null, zx, 1, zy, 1 ); // $ExpectError - zdotu( undefined, zx, 1, zy, 1 ); // $ExpectError - zdotu( [], zx, 1, zy, 1 ); // $ExpectError - zdotu( {}, zx, 1, zy, 1 ); // $ExpectError - zdotu( ( zx: number ): number => zx, zx, 1, zy, 1 ); // $ExpectError + zdotu( '10', x, 1, y, 1 ); // $ExpectError + zdotu( true, x, 1, y, 1 ); // $ExpectError + zdotu( false, x, 1, y, 1 ); // $ExpectError + zdotu( null, x, 1, y, 1 ); // $ExpectError + zdotu( undefined, x, 1, y, 1 ); // $ExpectError + zdotu( [], x, 1, y, 1 ); // $ExpectError + zdotu( {}, x, 1, y, 1 ); // $ExpectError + zdotu( ( x: number ): number => x, x, 1, y, 1 ); // $ExpectError } // The compiler throws an error if the function is provided a second argument which is not a Complex128Array... { - const zx = new Complex128Array( 10 ); - const zy = new Complex128Array( 10 ); + const x = new Complex128Array( 10 ); + const y = new Complex128Array( 10 ); - zdotu( zx.length, 10, 1, zy, 1 ); // $ExpectError - zdotu( zx.length, '10', 1, zy, 1 ); // $ExpectError - zdotu( zx.length, true, 1, zy, 1 ); // $ExpectError - zdotu( zx.length, false, 1, zy, 1 ); // $ExpectError - zdotu( zx.length, null, 1, zy, 1 ); // $ExpectError - zdotu( zx.length, undefined, 1, zy, 1 ); // $ExpectError - zdotu( zx.length, [ '1' ], 1, zy, 1 ); // $ExpectError - zdotu( zx.length, {}, 1, zy, 1 ); // $ExpectError - zdotu( zx.length, ( zx: number ): number => zx, 1, zy, 1 ); // $ExpectError + zdotu( x.length, 10, 1, y, 1 ); // $ExpectError + zdotu( x.length, '10', 1, y, 1 ); // $ExpectError + zdotu( x.length, true, 1, y, 1 ); // $ExpectError + zdotu( x.length, false, 1, y, 1 ); // $ExpectError + zdotu( x.length, null, 1, y, 1 ); // $ExpectError + zdotu( x.length, undefined, 1, y, 1 ); // $ExpectError + zdotu( x.length, [ '1' ], 1, y, 1 ); // $ExpectError + zdotu( x.length, {}, 1, y, 1 ); // $ExpectError + zdotu( x.length, ( x: number ): number => x, 1, y, 1 ); // $ExpectError } // The compiler throws an error if the function is provided a third argument which is not a number... { - const zx = new Complex128Array( 10 ); - const zy = new Complex128Array( 10 ); + const x = new Complex128Array( 10 ); + const y = new Complex128Array( 10 ); - zdotu( zx.length, zx, '10', zy, 1 ); // $ExpectError - zdotu( zx.length, zx, true, zy, 1 ); // $ExpectError - zdotu( zx.length, zx, false, zy, 1 ); // $ExpectError - zdotu( zx.length, zx, null, zy, 1 ); // $ExpectError - zdotu( zx.length, zx, undefined, zy, 1 ); // $ExpectError - zdotu( zx.length, zx, [], zy, 1 ); // $ExpectError - zdotu( zx.length, zx, {}, zy, 1 ); // $ExpectError - zdotu( zx.length, zx, ( zx: number ): number => zx, zy, 1 ); // $ExpectError + zdotu( x.length, x, '10', y, 1 ); // $ExpectError + zdotu( x.length, x, true, y, 1 ); // $ExpectError + zdotu( x.length, x, false, y, 1 ); // $ExpectError + zdotu( x.length, x, null, y, 1 ); // $ExpectError + zdotu( x.length, x, undefined, y, 1 ); // $ExpectError + zdotu( x.length, x, [], y, 1 ); // $ExpectError + zdotu( x.length, x, {}, y, 1 ); // $ExpectError + zdotu( x.length, x, ( x: number ): number => x, y, 1 ); // $ExpectError } // The compiler throws an error if the function is provided a fourth argument which is not a Complex128Array... { - const zx = new Complex128Array( 10 ); + const x = new Complex128Array( 10 ); - zdotu( zx.length, zx, 1, 10, 1 ); // $ExpectError - zdotu( zx.length, zx, 1, '10', 1 ); // $ExpectError - zdotu( zx.length, zx, 1, true, 1 ); // $ExpectError - zdotu( zx.length, zx, 1, false, 1 ); // $ExpectError - zdotu( zx.length, zx, 1, null, 1 ); // $ExpectError - zdotu( zx.length, zx, 1, undefined, 1 ); // $ExpectError - zdotu( zx.length, zx, 1, [], 1 ); // $ExpectError - zdotu( zx.length, zx, 1, {}, 1 ); // $ExpectError - zdotu( zx.length, zx, 1, ( zx: number ): number => zx, 1 ); // $ExpectError + zdotu( x.length, x, 1, 10, 1 ); // $ExpectError + zdotu( x.length, x, 1, '10', 1 ); // $ExpectError + zdotu( x.length, x, 1, true, 1 ); // $ExpectError + zdotu( x.length, x, 1, false, 1 ); // $ExpectError + zdotu( x.length, x, 1, null, 1 ); // $ExpectError + zdotu( x.length, x, 1, undefined, 1 ); // $ExpectError + zdotu( x.length, x, 1, [], 1 ); // $ExpectError + zdotu( x.length, x, 1, {}, 1 ); // $ExpectError + zdotu( x.length, x, 1, ( x: number ): number => x, 1 ); // $ExpectError } // The compiler throws an error if the function is provided a fifth argument which is not a number... { - const zx = new Complex128Array( 10 ); - const zy = new Complex128Array( 10 ); + const x = new Complex128Array( 10 ); + const y = new Complex128Array( 10 ); - zdotu( zx.length, zx, 1, zy, '10' ); // $ExpectError - zdotu( zx.length, zx, 1, zy, true ); // $ExpectError - zdotu( zx.length, zx, 1, zy, false ); // $ExpectError - zdotu( zx.length, zx, 1, zy, null ); // $ExpectError - zdotu( zx.length, zx, 1, zy, undefined ); // $ExpectError - zdotu( zx.length, zx, 1, zy, [] ); // $ExpectError - zdotu( zx.length, zx, 1, zy, {} ); // $ExpectError - zdotu( zx.length, zx, 1, zy, ( zx: number ): number => zx ); // $ExpectError + zdotu( x.length, x, 1, y, '10' ); // $ExpectError + zdotu( x.length, x, 1, y, true ); // $ExpectError + zdotu( x.length, x, 1, y, false ); // $ExpectError + zdotu( x.length, x, 1, y, null ); // $ExpectError + zdotu( x.length, x, 1, y, undefined ); // $ExpectError + zdotu( x.length, x, 1, y, [] ); // $ExpectError + zdotu( x.length, x, 1, y, {} ); // $ExpectError + zdotu( x.length, x, 1, y, ( x: number ): number => x ); // $ExpectError } // The compiler throws an error if the function is provided an unsupported number of arguments... { - const zx = new Complex128Array( 10 ); - const zy = new Complex128Array( 10 ); + const x = new Complex128Array( 10 ); + const y = new Complex128Array( 10 ); zdotu(); // $ExpectError - zdotu( zx.length ); // $ExpectError - zdotu( zx.length, zx ); // $ExpectError - zdotu( zx.length, zx, 1 ); // $ExpectError - zdotu( zx.length, zx, 1, zy ); // $ExpectError - zdotu( zx.length, zx, 1, zy, 1, 10 ); // $ExpectError + zdotu( x.length ); // $ExpectError + zdotu( x.length, x ); // $ExpectError + zdotu( x.length, x, 1 ); // $ExpectError + zdotu( x.length, x, 1, y ); // $ExpectError + zdotu( x.length, x, 1, y, 1, 10 ); // $ExpectError } // Attached to main export is an `ndarray` method which returns a Complex128... { - const zx = new Complex128Array( 10 ); - const zy = new Complex128Array( 10 ); + const x = new Complex128Array( 10 ); + const y = new Complex128Array( 10 ); - zdotu.ndarray( zx.length, zx, 1, 0, zy, 1, 0 ); // $ExpectType Complex128 + zdotu.ndarray( x.length, x, 1, 0, y, 1, 0 ); // $ExpectType Complex128 } // The compiler throws an error if the `ndarray` method is provided a first argument which is not a number... { - const zx = new Complex128Array( 10 ); - const zy = new Complex128Array( 10 ); + const x = new Complex128Array( 10 ); + const y = new Complex128Array( 10 ); - zdotu.ndarray( '10', zx, 1, 0, zy, 1, 0 ); // $ExpectError - zdotu.ndarray( true, zx, 1, 0, zy, 1, 0 ); // $ExpectError - zdotu.ndarray( false, zx, 1, 0, zy, 1, 0 ); // $ExpectError - zdotu.ndarray( null, zx, 1, 0, zy, 1, 0 ); // $ExpectError - zdotu.ndarray( undefined, zx, 1, 0, zy, 1, 0 ); // $ExpectError - zdotu.ndarray( [], zx, 1, 0, zy, 1, 0 ); // $ExpectError - zdotu.ndarray( {}, zx, 1, 0, zy, 1, 0 ); // $ExpectError - zdotu.ndarray( ( zx: number ): number => zx, zx, 1, 0, zy, 1, 0 ); // $ExpectError + zdotu.ndarray( '10', x, 1, 0, y, 1, 0 ); // $ExpectError + zdotu.ndarray( true, x, 1, 0, y, 1, 0 ); // $ExpectError + zdotu.ndarray( false, x, 1, 0, y, 1, 0 ); // $ExpectError + zdotu.ndarray( null, x, 1, 0, y, 1, 0 ); // $ExpectError + zdotu.ndarray( undefined, x, 1, 0, y, 1, 0 ); // $ExpectError + zdotu.ndarray( [], x, 1, 0, y, 1, 0 ); // $ExpectError + zdotu.ndarray( {}, x, 1, 0, y, 1, 0 ); // $ExpectError + zdotu.ndarray( ( x: number ): number => x, x, 1, 0, y, 1, 0 ); // $ExpectError } // The compiler throws an error if the `ndarray` method is provided a second argument which is not a Complex128Array... { - const zx = new Complex128Array( 10 ); - const zy = new Complex128Array( 10 ); + const x = new Complex128Array( 10 ); + const y = new Complex128Array( 10 ); - zdotu.ndarray( zx.length, 10, 1, 0, zy, 1, 0 ); // $ExpectError - zdotu.ndarray( zx.length, '10', 1, 0, zy, 1, 0 ); // $ExpectError - zdotu.ndarray( zx.length, true, 1, 0, zy, 1, 0 ); // $ExpectError - zdotu.ndarray( zx.length, false, 1, 0, zy, 1, 0 ); // $ExpectError - zdotu.ndarray( zx.length, null, 1, 0, zy, 1, 0 ); // $ExpectError - zdotu.ndarray( zx.length, undefined, 1, 0, zy, 1, 0 ); // $ExpectError - zdotu.ndarray( zx.length, [], 1, 0, zy, 1, 0 ); // $ExpectError - zdotu.ndarray( zx.length, {}, 1, 0, zy, 1, 0 ); // $ExpectError - zdotu.ndarray( zx.length, ( zx: number ): number => zx, 1, 0, zy, 1, 0 ); // $ExpectError + zdotu.ndarray( x.length, 10, 1, 0, y, 1, 0 ); // $ExpectError + zdotu.ndarray( x.length, '10', 1, 0, y, 1, 0 ); // $ExpectError + zdotu.ndarray( x.length, true, 1, 0, y, 1, 0 ); // $ExpectError + zdotu.ndarray( x.length, false, 1, 0, y, 1, 0 ); // $ExpectError + zdotu.ndarray( x.length, null, 1, 0, y, 1, 0 ); // $ExpectError + zdotu.ndarray( x.length, undefined, 1, 0, y, 1, 0 ); // $ExpectError + zdotu.ndarray( x.length, [], 1, 0, y, 1, 0 ); // $ExpectError + zdotu.ndarray( x.length, {}, 1, 0, y, 1, 0 ); // $ExpectError + zdotu.ndarray( x.length, ( x: number ): number => x, 1, 0, y, 1, 0 ); // $ExpectError } // The compiler throws an error if the `ndarray` method is provided a third argument which is not a number... { - const zx = new Complex128Array( 10 ); - const zy = new Complex128Array( 10 ); + const x = new Complex128Array( 10 ); + const y = new Complex128Array( 10 ); - zdotu.ndarray( zx.length, zx, '10', 0, zy, 1, 0 ); // $ExpectError - zdotu.ndarray( zx.length, zx, true, 0, zy, 1, 0 ); // $ExpectError - zdotu.ndarray( zx.length, zx, false, 0, zy, 1, 0 ); // $ExpectError - zdotu.ndarray( zx.length, zx, null, 0, zy, 1, 0 ); // $ExpectError - zdotu.ndarray( zx.length, zx, undefined, 0, zy, 1, 0 ); // $ExpectError - zdotu.ndarray( zx.length, zx, [], 0, zy, 1, 0 ); // $ExpectError - zdotu.ndarray( zx.length, zx, {}, 0, zy, 1, 0 ); // $ExpectError - zdotu.ndarray( zx.length, zx, ( zx: number ): number => zx, 0, zy, 1, 0 ); // $ExpectError + zdotu.ndarray( x.length, x, '10', 0, y, 1, 0 ); // $ExpectError + zdotu.ndarray( x.length, x, true, 0, y, 1, 0 ); // $ExpectError + zdotu.ndarray( x.length, x, false, 0, y, 1, 0 ); // $ExpectError + zdotu.ndarray( x.length, x, null, 0, y, 1, 0 ); // $ExpectError + zdotu.ndarray( x.length, x, undefined, 0, y, 1, 0 ); // $ExpectError + zdotu.ndarray( x.length, x, [], 0, y, 1, 0 ); // $ExpectError + zdotu.ndarray( x.length, x, {}, 0, y, 1, 0 ); // $ExpectError + zdotu.ndarray( x.length, x, ( x: number ): number => x, 0, y, 1, 0 ); // $ExpectError } // The compiler throws an error if the `ndarray` method is provided a fourth argument which is not a number... { - const zx = new Complex128Array( 10 ); - const zy = new Complex128Array( 10 ); + const x = new Complex128Array( 10 ); + const y = new Complex128Array( 10 ); - zdotu.ndarray( zx.length, zx, 1, '10', zy, 1, 0 ); // $ExpectError - zdotu.ndarray( zx.length, zx, 1, true, zy, 1, 0 ); // $ExpectError - zdotu.ndarray( zx.length, zx, 1, false, zy, 1, 0 ); // $ExpectError - zdotu.ndarray( zx.length, zx, 1, null, zy, 1, 0 ); // $ExpectError - zdotu.ndarray( zx.length, zx, 1, undefined, zy, 1, 0 ); // $ExpectError - zdotu.ndarray( zx.length, zx, 1, [], zy, 1, 0 ); // $ExpectError - zdotu.ndarray( zx.length, zx, 1, {}, zy, 1, 0 ); // $ExpectError - zdotu.ndarray( zx.length, zx, 1, ( zx: number ): number => zx, zy, 1, 0 ); // $ExpectError + zdotu.ndarray( x.length, x, 1, '10', y, 1, 0 ); // $ExpectError + zdotu.ndarray( x.length, x, 1, true, y, 1, 0 ); // $ExpectError + zdotu.ndarray( x.length, x, 1, false, y, 1, 0 ); // $ExpectError + zdotu.ndarray( x.length, x, 1, null, y, 1, 0 ); // $ExpectError + zdotu.ndarray( x.length, x, 1, undefined, y, 1, 0 ); // $ExpectError + zdotu.ndarray( x.length, x, 1, [], y, 1, 0 ); // $ExpectError + zdotu.ndarray( x.length, x, 1, {}, y, 1, 0 ); // $ExpectError + zdotu.ndarray( x.length, x, 1, ( x: number ): number => x, y, 1, 0 ); // $ExpectError } // The compiler throws an error if the `ndarray` method is provided a fifth argument which is not a Complex128Array... { - const zx = new Complex128Array( 10 ); + const x = new Complex128Array( 10 ); - zdotu.ndarray( zx.length, zx, 1, 0, 10, 1, 0 ); // $ExpectError - zdotu.ndarray( zx.length, zx, 1, 0, '10', 1, 0 ); // $ExpectError - zdotu.ndarray( zx.length, zx, 1, 0, true, 1, 0 ); // $ExpectError - zdotu.ndarray( zx.length, zx, 1, 0, false, 1, 0 ); // $ExpectError - zdotu.ndarray( zx.length, zx, 1, 0, null, 1, 0 ); // $ExpectError - zdotu.ndarray( zx.length, zx, 1, 0, undefined, 1, 0 ); // $ExpectError - zdotu.ndarray( zx.length, zx, 1, 0, [], 1, 0 ); // $ExpectError - zdotu.ndarray( zx.length, zx, 1, 0, {}, 1, 0 ); // $ExpectError - zdotu.ndarray( zx.length, zx, 1, 0, ( zx: number ): number => zx, 1, 0 ); // $ExpectError + zdotu.ndarray( x.length, x, 1, 0, 10, 1, 0 ); // $ExpectError + zdotu.ndarray( x.length, x, 1, 0, '10', 1, 0 ); // $ExpectError + zdotu.ndarray( x.length, x, 1, 0, true, 1, 0 ); // $ExpectError + zdotu.ndarray( x.length, x, 1, 0, false, 1, 0 ); // $ExpectError + zdotu.ndarray( x.length, x, 1, 0, null, 1, 0 ); // $ExpectError + zdotu.ndarray( x.length, x, 1, 0, undefined, 1, 0 ); // $ExpectError + zdotu.ndarray( x.length, x, 1, 0, [], 1, 0 ); // $ExpectError + zdotu.ndarray( x.length, x, 1, 0, {}, 1, 0 ); // $ExpectError + zdotu.ndarray( x.length, x, 1, 0, ( x: number ): number => x, 1, 0 ); // $ExpectError } // The compiler throws an error if the `ndarray` method is provided a sixth argument which is not a number... { - const zx = new Complex128Array( 10 ); - const zy = new Complex128Array( 10 ); + const x = new Complex128Array( 10 ); + const y = new Complex128Array( 10 ); - zdotu.ndarray( zx.length, zx, 1, 0, zy, '10', 0 ); // $ExpectError - zdotu.ndarray( zx.length, zx, 1, 0, zy, true, 0 ); // $ExpectError - zdotu.ndarray( zx.length, zx, 1, 0, zy, false, 0 ); // $ExpectError - zdotu.ndarray( zx.length, zx, 1, 0, zy, null, 0 ); // $ExpectError - zdotu.ndarray( zx.length, zx, 1, 0, zy, undefined, 0 ); // $ExpectError - zdotu.ndarray( zx.length, zx, 1, 0, zy, [], 0 ); // $ExpectError - zdotu.ndarray( zx.length, zx, 1, 0, zy, {}, 0 ); // $ExpectError - zdotu.ndarray( zx.length, zx, 1, 0, zy, ( zx: number ): number => zx, 0 ); // $ExpectError + zdotu.ndarray( x.length, x, 1, 0, y, '10', 0 ); // $ExpectError + zdotu.ndarray( x.length, x, 1, 0, y, true, 0 ); // $ExpectError + zdotu.ndarray( x.length, x, 1, 0, y, false, 0 ); // $ExpectError + zdotu.ndarray( x.length, x, 1, 0, y, null, 0 ); // $ExpectError + zdotu.ndarray( x.length, x, 1, 0, y, undefined, 0 ); // $ExpectError + zdotu.ndarray( x.length, x, 1, 0, y, [], 0 ); // $ExpectError + zdotu.ndarray( x.length, x, 1, 0, y, {}, 0 ); // $ExpectError + zdotu.ndarray( x.length, x, 1, 0, y, ( x: number ): number => x, 0 ); // $ExpectError } // The compiler throws an error if the `ndarray` method is provided a seventh argument which is not a number... { - const zx = new Complex128Array( 10 ); - const zy = new Complex128Array( 10 ); + const x = new Complex128Array( 10 ); + const y = new Complex128Array( 10 ); - zdotu.ndarray( zx.length, zx, 1, 0, zy, 1, '10' ); // $ExpectError - zdotu.ndarray( zx.length, zx, 1, 0, zy, 1, true ); // $ExpectError - zdotu.ndarray( zx.length, zx, 1, 0, zy, 1, false ); // $ExpectError - zdotu.ndarray( zx.length, zx, 1, 0, zy, 1, null ); // $ExpectError - zdotu.ndarray( zx.length, zx, 1, 0, zy, 1, undefined ); // $ExpectError - zdotu.ndarray( zx.length, zx, 1, 0, zy, 1, [] ); // $ExpectError - zdotu.ndarray( zx.length, zx, 1, 0, zy, 1, {} ); // $ExpectError - zdotu.ndarray( zx.length, zx, 1, 0, zy, 1, ( zx: number ): number => zx ); // $ExpectError + zdotu.ndarray( x.length, x, 1, 0, y, 1, '10' ); // $ExpectError + zdotu.ndarray( x.length, x, 1, 0, y, 1, true ); // $ExpectError + zdotu.ndarray( x.length, x, 1, 0, y, 1, false ); // $ExpectError + zdotu.ndarray( x.length, x, 1, 0, y, 1, null ); // $ExpectError + zdotu.ndarray( x.length, x, 1, 0, y, 1, undefined ); // $ExpectError + zdotu.ndarray( x.length, x, 1, 0, y, 1, [] ); // $ExpectError + zdotu.ndarray( x.length, x, 1, 0, y, 1, {} ); // $ExpectError + zdotu.ndarray( x.length, x, 1, 0, y, 1, ( x: number ): number => x ); // $ExpectError } // The compiler throws an error if the `ndarray` method is provided an unsupported number of arguments... { - const zx = new Complex128Array( 10 ); - const zy = new Complex128Array( 10 ); + const x = new Complex128Array( 10 ); + const y = new Complex128Array( 10 ); zdotu.ndarray(); // $ExpectError - zdotu.ndarray( zx.length ); // $ExpectError - zdotu.ndarray( zx.length, zx ); // $ExpectError - zdotu.ndarray( zx.length, zx, 1 ); // $ExpectError - zdotu.ndarray( zx.length, zx, 1, 0 ); // $ExpectError - zdotu.ndarray( zx.length, zx, 1, 0, zy ); // $ExpectError - zdotu.ndarray( zx.length, zx, 1, 0, zy, 1 ); // $ExpectError - zdotu.ndarray( zx.length, zx, 1, 0, zy, 1, 0, 10 ); // $ExpectError + zdotu.ndarray( x.length ); // $ExpectError + zdotu.ndarray( x.length, x ); // $ExpectError + zdotu.ndarray( x.length, x, 1 ); // $ExpectError + zdotu.ndarray( x.length, x, 1, 0 ); // $ExpectError + zdotu.ndarray( x.length, x, 1, 0, y ); // $ExpectError + zdotu.ndarray( x.length, x, 1, 0, y, 1 ); // $ExpectError + zdotu.ndarray( x.length, x, 1, 0, y, 1, 0, 10 ); // $ExpectError } diff --git a/lib/node_modules/@stdlib/blas/base/zdotu/lib/index.js b/lib/node_modules/@stdlib/blas/base/zdotu/lib/index.js index bf00abdd169a..b09075b87a51 100644 --- a/lib/node_modules/@stdlib/blas/base/zdotu/lib/index.js +++ b/lib/node_modules/@stdlib/blas/base/zdotu/lib/index.js @@ -25,39 +25,23 @@ * * @example * var Complex128Array = require( '@stdlib/array/complex128' ); -* var real = require( '@stdlib/complex/float64/real' ); -* var imag = require( '@stdlib/complex/float64/imag' ); * var zdotu = require( '@stdlib/blas/base/zdotu' ); * -* var zx = new Complex128Array( [ 4.0, 2.0, -3.0, 5.0, -1.0, 7.0 ] ); -* var zy = new Complex128Array( [ 2.0, 6.0, -1.0, -4.0, 8.0, 9.0 ] ); +* var x = new Complex128Array( [ 4.0, 2.0, -3.0, 5.0, -1.0, 7.0 ] ); +* var y = new Complex128Array( [ 2.0, 6.0, -1.0, -4.0, 8.0, 9.0 ] ); * -* var z = zdotu( 3, zx, 1, zy, 1 ); -* // returns -* -* var re = real( z ); -* // returns -52.0 -* -* var im = imag( z ); -* // returns 82.0 +* var z = zdotu( 3, x, 1, y, 1 ); +* // returns [ -52.0, 82.0 ] * * @example * var Complex128Array = require( '@stdlib/array/complex128' ); -* var real = require( '@stdlib/complex/float64/real' ); -* var imag = require( '@stdlib/complex/float64/imag' ); * var zdotu = require( '@stdlib/blas/base/zdotu' ); * -* var zx = new Complex128Array( [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0 ] ); -* var zy = new Complex128Array( [ 9.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0 ] ); -* -* var z = zdotu.ndarray( 2, zx, 2, 1, zy, -1, zy.length-1 ); -* // returns -* -* var re = real( z ); -* // returns -40.0 +* var x = new Complex128Array( [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0 ] ); +* var y = new Complex128Array( [ 9.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0 ] ); * -* var im = imag( z ); -* // returns 310.0 +* var z = zdotu.ndarray( 2, x, 2, 1, y, -1, y.length-1 ); +* // returns [ -40.0, 310.0 ] */ // MODULES // diff --git a/lib/node_modules/@stdlib/blas/base/zdotu/lib/ndarray.js b/lib/node_modules/@stdlib/blas/base/zdotu/lib/ndarray.js index 304689fc3316..8aa5f4c33bfb 100644 --- a/lib/node_modules/@stdlib/blas/base/zdotu/lib/ndarray.js +++ b/lib/node_modules/@stdlib/blas/base/zdotu/lib/ndarray.js @@ -30,32 +30,24 @@ var muladd = require( '@stdlib/complex/float64/base/mul-add' ); * Calculates the dot product of two double-precision complex floating-point vectors. * * @param {integer} N - number of indexed elements -* @param {Complex128Array} zx - first input array -* @param {integer} strideX - `zx` stride length -* @param {NonNegativeInteger} offsetX - starting index for `zx` -* @param {Complex128Array} zy - second input array -* @param {integer} strideY - `zy` stride length -* @param {NonNegativeInteger} offsetY - starting index for `zy` +* @param {Complex128Array} x - first input array +* @param {integer} strideX - `x` stride length +* @param {NonNegativeInteger} offsetX - starting index for `x` +* @param {Complex128Array} y - second input array +* @param {integer} strideY - `y` stride length +* @param {NonNegativeInteger} offsetY - starting index for `y` * @returns {Complex128} dot product * * @example * var Complex128Array = require( '@stdlib/array/complex128' ); -* var real = require( '@stdlib/complex/float64/real' ); -* var imag = require( '@stdlib/complex/float64/imag' ); * -* var zx = new Complex128Array( [ 4.0, 2.0, -3.0, 5.0, -1.0, 7.0 ] ); -* var zy = new Complex128Array( [ 2.0, 6.0, -1.0, -4.0, 8.0, 9.0 ] ); +* var x = new Complex128Array( [ 4.0, 2.0, -3.0, 5.0, -1.0, 7.0 ] ); +* var y = new Complex128Array( [ 2.0, 6.0, -1.0, -4.0, 8.0, 9.0 ] ); * -* var z = zdotu( 3, zx, 1, 0, zy, 1, 0 ); -* // returns -* -* var re = real( z ); -* // returns -52.0 -* -* var im = imag( z ); -* // returns 82.0 +* var z = zdotu( 3, x, 1, 0, y, 1, 0 ); +* // returns [ -52.0, 82.0 ] */ -function zdotu( N, zx, strideX, offsetX, zy, strideY, offsetY ) { +function zdotu( N, x, strideX, offsetX, y, strideY, offsetY ) { var dot; var ix; var iy; @@ -68,7 +60,7 @@ function zdotu( N, zx, strideX, offsetX, zy, strideY, offsetY ) { ix = offsetX; iy = offsetY; for ( i = 0; i < N; i++ ) { - dot = muladd( zx.get( ix ), zy.get( iy ), dot ); + dot = muladd( x.get( ix ), y.get( iy ), dot ); ix += strideX; iy += strideY; } diff --git a/lib/node_modules/@stdlib/blas/base/zdotu/lib/zdotu.js b/lib/node_modules/@stdlib/blas/base/zdotu/lib/zdotu.js index 5119654eea9f..3ca8b6c14682 100644 --- a/lib/node_modules/@stdlib/blas/base/zdotu/lib/zdotu.js +++ b/lib/node_modules/@stdlib/blas/base/zdotu/lib/zdotu.js @@ -30,33 +30,25 @@ var ndarray = require( './ndarray.js' ); * Calculates the dot product of two double-precision complex floating-point vectors. * * @param {PositiveInteger} N - number of indexed elements -* @param {Complex128Array} zx - first input array -* @param {integer} strideX - `zx` stride length -* @param {Complex128Array} zy - second input array -* @param {integer} strideY - `zy` stride length +* @param {Complex128Array} x - first input array +* @param {integer} strideX - `x` stride length +* @param {Complex128Array} y - second input array +* @param {integer} strideY - `y` stride length * @returns {Complex128} dot product * * @example * var Complex128Array = require( '@stdlib/array/complex128' ); -* var real = require( '@stdlib/complex/float64/real' ); -* var imag = require( '@stdlib/complex/float64/imag' ); * -* var zx = new Complex128Array( [ 4.0, 2.0, -3.0, 5.0, -1.0, 7.0 ] ); -* var zy = new Complex128Array( [ 2.0, 6.0, -1.0, -4.0, 8.0, 9.0 ] ); +* var x = new Complex128Array( [ 4.0, 2.0, -3.0, 5.0, -1.0, 7.0 ] ); +* var y = new Complex128Array( [ 2.0, 6.0, -1.0, -4.0, 8.0, 9.0 ] ); * -* var z = zdotu( 3, zx, 1, zy, 1 ); -* // returns -* -* var re = real( z ); -* // returns -52.0 -* -* var im = imag( z ); -* // returns 82.0 +* var z = zdotu( 3, x, 1, y, 1 ); +* // returns [ -52.0, 82.0 ] */ -function zdotu( N, zx, strideX, zy, strideY ) { +function zdotu( N, x, strideX, y, strideY ) { var ix = stride2offset( N, strideX ); var iy = stride2offset( N, strideY ); - return ndarray( N, zx, strideX, ix, zy, strideY, iy ); + return ndarray( N, x, strideX, ix, y, strideY, iy ); } From 68425199e7441ff89a3916174769d1af9e0aab41 Mon Sep 17 00:00:00 2001 From: ShabiShett07 Date: Mon, 7 Jul 2025 17:38:28 +0530 Subject: [PATCH 4/8] chore: update repl --- type: pre_commit_static_analysis_report description: Results of running static analysis checks when committing changes. report: - task: lint_filenames status: passed - task: lint_editorconfig status: passed - task: lint_markdown status: na - task: lint_package_json status: na - task: lint_repl_help status: passed - task: lint_javascript_src status: na - task: lint_javascript_cli status: na - task: lint_javascript_examples status: na - task: lint_javascript_tests status: na - task: lint_javascript_benchmarks status: na - task: lint_python status: na - task: lint_r status: na - task: lint_c_src status: na - task: lint_c_examples status: na - task: lint_c_benchmarks status: na - task: lint_c_tests_fixtures status: na - task: lint_shell status: na - task: lint_typescript_declarations status: na - task: lint_typescript_tests status: na - task: lint_license_headers status: passed --- --- .../@stdlib/blas/base/zdotu/docs/repl.txt | 87 ++++++++----------- 1 file changed, 36 insertions(+), 51 deletions(-) diff --git a/lib/node_modules/@stdlib/blas/base/zdotu/docs/repl.txt b/lib/node_modules/@stdlib/blas/base/zdotu/docs/repl.txt index f05d4cf51b8e..4903798457fd 100644 --- a/lib/node_modules/@stdlib/blas/base/zdotu/docs/repl.txt +++ b/lib/node_modules/@stdlib/blas/base/zdotu/docs/repl.txt @@ -1,5 +1,5 @@ -{{alias}}( N, zx, strideX, zy, strideY ) +{{alias}}( N, x, strideX, y, strideY ) Calculate the dot product of two double-precision complex floating-point vectors. @@ -16,17 +16,17 @@ N: integer Number of indexed elements. - zx: Complex128Array + x: Complex128Array First input array. strideX: integer - Index increment for `zx`. + Stride length for `x`. - zy: Complex128Array + y: Complex128Array Second input array. strideY: integer - Index increment for `zy`. + Stride length for `y`. Returns ------- @@ -36,36 +36,27 @@ Examples -------- // Standard usage: - > var zx = new {{alias:@stdlib/array/complex128}}( [ 1.0, 2.0, 3.0, 4.0 ] ); - > var zy = new {{alias:@stdlib/array/complex128}}( [ 6.0, 7.0, 8.0, 9.0 ] ); - > var z = {{alias}}( zx.length, zx, 1, zy, 1 ); - > var re = {{alias:@stdlib/complex/float64/real}}( z ) - -20.0 - > var im = {{alias:@stdlib/complex/float64/imag}}( z ) - 78.0 + > var x = new {{alias:@stdlib/array/complex128}}( [ 1.0, 2.0, 3.0, 4.0 ] ); + > var y = new {{alias:@stdlib/array/complex128}}( [ 6.0, 7.0, 8.0, 9.0 ] ); + > var z = {{alias}}( x.length, x, 1, y, 1 ) + [ -20.0, 78.0 ] // Advanced indexing: - > var zx = new {{alias:@stdlib/array/complex128}}( [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0 ] ); - > var zy = new {{alias:@stdlib/array/complex128}}( [ 1.0, 1.0, 1.0, 1.0, 1.0, 1.0 ] ); - > var z = {{alias}}( 2, zx, 2, zy, -1 ); - > var re = {{alias:@stdlib/complex/float64/real}}( z ) - -2.0 - > var im = {{alias:@stdlib/complex/float64/imag}}( z ) - 14.0 + > var x = new {{alias:@stdlib/array/complex128}}( [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0 ] ); + > var y = new {{alias:@stdlib/array/complex128}}( [ 1.0, 1.0, 1.0, 1.0, 1.0, 1.0 ] ); + > var z = {{alias}}( 2, x, 2, y, -1 ) + [ -2.0, 14.0 ] // Using typed array views: - > var zx0 = new {{alias:@stdlib/array/complex128}}( [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0 ] ); - > var zy0 = new {{alias:@stdlib/array/complex128}}( [ 7.0, 8.0, 9.0, 10.0, 11.0, 12.0 ] ); - > var zx1 = new {{alias:@stdlib/array/complex128}}( zx0.buffer, zx0.BYTES_PER_ELEMENT*1 ); - > var zy1 = new {{alias:@stdlib/array/complex128}}( zy0.buffer, zy0.BYTES_PER_ELEMENT*2 ); - > var z = {{alias}}( 1, zx1, 1, zy1, 1 ); - > var re = {{alias:@stdlib/complex/float64/real}}( z ) - -15.0 - > var im = {{alias:@stdlib/complex/float64/imag}}( z ) - 80.0 - - -{{alias}}.ndarray( N, zx, strideX, offsetX, zy, strideY, offsetY ) + > var x0 = new {{alias:@stdlib/array/complex128}}( [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0 ] ); + > var y0 = new {{alias:@stdlib/array/complex128}}( [ 7.0, 8.0, 9.0, 10.0, 11.0, 12.0 ] ); + > var x1 = new {{alias:@stdlib/array/complex128}}( x0.buffer, x0.BYTES_PER_ELEMENT*1 ); + > var y1 = new {{alias:@stdlib/array/complex128}}( y0.buffer, y0.BYTES_PER_ELEMENT*2 ); + > var z = {{alias}}( 1, x1, 1, y1, 1 ) + [ -15.0, 80.0 ] + + +{{alias}}.ndarray( N, x, strideX, offsetX, y, strideY, offsetY ) Computes the dot product of two double-precision complex floating-point vectors using alternative indexing semantics. @@ -77,23 +68,23 @@ N: integer Number of indexed elements. - zx: Complex128Array + x: Complex128Array First input array. strideX: integer - Index increment for `zx`. + Stride length for `x`. offsetX: integer - Starting index for `zx`. + Starting index for `x`. - zy: Complex128Array + y: Complex128Array Second input array. strideY: integer - Index increment for `zy`. + Stride length for `y`. offsetY: integer - Starting index for `zy`. + Starting index for `y`. Returns ------- @@ -103,22 +94,16 @@ Examples -------- // Standard usage: - > var zx = new {{alias:@stdlib/array/complex128}}( [ 1.0, 2.0, 3.0, 4.0 ] ); - > var zy = new {{alias:@stdlib/array/complex128}}( [ 6.0, 7.0, 8.0, 9.0 ] ); - > var z = {{alias}}.ndarray( zx.length, zx, 1, 0, zy, 1, 0 ); - > var re = {{alias:@stdlib/complex/float64/real}}( z ) - -20.0 - > var im = {{alias:@stdlib/complex/float64/imag}}( z ) - 78.0 + > var x = new {{alias:@stdlib/array/complex128}}( [ 1.0, 2.0, 3.0, 4.0 ] ); + > var y = new {{alias:@stdlib/array/complex128}}( [ 6.0, 7.0, 8.0, 9.0 ] ); + > var z = {{alias}}.ndarray( x.length, x, 1, 0, y, 1, 0 ) + [ -20.0, 78.0 ] // Advanced indexing: - > var zx = new {{alias:@stdlib/array/complex128}}( [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0 ] ); - > var zy = new {{alias:@stdlib/array/complex128}}( [ 1.0, 1.0, 1.0, 1.0, 1.0, 1.0 ] ); - > var z = {{alias}}.ndarray( 1, zx, 2, 1, zy, -1, zy.length-1 ); - > var re = {{alias:@stdlib/complex/float64/real}}( z ) - -1.0 - > var im = {{alias:@stdlib/complex/float64/imag}}( z ) - 7.0 + > var x = new {{alias:@stdlib/array/complex128}}( [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0 ] ); + > var y = new {{alias:@stdlib/array/complex128}}( [ 1.0, 1.0, 1.0, 1.0, 1.0, 1.0 ] ); + > var z = {{alias}}.ndarray( 1, x, 2, 1, y, -1, y.length-1 ) + [ -1.0, 7.0 ] See Also -------- From 393da2b327c5328257416ac855d1ab8af9ba4045 Mon Sep 17 00:00:00 2001 From: ShabiShett07 Date: Mon, 7 Jul 2025 17:41:45 +0530 Subject: [PATCH 5/8] chore: add examples --- type: pre_commit_static_analysis_report description: Results of running static analysis checks when committing changes. report: - task: lint_filenames status: passed - task: lint_editorconfig status: passed - task: lint_markdown status: na - task: lint_package_json status: na - task: lint_repl_help status: na - task: lint_javascript_src status: na - task: lint_javascript_cli status: na - task: lint_javascript_examples status: passed - task: lint_javascript_tests status: na - task: lint_javascript_benchmarks status: na - task: lint_python status: na - task: lint_r status: na - task: lint_c_src status: na - task: lint_c_examples status: na - task: lint_c_benchmarks status: na - task: lint_c_tests_fixtures status: na - task: lint_shell status: na - task: lint_typescript_declarations status: na - task: lint_typescript_tests status: na - task: lint_license_headers status: passed --- --- .../@stdlib/blas/base/zdotu/examples/index.js | 15 ++++++++++----- 1 file changed, 10 insertions(+), 5 deletions(-) diff --git a/lib/node_modules/@stdlib/blas/base/zdotu/examples/index.js b/lib/node_modules/@stdlib/blas/base/zdotu/examples/index.js index cd368556be2d..d74f1f7efc9f 100644 --- a/lib/node_modules/@stdlib/blas/base/zdotu/examples/index.js +++ b/lib/node_modules/@stdlib/blas/base/zdotu/examples/index.js @@ -27,11 +27,16 @@ function rand() { return new Complex128( discreteUniform( 0, 10 ), discreteUniform( -5, 5 ) ); } -var zx = filledarrayBy( 10, 'complex128', rand ); -console.log( zx.toString() ); +var x = filledarrayBy( 10, 'complex128', rand ); +console.log( x.toString() ); -var zy = filledarrayBy( 10, 'complex128', rand ); -console.log( zy.toString() ); +var y = filledarrayBy( 10, 'complex128', rand ); +console.log( y.toString() ); -var out = zdotu.ndarray( zx.length, zx, 1, 0, zy, -1, zy.length-1 ); +// Compute the dot product: +var out = zdotu( x.length, x, 1, 0, y, -1, y.length-1 ); +console.log( out.toString() ); + +// Compute the dot product using alternative indexing semantics: +out = zdotu.ndarray( x.length, x, 1, 0, y, -1, y.length-1 ); console.log( out.toString() ); From af6e6a83220307a500396224231e83cd60edccb2 Mon Sep 17 00:00:00 2001 From: ShabiShett07 Date: Mon, 7 Jul 2025 17:52:34 +0530 Subject: [PATCH 6/8] test: change variable naming --- type: pre_commit_static_analysis_report description: Results of running static analysis checks when committing changes. report: - task: lint_filenames status: passed - task: lint_editorconfig status: passed - task: lint_markdown status: na - task: lint_package_json status: na - task: lint_repl_help status: na - task: lint_javascript_src status: na - task: lint_javascript_cli status: na - task: lint_javascript_examples status: na - task: lint_javascript_tests status: passed - task: lint_javascript_benchmarks status: na - task: lint_python status: na - task: lint_r status: na - task: lint_c_src status: na - task: lint_c_examples status: na - task: lint_c_benchmarks status: na - task: lint_c_tests_fixtures status: na - task: lint_shell status: na - task: lint_typescript_declarations status: na - task: lint_typescript_tests status: na - task: lint_license_headers status: passed --- --- .../blas/base/zdotu/test/test.ndarray.js | 98 +++++++++---------- .../blas/base/zdotu/test/test.zdotu.js | 74 +++++++------- 2 files changed, 86 insertions(+), 86 deletions(-) diff --git a/lib/node_modules/@stdlib/blas/base/zdotu/test/test.ndarray.js b/lib/node_modules/@stdlib/blas/base/zdotu/test/test.ndarray.js index a5b6b7918f90..1b98d6c18ca7 100644 --- a/lib/node_modules/@stdlib/blas/base/zdotu/test/test.ndarray.js +++ b/lib/node_modules/@stdlib/blas/base/zdotu/test/test.ndarray.js @@ -40,21 +40,21 @@ tape( 'the function has an arity of 7', function test( t ) { t.end(); }); -tape( 'the function calculates the dot product of two double-precision complex floating-point vectors `zx` and `zy`', function test( t ) { +tape( 'the function calculates the dot product of two double-precision complex floating-point vectors `x` and `y`', function test( t ) { var dot; - var zx; - var zy; + var x; + var y; - zx = new Complex128Array( [ 4.0, 2.0, -3.0, 5.0, -1.0, 2.0, -5.0, 6.0 ] ); - zy = new Complex128Array( [ 2.0, 6.0, -1.0, -4.0, 8.0, 8.0, 2.0, -3.0 ] ); + x = new Complex128Array( [ 4.0, 2.0, -3.0, 5.0, -1.0, 2.0, -5.0, 6.0 ] ); + y = new Complex128Array( [ 2.0, 6.0, -1.0, -4.0, 8.0, 8.0, 2.0, -3.0 ] ); - dot = zdotu( zx.length, zx, 1, 0, zy, 1, 0 ); + dot = zdotu( x.length, x, 1, 0, y, 1, 0 ); t.strictEqual(isSameComplex128( dot, new Complex128( 3, 70 ) ), true, 'returns expected value' ); - zx = new Complex128Array( [ 3.0, -4.0, 1.0, 2.0 ] ); - zy = new Complex128Array( [ 1.0, -2.0, 3.0, 8.0 ] ); + x = new Complex128Array( [ 3.0, -4.0, 1.0, 2.0 ] ); + y = new Complex128Array( [ 1.0, -2.0, 3.0, 8.0 ] ); - dot = zdotu( zx.length, zx, 1, 0, zy, 1, 0 ); + dot = zdotu( x.length, x, 1, 0, y, 1, 0 ); t.strictEqual( isSameComplex128( dot, new Complex128( -18, 4 ) ), true, 'returns expected value' ); t.end(); @@ -62,26 +62,26 @@ tape( 'the function calculates the dot product of two double-precision complex f tape( 'if provided an `N` parameter less than or equal to `0`, the function returns `0`', function test( t ) { var dot; - var zx; - var zy; + var x; + var y; - zx = new Complex128Array( [ 3.0, -4.0, 1.0, 7.0 ] ); - zy = new Complex128Array( [ 1.0, -2.0, 3.0, -3.0 ] ); + x = new Complex128Array( [ 3.0, -4.0, 1.0, 7.0 ] ); + y = new Complex128Array( [ 1.0, -2.0, 3.0, -3.0 ] ); - dot = zdotu( 0, zx, 1, 0, zy, 1, 0 ); + dot = zdotu( 0, x, 1, 0, y, 1, 0 ); t.strictEqual( isSameComplex128( dot, new Complex128( 0, 0 ) ), true, 'returns expected value' ); - dot = zdotu( -4, zx, 1, 0, zy, 1, 0 ); + dot = zdotu( -4, x, 1, 0, y, 1, 0 ); t.strictEqual( isSameComplex128( dot, new Complex128( 0, 0 ) ), true, 'returns expected value' ); t.end(); }); -tape( 'the function supports an `zx` stride', function test( t ) { +tape( 'the function supports an `x` stride', function test( t ) { var dot; - var zx; - var zy; + var x; + var y; - zx = new Complex128Array([ + x = new Complex128Array([ 2.0, // 0 -3.0, // 0 -5.0, @@ -89,7 +89,7 @@ tape( 'the function supports an `zx` stride', function test( t ) { 7.0, // 1 6.0 // 1 ]); - zy = new Complex128Array([ + y = new Complex128Array([ 8.0, // 0 2.0, // 0 -3.0, // 1 @@ -98,17 +98,17 @@ tape( 'the function supports an `zx` stride', function test( t ) { 1.0 ]); - dot = zdotu( 2, zx, 2, 0, zy, 1, 0 ); + dot = zdotu( 2, x, 2, 0, y, 1, 0 ); t.strictEqual( isSameComplex128( dot, new Complex128( -17, -17 ) ), true, 'returns expected value' ); t.end(); }); -tape( 'the function supports an `zx` offset', function test( t ) { +tape( 'the function supports an `x` offset', function test( t ) { var dot; - var zx; - var zy; + var x; + var y; - zx = new Complex128Array([ + x = new Complex128Array([ 2.0, -3.0, -5.0, // 0 @@ -116,7 +116,7 @@ tape( 'the function supports an `zx` offset', function test( t ) { 7.0, // 1 6.0 // 1 ]); - zy = new Complex128Array([ + y = new Complex128Array([ 8.0, // 0 2.0, // 0 -3.0, // 1 @@ -125,17 +125,17 @@ tape( 'the function supports an `zx` offset', function test( t ) { 1.0 ]); - dot = zdotu( 2, zx, 1, 1, zy, 1, 0 ); + dot = zdotu( 2, x, 1, 1, y, 1, 0 ); t.strictEqual( isSameComplex128( dot, new Complex128( -91, 41 ) ), true, 'returns expected value' ); t.end(); }); -tape( 'the function supports a `zy` stride', function test( t ) { +tape( 'the function supports a `y` stride', function test( t ) { var dot; - var zx; - var zy; + var x; + var y; - zx = new Complex128Array([ + x = new Complex128Array([ 2.0, // 0 -3.0, // 0 -5.0, // 1 @@ -143,7 +143,7 @@ tape( 'the function supports a `zy` stride', function test( t ) { 7.0, 6.0 ]); - zy = new Complex128Array([ + y = new Complex128Array([ 8.0, // 0 2.0, // 0 -3.0, @@ -152,17 +152,17 @@ tape( 'the function supports a `zy` stride', function test( t ) { 1.0 // 1 ]); - dot = zdotu( 2, zx, 1, 0, zy, 2, 0 ); + dot = zdotu( 2, x, 1, 0, y, 2, 0 ); t.strictEqual( isSameComplex128( dot, new Complex128( 36, -49 ) ), true, 'returns expected value' ); t.end(); }); -tape( 'the function supports a `zy` offset', function test( t ) { +tape( 'the function supports a `y` offset', function test( t ) { var dot; - var zx; - var zy; + var x; + var y; - zx = new Complex128Array([ + x = new Complex128Array([ 1.0, // 0 2.0, // 0 3.0, @@ -170,7 +170,7 @@ tape( 'the function supports a `zy` offset', function test( t ) { 5.0, // 1 6.0 // 1 ]); - zy = new Complex128Array([ + y = new Complex128Array([ 7.0, 8.0, 9.0, // 0 @@ -179,17 +179,17 @@ tape( 'the function supports a `zy` offset', function test( t ) { 12.0 // 1 ]); - dot = zdotu( 2, zx, 2, 0, zy, 1, 1 ); + dot = zdotu( 2, x, 2, 0, y, 1, 1 ); t.strictEqual( isSameComplex128( dot, new Complex128( -28, 154 ) ), true, 'returns expected value' ); t.end(); }); tape( 'the function supports negative strides', function test( t ) { var dot; - var zx; - var zy; + var x; + var y; - zx = new Complex128Array([ + x = new Complex128Array([ 1.0, // 1 2.0, // 1 3.0, @@ -197,7 +197,7 @@ tape( 'the function supports negative strides', function test( t ) { 5.0, // 0 6.0 // 0 ]); - zy = new Complex128Array([ + y = new Complex128Array([ 7.0, 8.0, 9.0, // 1 @@ -206,17 +206,17 @@ tape( 'the function supports negative strides', function test( t ) { 12.0 // 0 ]); - dot = zdotu( 2, zx, -2, zx.length-1, zy, -1, 2 ); + dot = zdotu( 2, x, -2, x.length-1, y, -1, 2 ); t.strictEqual( isSameComplex128( dot, new Complex128( -28, 154 ) ), true, 'returns expected value' ); t.end(); }); tape( 'the function supports complex access patterns', function test( t ) { var dot; - var zx; - var zy; + var x; + var y; - zx = new Complex128Array([ + x = new Complex128Array([ 1.0, // 0 2.0, // 0 3.0, @@ -224,7 +224,7 @@ tape( 'the function supports complex access patterns', function test( t ) { 5.0, // 1 6.0 // 1 ]); - zy = new Complex128Array([ + y = new Complex128Array([ 7.0, // 0 8.0, // 0 9.0, // 1 @@ -233,7 +233,7 @@ tape( 'the function supports complex access patterns', function test( t ) { 12.0 ]); - dot = zdotu( 2, zx, 2, 0, zy, -1, zy.length-2 ); + dot = zdotu( 2, x, 2, 0, y, -1, y.length-2 ); t.strictEqual( isSameComplex128( dot, new Complex128( -24, 110 ) ), true, 'returns expected value' ); t.end(); }); diff --git a/lib/node_modules/@stdlib/blas/base/zdotu/test/test.zdotu.js b/lib/node_modules/@stdlib/blas/base/zdotu/test/test.zdotu.js index cb2561065b25..7613bd1995d0 100644 --- a/lib/node_modules/@stdlib/blas/base/zdotu/test/test.zdotu.js +++ b/lib/node_modules/@stdlib/blas/base/zdotu/test/test.zdotu.js @@ -40,21 +40,21 @@ tape( 'the function has an arity of 5', function test( t ) { t.end(); }); -tape( 'the function calculates the dot product of two double-precision complex floating-point vectors `zx` and `zy`', function test( t ) { +tape( 'the function calculates the dot product of two double-precision complex floating-point vectors `x` and `y`', function test( t ) { var dot; - var zx; - var zy; + var x; + var y; - zx = new Complex128Array( [ 4.0, 2.0, -3.0, 5.0, -1.0, 2.0, -5.0, 6.0 ] ); - zy = new Complex128Array( [ 2.0, 6.0, -1.0, -4.0, 8.0, 8.0, 2.0, -3.0 ] ); + x = new Complex128Array( [ 4.0, 2.0, -3.0, 5.0, -1.0, 2.0, -5.0, 6.0 ] ); + y = new Complex128Array( [ 2.0, 6.0, -1.0, -4.0, 8.0, 8.0, 2.0, -3.0 ] ); - dot = zdotu( 4, zx, 1, zy, 1 ); + dot = zdotu( 4, x, 1, y, 1 ); t.strictEqual( isSameComplex128( dot, new Complex128( 3, 70 ) ), true, 'returns expected value' ); - zx = new Complex128Array( [ 3.0, -4.0, 1.0, 2.0 ] ); - zy = new Complex128Array( [ 1.0, -2.0, 3.0, 8.0 ] ); + x = new Complex128Array( [ 3.0, -4.0, 1.0, 2.0 ] ); + y = new Complex128Array( [ 1.0, -2.0, 3.0, 8.0 ] ); - dot = zdotu( 2, zx, 1, zy, 1 ); + dot = zdotu( 2, x, 1, y, 1 ); t.strictEqual( isSameComplex128( dot, new Complex128( -18, 4 ) ), true, 'returns expected value' ); t.end(); @@ -62,26 +62,26 @@ tape( 'the function calculates the dot product of two double-precision complex f tape( 'if provided an `N` parameter less than or equal to `0`, the function returns `0 + 0i`', function test( t ) { var dot; - var zx; - var zy; + var x; + var y; - zx = new Complex128Array( [ 3.0, -4.0, 1.0, 7.0 ] ); - zy = new Complex128Array( [ 1.0, -2.0, 3.0, -3.0 ] ); + x = new Complex128Array( [ 3.0, -4.0, 1.0, 7.0 ] ); + y = new Complex128Array( [ 1.0, -2.0, 3.0, -3.0 ] ); - dot = zdotu( 0, zx, 1, zy, 1 ); + dot = zdotu( 0, x, 1, y, 1 ); t.strictEqual( isSameComplex128( dot, new Complex128( 0, 0 ) ), true, 'returns expected value' ); - dot = zdotu( -4, zx, 1, zy, 1 ); + dot = zdotu( -4, x, 1, y, 1 ); t.strictEqual( isSameComplex128( dot, new Complex128( 0, 0 ) ), true, 'returns expected value' ); t.end(); }); -tape( 'the function supports an `zx` stride', function test( t ) { +tape( 'the function supports an `x` stride', function test( t ) { var dot; - var zx; - var zy; + var x; + var y; - zx = new Complex128Array([ + x = new Complex128Array([ 2.0, // 0 -3.0, // 0 -5.0, @@ -89,7 +89,7 @@ tape( 'the function supports an `zx` stride', function test( t ) { 7.0, // 1 6.0 // 1 ]); - zy = new Complex128Array([ + y = new Complex128Array([ 8.0, // 0 2.0, // 0 -3.0, // 1 @@ -98,17 +98,17 @@ tape( 'the function supports an `zx` stride', function test( t ) { 1.0 ]); - dot = zdotu( 2, zx, 2, zy, 1 ); + dot = zdotu( 2, x, 2, y, 1 ); t.strictEqual( isSameComplex128( dot, new Complex128( -17, -17 ) ), true, 'returns expected value' ); t.end(); }); -tape( 'the function supports a `zy` stride', function test( t ) { +tape( 'the function supports a `y` stride', function test( t ) { var dot; - var zx; - var zy; + var x; + var y; - zx = new Complex128Array([ + x = new Complex128Array([ 2.0, // 0 -3.0, // 0 -5.0, // 1 @@ -116,7 +116,7 @@ tape( 'the function supports a `zy` stride', function test( t ) { 6.0, -2.0 ]); - zy = new Complex128Array([ + y = new Complex128Array([ 8.0, // 0 2.0, // 0 -3.0, @@ -125,17 +125,17 @@ tape( 'the function supports a `zy` stride', function test( t ) { 1.0 // 1 ]); - dot = zdotu( 2, zx, 1, zy, 2 ); + dot = zdotu( 2, x, 1, y, 2 ); t.strictEqual( isSameComplex128( dot, new Complex128( 35, -53 ) ), true, 'returns expected value' ); t.end(); }); tape( 'the function supports negative strides', function test( t ) { var dot; - var zx; - var zy; + var x; + var y; - zx = new Complex128Array([ + x = new Complex128Array([ 1.0, // 1 2.0, // 1 3.0, @@ -143,7 +143,7 @@ tape( 'the function supports negative strides', function test( t ) { 5.0, // 0 6.0 // 0 ]); - zy = new Complex128Array([ + y = new Complex128Array([ 7.0, // 1 8.0, // 1 9.0, // 0 @@ -152,17 +152,17 @@ tape( 'the function supports negative strides', function test( t ) { 12.0 ]); - dot = zdotu( 2, zx, -2, zy, -1 ); + dot = zdotu( 2, x, -2, y, -1 ); t.strictEqual( isSameComplex128( dot, new Complex128( -24, 126 ) ), true, 'returns expected value' ); t.end(); }); tape( 'the function supports complex access patterns', function test( t ) { var dot; - var zx; - var zy; + var x; + var y; - zx = new Complex128Array([ + x = new Complex128Array([ 1.0, // 0 2.0, // 0 3.0, @@ -170,7 +170,7 @@ tape( 'the function supports complex access patterns', function test( t ) { 5.0, // 1 6.0 // 1 ]); - zy = new Complex128Array([ + y = new Complex128Array([ 7.0, // 0 8.0, // 0 9.0, // 1 @@ -179,7 +179,7 @@ tape( 'the function supports complex access patterns', function test( t ) { 12.0 ]); - dot = zdotu( 2, zx, 2, zy, -1 ); + dot = zdotu( 2, x, 2, y, -1 ); t.strictEqual( isSameComplex128( dot, new Complex128( -24, 110 ) ), true, 'returns expected value' ); t.end(); }); From 01395e47d8a65a1d0a17839f3e896f1e056145f4 Mon Sep 17 00:00:00 2001 From: ShabiShett07 Date: Mon, 7 Jul 2025 18:01:53 +0530 Subject: [PATCH 7/8] chore: update markdown file --- type: pre_commit_static_analysis_report description: Results of running static analysis checks when committing changes. report: - task: lint_filenames status: passed - task: lint_editorconfig status: passed - task: lint_markdown status: passed - task: lint_package_json status: na - task: lint_repl_help status: na - task: lint_javascript_src status: na - task: lint_javascript_cli status: na - task: lint_javascript_examples status: na - task: lint_javascript_tests status: na - task: lint_javascript_benchmarks status: na - task: lint_python status: na - task: lint_r status: na - task: lint_c_src status: na - task: lint_c_examples status: na - task: lint_c_benchmarks status: na - task: lint_c_tests_fixtures status: na - task: lint_shell status: na - task: lint_typescript_declarations status: na - task: lint_typescript_tests status: na - task: lint_license_headers status: passed --- --- .../@stdlib/blas/base/zdotu/README.md | 125 +++++++----------- 1 file changed, 45 insertions(+), 80 deletions(-) diff --git a/lib/node_modules/@stdlib/blas/base/zdotu/README.md b/lib/node_modules/@stdlib/blas/base/zdotu/README.md index 694f5d6f47f1..913df6f0eaf2 100644 --- a/lib/node_modules/@stdlib/blas/base/zdotu/README.md +++ b/lib/node_modules/@stdlib/blas/base/zdotu/README.md @@ -29,7 +29,7 @@ The [dot product][dot-product] (or scalar product) is defined as ```math -\mathbf{zx}\cdot\mathbf{zy} = \sum_{i=0}^{N-1} zx_i zy_i = zx_0 zy_0 + zx_1 zy_1 + \ldots + zx_{N-1} zy_{N-1} +\mathbf{x}\cdot\mathbf{y} = \sum_{i=0}^{N-1} x_i y_i = x_0 y_0 + x_1 y_1 + \ldots + x_{N-1} y_{N-1} ```