feat: add lapack/base/dlaqr5

lib/node_modules/@stdlib/lapack/base/dlaqr5/lib/dlaqr1.js

@@ -0,0 +1,124 @@
+/**
+* @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 abs = require( '@stdlib/math/base/special/fast/abs' );
+
+
+// MAIN //
+
+/**
+* Given a 2-by-2 or a 3-by-3 matrix `H`, this function sets `V` to a scalar multiple of the first column of `K` where `K = (H - (sr1 + i*si1)*I)*(H - (sr2 + i*si2)*I)`.
+*
+* ## Notes
+*
+* -   It is expected that either `sr1 = sr2` and `si1 + si2 = 0` or `si1 = si2 = 0` (i.e., they represent complex conjugate values).
+* -   This is useful for starting double implicit shift bulges in the QR algorithm.
+* -   `V` should have at least `N` indexed elements.
+*
+* @private
+* @param {PositiveInteger} N - number of row/columns in `H`
+* @param {Float64Array} H - input matrix
+* @param {integer} strideH1 - stride of the first dimension of `H`
+* @param {integer} strideH2 - stride of the second dimension of `H`
+* @param {NonNegativeInteger} offsetH - index offset for `H`
+* @param {number} sr1 - real part of the first conjugate complex shift
+* @param {number} si1 - imaginary part of the first conjugate complex shift
+* @param {number} sr2 - real part of the second conjugate complex shift
+* @param {number} si2 - imaginary part of the second conjugate complex shift
+* @param {Float64Array} V - output array
+* @param {integer} strideV - stride length for `V`
+* @param {NonNegativeInteger} offsetV - index offset for `V`
+* @returns {Float64Array} `V`
+*
+* @example
+* var Float64Array = require( '@stdlib/array/float64' );
+*
+* var H = new Float64Array( [ 1.0, 3.0, 2.0, 2.0, 4.0, 6.0, 0.0, 5.0, 7.0 ] ); // => [ [ 1.0, 3.0, 2.0 ], [ 2.0, 4.0, 6.0 ], [ 0.0, 5.0, 7.0 ] ]
+* var V = new Float64Array( 3 );
+*
+* var out = dlaqr1( 3, H, 3, 1, 0, 1.5, 0.0, 2.5, 0.0, V, 1, 0 );
+* // returns <Float64Array>[ ~1.93, ~0.57, ~2.86 ]
+*/
+function dlaqr1( N, H, strideH1, strideH2, offsetH, sr1, si1, sr2, si2, V, strideV, offsetV ) { // eslint-disable-line max-params, max-len
+	var h21s;
+	var h31s;
+	var h11;
+	var h12;
+	var h13;
+	var h21;
+	var h22;
+	var h23;
+	var h31;
+	var h32;
+	var h33;
+	var iv;
+	var s;
+	var i;
+
+	h11 = offsetH;
+	h12 = offsetH + strideH2;
+	h21 = offsetH + strideH1;
+	h22 = h21 + strideH2;
+
+	if ( N === 2 ) {
+		s = abs( H[ h11 ] - sr2 ) + abs( si2 ) + abs( H[ h21 ] );
+		if ( s === 0.0 ) {
+			V[ offsetV ] = 0.0;
+			V[ strideV + offsetV ] = 0.0;
+			return V;
+		}
+		h21s = H[ h21 ] / s;
+		V[ offsetV ] = ( h21s * H[ h12 ] ) + ( ( H[ h11 ]-sr1 ) * ( ( H[ h11 ]-sr2 ) / s ) ) - ( si1*( si2 / s ) ); // eslint-disable-line max-len
+		V[ offsetV + strideV ] = h21s*( H[ h11 ]+H[ h22 ]-sr1-sr2 );
+		return V;
+	}
+
+	h13 = h12 + strideH2;
+	h31 = h21 + strideH1;
+	h33 = h22 + strideH1 + strideH2;
+	h23 = h22 + strideH2;
+	h32 = h22 + strideH1;
+
+	s = abs( H[ h11 ]-sr2 ) + abs( si2 ) + abs( H[ h21 ] ) + abs( H[ h31 ] );
+	if ( s === 0.0 ) {
+		iv = offsetV;
+		for ( i = 0; i < 3; i++ ) {
+			V[ iv ] = 0.0;
+			iv += strideV;
+		}
+		return V;
+	}
+	h21s = H[ h21 ] / s;
+	h31s = H[ h31 ] / s;
+	iv = offsetV;
+	V[ iv ] = (( H[ h11 ]-sr1 )*( ( H[ h11 ]-sr2 ) / s )) - (si1*( si2 / s )) + ((H[ h12 ]*h21s) + (H[ h13 ]*h31s)); // eslint-disable-line max-len
+	iv += strideV;
+	V[ iv ] = (h21s*( H[ h11 ]+H[ h22 ]-sr1-sr2 )) + (H[ h23 ]*h31s);
+	iv += strideV;
+	V[ iv ] = (h31s*( H[ h11 ]+H[ h33 ]-sr1-sr2 )) + (h21s*H[ h32 ]);
+	return V;
+}
+
+
+// EXPORTS //
+
+module.exports = dlaqr1;

