diff --git a/lib/node_modules/@stdlib/lapack/base/dlansp/README.md b/lib/node_modules/@stdlib/lapack/base/dlansp/README.md
new file mode 100644
index 000000000000..580d858c6521
--- /dev/null
+++ b/lib/node_modules/@stdlib/lapack/base/dlansp/README.md
@@ -0,0 +1,239 @@
+
+
+# dlansp
+
+> Return the value of the one-norm, Frobenius norm, infinity-norm, or the largest absolute value of any element of a real symmetric matrix stored in packed form.
+
+
+
+## Usage
+
+```javascript
+var dlansp = require( '@stdlib/lapack/base/dlansp' );
+```
+
+#### dlansp( order, norm, uplo, N, AP )
+
+Returns the value of the specified norm of a real symmetric matrix `A` stored in packed form `AP`.
+
+```javascript
+var Float64Array = require( '@stdlib/array/float64' );
+
+// AP = [ 1.0, 2.0, 5.0 ] (2x2 symmetric packed column-major upper)
+var AP = new Float64Array( [ 1.0, 2.0, 5.0 ] );
+
+var v = dlansp( 'column-major', 'M', 'upper', 2, AP );
+// returns 5.0
+```
+
+The function has the following parameters:
+
+- **order**: storage layout (`'row-major'` or `'column-major'`).
+- **norm**: specifies the norm type (`'M'`/`'m'`: max norm, `'1'`/`'O'`/`'o'`: one norm, `'I'`/`'i'`: infinity norm, `'F'`/`'f'`/`'E'`/`'e'`: Frobenius norm).
+- **uplo**: specifies whether the upper or lower triangular part of `A` is supplied (`'upper'` or `'lower'`).
+- **N**: order of the matrix `A`. When `N = 0`, the function returns `0`.
+- **AP**: input [`Float64Array`][mdn-float64array] containing the symmetric matrix in packed form.
+
+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 AP0 = new Float64Array( [ 0.0, 1.0, 2.0, 5.0 ] );
+
+// Create an offset view...
+var AP1 = new Float64Array( AP0.buffer, AP0.BYTES_PER_ELEMENT*1 );
+
+var v = dlansp( 'column-major', 'M', 'upper', 2, AP1 );
+// returns 5.0
+```
+
+#### dlansp.ndarray( order, norm, uplo, N, AP, strideAP, offsetAP )
+
+Returns the value of the specified norm of a real symmetric matrix `A` stored in packed form `AP` using alternative indexing semantics.
+
+```javascript
+var Float64Array = require( '@stdlib/array/float64' );
+
+// AP = [ 1.0, 2.0, 5.0 ] (2x2 symmetric packed column-major upper)
+var AP = new Float64Array( [ 1.0, 2.0, 5.0 ] );
+
+var v = dlansp.ndarray( 'column-major', 'M', 'upper', 2, AP, 1, 0 );
+// returns 5.0
+```
+
+The function has the following additional parameters:
+
+- **strideAP**: stride length for `AP`.
+- **offsetAP**: starting index for `AP`.
+
+While [`typed array`][mdn-typed-array] views mandate a view offset based on the underlying buffer, the offset parameter supports indexing semantics based on starting indices. For example,
+
+```javascript
+var Float64Array = require( '@stdlib/array/float64' );
+
+var AP = new Float64Array( [ 0.0, 1.0, 2.0, 5.0 ] );
+
+var v = dlansp.ndarray( 'column-major', 'M', 'upper', 2, AP, 1, 1 );
+// returns 5.0
+```
+
+
+
+
+
+
+
+## Notes
+
+- `dlansp()` corresponds to the [LAPACK][lapack] routine [`dlansp`][lapack-dlansp].
+- Since the matrix is symmetric, the one norm and infinity norm are equal.
+
+
+
+
+
+
+
+## Examples
+
+
+
+```javascript
+var uniform = require( '@stdlib/random/array/discrete-uniform' );
+var dlansp = require( '@stdlib/lapack/base/dlansp' );
+
+var N = 4;
+var AP = uniform( N * ( N + 1 ) / 2, -10, 10, {
+ 'dtype': 'float64'
+});
+console.log( AP );
+
+var v = dlansp( 'column-major', 'M', 'upper', N, AP );
+console.log( 'Max norm: %d', v );
+
+v = dlansp( 'column-major', '1', 'upper', N, AP );
+console.log( 'One norm: %d', v );
+
+v = dlansp( 'column-major', 'F', 'upper', N, AP );
+console.log( 'Frobenius norm: %d', v );
+```
+
+
+
+
+
+
+
+* * *
+
+
+
+## C APIs
+
+
+
+
+
+
+
+
+
+
+
+### Usage
+
+```c
+TODO
+```
+
+#### TODO
+
+TODO.
+
+```c
+TODO
+```
+
+TODO
+
+```c
+TODO
+```
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+### Examples
+
+```c
+TODO
+```
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+[lapack]: http://www.netlib.org/lapack/
+
+[lapack-dlansp]: http://www.netlib.org/lapack/explore-html/da/df5/group__lanhp_ga0e11da53350a7d0126a428d5842b8991.html
+
+[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/dlansp/benchmark/benchmark.js b/lib/node_modules/@stdlib/lapack/base/dlansp/benchmark/benchmark.js
new file mode 100644
index 000000000000..460fd8c7a406
--- /dev/null
+++ b/lib/node_modules/@stdlib/lapack/base/dlansp/benchmark/benchmark.js
@@ -0,0 +1,104 @@
+/**
+* @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 uniform = require( '@stdlib/random/array/uniform' );
+var isnan = require( '@stdlib/math/base/assert/is-nan' );
+var pow = require( '@stdlib/math/base/special/pow' );
+var floor = require( '@stdlib/math/base/special/floor' );
+var format = require( '@stdlib/string/format' );
+var pkg = require( './../package.json' ).name;
+var dlansp = require( './../lib/dlansp.js' );
+
+
+// FUNCTIONS //
+
+/**
+* Creates a benchmark function.
+*
+* @private
+* @param {PositiveInteger} N - number of elements along each dimension
+* @returns {Function} benchmark function
+*/
+function createBenchmark( N ) {
+ var opts;
+ var AP;
+
+ opts = {
+ 'dtype': 'float64'
+ };
+
+ AP = uniform( N * ( N + 1 ) / 2, -10.0, 10.0, opts );
+ return benchmark;
+
+ /**
+ * Benchmark function.
+ *
+ * @private
+ * @param {Benchmark} b - benchmark instance
+ */
+ function benchmark( b ) {
+ var z;
+ var i;
+
+ b.tic();
+ for ( i = 0; i < b.iterations; i++ ) {
+ z = dlansp( 'column-major', 'M', 'upper', N, AP );
+ if ( isnan( z ) ) {
+ b.fail( 'should not return NaN' );
+ }
+ }
+ b.toc();
+ if ( isnan( z ) ) {
+ b.fail( 'should not return NaN' );
+ }
+ b.pass( 'benchmark finished' );
+ b.end();
+ }
+}
+
+
+// MAIN //
+
+/**
+* Main execution sequence.
+*
+* @private
+*/
+function main() {
+ var min;
+ var max;
+ var N;
+ var f;
+ var i;
+
+ min = 1; // 10^min
+ max = 6; // 10^max
+
+ for ( i = min; i <= max; i++ ) {
+ N = floor( pow( pow( 10, i ), 1.0 / 2.0 ) );
+ f = createBenchmark( N );
+ bench( format( '%s:order=column-major,size=%d', pkg, N * ( N + 1 ) / 2 ), f );
+ }
+}
+
+main();
diff --git a/lib/node_modules/@stdlib/lapack/base/dlansp/benchmark/benchmark.ndarray.js b/lib/node_modules/@stdlib/lapack/base/dlansp/benchmark/benchmark.ndarray.js
new file mode 100644
index 000000000000..6d4d5a2f5809
--- /dev/null
+++ b/lib/node_modules/@stdlib/lapack/base/dlansp/benchmark/benchmark.ndarray.js
@@ -0,0 +1,104 @@
+/**
+* @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 uniform = require( '@stdlib/random/array/uniform' );
+var isnan = require( '@stdlib/math/base/assert/is-nan' );
+var pow = require( '@stdlib/math/base/special/pow' );
+var floor = require( '@stdlib/math/base/special/floor' );
+var format = require( '@stdlib/string/format' );
+var pkg = require( './../package.json' ).name;
+var dlansp = require( './../lib/ndarray.js' );
+
+
+// FUNCTIONS //
+
+/**
+* Creates a benchmark function.
+*
+* @private
+* @param {PositiveInteger} N - number of elements along each dimension
+* @returns {Function} benchmark function
+*/
+function createBenchmark( N ) {
+ var opts;
+ var AP;
+
+ opts = {
+ 'dtype': 'float64'
+ };
+
+ AP = uniform( N * ( N + 1 ) / 2, -10.0, 10.0, opts );
+ return benchmark;
+
+ /**
+ * Benchmark function.
+ *
+ * @private
+ * @param {Benchmark} b - benchmark instance
+ */
+ function benchmark( b ) {
+ var z;
+ var i;
+
+ b.tic();
+ for ( i = 0; i < b.iterations; i++ ) {
+ z = dlansp( 'column-major', 'M', 'upper', N, AP, 1, 0 );
+ if ( isnan( z ) ) {
+ b.fail( 'should not return NaN' );
+ }
+ }
+ b.toc();
+ if ( isnan( z ) ) {
+ b.fail( 'should not return NaN' );
+ }
+ b.pass( 'benchmark finished' );
+ b.end();
+ }
+}
+
+
+// MAIN //
+
+/**
+* Main execution sequence.
+*
+* @private
+*/
+function main() {
+ var min;
+ var max;
+ var N;
+ var f;
+ var i;
+
+ min = 1; // 10^min
+ max = 6; // 10^max
+
+ for ( i = min; i <= max; i++ ) {
+ N = floor( pow( pow( 10, i ), 1.0 / 2.0 ) );
+ f = createBenchmark( N );
+ bench( format( '%s::ndarray:order=column-major,size=%d', pkg, N * ( N + 1 ) / 2 ), f );
+ }
+}
+
+main();
diff --git a/lib/node_modules/@stdlib/lapack/base/dlansp/docs/repl.txt b/lib/node_modules/@stdlib/lapack/base/dlansp/docs/repl.txt
new file mode 100644
index 000000000000..5be8af8923e4
--- /dev/null
+++ b/lib/node_modules/@stdlib/lapack/base/dlansp/docs/repl.txt
@@ -0,0 +1,89 @@
+
+{{alias}}( order, norm, uplo, N, AP )
+ Returns the value of the one-norm, Frobenius norm, infinity-norm, or the
+ largest absolute value of any element of a real symmetric matrix stored in
+ packed form.
+
+ Indexing is relative to the first index. To introduce an offset, use typed
+ array views.
+
+ Parameters
+ ----------
+ order: string
+ Row-major (C-style) or column-major (Fortran-style) order. Must be
+ either 'row-major' or 'column-major'.
+
+ norm: string
+ Specifies the norm type ('M'/'m': max norm, '1'/'O'/'o': one norm,
+ 'I'/'i': infinity norm, 'F'/'f'/'E'/'e': Frobenius norm).
+
+ uplo: string
+ Specifies whether the upper or lower triangular part of `A` is
+ supplied ('upper' or 'lower').
+
+ N: integer
+ Order of the matrix `A`.
+
+ AP: Float64Array
+ Input symmetric matrix `A` stored in packed form.
+
+ Returns
+ -------
+ v: number
+ Matrix norm.
+
+ Examples
+ --------
+ > var AP = new {{alias:@stdlib/array/float64}}( [ 1.0, 2.0, 5.0 ] );
+ > {{alias}}( 'column-major', 'M', 'upper', 2, AP )
+ 5.0
+
+
+{{alias}}.ndarray( order, norm, uplo, N, AP, strideAP, offsetAP )
+ Returns the value of the one-norm, Frobenius norm, infinity-norm, or the
+ largest absolute value of any element of a real symmetric matrix stored in
+ packed form 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
+ ----------
+ order: string
+ Row-major (C-style) or column-major (Fortran-style) order. Must be
+ either 'row-major' or 'column-major'.
+
+ norm: string
+ Specifies the norm type ('M'/'m': max norm, '1'/'O'/'o': one norm,
+ 'I'/'i': infinity norm, 'F'/'f'/'E'/'e': Frobenius norm).
+
+ uplo: string
+ Specifies whether the upper or lower triangular part of `A` is
+ supplied ('upper' or 'lower').
+
+ N: integer
+ Order of the matrix `A`.
+
+ AP: Float64Array
+ Input symmetric matrix `A` stored in packed form.
+
+ strideAP: integer
+ AP stride length.
+
+ offsetAP: integer
+ Starting index for `AP`.
+
+ Returns
+ -------
+ v: number
+ Matrix norm.
+
+ Examples
+ --------
+ > var AP = new {{alias:@stdlib/array/float64}}( [ 1.0, 2.0, 5.0 ] );
+ > {{alias}}.ndarray( 'column-major', 'M', 'upper', 2, AP, 1, 0 )
+ 5.0
+
+ See Also
+ --------
diff --git a/lib/node_modules/@stdlib/lapack/base/dlansp/docs/types/index.d.ts b/lib/node_modules/@stdlib/lapack/base/dlansp/docs/types/index.d.ts
new file mode 100644
index 000000000000..86124b156300
--- /dev/null
+++ b/lib/node_modules/@stdlib/lapack/base/dlansp/docs/types/index.d.ts
@@ -0,0 +1,103 @@
+/*
+* @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.
+*/
+
+// TypeScript Version: 4.1
+
+///
+
+import { Layout } from '@stdlib/types/blas';
+
+/**
+* Interface describing `dlansp`.
+*/
+interface Routine {
+ /**
+ * Returns the value of the one-norm, Frobenius norm, infinity-norm, or the largest absolute value of any element of a real symmetric matrix stored in packed form.
+ *
+ * @param order - storage layout of `AP`
+ * @param norm - specifies the norm type
+ * @param uplo - specifies whether the upper or lower triangular part of `A` is supplied
+ * @param N - order of the matrix `A`
+ * @param AP - packed form of a symmetric matrix `A`
+ * @returns matrix norm
+ *
+ * @example
+ * var Float64Array = require( '@stdlib/array/float64' );
+ *
+ * var AP = new Float64Array( [ 1.0, 2.0, 5.0 ] );
+ *
+ * var v = dlansp( 'column-major', 'M', 'upper', 2, AP );
+ * // returns 5.0
+ */
+ ( order: Layout, norm: string, uplo: string, N: number, AP: Float64Array ): number;
+
+ /**
+ * Returns the value of the one-norm, Frobenius norm, infinity-norm, or the largest absolute value of any element of a real symmetric matrix stored in packed form using alternative indexing semantics.
+ *
+ * @param order - storage layout of `AP`
+ * @param norm - specifies the norm type
+ * @param uplo - specifies whether the upper or lower triangular part of `A` is supplied
+ * @param N - order of the matrix `A`
+ * @param AP - packed form of a symmetric matrix `A`
+ * @param strideAP - `AP` stride length
+ * @param offsetAP - starting `AP` index
+ * @returns matrix norm
+ *
+ * @example
+ * var Float64Array = require( '@stdlib/array/float64' );
+ *
+ * var AP = new Float64Array( [ 1.0, 2.0, 5.0 ] );
+ *
+ * var v = dlansp.ndarray( 'column-major', 'M', 'upper', 2, AP, 1, 0 );
+ * // returns 5.0
+ */
+ ndarray( order: Layout, norm: string, uplo: string, N: number, AP: Float64Array, strideAP: number, offsetAP: number ): number;
+}
+
+/**
+* Returns the value of the one-norm, Frobenius norm, infinity-norm, or the largest absolute value of any element of a real symmetric matrix stored in packed form.
+*
+* @param order - storage layout of `AP`
+* @param norm - specifies the norm type
+* @param uplo - specifies whether the upper or lower triangular part of `A` is supplied
+* @param N - order of the matrix `A`
+* @param AP - packed form of a symmetric matrix `A`
+* @returns matrix norm
+*
+* @example
+* var Float64Array = require( '@stdlib/array/float64' );
+*
+* var AP = new Float64Array( [ 1.0, 2.0, 5.0 ] );
+*
+* var v = dlansp( 'column-major', 'M', 'upper', 2, AP );
+* // returns 5.0
+*
+* @example
+* var Float64Array = require( '@stdlib/array/float64' );
+*
+* var AP = new Float64Array( [ 1.0, 2.0, 5.0 ] );
+*
+* var v = dlansp.ndarray( 'column-major', 'M', 'upper', 2, AP, 1, 0 );
+* // returns 5.0
+*/
+declare var dlansp: Routine;
+
+
+// EXPORTS //
+
+export = dlansp;
diff --git a/lib/node_modules/@stdlib/lapack/base/dlansp/docs/types/test.ts b/lib/node_modules/@stdlib/lapack/base/dlansp/docs/types/test.ts
new file mode 100644
index 000000000000..5ed5acbe8f0a
--- /dev/null
+++ b/lib/node_modules/@stdlib/lapack/base/dlansp/docs/types/test.ts
@@ -0,0 +1,229 @@
+/*
+* @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.
+*/
+
+import dlansp = require( './index' );
+
+
+// TESTS //
+
+// The function returns a number...
+{
+ const AP = new Float64Array( [ 1.0, 2.0, 5.0 ] );
+
+ dlansp( 'row-major', 'M', 'upper', 2, AP ); // $ExpectType number
+ dlansp( 'column-major', '1', 'lower', 2, AP ); // $ExpectType number
+}
+
+// The compiler throws an error if the function is provided a first argument which is not a string...
+{
+ const AP = new Float64Array( [ 1.0, 2.0, 5.0 ] );
+
+ dlansp( 5, 'M', 'upper', 2, AP ); // $ExpectError
+ dlansp( true, 'M', 'upper', 2, AP ); // $ExpectError
+ dlansp( false, 'M', 'upper', 2, AP ); // $ExpectError
+ dlansp( null, 'M', 'upper', 2, AP ); // $ExpectError
+ dlansp( void 0, 'M', 'upper', 2, AP ); // $ExpectError
+ dlansp( [], 'M', 'upper', 2, AP ); // $ExpectError
+ dlansp( {}, 'M', 'upper', 2, AP ); // $ExpectError
+ dlansp( ( x: number ): number => x, 'M', 'upper', 2, AP ); // $ExpectError
+}
+
+// The compiler throws an error if the function is provided a second argument which is not a string...
+{
+ const AP = new Float64Array( [ 1.0, 2.0, 5.0 ] );
+
+ dlansp( 'row-major', 5, 'upper', 2, AP ); // $ExpectError
+ dlansp( 'row-major', true, 'upper', 2, AP ); // $ExpectError
+ dlansp( 'row-major', false, 'upper', 2, AP ); // $ExpectError
+ dlansp( 'row-major', null, 'upper', 2, AP ); // $ExpectError
+ dlansp( 'row-major', void 0, 'upper', 2, AP ); // $ExpectError
+ dlansp( 'row-major', [], 'upper', 2, AP ); // $ExpectError
+ dlansp( 'row-major', {}, 'upper', 2, AP ); // $ExpectError
+ dlansp( 'row-major', ( x: number ): number => x, 'upper', 2, AP ); // $ExpectError
+}
+
+// The compiler throws an error if the function is provided a third argument which is not a string...
+{
+ const AP = new Float64Array( [ 1.0, 2.0, 5.0 ] );
+
+ dlansp( 'row-major', 'M', 5, 2, AP ); // $ExpectError
+ dlansp( 'row-major', 'M', true, 2, AP ); // $ExpectError
+ dlansp( 'row-major', 'M', false, 2, AP ); // $ExpectError
+ dlansp( 'row-major', 'M', null, 2, AP ); // $ExpectError
+ dlansp( 'row-major', 'M', void 0, 2, AP ); // $ExpectError
+ dlansp( 'row-major', 'M', [], 2, AP ); // $ExpectError
+ dlansp( 'row-major', 'M', {}, 2, AP ); // $ExpectError
+ dlansp( 'row-major', 'M', ( x: number ): number => x, 2, AP ); // $ExpectError
+}
+
+// The compiler throws an error if the function is provided a fourth argument which is not a number...
+{
+ const AP = new Float64Array( [ 1.0, 2.0, 5.0 ] );
+
+ dlansp( 'row-major', 'M', 'upper', '5', AP ); // $ExpectError
+ dlansp( 'row-major', 'M', 'upper', true, AP ); // $ExpectError
+ dlansp( 'row-major', 'M', 'upper', false, AP ); // $ExpectError
+ dlansp( 'row-major', 'M', 'upper', null, AP ); // $ExpectError
+ dlansp( 'row-major', 'M', 'upper', void 0, AP ); // $ExpectError
+ dlansp( 'row-major', 'M', 'upper', [], AP ); // $ExpectError
+ dlansp( 'row-major', 'M', 'upper', {}, AP ); // $ExpectError
+ dlansp( 'row-major', 'M', 'upper', ( x: number ): number => x, AP ); // $ExpectError
+}
+
+// The compiler throws an error if the function is provided a fifth argument which is not a Float64Array...
+{
+ dlansp( 'row-major', 'M', 'upper', 2, '5' ); // $ExpectError
+ dlansp( 'row-major', 'M', 'upper', 2, 5 ); // $ExpectError
+ dlansp( 'row-major', 'M', 'upper', 2, true ); // $ExpectError
+ dlansp( 'row-major', 'M', 'upper', 2, false ); // $ExpectError
+ dlansp( 'row-major', 'M', 'upper', 2, null ); // $ExpectError
+ dlansp( 'row-major', 'M', 'upper', 2, void 0 ); // $ExpectError
+ dlansp( 'row-major', 'M', 'upper', 2, [] ); // $ExpectError
+ dlansp( 'row-major', 'M', 'upper', 2, {} ); // $ExpectError
+ dlansp( 'row-major', 'M', 'upper', 2, ( x: number ): number => x ); // $ExpectError
+}
+
+// The compiler throws an error if the function is provided an unsupported number of arguments...
+{
+ const AP = new Float64Array( [ 1.0, 2.0, 5.0 ] );
+
+ dlansp(); // $ExpectError
+ dlansp( 'row-major' ); // $ExpectError
+ dlansp( 'row-major', 'M' ); // $ExpectError
+ dlansp( 'row-major', 'M', 'upper' ); // $ExpectError
+ dlansp( 'row-major', 'M', 'upper', 2 ); // $ExpectError
+ dlansp( 'row-major', 'M', 'upper', 2, AP, 10 ); // $ExpectError
+}
+
+// Attached to the main export is an `ndarray` method which returns a number...
+{
+ const AP = new Float64Array( [ 1.0, 2.0, 5.0 ] );
+
+ dlansp.ndarray( 'row-major', 'M', 'upper', 2, AP, 1, 0 ); // $ExpectType number
+}
+
+// The compiler throws an error if the `ndarray` method is provided a first argument which is not a string...
+{
+ const AP = new Float64Array( [ 1.0, 2.0, 5.0 ] );
+
+ dlansp.ndarray( 5, 'M', 'upper', 2, AP, 1, 0 ); // $ExpectError
+ dlansp.ndarray( true, 'M', 'upper', 2, AP, 1, 0 ); // $ExpectError
+ dlansp.ndarray( false, 'M', 'upper', 2, AP, 1, 0 ); // $ExpectError
+ dlansp.ndarray( null, 'M', 'upper', 2, AP, 1, 0 ); // $ExpectError
+ dlansp.ndarray( void 0, 'M', 'upper', 2, AP, 1, 0 ); // $ExpectError
+ dlansp.ndarray( [], 'M', 'upper', 2, AP, 1, 0 ); // $ExpectError
+ dlansp.ndarray( {}, 'M', 'upper', 2, AP, 1, 0 ); // $ExpectError
+ dlansp.ndarray( ( x: number ): number => x, 'M', 'upper', 2, AP, 1, 0 ); // $ExpectError
+}
+
+// The compiler throws an error if the `ndarray` method is provided a second argument which is not a string...
+{
+ const AP = new Float64Array( [ 1.0, 2.0, 5.0 ] );
+
+ dlansp.ndarray( 'row-major', 5, 'upper', 2, AP, 1, 0 ); // $ExpectError
+ dlansp.ndarray( 'row-major', true, 'upper', 2, AP, 1, 0 ); // $ExpectError
+ dlansp.ndarray( 'row-major', false, 'upper', 2, AP, 1, 0 ); // $ExpectError
+ dlansp.ndarray( 'row-major', null, 'upper', 2, AP, 1, 0 ); // $ExpectError
+ dlansp.ndarray( 'row-major', void 0, 'upper', 2, AP, 1, 0 ); // $ExpectError
+ dlansp.ndarray( 'row-major', [], 'upper', 2, AP, 1, 0 ); // $ExpectError
+ dlansp.ndarray( 'row-major', {}, 'upper', 2, AP, 1, 0 ); // $ExpectError
+ dlansp.ndarray( 'row-major', ( x: number ): number => x, 'upper', 2, AP, 1, 0 ); // $ExpectError
+}
+
+// The compiler throws an error if the `ndarray` method is provided a third argument which is not a string...
+{
+ const AP = new Float64Array( [ 1.0, 2.0, 5.0 ] );
+
+ dlansp.ndarray( 'row-major', 'M', 5, 2, AP, 1, 0 ); // $ExpectError
+ dlansp.ndarray( 'row-major', 'M', true, 2, AP, 1, 0 ); // $ExpectError
+ dlansp.ndarray( 'row-major', 'M', false, 2, AP, 1, 0 ); // $ExpectError
+ dlansp.ndarray( 'row-major', 'M', null, 2, AP, 1, 0 ); // $ExpectError
+ dlansp.ndarray( 'row-major', 'M', void 0, 2, AP, 1, 0 ); // $ExpectError
+ dlansp.ndarray( 'row-major', 'M', [], 2, AP, 1, 0 ); // $ExpectError
+ dlansp.ndarray( 'row-major', 'M', {}, 2, AP, 1, 0 ); // $ExpectError
+ dlansp.ndarray( 'row-major', 'M', ( x: number ): number => x, 2, AP, 1, 0 ); // $ExpectError
+}
+
+// The compiler throws an error if the `ndarray` method is provided a fourth argument which is not a number...
+{
+ const AP = new Float64Array( [ 1.0, 2.0, 5.0 ] );
+
+ dlansp.ndarray( 'row-major', 'M', 'upper', '5', AP, 1, 0 ); // $ExpectError
+ dlansp.ndarray( 'row-major', 'M', 'upper', true, AP, 1, 0 ); // $ExpectError
+ dlansp.ndarray( 'row-major', 'M', 'upper', false, AP, 1, 0 ); // $ExpectError
+ dlansp.ndarray( 'row-major', 'M', 'upper', null, AP, 1, 0 ); // $ExpectError
+ dlansp.ndarray( 'row-major', 'M', 'upper', void 0, AP, 1, 0 ); // $ExpectError
+ dlansp.ndarray( 'row-major', 'M', 'upper', [], AP, 1, 0 ); // $ExpectError
+ dlansp.ndarray( 'row-major', 'M', 'upper', {}, AP, 1, 0 ); // $ExpectError
+ dlansp.ndarray( 'row-major', 'M', 'upper', ( x: number ): number => x, AP, 1, 0 ); // $ExpectError
+}
+
+// The compiler throws an error if the `ndarray` method is provided a fifth argument which is not a Float64Array...
+{
+ dlansp.ndarray( 'row-major', 'M', 'upper', 2, '5', 1, 0 ); // $ExpectError
+ dlansp.ndarray( 'row-major', 'M', 'upper', 2, 5, 1, 0 ); // $ExpectError
+ dlansp.ndarray( 'row-major', 'M', 'upper', 2, true, 1, 0 ); // $ExpectError
+ dlansp.ndarray( 'row-major', 'M', 'upper', 2, false, 1, 0 ); // $ExpectError
+ dlansp.ndarray( 'row-major', 'M', 'upper', 2, null, 1, 0 ); // $ExpectError
+ dlansp.ndarray( 'row-major', 'M', 'upper', 2, void 0, 1, 0 ); // $ExpectError
+ dlansp.ndarray( 'row-major', 'M', 'upper', 2, [], 1, 0 ); // $ExpectError
+ dlansp.ndarray( 'row-major', 'M', 'upper', 2, {}, 1, 0 ); // $ExpectError
+ dlansp.ndarray( 'row-major', 'M', 'upper', 2, ( x: number ): number => x, 1, 0 ); // $ExpectError
+}
+
+// The compiler throws an error if the `ndarray` method is provided a sixth argument which is not a number...
+{
+ const AP = new Float64Array( [ 1.0, 2.0, 5.0 ] );
+
+ dlansp.ndarray( 'row-major', 'M', 'upper', 2, AP, '5', 0 ); // $ExpectError
+ dlansp.ndarray( 'row-major', 'M', 'upper', 2, AP, true, 0 ); // $ExpectError
+ dlansp.ndarray( 'row-major', 'M', 'upper', 2, AP, false, 0 ); // $ExpectError
+ dlansp.ndarray( 'row-major', 'M', 'upper', 2, AP, null, 0 ); // $ExpectError
+ dlansp.ndarray( 'row-major', 'M', 'upper', 2, AP, void 0, 0 ); // $ExpectError
+ dlansp.ndarray( 'row-major', 'M', 'upper', 2, AP, [], 0 ); // $ExpectError
+ dlansp.ndarray( 'row-major', 'M', 'upper', 2, AP, {}, 0 ); // $ExpectError
+ dlansp.ndarray( 'row-major', 'M', 'upper', 2, AP, ( x: number ): number => x, 0 ); // $ExpectError
+}
+
+// The compiler throws an error if the `ndarray` method is provided a seventh argument which is not a number...
+{
+ const AP = new Float64Array( [ 1.0, 2.0, 5.0 ] );
+
+ dlansp.ndarray( 'row-major', 'M', 'upper', 2, AP, 1, '5' ); // $ExpectError
+ dlansp.ndarray( 'row-major', 'M', 'upper', 2, AP, 1, true ); // $ExpectError
+ dlansp.ndarray( 'row-major', 'M', 'upper', 2, AP, 1, false ); // $ExpectError
+ dlansp.ndarray( 'row-major', 'M', 'upper', 2, AP, 1, null ); // $ExpectError
+ dlansp.ndarray( 'row-major', 'M', 'upper', 2, AP, 1, void 0 ); // $ExpectError
+ dlansp.ndarray( 'row-major', 'M', 'upper', 2, AP, 1, [] ); // $ExpectError
+ dlansp.ndarray( 'row-major', 'M', 'upper', 2, AP, 1, {} ); // $ExpectError
+ dlansp.ndarray( 'row-major', 'M', 'upper', 2, AP, 1, ( x: number ): number => x ); // $ExpectError
+}
+
+// The compiler throws an error if the `ndarray` method is provided an unsupported number of arguments...
+{
+ const AP = new Float64Array( [ 1.0, 2.0, 5.0 ] );
+
+ dlansp.ndarray(); // $ExpectError
+ dlansp.ndarray( 'row-major' ); // $ExpectError
+ dlansp.ndarray( 'row-major', 'M' ); // $ExpectError
+ dlansp.ndarray( 'row-major', 'M', 'upper' ); // $ExpectError
+ dlansp.ndarray( 'row-major', 'M', 'upper', 2 ); // $ExpectError
+ dlansp.ndarray( 'row-major', 'M', 'upper', 2, AP ); // $ExpectError
+ dlansp.ndarray( 'row-major', 'M', 'upper', 2, AP, 1 ); // $ExpectError
+ dlansp.ndarray( 'row-major', 'M', 'upper', 2, AP, 1, 0, 10 ); // $ExpectError
+}
diff --git a/lib/node_modules/@stdlib/lapack/base/dlansp/examples/index.js b/lib/node_modules/@stdlib/lapack/base/dlansp/examples/index.js
new file mode 100644
index 000000000000..2f60b68ee582
--- /dev/null
+++ b/lib/node_modules/@stdlib/lapack/base/dlansp/examples/index.js
@@ -0,0 +1,41 @@
+/**
+* @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';
+
+var uniform = require( '@stdlib/random/array/discrete-uniform' );
+var dlansp = require( './../lib' );
+
+var N = 4;
+var AP = uniform( N * ( N + 1 ) / 2, -10, 10, {
+ 'dtype': 'float64'
+});
+console.log( 'Packed Symmetric Matrix AP:' );
+console.log( AP );
+
+var v = dlansp( 'column-major', 'M', 'upper', N, AP );
+console.log( 'Max norm: %d', v );
+
+v = dlansp( 'column-major', '1', 'upper', N, AP );
+console.log( 'One norm: %d', v );
+
+v = dlansp( 'column-major', 'I', 'upper', N, AP );
+console.log( 'Infinity norm: %d', v );
+
+v = dlansp( 'column-major', 'F', 'upper', N, AP );
+console.log( 'Frobenius norm: %d', v );
diff --git a/lib/node_modules/@stdlib/lapack/base/dlansp/lib/base.js b/lib/node_modules/@stdlib/lapack/base/dlansp/lib/base.js
new file mode 100644
index 000000000000..b852c6de007a
--- /dev/null
+++ b/lib/node_modules/@stdlib/lapack/base/dlansp/lib/base.js
@@ -0,0 +1,208 @@
+/**
+* @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 */
+
+'use strict';
+
+// MODULES //
+
+var abs = require( '@stdlib/math/base/special/abs' );
+var sqrt = require( '@stdlib/math/base/special/sqrt' );
+var isnan = require( '@stdlib/math/base/assert/is-nan' );
+var Float64Array = require( '@stdlib/array/float64' );
+var isRowMajor = require( '@stdlib/ndarray/base/assert/is-row-major-string' );
+var isColumnMajor = require( '@stdlib/ndarray/base/assert/is-column-major-string' );
+var dlassq = require( '@stdlib/lapack/base/dlassq' ).ndarray;
+
+
+// MAIN //
+
+/**
+* Returns the value of the one-norm, Frobenius norm, infinity-norm, or the largest absolute value of any element of a real symmetric matrix `A` supplied in packed form.
+*
+* @private
+* @param {string} order - storage layout ('row-major' or 'column-major')
+* @param {string} norm - specifies the norm: 'M' (max abs), '1'/'O' (one-norm), 'I' (infinity-norm), 'F'/'E' (Frobenius)
+* @param {string} uplo - specifies whether the upper or lower triangular part of the symmetric matrix `A` is supplied ('upper' or 'lower')
+* @param {NonNegativeInteger} N - order of the matrix `A`
+* @param {Float64Array} AP - packed form of a symmetric matrix `A`
+* @param {integer} strideAP - `AP` stride length
+* @param {NonNegativeInteger} offsetAP - starting `AP` index
+* @returns {number} matrix norm
+*
+* @example
+* var Float64Array = require( '@stdlib/array/float64' );
+*
+* // AP = [ 1.0, 2.0, 5.0 ] (2x2 symmetric packed column-major upper)
+* var AP = new Float64Array( [ 1.0, 2.0, 5.0 ] );
+*
+* var norm = dlansp( 'column-major', 'M', 'upper', 2, AP, 1, 0 );
+* // returns 5.0
+*/
+function dlansp( order, norm, uplo, N, AP, strideAP, offsetAP ) {
+ var anorm;
+ var scale;
+ var sumsq;
+ var ratio;
+ var absa;
+ var work;
+ var temp;
+ var out;
+ var sum;
+ var P;
+ var i;
+ var j;
+ var k;
+
+ if ( N <= 0 ) {
+ return 0.0;
+ }
+ if ( norm === 'M' || norm === 'm' ) {
+ // Find max(abs(A(i,j)))
+ P = N * ( N + 1 ) / 2;
+ anorm = 0.0;
+ for ( i = 0; i < P; i++ ) {
+ temp = abs( AP[ offsetAP + ( i * strideAP ) ] );
+ if ( anorm < temp || isnan( temp ) ) {
+ anorm = temp;
+ }
+ }
+ } else if ( norm === 'I' || norm === 'i' || norm === 'O' || norm === 'o' || norm === '1' ) {
+ // Find normI(A) ( = norm1(A), since A is symmetric)
+ if (
+ ( isColumnMajor( order ) && uplo === 'upper' ) ||
+ ( isRowMajor( order ) && uplo === 'lower' )
+ ) {
+ work = new Float64Array( N );
+ k = 0;
+ for ( j = 0; j < N; j++ ) {
+ sum = 0.0;
+ for ( i = 0; i < j; i++ ) {
+ absa = abs( AP[ offsetAP + ( k * strideAP ) ] );
+ sum += absa;
+ work[ i ] += absa;
+ k += 1;
+ }
+ work[ j ] = sum + abs( AP[ offsetAP + ( k * strideAP ) ] );
+ k += 1;
+ }
+ anorm = 0.0;
+ for ( i = 0; i < N; i++ ) {
+ temp = work[ i ];
+ if ( anorm < temp || isnan( temp ) ) {
+ anorm = temp;
+ }
+ }
+ } else {
+ work = new Float64Array( N );
+ k = 0;
+ anorm = 0.0;
+ for ( j = 0; j < N; j++ ) {
+ sum = work[ j ] + abs( AP[ offsetAP + ( k * strideAP ) ] );
+ k += 1;
+ for ( i = j + 1; i < N; i++ ) {
+ absa = abs( AP[ offsetAP + ( k * strideAP ) ] );
+ sum += absa;
+ work[ i ] += absa;
+ k += 1;
+ }
+ if ( anorm < sum || isnan( sum ) ) {
+ anorm = sum;
+ }
+ }
+ }
+ } else if ( norm === 'F' || norm === 'f' || norm === 'E' || norm === 'e' ) {
+ // Find normF(A) = Frobenius norm
+ out = new Float64Array( 2 );
+ scale = 0.0;
+ sumsq = 1.0;
+ if (
+ ( isColumnMajor( order ) && uplo === 'upper' ) ||
+ ( isRowMajor( order ) && uplo === 'lower' )
+ ) {
+ k = 0;
+ for ( j = 0; j < N; j++ ) {
+ if ( j > 0 ) {
+ dlassq( j, AP, strideAP, offsetAP + ( k * strideAP ), scale, sumsq, out, 1, 0 );
+ scale = out[ 0 ];
+ sumsq = out[ 1 ];
+ k += j;
+ }
+ k += 1;
+ }
+ } else {
+ k = 0;
+ for ( j = 0; j < N; j++ ) {
+ if ( j < N - 1 ) {
+ dlassq( N - j - 1, AP, strideAP, offsetAP + ( ( k + 1 ) * strideAP ), scale, sumsq, out, 1, 0 );
+ scale = out[ 0 ];
+ sumsq = out[ 1 ];
+ }
+ k += N - j;
+ }
+ }
+
+ sumsq *= 2.0;
+
+ // Add diagonal elements
+ if (
+ ( isColumnMajor( order ) && uplo === 'upper' ) ||
+ ( isRowMajor( order ) && uplo === 'lower' )
+ ) {
+ k = 0;
+ for ( i = 0; i < N; i++ ) {
+ absa = abs( AP[ offsetAP + ( k * strideAP ) ] );
+ if ( absa !== 0.0 ) {
+ if ( scale < absa ) {
+ ratio = scale / absa;
+ sumsq = 1.0 + ( sumsq * ( ratio * ratio ) );
+ scale = absa;
+ } else {
+ ratio = absa / scale;
+ sumsq += ratio * ratio;
+ }
+ }
+ k += i + 2;
+ }
+ } else {
+ k = 0;
+ for ( i = 0; i < N; i++ ) {
+ absa = abs( AP[ offsetAP + ( k * strideAP ) ] );
+ if ( absa !== 0.0 ) {
+ if ( scale < absa ) {
+ ratio = scale / absa;
+ sumsq = 1.0 + ( sumsq * ( ratio * ratio ) );
+ scale = absa;
+ } else {
+ ratio = absa / scale;
+ sumsq += ratio * ratio;
+ }
+ }
+ k += N - i;
+ }
+ }
+ anorm = scale * sqrt( sumsq );
+ }
+ return anorm;
+}
+
+
+// EXPORTS //
+
+module.exports = dlansp;
diff --git a/lib/node_modules/@stdlib/lapack/base/dlansp/lib/dlansp.js b/lib/node_modules/@stdlib/lapack/base/dlansp/lib/dlansp.js
new file mode 100644
index 000000000000..63528da1df34
--- /dev/null
+++ b/lib/node_modules/@stdlib/lapack/base/dlansp/lib/dlansp.js
@@ -0,0 +1,74 @@
+/**
+* @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 isLayout = require( '@stdlib/blas/base/assert/is-layout' );
+var format = require( '@stdlib/string/format' );
+var base = require( './base.js' );
+
+
+// VARIABLES //
+
+var NORMS = [ 'M', 'm', '1', 'O', 'o', 'I', 'i', 'F', 'f', 'E', 'e' ];
+var UPLOS = [ 'upper', 'lower' ];
+
+
+// MAIN //
+
+/**
+* Returns the value of the one-norm, Frobenius norm, infinity-norm, or the largest absolute value of any element of a real symmetric matrix `AP` supplied in packed form.
+*
+* @param {string} order - storage layout of `AP`
+* @param {string} norm - specifies the norm type
+* @param {string} uplo - specifies whether the upper or lower triangular part of `A` is referenced
+* @param {NonNegativeInteger} N - order of the matrix `A`
+* @param {Float64Array} AP - packed form of a symmetric matrix `A`
+* @throws {TypeError} first argument must be a valid order
+* @throws {TypeError} second argument must be a valid norm type
+* @throws {TypeError} third argument must be a valid uplo value
+* @returns {number} matrix norm
+*
+* @example
+* var Float64Array = require( '@stdlib/array/float64' );
+*
+* // AP = [ 1.0, 2.0, 5.0 ] (2x2 symmetric packed column-major upper)
+* var AP = new Float64Array( [ 1.0, 2.0, 5.0 ] );
+*
+* var norm = dlansp( 'column-major', 'M', 'upper', 2, AP );
+* // returns 5.0
+*/
+function dlansp( order, norm, uplo, N, AP ) {
+ if ( !isLayout( order ) ) {
+ throw new TypeError( format( 'invalid argument. First argument must be a valid order. Value: `%s`.', order ) );
+ }
+ if ( NORMS.indexOf( norm ) === -1 ) {
+ throw new TypeError( format( 'invalid argument. Second argument must be a valid norm type. Value: `%s`.', norm ) );
+ }
+ if ( UPLOS.indexOf( uplo ) === -1 ) {
+ throw new TypeError( format( 'invalid argument. Third argument must be a valid uplo value. Value: `%s`.', uplo ) );
+ }
+ return base( order, norm, uplo, N, AP, 1, 0 );
+}
+
+
+// EXPORTS //
+
+module.exports = dlansp;
diff --git a/lib/node_modules/@stdlib/lapack/base/dlansp/lib/index.js b/lib/node_modules/@stdlib/lapack/base/dlansp/lib/index.js
new file mode 100644
index 000000000000..952b3cbba266
--- /dev/null
+++ b/lib/node_modules/@stdlib/lapack/base/dlansp/lib/index.js
@@ -0,0 +1,70 @@
+/**
+* @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 return the value of the one-norm, Frobenius norm, infinity-norm, or the largest absolute value of any element of a real symmetric matrix supplied in packed form.
+*
+* @module @stdlib/lapack/base/dlansp
+*
+* @example
+* var Float64Array = require( '@stdlib/array/float64' );
+* var dlansp = require( '@stdlib/lapack/base/dlansp' );
+*
+* // AP = [ 1.0, 2.0, 5.0 ] (2x2 symmetric packed column-major upper)
+* var AP = new Float64Array( [ 1.0, 2.0, 5.0 ] );
+*
+* var norm = dlansp( 'column-major', 'M', 'upper', 2, AP );
+* // returns 5.0
+*
+* @example
+* var Float64Array = require( '@stdlib/array/float64' );
+* var dlansp = require( '@stdlib/lapack/base/dlansp' );
+*
+* // AP = [ 1.0, 2.0, 5.0 ] (2x2 symmetric packed column-major upper)
+* var AP = new Float64Array( [ 1.0, 2.0, 5.0 ] );
+*
+* var norm = dlansp.ndarray( 'column-major', 'M', 'upper', 2, AP, 1, 0 );
+* // returns 5.0
+*/
+
+// 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 dlansp;
+var tmp = tryRequire( join( __dirname, './native.js' ) );
+if ( isError( tmp ) ) {
+ dlansp = main;
+} else {
+ dlansp = tmp;
+}
+
+
+// EXPORTS //
+
+module.exports = dlansp;
+
+// exports: { "ndarray": "dlansp.ndarray" }
diff --git a/lib/node_modules/@stdlib/lapack/base/dlansp/lib/main.js b/lib/node_modules/@stdlib/lapack/base/dlansp/lib/main.js
new file mode 100644
index 000000000000..f48da6741dcf
--- /dev/null
+++ b/lib/node_modules/@stdlib/lapack/base/dlansp/lib/main.js
@@ -0,0 +1,35 @@
+/**
+* @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 setReadOnly = require( '@stdlib/utils/define-nonenumerable-read-only-property' );
+var dlansp = require( './dlansp.js' );
+var ndarray = require( './ndarray.js' );
+
+
+// MAIN //
+
+setReadOnly( dlansp, 'ndarray', ndarray );
+
+
+// EXPORTS //
+
+module.exports = dlansp;
diff --git a/lib/node_modules/@stdlib/lapack/base/dlansp/lib/ndarray.js b/lib/node_modules/@stdlib/lapack/base/dlansp/lib/ndarray.js
new file mode 100644
index 000000000000..368139589e52
--- /dev/null
+++ b/lib/node_modules/@stdlib/lapack/base/dlansp/lib/ndarray.js
@@ -0,0 +1,56 @@
+/**
+* @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 base = require( './base.js' );
+
+
+// MAIN //
+
+/**
+* Returns the value of the one-norm, Frobenius norm, infinity-norm, or the largest absolute value of any element of a real symmetric matrix `AP` supplied in packed form using alternative indexing semantics.
+*
+* @param {string} order - storage layout ('row-major' or 'column-major')
+* @param {string} norm - specifies the norm type
+* @param {string} uplo - specifies whether the upper or lower triangular part of `A` is referenced ('upper' or 'lower')
+* @param {NonNegativeInteger} N - order of the matrix `A`
+* @param {Float64Array} AP - packed form of a symmetric matrix `A`
+* @param {integer} strideAP - `AP` stride length
+* @param {NonNegativeInteger} offsetAP - starting `AP` index
+* @returns {number} matrix norm
+*
+* @example
+* var Float64Array = require( '@stdlib/array/float64' );
+*
+* // AP = [ 1.0, 2.0, 5.0 ] (2x2 symmetric packed column-major upper)
+* var AP = new Float64Array( [ 1.0, 2.0, 5.0 ] );
+*
+* var norm = dlansp( 'column-major', 'M', 'upper', 2, AP, 1, 0 );
+* // returns 5.0
+*/
+function dlansp( order, norm, uplo, N, AP, strideAP, offsetAP ) {
+ return base( order, norm, uplo, N, AP, strideAP, offsetAP );
+}
+
+
+// EXPORTS //
+
+module.exports = dlansp;
diff --git a/lib/node_modules/@stdlib/lapack/base/dlansp/package.json b/lib/node_modules/@stdlib/lapack/base/dlansp/package.json
new file mode 100644
index 000000000000..ad13e233c648
--- /dev/null
+++ b/lib/node_modules/@stdlib/lapack/base/dlansp/package.json
@@ -0,0 +1,72 @@
+{
+ "name": "@stdlib/lapack/base/dlansp",
+ "version": "0.0.0",
+ "description": "Return the value of the one-norm, Frobenius norm, infinity-norm, or the largest absolute value of any element of a real symmetric matrix stored in packed form.",
+ "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",
+ "browser": "./lib/main.js",
+ "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",
+ "dlansp",
+ "norm",
+ "packed",
+ "symmetric",
+ "matrix",
+ "linear",
+ "algebra",
+ "subroutines",
+ "array",
+ "ndarray",
+ "float64",
+ "double",
+ "float64array"
+ ]
+}
diff --git a/lib/node_modules/@stdlib/lapack/base/dlansp/test/fixtures/frobenius_norm_column_major_lower.json b/lib/node_modules/@stdlib/lapack/base/dlansp/test/fixtures/frobenius_norm_column_major_lower.json
new file mode 100644
index 000000000000..b4e4bf8fd26d
--- /dev/null
+++ b/lib/node_modules/@stdlib/lapack/base/dlansp/test/fixtures/frobenius_norm_column_major_lower.json
@@ -0,0 +1,47 @@
+{
+ "order": "column-major",
+ "norm": "F",
+ "uplo": "lower",
+ "N": 4,
+ "AP": [
+ 4,
+ -2,
+ 1,
+ 0,
+ 5,
+ -3,
+ 2,
+ 8,
+ -1,
+ 6
+ ],
+ "AP_mat": [
+ [
+ 4,
+ -2,
+ 1,
+ 0
+ ],
+ [
+ -2,
+ 5,
+ -3,
+ 2
+ ],
+ [
+ 1,
+ -3,
+ 8,
+ -1
+ ],
+ [
+ 0,
+ 2,
+ -1,
+ 6
+ ]
+ ],
+ "strideAP": 1,
+ "offsetAP": 0,
+ "expected": 13.379088160259652
+}
diff --git a/lib/node_modules/@stdlib/lapack/base/dlansp/test/fixtures/frobenius_norm_column_major_upper.json b/lib/node_modules/@stdlib/lapack/base/dlansp/test/fixtures/frobenius_norm_column_major_upper.json
new file mode 100644
index 000000000000..1675180f79d9
--- /dev/null
+++ b/lib/node_modules/@stdlib/lapack/base/dlansp/test/fixtures/frobenius_norm_column_major_upper.json
@@ -0,0 +1,47 @@
+{
+ "order": "column-major",
+ "norm": "F",
+ "uplo": "upper",
+ "N": 4,
+ "AP": [
+ 4,
+ -2,
+ 5,
+ 1,
+ -3,
+ 8,
+ 0,
+ 2,
+ -1,
+ 6
+ ],
+ "AP_mat": [
+ [
+ 4,
+ -2,
+ 1,
+ 0
+ ],
+ [
+ -2,
+ 5,
+ -3,
+ 2
+ ],
+ [
+ 1,
+ -3,
+ 8,
+ -1
+ ],
+ [
+ 0,
+ 2,
+ -1,
+ 6
+ ]
+ ],
+ "strideAP": 1,
+ "offsetAP": 0,
+ "expected": 13.379088160259652
+}
diff --git a/lib/node_modules/@stdlib/lapack/base/dlansp/test/fixtures/frobenius_norm_row_major_lower.json b/lib/node_modules/@stdlib/lapack/base/dlansp/test/fixtures/frobenius_norm_row_major_lower.json
new file mode 100644
index 000000000000..c1830860d69b
--- /dev/null
+++ b/lib/node_modules/@stdlib/lapack/base/dlansp/test/fixtures/frobenius_norm_row_major_lower.json
@@ -0,0 +1,47 @@
+{
+ "order": "row-major",
+ "norm": "F",
+ "uplo": "lower",
+ "N": 4,
+ "AP": [
+ 4,
+ -2,
+ 5,
+ 1,
+ -3,
+ 8,
+ 0,
+ 2,
+ -1,
+ 6
+ ],
+ "AP_mat": [
+ [
+ 4,
+ -2,
+ 1,
+ 0
+ ],
+ [
+ -2,
+ 5,
+ -3,
+ 2
+ ],
+ [
+ 1,
+ -3,
+ 8,
+ -1
+ ],
+ [
+ 0,
+ 2,
+ -1,
+ 6
+ ]
+ ],
+ "strideAP": 1,
+ "offsetAP": 0,
+ "expected": 13.379088160259652
+}
diff --git a/lib/node_modules/@stdlib/lapack/base/dlansp/test/fixtures/frobenius_norm_row_major_upper.json b/lib/node_modules/@stdlib/lapack/base/dlansp/test/fixtures/frobenius_norm_row_major_upper.json
new file mode 100644
index 000000000000..6a8daba761df
--- /dev/null
+++ b/lib/node_modules/@stdlib/lapack/base/dlansp/test/fixtures/frobenius_norm_row_major_upper.json
@@ -0,0 +1,47 @@
+{
+ "order": "row-major",
+ "norm": "F",
+ "uplo": "upper",
+ "N": 4,
+ "AP": [
+ 4,
+ -2,
+ 1,
+ 0,
+ 5,
+ -3,
+ 2,
+ 8,
+ -1,
+ 6
+ ],
+ "AP_mat": [
+ [
+ 4,
+ -2,
+ 1,
+ 0
+ ],
+ [
+ -2,
+ 5,
+ -3,
+ 2
+ ],
+ [
+ 1,
+ -3,
+ 8,
+ -1
+ ],
+ [
+ 0,
+ 2,
+ -1,
+ 6
+ ]
+ ],
+ "strideAP": 1,
+ "offsetAP": 0,
+ "expected": 13.379088160259652
+}
diff --git a/lib/node_modules/@stdlib/lapack/base/dlansp/test/fixtures/large_strides/frobenius_norm_column_major_lower.json b/lib/node_modules/@stdlib/lapack/base/dlansp/test/fixtures/large_strides/frobenius_norm_column_major_lower.json
new file mode 100644
index 000000000000..116dda0e51ed
--- /dev/null
+++ b/lib/node_modules/@stdlib/lapack/base/dlansp/test/fixtures/large_strides/frobenius_norm_column_major_lower.json
@@ -0,0 +1,57 @@
+{
+ "order": "column-major",
+ "norm": "F",
+ "uplo": "lower",
+ "N": 4,
+ "AP": [
+ 4,
+ 9999,
+ -2,
+ 9999,
+ 1,
+ 9999,
+ 0,
+ 9999,
+ 5,
+ 9999,
+ -3,
+ 9999,
+ 2,
+ 9999,
+ 8,
+ 9999,
+ -1,
+ 9999,
+ 6,
+ 9999
+ ],
+ "AP_mat": [
+ [
+ 4,
+ -2,
+ 1,
+ 0
+ ],
+ [
+ -2,
+ 5,
+ -3,
+ 2
+ ],
+ [
+ 1,
+ -3,
+ 8,
+ -1
+ ],
+ [
+ 0,
+ 2,
+ -1,
+ 6
+ ]
+ ],
+ "strideAP": 2,
+ "offsetAP": 0,
+ "expected": 13.379088160259652
+}
diff --git a/lib/node_modules/@stdlib/lapack/base/dlansp/test/fixtures/large_strides/frobenius_norm_column_major_upper.json b/lib/node_modules/@stdlib/lapack/base/dlansp/test/fixtures/large_strides/frobenius_norm_column_major_upper.json
new file mode 100644
index 000000000000..5dfd4bc443e8
--- /dev/null
+++ b/lib/node_modules/@stdlib/lapack/base/dlansp/test/fixtures/large_strides/frobenius_norm_column_major_upper.json
@@ -0,0 +1,57 @@
+{
+ "order": "column-major",
+ "norm": "F",
+ "uplo": "upper",
+ "N": 4,
+ "AP": [
+ 4,
+ 9999,
+ -2,
+ 9999,
+ 5,
+ 9999,
+ 1,
+ 9999,
+ -3,
+ 9999,
+ 8,
+ 9999,
+ 0,
+ 9999,
+ 2,
+ 9999,
+ -1,
+ 9999,
+ 6,
+ 9999
+ ],
+ "AP_mat": [
+ [
+ 4,
+ -2,
+ 1,
+ 0
+ ],
+ [
+ -2,
+ 5,
+ -3,
+ 2
+ ],
+ [
+ 1,
+ -3,
+ 8,
+ -1
+ ],
+ [
+ 0,
+ 2,
+ -1,
+ 6
+ ]
+ ],
+ "strideAP": 2,
+ "offsetAP": 0,
+ "expected": 13.379088160259652
+}
diff --git a/lib/node_modules/@stdlib/lapack/base/dlansp/test/fixtures/large_strides/frobenius_norm_row_major_lower.json b/lib/node_modules/@stdlib/lapack/base/dlansp/test/fixtures/large_strides/frobenius_norm_row_major_lower.json
new file mode 100644
index 000000000000..42378f6c8df5
--- /dev/null
+++ b/lib/node_modules/@stdlib/lapack/base/dlansp/test/fixtures/large_strides/frobenius_norm_row_major_lower.json
@@ -0,0 +1,57 @@
+{
+ "order": "row-major",
+ "norm": "F",
+ "uplo": "lower",
+ "N": 4,
+ "AP": [
+ 4,
+ 9999,
+ -2,
+ 9999,
+ 5,
+ 9999,
+ 1,
+ 9999,
+ -3,
+ 9999,
+ 8,
+ 9999,
+ 0,
+ 9999,
+ 2,
+ 9999,
+ -1,
+ 9999,
+ 6,
+ 9999
+ ],
+ "AP_mat": [
+ [
+ 4,
+ -2,
+ 1,
+ 0
+ ],
+ [
+ -2,
+ 5,
+ -3,
+ 2
+ ],
+ [
+ 1,
+ -3,
+ 8,
+ -1
+ ],
+ [
+ 0,
+ 2,
+ -1,
+ 6
+ ]
+ ],
+ "strideAP": 2,
+ "offsetAP": 0,
+ "expected": 13.379088160259652
+}
diff --git a/lib/node_modules/@stdlib/lapack/base/dlansp/test/fixtures/large_strides/frobenius_norm_row_major_upper.json b/lib/node_modules/@stdlib/lapack/base/dlansp/test/fixtures/large_strides/frobenius_norm_row_major_upper.json
new file mode 100644
index 000000000000..53fd1158244f
--- /dev/null
+++ b/lib/node_modules/@stdlib/lapack/base/dlansp/test/fixtures/large_strides/frobenius_norm_row_major_upper.json
@@ -0,0 +1,57 @@
+{
+ "order": "row-major",
+ "norm": "F",
+ "uplo": "upper",
+ "N": 4,
+ "AP": [
+ 4,
+ 9999,
+ -2,
+ 9999,
+ 1,
+ 9999,
+ 0,
+ 9999,
+ 5,
+ 9999,
+ -3,
+ 9999,
+ 2,
+ 9999,
+ 8,
+ 9999,
+ -1,
+ 9999,
+ 6,
+ 9999
+ ],
+ "AP_mat": [
+ [
+ 4,
+ -2,
+ 1,
+ 0
+ ],
+ [
+ -2,
+ 5,
+ -3,
+ 2
+ ],
+ [
+ 1,
+ -3,
+ 8,
+ -1
+ ],
+ [
+ 0,
+ 2,
+ -1,
+ 6
+ ]
+ ],
+ "strideAP": 2,
+ "offsetAP": 0,
+ "expected": 13.379088160259652
+}
diff --git a/lib/node_modules/@stdlib/lapack/base/dlansp/test/fixtures/large_strides/max_norm_column_major_lower.json b/lib/node_modules/@stdlib/lapack/base/dlansp/test/fixtures/large_strides/max_norm_column_major_lower.json
new file mode 100644
index 000000000000..aace53378748
--- /dev/null
+++ b/lib/node_modules/@stdlib/lapack/base/dlansp/test/fixtures/large_strides/max_norm_column_major_lower.json
@@ -0,0 +1,57 @@
+{
+ "order": "column-major",
+ "norm": "M",
+ "uplo": "lower",
+ "N": 4,
+ "AP": [
+ 4,
+ 9999,
+ -2,
+ 9999,
+ 1,
+ 9999,
+ 0,
+ 9999,
+ 5,
+ 9999,
+ -3,
+ 9999,
+ 2,
+ 9999,
+ 8,
+ 9999,
+ -1,
+ 9999,
+ 6,
+ 9999
+ ],
+ "AP_mat": [
+ [
+ 4,
+ -2,
+ 1,
+ 0
+ ],
+ [
+ -2,
+ 5,
+ -3,
+ 2
+ ],
+ [
+ 1,
+ -3,
+ 8,
+ -1
+ ],
+ [
+ 0,
+ 2,
+ -1,
+ 6
+ ]
+ ],
+ "strideAP": 2,
+ "offsetAP": 0,
+ "expected": 8
+}
diff --git a/lib/node_modules/@stdlib/lapack/base/dlansp/test/fixtures/large_strides/max_norm_column_major_upper.json b/lib/node_modules/@stdlib/lapack/base/dlansp/test/fixtures/large_strides/max_norm_column_major_upper.json
new file mode 100644
index 000000000000..bb0e50309005
--- /dev/null
+++ b/lib/node_modules/@stdlib/lapack/base/dlansp/test/fixtures/large_strides/max_norm_column_major_upper.json
@@ -0,0 +1,57 @@
+{
+ "order": "column-major",
+ "norm": "M",
+ "uplo": "upper",
+ "N": 4,
+ "AP": [
+ 4,
+ 9999,
+ -2,
+ 9999,
+ 5,
+ 9999,
+ 1,
+ 9999,
+ -3,
+ 9999,
+ 8,
+ 9999,
+ 0,
+ 9999,
+ 2,
+ 9999,
+ -1,
+ 9999,
+ 6,
+ 9999
+ ],
+ "AP_mat": [
+ [
+ 4,
+ -2,
+ 1,
+ 0
+ ],
+ [
+ -2,
+ 5,
+ -3,
+ 2
+ ],
+ [
+ 1,
+ -3,
+ 8,
+ -1
+ ],
+ [
+ 0,
+ 2,
+ -1,
+ 6
+ ]
+ ],
+ "strideAP": 2,
+ "offsetAP": 0,
+ "expected": 8
+}
diff --git a/lib/node_modules/@stdlib/lapack/base/dlansp/test/fixtures/large_strides/max_norm_row_major_lower.json b/lib/node_modules/@stdlib/lapack/base/dlansp/test/fixtures/large_strides/max_norm_row_major_lower.json
new file mode 100644
index 000000000000..2b5507df237a
--- /dev/null
+++ b/lib/node_modules/@stdlib/lapack/base/dlansp/test/fixtures/large_strides/max_norm_row_major_lower.json
@@ -0,0 +1,57 @@
+{
+ "order": "row-major",
+ "norm": "M",
+ "uplo": "lower",
+ "N": 4,
+ "AP": [
+ 4,
+ 9999,
+ -2,
+ 9999,
+ 5,
+ 9999,
+ 1,
+ 9999,
+ -3,
+ 9999,
+ 8,
+ 9999,
+ 0,
+ 9999,
+ 2,
+ 9999,
+ -1,
+ 9999,
+ 6,
+ 9999
+ ],
+ "AP_mat": [
+ [
+ 4,
+ -2,
+ 1,
+ 0
+ ],
+ [
+ -2,
+ 5,
+ -3,
+ 2
+ ],
+ [
+ 1,
+ -3,
+ 8,
+ -1
+ ],
+ [
+ 0,
+ 2,
+ -1,
+ 6
+ ]
+ ],
+ "strideAP": 2,
+ "offsetAP": 0,
+ "expected": 8
+}
diff --git a/lib/node_modules/@stdlib/lapack/base/dlansp/test/fixtures/large_strides/max_norm_row_major_upper.json b/lib/node_modules/@stdlib/lapack/base/dlansp/test/fixtures/large_strides/max_norm_row_major_upper.json
new file mode 100644
index 000000000000..6fdc7d26c034
--- /dev/null
+++ b/lib/node_modules/@stdlib/lapack/base/dlansp/test/fixtures/large_strides/max_norm_row_major_upper.json
@@ -0,0 +1,57 @@
+{
+ "order": "row-major",
+ "norm": "M",
+ "uplo": "upper",
+ "N": 4,
+ "AP": [
+ 4,
+ 9999,
+ -2,
+ 9999,
+ 1,
+ 9999,
+ 0,
+ 9999,
+ 5,
+ 9999,
+ -3,
+ 9999,
+ 2,
+ 9999,
+ 8,
+ 9999,
+ -1,
+ 9999,
+ 6,
+ 9999
+ ],
+ "AP_mat": [
+ [
+ 4,
+ -2,
+ 1,
+ 0
+ ],
+ [
+ -2,
+ 5,
+ -3,
+ 2
+ ],
+ [
+ 1,
+ -3,
+ 8,
+ -1
+ ],
+ [
+ 0,
+ 2,
+ -1,
+ 6
+ ]
+ ],
+ "strideAP": 2,
+ "offsetAP": 0,
+ "expected": 8
+}
diff --git a/lib/node_modules/@stdlib/lapack/base/dlansp/test/fixtures/large_strides/one_norm_column_major_lower.json b/lib/node_modules/@stdlib/lapack/base/dlansp/test/fixtures/large_strides/one_norm_column_major_lower.json
new file mode 100644
index 000000000000..5c26f3415ffc
--- /dev/null
+++ b/lib/node_modules/@stdlib/lapack/base/dlansp/test/fixtures/large_strides/one_norm_column_major_lower.json
@@ -0,0 +1,57 @@
+{
+ "order": "column-major",
+ "norm": "1",
+ "uplo": "lower",
+ "N": 4,
+ "AP": [
+ 4,
+ 9999,
+ -2,
+ 9999,
+ 1,
+ 9999,
+ 0,
+ 9999,
+ 5,
+ 9999,
+ -3,
+ 9999,
+ 2,
+ 9999,
+ 8,
+ 9999,
+ -1,
+ 9999,
+ 6,
+ 9999
+ ],
+ "AP_mat": [
+ [
+ 4,
+ -2,
+ 1,
+ 0
+ ],
+ [
+ -2,
+ 5,
+ -3,
+ 2
+ ],
+ [
+ 1,
+ -3,
+ 8,
+ -1
+ ],
+ [
+ 0,
+ 2,
+ -1,
+ 6
+ ]
+ ],
+ "strideAP": 2,
+ "offsetAP": 0,
+ "expected": 13
+}
diff --git a/lib/node_modules/@stdlib/lapack/base/dlansp/test/fixtures/large_strides/one_norm_column_major_upper.json b/lib/node_modules/@stdlib/lapack/base/dlansp/test/fixtures/large_strides/one_norm_column_major_upper.json
new file mode 100644
index 000000000000..dba038c3ca3f
--- /dev/null
+++ b/lib/node_modules/@stdlib/lapack/base/dlansp/test/fixtures/large_strides/one_norm_column_major_upper.json
@@ -0,0 +1,57 @@
+{
+ "order": "column-major",
+ "norm": "1",
+ "uplo": "upper",
+ "N": 4,
+ "AP": [
+ 4,
+ 9999,
+ -2,
+ 9999,
+ 5,
+ 9999,
+ 1,
+ 9999,
+ -3,
+ 9999,
+ 8,
+ 9999,
+ 0,
+ 9999,
+ 2,
+ 9999,
+ -1,
+ 9999,
+ 6,
+ 9999
+ ],
+ "AP_mat": [
+ [
+ 4,
+ -2,
+ 1,
+ 0
+ ],
+ [
+ -2,
+ 5,
+ -3,
+ 2
+ ],
+ [
+ 1,
+ -3,
+ 8,
+ -1
+ ],
+ [
+ 0,
+ 2,
+ -1,
+ 6
+ ]
+ ],
+ "strideAP": 2,
+ "offsetAP": 0,
+ "expected": 13
+}
diff --git a/lib/node_modules/@stdlib/lapack/base/dlansp/test/fixtures/large_strides/one_norm_row_major_lower.json b/lib/node_modules/@stdlib/lapack/base/dlansp/test/fixtures/large_strides/one_norm_row_major_lower.json
new file mode 100644
index 000000000000..72439712d649
--- /dev/null
+++ b/lib/node_modules/@stdlib/lapack/base/dlansp/test/fixtures/large_strides/one_norm_row_major_lower.json
@@ -0,0 +1,57 @@
+{
+ "order": "row-major",
+ "norm": "1",
+ "uplo": "lower",
+ "N": 4,
+ "AP": [
+ 4,
+ 9999,
+ -2,
+ 9999,
+ 5,
+ 9999,
+ 1,
+ 9999,
+ -3,
+ 9999,
+ 8,
+ 9999,
+ 0,
+ 9999,
+ 2,
+ 9999,
+ -1,
+ 9999,
+ 6,
+ 9999
+ ],
+ "AP_mat": [
+ [
+ 4,
+ -2,
+ 1,
+ 0
+ ],
+ [
+ -2,
+ 5,
+ -3,
+ 2
+ ],
+ [
+ 1,
+ -3,
+ 8,
+ -1
+ ],
+ [
+ 0,
+ 2,
+ -1,
+ 6
+ ]
+ ],
+ "strideAP": 2,
+ "offsetAP": 0,
+ "expected": 13
+}
diff --git a/lib/node_modules/@stdlib/lapack/base/dlansp/test/fixtures/large_strides/one_norm_row_major_upper.json b/lib/node_modules/@stdlib/lapack/base/dlansp/test/fixtures/large_strides/one_norm_row_major_upper.json
new file mode 100644
index 000000000000..028c45a11996
--- /dev/null
+++ b/lib/node_modules/@stdlib/lapack/base/dlansp/test/fixtures/large_strides/one_norm_row_major_upper.json
@@ -0,0 +1,57 @@
+{
+ "order": "row-major",
+ "norm": "1",
+ "uplo": "upper",
+ "N": 4,
+ "AP": [
+ 4,
+ 9999,
+ -2,
+ 9999,
+ 1,
+ 9999,
+ 0,
+ 9999,
+ 5,
+ 9999,
+ -3,
+ 9999,
+ 2,
+ 9999,
+ 8,
+ 9999,
+ -1,
+ 9999,
+ 6,
+ 9999
+ ],
+ "AP_mat": [
+ [
+ 4,
+ -2,
+ 1,
+ 0
+ ],
+ [
+ -2,
+ 5,
+ -3,
+ 2
+ ],
+ [
+ 1,
+ -3,
+ 8,
+ -1
+ ],
+ [
+ 0,
+ 2,
+ -1,
+ 6
+ ]
+ ],
+ "strideAP": 2,
+ "offsetAP": 0,
+ "expected": 13
+}
diff --git a/lib/node_modules/@stdlib/lapack/base/dlansp/test/fixtures/max_norm_column_major_lower.json b/lib/node_modules/@stdlib/lapack/base/dlansp/test/fixtures/max_norm_column_major_lower.json
new file mode 100644
index 000000000000..e5f64d411595
--- /dev/null
+++ b/lib/node_modules/@stdlib/lapack/base/dlansp/test/fixtures/max_norm_column_major_lower.json
@@ -0,0 +1,47 @@
+{
+ "order": "column-major",
+ "norm": "M",
+ "uplo": "lower",
+ "N": 4,
+ "AP": [
+ 4,
+ -2,
+ 1,
+ 0,
+ 5,
+ -3,
+ 2,
+ 8,
+ -1,
+ 6
+ ],
+ "AP_mat": [
+ [
+ 4,
+ -2,
+ 1,
+ 0
+ ],
+ [
+ -2,
+ 5,
+ -3,
+ 2
+ ],
+ [
+ 1,
+ -3,
+ 8,
+ -1
+ ],
+ [
+ 0,
+ 2,
+ -1,
+ 6
+ ]
+ ],
+ "strideAP": 1,
+ "offsetAP": 0,
+ "expected": 8
+}
diff --git a/lib/node_modules/@stdlib/lapack/base/dlansp/test/fixtures/max_norm_column_major_upper.json b/lib/node_modules/@stdlib/lapack/base/dlansp/test/fixtures/max_norm_column_major_upper.json
new file mode 100644
index 000000000000..08d472ffc385
--- /dev/null
+++ b/lib/node_modules/@stdlib/lapack/base/dlansp/test/fixtures/max_norm_column_major_upper.json
@@ -0,0 +1,47 @@
+{
+ "order": "column-major",
+ "norm": "M",
+ "uplo": "upper",
+ "N": 4,
+ "AP": [
+ 4,
+ -2,
+ 5,
+ 1,
+ -3,
+ 8,
+ 0,
+ 2,
+ -1,
+ 6
+ ],
+ "AP_mat": [
+ [
+ 4,
+ -2,
+ 1,
+ 0
+ ],
+ [
+ -2,
+ 5,
+ -3,
+ 2
+ ],
+ [
+ 1,
+ -3,
+ 8,
+ -1
+ ],
+ [
+ 0,
+ 2,
+ -1,
+ 6
+ ]
+ ],
+ "strideAP": 1,
+ "offsetAP": 0,
+ "expected": 8
+}
diff --git a/lib/node_modules/@stdlib/lapack/base/dlansp/test/fixtures/max_norm_row_major_lower.json b/lib/node_modules/@stdlib/lapack/base/dlansp/test/fixtures/max_norm_row_major_lower.json
new file mode 100644
index 000000000000..907bb67c4785
--- /dev/null
+++ b/lib/node_modules/@stdlib/lapack/base/dlansp/test/fixtures/max_norm_row_major_lower.json
@@ -0,0 +1,47 @@
+{
+ "order": "row-major",
+ "norm": "M",
+ "uplo": "lower",
+ "N": 4,
+ "AP": [
+ 4,
+ -2,
+ 5,
+ 1,
+ -3,
+ 8,
+ 0,
+ 2,
+ -1,
+ 6
+ ],
+ "AP_mat": [
+ [
+ 4,
+ -2,
+ 1,
+ 0
+ ],
+ [
+ -2,
+ 5,
+ -3,
+ 2
+ ],
+ [
+ 1,
+ -3,
+ 8,
+ -1
+ ],
+ [
+ 0,
+ 2,
+ -1,
+ 6
+ ]
+ ],
+ "strideAP": 1,
+ "offsetAP": 0,
+ "expected": 8
+}
diff --git a/lib/node_modules/@stdlib/lapack/base/dlansp/test/fixtures/max_norm_row_major_upper.json b/lib/node_modules/@stdlib/lapack/base/dlansp/test/fixtures/max_norm_row_major_upper.json
new file mode 100644
index 000000000000..9ce9bda568a1
--- /dev/null
+++ b/lib/node_modules/@stdlib/lapack/base/dlansp/test/fixtures/max_norm_row_major_upper.json
@@ -0,0 +1,47 @@
+{
+ "order": "row-major",
+ "norm": "M",
+ "uplo": "upper",
+ "N": 4,
+ "AP": [
+ 4,
+ -2,
+ 1,
+ 0,
+ 5,
+ -3,
+ 2,
+ 8,
+ -1,
+ 6
+ ],
+ "AP_mat": [
+ [
+ 4,
+ -2,
+ 1,
+ 0
+ ],
+ [
+ -2,
+ 5,
+ -3,
+ 2
+ ],
+ [
+ 1,
+ -3,
+ 8,
+ -1
+ ],
+ [
+ 0,
+ 2,
+ -1,
+ 6
+ ]
+ ],
+ "strideAP": 1,
+ "offsetAP": 0,
+ "expected": 8
+}
diff --git a/lib/node_modules/@stdlib/lapack/base/dlansp/test/fixtures/mixed_strides/frobenius_norm_column_major_lower.json b/lib/node_modules/@stdlib/lapack/base/dlansp/test/fixtures/mixed_strides/frobenius_norm_column_major_lower.json
new file mode 100644
index 000000000000..e6ef80a44b64
--- /dev/null
+++ b/lib/node_modules/@stdlib/lapack/base/dlansp/test/fixtures/mixed_strides/frobenius_norm_column_major_lower.json
@@ -0,0 +1,50 @@
+{
+ "order": "column-major",
+ "norm": "F",
+ "uplo": "lower",
+ "N": 4,
+ "AP": [
+ 9999,
+ 9999,
+ 9999,
+ 6,
+ -1,
+ 8,
+ 2,
+ -3,
+ 5,
+ 0,
+ 1,
+ -2,
+ 4
+ ],
+ "AP_mat": [
+ [
+ 4,
+ -2,
+ 1,
+ 0
+ ],
+ [
+ -2,
+ 5,
+ -3,
+ 2
+ ],
+ [
+ 1,
+ -3,
+ 8,
+ -1
+ ],
+ [
+ 0,
+ 2,
+ -1,
+ 6
+ ]
+ ],
+ "strideAP": -1,
+ "offsetAP": 12,
+ "expected": 13.379088160259652
+}
diff --git a/lib/node_modules/@stdlib/lapack/base/dlansp/test/fixtures/mixed_strides/frobenius_norm_column_major_upper.json b/lib/node_modules/@stdlib/lapack/base/dlansp/test/fixtures/mixed_strides/frobenius_norm_column_major_upper.json
new file mode 100644
index 000000000000..c6d324a19556
--- /dev/null
+++ b/lib/node_modules/@stdlib/lapack/base/dlansp/test/fixtures/mixed_strides/frobenius_norm_column_major_upper.json
@@ -0,0 +1,50 @@
+{
+ "order": "column-major",
+ "norm": "F",
+ "uplo": "upper",
+ "N": 4,
+ "AP": [
+ 9999,
+ 9999,
+ 9999,
+ 6,
+ -1,
+ 2,
+ 0,
+ 8,
+ -3,
+ 1,
+ 5,
+ -2,
+ 4
+ ],
+ "AP_mat": [
+ [
+ 4,
+ -2,
+ 1,
+ 0
+ ],
+ [
+ -2,
+ 5,
+ -3,
+ 2
+ ],
+ [
+ 1,
+ -3,
+ 8,
+ -1
+ ],
+ [
+ 0,
+ 2,
+ -1,
+ 6
+ ]
+ ],
+ "strideAP": -1,
+ "offsetAP": 12,
+ "expected": 13.379088160259652
+}
diff --git a/lib/node_modules/@stdlib/lapack/base/dlansp/test/fixtures/mixed_strides/frobenius_norm_row_major_lower.json b/lib/node_modules/@stdlib/lapack/base/dlansp/test/fixtures/mixed_strides/frobenius_norm_row_major_lower.json
new file mode 100644
index 000000000000..cdc572f72b99
--- /dev/null
+++ b/lib/node_modules/@stdlib/lapack/base/dlansp/test/fixtures/mixed_strides/frobenius_norm_row_major_lower.json
@@ -0,0 +1,50 @@
+{
+ "order": "row-major",
+ "norm": "F",
+ "uplo": "lower",
+ "N": 4,
+ "AP": [
+ 9999,
+ 9999,
+ 9999,
+ 6,
+ -1,
+ 2,
+ 0,
+ 8,
+ -3,
+ 1,
+ 5,
+ -2,
+ 4
+ ],
+ "AP_mat": [
+ [
+ 4,
+ -2,
+ 1,
+ 0
+ ],
+ [
+ -2,
+ 5,
+ -3,
+ 2
+ ],
+ [
+ 1,
+ -3,
+ 8,
+ -1
+ ],
+ [
+ 0,
+ 2,
+ -1,
+ 6
+ ]
+ ],
+ "strideAP": -1,
+ "offsetAP": 12,
+ "expected": 13.379088160259652
+}
diff --git a/lib/node_modules/@stdlib/lapack/base/dlansp/test/fixtures/mixed_strides/frobenius_norm_row_major_upper.json b/lib/node_modules/@stdlib/lapack/base/dlansp/test/fixtures/mixed_strides/frobenius_norm_row_major_upper.json
new file mode 100644
index 000000000000..1fde80c1f988
--- /dev/null
+++ b/lib/node_modules/@stdlib/lapack/base/dlansp/test/fixtures/mixed_strides/frobenius_norm_row_major_upper.json
@@ -0,0 +1,50 @@
+{
+ "order": "row-major",
+ "norm": "F",
+ "uplo": "upper",
+ "N": 4,
+ "AP": [
+ 9999,
+ 9999,
+ 9999,
+ 6,
+ -1,
+ 8,
+ 2,
+ -3,
+ 5,
+ 0,
+ 1,
+ -2,
+ 4
+ ],
+ "AP_mat": [
+ [
+ 4,
+ -2,
+ 1,
+ 0
+ ],
+ [
+ -2,
+ 5,
+ -3,
+ 2
+ ],
+ [
+ 1,
+ -3,
+ 8,
+ -1
+ ],
+ [
+ 0,
+ 2,
+ -1,
+ 6
+ ]
+ ],
+ "strideAP": -1,
+ "offsetAP": 12,
+ "expected": 13.379088160259652
+}
diff --git a/lib/node_modules/@stdlib/lapack/base/dlansp/test/fixtures/mixed_strides/max_norm_column_major_lower.json b/lib/node_modules/@stdlib/lapack/base/dlansp/test/fixtures/mixed_strides/max_norm_column_major_lower.json
new file mode 100644
index 000000000000..e14decfb482d
--- /dev/null
+++ b/lib/node_modules/@stdlib/lapack/base/dlansp/test/fixtures/mixed_strides/max_norm_column_major_lower.json
@@ -0,0 +1,50 @@
+{
+ "order": "column-major",
+ "norm": "M",
+ "uplo": "lower",
+ "N": 4,
+ "AP": [
+ 9999,
+ 9999,
+ 9999,
+ 6,
+ -1,
+ 8,
+ 2,
+ -3,
+ 5,
+ 0,
+ 1,
+ -2,
+ 4
+ ],
+ "AP_mat": [
+ [
+ 4,
+ -2,
+ 1,
+ 0
+ ],
+ [
+ -2,
+ 5,
+ -3,
+ 2
+ ],
+ [
+ 1,
+ -3,
+ 8,
+ -1
+ ],
+ [
+ 0,
+ 2,
+ -1,
+ 6
+ ]
+ ],
+ "strideAP": -1,
+ "offsetAP": 12,
+ "expected": 8
+}
diff --git a/lib/node_modules/@stdlib/lapack/base/dlansp/test/fixtures/mixed_strides/max_norm_column_major_upper.json b/lib/node_modules/@stdlib/lapack/base/dlansp/test/fixtures/mixed_strides/max_norm_column_major_upper.json
new file mode 100644
index 000000000000..66edc529f602
--- /dev/null
+++ b/lib/node_modules/@stdlib/lapack/base/dlansp/test/fixtures/mixed_strides/max_norm_column_major_upper.json
@@ -0,0 +1,50 @@
+{
+ "order": "column-major",
+ "norm": "M",
+ "uplo": "upper",
+ "N": 4,
+ "AP": [
+ 9999,
+ 9999,
+ 9999,
+ 6,
+ -1,
+ 2,
+ 0,
+ 8,
+ -3,
+ 1,
+ 5,
+ -2,
+ 4
+ ],
+ "AP_mat": [
+ [
+ 4,
+ -2,
+ 1,
+ 0
+ ],
+ [
+ -2,
+ 5,
+ -3,
+ 2
+ ],
+ [
+ 1,
+ -3,
+ 8,
+ -1
+ ],
+ [
+ 0,
+ 2,
+ -1,
+ 6
+ ]
+ ],
+ "strideAP": -1,
+ "offsetAP": 12,
+ "expected": 8
+}
diff --git a/lib/node_modules/@stdlib/lapack/base/dlansp/test/fixtures/mixed_strides/max_norm_row_major_lower.json b/lib/node_modules/@stdlib/lapack/base/dlansp/test/fixtures/mixed_strides/max_norm_row_major_lower.json
new file mode 100644
index 000000000000..9e45f2e474ed
--- /dev/null
+++ b/lib/node_modules/@stdlib/lapack/base/dlansp/test/fixtures/mixed_strides/max_norm_row_major_lower.json
@@ -0,0 +1,50 @@
+{
+ "order": "row-major",
+ "norm": "M",
+ "uplo": "lower",
+ "N": 4,
+ "AP": [
+ 9999,
+ 9999,
+ 9999,
+ 6,
+ -1,
+ 2,
+ 0,
+ 8,
+ -3,
+ 1,
+ 5,
+ -2,
+ 4
+ ],
+ "AP_mat": [
+ [
+ 4,
+ -2,
+ 1,
+ 0
+ ],
+ [
+ -2,
+ 5,
+ -3,
+ 2
+ ],
+ [
+ 1,
+ -3,
+ 8,
+ -1
+ ],
+ [
+ 0,
+ 2,
+ -1,
+ 6
+ ]
+ ],
+ "strideAP": -1,
+ "offsetAP": 12,
+ "expected": 8
+}
diff --git a/lib/node_modules/@stdlib/lapack/base/dlansp/test/fixtures/mixed_strides/max_norm_row_major_upper.json b/lib/node_modules/@stdlib/lapack/base/dlansp/test/fixtures/mixed_strides/max_norm_row_major_upper.json
new file mode 100644
index 000000000000..007da4b590d2
--- /dev/null
+++ b/lib/node_modules/@stdlib/lapack/base/dlansp/test/fixtures/mixed_strides/max_norm_row_major_upper.json
@@ -0,0 +1,50 @@
+{
+ "order": "row-major",
+ "norm": "M",
+ "uplo": "upper",
+ "N": 4,
+ "AP": [
+ 9999,
+ 9999,
+ 9999,
+ 6,
+ -1,
+ 8,
+ 2,
+ -3,
+ 5,
+ 0,
+ 1,
+ -2,
+ 4
+ ],
+ "AP_mat": [
+ [
+ 4,
+ -2,
+ 1,
+ 0
+ ],
+ [
+ -2,
+ 5,
+ -3,
+ 2
+ ],
+ [
+ 1,
+ -3,
+ 8,
+ -1
+ ],
+ [
+ 0,
+ 2,
+ -1,
+ 6
+ ]
+ ],
+ "strideAP": -1,
+ "offsetAP": 12,
+ "expected": 8
+}
diff --git a/lib/node_modules/@stdlib/lapack/base/dlansp/test/fixtures/mixed_strides/one_norm_column_major_lower.json b/lib/node_modules/@stdlib/lapack/base/dlansp/test/fixtures/mixed_strides/one_norm_column_major_lower.json
new file mode 100644
index 000000000000..73df0a750efa
--- /dev/null
+++ b/lib/node_modules/@stdlib/lapack/base/dlansp/test/fixtures/mixed_strides/one_norm_column_major_lower.json
@@ -0,0 +1,50 @@
+{
+ "order": "column-major",
+ "norm": "1",
+ "uplo": "lower",
+ "N": 4,
+ "AP": [
+ 9999,
+ 9999,
+ 9999,
+ 6,
+ -1,
+ 8,
+ 2,
+ -3,
+ 5,
+ 0,
+ 1,
+ -2,
+ 4
+ ],
+ "AP_mat": [
+ [
+ 4,
+ -2,
+ 1,
+ 0
+ ],
+ [
+ -2,
+ 5,
+ -3,
+ 2
+ ],
+ [
+ 1,
+ -3,
+ 8,
+ -1
+ ],
+ [
+ 0,
+ 2,
+ -1,
+ 6
+ ]
+ ],
+ "strideAP": -1,
+ "offsetAP": 12,
+ "expected": 13
+}
diff --git a/lib/node_modules/@stdlib/lapack/base/dlansp/test/fixtures/mixed_strides/one_norm_column_major_upper.json b/lib/node_modules/@stdlib/lapack/base/dlansp/test/fixtures/mixed_strides/one_norm_column_major_upper.json
new file mode 100644
index 000000000000..cedf8db4be7b
--- /dev/null
+++ b/lib/node_modules/@stdlib/lapack/base/dlansp/test/fixtures/mixed_strides/one_norm_column_major_upper.json
@@ -0,0 +1,50 @@
+{
+ "order": "column-major",
+ "norm": "1",
+ "uplo": "upper",
+ "N": 4,
+ "AP": [
+ 9999,
+ 9999,
+ 9999,
+ 6,
+ -1,
+ 2,
+ 0,
+ 8,
+ -3,
+ 1,
+ 5,
+ -2,
+ 4
+ ],
+ "AP_mat": [
+ [
+ 4,
+ -2,
+ 1,
+ 0
+ ],
+ [
+ -2,
+ 5,
+ -3,
+ 2
+ ],
+ [
+ 1,
+ -3,
+ 8,
+ -1
+ ],
+ [
+ 0,
+ 2,
+ -1,
+ 6
+ ]
+ ],
+ "strideAP": -1,
+ "offsetAP": 12,
+ "expected": 13
+}
diff --git a/lib/node_modules/@stdlib/lapack/base/dlansp/test/fixtures/mixed_strides/one_norm_row_major_lower.json b/lib/node_modules/@stdlib/lapack/base/dlansp/test/fixtures/mixed_strides/one_norm_row_major_lower.json
new file mode 100644
index 000000000000..3c6659780bac
--- /dev/null
+++ b/lib/node_modules/@stdlib/lapack/base/dlansp/test/fixtures/mixed_strides/one_norm_row_major_lower.json
@@ -0,0 +1,50 @@
+{
+ "order": "row-major",
+ "norm": "1",
+ "uplo": "lower",
+ "N": 4,
+ "AP": [
+ 9999,
+ 9999,
+ 9999,
+ 6,
+ -1,
+ 2,
+ 0,
+ 8,
+ -3,
+ 1,
+ 5,
+ -2,
+ 4
+ ],
+ "AP_mat": [
+ [
+ 4,
+ -2,
+ 1,
+ 0
+ ],
+ [
+ -2,
+ 5,
+ -3,
+ 2
+ ],
+ [
+ 1,
+ -3,
+ 8,
+ -1
+ ],
+ [
+ 0,
+ 2,
+ -1,
+ 6
+ ]
+ ],
+ "strideAP": -1,
+ "offsetAP": 12,
+ "expected": 13
+}
diff --git a/lib/node_modules/@stdlib/lapack/base/dlansp/test/fixtures/mixed_strides/one_norm_row_major_upper.json b/lib/node_modules/@stdlib/lapack/base/dlansp/test/fixtures/mixed_strides/one_norm_row_major_upper.json
new file mode 100644
index 000000000000..da9144930795
--- /dev/null
+++ b/lib/node_modules/@stdlib/lapack/base/dlansp/test/fixtures/mixed_strides/one_norm_row_major_upper.json
@@ -0,0 +1,50 @@
+{
+ "order": "row-major",
+ "norm": "1",
+ "uplo": "upper",
+ "N": 4,
+ "AP": [
+ 9999,
+ 9999,
+ 9999,
+ 6,
+ -1,
+ 8,
+ 2,
+ -3,
+ 5,
+ 0,
+ 1,
+ -2,
+ 4
+ ],
+ "AP_mat": [
+ [
+ 4,
+ -2,
+ 1,
+ 0
+ ],
+ [
+ -2,
+ 5,
+ -3,
+ 2
+ ],
+ [
+ 1,
+ -3,
+ 8,
+ -1
+ ],
+ [
+ 0,
+ 2,
+ -1,
+ 6
+ ]
+ ],
+ "strideAP": -1,
+ "offsetAP": 12,
+ "expected": 13
+}
diff --git a/lib/node_modules/@stdlib/lapack/base/dlansp/test/fixtures/negative_strides/frobenius_norm_column_major_lower.json b/lib/node_modules/@stdlib/lapack/base/dlansp/test/fixtures/negative_strides/frobenius_norm_column_major_lower.json
new file mode 100644
index 000000000000..08ee3251995c
--- /dev/null
+++ b/lib/node_modules/@stdlib/lapack/base/dlansp/test/fixtures/negative_strides/frobenius_norm_column_major_lower.json
@@ -0,0 +1,47 @@
+{
+ "order": "column-major",
+ "norm": "F",
+ "uplo": "lower",
+ "N": 4,
+ "AP": [
+ 6,
+ -1,
+ 8,
+ 2,
+ -3,
+ 5,
+ 0,
+ 1,
+ -2,
+ 4
+ ],
+ "AP_mat": [
+ [
+ 4,
+ -2,
+ 1,
+ 0
+ ],
+ [
+ -2,
+ 5,
+ -3,
+ 2
+ ],
+ [
+ 1,
+ -3,
+ 8,
+ -1
+ ],
+ [
+ 0,
+ 2,
+ -1,
+ 6
+ ]
+ ],
+ "strideAP": -1,
+ "offsetAP": 9,
+ "expected": 13.379088160259652
+}
diff --git a/lib/node_modules/@stdlib/lapack/base/dlansp/test/fixtures/negative_strides/frobenius_norm_column_major_upper.json b/lib/node_modules/@stdlib/lapack/base/dlansp/test/fixtures/negative_strides/frobenius_norm_column_major_upper.json
new file mode 100644
index 000000000000..feeb0007450b
--- /dev/null
+++ b/lib/node_modules/@stdlib/lapack/base/dlansp/test/fixtures/negative_strides/frobenius_norm_column_major_upper.json
@@ -0,0 +1,47 @@
+{
+ "order": "column-major",
+ "norm": "F",
+ "uplo": "upper",
+ "N": 4,
+ "AP": [
+ 6,
+ -1,
+ 2,
+ 0,
+ 8,
+ -3,
+ 1,
+ 5,
+ -2,
+ 4
+ ],
+ "AP_mat": [
+ [
+ 4,
+ -2,
+ 1,
+ 0
+ ],
+ [
+ -2,
+ 5,
+ -3,
+ 2
+ ],
+ [
+ 1,
+ -3,
+ 8,
+ -1
+ ],
+ [
+ 0,
+ 2,
+ -1,
+ 6
+ ]
+ ],
+ "strideAP": -1,
+ "offsetAP": 9,
+ "expected": 13.379088160259652
+}
diff --git a/lib/node_modules/@stdlib/lapack/base/dlansp/test/fixtures/negative_strides/frobenius_norm_row_major_lower.json b/lib/node_modules/@stdlib/lapack/base/dlansp/test/fixtures/negative_strides/frobenius_norm_row_major_lower.json
new file mode 100644
index 000000000000..6c08c8fb2ebd
--- /dev/null
+++ b/lib/node_modules/@stdlib/lapack/base/dlansp/test/fixtures/negative_strides/frobenius_norm_row_major_lower.json
@@ -0,0 +1,47 @@
+{
+ "order": "row-major",
+ "norm": "F",
+ "uplo": "lower",
+ "N": 4,
+ "AP": [
+ 6,
+ -1,
+ 2,
+ 0,
+ 8,
+ -3,
+ 1,
+ 5,
+ -2,
+ 4
+ ],
+ "AP_mat": [
+ [
+ 4,
+ -2,
+ 1,
+ 0
+ ],
+ [
+ -2,
+ 5,
+ -3,
+ 2
+ ],
+ [
+ 1,
+ -3,
+ 8,
+ -1
+ ],
+ [
+ 0,
+ 2,
+ -1,
+ 6
+ ]
+ ],
+ "strideAP": -1,
+ "offsetAP": 9,
+ "expected": 13.379088160259652
+}
diff --git a/lib/node_modules/@stdlib/lapack/base/dlansp/test/fixtures/negative_strides/frobenius_norm_row_major_upper.json b/lib/node_modules/@stdlib/lapack/base/dlansp/test/fixtures/negative_strides/frobenius_norm_row_major_upper.json
new file mode 100644
index 000000000000..2f515cbc8f6d
--- /dev/null
+++ b/lib/node_modules/@stdlib/lapack/base/dlansp/test/fixtures/negative_strides/frobenius_norm_row_major_upper.json
@@ -0,0 +1,47 @@
+{
+ "order": "row-major",
+ "norm": "F",
+ "uplo": "upper",
+ "N": 4,
+ "AP": [
+ 6,
+ -1,
+ 8,
+ 2,
+ -3,
+ 5,
+ 0,
+ 1,
+ -2,
+ 4
+ ],
+ "AP_mat": [
+ [
+ 4,
+ -2,
+ 1,
+ 0
+ ],
+ [
+ -2,
+ 5,
+ -3,
+ 2
+ ],
+ [
+ 1,
+ -3,
+ 8,
+ -1
+ ],
+ [
+ 0,
+ 2,
+ -1,
+ 6
+ ]
+ ],
+ "strideAP": -1,
+ "offsetAP": 9,
+ "expected": 13.379088160259652
+}
diff --git a/lib/node_modules/@stdlib/lapack/base/dlansp/test/fixtures/negative_strides/max_norm_column_major_lower.json b/lib/node_modules/@stdlib/lapack/base/dlansp/test/fixtures/negative_strides/max_norm_column_major_lower.json
new file mode 100644
index 000000000000..4a167d6df7c5
--- /dev/null
+++ b/lib/node_modules/@stdlib/lapack/base/dlansp/test/fixtures/negative_strides/max_norm_column_major_lower.json
@@ -0,0 +1,47 @@
+{
+ "order": "column-major",
+ "norm": "M",
+ "uplo": "lower",
+ "N": 4,
+ "AP": [
+ 6,
+ -1,
+ 8,
+ 2,
+ -3,
+ 5,
+ 0,
+ 1,
+ -2,
+ 4
+ ],
+ "AP_mat": [
+ [
+ 4,
+ -2,
+ 1,
+ 0
+ ],
+ [
+ -2,
+ 5,
+ -3,
+ 2
+ ],
+ [
+ 1,
+ -3,
+ 8,
+ -1
+ ],
+ [
+ 0,
+ 2,
+ -1,
+ 6
+ ]
+ ],
+ "strideAP": -1,
+ "offsetAP": 9,
+ "expected": 8
+}
diff --git a/lib/node_modules/@stdlib/lapack/base/dlansp/test/fixtures/negative_strides/max_norm_column_major_upper.json b/lib/node_modules/@stdlib/lapack/base/dlansp/test/fixtures/negative_strides/max_norm_column_major_upper.json
new file mode 100644
index 000000000000..b38e5adda677
--- /dev/null
+++ b/lib/node_modules/@stdlib/lapack/base/dlansp/test/fixtures/negative_strides/max_norm_column_major_upper.json
@@ -0,0 +1,47 @@
+{
+ "order": "column-major",
+ "norm": "M",
+ "uplo": "upper",
+ "N": 4,
+ "AP": [
+ 6,
+ -1,
+ 2,
+ 0,
+ 8,
+ -3,
+ 1,
+ 5,
+ -2,
+ 4
+ ],
+ "AP_mat": [
+ [
+ 4,
+ -2,
+ 1,
+ 0
+ ],
+ [
+ -2,
+ 5,
+ -3,
+ 2
+ ],
+ [
+ 1,
+ -3,
+ 8,
+ -1
+ ],
+ [
+ 0,
+ 2,
+ -1,
+ 6
+ ]
+ ],
+ "strideAP": -1,
+ "offsetAP": 9,
+ "expected": 8
+}
diff --git a/lib/node_modules/@stdlib/lapack/base/dlansp/test/fixtures/negative_strides/max_norm_row_major_lower.json b/lib/node_modules/@stdlib/lapack/base/dlansp/test/fixtures/negative_strides/max_norm_row_major_lower.json
new file mode 100644
index 000000000000..4a26e320e9bc
--- /dev/null
+++ b/lib/node_modules/@stdlib/lapack/base/dlansp/test/fixtures/negative_strides/max_norm_row_major_lower.json
@@ -0,0 +1,47 @@
+{
+ "order": "row-major",
+ "norm": "M",
+ "uplo": "lower",
+ "N": 4,
+ "AP": [
+ 6,
+ -1,
+ 2,
+ 0,
+ 8,
+ -3,
+ 1,
+ 5,
+ -2,
+ 4
+ ],
+ "AP_mat": [
+ [
+ 4,
+ -2,
+ 1,
+ 0
+ ],
+ [
+ -2,
+ 5,
+ -3,
+ 2
+ ],
+ [
+ 1,
+ -3,
+ 8,
+ -1
+ ],
+ [
+ 0,
+ 2,
+ -1,
+ 6
+ ]
+ ],
+ "strideAP": -1,
+ "offsetAP": 9,
+ "expected": 8
+}
diff --git a/lib/node_modules/@stdlib/lapack/base/dlansp/test/fixtures/negative_strides/max_norm_row_major_upper.json b/lib/node_modules/@stdlib/lapack/base/dlansp/test/fixtures/negative_strides/max_norm_row_major_upper.json
new file mode 100644
index 000000000000..da7d563293df
--- /dev/null
+++ b/lib/node_modules/@stdlib/lapack/base/dlansp/test/fixtures/negative_strides/max_norm_row_major_upper.json
@@ -0,0 +1,47 @@
+{
+ "order": "row-major",
+ "norm": "M",
+ "uplo": "upper",
+ "N": 4,
+ "AP": [
+ 6,
+ -1,
+ 8,
+ 2,
+ -3,
+ 5,
+ 0,
+ 1,
+ -2,
+ 4
+ ],
+ "AP_mat": [
+ [
+ 4,
+ -2,
+ 1,
+ 0
+ ],
+ [
+ -2,
+ 5,
+ -3,
+ 2
+ ],
+ [
+ 1,
+ -3,
+ 8,
+ -1
+ ],
+ [
+ 0,
+ 2,
+ -1,
+ 6
+ ]
+ ],
+ "strideAP": -1,
+ "offsetAP": 9,
+ "expected": 8
+}
diff --git a/lib/node_modules/@stdlib/lapack/base/dlansp/test/fixtures/negative_strides/one_norm_column_major_lower.json b/lib/node_modules/@stdlib/lapack/base/dlansp/test/fixtures/negative_strides/one_norm_column_major_lower.json
new file mode 100644
index 000000000000..cb666b973202
--- /dev/null
+++ b/lib/node_modules/@stdlib/lapack/base/dlansp/test/fixtures/negative_strides/one_norm_column_major_lower.json
@@ -0,0 +1,47 @@
+{
+ "order": "column-major",
+ "norm": "1",
+ "uplo": "lower",
+ "N": 4,
+ "AP": [
+ 6,
+ -1,
+ 8,
+ 2,
+ -3,
+ 5,
+ 0,
+ 1,
+ -2,
+ 4
+ ],
+ "AP_mat": [
+ [
+ 4,
+ -2,
+ 1,
+ 0
+ ],
+ [
+ -2,
+ 5,
+ -3,
+ 2
+ ],
+ [
+ 1,
+ -3,
+ 8,
+ -1
+ ],
+ [
+ 0,
+ 2,
+ -1,
+ 6
+ ]
+ ],
+ "strideAP": -1,
+ "offsetAP": 9,
+ "expected": 13
+}
diff --git a/lib/node_modules/@stdlib/lapack/base/dlansp/test/fixtures/negative_strides/one_norm_column_major_upper.json b/lib/node_modules/@stdlib/lapack/base/dlansp/test/fixtures/negative_strides/one_norm_column_major_upper.json
new file mode 100644
index 000000000000..a21bbcdf1479
--- /dev/null
+++ b/lib/node_modules/@stdlib/lapack/base/dlansp/test/fixtures/negative_strides/one_norm_column_major_upper.json
@@ -0,0 +1,47 @@
+{
+ "order": "column-major",
+ "norm": "1",
+ "uplo": "upper",
+ "N": 4,
+ "AP": [
+ 6,
+ -1,
+ 2,
+ 0,
+ 8,
+ -3,
+ 1,
+ 5,
+ -2,
+ 4
+ ],
+ "AP_mat": [
+ [
+ 4,
+ -2,
+ 1,
+ 0
+ ],
+ [
+ -2,
+ 5,
+ -3,
+ 2
+ ],
+ [
+ 1,
+ -3,
+ 8,
+ -1
+ ],
+ [
+ 0,
+ 2,
+ -1,
+ 6
+ ]
+ ],
+ "strideAP": -1,
+ "offsetAP": 9,
+ "expected": 13
+}
diff --git a/lib/node_modules/@stdlib/lapack/base/dlansp/test/fixtures/negative_strides/one_norm_row_major_lower.json b/lib/node_modules/@stdlib/lapack/base/dlansp/test/fixtures/negative_strides/one_norm_row_major_lower.json
new file mode 100644
index 000000000000..1ef5836d8678
--- /dev/null
+++ b/lib/node_modules/@stdlib/lapack/base/dlansp/test/fixtures/negative_strides/one_norm_row_major_lower.json
@@ -0,0 +1,47 @@
+{
+ "order": "row-major",
+ "norm": "1",
+ "uplo": "lower",
+ "N": 4,
+ "AP": [
+ 6,
+ -1,
+ 2,
+ 0,
+ 8,
+ -3,
+ 1,
+ 5,
+ -2,
+ 4
+ ],
+ "AP_mat": [
+ [
+ 4,
+ -2,
+ 1,
+ 0
+ ],
+ [
+ -2,
+ 5,
+ -3,
+ 2
+ ],
+ [
+ 1,
+ -3,
+ 8,
+ -1
+ ],
+ [
+ 0,
+ 2,
+ -1,
+ 6
+ ]
+ ],
+ "strideAP": -1,
+ "offsetAP": 9,
+ "expected": 13
+}
diff --git a/lib/node_modules/@stdlib/lapack/base/dlansp/test/fixtures/negative_strides/one_norm_row_major_upper.json b/lib/node_modules/@stdlib/lapack/base/dlansp/test/fixtures/negative_strides/one_norm_row_major_upper.json
new file mode 100644
index 000000000000..d742dfef3dff
--- /dev/null
+++ b/lib/node_modules/@stdlib/lapack/base/dlansp/test/fixtures/negative_strides/one_norm_row_major_upper.json
@@ -0,0 +1,47 @@
+{
+ "order": "row-major",
+ "norm": "1",
+ "uplo": "upper",
+ "N": 4,
+ "AP": [
+ 6,
+ -1,
+ 8,
+ 2,
+ -3,
+ 5,
+ 0,
+ 1,
+ -2,
+ 4
+ ],
+ "AP_mat": [
+ [
+ 4,
+ -2,
+ 1,
+ 0
+ ],
+ [
+ -2,
+ 5,
+ -3,
+ 2
+ ],
+ [
+ 1,
+ -3,
+ 8,
+ -1
+ ],
+ [
+ 0,
+ 2,
+ -1,
+ 6
+ ]
+ ],
+ "strideAP": -1,
+ "offsetAP": 9,
+ "expected": 13
+}
diff --git a/lib/node_modules/@stdlib/lapack/base/dlansp/test/fixtures/offsets/frobenius_norm_column_major_lower.json b/lib/node_modules/@stdlib/lapack/base/dlansp/test/fixtures/offsets/frobenius_norm_column_major_lower.json
new file mode 100644
index 000000000000..2b08c9f62ca4
--- /dev/null
+++ b/lib/node_modules/@stdlib/lapack/base/dlansp/test/fixtures/offsets/frobenius_norm_column_major_lower.json
@@ -0,0 +1,48 @@
+{
+ "order": "column-major",
+ "norm": "F",
+ "uplo": "lower",
+ "N": 4,
+ "AP": [
+ 9999,
+ 4,
+ -2,
+ 1,
+ 0,
+ 5,
+ -3,
+ 2,
+ 8,
+ -1,
+ 6
+ ],
+ "AP_mat": [
+ [
+ 4,
+ -2,
+ 1,
+ 0
+ ],
+ [
+ -2,
+ 5,
+ -3,
+ 2
+ ],
+ [
+ 1,
+ -3,
+ 8,
+ -1
+ ],
+ [
+ 0,
+ 2,
+ -1,
+ 6
+ ]
+ ],
+ "strideAP": 1,
+ "offsetAP": 1,
+ "expected": 13.379088160259652
+}
diff --git a/lib/node_modules/@stdlib/lapack/base/dlansp/test/fixtures/offsets/frobenius_norm_column_major_upper.json b/lib/node_modules/@stdlib/lapack/base/dlansp/test/fixtures/offsets/frobenius_norm_column_major_upper.json
new file mode 100644
index 000000000000..26fdff559857
--- /dev/null
+++ b/lib/node_modules/@stdlib/lapack/base/dlansp/test/fixtures/offsets/frobenius_norm_column_major_upper.json
@@ -0,0 +1,48 @@
+{
+ "order": "column-major",
+ "norm": "F",
+ "uplo": "upper",
+ "N": 4,
+ "AP": [
+ 9999,
+ 4,
+ -2,
+ 5,
+ 1,
+ -3,
+ 8,
+ 0,
+ 2,
+ -1,
+ 6
+ ],
+ "AP_mat": [
+ [
+ 4,
+ -2,
+ 1,
+ 0
+ ],
+ [
+ -2,
+ 5,
+ -3,
+ 2
+ ],
+ [
+ 1,
+ -3,
+ 8,
+ -1
+ ],
+ [
+ 0,
+ 2,
+ -1,
+ 6
+ ]
+ ],
+ "strideAP": 1,
+ "offsetAP": 1,
+ "expected": 13.379088160259652
+}
diff --git a/lib/node_modules/@stdlib/lapack/base/dlansp/test/fixtures/offsets/frobenius_norm_row_major_lower.json b/lib/node_modules/@stdlib/lapack/base/dlansp/test/fixtures/offsets/frobenius_norm_row_major_lower.json
new file mode 100644
index 000000000000..57d07a234270
--- /dev/null
+++ b/lib/node_modules/@stdlib/lapack/base/dlansp/test/fixtures/offsets/frobenius_norm_row_major_lower.json
@@ -0,0 +1,48 @@
+{
+ "order": "row-major",
+ "norm": "F",
+ "uplo": "lower",
+ "N": 4,
+ "AP": [
+ 9999,
+ 4,
+ -2,
+ 5,
+ 1,
+ -3,
+ 8,
+ 0,
+ 2,
+ -1,
+ 6
+ ],
+ "AP_mat": [
+ [
+ 4,
+ -2,
+ 1,
+ 0
+ ],
+ [
+ -2,
+ 5,
+ -3,
+ 2
+ ],
+ [
+ 1,
+ -3,
+ 8,
+ -1
+ ],
+ [
+ 0,
+ 2,
+ -1,
+ 6
+ ]
+ ],
+ "strideAP": 1,
+ "offsetAP": 1,
+ "expected": 13.379088160259652
+}
diff --git a/lib/node_modules/@stdlib/lapack/base/dlansp/test/fixtures/offsets/frobenius_norm_row_major_upper.json b/lib/node_modules/@stdlib/lapack/base/dlansp/test/fixtures/offsets/frobenius_norm_row_major_upper.json
new file mode 100644
index 000000000000..d9ee047d2c4e
--- /dev/null
+++ b/lib/node_modules/@stdlib/lapack/base/dlansp/test/fixtures/offsets/frobenius_norm_row_major_upper.json
@@ -0,0 +1,48 @@
+{
+ "order": "row-major",
+ "norm": "F",
+ "uplo": "upper",
+ "N": 4,
+ "AP": [
+ 9999,
+ 4,
+ -2,
+ 1,
+ 0,
+ 5,
+ -3,
+ 2,
+ 8,
+ -1,
+ 6
+ ],
+ "AP_mat": [
+ [
+ 4,
+ -2,
+ 1,
+ 0
+ ],
+ [
+ -2,
+ 5,
+ -3,
+ 2
+ ],
+ [
+ 1,
+ -3,
+ 8,
+ -1
+ ],
+ [
+ 0,
+ 2,
+ -1,
+ 6
+ ]
+ ],
+ "strideAP": 1,
+ "offsetAP": 1,
+ "expected": 13.379088160259652
+}
diff --git a/lib/node_modules/@stdlib/lapack/base/dlansp/test/fixtures/offsets/max_norm_column_major_lower.json b/lib/node_modules/@stdlib/lapack/base/dlansp/test/fixtures/offsets/max_norm_column_major_lower.json
new file mode 100644
index 000000000000..29a2e4dc15ea
--- /dev/null
+++ b/lib/node_modules/@stdlib/lapack/base/dlansp/test/fixtures/offsets/max_norm_column_major_lower.json
@@ -0,0 +1,48 @@
+{
+ "order": "column-major",
+ "norm": "M",
+ "uplo": "lower",
+ "N": 4,
+ "AP": [
+ 9999,
+ 4,
+ -2,
+ 1,
+ 0,
+ 5,
+ -3,
+ 2,
+ 8,
+ -1,
+ 6
+ ],
+ "AP_mat": [
+ [
+ 4,
+ -2,
+ 1,
+ 0
+ ],
+ [
+ -2,
+ 5,
+ -3,
+ 2
+ ],
+ [
+ 1,
+ -3,
+ 8,
+ -1
+ ],
+ [
+ 0,
+ 2,
+ -1,
+ 6
+ ]
+ ],
+ "strideAP": 1,
+ "offsetAP": 1,
+ "expected": 8
+}
diff --git a/lib/node_modules/@stdlib/lapack/base/dlansp/test/fixtures/offsets/max_norm_column_major_upper.json b/lib/node_modules/@stdlib/lapack/base/dlansp/test/fixtures/offsets/max_norm_column_major_upper.json
new file mode 100644
index 000000000000..50c066c3f8b3
--- /dev/null
+++ b/lib/node_modules/@stdlib/lapack/base/dlansp/test/fixtures/offsets/max_norm_column_major_upper.json
@@ -0,0 +1,48 @@
+{
+ "order": "column-major",
+ "norm": "M",
+ "uplo": "upper",
+ "N": 4,
+ "AP": [
+ 9999,
+ 4,
+ -2,
+ 5,
+ 1,
+ -3,
+ 8,
+ 0,
+ 2,
+ -1,
+ 6
+ ],
+ "AP_mat": [
+ [
+ 4,
+ -2,
+ 1,
+ 0
+ ],
+ [
+ -2,
+ 5,
+ -3,
+ 2
+ ],
+ [
+ 1,
+ -3,
+ 8,
+ -1
+ ],
+ [
+ 0,
+ 2,
+ -1,
+ 6
+ ]
+ ],
+ "strideAP": 1,
+ "offsetAP": 1,
+ "expected": 8
+}
diff --git a/lib/node_modules/@stdlib/lapack/base/dlansp/test/fixtures/offsets/max_norm_row_major_lower.json b/lib/node_modules/@stdlib/lapack/base/dlansp/test/fixtures/offsets/max_norm_row_major_lower.json
new file mode 100644
index 000000000000..fd08b228eee2
--- /dev/null
+++ b/lib/node_modules/@stdlib/lapack/base/dlansp/test/fixtures/offsets/max_norm_row_major_lower.json
@@ -0,0 +1,48 @@
+{
+ "order": "row-major",
+ "norm": "M",
+ "uplo": "lower",
+ "N": 4,
+ "AP": [
+ 9999,
+ 4,
+ -2,
+ 5,
+ 1,
+ -3,
+ 8,
+ 0,
+ 2,
+ -1,
+ 6
+ ],
+ "AP_mat": [
+ [
+ 4,
+ -2,
+ 1,
+ 0
+ ],
+ [
+ -2,
+ 5,
+ -3,
+ 2
+ ],
+ [
+ 1,
+ -3,
+ 8,
+ -1
+ ],
+ [
+ 0,
+ 2,
+ -1,
+ 6
+ ]
+ ],
+ "strideAP": 1,
+ "offsetAP": 1,
+ "expected": 8
+}
diff --git a/lib/node_modules/@stdlib/lapack/base/dlansp/test/fixtures/offsets/max_norm_row_major_upper.json b/lib/node_modules/@stdlib/lapack/base/dlansp/test/fixtures/offsets/max_norm_row_major_upper.json
new file mode 100644
index 000000000000..8d8fe66cb0e5
--- /dev/null
+++ b/lib/node_modules/@stdlib/lapack/base/dlansp/test/fixtures/offsets/max_norm_row_major_upper.json
@@ -0,0 +1,48 @@
+{
+ "order": "row-major",
+ "norm": "M",
+ "uplo": "upper",
+ "N": 4,
+ "AP": [
+ 9999,
+ 4,
+ -2,
+ 1,
+ 0,
+ 5,
+ -3,
+ 2,
+ 8,
+ -1,
+ 6
+ ],
+ "AP_mat": [
+ [
+ 4,
+ -2,
+ 1,
+ 0
+ ],
+ [
+ -2,
+ 5,
+ -3,
+ 2
+ ],
+ [
+ 1,
+ -3,
+ 8,
+ -1
+ ],
+ [
+ 0,
+ 2,
+ -1,
+ 6
+ ]
+ ],
+ "strideAP": 1,
+ "offsetAP": 1,
+ "expected": 8
+}
diff --git a/lib/node_modules/@stdlib/lapack/base/dlansp/test/fixtures/offsets/one_norm_column_major_lower.json b/lib/node_modules/@stdlib/lapack/base/dlansp/test/fixtures/offsets/one_norm_column_major_lower.json
new file mode 100644
index 000000000000..7e2c5840c10c
--- /dev/null
+++ b/lib/node_modules/@stdlib/lapack/base/dlansp/test/fixtures/offsets/one_norm_column_major_lower.json
@@ -0,0 +1,48 @@
+{
+ "order": "column-major",
+ "norm": "1",
+ "uplo": "lower",
+ "N": 4,
+ "AP": [
+ 9999,
+ 4,
+ -2,
+ 1,
+ 0,
+ 5,
+ -3,
+ 2,
+ 8,
+ -1,
+ 6
+ ],
+ "AP_mat": [
+ [
+ 4,
+ -2,
+ 1,
+ 0
+ ],
+ [
+ -2,
+ 5,
+ -3,
+ 2
+ ],
+ [
+ 1,
+ -3,
+ 8,
+ -1
+ ],
+ [
+ 0,
+ 2,
+ -1,
+ 6
+ ]
+ ],
+ "strideAP": 1,
+ "offsetAP": 1,
+ "expected": 13
+}
diff --git a/lib/node_modules/@stdlib/lapack/base/dlansp/test/fixtures/offsets/one_norm_column_major_upper.json b/lib/node_modules/@stdlib/lapack/base/dlansp/test/fixtures/offsets/one_norm_column_major_upper.json
new file mode 100644
index 000000000000..4376d7d4f093
--- /dev/null
+++ b/lib/node_modules/@stdlib/lapack/base/dlansp/test/fixtures/offsets/one_norm_column_major_upper.json
@@ -0,0 +1,48 @@
+{
+ "order": "column-major",
+ "norm": "1",
+ "uplo": "upper",
+ "N": 4,
+ "AP": [
+ 9999,
+ 4,
+ -2,
+ 5,
+ 1,
+ -3,
+ 8,
+ 0,
+ 2,
+ -1,
+ 6
+ ],
+ "AP_mat": [
+ [
+ 4,
+ -2,
+ 1,
+ 0
+ ],
+ [
+ -2,
+ 5,
+ -3,
+ 2
+ ],
+ [
+ 1,
+ -3,
+ 8,
+ -1
+ ],
+ [
+ 0,
+ 2,
+ -1,
+ 6
+ ]
+ ],
+ "strideAP": 1,
+ "offsetAP": 1,
+ "expected": 13
+}
diff --git a/lib/node_modules/@stdlib/lapack/base/dlansp/test/fixtures/offsets/one_norm_row_major_lower.json b/lib/node_modules/@stdlib/lapack/base/dlansp/test/fixtures/offsets/one_norm_row_major_lower.json
new file mode 100644
index 000000000000..bd0dfaf5c7d0
--- /dev/null
+++ b/lib/node_modules/@stdlib/lapack/base/dlansp/test/fixtures/offsets/one_norm_row_major_lower.json
@@ -0,0 +1,48 @@
+{
+ "order": "row-major",
+ "norm": "1",
+ "uplo": "lower",
+ "N": 4,
+ "AP": [
+ 9999,
+ 4,
+ -2,
+ 5,
+ 1,
+ -3,
+ 8,
+ 0,
+ 2,
+ -1,
+ 6
+ ],
+ "AP_mat": [
+ [
+ 4,
+ -2,
+ 1,
+ 0
+ ],
+ [
+ -2,
+ 5,
+ -3,
+ 2
+ ],
+ [
+ 1,
+ -3,
+ 8,
+ -1
+ ],
+ [
+ 0,
+ 2,
+ -1,
+ 6
+ ]
+ ],
+ "strideAP": 1,
+ "offsetAP": 1,
+ "expected": 13
+}
diff --git a/lib/node_modules/@stdlib/lapack/base/dlansp/test/fixtures/offsets/one_norm_row_major_upper.json b/lib/node_modules/@stdlib/lapack/base/dlansp/test/fixtures/offsets/one_norm_row_major_upper.json
new file mode 100644
index 000000000000..f07578cee832
--- /dev/null
+++ b/lib/node_modules/@stdlib/lapack/base/dlansp/test/fixtures/offsets/one_norm_row_major_upper.json
@@ -0,0 +1,48 @@
+{
+ "order": "row-major",
+ "norm": "1",
+ "uplo": "upper",
+ "N": 4,
+ "AP": [
+ 9999,
+ 4,
+ -2,
+ 1,
+ 0,
+ 5,
+ -3,
+ 2,
+ 8,
+ -1,
+ 6
+ ],
+ "AP_mat": [
+ [
+ 4,
+ -2,
+ 1,
+ 0
+ ],
+ [
+ -2,
+ 5,
+ -3,
+ 2
+ ],
+ [
+ 1,
+ -3,
+ 8,
+ -1
+ ],
+ [
+ 0,
+ 2,
+ -1,
+ 6
+ ]
+ ],
+ "strideAP": 1,
+ "offsetAP": 1,
+ "expected": 13
+}
diff --git a/lib/node_modules/@stdlib/lapack/base/dlansp/test/fixtures/one_norm_column_major_lower.json b/lib/node_modules/@stdlib/lapack/base/dlansp/test/fixtures/one_norm_column_major_lower.json
new file mode 100644
index 000000000000..d45ed7d64572
--- /dev/null
+++ b/lib/node_modules/@stdlib/lapack/base/dlansp/test/fixtures/one_norm_column_major_lower.json
@@ -0,0 +1,47 @@
+{
+ "order": "column-major",
+ "norm": "1",
+ "uplo": "lower",
+ "N": 4,
+ "AP": [
+ 4,
+ -2,
+ 1,
+ 0,
+ 5,
+ -3,
+ 2,
+ 8,
+ -1,
+ 6
+ ],
+ "AP_mat": [
+ [
+ 4,
+ -2,
+ 1,
+ 0
+ ],
+ [
+ -2,
+ 5,
+ -3,
+ 2
+ ],
+ [
+ 1,
+ -3,
+ 8,
+ -1
+ ],
+ [
+ 0,
+ 2,
+ -1,
+ 6
+ ]
+ ],
+ "strideAP": 1,
+ "offsetAP": 0,
+ "expected": 13
+}
diff --git a/lib/node_modules/@stdlib/lapack/base/dlansp/test/fixtures/one_norm_column_major_upper.json b/lib/node_modules/@stdlib/lapack/base/dlansp/test/fixtures/one_norm_column_major_upper.json
new file mode 100644
index 000000000000..817f26d4c975
--- /dev/null
+++ b/lib/node_modules/@stdlib/lapack/base/dlansp/test/fixtures/one_norm_column_major_upper.json
@@ -0,0 +1,47 @@
+{
+ "order": "column-major",
+ "norm": "1",
+ "uplo": "upper",
+ "N": 4,
+ "AP": [
+ 4,
+ -2,
+ 5,
+ 1,
+ -3,
+ 8,
+ 0,
+ 2,
+ -1,
+ 6
+ ],
+ "AP_mat": [
+ [
+ 4,
+ -2,
+ 1,
+ 0
+ ],
+ [
+ -2,
+ 5,
+ -3,
+ 2
+ ],
+ [
+ 1,
+ -3,
+ 8,
+ -1
+ ],
+ [
+ 0,
+ 2,
+ -1,
+ 6
+ ]
+ ],
+ "strideAP": 1,
+ "offsetAP": 0,
+ "expected": 13
+}
diff --git a/lib/node_modules/@stdlib/lapack/base/dlansp/test/fixtures/one_norm_row_major_lower.json b/lib/node_modules/@stdlib/lapack/base/dlansp/test/fixtures/one_norm_row_major_lower.json
new file mode 100644
index 000000000000..b32107536b55
--- /dev/null
+++ b/lib/node_modules/@stdlib/lapack/base/dlansp/test/fixtures/one_norm_row_major_lower.json
@@ -0,0 +1,47 @@
+{
+ "order": "row-major",
+ "norm": "1",
+ "uplo": "lower",
+ "N": 4,
+ "AP": [
+ 4,
+ -2,
+ 5,
+ 1,
+ -3,
+ 8,
+ 0,
+ 2,
+ -1,
+ 6
+ ],
+ "AP_mat": [
+ [
+ 4,
+ -2,
+ 1,
+ 0
+ ],
+ [
+ -2,
+ 5,
+ -3,
+ 2
+ ],
+ [
+ 1,
+ -3,
+ 8,
+ -1
+ ],
+ [
+ 0,
+ 2,
+ -1,
+ 6
+ ]
+ ],
+ "strideAP": 1,
+ "offsetAP": 0,
+ "expected": 13
+}
diff --git a/lib/node_modules/@stdlib/lapack/base/dlansp/test/fixtures/one_norm_row_major_upper.json b/lib/node_modules/@stdlib/lapack/base/dlansp/test/fixtures/one_norm_row_major_upper.json
new file mode 100644
index 000000000000..0c44b9ae6f9e
--- /dev/null
+++ b/lib/node_modules/@stdlib/lapack/base/dlansp/test/fixtures/one_norm_row_major_upper.json
@@ -0,0 +1,47 @@
+{
+ "order": "row-major",
+ "norm": "1",
+ "uplo": "upper",
+ "N": 4,
+ "AP": [
+ 4,
+ -2,
+ 1,
+ 0,
+ 5,
+ -3,
+ 2,
+ 8,
+ -1,
+ 6
+ ],
+ "AP_mat": [
+ [
+ 4,
+ -2,
+ 1,
+ 0
+ ],
+ [
+ -2,
+ 5,
+ -3,
+ 2
+ ],
+ [
+ 1,
+ -3,
+ 8,
+ -1
+ ],
+ [
+ 0,
+ 2,
+ -1,
+ 6
+ ]
+ ],
+ "strideAP": 1,
+ "offsetAP": 0,
+ "expected": 13
+}
diff --git a/lib/node_modules/@stdlib/lapack/base/dlansp/test/test.dlansp.js b/lib/node_modules/@stdlib/lapack/base/dlansp/test/test.dlansp.js
new file mode 100644
index 000000000000..c4acd5eed969
--- /dev/null
+++ b/lib/node_modules/@stdlib/lapack/base/dlansp/test/test.dlansp.js
@@ -0,0 +1,428 @@
+/**
+* @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 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 isnan = require( '@stdlib/math/base/assert/is-nan' );
+var dlansp = require( './../lib/dlansp.js' );
+
+
+// FIXTURES //
+
+var MAX_NORM_ROW_MAJOR_UPPER = require( './fixtures/max_norm_row_major_upper.json' );
+var MAX_NORM_ROW_MAJOR_LOWER = require( './fixtures/max_norm_row_major_lower.json' );
+var MAX_NORM_COLUMN_MAJOR_UPPER = require( './fixtures/max_norm_column_major_upper.json' );
+var MAX_NORM_COLUMN_MAJOR_LOWER = require( './fixtures/max_norm_column_major_lower.json' );
+var ONE_NORM_ROW_MAJOR_UPPER = require( './fixtures/one_norm_row_major_upper.json' );
+var ONE_NORM_ROW_MAJOR_LOWER = require( './fixtures/one_norm_row_major_lower.json' );
+var ONE_NORM_COLUMN_MAJOR_UPPER = require( './fixtures/one_norm_column_major_upper.json' );
+var ONE_NORM_COLUMN_MAJOR_LOWER = require( './fixtures/one_norm_column_major_lower.json' );
+var FROBENIUS_NORM_ROW_MAJOR_UPPER = require( './fixtures/frobenius_norm_row_major_upper.json' );
+var FROBENIUS_NORM_ROW_MAJOR_LOWER = require( './fixtures/frobenius_norm_row_major_lower.json' );
+var FROBENIUS_NORM_COLUMN_MAJOR_UPPER = require( './fixtures/frobenius_norm_column_major_upper.json' );
+var FROBENIUS_NORM_COLUMN_MAJOR_LOWER = require( './fixtures/frobenius_norm_column_major_lower.json' );
+
+
+// FUNCTIONS //
+
+/**
+* Tests whether two values are approximately equal.
+*
+* @private
+* @param {Object} t - test object
+* @param {number} actual - actual value
+* @param {number} expected - expected value
+* @param {string} msg - message
+*/
+function isApprox( t, actual, expected, msg ) {
+ var delta;
+ var tol;
+
+ if ( actual === expected ) {
+ t.strictEqual( actual, expected, msg );
+ } else {
+ delta = abs( actual - expected );
+ tol = 20.0 * EPS * abs( expected );
+ t.ok( delta <= tol, msg + '. Expected: ' + expected + '. Actual: ' + actual + '. Delta: ' + delta + '. Tol: ' + tol + '.' );
+ }
+}
+
+
+// TESTS //
+
+tape( 'main export is a function', function test( t ) {
+ t.ok( true, __filename );
+ t.strictEqual( typeof dlansp, 'function', 'main export is a function' );
+ t.end();
+});
+
+tape( 'the function has an arity of 5', function test( t ) {
+ t.strictEqual( dlansp.length, 5, 'returns expected value' );
+ t.end();
+});
+
+tape( 'the function throws an error if provided an invalid first argument', function test( t ) {
+ var values;
+ var AP;
+ var i;
+
+ values = [
+ 'foo',
+ 'bar',
+ 'beep',
+ 'boop'
+ ];
+
+ AP = new Float64Array( [ 1.0, 2.0, 5.0 ] );
+
+ for ( i = 0; i < values.length; i++ ) {
+ t.throws( badValue( values[ i ] ), TypeError, 'throws an error when provided ' + values[ i ] );
+ }
+ t.end();
+
+ function badValue( value ) {
+ return function badValue() {
+ dlansp( value, 'M', 'upper', 2, AP );
+ };
+ }
+});
+
+tape( 'the function throws an error if provided an invalid second argument', function test( t ) {
+ var values;
+ var AP;
+ var i;
+
+ values = [
+ 'foo',
+ 'bar',
+ 'beep',
+ 'boop'
+ ];
+
+ AP = new Float64Array( [ 1.0, 2.0, 5.0 ] );
+
+ for ( i = 0; i < values.length; i++ ) {
+ t.throws( badValue( values[ i ] ), TypeError, 'throws an error when provided ' + values[ i ] );
+ }
+ t.end();
+
+ function badValue( value ) {
+ return function badValue() {
+ dlansp( 'row-major', value, 'upper', 2, AP );
+ };
+ }
+});
+
+tape( 'the function throws an error if provided an invalid third argument', function test( t ) {
+ var values;
+ var AP;
+ var i;
+
+ values = [
+ 'foo',
+ 'bar',
+ 'beep',
+ 'boop'
+ ];
+
+ AP = new Float64Array( [ 1.0, 2.0, 5.0 ] );
+
+ for ( i = 0; i < values.length; i++ ) {
+ t.throws( badValue( values[ i ] ), TypeError, 'throws an error when provided ' + values[ i ] );
+ }
+ t.end();
+
+ function badValue( value ) {
+ return function badValue() {
+ dlansp( 'row-major', 'M', value, 2, AP );
+ };
+ }
+});
+
+tape( 'the function returns 0 when N is 0', function test( t ) {
+ var AP = new Float64Array( [ 1.0 ] );
+ var v;
+
+ v = dlansp( 'row-major', 'M', 'upper', 0, AP );
+ t.strictEqual( v, 0.0, 'returns expected value' );
+
+ v = dlansp( 'row-major', '1', 'lower', 0, AP );
+ t.strictEqual( v, 0.0, 'returns expected value' );
+
+ v = dlansp( 'row-major', 'F', 'upper', 0, AP );
+ t.strictEqual( v, 0.0, 'returns expected value' );
+
+ t.end();
+});
+
+tape( 'the function computes the max norm (row-major, upper)', function test( t ) {
+ var data;
+ var v;
+
+ data = MAX_NORM_ROW_MAJOR_UPPER;
+ v = dlansp( data.order, data.norm, data.uplo, data.N, new Float64Array( data.AP ) );
+ t.strictEqual( v, data.expected, 'returns expected value' );
+ t.end();
+});
+
+tape( 'the function computes the max norm (row-major, lower)', function test( t ) {
+ var data;
+ var v;
+
+ data = MAX_NORM_ROW_MAJOR_LOWER;
+ v = dlansp( data.order, data.norm, data.uplo, data.N, new Float64Array( data.AP ) );
+ t.strictEqual( v, data.expected, 'returns expected value' );
+ t.end();
+});
+
+tape( 'the function computes the max norm (column-major, upper)', function test( t ) {
+ var data;
+ var v;
+
+ data = MAX_NORM_COLUMN_MAJOR_UPPER;
+ v = dlansp( data.order, data.norm, data.uplo, data.N, new Float64Array( data.AP ) );
+ t.strictEqual( v, data.expected, 'returns expected value' );
+ t.end();
+});
+
+tape( 'the function computes the max norm (column-major, lower)', function test( t ) {
+ var data;
+ var v;
+
+ data = MAX_NORM_COLUMN_MAJOR_LOWER;
+ v = dlansp( data.order, data.norm, data.uplo, data.N, new Float64Array( data.AP ) );
+ t.strictEqual( v, data.expected, 'returns expected value' );
+ t.end();
+});
+
+tape( 'the function computes the one norm (row-major, upper)', function test( t ) {
+ var data;
+ var v;
+
+ data = ONE_NORM_ROW_MAJOR_UPPER;
+ v = dlansp( data.order, data.norm, data.uplo, data.N, new Float64Array( data.AP ) );
+ t.strictEqual( v, data.expected, 'returns expected value' );
+ t.end();
+});
+
+tape( 'the function computes the one norm (row-major, lower)', function test( t ) {
+ var data;
+ var v;
+
+ data = ONE_NORM_ROW_MAJOR_LOWER;
+ v = dlansp( data.order, data.norm, data.uplo, data.N, new Float64Array( data.AP ) );
+ t.strictEqual( v, data.expected, 'returns expected value' );
+ t.end();
+});
+
+tape( 'the function computes the one norm (column-major, upper)', function test( t ) {
+ var data;
+ var v;
+
+ data = ONE_NORM_COLUMN_MAJOR_UPPER;
+ v = dlansp( data.order, data.norm, data.uplo, data.N, new Float64Array( data.AP ) );
+ t.strictEqual( v, data.expected, 'returns expected value' );
+ t.end();
+});
+
+tape( 'the function computes the one norm (column-major, lower)', function test( t ) {
+ var data;
+ var v;
+
+ data = ONE_NORM_COLUMN_MAJOR_LOWER;
+ v = dlansp( data.order, data.norm, data.uplo, data.N, new Float64Array( data.AP ) );
+ t.strictEqual( v, data.expected, 'returns expected value' );
+ t.end();
+});
+
+tape( 'the function computes the infinity norm (symmetric: normI == norm1)', function test( t ) {
+ var one;
+ var AP;
+ var v;
+
+ AP = new Float64Array( ONE_NORM_ROW_MAJOR_UPPER.AP );
+ one = dlansp( 'row-major', '1', 'upper', ONE_NORM_ROW_MAJOR_UPPER.N, AP );
+ v = dlansp( 'row-major', 'I', 'upper', ONE_NORM_ROW_MAJOR_UPPER.N, AP );
+ t.strictEqual( v, one, 'infinity norm equals one norm (upper)' );
+
+ AP = new Float64Array( ONE_NORM_ROW_MAJOR_LOWER.AP );
+ one = dlansp( 'row-major', '1', 'lower', ONE_NORM_ROW_MAJOR_LOWER.N, AP );
+ v = dlansp( 'row-major', 'I', 'lower', ONE_NORM_ROW_MAJOR_LOWER.N, AP );
+ t.strictEqual( v, one, 'infinity norm equals one norm (lower)' );
+
+ t.end();
+});
+
+tape( 'the function computes the Frobenius norm (row-major, upper)', function test( t ) {
+ var data;
+ var v;
+
+ data = FROBENIUS_NORM_ROW_MAJOR_UPPER;
+ v = dlansp( data.order, data.norm, data.uplo, data.N, new Float64Array( data.AP ) );
+ isApprox( t, v, data.expected, 'returns expected value' );
+ t.end();
+});
+
+tape( 'the function computes the Frobenius norm (row-major, lower)', function test( t ) {
+ var data;
+ var v;
+
+ data = FROBENIUS_NORM_ROW_MAJOR_LOWER;
+ v = dlansp( data.order, data.norm, data.uplo, data.N, new Float64Array( data.AP ) );
+ isApprox( t, v, data.expected, 'returns expected value' );
+ t.end();
+});
+
+tape( 'the function computes the Frobenius norm (column-major, upper)', function test( t ) {
+ var data;
+ var v;
+
+ data = FROBENIUS_NORM_COLUMN_MAJOR_UPPER;
+ v = dlansp( data.order, data.norm, data.uplo, data.N, new Float64Array( data.AP ) );
+ isApprox( t, v, data.expected, 'returns expected value' );
+ t.end();
+});
+
+tape( 'the function computes the Frobenius norm (column-major, lower)', function test( t ) {
+ var data;
+ var v;
+
+ data = FROBENIUS_NORM_COLUMN_MAJOR_LOWER;
+ v = dlansp( data.order, data.norm, data.uplo, data.N, new Float64Array( data.AP ) );
+ isApprox( t, v, data.expected, 'returns expected value' );
+ t.end();
+});
+
+tape( 'the function supports norm character aliases', function test( t ) {
+ var AP;
+ var v;
+
+ AP = new Float64Array( [ 1.0, 2.0, 5.0 ] );
+
+ v = dlansp( 'row-major', 'm', 'upper', 2, AP );
+ t.strictEqual( v, 5.0, 'returns expected value for lowercase m' );
+
+ v = dlansp( 'row-major', 'o', 'upper', 2, AP );
+ t.strictEqual( v, 7.0, 'returns expected value for lowercase o' );
+
+ v = dlansp( 'row-major', 'i', 'upper', 2, AP );
+ t.strictEqual( v, 7.0, 'returns expected value for lowercase i' );
+
+ v = dlansp( 'row-major', 'O', 'upper', 2, AP );
+ t.strictEqual( v, 7.0, 'returns expected value for O' );
+
+ v = dlansp( 'row-major', 'f', 'upper', 2, AP );
+ isApprox( t, v, dlansp( 'row-major', 'F', 'upper', 2, AP ), 'returns expected value for lowercase f' );
+
+ v = dlansp( 'row-major', 'E', 'upper', 2, AP );
+ isApprox( t, v, dlansp( 'row-major', 'F', 'upper', 2, AP ), 'returns expected value for E' );
+
+ v = dlansp( 'row-major', 'e', 'upper', 2, AP );
+ isApprox( t, v, dlansp( 'row-major', 'F', 'upper', 2, AP ), 'returns expected value for lowercase e' );
+
+ t.end();
+});
+
+tape( 'the function handles N=1', function test( t ) {
+ var AP;
+ var v;
+
+ AP = new Float64Array( [ 7.0 ] );
+
+ v = dlansp( 'row-major', 'M', 'upper', 1, AP );
+ t.strictEqual( v, 7.0, 'returns expected value for M norm' );
+
+ v = dlansp( 'row-major', '1', 'upper', 1, AP );
+ t.strictEqual( v, 7.0, 'returns expected value for one norm' );
+
+ v = dlansp( 'row-major', 'I', 'lower', 1, AP );
+ t.strictEqual( v, 7.0, 'returns expected value for infinity norm' );
+
+ v = dlansp( 'row-major', 'F', 'upper', 1, AP );
+ isApprox( t, v, 7.0, 'returns expected value for Frobenius norm' );
+
+ t.end();
+});
+
+tape( 'the function returns NaN if the input matrix contains NaN (max norm)', function test( t ) {
+ var AP;
+ var v;
+
+ AP = new Float64Array( [ 1.0, NaN, 3.0 ] );
+
+ v = dlansp( 'row-major', 'M', 'upper', 2, AP );
+ t.strictEqual( isnan( v ), true, 'returns NaN' );
+
+ v = dlansp( 'row-major', 'm', 'lower', 2, AP );
+ t.strictEqual( isnan( v ), true, 'returns NaN' );
+
+ t.end();
+});
+
+tape( 'the function returns NaN if the input matrix contains NaN (one norm, upper)', function test( t ) {
+ var AP;
+ var v;
+
+ AP = new Float64Array( [ 1.0, NaN, 3.0 ] );
+
+ v = dlansp( 'row-major', '1', 'upper', 2, AP );
+ t.strictEqual( isnan( v ), true, 'returns NaN' );
+
+ v = dlansp( 'column-major', '1', 'upper', 2, AP );
+ t.strictEqual( isnan( v ), true, 'returns NaN' );
+
+ t.end();
+});
+
+tape( 'the function returns NaN if the input matrix contains NaN (one norm, lower)', function test( t ) {
+ var AP;
+ var v;
+
+ AP = new Float64Array( [ 1.0, NaN, 3.0 ] );
+
+ v = dlansp( 'row-major', '1', 'lower', 2, AP );
+ t.strictEqual( isnan( v ), true, 'returns NaN' );
+
+ v = dlansp( 'column-major', '1', 'lower', 2, AP );
+ t.strictEqual( isnan( v ), true, 'returns NaN' );
+
+ t.end();
+});
+
+tape( 'the function computes the Frobenius norm if the diagonal contains zeros', function test( t ) {
+ var expected;
+ var AP;
+ var v;
+
+ AP = new Float64Array( [ 0.0, 2.0, 0.0 ] );
+ expected = 2.8284271247461903;
+
+ v = dlansp( 'row-major', 'F', 'upper', 2, AP );
+ isApprox( t, v, expected, 'returns expected value for upper' );
+
+ v = dlansp( 'row-major', 'F', 'lower', 2, AP );
+ isApprox( t, v, expected, 'returns expected value for lower' );
+
+ t.end();
+});
diff --git a/lib/node_modules/@stdlib/lapack/base/dlansp/test/test.js b/lib/node_modules/@stdlib/lapack/base/dlansp/test/test.js
new file mode 100644
index 000000000000..fc3af656a2c4
--- /dev/null
+++ b/lib/node_modules/@stdlib/lapack/base/dlansp/test/test.js
@@ -0,0 +1,94 @@
+/**
+* @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 tape = require( 'tape' );
+var proxyquire = require( 'proxyquire' );
+var IS_BROWSER = require( '@stdlib/assert/is-browser' );
+var dlansp = 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 dlansp, '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 dlansp.ndarray, 'function', 'method is a function' );
+ t.end();
+});
+
+tape( 'the function has an arity of 5', function test( t ) {
+ t.strictEqual( dlansp.length, 5, 'returns expected value' );
+ t.end();
+});
+
+tape( 'the `ndarray` method has an arity of 7', function test( t ) {
+ t.strictEqual( dlansp.ndarray.length, 7, 'returns expected value' );
+ t.end();
+});
+
+tape( 'if a native implementation is available, the main export is the native implementation', opts, function test( t ) {
+ var dlansp;
+
+ dlansp = proxyquire( './../lib', {
+ '@stdlib/utils/try-require': tryRequire
+ });
+
+ t.strictEqual( dlansp, 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 dlansp;
+ var main;
+
+ main = require( './../lib/main.js' );
+
+ dlansp = proxyquire( './../lib', {
+ '@stdlib/utils/try-require': tryRequire
+ });
+
+ t.strictEqual( dlansp, main, 'returns expected value' );
+ t.end();
+
+ function tryRequire() {
+ return new Error( 'Cannot find module' );
+ }
+});
diff --git a/lib/node_modules/@stdlib/lapack/base/dlansp/test/test.ndarray.js b/lib/node_modules/@stdlib/lapack/base/dlansp/test/test.ndarray.js
new file mode 100644
index 000000000000..18eb348af1b8
--- /dev/null
+++ b/lib/node_modules/@stdlib/lapack/base/dlansp/test/test.ndarray.js
@@ -0,0 +1,862 @@
+/**
+* @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 */
+
+'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 dlansp = require( './../lib/ndarray.js' );
+
+
+// FIXTURES //
+
+var MAX_NORM_ROW_MAJOR_UPPER = require( './fixtures/max_norm_row_major_upper.json' );
+var MAX_NORM_ROW_MAJOR_LOWER = require( './fixtures/max_norm_row_major_lower.json' );
+var MAX_NORM_COLUMN_MAJOR_UPPER = require( './fixtures/max_norm_column_major_upper.json' );
+var MAX_NORM_COLUMN_MAJOR_LOWER = require( './fixtures/max_norm_column_major_lower.json' );
+var ONE_NORM_ROW_MAJOR_UPPER = require( './fixtures/one_norm_row_major_upper.json' );
+var ONE_NORM_ROW_MAJOR_LOWER = require( './fixtures/one_norm_row_major_lower.json' );
+var ONE_NORM_COLUMN_MAJOR_UPPER = require( './fixtures/one_norm_column_major_upper.json' );
+var ONE_NORM_COLUMN_MAJOR_LOWER = require( './fixtures/one_norm_column_major_lower.json' );
+var FROBENIUS_NORM_ROW_MAJOR_UPPER = require( './fixtures/frobenius_norm_row_major_upper.json' );
+var FROBENIUS_NORM_ROW_MAJOR_LOWER = require( './fixtures/frobenius_norm_row_major_lower.json' );
+var FROBENIUS_NORM_COLUMN_MAJOR_UPPER = require( './fixtures/frobenius_norm_column_major_upper.json' );
+var FROBENIUS_NORM_COLUMN_MAJOR_LOWER = require( './fixtures/frobenius_norm_column_major_lower.json' );
+var OFFSET_MAX_NORM_ROW_MAJOR_UPPER = require( './fixtures/offsets/max_norm_row_major_upper.json' );
+var OFFSET_MAX_NORM_ROW_MAJOR_LOWER = require( './fixtures/offsets/max_norm_row_major_lower.json' );
+var OFFSET_MAX_NORM_COLUMN_MAJOR_UPPER = require( './fixtures/offsets/max_norm_column_major_upper.json' );
+var OFFSET_MAX_NORM_COLUMN_MAJOR_LOWER = require( './fixtures/offsets/max_norm_column_major_lower.json' );
+var OFFSET_ONE_NORM_ROW_MAJOR_UPPER = require( './fixtures/offsets/one_norm_row_major_upper.json' );
+var OFFSET_ONE_NORM_ROW_MAJOR_LOWER = require( './fixtures/offsets/one_norm_row_major_lower.json' );
+var OFFSET_ONE_NORM_COLUMN_MAJOR_UPPER = require( './fixtures/offsets/one_norm_column_major_upper.json' );
+var OFFSET_ONE_NORM_COLUMN_MAJOR_LOWER = require( './fixtures/offsets/one_norm_column_major_lower.json' );
+var OFFSET_FROBENIUS_NORM_ROW_MAJOR_UPPER = require( './fixtures/offsets/frobenius_norm_row_major_upper.json' );
+var OFFSET_FROBENIUS_NORM_ROW_MAJOR_LOWER = require( './fixtures/offsets/frobenius_norm_row_major_lower.json' );
+var OFFSET_FROBENIUS_NORM_COLUMN_MAJOR_UPPER = require( './fixtures/offsets/frobenius_norm_column_major_upper.json' );
+var OFFSET_FROBENIUS_NORM_COLUMN_MAJOR_LOWER = require( './fixtures/offsets/frobenius_norm_column_major_lower.json' );
+var NEGATIVE_STRIDES_MAX_NORM_ROW_MAJOR_UPPER = require( './fixtures/negative_strides/max_norm_row_major_upper.json' );
+var NEGATIVE_STRIDES_MAX_NORM_ROW_MAJOR_LOWER = require( './fixtures/negative_strides/max_norm_row_major_lower.json' );
+var NEGATIVE_STRIDES_MAX_NORM_COLUMN_MAJOR_UPPER = require( './fixtures/negative_strides/max_norm_column_major_upper.json' );
+var NEGATIVE_STRIDES_MAX_NORM_COLUMN_MAJOR_LOWER = require( './fixtures/negative_strides/max_norm_column_major_lower.json' );
+var NEGATIVE_STRIDES_ONE_NORM_ROW_MAJOR_UPPER = require( './fixtures/negative_strides/one_norm_row_major_upper.json' );
+var NEGATIVE_STRIDES_ONE_NORM_ROW_MAJOR_LOWER = require( './fixtures/negative_strides/one_norm_row_major_lower.json' );
+var NEGATIVE_STRIDES_ONE_NORM_COLUMN_MAJOR_UPPER = require( './fixtures/negative_strides/one_norm_column_major_upper.json' );
+var NEGATIVE_STRIDES_ONE_NORM_COLUMN_MAJOR_LOWER = require( './fixtures/negative_strides/one_norm_column_major_lower.json' );
+var NEGATIVE_STRIDES_FROBENIUS_NORM_ROW_MAJOR_UPPER = require( './fixtures/negative_strides/frobenius_norm_row_major_upper.json' );
+var NEGATIVE_STRIDES_FROBENIUS_NORM_ROW_MAJOR_LOWER = require( './fixtures/negative_strides/frobenius_norm_row_major_lower.json' );
+var NEGATIVE_STRIDES_FROBENIUS_NORM_COLUMN_MAJOR_UPPER = require( './fixtures/negative_strides/frobenius_norm_column_major_upper.json' );
+var NEGATIVE_STRIDES_FROBENIUS_NORM_COLUMN_MAJOR_LOWER = require( './fixtures/negative_strides/frobenius_norm_column_major_lower.json' );
+var LARGE_STRIDES_MAX_NORM_ROW_MAJOR_UPPER = require( './fixtures/large_strides/max_norm_row_major_upper.json' );
+var LARGE_STRIDES_MAX_NORM_ROW_MAJOR_LOWER = require( './fixtures/large_strides/max_norm_row_major_lower.json' );
+var LARGE_STRIDES_MAX_NORM_COLUMN_MAJOR_UPPER = require( './fixtures/large_strides/max_norm_column_major_upper.json' );
+var LARGE_STRIDES_MAX_NORM_COLUMN_MAJOR_LOWER = require( './fixtures/large_strides/max_norm_column_major_lower.json' );
+var LARGE_STRIDES_ONE_NORM_ROW_MAJOR_UPPER = require( './fixtures/large_strides/one_norm_row_major_upper.json' );
+var LARGE_STRIDES_ONE_NORM_ROW_MAJOR_LOWER = require( './fixtures/large_strides/one_norm_row_major_lower.json' );
+var LARGE_STRIDES_ONE_NORM_COLUMN_MAJOR_UPPER = require( './fixtures/large_strides/one_norm_column_major_upper.json' );
+var LARGE_STRIDES_ONE_NORM_COLUMN_MAJOR_LOWER = require( './fixtures/large_strides/one_norm_column_major_lower.json' );
+var LARGE_STRIDES_FROBENIUS_NORM_ROW_MAJOR_UPPER = require( './fixtures/large_strides/frobenius_norm_row_major_upper.json' );
+var LARGE_STRIDES_FROBENIUS_NORM_ROW_MAJOR_LOWER = require( './fixtures/large_strides/frobenius_norm_row_major_lower.json' );
+var LARGE_STRIDES_FROBENIUS_NORM_COLUMN_MAJOR_UPPER = require( './fixtures/large_strides/frobenius_norm_column_major_upper.json' );
+var LARGE_STRIDES_FROBENIUS_NORM_COLUMN_MAJOR_LOWER = require( './fixtures/large_strides/frobenius_norm_column_major_lower.json' );
+var MIXED_STRIDES_MAX_NORM_ROW_MAJOR_UPPER = require( './fixtures/mixed_strides/max_norm_row_major_upper.json' );
+var MIXED_STRIDES_MAX_NORM_ROW_MAJOR_LOWER = require( './fixtures/mixed_strides/max_norm_row_major_lower.json' );
+var MIXED_STRIDES_MAX_NORM_COLUMN_MAJOR_UPPER = require( './fixtures/mixed_strides/max_norm_column_major_upper.json' );
+var MIXED_STRIDES_MAX_NORM_COLUMN_MAJOR_LOWER = require( './fixtures/mixed_strides/max_norm_column_major_lower.json' );
+var MIXED_STRIDES_ONE_NORM_ROW_MAJOR_UPPER = require( './fixtures/mixed_strides/one_norm_row_major_upper.json' );
+var MIXED_STRIDES_ONE_NORM_ROW_MAJOR_LOWER = require( './fixtures/mixed_strides/one_norm_row_major_lower.json' );
+var MIXED_STRIDES_ONE_NORM_COLUMN_MAJOR_UPPER = require( './fixtures/mixed_strides/one_norm_column_major_upper.json' );
+var MIXED_STRIDES_ONE_NORM_COLUMN_MAJOR_LOWER = require( './fixtures/mixed_strides/one_norm_column_major_lower.json' );
+var MIXED_STRIDES_FROBENIUS_NORM_ROW_MAJOR_UPPER = require( './fixtures/mixed_strides/frobenius_norm_row_major_upper.json' );
+var MIXED_STRIDES_FROBENIUS_NORM_ROW_MAJOR_LOWER = require( './fixtures/mixed_strides/frobenius_norm_row_major_lower.json' );
+var MIXED_STRIDES_FROBENIUS_NORM_COLUMN_MAJOR_UPPER = require( './fixtures/mixed_strides/frobenius_norm_column_major_upper.json' );
+var MIXED_STRIDES_FROBENIUS_NORM_COLUMN_MAJOR_LOWER = require( './fixtures/mixed_strides/frobenius_norm_column_major_lower.json' );
+
+
+// FUNCTIONS //
+
+/**
+* Tests whether two values are approximately equal.
+*
+* @private
+* @param {Object} t - test object
+* @param {number} actual - actual value
+* @param {number} expected - expected value
+* @param {string} msg - message
+*/
+function isApprox( t, actual, expected, msg ) {
+ var delta;
+ var tol;
+
+ if ( actual === expected ) {
+ t.strictEqual( actual, expected, msg );
+ } else {
+ delta = abs( actual - expected );
+ tol = 20.0 * EPS * abs( expected );
+ t.ok( delta <= tol, msg + '. Expected: ' + expected + '. Actual: ' + actual + '. Delta: ' + delta + '. Tol: ' + tol + '.' );
+ }
+}
+
+
+// TESTS //
+
+tape( 'main export is a function', function test( t ) {
+ t.ok( true, __filename );
+ t.strictEqual( typeof dlansp, 'function', 'main export is a function' );
+ t.end();
+});
+
+tape( 'the function has an arity of 7', function test( t ) {
+ t.strictEqual( dlansp.length, 7, 'returns expected value' );
+ t.end();
+});
+
+tape( 'the function returns 0 when N is 0', function test( t ) {
+ var AP;
+ var v;
+
+ AP = new Float64Array( [ 1.0 ] );
+ v = dlansp( 'row-major', 'M', 'upper', 0, AP, 1, 0 );
+ t.strictEqual( v, 0.0, 'returns expected value' );
+ t.end();
+});
+
+tape( 'the function computes the max norm (row-major, upper)', function test( t ) {
+ var data;
+ var AP;
+ var v;
+
+ data = MAX_NORM_ROW_MAJOR_UPPER;
+ AP = new Float64Array( data.AP );
+ v = dlansp( data.order, data.norm, data.uplo, data.N, AP, data.strideAP, data.offsetAP );
+ t.strictEqual( v, data.expected, 'returns expected value' );
+ t.end();
+});
+
+tape( 'the function computes the max norm (row-major, lower)', function test( t ) {
+ var data;
+ var AP;
+ var v;
+
+ data = MAX_NORM_ROW_MAJOR_LOWER;
+ AP = new Float64Array( data.AP );
+ v = dlansp( data.order, data.norm, data.uplo, data.N, AP, data.strideAP, data.offsetAP );
+ t.strictEqual( v, data.expected, 'returns expected value' );
+ t.end();
+});
+
+tape( 'the function computes the max norm (column-major, upper)', function test( t ) {
+ var data;
+ var AP;
+ var v;
+
+ data = MAX_NORM_COLUMN_MAJOR_UPPER;
+ AP = new Float64Array( data.AP );
+ v = dlansp( data.order, data.norm, data.uplo, data.N, AP, data.strideAP, data.offsetAP );
+ t.strictEqual( v, data.expected, 'returns expected value' );
+ t.end();
+});
+
+tape( 'the function computes the max norm (column-major, lower)', function test( t ) {
+ var data;
+ var AP;
+ var v;
+
+ data = MAX_NORM_COLUMN_MAJOR_LOWER;
+ AP = new Float64Array( data.AP );
+ v = dlansp( data.order, data.norm, data.uplo, data.N, AP, data.strideAP, data.offsetAP );
+ t.strictEqual( v, data.expected, 'returns expected value' );
+ t.end();
+});
+
+tape( 'the function computes the one norm (row-major, upper)', function test( t ) {
+ var data;
+ var AP;
+ var v;
+
+ data = ONE_NORM_ROW_MAJOR_UPPER;
+ AP = new Float64Array( data.AP );
+ v = dlansp( data.order, data.norm, data.uplo, data.N, AP, data.strideAP, data.offsetAP );
+ t.strictEqual( v, data.expected, 'returns expected value' );
+ t.end();
+});
+
+tape( 'the function computes the one norm (row-major, lower)', function test( t ) {
+ var data;
+ var AP;
+ var v;
+
+ data = ONE_NORM_ROW_MAJOR_LOWER;
+ AP = new Float64Array( data.AP );
+ v = dlansp( data.order, data.norm, data.uplo, data.N, AP, data.strideAP, data.offsetAP );
+ t.strictEqual( v, data.expected, 'returns expected value' );
+ t.end();
+});
+
+tape( 'the function computes the one norm (column-major, upper)', function test( t ) {
+ var data;
+ var AP;
+ var v;
+
+ data = ONE_NORM_COLUMN_MAJOR_UPPER;
+ AP = new Float64Array( data.AP );
+ v = dlansp( data.order, data.norm, data.uplo, data.N, AP, data.strideAP, data.offsetAP );
+ t.strictEqual( v, data.expected, 'returns expected value' );
+ t.end();
+});
+
+tape( 'the function computes the one norm (column-major, lower)', function test( t ) {
+ var data;
+ var AP;
+ var v;
+
+ data = ONE_NORM_COLUMN_MAJOR_LOWER;
+ AP = new Float64Array( data.AP );
+ v = dlansp( data.order, data.norm, data.uplo, data.N, AP, data.strideAP, data.offsetAP );
+ t.strictEqual( v, data.expected, 'returns expected value' );
+ t.end();
+});
+
+tape( 'the function computes the Frobenius norm (row-major, upper)', function test( t ) {
+ var data;
+ var AP;
+ var v;
+
+ data = FROBENIUS_NORM_ROW_MAJOR_UPPER;
+ AP = new Float64Array( data.AP );
+ v = dlansp( data.order, data.norm, data.uplo, data.N, AP, data.strideAP, data.offsetAP );
+ isApprox( t, v, data.expected, 'returns expected value' );
+ t.end();
+});
+
+tape( 'the function computes the Frobenius norm (row-major, lower)', function test( t ) {
+ var data;
+ var AP;
+ var v;
+
+ data = FROBENIUS_NORM_ROW_MAJOR_LOWER;
+ AP = new Float64Array( data.AP );
+ v = dlansp( data.order, data.norm, data.uplo, data.N, AP, data.strideAP, data.offsetAP );
+ isApprox( t, v, data.expected, 'returns expected value' );
+ t.end();
+});
+
+tape( 'the function computes the Frobenius norm (column-major, upper)', function test( t ) {
+ var data;
+ var AP;
+ var v;
+
+ data = FROBENIUS_NORM_COLUMN_MAJOR_UPPER;
+ AP = new Float64Array( data.AP );
+ v = dlansp( data.order, data.norm, data.uplo, data.N, AP, data.strideAP, data.offsetAP );
+ isApprox( t, v, data.expected, 'returns expected value' );
+ t.end();
+});
+
+tape( 'the function computes the Frobenius norm (column-major, lower)', function test( t ) {
+ var data;
+ var AP;
+ var v;
+
+ data = FROBENIUS_NORM_COLUMN_MAJOR_LOWER;
+ AP = new Float64Array( data.AP );
+ v = dlansp( data.order, data.norm, data.uplo, data.N, AP, data.strideAP, data.offsetAP );
+ isApprox( t, v, data.expected, 'returns expected value' );
+ t.end();
+});
+
+tape( 'the function computes the max norm (row-major, upper) (offsets)', function test( t ) {
+ var data;
+ var AP;
+ var v;
+
+ data = OFFSET_MAX_NORM_ROW_MAJOR_UPPER;
+ AP = new Float64Array( data.AP );
+ v = dlansp( data.order, data.norm, data.uplo, data.N, AP, data.strideAP, data.offsetAP );
+ t.strictEqual( v, data.expected, 'returns expected value' );
+ t.end();
+});
+
+tape( 'the function computes the max norm (row-major, lower) (offsets)', function test( t ) {
+ var data;
+ var AP;
+ var v;
+
+ data = OFFSET_MAX_NORM_ROW_MAJOR_LOWER;
+ AP = new Float64Array( data.AP );
+ v = dlansp( data.order, data.norm, data.uplo, data.N, AP, data.strideAP, data.offsetAP );
+ t.strictEqual( v, data.expected, 'returns expected value' );
+ t.end();
+});
+
+tape( 'the function computes the max norm (column-major, upper) (offsets)', function test( t ) {
+ var data;
+ var AP;
+ var v;
+
+ data = OFFSET_MAX_NORM_COLUMN_MAJOR_UPPER;
+ AP = new Float64Array( data.AP );
+ v = dlansp( data.order, data.norm, data.uplo, data.N, AP, data.strideAP, data.offsetAP );
+ t.strictEqual( v, data.expected, 'returns expected value' );
+ t.end();
+});
+
+tape( 'the function computes the max norm (column-major, lower) (offsets)', function test( t ) {
+ var data;
+ var AP;
+ var v;
+
+ data = OFFSET_MAX_NORM_COLUMN_MAJOR_LOWER;
+ AP = new Float64Array( data.AP );
+ v = dlansp( data.order, data.norm, data.uplo, data.N, AP, data.strideAP, data.offsetAP );
+ t.strictEqual( v, data.expected, 'returns expected value' );
+ t.end();
+});
+
+tape( 'the function computes the one norm (row-major, upper) (offsets)', function test( t ) {
+ var data;
+ var AP;
+ var v;
+
+ data = OFFSET_ONE_NORM_ROW_MAJOR_UPPER;
+ AP = new Float64Array( data.AP );
+ v = dlansp( data.order, data.norm, data.uplo, data.N, AP, data.strideAP, data.offsetAP );
+ t.strictEqual( v, data.expected, 'returns expected value' );
+ t.end();
+});
+
+tape( 'the function computes the one norm (row-major, lower) (offsets)', function test( t ) {
+ var data;
+ var AP;
+ var v;
+
+ data = OFFSET_ONE_NORM_ROW_MAJOR_LOWER;
+ AP = new Float64Array( data.AP );
+ v = dlansp( data.order, data.norm, data.uplo, data.N, AP, data.strideAP, data.offsetAP );
+ t.strictEqual( v, data.expected, 'returns expected value' );
+ t.end();
+});
+
+tape( 'the function computes the one norm (column-major, upper) (offsets)', function test( t ) {
+ var data;
+ var AP;
+ var v;
+
+ data = OFFSET_ONE_NORM_COLUMN_MAJOR_UPPER;
+ AP = new Float64Array( data.AP );
+ v = dlansp( data.order, data.norm, data.uplo, data.N, AP, data.strideAP, data.offsetAP );
+ t.strictEqual( v, data.expected, 'returns expected value' );
+ t.end();
+});
+
+tape( 'the function computes the one norm (column-major, lower) (offsets)', function test( t ) {
+ var data;
+ var AP;
+ var v;
+
+ data = OFFSET_ONE_NORM_COLUMN_MAJOR_LOWER;
+ AP = new Float64Array( data.AP );
+ v = dlansp( data.order, data.norm, data.uplo, data.N, AP, data.strideAP, data.offsetAP );
+ t.strictEqual( v, data.expected, 'returns expected value' );
+ t.end();
+});
+
+tape( 'the function computes the Frobenius norm (row-major, upper) (offsets)', function test( t ) {
+ var data;
+ var AP;
+ var v;
+
+ data = OFFSET_FROBENIUS_NORM_ROW_MAJOR_UPPER;
+ AP = new Float64Array( data.AP );
+ v = dlansp( data.order, data.norm, data.uplo, data.N, AP, data.strideAP, data.offsetAP );
+ isApprox( t, v, data.expected, 'returns expected value' );
+ t.end();
+});
+
+tape( 'the function computes the Frobenius norm (row-major, lower) (offsets)', function test( t ) {
+ var data;
+ var AP;
+ var v;
+
+ data = OFFSET_FROBENIUS_NORM_ROW_MAJOR_LOWER;
+ AP = new Float64Array( data.AP );
+ v = dlansp( data.order, data.norm, data.uplo, data.N, AP, data.strideAP, data.offsetAP );
+ isApprox( t, v, data.expected, 'returns expected value' );
+ t.end();
+});
+
+tape( 'the function computes the Frobenius norm (column-major, upper) (offsets)', function test( t ) {
+ var data;
+ var AP;
+ var v;
+
+ data = OFFSET_FROBENIUS_NORM_COLUMN_MAJOR_UPPER;
+ AP = new Float64Array( data.AP );
+ v = dlansp( data.order, data.norm, data.uplo, data.N, AP, data.strideAP, data.offsetAP );
+ isApprox( t, v, data.expected, 'returns expected value' );
+ t.end();
+});
+
+tape( 'the function computes the Frobenius norm (column-major, lower) (offsets)', function test( t ) {
+ var data;
+ var AP;
+ var v;
+
+ data = OFFSET_FROBENIUS_NORM_COLUMN_MAJOR_LOWER;
+ AP = new Float64Array( data.AP );
+ v = dlansp( data.order, data.norm, data.uplo, data.N, AP, data.strideAP, data.offsetAP );
+ isApprox( t, v, data.expected, 'returns expected value' );
+ t.end();
+});
+
+tape( 'the function computes the max norm (row-major, upper) (negative strides)', function test( t ) {
+ var data;
+ var AP;
+ var v;
+
+ data = NEGATIVE_STRIDES_MAX_NORM_ROW_MAJOR_UPPER;
+ AP = new Float64Array( data.AP );
+ v = dlansp( data.order, data.norm, data.uplo, data.N, AP, data.strideAP, data.offsetAP );
+ t.strictEqual( v, data.expected, 'returns expected value' );
+ t.end();
+});
+
+tape( 'the function computes the max norm (row-major, lower) (negative strides)', function test( t ) {
+ var data;
+ var AP;
+ var v;
+
+ data = NEGATIVE_STRIDES_MAX_NORM_ROW_MAJOR_LOWER;
+ AP = new Float64Array( data.AP );
+ v = dlansp( data.order, data.norm, data.uplo, data.N, AP, data.strideAP, data.offsetAP );
+ t.strictEqual( v, data.expected, 'returns expected value' );
+ t.end();
+});
+
+tape( 'the function computes the max norm (column-major, upper) (negative strides)', function test( t ) {
+ var data;
+ var AP;
+ var v;
+
+ data = NEGATIVE_STRIDES_MAX_NORM_COLUMN_MAJOR_UPPER;
+ AP = new Float64Array( data.AP );
+ v = dlansp( data.order, data.norm, data.uplo, data.N, AP, data.strideAP, data.offsetAP );
+ t.strictEqual( v, data.expected, 'returns expected value' );
+ t.end();
+});
+
+tape( 'the function computes the max norm (column-major, lower) (negative strides)', function test( t ) {
+ var data;
+ var AP;
+ var v;
+
+ data = NEGATIVE_STRIDES_MAX_NORM_COLUMN_MAJOR_LOWER;
+ AP = new Float64Array( data.AP );
+ v = dlansp( data.order, data.norm, data.uplo, data.N, AP, data.strideAP, data.offsetAP );
+ t.strictEqual( v, data.expected, 'returns expected value' );
+ t.end();
+});
+
+tape( 'the function computes the one norm (row-major, upper) (negative strides)', function test( t ) {
+ var data;
+ var AP;
+ var v;
+
+ data = NEGATIVE_STRIDES_ONE_NORM_ROW_MAJOR_UPPER;
+ AP = new Float64Array( data.AP );
+ v = dlansp( data.order, data.norm, data.uplo, data.N, AP, data.strideAP, data.offsetAP );
+ t.strictEqual( v, data.expected, 'returns expected value' );
+ t.end();
+});
+
+tape( 'the function computes the one norm (row-major, lower) (negative strides)', function test( t ) {
+ var data;
+ var AP;
+ var v;
+
+ data = NEGATIVE_STRIDES_ONE_NORM_ROW_MAJOR_LOWER;
+ AP = new Float64Array( data.AP );
+ v = dlansp( data.order, data.norm, data.uplo, data.N, AP, data.strideAP, data.offsetAP );
+ t.strictEqual( v, data.expected, 'returns expected value' );
+ t.end();
+});
+
+tape( 'the function computes the one norm (column-major, upper) (negative strides)', function test( t ) {
+ var data;
+ var AP;
+ var v;
+
+ data = NEGATIVE_STRIDES_ONE_NORM_COLUMN_MAJOR_UPPER;
+ AP = new Float64Array( data.AP );
+ v = dlansp( data.order, data.norm, data.uplo, data.N, AP, data.strideAP, data.offsetAP );
+ t.strictEqual( v, data.expected, 'returns expected value' );
+ t.end();
+});
+
+tape( 'the function computes the one norm (column-major, lower) (negative strides)', function test( t ) {
+ var data;
+ var AP;
+ var v;
+
+ data = NEGATIVE_STRIDES_ONE_NORM_COLUMN_MAJOR_LOWER;
+ AP = new Float64Array( data.AP );
+ v = dlansp( data.order, data.norm, data.uplo, data.N, AP, data.strideAP, data.offsetAP );
+ t.strictEqual( v, data.expected, 'returns expected value' );
+ t.end();
+});
+
+tape( 'the function computes the Frobenius norm (row-major, upper) (negative strides)', function test( t ) {
+ var data;
+ var AP;
+ var v;
+
+ data = NEGATIVE_STRIDES_FROBENIUS_NORM_ROW_MAJOR_UPPER;
+ AP = new Float64Array( data.AP );
+ v = dlansp( data.order, data.norm, data.uplo, data.N, AP, data.strideAP, data.offsetAP );
+ isApprox( t, v, data.expected, 'returns expected value' );
+ t.end();
+});
+
+tape( 'the function computes the Frobenius norm (row-major, lower) (negative strides)', function test( t ) {
+ var data;
+ var AP;
+ var v;
+
+ data = NEGATIVE_STRIDES_FROBENIUS_NORM_ROW_MAJOR_LOWER;
+ AP = new Float64Array( data.AP );
+ v = dlansp( data.order, data.norm, data.uplo, data.N, AP, data.strideAP, data.offsetAP );
+ isApprox( t, v, data.expected, 'returns expected value' );
+ t.end();
+});
+
+tape( 'the function computes the Frobenius norm (column-major, upper) (negative strides)', function test( t ) {
+ var data;
+ var AP;
+ var v;
+
+ data = NEGATIVE_STRIDES_FROBENIUS_NORM_COLUMN_MAJOR_UPPER;
+ AP = new Float64Array( data.AP );
+ v = dlansp( data.order, data.norm, data.uplo, data.N, AP, data.strideAP, data.offsetAP );
+ isApprox( t, v, data.expected, 'returns expected value' );
+ t.end();
+});
+
+tape( 'the function computes the Frobenius norm (column-major, lower) (negative strides)', function test( t ) {
+ var data;
+ var AP;
+ var v;
+
+ data = NEGATIVE_STRIDES_FROBENIUS_NORM_COLUMN_MAJOR_LOWER;
+ AP = new Float64Array( data.AP );
+ v = dlansp( data.order, data.norm, data.uplo, data.N, AP, data.strideAP, data.offsetAP );
+ isApprox( t, v, data.expected, 'returns expected value' );
+ t.end();
+});
+
+tape( 'the function computes the max norm (row-major, upper) (large strides)', function test( t ) {
+ var data;
+ var AP;
+ var v;
+
+ data = LARGE_STRIDES_MAX_NORM_ROW_MAJOR_UPPER;
+ AP = new Float64Array( data.AP );
+ v = dlansp( data.order, data.norm, data.uplo, data.N, AP, data.strideAP, data.offsetAP );
+ t.strictEqual( v, data.expected, 'returns expected value' );
+ t.end();
+});
+
+tape( 'the function computes the max norm (row-major, lower) (large strides)', function test( t ) {
+ var data;
+ var AP;
+ var v;
+
+ data = LARGE_STRIDES_MAX_NORM_ROW_MAJOR_LOWER;
+ AP = new Float64Array( data.AP );
+ v = dlansp( data.order, data.norm, data.uplo, data.N, AP, data.strideAP, data.offsetAP );
+ t.strictEqual( v, data.expected, 'returns expected value' );
+ t.end();
+});
+
+tape( 'the function computes the max norm (column-major, upper) (large strides)', function test( t ) {
+ var data;
+ var AP;
+ var v;
+
+ data = LARGE_STRIDES_MAX_NORM_COLUMN_MAJOR_UPPER;
+ AP = new Float64Array( data.AP );
+ v = dlansp( data.order, data.norm, data.uplo, data.N, AP, data.strideAP, data.offsetAP );
+ t.strictEqual( v, data.expected, 'returns expected value' );
+ t.end();
+});
+
+tape( 'the function computes the max norm (column-major, lower) (large strides)', function test( t ) {
+ var data;
+ var AP;
+ var v;
+
+ data = LARGE_STRIDES_MAX_NORM_COLUMN_MAJOR_LOWER;
+ AP = new Float64Array( data.AP );
+ v = dlansp( data.order, data.norm, data.uplo, data.N, AP, data.strideAP, data.offsetAP );
+ t.strictEqual( v, data.expected, 'returns expected value' );
+ t.end();
+});
+
+tape( 'the function computes the one norm (row-major, upper) (large strides)', function test( t ) {
+ var data;
+ var AP;
+ var v;
+
+ data = LARGE_STRIDES_ONE_NORM_ROW_MAJOR_UPPER;
+ AP = new Float64Array( data.AP );
+ v = dlansp( data.order, data.norm, data.uplo, data.N, AP, data.strideAP, data.offsetAP );
+ t.strictEqual( v, data.expected, 'returns expected value' );
+ t.end();
+});
+
+tape( 'the function computes the one norm (row-major, lower) (large strides)', function test( t ) {
+ var data;
+ var AP;
+ var v;
+
+ data = LARGE_STRIDES_ONE_NORM_ROW_MAJOR_LOWER;
+ AP = new Float64Array( data.AP );
+ v = dlansp( data.order, data.norm, data.uplo, data.N, AP, data.strideAP, data.offsetAP );
+ t.strictEqual( v, data.expected, 'returns expected value' );
+ t.end();
+});
+
+tape( 'the function computes the one norm (column-major, upper) (large strides)', function test( t ) {
+ var data;
+ var AP;
+ var v;
+
+ data = LARGE_STRIDES_ONE_NORM_COLUMN_MAJOR_UPPER;
+ AP = new Float64Array( data.AP );
+ v = dlansp( data.order, data.norm, data.uplo, data.N, AP, data.strideAP, data.offsetAP );
+ t.strictEqual( v, data.expected, 'returns expected value' );
+ t.end();
+});
+
+tape( 'the function computes the one norm (column-major, lower) (large strides)', function test( t ) {
+ var data;
+ var AP;
+ var v;
+
+ data = LARGE_STRIDES_ONE_NORM_COLUMN_MAJOR_LOWER;
+ AP = new Float64Array( data.AP );
+ v = dlansp( data.order, data.norm, data.uplo, data.N, AP, data.strideAP, data.offsetAP );
+ t.strictEqual( v, data.expected, 'returns expected value' );
+ t.end();
+});
+
+tape( 'the function computes the Frobenius norm (row-major, upper) (large strides)', function test( t ) {
+ var data;
+ var AP;
+ var v;
+
+ data = LARGE_STRIDES_FROBENIUS_NORM_ROW_MAJOR_UPPER;
+ AP = new Float64Array( data.AP );
+ v = dlansp( data.order, data.norm, data.uplo, data.N, AP, data.strideAP, data.offsetAP );
+ isApprox( t, v, data.expected, 'returns expected value' );
+ t.end();
+});
+
+tape( 'the function computes the Frobenius norm (row-major, lower) (large strides)', function test( t ) {
+ var data;
+ var AP;
+ var v;
+
+ data = LARGE_STRIDES_FROBENIUS_NORM_ROW_MAJOR_LOWER;
+ AP = new Float64Array( data.AP );
+ v = dlansp( data.order, data.norm, data.uplo, data.N, AP, data.strideAP, data.offsetAP );
+ isApprox( t, v, data.expected, 'returns expected value' );
+ t.end();
+});
+
+tape( 'the function computes the Frobenius norm (column-major, upper) (large strides)', function test( t ) {
+ var data;
+ var AP;
+ var v;
+
+ data = LARGE_STRIDES_FROBENIUS_NORM_COLUMN_MAJOR_UPPER;
+ AP = new Float64Array( data.AP );
+ v = dlansp( data.order, data.norm, data.uplo, data.N, AP, data.strideAP, data.offsetAP );
+ isApprox( t, v, data.expected, 'returns expected value' );
+ t.end();
+});
+
+tape( 'the function computes the Frobenius norm (column-major, lower) (large strides)', function test( t ) {
+ var data;
+ var AP;
+ var v;
+
+ data = LARGE_STRIDES_FROBENIUS_NORM_COLUMN_MAJOR_LOWER;
+ AP = new Float64Array( data.AP );
+ v = dlansp( data.order, data.norm, data.uplo, data.N, AP, data.strideAP, data.offsetAP );
+ isApprox( t, v, data.expected, 'returns expected value' );
+ t.end();
+});
+
+tape( 'the function computes the max norm (row-major, upper) (mixed strides)', function test( t ) {
+ var data;
+ var AP;
+ var v;
+
+ data = MIXED_STRIDES_MAX_NORM_ROW_MAJOR_UPPER;
+ AP = new Float64Array( data.AP );
+ v = dlansp( data.order, data.norm, data.uplo, data.N, AP, data.strideAP, data.offsetAP );
+ t.strictEqual( v, data.expected, 'returns expected value' );
+ t.end();
+});
+
+tape( 'the function computes the max norm (row-major, lower) (mixed strides)', function test( t ) {
+ var data;
+ var AP;
+ var v;
+
+ data = MIXED_STRIDES_MAX_NORM_ROW_MAJOR_LOWER;
+ AP = new Float64Array( data.AP );
+ v = dlansp( data.order, data.norm, data.uplo, data.N, AP, data.strideAP, data.offsetAP );
+ t.strictEqual( v, data.expected, 'returns expected value' );
+ t.end();
+});
+
+tape( 'the function computes the max norm (column-major, upper) (mixed strides)', function test( t ) {
+ var data;
+ var AP;
+ var v;
+
+ data = MIXED_STRIDES_MAX_NORM_COLUMN_MAJOR_UPPER;
+ AP = new Float64Array( data.AP );
+ v = dlansp( data.order, data.norm, data.uplo, data.N, AP, data.strideAP, data.offsetAP );
+ t.strictEqual( v, data.expected, 'returns expected value' );
+ t.end();
+});
+
+tape( 'the function computes the max norm (column-major, lower) (mixed strides)', function test( t ) {
+ var data;
+ var AP;
+ var v;
+
+ data = MIXED_STRIDES_MAX_NORM_COLUMN_MAJOR_LOWER;
+ AP = new Float64Array( data.AP );
+ v = dlansp( data.order, data.norm, data.uplo, data.N, AP, data.strideAP, data.offsetAP );
+ t.strictEqual( v, data.expected, 'returns expected value' );
+ t.end();
+});
+
+tape( 'the function computes the one norm (row-major, upper) (mixed strides)', function test( t ) {
+ var data;
+ var AP;
+ var v;
+
+ data = MIXED_STRIDES_ONE_NORM_ROW_MAJOR_UPPER;
+ AP = new Float64Array( data.AP );
+ v = dlansp( data.order, data.norm, data.uplo, data.N, AP, data.strideAP, data.offsetAP );
+ t.strictEqual( v, data.expected, 'returns expected value' );
+ t.end();
+});
+
+tape( 'the function computes the one norm (row-major, lower) (mixed strides)', function test( t ) {
+ var data;
+ var AP;
+ var v;
+
+ data = MIXED_STRIDES_ONE_NORM_ROW_MAJOR_LOWER;
+ AP = new Float64Array( data.AP );
+ v = dlansp( data.order, data.norm, data.uplo, data.N, AP, data.strideAP, data.offsetAP );
+ t.strictEqual( v, data.expected, 'returns expected value' );
+ t.end();
+});
+
+tape( 'the function computes the one norm (column-major, upper) (mixed strides)', function test( t ) {
+ var data;
+ var AP;
+ var v;
+
+ data = MIXED_STRIDES_ONE_NORM_COLUMN_MAJOR_UPPER;
+ AP = new Float64Array( data.AP );
+ v = dlansp( data.order, data.norm, data.uplo, data.N, AP, data.strideAP, data.offsetAP );
+ t.strictEqual( v, data.expected, 'returns expected value' );
+ t.end();
+});
+
+tape( 'the function computes the one norm (column-major, lower) (mixed strides)', function test( t ) {
+ var data;
+ var AP;
+ var v;
+
+ data = MIXED_STRIDES_ONE_NORM_COLUMN_MAJOR_LOWER;
+ AP = new Float64Array( data.AP );
+ v = dlansp( data.order, data.norm, data.uplo, data.N, AP, data.strideAP, data.offsetAP );
+ t.strictEqual( v, data.expected, 'returns expected value' );
+ t.end();
+});
+
+tape( 'the function computes the Frobenius norm (row-major, upper) (mixed strides)', function test( t ) {
+ var data;
+ var AP;
+ var v;
+
+ data = MIXED_STRIDES_FROBENIUS_NORM_ROW_MAJOR_UPPER;
+ AP = new Float64Array( data.AP );
+ v = dlansp( data.order, data.norm, data.uplo, data.N, AP, data.strideAP, data.offsetAP );
+ isApprox( t, v, data.expected, 'returns expected value' );
+ t.end();
+});
+
+tape( 'the function computes the Frobenius norm (row-major, lower) (mixed strides)', function test( t ) {
+ var data;
+ var AP;
+ var v;
+
+ data = MIXED_STRIDES_FROBENIUS_NORM_ROW_MAJOR_LOWER;
+ AP = new Float64Array( data.AP );
+ v = dlansp( data.order, data.norm, data.uplo, data.N, AP, data.strideAP, data.offsetAP );
+ isApprox( t, v, data.expected, 'returns expected value' );
+ t.end();
+});
+
+tape( 'the function computes the Frobenius norm (column-major, upper) (mixed strides)', function test( t ) {
+ var data;
+ var AP;
+ var v;
+
+ data = MIXED_STRIDES_FROBENIUS_NORM_COLUMN_MAJOR_UPPER;
+ AP = new Float64Array( data.AP );
+ v = dlansp( data.order, data.norm, data.uplo, data.N, AP, data.strideAP, data.offsetAP );
+ isApprox( t, v, data.expected, 'returns expected value' );
+ t.end();
+});
+
+tape( 'the function computes the Frobenius norm (column-major, lower) (mixed strides)', function test( t ) {
+ var data;
+ var AP;
+ var v;
+
+ data = MIXED_STRIDES_FROBENIUS_NORM_COLUMN_MAJOR_LOWER;
+ AP = new Float64Array( data.AP );
+ v = dlansp( data.order, data.norm, data.uplo, data.N, AP, data.strideAP, data.offsetAP );
+ isApprox( t, v, data.expected, 'returns expected value' );
+ t.end();
+});