feat: add lapack/base/dorml2

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

@@ -0,0 +1,172 @@
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2026 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 dlarf1f = require( '@stdlib/lapack/base/dlarf1f' ).ndarray;
+
+
+// FUNCTIONS //
+
+/**
+* Tests whether an operation should be applied to the left side.
+*
+* @private
+* @param {string} side - operation side
+* @returns {boolean} boolean indicating if an operation should be applied to the left side
+*/
+function isLeftSide( side ) {
+	return side === 'left';
+}
+
+
+// MAIN //
+
+/**
+* Multiply a general matrix by the orthogonal matrix from a LQ factorization determined by `DGELQF`.
+*
+* ## Notes
+*
+* -   `Q` is a real orthogonal matrix defined as the product of k elementary reflectors, Q = H(k) . . . H(2) H(1) as returned by `DGELQF`.
+*
+* -   `Q` is of order `M` if SIDE = 'left' and of order `N` if SIDE = 'R'.
+*
+* -   `DORML2` overwrites the general real `M` by `N` matrix `C` with,
+*
+*     -   `Q * C`  if SIDE = 'left' and TRANS = 'no-transpose', or
+*     -   `Q^T* C`  if SIDE = 'left' and TRANS = 'transpose', or
+*     -   `C * Q`  if SIDE = 'right' and TRANS = 'no-transpose', or
+*     -   `C * Q**T` if SIDE = 'right' and TRANS = 'transpose'.
+*
+* @private
+* @param {string} side - specifies the side of multiplication with `C`
+* @param {string} trans - `'no-transpose'` for `Q`, `'transpose'` for `Q^T`
+* @param {NonNegativeInteger} M - number of rows of `C`
+* @param {NonNegativeInteger} N - number of columns of `C`
+* @param {NonNegativeInteger} K - number of elementary reflectors
+* @param {Float64Array} A - reflector vectors from `DGELQ2`
+* @param {integer} strideA1 - stride of the first dimension of A
+* @param {integer} strideA2 - stride of the second dimension of A
+* @param {NonNegativeInteger} offsetA - starting index for A
+* @param {Float64Array} TAU - scalar factors of reflectors
+* @param {integer} strideTAU - stride for TAU
+* @param {NonNegativeInteger} offsetTAU - starting index for TAU
+* @param {Float64Array} C - input/output matrix
+* @param {integer} strideC1 - stride of the first dimension of `C`
+* @param {integer} strideC2 - stride of the second dimension of `C`
+* @param {NonNegativeInteger} offsetC - starting index for `C`
+* @param {Float64Array} WORK - workspace array
+* @param {integer} strideWORK - stride for `WORK`
+* @param {NonNegativeInteger} offsetWORK - starting index for `WORK`
+* @returns {integer} status code (0 if successful)
+*
+* @example
+* var Float64Array = require( '@stdlib/array/float64' );
+*
+* var A = new Float64Array( [ 1, 0 ] );
+* var TAU = new Float64Array( [ 2 ] );
+* var C = new Float64Array( [ 1, 3, 5, 2, 4, 6 ] );
+* var WORK = new Float64Array( 3 );
+*
+* var info = dorml2( 'left', 'no-transpose', 2, 3, 1, A, 2, 1, 0, TAU, 1, 0, C, 3, 1, 0, WORK, 1, 0 );
+* // returns 0
+* // C => <Float64Array>[ -1, -3, -5, 2, 4, 6 ]
+* // WORK => <Float64Array>[ 1, 3, 5 ]
+*/
+function dorml2( side, trans, M, N, K, A, strideA1, strideA2, offsetA, TAU, strideTAU, offsetTAU, C, strideC1, strideC2, offsetC, WORK, strideWORK, offsetWORK ) {
+	var isTrans;
+	var isLeft;
+	var idx0;
+	var idx1;
+	var idx2;
+	var mi;
+	var ni;
+	var ic;
+	var jc;
+	var i1;
+	var i2;
+	var i3;
+	var i;
+
+	isLeft = isLeftSide( side );
+	isTrans = ( trans === 'transpose' );
+
+	// Quick return if possible
+	if ( M === 0 || N === 0 || K === 0 ) {
+		return 0;
+	}
+
+	if ( ( isLeft && !isTrans ) || ( !isLeft && isTrans ) ) {
+		i1 = 0;
+		i2 = K - 1;
+		i3 = 1;
+	} else {
+		i1 = K - 1;
+		i2 = 0;
+		i3 = -1;
+	}
+
+	if ( isLeft ) {
+		ni = N;
+		jc = 0;
+
+		idx0 = offsetA + ( i1*strideA1 ) + ( i1*strideA2 );
+		idx1 = offsetTAU + ( i1*strideTAU );
+		idx2 = offsetC + ( i1*strideC1 ) + ( jc*strideC2 );
+		for ( i = i1; ( i3 > 0 ) ? ( i <= i2 ) : ( i >= i2 ); i += i3 ) {
+			// Apply H(i) to C(i:M-1, 0:N-1)
+			mi = M - i;
+			ic = i;
+
+			// Apply H(i): the reflector vector is row i of A starting at column i,
+			dlarf1f( side, mi, ni, A, strideA2, idx0, TAU[ idx1 ], C, strideC1, strideC2, idx2, WORK, strideWORK, offsetWORK );
+			idx0 += i3*( strideA1 + strideA2 );
+			idx1 += i3*strideTAU;
+			idx2 += i3*strideC1;
+		}
+	} else {
+		mi = M;
+		ic = 0;
+
+		idx0 = offsetA + ( i1*strideA1 ) + ( i1*strideA2 );
+		idx1 = offsetTAU + ( i1*strideTAU );
+		idx2 = offsetC + ( ic*strideC1 ) + ( i1*strideC2 );
+		for ( i = i1; ( i3 > 0 ) ? ( i <= i2 ) : ( i >= i2 ); i += i3 ) {
+			// Apply H(i) to C(0:M-1, i:N-1)
+			ni = N - i;
+			jc = i;
+
+			// Apply H(i): the reflector vector is row i of A starting at column i,
+			dlarf1f( side, mi, ni, A, strideA2, idx0, TAU[ idx1 ], C, strideC1, strideC2, idx2, WORK, strideWORK, offsetWORK );
+			idx0 += i3*( strideA1 + strideA2 );
+			idx1 += i3*strideTAU;
+			idx2 += i3*strideC2;
+		}
+	}
+
+	return 0;
+}
+
+
+// EXPORTS //
+
+module.exports = dorml2;

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

