From 2477b905d23e8a02d652571cc26f9d3444573053 Mon Sep 17 00:00:00 2001 From: Benjamin Date: Fri, 2 Oct 2026 18:29:13 +0200 Subject: [PATCH] feat: add C implementation for blas/ext/base/ndarray/dcusumkbn Add the ndarray adapter and optional native bridge while preserving the adopted compensated prefix semantics and JavaScript fallback. Cover exact cancellation prefixes, aliases, scalar read order and configured integer widths. Assisted-by: OpenAI Codex --- .../blas/ext/base/ndarray/dcusumkbn/README.md | 167 ++++++++ .../dcusumkbn/benchmark/benchmark.native.js | 111 +++++ .../ndarray/dcusumkbn/benchmark/c/Makefile | 146 +++++++ .../ndarray/dcusumkbn/benchmark/c/benchmark.c | 152 +++++++ .../ext/base/ndarray/dcusumkbn/binding.gyp | 267 ++++++++++++ .../ndarray/dcusumkbn/examples/c/Makefile | 146 +++++++ .../ndarray/dcusumkbn/examples/c/example.c | 81 ++++ .../ext/base/ndarray/dcusumkbn/include.gypi | 53 +++ .../stdlib/blas/ext/base/ndarray/dcusumkbn.h | 42 ++ .../ndarray/dcusumkbn/lib/can_use_native.js | 73 ++++ .../ext/base/ndarray/dcusumkbn/lib/index.js | 8 +- .../ext/base/ndarray/dcusumkbn/lib/native.js | 100 +++++ .../ext/base/ndarray/dcusumkbn/manifest.json | 111 +++++ .../ext/base/ndarray/dcusumkbn/package.json | 8 +- .../ext/base/ndarray/dcusumkbn/src/Makefile | 70 ++++ .../ext/base/ndarray/dcusumkbn/src/addon.c | 126 ++++++ .../ext/base/ndarray/dcusumkbn/src/main.c | 92 ++++ .../test/fixtures/exact-prefixes.json | 395 ++++++++++++++++++ .../ndarray/dcusumkbn/test/test.native.js | 253 +++++++++++ 19 files changed, 2398 insertions(+), 3 deletions(-) create mode 100644 lib/node_modules/@stdlib/blas/ext/base/ndarray/dcusumkbn/benchmark/benchmark.native.js create mode 100644 lib/node_modules/@stdlib/blas/ext/base/ndarray/dcusumkbn/benchmark/c/Makefile create mode 100644 lib/node_modules/@stdlib/blas/ext/base/ndarray/dcusumkbn/benchmark/c/benchmark.c create mode 100644 lib/node_modules/@stdlib/blas/ext/base/ndarray/dcusumkbn/binding.gyp create mode 100644 lib/node_modules/@stdlib/blas/ext/base/ndarray/dcusumkbn/examples/c/Makefile create mode 100644 lib/node_modules/@stdlib/blas/ext/base/ndarray/dcusumkbn/examples/c/example.c create mode 100644 lib/node_modules/@stdlib/blas/ext/base/ndarray/dcusumkbn/include.gypi create mode 100644 lib/node_modules/@stdlib/blas/ext/base/ndarray/dcusumkbn/include/stdlib/blas/ext/base/ndarray/dcusumkbn.h create mode 100644 lib/node_modules/@stdlib/blas/ext/base/ndarray/dcusumkbn/lib/can_use_native.js create mode 100644 lib/node_modules/@stdlib/blas/ext/base/ndarray/dcusumkbn/lib/native.js create mode 100644 lib/node_modules/@stdlib/blas/ext/base/ndarray/dcusumkbn/manifest.json create mode 100644 lib/node_modules/@stdlib/blas/ext/base/ndarray/dcusumkbn/src/Makefile create mode 100644 lib/node_modules/@stdlib/blas/ext/base/ndarray/dcusumkbn/src/addon.c create mode 100644 lib/node_modules/@stdlib/blas/ext/base/ndarray/dcusumkbn/src/main.c create mode 100644 lib/node_modules/@stdlib/blas/ext/base/ndarray/dcusumkbn/test/fixtures/exact-prefixes.json create mode 100644 lib/node_modules/@stdlib/blas/ext/base/ndarray/dcusumkbn/test/test.native.js diff --git a/lib/node_modules/@stdlib/blas/ext/base/ndarray/dcusumkbn/README.md b/lib/node_modules/@stdlib/blas/ext/base/ndarray/dcusumkbn/README.md index 34e940b0cbc5..5071903dce2a 100644 --- a/lib/node_modules/@stdlib/blas/ext/base/ndarray/dcusumkbn/README.md +++ b/lib/node_modules/@stdlib/blas/ext/base/ndarray/dcusumkbn/README.md @@ -123,6 +123,173 @@ console.log( ndarray2array( v ) ); + + +* * * + +
+ +## C APIs + +
+ +
+ + + +
+ +### Usage + +```c +#include "stdlib/blas/ext/base/ndarray/dcusumkbn.h" +``` + +#### stdlib_blas_ext_dcusumkbn( arrays ) + +Computes the cumulative sum of a one-dimensional double-precision floating-point ndarray using an improved Kahan–Babuška algorithm. + +```c +#include "stdlib/ndarray/ctor.h" +#include "stdlib/ndarray/dtypes.h" +#include "stdlib/ndarray/index_modes.h" +#include "stdlib/ndarray/orders.h" +#include "stdlib/ndarray/base/bytes_per_element.h" +#include + +// Create one-dimensional input and output ndarrays: +const double dataX[] = { 1.0e16, 1.0, -1.0e16 }; +double dataY[] = { 0.0, 0.0, 0.0 }; +int64_t shape[] = { 3 }; +int64_t strides[] = { STDLIB_NDARRAY_FLOAT64_BYTES_PER_ELEMENT }; +int8_t submodes[] = { STDLIB_NDARRAY_INDEX_ERROR }; + +struct ndarray *x = stdlib_ndarray_allocate( STDLIB_NDARRAY_FLOAT64, (uint8_t *)dataX, 1, shape, strides, 0, STDLIB_NDARRAY_ROW_MAJOR, STDLIB_NDARRAY_INDEX_ERROR, 1, submodes ); +struct ndarray *y = stdlib_ndarray_allocate( STDLIB_NDARRAY_FLOAT64, (uint8_t *)dataY, 1, shape, strides, 0, STDLIB_NDARRAY_ROW_MAJOR, STDLIB_NDARRAY_INDEX_ERROR, 1, submodes ); + +// Create a zero-dimensional ndarray containing the initial sum: +const double dataInitial[] = { 0.0 }; +int64_t scalarStrides[] = { 0 }; +struct ndarray *initial = stdlib_ndarray_allocate( STDLIB_NDARRAY_FLOAT64, (uint8_t *)dataInitial, 0, NULL, scalarStrides, 0, STDLIB_NDARRAY_ROW_MAJOR, STDLIB_NDARRAY_INDEX_ERROR, 1, submodes ); + +// Perform computation: +const struct ndarray *arrays[] = { x, y, initial }; +stdlib_blas_ext_dcusumkbn( arrays ); +// dataY => { 1.0e16, 1.0e16, 1.0 } + +// Free allocated memory: +stdlib_ndarray_free( x ); +stdlib_ndarray_free( y ); +stdlib_ndarray_free( initial ); +``` + +The function accepts the following arguments: + +- **arrays**: `[in] const struct ndarray**` list containing the following ndarrays: + + - `[in] const struct ndarray*` a one-dimensional double-precision floating-point input ndarray. + - `[out] const struct ndarray*` a one-dimensional double-precision floating-point output ndarray. + - `[in] const struct ndarray*` a zero-dimensional double-precision floating-point ndarray containing the initial sum. + +```c +void stdlib_blas_ext_dcusumkbn( const struct ndarray *arrays[] ); +``` + +
+ + + +
+ +### Notes + +- The function writes cumulative sums to the output ndarray and returns no value. +- The input ndarray's length determines the number of elements to process. The caller must provide valid data buffers and an output ndarray containing at least that many elements. +- The function reads the initial sum at the zero-dimensional ndarray's own byte offset before writing output elements. +- If provided an empty input ndarray, the function leaves the output ndarray unchanged. +- The function supports positive, negative, and zero strides. Input and output buffers may overlap; each input element is read before the corresponding output element is written, following the existing strided cumulative-sum implementation's sequential semantics. +- Byte strides and byte offsets must be aligned for double-precision floating-point elements. Element strides, offsets, and all indexed and post-increment positions must be representable using the configured `CBLAS_INT` type. Invalid or unrepresentable ndarray metadata leaves the output ndarray unchanged. +- The implementation reuses the improved Kahan–Babuška algorithm described by Neumaier (1974). + +
+ + + +
+ +### Examples + +```c +#include "stdlib/blas/ext/base/ndarray/dcusumkbn.h" +#include "stdlib/ndarray/ctor.h" +#include "stdlib/ndarray/dtypes.h" +#include "stdlib/ndarray/index_modes.h" +#include "stdlib/ndarray/orders.h" +#include "stdlib/ndarray/base/bytes_per_element.h" +#include +#include +#include + +int main( void ) { + // Create data buffers: + const double dataX[] = { 1.0e16, 1.0, -1.0e16 }; + double dataY[] = { 0.0, 0.0, 0.0 }; + const double dataInitial[] = { 123.0, 0.0 }; + + // Specify the ndarray metadata: + int64_t shape[] = { 3 }; + int64_t strides[] = { STDLIB_NDARRAY_FLOAT64_BYTES_PER_ELEMENT }; + int64_t scalarStrides[] = { 0 }; + int8_t submodes[] = { STDLIB_NDARRAY_INDEX_ERROR }; + const enum STDLIB_NDARRAY_ORDER order = STDLIB_NDARRAY_ROW_MAJOR; + const enum STDLIB_NDARRAY_INDEX_MODE imode = STDLIB_NDARRAY_INDEX_ERROR; + + // Create one-dimensional input and output ndarrays: + struct ndarray *x = stdlib_ndarray_allocate( STDLIB_NDARRAY_FLOAT64, (uint8_t *)dataX, 1, shape, strides, 0, order, imode, 1, submodes ); + struct ndarray *y = stdlib_ndarray_allocate( STDLIB_NDARRAY_FLOAT64, (uint8_t *)dataY, 1, shape, strides, 0, order, imode, 1, submodes ); + + // Select an initial sum of zero at the scalar's own byte offset: + struct ndarray *initial = stdlib_ndarray_allocate( STDLIB_NDARRAY_FLOAT64, (uint8_t *)dataInitial, 0, NULL, scalarStrides, STDLIB_NDARRAY_FLOAT64_BYTES_PER_ELEMENT, order, imode, 1, submodes ); + int status = EXIT_SUCCESS; + if ( x == NULL || y == NULL || initial == NULL ) { + fprintf( stderr, "Error allocating ndarray descriptors.\n" ); + status = EXIT_FAILURE; + } else { + const struct ndarray *arrays[] = { x, y, initial }; + stdlib_blas_ext_dcusumkbn( arrays ); + + // Compensated summation retains the unit term after cancellation: + if ( dataY[ 0 ] != 1.0e16 || dataY[ 1 ] != 1.0e16 || dataY[ 2 ] != 1.0 ) { + fprintf( stderr, "Unexpected cumulative sum.\n" ); + status = EXIT_FAILURE; + } + for ( int i = 0; i < 3; i++ ) { + printf( "y[ %i ] = %.17g\n", i, dataY[ i ] ); + } + } + + // Free any successfully allocated descriptors: + if ( x != NULL ) { + stdlib_ndarray_free( x ); + } + if ( y != NULL ) { + stdlib_ndarray_free( y ); + } + if ( initial != NULL ) { + stdlib_ndarray_free( initial ); + } + return status; +} +``` + +
+ + + +
+ + +
diff --git a/lib/node_modules/@stdlib/blas/ext/base/ndarray/dcusumkbn/benchmark/benchmark.native.js b/lib/node_modules/@stdlib/blas/ext/base/ndarray/dcusumkbn/benchmark/benchmark.native.js new file mode 100644 index 000000000000..f6c3afcd62db --- /dev/null +++ b/lib/node_modules/@stdlib/blas/ext/base/ndarray/dcusumkbn/benchmark/benchmark.native.js @@ -0,0 +1,111 @@ +/** +* @license Apache-2.0 +* +* Copyright (c) 2025 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 resolve = require( 'path' ).resolve; +var bench = require( '@stdlib/bench' ); +var tryRequire = require( '@stdlib/utils/try-require' ); +var uniform = require( '@stdlib/random/uniform' ); +var Float64Vector = require( '@stdlib/ndarray/vector/float64' ); +var isnan = require( '@stdlib/math/base/assert/is-nan' ); +var pow = require( '@stdlib/math/base/special/pow' ); +var scalar2ndarray = require( '@stdlib/ndarray/from-scalar' ); +var format = require( '@stdlib/string/format' ); +var pkg = require( './../package.json' ).name; +var dcusumkbn = tryRequire( resolve( __dirname, './../lib/native.js' ) ); + + +// VARIABLES // + +var options = { + 'dtype': 'float64' +}; + + +// FUNCTIONS // + +/** +* Creates a benchmark function. +* +* @private +* @param {PositiveInteger} len - array length +* @returns {Function} benchmark function +*/ +function createBenchmark( len ) { + var initial = scalar2ndarray( 0.0, options ); + var x = uniform( [ len ], -10.0, 10.0, options ); + var y = new Float64Vector( len ); + return benchmark; + + /** + * Benchmark function. + * + * @private + * @param {Benchmark} b - benchmark instance + */ + function benchmark( b ) { + var v; + var i; + + b.tic(); + for ( i = 0; i < b.iterations; i++ ) { + v = dcusumkbn( [ x, y, initial ] ); + if ( typeof v !== 'object' ) { + b.fail( 'should return an ndarray' ); + } + } + b.toc(); + if ( isnan( v.get( i%len ) ) ) { + b.fail( 'should not return NaN' ); + } + b.pass( 'benchmark finished' ); + b.end(); + } +} + + +// MAIN // + +/** +* Main execution sequence. +* +* @private +*/ +function main() { + var len; + var min; + var max; + var f; + var i; + + min = 1; // 10^min + max = 6; // 10^max + + for ( i = min; i <= max; i++ ) { + len = pow( 10, i ); + f = createBenchmark( len ); + bench( format( '%s:len=%d,native', pkg, len ), { + 'skip': dcusumkbn instanceof Error + }, f ); + } +} + +main(); diff --git a/lib/node_modules/@stdlib/blas/ext/base/ndarray/dcusumkbn/benchmark/c/Makefile b/lib/node_modules/@stdlib/blas/ext/base/ndarray/dcusumkbn/benchmark/c/Makefile new file mode 100644 index 000000000000..0756dc7da20a --- /dev/null +++ b/lib/node_modules/@stdlib/blas/ext/base/ndarray/dcusumkbn/benchmark/c/Makefile @@ -0,0 +1,146 @@ +#/ +# @license Apache-2.0 +# +# Copyright (c) 2026 The Stdlib Authors. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +#/ + +# VARIABLES # + +ifndef VERBOSE + QUIET := @ +else + QUIET := +endif + +# Determine the OS ([1][1], [2][2]). +# +# [1]: https://en.wikipedia.org/wiki/Uname#Examples +# [2]: http://stackoverflow.com/a/27776822/2225624 +OS ?= $(shell uname) +ifneq (, $(findstring MINGW,$(OS))) + OS := WINNT +else +ifneq (, $(findstring MSYS,$(OS))) + OS := WINNT +else +ifneq (, $(findstring CYGWIN,$(OS))) + OS := WINNT +else +ifneq (, $(findstring Windows_NT,$(OS))) + OS := WINNT +endif +endif +endif +endif + +# Define the program used for compiling C source files: +ifdef C_COMPILER + CC := $(C_COMPILER) +else + CC := gcc +endif + +# Define the command-line options when compiling C files: +CFLAGS ?= \ + -std=c99 \ + -O3 \ + -Wall \ + -pedantic + +# Determine whether to generate position independent code ([1][1], [2][2]). +# +# [1]: https://gcc.gnu.org/onlinedocs/gcc/Code-Gen-Options.html#Code-Gen-Options +# [2]: http://stackoverflow.com/questions/5311515/gcc-fpic-option +ifeq ($(OS), WINNT) + fPIC ?= +else + fPIC ?= -fPIC +endif + +# List of includes (e.g., `-I /foo/bar -I /beep/boop/include`): +INCLUDE ?= + +# List of source files: +SOURCE_FILES ?= + +# List of libraries (e.g., `-lopenblas -lpthread`): +LIBRARIES ?= + +# List of library paths (e.g., `-L /foo/bar -L /beep/boop`): +LIBPATH ?= + +# List of C targets: +c_targets := benchmark.length.out + + +# RULES # + +#/ +# Compiles source files. +# +# @param {string} [C_COMPILER] - C compiler (e.g., `gcc`) +# @param {string} [CFLAGS] - C compiler options +# @param {(string|void)} [fPIC] - compiler flag determining whether to generate position independent code (e.g., `-fPIC`) +# @param {string} [INCLUDE] - list of includes (e.g., `-I /foo/bar -I /beep/boop/include`) +# @param {string} [SOURCE_FILES] - list of source files +# @param {string} [LIBPATH] - list of library paths (e.g., `-L /foo/bar -L /beep/boop`) +# @param {string} [LIBRARIES] - list of libraries (e.g., `-lopenblas -lpthread`) +# +# @example +# make +# +# @example +# make all +#/ +all: $(c_targets) + +.PHONY: all + +#/ +# Compiles C source files. +# +# @private +# @param {string} CC - C compiler (e.g., `gcc`) +# @param {string} CFLAGS - C compiler options +# @param {(string|void)} fPIC - compiler flag determining whether to generate position independent code (e.g., `-fPIC`) +# @param {string} INCLUDE - list of includes (e.g., `-I /foo/bar`) +# @param {string} SOURCE_FILES - list of source files +# @param {string} LIBPATH - list of library paths (e.g., `-L /foo/bar`) +# @param {string} LIBRARIES - list of libraries (e.g., `-lopenblas`) +#/ +$(c_targets): %.out: %.c + $(QUIET) $(CC) $(CFLAGS) $(fPIC) $(INCLUDE) -o $@ $(SOURCE_FILES) $< $(LIBPATH) -lm $(LIBRARIES) + +#/ +# Runs compiled benchmarks. +# +# @example +# make run +#/ +run: $(c_targets) + $(QUIET) ./$< + +.PHONY: run + +#/ +# Removes generated files. +# +# @example +# make clean +#/ +clean: + $(QUIET) -rm -f *.o *.out + +.PHONY: clean diff --git a/lib/node_modules/@stdlib/blas/ext/base/ndarray/dcusumkbn/benchmark/c/benchmark.c b/lib/node_modules/@stdlib/blas/ext/base/ndarray/dcusumkbn/benchmark/c/benchmark.c new file mode 100644 index 000000000000..7968b95f2b53 --- /dev/null +++ b/lib/node_modules/@stdlib/blas/ext/base/ndarray/dcusumkbn/benchmark/c/benchmark.c @@ -0,0 +1,152 @@ +/** +* @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. +*/ + +#include "stdlib/blas/ext/base/ndarray/dcusumkbn.h" +#include "stdlib/ndarray/ctor.h" +#include "stdlib/ndarray/dtypes.h" +#include "stdlib/ndarray/index_modes.h" +#include "stdlib/ndarray/orders.h" +#include "stdlib/ndarray/base/bytes_per_element.h" +#include +#include +#include +#include + +#define NAME "dcusumkbn" +#define ITERATIONS 1000 +#define REPEATS 2 + +/** +* Returns a clock time in seconds. +* +* @return clock time +*/ +static double tic( void ) { + struct timeval now; + gettimeofday( &now, NULL ); + return (double)now.tv_sec + (double)now.tv_usec/1.0e6; +} + +/** +* Runs a benchmark and validates the final cumulative sum. +* +* @param iterations number of iterations +* @param len array length +* @return elapsed time in seconds or -1 on failure +*/ +static double benchmark( const int iterations, const int len ) { + const enum STDLIB_NDARRAY_ORDER order = STDLIB_NDARRAY_ROW_MAJOR; + const enum STDLIB_NDARRAY_INDEX_MODE imode = STDLIB_NDARRAY_INDEX_ERROR; + int64_t shape[] = { len }; + int64_t strides[] = { STDLIB_NDARRAY_FLOAT64_BYTES_PER_ELEMENT }; + int64_t scalarStrides[] = { 0 }; + int8_t submodes[] = { STDLIB_NDARRAY_INDEX_ERROR }; + double dataInitial[] = { 0.0 }; + double elapsed = -1.0; + double t; + int i; + + double *dataX = (double *)malloc( (size_t)len * sizeof( double ) ); + double *dataY = (double *)malloc( (size_t)len * sizeof( double ) ); + if ( dataX == NULL || dataY == NULL ) { + fprintf( stderr, "Error allocating data buffers.\n" ); + free( dataX ); + free( dataY ); + return elapsed; + } + for ( i = 0; i < len; i++ ) { + dataX[ i ] = 1.0; + dataY[ i ] = 0.0; + } + + // cppcheck-suppress invalidPointerCast + struct ndarray *x = stdlib_ndarray_allocate( STDLIB_NDARRAY_FLOAT64, (uint8_t *)dataX, 1, shape, strides, 0, order, imode, 1, submodes ); + // cppcheck-suppress invalidPointerCast + struct ndarray *y = stdlib_ndarray_allocate( STDLIB_NDARRAY_FLOAT64, (uint8_t *)dataY, 1, shape, strides, 0, order, imode, 1, submodes ); + // cppcheck-suppress invalidPointerCast + struct ndarray *initial = stdlib_ndarray_allocate( STDLIB_NDARRAY_FLOAT64, (uint8_t *)dataInitial, 0, NULL, scalarStrides, 0, order, imode, 1, submodes ); + if ( x == NULL || y == NULL || initial == NULL ) { + fprintf( stderr, "Error allocating ndarray descriptors.\n" ); + } else { + const struct ndarray *arrays[] = { x, y, initial }; + t = tic(); + for ( i = 0; i < iterations; i++ ) { + stdlib_blas_ext_dcusumkbn( arrays ); + } + elapsed = tic() - t; + if ( dataY[ 0 ] != 1.0 || dataY[ len-1 ] != (double)len ) { + fprintf( stderr, "Unexpected cumulative sum.\n" ); + elapsed = -1.0; + } + } + + // Free descriptors before releasing their backing buffers: + if ( x != NULL ) { + stdlib_ndarray_free( x ); + } + if ( y != NULL ) { + stdlib_ndarray_free( y ); + } + if ( initial != NULL ) { + stdlib_ndarray_free( initial ); + } + free( dataX ); + free( dataY ); + return elapsed; +} + +/** +* Main execution sequence. +*/ +int main( void ) { + const int lengths[] = { 16, 1024 }; + double elapsed; + int passing = 0; + int count = 0; + int i; + int j; + + printf( "TAP version 13\n" ); + for ( i = 0; i < 2; i++ ) { + for ( j = 0; j < REPEATS; j++ ) { + count += 1; + printf( "# c::%s:len=%d\n", NAME, lengths[ i ] ); + elapsed = benchmark( ITERATIONS, lengths[ i ] ); + if ( elapsed < 0.0 ) { + printf( "not ok %d benchmark failed\n", count ); + } else { + printf( " ---\n" ); + printf( " iterations: %d\n", ITERATIONS ); + printf( " elapsed: %0.9f\n", elapsed ); + printf( " ...\n" ); + printf( "ok %d benchmark finished\n", count ); + passing += 1; + } + } + } + printf( "#\n" ); + printf( "1..%d\n", count ); + printf( "# total %d\n", count ); + printf( "# pass %d\n", passing ); + printf( "#\n" ); + if ( passing == count ) { + printf( "# ok\n" ); + return EXIT_SUCCESS; + } + return EXIT_FAILURE; +} diff --git a/lib/node_modules/@stdlib/blas/ext/base/ndarray/dcusumkbn/binding.gyp b/lib/node_modules/@stdlib/blas/ext/base/ndarray/dcusumkbn/binding.gyp new file mode 100644 index 000000000000..488c2c091085 --- /dev/null +++ b/lib/node_modules/@stdlib/blas/ext/base/ndarray/dcusumkbn/binding.gyp @@ -0,0 +1,267 @@ +# @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. + +# A `.gyp` file for building a Node.js native add-on. +# +# [1]: https://gyp.gsrc.io/docs/InputFormatReference.md +# [2]: https://gyp.gsrc.io/docs/UserDocumentation.md +{ + # List of files to include in this file: + 'includes': [ + './include.gypi', + ], + + # Define variables to be used throughout the configuration for all targets: + 'variables': { + # Target name should match the add-on export name: + 'addon_target_name%': 'addon', + + # Fortran compiler (to override -Dfortran_compiler=): + 'fortran_compiler%': 'gfortran', + + # Fortran compiler flags: + 'fflags': [ + # Specify the Fortran standard to which a program is expected to conform: + '-std=f95', + + # Indicate that the layout is free-form source code: + '-ffree-form', + + # Aggressive optimization: + '-O3', + '-ffp-contract=off', + + # Enable commonly used warning options: + '-Wall', + + # Warn if source code contains problematic language features: + '-Wextra', + + # Warn if a procedure is called without an explicit interface: + '-Wimplicit-interface', + + # Do not transform names of entities specified in Fortran source files by appending underscores (i.e., don't mangle names, thus allowing easier usage in C wrappers): + '-fno-underscoring', + + # Warn if source code contains Fortran 95 extensions and C-language constructs: + '-pedantic', + + # Compile but do not link (output is an object file): + '-c', + ], + + # Set variables based on the host OS: + 'conditions': [ + [ + 'OS=="win"', + { + # Define the object file suffix: + 'obj': 'obj', + }, + { + # Define the object file suffix: + 'obj': 'o', + } + ], # end condition (OS=="win") + ], # end conditions + }, # end variables + + # Define compile targets: + 'targets': [ + + # Target to generate an add-on: + { + # The target name should match the add-on export name: + 'target_name': '<(addon_target_name)', + + # Define dependencies: + 'dependencies': [], + + # Define directories which contain relevant include headers: + 'include_dirs': [ + # Local include directory: + '<@(include_dirs)', + ], + + # List of source files: + 'sources': [ + '<@(src_files)', + ], + + # Settings which should be applied when a target's object files are used as linker input: + 'link_settings': { + # Define libraries: + 'libraries': [ + '<@(libraries)', + ], + + # Define library directories: + 'library_dirs': [ + '<@(library_dirs)', + ], + }, + + # C/C++ compiler flags: + 'cflags': [ + # Enable commonly used warning options: + '-Wall', + + # Aggressive optimization: + '-O3', + '-ffp-contract=off', + ], + + # C specific compiler flags: + 'cflags_c': [ + # Specify the C standard to which a program is expected to conform: + '-std=c99', + ], + + # C++ specific compiler flags: + 'cflags_cpp': [ + # Specify the C++ standard to which a program is expected to conform: + '-std=c++11', + ], + + # Linker flags: + 'ldflags': [], + + # Apply conditions based on the host OS: + 'conditions': [ + [ + 'OS=="mac"', + { + # Linker flags: + 'ldflags': [ + '-undefined dynamic_lookup', + '-Wl,-no-pie', + '-Wl,-search_paths_first', + ], + }, + ], # end condition (OS=="mac") + [ + 'OS!="win"', + { + # C/C++ flags: + 'cflags': [ + # Generate platform-independent code: + '-fPIC', + ], + }, + ], # end condition (OS!="win") + ], # end conditions + + # Define custom build actions for particular inputs: + 'rules': [ + { + # Define a rule for processing Fortran files: + 'extension': 'f', + + # Define the pathnames to be used as inputs when performing processing: + 'inputs': [ + # Full path of the current input: + '<(RULE_INPUT_PATH)' + ], + + # Define the outputs produced during processing: + 'outputs': [ + # Store an output object file in a directory for placing intermediate results (only accessible within a single target): + '<(INTERMEDIATE_DIR)/<(RULE_INPUT_ROOT).<(obj)' + ], + + # Define the rule for compiling Fortran based on the host OS: + 'conditions': [ + [ + 'OS=="win"', + + # Rule to compile Fortran on Windows: + { + 'rule_name': 'compile_fortran_windows', + 'message': 'Compiling Fortran file <(RULE_INPUT_PATH) on Windows...', + + 'process_outputs_as_sources': 0, + + # Define the command-line invocation: + 'action': [ + '<(fortran_compiler)', + '<@(fflags)', + '<@(_inputs)', + '-o', + '<@(_outputs)', + ], + }, + + # Rule to compile Fortran on non-Windows: + { + 'rule_name': 'compile_fortran_linux', + 'message': 'Compiling Fortran file <(RULE_INPUT_PATH) on Linux...', + + 'process_outputs_as_sources': 1, + + # Define the command-line invocation: + 'action': [ + '<(fortran_compiler)', + '<@(fflags)', + '-fPIC', # generate platform-independent code + '<@(_inputs)', + '-o', + '<@(_outputs)', + ], + } + ], # end condition (OS=="win") + ], # end conditions + }, # end rule (extension=="f") + ], # end rules + }, # end target <(addon_target_name) + + # Target to copy a generated add-on to a standard location: + { + 'target_name': 'copy_addon', + + # Declare that the output of this target is not linked: + 'type': 'none', + + # Define dependencies: + 'dependencies': [ + # Require that the add-on be generated before building this target: + '<(addon_target_name)', + ], + + # Define a list of actions: + 'actions': [ + { + 'action_name': 'copy_addon', + 'message': 'Copying addon...', + + # Explicitly list the inputs in the command-line invocation below: + 'inputs': [], + + # Declare the expected outputs: + 'outputs': [ + '<(addon_output_dir)/<(addon_target_name).node', + ], + + # Define the command-line invocation: + 'action': [ + 'cp', + '<(PRODUCT_DIR)/<(addon_target_name).node', + '<(addon_output_dir)/<(addon_target_name).node', + ], + }, + ], # end actions + }, # end target copy_addon + ], # end targets +} diff --git a/lib/node_modules/@stdlib/blas/ext/base/ndarray/dcusumkbn/examples/c/Makefile b/lib/node_modules/@stdlib/blas/ext/base/ndarray/dcusumkbn/examples/c/Makefile new file mode 100644 index 000000000000..c8f8e9a1517b --- /dev/null +++ b/lib/node_modules/@stdlib/blas/ext/base/ndarray/dcusumkbn/examples/c/Makefile @@ -0,0 +1,146 @@ +#/ +# @license Apache-2.0 +# +# Copyright (c) 2026 The Stdlib Authors. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +#/ + +# VARIABLES # + +ifndef VERBOSE + QUIET := @ +else + QUIET := +endif + +# Determine the OS ([1][1], [2][2]). +# +# [1]: https://en.wikipedia.org/wiki/Uname#Examples +# [2]: http://stackoverflow.com/a/27776822/2225624 +OS ?= $(shell uname) +ifneq (, $(findstring MINGW,$(OS))) + OS := WINNT +else +ifneq (, $(findstring MSYS,$(OS))) + OS := WINNT +else +ifneq (, $(findstring CYGWIN,$(OS))) + OS := WINNT +else +ifneq (, $(findstring Windows_NT,$(OS))) + OS := WINNT +endif +endif +endif +endif + +# Define the program used for compiling C source files: +ifdef C_COMPILER + CC := $(C_COMPILER) +else + CC := gcc +endif + +# Define the command-line options when compiling C files: +CFLAGS ?= \ + -std=c99 \ + -O3 \ + -Wall \ + -pedantic + +# Determine whether to generate position independent code ([1][1], [2][2]). +# +# [1]: https://gcc.gnu.org/onlinedocs/gcc/Code-Gen-Options.html#Code-Gen-Options +# [2]: http://stackoverflow.com/questions/5311515/gcc-fpic-option +ifeq ($(OS), WINNT) + fPIC ?= +else + fPIC ?= -fPIC +endif + +# List of includes (e.g., `-I /foo/bar -I /beep/boop/include`): +INCLUDE ?= + +# List of source files: +SOURCE_FILES ?= + +# List of libraries (e.g., `-lopenblas -lpthread`): +LIBRARIES ?= + +# List of library paths (e.g., `-L /foo/bar -L /beep/boop`): +LIBPATH ?= + +# List of C targets: +c_targets := example.out + + +# RULES # + +#/ +# Compiles source files. +# +# @param {string} [C_COMPILER] - C compiler (e.g., `gcc`) +# @param {string} [CFLAGS] - C compiler options +# @param {(string|void)} [fPIC] - compiler flag determining whether to generate position independent code (e.g., `-fPIC`) +# @param {string} [INCLUDE] - list of includes (e.g., `-I /foo/bar -I /beep/boop/include`) +# @param {string} [SOURCE_FILES] - list of source files +# @param {string} [LIBPATH] - list of library paths (e.g., `-L /foo/bar -L /beep/boop`) +# @param {string} [LIBRARIES] - list of libraries (e.g., `-lopenblas -lpthread`) +# +# @example +# make +# +# @example +# make all +#/ +all: $(c_targets) + +.PHONY: all + +#/ +# Compiles C source files. +# +# @private +# @param {string} CC - C compiler (e.g., `gcc`) +# @param {string} CFLAGS - C compiler options +# @param {(string|void)} fPIC - compiler flag determining whether to generate position independent code (e.g., `-fPIC`) +# @param {string} INCLUDE - list of includes (e.g., `-I /foo/bar`) +# @param {string} SOURCE_FILES - list of source files +# @param {string} LIBPATH - list of library paths (e.g., `-L /foo/bar`) +# @param {string} LIBRARIES - list of libraries (e.g., `-lopenblas`) +#/ +$(c_targets): %.out: %.c + $(QUIET) $(CC) $(CFLAGS) $(fPIC) $(INCLUDE) -o $@ $(SOURCE_FILES) $< $(LIBPATH) -lm $(LIBRARIES) + +#/ +# Runs compiled examples. +# +# @example +# make run +#/ +run: $(c_targets) + $(QUIET) ./$< + +.PHONY: run + +#/ +# Removes generated files. +# +# @example +# make clean +#/ +clean: + $(QUIET) -rm -f *.o *.out + +.PHONY: clean diff --git a/lib/node_modules/@stdlib/blas/ext/base/ndarray/dcusumkbn/examples/c/example.c b/lib/node_modules/@stdlib/blas/ext/base/ndarray/dcusumkbn/examples/c/example.c new file mode 100644 index 000000000000..1294cb5555a1 --- /dev/null +++ b/lib/node_modules/@stdlib/blas/ext/base/ndarray/dcusumkbn/examples/c/example.c @@ -0,0 +1,81 @@ +/** +* @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. +*/ + +#include "stdlib/blas/ext/base/ndarray/dcusumkbn.h" +#include "stdlib/ndarray/ctor.h" +#include "stdlib/ndarray/dtypes.h" +#include "stdlib/ndarray/index_modes.h" +#include "stdlib/ndarray/orders.h" +#include "stdlib/ndarray/base/bytes_per_element.h" +#include +#include +#include + +int main( void ) { + // Create data buffers: + const double dataX[] = { 1.0e16, 1.0, -1.0e16 }; + double dataY[] = { 0.0, 0.0, 0.0 }; + const double dataInitial[] = { 123.0, 0.0 }; + + // Specify the ndarray metadata: + int64_t shape[] = { 3 }; + int64_t strides[] = { STDLIB_NDARRAY_FLOAT64_BYTES_PER_ELEMENT }; + int64_t scalarStrides[] = { 0 }; + int8_t submodes[] = { STDLIB_NDARRAY_INDEX_ERROR }; + const enum STDLIB_NDARRAY_ORDER order = STDLIB_NDARRAY_ROW_MAJOR; + const enum STDLIB_NDARRAY_INDEX_MODE imode = STDLIB_NDARRAY_INDEX_ERROR; + + // Create one-dimensional input and output ndarrays: + // cppcheck-suppress invalidPointerCast + struct ndarray *x = stdlib_ndarray_allocate( STDLIB_NDARRAY_FLOAT64, (uint8_t *)dataX, 1, shape, strides, 0, order, imode, 1, submodes ); + // cppcheck-suppress invalidPointerCast + struct ndarray *y = stdlib_ndarray_allocate( STDLIB_NDARRAY_FLOAT64, (uint8_t *)dataY, 1, shape, strides, 0, order, imode, 1, submodes ); + + // Select an initial sum of zero at the scalar's own byte offset: + // cppcheck-suppress invalidPointerCast + struct ndarray *initial = stdlib_ndarray_allocate( STDLIB_NDARRAY_FLOAT64, (uint8_t *)dataInitial, 0, NULL, scalarStrides, STDLIB_NDARRAY_FLOAT64_BYTES_PER_ELEMENT, order, imode, 1, submodes ); + int status = EXIT_SUCCESS; + if ( x == NULL || y == NULL || initial == NULL ) { + fprintf( stderr, "Error allocating ndarray descriptors.\n" ); + status = EXIT_FAILURE; + } else { + const struct ndarray *arrays[] = { x, y, initial }; + stdlib_blas_ext_dcusumkbn( arrays ); + + // Compensated summation retains the unit term after cancellation: + if ( dataY[ 0 ] != 1.0e16 || dataY[ 1 ] != 1.0e16 || dataY[ 2 ] != 1.0 ) { + fprintf( stderr, "Unexpected cumulative sum.\n" ); + status = EXIT_FAILURE; + } + for ( int i = 0; i < 3; i++ ) { + printf( "y[ %i ] = %.17g\n", i, dataY[ i ] ); + } + } + + // Free any successfully allocated descriptors: + if ( x != NULL ) { + stdlib_ndarray_free( x ); + } + if ( y != NULL ) { + stdlib_ndarray_free( y ); + } + if ( initial != NULL ) { + stdlib_ndarray_free( initial ); + } + return status; +} diff --git a/lib/node_modules/@stdlib/blas/ext/base/ndarray/dcusumkbn/include.gypi b/lib/node_modules/@stdlib/blas/ext/base/ndarray/dcusumkbn/include.gypi new file mode 100644 index 000000000000..bee8d41a2caf --- /dev/null +++ b/lib/node_modules/@stdlib/blas/ext/base/ndarray/dcusumkbn/include.gypi @@ -0,0 +1,53 @@ +# @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. + +# A GYP include file for building a Node.js native add-on. +# +# Main documentation: +# +# [1]: https://gyp.gsrc.io/docs/InputFormatReference.md +# [2]: https://gyp.gsrc.io/docs/UserDocumentation.md +{ + # Define variables to be used throughout the configuration for all targets: + 'variables': { + # Source directory: + 'src_dir': './src', + + # Include directories: + 'include_dirs': [ + ' 2147483647 ) { + return false; + } + if ( !isSafeInteger( stride ) || stride < -2147483648 || stride > 2147483647 || !isSafeInteger( offset ) || offset < 0 || offset > 2147483647 ) { + return false; + } + try { + length = lengthGetter.call( x ); + } catch ( err ) { // eslint-disable-line no-unused-vars + return false; + } + if ( getPrototypeOf( x ) !== Float64Array.prototype ) { + return false; + } + last = offset + ((N-1)*stride); + post = offset + (N*stride); + return isSafeInteger( last ) && isSafeInteger( post ) && last >= 0 && last < length && offset < length && last <= 2147483647 && post >= -2147483648 && post <= 2147483647; +} + + +// EXPORTS // + +module.exports = canUseNative; diff --git a/lib/node_modules/@stdlib/blas/ext/base/ndarray/dcusumkbn/lib/index.js b/lib/node_modules/@stdlib/blas/ext/base/ndarray/dcusumkbn/lib/index.js index dd0ab5eb243a..a40a3ea68285 100644 --- a/lib/node_modules/@stdlib/blas/ext/base/ndarray/dcusumkbn/lib/index.js +++ b/lib/node_modules/@stdlib/blas/ext/base/ndarray/dcusumkbn/lib/index.js @@ -44,7 +44,13 @@ // MODULES // -var main = require( './main.js' ); +var resolve = require( 'path' ).resolve; +var tryRequire = require( '@stdlib/utils/try-require' ); + +var main = tryRequire( resolve( __dirname, './native.js' ) ); +if ( main instanceof Error ) { + main = require( './main.js' ); +} // EXPORTS // diff --git a/lib/node_modules/@stdlib/blas/ext/base/ndarray/dcusumkbn/lib/native.js b/lib/node_modules/@stdlib/blas/ext/base/ndarray/dcusumkbn/lib/native.js new file mode 100644 index 000000000000..72d7ff32b77a --- /dev/null +++ b/lib/node_modules/@stdlib/blas/ext/base/ndarray/dcusumkbn/lib/native.js @@ -0,0 +1,100 @@ +/** +* @license Apache-2.0 +* +* Copyright (c) 2025 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 numelDimension = require( '@stdlib/ndarray/base/numel-dimension' ); +var getStride = require( '@stdlib/ndarray/base/stride' ); +var getOffset = require( '@stdlib/ndarray/base/offset' ); +var getData = require( '@stdlib/ndarray/base/data-buffer' ); +var ndarraylike2scalar = require( '@stdlib/ndarray/base/ndarraylike2scalar' ); +var strided = require( '@stdlib/blas/ext/base/dcusumkbn' ).ndarray; +var canUseNative = require( './can_use_native.js' ); +var addon = require( './../src/addon.node' ); + + +// MAIN // + +/** +* Computes the cumulative sum of a one-dimensional double-precision floating-point ndarray using an improved Kahan–Babuška algorithm. +* +* ## Notes +* +* - The function expects the following ndarrays: +* +* - a one-dimensional input ndarray. +* - a one-dimensional output ndarray. +* - a zero-dimensional ndarray containing the initial sum. +* +* @param {ArrayLikeObject} arrays - array-like object containing ndarrays +* @returns {Object} output ndarray +* +* @example +* var Float64Vector = require( '@stdlib/ndarray/vector/float64' ); +* var scalar2ndarray = require( '@stdlib/ndarray/from-scalar' ); +* +* var x = new Float64Vector( [ 1.0, 3.0, 4.0, 2.0 ] ); +* var y = new Float64Vector( [ 0.0, 0.0, 0.0, 0.0 ] ); +* +* var initial = scalar2ndarray( 0.0, { +* 'dtype': 'float64' +* }); +* +* var z = dcusumkbn( [ x, y, initial ] ); +* // returns [ 1.0, 4.0, 8.0, 10.0 ] +* +* var bool = ( z === y ); +* // returns true +*/ +function dcusumkbn( arrays ) { + var xb; + var sx; + var ox; + var yb; + var sy; + var oy; + var x; + var y; + var v; + var N; + + x = arrays[ 0 ]; + y = arrays[ 1 ]; + v = ndarraylike2scalar( arrays[ 2 ] ); + N = numelDimension( x, 0 ); + xb = getData( x ); + sx = getStride( x, 0 ); + ox = getOffset( x ); + yb = getData( y ); + sy = getStride( y, 0 ); + oy = getOffset( y ); + + if ( typeof v === 'number' && canUseNative( N, xb, sx, ox ) && canUseNative( N, yb, sy, oy ) ) { + addon( N, v, xb, sx, ox, yb, sy, oy ); + } else { + strided( N, v, xb, sx, ox, yb, sy, oy ); + } + return y; +} + + +// EXPORTS // + +module.exports = dcusumkbn; diff --git a/lib/node_modules/@stdlib/blas/ext/base/ndarray/dcusumkbn/manifest.json b/lib/node_modules/@stdlib/blas/ext/base/ndarray/dcusumkbn/manifest.json new file mode 100644 index 000000000000..51efb4e5ac7a --- /dev/null +++ b/lib/node_modules/@stdlib/blas/ext/base/ndarray/dcusumkbn/manifest.json @@ -0,0 +1,111 @@ +{ + "options": { + "task": "build", + "wasm": false + }, + "fields": [ + { + "field": "src", + "resolve": true, + "relative": true + }, + { + "field": "include", + "resolve": true, + "relative": true + }, + { + "field": "libraries", + "resolve": false, + "relative": false + }, + { + "field": "libpath", + "resolve": true, + "relative": false + } + ], + "confs": [ + { + "task": "build", + "wasm": false, + "src": [ + "./src/main.c" + ], + "include": [ + "./include" + ], + "libraries": [], + "libpath": [], + "dependencies": [ + "@stdlib/blas/base/shared", + "@stdlib/blas/ext/base/dcusumkbn", + "@stdlib/ndarray/ctor", + "@stdlib/napi/export", + "@stdlib/napi/argv", + "@stdlib/napi/argv-float64array", + "@stdlib/napi/argv-int64", + "@stdlib/napi/argv-double" + ] + }, + { + "task": "benchmark", + "wasm": false, + "src": [ + "./src/main.c" + ], + "include": [ + "./include" + ], + "libraries": [], + "libpath": [], + "dependencies": [ + "@stdlib/blas/base/shared", + "@stdlib/blas/ext/base/dcusumkbn", + "@stdlib/ndarray/ctor", + "@stdlib/ndarray/dtypes", + "@stdlib/ndarray/index-modes", + "@stdlib/ndarray/orders", + "@stdlib/ndarray/base/bytes-per-element" + ] + }, + { + "task": "examples", + "wasm": false, + "src": [ + "./src/main.c" + ], + "include": [ + "./include" + ], + "libraries": [], + "libpath": [], + "dependencies": [ + "@stdlib/blas/base/shared", + "@stdlib/blas/ext/base/dcusumkbn", + "@stdlib/ndarray/ctor", + "@stdlib/ndarray/dtypes", + "@stdlib/ndarray/index-modes", + "@stdlib/ndarray/orders", + "@stdlib/ndarray/base/bytes-per-element" + ] + }, + { + "task": "", + "wasm": true, + "src": [ + "./src/main.c" + ], + "include": [ + "./include" + ], + "libraries": [], + "libpath": [], + "dependencies": [ + "@stdlib/blas/base/shared", + "@stdlib/blas/ext/base/dcusumkbn", + "@stdlib/ndarray/ctor" + ] + } + ] +} diff --git a/lib/node_modules/@stdlib/blas/ext/base/ndarray/dcusumkbn/package.json b/lib/node_modules/@stdlib/blas/ext/base/ndarray/dcusumkbn/package.json index 0fa2820768f1..200c67f1a4bc 100644 --- a/lib/node_modules/@stdlib/blas/ext/base/ndarray/dcusumkbn/package.json +++ b/lib/node_modules/@stdlib/blas/ext/base/ndarray/dcusumkbn/package.json @@ -1,7 +1,7 @@ { "name": "@stdlib/blas/ext/base/ndarray/dcusumkbn", "version": "0.0.0", - "description": "Compute the cumulative sum of a one-dimensional double-precision floating-point ndarray using an improved Kahan–Babuška algorithm.", + "description": "Compute the cumulative sum of a one-dimensional double-precision floating-point ndarray using an improved Kahan\u2013Babu\u0161ka algorithm.", "license": "Apache-2.0", "author": { "name": "The Stdlib Authors", @@ -67,5 +67,9 @@ "summation", "ndarray" ], - "__stdlib__": {} + "__stdlib__": {}, + "gypfile": true, + "browser": { + "./lib/native.js": "./lib/main.js" + } } diff --git a/lib/node_modules/@stdlib/blas/ext/base/ndarray/dcusumkbn/src/Makefile b/lib/node_modules/@stdlib/blas/ext/base/ndarray/dcusumkbn/src/Makefile new file mode 100644 index 000000000000..2caf905cedbe --- /dev/null +++ b/lib/node_modules/@stdlib/blas/ext/base/ndarray/dcusumkbn/src/Makefile @@ -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. +#/ + +# VARIABLES # + +ifndef VERBOSE + QUIET := @ +else + QUIET := +endif + +# Determine the OS ([1][1], [2][2]). +# +# [1]: https://en.wikipedia.org/wiki/Uname#Examples +# [2]: http://stackoverflow.com/a/27776822/2225624 +OS ?= $(shell uname) +ifneq (, $(findstring MINGW,$(OS))) + OS := WINNT +else +ifneq (, $(findstring MSYS,$(OS))) + OS := WINNT +else +ifneq (, $(findstring CYGWIN,$(OS))) + OS := WINNT +else +ifneq (, $(findstring Windows_NT,$(OS))) + OS := WINNT +endif +endif +endif +endif + + +# RULES # + +#/ +# Removes generated files for building an add-on. +# +# @example +# make clean-addon +#/ +clean-addon: + $(QUIET) -rm -f *.o *.node + +.PHONY: clean-addon + +#/ +# Removes generated files. +# +# @example +# make clean +#/ +clean: clean-addon + +.PHONY: clean diff --git a/lib/node_modules/@stdlib/blas/ext/base/ndarray/dcusumkbn/src/addon.c b/lib/node_modules/@stdlib/blas/ext/base/ndarray/dcusumkbn/src/addon.c new file mode 100644 index 000000000000..4d0e531ee605 --- /dev/null +++ b/lib/node_modules/@stdlib/blas/ext/base/ndarray/dcusumkbn/src/addon.c @@ -0,0 +1,126 @@ +/** +* @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. +*/ + +#include "stdlib/blas/ext/base/ndarray/dcusumkbn.h" +#include "stdlib/napi/export.h" +#include "stdlib/napi/argv.h" +#include "stdlib/napi/argv_float64array.h" +#include "stdlib/napi/argv_int64.h" +#include "stdlib/napi/argv_double.h" +#include "stdlib/ndarray/ctor.h" +#include +#include + +/** +* Checks physical typed-array endpoints and the final integer increment. +* +* @param N length +* @param stride element stride +* @param offset offset +* @param length physical length +* @return whether the bridge can safely execute +*/ +static int8_t valid_view( const int64_t N, const int64_t stride, const int64_t offset, const int64_t length ) { + const long double last = (long double)offset + ((long double)(N-1)*stride); + const long double post = (long double)offset + ((long double)N*stride); + return stride >= INT32_MIN && stride <= INT32_MAX && offset >= 0 && offset <= INT32_MAX && offset < length && last >= 0 && last < length && last <= INT32_MAX && post >= INT32_MIN && post <= INT32_MAX; +} + +/** +* Executes using normalized values already extracted in JavaScript read order. +* +* @param env environment +* @param info callback data +* @return undefined +*/ +static napi_value addon( napi_env env, napi_callback_info info ) { + STDLIB_NAPI_ARGV( env, info, argv, argc, 8 ); + STDLIB_NAPI_ARGV_INT64( env, N, argv, 0 ); + STDLIB_NAPI_ARGV_DOUBLE( env, sum, argv, 1 ); + STDLIB_NAPI_ARGV_FLOAT64ARRAY( env, X, nx, argv, 2 ); + STDLIB_NAPI_ARGV_INT64( env, sx, argv, 3 ); + STDLIB_NAPI_ARGV_INT64( env, ox, argv, 4 ); + STDLIB_NAPI_ARGV_FLOAT64ARRAY( env, Y, ny, argv, 5 ); + STDLIB_NAPI_ARGV_INT64( env, sy, argv, 6 ); + STDLIB_NAPI_ARGV_INT64( env, oy, argv, 7 ); + + STDLIB_NAPI_ARGV_DOUBLE( env, exact_N, argv, 0 ); + if ( exact_N != (double)N ) { + napi_throw_range_error( env, NULL, "native metadata must be integers." ); + return NULL; + } + + STDLIB_NAPI_ARGV_DOUBLE( env, exact_sx, argv, 3 ); + if ( exact_sx != (double)sx ) { + napi_throw_range_error( env, NULL, "native metadata must be integers." ); + return NULL; + } + + STDLIB_NAPI_ARGV_DOUBLE( env, exact_ox, argv, 4 ); + if ( exact_ox != (double)ox ) { + napi_throw_range_error( env, NULL, "native metadata must be integers." ); + return NULL; + } + + STDLIB_NAPI_ARGV_DOUBLE( env, exact_sy, argv, 6 ); + if ( exact_sy != (double)sy ) { + napi_throw_range_error( env, NULL, "native metadata must be integers." ); + return NULL; + } + + STDLIB_NAPI_ARGV_DOUBLE( env, exact_oy, argv, 7 ); + if ( exact_oy != (double)oy ) { + napi_throw_range_error( env, NULL, "native metadata must be integers." ); + return NULL; + } + + if ( N < 0 || N > INT32_MAX || (N > 0 && (!valid_view( N, sx, ox, nx ) || !valid_view( N, sy, oy, ny ))) ) { + napi_throw_range_error( env, NULL, "invalid native indexing bounds or integer width." ); + return NULL; + } + if ( N == 0 ) { + napi_value empty; + napi_get_undefined( env, &empty ); + return empty; + } + int64_t shape[] = { N }; + int64_t xs[] = { sx*8 }; + int64_t ys[] = { sy*8 }; + int64_t ss[] = { 0 }; + int8_t modes[] = { STDLIB_NDARRAY_INDEX_ERROR }; + struct ndarray *x = stdlib_ndarray_allocate( STDLIB_NDARRAY_FLOAT64, (uint8_t *)X, 1, shape, xs, ox*8, STDLIB_NDARRAY_ROW_MAJOR, STDLIB_NDARRAY_INDEX_ERROR, 1, modes ); + struct ndarray *y = stdlib_ndarray_allocate( STDLIB_NDARRAY_FLOAT64, (uint8_t *)Y, 1, shape, ys, oy*8, STDLIB_NDARRAY_ROW_MAJOR, STDLIB_NDARRAY_INDEX_ERROR, 1, modes ); + struct ndarray *initial = stdlib_ndarray_allocate( STDLIB_NDARRAY_FLOAT64, (uint8_t *)&sum, 0, NULL, ss, 0, STDLIB_NDARRAY_ROW_MAJOR, STDLIB_NDARRAY_INDEX_ERROR, 1, modes ); + if ( x == NULL || y == NULL || initial == NULL ) { + if ( x != NULL ) { stdlib_ndarray_free( x ); } + if ( y != NULL ) { stdlib_ndarray_free( y ); } + if ( initial != NULL ) { stdlib_ndarray_free( initial ); } + napi_throw_error( env, NULL, "unable to allocate ndarray metadata." ); + return NULL; + } + const struct ndarray *arrays[] = { x, y, initial }; + stdlib_blas_ext_dcusumkbn( arrays ); + stdlib_ndarray_free( x ); + stdlib_ndarray_free( y ); + stdlib_ndarray_free( initial ); + napi_value out; + napi_get_undefined( env, &out ); + return out; +} + +STDLIB_NAPI_MODULE_EXPORT_FCN( addon ) diff --git a/lib/node_modules/@stdlib/blas/ext/base/ndarray/dcusumkbn/src/main.c b/lib/node_modules/@stdlib/blas/ext/base/ndarray/dcusumkbn/src/main.c new file mode 100644 index 000000000000..78ad41860014 --- /dev/null +++ b/lib/node_modules/@stdlib/blas/ext/base/ndarray/dcusumkbn/src/main.c @@ -0,0 +1,92 @@ +/** +* @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. +*/ + +#include "stdlib/blas/ext/base/ndarray/dcusumkbn.h" +#include "stdlib/blas/ext/base/dcusumkbn.h" +#include "stdlib/blas/base/shared.h" +#include "stdlib/ndarray/ctor.h" +#include + +/** +* Checks configured integer width before narrowing or advancing indices. +* +* @param N length +* @param stride element stride +* @param offset starting element index +* @return whether the strided kernel's integer arithmetic is representable +*/ +static int8_t valid_indices( const int64_t N, const int64_t stride, const int64_t offset ) { + const int64_t hi = ( sizeof(CBLAS_INT) == sizeof(int64_t) ) ? INT64_MAX : INT32_MAX; + const int64_t lo = ( sizeof(CBLAS_INT) == sizeof(int64_t) ) ? INT64_MIN : INT32_MIN; + uint64_t magnitude; + uint64_t distance; + + if ( N <= 0 || N > hi || stride < lo || stride > hi || offset < 0 || offset > hi ) { + return 0; + } + if ( stride >= 0 ) { + return stride <= (hi-offset)/N; + } + // Compute magnitude without negating INT64_MIN. + magnitude = (uint64_t)( -(stride+1) ) + 1; + if ( N > 1 && magnitude > (uint64_t)offset/(uint64_t)(N-1) ) { + return 0; + } + // Offset-to-minimum distance can span the full unsigned 64-bit range. + distance = (uint64_t)offset + (uint64_t)( -(lo+1) ) + 1; + return magnitude <= distance/(uint64_t)N; +} + +/** +* Computes compensated cumulative prefixes using the adopted strided kernel. +* +* The list contains two valid one-dimensional float64 ndarrays and a valid +* zero-dimensional float64 initial value. Physical bounds are caller supplied. +* Indexed and post-iteration arithmetic must fit configured CBLAS_INT. +* Invalid dtype/dimensions or unrepresentable metadata leave output unchanged. +* +* @param arrays input, output, and initial sum ndarrays +*/ +void stdlib_blas_ext_dcusumkbn( const struct ndarray *arrays[] ) { + const struct ndarray *x = arrays[ 0 ]; + const struct ndarray *y = arrays[ 1 ]; + const struct ndarray *initial = arrays[ 2 ]; + double sum; + + if ( stdlib_ndarray_dtype( x ) != STDLIB_NDARRAY_FLOAT64 || stdlib_ndarray_dtype( y ) != STDLIB_NDARRAY_FLOAT64 || stdlib_ndarray_dtype( initial ) != STDLIB_NDARRAY_FLOAT64 || stdlib_ndarray_ndims( x ) != 1 || stdlib_ndarray_ndims( y ) != 1 || stdlib_ndarray_ndims( initial ) != 0 ) { + return; + } + if ( stdlib_ndarray_get_float64( initial, NULL, &sum ) != 0 ) { + return; + } + const int64_t N = stdlib_ndarray_dimension( x, 0 ); + if ( N <= 0 ) { + return; + } + if ( stdlib_ndarray_stride( x, 0 ) % 8 != 0 || stdlib_ndarray_stride( y, 0 ) % 8 != 0 || stdlib_ndarray_offset( x ) % 8 != 0 || stdlib_ndarray_offset( y ) % 8 != 0 ) { + return; + } + const int64_t sx = stdlib_ndarray_stride_elements( x, 0 ); + const int64_t sy = stdlib_ndarray_stride_elements( y, 0 ); + const int64_t ox = stdlib_ndarray_offset_elements( x ); + const int64_t oy = stdlib_ndarray_offset_elements( y ); + if ( !valid_indices( N, sx, ox ) || !valid_indices( N, sy, oy ) ) { + return; + } + API_SUFFIX(stdlib_strided_dcusumkbn_ndarray)( (CBLAS_INT)N, sum, (const double *)stdlib_ndarray_data( x ), (CBLAS_INT)sx, (CBLAS_INT)ox, (double *)stdlib_ndarray_data( y ), (CBLAS_INT)sy, (CBLAS_INT)oy ); +} diff --git a/lib/node_modules/@stdlib/blas/ext/base/ndarray/dcusumkbn/test/fixtures/exact-prefixes.json b/lib/node_modules/@stdlib/blas/ext/base/ndarray/dcusumkbn/test/fixtures/exact-prefixes.json new file mode 100644 index 000000000000..907b845e138c --- /dev/null +++ b/lib/node_modules/@stdlib/blas/ext/base/ndarray/dcusumkbn/test/fixtures/exact-prefixes.json @@ -0,0 +1,395 @@ +{ + "oracle": "Each initial/input is converted exactly to Python Fraction; every mathematical prefix is rounded once to binary64.", + "cases": [ + { + "x": [ + 1.712351053912815e-195, + 1.90109156629516e-211, + -1.712351053912815e-195 + ], + "initial": 0.0, + "prefixes": [ + 1.712351053912815e-195, + 1.712351053912815e-195, + 1.90109156629516e-211 + ] + }, + { + "x": [ + 1.712351053912815e-195, + -1.712351053912815e-195, + 1.90109156629516e-211 + ], + "initial": 0.0, + "prefixes": [ + 1.712351053912815e-195, + 0.0, + 1.90109156629516e-211 + ] + }, + { + "x": [ + -1.712351053912815e-195, + -1.90109156629516e-211, + 1.712351053912815e-195 + ], + "initial": 0.0, + "prefixes": [ + -1.712351053912815e-195, + -1.712351053912815e-195, + -1.90109156629516e-211 + ] + }, + { + "x": [ + 1.90109156629516e-211, + 1.712351053912815e-195, + -1.712351053912815e-195 + ], + "initial": 0.0, + "prefixes": [ + 1.90109156629516e-211, + 1.712351053912815e-195, + 1.90109156629516e-211 + ] + }, + { + "x": [ + 1.712351053912815e-195, + 1.90109156629516e-211, + -1.712351053912815e-195 + ], + "initial": 1.90109156629516e-211, + "prefixes": [ + 1.712351053912815e-195, + 1.7123510539128153e-195, + 3.80218313259032e-211 + ] + }, + { + "x": [ + 1.712351053912815e-195, + -1.712351053912815e-195, + -1.90109156629516e-211 + ], + "initial": 1.90109156629516e-211, + "prefixes": [ + 1.712351053912815e-195, + 1.90109156629516e-211, + 0.0 + ] + }, + { + "x": [ + 7.105427357601002e-15, + 7.888609052210118e-31, + -7.105427357601002e-15 + ], + "initial": 0.0, + "prefixes": [ + 7.105427357601002e-15, + 7.105427357601002e-15, + 7.888609052210118e-31 + ] + }, + { + "x": [ + 7.105427357601002e-15, + -7.105427357601002e-15, + 7.888609052210118e-31 + ], + "initial": 0.0, + "prefixes": [ + 7.105427357601002e-15, + 0.0, + 7.888609052210118e-31 + ] + }, + { + "x": [ + -7.105427357601002e-15, + -7.888609052210118e-31, + 7.105427357601002e-15 + ], + "initial": 0.0, + "prefixes": [ + -7.105427357601002e-15, + -7.105427357601002e-15, + -7.888609052210118e-31 + ] + }, + { + "x": [ + 7.888609052210118e-31, + 7.105427357601002e-15, + -7.105427357601002e-15 + ], + "initial": 0.0, + "prefixes": [ + 7.888609052210118e-31, + 7.105427357601002e-15, + 7.888609052210118e-31 + ] + }, + { + "x": [ + 7.105427357601002e-15, + 7.888609052210118e-31, + -7.105427357601002e-15 + ], + "initial": 7.888609052210118e-31, + "prefixes": [ + 7.105427357601002e-15, + 7.105427357601003e-15, + 1.5777218104420236e-30 + ] + }, + { + "x": [ + 7.105427357601002e-15, + -7.105427357601002e-15, + -7.888609052210118e-31 + ], + "initial": 7.888609052210118e-31, + "prefixes": [ + 7.105427357601002e-15, + 7.888609052210118e-31, + 0.0 + ] + }, + { + "x": [ + 9007199254740992.0, + 1.0, + -9007199254740992.0 + ], + "initial": 0.0, + "prefixes": [ + 9007199254740992.0, + 9007199254740992.0, + 1.0 + ] + }, + { + "x": [ + 9007199254740992.0, + -9007199254740992.0, + 1.0 + ], + "initial": 0.0, + "prefixes": [ + 9007199254740992.0, + 0.0, + 1.0 + ] + }, + { + "x": [ + -9007199254740992.0, + -1.0, + 9007199254740992.0 + ], + "initial": 0.0, + "prefixes": [ + -9007199254740992.0, + -9007199254740992.0, + -1.0 + ] + }, + { + "x": [ + 1.0, + 9007199254740992.0, + -9007199254740992.0 + ], + "initial": 0.0, + "prefixes": [ + 1.0, + 9007199254740992.0, + 1.0 + ] + }, + { + "x": [ + 9007199254740992.0, + 1.0, + -9007199254740992.0 + ], + "initial": 1.0, + "prefixes": [ + 9007199254740992.0, + 9007199254740994.0, + 2.0 + ] + }, + { + "x": [ + 9007199254740992.0, + -9007199254740992.0, + -1.0 + ], + "initial": 1.0, + "prefixes": [ + 9007199254740992.0, + 1.0, + 0.0 + ] + }, + { + "x": [ + 1.141798154164768e+46, + 1.2676506002282294e+30, + -1.141798154164768e+46 + ], + "initial": 0.0, + "prefixes": [ + 1.141798154164768e+46, + 1.141798154164768e+46, + 1.2676506002282294e+30 + ] + }, + { + "x": [ + 1.141798154164768e+46, + -1.141798154164768e+46, + 1.2676506002282294e+30 + ], + "initial": 0.0, + "prefixes": [ + 1.141798154164768e+46, + 0.0, + 1.2676506002282294e+30 + ] + }, + { + "x": [ + -1.141798154164768e+46, + -1.2676506002282294e+30, + 1.141798154164768e+46 + ], + "initial": 0.0, + "prefixes": [ + -1.141798154164768e+46, + -1.141798154164768e+46, + -1.2676506002282294e+30 + ] + }, + { + "x": [ + 1.2676506002282294e+30, + 1.141798154164768e+46, + -1.141798154164768e+46 + ], + "initial": 0.0, + "prefixes": [ + 1.2676506002282294e+30, + 1.141798154164768e+46, + 1.2676506002282294e+30 + ] + }, + { + "x": [ + 1.141798154164768e+46, + 1.2676506002282294e+30, + -1.141798154164768e+46 + ], + "initial": 1.2676506002282294e+30, + "prefixes": [ + 1.141798154164768e+46, + 1.1417981541647682e+46, + 2.535301200456459e+30 + ] + }, + { + "x": [ + 1.141798154164768e+46, + -1.141798154164768e+46, + -1.2676506002282294e+30 + ], + "initial": 1.2676506002282294e+30, + "prefixes": [ + 1.141798154164768e+46, + 1.2676506002282294e+30, + 0.0 + ] + }, + { + "x": [ + 4.737909217226285e+226, + 5.260135901548374e+210, + -4.737909217226285e+226 + ], + "initial": 0.0, + "prefixes": [ + 4.737909217226285e+226, + 4.737909217226285e+226, + 5.260135901548374e+210 + ] + }, + { + "x": [ + 4.737909217226285e+226, + -4.737909217226285e+226, + 5.260135901548374e+210 + ], + "initial": 0.0, + "prefixes": [ + 4.737909217226285e+226, + 0.0, + 5.260135901548374e+210 + ] + }, + { + "x": [ + -4.737909217226285e+226, + -5.260135901548374e+210, + 4.737909217226285e+226 + ], + "initial": 0.0, + "prefixes": [ + -4.737909217226285e+226, + -4.737909217226285e+226, + -5.260135901548374e+210 + ] + }, + { + "x": [ + 5.260135901548374e+210, + 4.737909217226285e+226, + -4.737909217226285e+226 + ], + "initial": 0.0, + "prefixes": [ + 5.260135901548374e+210, + 4.737909217226285e+226, + 5.260135901548374e+210 + ] + }, + { + "x": [ + 4.737909217226285e+226, + 5.260135901548374e+210, + -4.737909217226285e+226 + ], + "initial": 5.260135901548374e+210, + "prefixes": [ + 4.737909217226285e+226, + 4.737909217226286e+226, + 1.0520271803096747e+211 + ] + }, + { + "x": [ + 4.737909217226285e+226, + -4.737909217226285e+226, + -5.260135901548374e+210 + ], + "initial": 5.260135901548374e+210, + "prefixes": [ + 4.737909217226285e+226, + 5.260135901548374e+210, + 0.0 + ] + } + ] +} diff --git a/lib/node_modules/@stdlib/blas/ext/base/ndarray/dcusumkbn/test/test.native.js b/lib/node_modules/@stdlib/blas/ext/base/ndarray/dcusumkbn/test/test.native.js new file mode 100644 index 000000000000..1a532be320a0 --- /dev/null +++ b/lib/node_modules/@stdlib/blas/ext/base/ndarray/dcusumkbn/test/test.native.js @@ -0,0 +1,253 @@ +/** +* @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 resolve = require( 'path' ).resolve; +var tape = require( 'tape' ); +var sameValue = require( '@stdlib/assert/is-same-value' ); +var tryRequire = require( '@stdlib/utils/try-require' ); +var ndarray = require( '@stdlib/ndarray/base/ctor' ); +var Float64Array = require( '@stdlib/array/float64' ); +var main = require( './../lib/main.js' ); +var fixtures = require( './fixtures/exact-prefixes.json' ).cases; +var addonPath = resolve( __dirname, './../src/addon.node' ); +var nativePath = resolve( __dirname, './../lib/native.js' ); +var addon = tryRequire( addonPath ); +var calls = 0; +var native; + +if ( !(addon instanceof Error) ) { + require.cache[ addonPath ].exports = function instrument() { + calls += 1; + return addon.apply( null, arguments ); + }; + delete require.cache[ nativePath ]; +} +native = tryRequire( nativePath ); + + +// FUNCTIONS // + +/** +* Returns a selected float64 view. +* +* @private +* @param {Float64Array} data - data +* @param {integer} N - length +* @param {integer} stride - stride +* @param {integer} offset - offset +* @returns {ndarray} view +*/ +function vector( data, N, stride, offset ) { + return new ndarray( 'float64', data, [ N ], [ stride ], offset, 'row-major' ); +} + +/** +* Compares all entries using exact SameValue semantics. +* +* @private +* @param {Float64Array} a - first buffer +* @param {Float64Array} b - second buffer +* @returns {boolean} whether every entry matches +*/ +function equalBuffers( a, b ) { + var i; + if ( a.length !== b.length ) { + return false; + } + for ( i = 0; i < a.length; i++ ) { + if ( !sameValue( a[ i ], b[ i ] ) ) { + return false; + } + } + return true; +} + +/** +* Returns a scalar selecting its own offset. +* +* @private +* @param {number} value - scalar +* @returns {Object} scalar view +*/ +function scalar( value ) { + return { + 'data': [ 123.0, value ], + 'offset': 1 + }; +} + + +// TESTS // + +tape( 'main export is a function', function test( t ) { + t.ok( true, __filename ); + t.strictEqual( typeof main, 'function', 'main export is a function' ); + t.end(); +}); + +tape( 'compiled cumulative prefixes equal independently rounded exact sums', { + 'skip': native instanceof Error +}, function test( t ) { + var expected; + var strides; + var initial; + var actual; + var before; + var values; + var output; + var input; + var count; + var sx; + var sy; + var ox; + var oy; + var x; + var y; + var i; + var j; + var k; + var q; + + count = calls; + strides = [ -3, -1, 1, 2, 3 ]; + for ( i = 0; i < fixtures.length; i++ ) { + values = fixtures[ i ].x; + initial = scalar( fixtures[ i ].initial ); + for ( j = 0; j < strides.length; j++ ) { + for ( k = 0; k < strides.length; k++ ) { + sx = strides[ j ]; + sy = strides[ k ]; + ox = 3 + ( (sx < 0) ? -2*sx : 0 ); + oy = 3 + ( (sy < 0) ? -2*sy : 0 ); + input = new Float64Array( 32 ).subarray( 2, 25 ); + output = new Float64Array( 32 ).subarray( 3, 26 ); + input.fill( 999.0 ); + output.fill( 987.0 ); + expected = new Float64Array( output ); + for ( q = 0; q < 3; q++ ) { + input[ ox+(q*sx) ] = values[ q ]; + expected[ oy+(q*sy) ] = fixtures[ i ].prefixes[ q ]; + } + before = new Float64Array( input ); + x = vector( input, 3, sx, ox ); + y = vector( output, 3, sy, oy ); + actual = native( [ x, y, initial ] ); + t.strictEqual( actual, y, 'preserves output identity' ); + t.deepEqual( output, expected, 'exact mathematical prefixes and guards' ); + t.deepEqual( input, before, 'input and guards unchanged' ); + } + } + } + t.strictEqual( calls-count, 750, '750 actual addon calls over independent layouts' ); + t.end(); +}); + +tape( 'native sequential aliases, zero strides and special values preserve the adopted algorithm', { + 'skip': native instanceof Error +}, function test( t ) { + var sequences; + var expected; + var strides; + var initial; + var actual; + var sx; + var sy; + var ox; + var oy; + var i; + var j; + var k; + var q; + + sequences = [ [ 1e16, 1.0, -1e16, 3.0 ], [ -0.0, -0.0, 0.0, -0.0 ], [ NaN, 1.0, Infinity, -Infinity ], [ Infinity, 0.0, -Infinity, 1.0 ] ]; + strides = [ -1, 0, 1, 2 ]; + initial = scalar( -0.0 ); + for ( i = 0; i < sequences.length; i++ ) { + for ( j = 0; j < strides.length; j++ ) { + for ( k = 0; k < strides.length; k++ ) { + sx = strides[ j ]; + sy = strides[ k ]; + ox = 4 + ( (sx < 0) ? -3*sx : 0 ); + oy = 5 + ( (sy < 0) ? -3*sy : 0 ); + expected = new Float64Array( 20 ); + for ( q = 0; q < 4; q++ ) { + expected[ ox+(q*sx) ] = sequences[ i ][ q ]; + } + actual = new Float64Array( expected ); + main( [ vector( expected, 4, sx, ox ), vector( expected, 4, sy, oy ), initial ] ); + native( [ vector( actual, 4, sx, ox ), vector( actual, 4, sy, oy ), initial ] ); + t.strictEqual( equalBuffers( actual, expected ), true, 'whole shared buffer matches sequential JS including NaN/signedzero' ); + } + } + } + t.end(); +}); + +tape( 'snapshot, scalar extraction, fallback and post-increment width semantics', { + 'skip': native instanceof Error +}, function test( t ) { + var count; + var data; + var init; + var out; + var x; + var y; + + data = new Float64Array( [ 999.0, 2.0 ] ); + out = new Float64Array( [ 999.0, 0.0 ] ); + x = vector( data, 1, 2147483647, 1 ); + y = vector( out, 1, 1, 1 ); + count = calls; + t.strictEqual( native( [ x, y, scalar( 3.0 ) ] ), y, 'wide singleton returns same output' ); + t.strictEqual( out[ 1 ], 5.0, 'wider valid JS result preserved' ); + t.strictEqual( calls, count, 'unused post-increment overflow falls back' ); + data = [ 1e16, 1.0, -1e16 ]; + out = [ 0.0, 0.0, 0.0 ]; + x = { + 'data': data, + 'shape': [ 3 ], + 'strides': [ 1 ], + 'offset': 0 + }; + y = { + 'data': out, + 'shape': [ 3 ], + 'strides': [ 1 ], + 'offset': 0 + }; + t.strictEqual( native( [ x, y, scalar( 0.0 ) ] ), y, 'ordinary accepted arrays fall back' ); + t.deepEqual( out, [ 1e16, 1e16, 1.0 ], 'fallback retains compensation' ); + t.strictEqual( calls, count, 'fallback does not invoke addon' ); + x = vector( new Float64Array( 0 ), 0, 1, 0 ); + y = vector( new Float64Array( [ 42.0 ] ), 1, 1, 0 ); + init = { + 'data': null, + 'offset': 0 + }; + t.throws( function invalidScalar() { + native( [ x, y, init ] ); + }, 'empty input still extracts scalar' ); + t.deepEqual( y.data, new Float64Array( [ 42.0 ] ), 'empty failing scalar leaves output untouched' ); + t.strictEqual( native( [ x, y, scalar( 2.0 ) ] ), y, 'empty valid scalar returns output' ); + t.strictEqual( calls, count, 'empty uses original fallback' ); + t.end(); +});