feat: add lapack/base/dgelq2

lib/node_modules/@stdlib/lapack/base/dgelq2/benchmark/benchmark.js

@@ -0,0 +1,118 @@
+/**
+* @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';
+
+// MODULES //
+
+var bench = require( '@stdlib/bench' );
+var discreteUniform = require( '@stdlib/random/array/discrete-uniform' );
+var Float64Array = require( '@stdlib/array/float64' );
+var floor = require( '@stdlib/math/base/special/floor' );
+var pow = require( '@stdlib/math/base/special/pow' );
+var format = require( '@stdlib/string/format' );
+var pkg = require( './../package.json' ).name;
+var dgelq2 = require( './../lib/dgelq2.js' );
+
+
+// VARIABLES //
+
+var LAYOUTS = [
+	'row-major',
+	'column-major'
+];
+var opts = {
+	'dtype': 'float64'
+};
+
+
+// FUNCTIONS //
+
+/**
+* Creates a benchmark function.
+*
+* @private
+* @param {string} order - storage layout
+* @param {PositiveInteger} N - matrix dimension
+* @returns {Function} benchmark function
+*/
+function createBenchmark( order, N ) {
+	var work = new Float64Array( N );
+	var TAU = new Float64Array( N );
+	var A = discreteUniform( N*N, 1.0, 10.0, opts );
+
+	return benchmark;
+
+	/**
+	* Benchmark function.
+	*
+	* @private
+	* @param {Benchmark} b - benchmark instance
+	*/
+	function benchmark( b ) {
+		var i;
+		var z;
+
+		b.tic();
+		for ( i = 0; i < b.iterations; i++ ) {
+			z = dgelq2( order, N, N, A, N, TAU, work );
+			if ( z !== 0 ) {
+				b.fail( 'should return 0' );
+			}
+		}
+		b.toc();
+
+		if ( z !== 0 ) {
+			b.fail( 'should return 0' );
+		}
+		b.pass( 'benchmark finished' );
+		b.end();
+	}
+}
+
+
+// MAIN //
+
+/**
+* Main execution sequence.
+*
+* @private
+*/
+function main() {
+	var min;
+	var max;
+	var ord;
+	var N;
+	var f;
+	var i;
+	var k;
+
+	min = 1; // 10^min
+	max = 6; // 10^max
+
+	for ( k = 0; k < LAYOUTS.length; k++ ) {
+		ord = LAYOUTS[ k ];
+		for ( i = min; i <= max; i++ ) {
+			N = floor( pow( pow( 10, i ), 1.0/2.0 ) );
+			f = createBenchmark( ord, N );
+			bench( format( '%s::square_matrix:order=%s,size=%d', pkg, ord, N*N ), f );
+		}
+	}
+}
+
+main();

lib/node_modules/@stdlib/lapack/base/dgelq2/benchmark/benchmark.ndarray.js

@@ -0,0 +1,132 @@
+/**
+* @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';
+
+// MODULES //
+
+var bench = require( '@stdlib/bench' );
+var discreteUniform = require( '@stdlib/random/array/discrete-uniform' );
+var isColumnMajor = require( '@stdlib/ndarray/base/assert/is-column-major-string' );
+var Float64Array = require( '@stdlib/array/float64' );
+var floor = require( '@stdlib/math/base/special/floor' );
+var pow = require( '@stdlib/math/base/special/pow' );
+var format = require( '@stdlib/string/format' );
+var pkg = require( './../package.json' ).name;
+var dgelq2 = require( './../lib/ndarray.js' );
+
+
+// VARIABLES //
+
+var LAYOUTS = [
+	'row-major',
+	'column-major'
+];
+var opts = {
+	'dtype': 'float64'
+};
+
+
+// FUNCTIONS //
+
+/**
+* Creates a benchmark function.
+*
+* @private
+* @param {string} order - storage layout
+* @param {PositiveInteger} N - matrix dimension
+* @returns {Function} benchmark function
+*/
+function createBenchmark( order, N ) {
+	var work;
+	var TAU;
+	var sa1;
+	var sa2;
+	var A;
+
+	work = new Float64Array( N );
+	TAU = new Float64Array( N );
+	A = discreteUniform( N*N, 1.0, 10.0, opts );
+	if ( isColumnMajor( order ) ) {
+		sa1 = 1;
+		sa2 = N;
+	} else { // order === 'row-major'
+		sa1 = N;
+		sa2 = 1;
+	}
+
+	return benchmark;
+
+	/**
+	* Benchmark function.
+	*
+	* @private
+	* @param {Benchmark} b - benchmark instance
+	*/
+	function benchmark( b ) {
+		var i;
+		var z;
+
+		b.tic();
+		for ( i = 0; i < b.iterations; i++ ) {
+			z = dgelq2( N, N, A, sa1, sa2, 0, TAU, 1, 0, work, 1, 0 );
+			if ( z !== 0 ) {
+				b.fail( 'should return 0' );
+			}
+		}
+		b.toc();
+
+		if ( z !== 0 ) {
+			b.fail( 'should return 0' );
+		}
+		b.pass( 'benchmark finished' );
+		b.end();
+	}
+}
+
+
+// MAIN //
+
+/**
+* Main execution sequence.
+*
+* @private
+*/
+function main() {
+	var min;
+	var max;
+	var ord;
+	var N;
+	var f;
+	var i;
+	var k;
+
+	min = 1; // 10^min
+	max = 6; // 10^max
+
+	for ( k = 0; k < LAYOUTS.length; k++ ) {
+		ord = LAYOUTS[ k ];
+		for ( i = min; i <= max; i++ ) {
+			N = floor( pow( pow( 10, i ), 1.0/2.0 ) );
+			f = createBenchmark( ord, N );
+			bench( format( '%s::square_matrix:ndarray:order=%s,size=%d', pkg, ord, N*N ), f );
+		}
+	}
+}
+
+main();

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