@@ -0,0 +1,146 @@
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2026 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 format = require( '@stdlib/string/format' );
+var isOperationSide = require( '@stdlib/blas/base/assert/is-operation-side' );
+var isRowMajor = require( '@stdlib/ndarray/base/assert/is-row-major-string' );
+var isMatrixTranspose = require( '@stdlib/blas/base/assert/is-transpose-operation' );
+var max = require( '@stdlib/math/base/special/fast/max' );
+var base = require( './base.js' );
+
+
+// MAIN //
+
+/**
+* Multiply a general matrix by the orthogonal matrix from a LQ factorization determined by `DGELQF`.
+*
+* ## Notes
+*
+* -   `Q` is a real orthogonal matrix defined as the product of k elementary reflectors, Q = H(k) . . . H(2) H(1) as returned by `DGELQF`.
+*
+* -   `Q` is of order `M` if SIDE = 'left' and of order `N` if SIDE = 'R'.
+*
+* -   `DORML2` overwrites the general real `M` by `N` matrix `C` with,
+*
+*     -   `Q * C`  if SIDE = 'left' and TRANS = 'no-transpose', or
+*     -   `Q^T* C`  if SIDE = 'left' and TRANS = 'transpose', or
+*     -   `C * Q`  if SIDE = 'right' and TRANS = 'no-transpose', or
+*     -   `C * Q**T` if SIDE = 'right' and TRANS = 'transpose'.
+*
+* @param {string} order - storage layout
+* @param {string} side - specifies the side of multiplication with `C`
+* @param {string} trans - `'no-transpose'` for `Q`, `'transpose'` for `Q^T`
+* @param {NonNegativeInteger} M - number of rows of `C`
+* @param {NonNegativeInteger} N - number of columns of `C`
+* @param {NonNegativeInteger} K - number of elementary reflectors
+* @param {Float64Array} A - reflector vectors from `DGELQ2`
+* @param {integer} LDA - stride of the first dimension of `A` (a.k.a., leading dimension of the matrix `A`)
+* @param {Float64Array} TAU - scalar factors of reflectors
+* @param {Float64Array} C - input/output matrix
+* @param {integer} LDC - stride of the first dimension of `C` (a.k.a., leading dimension of the matrix `C`)
+* @param {Float64Array} WORK - workspace array
+* @throws {TypeError} first argument must be a valid order
+* @throws {TypeError} second argument must be a valid side
+* @throws {TypeError} third argument must be a valid transpose operation
+* @throws {RangeError} fourth argument must be a non-negative integer
+* @throws {RangeError} fifth argument must be a non-negative integer
+* @throws {RangeError} sixth argument must be a non-negative integer]
+* @throws {RangeError} sixth argument must be smaller than the order of `Q`
+* @throws {RangeError} sixth argument must be smaller than the order of `Q`
+* @throws {RangeError} eighth argument must be greater than or equal to max(1,K)
+* @throws {RangeError} eleventh argument must be greater than or equal to max(1,M)
+* @returns {integer} status code (0 if successful)
+*
+* @example
+* var Float64Array = require( '@stdlib/array/float64' );
+*
+* var A = new Float64Array( [ 1, 0 ] );
+* var TAU = new Float64Array( [ 2 ] );
+* var C = new Float64Array( [ 1, 3, 5, 2, 4, 6 ] );
+* var WORK = new Float64Array( 3 );
+*
+* var info = dorml2( 'row-major', 'left', 'no-transpose', 2, 3, 1, A, 1, TAU, C, 2, WORK );
+* // returns 0
+* // C => <Float64Array>[ -1, -3, -5, 2, 4, 6 ]
+* // WORK => <Float64Array>[ 1, 3, 5 ]
+*/
+function dorml2( order, side, trans, M, N, K, A, LDA, TAU, C, LDC, WORK ) {
+	var sa1;
+	var sa2;
+	var sc1;
+	var sc2;
+
+	if ( !isLayout( order ) ) {
+		throw new TypeError( format( 'invalid argument. First argument must be a valid order. Value: `%s`.', order ) );
+	}
+	if ( !isOperationSide( side ) ) {
+		throw new TypeError( format( 'invalid argument. Second argument must be a valid operation side. Value: `%s`.', side ) );
+	}
+	if ( !isMatrixTranspose( trans ) ) {
+		throw new TypeError( format( 'invalid argument. Third argument must be a valid transpose operation. Value: `%s`.', trans ) );
+	}
+	if ( M < 0 ) {
+		throw new RangeError( format( 'invalid argument. Fourth argument must be a nonnegative integer. Value: `%d`.', M ) );
+	}
+	if ( N < 0 ) {
+		throw new RangeError( format( 'invalid argument. Fifth argument must be a nonnegative integer. Value: `%d`.', N ) );
+	}
+	if ( K < 0 ) {
+		throw new RangeError( format( 'invalid argument. Sixth argument must be a nonnegative integer. Value: `%d`.', K ) );
+	}
+	if ( side === 'left' && K > M ) {
+		throw new RangeError( format( 'invalid argument. Sixth argument must be smaller than the order of `Q`. Value: `%d`.', K ) );
+	}
+	if ( side === 'right' && K > N ) {
+		throw new RangeError( format( 'invalid argument. Sixth argument must be smaller than the order of `Q`. Value: `%d`.', K ) );
+	}
+	if ( isRowMajor( order ) && LDA < max( 1, K ) ) {
+		throw new RangeError( format( 'invalid argument. Eighth argument must be greater than or equal to max(1,K). Value: `%d`.', LDA ) );
+	}
+	if ( isRowMajor( order ) && LDC < max( 1, M ) ) {
+		throw new RangeError( format( 'invalid argument. Eleventh argument must be greater than or equal to max(1,M). Value: `%d`.', LDC ) );
+	}
+	if ( order === 'column-major' ) {
+		sa1 = 1;
+		sa2 = LDA;
+		sc1 = 1;
+		sc2 = LDC;
+	} else {
+		if ( side === 'left' ) {
+			sa1 = M;
+		} else {
+			sa1 = N;
+		}
+		sa2 = 1;
+		sc1 = N;
+		sc2 = 1;
+	}
+	return base( side, trans, M, N, K, A, sa1, sa2, 0, TAU, 1, 0, C, sc1, sc2, 0, WORK, 1, 0 );
+}
+
+
+// EXPORTS //
+
+module.exports = dorml2;