lib/node_modules/@stdlib/lapack/base/dlaqr5/lib/dlaqr5.js

@@ -0,0 +1,132 @@
+/**
+* @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, max-params */
+
+'use strict';
+
+// MODULES //
+
+var isLayout = require( '@stdlib/blas/base/assert/is-layout' );
+var isRowMajor = require( '@stdlib/ndarray/base/assert/is-row-major-string' );
+var format = require( '@stdlib/string/format' );
+var base = require( './base.js' );
+
+
+// MAIN //
+
+/**
+* Performs a single, small shift multiline QR sweep.
+*
+* @param {string} order - storage layout
+* @param {boolean} wantT - boolean value indicating whether the quasi triangular Schur factor is being computed
+* @param {boolean} wantZ - boolean value indicating whether the orthogonal Schur factor is being computed
+* @param {integer} kacc22 - integer value ranging from 0 to 2 (inclusive), specifies the computation mode for far-from-diagonal updates
+* @param {integer} N - number of rows/columns in `H`
+* @param {integer} KTOP - first row and column of the submatrix of `H` where the QR sweep will be applied
+* @param {integer} KBOT - last row and column of the submatrix of `H` where the QR sweep will be applied
+* @param {integer} nshifts - number of simultaneous shifts, must be even and positive
+* @param {Float64Array} SR - real parts of the shifts of origin that define the QR sweep
+* @param {Float64Array} SI - imaginary parts of the shifts of origin that define the QR sweep
+* @param {Float64Array} H - input upper hessenberg matrix
+* @param {PositiveInteger} LDH - stride of the first dimension of `H` (a.k.a., leading dimension of the matrix `H`)
+* @param {integer} iloZ - starting row from where the transformation must be applied if `wantZ` is true
+* @param {integer} ihiZ - ending row from where the transformation must be applied if `wantZ` is true
+* @param {Float64Array} Z - the QR sweep orthogonal similarity transformation is accumulated into `Z` between the rows and columns `iloZ` and `ihiZ` if `wantZ` is true, otherwise `Z` is not referenced
+* @param {PositiveInteger} LDZ - stride of the first dimension of `Z` (a.k.a., leading dimension of the matrix `Z`)
+* @param {Float64Array} V - householder vectors are stored column-wise, used in forming bulges for the multi shift QR algorithm
+* @param {PositiveInteger} LDV - stride of the first dimension of `V` (a.k.a., leading dimension of the matrix `V`)
+* @param {Float64Array} U - used to hold the product of householder reflector that represent accumulated orthogonal transformations from the bulge-chasing process
+* @param {PositiveInteger} LDU - stride of the first dimension of `U` (a.k.a., leading dimension of the matrix `U`)
+* @param {integer} NH - number of columns in `WH` available for workspace
+* @param {Float64Array} WH - workspace array
+* @param {PositiveInteger} LDWH - stride of the first dimension of `WH` (a.k.a., leading dimension of the matrix `WH`)
+* @param {integer} NV - number of rows in `WV` available for workspace
+* @param {Float64Array} WV - workspace array
+* @param {PositiveInteger} LDWV - stride of the first dimension of `WV` (a.k.a., leading dimension of the matrix `WV`)
+* @throws {TypeError} first argument must be a valid order
+* @throws {RangeError} fourth argument must be greater than or equal to max(1,N)
+* @returns {void} permuted matrix `A`
+*
+* @example
+* var Float64Array = require( '@stdlib/array/float64' );
+*
+* var H = new Float64Array( [ 1.0, 1.0, 0.0, 0.0, 0.0, 2.0, 1.5, 0.0, 0.0, 0.0, 3, 2.0, 0.0, 0.0, 0.0, 4.0 ] );
+* var Z = new Float64Array( [ 1.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0, 0.0, 1.0 ] );
+* var V = new Float64Array( 6 );
+* var U = new Float64Array( 10 );
+* var WH = new Float64Array( 16 );
+* var WV = new Float64Array( 16 );
+* var SR = new Float64Array( [ 1.1, 2.2 ] );
+* var SI = new Float64Array( [ 0.0, 0.0 ] );
+*
+* dlaqr5( 'row-major', true, true, 0, 4, 1, 4, 2, SR, SI, H, 4, 1, 4, Z, 4, V, 2, U, 2, 4, WH, 4, 4, WV, 4 );
+* // H => <Float64Array>[ 1.0, 1.0, 0.0, 0.0, 0.0, 2.0, 1.5, 0.0, 0.0, 0.0, 3, 2.0, 0.0, 0.0, 0.0, 4.0 ]
+* // Z => <Float64Array>[ 1.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0, 0.0, 1.0 ]
+*/
+function dlaqr5( order, wantT, wantZ, kacc22, N, KTOP, KBOT, nshifts, SR, SI, H, LDH, iloZ, ihiZ, Z, LDZ, V, LDV, U, LDU, NH, WH, LDWH, NV, WV, LDWV ) {
+	var swh1;
+	var swh2;
+	var swv1;
+	var swv2;
+	var sh1;
+	var sh2;
+	var sz1;
+	var sz2;
+	var sv1;
+	var sv2;
+	var su1;
+	var su2;
+
+	if ( !isLayout( order ) ) {
+		throw new TypeError( format( 'invalid argument. First argument must be a valid order. Value: `%s`.', order ) );
+	}
+	if ( isRowMajor( order ) ) {
+		sh1 = LDH;
+		sh2 = 1;
+		sz1 = LDZ;
+		sz2 = 1;
+		sv1 = LDV;
+		sv2 = 1;
+		su1 = LDU;
+		su2 = 1;
+		swh1 = LDWH;
+		swh2 = 1;
+		swv1 = LDWV;
+		swv2 = 1;
+	} else { // order === 'col-major'
+		sh1 = 1;
+		sh2 = LDH;
+		sz1 = 1;
+		sz2 = LDZ;
+		sv1 = 1;
+		sv2 = LDV;
+		su1 = 1;
+		su2 = LDU;
+		swh1 = 1;
+		swh2 = LDWH;
+		swv1 = 1;
+		swv2 = LDWV;
+	}
+	base( wantT, wantZ, kacc22, N, KTOP, KBOT, nshifts, SR, 1, 0, SI, 1, 0, H, sh1, sh2, 0, iloZ, ihiZ, Z, sz1, sz2, 0, V, sv1, sv2, 0, U, su1, su2, 0, NH, WH, swh1, swh2, 0, NV, WV, swv1, swv2, 0 );
+}
+
+
+// EXPORTS //
+
+module.exports = dlaqr5;