diff --git a/lib/node_modules/@stdlib/lapack/base/dlas2/README.md b/lib/node_modules/@stdlib/lapack/base/dlas2/README.md new file mode 100644 index 00000000000..d6b650da5b2 --- /dev/null +++ b/lib/node_modules/@stdlib/lapack/base/dlas2/README.md @@ -0,0 +1,221 @@ + + +# dlas2 + +> Compute the singular values of `2x2` matrix. + +
+ +## Usage + +```javascript +var dlas2 = require( '@stdlib/lapack/base/dlas2' ); +``` + +#### dlas2( F, G, H, out ) + +Computes the singular values of `2x2` matrix. + +```javascript +var Float64Array = require( '@stdlib/array/float64' ); + +var out = new Float64Array( 2 ); +dlas2( 1.0, 2.0, 3.0, out ); +// out => [ ~0.822, ~3.65 ] +``` + +The function has the following parameters: + +- **F**: the (0,0) element of a 2x2 matrix. +- **G**: the (0,1) and (1,0) elements of a 2x2 matrix. +- **H**: the (1,1) element of a 2x2 matrix. +- **out**: output [`Float64Array`][mdn-float64array] containing the smaller and larger singular values respectively. + +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 array: +var out0 = new Float64Array( [ 0.0, 0.0, 0.0 ] ); + +// Create an offset view... +var out1 = new Float64Array( out0.buffer, out0.BYTES_PER_ELEMENT*1 ); // start at 2nd element + +dlas2( 1.0, 2.0, 3.0, out1 ); +// out0 => [ 0.0, ~0.822, ~3.65 ] +``` + +#### dlas2.ndarray( F, G, H, out, strideOut, offsetOut ) + +Computes the singular values of `2x2` matrix using alternative indexing semantics. + +```javascript +var Float64Array = require( '@stdlib/array/float64' ); + +var out = new Float64Array( 2 ); +dlas2.ndarray( 1.0, 2.0, 3.0, out, 1, 0 ); +// out => [ ~0.822, ~3.65 ] +``` + +The function has the following additional parameters: + +- **strideOut**: stride length for `out`. +- **offsetOut**: starting index of `out` + +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 out = new Float64Array( [ 0.0, 0.0, 0.0 ] ); +dlas2.ndarray( 1.0, 2.0, 3.0, out, -1, 2 ); +// out => [ 0.0, ~3.65, ~0.822 ] +``` + +
+ + + +
+ +## Notes + +- `dlas2()` corresponds to the [LAPACK][lapack] routine [`dlas2`][lapack-dlas2]. + +
+ + + +
+ +## Examples + + + +```javascript +var Float64Array = require( '@stdlib/array/float64' ); +var dlas2 = require( '@stdlib/lapack/base/dlas2' ); + +var out = new Float64Array( 2 ); +dlas2( 1.0, 2.0, 3.0, out ); +console.log( out ); +``` + +
+ + + + + +* * * + +
+ +## C APIs + + + +
+ +
+ + + + + +
+ +### Usage + +```c +TODO +``` + +#### TODO + +TODO. + +```c +TODO +``` + +TODO + +```c +TODO +``` + +
+ + + + + +
+ +
+ + + + + +
+ +### Examples + +```c +TODO +``` + +
+ + + +
+ + + + + +
+ +
+ + + + + +
+ +[lapack]: https://www.netlib.org/lapack/explore-html/ + +[lapack-dlas2]: https://www.netlib.org/lapack/explore-html/d3/dac/group__las2_ga94ed6ef29392ac8204cb0750f6cb3c8e.html#ga94ed6ef29392ac8204cb0750f6cb3c8e + +[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/dlas2/benchmark/benchmark.js b/lib/node_modules/@stdlib/lapack/base/dlas2/benchmark/benchmark.js new file mode 100644 index 00000000000..ce93591ae90 --- /dev/null +++ b/lib/node_modules/@stdlib/lapack/base/dlas2/benchmark/benchmark.js @@ -0,0 +1,60 @@ +/** +* @license Apache-2.0 +* +* Copyright (c) 2024 The Stdlib Authors. +* +* Licensed under the Apache License, Version 2.0 (the "License"); +* you may not use this file except in compliance with the License. +* You may obtain a copy of the License at +* +* http://www.apache.org/licenses/LICENSE-2.0 +* +* Unless required by applicable law or agreed to in writing, software +* distributed under the License is distributed on an "AS IS" BASIS, +* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +* See the License for the specific language governing permissions and +* limitations under the License. +*/ + +'use strict'; + +// MODULES // + +var bench = require( '@stdlib/bench' ); +var Float64Array = require( '@stdlib/array/float64' ); +var randu = require( '@stdlib/random/base/randu' ); +var isnan = require( '@stdlib/math/base/assert/is-nan' ); +var pkg = require( './../package.json' ).name; +var dlas2 = require( './../lib/dlas2.js' ); + + +// MAIN // + +bench( pkg, function benchmark( b ) { + var out; + var A; + var B; + var C; + var i; + + b.tic(); + A = ( randu() * 100.0 ) - 50.0; + B = ( randu() * 100.0 ) - 50.0; + C = ( randu() * 100.0 ) - 50.0; + out = new Float64Array( 2 ); + for ( i = 0; i < b.iterations; i++ ) { + out = dlas2( A, B, C, out ); + A = out[ i%out.length ]; + B = out[ i%out.length ]; + C = out[ i%out.length ]; + if ( isnan( out[ i%out.length ] ) ) { + b.fail( 'should not return NaN' ); + } + } + b.toc(); + if ( isnan( out[ i%out.length ] ) ) { + b.fail( 'should not return NaN' ); + } + b.pass( 'benchmark finished' ); + b.end(); +}); diff --git a/lib/node_modules/@stdlib/lapack/base/dlas2/benchmark/benchmark.ndarray.js b/lib/node_modules/@stdlib/lapack/base/dlas2/benchmark/benchmark.ndarray.js new file mode 100644 index 00000000000..fbc976e2790 --- /dev/null +++ b/lib/node_modules/@stdlib/lapack/base/dlas2/benchmark/benchmark.ndarray.js @@ -0,0 +1,61 @@ +/** +* @license Apache-2.0 +* +* Copyright (c) 2024 The Stdlib Authors. +* +* Licensed under the Apache License, Version 2.0 (the "License"); +* you may not use this file except in compliance with the License. +* You may obtain a copy of the License at +* +* http://www.apache.org/licenses/LICENSE-2.0 +* +* Unless required by applicable law or agreed to in writing, software +* distributed under the License is distributed on an "AS IS" BASIS, +* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +* See the License for the specific language governing permissions and +* limitations under the License. +*/ + +'use strict'; + +// MODULES // + +var bench = require( '@stdlib/bench' ); +var Float64Array = require( '@stdlib/array/float64' ); +var randu = require( '@stdlib/random/base/randu' ); +var isnan = require( '@stdlib/math/base/assert/is-nan' ); +var pkg = require( './../package.json' ).name; +var dlas2 = require( './../lib/ndarray.js' ); + + +// MAIN // + +bench( pkg+':ndarray', function benchmark( b ) { + var out; + var A; + var B; + var C; + var i; + + A = ( randu() * 100.0 ) - 50.0; + B = ( randu() * 100.0 ) - 50.0; + C = ( randu() * 100.0 ) - 50.0; + out = new Float64Array( 2 ); + + b.tic(); + for ( i = 0; i < b.iterations; i++ ) { + out = dlas2( A, B, C, out, 1, 0 ); + A = out[ i%out.length ]; + B = out[ i%out.length ]; + C = out[ i%out.length ]; + if ( isnan( out[ i%out.length ] ) ) { + b.fail( 'should not return NaN' ); + } + } + b.toc(); + if ( isnan( out[ i%out.length ] ) ) { + b.fail( 'should not return NaN' ); + } + b.pass( 'benchmark finished' ); + b.end(); +}); diff --git a/lib/node_modules/@stdlib/lapack/base/dlas2/docs/repl.txt b/lib/node_modules/@stdlib/lapack/base/dlas2/docs/repl.txt new file mode 100644 index 00000000000..96a95922a63 --- /dev/null +++ b/lib/node_modules/@stdlib/lapack/base/dlas2/docs/repl.txt @@ -0,0 +1,76 @@ + +{{alias}}( F, G, H, out ) + Computes the eigenvalues of a 2x2 matrix. + + Indexing is relative to the first index. To introduce an offset, use typed + array views. + + Parameters + ---------- + F: number + The (0,0) element of a 2x2 matrix. + + G: number + The (0,1) and (1,0) elements of a 2x2 matrix. + + H: number + The (1,1) element of a 2x2 matrix. + + out: Float64Array + Output array containing eigenvalues of the larger and smaller absolute + values, respectively. + + Returns + ------- + out: Float64Array + Output array. + + Examples + -------- + > var out = new {{alias:@stdlib/array/float64}}( 2 ); + > {{alias}}( 1.0, 2.0, 3.0, out ) + [ ~0.822, ~3.65 ] + + +{{alias}}.ndarray( F, G, H, out, strideOut, offsetOut ) + Computes the eigenvalues of a 2x2 using alternative + indexing semantics. + + 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: number + The (0,0) element of a 2x2 matrix. + + G: number + The (0,1) and (1,0) elements of a 2x2 matrix. + + H: number + The (1,1) element of a 2x2 matrix. + + out: Float64Array + Output array containing eigenvalues of the larger and smaller absolute + values, respectively. + + strideOut: integer + Stride length for `out`. + + offsetOut: integer + Starting index of `out`. + + Returns + ------- + out: Float64Array + Output matrix. + + Examples + -------- + > var out = new {{alias:@stdlib/array/float64}}( [ 0.0, 0.0, 0.0 ] ); + > {{alias}}.ndarray( 1.0, 2.0, 3.0, out, 1, 1 ) + [ 0.0, ~0.822, ~3.65 ] + + See Also + -------- diff --git a/lib/node_modules/@stdlib/lapack/base/dlas2/docs/types/index.d.ts b/lib/node_modules/@stdlib/lapack/base/dlas2/docs/types/index.d.ts new file mode 100644 index 00000000000..b92c5cb3950 --- /dev/null +++ b/lib/node_modules/@stdlib/lapack/base/dlas2/docs/types/index.d.ts @@ -0,0 +1,96 @@ +/** +* @license Apache-2.0 +* +* Copyright (c) 2024 The Stdlib Authors. +* +* Licensed under the Apache License, Version 2.0 (the "License"); +* you may not use this file except in compliance with the License. +* You may obtain a copy of the License at +* +* http://www.apache.org/licenses/LICENSE-2.0 +* +* Unless required by applicable law or agreed to in writing, software +* distributed under the License is distributed on an "AS IS" BASIS, +* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +* See the License for the specific language governing permissions and +* limitations under the License. +*/ + +// TypeScript Version: 4.1 + +/// + +/** +* Interface describing `dlas2`. +*/ +interface Routine { + /** + * Computes the singular values of `2x2` matrix. + * + * @param F - the (0,0) element of a `2x2` matrix + * @param G - the (0,1) element of a `2x2` matrix + * @param H - the (1,1) element of a `2x2` matrix + * @param out - output array containing the smaller and larger singular values respectively + * @returns output array + * + * @example + * var Float64Array = require( '@stdlib/array/float64' ); + * + * var out = new Float64Array( 2 ); + * dlas2( 1.0, 2.0, 3.0, out ); + * // out => [ ~0.822, ~3.65 ] + */ + ( F: number, G: number, H: number, out: Float64Array ): Float64Array; + + /** + * Computes the singular values of `2x2` matrix using alternative indexing semantics. + * + * @name dlas2.ndarray + * @type {Function} + * @param F - the (0,0) element of a `2x2` matrix + * @param G - the (0,1) element of a `2x2` matrix + * @param H - the (1,1) element of a `2x2` matrix + * @param out - output array containing the smaller and larger singular values respectively + * @param strideOut - stride length for `out` + * @param offsetOut - starting index of `out` + * @returns output array + * + * @example + * var Float64Array = require( '@stdlib/array/float64' ); + * + * var out = new Float64Array( 2 ); + * dlas2.ndarray( 1.0, 2.0, 3.0, out, 1, 0 ); + * // out => [ ~0.822, ~3.65 ] + */ + ndarray( F: number, G: number, H: number, out: Float64Array, strideOut: number, offsetOut: number ): Float64Array; +} + +/** +* Computes the singular values of `2x2` matrix. +* +* @param F - the (0,0) element of a `2x2` matrix +* @param G - the (0,1) element of a `2x2` matrix +* @param H - the (1,1) element of a `2x2` matrix +* @param out - output array containing the smaller and larger singular values respectively +* @returns output array +* +* @example +* var Float64Array = require( '@stdlib/array/float64' ); +* +* var out = new Float64Array( 2 ); +* dlas2( 1.0, 2.0, 3.0, out ); +* // out => [ ~0.822, ~3.65 ] +* +* @example +* var Float64Array = require( '@stdlib/array/float64' ); +* +* var out = new Float64Array( 2 ); +* dlas2.ndarray( 1.0, 2.0, 3.0, out, 1, 0 ); +* // out => [ ~0.822, ~3.65 ] +*/ +declare var dlas2: Routine; + + +// EXPORTS // + +export = dlas2; diff --git a/lib/node_modules/@stdlib/lapack/base/dlas2/docs/types/test.ts b/lib/node_modules/@stdlib/lapack/base/dlas2/docs/types/test.ts new file mode 100644 index 00000000000..de8eac3ed1f --- /dev/null +++ b/lib/node_modules/@stdlib/lapack/base/dlas2/docs/types/test.ts @@ -0,0 +1,200 @@ +/* +* @license Apache-2.0 +* +* Copyright (c) 2024 The Stdlib Authors. +* +* Licensed under the Apache License, Version 2.0 (the "License"); +* you may not use this file except in compliance with the License. +* You may obtain a copy of the License at +* +* http://www.apache.org/licenses/LICENSE-2.0 +* +* Unless required by applicable law or agreed to in writing, software +* distributed under the License is distributed on an "AS IS" BASIS, +* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +* See the License for the specific language governing permissions and +* limitations under the License. +*/ + +import dlas2 = require( './index' ); + + +// TESTS // + +// The function returns a Float64Array... +{ + const out = new Float64Array( [ 1.0, 2.0 ] ); + + dlas2( 2.0, 3.0, 4.0, out ); // $ExpectType Float64Array +} + +// The compiler throws an error if the function is provided a first argument which is not a number... +{ + const out = new Float64Array( [ 1.0, 2.0 ] ); + + dlas2( '5', 3.0, 4.0, out ); // $ExpectError + dlas2( true, 3.0, 4.0, out ); // $ExpectError + dlas2( false, 3.0, 4.0, out ); // $ExpectError + dlas2( null, 3.0, 4.0, out ); // $ExpectError + dlas2( void 0, 3.0, 4.0, out ); // $ExpectError + dlas2( [], 3.0, 4.0, out ); // $ExpectError + dlas2( {}, 3.0, 4.0, out ); // $ExpectError + dlas2( ( x: number ): number => x, 3.0, 4.0, out ); // $ExpectError +} + +// The compiler throws an error if the function is provided a second argument which is not a number... +{ + const out = new Float64Array( [ 1.0, 2.0 ] ); + + dlas2( 2.0, '5', 4.0, out ); // $ExpectError + dlas2( 2.0, true, 4.0, out ); // $ExpectError + dlas2( 2.0, false, 4.0, out ); // $ExpectError + dlas2( 2.0, null, 4.0, out ); // $ExpectError + dlas2( 2.0, void 0, 4.0, out ); // $ExpectError + dlas2( 2.0, [], 4.0, out ); // $ExpectError + dlas2( 2.0, {}, 4.0, out ); // $ExpectError + dlas2( 2.0, ( x: number ): number => x, 4.0, out ); // $ExpectError +} + +// The compiler throws an error if the function is provided a third argument which is not a number... +{ + const out = new Float64Array( [ 1.0, 2.0 ] ); + + dlas2( 2.0, 3.0, '5', out ); // $ExpectError + dlas2( 2.0, 3.0, true, out ); // $ExpectError + dlas2( 2.0, 3.0, false, out ); // $ExpectError + dlas2( 2.0, 3.0, null, out ); // $ExpectError + dlas2( 2.0, 3.0, void 0, out ); // $ExpectError + dlas2( 2.0, 3.0, [], out ); // $ExpectError + dlas2( 2.0, 3.0, {}, out ); // $ExpectError + dlas2( 2.0, 3.0, ( x: number ): number => x, out ); // $ExpectError +} + +// The compiler throws an error if the function is provided a fourth argument which is not a Float64Array... +{ + + dlas2( 2.0, 3.0, 4.0, '5' ); // $ExpectError + dlas2( 2.0, 3.0, 4.0, 5 ); // $ExpectError + dlas2( 2.0, 3.0, 4.0, true ); // $ExpectError + dlas2( 2.0, 3.0, 4.0, false ); // $ExpectError + dlas2( 2.0, 3.0, 4.0, null ); // $ExpectError + dlas2( 2.0, 3.0, 4.0, void 0 ); // $ExpectError + dlas2( 2.0, 3.0, 4.0, [] ); // $ExpectError + dlas2( 2.0, 3.0, 4.0, {} ); // $ExpectError + dlas2( 2.0, 3.0, 4.0, ( x: number ): number => x ); // $ExpectError +} + +// The compiler throws an error if the function is provided an unsupported number of arguments... +{ + const out = new Float64Array( [ 1.0, 2.0 ] ); + + dlas2(); // $ExpectError + dlas2( 2.0 ); // $ExpectError + dlas2( 2.0, 3.0 ); // $ExpectError + dlas2( 2.0, 3.0, 4.0 ); // $ExpectError + dlas2( 2.0, 3.0, 4.0, out, 10 ); // $ExpectError +} + +// Attached to main export is an `ndarray` method which returns a Float64Array... +{ + const out = new Float64Array( [ 1.0, 2.0 ] ); + + dlas2.ndarray( 2.0, 3.0, 4.0, out, 1, 0 ); // $ExpectType Float64Array +} + +// The compiler throws an error if the function is provided a first argument which is not a number... +{ + const out = new Float64Array( [ 1.0, 2.0 ] ); + + dlas2.ndarray( '5', 3.0, 4.0, out, 1, 0 ); // $ExpectError + dlas2.ndarray( true, 3.0, 4.0, out, 1, 0 ); // $ExpectError + dlas2.ndarray( false, 3.0, 4.0, out, 1, 0 ); // $ExpectError + dlas2.ndarray( null, 3.0, 4.0, out, 1, 0 ); // $ExpectError + dlas2.ndarray( void 0, 3.0, 4.0, out, 1, 0 ); // $ExpectError + dlas2.ndarray( [], 3.0, 4.0, out, 1, 0 ); // $ExpectError + dlas2.ndarray( {}, 3.0, 4.0, out, 1, 0 ); // $ExpectError + dlas2.ndarray( ( x: number ): number => x, 3.0, 4.0, out, 1, 0 ); // $ExpectError +} + +// The compiler throws an error if the function is provided a second argument which is not a number... +{ + const out = new Float64Array( [ 1.0, 2.0 ] ); + + dlas2.ndarray( 2.0, '5', 4.0, out, 1, 0 ); // $ExpectError + dlas2.ndarray( 2.0, true, 4.0, out, 1, 0 ); // $ExpectError + dlas2.ndarray( 2.0, false, 4.0, out, 1, 0 ); // $ExpectError + dlas2.ndarray( 2.0, null, 4.0, out, 1, 0 ); // $ExpectError + dlas2.ndarray( 2.0, void 0, 4.0, out, 1, 0 ); // $ExpectError + dlas2.ndarray( 2.0, [], 4.0, out, 1, 0 ); // $ExpectError + dlas2.ndarray( 2.0, {}, 4.0, out, 1, 0 ); // $ExpectError + dlas2.ndarray( 2.0, ( x: number ): number => x, 4.0, out, 1, 0 ); // $ExpectError +} + +// The compiler throws an error if the function is provided a third argument which is not a number... +{ + const out = new Float64Array( [ 1.0, 2.0 ] ); + + dlas2.ndarray( 2.0, 3.0, '5', out, 1, 0 ); // $ExpectError + dlas2.ndarray( 2.0, 3.0, true, out, 1, 0 ); // $ExpectError + dlas2.ndarray( 2.0, 3.0, false, out, 1, 0 ); // $ExpectError + dlas2.ndarray( 2.0, 3.0, null, out, 1, 0 ); // $ExpectError + dlas2.ndarray( 2.0, 3.0, void 0, out, 1, 0 ); // $ExpectError + dlas2.ndarray( 2.0, 3.0, [], out, 1, 0 ); // $ExpectError + dlas2.ndarray( 2.0, 3.0, {}, out, 1, 0 ); // $ExpectError + dlas2.ndarray( 2.0, 3.0, ( x: number ): number => x, out, 1, 0 ); // $ExpectError +} + +// The compiler throws an error if the function is provided a fourth argument which is not a Float64Array... +{ + + dlas2.ndarray( 2.0, 3.0, 4.0, '5', 1, 0 ); // $ExpectError + dlas2.ndarray( 2.0, 3.0, 4.0, 5, 1, 0 ); // $ExpectError + dlas2.ndarray( 2.0, 3.0, 4.0, true, 1, 0 ); // $ExpectError + dlas2.ndarray( 2.0, 3.0, 4.0, false, 1, 0 ); // $ExpectError + dlas2.ndarray( 2.0, 3.0, 4.0, null, 1, 0 ); // $ExpectError + dlas2.ndarray( 2.0, 3.0, 4.0, void 0, 1, 0 ); // $ExpectError + dlas2.ndarray( 2.0, 3.0, 4.0, [], 1, 0 ); // $ExpectError + dlas2.ndarray( 2.0, 3.0, 4.0, {}, 1, 0 ); // $ExpectError + dlas2.ndarray( 2.0, 3.0, 4.0, ( x: number ): number => x, 1, 0 ); // $ExpectError +} + +// The compiler throws an error if the function is provided a fifth argument which is not a number... +{ + const out = new Float64Array( [ 1.0, 2.0 ] ); + + dlas2.ndarray( 2.0, 3.0, 4.0, out, '5', 0 ); // $ExpectError + dlas2.ndarray( 2.0, 3.0, 4.0, out, true, 0 ); // $ExpectError + dlas2.ndarray( 2.0, 3.0, 4.0, out, false, 0 ); // $ExpectError + dlas2.ndarray( 2.0, 3.0, 4.0, out, null, 0 ); // $ExpectError + dlas2.ndarray( 2.0, 3.0, 4.0, out, void 0, 0 ); // $ExpectError + dlas2.ndarray( 2.0, 3.0, 4.0, out, [], 0 ); // $ExpectError + dlas2.ndarray( 2.0, 3.0, 4.0, out, {}, 0 ); // $ExpectError + dlas2.ndarray( 2.0, 3.0, 4.0, out, ( x: number ): number => x, 0 ); // $ExpectError +} + +// The compiler throws an error if the function is provided a sixth argument which is not a number... +{ + const out = new Float64Array( [ 1.0, 2.0 ] ); + + dlas2.ndarray( 2.0, 3.0, 4.0, out, 1, '5' ); // $ExpectError + dlas2.ndarray( 2.0, 3.0, 4.0, out, 1, true ); // $ExpectError + dlas2.ndarray( 2.0, 3.0, 4.0, out, 1, false ); // $ExpectError + dlas2.ndarray( 2.0, 3.0, 4.0, out, 1, null ); // $ExpectError + dlas2.ndarray( 2.0, 3.0, 4.0, out, 1, void 0 ); // $ExpectError + dlas2.ndarray( 2.0, 3.0, 4.0, out, 1, [] ); // $ExpectError + dlas2.ndarray( 2.0, 3.0, 4.0, out, 1, {} ); // $ExpectError + dlas2.ndarray( 2.0, 3.0, 4.0, out, 1, ( x: number ): number => x ); // $ExpectError +} + +// The compiler throws an error if the `ndarray` method is provided an unsupported number of arguments... +{ + const out = new Float64Array( [ 1.0, 2.0 ] ); + + dlas2.ndarray(); // $ExpectError + dlas2.ndarray( 2.0 ); // $ExpectError + dlas2.ndarray( 2.0, 3.0 ); // $ExpectError + dlas2.ndarray( 2.0, 3.0, 4.0 ); // $ExpectError + dlas2.ndarray( 2.0, 3.0, 4.0, out ); // $ExpectError + dlas2.ndarray( 2.0, 3.0, 4.0, out, 1 ); // $ExpectError + dlas2.ndarray( 2.0, 3.0, 4.0, out, 1, 0, 10 ); // $ExpectError +} diff --git a/lib/node_modules/@stdlib/lapack/base/dlas2/examples/index.js b/lib/node_modules/@stdlib/lapack/base/dlas2/examples/index.js new file mode 100644 index 00000000000..47dfa8a98b5 --- /dev/null +++ b/lib/node_modules/@stdlib/lapack/base/dlas2/examples/index.js @@ -0,0 +1,26 @@ +/** +* @license Apache-2.0 +* +* Copyright (c) 2024 The Stdlib Authors. +* +* Licensed under the Apache License, Version 2.0 (the "License"); +* you may not use this file except in compliance with the License. +* You may obtain a copy of the License at +* +* http://www.apache.org/licenses/LICENSE-2.0 +* +* Unless required by applicable law or agreed to in writing, software +* distributed under the License is distributed on an "AS IS" BASIS, +* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +* See the License for the specific language governing permissions and +* limitations under the License. +*/ + +'use strict'; + +var Float64Array = require( '@stdlib/array/float64' ); +var dlas2 = require( './../lib' ); + +var out = new Float64Array( 2 ); +dlas2( 1.0, 2.0, 3.0, out ); +console.log( out ); diff --git a/lib/node_modules/@stdlib/lapack/base/dlas2/lib/base.js b/lib/node_modules/@stdlib/lapack/base/dlas2/lib/base.js new file mode 100644 index 00000000000..9891cc976f1 --- /dev/null +++ b/lib/node_modules/@stdlib/lapack/base/dlas2/lib/base.js @@ -0,0 +1,106 @@ +/** +* @license Apache-2.0 +* +* Copyright (c) 2024 The Stdlib Authors. +* +* Licensed under the Apache License, Version 2.0 (the "License"); +* you may not use this file except in compliance with the License. +* You may obtain a copy of the License at +* +* http://www.apache.org/licenses/LICENSE-2.0 +* +* Unless required by applicable law or agreed to in writing, software +* distributed under the License is distributed on an "AS IS" BASIS, +* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +* See the License for the specific language governing permissions and +* limitations under the License. +*/ + +'use strict'; + +// MODULES // + +var sqrt = require( '@stdlib/math/base/special/sqrt' ); +var abs = require( '@stdlib/math/base/special/abs' ); +var max = require( '@stdlib/math/base/special/max' ); +var min = require( '@stdlib/math/base/special/min' ); +var pow = require( '@stdlib/math/base/special/pow' ); + + +// MAIN // + +/** +* Computes the singular values of `2x2` matrix. +* +* @private +* @param {number} F - the (0,0) element of a `2x2` matrix +* @param {number} G - the (0,1) element of a `2x2` matrix +* @param {number} H - the (1,1) element of a `2x2` matrix +* @param {Float64Array} out - output array containing the smaller and larger singular values respectively +* @param {integer} strideOut - stride length for `out` +* @param {NonNegativeInteger} offsetOut - starting index of `out` +* @returns {Float64Array} output array +* +* @example +* var Float64Array = require( '@stdlib/array/float64' ); +* +* var out = new Float64Array( 2 ); +* dlas2( 1.0, 2.0, 3.0, out, 1, 0 ); +* // out => [ ~0.822, ~3.65 ] +*/ +function dlas2( F, G, H, out, strideOut, offsetOut ) { + var ssmax; + var ssmin; + var fhmn; + var fhmx; + var as; + var at; + var au; + var fa; + var ga; + var ha; + var c; + + fa = abs( F ); + ga = abs( G ); + ha = abs( H ); + fhmn = min( fa, ha ); + fhmx = max( fa, ha ); + if ( fhmn === 0.0 ) { + ssmin = 0.0; + if ( fhmx === 0.0 ) { + ssmax = ga; + } else { + ssmax = max( fhmx, ga ) * sqrt( 1.0 + pow( min( fhmx, ga ) / max( fhmx, ga ), 2 ) ); + } + } else if ( ga < fhmx ) { + as = 1.0 + ( fhmn / fhmx ); + at = ( fhmx - fhmn ) / fhmx; + au = pow( ga / fhmx, 2 ); + c = 2.0 / ( sqrt( ( as * as ) + au ) + sqrt( ( at * at ) + au ) ); + ssmin = fhmn * c; + ssmax = fhmx / c; + } else { + au = fhmx / ga; + if ( au === 0.0 ) { + // Avoid possible harmful underflow if exponent range asymmetric. + ssmin = ( fhmn * fhmx ) / ga; + ssmax = ga; + } else { + as = 1.0 + ( fhmn / fhmx ); + at = ( fhmx - fhmn ) / fhmx; + c = 1.0 / ( sqrt( 1.0 + pow( as * au, 2 ) ) + sqrt( 1.0 + pow( at * au, 2 ) ) ); + ssmin = ( fhmn * c ) * au; + ssmin += ssmin; + ssmax = ga / ( c + c ); + } + } + out[ offsetOut ] = ssmin; + out[ offsetOut + strideOut ] = ssmax; + return out; +} + + +// EXPORTS // + +module.exports = dlas2; diff --git a/lib/node_modules/@stdlib/lapack/base/dlas2/lib/dlas2.js b/lib/node_modules/@stdlib/lapack/base/dlas2/lib/dlas2.js new file mode 100644 index 00000000000..a62c7408525 --- /dev/null +++ b/lib/node_modules/@stdlib/lapack/base/dlas2/lib/dlas2.js @@ -0,0 +1,51 @@ +/** +* @license Apache-2.0 +* +* Copyright (c) 2024 The Stdlib Authors. +* +* Licensed under the Apache License, Version 2.0 (the "License"); +* you may not use this file except in compliance with the License. +* You may obtain a copy of the License at +* +* http://www.apache.org/licenses/LICENSE-2.0 +* +* Unless required by applicable law or agreed to in writing, software +* distributed under the License is distributed on an "AS IS" BASIS, +* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +* See the License for the specific language governing permissions and +* limitations under the License. +*/ + +'use strict'; + +// MODULES // + +var base = require( './base.js' ); + + +// MAIN // + +/** +* Computes the singular values of `2x2` matrix. +* +* @param {number} F - the (0,0) element of a `2x2` matrix +* @param {number} G - the (0,1) element of a `2x2` matrix +* @param {number} H - the (1,1) element of a `2x2` matrix +* @param {Float64Array} out - output array containing the smaller and larger singular values respectively +* @returns {Float64Array} output array +* +* @example +* var Float64Array = require( '@stdlib/array/float64' ); +* +* var out = new Float64Array( 2 ); +* dlas2( 1.0, 2.0, 3.0, out ); +* // out => [ ~0.822, ~3.65 ] +*/ +function dlas2( F, G, H, out ) { + return base( F, G, H, out, 1, 0 ); +} + + +// EXPORTS // + +module.exports = dlas2; diff --git a/lib/node_modules/@stdlib/lapack/base/dlas2/lib/index.js b/lib/node_modules/@stdlib/lapack/base/dlas2/lib/index.js new file mode 100644 index 00000000000..16e497008d8 --- /dev/null +++ b/lib/node_modules/@stdlib/lapack/base/dlas2/lib/index.js @@ -0,0 +1,64 @@ +/** +* @license Apache-2.0 +* +* Copyright (c) 2024 The Stdlib Authors. +* +* Licensed under the Apache License, Version 2.0 (the "License"); +* you may not use this file except in compliance with the License. +* You may obtain a copy of the License at +* +* http://www.apache.org/licenses/LICENSE-2.0 +* +* Unless required by applicable law or agreed to in writing, software +* distributed under the License is distributed on an "AS IS" BASIS, +* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +* See the License for the specific language governing permissions and +* limitations under the License. +*/ + +'use strict'; + +/** +* LAPACK routine to compute the singular values of `2x2` matrix. +* +* @module @stdlib/lapack/base/dlas2 +* +* @example +* var Float64Array = require( '@stdlib/array/float64' ); +* var dlas2 = require( '@stdlib/lapack/base/dlas2' ); +* +* var out = new Float64Array( 2 ); +* dlas2( 1.0, 2.0, 3.0, out ); +* // out => [ ~0.822, ~3.65 ] +* +* @example +* var Float64Array = require( '@stdlib/array/float64' ); +* var dlas2 = require( '@stdlib/lapack/base/dlas2' ); +* +* var out = new Float64Array( 2 ); +* dlas2.ndarray( 1.0, 2.0, 3.0, out, 1, 0 ); +* // out => [ ~0.822, ~3.65 ] +*/ + +// 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 dlas2; +var tmp = tryRequire( join( __dirname, './native.js' ) ); +if ( isError( tmp ) ) { + dlas2 = main; +} else { + dlas2 = tmp; +} + + +// EXPORTS // + +module.exports = dlas2; diff --git a/lib/node_modules/@stdlib/lapack/base/dlas2/lib/main.js b/lib/node_modules/@stdlib/lapack/base/dlas2/lib/main.js new file mode 100644 index 00000000000..59c5d7a1c29 --- /dev/null +++ b/lib/node_modules/@stdlib/lapack/base/dlas2/lib/main.js @@ -0,0 +1,35 @@ +/** +* @license Apache-2.0 +* +* Copyright (c) 2024 The Stdlib Authors. +* +* Licensed under the Apache License, Version 2.0 (the "License"); +* you may not use this file except in compliance with the License. +* You may obtain a copy of the License at +* +* http://www.apache.org/licenses/LICENSE-2.0 +* +* Unless required by applicable law or agreed to in writing, software +* distributed under the License is distributed on an "AS IS" BASIS, +* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +* See the License for the specific language governing permissions and +* limitations under the License. +*/ + +'use strict'; + +// MODULES // + +var setReadOnly = require( '@stdlib/utils/define-nonenumerable-read-only-property' ); +var dlas2 = require( './dlas2.js' ); +var ndarray = require( './ndarray.js' ); + + +// MAIN // + +setReadOnly( dlas2, 'ndarray', ndarray ); + + +// EXPORTS // + +module.exports = dlas2; diff --git a/lib/node_modules/@stdlib/lapack/base/dlas2/lib/ndarray.js b/lib/node_modules/@stdlib/lapack/base/dlas2/lib/ndarray.js new file mode 100644 index 00000000000..2acdb781b99 --- /dev/null +++ b/lib/node_modules/@stdlib/lapack/base/dlas2/lib/ndarray.js @@ -0,0 +1,53 @@ +/** +* @license Apache-2.0 +* +* Copyright (c) 2024 The Stdlib Authors. +* +* Licensed under the Apache License, Version 2.0 (the "License"); +* you may not use this file except in compliance with the License. +* You may obtain a copy of the License at +* +* http://www.apache.org/licenses/LICENSE-2.0 +* +* Unless required by applicable law or agreed to in writing, software +* distributed under the License is distributed on an "AS IS" BASIS, +* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +* See the License for the specific language governing permissions and +* limitations under the License. +*/ + +'use strict'; + +// MODULES // + +var base = require( './base.js' ); + + +// MAIN // + +/** +* Computes the singular values of `2x2` matrix using alternative indexing semantics. +* +* @name dlas2 +* @type {Function} +* @param {number} F - the (0,0) element of a `2x2` matrix +* @param {number} G - the (0,1) element of a `2x2` matrix +* @param {number} H - the (1,1) element of a `2x2` matrix +* @param {Float64Array} out - output array containing the smaller and larger singular values respectively +* @param {integer} strideOut - stride length for `out` +* @param {NonNegativeInteger} offsetOut - starting index of `out` +* @returns {Float64Array} output array +* +* @example +* var Float64Array = require( '@stdlib/array/float64' ); +* +* var out = new Float64Array( 2 ); +* dlas2( 1.0, 2.0, 3.0, out, 1, 0 ); +* // out => [ ~0.822, ~3.65 ] +*/ +var dlas2 = base; + + +// EXPORTS // + +module.exports = dlas2; diff --git a/lib/node_modules/@stdlib/lapack/base/dlas2/package.json b/lib/node_modules/@stdlib/lapack/base/dlas2/package.json new file mode 100644 index 00000000000..44f4c43f2c4 --- /dev/null +++ b/lib/node_modules/@stdlib/lapack/base/dlas2/package.json @@ -0,0 +1,69 @@ +{ + "name": "@stdlib/lapack/base/dlas2", + "version": "0.0.0", + "description": "Compute the singular values of `2x2` matrix.", + "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", + "dlas2", + "singular", + "linear", + "algebra", + "subroutines", + "array", + "ndarray", + "matrix", + "float64", + "double", + "float64array" + ] +} diff --git a/lib/node_modules/@stdlib/lapack/base/dlas2/test/test.dlas2.js b/lib/node_modules/@stdlib/lapack/base/dlas2/test/test.dlas2.js new file mode 100644 index 00000000000..5cd65b3cb75 --- /dev/null +++ b/lib/node_modules/@stdlib/lapack/base/dlas2/test/test.dlas2.js @@ -0,0 +1,114 @@ +/** +* @license Apache-2.0 +* +* Copyright (c) 2024 The Stdlib Authors. +* +* Licensed under the Apache License, Version 2.0 (the "License"); +* you may not use this file except in compliance with the License. +* You may obtain a copy of the License at +* +* http://www.apache.org/licenses/LICENSE-2.0 +* +* Unless required by applicable law or agreed to in writing, software +* distributed under the License is distributed on an "AS IS" BASIS, +* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +* See the License for the specific language governing permissions and +* limitations under the License. +*/ + +'use strict'; + +// MODULES // + +var tape = require( 'tape' ); +var Float64Array = require( '@stdlib/array/float64' ); +var EPS = require( '@stdlib/constants/float64/eps' ); +var abs = require( '@stdlib/math/base/special/abs' ); +var dlas2 = require( './../lib/dlas2.js' ); + + +// FUNCTIONS // + +/** +* Tests for element-wise approximate equality. +* +* @private +* @param {Object} t - test object +* @param {Collection} actual - actual values +* @param {Collection} expected - expected values +* @param {number} rtol - relative tolerance +*/ +function isApprox( t, actual, expected, rtol ) { + var delta; + var tol; + var i; + + t.strictEqual( actual.length, expected.length, 'returns expected value' ); + for ( i = 0; i < expected.length; i++ ) { + if ( actual[ i ] === expected[ i ] ) { + t.strictEqual( actual[ i ], expected[ i ], 'returns expected value' ); + } else { + delta = abs( actual[ i ] - expected[ i ] ); + tol = rtol * EPS * abs( expected[ i ] ); + t.ok( delta <= tol, 'within tolerance. actual: '+actual[ i ]+'. expected: '+expected[ i ]+'. delta: '+delta+'. tol: '+tol+'.' ); + } + } +} + + +// TESTS // + +tape( 'main export is a function', function test( t ) { + t.ok( true, __filename ); + t.strictEqual( typeof dlas2, 'function', 'main export is a function' ); + t.end(); +}); + +tape( 'the function has an arity of 4', function test( t ) { + t.strictEqual( dlas2.length, 4, 'returns expected value' ); + t.end(); +}); + +tape( 'the function computes the eigenvalues of a 2x2 symmetric matrix', function test( t ) { + var expected; + var out; + + out = new Float64Array( 2 ); + out = dlas2( 2.0, 3.0, 4.0, out ); + expected = new Float64Array( [ 1.5513263285176897, 5.1568776039816795 ] ); + isApprox( t, out, expected, 1.0 ); + + out = dlas2( -1.0, 3.0, 9.4, out ); + + expected = new Float64Array( [ 0.9522030268983716, 9.871844275289476 ] ); + isApprox( t, out, expected, 1.0 ); + + out = dlas2( -99.9, -67.124, -4.24, out ); + + expected = new Float64Array( [ 3.518670509963777, 120.37955779052484 ] ); + isApprox( t, out, expected, 1.0 ); + t.end(); +}); + +tape( 'the function computes eigenvalues of a 2x2 diagonal matrix', function test( t ) { + var expected; + var out; + + out = new Float64Array( 2 ); + out = dlas2( 2.0, 0.0, 4.0, out ); + expected = new Float64Array( [ 2, 4 ] ); + isApprox( t, out, expected, 1.0 ); + + out = dlas2( -1.0, 0.0, 9.4, out ); + expected = new Float64Array( [ 1, 9.4 ] ); + isApprox( t, out, expected, 1.0 ); + + out = dlas2( -99.9, 0.0, -4.24, out ); + expected = new Float64Array( [ 4.24, 99.9 ] ); + isApprox( t, out, expected, 1.0 ); + + out = dlas2( 1.0, 0.0, 1.0, out ); + expected = new Float64Array( [ 1.0, 1.0 ] ); + isApprox( t, out, expected, 1.0 ); + t.end(); +}); diff --git a/lib/node_modules/@stdlib/lapack/base/dlas2/test/test.js b/lib/node_modules/@stdlib/lapack/base/dlas2/test/test.js new file mode 100644 index 00000000000..c09071170ce --- /dev/null +++ b/lib/node_modules/@stdlib/lapack/base/dlas2/test/test.js @@ -0,0 +1,82 @@ +/** +* @license Apache-2.0 +* +* Copyright (c) 2024 The Stdlib Authors. +* +* Licensed under the Apache License, Version 2.0 (the "License"); +* you may not use this file except in compliance with the License. +* You may obtain a copy of the License at +* +* http://www.apache.org/licenses/LICENSE-2.0 +* +* Unless required by applicable law or agreed to in writing, software +* distributed under the License is distributed on an "AS IS" BASIS, +* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +* See the License for the specific language governing permissions and +* limitations under the License. +*/ + +'use strict'; + +// MODULES // + +var tape = require( 'tape' ); +var proxyquire = require( 'proxyquire' ); +var IS_BROWSER = require( '@stdlib/assert/is-browser' ); +var dlas2 = 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 dlas2, '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 dlas2.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 dlas2 = proxyquire( './../lib', { + '@stdlib/utils/try-require': tryRequire + }); + + t.strictEqual( dlas2, 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 dlas2; + var main; + + main = require( './../lib/dlas2.js' ); + + dlas2 = proxyquire( './../lib', { + '@stdlib/utils/try-require': tryRequire + }); + + t.strictEqual( dlas2, main, 'returns expected value' ); + t.end(); + + function tryRequire() { + return new Error( 'Cannot find module' ); + } +}); diff --git a/lib/node_modules/@stdlib/lapack/base/dlas2/test/test.ndarray.js b/lib/node_modules/@stdlib/lapack/base/dlas2/test/test.ndarray.js new file mode 100644 index 00000000000..54e4f200f26 --- /dev/null +++ b/lib/node_modules/@stdlib/lapack/base/dlas2/test/test.ndarray.js @@ -0,0 +1,92 @@ +/** +* @license Apache-2.0 +* +* Copyright (c) 2024 The Stdlib Authors. +* +* Licensed under the Apache License, Version 2.0 (the "License"); +* you may not use this file except in compliance with the License. +* You may obtain a copy of the License at +* +* http://www.apache.org/licenses/LICENSE-2.0 +* +* Unless required by applicable law or agreed to in writing, software +* distributed under the License is distributed on an "AS IS" BASIS, +* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +* See the License for the specific language governing permissions and +* limitations under the License. +*/ + +'use strict'; + +// MODULES // + +var tape = require( 'tape' ); +var Float64Array = require( '@stdlib/array/float64' ); +var EPS = require( '@stdlib/constants/float64/eps' ); +var abs = require( '@stdlib/math/base/special/abs' ); +var dlas2 = require( './../lib/ndarray.js' ); + + +// FUNCTIONS // + +/** +* Tests for element-wise approximate equality. +* +* @private +* @param {Object} t - test object +* @param {Collection} actual - actual values +* @param {Collection} expected - expected values +* @param {number} rtol - relative tolerance +*/ +function isApprox( t, actual, expected, rtol ) { + var delta; + var tol; + var i; + + t.strictEqual( actual.length, expected.length, 'returns expected value' ); + for ( i = 0; i < expected.length; i++ ) { + if ( actual[ i ] === expected[ i ] ) { + t.strictEqual( actual[ i ], expected[ i ], 'returns expected value' ); + } else { + delta = abs( actual[ i ] - expected[ i ] ); + tol = rtol * EPS * abs( expected[ i ] ); + t.ok( delta <= tol, 'within tolerance. actual: '+actual[ i ]+'. expected: '+expected[ i ]+'. delta: '+delta+'. tol: '+tol+'.' ); + } + } +} + + +// TESTS // + +tape( 'main export is a function', function test( t ) { + t.ok( true, __filename ); + t.strictEqual( typeof dlas2, 'function', 'main export is a function' ); + t.end(); +}); + +tape( 'the function has an arity of 6', function test( t ) { + t.strictEqual( dlas2.length, 6, 'returns expected value' ); + t.end(); +}); + +tape( 'the function supports complex access pattern to store computed values', function test( t ) { + var expected; + var out; + + out = new Float64Array( [ 999.9, 999.9, 0.0, 999.9, 999.9, 0.0 ] ); + expected = new Float64Array( [ 999.9, 999.9, 1.5513263285176897, 999.9, 999.9, 5.1568776039816795 ] ); + out = dlas2( 2.0, 3.0, 4.0, out, 3, 2 ); + isApprox( t, out, expected, 1.0 ); + t.end(); +}); + +tape( 'the function supports accessing elements in reverse order to store computed values', function test( t ) { + var expected; + var out; + + out = new Float64Array( [ 999.9, 999.9, 0.0, 999.9, 999.9, 0.0 ] ); + expected = new Float64Array( [ 999.9, 999.9, 5.1568776039816795, 999.9, 999.9, 1.5513263285176897 ] ); + out = dlas2( 2.0, 3.0, 4.0, out, -3, out.length-1 ); + isApprox( t, out, expected, 1.0 ); + t.end(); +});