lib/node_modules/@stdlib/lapack/base/dorml2/lib/index.js

@@ -0,0 +1,64 @@
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2026 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 multiply a general matrix by the orthogonal matrix from a LQ factorization determined by `DGELQF`.
+*
+* @module @stdlib/lapack/base/dorml2
+*
+* @example
+* var Float64Array = require( '@stdlib/array/float64' );
+* var dorml2 = require( '@stdlib/lapack/base/dorml2' );
+*
+* var A = new Float64Array( [ 1, 0 ] );
+* var TAU = new Float64Array( [ 2 ] );
+* var C = new Float64Array( [ 1, 3, 5, 2, 4, 6 ] );
+* var WORK = new Float64Array( 3 );
+*
+* var info = dorml2( 'row-major', 'left', 'no-transpose', 2, 3, 1, A, 1, TAU, C, 2, WORK );
+* // returns 0
+* // C => <Float64Array>[ -1, -3, -5, 2, 4, 6 ]
+* // WORK => <Float64Array>[ 1, 3, 5 ]
+*/
+
+// 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 dorml2;
+var tmp = tryRequire( join( __dirname, './native.js' ) );
+if ( isError( tmp ) ) {
+	dorml2 = main;
+} else {
+	dorml2 = tmp;
+}
+
+
+// EXPORTS //
+
+module.exports = dorml2;
+
+// exports: { "ndarray": "dorml2.ndarray" }