feat: add lapack/base/dlasr

[prajjwalbajpai]

Description

What is the purpose of this pull request?

This pull request:

• adds lapack/base/dlasr

Related Issues

Does this pull request have any related issues?

No.

Questions

Any questions for reviewers of this pull request?

No.

Other

Any other information relevant to this pull request? This may include screenshots, references, and/or implementation notes.

No.

Checklist

Please ensure the following tasks are completed before submitting this pull request.

• Read, understood, and followed the contributing guidelines.

AI Assistance

When authoring the changes proposed in this PR, did you use any kind of AI assistance?

• Yes
• No

If you answered "yes" above, how did you use AI assistance?

• Code generation (e.g., when writing an implementation or fixing a bug)
• Test/benchmark generation
• Documentation (including examples)
• Research and understanding

Disclosure

If you answered "yes" to using AI assistance, please provide a short disclosure indicating how you used AI assistance. This helps reviewers determine how much scrutiny to apply when reviewing your contribution. Example disclosures: "This PR was written primarily by Claude Code." or "I consulted ChatGPT to understand the codebase, but the proposed changes were fully authored manually by myself.".

I consulted ChatGPT for testcases to get 100% code coverage.

---

@stdlib-js/reviewers

[stdlib-bot]

Coverage Report

Package	Statements	Branches	Functions	Lines
lapack/base/dlasr	$\color{green}719/719$ $\color{green}+100.00\%$	$\color{green}109/109$ $\color{green}+100.00\%$	$\color{green}7/7$ $\color{green}+100.00\%$	$\color{green}719/719$ $\color{green}+100.00\%$

The above coverage report was generated for the changes in this PR.

[kgryte]

No explicit functions like this. Use array/base/assert/contains to generate an assertion function similar to

var contains = require( '@stdlib/array/base/assert/contains' ).factory;

var isPivot = contains( [ 'variable', 'top', 'bottom' ] );

[kgryte]

Also, given that this is duplicated in ndarray.js, you should move it to a separate file is_pivot.js so that it can be imported in both implementations.

[kgryte]

Same applies to isDirection.

[kgryte]

Ultimately, we should move these assertion utilities to separate independent packages, so moving to a separate file is a step in that direction.

[kgryte]

Suggested change

	if ( ( isColumnMajor( order ) ) && LDA < max( 1, M ) ) {
	throw new RangeError( format( 'invalid argument. Tenth argument must be greater than or equal to max(1,`M`). Value: `%d`.', LDA ) );
	}
	if ( order === 'column-major' ) {
	if ( isColumnMajor( order ) ) {
	if ( LDA < max( 1, M ) ) {
	throw new RangeError( format( 'invalid argument. Tenth argument must be greater than or equal to max(1,`M`). Value: `%d`.', LDA ) );
	}

Consolidate your conditionals (a) and (b) why are you comparing a string literal when you use isColumnMajor in the conditional just before? We try to avoid explicit string comparisons for a reason and defer to dedicated utilities. Why? Because string literals are a significant source of bundle bloat, as they cannot be minified away.

[kgryte]

You have an LDA check for column-major. There is not a similar check for row-major? I would double-check that is the case by looking at LAPACKE.

[kgryte]

Suggested change

	Similarly, when `PIVOT = 'bottom'` (bottom pivot), the rotation is performed for the
	plane `(k,z)`, where `z = M` if `SIDE = 'L'` and `z = N` if `SIDE = 'R'`.
	In this case, `P(k)` has the form
	Similarly, when `PIVOT = 'bottom'` (bottom pivot), the rotation is performed for the plane `(k,z)`, where `z = M` if `SIDE = 'L'` and `z = N` if `SIDE = 'R'`. In this case, `P(k)` has the form

Don't line wrap Markdown.

[kgryte]

Suggested change

	// returns <Float64Array>[ 2, ~-1.443, ~4.276, ~2.373, 7.6, ~-3.74, ~9.054, ~4.504, 13.2, ~-6.037, ~13.832, ~6.634 ]
	// returns <Float64Array>[ 2.0, ~-1.443, ~4.276, ~2.373, 7.6, ~-3.74, ~9.054, ~4.504, 13.2, ~-6.037, ~13.832, ~6.634 ]

[kgryte]

Suggested change

	// A0 => <Float64Array>[ 0, 2, ~-1.443, ~2.814, 6.2, ~-3.166, ~5.343 ]
	// A0 => <Float64Array>[ 0.0, 2.0, ~-1.443, ~2.814, 6.2, ~-3.166, ~5.343 ]

This is a Float64Array. Array contents should always be documented as decimal values.

[kgryte]

Applies here and throughout this PR.

[kgryte]

As it is, this function is going to be nearly impossible for an optimizing compiler to optimize due to all the nested conditionals. Instead, move each of the loop logic to a function in this file, using the naming convention sidePivotDirection. So, here,

function leftVariableForward( M, N, C, strideC, offsetC, S, strideS, offsetS, A, strideA1, strideA2, offsetA ) {
	var ctemp;
	var stemp;
	var temp;
	var idx0;
	var idx1;
	var idx2;
	var idx3;
	var idx4;
	var i;
	var j;

	// Variable pivot, forward direction
	idx0 = offsetC;
	idx1 = offsetS;
	idx2 = offsetA;
	for ( j = 0; j < M - 1; j++ ) {
		ctemp = C[ idx0 ];
		stemp = S[ idx1 ];
		if ( ctemp !== 1.0 || stemp !== 0.0 ) {
			idx3 = idx2;
			for ( i = 0; i < N; i++ ) {
				idx4 = idx3 + strideA1;
				temp = A[ idx4 ];
				A[ idx4 ] = ( ctemp * temp ) - ( stemp * A[ idx3 ] );
				A[ idx3 ] = ( stemp * temp ) + ( ctemp * A[ idx3 ] );
				idx3 += strideA2;
			}
		}
		idx0 += strideC;
		idx1 += strideS;
		idx2 += strideA1;
	}
	return A;
}

Then, create a hash table which maps each function to a separate of parameters.

{
	'left': {
		'variable': {
			'forward': leftVariableForward,
			// ...
		}
		// ...
	// ...
}

But even more clever is make the hash table a strided array in order to avoid nested property look-up:

var TABLE = [ leftVariableForward, leftVariableBackward, leftTopForward, leftTopBackward, leftBottomForward, leftBottomBackward, rightVariableForward, ... ]

Define strides.

var strideSide = 6;
var stridePivot = 2;
var strideDirection = 1;

Then compute the index into your cache:

var SIDE_INDICES = {
	'left': 0,
	'right': 1
};
var PIVOT_INDICES = {
	'variable': 0,
	'top': 1,
	'bottom': 2
};
var DIRECTION_INDICES = {
	'forward': 0,
	'backward': 1
};

var sidx = SIDE_INDICES[ side ];
var pidx = PIVOT_INDICES[ pivot ];
var didx = DIRECTION_INDICES[ direction ];

var idx = ( sidx*strideSide ) + ( pidx*stridePivot ) + ( didx*strideDirection );
return TABLE[ idx ]( M, N, C, strideC, offsetC, S, strideS, offsetS, A, strideA1, strideA2, offsetA );

With this, all your nested loops go away and each set of nested loops can be independently optimized by the optimizer compiler(s).

[kgryte]

Left initial comments.