diff --git a/lib/node_modules/@stdlib/blas/ext/base/gsummed-area-table/README.md b/lib/node_modules/@stdlib/blas/ext/base/gsummed-area-table/README.md new file mode 100644 index 000000000000..0d69bbf875d1 --- /dev/null +++ b/lib/node_modules/@stdlib/blas/ext/base/gsummed-area-table/README.md @@ -0,0 +1,184 @@ + + +# gsummedAreaTable + +> Compute a summed-area table for a matrix. + +
+ +## Usage + +```javascript +var gsummedAreaTable = require( '@stdlib/blas/ext/base/gsummed-area-table' ); +``` + +#### gsummedAreaTable( order, M, N, A, LDA, out, LDO ) + +Computes a summed-area table for a matrix. + +```javascript +var A = [ 1, 2, 3, 4 ]; +var out = [ 0, 0, 0, 0 ]; + +gsummedAreaTable( 'row-major', 2, 2, A, 2, out, 2 ); +// out => [ 1, 3, 4, 10 ] +``` + +The function has the following parameters: + +- **order**: memory layout order ('row-major' or 'column-major'). +- **M**: number of rows in `A`. +- **N**: number of columns in `A`. +- **A**: input matrix. +- **LDA**: stride length between successive contiguous vectors of the matrix `A` (leading dimension of `A`). +- **out**: output matrix. +- **LDO**: stride length between successive contiguous vectors of the matrix `out` (leading dimension of `out`). + +The `M`, `N`, `LDA`, and `LDO` parameters determine which elements in the matrices are accessed at runtime. For example, to compute a summed-area table for every other pair of elements in the input matrix: + +```javascript +var A = [ 1.0, 2.0, 0.0, 3.0, 4.0, 0.0 ]; +var out = [ 0.0, 0.0, 0.0, 0.0, 0.0, 0.0 ]; + +gsummedAreaTable( 'row-major', 2, 2, A, 3, out, 3 ); +// out => [ 1.0, 3.0, 0.0, 4.0, 10.0, 0.0 ] +``` + +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 matrices... +var A0 = new Float64Array( [ 0.0, 1.0, 2.0, 0.0, 3.0, 4.0 ] ); +var out0 = new Float64Array( [ 0.0, 0.0, 0.0, 0.0, 0.0, 0.0 ] ); + +// Create offset views... +var A1 = new Float64Array( A0.buffer, A0.BYTES_PER_ELEMENT*1 ); // start at 2nd element +var out1 = new Float64Array( out0.buffer, out0.BYTES_PER_ELEMENT*1 ); // start at 2nd element + +gsummedAreaTable( 'row-major', 2, 2, A1, 2, out1, 2 ); +// out0 => [ 0.0, 1.0, 3.0, 1.0, 6.0, 0.0 ] +``` + + + +#### gsummedAreaTable.ndarray( M, N, A, strideA1, strideA2, offsetA, out, strideOut1, strideOut2, offsetOut ) + + + +Computes a summed-area table for a matrix using alternative indexing semantics. + +```javascript +var A = [ 1.0, 2.0, 3.0, 4.0 ]; +var out = [ 0.0, 0.0, 0.0, 0.0 ]; + +gsummedAreaTable.ndarray( 2, 2, A, 2, 1, 0, out, 2, 1, 0 ); +// out => [ 1.0, 3.0, 4.0, 10.0 ] +``` + +The function has the following parameters: + +- **M**: number of rows in `A`. +- **N**: number of columns in `A`. +- **A**: input matrix. +- **strideA1**: stride length of first dimension of `A`. +- **strideA2**: stride length of second dimension of `A`. +- **offsetA**: starting index for `A`. +- **out**: output matrix. +- **strideOut1**: stride length of first dimension of `out`. +- **strideOut2**: stride length of second dimension of `out`. +- **offsetOut**: starting index for `out`. + +While [`typed array`][mdn-typed-array] views mandate a view offset based on the underlying buffer, the offset parameters support indexing semantics based on starting indices. For example, to access only a submatrix: + +```javascript +var A = [ 0.0, 0.0, 0.0, 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0 ]; +var out = [ 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0 ]; + +gsummedAreaTable.ndarray( 2, 2, A, 4, 1, 3, out, 4, 1, 3 ); +// out => [ 0.0, 0.0, 0.0, 1.0, 3.0, 0.0, 0.0, 6.0, 14.0, 0.0, 0.0, 0.0 ] +``` + +
+ + + +
+ +## Notes + +- If `M <= 0` or `N <= 0`, both functions return `out` unchanged. +- Both functions support array-like objects having getter and setter accessors for array element access (e.g., [`@stdlib/array/base/accessor`][@stdlib/array/base/accessor]). + +
+ + + +
+ +## Examples + + + +```javascript +var discreteUniform = require( '@stdlib/random/array/discrete-uniform' ); +var Float64Array = require( '@stdlib/array/float64' ); +var gsummedAreaTable = require( '@stdlib/blas/ext/base/gsummed-area-table' ); + +var A = discreteUniform( 6, 1, 10, { + 'dtype': 'float64' +}); +console.log( A ); + +var out = new Float64Array( 6 ); + +gsummedAreaTable( 'row-major', 2, 3, A, 3, out, 3 ); +console.log( out ); +``` + +
+ + + + + +
+ +
+ + + + + +
+ +[mdn-typed-array]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray + +[@stdlib/array/base/accessor]: https://github.com/stdlib-js/stdlib/tree/develop/lib/node_modules/%40stdlib/array/base/accessor + + + + + +
+ + diff --git a/lib/node_modules/@stdlib/blas/ext/base/gsummed-area-table/benchmark/benchmark.js b/lib/node_modules/@stdlib/blas/ext/base/gsummed-area-table/benchmark/benchmark.js new file mode 100644 index 000000000000..1ab00cbf0648 --- /dev/null +++ b/lib/node_modules/@stdlib/blas/ext/base/gsummed-area-table/benchmark/benchmark.js @@ -0,0 +1,109 @@ +/** +* @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 zeros = require( '@stdlib/array/zeros' ); +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 gsummedAreaTable = require( './../lib/main.js' ); + + +// VARIABLES // + +var options = { + 'dtype': 'generic' +}; + + +// FUNCTIONS // + +/** +* Creates a benchmark function. +* +* @private +* @param {PositiveInteger} N - matrix dimension +* @returns {Function} benchmark function +*/ +function createBenchmark( N ) { + var out; + var A; + + A = uniform( N*N, 0.0, 10.0, options ); + out = zeros( N*N, options.dtype ); + 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 = gsummedAreaTable( 'row-major', N, N, A, N, out, N ); + if ( isnan( z[ i%z.length ] ) ) { + b.fail( 'should not return NaN' ); + } + } + b.toc(); + if ( isnan( z[ i%z.length ] ) ) { + 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 = 4; // 10^max + + for ( i = min; i <= max; i++ ) { + N = floor( pow( pow( 10, i ), 1.0/2.0 ) ); + f = createBenchmark( N ); + bench( format( '%s:size=%d', pkg, N*N ), f ); + } +} + +main(); diff --git a/lib/node_modules/@stdlib/blas/ext/base/gsummed-area-table/benchmark/benchmark.ndarray.js b/lib/node_modules/@stdlib/blas/ext/base/gsummed-area-table/benchmark/benchmark.ndarray.js new file mode 100644 index 000000000000..562841cc5134 --- /dev/null +++ b/lib/node_modules/@stdlib/blas/ext/base/gsummed-area-table/benchmark/benchmark.ndarray.js @@ -0,0 +1,109 @@ +/** +* @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 zeros = require( '@stdlib/array/zeros' ); +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 gsummedAreaTable = require( './../lib/ndarray.js' ); + + +// VARIABLES // + +var options = { + 'dtype': 'generic' +}; + + +// FUNCTIONS // + +/** +* Creates a benchmark function. +* +* @private +* @param {PositiveInteger} N - matrix dimension +* @returns {Function} benchmark function +*/ +function createBenchmark( N ) { + var out; + var A; + + A = uniform( N*N, 0.0, 10.0, options ); + out = zeros( N*N, options.dtype ); + 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 = gsummedAreaTable( N, N, A, N, 1, 0, out, N, 1, 0 ); + if ( isnan( z[ i%z.length ] ) ) { + b.fail( 'should not return NaN' ); + } + } + b.toc(); + if ( isnan( z[ i%z.length ] ) ) { + 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 = 4; // 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:size=%d', pkg, N*N ), f ); + } +} + +main(); diff --git a/lib/node_modules/@stdlib/blas/ext/base/gsummed-area-table/docs/repl.txt b/lib/node_modules/@stdlib/blas/ext/base/gsummed-area-table/docs/repl.txt new file mode 100644 index 000000000000..3962c86983a6 --- /dev/null +++ b/lib/node_modules/@stdlib/blas/ext/base/gsummed-area-table/docs/repl.txt @@ -0,0 +1,127 @@ + +{{alias}}( order, M, N, A, LDA, out, LDO ) + Computes a summed-area table for a matrix. + + The `M`, `N`, `LDA` and `LDO` parameters determine which elements in the + matrices are accessed at runtime. + + Indexing is relative to the first index. To introduce an offset, use typed + array views. + + If `M <= 0` or `N <= 0`, the function returns `out` unchanged. + + Parameters + ---------- + order: string + Row-major (C-style) or column-major (Fortran-style) order. + + M: integer + Number of rows in `A`. + + N: integer + Number of columns in `A`. + + A: Array|TypedArray + Input matrix. + + LDA: integer + Stride of the first dimension of `A` (a.k.a., leading dimension of the + matrix `A`). + + out: Array|TypedArray + Output matrix. + + LDO: integer + Stride of the first dimension of `out` (a.k.a., leading dimension of the + output matrix). + + Returns + ------- + out: Array|TypedArray + Output matrix. + + Examples + -------- + // Standard Usage: + > var A = [ 1.0, 2.0, 3.0, 4.0 ]; + > var out = [ 0.0, 0.0, 0.0, 0.0 ]; + > {{alias}}( 'row-major', 2, 2, A, 2, out, 2 ) + [ 1.0, 3.0, 4.0, 10.0 ] + + // Using stride parameters: + > A = [ 1.0, 2.0, 0.0, 3.0, 4.0, 0.0 ]; + > out = [ 0.0, 0.0, 0.0, 0.0, 0.0, 0.0 ]; + > {{alias}}( 'row-major', 2, 2, A, 3, out, 3 ) + [ 1.0, 3.0, 0.0, 4.0, 10.0, 0.0 ] + + // Using view offsets: + > var A0 = new {{alias:@stdlib/array/float64}}( [ 0.0, 1.0, 2.0, 0.0, 3.0, 4.0 ] ); + > var out0 = new {{alias:@stdlib/array/float64}}( [ 0.0, 0.0, 0.0, 0.0, 0.0, 0.0 ] ); + > var A1 = new {{alias:@stdlib/array/float64}}( A0.buffer, A0.BYTES_PER_ELEMENT*1 ); + > var out1 = new {{alias:@stdlib/array/float64}}( out0.buffer, out0.BYTES_PER_ELEMENT*1 ); + > {{alias}}( 'row-major', 2, 2, A1, 2, out1, 2 ); + > out0 + [ 0.0, 1.0, 3.0, 1.0, 6.0, 0.0 ] + + +{{alias}}.ndarray( M, N, A, sA1, sA2, oA, o, so1, so2, oo ) + Computes a summed-area table for a matrix using alternative indexing + semantics. + + While typed array views mandate a view offset based on the underlying + buffer, the offset parameter supports indexing semantics based on a + starting index. + + Parameters + ---------- + M: integer + Number of rows in `A`. + + N: integer + Number of columns in `A`. + + A: Array|TypedArray + Input matrix. + + sA1: integer + Stride of the first dimension of `A`. + + sA2: integer + Stride of the second dimension of `A`. + + oA: integer + Starting index for `A`. + + o: Array|TypedArray + Output matrix. + + so1: integer + Stride of the first dimension of `o`. + + so2: integer + Stride of the second dimension of `o`. + + oo: integer + Starting index for `o`. + + Returns + ------- + o: Array|TypedArray + Output matrix. + + Examples + -------- + // Standard Usage: + > var A = [ 1.0, 2.0, 3.0, 4.0 ]; + > var o = [ 0.0, 0.0, 0.0, 0.0 ]; + > {{alias}}.ndarray( 2, 2, A, 2, 1, 0, o, 2, 1, 0 ) + [ 1.0, 3.0, 4.0, 10.0 ] + + // Using an index offset: + > A = [ 0.0, 0.0, 0.0, 1.0, 2.0, 3.0, 4.0 ]; + > o = [ 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0 ]; + > {{alias}}.ndarray( 2, 2, A, 2, 1, 3, o, 2, 1, 3 ) + [ 0.0, 0.0, 0.0, 1.0, 3.0, 4.0, 10.0 ] + + See Also + -------- diff --git a/lib/node_modules/@stdlib/blas/ext/base/gsummed-area-table/docs/types/index.d.ts b/lib/node_modules/@stdlib/blas/ext/base/gsummed-area-table/docs/types/index.d.ts new file mode 100644 index 000000000000..0c0922b29bf9 --- /dev/null +++ b/lib/node_modules/@stdlib/blas/ext/base/gsummed-area-table/docs/types/index.d.ts @@ -0,0 +1,117 @@ +/* +* @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 { NumericArray, Collection, AccessorArrayLike } from '@stdlib/types/array'; +import { Layout } from '@stdlib/types/blas'; + +/** +* Input array. +*/ +type InputArray = NumericArray | Collection | AccessorArrayLike; + +/** +* Output array. +*/ +type OutputArray = NumericArray | Collection | AccessorArrayLike; + +/** +* Interface describing `gsummedAreaTable`. +*/ +interface Routine { + /** + * Computes a summed-area table for a matrix. + * + * @param order - memory layout order ('row-major' or 'column-major') + * @param M - number of rows in `A` + * @param N - number of columns in `A` + * @param A - input matrix + * @param LDA - stride length of first dimension of `A` + * @param out - output matrix + * @param LDO - stride length of first dimension of `out` + * @returns output matrix + * + * @example + * var A = [ 1.0, 2.0, 3.0, 4.0 ]; + * var out = [ 0.0, 0.0, 0.0, 0.0 ]; + * + * gsummedAreaTable( 'row-major', 2, 2, A, 2, out, 2 ); + * // out => [ 1.0, 3.0, 4.0, 10.0 ] + */ + ( order: Layout, M: number, N: number, A: InputArray, LDA: number, out: T, LDO: number ): T; + + /** + * Computes a summed-area table for a matrix using alternative indexing semantics. + * + * @param M - number of rows in `A` + * @param N - number of columns in `A` + * @param A - input matrix + * @param strideA1 - stride length of first dimension of `A` + * @param strideA2 - stride length of second dimension of `A` + * @param offsetA - starting index for `A` + * @param out - output matrix + * @param strideOut1 - stride length of first dimension of `out` + * @param strideOut2 - stride length of second dimension of `out` + * @param offsetOut - starting index for `out` + * @returns output matrix + * + * @example + * var A = [ 1.0, 2.0, 3.0, 4.0 ]; + * var out = [ 0.0, 0.0, 0.0, 0.0 ]; + * + * gsummedAreaTable.ndarray( 2, 2, A, 2, 1, 0, out, 2, 1, 0 ); + * // out => [ 1.0, 3.0, 4.0, 10.0 ] + */ + ndarray( M: number, N: number, A: InputArray, strideA1: number, strideA2: number, offsetA: number, out: T, strideOut1: number, strideOut2: number, offsetOut: number ): T; +} + +/** +* Computes a summed-area table for a matrix. +* +* @param order - memory layout order ('row-major' or 'column-major') +* @param M - number of rows in `A` +* @param N - number of columns in `A` +* @param A - input matrix +* @param LDA - stride length of first dimension of `A` +* @param out - output matrix +* @param LDO - stride length of first dimension of `out` +* @returns output matrix +* +* @example +* var A = [ 1.0, 2.0, 3.0, 4.0 ]; +* var out = [ 0.0, 0.0, 0.0, 0.0 ]; +* +* gsummedAreaTable( 'row-major', 2, 2, A, 2, out, 2 ); +* // out => [ 1.0, 3.0, 4.0, 10.0 ] +* +* @example +* var A = [ 1.0, 2.0, 3.0, 4.0 ]; +* var out = [ 0.0, 0.0, 0.0, 0.0 ]; +* +* gsummedAreaTable.ndarray( 2, 2, A, 2, 1, 0, out, 2, 1, 0 ); +* // out => [ 1.0, 3.0, 4.0, 10.0 ] +*/ +declare var gsummedAreaTable: Routine; + + +// EXPORTS // + +export = gsummedAreaTable; diff --git a/lib/node_modules/@stdlib/blas/ext/base/gsummed-area-table/docs/types/test.ts b/lib/node_modules/@stdlib/blas/ext/base/gsummed-area-table/docs/types/test.ts new file mode 100644 index 000000000000..c1572e51199a --- /dev/null +++ b/lib/node_modules/@stdlib/blas/ext/base/gsummed-area-table/docs/types/test.ts @@ -0,0 +1,326 @@ +/* +* @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 space-in-parens */ + +import AccessorArray = require( '@stdlib/array/base/accessor' ); +import gsummedAreaTable = require( './index' ); + + +// TESTS // + +// The function returns a numeric array... +{ + const A = new Float64Array( [ 1.0, 2.0, 3.0, 4.0 ] ); + const out = new Float64Array( [ 0.0, 0.0, 0.0, 0.0 ]); + + gsummedAreaTable( 'row-major', 2, 2, A, 2, out, 2 ); // $ExpectType Float64Array + gsummedAreaTable( 'row-major', 2, 2, new AccessorArray( A ), 2, new AccessorArray( out ), 2 ); // $ExpectType AccessorArray +} + +// The compiler throws an error if the function is provided a first argument which is not a string... +{ + const A = new Float64Array( [ 1.0, 2.0, 3.0, 4.0 ] ); + const out = new Float64Array( [ 0.0, 0.0, 0.0, 0.0 ]); + + gsummedAreaTable( 10, 2, 2, A, 2, out, 2 ); // $ExpectError + gsummedAreaTable( true, 2, 2, A, 2, out, 2 ); // $ExpectError + gsummedAreaTable( false, 2, 2, A, 2, out, 2 ); // $ExpectError + gsummedAreaTable( null, 2, 2, A, 2, out, 2 ); // $ExpectError + gsummedAreaTable( undefined, 2, 2, A, 2, out, 2 ); // $ExpectError + gsummedAreaTable( [], 2, 2, A, 2, out, 2 ); // $ExpectError + gsummedAreaTable( {}, 2, 2, A, 2, out, 2 ); // $ExpectError + gsummedAreaTable( ( x: number ): number => x, 2, 2, A, 2, out, 2 ); // $ExpectError +} + +// The compiler throws an error if the function is provided a second argument which is not a number... +{ + const A = new Float64Array( [ 1.0, 2.0, 3.0, 4.0 ] ); + const out = new Float64Array( [ 0.0, 0.0, 0.0, 0.0 ]); + + gsummedAreaTable( 'row-major', '2', 2, A, 2, out, 2 ); // $ExpectError + gsummedAreaTable( 'row-major', true, 2, A, 2, out, 2 ); // $ExpectError + gsummedAreaTable( 'row-major', false, 2, A, 2, out, 2 ); // $ExpectError + gsummedAreaTable( 'row-major', null, 2, A, 2, out, 2 ); // $ExpectError + gsummedAreaTable( 'row-major', undefined, 2, A, 2, out, 2 ); // $ExpectError + gsummedAreaTable( 'row-major', [], 2, A, 2, out, 2 ); // $ExpectError + gsummedAreaTable( 'row-major', {}, 2, A, 2, out, 2 ); // $ExpectError + gsummedAreaTable( 'row-major', ( x: number ): number => x, 2, A, 2, out, 2 ); // $ExpectError +} + +// The compiler throws an error if the function is provided a third argument which is not a number... +{ + const A = new Float64Array( [ 1.0, 2.0, 3.0, 4.0 ] ); + const out = new Float64Array( [ 0.0, 0.0, 0.0, 0.0 ]); + + gsummedAreaTable( 'row-major', 2, '2', A, 2, out, 2 ); // $ExpectError + gsummedAreaTable( 'row-major', 2, true, A, 2, out, 2 ); // $ExpectError + gsummedAreaTable( 'row-major', 2, false, A, 2, out, 2 ); // $ExpectError + gsummedAreaTable( 'row-major', 2, null, A, 2, out, 2 ); // $ExpectError + gsummedAreaTable( 'row-major', 2, undefined, A, 2, out, 2 ); // $ExpectError + gsummedAreaTable( 'row-major', 2, [], A, 2, out, 2 ); // $ExpectError + gsummedAreaTable( 'row-major', 2, {}, A, 2, out, 2 ); // $ExpectError + gsummedAreaTable( 'row-major', 2, ( x: number ): number => x, A, 2, out, 2 ); // $ExpectError +} + +// The compiler throws an error if the function is provided a fourth argument which is not a numeric array... +{ + const out = new Float64Array( [ 0.0, 0.0, 0.0, 0.0 ]); + + gsummedAreaTable( 'row-major', 2, 2, '2', 2, out, 2 ); // $ExpectError + gsummedAreaTable( 'row-major', 2, 2, true, 2, out, 2 ); // $ExpectError + gsummedAreaTable( 'row-major', 2, 2, false, 2, out, 2 ); // $ExpectError + gsummedAreaTable( 'row-major', 2, 2, null, 2, out, 2 ); // $ExpectError + gsummedAreaTable( 'row-major', 2, 2, undefined, 2, out, 2 ); // $ExpectError + gsummedAreaTable( 'row-major', 2, 2, {}, 2, out, 2 ); // $ExpectError + gsummedAreaTable( 'row-major', 2, 2, ( x: number ): number => x, 2, out, 2 ); // $ExpectError +} + +// The compiler throws an error if the function is provided a fifth argument which is not a number... +{ + const A = new Float64Array( [ 1.0, 2.0, 3.0, 4.0 ] ); + const out = new Float64Array( [ 0.0, 0.0, 0.0, 0.0 ]); + + gsummedAreaTable( 'row-major', 2, 2, A, '2', out, 2 ); // $ExpectError + gsummedAreaTable( 'row-major', 2, 2, A, true, out, 2 ); // $ExpectError + gsummedAreaTable( 'row-major', 2, 2, A, false, out, 2 ); // $ExpectError + gsummedAreaTable( 'row-major', 2, 2, A, null, out, 2 ); // $ExpectError + gsummedAreaTable( 'row-major', 2, 2, A, undefined, out, 2 ); // $ExpectError + gsummedAreaTable( 'row-major', 2, 2, A, [], out, 2 ); // $ExpectError + gsummedAreaTable( 'row-major', 2, 2, A, {}, out, 2 ); // $ExpectError + gsummedAreaTable( 'row-major', 2, 2, A, ( x: number ): number => x, out, 2 ); // $ExpectError +} + +// The compiler throws an error if the function is provided a sixth argument which is not a numeric array... +{ + const A = new Float64Array( [ 1.0, 2.0, 3.0, 4.0 ] ); + + gsummedAreaTable( 'row-major', 2, 2, A, 2, '2', 2 ); // $ExpectError + gsummedAreaTable( 'row-major', 2, 2, A, 2, true, 2 ); // $ExpectError + gsummedAreaTable( 'row-major', 2, 2, A, 2, false, 2 ); // $ExpectError + gsummedAreaTable( 'row-major', 2, 2, A, 2, null, 2 ); // $ExpectError + gsummedAreaTable( 'row-major', 2, 2, A, 2, undefined, 2 ); // $ExpectError + gsummedAreaTable( 'row-major', 2, 2, A, 2, [ '1' ], 2 ); // $ExpectError + gsummedAreaTable( 'row-major', 2, 2, A, 2, {}, 2 ); // $ExpectError + gsummedAreaTable( 'row-major', 2, 2, A, 2, ( x: number ): number => x, 2 ); // $ExpectError +} + +// The compiler throws an error if the function is provided a seventh argument which is not a number... +{ + const A = new Float64Array( [ 1.0, 2.0, 3.0, 4.0 ] ); + const out = new Float64Array( [ 0.0, 0.0, 0.0, 0.0 ]); + + gsummedAreaTable( 'row-major', 2, 2, A, 2, out, '2' ); // $ExpectError + gsummedAreaTable( 'row-major', 2, 2, A, 2, out, true ); // $ExpectError + gsummedAreaTable( 'row-major', 2, 2, A, 2, out, false ); // $ExpectError + gsummedAreaTable( 'row-major', 2, 2, A, 2, out, null ); // $ExpectError + gsummedAreaTable( 'row-major', 2, 2, A, 2, out, undefined ); // $ExpectError + gsummedAreaTable( 'row-major', 2, 2, A, 2, out, [] ); // $ExpectError + gsummedAreaTable( 'row-major', 2, 2, A, 2, out, {} ); // $ExpectError + gsummedAreaTable( 'row-major', 2, 2, A, 2, out, ( x: number ): number => x ); // $ExpectError +} + +// The compiler throws an error if the function is provided an unsupported number of arguments... +{ + const A = new Float64Array( [ 1.0, 2.0, 3.0, 4.0 ] ); + const out = new Float64Array( [ 0.0, 0.0, 0.0, 0.0 ] ); + + gsummedAreaTable(); // $ExpectError + gsummedAreaTable( 'row-major' ); // $ExpectError + gsummedAreaTable( 'row-major', 2 ); // $ExpectError + gsummedAreaTable( 'row-major', 2, 2 ); // $ExpectError + gsummedAreaTable( 'row-major', 2, 2, A ); // $ExpectError + gsummedAreaTable( 'row-major', 2, 2, A, 2 ); // $ExpectError + gsummedAreaTable( 'row-major', 2, 2, A, 2, out ); // $ExpectError + gsummedAreaTable( 'row-major', 2, 2, A, 2, out, 2, {} ); // $ExpectError +} + +// Attached to main export is an `ndarray` method which returns a numeric array... +{ + const A = new Float64Array( [ 1.0, 2.0, 3.0, 4.0 ] ); + const out = new Float64Array( [ 0.0, 0.0, 0.0, 0.0 ] ); + + gsummedAreaTable.ndarray( 2, 2, A, 2, 1, 0, out, 2, 1, 0 ); // $ExpectType Float64Array + gsummedAreaTable.ndarray( 2, 2, new AccessorArray( A ), 2, 1, 0, new AccessorArray( out ), 2, 1, 0 ); // $ExpectType AccessorArray +} + +// The compiler throws an error if the `ndarray` method is provided a first argument which is not a number... +{ + const A = new Float64Array( [ 1.0, 2.0, 3.0, 4.0 ] ); + const out = new Float64Array( [ 0.0, 0.0, 0.0, 0.0 ] ); + + gsummedAreaTable.ndarray( '2', 2, A, 2, 1, 0, out, 2, 1, 0 ); // $ExpectError + gsummedAreaTable.ndarray( true, 2, A, 2, 1, 0, out, 2, 1, 0 ); // $ExpectError + gsummedAreaTable.ndarray( false, 2, A, 2, 1, 0, out, 2, 1, 0 ); // $ExpectError + gsummedAreaTable.ndarray( null, 2, A, 2, 1, 0, out, 2, 1, 0 ); // $ExpectError + gsummedAreaTable.ndarray( undefined, 2, A, 2, 1, 0, out, 2, 1, 0 ); // $ExpectError + gsummedAreaTable.ndarray( [], 2, A, 2, 1, 0, out, 2, 1, 0 ); // $ExpectError + gsummedAreaTable.ndarray( {}, 2, A, 2, 1, 0, out, 2, 1, 0 ); // $ExpectError + gsummedAreaTable.ndarray( ( x: number ): number => x, 2, A, 2, 1, 0, out, 2, 1, 0 ); // $ExpectError +} + +// The compiler throws an error if the `ndarray` method is provided a second argument which is not a number... +{ + const A = new Float64Array( [ 1.0, 2.0, 3.0, 4.0 ] ); + const out = new Float64Array( [ 0.0, 0.0, 0.0, 0.0 ] ); + + gsummedAreaTable.ndarray( 2, '2', A, 2, 1, 0, out, 2, 1, 0 ); // $ExpectError + gsummedAreaTable.ndarray( 2, true, A, 2, 1, 0, out, 2, 1, 0 ); // $ExpectError + gsummedAreaTable.ndarray( 2, false, A, 2, 1, 0, out, 2, 1, 0 ); // $ExpectError + gsummedAreaTable.ndarray( 2, null, A, 2, 1, 0, out, 2, 1, 0 ); // $ExpectError + gsummedAreaTable.ndarray( 2, undefined, A, 2, 1, 0, out, 2, 1, 0 ); // $ExpectError + gsummedAreaTable.ndarray( 2, [], A, 2, 1, 0, out, 2, 1, 0 ); // $ExpectError + gsummedAreaTable.ndarray( 2, {}, A, 2, 1, 0, out, 2, 1, 0 ); // $ExpectError + gsummedAreaTable.ndarray( 2, ( x: number ): number => x, A, 2, 1, 0, out, 2, 1, 0 ); // $ExpectError +} + +// The compiler throws an error if the `ndarray` method is provided a third argument which is not a numeric array... +{ + const out = new Float64Array( [ 0.0, 0.0, 0.0, 0.0 ] ); + + gsummedAreaTable.ndarray( 2, 2, '2', 2, 1, 0, out, 2, 1, 0 ); // $ExpectError + gsummedAreaTable.ndarray( 2, 2, true, 2, 1, 0, out, 2, 1, 0 ); // $ExpectError + gsummedAreaTable.ndarray( 2, 2, false, 2, 1, 0, out, 2, 1, 0 ); // $ExpectError + gsummedAreaTable.ndarray( 2, 2, null, 2, 1, 0, out, 2, 1, 0 ); // $ExpectError + gsummedAreaTable.ndarray( 2, 2, undefined, 2, 1, 0, out, 2, 1, 0 ); // $ExpectError + gsummedAreaTable.ndarray( 2, 2, [ '1' ], 2, 1, 0, out, 2, 1, 0 ); // $ExpectError + gsummedAreaTable.ndarray( 2, 2, {}, 2, 1, 0, out, 2, 1, 0 ); // $ExpectError + gsummedAreaTable.ndarray( 2, 2, ( x: number ): number => x, 2, 1, 0, out, 2, 1, 0 ); // $ExpectError +} + +// The compiler throws an error if the `ndarray` method is provided a fourth argument which is not a number... +{ + const A = new Float64Array( [ 1.0, 2.0, 3.0, 4.0 ] ); + const out = new Float64Array( [ 0.0, 0.0, 0.0, 0.0 ] ); + + gsummedAreaTable.ndarray( 2, 2, A, '2', 1, 0, out, 2, 1, 0 ); // $ExpectError + gsummedAreaTable.ndarray( 2, 2, A, true, 1, 0, out, 2, 1, 0 ); // $ExpectError + gsummedAreaTable.ndarray( 2, 2, A, false, 1, 0, out, 2, 1, 0 ); // $ExpectError + gsummedAreaTable.ndarray( 2, 2, A, null, 1, 0, out, 2, 1, 0 ); // $ExpectError + gsummedAreaTable.ndarray( 2, 2, A, undefined, 1, 0, out, 2, 1, 0 ); // $ExpectError + gsummedAreaTable.ndarray( 2, 2, A, [], 1, 0, out, 2, 1, 0 ); // $ExpectError + gsummedAreaTable.ndarray( 2, 2, A, {}, 1, 0, out, 2, 1, 0 ); // $ExpectError + gsummedAreaTable.ndarray( 2, 2, A, ( x: number ): number => x, 1, 0, out, 2, 1, 0 ); // $ExpectError +} + +// The compiler throws an error if the `ndarray` method is provided a fifth argument which is not a number... +{ + const A = new Float64Array( [ 1.0, 2.0, 3.0, 4.0 ] ); + const out = new Float64Array( [ 0.0, 0.0, 0.0, 0.0 ] ); + + gsummedAreaTable.ndarray( 2, 2, A, 2, '1', 0, out, 2, 1, 0 ); // $ExpectError + gsummedAreaTable.ndarray( 2, 2, A, 2, true, 0, out, 2, 1, 0 ); // $ExpectError + gsummedAreaTable.ndarray( 2, 2, A, 2, false, 0, out, 2, 1, 0 ); // $ExpectError + gsummedAreaTable.ndarray( 2, 2, A, 2, null, 0, out, 2, 1, 0 ); // $ExpectError + gsummedAreaTable.ndarray( 2, 2, A, 2, undefined, 0, out, 2, 1, 0 ); // $ExpectError + gsummedAreaTable.ndarray( 2, 2, A, 2, [], 0, out, 2, 1, 0 ); // $ExpectError + gsummedAreaTable.ndarray( 2, 2, A, 2, {}, 0, out, 2, 1, 0 ); // $ExpectError + gsummedAreaTable.ndarray( 2, 2, A, 2, ( x: number ): number => x, 0, out, 2, 1, 0 ); // $ExpectError +} + +// The compiler throws an error if the `ndarray` method is provided a sixth argument which is not a number... +{ + const A = new Float64Array( [ 1.0, 2.0, 3.0, 4.0 ] ); + const out = new Float64Array( [ 0.0, 0.0, 0.0, 0.0 ] ); + + gsummedAreaTable.ndarray( 2, 2, A, 2, 1, '0', out, 2, 1, 0 ); // $ExpectError + gsummedAreaTable.ndarray( 2, 2, A, 2, 1, true, out, 2, 1, 0 ); // $ExpectError + gsummedAreaTable.ndarray( 2, 2, A, 2, 1, false, out, 2, 1, 0 ); // $ExpectError + gsummedAreaTable.ndarray( 2, 2, A, 2, 1, null, out, 2, 1, 0 ); // $ExpectError + gsummedAreaTable.ndarray( 2, 2, A, 2, 1, undefined, out, 2, 1, 0 ); // $ExpectError + gsummedAreaTable.ndarray( 2, 2, A, 2, 1, [], out, 2, 1, 0 ); // $ExpectError + gsummedAreaTable.ndarray( 2, 2, A, 2, 1, {}, out, 2, 1, 0 ); // $ExpectError + gsummedAreaTable.ndarray( 2, 2, A, 2, 1, ( x: number ): number => x, out, 2, 1, 0 ); // $ExpectError +} + +// The compiler throws an error if the `ndarray` method is provided a seventh argument which is not a numeric array... +{ + const A = new Float64Array( [ 1.0, 2.0, 3.0, 4.0 ] ); + + gsummedAreaTable.ndarray( 2, 2, A, 2, 1, 0, '2', 2, 1, 0 ); // $ExpectError + gsummedAreaTable.ndarray( 2, 2, A, 2, 1, 0, true, 2, 1, 0 ); // $ExpectError + gsummedAreaTable.ndarray( 2, 2, A, 2, 1, 0, false, 2, 1, 0 ); // $ExpectError + gsummedAreaTable.ndarray( 2, 2, A, 2, 1, 0, null, 2, 1, 0 ); // $ExpectError + gsummedAreaTable.ndarray( 2, 2, A, 2, 1, 0, undefined, 2, 1, 0 ); // $ExpectError + gsummedAreaTable.ndarray( 2, 2, A, 2, 1, 0, [ '1' ], 2, 1, 0 ); // $ExpectError + gsummedAreaTable.ndarray( 2, 2, A, 2, 1, 0, {}, 2, 1, 0 ); // $ExpectError + gsummedAreaTable.ndarray( 2, 2, A, 2, 1, 0, ( x: number ): number => x, 2, 1, 0 ); // $ExpectError +} + +// The compiler throws an error if the `ndarray` method is provided an eighth argument which is not a number... +{ + const A = new Float64Array( [ 1.0, 2.0, 3.0, 4.0 ] ); + const out = new Float64Array( [ 0.0, 0.0, 0.0, 0.0 ] ); + + gsummedAreaTable.ndarray( 2, 2, A, 2, 1, 0, out, '2', 1, 0 ); // $ExpectError + gsummedAreaTable.ndarray( 2, 2, A, 2, 1, 0, out, true, 1, 0 ); // $ExpectError + gsummedAreaTable.ndarray( 2, 2, A, 2, 1, 0, out, false, 1, 0 ); // $ExpectError + gsummedAreaTable.ndarray( 2, 2, A, 2, 1, 0, out, null, 1, 0 ); // $ExpectError + gsummedAreaTable.ndarray( 2, 2, A, 2, 1, 0, out, undefined, 1, 0 ); // $ExpectError + gsummedAreaTable.ndarray( 2, 2, A, 2, 1, 0, out, [], 1, 0 ); // $ExpectError + gsummedAreaTable.ndarray( 2, 2, A, 2, 1, 0, out, {}, 1, 0 ); // $ExpectError + gsummedAreaTable.ndarray( 2, 2, A, 2, 1, 0, out, ( x: number ): number => x, 1, 0 ); // $ExpectError +} + +// The compiler throws an error if the `ndarray` method is provided a ninth argument which is not a number... +{ + const A = new Float64Array( [ 1.0, 2.0, 3.0, 4.0 ] ); + const out = new Float64Array( [ 0.0, 0.0, 0.0, 0.0 ] ); + + gsummedAreaTable.ndarray( 2, 2, A, 2, 1, 0, out, 2, '1', 0 ); // $ExpectError + gsummedAreaTable.ndarray( 2, 2, A, 2, 1, 0, out, 2, true, 0 ); // $ExpectError + gsummedAreaTable.ndarray( 2, 2, A, 2, 1, 0, out, 2, false, 0 ); // $ExpectError + gsummedAreaTable.ndarray( 2, 2, A, 2, 1, 0, out, 2, null, 0 ); // $ExpectError + gsummedAreaTable.ndarray( 2, 2, A, 2, 1, 0, out, 2, undefined, 0 ); // $ExpectError + gsummedAreaTable.ndarray( 2, 2, A, 2, 1, 0, out, 2, [], 0 ); // $ExpectError + gsummedAreaTable.ndarray( 2, 2, A, 2, 1, 0, out, 2, {}, 0 ); // $ExpectError + gsummedAreaTable.ndarray( 2, 2, A, 2, 1, 0, out, 2, ( x: number ): number => x, 0 ); // $ExpectError +} + +// The compiler throws an error if the `ndarray` method is provided a tenth argument which is not a number... +{ + const A = new Float64Array( [ 1.0, 2.0, 3.0, 4.0 ] ); + const out = new Float64Array( [ 0.0, 0.0, 0.0, 0.0 ] ); + + gsummedAreaTable.ndarray( 2, 2, A, 2, 1, 0, out, 2, 1, '0' ); // $ExpectError + gsummedAreaTable.ndarray( 2, 2, A, 2, 1, 0, out, 2, 1, true ); // $ExpectError + gsummedAreaTable.ndarray( 2, 2, A, 2, 1, 0, out, 2, 1, false ); // $ExpectError + gsummedAreaTable.ndarray( 2, 2, A, 2, 1, 0, out, 2, 1, null ); // $ExpectError + gsummedAreaTable.ndarray( 2, 2, A, 2, 1, 0, out, 2, 1, undefined ); // $ExpectError + gsummedAreaTable.ndarray( 2, 2, A, 2, 1, 0, out, 2, 1, [] ); // $ExpectError + gsummedAreaTable.ndarray( 2, 2, A, 2, 1, 0, out, 2, 1, {} ); // $ExpectError + gsummedAreaTable.ndarray( 2, 2, A, 2, 1, 0, out, 2, 1, ( x: number ): number => x ); // $ExpectError +} + +// The compiler throws an error if the `ndarray` method is provided an unsupported number of arguments... +{ + const A = new Float64Array( [ 1.0, 2.0, 3.0, 4.0 ] ); + const out = new Float64Array( [ 0.0, 0.0, 0.0, 0.0 ] ); + + gsummedAreaTable.ndarray(); // $ExpectError + gsummedAreaTable.ndarray( 2 ); // $ExpectError + gsummedAreaTable.ndarray( 2, 2 ); // $ExpectError + gsummedAreaTable.ndarray( 2, 2, A ); // $ExpectError + gsummedAreaTable.ndarray( 2, 2, A, 2 ); // $ExpectError + gsummedAreaTable.ndarray( 2, 2, A, 2, 1 ); // $ExpectError + gsummedAreaTable.ndarray( 2, 2, A, 2, 1, 0 ); // $ExpectError + gsummedAreaTable.ndarray( 2, 2, A, 2, 1, 0, out ); // $ExpectError + gsummedAreaTable.ndarray( 2, 2, A, 2, 1, 0, out, 2 ); // $ExpectError + gsummedAreaTable.ndarray( 2, 2, A, 2, 1, 0, out, 2, 1 ); // $ExpectError + gsummedAreaTable.ndarray( 2, 2, A, 2, 1, 0, out, 2, 1, 0, {} ); // $ExpectError +} diff --git a/lib/node_modules/@stdlib/blas/ext/base/gsummed-area-table/examples/index.js b/lib/node_modules/@stdlib/blas/ext/base/gsummed-area-table/examples/index.js new file mode 100644 index 000000000000..3d2d6db85fd2 --- /dev/null +++ b/lib/node_modules/@stdlib/blas/ext/base/gsummed-area-table/examples/index.js @@ -0,0 +1,33 @@ +/** +* @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 discreteUniform = require( '@stdlib/random/array/discrete-uniform' ); +var Float64Array = require( '@stdlib/array/float64' ); +var gsummedAreaTable = require( './../lib' ); + +var A = discreteUniform( 6, 1, 10, { + 'dtype': 'float64' +}); +console.log( A ); + +var out = new Float64Array( 6 ); + +gsummedAreaTable( 'row-major', 2, 3, A, 3, out, 3 ); +console.log( out ); diff --git a/lib/node_modules/@stdlib/blas/ext/base/gsummed-area-table/lib/accessors.js b/lib/node_modules/@stdlib/blas/ext/base/gsummed-area-table/lib/accessors.js new file mode 100644 index 000000000000..d94fd58e4a77 --- /dev/null +++ b/lib/node_modules/@stdlib/blas/ext/base/gsummed-area-table/lib/accessors.js @@ -0,0 +1,118 @@ +/** +* @license Apache-2.0 +* +* Copyright (c) 2026 The Stdlib Authors. +* +* Licensed under the Apache License, Version 2.0 (the "License"); +* you may not use this file except in compliance with the License. +* You may obtain a copy of the License at +* +* http://www.apache.org/licenses/LICENSE-2.0 +* +* Unless required by applicable law or agreed to in writing, software +* distributed under the License is distributed on an "AS IS" BASIS, +* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +* See the License for the specific language governing permissions and +* limitations under the License. +*/ + +'use strict'; + +// MODULES // + +var gcusumors = require( '@stdlib/blas/ext/base/gcusumors' ).ndarray; +var isColumnMajor = require( '@stdlib/ndarray/base/assert/is-column-major' ); + + +// MAIN // + +/** +* Computes a summed-area table for a matrix using accessor arrays. +* +* @private +* @param {PositiveInteger} M - number of rows in `A` +* @param {PositiveInteger} N - number of columns in `A` +* @param {Object} A - input matrix object +* @param {Collection} A.data - input matrix data +* @param {Array} A.accessors - array element accessors +* @param {integer} strideA1 - stride length of first dimension of `A` +* @param {integer} strideA2 - stride length of second dimension of `A` +* @param {NonNegativeInteger} offsetA - starting index for `A` +* @param {Object} out - output matrix object +* @param {Collection} out.data - output matrix data +* @param {Array} out.accessors - array element accessors +* @param {integer} strideOut1 - stride length of first dimension of `out` +* @param {integer} strideOut2 - stride length of second dimension of `out` +* @param {NonNegativeInteger} offsetOut - starting index for `out` +* @returns {Object} output matrix object +* +* @example +* var toAccessorArray = require( '@stdlib/array/base/to-accessor-array' ); +* var arraylike2object = require( '@stdlib/array/base/arraylike2object' ); +* +* var A = [ 1, 2, 3, 4 ]; +* var out = [ 0, 0, 0, 0 ]; +* +* accessors( 2, 2, arraylike2object( toAccessorArray( A ) ), 2, 1, 0, arraylike2object( toAccessorArray( out ) ), 2, 1, 0 ); +* // out => [ 1, 3, 4, 10 ] +*/ +function accessors( M, N, A, strideA1, strideA2, offsetA, out, strideOut1, strideOut2, offsetOut ) { // eslint-disable-line max-len + var obuf; + var oset; + var oget; + var abuf; + var aget; + var io; + var ia; + var i; + var j; + var v; + + // Cache references to array data: + abuf = A.data; + obuf = out.data; + + // Cache references to element accessors: + aget = A.accessors[ 0 ]; + oget = out.accessors[ 0 ]; + oset = out.accessors[ 1 ]; + + // Compute cumulative sum of first row: + gcusumors( N, 0.0, abuf, strideA2, offsetA, obuf, strideOut2, offsetOut ); + + // Compute cumulative sum of first column: + gcusumors( M - 1, oget( obuf, offsetOut ), abuf, strideA1, offsetA + strideA1, obuf, strideOut1, offsetOut + strideOut1 ); // eslint-disable-line max-len + + // Process remaining elements: + if ( isColumnMajor( [ strideOut1, strideOut2 ] ) ) { // Column-major + for ( j = 1; j < N; j++ ) { + for ( i = 1; i < M; i++ ) { + ia = offsetA + ( i * strideA1 ); + io = offsetOut + ( i * strideOut1 ); + v = aget( abuf, ia + ( j * strideA2 ) ) + + oget( obuf, io + ( ( j - 1 ) * strideOut2 ) ) + + oget( obuf, ( io - strideOut1 ) + ( j * strideOut2 ) ) - + oget( obuf, ( io - strideOut1 ) + ( ( j - 1 ) * strideOut2 ) ); // eslint-disable-line max-len + oset( obuf, io + ( j * strideOut2 ), v ); + } + } + } else { // Row-major + for ( i = 1; i < M; i++ ) { + ia = offsetA + ( i * strideA1 ); + io = offsetOut + ( i * strideOut1 ); + for ( j = 1; j < N; j++ ) { + v = aget( abuf, ia + ( j * strideA2 ) ) + + oget( obuf, io + ( ( j - 1 ) * strideOut2 ) ) + + oget( obuf, ( io - strideOut1 ) + ( j * strideOut2 ) ) - + oget( obuf, ( io - strideOut1 ) + ( ( j - 1 ) * strideOut2 ) ); // eslint-disable-line max-len + oset( obuf, io + ( j * strideOut2 ), v ); + } + } + } + return out; +} + + +// EXPORTS // + +module.exports = accessors; diff --git a/lib/node_modules/@stdlib/blas/ext/base/gsummed-area-table/lib/index.js b/lib/node_modules/@stdlib/blas/ext/base/gsummed-area-table/lib/index.js new file mode 100644 index 000000000000..7da5033dba7e --- /dev/null +++ b/lib/node_modules/@stdlib/blas/ext/base/gsummed-area-table/lib/index.js @@ -0,0 +1,59 @@ +/** +* @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'; + +/** +* Compute a summed-area table for a matrix. +* +* @module @stdlib/blas/ext/base/gsummed-area-table +* +* @example +* var gsummedAreaTable = require( '@stdlib/blas/ext/base/gsummed-area-table' ); +* +* var A = [ 1, 2, 3, 4 ]; +* var out = [ 0, 0, 0, 0 ]; +* +* gsummedAreaTable( 'row-major', 2, 2, A, 2, out, 2 ); +* // out => [ 1, 3, 4, 10 ] +* +* @example +* var gsummedAreaTable = require( '@stdlib/blas/ext/base/gsummed-area-table' ); +* +* var A = [ 1, 2, 3, 4 ]; +* var out = [ 0, 0, 0, 0 ]; +* +* gsummedAreaTable.ndarray( 2, 2, A, 2, 1, 0, out, 2, 1, 0 ); +* // out => [ 1, 3, 4, 10 ] +*/ + +// MODULES // + +var setReadOnly = require( '@stdlib/utils/define-nonenumerable-read-only-property' ); +var main = require( './main.js' ); +var ndarray = require( './ndarray.js' ); + + +// MAIN // + +setReadOnly( main, 'ndarray', ndarray ); + + +// EXPORTS // + +module.exports = main; diff --git a/lib/node_modules/@stdlib/blas/ext/base/gsummed-area-table/lib/main.js b/lib/node_modules/@stdlib/blas/ext/base/gsummed-area-table/lib/main.js new file mode 100644 index 000000000000..269a1806c0a8 --- /dev/null +++ b/lib/node_modules/@stdlib/blas/ext/base/gsummed-area-table/lib/main.js @@ -0,0 +1,86 @@ +/** +* @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 max = require( '@stdlib/math/base/special/fast/max' ); +var format = require( '@stdlib/string/format' ); +var ndarray = require( './ndarray.js' ); + + +// MAIN // + +/** +* Computes a summed-area table for a matrix. +* +* @param {string} order - memory layout order ('row-major' or 'column-major') +* @param {PositiveInteger} M - number of rows in `A` +* @param {PositiveInteger} N - number of columns in `A` +* @param {NumericArray} A - input matrix +* @param {integer} LDA - stride length between successive contiguous vectors of `A` (leading dimension of `A`) +* @param {NumericArray} out - output matrix +* @param {integer} LDO - stride length between successive contiguous vectors of `out` (leading dimension of `out`) +* @throws {TypeError} first argument must be a valid order +* @throws {RangeError} fifth argument must be greater than or equal to max(1,N) +* @throws {RangeError} seventh argument must be greater than or equal to max(1,N) +* @returns {NumericArray} output matrix +* +* @example +* var A = [ 1, 2, 3, 4 ]; +* var out = [ 0, 0, 0, 0 ]; +* +* gsummedAreaTable( 'row-major', 2, 2, A, 2, out, 2 ); +* // out => [ 1, 3, 4, 10 ] +*/ +function gsummedAreaTable( order, M, N, A, LDA, out, LDO ) { + var strideOut1; + var strideOut2; + var strideA1; + var strideA2; + var s; + + if ( order === 'row-major' ) { + s = N; + strideA1 = LDA; + strideA2 = 1; + strideOut1 = LDO; + strideOut2 = 1; + } else if ( order === 'column-major' ) { + s = M; + strideA1 = 1; + strideA2 = LDA; + strideOut1 = 1; + strideOut2 = LDO; + } else { + throw new TypeError( format( 'invalid argument. First argument must be a valid order. Value: `%s`.', order ) ); + } + if ( LDA < max( 1, s ) ) { + throw new RangeError( format( 'invalid argument. Fifth argument must be greater than or equal to max(1,%d). Value: `%d`.', s, LDA ) ); + } + if ( LDO < max( 1, s ) ) { + throw new RangeError( format( 'invalid argument. Seventh argument must be greater than or equal to max(1,%d). Value: `%d`.', s, LDO ) ); + } + return ndarray( M, N, A, strideA1, strideA2, 0, out, strideOut1, strideOut2, 0 ); // eslint-disable-line max-len +} + + +// EXPORTS // + +module.exports = gsummedAreaTable; diff --git a/lib/node_modules/@stdlib/blas/ext/base/gsummed-area-table/lib/ndarray.js b/lib/node_modules/@stdlib/blas/ext/base/gsummed-area-table/lib/ndarray.js new file mode 100644 index 000000000000..bf1e93f07733 --- /dev/null +++ b/lib/node_modules/@stdlib/blas/ext/base/gsummed-area-table/lib/ndarray.js @@ -0,0 +1,106 @@ +/** +* @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 gcusumors = require( '@stdlib/blas/ext/base/gcusumors' ).ndarray; +var arraylike2object = require( '@stdlib/array/base/arraylike2object' ); +var isColumnMajor = require( '@stdlib/ndarray/base/assert/is-column-major' ); +var accessors = require( './accessors.js' ); + + +// MAIN // + +/** +* Computes a summed-area table for a matrix using alternative indexing semantics. +* +* @param {PositiveInteger} M - number of rows in `A` +* @param {PositiveInteger} N - number of columns in `A` +* @param {NumericArray} A - input matrix +* @param {integer} strideA1 - stride length of first dimension of `A` +* @param {integer} strideA2 - stride length of second dimension of `A` +* @param {NonNegativeInteger} offsetA - starting index for `A` +* @param {NumericArray} out - output matrix +* @param {integer} strideOut1 - stride length of first dimension of `out` +* @param {integer} strideOut2 - stride length of second dimension of `out` +* @param {NonNegativeInteger} offsetOut - starting index for `out` +* @returns {NumericArray} output matrix +* +* @example +* var A = [ 1, 2, 3, 4 ]; +* var out = [ 0, 0, 0, 0 ]; +* +* gsummedAreaTable( 2, 2, A, 2, 1, 0, out, 2, 1, 0 ); +* // out => [ 1, 3, 4, 10 ] +*/ +function gsummedAreaTable( M, N, A, strideA1, strideA2, offsetA, out, strideOut1, strideOut2, offsetOut ) { // eslint-disable-line max-len + var oa; + var oo; + var ia; + var io; + var i; + var j; + + if ( M <= 0 || N <= 0 ) { + return out; + } + oa = arraylike2object( A ); + oo = arraylike2object( out ); + if ( oa.accessorProtocol || oo.accessorProtocol ) { + return accessors( M, N, oa, strideA1, strideA2, offsetA, oo, strideOut1, strideOut2, offsetOut ); // eslint-disable-line max-len + } + + // Compute cumulative sum of first row: + gcusumors( N, 0.0, A, strideA2, offsetA, out, strideOut2, offsetOut ); + + // Compute cumulative sum of first column: + gcusumors( M - 1, out[ offsetOut ], A, strideA1, offsetA + strideA1, out, strideOut1, offsetOut + strideOut1 ); // eslint-disable-line max-len + + // Process remaining elements... + if ( isColumnMajor( [ strideOut1, strideOut2 ] ) ) { // Column-major + for ( j = 1; j < N; j++ ) { + for ( i = 1; i < M; i++ ) { + ia = offsetA + ( i * strideA1 ); + io = offsetOut + ( i * strideOut1 ); + out[ io + ( j * strideOut2 ) ] = A[ ia + ( j * strideA2 ) ] + + out[ io + ( ( j - 1 ) * strideOut2 ) ] + + out[ ( io - strideOut1 ) + ( j * strideOut2 ) ] - + out[ ( io - strideOut1 ) + ( ( j - 1 ) * strideOut2 ) ]; + } + } + } else { // Row-major + for ( i = 1; i < M; i++ ) { + ia = offsetA + ( i * strideA1 ); + io = offsetOut + ( i * strideOut1 ); + for ( j = 1; j < N; j++ ) { + out[ io + ( j * strideOut2 ) ] = A[ ia + ( j * strideA2 ) ] + + out[ io + ( ( j - 1 ) * strideOut2 ) ] + + out[ ( io - strideOut1 ) + ( j * strideOut2 ) ] - + out[ ( io - strideOut1 ) + ( ( j - 1 ) * strideOut2 ) ]; + } + } + } + return out; +} + + +// EXPORTS // + +module.exports = gsummedAreaTable; diff --git a/lib/node_modules/@stdlib/blas/ext/base/gsummed-area-table/package.json b/lib/node_modules/@stdlib/blas/ext/base/gsummed-area-table/package.json new file mode 100644 index 000000000000..d950a29eb2dc --- /dev/null +++ b/lib/node_modules/@stdlib/blas/ext/base/gsummed-area-table/package.json @@ -0,0 +1,66 @@ +{ + "name": "@stdlib/blas/ext/base/gsummed-area-table", + "version": "0.0.0", + "description": "Compute a summed-area table for a matrix.", + "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", + "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", + "blas", + "extended", + "summed-area-table", + "integral-image", + "matrix", + "strided", + "array", + "ndarray" + ], + "__stdlib__": {} +} diff --git a/lib/node_modules/@stdlib/blas/ext/base/gsummed-area-table/test/test.js b/lib/node_modules/@stdlib/blas/ext/base/gsummed-area-table/test/test.js new file mode 100644 index 000000000000..311ecce30671 --- /dev/null +++ b/lib/node_modules/@stdlib/blas/ext/base/gsummed-area-table/test/test.js @@ -0,0 +1,38 @@ +/** +* @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 gsummedAreaTable = require( './../lib' ); + + +// TESTS // + +tape( 'main export is a function', function test( t ) { + t.ok( true, __filename ); + t.strictEqual( typeof gsummedAreaTable, '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 gsummedAreaTable.ndarray, 'function', 'method is a function' ); + t.end(); +}); diff --git a/lib/node_modules/@stdlib/blas/ext/base/gsummed-area-table/test/test.main.js b/lib/node_modules/@stdlib/blas/ext/base/gsummed-area-table/test/test.main.js new file mode 100644 index 000000000000..23a73b8d186d --- /dev/null +++ b/lib/node_modules/@stdlib/blas/ext/base/gsummed-area-table/test/test.main.js @@ -0,0 +1,356 @@ +/** +* @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 toAccessorArray = require( '@stdlib/array/base/to-accessor-array' ); +var gsummedAreaTable = require( './../lib/main.js' ); + + +// TESTS // + +tape( 'main export is a function', function test( t ) { + t.ok( true, __filename ); + t.strictEqual( typeof gsummedAreaTable, 'function', 'main export is a function' ); + t.end(); +}); + +tape( 'the function has an arity of 7', function test( t ) { + t.strictEqual( gsummedAreaTable.length, 7, 'has expected arity' ); + t.end(); +}); + +tape( 'the function throws an error if provided a first argument which is not a valid order', function test( t ) { + var values; + var out; + var A; + var i; + + A = [ 1.0, 2.0, 3.0, 4.0 ]; + out = [ 0.0, 0.0, 0.0, 0.0 ]; + + values = [ + 'foo', + 'bar', + 'beep', + 'boop', + -5, + NaN, + true, + false, + null, + void 0, + [], + {}, + function noop() {} + ]; + + 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() { + gsummedAreaTable( value, 2, 2, A, 2, out, 2 ); + }; + } +}); + +tape( 'the function throws an error if provided a fifth argument which is not a valid `LDA` value (row-major)', function test( t ) { + var values; + var out; + var A; + var i; + + A = [ 1.0, 2.0, 3.0, 4.0 ]; + out = [ 0.0, 0.0, 0.0, 0.0 ]; + + values = [ + 0, + 1 + ]; + + for ( i = 0; i < values.length; i++ ) { + t.throws( badValue( values[ i ] ), RangeError, 'throws an error when provided ' + values[ i ] ); + } + t.end(); + + function badValue( value ) { + return function badValue() { + gsummedAreaTable( 'row-major', 2, 2, A, value, out, 2 ); + }; + } +}); + +tape( 'the function throws an error if provided a fifth argument which is not a valid `LDA` value (column-major)', function test( t ) { + var values; + var out; + var A; + var i; + + A = [ 1.0, 2.0, 3.0, 4.0 ]; + out = [ 0.0, 0.0, 0.0, 0.0 ]; + + values = [ + 0, + 1 + ]; + + for ( i = 0; i < values.length; i++ ) { + t.throws( badValue( values[ i ] ), RangeError, 'throws an error when provided ' + values[ i ] ); + } + t.end(); + + function badValue( value ) { + return function badValue() { + gsummedAreaTable( 'column-major', 2, 2, A, value, out, 2 ); + }; + } +}); + +tape( 'the function throws an error if provided a seventh argument which is not a valid `LDO` value (row-major)', function test( t ) { + var values; + var out; + var A; + var i; + + A = [ 1.0, 2.0, 3.0, 4.0 ]; + out = [ 0.0, 0.0, 0.0, 0.0 ]; + + values = [ + 0, + 1 + ]; + + for ( i = 0; i < values.length; i++ ) { + t.throws( badValue( values[ i ] ), RangeError, 'throws an error when provided ' + values[ i ] ); + } + t.end(); + + function badValue( value ) { + return function badValue() { + gsummedAreaTable( 'row-major', 2, 2, A, 2, out, value ); + }; + } +}); + +tape( 'the function throws an error if provided a seventh argument which is not a valid `LDO` value (column-major)', function test( t ) { + var values; + var out; + var A; + var i; + + A = [ 1.0, 2.0, 3.0, 4.0 ]; + out = [ 0.0, 0.0, 0.0, 0.0 ]; + + values = [ + 0, + 1 + ]; + + for ( i = 0; i < values.length; i++ ) { + t.throws( badValue( values[ i ] ), RangeError, 'throws an error when provided ' + values[ i ] ); + } + t.end(); + + function badValue( value ) { + return function badValue() { + gsummedAreaTable( 'column-major', 2, 2, A, 2, out, value ); + }; + } +}); + +tape( 'the function computes a summed-area table for a matrix (row-major)', function test( t ) { + var expected; + var out; + var A; + + A = [ 1.0, 2.0, 3.0, 4.0 ]; + out = [ 0.0, 0.0, 0.0, 0.0 ]; + expected = [ 1.0, 3.0, 4.0, 10.0 ]; + + gsummedAreaTable( 'row-major', 2, 2, A, 2, out, 2 ); + t.deepEqual( out, expected, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function computes a summed-area table for a matrix (row-major, accessors)', function test( t ) { + var expected; + var out; + var A; + + A = [ 1.0, 2.0, 3.0, 4.0 ]; + out = [ 0.0, 0.0, 0.0, 0.0 ]; + expected = [ 1.0, 3.0, 4.0, 10.0 ]; + + gsummedAreaTable( 'row-major', 2, 2, toAccessorArray( A ), 2, toAccessorArray( out ), 2 ); + t.deepEqual( out, expected, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function computes a summed-area table (column-major)', function test( t ) { + var expected; + var out; + var A; + + A = [ 1.0, 3.0, 2.0, 4.0 ]; + out = [ 0.0, 0.0, 0.0, 0.0 ]; + expected = [ 1.0, 4.0, 3.0, 10.0 ]; + + gsummedAreaTable( 'column-major', 2, 2, A, 2, out, 2 ); + t.deepEqual( out, expected, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function computes a summed-area table (column-major, accessors)', function test( t ) { + var expected; + var out; + var A; + + A = [ 1.0, 3.0, 2.0, 4.0 ]; + out = [ 0.0, 0.0, 0.0, 0.0 ]; + expected = [ 1.0, 4.0, 3.0, 10.0 ]; + + gsummedAreaTable( 'column-major', 2, 2, toAccessorArray( A ), 2, toAccessorArray( out ), 2 ); + t.deepEqual( out, expected, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function returns a reference to the output array', function test( t ) { + var result; + var out; + var A; + + A = [ 1.0, 2.0, 3.0, 4.0 ]; + out = [ 0.0, 0.0, 0.0, 0.0 ]; + result = gsummedAreaTable( 'row-major', 2, 2, A, 2, out, 2 ); + + t.strictEqual( result, out, 'same reference' ); + + t.end(); +}); + +tape( 'if `M` or `N` is less than or equal to `0`, the function returns the output unchanged', function test( t ) { + var expected; + var out; + var A; + + A = [ 1.0, 2.0, 3.0, 4.0 ]; + out = [ 1.0, 2.0, 3.0, 4.0 ]; + expected = [ 1.0, 2.0, 3.0, 4.0 ]; + + gsummedAreaTable( 'row-major', 0, 2, A, 2, out, 2 ); + t.deepEqual( out, expected, 'returns expected value' ); + + gsummedAreaTable( 'row-major', 2, 0, A, 2, out, 2 ); + t.deepEqual( out, expected, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function supports specifying a stride', function test( t ) { + var expected; + var out; + var A; + + A = [ + 1.0, // [0,0] + 2.0, // [0,1] + 0.0, + 0.0, + 3.0, // [1,0] + 4.0, // [1,1] + 0.0, + 0.0 + ]; + out = [ + 0.0, // [0,0] + 0.0, // [0,1] + 0.0, + 0.0, + 0.0, // [1,0] + 0.0, // [1,1] + 0.0, + 0.0 + ]; + expected = [ + 1.0, // [0,0] + 3.0, // [0,1] + 0.0, + 0.0, + 4.0, // [1,0] + 10.0, // [1,1] + 0.0, + 0.0 + ]; + + gsummedAreaTable( 'row-major', 2, 2, A, 4, out, 4 ); + t.deepEqual( out, expected, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function supports specifying a stride (accessors)', function test( t ) { + var expected; + var out; + var A; + + A = [ + 1.0, // [0,0] + 2.0, // [0,1] + 0.0, + 0.0, + 3.0, // [1,0] + 4.0, // [1,1] + 0.0, + 0.0 + ]; + out = [ + 0.0, // [0,0] + 0.0, // [0,1] + 0.0, + 0.0, + 0.0, // [1,0] + 0.0, // [1,1] + 0.0, + 0.0 + ]; + expected = [ + 1.0, // [0,0] + 3.0, // [0,1] + 0.0, + 0.0, + 4.0, // [1,0] + 10.0, // [1,1] + 0.0, + 0.0 + ]; + + gsummedAreaTable( 'row-major', 2, 2, toAccessorArray( A ), 4, toAccessorArray( out ), 4 ); + t.deepEqual( out, expected, 'returns expected value' ); + + t.end(); +}); diff --git a/lib/node_modules/@stdlib/blas/ext/base/gsummed-area-table/test/test.ndarray.js b/lib/node_modules/@stdlib/blas/ext/base/gsummed-area-table/test/test.ndarray.js new file mode 100644 index 000000000000..f708a71c5593 --- /dev/null +++ b/lib/node_modules/@stdlib/blas/ext/base/gsummed-area-table/test/test.ndarray.js @@ -0,0 +1,347 @@ +/** +* @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 toAccessorArray = require( '@stdlib/array/base/to-accessor-array' ); +var gsummedAreaTable = require( './../lib/ndarray.js' ); + + +// TESTS // + +tape( 'main export is a function', function test( t ) { + t.ok( true, __filename ); + t.strictEqual( typeof gsummedAreaTable, 'function', 'main export is a function' ); + t.end(); +}); + +tape( 'the function has an arity of 10', function test( t ) { + t.strictEqual( gsummedAreaTable.length, 10, 'has expected arity' ); + t.end(); +}); + +tape( 'the function computes a summed-area table for a matrix', function test( t ) { + var expected; + var out; + var A; + + A = [ 1.0, 2.0, 3.0, 4.0 ]; + out = [ 0.0, 0.0, 0.0, 0.0 ]; + expected = [ 1.0, 3.0, 4.0, 10.0 ]; + + gsummedAreaTable( 2, 2, A, 2, 1, 0, out, 2, 1, 0 ); + t.deepEqual( out, expected, 'returns expected value' ); + + A = [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0 ]; + out = [ 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0 ]; + expected = [ 1.0, 3.0, 6.0, 5.0, 12.0, 21.0, 12.0, 27.0, 45.0 ]; + + gsummedAreaTable( 3, 3, A, 3, 1, 0, out, 3, 1, 0 ); + t.deepEqual( out, expected, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function computes a summed-area table for a matrix (accessors)', function test( t ) { + var expected; + var out; + var A; + + A = [ 1.0, 2.0, 3.0, 4.0 ]; + out = [ 0.0, 0.0, 0.0, 0.0 ]; + expected = [ 1.0, 3.0, 4.0, 10.0 ]; + + gsummedAreaTable( 2, 2, toAccessorArray( A ), 2, 1, 0, toAccessorArray( out ), 2, 1, 0 ); + t.deepEqual( out, expected, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function returns a reference to the output array', function test( t ) { + var result; + var out; + var A; + + A = [ 1.0, 2.0, 3.0, 4.0 ]; + out = [ 0.0, 0.0, 0.0, 0.0 ]; + result = gsummedAreaTable( 2, 2, A, 2, 1, 0, out, 2, 1, 0 ); + + t.strictEqual( result, out, 'same reference' ); + t.end(); +}); + +tape( 'if `M` or `N` is less than or equal to `0`, the function returns the output unchanged', function test( t ) { + var expected; + var out; + var A; + + A = [ 1.0, 2.0, 3.0, 4.0 ]; + out = [ 1.0, 2.0, 3.0, 4.0 ]; + expected = [ 1.0, 2.0, 3.0, 4.0 ]; + + gsummedAreaTable( 0, 2, A, 2, 1, 0, out, 2, 1, 0 ); + t.deepEqual( out, expected, 'returns expected value' ); + + gsummedAreaTable( 2, 0, A, 2, 1, 0, out, 2, 1, 0 ); + t.deepEqual( out, expected, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function supports specifying a stride', function test( t ) { + var expected; + var out; + var A; + + A = [ + 1.0, // [0,0] + 2.0, // [0,1] + 0.0, + 0.0, + 3.0, // [1,0] + 4.0, // [1,1] + 0.0, + 0.0 + ]; + out = [ + 0.0, // [0,0] + 0.0, // [0,1] + 0.0, + 0.0, + 0.0, // [1,0] + 0.0, // [1,1] + 0.0, + 0.0 + ]; + expected = [ + 1.0, // [0,0] + 3.0, // [0,1] + 0.0, + 0.0, + 4.0, // [1,0] + 10.0, // [1,1] + 0.0, + 0.0 + ]; + + gsummedAreaTable( 2, 2, A, 4, 1, 0, out, 4, 1, 0 ); + t.deepEqual( out, expected, 'returns expected value' ); + t.end(); +}); + +tape( 'the function supports specifying a stride (accessors)', function test( t ) { + var expected; + var out; + var A; + + A = [ + 1.0, // [0,0] + 2.0, // [0,1] + 0.0, + 0.0, + 3.0, // [1,0] + 4.0, // [1,1] + 0.0, + 0.0 + ]; + out = [ + 0.0, // [0,0] + 0.0, // [0,1] + 0.0, + 0.0, + 0.0, // [1,0] + 0.0, // [1,1] + 0.0, + 0.0 + ]; + expected = [ + 1.0, // [0,0] + 3.0, // [0,1] + 0.0, + 0.0, + 4.0, // [1,0] + 10.0, // [1,1] + 0.0, + 0.0 + ]; + + gsummedAreaTable( 2, 2, toAccessorArray( A ), 4, 1, 0, toAccessorArray( out ), 4, 1, 0 ); + t.deepEqual( out, expected, 'returns expected value' ); + t.end(); +}); + +tape( 'the function supports specifying a negative stride', function test( t ) { + var expected; + var out; + var A; + + A = [ + 0.0, + 0.0, + 0.0, + 0.0, + 3.0, // [1,0] + 4.0, // [1,1] + 1.0, // [0,0] + 2.0 // [0,1] + ]; + out = [ + 0.0, + 0.0, + 0.0, + 0.0, + 0.0, // [1,0] + 0.0, // [1,1] + 0.0, // [0,0] + 0.0 // [0,1] + ]; + expected = [ + 0.0, + 0.0, + 0.0, + 0.0, + 4.0, // [1,0] + 10.0, // [1,1] + 1.0, // [0,0] + 3.0 // [0,1] + ]; + + gsummedAreaTable( 2, 2, A, -2, 1, 6, out, -2, 1, 6 ); + t.deepEqual( out, expected, 'returns expected value' ); + t.end(); +}); + +tape( 'the function supports specifying a negative stride (accessors)', function test( t ) { + var expected; + var out; + var A; + + A = [ + 0.0, + 0.0, + 0.0, + 0.0, + 3.0, // [1,0] + 4.0, // [1,1] + 1.0, // [0,0] + 2.0 // [0,1] + ]; + out = [ + 0.0, + 0.0, + 0.0, + 0.0, + 0.0, // [1,0] + 0.0, // [1,1] + 0.0, // [0,0] + 0.0 // [0,1] + ]; + expected = [ + 0.0, + 0.0, + 0.0, + 0.0, + 4.0, // [1,0] + 10.0, // [1,1] + 1.0, // [0,0] + 3.0 // [0,1] + ]; + + gsummedAreaTable( 2, 2, toAccessorArray( A ), -2, 1, 6, toAccessorArray( out ), -2, 1, 6 ); + t.deepEqual( out, expected, 'returns expected value' ); + t.end(); +}); + +tape( 'the function supports an offset parameter', function test( t ) { + var expected; + var out; + var A; + + A = [ + 0.0, + 0.0, + 0.0, + 1.0, // [0,0] + 2.0, // [0,1] + 3.0, // [1,0] + 4.0 // [1,1] + ]; + out = [ + 0.0, + 0.0, + 0.0, + 0.0, // [0,0] + 0.0, // [0,1] + 0.0, // [1,0] + 0.0 // [1,1] + ]; + expected = [ + 0.0, + 0.0, + 0.0, + 1.0, // [0,0] + 3.0, // [0,1] + 4.0, // [1,0] + 10.0 // [1,1] + ]; + + gsummedAreaTable( 2, 2, A, 2, 1, 3, out, 2, 1, 3 ); + t.deepEqual( out, expected, 'returns expected value' ); + t.end(); +}); + +tape( 'the function supports an offset parameter (accessors)', function test( t ) { + var expected; + var out; + var A; + + A = [ + 0.0, + 0.0, + 0.0, + 1.0, // [0,0] + 2.0, // [0,1] + 3.0, // [1,0] + 4.0 // [1,1] + ]; + out = [ + 0.0, + 0.0, + 0.0, + 0.0, // [0,0] + 0.0, // [0,1] + 0.0, // [1,0] + 0.0 // [1,1] + ]; + expected = [ + 0.0, + 0.0, + 0.0, + 1.0, // [0,0] + 3.0, // [0,1] + 4.0, // [1,0] + 10.0 // [1,1] + ]; + + gsummedAreaTable( 2, 2, toAccessorArray( A ), 2, 1, 3, toAccessorArray( out ), 2, 1, 3 ); + t.deepEqual( out, expected, 'returns expected value' ); + t.end(); +});