diff --git a/lib/node_modules/@stdlib/lapack/base/dlartg/README.md b/lib/node_modules/@stdlib/lapack/base/dlartg/README.md new file mode 100644 index 000000000000..a5e7729ef44a --- /dev/null +++ b/lib/node_modules/@stdlib/lapack/base/dlartg/README.md @@ -0,0 +1,292 @@ + + +# dlartg + +> LAPACK routine to construct a Givens rotation of a two-dimensional vector that zeros out the second component. + +
+ +`dlartg` constructs a Givens rotation for a two-dimensional vector such that the following equation is satisfied: + + + + +```math +\begin{bmatrix} C & S \\ -S & C \end{bmatrix} \begin{bmatrix} F \\ G \end{bmatrix} = \begin{bmatrix} R \\ 0 \end{bmatrix} +``` + + + +where `C` represents the cosine of the rotation `S` represents the sine of the rotation and `R` represents the length of the vector after rotation. + +
+ + + +
+ +## Usage + +```javascript +var dlartg = require( '@stdlib/lapack/base/dlartg' ); +``` + +#### dlartg( F, G, C, S, R ) + +Constructs a Givens rotation of a two-dimensional vector that zeros out the second component. For a two-dimensional vector `( F, G )` it computes the sine `S`, cosine `C` and the resultant `R`. + +```javascript +var Float64Array = require( '@stdlib/array/float64' ); + +var F = new Float64Array( [ 3.0 ] ); +var G = new Float64Array( [ 4.0 ] ); +var C = new Float64Array( 1 ); +var S = new Float64Array( 1 ); +var R = new Float64Array( 1 ); + +dlartg( F, G, C, S, R ); +// R => [ 5.0 ] +// C => [ 0.6 ] +// S => [ 0.8 ] +``` + +The function has the following parameters: + +- **F**: single element array representing the first component of the vector to be rotated as a [`Float64Array`][mdn-float64array]. +- **G**: single element array representing the second component of the vector to be rotated as a [`Float64Array`][mdn-float64array]. +- **C**: single element array overwritten by the cosine of the rotation as a [`Float64Array`][mdn-float64array]. +- **S**: single element array overwritten by the sine of the rotation as a [`Float64Array`][mdn-float64array]. +- **R**: single element array overwritten by the length of the rotated vector as a [`Float64Array`][mdn-float64array]. + +Note that indexing is relative to the first index. To introduce an offset, use [`typed array`][mdn-typed-array] views. + + + +```javascript +var Float64Array = require( '@stdlib/array/float64' ); + +// Initial arrays... +var F0 = new Float64Array( [ 0.0, 3.0 ] ); +var G0 = new Float64Array( [ 0.0, 4.0 ] ); +var C0 = new Float64Array( [ 0.0, 0.0 ] ); +var S0 = new Float64Array( [ 0.0, 0.0 ] ); +var R0 = new Float64Array( [ 0.0, 0.0 ] ); + +// Create offset views... +var F1 = new Float64Array( F0.buffer, F0.BYTES_PER_ELEMENT*1 ); // start at 2nd element +var G1 = new Float64Array( G0.buffer, G0.BYTES_PER_ELEMENT*1 ); // start at 2nd element +var C1 = new Float64Array( C0.buffer, C0.BYTES_PER_ELEMENT*1 ); // start at 2nd element +var S1 = new Float64Array( S0.buffer, S0.BYTES_PER_ELEMENT*1 ); // start at 2nd element +var R1 = new Float64Array( R0.buffer, R0.BYTES_PER_ELEMENT*1 ); // start at 2nd element + +dlartg( F1, G1, C1, S1, R1 ); +// R0 => [ 0.0, 5.0 ] +// C0 => [ 0.0, 0.6 ] +// S0 => [ 0.0, 0.8 ] +``` + +#### dlartg.ndarray( F, offsetF, G, offsetG, C, offsetC, S, offsetS, R, offsetR ) + +Constructs a Givens rotation of a two-dimensional vector that zeros out the second component, using alternative indexing semantics. For a two-dimensional vector `( F, G )` it computes the sine `S`, cosine `C` and the resultant `R`. + +```javascript +var Float64Array = require( '@stdlib/array/float64' ); + +var F = new Float64Array( [ 3.0 ] ); +var G = new Float64Array( [ 4.0 ] ); +var C = new Float64Array( 1 ); +var S = new Float64Array( 1 ); +var R = new Float64Array( 1 ); + +dlartg.ndarray( F, 0, G, 0, C, 0, S, 0, R, 0 ); +// R => [ 5.0 ] +// C => [ 0.6 ] +// S => [ 0.8 ] +``` + +The function has the following parameters: + +- **F**: single element array representing the first component of the vector to be rotated as a [`Float64Array`][mdn-float64array]. +- **offsetF**: starting index for `F`. +- **G**: single element array representing the second component of the vector to be rotated as a [`Float64Array`][mdn-float64array]. +- **offsetG**: starting index for `G`. +- **C**: single element array overwritten by the cosine of the rotation as a [`Float64Array`][mdn-float64array]. +- **offsetC**: starting index for `C`. +- **S**: single element array overwritten by the sine of the rotation as a [`Float64Array`][mdn-float64array]. +- **offsetS**: starting index for `S`. +- **R**: single element array overwritten by the length of the rotated vector as a [`Float64Array`][mdn-float64array]. +- **offsetR**: starting index for `R`. + +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, + + + +```javascript +var Float64Array = require( '@stdlib/array/float64' ); + +var F = new Float64Array( [ 0.0, 3.0 ] ); +var G = new Float64Array( [ 0.0, 4.0 ] ); +var C = new Float64Array( 2 ); +var S = new Float64Array( 2 ); +var R = new Float64Array( 2 ); + +dlartg.ndarray( F, 1, G, 1, C, 1, S, 1, R, 1 ); +// R => [ 0.0, 5.0 ] +// C => [ 0.0, 0.6 ] +// S => [ 0.0, 0.8 ] +``` + +
+ + + +
+ +## Notes + +- `dlartg()` corresponds to the [LAPACK][LAPACK] function [`dlartg`][lapack-dlartg]. + +
+ + + +
+ +## Examples + + + +```javascript +var Float64Array = require( '@stdlib/array/float64' ); +var uniform = require( '@stdlib/random/array/uniform' ); +var dlartg = require( '@stdlib/lapack/base/dlartg' ); + +var F = uniform( 1, -10.0, 10.0 ); +var G = uniform( 1, -10.0, 10.0 ); +var C = new Float64Array( 1 ); +var S = new Float64Array( 1 ); +var R = new Float64Array( 1 ); + +dlartg( F, G, C, S, R ); + +console.log( C ); +console.log( S ); +console.log( R ); +``` + +
+ + + + + +* * * + +
+ +## C APIs + + + +
+ +
+ + + + + +
+ +### Usage + +```c +TODO +``` + +#### TODO + +TODO. + +```c +TODO +``` + +TODO + +```c +TODO +``` + +
+ + + + + +
+ +
+ + + + + +
+ +### Examples + +```c +TODO +``` + +
+ + + +
+ + + + + +
+ +
+ + + + + +
+ +[lapack]: https://www.netlib.org/lapack/explore-html/ + +[lapack-dlartg]: https://netlib.org/lapack/explore-html/da/dd3/group__lartg_ga86f8f877eaea0386cdc2c3c175d9ea88.html#ga86f8f877eaea0386cdc2c3c175d9ea88 + +[mdn-float64array]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Float64Array + +[mdn-typed-array]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray + +
+ + diff --git a/lib/node_modules/@stdlib/lapack/base/dlartg/benchmark/benchmark.js b/lib/node_modules/@stdlib/lapack/base/dlartg/benchmark/benchmark.js new file mode 100644 index 000000000000..91544fa03eb7 --- /dev/null +++ b/lib/node_modules/@stdlib/lapack/base/dlartg/benchmark/benchmark.js @@ -0,0 +1,67 @@ +/** +* @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 discreteUniform = require( '@stdlib/random/array/discrete-uniform' ); +var Float64Array = require( '@stdlib/array/float64' ); +var isnan = require( '@stdlib/math/base/assert/is-nan' ); +var pkg = require( './../package.json' ).name; +var dlartg = require( './../lib/dlartg.js' ); + + +// VARIABLES // + +var opts = { + 'dtype': 'float64' +}; + + +// MAIN // + +bench( pkg, function benchmark( b ) { + var C; + var S; + var R; + var F; + var G; + var i; + + F = discreteUniform( 1, -50, 50, opts ); + G = discreteUniform( 1, -50, 50, opts ); + C = new Float64Array( 1 ); + S = new Float64Array( 1 ); + R = new Float64Array( 1 ); + + b.tic(); + for ( i = 0; i < b.iterations; i++ ) { + dlartg( F, G, C, S, R ); + if ( isnan( C[ 0 ] ) ) { + b.fail( 'should not return NaN' ); + } + } + b.toc(); + if ( isnan( S[ 0 ] ) ) { + b.fail( 'should not return NaN' ); + } + b.pass( 'benchmark finished' ); + b.end(); +}); diff --git a/lib/node_modules/@stdlib/lapack/base/dlartg/benchmark/benchmark.ndarray.js b/lib/node_modules/@stdlib/lapack/base/dlartg/benchmark/benchmark.ndarray.js new file mode 100644 index 000000000000..dbd7ec3bcada --- /dev/null +++ b/lib/node_modules/@stdlib/lapack/base/dlartg/benchmark/benchmark.ndarray.js @@ -0,0 +1,67 @@ +/** +* @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 discreteUniform = require( '@stdlib/random/array/discrete-uniform' ); +var Float64Array = require( '@stdlib/array/float64' ); +var isnan = require( '@stdlib/math/base/assert/is-nan' ); +var pkg = require( './../package.json' ).name; +var dlartg = require( './../lib/ndarray.js' ); + + +// VARIABLES // + +var opts = { + 'dtype': 'float64' +}; + + +// MAIN // + +bench( pkg, function benchmark( b ) { + var C; + var S; + var R; + var F; + var G; + var i; + + F = discreteUniform( 1, -50, 50, opts ); + G = discreteUniform( 1, -50, 50, opts ); + C = new Float64Array( 1 ); + S = new Float64Array( 1 ); + R = new Float64Array( 1 ); + + b.tic(); + for ( i = 0; i < b.iterations; i++ ) { + dlartg( F, 0, G, 0, C, 0, S, 0, R, 0 ); + if ( isnan( C[ 0 ] ) ) { + b.fail( 'should not return NaN' ); + } + } + b.toc(); + if ( isnan( S[ 0 ] ) ) { + b.fail( 'should not return NaN' ); + } + b.pass( 'benchmark finished' ); + b.end(); +}); diff --git a/lib/node_modules/@stdlib/lapack/base/dlartg/docs/repl.txt b/lib/node_modules/@stdlib/lapack/base/dlartg/docs/repl.txt new file mode 100644 index 000000000000..9f5806827422 --- /dev/null +++ b/lib/node_modules/@stdlib/lapack/base/dlartg/docs/repl.txt @@ -0,0 +1,114 @@ + +{{alias}}( F, G, C, S, R ) + Constructs a Givens rotation of a two-dimensional vector that zeros out the + second component. + + For a two-dimensional vector `( F, G )` it computes the sine `S`, cosine `C` + and the resultant `R`. + + Indexing is relative to the first index. To introduce an offset, use typed + array views. + + Parameters + ---------- + F: Float64Array + First component of the vector to be rotated. + + G: Float64Array + Second component of the vector to be rotated. + + C: Float64Array + Overwritten by the cosine of the rotation. + + S: Float64Array + Overwritten by the sine of the rotation. + + R: Float64Array + Overwritten by the length of the rotated vector. + + Returns + ------- + undefined + Overwrites the arrays in place. + + Examples + -------- + > var F = new {{alias:@stdlib/array/float64}}( [ 3.0 ] ); + > var G = new {{alias:@stdlib/array/float64}}( [ 4.0 ] ); + > var C = new {{alias:@stdlib/array/float64}}( 1 ); + > var S = new {{alias:@stdlib/array/float64}}( 1 ); + > var R = new {{alias:@stdlib/array/float64}}( 1 ); + > {{alias}}( F, G, C, S, R ); + > R + [ 5.0 ] + > C + [ 0.6 ] + > S + [ 0.8 ] + + +{{alias}}.ndarray( F, offsetF, G, offsetG, C, offsetC, S, offsetS, R, offsetR ) + Constructs a Givens rotation of a two-dimensional vector that zeros out the + second component, using alternative indexing semantics. + + For a two-dimensional vector `( F, G )` it computes the sine `S`, cosine `C` + and the resultant `R`. + + While typed array views mandate a view offset based on the underlying + buffer, the offset parameters support indexing semantics based on starting + indices. + + Parameters + ---------- + F: Float64Array + First component of the vector to be rotated. + + offsetF: integer + Starting index for `F`. + + G: Float64Array + Second component of the vector to be rotated. + + offsetG: integer + Starting index for `G`. + + C: Float64Array + Overwritten by the cosine of the rotation. + + offsetC: integer + Starting index for `C`. + + S: Float64Array + Overwritten by the sine of the rotation. + + offsetS: integer + Starting index for `S`. + + R: Float64Array + Overwritten by the length of the rotated vector. + + offsetR: integer + Starting index for `R`. + + Returns + ------- + undefined + Overwrites the arrays in place. + + Examples + -------- + > var F = new {{alias:@stdlib/array/float64}}( [ 0.0, 3.0 ] ); + > var G = new {{alias:@stdlib/array/float64}}( [ 0.0, 4.0 ] ); + > var C = new {{alias:@stdlib/array/float64}}( 2 ); + > var S = new {{alias:@stdlib/array/float64}}( 2 ); + > var R = new {{alias:@stdlib/array/float64}}( 2 ); + > {{alias}}.ndarray( F, 1, G, 1, C, 1, S, 1, R, 1 ); + > R + [ 0.0, 5.0 ] + > C + [ 0.0, 0.6 ] + > S + [ 0.0, 0.8 ] + + See Also + -------- diff --git a/lib/node_modules/@stdlib/lapack/base/dlartg/docs/types/index.d.ts b/lib/node_modules/@stdlib/lapack/base/dlartg/docs/types/index.d.ts new file mode 100644 index 000000000000..09762a82e955 --- /dev/null +++ b/lib/node_modules/@stdlib/lapack/base/dlartg/docs/types/index.d.ts @@ -0,0 +1,144 @@ +/* +* @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 + +/** +* Interface describing `dlartg`. +*/ +interface Routine { + /** + * Constructs a Givens rotation of a two-dimensional vector that zeros out the second component. + * + * For a two-dimensional vector ( f, g ) it computes the sine `S`, cosine `C` and the resultant `R` such that the following equation is satisfied: + * + * ```tex + * \(\begin{bmatrix} C & S \\ -S & C \end{bmatrix} \begin{bmatrix} F \\ G \end{bmatrix} = \begin{bmatrix} R \\ 0 \end{bmatrix}\) + * ``` + * + * @param F - single element array representing the first component of the vector to be rotated + * @param G - single element array representing the second component of the vector to be rotated + * @param C - single element array overwritten by the cosine of the rotation + * @param S - single element array overwritten by the sine of the rotation + * @param R - single element array overwritten by the length of the rotated vector + * @returns {void} + * + * @example + * var Float64Array = require( '@stdlib/array/float64' ); + * + * var F = new Float64Array( [ 3.0 ] ); + * var G = new Float64Array( [ 4.0 ] ); + * var C = new Float64Array( 1 ); + * var S = new Float64Array( 1 ); + * var R = new Float64Array( 1 ); + * + * dlartg( F, G, C, S, R ); + * // R => [ 5.0 ] + * // C => [ 0.6 ] + * // S => [ 0.8 ] + */ + ( F: Float64Array, G: Float64Array, C: Float64Array, S: Float64Array, R: Float64Array ): void; + + /** + * Constructs a Givens rotation of a two-dimensional vector that zeros out the second component. + * + * For a two-dimensional vector ( f, g ) it computes the sine `S`, cosine `C` and the resultant `R` such that the following equation is satisfied: + * + * ```tex + * \(\begin{bmatrix} C & S \\ -S & C \end{bmatrix} \begin{bmatrix} F \\ G \end{bmatrix} = \begin{bmatrix} R \\ 0 \end{bmatrix}\) + * ``` + * + * @param F - single element array representing the first component of the vector to be rotated + * @param offsetF - starting index for `F` + * @param G - single element array representing the second component of the vector to be rotated + * @param offsetG - starting index for `G` + * @param C - single element array overwritten by the cosine of the rotation + * @param offsetC - starting index for `C` + * @param S - single element array overwritten by the sine of the rotation + * @param offsetS - starting index for `S` + * @param R - single element array overwritten by the length of the rotated vector + * @param offsetR - starting index for `R` + * @returns {void} + * + * @example + * var Float64Array = require( '@stdlib/array/float64' ); + * + * var F = new Float64Array( [ 3.0 ] ); + * var G = new Float64Array( [ 4.0 ] ); + * var C = new Float64Array( 1 ); + * var S = new Float64Array( 1 ); + * var R = new Float64Array( 1 ); + * + * dlartg.ndarray( F, 0, G, 0, C, 0, S, 0, R, 0 ); + * // R => [ 5.0 ] + * // C => [ 0.6 ] + * // S => [ 0.8 ] + */ + ndarray( F: Float64Array, offsetF: number, G: Float64Array, offsetG: number, C: Float64Array, offsetC: number, S: Float64Array, offsetS: number, R: Float64Array, offsetR: number ): void; +} + +/** +* Constructs a Givens rotation of a two-dimensional vector that zeros out the second component. +* +* For a two-dimensional vector ( f, g ) it computes the sine `S`, cosine `C` and the resultant `R` such that the following equation is satisfied: +* +* ```tex +* \(\begin{bmatrix} C & S \\ -S & C \end{bmatrix} \begin{bmatrix} F \\ G \end{bmatrix} = \begin{bmatrix} R \\ 0 \end{bmatrix}\) +* ``` +* +* @param F - single element array representing the first component of the vector to be rotated +* @param G - single element array representing the second component of the vector to be rotated +* @param C - single element array overwritten by the cosine of the rotation +* @param S - single element array overwritten by the sine of the rotation +* @param R - single element array overwritten by the length of the rotated vector +* @returns {void} +* +* @example +* var Float64Array = require( '@stdlib/array/float64' ); +* +* var F = new Float64Array( [ 3.0 ] ); +* var G = new Float64Array( [ 4.0 ] ); +* var C = new Float64Array( 1 ); +* var S = new Float64Array( 1 ); +* var R = new Float64Array( 1 ); +* +* dlartg( F, G, C, S, R ); +* // R => [ 5.0 ] +* // C => [ 0.6 ] +* // S => [ 0.8 ] +* +* @example +* var Float64Array = require( '@stdlib/array/float64' ); +* +* var F = new Float64Array( [ 3.0 ] ); +* var G = new Float64Array( [ 4.0 ] ); +* var C = new Float64Array( 1 ); +* var S = new Float64Array( 1 ); +* var R = new Float64Array( 1 ); +* +* dlartg.ndarray( F, 0, G, 0, C, 0, S, 0, R, 0 ); +* // R => [ 5.0 ] +* // C => [ 0.6 ] +* // S => [ 0.8 ] +*/ +declare var dlartg: Routine; + + +// EXPORTS // + +export = dlartg; diff --git a/lib/node_modules/@stdlib/lapack/base/dlartg/docs/types/test.ts b/lib/node_modules/@stdlib/lapack/base/dlartg/docs/types/test.ts new file mode 100644 index 000000000000..99b7511aaa75 --- /dev/null +++ b/lib/node_modules/@stdlib/lapack/base/dlartg/docs/types/test.ts @@ -0,0 +1,351 @@ +/* +* @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 dlartg = require( './index' ); + + +// TESTS // + +// The function returns void... +{ + const F = new Float64Array( 1 ); + const G = new Float64Array( 1 ); + const C = new Float64Array( 1 ); + const S = new Float64Array( 1 ); + const R = new Float64Array( 1 ); + + dlartg( F, G, C, S, R ); // $ExpectType void +} + +// The compiler throws an error if the function is provided a first argument which is not a Float64Array... +{ + const G = new Float64Array( 1 ); + const C = new Float64Array( 1 ); + const S = new Float64Array( 1 ); + const R = new Float64Array( 1 ); + + dlartg( '5', G, C, S, R ); // $ExpectError + dlartg( 5, G, C, S, R ); // $ExpectError + dlartg( true, G, C, S, R ); // $ExpectError + dlartg( false, G, C, S, R ); // $ExpectError + dlartg( null, G, C, S, R ); // $ExpectError + dlartg( void 0, G, C, S, R ); // $ExpectError + dlartg( [], G, C, S, R ); // $ExpectError + dlartg( {}, G, C, S, R ); // $ExpectError + dlartg( ( x: number ): number => x, G, C, S, R ); // $ExpectError +} + +// The compiler throws an error if the function is provided a second argument which is not a Float64Array... +{ + const F = new Float64Array( 1 ); + const C = new Float64Array( 1 ); + const S = new Float64Array( 1 ); + const R = new Float64Array( 1 ); + + dlartg( F, '5', C, S, R ); // $ExpectError + dlartg( F, 5, C, S, R ); // $ExpectError + dlartg( F, true, C, S, R ); // $ExpectError + dlartg( F, false, C, S, R ); // $ExpectError + dlartg( F, null, C, S, R ); // $ExpectError + dlartg( F, void 0, C, S, R ); // $ExpectError + dlartg( F, [], C, S, R ); // $ExpectError + dlartg( F, {}, C, S, R ); // $ExpectError + dlartg( F, ( x: number ): number => x, C, S, R ); // $ExpectError +} + +// The compiler throws an error if the function is provided a third argument which is not a Float64Array... +{ + const F = new Float64Array( 1 ); + const G = new Float64Array( 1 ); + const S = new Float64Array( 1 ); + const R = new Float64Array( 1 ); + + dlartg( F, G, '5', S, R ); // $ExpectError + dlartg( F, G, 5, S, R ); // $ExpectError + dlartg( F, G, true, S, R ); // $ExpectError + dlartg( F, G, false, S, R ); // $ExpectError + dlartg( F, G, null, S, R ); // $ExpectError + dlartg( F, G, void 0, S, R ); // $ExpectError + dlartg( F, G, [], S, R ); // $ExpectError + dlartg( F, G, {}, S, R ); // $ExpectError + dlartg( F, G, ( x: number ): number => x, S, R ); // $ExpectError +} + +// The compiler throws an error if the function is provided a fourth argument which is not a Float64Array... +{ + const F = new Float64Array( 1 ); + const G = new Float64Array( 1 ); + const C = new Float64Array( 1 ); + const R = new Float64Array( 1 ); + + dlartg( F, G, C, '5', R ); // $ExpectError + dlartg( F, G, C, 5, R ); // $ExpectError + dlartg( F, G, C, true, R ); // $ExpectError + dlartg( F, G, C, false, R ); // $ExpectError + dlartg( F, G, C, null, R ); // $ExpectError + dlartg( F, G, C, void 0, R ); // $ExpectError + dlartg( F, G, C, [], R ); // $ExpectError + dlartg( F, G, C, {}, R ); // $ExpectError + dlartg( F, G, C, ( x: number ): number => x, R ); // $ExpectError +} + +// The compiler throws an error if the function is provided a fifth argument which is not a Float64Array... +{ + const F = new Float64Array( 1 ); + const G = new Float64Array( 1 ); + const C = new Float64Array( 1 ); + const S = new Float64Array( 1 ); + + dlartg( F, G, C, S, '5' ); // $ExpectError + dlartg( F, G, C, S, 5 ); // $ExpectError + dlartg( F, G, C, S, true ); // $ExpectError + dlartg( F, G, C, S, false ); // $ExpectError + dlartg( F, G, C, S, null ); // $ExpectError + dlartg( F, G, C, S, void 0 ); // $ExpectError + dlartg( F, G, C, S, [] ); // $ExpectError + dlartg( F, G, C, S, {} ); // $ExpectError + dlartg( F, G, C, S, ( x: number ): number => x ); // $ExpectError +} + +// The compiler throws an error if the function is provided an unsupported number of arguments... +{ + const F = new Float64Array( 1 ); + const G = new Float64Array( 1 ); + const C = new Float64Array( 1 ); + const S = new Float64Array( 1 ); + const R = new Float64Array( 1 ); + + dlartg(); // $ExpectError + dlartg( F ); // $ExpectError + dlartg( F, G ); // $ExpectError + dlartg( F, G, C ); // $ExpectError + dlartg( F, G, C, S ); // $ExpectError + dlartg( F, G, C, S, R, 10 ); // $ExpectError +} + +// Attached to main export is an `ndarray` method which returns void... +{ + const F = new Float64Array( 1 ); + const G = new Float64Array( 1 ); + const C = new Float64Array( 1 ); + const S = new Float64Array( 1 ); + const R = new Float64Array( 1 ); + + dlartg.ndarray( F, 0, G, 0, C, 0, S, 0, R, 0 ); // $ExpectType void +} + +// The compiler throws an error if the `ndarray` method is provided a first argument which is not a Float64Array... +{ + const G = new Float64Array( 1 ); + const C = new Float64Array( 1 ); + const S = new Float64Array( 1 ); + const R = new Float64Array( 1 ); + + dlartg.ndarray( '5', 0, G, 0, C, 0, S, 0, R, 0 ); // $ExpectError + dlartg.ndarray( 5, 0, G, 0, C, 0, S, 0, R, 0 ); // $ExpectError + dlartg.ndarray( true, 0, G, 0, C, 0, S, 0, R, 0 ); // $ExpectError + dlartg.ndarray( false, 0, G, 0, C, 0, S, 0, R, 0 ); // $ExpectError + dlartg.ndarray( null, 0, G, 0, C, 0, S, 0, R, 0 ); // $ExpectError + dlartg.ndarray( void 0, 0, G, 0, C, 0, S, 0, R, 0 ); // $ExpectError + dlartg.ndarray( [], 0, G, 0, C, 0, S, 0, R, 0 ); // $ExpectError + dlartg.ndarray( {}, 0, G, 0, C, 0, S, 0, R, 0 ); // $ExpectError + dlartg.ndarray( ( x: number ): number => x, 0, G, 0, C, 0, S, 0, R, 0 ); // $ExpectError +} + +// The compiler throws an error if the `ndarray` method is provided a second argument which is not a number... +{ + const F = new Float64Array( 1 ); + const G = new Float64Array( 1 ); + const C = new Float64Array( 1 ); + const S = new Float64Array( 1 ); + const R = new Float64Array( 1 ); + + dlartg.ndarray( F, '5', G, 0, C, 0, S, 0, R, 0 ); // $ExpectError + dlartg.ndarray( F, true, G, 0, C, 0, S, 0, R, 0 ); // $ExpectError + dlartg.ndarray( F, false, G, 0, C, 0, S, 0, R, 0 ); // $ExpectError + dlartg.ndarray( F, null, G, 0, C, 0, S, 0, R, 0 ); // $ExpectError + dlartg.ndarray( F, void 0, G, 0, C, 0, S, 0, R, 0 ); // $ExpectError + dlartg.ndarray( F, [], G, 0, C, 0, S, 0, R, 0 ); // $ExpectError + dlartg.ndarray( F, {}, G, 0, C, 0, S, 0, R, 0 ); // $ExpectError + dlartg.ndarray( F, ( x: number ): number => x, G, 0, C, 0, S, 0, R, 0 ); // $ExpectError +} + +// The compiler throws an error if the `ndarray` method is provided a third argument which is not a Float64Array... +{ + const F = new Float64Array( 1 ); + const C = new Float64Array( 1 ); + const S = new Float64Array( 1 ); + const R = new Float64Array( 1 ); + + dlartg.ndarray( F, 0, '5', 0, C, 0, S, 0, R, 0 ); // $ExpectError + dlartg.ndarray( F, 0, 5, 0, C, 0, S, 0, R, 0 ); // $ExpectError + dlartg.ndarray( F, 0, true, 0, C, 0, S, 0, R, 0 ); // $ExpectError + dlartg.ndarray( F, 0, false, 0, C, 0, S, 0, R, 0 ); // $ExpectError + dlartg.ndarray( F, 0, null, 0, C, 0, S, 0, R, 0 ); // $ExpectError + dlartg.ndarray( F, 0, void 0, 0, C, 0, S, 0, R, 0 ); // $ExpectError + dlartg.ndarray( F, 0, [], 0, C, 0, S, 0, R, 0 ); // $ExpectError + dlartg.ndarray( F, 0, {}, 0, C, 0, S, 0, R, 0 ); // $ExpectError + dlartg.ndarray( F, 0, ( x: number ): number => x, 0, C, 0, S, 0, R, 0 ); // $ExpectError +} + +// The compiler throws an error if the `ndarray` method is provided a fourth argument which is not a number... +{ + const F = new Float64Array( 1 ); + const G = new Float64Array( 1 ); + const C = new Float64Array( 1 ); + const S = new Float64Array( 1 ); + const R = new Float64Array( 1 ); + + dlartg.ndarray( F, 0, G, '5', C, 0, S, 0, R, 0 ); // $ExpectError + dlartg.ndarray( F, 0, G, true, C, 0, S, 0, R, 0 ); // $ExpectError + dlartg.ndarray( F, 0, G, false, C, 0, S, 0, R, 0 ); // $ExpectError + dlartg.ndarray( F, 0, G, null, C, 0, S, 0, R, 0 ); // $ExpectError + dlartg.ndarray( F, 0, G, void 0, C, 0, S, 0, R, 0 ); // $ExpectError + dlartg.ndarray( F, 0, G, [], C, 0, S, 0, R, 0 ); // $ExpectError + dlartg.ndarray( F, 0, G, {}, C, 0, S, 0, R, 0 ); // $ExpectError + dlartg.ndarray( F, 0, G, ( x: number ): number => x, C, 0, S, 0, R, 0 ); // $ExpectError +} + +// The compiler throws an error if the `ndarray` method is provided a fifth argument which is not a Float64Array... +{ + const F = new Float64Array( 1 ); + const G = new Float64Array( 1 ); + const S = new Float64Array( 1 ); + const R = new Float64Array( 1 ); + + dlartg.ndarray( F, 0, G, 0, '5', 0, S, 0, R, 0 ); // $ExpectError + dlartg.ndarray( F, 0, G, 0, 5, 0, S, 0, R, 0 ); // $ExpectError + dlartg.ndarray( F, 0, G, 0, true, 0, S, 0, R, 0 ); // $ExpectError + dlartg.ndarray( F, 0, G, 0, false, 0, S, 0, R, 0 ); // $ExpectError + dlartg.ndarray( F, 0, G, 0, null, 0, S, 0, R, 0 ); // $ExpectError + dlartg.ndarray( F, 0, G, 0, void 0, 0, S, 0, R, 0 ); // $ExpectError + dlartg.ndarray( F, 0, G, 0, [], 0, S, 0, R, 0 ); // $ExpectError + dlartg.ndarray( F, 0, G, 0, {}, 0, S, 0, R, 0 ); // $ExpectError + dlartg.ndarray( F, 0, G, 0, ( x: number ): number => x, 0, S, 0, R, 0 ); // $ExpectError +} + +// The compiler throws an error if the `ndarray` method is provided a sixth argument which is not a number... +{ + const F = new Float64Array( 1 ); + const G = new Float64Array( 1 ); + const C = new Float64Array( 1 ); + const S = new Float64Array( 1 ); + const R = new Float64Array( 1 ); + + dlartg.ndarray( F, 0, G, 0, C, '5', S, 0, R, 0 ); // $ExpectError + dlartg.ndarray( F, 0, G, 0, C, true, S, 0, R, 0 ); // $ExpectError + dlartg.ndarray( F, 0, G, 0, C, false, S, 0, R, 0 ); // $ExpectError + dlartg.ndarray( F, 0, G, 0, C, null, S, 0, R, 0 ); // $ExpectError + dlartg.ndarray( F, 0, G, 0, C, void 0, S, 0, R, 0 ); // $ExpectError + dlartg.ndarray( F, 0, G, 0, C, [], S, 0, R, 0 ); // $ExpectError + dlartg.ndarray( F, 0, G, 0, C, {}, S, 0, R, 0 ); // $ExpectError + dlartg.ndarray( F, 0, G, 0, C, ( x: number ): number => x, S, 0, R, 0 ); // $ExpectError +} + +// The compiler throws an error if the `ndarray` method is provided a seventh argument which is not a Float64Array... +{ + const F = new Float64Array( 1 ); + const G = new Float64Array( 1 ); + const C = new Float64Array( 1 ); + const R = new Float64Array( 1 ); + + dlartg.ndarray( F, 0, G, 0, C, 0, '5', 0, R, 0 ); // $ExpectError + dlartg.ndarray( F, 0, G, 0, C, 0, 5, 0, R, 0 ); // $ExpectError + dlartg.ndarray( F, 0, G, 0, C, 0, true, 0, R, 0 ); // $ExpectError + dlartg.ndarray( F, 0, G, 0, C, 0, false, 0, R, 0 ); // $ExpectError + dlartg.ndarray( F, 0, G, 0, C, 0, null, 0, R, 0 ); // $ExpectError + dlartg.ndarray( F, 0, G, 0, C, 0, void 0, 0, R, 0 ); // $ExpectError + dlartg.ndarray( F, 0, G, 0, C, 0, [], 0, R, 0 ); // $ExpectError + dlartg.ndarray( F, 0, G, 0, C, 0, {}, 0, R, 0 ); // $ExpectError + dlartg.ndarray( F, 0, G, 0, C, 0, ( x: number ): number => x, 0, R, 0 ); // $ExpectError +} + +// The compiler throws an error if the `ndarray` method is provided an eighth argument which is not a number... +{ + const F = new Float64Array( 1 ); + const G = new Float64Array( 1 ); + const C = new Float64Array( 1 ); + const S = new Float64Array( 1 ); + const R = new Float64Array( 1 ); + + dlartg.ndarray( F, 0, G, 0, C, 0, S, '5', R, 0 ); // $ExpectError + dlartg.ndarray( F, 0, G, 0, C, 0, S, true, R, 0 ); // $ExpectError + dlartg.ndarray( F, 0, G, 0, C, 0, S, false, R, 0 ); // $ExpectError + dlartg.ndarray( F, 0, G, 0, C, 0, S, null, R, 0 ); // $ExpectError + dlartg.ndarray( F, 0, G, 0, C, 0, S, void 0, R, 0 ); // $ExpectError + dlartg.ndarray( F, 0, G, 0, C, 0, S, [], R, 0 ); // $ExpectError + dlartg.ndarray( F, 0, G, 0, C, 0, S, {}, R, 0 ); // $ExpectError + dlartg.ndarray( F, 0, G, 0, C, 0, S, ( x: number ): number => x, R, 0 ); // $ExpectError +} + +// The compiler throws an error if the `ndarray` method is provided a ninth argument which is not a Float64Array... +{ + const F = new Float64Array( 1 ); + const G = new Float64Array( 1 ); + const C = new Float64Array( 1 ); + const S = new Float64Array( 1 ); + + dlartg.ndarray( F, 0, G, 0, C, 0, S, 0, '5', 0 ); // $ExpectError + dlartg.ndarray( F, 0, G, 0, C, 0, S, 0, 5, 0 ); // $ExpectError + dlartg.ndarray( F, 0, G, 0, C, 0, S, 0, true, 0 ); // $ExpectError + dlartg.ndarray( F, 0, G, 0, C, 0, S, 0, false, 0 ); // $ExpectError + dlartg.ndarray( F, 0, G, 0, C, 0, S, 0, null, 0 ); // $ExpectError + dlartg.ndarray( F, 0, G, 0, C, 0, S, 0, void 0, 0 ); // $ExpectError + dlartg.ndarray( F, 0, G, 0, C, 0, S, 0, [], 0 ); // $ExpectError + dlartg.ndarray( F, 0, G, 0, C, 0, S, 0, {}, 0 ); // $ExpectError + dlartg.ndarray( F, 0, G, 0, C, 0, S, 0, ( x: number ): number => x, 0 ); // $ExpectError +} + +// The compiler throws an error if the `ndarray` method is provided a tenth argument which is not a number... +{ + const F = new Float64Array( 1 ); + const G = new Float64Array( 1 ); + const C = new Float64Array( 1 ); + const S = new Float64Array( 1 ); + const R = new Float64Array( 1 ); + + dlartg.ndarray( F, 0, G, 0, C, 0, S, 0, R, '5' ); // $ExpectError + dlartg.ndarray( F, 0, G, 0, C, 0, S, 0, R, true ); // $ExpectError + dlartg.ndarray( F, 0, G, 0, C, 0, S, 0, R, false ); // $ExpectError + dlartg.ndarray( F, 0, G, 0, C, 0, S, 0, R, null ); // $ExpectError + dlartg.ndarray( F, 0, G, 0, C, 0, S, 0, R, void 0 ); // $ExpectError + dlartg.ndarray( F, 0, G, 0, C, 0, S, 0, R, [] ); // $ExpectError + dlartg.ndarray( F, 0, G, 0, C, 0, S, 0, R, {} ); // $ExpectError + dlartg.ndarray( F, 0, G, 0, C, 0, S, 0, R, ( x: number ): number => x ); // $ExpectError +} + +// The compiler throws an error if the `ndarray` method is provided an unsupported number of arguments... +{ + const F = new Float64Array( 1 ); + const G = new Float64Array( 1 ); + const C = new Float64Array( 1 ); + const S = new Float64Array( 1 ); + const R = new Float64Array( 1 ); + + dlartg.ndarray(); // $ExpectError + dlartg.ndarray( F ); // $ExpectError + dlartg.ndarray( F, 0 ); // $ExpectError + dlartg.ndarray( F, 0, G ); // $ExpectError + dlartg.ndarray( F, 0, G, 0 ); // $ExpectError + dlartg.ndarray( F, 0, G, 0, C ); // $ExpectError + dlartg.ndarray( F, 0, G, 0, C, 0 ); // $ExpectError + dlartg.ndarray( F, 0, G, 0, C, 0, S ); // $ExpectError + dlartg.ndarray( F, 0, G, 0, C, 0, S, 0 ); // $ExpectError + dlartg.ndarray( F, 0, G, 0, C, 0, S, 0, R ); // $ExpectError + dlartg.ndarray( F, 0, G, 0, C, 0, S, 0, R, 0, 10 ); // $ExpectError +} diff --git a/lib/node_modules/@stdlib/lapack/base/dlartg/examples/index.js b/lib/node_modules/@stdlib/lapack/base/dlartg/examples/index.js new file mode 100644 index 000000000000..ccc43a7529b1 --- /dev/null +++ b/lib/node_modules/@stdlib/lapack/base/dlartg/examples/index.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'; + +var Float64Array = require( '@stdlib/array/float64' ); +var uniform = require( '@stdlib/random/array/uniform' ); +var dlartg = require( './../lib' ); + +var F = uniform( 1, -10.0, 10.0 ); +var G = uniform( 1, -10.0, 10.0 ); +var C = new Float64Array( 1 ); +var S = new Float64Array( 1 ); +var R = new Float64Array( 1 ); + +dlartg( F, G, C, S, R ); + +console.log( C ); +console.log( S ); +console.log( R ); diff --git a/lib/node_modules/@stdlib/lapack/base/dlartg/lib/base.js b/lib/node_modules/@stdlib/lapack/base/dlartg/lib/base.js new file mode 100644 index 000000000000..1928af7020f0 --- /dev/null +++ b/lib/node_modules/@stdlib/lapack/base/dlartg/lib/base.js @@ -0,0 +1,116 @@ +/** +* @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 dlamch = require( '@stdlib/lapack/base/dlamch' ); +var sqrt = require( '@stdlib/math/base/special/sqrt' ); +var abs = require( '@stdlib/math/base/special/fast/abs' ); +var sign = require( '@stdlib/math/base/special/copysign' ); +var min = require( '@stdlib/math/base/special/fast/min' ); +var max = require( '@stdlib/math/base/special/maxn' ); + + +// VARIABLES // + +var safmin = dlamch( 'safe minimum' ); +var safmax = 1.0 / safmin; +var rtmin = sqrt( safmin ); +var rtmax = sqrt( safmax / 2.0 ); + + +// MAIN // + +/** +* Constructs a Givens rotation of a two-dimensional vector that zeros out the second component. +* +* For a two-dimensional vector ( f, g ) it computes the sine `S`, cosine `C` and the resultant `R` such that the following equation is satisfied: +* +* ```tex +* \(\begin{bmatrix} C & S \\ -S & C \end{bmatrix} \begin{bmatrix} F \\ G \end{bmatrix} = \begin{bmatrix} R \\ 0 \end{bmatrix}\) +* ``` +* +* @private +* @param {Float64Array} F - single element array representing the first component of the vector to be rotated +* @param {NonNegativeInteger} offsetF - starting index for `F` +* @param {Float64Array} G - single element array representing the second component of the vector to be rotated +* @param {NonNegativeInteger} offsetG - starting index for `G` +* @param {Float64Array} C - single element array overwritten by the cosine of the rotation +* @param {NonNegativeInteger} offsetC - starting index for `C` +* @param {Float64Array} S - single element array overwritten by the sine of the rotation +* @param {NonNegativeInteger} offsetS - starting index for `S` +* @param {Float64Array} R - single element array overwritten by the length of the rotated vector +* @param {NonNegativeInteger} offsetR - starting index for `R` +* @returns {void} +* +* @example +* var Float64Array = require( '@stdlib/array/float64' ); +* +* var F = new Float64Array( [ 3.0 ] ); +* var G = new Float64Array( [ 4.0 ] ); +* var C = new Float64Array( 1 ); +* var S = new Float64Array( 1 ); +* var R = new Float64Array( 1 ); +* +* dlartg( F, 0, G, 0, C, 0, S, 0, R, 0 ); +* // R => [ 5.0 ] +* // C => [ 0.6 ] +* // S => [ 0.8 ] +*/ +function dlartg( F, offsetF, G, offsetG, C, offsetC, S, offsetS, R, offsetR ) { + var f1; + var g1; + var fs; + var gs; + var u; + var d; + + f1 = abs( F[ offsetF ] ); + g1 = abs( G[ offsetG ] ); + + if ( G[ offsetG ] === 0.0 ) { + C[ offsetC ] = 1.0; + S[ offsetS ] = 0.0; + R[ offsetR ] = F[ offsetF ]; + } else if ( F[ offsetF ] === 0.0 ) { + C[ offsetC ] = 0.0; + S[ offsetS ] = sign( 1.0, G[ offsetG ] ); + R[ offsetR ] = g1; + } else if ( f1 > rtmin && f1 < rtmax && g1 > rtmin && g1 < rtmax ) { + d = sqrt( (F[ offsetF ]*F[ offsetF ]) + (G[ offsetG ]*G[ offsetG ]) ); + C[ offsetC ] = f1 / d; + R[ offsetR ] = sign( d, F[ offsetF ] ); + S[ offsetS ] = G[ offsetG ] / R[ offsetR ]; + } else { + u = min( safmax, max( safmin, f1, g1 ) ); + fs = F[ offsetF ] / u; + gs = G[ offsetG ] / u; + d = sqrt( (fs*fs) + (gs*gs) ); + C[ offsetC ] = abs( fs ) / d; + R[ offsetR ] = sign( d, F[ offsetF ] ); + S[ offsetS ] = gs / R[ offsetR ]; + R[ offsetR ] *= u; + } +} + + +// EXPORTS // + +module.exports = dlartg; diff --git a/lib/node_modules/@stdlib/lapack/base/dlartg/lib/dlartg.js b/lib/node_modules/@stdlib/lapack/base/dlartg/lib/dlartg.js new file mode 100644 index 000000000000..bc53d5be81e0 --- /dev/null +++ b/lib/node_modules/@stdlib/lapack/base/dlartg/lib/dlartg.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 base = require( './base.js' ); + + +// MAIN // + +/** +* Constructs a Givens rotation of a two-dimensional vector that zeros out the second component. +* +* For a two-dimensional vector ( f, g ) it computes the sine `S`, cosine `C` and the resultant `R` such that the following equation is satisfied: +* +* ```tex +* \(\begin{bmatrix} C & S \\ -S & C \end{bmatrix} \begin{bmatrix} F \\ G \end{bmatrix} = \begin{bmatrix} R \\ 0 \end{bmatrix}\) +* ``` +* +* @param {Float64Array} F - single element array representing the first component of the vector to be rotated +* @param {Float64Array} G - single element array representing the second component of the vector to be rotated +* @param {Float64Array} C - single element array overwritten by the cosine of the rotation +* @param {Float64Array} S - single element array overwritten by the sine of the rotation +* @param {Float64Array} R - single element array overwritten by the length of the rotated vector +* @returns {void} +* +* @example +* var Float64Array = require( '@stdlib/array/float64' ); +* +* var F = new Float64Array( [ 3.0 ] ); +* var G = new Float64Array( [ 4.0 ] ); +* var C = new Float64Array( 1 ); +* var S = new Float64Array( 1 ); +* var R = new Float64Array( 1 ); +* +* dlartg( F, G, C, S, R ); +* // R => [ 5.0 ] +* // C => [ 0.6 ] +* // S => [ 0.8 ] +*/ +function dlartg( F, G, C, S, R ) { + base( F, 0, G, 0, C, 0, S, 0, R, 0 ); +} + + +// EXPORTS // + +module.exports = dlartg; diff --git a/lib/node_modules/@stdlib/lapack/base/dlartg/lib/index.js b/lib/node_modules/@stdlib/lapack/base/dlartg/lib/index.js new file mode 100644 index 000000000000..be2716ede04b --- /dev/null +++ b/lib/node_modules/@stdlib/lapack/base/dlartg/lib/index.js @@ -0,0 +1,69 @@ +/** +* @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'; + +/** +* LAPACK routine to construct a Givens rotation of a two-dimensional vector that zeros out the second component. +* +* For a two-dimensional vector ( f, g ) it computes the sine `S`, cosine `C` and the resultant `R` such that the following equation is satisfied: +* +* ```tex +* \(\begin{bmatrix} C & S \\ -S & C \end{bmatrix} \begin{bmatrix} F \\ G \end{bmatrix} = \begin{bmatrix} R \\ 0 \end{bmatrix}\) +* ``` +* +* @module @stdlib/lapack/base/dlartg +* +* @example +* var Float64Array = require( '@stdlib/array/float64' ); +* var dlartg = require( '@stdlib/lapack/base/dlartg' ); +* +* var F = new Float64Array( [ 3.0 ] ); +* var G = new Float64Array( [ 4.0 ] ); +* var C = new Float64Array( 1 ); +* var S = new Float64Array( 1 ); +* var R = new Float64Array( 1 ); +* +* dlartg( F, G, C, S, R ); +* // R => [ 5.0 ] +* // C => [ 0.6 ] +* // S => [ 0.8 ] +*/ + +// 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 dlartg; +var tmp = tryRequire( join( __dirname, './native.js' ) ); +if ( isError( tmp ) ) { + dlartg = main; +} else { + dlartg = tmp; +} + + +// EXPORTS // + +module.exports = dlartg; diff --git a/lib/node_modules/@stdlib/lapack/base/dlartg/lib/main.js b/lib/node_modules/@stdlib/lapack/base/dlartg/lib/main.js new file mode 100644 index 000000000000..b82f04b67f15 --- /dev/null +++ b/lib/node_modules/@stdlib/lapack/base/dlartg/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 dlartg = require( './dlartg.js' ); +var ndarray = require( './ndarray.js' ); + + +// MAIN // + +setReadOnly( dlartg, 'ndarray', ndarray ); + + +// EXPORTS // + +module.exports = dlartg; diff --git a/lib/node_modules/@stdlib/lapack/base/dlartg/lib/ndarray.js b/lib/node_modules/@stdlib/lapack/base/dlartg/lib/ndarray.js new file mode 100644 index 000000000000..fe043f61900e --- /dev/null +++ b/lib/node_modules/@stdlib/lapack/base/dlartg/lib/ndarray.js @@ -0,0 +1,70 @@ +/** +* @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 base = require( './base.js' ); + + +// MAIN // + +/** +* Constructs a Givens rotation of a two-dimensional vector that zeros out the second component. +* +* For a two-dimensional vector ( f, g ) it computes the sine `S`, cosine `C` and the resultant `R` such that the following equation is satisfied: +* +* ```tex +* \(\begin{bmatrix} C & S \\ -S & C \end{bmatrix} \begin{bmatrix} F \\ G \end{bmatrix} = \begin{bmatrix} R \\ 0 \end{bmatrix}\) +* ``` +* +* @param {Float64Array} F - single element array representing the first component of the vector to be rotated +* @param {NonNegativeInteger} offsetF - starting index for `F` +* @param {Float64Array} G - single element array representing the second component of the vector to be rotated +* @param {NonNegativeInteger} offsetG - starting index for `G` +* @param {Float64Array} C - single element array overwritten by the cosine of the rotation +* @param {NonNegativeInteger} offsetC - starting index for `C` +* @param {Float64Array} S - single element array overwritten by the sine of the rotation +* @param {NonNegativeInteger} offsetS - starting index for `S` +* @param {Float64Array} R - single element array overwritten by the length of the rotated vector +* @param {NonNegativeInteger} offsetR - starting index for `R` +* @returns {void} +* +* @example +* var Float64Array = require( '@stdlib/array/float64' ); +* +* var F = new Float64Array( [ 3.0 ] ); +* var G = new Float64Array( [ 4.0 ] ); +* var C = new Float64Array( 1 ); +* var S = new Float64Array( 1 ); +* var R = new Float64Array( 1 ); +* +* dlartg( F, 0, G, 0, C, 0, S, 0, R, 0 ); +* // R => [ 5.0 ] +* // C => [ 0.6 ] +* // S => [ 0.8 ] +*/ +function dlartg( F, offsetF, G, offsetG, C, offsetC, S, offsetS, R, offsetR) { + base( F, offsetF, G, offsetG, C, offsetC, S, offsetS, R, offsetR ); +} + + +// EXPORTS // + +module.exports = dlartg; diff --git a/lib/node_modules/@stdlib/lapack/base/dlartg/package.json b/lib/node_modules/@stdlib/lapack/base/dlartg/package.json new file mode 100644 index 000000000000..52274dbd7945 --- /dev/null +++ b/lib/node_modules/@stdlib/lapack/base/dlartg/package.json @@ -0,0 +1,71 @@ +{ + "name": "@stdlib/lapack/base/dlartg", + "version": "0.0.0", + "description": "LAPACK routine to construct a Givens rotation of a two-dimensional vector that zeros out the second component.", + "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", + "lapack", + "dlartg", + "rotation", + "givens", + "plane", + "linear", + "algebra", + "subroutines", + "array", + "ndarray", + "matrix", + "float64", + "double", + "float64array" + ] +} diff --git a/lib/node_modules/@stdlib/lapack/base/dlartg/test/fixtures/f_eq_zero.json b/lib/node_modules/@stdlib/lapack/base/dlartg/test/fixtures/f_eq_zero.json new file mode 100644 index 000000000000..0310364ecb67 --- /dev/null +++ b/lib/node_modules/@stdlib/lapack/base/dlartg/test/fixtures/f_eq_zero.json @@ -0,0 +1,16 @@ +{ + "F": [ 0.0 ], + "offsetF": 0, + "G": [ 5.0 ], + "offsetG": 0, + "S": [ 0.0 ], + "offsetS": 0, + "C": [ 0.0 ], + "offsetC": 0, + "R": [ 0.0 ], + "offsetR": 0, + + "S_out": [ 1.0 ], + "C_out": [ 0.0 ], + "R_out": [ 5.0 ] +} diff --git a/lib/node_modules/@stdlib/lapack/base/dlartg/test/fixtures/g_eq_zero.json b/lib/node_modules/@stdlib/lapack/base/dlartg/test/fixtures/g_eq_zero.json new file mode 100644 index 000000000000..c4bd76d3c7b3 --- /dev/null +++ b/lib/node_modules/@stdlib/lapack/base/dlartg/test/fixtures/g_eq_zero.json @@ -0,0 +1,16 @@ +{ + "F": [ 5.0 ], + "offsetF": 0, + "G": [ 0.0 ], + "offsetG": 0, + "S": [ 0.0 ], + "offsetS": 0, + "C": [ 0.0 ], + "offsetC": 0, + "R": [ 0.0 ], + "offsetR": 0, + + "S_out": [ 0.0 ], + "C_out": [ 1.0 ], + "R_out": [ 5.0 ] +} diff --git a/lib/node_modules/@stdlib/lapack/base/dlartg/test/fixtures/large_values.json b/lib/node_modules/@stdlib/lapack/base/dlartg/test/fixtures/large_values.json new file mode 100644 index 000000000000..b4d96ce30dd8 --- /dev/null +++ b/lib/node_modules/@stdlib/lapack/base/dlartg/test/fixtures/large_values.json @@ -0,0 +1,16 @@ +{ + "F": [ 9.9999999999999997e+199 ], + "offsetF": 0, + "G": [ 9.9999999999999997E+199 ], + "offsetG": 0, + "S": [ 0.0 ], + "offsetS": 0, + "C": [ 0.0 ], + "offsetC": 0, + "R": [ 0.0 ], + "offsetR": 0, + + "S_out": [ 0.70710678118654746 ], + "C_out": [ 0.70710678118654746 ], + "R_out": [ 1.4142135623730950e+200 ] +} diff --git a/lib/node_modules/@stdlib/lapack/base/dlartg/test/fixtures/nonzero.json b/lib/node_modules/@stdlib/lapack/base/dlartg/test/fixtures/nonzero.json new file mode 100644 index 000000000000..a41f6a6fd9cd --- /dev/null +++ b/lib/node_modules/@stdlib/lapack/base/dlartg/test/fixtures/nonzero.json @@ -0,0 +1,16 @@ +{ + "F": [ 3.0 ], + "offsetF": 0, + "G": [ 4.0 ], + "offsetG": 0, + "S": [ 0.0 ], + "offsetS": 0, + "C": [ 0.0 ], + "offsetC": 0, + "R": [ 0.0 ], + "offsetR": 0, + + "S_out": [ 0.8 ], + "C_out": [ 0.6 ], + "R_out": [ 5.0 ] +} diff --git a/lib/node_modules/@stdlib/lapack/base/dlartg/test/fixtures/offsets/f_eq_zero.json b/lib/node_modules/@stdlib/lapack/base/dlartg/test/fixtures/offsets/f_eq_zero.json new file mode 100644 index 000000000000..dd652ef9cd48 --- /dev/null +++ b/lib/node_modules/@stdlib/lapack/base/dlartg/test/fixtures/offsets/f_eq_zero.json @@ -0,0 +1,39 @@ +{ + "F": [ + 9999, + 0 + ], + "offsetF": 1, + "G": [ + 9999, + 5 + ], + "offsetG": 1, + "S": [ + 9999, + 0 + ], + "offsetS": 1, + "C": [ + 9999, + 0 + ], + "offsetC": 1, + "R": [ + 9999, + 0 + ], + "offsetR": 1, + "S_out": [ + 9999, + 1 + ], + "C_out": [ + 9999, + 0 + ], + "R_out": [ + 9999, + 5 + ] +} diff --git a/lib/node_modules/@stdlib/lapack/base/dlartg/test/fixtures/offsets/g_eq_zero.json b/lib/node_modules/@stdlib/lapack/base/dlartg/test/fixtures/offsets/g_eq_zero.json new file mode 100644 index 000000000000..e7bdbf856168 --- /dev/null +++ b/lib/node_modules/@stdlib/lapack/base/dlartg/test/fixtures/offsets/g_eq_zero.json @@ -0,0 +1,39 @@ +{ + "F": [ + 9999, + 5 + ], + "offsetF": 1, + "G": [ + 9999, + 0 + ], + "offsetG": 1, + "S": [ + 9999, + 0 + ], + "offsetS": 1, + "C": [ + 9999, + 0 + ], + "offsetC": 1, + "R": [ + 9999, + 0 + ], + "offsetR": 1, + "S_out": [ + 9999, + 0 + ], + "C_out": [ + 9999, + 1 + ], + "R_out": [ + 9999, + 5 + ] +} diff --git a/lib/node_modules/@stdlib/lapack/base/dlartg/test/fixtures/offsets/large_values.json b/lib/node_modules/@stdlib/lapack/base/dlartg/test/fixtures/offsets/large_values.json new file mode 100644 index 000000000000..814d21665646 --- /dev/null +++ b/lib/node_modules/@stdlib/lapack/base/dlartg/test/fixtures/offsets/large_values.json @@ -0,0 +1,39 @@ +{ + "F": [ + 9999, + 1e+200 + ], + "offsetF": 1, + "G": [ + 9999, + 1e+200 + ], + "offsetG": 1, + "S": [ + 9999, + 0 + ], + "offsetS": 1, + "C": [ + 9999, + 0 + ], + "offsetC": 1, + "R": [ + 9999, + 0 + ], + "offsetR": 1, + "S_out": [ + 9999, + 0.7071067811865475 + ], + "C_out": [ + 9999, + 0.7071067811865475 + ], + "R_out": [ + 9999, + 1.414213562373095e+200 + ] +} diff --git a/lib/node_modules/@stdlib/lapack/base/dlartg/test/fixtures/offsets/nonzero.json b/lib/node_modules/@stdlib/lapack/base/dlartg/test/fixtures/offsets/nonzero.json new file mode 100644 index 000000000000..7a46b9a20828 --- /dev/null +++ b/lib/node_modules/@stdlib/lapack/base/dlartg/test/fixtures/offsets/nonzero.json @@ -0,0 +1,39 @@ +{ + "F": [ + 9999, + 3 + ], + "offsetF": 1, + "G": [ + 9999, + 4 + ], + "offsetG": 1, + "S": [ + 9999, + 0 + ], + "offsetS": 1, + "C": [ + 9999, + 0 + ], + "offsetC": 1, + "R": [ + 9999, + 0 + ], + "offsetR": 1, + "S_out": [ + 9999, + 0.8 + ], + "C_out": [ + 9999, + 0.6 + ], + "R_out": [ + 9999, + 5 + ] +} diff --git a/lib/node_modules/@stdlib/lapack/base/dlartg/test/test.dlartg.js b/lib/node_modules/@stdlib/lapack/base/dlartg/test/test.dlartg.js new file mode 100644 index 000000000000..31486a2d7316 --- /dev/null +++ b/lib/node_modules/@stdlib/lapack/base/dlartg/test/test.dlartg.js @@ -0,0 +1,171 @@ +/** +* @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 Float64Array = require( '@stdlib/array/float64' ); +var dlartg = require( './../lib/dlartg.js' ); + + +// FIXTURES // + +var G_EQ_ZERO = require( './fixtures/g_eq_zero.json' ); +var F_EQ_ZERO = require( './fixtures/f_eq_zero.json' ); +var NONZERO_VALUES = require( './fixtures/nonzero.json' ); +var LARGE_VALUES = require( './fixtures/large_values.json' ); + + +// TESTS // + +tape( 'main export is a function', function test( t ) { + t.ok( true, __filename ); + t.strictEqual( typeof dlartg, 'function', 'main export is a function' ); + t.end(); +}); + +tape( 'the function has an arity of 5', function test( t ) { + t.strictEqual( dlartg.length, 5, 'returns expected value' ); + t.end(); +}); + +tape( 'the function returns expected values for G = 0', function test( t ) { + var expectedS; + var expectedC; + var expectedR; + var data; + var F; + var G; + var S; + var C; + var R; + + data = G_EQ_ZERO; + + F = new Float64Array( data.F ); + G = new Float64Array( data.G ); + S = new Float64Array( data.S ); + C = new Float64Array( data.C ); + R = new Float64Array( data.R ); + + expectedC = new Float64Array( data.C_out ); + expectedS = new Float64Array( data.S_out ); + expectedR = new Float64Array( data.R_out ); + + dlartg( F, G, C, S, R ); + + t.deepEqual( S, expectedS, 'returns expected value' ); + t.deepEqual( C, expectedC, 'returns expected value' ); + t.deepEqual( R, expectedR, 'returns expected value' ); + t.end(); +}); + +tape( 'the function returns expected values for F = 0', function test( t ) { + var expectedS; + var expectedC; + var expectedR; + var data; + var F; + var G; + var S; + var C; + var R; + + data = F_EQ_ZERO; + + F = new Float64Array( data.F ); + G = new Float64Array( data.G ); + S = new Float64Array( data.S ); + C = new Float64Array( data.C ); + R = new Float64Array( data.R ); + + expectedC = new Float64Array( data.C_out ); + expectedS = new Float64Array( data.S_out ); + expectedR = new Float64Array( data.R_out ); + + dlartg( F, G, C, S, R ); + + t.deepEqual( S, expectedS, 'returns expected value' ); + t.deepEqual( C, expectedC, 'returns expected value' ); + t.deepEqual( R, expectedR, 'returns expected value' ); + t.end(); +}); + +tape( 'the function returns expected values for nonzero inputs', function test( t ) { + var expectedS; + var expectedC; + var expectedR; + var data; + var F; + var G; + var S; + var C; + var R; + + data = NONZERO_VALUES; + + F = new Float64Array( data.F ); + G = new Float64Array( data.G ); + S = new Float64Array( data.S ); + C = new Float64Array( data.C ); + R = new Float64Array( data.R ); + + expectedC = new Float64Array( data.C_out ); + expectedS = new Float64Array( data.S_out ); + expectedR = new Float64Array( data.R_out ); + + dlartg( F, G, C, S, R ); + + t.deepEqual( S, expectedS, 'returns expected value' ); + t.deepEqual( C, expectedC, 'returns expected value' ); + t.deepEqual( R, expectedR, 'returns expected value' ); + t.end(); +}); + +tape( 'the function returns expected values for large inputs', function test( t ) { + var expectedS; + var expectedC; + var expectedR; + var data; + var F; + var G; + var S; + var C; + var R; + + data = LARGE_VALUES; + + F = new Float64Array( data.F ); + G = new Float64Array( data.G ); + S = new Float64Array( data.S ); + C = new Float64Array( data.C ); + R = new Float64Array( data.R ); + + expectedC = new Float64Array( data.C_out ); + expectedS = new Float64Array( data.S_out ); + expectedR = new Float64Array( data.R_out ); + + dlartg( F, G, C, S, R ); + + t.deepEqual( S, expectedS, 'returns expected value' ); + t.deepEqual( C, expectedC, 'returns expected value' ); + t.deepEqual( R, expectedR, 'returns expected value' ); + t.end(); +}); diff --git a/lib/node_modules/@stdlib/lapack/base/dlartg/test/test.js b/lib/node_modules/@stdlib/lapack/base/dlartg/test/test.js new file mode 100644 index 000000000000..469d2df8c732 --- /dev/null +++ b/lib/node_modules/@stdlib/lapack/base/dlartg/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 dlartg = 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 dlartg, '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 dlartg.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 dlartg = proxyquire( './../lib', { + '@stdlib/utils/try-require': tryRequire + }); + + t.strictEqual( dlartg, 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 dlartg; + var main; + + main = require( './../lib/dlartg.js' ); + + dlartg = proxyquire( './../lib', { + '@stdlib/utils/try-require': tryRequire + }); + + t.strictEqual( dlartg, main, 'returns expected value' ); + t.end(); + + function tryRequire() { + return new Error( 'Cannot find module' ); + } +}); diff --git a/lib/node_modules/@stdlib/lapack/base/dlartg/test/test.ndarray.js b/lib/node_modules/@stdlib/lapack/base/dlartg/test/test.ndarray.js new file mode 100644 index 000000000000..b65668151113 --- /dev/null +++ b/lib/node_modules/@stdlib/lapack/base/dlartg/test/test.ndarray.js @@ -0,0 +1,302 @@ +/** +* @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. +*/ + +/* eslint-disable max-len */ + +'use strict'; + +// MODULES // + +var tape = require( 'tape' ); +var Float64Array = require( '@stdlib/array/float64' ); +var dlartg = require( './../lib/ndarray.js' ); + + +// FIXTURES // + +var G_EQ_ZERO = require( './fixtures/g_eq_zero.json' ); +var F_EQ_ZERO = require( './fixtures/f_eq_zero.json' ); +var NONZERO_VALUES = require( './fixtures/nonzero.json' ); +var LARGE_VALUES = require( './fixtures/large_values.json' ); + +var OFFSET_G_EQ_ZERO = require( './fixtures/offsets/g_eq_zero.json' ); +var OFFSET_F_EQ_ZERO = require( './fixtures/offsets/f_eq_zero.json' ); +var OFFSET_NONZERO_VALUES = require( './fixtures/offsets/nonzero.json' ); +var OFFSET_LARGE_VALUES = require( './fixtures/offsets/large_values.json' ); + + +// TESTS // + +tape( 'main export is a function', function test( t ) { + t.ok( true, __filename ); + t.strictEqual( typeof dlartg, 'function', 'main export is a function' ); + t.end(); +}); + +tape( 'the function has an arity of 10', function test( t ) { + t.strictEqual( dlartg.length, 10, 'returns expected value' ); + t.end(); +}); + +tape( 'the function returns expected values for G = 0', function test( t ) { + var expectedS; + var expectedC; + var expectedR; + var data; + var F; + var G; + var S; + var C; + var R; + + data = G_EQ_ZERO; + + F = new Float64Array( data.F ); + G = new Float64Array( data.G ); + S = new Float64Array( data.S ); + C = new Float64Array( data.C ); + R = new Float64Array( data.R ); + + expectedC = new Float64Array( data.C_out ); + expectedS = new Float64Array( data.S_out ); + expectedR = new Float64Array( data.R_out ); + + dlartg( F, data.offsetF, G, data.offsetG, C, data.offsetC, S, data.offsetS, R, data.offsetR ); + + t.deepEqual( S, expectedS, 'returns expected value' ); + t.deepEqual( C, expectedC, 'returns expected value' ); + t.deepEqual( R, expectedR, 'returns expected value' ); + t.end(); +}); + +tape( 'the function returns expected values for F = 0', function test( t ) { + var expectedS; + var expectedC; + var expectedR; + var data; + var F; + var G; + var S; + var C; + var R; + + data = F_EQ_ZERO; + + F = new Float64Array( data.F ); + G = new Float64Array( data.G ); + S = new Float64Array( data.S ); + C = new Float64Array( data.C ); + R = new Float64Array( data.R ); + + expectedC = new Float64Array( data.C_out ); + expectedS = new Float64Array( data.S_out ); + expectedR = new Float64Array( data.R_out ); + + dlartg( F, data.offsetF, G, data.offsetG, C, data.offsetC, S, data.offsetS, R, data.offsetR ); + + t.deepEqual( S, expectedS, 'returns expected value' ); + t.deepEqual( C, expectedC, 'returns expected value' ); + t.deepEqual( R, expectedR, 'returns expected value' ); + t.end(); +}); + +tape( 'the function returns expected values for nonzero inputs', function test( t ) { + var expectedS; + var expectedC; + var expectedR; + var data; + var F; + var G; + var S; + var C; + var R; + + data = NONZERO_VALUES; + + F = new Float64Array( data.F ); + G = new Float64Array( data.G ); + S = new Float64Array( data.S ); + C = new Float64Array( data.C ); + R = new Float64Array( data.R ); + + expectedC = new Float64Array( data.C_out ); + expectedS = new Float64Array( data.S_out ); + expectedR = new Float64Array( data.R_out ); + + dlartg( F, data.offsetF, G, data.offsetG, C, data.offsetC, S, data.offsetS, R, data.offsetR ); + + t.deepEqual( S, expectedS, 'returns expected value' ); + t.deepEqual( C, expectedC, 'returns expected value' ); + t.deepEqual( R, expectedR, 'returns expected value' ); + t.end(); +}); + +tape( 'the function returns expected values for large inputs', function test( t ) { + var expectedS; + var expectedC; + var expectedR; + var data; + var F; + var G; + var S; + var C; + var R; + + data = LARGE_VALUES; + + F = new Float64Array( data.F ); + G = new Float64Array( data.G ); + S = new Float64Array( data.S ); + C = new Float64Array( data.C ); + R = new Float64Array( data.R ); + + expectedC = new Float64Array( data.C_out ); + expectedS = new Float64Array( data.S_out ); + expectedR = new Float64Array( data.R_out ); + + dlartg( F, data.offsetF, G, data.offsetG, C, data.offsetC, S, data.offsetS, R, data.offsetR ); + + t.deepEqual( S, expectedS, 'returns expected value' ); + t.deepEqual( C, expectedC, 'returns expected value' ); + t.deepEqual( R, expectedR, 'returns expected value' ); + t.end(); +}); + +tape( 'the function returns expected values for G = 0 (offsets)', function test( t ) { + var expectedS; + var expectedC; + var expectedR; + var data; + var F; + var G; + var S; + var C; + var R; + + data = OFFSET_G_EQ_ZERO; + + F = new Float64Array( data.F ); + G = new Float64Array( data.G ); + S = new Float64Array( data.S ); + C = new Float64Array( data.C ); + R = new Float64Array( data.R ); + + expectedC = new Float64Array( data.C_out ); + expectedS = new Float64Array( data.S_out ); + expectedR = new Float64Array( data.R_out ); + + dlartg( F, data.offsetF, G, data.offsetG, C, data.offsetC, S, data.offsetS, R, data.offsetR ); + + t.deepEqual( S, expectedS, 'returns expected value' ); + t.deepEqual( C, expectedC, 'returns expected value' ); + t.deepEqual( R, expectedR, 'returns expected value' ); + t.end(); +}); + +tape( 'the function returns expected values for F = 0 (offsets)', function test( t ) { + var expectedS; + var expectedC; + var expectedR; + var data; + var F; + var G; + var S; + var C; + var R; + + data = OFFSET_F_EQ_ZERO; + + F = new Float64Array( data.F ); + G = new Float64Array( data.G ); + S = new Float64Array( data.S ); + C = new Float64Array( data.C ); + R = new Float64Array( data.R ); + + expectedC = new Float64Array( data.C_out ); + expectedS = new Float64Array( data.S_out ); + expectedR = new Float64Array( data.R_out ); + + dlartg( F, data.offsetF, G, data.offsetG, C, data.offsetC, S, data.offsetS, R, data.offsetR ); + + t.deepEqual( S, expectedS, 'returns expected value' ); + t.deepEqual( C, expectedC, 'returns expected value' ); + t.deepEqual( R, expectedR, 'returns expected value' ); + t.end(); +}); + +tape( 'the function returns expected values for nonzero inputs (offsets)', function test( t ) { + var expectedS; + var expectedC; + var expectedR; + var data; + var F; + var G; + var S; + var C; + var R; + + data = OFFSET_NONZERO_VALUES; + + F = new Float64Array( data.F ); + G = new Float64Array( data.G ); + S = new Float64Array( data.S ); + C = new Float64Array( data.C ); + R = new Float64Array( data.R ); + + expectedC = new Float64Array( data.C_out ); + expectedS = new Float64Array( data.S_out ); + expectedR = new Float64Array( data.R_out ); + + dlartg( F, data.offsetF, G, data.offsetG, C, data.offsetC, S, data.offsetS, R, data.offsetR ); + + t.deepEqual( S, expectedS, 'returns expected value' ); + t.deepEqual( C, expectedC, 'returns expected value' ); + t.deepEqual( R, expectedR, 'returns expected value' ); + t.end(); +}); + +tape( 'the function returns expected values for large inputs (offsets)', function test( t ) { + var expectedS; + var expectedC; + var expectedR; + var data; + var F; + var G; + var S; + var C; + var R; + + data = OFFSET_LARGE_VALUES; + + F = new Float64Array( data.F ); + G = new Float64Array( data.G ); + S = new Float64Array( data.S ); + C = new Float64Array( data.C ); + R = new Float64Array( data.R ); + + expectedC = new Float64Array( data.C_out ); + expectedS = new Float64Array( data.S_out ); + expectedR = new Float64Array( data.R_out ); + + dlartg( F, data.offsetF, G, data.offsetG, C, data.offsetC, S, data.offsetS, R, data.offsetR ); + + t.deepEqual( S, expectedS, 'returns expected value' ); + t.deepEqual( C, expectedC, 'returns expected value' ); + t.deepEqual( R, expectedR, 'returns expected value' ); + t.end(); +});