@@ -0,0 +1,99 @@
+/**
+* @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';
+
+// MODULES //
+
+var dlarf1f = require( '@stdlib/lapack/base/dlarf1f' ).ndarray;
+var Float64Array = require( '@stdlib/array/float64' );
+var min = require( '@stdlib/math/base/special/min' );
+var dlarfg = require( './dlarfg.js' );
+
+
+// MAIN //
+
+/**
+* Computes an LQ factorization of a real M-by-N matrix `A = L * Q`, using Householder reflections (unblocked algorithm).
+*
+* ## Notes
+*
+* -   On exit, the elements on and below the diagonal of A contain the M-by-min(M,N) lower trapezoidal matrix `L`.
+* -   The elements above the diagonal, with the array `TAU`, represent the orthogonal matrix `Q` as a product of elementary reflectors.
+*
+* @private
+* @param {NonNegativeInteger} M - number of rows in `A`
+* @param {NonNegativeInteger} N - number of columns in `A`
+* @param {Float64Array} A - input/output matrix
+* @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 - output array of scalar factors (length min(M,N))
+* @param {integer} strideTAU - stride for TAU
+* @param {NonNegativeInteger} offsetTAU - starting index for TAU
+* @param {Float64Array} WORK - workspace array (length >= M)
+* @param {integer} strideWORK - stride for WORK
+* @param {NonNegativeInteger} offsetWORK - starting index for WORK
+* @returns {integer} status code
+*
+* @example
+* var Float64Array = require( '@stdlib/array/float64' );
+*
+* var A = new Float64Array( [ 1, 5, 9, 2, 6, 10, 3, 7, 11, 4, 8, 12 ] );
+* var TAU = new Float64Array( 3 );
+* var work = new Float64Array( 3 );
+*
+* dgelq2( 3, 4, A, 1, 3, 0, TAU, 1, 0, work, 1, 0 );
+* // A => <Float64Array>[ ~-5.477, ~-12.78, ~-20.083, ~0.309, ~-3.266, ~-6.532, ~0.463, ~-0.327, ~0, ~0.618, ~-0.789, ~0.618 ]
+* // TAU => <Float64Array>[ ~1.183, ~1.156, ~1.447 ]
+* // work => <Float64Array>[ ~6.532, ~24.593, 0 ]
+*/
+function dgelq2( M, N, A, strideA1, strideA2, offsetA, TAU, strideTAU, offsetTAU, WORK, strideWORK, offsetWORK ) { // eslint-disable-line stdlib/jsdoc-doctest-decimal-point, max-len, max-params
+	var taui;
+	var aii;
+	var out;
+	var K;
+	var i;
+
+	K = min( M, N );
+	out = new Float64Array( 2 );
+
+	aii = offsetA; // Index of A(i,i)
+	taui = offsetTAU; // Index of TAU(i)
+
+	for ( i = 0; i < K; i++ ) {
+		// Generate elementary reflector H(i) to annihilate A(i, i+1:N-1)
+		out[ 0 ] = A[ aii ];
+		dlarfg( N - i, A, strideA2, aii + ( min( 1, N - 1 - i ) * strideA2 ), out, 1, 0 );
+		A[ aii ] = out[ 0 ];
+		TAU[ taui ] = out[ 1 ];
+
+		if ( i < M - 1 ) {
+			// Apply H(i) to A(i+1:M-1, i:N-1) from the right
+			dlarf1f( 'right', M - i - 1, N - i, A,	strideA2, aii, TAU[ taui ], A, strideA1, strideA2, aii + strideA1, WORK, strideWORK, offsetWORK);
+		}
+		aii += strideA1 + strideA2;
+		taui += strideTAU;
+	}
+	return 0;
+}
+
+
+// EXPORTS //
+
+module.exports = dgelq2;