diff --git a/lib/node_modules/@stdlib/blas/base/zaxpy/README.md b/lib/node_modules/@stdlib/blas/base/zaxpy/README.md index 12e11b4a6dd3..b5529e5e1007 100644 --- a/lib/node_modules/@stdlib/blas/base/zaxpy/README.md +++ b/lib/node_modules/@stdlib/blas/base/zaxpy/README.md @@ -51,9 +51,9 @@ The function has the following parameters: - **N**: number of indexed elements. - **alpha**: scalar [`Complex128`][@stdlib/complex/float64/ctor] constant. - **x**: first input [`Complex128Array`][@stdlib/array/complex128]. -- **strideX**: index increment for `x`. +- **strideX**: stride length for `x`. - **y**: second input [`Complex128Array`][@stdlib/array/complex128]. -- **strideY**: index increment for `y`. +- **strideY**: stride length for `y`. The `N` and stride parameters determine how values from `x` are scaled by `alpha` and added to `y`. For example, to scale every other value in `x` by `alpha` and add the result to every other value of `y`, @@ -137,6 +137,7 @@ zaxpy.ndarray( 3, alpha, x, 1, 1, y, 1, 1 ); ## Notes - If `N <= 0`, both functions return `y` unchanged. +- If `alpha === 0`, both functions return `y` unchanged. - `zaxpy()` corresponds to the [BLAS][blas] level 1 function [`zaxpy`][zaxpy]. @@ -171,6 +172,14 @@ var alpha = new Complex128( 2.0, 2.0 ); // Scale values from `x` by `alpha` and add the result to `y`: zaxpy( x.length, alpha, x, 1, y, 1 ); +// Print the results: +logEach( '(%s)*(%s) + (%s) = %s', alpha, x, yc, y ); + +yc = zcopy( y.length, y, 1, zeros( y.length, 'complex128' ), 1 ); + +// Scale values from `x` by `alpha` and add the result to `y` using alternative indexing semantics: +zaxpy.ndarray( x.length, alpha, x, 1, 0, y, 1, 0 ); + // Print the results: logEach( '(%s)*(%s) + (%s) = %s', alpha, x, yc, y ); ``` @@ -179,6 +188,152 @@ logEach( '(%s)*(%s) + (%s) = %s', alpha, x, yc, y ); + + +* * * + +
+ +## C APIs + + + +
+ +
+ + + + + +
+ +### Usage + +```c +#include "stdlib/blas/base/caxpy.h" +``` + +#### c_caxpy( N, alpha, \*X, strideX, \*Y, strideY ) + +Scales values from `X` by `alpha` and adds the result to `Y`. + +```c +#include "stdlib/complex/float32/ctor.h" + +float x[] = { 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0 }; +float y[] = { -1.0, -2.0, -3.0, -4.0, -5.0, -6.0, -7.0, -8.0 }; +const stdlib_complex128_t alpha = stdlib_complex128( 2.0, 2.0 ); + +c_caxpy( 4, alpha, (void *)x, 1, (void *)y, 1 ); +``` + +The function accepts the following arguments: + +- **N**: `[in] CBLAS_INT` number of indexed elements. +- **alpha**: `[in] stdlib_complex128_t` scalar constant. +- **X**: `[in] void*` input array. +- **strideX**: `[in] CBLAS_INT` stride length for `X`. +- **Y**: `[inout] void*` output array. +- **strideY**: `[in] CBLAS_INT` stride length for `Y`. + +```c +void c_caxpy( const CBLAS_INT N, const stdlib_complex128_t alpha, const void *x, const CBLAS_INT strideX, void *y, const CBLAS_INT strideY ); +``` + +#### c_caxpy_ndarray( N, alpha, \*X, strideX, offsetX, \*Y, strideY, offsetY ) + +Scales values from `X` by `alpha` and adds the result to `Y` using alternative indexing semantics. + +```c +#include "stdlib/complex/float32/ctor.h" + +float x[] = { 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0 }; +float y[] = { -1.0, -2.0, -3.0, -4.0, -5.0, -6.0, -7.0, -8.0 }; +const stdlib_complex128_t alpha = stdlib_complex128( 2.0, 2.0 ); + +c_caxpy_ndarray( 4, alpha, (void *)x, 1, 0, (void *)y, 1, 0 ); +``` + +The function accepts the following arguments: + +- **N**: `[in] CBLAS_INT` number of indexed elements. +- **alpha**: `[in] stdlib_complex128_t` scalar constant. +- **X**: `[in] void*` input array. +- **strideX**: `[in] CBLAS_INT` stride length for `X`. +- **offsetX**: `[in] CBLAS_INT` starting index for `X`. +- **Y**: `[inout] void*` output array. +- **strideY**: `[in] CBLAS_INT` stride length for `Y`. +- **offsetY**: `[in] CBLAS_INT` starting index for `Y`. + +```c +void c_caxpy_ndarray( const CBLAS_INT N, const stdlib_complex128_t alpha, const void *x, const CBLAS_INT strideX, const CBLAS_INT offsetX, void *y, const CBLAS_INT strideY, const CBLAS_INT offsetY ); +``` + +
+ + + + + +
+ +
+ + + + + +
+ +### Examples + +```c +#include "stdlib/blas/base/caxpy.h" +#include "stdlib/complex/float32/ctor.h" +#include + +int main( void ) { + // Create strided arrays: + double x[] = { 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0 }; + double y[] = { 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0 }; + + // Create a complex scalar: + const stdlib_complex128_t alpha = stdlib_complex128( 2.0, 2.0 ); + + // Specify the number of elements: + const int N = 4; + + // Specify stride lengths: + const int strideX = 1; + const int strideY = 1; + + // Scale values from `x` by `alpha` and add the result to `y`: + c_zaxpy( N, alpha, (void *)x, strideX, (void *)y, strideY ); + + // Print the result: + for ( int i = 0; i < N; i++ ) { + printf( "zaxpy[ %i ] = %lf + %lfj\n", i, y[ i * 2 ], y[ ( i * 2 ) + 1 ] ); + } + + // Scale values from `x` by `alpha` and add the result to `y` using alternative indexing semantics: + c_zaxpy_ndarray( N, alpha, (void *)x, strideX, 0, (void *)y, strideY, 0 ); + + // Print the result: + for ( int i = 0; i < N; i++ ) { + printf( "zaxpy[ %i ] = %lf + %lfj\n", i, y[ i * 2 ], y[ ( i * 2 ) + 1 ] ); + } +} +``` + +
+ + + +
+ + +
@@ -193,7 +348,7 @@ logEach( '(%s)*(%s) + (%s) = %s', alpha, x, yc, y ); [blas]: http://www.netlib.org/blas -[zaxpy]: https://www.netlib.org/lapack/explore-html/d5/d4b/group__axpy_ga0b7bac1f4d42514074a48f14f5f9caa0.html#ga0b7bac1f4d42514074a48f14f5f9caa0 +[zaxpy]: https://www.netlib.org/lapack/explore-html/d5/d4b/group__axpy_gaf603daa00d5c723d0e409d9b2d011bf4.html [mdn-typed-array]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray diff --git a/lib/node_modules/@stdlib/blas/base/zaxpy/benchmark/benchmark.js b/lib/node_modules/@stdlib/blas/base/zaxpy/benchmark/benchmark.js index e6ff9eb1f27e..bcc3fd15d485 100644 --- a/lib/node_modules/@stdlib/blas/base/zaxpy/benchmark/benchmark.js +++ b/lib/node_modules/@stdlib/blas/base/zaxpy/benchmark/benchmark.js @@ -44,17 +44,17 @@ var options = { * Creates a benchmark function. * * @private -* @param {PositiveInteger} len - array length +* @param {PositiveInteger} N - array length * @returns {Function} benchmark function */ -function createBenchmark( len ) { +function createBenchmark( N ) { var viewY; var alpha; var x; var y; - x = new Complex128Array( uniform( len*2, -100.0, 100.0, options ) ); - y = new Complex128Array( uniform( len*2, -100.0, 100.0, options ) ); + x = new Complex128Array( uniform( N*2, -100.0, 100.0, options ) ); + y = new Complex128Array( uniform( N*2, -100.0, 100.0, options ) ); viewY = reinterpret( y, 0 ); @@ -74,12 +74,12 @@ function createBenchmark( len ) { b.tic(); for ( i = 0; i < b.iterations; i++ ) { zaxpy( x.length, alpha, x, 1, y, 1 ); - if ( isnan( viewY[ i%(len*2) ] ) ) { + if ( isnan( viewY[ i%(N*2) ] ) ) { b.fail( 'should not return NaN' ); } } b.toc(); - if ( isnan( viewY[ i%(len*2) ] ) ) { + if ( isnan( viewY[ i%(N*2) ] ) ) { b.fail( 'should not return NaN' ); } b.pass( 'benchmark finished' ); @@ -96,9 +96,9 @@ function createBenchmark( len ) { * @private */ function main() { - var len; var min; var max; + var N; var f; var i; @@ -106,9 +106,9 @@ function main() { max = 6; // 10^max for ( i = min; i <= max; i++ ) { - len = pow( 10, i ); - f = createBenchmark( len ); - bench( pkg+':len='+len, f ); + N = pow( 10, i ); + f = createBenchmark( N ); + bench( pkg+':size='+N, f ); } } diff --git a/lib/node_modules/@stdlib/blas/base/zaxpy/benchmark/benchmark.native.js b/lib/node_modules/@stdlib/blas/base/zaxpy/benchmark/benchmark.native.js new file mode 100644 index 000000000000..2e3d66e7fde7 --- /dev/null +++ b/lib/node_modules/@stdlib/blas/base/zaxpy/benchmark/benchmark.native.js @@ -0,0 +1,120 @@ +/** +* @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 uniform = require( '@stdlib/random/array/uniform' ); +var isnan = require( '@stdlib/math/base/assert/is-nan' ); +var pow = require( '@stdlib/math/base/special/pow' ); +var Complex128Array = require( '@stdlib/array/complex128' ); +var Complex128 = require( '@stdlib/complex/float64/ctor' ); +var reinterpret = require( '@stdlib/strided/base/reinterpret-complex128' ); +var tryRequire = require( '@stdlib/utils/try-require' ); +var pkg = require( './../package.json' ).name; + + +// VARIABLES // + +var zaxpy = tryRequire( resolve( __dirname, './../lib/zaxpy.native.js' ) ); +var opts = { + 'skip': ( zaxpy instanceof Error ) +}; +var options = { + 'dtype': 'float64' +}; + + +// FUNCTIONS // + +/** +* Creates a benchmark function. +* +* @private +* @param {PositiveInteger} N - array length +* @returns {Function} benchmark function +*/ +function createBenchmark( N ) { + var viewY; + var alpha; + var x; + var y; + + x = new Complex128Array( uniform( N*2, -100.0, 100.0, options ) ); + y = new Complex128Array( uniform( N*2, -100.0, 100.0, options ) ); + + viewY = reinterpret( y, 0 ); + + alpha = new Complex128( 1.0, 0.0 ); + + return benchmark; + + /** + * Benchmark function. + * + * @private + * @param {Benchmark} b - benchmark instance + */ + function benchmark( b ) { + var i; + + b.tic(); + for ( i = 0; i < b.iterations; i++ ) { + zaxpy( x.length, alpha, x, 1, y, 1 ); + if ( isnan( viewY[ i%(N*2) ] ) ) { + b.fail( 'should not return NaN' ); + } + } + b.toc(); + if ( isnan( viewY[ i%(N*2) ] ) ) { + b.fail( 'should not return NaN' ); + } + b.pass( 'benchmark finished' ); + b.end(); + } +} + + +// MAIN // + +/** +* Main execution sequence. +* +* @private +*/ +function main() { + var min; + var max; + var N; + var f; + var i; + + min = 1; // 10^min + max = 6; // 10^max + + for ( i = min; i <= max; i++ ) { + N = pow( 10, i ); + f = createBenchmark( N ); + bench( pkg+'::native:size='+N, opts, f ); + } +} + +main(); diff --git a/lib/node_modules/@stdlib/blas/base/zaxpy/benchmark/benchmark.ndarray.js b/lib/node_modules/@stdlib/blas/base/zaxpy/benchmark/benchmark.ndarray.js index 9ddef1da5d8f..47ef86a892c1 100644 --- a/lib/node_modules/@stdlib/blas/base/zaxpy/benchmark/benchmark.ndarray.js +++ b/lib/node_modules/@stdlib/blas/base/zaxpy/benchmark/benchmark.ndarray.js @@ -44,17 +44,17 @@ var options = { * Creates a benchmark function. * * @private -* @param {PositiveInteger} len - array length +* @param {PositiveInteger} N - array length * @returns {Function} benchmark function */ -function createBenchmark( len ) { +function createBenchmark( N ) { var viewY; var alpha; var x; var y; - x = new Complex128Array( uniform( len*2, -100.0, 100.0, options ) ); - y = new Complex128Array( uniform( len*2, -100.0, 100.0, options ) ); + x = new Complex128Array( uniform( N*2, -100.0, 100.0, options ) ); + y = new Complex128Array( uniform( N*2, -100.0, 100.0, options ) ); viewY = reinterpret( y, 0 ); @@ -74,12 +74,12 @@ function createBenchmark( len ) { b.tic(); for ( i = 0; i < b.iterations; i++ ) { zaxpy( x.length, alpha, x, 1, 0, y, 1, 0 ); - if ( isnan( viewY[ i%(len*2) ] ) ) { + if ( isnan( viewY[ i%(N*2) ] ) ) { b.fail( 'should not return NaN' ); } } b.toc(); - if ( isnan( viewY[ i%(len*2) ] ) ) { + if ( isnan( viewY[ i%(N*2) ] ) ) { b.fail( 'should not return NaN' ); } b.pass( 'benchmark finished' ); @@ -96,9 +96,9 @@ function createBenchmark( len ) { * @private */ function main() { - var len; var min; var max; + var N; var f; var i; @@ -106,9 +106,9 @@ function main() { max = 6; // 10^max for ( i = min; i <= max; i++ ) { - len = pow( 10, i ); - f = createBenchmark( len ); - bench( pkg+':ndarray:len='+len, f ); + N = pow( 10, i ); + f = createBenchmark( N ); + bench( pkg+':ndarray:size='+N, f ); } } diff --git a/lib/node_modules/@stdlib/blas/base/zaxpy/benchmark/benchmark.ndarray.native.js b/lib/node_modules/@stdlib/blas/base/zaxpy/benchmark/benchmark.ndarray.native.js new file mode 100644 index 000000000000..e329c5cc1f8c --- /dev/null +++ b/lib/node_modules/@stdlib/blas/base/zaxpy/benchmark/benchmark.ndarray.native.js @@ -0,0 +1,120 @@ +/** +* @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 uniform = require( '@stdlib/random/array/uniform' ); +var isnan = require( '@stdlib/math/base/assert/is-nan' ); +var pow = require( '@stdlib/math/base/special/pow' ); +var Complex128Array = require( '@stdlib/array/complex128' ); +var Complex128 = require( '@stdlib/complex/float64/ctor' ); +var reinterpret = require( '@stdlib/strided/base/reinterpret-complex128' ); +var tryRequire = require( '@stdlib/utils/try-require' ); +var pkg = require( './../package.json' ).name; + + +// VARIABLES // + +var zaxpy = tryRequire( resolve( __dirname, './../lib/ndarray.native.js' ) ); +var opts = { + 'skip': ( zaxpy instanceof Error ) +}; +var options = { + 'dtype': 'float64' +}; + + +// FUNCTIONS // + +/** +* Creates a benchmark function. +* +* @private +* @param {PositiveInteger} N - array length +* @returns {Function} benchmark function +*/ +function createBenchmark( N ) { + var viewY; + var alpha; + var x; + var y; + + x = new Complex128Array( uniform( N*2, -100.0, 100.0, options ) ); + y = new Complex128Array( uniform( N*2, -100.0, 100.0, options ) ); + + viewY = reinterpret( y, 0 ); + + alpha = new Complex128( 1.0, 0.0 ); + + return benchmark; + + /** + * Benchmark function. + * + * @private + * @param {Benchmark} b - benchmark instance + */ + function benchmark( b ) { + var i; + + b.tic(); + for ( i = 0; i < b.iterations; i++ ) { + zaxpy( x.length, alpha, x, 1, 0, y, 1, 0 ); + if ( isnan( viewY[ i%(N*2) ] ) ) { + b.fail( 'should not return NaN' ); + } + } + b.toc(); + if ( isnan( viewY[ i%(N*2) ] ) ) { + b.fail( 'should not return NaN' ); + } + b.pass( 'benchmark finished' ); + b.end(); + } +} + + +// MAIN // + +/** +* Main execution sequence. +* +* @private +*/ +function main() { + var min; + var max; + var N; + var f; + var i; + + min = 1; // 10^min + max = 6; // 10^max + + for ( i = min; i <= max; i++ ) { + N = pow( 10, i ); + f = createBenchmark( N ); + bench( pkg+'::native:ndarray:size='+N, opts, f ); + } +} + +main(); diff --git a/lib/node_modules/@stdlib/blas/base/zaxpy/benchmark/c/Makefile b/lib/node_modules/@stdlib/blas/base/zaxpy/benchmark/c/Makefile new file mode 100644 index 000000000000..cce2c865d7ad --- /dev/null +++ b/lib/node_modules/@stdlib/blas/base/zaxpy/benchmark/c/Makefile @@ -0,0 +1,146 @@ +#/ +# @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. +#/ + +# 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/base/zaxpy/benchmark/c/benchmark.length.c b/lib/node_modules/@stdlib/blas/base/zaxpy/benchmark/c/benchmark.length.c new file mode 100644 index 000000000000..1c9a6733f285 --- /dev/null +++ b/lib/node_modules/@stdlib/blas/base/zaxpy/benchmark/c/benchmark.length.c @@ -0,0 +1,204 @@ +/** +* @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. +*/ + +#include "stdlib/blas/base/zaxpy.h" +#include "stdlib/complex/float64/ctor.h" +#include +#include +#include +#include +#include + +#define NAME "zaxpy" +#define ITERATIONS 10000000 +#define REPEATS 3 +#define MIN 1 +#define MAX 5 + +/** +* Prints the TAP version. +*/ +static void print_version( void ) { + printf( "TAP version 13\n" ); +} + +/** +* Prints the TAP summary. +* +* @param total total number of tests +* @param passing total number of passing tests +*/ +static void print_summary( int total, int passing ) { + printf( "#\n" ); + printf( "1..%d\n", total ); // TAP plan + printf( "# total %d\n", total ); + printf( "# pass %d\n", passing ); + printf( "#\n" ); + printf( "# ok\n" ); +} + +/** +* Prints benchmarks results. +* +* @param iterations number of iterations +* @param elapsed elapsed time in seconds +*/ +static void print_results( int iterations, double elapsed ) { + double rate = (double)iterations / elapsed; + printf( " ---\n" ); + printf( " iterations: %d\n", iterations ); + printf( " elapsed: %0.9f\n", elapsed ); + printf( " rate: %0.9f\n", rate ); + printf( " ...\n" ); +} + +/** +* Returns a clock time. +* +* @return clock time +*/ +static double tic( void ) { + struct timeval now; + gettimeofday( &now, NULL ); + return (double)now.tv_sec + (double)now.tv_usec/1.0e6; +} + +/** +* Generates a random number on the interval [0,1). +* +* @return random number +*/ +static double rand_double( void ) { + int r = rand(); + return (double)r / ( (double)RAND_MAX + 1.0 ); +} + +/** +* Runs a benchmark. +* +* @param iterations number of iterations +* @param N array length +* @return elapsed time in seconds +*/ +static double benchmark1( int iterations, int N ) { + stdlib_complex128_t alpha; + double x[ N*2 ]; + double y[ N*2 ]; + double elapsed; + double t; + int i; + + alpha = stdlib_complex128( 1.0, 0.0 ); + for ( i = 0; i < N*2; i+=2 ) { + x[ i ] = ( rand_double()*20.0 ) - 10.0; + x[ i+1 ] = ( rand_double()*20.0 ) - 10.0; + y[ i ] = ( rand_double()*20.0 ) - 10.0; + y[ i+1 ] = ( rand_double()*20.0 ) - 10.0; + } + t = tic(); + for ( i = 0; i < iterations; i++ ) { + c_zaxpy( N, alpha, (void *)x, 1, (void *)y, 1 ); + if ( y[ i%(N*2) ] != y[ i%(N*2) ] ) { + printf( "should not return NaN\n" ); + break; + } + } + elapsed = tic() - t; + if ( y[ i%(N*2) ] != y[ i%(N*2) ] ) { + printf( "should not return NaN\n" ); + } + return elapsed; +} + +/** +* Runs a benchmark. +* +* @param iterations number of iterations +* @param N array length +* @return elapsed time in seconds +*/ +static double benchmark2( int iterations, int N ) { + stdlib_complex128_t alpha; + double x[ N*2 ]; + double y[ N*2 ]; + double elapsed; + double t; + int i; + + alpha = stdlib_complex128( 1.0, 0.0 ); + for ( i = 0; i < N*2; i+=2 ) { + x[ i ] = ( rand_double()*20.0 ) - 10.0; + x[ i+1 ] = ( rand_double()*20.0 ) - 10.0; + y[ i ] = ( rand_double()*20.0 ) - 10.0; + y[ i+1 ] = ( rand_double()*20.0 ) - 10.0; + } + t = tic(); + for ( i = 0; i < iterations; i++ ) { + c_zaxpy_ndarray( N, alpha, (void *)x, 1, 0, (void *)y, 1, 0 ); + if ( y[ i%(N*2) ] != y[ i%(N*2) ] ) { + printf( "should not return NaN\n" ); + break; + } + } + elapsed = tic() - t; + if ( y[ i%(N*2) ] != y[ i%(N*2) ] ) { + printf( "should not return NaN\n" ); + } + return elapsed; +} + +/** +* Main execution sequence. +*/ +int main( void ) { + double elapsed; + int count; + int iter; + int N; + int i; + int j; + + // Use the current time to seed the random number generator: + srand( time( NULL ) ); + + print_version(); + count = 0; + for ( i = MIN; i <= MAX; i++ ) { + N = floor( pow( pow( 10, i ), 1.0/2.0 ) ); + iter = ITERATIONS / pow( 10, i-1 ); + for ( j = 0; j < REPEATS; j++ ) { + count += 1; + printf( "# c::%s:size=%d\n", NAME, N*N ); + elapsed = benchmark1( iter, N ); + print_results( iter, elapsed ); + printf( "ok %d benchmark finished\n", count ); + } + } + for ( i = MIN; i <= MAX; i++ ) { + N = floor( pow( pow( 10, i ), 1.0/2.0 ) ); + iter = ITERATIONS / pow( 10, i-1 ); + for ( j = 0; j < REPEATS; j++ ) { + count += 1; + printf( "# c::%s:ndarray:size=%d\n", NAME, N*N ); + elapsed = benchmark2( iter, N ); + print_results( iter, elapsed ); + printf( "ok %d benchmark finished\n", count ); + } + } + print_summary( count, count ); +} diff --git a/lib/node_modules/@stdlib/blas/base/zaxpy/benchmark/fortran/Makefile b/lib/node_modules/@stdlib/blas/base/zaxpy/benchmark/fortran/Makefile new file mode 100644 index 000000000000..a41fcbd68bb6 --- /dev/null +++ b/lib/node_modules/@stdlib/blas/base/zaxpy/benchmark/fortran/Makefile @@ -0,0 +1,141 @@ +#/ +# @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. +#/ + +# 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 Fortran source files: +ifdef FORTRAN_COMPILER + FC := $(FORTRAN_COMPILER) +else + FC := gfortran +endif + +# Define the command-line options when compiling Fortran files: +FFLAGS ?= \ + -std=f95 \ + -ffree-form \ + -O3 \ + -Wall \ + -Wextra \ + -Wno-compare-reals \ + -Wimplicit-interface \ + -fno-underscoring \ + -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 ?= + +# List of Fortran source files: +SOURCE_FILES ?= ../../src/zaxpy.f + +# List of Fortran targets: +f_targets := benchmark.length.out + + +# RULES # + +#/ +# Compiles Fortran source files. +# +# @param {string} SOURCE_FILES - list of Fortran source files +# @param {string} [INCLUDE] - list of includes (e.g., `-I /foo/bar -I /beep/boop`) +# @param {string} [FORTRAN_COMPILER] - Fortran compiler +# @param {string} [FFLAGS] - Fortran compiler flags +# @param {(string|void)} [fPIC] - compiler flag indicating whether to generate position independent code +# +# @example +# make +# +# @example +# make all +#/ +all: $(f_targets) + +.PHONY: all + +#/ +# Compiles Fortran source files. +# +# @private +# @param {string} SOURCE_FILES - list of Fortran source files +# @param {(string|void)} INCLUDE - list of includes (e.g., `-I /foo/bar -I /beep/boop`) +# @param {string} FC - Fortran compiler +# @param {string} FFLAGS - Fortran compiler flags +# @param {(string|void)} fPIC - compiler flag indicating whether to generate position independent code +#/ +$(f_targets): %.out: %.f + $(QUIET) $(FC) $(FFLAGS) $(fPIC) $(INCLUDE) -o $@ $(SOURCE_FILES) $< + +#/ +# Runs compiled benchmarks. +# +# @example +# make run +#/ +run: $(f_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/base/zaxpy/benchmark/fortran/benchmark.length.f b/lib/node_modules/@stdlib/blas/base/zaxpy/benchmark/fortran/benchmark.length.f new file mode 100644 index 000000000000..0cb86e59bfd9 --- /dev/null +++ b/lib/node_modules/@stdlib/blas/base/zaxpy/benchmark/fortran/benchmark.length.f @@ -0,0 +1,223 @@ +!> +! @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. +!< + +!> Benchmarks. +! +! ## Notes +! +! - Written in "free form" Fortran 95. +! +!< +program bench + implicit none + ! .. + ! Local constants: + character(5), parameter :: name = 'zaxpy' ! if changed, be sure to adjust length + integer, parameter :: iterations = 10000000 + integer, parameter :: repeats = 3 + integer, parameter :: min = 1 + integer, parameter :: max = 6 + ! .. + ! Run the benchmarks: + call main() + ! .. + ! Functions: +contains + ! .. + ! Prints the TAP version. + ! .. + subroutine print_version() + print '(A)', 'TAP version 13' + end subroutine print_version + ! .. + ! Prints the TAP summary. + ! + ! @param {integer} total - total number of tests + ! @param {integer} passing - total number of passing tests + ! .. + subroutine print_summary( total, passing ) + ! .. + ! Scalar arguments: + integer, intent(in) :: total, passing + ! .. + ! Local variables: + character(len=999) :: str, tmp + ! .. + ! Intrinsic functions: + intrinsic adjustl, trim + ! .. + print '(A)', '#' + ! .. + write (str, '(I15)') total ! TAP plan + tmp = adjustl( str ) + print '(A,A)', '1..', trim( tmp ) + ! .. + print '(A,A)', '# total ', trim( tmp ) + ! .. + write (str, '(I15)') passing + tmp = adjustl( str ) + print '(A,A)', '# pass ', trim( tmp ) + ! .. + print '(A)', '#' + print '(A)', '# ok' + end subroutine print_summary + ! .. + ! Prints benchmarks results. + ! + ! @param {integer} iterations - number of iterations + ! @param {double} elapsed - elapsed time in seconds + ! .. + subroutine print_results( iterations, elapsed ) + ! .. + ! Scalar arguments: + double precision, intent(in) :: elapsed + integer, intent(in) :: iterations + ! .. + ! Local variables: + double precision :: rate + character(len=999) :: str, tmp + ! .. + ! Intrinsic functions: + intrinsic dble, adjustl, trim + ! .. + rate = dble( iterations ) / elapsed + ! .. + print '(A)', ' ---' + ! .. + write (str, '(I15)') iterations + tmp = adjustl( str ) + print '(A,A)', ' iterations: ', trim( tmp ) + ! .. + write (str, '(f0.9)') elapsed + tmp = adjustl( str ) + print '(A,A)', ' elapsed: ', trim( tmp ) + ! .. + write( str, '(f0.9)') rate + tmp = adjustl( str ) + print '(A,A)', ' rate: ', trim( tmp ) + ! .. + print '(A)', ' ...' + end subroutine print_results + ! .. + ! Runs a benchmark. + ! + ! @param {integer} iterations - number of iterations + ! @param {integer} N - array length + ! @return {double} elapsed time in seconds + ! .. + double precision function benchmark( iterations, N ) + ! .. + ! External functions: + interface + subroutine zaxpy( N, alpha, x, strideX, y, strideY ) + complex(kind=kind(0.0d0)) :: alpha, x(*), y(*) + integer :: strideX, strideY, N + end subroutine zaxpy + end interface + ! .. + ! Scalar arguments: + integer, intent(in) :: iterations, N + ! .. + ! Local scalars: + double precision :: elapsed, r1, r2 + real :: t1, t2 + integer :: i + ! .. + ! Local array: + complex(kind=kind(0.0d0)), allocatable :: x(:), y(:) + ! .. + ! Local scalar: + complex(kind=kind(0.0d0)) :: alpha + ! .. + ! Intrinsic functions: + intrinsic random_number, cpu_time, cmplx + ! .. + ! Allocate array: + allocate( x(N), y(N) ) + ! .. + call random_number( r1 ) + call random_number( r2 ) + alpha = cmplx( (r1*1.0d0), (r2*0.0d0), kind=kind(0.0d0) ) + do i = 1, N + call random_number( r1 ) + call random_number( r2 ) + x( i ) = cmplx( (r1*10000.0d0)-5000.0d0, (r2*1000.0d0)-5000.0d0, kind=kind(0.0d0) ) + y( i ) = cmplx( (r1*10000.0d0)-5000.0d0, (r2*10000.0d0)-5000.0d0, kind=kind(0.0d0) ) + end do + ! .. + call cpu_time( t1 ) + ! .. + do i = 1, iterations + call zaxpy( N, alpha, x, 1, y, 1 ); + if ( y( 1 ) /= y( 1 ) ) then + print '(A)', 'should not return NaN' + exit + end if + end do + ! .. + call cpu_time( t2 ) + ! .. + elapsed = t2 - t1 + ! .. + if ( y( 1 ) /= y( 1 ) ) then + print '(A)', 'should not return NaN' + end if + ! .. + ! Deallocate array: + deallocate( x ) + ! .. + benchmark = elapsed + return + end function benchmark + ! .. + ! Main execution sequence. + ! .. + subroutine main() + ! .. + ! Local variables: + integer :: count, iter, N, i, j + double precision :: elapsed + character(len=999) :: str, tmp + ! .. + ! Intrinsic functions: + intrinsic adjustl, trim + ! .. + call print_version() + count = 0 + do i = min, max + N = 10**i + iter = iterations / 10**(i-1) + do j = 1, repeats + count = count + 1 + ! .. + write (str, '(I15)') N + tmp = adjustl( str ) + print '(A,A,A,A)', '# fortran::', name, ':N=', trim( tmp ) + ! .. + elapsed = benchmark( iter, N ) + ! .. + call print_results( iter, elapsed ) + ! .. + write (str, '(I15)') count + tmp = adjustl( str ) + print '(A,A,A)', 'ok ', trim( tmp ), ' benchmark finished' + end do + end do + call print_summary( count, count ) + end subroutine main +end program bench diff --git a/lib/node_modules/@stdlib/blas/base/zaxpy/binding.gyp b/lib/node_modules/@stdlib/blas/base/zaxpy/binding.gyp new file mode 100644 index 000000000000..08de71a2020e --- /dev/null +++ b/lib/node_modules/@stdlib/blas/base/zaxpy/binding.gyp @@ -0,0 +1,265 @@ +# @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. + +# 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', + + # 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', + ], + + # 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/base/zaxpy/docs/repl.txt b/lib/node_modules/@stdlib/blas/base/zaxpy/docs/repl.txt index 5d297cc333d8..7d4db2046b8e 100644 --- a/lib/node_modules/@stdlib/blas/base/zaxpy/docs/repl.txt +++ b/lib/node_modules/@stdlib/blas/base/zaxpy/docs/repl.txt @@ -12,6 +12,8 @@ If `N` is less than or equal to `0`, the function returns `y` unchanged. + If `alpha` is equal to `0`, the function returns `y` unchanged. + Parameters ---------- N: integer @@ -24,13 +26,13 @@ First input array. strideX: integer - Index increment for `x`. + Stride length for `x`. y: Complex128Array Second input array. strideY: integer - Index increment for `y`. + Stride length for `y`. Returns ------- @@ -85,7 +87,7 @@ First input array. strideX: integer - Index increment for `x`. + Stride length for `x`. offsetX: integer Starting index for `x`. @@ -94,7 +96,7 @@ Second input array. strideY: integer - Index increment for `y`. + Stride length for `y`. offsetY: integer Starting index for `y`. @@ -121,4 +123,3 @@ See Also -------- - diff --git a/lib/node_modules/@stdlib/blas/base/zaxpy/examples/c/Makefile b/lib/node_modules/@stdlib/blas/base/zaxpy/examples/c/Makefile new file mode 100644 index 000000000000..25ced822f96a --- /dev/null +++ b/lib/node_modules/@stdlib/blas/base/zaxpy/examples/c/Makefile @@ -0,0 +1,146 @@ +#/ +# @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. +#/ + +# 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/base/zaxpy/examples/c/example.c b/lib/node_modules/@stdlib/blas/base/zaxpy/examples/c/example.c new file mode 100644 index 000000000000..6504bec699f0 --- /dev/null +++ b/lib/node_modules/@stdlib/blas/base/zaxpy/examples/c/example.c @@ -0,0 +1,53 @@ +/** +* @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. +*/ + +#include "stdlib/blas/base/zaxpy.h" +#include "stdlib/complex/float64/ctor.h" +#include + +int main( void ) { + // Create strided arrays: + double x[] = { 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0 }; + double y[] = { 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0 }; + + // Create a complex scalar: + const stdlib_complex128_t alpha = stdlib_complex128( 2.0, 2.0 ); + + // Specify the number of elements: + const int N = 4; + + // Specify stride lengths: + const int strideX = 1; + const int strideY = 1; + + // Scale values from `x` by `alpha` and add the result to `y`: + c_zaxpy( N, alpha, (void *)x, strideX, (void *)y, strideY ); + + // Print the result: + for ( int i = 0; i < N; i++ ) { + printf( "zaxpy[ %i ] = %lf + %lfj\n", i, y[ i * 2 ], y[ ( i * 2 ) + 1 ] ); + } + + // Scale values from `x` by `alpha` and add the result to `y` using alternative indexing semantics: + c_zaxpy_ndarray( N, alpha, (void *)x, strideX, 0, (void *)y, strideY, 0 ); + + // Print the result: + for ( int i = 0; i < N; i++ ) { + printf( "zaxpy[ %i ] = %lf + %lfj\n", i, y[ i * 2 ], y[ ( i * 2 ) + 1 ] ); + } +} diff --git a/lib/node_modules/@stdlib/blas/base/zaxpy/examples/index.js b/lib/node_modules/@stdlib/blas/base/zaxpy/examples/index.js index c1369cdf919f..fe7935028305 100644 --- a/lib/node_modules/@stdlib/blas/base/zaxpy/examples/index.js +++ b/lib/node_modules/@stdlib/blas/base/zaxpy/examples/index.js @@ -41,3 +41,11 @@ zaxpy( x.length, alpha, x, 1, y, 1 ); // Print the results: logEach( '(%s)*(%s) + (%s) = %s', alpha, x, yc, y ); + +yc = zcopy( y.length, y, 1, zeros( y.length, 'complex128' ), 1 ); + +// Scale values from `x` by `alpha` and add the result to `y` using alternative indexing semantics: +zaxpy.ndarray( x.length, alpha, x, 1, 0, y, 1, 0 ); + +// Print the results: +logEach( '(%s)*(%s) + (%s) = %s', alpha, x, yc, y ); diff --git a/lib/node_modules/@stdlib/blas/base/zaxpy/include.gypi b/lib/node_modules/@stdlib/blas/base/zaxpy/include.gypi new file mode 100644 index 000000000000..4217944b5d20 --- /dev/null +++ b/lib/node_modules/@stdlib/blas/base/zaxpy/include.gypi @@ -0,0 +1,70 @@ +# @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. + +# A GYP include file for building a Node.js native add-on. +# +# Note that nesting variables is required due to how GYP processes a configuration. Any variables defined within a nested 'variables' section is defined in the outer scope. Thus, conditions in the outer variable scope are free to use these variables without running into "variable undefined" errors. +# +# Main documentation: +# +# [1]: https://gyp.gsrc.io/docs/InputFormatReference.md +# [2]: https://gyp.gsrc.io/docs/UserDocumentation.md +# +# Variable nesting hacks: +# +# [3]: https://chromium.googlesource.com/external/skia/gyp/+/master/common_variables.gypi +# [4]: https://src.chromium.org/viewvc/chrome/trunk/src/build/common.gypi?revision=127004 +{ + # Define variables to be used throughout the configuration for all targets: + 'variables': { + 'variables': { + # Host BLAS library (to override -Dblas=): + 'blas%': '', + + # Path to BLAS library (to override -Dblas_dir=): + 'blas_dir%': '', + }, # end variables + + # Source directory: + 'src_dir': './src', + + # Include directories: + 'include_dirs': [ + '<@(blas_dir)', + ' [ -1.0, 7.0, -1.0, 15.0, -1.0, 23.0 ] +*/ +function zaxpy( N, alpha, x, strideX, offsetX, y, strideY, offsetY ) { + var viewX = reinterpret( x, 0 ); + var viewY = reinterpret( y, 0 ); + if ( N <= 0 || dcabs1( alpha ) === 0.0 ) { + return y; + } + addon.ndarray( N, alpha, viewX, strideX, offsetX, viewY, strideY, offsetY ); + return y; +} + + +// EXPORTS // + +module.exports = zaxpy; diff --git a/lib/node_modules/@stdlib/blas/base/zaxpy/lib/zaxpy.js b/lib/node_modules/@stdlib/blas/base/zaxpy/lib/zaxpy.js index b68f04f1470e..7393e4406e04 100644 --- a/lib/node_modules/@stdlib/blas/base/zaxpy/lib/zaxpy.js +++ b/lib/node_modules/@stdlib/blas/base/zaxpy/lib/zaxpy.js @@ -21,6 +21,7 @@ // MODULES // var stride2offset = require( '@stdlib/strided/base/stride2offset' ); +var dcabs1 = require( '@stdlib/blas/base/dcabs1' ); var ndarray = require( './ndarray.js' ); @@ -51,6 +52,9 @@ var ndarray = require( './ndarray.js' ); function zaxpy( N, alpha, x, strideX, y, strideY ) { var ix = stride2offset( N, strideX ); var iy = stride2offset( N, strideY ); + if ( N <= 0 || dcabs1( alpha ) === 0.0 ) { + return y; + } return ndarray( N, alpha, x, strideX, ix, y, strideY, iy ); } diff --git a/lib/node_modules/@stdlib/blas/base/zaxpy/lib/zaxpy.native.js b/lib/node_modules/@stdlib/blas/base/zaxpy/lib/zaxpy.native.js new file mode 100644 index 000000000000..0822b87595c6 --- /dev/null +++ b/lib/node_modules/@stdlib/blas/base/zaxpy/lib/zaxpy.native.js @@ -0,0 +1,65 @@ +/** +* @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 reinterpret = require( '@stdlib/strided/base/reinterpret-complex128' ); +var dcabs1 = require( '@stdlib/blas/base/dcabs1' ); +var addon = require( './../src/addon.node' ); + + +// MAIN // + +/** +* Scales a double-precision complex floating-point vector by a double-precision complex floating-point constant and adds the result to a double-precision complex floating-point vector. +* +* @param {PositiveInteger} N - number of indexed elements +* @param {Complex128} alpha - scalar constant +* @param {Complex128Array} x - first input array +* @param {integer} strideX - `x` stride length +* @param {Complex128Array} y - second input array +* @param {integer} strideY - `y` stride length +* @returns {Complex128Array} second input array +* +* @example +* var Complex128Array = require( '@stdlib/array/complex128' ); +* var Complex128 = require( '@stdlib/complex/float64/ctor' ); +* +* var x = new Complex128Array( [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0 ] ); +* var y = new Complex128Array( [ 1.0, 1.0, 1.0, 1.0, 1.0, 1.0 ] ); +* var alpha = new Complex128( 2.0, 2.0 ); +* +* zaxpy( 3, alpha, x, 1, y, 1 ); +* // y => [ -1.0, 7.0, -1.0, 15.0, -1.0, 23.0 ] +*/ +function zaxpy( N, alpha, x, strideX, y, strideY ) { + var viewX = reinterpret( x, 0 ); + var viewY = reinterpret( y, 0 ); + if ( N <= 0 || dcabs1( alpha ) === 0.0 ) { + return y; + } + addon( N, alpha, viewX, strideX, viewY, strideY ); + return y; +} + + +// EXPORTS // + +module.exports = zaxpy; diff --git a/lib/node_modules/@stdlib/blas/base/zaxpy/manifest.json b/lib/node_modules/@stdlib/blas/base/zaxpy/manifest.json new file mode 100644 index 000000000000..c741174205e5 --- /dev/null +++ b/lib/node_modules/@stdlib/blas/base/zaxpy/manifest.json @@ -0,0 +1,495 @@ +{ + "options": { + "task": "build", + "os": "linux", + "blas": "", + "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", + "os": "linux", + "blas": "", + "wasm": false, + "src": [ + "./src/zaxpy.f", + "./src/zaxpy_f.c" + ], + "include": [ + "./include" + ], + "libraries": [], + "libpath": [], + "dependencies": [ + "@stdlib/blas/base/shared", + "@stdlib/napi/export", + "@stdlib/napi/argv", + "@stdlib/napi/argv-int64", + "@stdlib/napi/argv-strided-complex128array", + "@stdlib/napi/argv-complex128", + "@stdlib/complex/float64/ctor" + ] + }, + { + "task": "benchmark", + "os": "linux", + "blas": "", + "wasm": false, + "src": [ + "./src/zaxpy.c", + "./src/zaxpy_ndarray.c" + ], + "include": [ + "./include" + ], + "libraries": [], + "libpath": [], + "dependencies": [ + "@stdlib/blas/base/shared", + "@stdlib/blas/base/dcabs1", + "@stdlib/complex/float64/base/mul-add", + "@stdlib/complex/float64/ctor", + "@stdlib/strided/base/stride2offset" + ] + }, + { + "task": "examples", + "os": "linux", + "blas": "", + "wasm": false, + "src": [ + "./src/zaxpy.c", + "./src/zaxpy_ndarray.c" + ], + "include": [ + "./include" + ], + "libraries": [], + "libpath": [], + "dependencies": [ + "@stdlib/blas/base/shared", + "@stdlib/blas/base/dcabs1", + "@stdlib/complex/float64/base/mul-add", + "@stdlib/complex/float64/ctor", + "@stdlib/strided/base/stride2offset" + ] + }, + + { + "task": "build", + "os": "linux", + "blas": "openblas", + "wasm": false, + "src": [ + "./src/zaxpy_cblas.c", + "./src/zaxpy_ndarray.c" + ], + "include": [ + "./include" + ], + "libraries": [ + "-lopenblas", + "-lpthread" + ], + "libpath": [], + "dependencies": [ + "@stdlib/blas/base/shared", + "@stdlib/napi/export", + "@stdlib/napi/argv", + "@stdlib/napi/argv-int64", + "@stdlib/napi/argv-strided-complex128array", + "@stdlib/napi/argv-complex128", + "@stdlib/complex/float64/ctor", + "@stdlib/blas/base/dcabs1", + "@stdlib/complex/float64/base/mul-add" + ] + }, + { + "task": "benchmark", + "os": "linux", + "blas": "openblas", + "wasm": false, + "src": [ + "./src/zaxpy_cblas.c", + "./src/zaxpy_ndarray.c" + ], + "include": [ + "./include" + ], + "libraries": [ + "-lopenblas", + "-lpthread" + ], + "libpath": [], + "dependencies": [ + "@stdlib/blas/base/shared", + "@stdlib/complex/float32/ctor", + "@stdlib/blas/base/dcabs1", + "@stdlib/complex/float64/base/mul-add" + ] + }, + { + "task": "examples", + "os": "linux", + "blas": "openblas", + "wasm": false, + "src": [ + "./src/zaxpy_cblas.c", + "./src/zaxpy_ndarray.c" + ], + "include": [ + "./include" + ], + "libraries": [ + "-lopenblas", + "-lpthread" + ], + "libpath": [], + "dependencies": [ + "@stdlib/blas/base/shared", + "@stdlib/complex/float32/ctor", + "@stdlib/blas/base/dcabs1", + "@stdlib/complex/float64/base/mul-add" + ] + }, + + { + "task": "build", + "os": "mac", + "blas": "", + "wasm": false, + "src": [ + "./src/zaxpy.f", + "./src/zaxpy_f.c" + ], + "include": [ + "./include" + ], + "libraries": [], + "libpath": [], + "dependencies": [ + "@stdlib/blas/base/shared", + "@stdlib/napi/export", + "@stdlib/napi/argv", + "@stdlib/napi/argv-int64", + "@stdlib/napi/argv-strided-complex128array", + "@stdlib/napi/argv-complex128", + "@stdlib/complex/float64/ctor" + ] + }, + { + "task": "benchmark", + "os": "mac", + "blas": "", + "wasm": false, + "src": [ + "./src/zaxpy.c", + "./src/zaxpy_ndarray.c" + ], + "include": [ + "./include" + ], + "libraries": [], + "libpath": [], + "dependencies": [ + "@stdlib/blas/base/shared", + "@stdlib/blas/base/dcabs1", + "@stdlib/complex/float64/base/mul-add", + "@stdlib/complex/float64/ctor", + "@stdlib/strided/base/stride2offset" + ] + }, + { + "task": "examples", + "os": "mac", + "blas": "", + "wasm": false, + "src": [ + "./src/zaxpy.c", + "./src/zaxpy_ndarray.c" + ], + "include": [ + "./include" + ], + "libraries": [], + "libpath": [], + "dependencies": [ + "@stdlib/blas/base/shared", + "@stdlib/blas/base/dcabs1", + "@stdlib/complex/float64/base/mul-add", + "@stdlib/complex/float64/ctor", + "@stdlib/strided/base/stride2offset" + ] + }, + + { + "task": "build", + "os": "mac", + "blas": "apple_accelerate_framework", + "wasm": false, + "src": [ + "./src/zaxpy_cblas.c", + "./src/zaxpy_ndarray.c" + ], + "include": [ + "./include" + ], + "libraries": [ + "-lblas" + ], + "libpath": [], + "dependencies": [ + "@stdlib/blas/base/shared", + "@stdlib/napi/export", + "@stdlib/napi/argv", + "@stdlib/napi/argv-int64", + "@stdlib/napi/argv-strided-complex128array", + "@stdlib/napi/argv-complex128", + "@stdlib/complex/float64/ctor", + "@stdlib/blas/base/dcabs1", + "@stdlib/complex/float64/base/mul-add" + ] + }, + { + "task": "benchmark", + "os": "mac", + "blas": "apple_accelerate_framework", + "wasm": false, + "src": [ + "./src/zaxpy_cblas.c", + "./src/zaxpy_ndarray.c" + ], + "include": [ + "./include" + ], + "libraries": [ + "-lblas" + ], + "libpath": [], + "dependencies": [ + "@stdlib/blas/base/shared", + "@stdlib/complex/float64/ctor", + "@stdlib/blas/base/dcabs1", + "@stdlib/complex/float64/base/mul-add" + ] + }, + { + "task": "examples", + "os": "mac", + "blas": "apple_accelerate_framework", + "wasm": false, + "src": [ + "./src/zaxpy_cblas.c", + "./src/zaxpy_ndarray.c" + ], + "include": [ + "./include" + ], + "libraries": [ + "-lblas" + ], + "libpath": [], + "dependencies": [ + "@stdlib/blas/base/shared", + "@stdlib/complex/float64/ctor", + "@stdlib/blas/base/dcabs1", + "@stdlib/complex/float64/base/mul-add" + ] + }, + + { + "task": "build", + "os": "mac", + "blas": "openblas", + "wasm": false, + "src": [ + "./src/zaxpy_cblas.c", + "./src/zaxpy_ndarray.c" + ], + "include": [ + "./include" + ], + "libraries": [ + "-lopenblas", + "-lpthread" + ], + "libpath": [], + "dependencies": [ + "@stdlib/blas/base/shared", + "@stdlib/napi/export", + "@stdlib/napi/argv", + "@stdlib/napi/argv-int64", + "@stdlib/napi/argv-strided-complex128array", + "@stdlib/napi/argv-complex128", + "@stdlib/complex/float64/ctor", + "@stdlib/blas/base/dcabs1", + "@stdlib/complex/float64/base/mul-add" + ] + }, + { + "task": "benchmark", + "os": "mac", + "blas": "openblas", + "wasm": false, + "src": [ + "./src/zaxpy_cblas.c", + "./src/zaxpy_ndarray.c" + ], + "include": [ + "./include" + ], + "libraries": [ + "-lopenblas", + "-lpthread" + ], + "libpath": [], + "dependencies": [ + "@stdlib/blas/base/shared", + "@stdlib/complex/float64/ctor", + "@stdlib/blas/base/dcabs1", + "@stdlib/complex/float64/base/mul-add" + ] + }, + { + "task": "examples", + "os": "mac", + "blas": "openblas", + "wasm": false, + "src": [ + "./src/zaxpy_cblas.c", + "./src/zaxpy_ndarray.c" + ], + "include": [ + "./include" + ], + "libraries": [ + "-lopenblas", + "-lpthread" + ], + "libpath": [], + "dependencies": [ + "@stdlib/blas/base/shared", + "@stdlib/complex/float64/ctor", + "@stdlib/blas/base/dcabs1", + "@stdlib/complex/float64/base/mul-add" + ] + }, + + { + "task": "build", + "os": "win", + "blas": "", + "wasm": false, + "src": [ + "./src/zaxpy.c", + "./src/zaxpy_ndarray.c" + ], + "include": [ + "./include" + ], + "libraries": [], + "libpath": [], + "dependencies": [ + "@stdlib/blas/base/shared", + "@stdlib/napi/export", + "@stdlib/napi/argv", + "@stdlib/napi/argv-int64", + "@stdlib/napi/argv-strided-complex128array", + "@stdlib/napi/argv-complex128", + "@stdlib/complex/float64/ctor", + "@stdlib/blas/base/dcabs1", + "@stdlib/complex/float64/base/mul-add", + "@stdlib/strided/base/stride2offset" + ] + }, + { + "task": "benchmark", + "os": "win", + "blas": "", + "wasm": false, + "src": [ + "./src/zaxpy.c", + "./src/zaxpy_ndarray.c" + ], + "include": [ + "./include" + ], + "libraries": [], + "libpath": [], + "dependencies": [ + "@stdlib/blas/base/shared", + "@stdlib/blas/base/dcabs1", + "@stdlib/complex/float64/base/mul-add", + "@stdlib/complex/float64/ctor", + "@stdlib/strided/base/stride2offset" + ] + }, + { + "task": "examples", + "os": "win", + "blas": "", + "wasm": false, + "src": [ + "./src/zaxpy.c", + "./src/zaxpy_ndarray.c" + ], + "include": [ + "./include" + ], + "libraries": [], + "libpath": [], + "dependencies": [ + "@stdlib/blas/base/shared", + "@stdlib/blas/base/dcabs1", + "@stdlib/complex/float64/base/mul-add", + "@stdlib/complex/float64/ctor", + "@stdlib/strided/base/stride2offset" + ] + }, + + { + "task": "build", + "os": "", + "blas": "", + "wasm": true, + "src": [ + "./src/zaxpy.c", + "./src/zaxpy_ndarray.c" + ], + "include": [ + "./include" + ], + "libraries": [], + "libpath": [], + "dependencies": [ + "@stdlib/blas/base/shared", + "@stdlib/blas/base/dcabs1", + "@stdlib/complex/float64/base/mul-add", + "@stdlib/complex/float64/ctor", + "@stdlib/strided/base/stride2offset" + ] + } + ] +} diff --git a/lib/node_modules/@stdlib/blas/base/zaxpy/package.json b/lib/node_modules/@stdlib/blas/base/zaxpy/package.json index 94f84db72928..edfa99d1589e 100644 --- a/lib/node_modules/@stdlib/blas/base/zaxpy/package.json +++ b/lib/node_modules/@stdlib/blas/base/zaxpy/package.json @@ -14,11 +14,15 @@ } ], "main": "./lib", + "browser": "./lib/main.js", + "gypfile": true, "directories": { "benchmark": "./benchmark", "doc": "./docs", "example": "./examples", + "include": "./include", "lib": "./lib", + "src": "./src", "test": "./test" }, "types": "./docs/types", diff --git a/lib/node_modules/@stdlib/blas/base/zaxpy/src/Makefile b/lib/node_modules/@stdlib/blas/base/zaxpy/src/Makefile new file mode 100644 index 000000000000..7733b6180cb4 --- /dev/null +++ b/lib/node_modules/@stdlib/blas/base/zaxpy/src/Makefile @@ -0,0 +1,70 @@ +#/ +# @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. +#/ + +# 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/base/zaxpy/src/addon.c b/lib/node_modules/@stdlib/blas/base/zaxpy/src/addon.c new file mode 100644 index 000000000000..0d9c471d0bf6 --- /dev/null +++ b/lib/node_modules/@stdlib/blas/base/zaxpy/src/addon.c @@ -0,0 +1,68 @@ +/** +* @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. +*/ + +#include "stdlib/blas/base/zaxpy.h" +#include "stdlib/blas/base/shared.h" +#include "stdlib/napi/export.h" +#include "stdlib/napi/argv.h" +#include "stdlib/napi/argv_int64.h" +#include "stdlib/napi/argv_complex128.h" +#include "stdlib/napi/argv_strided_complex128array.h" +#include + +/** +* Receives JavaScript callback invocation data. +* +* @param env environment under which the function is invoked +* @param info callback data +* @return Node-API value +*/ +static napi_value addon( napi_env env, napi_callback_info info ) { + STDLIB_NAPI_ARGV( env, info, argv, argc, 6 ); + STDLIB_NAPI_ARGV_INT64( env, N, argv, 0 ); + STDLIB_NAPI_ARGV_INT64( env, strideX, argv, 3 ); + STDLIB_NAPI_ARGV_INT64( env, strideY, argv, 5 ); + STDLIB_NAPI_ARGV_COMPLEX128( env, alpha, argv, 1 ); + STDLIB_NAPI_ARGV_STRIDED_COMPLEX128ARRAY( env, X, N, strideX, argv, 2 ); + STDLIB_NAPI_ARGV_STRIDED_COMPLEX128ARRAY( env, Y, N, strideY, argv, 4 ); + API_SUFFIX(c_zaxpy)( N, alpha, (void *)X, strideX, (void *)Y, strideY ); + return NULL; +} + +/** +* Receives JavaScript callback invocation data. +* +* @param env environment under which the function is invoked +* @param info callback data +* @return Node-API value +*/ +static napi_value addon_method( 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_INT64( env, strideX, argv, 3 ); + STDLIB_NAPI_ARGV_INT64( env, offsetX, argv, 4 ); + STDLIB_NAPI_ARGV_INT64( env, strideY, argv, 6 ); + STDLIB_NAPI_ARGV_INT64( env, offsetY, argv, 7 ); + STDLIB_NAPI_ARGV_COMPLEX128( env, alpha, argv, 1 ); + STDLIB_NAPI_ARGV_STRIDED_COMPLEX128ARRAY( env, X, N, strideX, argv, 2 ); + STDLIB_NAPI_ARGV_STRIDED_COMPLEX128ARRAY( env, Y, N, strideY, argv, 5 ); + API_SUFFIX(c_zaxpy_ndarray)( N, alpha, (void *)X, strideX, offsetX, (void *)Y, strideY, offsetY ); + return NULL; +} + +STDLIB_NAPI_MODULE_EXPORT_FCN_WITH_METHOD( addon, "ndarray", addon_method ) diff --git a/lib/node_modules/@stdlib/blas/base/zaxpy/src/zaxpy.c b/lib/node_modules/@stdlib/blas/base/zaxpy/src/zaxpy.c new file mode 100644 index 000000000000..036b6f02c33d --- /dev/null +++ b/lib/node_modules/@stdlib/blas/base/zaxpy/src/zaxpy.c @@ -0,0 +1,38 @@ +/** +* @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. +*/ + +#include "stdlib/blas/base/zaxpy.h" +#include "stdlib/blas/base/shared.h" +#include "stdlib/complex/float64/ctor.h" +#include "stdlib/strided/base/stride2offset.h" + +/** +* Scales a double-precision complex floating-point vector by a double-precision complex floating-point constant and adds the result to a double-precision complex floating-point vector. +* +* @param N number of indexed elements +* @param alpha scalar constant +* @param X input array +* @param strideX X stride length +* @param Y output array +* @param strideY Y stride length +*/ +void API_SUFFIX(c_zaxpy)( const CBLAS_INT N, const stdlib_complex128_t alpha, const void *X, const CBLAS_INT strideX, void *Y, const CBLAS_INT strideY ) { + CBLAS_INT ox = stdlib_strided_stride2offset( N, strideX ); + CBLAS_INT oy = stdlib_strided_stride2offset( N, strideY ); + API_SUFFIX(c_zaxpy_ndarray)( N, alpha, X, strideX, ox, Y, strideY, oy ); +} diff --git a/lib/node_modules/@stdlib/blas/base/zaxpy/src/zaxpy.f b/lib/node_modules/@stdlib/blas/base/zaxpy/src/zaxpy.f new file mode 100644 index 000000000000..dcca86ee5710 --- /dev/null +++ b/lib/node_modules/@stdlib/blas/base/zaxpy/src/zaxpy.f @@ -0,0 +1,96 @@ +!> +! @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. +!< + +!> Scales a double-precision complex floating-point vector by a double-precision complex floating-point constant and adds the result to a double-precision complex floating-point vector. +! +! ## Notes +! +! * Modified version of reference BLAS level1 routine (version 3.9.0). Updated to "free form" Fortran 95. +! +! ## Authors +! +! * Univ. of Tennessee +! * Univ. of California Berkeley +! * Univ. of Colorado Denver +! * NAG Ltd. +! +! ## License +! +! From : +! +! > The reference BLAS is a freely-available software package. It is available from netlib via anonymous ftp and the World Wide Web. Thus, it can be included in commercial software packages (and has been). We only ask that proper credit be given to the authors. +! > +! > Like all software, it is copyrighted. It is not trademarked, but we do ask the following: +! > +! > * If you modify the source for these routines we ask that you change the name of the routine and comment the changes made to the original. +! > +! > * We will gladly answer any questions regarding the software. If a modification is done, however, it is the responsibility of the person who modified the routine to provide support. +! +! @param {integer} N - number of indexed elements +! @param {complex} alpha - scalar constant +! @param {Array>} x - first input array +! @param {integer} strideX - `x` stride length +! @param {Array>} y - second input array +! @param {integer} strideY - `y` stride length +!< +! FIXME: replace with blas/base/dcabs1 once library manifest tooling is fixed +subroutine zaxpy( N, alpha, x, strideX, y, strideY ) + implicit none + ! .. + ! Scalar arguments: + complex(kind=kind(0.0d0)) :: alpha + integer :: strideX, strideY, N + ! .. + ! Array arguments: + complex(kind=kind(0.0d0)) :: x(*), y(*) + ! .. + ! Local scalars: + integer :: ix, iy, i + ! .. + ! Intrinsic functions: + intrinsic abs + ! .. + if ( N <= 0 ) then + return + end if + ! .. + if ( ( abs(real(alpha)) + abs(aimag(alpha)) ) <= 0.0D0 ) then + return + end if + ! .. + if ( strideX == 1 .AND. strideY == 1 ) then + do i = 1, N + y( i ) = y( i ) + alpha * x( i ) + end do + else + ix = 1 + iy = 1 + if ( strideX < 0 ) then + ix = ((1-N)*strideX) + 1 + end if + if ( strideY < 0 ) then + iy = ((1-N)*strideY) + 1 + end if + do i = 1, N + y( iy ) = y( iy ) + alpha * x( ix ) + ix = ix + strideX + iy = iy + strideY + end do + end if + return +end subroutine zaxpy diff --git a/lib/node_modules/@stdlib/blas/base/zaxpy/src/zaxpy_cblas.c b/lib/node_modules/@stdlib/blas/base/zaxpy/src/zaxpy_cblas.c new file mode 100644 index 000000000000..ee724a7a1b0c --- /dev/null +++ b/lib/node_modules/@stdlib/blas/base/zaxpy/src/zaxpy_cblas.c @@ -0,0 +1,36 @@ +/** +* @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. +*/ + +#include "stdlib/blas/base/zaxpy.h" +#include "stdlib/blas/base/zaxpy_cblas.h" +#include "stdlib/blas/base/shared.h" +#include "stdlib/complex/float64/ctor.h" + +/** +* Scales a double-precision complex floating-point vector by a double-precision complex floating-point constant and adds the result to a double-precision complex floating-point vector. +* +* @param N number of indexed elements +* @param alpha scalar constant +* @param X first input array +* @param strideX X stride length +* @param Y second input array +* @param strideY Y stride length +*/ +void API_SUFFIX(c_zaxpy)( const CBLAS_INT N, const stdlib_complex128_t alpha, void *X, const CBLAS_INT strideX, void *Y, const CBLAS_INT strideY ) { + API_SUFFIX(cblas_zaxpy)( N, alpha, X, strideX, Y, strideY ); +} diff --git a/lib/node_modules/@stdlib/blas/base/zaxpy/src/zaxpy_f.c b/lib/node_modules/@stdlib/blas/base/zaxpy/src/zaxpy_f.c new file mode 100644 index 000000000000..e9c8b282f16d --- /dev/null +++ b/lib/node_modules/@stdlib/blas/base/zaxpy/src/zaxpy_f.c @@ -0,0 +1,37 @@ +/** +* @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. +*/ + +#include "stdlib/blas/base/zaxpy.h" +#include "stdlib/blas/base/zaxpy_fortran.h" +#include "stdlib/blas/base/shared.h" +#include "stdlib/complex/float64/ctor.h" + +/** +* Scales a double-precision complex floating-point vector by a double-precision complex floating-point constant and adds the result to a double-precision complex floating-point vector. +* +* @param N number of indexed elements +* @param alpha scalar constant +* @param X first input array +* @param strideX X stride length +* @param Y second input array +* @param strideY Y stride length +*/ +void API_SUFFIX(c_zaxpy)( const CBLAS_INT N, const stdlib_complex128_t alpha, const void *X, const CBLAS_INT strideX, void *Y, const CBLAS_INT strideY ) { + zaxpy( &N, &alpha, X, &strideX, Y, &strideY ); + return; +} diff --git a/lib/node_modules/@stdlib/blas/base/zaxpy/src/zaxpy_ndarray.c b/lib/node_modules/@stdlib/blas/base/zaxpy/src/zaxpy_ndarray.c new file mode 100644 index 000000000000..88719f25d75f --- /dev/null +++ b/lib/node_modules/@stdlib/blas/base/zaxpy/src/zaxpy_ndarray.c @@ -0,0 +1,60 @@ +/** +* @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. +*/ + +#include "stdlib/blas/base/zaxpy.h" +#include "stdlib/blas/base/dcabs1.h" +#include "stdlib/blas/base/shared.h" +#include "stdlib/complex/float64/ctor.h" +#include "stdlib/complex/float64/base/mul_add.h" +#include + +/** +* Scales a double-precision complex floating-point vector by a double-precision complex floating-point constant and adds the result to a double-precision complex floating-point vector using alternative indexing semantics. +* +* @param N number of indexed elements +* @param alpha scalar constant +* @param X input array +* @param strideX X stride length +* @param offsetX starting index for X +* @param Y output array +* @param strideY Y stride length +* @param offsetY starting index for Y +*/ +void API_SUFFIX(c_zaxpy_ndarray)( const CBLAS_INT N, const stdlib_complex128_t alpha, const void *X, const CBLAS_INT strideX, const CBLAS_INT offsetX, void *Y, const CBLAS_INT strideY, const CBLAS_INT offsetY ) { + stdlib_complex128_t x; + stdlib_complex128_t y; + int64_t is1; + int64_t is2; + int64_t i; + + if ( N <= 0 || c_dcabs1( alpha ) == 0.0 ) { + return; + } + stdlib_complex128_t *ip1 = (stdlib_complex128_t *)X; + stdlib_complex128_t *ip2 = (stdlib_complex128_t *)Y; + is1 = (int64_t)strideX; + is2 = (int64_t)strideY; + ip1 += offsetX; + ip2 += offsetY; + for ( i = 0; i < N; i++, ip1 += is1, ip2 += is2 ) { + x = *ip1; + y = *ip2; + *ip2 = stdlib_base_complex128_muladd( alpha, x, y ); + } + return; +} diff --git a/lib/node_modules/@stdlib/blas/base/zaxpy/test/test.ndarray.js b/lib/node_modules/@stdlib/blas/base/zaxpy/test/test.ndarray.js index 1c1ba2b59427..28f1006aec0b 100644 --- a/lib/node_modules/@stdlib/blas/base/zaxpy/test/test.ndarray.js +++ b/lib/node_modules/@stdlib/blas/base/zaxpy/test/test.ndarray.js @@ -135,7 +135,7 @@ tape( 'the function scales elements from `x` by `alpha` and adds the result to ` t.end(); }); -tape( 'the function supports a `x` stride', function test( t ) { +tape( 'if dcabs1( alpha ) === 0.0; the function returns the second input array unchanged', function test( t ) { var expected; var viewY; var alpha; @@ -174,6 +174,93 @@ tape( 'the function supports a `x` stride', function test( t ) { 0.8, -0.7 ]); + alpha = new Complex128( 0.0, 0.0 ); + + zaxpy( 4, alpha, x, 2, 0, y, 1, 0 ); + + viewY = new Float64Array( y.buffer ); + expected = new Float64Array([ + 0.6, // 1 + -0.6, // 1 + -0.9, // 2 + 0.5, // 2 + 0.7, // 3 + -0.6, // 3 + 0.1, // 4 + -0.5, // 4 + -0.1, + -0.2, + -0.5, + -0.3, + 0.8, + -0.7 + ] ); + isApprox( t, viewY, expected, 14.0 ); + t.end(); +}); + +tape( 'if provided an `N` parameter less than or equal to `0`, the function returns the second input array unchanged', function test( t ) { + var expected; + var viewY; + var alpha; + var x; + var y; + + x = new Complex128Array( [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0 ] ); + y = new Complex128Array( [ 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0 ] ); + alpha = new Complex128( 2.0, 2.0 ); + + viewY = new Float64Array( y.buffer ); + expected = new Float64Array( [ 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0 ] ); + + zaxpy( -1, alpha, x, 1, 0, y, 1, 0 ); + t.deepEqual( viewY, expected, 'returns expected value' ); + + zaxpy( 0, alpha, x, 1, 0, y, 1, 0 ); + t.deepEqual( viewY, expected, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function supports a `x` stride', function test( t ) { + var expected; + var viewY; + var alpha; + var x; + var y; + + x = new Complex128Array([ + 0.7, // 1 + -0.8, // 1 + -0.4, + -0.7, + -0.1, // 2 + -0.9, // 2 + 0.2, + -0.8, + -0.9, // 3 + -0.4, // 3 + 0.1, + 0.4, + -0.6, // 4 + 0.6 // 4 + ] ); + y = new Complex128Array([ + 0.6, // 1 + -0.6, // 1 + -0.9, // 2 + 0.5, // 2 + 0.7, // 3 + -0.6, // 3 + 0.1, // 4 + -0.5, // 4 + -0.1, + -0.2, + -0.5, + -0.3, + 0.8, + -0.7 + ] ); alpha = new Complex128( 0.4, -0.7 ); zaxpy( 4, alpha, x, 2, 0, y, 1, 0 ); @@ -407,52 +494,6 @@ tape( 'the function returns a reference to the output array', function test( t ) t.end(); }); -tape( 'if provided `alpha` parameter equal to `0`, the function returns the second input array unchanged', function test( t ) { - var expected; - var viewY; - var alpha; - var x; - var y; - - x = new Complex128Array( [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0 ] ); - y = new Complex128Array( [ 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0 ] ); - alpha = new Complex128( 0.0, 0.0 ); - - viewY = new Float64Array( y.buffer ); - expected = new Float64Array( [ 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0 ] ); - - zaxpy( -1, alpha, x, 1, 0, y, 1, 0 ); - t.deepEqual( viewY, expected, 'returns expected value' ); - - zaxpy( 0, alpha, x, 1, 0, y, 1, 0 ); - t.deepEqual( viewY, expected, 'returns expected value' ); - - t.end(); -}); - -tape( 'if provided an `N` parameter less than or equal to `0`, the function returns the second input array unchanged', function test( t ) { - var expected; - var viewY; - var alpha; - var x; - var y; - - x = new Complex128Array( [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0 ] ); - y = new Complex128Array( [ 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0 ] ); - alpha = new Complex128( 2.0, 2.0 ); - - viewY = new Float64Array( y.buffer ); - expected = new Float64Array( [ 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0 ] ); - - zaxpy( -1, alpha, x, 1, 0, y, 1, 0 ); - t.deepEqual( viewY, expected, 'returns expected value' ); - - zaxpy( 0, alpha, x, 1, 0, y, 1, 0 ); - t.deepEqual( viewY, expected, 'returns expected value' ); - - t.end(); -}); - tape( 'the function supports a negative `x` stride', function test( t ) { var expected; var viewY; diff --git a/lib/node_modules/@stdlib/blas/base/zaxpy/test/test.ndarray.native.js b/lib/node_modules/@stdlib/blas/base/zaxpy/test/test.ndarray.native.js new file mode 100644 index 000000000000..ba261653d9ae --- /dev/null +++ b/lib/node_modules/@stdlib/blas/base/zaxpy/test/test.ndarray.native.js @@ -0,0 +1,696 @@ +/** +* @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 tape = require( 'tape' ); +var Float64Array = require( '@stdlib/array/float64' ); +var Complex128Array = require( '@stdlib/array/complex128' ); +var Complex128 = require( '@stdlib/complex/float64/ctor' ); +var EPS = require( '@stdlib/constants/float64/eps' ); +var abs = require( '@stdlib/math/base/special/abs' ); +var tryRequire = require( '@stdlib/utils/try-require' ); + + +// VARIABLES // + +var zaxpy = tryRequire( resolve( __dirname, './../lib/ndarray.native.js' ) ); +var opts = { + 'skip': ( zaxpy instanceof Error ) +}; + + +// FUNCTIONS // + +/** +* Tests for element-wise approximate equality. +* +* @private +* @param {Object} t - test object +* @param {Collection} actual - actual values +* @param {Collection} expected - expected values +* @param {number} rtol - relative tolerance +*/ +function isApprox( t, actual, expected, rtol ) { + var delta; + var tol; + var i; + + t.strictEqual( actual.length, expected.length, 'returns expected value' ); + for ( i = 0; i < expected.length; i++ ) { + if ( actual[ i ] === expected[ i ] ) { + t.strictEqual( actual[ i ], expected[ i ], 'returns expected value' ); + } else { + delta = abs( actual[ i ] - expected[ i ] ); + tol = rtol * EPS * abs( expected[ i ] ); + t.ok( delta <= tol, 'within tolerance. actual: '+actual[ i ]+'. expected: '+expected[ i ]+'. delta: '+delta+'. tol: '+tol+'.' ); + } + } +} + + +// TESTS // + +tape( 'main export is a function', opts, function test( t ) { + t.ok( true, __filename ); + t.strictEqual( typeof zaxpy, 'function', 'main export is a function' ); + t.end(); +}); + +tape( 'the function has an arity of 8', opts, function test( t ) { + t.strictEqual( zaxpy.length, 8, 'arity of 8' ); + t.end(); +}); + +tape( 'the function scales elements from `x` by `alpha` and adds the result to `y`', opts, function test( t ) { + var expected; + var viewY; + var alpha; + var x; + var y; + + x = new Complex128Array([ + 0.7, // 1 + -0.8, // 1 + -0.4, // 2 + -0.7, // 2 + -0.1, // 3 + -0.9, // 3 + 0.2, // 4 + -0.8, // 4 + -0.9, + -0.4, + 0.1, + 0.4, + -0.6, + 0.6 + ] ); + y = new Complex128Array([ + 0.6, // 1 + -0.6, // 1 + -0.9, // 2 + 0.5, // 2 + 0.7, // 3 + -0.6, // 3 + 0.1, // 4 + -0.5, // 4 + -0.1, + -0.2, + -0.5, + -0.3, + 0.8, + -0.7 + ] ); + alpha = new Complex128( 0.4, -0.7 ); + + zaxpy( 4, alpha, x, 1, 0, y, 1, 0 ); + + viewY = new Float64Array( y.buffer ); + expected = new Float64Array([ + 0.32, // 1 + -1.41, // 1 + -1.55, // 2 + 0.5, // 2 + 0.03, // 3 + -0.89, // 3 + -0.38, // 4 + -0.96, // 4 + -0.1, + -0.2, + -0.5, + -0.3, + 0.8, + -0.7 + ] ); + isApprox( t, viewY, expected, 14.0 ); + t.end(); +}); + +tape( 'if dcabs1( alpha ) === 0.0; the function returns the second input array unchanged', opts, function test( t ) { + var expected; + var viewY; + var alpha; + var x; + var y; + + x = new Complex128Array([ + 0.7, // 1 + -0.8, // 1 + -0.4, + -0.7, + -0.1, // 2 + -0.9, // 2 + 0.2, + -0.8, + -0.9, // 3 + -0.4, // 3 + 0.1, + 0.4, + -0.6, // 4 + 0.6 // 4 + ] ); + y = new Complex128Array([ + 0.6, // 1 + -0.6, // 1 + -0.9, // 2 + 0.5, // 2 + 0.7, // 3 + -0.6, // 3 + 0.1, // 4 + -0.5, // 4 + -0.1, + -0.2, + -0.5, + -0.3, + 0.8, + -0.7 + ] ); + alpha = new Complex128( 0.0, 0.0 ); + + zaxpy( 4, alpha, x, 2, 0, y, 1, 0 ); + + viewY = new Float64Array( y.buffer ); + expected = new Float64Array([ + 0.6, // 1 + -0.6, // 1 + -0.9, // 2 + 0.5, // 2 + 0.7, // 3 + -0.6, // 3 + 0.1, // 4 + -0.5, // 4 + -0.1, + -0.2, + -0.5, + -0.3, + 0.8, + -0.7 + ] ); + isApprox( t, viewY, expected, 14.0 ); + t.end(); +}); + +tape( 'the function supports a `x` stride', opts, function test( t ) { + var expected; + var viewY; + var alpha; + var x; + var y; + + x = new Complex128Array([ + 0.7, // 1 + -0.8, // 1 + -0.4, + -0.7, + -0.1, // 2 + -0.9, // 2 + 0.2, + -0.8, + -0.9, // 3 + -0.4, // 3 + 0.1, + 0.4, + -0.6, // 4 + 0.6 // 4 + ] ); + y = new Complex128Array([ + 0.6, // 1 + -0.6, // 1 + -0.9, // 2 + 0.5, // 2 + 0.7, // 3 + -0.6, // 3 + 0.1, // 4 + -0.5, // 4 + -0.1, + -0.2, + -0.5, + -0.3, + 0.8, + -0.7 + ] ); + alpha = new Complex128( 0.4, -0.7 ); + + zaxpy( 4, alpha, x, 2, 0, y, 1, 0 ); + + viewY = new Float64Array( y.buffer ); + expected = new Float64Array([ + 0.32, // 1 + -1.41, // 1 + -1.57, // 2 + 0.21, // 2 + 0.06, // 3 + -0.13, // 3 + 0.28, // 4 + 0.16, // 4 + -0.1, + -0.2, + -0.5, + -0.3, + 0.8, + -0.7 + ] ); + isApprox( t, viewY, expected, 14.0 ); + t.end(); +}); + +tape( 'the function supports a `x` offset', opts, function test( t ) { + var expected; + var viewY; + var alpha; + var x; + var y; + + x = new Complex128Array([ + 0.7, + -0.8, + -0.4, // 1 + -0.7, // 1 + -0.1, + -0.9, + 0.2, // 2 + -0.8, // 2 + -0.9, + -0.4, + 0.1, // 3 + 0.4, // 3 + -0.6, + 0.6 + ] ); + y = new Complex128Array([ + 0.6, // 1 + -0.6, // 1 + -0.9, // 2 + 0.5, // 2 + 0.7, // 3 + -0.6, // 3 + 0.1, + -0.5, + -0.1, + -0.2, + -0.5, + -0.3, + 0.8, + -0.7 + ] ); + alpha = new Complex128( 0.4, -0.7 ); + + zaxpy( 3, alpha, x, 2, 1, y, 1, 0 ); + + viewY = new Float64Array( y.buffer ); + expected = new Float64Array([ + -0.05, // 1 + -0.6, // 1 + -1.38, // 2 + 0.04, // 2 + 1.02, // 3 + -0.51, // 3 + 0.1, + -0.5, + -0.1, + -0.2, + -0.5, + -0.3, + 0.8, + -0.7 + ] ); + isApprox( t, viewY, expected, 14.0 ); + t.end(); +}); + +tape( 'the function supports a `y` stride', opts, function test( t ) { + var expected; + var viewY; + var alpha; + var x; + var y; + + x = new Complex128Array([ + 0.7, // 1 + -0.8, // 1 + -0.4, // 2 + -0.7, // 2 + -0.1, // 3 + -0.9, // 3 + 0.2, // 4 + -0.8, // 4 + -0.9, + -0.4, + 0.1, + 0.4, + -0.6, + 0.6 + ] ); + y = new Complex128Array([ + 0.6, // 1 + -0.6, // 1 + -0.9, + 0.5, + 0.7, // 2 + -0.6, // 2 + 0.1, + -0.5, + -0.1, // 3 + -0.2, // 3 + -0.5, + -0.3, + 0.8, // 4 + -0.7 // 4 + ] ); + alpha = new Complex128( 0.4, -0.7 ); + + zaxpy( 4, alpha, x, 1, 0, y, 2, 0 ); + + viewY = new Float64Array( y.buffer ); + expected = new Float64Array([ + 0.32, // 1 + -1.41, // 1 + -0.9, + 0.5, + 0.05, // 2 + -0.6, // 2 + 0.1, + -0.5, + -0.77, // 3 + -0.49, // 3 + -0.5, + -0.3, + 0.32, // 4 + -1.16 // 4 + ] ); + isApprox( t, viewY, expected, 14.0 ); + t.end(); +}); + +tape( 'the function supports a `y` offset', opts, function test( t ) { + var expected; + var viewY; + var alpha; + var x; + var y; + + x = new Complex128Array([ + 0.7, // 1 + -0.8, // 1 + -0.4, // 2 + -0.7, // 2 + -0.1, // 3 + -0.9, // 3 + 0.2, + -0.8, + -0.9, + -0.4, + 0.1, + 0.4, + -0.6, + 0.6 + ] ); + y = new Complex128Array([ + 0.6, + -0.6, + -0.9, // 1 + 0.5, // 1 + 0.7, + -0.6, + 0.1, // 2 + -0.5, // 2 + -0.1, + -0.2, + -0.5, // 3 + -0.3, // 3 + 0.8, + -0.7 + ] ); + alpha = new Complex128( 0.4, -0.7 ); + + zaxpy( 3, alpha, x, 1, 0, y, 2, 1 ); + + viewY = new Float64Array( y.buffer ); + expected = new Float64Array([ + 0.6, + -0.6, + -1.18, // 1 + -0.31, // 1 + 0.7, + -0.6, + -0.55, // 2 + -0.5, // 2 + -0.1, + -0.2, + -1.17, // 3 + -0.59, // 3 + 0.8, + -0.7 + ] ); + isApprox( t, viewY, expected, 14.0 ); + t.end(); +}); + +tape( 'the function returns a reference to the output array', opts, function test( t ) { + var alpha; + var out; + var x; + var y; + + x = new Complex128Array( [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0 ] ); + y = new Complex128Array( [ 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0 ] ); + alpha = new Complex128( 2.0, 2.0 ); + + out = zaxpy( x.length, alpha, x, 1, 0, y, 1, 0 ); + + t.strictEqual( out, y, 'same reference' ); + t.end(); +}); + +tape( 'if provided an `N` parameter less than or equal to `0`, the function returns the second input array unchanged', opts, function test( t ) { + var expected; + var viewY; + var alpha; + var x; + var y; + + x = new Complex128Array( [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0 ] ); + y = new Complex128Array( [ 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0 ] ); + alpha = new Complex128( 2.0, 2.0 ); + + viewY = new Float64Array( y.buffer ); + expected = new Float64Array( [ 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0 ] ); + + zaxpy( -1, alpha, x, 1, 0, y, 1, 0 ); + t.deepEqual( viewY, expected, 'returns expected value' ); + + zaxpy( 0, alpha, x, 1, 0, y, 1, 0 ); + t.deepEqual( viewY, expected, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function supports a negative `x` stride', opts, function test( t ) { + var expected; + var viewY; + var alpha; + var x; + var y; + + x = new Complex128Array([ + 0.7, // 4 + -0.8, // 4 + -0.4, + -0.7, + -0.1, // 3 + -0.9, // 3 + 0.2, + -0.8, + -0.9, // 2 + -0.4, // 2 + 0.1, + 0.4, + -0.6, // 1 + 0.6 // 1 + ] ); + y = new Complex128Array([ + 0.6, // 1 + -0.6, // 1 + -0.9, // 2 + 0.5, // 2 + 0.7, // 3 + -0.6, // 3 + 0.1, // 4 + -0.5, // 4 + -0.1, + -0.2, + -0.5, + -0.3, + 0.8, + -0.7 + ] ); + alpha = new Complex128( 0.4, -0.7 ); + + zaxpy( 4, alpha, x, -2, 6, y, 1, 0 ); + + viewY = new Float64Array( y.buffer ); + expected = new Float64Array([ + 0.78, // 1 + 0.06, // 1 + -1.54, // 2 + 0.97, // 2 + 0.03, // 3 + -0.89, // 3 + -0.18, // 4 + -1.31, // 4 + -0.1, + -0.2, + -0.5, + -0.3, + 0.8, + -0.7 + ] ); + isApprox( t, viewY, expected, 14.0 ); + t.end(); +}); + +tape( 'the function supports a negative `y` stride', opts, function test( t ) { + var expected; + var viewY; + var alpha; + var x; + var y; + + x = new Complex128Array([ + 0.7, // 1 + -0.8, // 1 + -0.4, + -0.7, + -0.1, // 2 + -0.9, // 2 + 0.2, + -0.8, + -0.9, // 3 + -0.4, // 3 + 0.1, + 0.4, + -0.6, // 4 + 0.6 // 4 + ] ); + y = new Complex128Array([ + 0.6, // 4 + -0.6, // 4 + -0.9, + 0.5, + 0.7, // 3 + -0.6, // 3 + 0.1, + -0.5, + -0.1, // 2 + -0.2, // 2 + -0.5, + -0.3, + 0.8, // 1 + -0.7 // 1 + ] ); + alpha = new Complex128( 0.4, -0.7 ); + + zaxpy( 4, alpha, x, 2, 0, y, -2, 6 ); + + viewY = new Float64Array( y.buffer ); + expected = new Float64Array([ + 0.78, // 4 + 0.06, // 4 + -0.9, + 0.5, + 0.06, // 3 + -0.13, // 3 + 0.1, + -0.5, + -0.77, // 2 + -0.49, // 2 + -0.5, + -0.3, + 0.52, // 1 + -1.51 // 1 + ] ); + isApprox( t, viewY, expected, 14.0 ); + t.end(); +}); + +tape( 'the function supports complex access patterns', opts, function test( t ) { + var expected; + var viewY; + var alpha; + var x; + var y; + + x = new Complex128Array([ + 0.7, // 4 + -0.8, // 4 + -0.4, // 3 + -0.7, // 3 + -0.1, // 2 + -0.9, // 2 + 0.2, // 1 + -0.8, // 1 + -0.9, + -0.4, + 0.1, + 0.4, + -0.6, + 0.6 + ] ); + y = new Complex128Array([ + 0.6, // 4 + -0.6, // 4 + -0.9, + 0.5, + 0.7, // 3 + -0.6, // 3 + 0.1, + -0.5, + -0.1, // 2 + -0.2, // 2 + -0.5, + -0.3, + 0.8, // 1 + -0.7 // 1 + ] ); + alpha = new Complex128( 0.4, -0.7 ); + + zaxpy( 4, alpha, x, -1, 3, y, -2, 6 ); + + viewY = new Float64Array( y.buffer ); + expected = new Float64Array([ + 0.32, // 4 + -1.41, // 4 + -0.9, + 0.5, + 0.05, // 3 + -0.6, // 3 + 0.1, + -0.5, + -0.77, // 2 + -0.49, // 2 + -0.5, + -0.3, + 0.32, // 1 + -1.16 // 1 + ] ); + isApprox( t, viewY, expected, 14.0 ); + t.end(); +}); diff --git a/lib/node_modules/@stdlib/blas/base/zaxpy/test/test.zaxpy.js b/lib/node_modules/@stdlib/blas/base/zaxpy/test/test.zaxpy.js index f57382b5a227..5dc68d3e7c29 100644 --- a/lib/node_modules/@stdlib/blas/base/zaxpy/test/test.zaxpy.js +++ b/lib/node_modules/@stdlib/blas/base/zaxpy/test/test.zaxpy.js @@ -135,7 +135,7 @@ tape( 'the function scales elements from `x` by `alpha` and adds the result to ` t.end(); }); -tape( 'the function supports a `x` stride', function test( t ) { +tape( 'if dcabs1( alpha ) === 0.0; the function returns the second input array unchanged', function test( t ) { var expected; var viewY; var alpha; @@ -174,6 +174,93 @@ tape( 'the function supports a `x` stride', function test( t ) { 0.8, -0.7 ]); + alpha = new Complex128( 0.0, 0.0 ); + + zaxpy( 4, alpha, x, 2, y, 1 ); + + viewY = new Float64Array( y.buffer ); + expected = new Float64Array([ + 0.6, // 1 + -0.6, // 1 + -0.9, // 2 + 0.5, // 2 + 0.7, // 3 + -0.6, // 3 + 0.1, // 4 + -0.5, // 4 + -0.1, + -0.2, + -0.5, + -0.3, + 0.8, + -0.7 + ] ); + isApprox( t, viewY, expected, 14.0 ); + t.end(); +}); + +tape( 'if provided an `N` parameter less than or equal to `0`, the function returns the second input array unchanged', function test( t ) { + var expected; + var viewY; + var alpha; + var x; + var y; + + x = new Complex128Array( [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0 ] ); + y = new Complex128Array( [ 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0 ] ); + alpha = new Complex128( 2.0, 2.0 ); + + viewY = new Float64Array( y.buffer ); + expected = new Float64Array( [ 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0 ] ); + + zaxpy( -1, alpha, x, 1, y, 1 ); + t.deepEqual( viewY, expected, 'returns expected value' ); + + zaxpy( 0, alpha, x, 1, y, 1 ); + t.deepEqual( viewY, expected, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function supports a `x` stride', function test( t ) { + var expected; + var viewY; + var alpha; + var x; + var y; + + x = new Complex128Array([ + 0.7, // 1 + -0.8, // 1 + -0.4, + -0.7, + -0.1, // 2 + -0.9, // 2 + 0.2, + -0.8, + -0.9, // 3 + -0.4, // 3 + 0.1, + 0.4, + -0.6, // 4 + 0.6 // 4 + ] ); + y = new Complex128Array([ + 0.6, // 1 + -0.6, // 1 + -0.9, // 2 + 0.5, // 2 + 0.7, // 3 + -0.6, // 3 + 0.1, // 4 + -0.5, // 4 + -0.1, + -0.2, + -0.5, + -0.3, + 0.8, + -0.7 + ] ); alpha = new Complex128( 0.4, -0.7 ); zaxpy( 4, alpha, x, 2, y, 1 ); @@ -279,52 +366,6 @@ tape( 'the function returns a reference to the output array', function test( t ) t.end(); }); -tape( 'if provided `alpha` parameter equal to `0`, the function returns the second input array unchanged', function test( t ) { - var expected; - var viewY; - var alpha; - var cy; - var x; - - x = new Complex128Array( [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0 ] ); - cy = new Complex128Array( [ 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0 ] ); - alpha = new Complex128( 0.0, 0.0 ); - - viewY = new Float64Array( cy.buffer ); - expected = new Float64Array( [ 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0 ] ); - - zaxpy( -1, alpha, x, 1, 0, cy, 1, 0 ); - t.deepEqual( viewY, expected, 'returns expected value' ); - - zaxpy( 0, alpha, x, 1, 0, cy, 1, 0 ); - t.deepEqual( viewY, expected, 'returns expected value' ); - - t.end(); -}); - -tape( 'if provided an `N` parameter less than or equal to `0`, the function returns the second input array unchanged', function test( t ) { - var expected; - var viewY; - var alpha; - var x; - var y; - - x = new Complex128Array( [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0 ] ); - y = new Complex128Array( [ 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0 ] ); - alpha = new Complex128( 2.0, 2.0 ); - - viewY = new Float64Array( y.buffer ); - expected = new Float64Array( [ 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0 ] ); - - zaxpy( -1, alpha, x, 1, y, 1 ); - t.deepEqual( viewY, expected, 'returns expected value' ); - - zaxpy( 0, alpha, x, 1, y, 1 ); - t.deepEqual( viewY, expected, 'returns expected value' ); - - t.end(); -}); - tape( 'the function supports negative `x` strides', function test( t ) { var expected; var viewY; diff --git a/lib/node_modules/@stdlib/blas/base/zaxpy/test/test.zaxpy.native.js b/lib/node_modules/@stdlib/blas/base/zaxpy/test/test.zaxpy.native.js new file mode 100644 index 000000000000..dd984a212f63 --- /dev/null +++ b/lib/node_modules/@stdlib/blas/base/zaxpy/test/test.zaxpy.native.js @@ -0,0 +1,611 @@ +/** +* @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 tape = require( 'tape' ); +var Float64Array = require( '@stdlib/array/float64' ); +var Complex128Array = require( '@stdlib/array/complex128' ); +var Complex128 = require( '@stdlib/complex/float64/ctor' ); +var EPS = require( '@stdlib/constants/float64/eps' ); +var abs = require( '@stdlib/math/base/special/abs' ); +var tryRequire = require( '@stdlib/utils/try-require' ); + + +// VARIABLES // + +var zaxpy = tryRequire( resolve( __dirname, './../lib/zaxpy.native.js' ) ); +var opts = { + 'skip': ( zaxpy instanceof Error ) +}; + + +// FUNCTIONS // + +/** +* Tests for element-wise approximate equality. +* +* @private +* @param {Object} t - test object +* @param {Collection} actual - actual values +* @param {Collection} expected - expected values +* @param {number} rtol - relative tolerance +*/ +function isApprox( t, actual, expected, rtol ) { + var delta; + var tol; + var i; + + t.strictEqual( actual.length, expected.length, 'returns expected value' ); + for ( i = 0; i < expected.length; i++ ) { + if ( actual[ i ] === expected[ i ] ) { + t.strictEqual( actual[ i ], expected[ i ], 'returns expected value' ); + } else { + delta = abs( actual[ i ] - expected[ i ] ); + tol = rtol * EPS * abs( expected[ i ] ); + t.ok( delta <= tol, 'within tolerance. actual: '+actual[ i ]+'. expected: '+expected[ i ]+'. delta: '+delta+'. tol: '+tol+'.' ); + } + } +} + + +// TESTS // + +tape( 'main export is a function', opts, function test( t ) { + t.ok( true, __filename ); + t.strictEqual( typeof zaxpy, 'function', 'main export is a function' ); + t.end(); +}); + +tape( 'the function has an arity of 6', opts, function test( t ) { + t.strictEqual( zaxpy.length, 6, 'arity of 6' ); + t.end(); +}); + +tape( 'the function scales elements from `x` by `alpha` and adds the result to `y`', opts, function test( t ) { + var expected; + var viewY; + var alpha; + var x; + var y; + + x = new Complex128Array([ + 0.7, // 1 + -0.8, // 1 + -0.4, // 2 + -0.7, // 2 + -0.1, // 3 + -0.9, // 3 + 0.2, // 4 + -0.8, // 4 + -0.9, + -0.4, + 0.1, + 0.4, + -0.6, + 0.6 + ] ); + y = new Complex128Array([ + 0.6, // 1 + -0.6, // 1 + -0.9, // 2 + 0.5, // 2 + 0.7, // 3 + -0.6, // 3 + 0.1, // 4 + -0.5, // 4 + -0.1, + -0.2, + -0.5, + -0.3, + 0.8, + -0.7 + ] ); + alpha = new Complex128( 0.4, -0.7 ); + + zaxpy( 4, alpha, x, 1, y, 1 ); + + viewY = new Float64Array( y.buffer ); + expected = new Float64Array([ + 0.32, // 1 + -1.41, // 1 + -1.55, // 2 + 0.5, // 2 + 0.03, // 3 + -0.89, // 3 + -0.38, // 4 + -0.96, // 4 + -0.1, + -0.2, + -0.5, + -0.3, + 0.8, + -0.7 + ] ); + isApprox( t, viewY, expected, 14.0 ); + t.end(); +}); + +tape( 'if dcabs1( alpha ) === 0.0; the function returns the second input array unchanged', opts, function test( t ) { + var expected; + var viewY; + var alpha; + var x; + var y; + + x = new Complex128Array([ + 0.7, // 1 + -0.8, // 1 + -0.4, + -0.7, + -0.1, // 2 + -0.9, // 2 + 0.2, + -0.8, + -0.9, // 3 + -0.4, // 3 + 0.1, + 0.4, + -0.6, // 4 + 0.6 // 4 + ] ); + y = new Complex128Array([ + 0.6, // 1 + -0.6, // 1 + -0.9, // 2 + 0.5, // 2 + 0.7, // 3 + -0.6, // 3 + 0.1, // 4 + -0.5, // 4 + -0.1, + -0.2, + -0.5, + -0.3, + 0.8, + -0.7 + ] ); + alpha = new Complex128( 0.0, 0.0 ); + + zaxpy( 4, alpha, x, 2, y, 1 ); + + viewY = new Float64Array( y.buffer ); + expected = new Float64Array([ + 0.6, // 1 + -0.6, // 1 + -0.9, // 2 + 0.5, // 2 + 0.7, // 3 + -0.6, // 3 + 0.1, // 4 + -0.5, // 4 + -0.1, + -0.2, + -0.5, + -0.3, + 0.8, + -0.7 + ] ); + isApprox( t, viewY, expected, 14.0 ); + t.end(); +}); + +tape( 'the function supports a `x` stride', opts, function test( t ) { + var expected; + var viewY; + var alpha; + var x; + var y; + + x = new Complex128Array([ + 0.7, // 1 + -0.8, // 1 + -0.4, + -0.7, + -0.1, // 2 + -0.9, // 2 + 0.2, + -0.8, + -0.9, // 3 + -0.4, // 3 + 0.1, + 0.4, + -0.6, // 4 + 0.6 // 4 + ] ); + y = new Complex128Array([ + 0.6, // 1 + -0.6, // 1 + -0.9, // 2 + 0.5, // 2 + 0.7, // 3 + -0.6, // 3 + 0.1, // 4 + -0.5, // 4 + -0.1, + -0.2, + -0.5, + -0.3, + 0.8, + -0.7 + ] ); + alpha = new Complex128( 0.4, -0.7 ); + + zaxpy( 4, alpha, x, 2, y, 1 ); + + viewY = new Float64Array( y.buffer ); + expected = new Float64Array([ + 0.32, // 1 + -1.41, // 1 + -1.57, // 2 + 0.21, // 2 + 0.06, // 3 + -0.13, // 3 + 0.28, // 4 + 0.16, // 4 + -0.1, + -0.2, + -0.5, + -0.3, + 0.8, + -0.7 + ] ); + isApprox( t, viewY, expected, 14.0 ); + t.end(); +}); + +tape( 'the function supports a `y` stride', opts, function test( t ) { + var expected; + var viewY; + var alpha; + var x; + var y; + + x = new Complex128Array([ + 0.7, // 1 + -0.8, // 1 + -0.4, // 2 + -0.7, // 2 + -0.1, // 3 + -0.9, // 3 + 0.2, // 4 + -0.8, // 4 + -0.9, + -0.4, + 0.1, + 0.4, + -0.6, + 0.6 + ] ); + y = new Complex128Array([ + 0.6, // 1 + -0.6, // 1 + -0.9, + 0.5, + 0.7, // 2 + -0.6, // 2 + 0.1, + -0.5, + -0.1, // 3 + -0.2, // 3 + -0.5, + -0.3, + 0.8, // 4 + -0.7 // 4 + ] ); + alpha = new Complex128( 0.4, -0.7 ); + + zaxpy( 4, alpha, x, 1, y, 2 ); + + viewY = new Float64Array( y.buffer ); + expected = new Float64Array([ + 0.32, // 1 + -1.41, // 1 + -0.9, + 0.5, + 0.05, // 2 + -0.6, // 2 + 0.1, + -0.5, + -0.77, // 3 + -0.49, // 3 + -0.5, + -0.3, + 0.32, // 4 + -1.16 // 4 + ] ); + isApprox( t, viewY, expected, 14.0 ); + t.end(); +}); + +tape( 'the function returns a reference to the output array', opts, function test( t ) { + var alpha; + var out; + var x; + var y; + + x = new Complex128Array( [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0 ] ); + y = new Complex128Array( [ 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0 ] ); + alpha = new Complex128( 2.0, 2.0 ); + + out = zaxpy( x.length, alpha, x, 1, y, 1 ); + + t.strictEqual( out, y, 'same reference' ); + t.end(); +}); + +tape( 'if provided an `N` parameter less than or equal to `0`, the function returns the second input array unchanged', opts, function test( t ) { + var expected; + var viewY; + var alpha; + var x; + var y; + + x = new Complex128Array( [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0 ] ); + y = new Complex128Array( [ 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0 ] ); + alpha = new Complex128( 2.0, 2.0 ); + + viewY = new Float64Array( y.buffer ); + expected = new Float64Array( [ 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0 ] ); + + zaxpy( -1, alpha, x, 1, y, 1 ); + t.deepEqual( viewY, expected, 'returns expected value' ); + + zaxpy( 0, alpha, x, 1, y, 1 ); + t.deepEqual( viewY, expected, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function supports negative `x` strides', opts, function test( t ) { + var expected; + var viewY; + var alpha; + var x; + var y; + + x = new Complex128Array([ + 0.7, // 4 + -0.8, // 4 + -0.4, + -0.7, + -0.1, // 3 + -0.9, // 3 + 0.2, + -0.8, + -0.9, // 2 + -0.4, // 2 + 0.1, + 0.4, + -0.6, // 1 + 0.6 // 1 + ] ); + y = new Complex128Array([ + 0.6, // 1 + -0.6, // 1 + -0.9, // 2 + 0.5, // 2 + 0.7, // 3 + -0.6, // 3 + 0.1, // 4 + -0.5, // 4 + -0.1, + -0.2, + -0.5, + -0.3, + 0.8, + -0.7 + ] ); + alpha = new Complex128( 0.4, -0.7 ); + + zaxpy( 4, alpha, x, -2, y, 1 ); + + viewY = new Float64Array( y.buffer ); + expected = new Float64Array([ + 0.78, // 1 + 0.06, // 1 + -1.54, // 2 + 0.97, // 2 + 0.03, // 3 + -0.89, // 3 + -0.18, // 4 + -1.31, // 4 + -0.1, + -0.2, + -0.5, + -0.3, + 0.8, + -0.7 + ] ); + isApprox( t, viewY, expected, 14.0 ); + t.end(); +}); + +tape( 'the function supports negative `y` strides', opts, function test( t ) { + var expected; + var viewY; + var alpha; + var x; + var y; + + x = new Complex128Array([ + 0.7, // 1 + -0.8, // 1 + -0.4, + -0.7, + -0.1, // 2 + -0.9, // 2 + 0.2, + -0.8, + -0.9, // 3 + -0.4, // 3 + 0.1, + 0.4, + -0.6, // 4 + 0.6 // 4 + ] ); + y = new Complex128Array([ + 0.6, // 4 + -0.6, // 4 + -0.9, + 0.5, + 0.7, // 3 + -0.6, // 3 + 0.1, + -0.5, + -0.1, // 2 + -0.2, // 2 + -0.5, + -0.3, + 0.8, // 1 + -0.7 // 1 + ] ); + alpha = new Complex128( 0.4, -0.7 ); + + zaxpy( 4, alpha, x, 2, y, -2 ); + + viewY = new Float64Array( y.buffer ); + expected = new Float64Array([ + 0.78, // 4 + 0.06, // 4 + -0.9, + 0.5, + 0.06, // 3 + -0.13, // 3 + 0.1, + -0.5, + -0.77, // 2 + -0.49, // 2 + -0.5, + -0.3, + 0.52, // 1 + -1.51 // 1 + ] ); + isApprox( t, viewY, expected, 14.0 ); + t.end(); +}); + +tape( 'the function supports complex access patterns', opts, function test( t ) { + var expected; + var viewY; + var alpha; + var x; + var y; + + x = new Complex128Array([ + 0.7, // 4 + -0.8, // 4 + -0.4, // 3 + -0.7, // 3 + -0.1, // 2 + -0.9, // 2 + 0.2, // 1 + -0.8, // 1 + -0.9, + -0.4, + 0.1, + 0.4, + -0.6, + 0.6 + ] ); + y = new Complex128Array([ + 0.6, // 4 + -0.6, // 4 + -0.9, + 0.5, + 0.7, // 3 + -0.6, // 3 + 0.1, + -0.5, + -0.1, // 2 + -0.2, // 2 + -0.5, + -0.3, + 0.8, // 1 + -0.7 // 1 + ] ); + alpha = new Complex128( 0.4, -0.7 ); + + zaxpy( 4, alpha, x, -1, y, -2 ); + + viewY = new Float64Array( y.buffer ); + expected = new Float64Array([ + 0.32, // 4 + -1.41, // 4 + -0.9, + 0.5, + 0.05, // 3 + -0.6, // 3 + 0.1, + -0.5, + -0.77, // 2 + -0.49, // 2 + -0.5, + -0.3, + 0.32, // 1 + -1.16 // 1 + ] ); + isApprox( t, viewY, expected, 14.0 ); + t.end(); +}); + +tape( 'the function supports view offsets', opts, function test( t ) { + var expected; + var viewY; + var alpha; + var x0; + var y0; + var x1; + var y1; + + // Initial arrays... + x0 = new Complex128Array([ + 1.0, + 2.0, + 3.0, // 1 + 4.0, // 1 + 5.0, + 6.0 + ]); + y0 = new Complex128Array([ + 1.0, + 1.0, + 1.0, + 1.0, + 1.0, // 1 + 1.0 // 1 + ]); + + // Define a scalar constant: + alpha = new Complex128( 2.0, 2.0 ); + + // Create offset views... + x1 = new Complex128Array( x0.buffer, x0.BYTES_PER_ELEMENT*1 ); // begin at the 2nd element + y1 = new Complex128Array( y0.buffer, y0.BYTES_PER_ELEMENT*2 ); // begin at the 3rd element + + zaxpy( 1, alpha, x1, 1, y1, 1 ); + + viewY = new Float64Array( y0.buffer ); + expected = new Float64Array( [ 1.0, 1.0, 1.0, 1.0, -1.0, 15.0 ] ); + + t.deepEqual( viewY, expected, 'returns expected value' ); + t.end(); +}); diff --git a/lib/node_modules/@stdlib/stats/base/README.md b/lib/node_modules/@stdlib/stats/base/README.md index 232aeb473b93..839ada64ff2b 100644 --- a/lib/node_modules/@stdlib/stats/base/README.md +++ b/lib/node_modules/@stdlib/stats/base/README.md @@ -64,8 +64,8 @@ The namespace contains the following statistical functions: - [`nanmskmax( N, x, strideX, mask, strideMask )`][@stdlib/stats/strided/nanmskmax]: calculate the maximum value of a strided array according to a mask, ignoring `NaN` values. - [`nanmskmin( N, x, strideX, mask, strideMask )`][@stdlib/stats/strided/nanmskmin]: calculate the minimum value of a strided array according to a mask, ignoring `NaN` values. - [`nanmskrange( N, x, strideX, mask, strideMask )`][@stdlib/stats/strided/nanmskrange]: calculate the range of a strided array according to a mask, ignoring `NaN` values. -- [`nanrangeBy( N, x, stride, clbk[, thisArg] )`][@stdlib/stats/base/nanrange-by]: calculate the range of a strided array via a callback function, ignoring `NaN` values. -- [`nanrange( N, x, strideX )`][@stdlib/stats/base/nanrange]: calculate the range of a strided array, ignoring `NaN` values. +- [`nanrangeBy( N, x, stride, clbk[, thisArg] )`][@stdlib/stats/strided/nanrange-by]: calculate the range of a strided array via a callback function, ignoring `NaN` values. +- [`nanrange( N, x, strideX )`][@stdlib/stats/strided/nanrange]: calculate the range of a strided array, ignoring `NaN` values. - [`nanstdev( N, correction, x, strideX )`][@stdlib/stats/base/nanstdev]: calculate the standard deviation of a strided array ignoring `NaN` values. - [`nanstdevch( N, correction, x, stride )`][@stdlib/stats/base/nanstdevch]: calculate the standard deviation of a strided array ignoring `NaN` values and using a one-pass trial mean algorithm. - [`nanstdevpn( N, correction, x, strideX )`][@stdlib/stats/base/nanstdevpn]: calculate the standard deviation of a strided array ignoring `NaN` values and using a two-pass algorithm. @@ -79,8 +79,8 @@ The namespace contains the following statistical functions: - [`nanvariancewd( N, correction, x, strideX )`][@stdlib/stats/base/nanvariancewd]: calculate the variance of a strided array ignoring `NaN` values and using Welford's algorithm. - [`nanvarianceyc( N, correction, x, strideX )`][@stdlib/stats/base/nanvarianceyc]: calculate the variance of a strided array ignoring `NaN` values and using a one-pass algorithm proposed by Youngs and Cramer. - [`ndarray`][@stdlib/stats/base/ndarray]: base ndarray statistical functions. -- [`rangeBy( N, x, stride, clbk[, thisArg] )`][@stdlib/stats/base/range-by]: calculate the range of a strided array via a callback function. -- [`range( N, x, strideX )`][@stdlib/stats/base/range]: calculate the range of a strided array. +- [`rangeBy( N, x, stride, clbk[, thisArg] )`][@stdlib/stats/strided/range-by]: calculate the range of a strided array via a callback function. +- [`range( N, x, strideX )`][@stdlib/stats/strided/range]: calculate the range of a strided array. - [`sdsnanmean( N, x, stride )`][@stdlib/stats/base/sdsnanmean]: calculate the arithmetic mean of a single-precision floating-point strided array, ignoring `NaN` values and using extended accumulation. - [`sdsnanmeanors( N, x, stride )`][@stdlib/stats/base/sdsnanmeanors]: calculate the arithmetic mean of a single-precision floating-point strided array, ignoring `NaN` values and using ordinary recursive summation with extended accumulation. - [`smeankbn( N, x, stride )`][@stdlib/stats/strided/smeankbn]: calculate the arithmetic mean of a single-precision floating-point strided array using an improved Kahan–Babuška algorithm. @@ -177,9 +177,9 @@ console.log( objectKeys( ns ) ); [@stdlib/stats/strided/nanmskrange]: https://github.com/stdlib-js/stdlib/tree/develop/lib/node_modules/%40stdlib/stats/strided/nanmskrange -[@stdlib/stats/base/nanrange-by]: https://github.com/stdlib-js/stdlib/tree/develop/lib/node_modules/%40stdlib/stats/base/nanrange-by +[@stdlib/stats/strided/nanrange-by]: https://github.com/stdlib-js/stdlib/tree/develop/lib/node_modules/%40stdlib/stats/strided/nanrange-by -[@stdlib/stats/base/nanrange]: https://github.com/stdlib-js/stdlib/tree/develop/lib/node_modules/%40stdlib/stats/base/nanrange +[@stdlib/stats/strided/nanrange]: https://github.com/stdlib-js/stdlib/tree/develop/lib/node_modules/%40stdlib/stats/strided/nanrange [@stdlib/stats/base/nanstdev]: https://github.com/stdlib-js/stdlib/tree/develop/lib/node_modules/%40stdlib/stats/base/nanstdev @@ -207,9 +207,9 @@ console.log( objectKeys( ns ) ); [@stdlib/stats/base/ndarray]: https://github.com/stdlib-js/stdlib/tree/develop/lib/node_modules/%40stdlib/stats/base/ndarray -[@stdlib/stats/base/range-by]: https://github.com/stdlib-js/stdlib/tree/develop/lib/node_modules/%40stdlib/stats/base/range-by +[@stdlib/stats/strided/range-by]: https://github.com/stdlib-js/stdlib/tree/develop/lib/node_modules/%40stdlib/stats/strided/range-by -[@stdlib/stats/base/range]: https://github.com/stdlib-js/stdlib/tree/develop/lib/node_modules/%40stdlib/stats/base/range +[@stdlib/stats/strided/range]: https://github.com/stdlib-js/stdlib/tree/develop/lib/node_modules/%40stdlib/stats/strided/range [@stdlib/stats/base/sdsnanmean]: https://github.com/stdlib-js/stdlib/tree/develop/lib/node_modules/%40stdlib/stats/base/sdsnanmean diff --git a/lib/node_modules/@stdlib/stats/base/dists/bradford/cdf/README.md b/lib/node_modules/@stdlib/stats/base/dists/bradford/cdf/README.md index b67273c5abfd..a4140a7fe208 100644 --- a/lib/node_modules/@stdlib/stats/base/dists/bradford/cdf/README.md +++ b/lib/node_modules/@stdlib/stats/base/dists/bradford/cdf/README.md @@ -99,11 +99,11 @@ y = cdf( 0.5, -5.0 ); Returns a function for evaluating the [CDF][cdf] of a [Bradford][bradford-distribution] distribution with shape parameter `c`. ```javascript -var myPDF = cdf.factory( 5.0 ); -var y = myPDF( 0.5 ); +var myCDF = cdf.factory( 5.0 ); +var y = myCDF( 0.5 ); // returns ~0.699 -y = myPDF( 1.0 ); +y = myCDF( 1.0 ); // returns 1.0 ``` diff --git a/lib/node_modules/@stdlib/stats/base/dists/bradford/cdf/benchmark/benchmark.native.js b/lib/node_modules/@stdlib/stats/base/dists/bradford/cdf/benchmark/benchmark.native.js index 1f2eb0980f0c..2184bc03bc99 100644 --- a/lib/node_modules/@stdlib/stats/base/dists/bradford/cdf/benchmark/benchmark.native.js +++ b/lib/node_modules/@stdlib/stats/base/dists/bradford/cdf/benchmark/benchmark.native.js @@ -22,8 +22,7 @@ var resolve = require( 'path' ).resolve; var bench = require( '@stdlib/bench' ); -var Float64Array = require( '@stdlib/array/float64' ); -var uniform = require( '@stdlib/random/base/uniform' ); +var uniform = require( '@stdlib/random/array/uniform' ); var isnan = require( '@stdlib/math/base/assert/is-nan' ); var tryRequire = require( '@stdlib/utils/try-require' ); var pkg = require( './../package.json' ).name; @@ -40,23 +39,21 @@ var opts = { // MAIN // bench( pkg+'::native', opts, function benchmark( b ) { - var len; + var opts; var x; var c; var y; var i; - len = 100; - x = new Float64Array( len ); - c = new Float64Array( len ); - for ( i = 0; i < len; i++ ) { - x[ i ] = uniform( 0.0, 1.0 ); - c[ i ] = uniform( 0.1, 10.0 ); - } + opts = { + 'dtype': 'float64' + }; + x = uniform( 100, 0.0, 1.0, opts ); + c = uniform( 100, 0.1, 10.0, opts ); b.tic(); for ( i = 0; i < b.iterations; i++ ) { - y = cdf( x[ i % len ], c[ i % len ] ); + y = cdf( x[ i % x.length ], c[ i % c.length ] ); if ( isnan( y ) ) { b.fail( 'should not return NaN' ); } diff --git a/lib/node_modules/@stdlib/stats/base/dists/bradford/cdf/benchmark/c/benchmark.c b/lib/node_modules/@stdlib/stats/base/dists/bradford/cdf/benchmark/c/benchmark.c index 55fc86571330..782f3a396e54 100644 --- a/lib/node_modules/@stdlib/stats/base/dists/bradford/cdf/benchmark/c/benchmark.c +++ b/lib/node_modules/@stdlib/stats/base/dists/bradford/cdf/benchmark/c/benchmark.c @@ -100,13 +100,10 @@ static double benchmark( void ) { double y; int i; - // Generate test data: for ( i = 0; i < 100; i++ ) { x[ i ] = random_uniform( 0.0, 1.0 ); c[ i ] = random_uniform( STDLIB_CONSTANT_FLOAT64_EPS, 10.0 ); } - - // Run the benchmark: t = tic(); for ( i = 0; i < ITERATIONS; i++ ) { y = stdlib_base_dists_bradford_cdf( x[ i % 100 ], c[ i % 100 ] ); @@ -127,21 +124,17 @@ static double benchmark( void ) { */ int main( void ) { double elapsed; - int count; int i; // Use the current time to seed the pseudorandom number generator: srand( time( NULL ) ); print_version(); - count = 0; for ( i = 0; i < REPEATS; i++ ) { - count += 1; printf( "# c::%s\n", NAME ); elapsed = benchmark(); - printf( "ok %d benchmark finished\n", count ); print_results( elapsed ); - printf( "\n" ); + printf( "ok %d benchmark finished\n", i+1 ); } - print_summary( count, count ); + print_summary( REPEATS, REPEATS ); } diff --git a/lib/node_modules/@stdlib/stats/base/dists/bradford/cdf/docs/repl.txt b/lib/node_modules/@stdlib/stats/base/dists/bradford/cdf/docs/repl.txt index 40ba4eb7bf4f..5c69f386d98f 100644 --- a/lib/node_modules/@stdlib/stats/base/dists/bradford/cdf/docs/repl.txt +++ b/lib/node_modules/@stdlib/stats/base/dists/bradford/cdf/docs/repl.txt @@ -45,8 +45,8 @@ {{alias}}.factory( c ) - Returns a function for evaluating the cumulative distribution function - (CDF) of a Bradford distribution with shape parameter `c`. + Returns a function for evaluating the cumulative distribution function (CDF) + of a Bradford distribution with shape parameter `c`. Parameters ---------- diff --git a/lib/node_modules/@stdlib/stats/base/dists/bradford/cdf/docs/types/index.d.ts b/lib/node_modules/@stdlib/stats/base/dists/bradford/cdf/docs/types/index.d.ts index 049e7babd208..35fb3aadcb40 100644 --- a/lib/node_modules/@stdlib/stats/base/dists/bradford/cdf/docs/types/index.d.ts +++ b/lib/node_modules/@stdlib/stats/base/dists/bradford/cdf/docs/types/index.d.ts @@ -87,11 +87,11 @@ interface CDF { * @returns CDF * * @example - * var mypdf = cdf.factory( 5.0 ); - * var y = mypdf( 0.5 ); + * var mycdf = cdf.factory( 5.0 ); + * var y = mycdf( 0.5 ); * // returns ~0.699 * - * y = mypdf( 1.0 ); + * y = mycdf( 1.0 ); * // returns 1.0 */ factory( c: number ): Unary; diff --git a/lib/node_modules/@stdlib/stats/base/dists/bradford/cdf/lib/factory.js b/lib/node_modules/@stdlib/stats/base/dists/bradford/cdf/lib/factory.js index 648fa752d921..ec2ee407da36 100644 --- a/lib/node_modules/@stdlib/stats/base/dists/bradford/cdf/lib/factory.js +++ b/lib/node_modules/@stdlib/stats/base/dists/bradford/cdf/lib/factory.js @@ -42,10 +42,7 @@ var log1p = require( '@stdlib/math/base/special/log1p' ); * // returns 1.0 */ function factory( c ) { - if ( - isnan( c ) || - c <= 0.0 - ) { + if ( isnan( c ) || c <= 0.0 ) { return constantFunction( NaN ); } return cdf; @@ -62,9 +59,7 @@ function factory( c ) { * // returns */ function cdf( x ) { - if ( - isnan( x ) - ) { + if ( isnan( x ) ) { return NaN; } if ( x <= 0.0 ) { diff --git a/lib/node_modules/@stdlib/stats/base/dists/bradford/cdf/lib/index.js b/lib/node_modules/@stdlib/stats/base/dists/bradford/cdf/lib/index.js index dfc2916567ef..f9d00916bd6a 100644 --- a/lib/node_modules/@stdlib/stats/base/dists/bradford/cdf/lib/index.js +++ b/lib/node_modules/@stdlib/stats/base/dists/bradford/cdf/lib/index.js @@ -29,11 +29,11 @@ * var y = cdf( 0.5, 5.0 ); * // returns ~0.699 * -* var myPDF = cdf.factory( 5.0 ); -* y = myPDF( 0.5 ); +* var myCDF = cdf.factory( 5.0 ); +* y = myCDF( 0.5 ); * // returns ~0.699 * -* y = myPDF( 1.0 ); +* y = myCDF( 1.0 ); * // returns 1.0 */ diff --git a/lib/node_modules/@stdlib/stats/base/dists/bradford/cdf/lib/main.js b/lib/node_modules/@stdlib/stats/base/dists/bradford/cdf/lib/main.js index 66802a2d1dba..f3b647b7cedc 100644 --- a/lib/node_modules/@stdlib/stats/base/dists/bradford/cdf/lib/main.js +++ b/lib/node_modules/@stdlib/stats/base/dists/bradford/cdf/lib/main.js @@ -70,11 +70,7 @@ var log1p = require( '@stdlib/math/base/special/log1p' ); * // returns NaN */ function cdf( x, c ) { - if ( - isnan( c ) || - isnan( x ) || - c <= 0.0 - ) { + if ( isnan( c ) || isnan( x ) || c <= 0.0 ) { return NaN; } if ( x <= 0.0 ) { diff --git a/lib/node_modules/@stdlib/stats/base/dists/bradford/cdf/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/bradford/cdf/test/test.native.js index d42e86961b2b..8f42f6cd57b7 100644 --- a/lib/node_modules/@stdlib/stats/base/dists/bradford/cdf/test/test.native.js +++ b/lib/node_modules/@stdlib/stats/base/dists/bradford/cdf/test/test.native.js @@ -80,32 +80,38 @@ tape( 'if provided `c <= 0`, the function returns `NaN`', opts, function test( t t.end(); }); -tape( 'if provided `x <= 0` and a valid `c`, the function returns `0`', opts, function test( t ) { +tape( 'if provided a number greater than or equal to one for `x` and a finite `c`, the function returns `1`', opts, function test( t ) { var y; - y = cdf( 0.0, 1.0 ); - t.equal( y, 0.0, 'returns expected value' ); + y = cdf( PINF, 0.5 ); + t.equal( y, 1.0, 'returns expected value' ); - y = cdf( -0.5, 1.0 ); - t.equal( y, 0.0, 'returns expected value' ); + y = cdf( 100.0, 0.5 ); + t.equal( y, 1.0, 'returns expected value' ); - y = cdf( NINF, 1.0 ); - t.equal( y, 0.0, 'returns expected value' ); + y = cdf( 10.0, 0.5 ); + t.equal( y, 1.0, 'returns expected value' ); + + y = cdf( 1.0, 0.5 ); + t.equal( y, 1.0, 'returns expected value' ); t.end(); }); -tape( 'if provided `x >= 1` and a valid `c`, the function returns `1`', opts, function test( t ) { +tape( 'if provided a number less than or equal to zero for `x` and a finite `c`, the function returns `0`', opts, function test( t ) { var y; - y = cdf( 1.0, 1.0 ); - t.equal( y, 1.0, 'returns expected value' ); + y = cdf( NINF, 0.5 ); + t.equal( y, 0.0, 'returns expected value' ); - y = cdf( 2.0, 1.0 ); - t.equal( y, 1.0, 'returns expected value' ); + y = cdf( -100.0, 0.5 ); + t.equal( y, 0.0, 'returns expected value' ); - y = cdf( PINF, 1.0 ); - t.equal( y, 1.0, 'returns expected value' ); + y = cdf( -1.0, 0.5 ); + t.equal( y, 0.0, 'returns expected value' ); + + y = cdf( 0.0, 0.5 ); + t.equal( y, 0.0, 'returns expected value' ); t.end(); }); diff --git a/lib/node_modules/@stdlib/stats/base/dists/bradford/entropy/benchmark/c/benchmark.c b/lib/node_modules/@stdlib/stats/base/dists/bradford/entropy/benchmark/c/benchmark.c index b67a9eb1cfa6..2e3fa4acdf1e 100644 --- a/lib/node_modules/@stdlib/stats/base/dists/bradford/entropy/benchmark/c/benchmark.c +++ b/lib/node_modules/@stdlib/stats/base/dists/bradford/entropy/benchmark/c/benchmark.c @@ -99,12 +99,9 @@ static double benchmark( void ) { double y; int i; - // Generate test data: for ( i = 0; i < 100; i++ ) { c[ i ] = random_uniform( STDLIB_CONSTANT_FLOAT64_EPS, 10.0 ); } - - // Run the benchmark: t = tic(); for ( i = 0; i < ITERATIONS; i++ ) { y = stdlib_base_dists_bradford_entropy( c[ i % 100 ] ); @@ -125,21 +122,17 @@ static double benchmark( void ) { */ int main( void ) { double elapsed; - int count; int i; // Use the current time to seed the pseudorandom number generator: srand( time( NULL ) ); print_version(); - count = 0; for ( i = 0; i < REPEATS; i++ ) { - count += 1; printf( "# c::%s\n", NAME ); elapsed = benchmark(); - printf( "ok %d benchmark finished\n", count ); print_results( elapsed ); - printf( "\n" ); + printf( "ok %d benchmark finished\n", i+1 ); } - print_summary( count, count ); + print_summary( REPEATS, REPEATS ); } diff --git a/lib/node_modules/@stdlib/stats/base/dists/bradford/entropy/lib/main.js b/lib/node_modules/@stdlib/stats/base/dists/bradford/entropy/lib/main.js index 8bb6ada8f0c8..68b6f4ed2597 100644 --- a/lib/node_modules/@stdlib/stats/base/dists/bradford/entropy/lib/main.js +++ b/lib/node_modules/@stdlib/stats/base/dists/bradford/entropy/lib/main.js @@ -58,10 +58,7 @@ var ln = require( '@stdlib/math/base/special/ln' ); */ function entropy( c ) { var k; - if ( - isnan( c ) || - c <= 0.0 - ) { + if ( isnan( c ) || c <= 0.0 ) { return NaN; } k = ln( 1.0 + c ); diff --git a/lib/node_modules/@stdlib/stats/base/dists/bradford/entropy/src/main.c b/lib/node_modules/@stdlib/stats/base/dists/bradford/entropy/src/main.c index 66173059aa59..4a5b93cfe82f 100644 --- a/lib/node_modules/@stdlib/stats/base/dists/bradford/entropy/src/main.c +++ b/lib/node_modules/@stdlib/stats/base/dists/bradford/entropy/src/main.c @@ -32,10 +32,7 @@ */ double stdlib_base_dists_bradford_entropy( const double c ) { double k; - if ( - stdlib_base_is_nan( c ) || - c <= 0.0 - ) { + if ( stdlib_base_is_nan( c ) || c <= 0.0 ) { return 0.0/0.0; // NaN } k = stdlib_base_ln( 1.0 + c ); diff --git a/lib/node_modules/@stdlib/stats/base/dists/bradford/entropy/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/bradford/entropy/test/test.native.js index 7093993ebead..7c0add73a454 100644 --- a/lib/node_modules/@stdlib/stats/base/dists/bradford/entropy/test/test.native.js +++ b/lib/node_modules/@stdlib/stats/base/dists/bradford/entropy/test/test.native.js @@ -24,6 +24,7 @@ var resolve = require( 'path' ).resolve; var tape = require( 'tape' ); var isnan = require( '@stdlib/math/base/assert/is-nan' ); var abs = require( '@stdlib/math/base/special/abs' ); +var NINF = require( '@stdlib/constants/float64/ninf' ); var EPS = require( '@stdlib/constants/float64/eps' ); var tryRequire = require( '@stdlib/utils/try-require' ); @@ -38,7 +39,8 @@ var opts = { // FIXTURES // -var data = require( './fixtures/python/small_c.json' ); +var smallC = require( './fixtures/python/small_c.json' ); +var largeC = require( './fixtures/python/large_c.json' ); // TESTS // @@ -55,35 +57,61 @@ tape( 'the function returns `NaN` if provided `NaN`', opts, function test( t ) { t.end(); }); -tape( 'the function returns `NaN` if provided a shape parameter which is not positive', opts, function test( t ) { - var y; +tape( 'if provided `c <= 0`, the function returns `NaN`', opts, function test( t ) { + var v; - y = entropy( 0.0 ); - t.equal( isnan( y ), true, 'returns expected value' ); + v = entropy( 0.0 ); + t.equal( isnan( v ), true, 'returns expected value' ); - y = entropy( -1.0 ); - t.equal( isnan( y ), true, 'returns expected value' ); + v = entropy( -1.0 ); + t.equal( isnan( v ), true, 'returns expected value' ); + + v = entropy( NINF ); + t.equal( isnan( v ), true, 'returns expected value' ); t.end(); }); -tape( 'the function returns the differential entropy of a Bradford distribution', opts, function test( t ) { +tape( 'the function returns the differential entropy of a Bradford distribution given small parameter `c`', opts, function test( t ) { var expected; var delta; var tol; + var i; var c; var y; + + expected = smallC.expected; + c = smallC.c; + for ( i = 0; i < expected.length; i++ ) { + y = entropy( c[i] ); + if ( y === expected[i] ) { + t.equal( y, expected[i], 'c: '+c[i]+', y: '+y+', expected: '+expected[i] ); + } else { + delta = abs( y - expected[ i ] ); + tol = 1523.0 * EPS * abs( expected[ i ] ); + t.ok( delta <= tol, 'within tolerance. c: '+c[i]+'. y: '+y+'. E: '+expected[ i ]+'. Δ: '+delta+'. tol: '+tol+'.' ); + } + } + t.end(); +}); + +tape( 'the function returns the differential entropy of a Bradford distribution given large parameter `c`', opts, function test( t ) { + var expected; + var delta; + var tol; var i; + var c; + var y; - expected = data.expected; - c = data.c; - for ( i = 0; i < c.length; i++ ) { + expected = largeC.expected; + c = largeC.c; + for ( i = 0; i < expected.length; i++ ) { y = entropy( c[i] ); if ( y === expected[i] ) { t.equal( y, expected[i], 'c: '+c[i]+', y: '+y+', expected: '+expected[i] ); } else { delta = abs( y - expected[ i ] ); - tol = 990.0 * EPS * abs( expected[ i ] ); + tol = 45.0 * EPS * abs( expected[ i ] ); t.ok( delta <= tol, 'within tolerance. c: '+c[i]+'. y: '+y+'. E: '+expected[ i ]+'. Δ: '+delta+'. tol: '+tol+'.' ); } } diff --git a/lib/node_modules/@stdlib/stats/base/dists/bradford/mean/benchmark/benchmark.native.js b/lib/node_modules/@stdlib/stats/base/dists/bradford/mean/benchmark/benchmark.native.js index 5bd635f40150..24ad2b0ada49 100644 --- a/lib/node_modules/@stdlib/stats/base/dists/bradford/mean/benchmark/benchmark.native.js +++ b/lib/node_modules/@stdlib/stats/base/dists/bradford/mean/benchmark/benchmark.native.js @@ -22,8 +22,7 @@ var resolve = require( 'path' ).resolve; var bench = require( '@stdlib/bench' ); -var Float64Array = require( '@stdlib/array/float64' ); -var uniform = require( '@stdlib/random/base/uniform' ); +var uniform = require( '@stdlib/random/array/uniform' ); var isnan = require( '@stdlib/math/base/assert/is-nan' ); var tryRequire = require( '@stdlib/utils/try-require' ); var pkg = require( './../package.json' ).name; @@ -40,20 +39,19 @@ var opts = { // MAIN // bench( pkg+'::native', opts, function benchmark( b ) { - var len; + var opts; var c; var y; var i; - len = 100; - c = new Float64Array( len ); - for ( i = 0; i < len; i++ ) { - c[ i ] = uniform( 0.1, 10.0 ); - } + opts = { + 'dtype': 'float64' + }; + c = uniform( 100, 0.1, 10.0, opts ); b.tic(); for ( i = 0; i < b.iterations; i++ ) { - y = mean( c[ i % len ] ); + y = mean( c[ i % c.length ] ); if ( isnan( y ) ) { b.fail( 'should not return NaN' ); } diff --git a/lib/node_modules/@stdlib/stats/base/dists/bradford/mean/benchmark/c/benchmark.c b/lib/node_modules/@stdlib/stats/base/dists/bradford/mean/benchmark/c/benchmark.c index 5928279dbeb6..18f23d137044 100644 --- a/lib/node_modules/@stdlib/stats/base/dists/bradford/mean/benchmark/c/benchmark.c +++ b/lib/node_modules/@stdlib/stats/base/dists/bradford/mean/benchmark/c/benchmark.c @@ -99,12 +99,9 @@ static double benchmark( void ) { double y; int i; - // Generate test data: for ( i = 0; i < 100; i++ ) { c[ i ] = random_uniform( STDLIB_CONSTANT_FLOAT64_EPS, 10.0 ); } - - // Run the benchmark: t = tic(); for ( i = 0; i < ITERATIONS; i++ ) { y = stdlib_base_dists_bradford_mean( c[ i % 100 ] ); @@ -125,21 +122,17 @@ static double benchmark( void ) { */ int main( void ) { double elapsed; - int count; int i; // Use the current time to seed the pseudorandom number generator: srand( time( NULL ) ); print_version(); - count = 0; for ( i = 0; i < REPEATS; i++ ) { - count += 1; printf( "# c::%s\n", NAME ); elapsed = benchmark(); - printf( "ok %d benchmark finished\n", count ); print_results( elapsed ); - printf( "\n" ); + printf( "ok %d benchmark finished\n", i+1 ); } - print_summary( count, count ); + print_summary( REPEATS, REPEATS ); } diff --git a/lib/node_modules/@stdlib/stats/base/dists/bradford/mean/docs/repl.txt b/lib/node_modules/@stdlib/stats/base/dists/bradford/mean/docs/repl.txt index 63ea829ce2c1..0bd4f2e7b0c4 100644 --- a/lib/node_modules/@stdlib/stats/base/dists/bradford/mean/docs/repl.txt +++ b/lib/node_modules/@stdlib/stats/base/dists/bradford/mean/docs/repl.txt @@ -1,7 +1,7 @@ {{alias}}( c ) - Returns the expected value of a Bradford distribution with shape - parameter `c`. + Returns the expected value of a Bradford distribution with shape parameter + `c`. If `c <= 0`, the function returns `NaN`. diff --git a/lib/node_modules/@stdlib/stats/base/dists/bradford/mean/lib/main.js b/lib/node_modules/@stdlib/stats/base/dists/bradford/mean/lib/main.js index a4089c28d464..94869ff8b944 100644 --- a/lib/node_modules/@stdlib/stats/base/dists/bradford/mean/lib/main.js +++ b/lib/node_modules/@stdlib/stats/base/dists/bradford/mean/lib/main.js @@ -58,10 +58,7 @@ var ln = require( '@stdlib/math/base/special/ln' ); */ function mean( c ) { var k; - if ( - isnan( c ) || - c <= 0.0 - ) { + if ( isnan( c ) || c <= 0.0 ) { return NaN; } k = ln( 1.0 + c ); diff --git a/lib/node_modules/@stdlib/stats/base/dists/bradford/mean/src/main.c b/lib/node_modules/@stdlib/stats/base/dists/bradford/mean/src/main.c index e2e28712e8ea..db51bcddd72d 100644 --- a/lib/node_modules/@stdlib/stats/base/dists/bradford/mean/src/main.c +++ b/lib/node_modules/@stdlib/stats/base/dists/bradford/mean/src/main.c @@ -32,10 +32,7 @@ */ double stdlib_base_dists_bradford_mean( const double c ) { double k; - if ( - stdlib_base_is_nan( c ) || - c <= 0.0 - ) { + if ( stdlib_base_is_nan( c ) || c <= 0.0 ) { return 0.0/0.0; // NaN } k = stdlib_base_ln( 1.0 + c ); diff --git a/lib/node_modules/@stdlib/stats/base/dists/bradford/mean/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/bradford/mean/test/test.js index ddee526e35f9..3e8cf878f48e 100644 --- a/lib/node_modules/@stdlib/stats/base/dists/bradford/mean/test/test.js +++ b/lib/node_modules/@stdlib/stats/base/dists/bradford/mean/test/test.js @@ -41,7 +41,7 @@ tape( 'main export is a function', function test( t ) { t.end(); }); -tape( 'if provided `NaN` for `c`, the function returns `NaN`', function test( t ) { +tape( 'if provided `NaN`, the function returns `NaN`', function test( t ) { var v = mean( NaN ); t.equal( isnan( v ), true, 'returns expected value' ); t.end(); @@ -62,7 +62,7 @@ tape( 'if provided `c <= 0`, the function returns `NaN`', function test( t ) { t.end(); }); -tape( 'the function returns the mean of a Bradford distribution', function test( t ) { +tape( 'the function returns the expected value of a Bradford distribution', function test( t ) { var expected; var delta; var tol; diff --git a/lib/node_modules/@stdlib/stats/base/dists/bradford/mode/benchmark/c/benchmark.c b/lib/node_modules/@stdlib/stats/base/dists/bradford/mode/benchmark/c/benchmark.c index 16a7c136ee98..b359ab0fe848 100644 --- a/lib/node_modules/@stdlib/stats/base/dists/bradford/mode/benchmark/c/benchmark.c +++ b/lib/node_modules/@stdlib/stats/base/dists/bradford/mode/benchmark/c/benchmark.c @@ -99,12 +99,9 @@ static double benchmark( void ) { double y; int i; - // Generate test data: for ( i = 0; i < 100; i++ ) { c[ i ] = random_uniform( STDLIB_CONSTANT_FLOAT64_EPS, 10.0 ); } - - // Run the benchmark: t = tic(); for ( i = 0; i < ITERATIONS; i++ ) { y = stdlib_base_dists_bradford_mode( c[ i % 100 ] ); @@ -125,21 +122,17 @@ static double benchmark( void ) { */ int main( void ) { double elapsed; - int count; int i; // Use the current time to seed the pseudorandom number generator: srand( time( NULL ) ); print_version(); - count = 0; for ( i = 0; i < REPEATS; i++ ) { - count += 1; printf( "# c::%s\n", NAME ); elapsed = benchmark(); - printf( "ok %d benchmark finished\n", count ); print_results( elapsed ); - printf( "\n" ); + printf( "ok %d benchmark finished\n", i+1 ); } - print_summary( count, count ); + print_summary( REPEATS, REPEATS ); } diff --git a/lib/node_modules/@stdlib/stats/base/dists/bradford/mode/lib/main.js b/lib/node_modules/@stdlib/stats/base/dists/bradford/mode/lib/main.js index 797e533b6c5b..21f7862e946e 100644 --- a/lib/node_modules/@stdlib/stats/base/dists/bradford/mode/lib/main.js +++ b/lib/node_modules/@stdlib/stats/base/dists/bradford/mode/lib/main.js @@ -56,10 +56,7 @@ var isnan = require( '@stdlib/math/base/assert/is-nan' ); * // returns NaN */ function mode( c ) { - if ( - isnan( c ) || - c <= 0.0 - ) { + if ( isnan( c ) || c <= 0.0 ) { return NaN; } return 0.0; diff --git a/lib/node_modules/@stdlib/stats/base/dists/bradford/mode/lib/native.js b/lib/node_modules/@stdlib/stats/base/dists/bradford/mode/lib/native.js index 21e0c7fcc27d..d67b26a188f5 100644 --- a/lib/node_modules/@stdlib/stats/base/dists/bradford/mode/lib/native.js +++ b/lib/node_modules/@stdlib/stats/base/dists/bradford/mode/lib/native.js @@ -56,7 +56,9 @@ var addon = require( './../src/addon.node' ); * var v = mode( NaN ); * // returns NaN */ -var mode = addon; +function mode( c ) { + return addon( c ); +} // EXPORTS // diff --git a/lib/node_modules/@stdlib/stats/base/dists/bradford/mode/src/main.c b/lib/node_modules/@stdlib/stats/base/dists/bradford/mode/src/main.c index ea13b7cecb84..6a56097313b0 100644 --- a/lib/node_modules/@stdlib/stats/base/dists/bradford/mode/src/main.c +++ b/lib/node_modules/@stdlib/stats/base/dists/bradford/mode/src/main.c @@ -30,10 +30,7 @@ * // returns 0.0 */ double stdlib_base_dists_bradford_mode( const double c ) { - if ( - stdlib_base_is_nan( c ) || - c <= 0.0 - ) { + if ( stdlib_base_is_nan( c ) || c <= 0.0 ) { return 0.0/0.0; // NaN } return 0.0; diff --git a/lib/node_modules/@stdlib/stats/base/dists/bradford/mode/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/bradford/mode/test/test.native.js index 48342c84dab5..0e2796a3a62e 100644 --- a/lib/node_modules/@stdlib/stats/base/dists/bradford/mode/test/test.native.js +++ b/lib/node_modules/@stdlib/stats/base/dists/bradford/mode/test/test.native.js @@ -23,7 +23,7 @@ var resolve = require( 'path' ).resolve; var tape = require( 'tape' ); var isnan = require( '@stdlib/math/base/assert/is-nan' ); -var PINF = require( '@stdlib/constants/float64/pinf' ); +var uniform = require( '@stdlib/random/array/uniform' ); var NINF = require( '@stdlib/constants/float64/ninf' ); var tryRequire = require( '@stdlib/utils/try-require' ); @@ -46,45 +46,35 @@ tape( 'main export is a function', opts, function test( t ) { tape( 'if provided `NaN` for `c`, the function returns `NaN`', opts, function test( t ) { var v = mode( NaN ); - t.equal( isnan( v ), true, 'returns NaN' ); + t.equal( isnan( v ), true, 'returns expected value' ); t.end(); }); -tape( 'if provided a nonpositive `c`, the function returns `NaN`', opts, function test( t ) { +tape( 'if provided `c <= 0`, the function returns `NaN`', opts, function test( t ) { var v; v = mode( 0.0 ); - t.equal( isnan( v ), true, 'returns NaN' ); + t.equal( isnan( v ), true, 'returns expected value' ); v = mode( -1.0 ); - t.equal( isnan( v ), true, 'returns NaN' ); + t.equal( isnan( v ), true, 'returns expected value' ); v = mode( NINF ); - t.equal( isnan( v ), true, 'returns NaN' ); + t.equal( isnan( v ), true, 'returns expected value' ); t.end(); }); -tape( 'the function returns the mode of a Bradford distribution', opts, function test( t ) { - var v; - - v = mode( 0.1 ); - t.equal( v, 0.0, 'returns 0.0' ); - - v = mode( 0.5 ); - t.equal( v, 0.0, 'returns 0.0' ); - - v = mode( 1.0 ); - t.equal( v, 0.0, 'returns 0.0' ); - - v = mode( 10.0 ); - t.equal( v, 0.0, 'returns 0.0' ); - - v = mode( 100.0 ); - t.equal( v, 0.0, 'returns 0.0' ); +tape( 'the function returns `0.0` as the mode of a Bradford distribution', opts, function test( t ) { + var c; + var i; + var y; - v = mode( PINF ); - t.equal( v, 0.0, 'returns 0.0' ); + c = uniform( 10, 0.1, 10.0 ); + for ( i = 0; i < c.length; i++ ) { + y = mode( c[ i ] ); + t.equal( y, 0.0, 'returns expected value' ); + } t.end(); }); diff --git a/lib/node_modules/@stdlib/stats/base/dists/bradford/pdf/benchmark/benchmark.native.js b/lib/node_modules/@stdlib/stats/base/dists/bradford/pdf/benchmark/benchmark.native.js index 959aa759d91e..5323952f5943 100644 --- a/lib/node_modules/@stdlib/stats/base/dists/bradford/pdf/benchmark/benchmark.native.js +++ b/lib/node_modules/@stdlib/stats/base/dists/bradford/pdf/benchmark/benchmark.native.js @@ -22,8 +22,7 @@ var resolve = require( 'path' ).resolve; var bench = require( '@stdlib/bench' ); -var Float64Array = require( '@stdlib/array/float64' ); -var uniform = require( '@stdlib/random/base/uniform' ); +var uniform = require( '@stdlib/random/array/uniform' ); var isnan = require( '@stdlib/math/base/assert/is-nan' ); var tryRequire = require( '@stdlib/utils/try-require' ); var pkg = require( './../package.json' ).name; @@ -40,23 +39,21 @@ var opts = { // MAIN // bench( pkg+'::native', opts, function benchmark( b ) { - var len; + var opts; var x; var c; var y; var i; - len = 100; - x = new Float64Array( len ); - c = new Float64Array( len ); - for ( i = 0; i < len; i++ ) { - x[ i ] = uniform( 0.0, 1.0 ); - c[ i ] = uniform( 0.1, 10.0 ); - } + opts = { + 'dtype': 'float64' + }; + x = uniform( 100, 0.0, 1.0, opts ); + c = uniform( 100, 0.1, 10.0, opts ); b.tic(); for ( i = 0; i < b.iterations; i++ ) { - y = pdf( x[ i % len ], c[ i % len ] ); + y = pdf( x[ i % x.length ], c[ i % c.length ] ); if ( isnan( y ) ) { b.fail( 'should not return NaN' ); } diff --git a/lib/node_modules/@stdlib/stats/base/dists/bradford/pdf/benchmark/c/benchmark.c b/lib/node_modules/@stdlib/stats/base/dists/bradford/pdf/benchmark/c/benchmark.c index 6ca09fc46c66..5a0593924400 100644 --- a/lib/node_modules/@stdlib/stats/base/dists/bradford/pdf/benchmark/c/benchmark.c +++ b/lib/node_modules/@stdlib/stats/base/dists/bradford/pdf/benchmark/c/benchmark.c @@ -100,13 +100,10 @@ static double benchmark( void ) { double y; int i; - // Generate test data: for ( i = 0; i < 100; i++ ) { x[ i ] = random_uniform( 0.0, 1.0 ); c[ i ] = random_uniform( STDLIB_CONSTANT_FLOAT64_EPS, 10.0 ); } - - // Run the benchmark: t = tic(); for ( i = 0; i < ITERATIONS; i++ ) { y = stdlib_base_dists_bradford_pdf( x[ i % 100 ], c[ i % 100 ] ); @@ -127,21 +124,17 @@ static double benchmark( void ) { */ int main( void ) { double elapsed; - int count; int i; // Use the current time to seed the pseudorandom number generator: srand( time( NULL ) ); print_version(); - count = 0; for ( i = 0; i < REPEATS; i++ ) { - count += 1; printf( "# c::%s\n", NAME ); elapsed = benchmark(); - printf( "ok %d benchmark finished\n", count ); print_results( elapsed ); - printf( "\n" ); + printf( "ok %d benchmark finished\n", i+1 ); } - print_summary( count, count ); + print_summary( REPEATS, REPEATS ); } diff --git a/lib/node_modules/@stdlib/stats/base/dists/bradford/pdf/lib/factory.js b/lib/node_modules/@stdlib/stats/base/dists/bradford/pdf/lib/factory.js index 58006b001abb..85bceef9c331 100644 --- a/lib/node_modules/@stdlib/stats/base/dists/bradford/pdf/lib/factory.js +++ b/lib/node_modules/@stdlib/stats/base/dists/bradford/pdf/lib/factory.js @@ -43,10 +43,7 @@ var log1p = require( '@stdlib/math/base/special/log1p' ); */ function factory( c ) { var k; - if ( - isnan( c ) || - c <= 0.0 - ) { + if ( isnan( c ) || c <= 0.0 ) { return constantFunction( NaN ); } k = log1p( c ); @@ -64,13 +61,10 @@ function factory( c ) { * // returns */ function pdf( x ) { - if ( - isnan( x ) - ) { + if ( isnan( x ) ) { return NaN; } if ( x < 0.0 || x > 1.0 ) { - // Support of the Bradford distribution: [0,1] return 0.0; } return c / ( ( 1.0 + ( c*x ) ) * k ); diff --git a/lib/node_modules/@stdlib/stats/base/dists/bradford/pdf/lib/main.js b/lib/node_modules/@stdlib/stats/base/dists/bradford/pdf/lib/main.js index debecb8de99c..2d3c70da09b7 100644 --- a/lib/node_modules/@stdlib/stats/base/dists/bradford/pdf/lib/main.js +++ b/lib/node_modules/@stdlib/stats/base/dists/bradford/pdf/lib/main.js @@ -71,15 +71,10 @@ var log1p = require( '@stdlib/math/base/special/log1p' ); */ function pdf( x, c ) { var k; - if ( - isnan( c ) || - isnan( x ) || - c <= 0.0 - ) { + if ( isnan( c ) || isnan( x ) || c <= 0.0 ) { return NaN; } if ( x < 0.0 || x > 1.0 ) { - // Support of the Bradford distribution: [0,1] return 0.0; } k = log1p( c ); diff --git a/lib/node_modules/@stdlib/stats/base/dists/bradford/pdf/src/main.c b/lib/node_modules/@stdlib/stats/base/dists/bradford/pdf/src/main.c index 073b2117a9ec..0944fa4dfad1 100644 --- a/lib/node_modules/@stdlib/stats/base/dists/bradford/pdf/src/main.c +++ b/lib/node_modules/@stdlib/stats/base/dists/bradford/pdf/src/main.c @@ -33,16 +33,10 @@ */ double stdlib_base_dists_bradford_pdf( const double x, const double c ) { double k; - - if ( - stdlib_base_is_nan( x ) || - stdlib_base_is_nan( c ) || - c <= 0.0 - ) { + if ( stdlib_base_is_nan( x ) || stdlib_base_is_nan( c ) || c <= 0.0 ) { return 0.0/0.0; // NaN } if ( x < 0.0 || x > 1.0 ) { - // Support of the Bradford distribution: [0,1] return 0.0; } k = stdlib_base_log1p( c ); diff --git a/lib/node_modules/@stdlib/stats/base/dists/bradford/quantile/benchmark/benchmark.native.js b/lib/node_modules/@stdlib/stats/base/dists/bradford/quantile/benchmark/benchmark.native.js index 9d47715071a2..2c50ec4090b6 100644 --- a/lib/node_modules/@stdlib/stats/base/dists/bradford/quantile/benchmark/benchmark.native.js +++ b/lib/node_modules/@stdlib/stats/base/dists/bradford/quantile/benchmark/benchmark.native.js @@ -22,8 +22,7 @@ var resolve = require( 'path' ).resolve; var bench = require( '@stdlib/bench' ); -var Float64Array = require( '@stdlib/array/float64' ); -var uniform = require( '@stdlib/random/base/uniform' ); +var uniform = require( '@stdlib/random/array/uniform' ); var isnan = require( '@stdlib/math/base/assert/is-nan' ); var tryRequire = require( '@stdlib/utils/try-require' ); var pkg = require( './../package.json' ).name; @@ -40,23 +39,21 @@ var opts = { // MAIN // bench( pkg+'::native', opts, function benchmark( b ) { - var len; + var opts; var p; var c; var y; var i; - len = 100; - p = new Float64Array( len ); - c = new Float64Array( len ); - for ( i = 0; i < len; i++ ) { - p[ i ] = uniform( 0.0, 1.0 ); - c[ i ] = uniform( 0.1, 10.0 ); - } + opts = { + 'dtype': 'float64' + }; + p = uniform( 100, 0.0, 1.0, opts ); + c = uniform( 100, 0.1, 10.0, opts ); b.tic(); for ( i = 0; i < b.iterations; i++ ) { - y = quantile( p[ i % len ], c[ i % len ] ); + y = quantile( p[ i % p.length ], c[ i % c.length ] ); if ( isnan( y ) ) { b.fail( 'should not return NaN' ); } diff --git a/lib/node_modules/@stdlib/stats/base/dists/bradford/quantile/benchmark/c/benchmark.c b/lib/node_modules/@stdlib/stats/base/dists/bradford/quantile/benchmark/c/benchmark.c index 2fcb94b3de4d..7879e9f1376c 100644 --- a/lib/node_modules/@stdlib/stats/base/dists/bradford/quantile/benchmark/c/benchmark.c +++ b/lib/node_modules/@stdlib/stats/base/dists/bradford/quantile/benchmark/c/benchmark.c @@ -100,13 +100,10 @@ static double benchmark( void ) { double y; int i; - // Generate test data: for ( i = 0; i < 100; i++ ) { p[ i ] = random_uniform( 0.0, 1.0 ); c[ i ] = random_uniform( STDLIB_CONSTANT_FLOAT64_EPS, 10.0 ); } - - // Run the benchmark: t = tic(); for ( i = 0; i < ITERATIONS; i++ ) { y = stdlib_base_dists_bradford_quantile( p[ i % 100 ], c[ i % 100 ] ); @@ -127,21 +124,17 @@ static double benchmark( void ) { */ int main( void ) { double elapsed; - int count; int i; // Use the current time to seed the pseudorandom number generator: srand( time( NULL ) ); print_version(); - count = 0; for ( i = 0; i < REPEATS; i++ ) { - count += 1; printf( "# c::%s\n", NAME ); elapsed = benchmark(); - printf( "ok %d benchmark finished\n", count ); print_results( elapsed ); - printf( "\n" ); + printf( "ok %d benchmark finished\n", i+1 ); } - print_summary( count, count ); + print_summary( REPEATS, REPEATS ); } diff --git a/lib/node_modules/@stdlib/stats/base/dists/bradford/quantile/lib/factory.js b/lib/node_modules/@stdlib/stats/base/dists/bradford/quantile/lib/factory.js index 07e45fd9bd84..68348e73f331 100644 --- a/lib/node_modules/@stdlib/stats/base/dists/bradford/quantile/lib/factory.js +++ b/lib/node_modules/@stdlib/stats/base/dists/bradford/quantile/lib/factory.js @@ -46,10 +46,7 @@ var log1p = require( '@stdlib/math/base/special/log1p' ); * // returns 1.0 */ function factory( c ) { - if ( - isnan( c ) || - c <= 0.0 - ) { + if ( isnan( c ) || c <= 0.0 ) { return constantFunction( NaN ); } return quantile; @@ -66,11 +63,7 @@ function factory( c ) { * // returns */ function quantile( p ) { - if ( - isnan( p ) || - p < 0.0 || - p > 1.0 - ) { + if ( isnan( p ) || p < 0.0 || p > 1.0 ) { return NaN; } return expm1( p * log1p( c ) ) / c; diff --git a/lib/node_modules/@stdlib/stats/base/dists/bradford/quantile/lib/main.js b/lib/node_modules/@stdlib/stats/base/dists/bradford/quantile/lib/main.js index 74f033d9b3d3..9ca3f0067e15 100644 --- a/lib/node_modules/@stdlib/stats/base/dists/bradford/quantile/lib/main.js +++ b/lib/node_modules/@stdlib/stats/base/dists/bradford/quantile/lib/main.js @@ -67,13 +67,7 @@ var log1p = require( '@stdlib/math/base/special/log1p' ); * // returns NaN */ function quantile( p, c ) { - if ( - isnan( c ) || - isnan( p ) || - c <= 0.0 || - p < 0.0 || - p > 1.0 - ) { + if ( isnan( c ) || isnan( p ) || c <= 0.0 || p < 0.0 || p > 1.0 ) { return NaN; } return expm1( p * log1p( c ) ) / c; diff --git a/lib/node_modules/@stdlib/stats/base/dists/bradford/quantile/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/bradford/quantile/test/test.native.js index 4929b8d3b57f..a205860f761f 100644 --- a/lib/node_modules/@stdlib/stats/base/dists/bradford/quantile/test/test.native.js +++ b/lib/node_modules/@stdlib/stats/base/dists/bradford/quantile/test/test.native.js @@ -80,7 +80,7 @@ tape( 'if provided `c <= 0`, the function returns `NaN`', opts, function test( t t.end(); }); -tape( 'if provided a probability outside [0,1], the function returns `NaN`', opts, function test( t ) { +tape( 'if provided a number outside `[0,1]` for `p` and a valid `c`, the function returns `NaN`', opts, function test( t ) { var y; y = quantile( 2.0, 1.0 ); diff --git a/lib/node_modules/@stdlib/stats/base/dists/bradford/stdev/benchmark/c/benchmark.c b/lib/node_modules/@stdlib/stats/base/dists/bradford/stdev/benchmark/c/benchmark.c index 2cbc63786b7a..cb742037867d 100644 --- a/lib/node_modules/@stdlib/stats/base/dists/bradford/stdev/benchmark/c/benchmark.c +++ b/lib/node_modules/@stdlib/stats/base/dists/bradford/stdev/benchmark/c/benchmark.c @@ -99,12 +99,9 @@ static double benchmark( void ) { double y; int i; - // Generate test data: for ( i = 0; i < 100; i++ ) { c[ i ] = random_uniform( STDLIB_CONSTANT_FLOAT64_EPS, 10.0 ); } - - // Run the benchmark: t = tic(); for ( i = 0; i < ITERATIONS; i++ ) { y = stdlib_base_dists_bradford_stdev( c[ i % 100 ] ); @@ -125,21 +122,17 @@ static double benchmark( void ) { */ int main( void ) { double elapsed; - int count; int i; // Use the current time to seed the pseudorandom number generator: srand( time( NULL ) ); print_version(); - count = 0; for ( i = 0; i < REPEATS; i++ ) { - count += 1; printf( "# c::%s\n", NAME ); elapsed = benchmark(); - printf( "ok %d benchmark finished\n", count ); print_results( elapsed ); - printf( "\n" ); + printf( "ok %d benchmark finished\n", i+1 ); } - print_summary( count, count ); + print_summary( REPEATS, REPEATS ); } diff --git a/lib/node_modules/@stdlib/stats/base/dists/bradford/stdev/lib/main.js b/lib/node_modules/@stdlib/stats/base/dists/bradford/stdev/lib/main.js index ceaa668952eb..f93643b6a1da 100644 --- a/lib/node_modules/@stdlib/stats/base/dists/bradford/stdev/lib/main.js +++ b/lib/node_modules/@stdlib/stats/base/dists/bradford/stdev/lib/main.js @@ -59,10 +59,7 @@ var sqrt = require( '@stdlib/math/base/special/sqrt' ); */ function stdev( c ) { var k; - if ( - isnan( c ) || - c <= 0.0 - ) { + if ( isnan( c ) || c <= 0.0 ) { return NaN; } k = ln( 1.0 + c ); diff --git a/lib/node_modules/@stdlib/stats/base/dists/bradford/stdev/lib/native.js b/lib/node_modules/@stdlib/stats/base/dists/bradford/stdev/lib/native.js index 294eb47ae0a6..2d9be3e39151 100644 --- a/lib/node_modules/@stdlib/stats/base/dists/bradford/stdev/lib/native.js +++ b/lib/node_modules/@stdlib/stats/base/dists/bradford/stdev/lib/native.js @@ -56,7 +56,9 @@ var addon = require( './../src/addon.node' ); * var v = stdev( NaN ); * // returns NaN */ -var stdev = addon; +function stdev( c ) { + return addon( c ); +} // EXPORTS // diff --git a/lib/node_modules/@stdlib/stats/base/dists/bradford/stdev/src/main.c b/lib/node_modules/@stdlib/stats/base/dists/bradford/stdev/src/main.c index 96117ddd543f..2795f6b970ec 100644 --- a/lib/node_modules/@stdlib/stats/base/dists/bradford/stdev/src/main.c +++ b/lib/node_modules/@stdlib/stats/base/dists/bradford/stdev/src/main.c @@ -33,12 +33,9 @@ */ double stdlib_base_dists_bradford_stdev( const double c ) { double k; - if ( - stdlib_base_is_nan( c ) || - c <= 0.0 - ) { + if ( stdlib_base_is_nan( c ) || c <= 0.0 ) { return 0.0/0.0; // NaN } k = stdlib_base_ln( 1.0 + c ); - return stdlib_base_sqrt( ( ( ( 2.0 + c ) * k ) - ( 2.0 * c ) ) / ( 2.0 * c * k * k ) ); + return stdlib_base_sqrt( ( ( ( 2.0+c ) * k ) - ( 2.0*c ) ) / ( 2.0*c*k*k ) ); } diff --git a/lib/node_modules/@stdlib/stats/base/dists/chi/entropy/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/chi/entropy/test/test.native.js index 7e4f00c9cb68..389a41171862 100644 --- a/lib/node_modules/@stdlib/stats/base/dists/chi/entropy/test/test.native.js +++ b/lib/node_modules/@stdlib/stats/base/dists/chi/entropy/test/test.native.js @@ -71,7 +71,7 @@ tape( 'if provided a degrees of freedom parameter `k` that is not a positive num t.end(); }); -tape( 'the function returns the entropy of a chi distribution', opts, function test( t ) { +tape( 'the function returns the differential entropy of a chi distribution', opts, function test( t ) { var expected; var delta; var tol; diff --git a/lib/node_modules/@stdlib/stats/base/dists/chisquare/kurtosis/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/chisquare/kurtosis/test/test.native.js index ebd741ff052b..9d4220553b30 100644 --- a/lib/node_modules/@stdlib/stats/base/dists/chisquare/kurtosis/test/test.native.js +++ b/lib/node_modules/@stdlib/stats/base/dists/chisquare/kurtosis/test/test.native.js @@ -69,7 +69,7 @@ tape( 'if provided a degrees of freedom parameter `k` that is not a positive num t.end(); }); -tape( 'the function returns the kurtosis of a chi-squared distribution', opts, function test( t ) { +tape( 'the function returns the excess kurtosis of a chi-squared distribution', opts, function test( t ) { var expected; var k; var i; diff --git a/lib/node_modules/@stdlib/stats/base/dists/cosine/mean/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/cosine/mean/test/test.native.js index c47c4c1e8475..6b8ddc5f6791 100644 --- a/lib/node_modules/@stdlib/stats/base/dists/cosine/mean/test/test.native.js +++ b/lib/node_modules/@stdlib/stats/base/dists/cosine/mean/test/test.native.js @@ -80,7 +80,7 @@ tape( 'if provided `s <= 0.0`, the function returns `NaN`', opts, function test( t.end(); }); -tape( 'the function returns the mean of a cosine distribution', opts, function test( t ) { +tape( 'the function returns the expected value of a raised cosine distribution', opts, function test( t ) { var expected; var mu; var s; diff --git a/lib/node_modules/@stdlib/stats/base/dists/discrete-uniform/stdev/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/discrete-uniform/stdev/test/test.native.js index 2eebadc64ad3..58e11a8d3c58 100644 --- a/lib/node_modules/@stdlib/stats/base/dists/discrete-uniform/stdev/test/test.native.js +++ b/lib/node_modules/@stdlib/stats/base/dists/discrete-uniform/stdev/test/test.native.js @@ -58,7 +58,7 @@ tape( 'if provided `a > b`, the function returns `NaN`', opts, function test( t t.end(); }); -tape( 'the function returns the stdev of a discrete uniform distribution', opts, function test( t ) { +tape( 'the function returns the standard deviation of a discrete uniform distribution', opts, function test( t ) { var expected; var delta; var tol; diff --git a/lib/node_modules/@stdlib/stats/base/dists/exponential/entropy/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/exponential/entropy/test/test.native.js index 41e82b5531b9..f69a5f8946df 100644 --- a/lib/node_modules/@stdlib/stats/base/dists/exponential/entropy/test/test.native.js +++ b/lib/node_modules/@stdlib/stats/base/dists/exponential/entropy/test/test.native.js @@ -68,7 +68,7 @@ tape( 'if provided a rate parameter `lambda` that is not a nonnegative number, t t.end(); }); -tape( 'the function returns the entropy of an exponential distribution', opts, function test( t ) { +tape( 'the function returns the differential entropy of an exponential distribution', opts, function test( t ) { var expected; var lambda; var delta; diff --git a/lib/node_modules/@stdlib/stats/base/dists/geometric/kurtosis/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/geometric/kurtosis/test/test.native.js index 3edec486953a..4ed4e5f6b868 100644 --- a/lib/node_modules/@stdlib/stats/base/dists/geometric/kurtosis/test/test.native.js +++ b/lib/node_modules/@stdlib/stats/base/dists/geometric/kurtosis/test/test.native.js @@ -75,7 +75,7 @@ tape( 'if provided a success probability `p` outside of `[0,1]`, the function re t.end(); }); -tape( 'the function returns the kurtosis of a geometric distribution', opts, function test( t ) { +tape( 'the function returns the excess kurtosis of a geometric distribution', opts, function test( t ) { var expected; var delta; var tol; diff --git a/lib/node_modules/@stdlib/stats/base/dists/kumaraswamy/quantile/README.md b/lib/node_modules/@stdlib/stats/base/dists/kumaraswamy/quantile/README.md index 9a3c96526e98..790ace2f67a7 100644 --- a/lib/node_modules/@stdlib/stats/base/dists/kumaraswamy/quantile/README.md +++ b/lib/node_modules/@stdlib/stats/base/dists/kumaraswamy/quantile/README.md @@ -141,22 +141,14 @@ y = myQuantile( 0.3 ); ```javascript var uniform = require( '@stdlib/random/array/uniform' ); var EPS = require( '@stdlib/constants/float64/eps' ); +var logEachMap = require( '@stdlib/console/log-each-map' ); var quantile = require( '@stdlib/stats/base/dists/kumaraswamy/quantile' ); -var a; -var b; -var p; -var y; -var i; +var p = uniform( 10, 0.0, 1.0 ); +var a = uniform( 10, EPS, 5.0 ); +var b = uniform( 10, EPS, 5.0 ); -p = uniform( 10, 0.0, 1.0 ); -a = uniform( 10, EPS, 5.0 ); -b = uniform( 10, EPS, 5.0 ); - -for ( i = 0; i < p.length; i++ ) { - y = quantile( p[ i ], a[ i ], b[ i ] ); - console.log( 'p: %d, a: %d, b: %d, Q(p;a,b): %d', p[ i ].toFixed( 4 ), a[ i ].toFixed( 4 ), b[ i ].toFixed( 4 ), y.toFixed( 4 ) ); -} +logEachMap( 'p: %0.4f, a: %0.4f, b: %0.4f, Q(p;a,b): %0.4f', p, a, b, quantile ); ```
@@ -191,7 +183,7 @@ for ( i = 0; i < p.length; i++ ) { #### stdlib_base_dists_kumaraswamy_quantile( p, a, b ) -Evaluates the quantile function of a Kumaraswamy's double bounded distribution. +Evaluates the quantile function of a [Kumaraswamy's double bounded][kumaraswamy-distribution] distribution with parameters `a` (first shape parameter) and `b` (second shape parameter). ```c double out = stdlib_base_dists_kumaraswamy_quantile( 0.5, 1.0, 1.0 ); @@ -205,8 +197,7 @@ The function accepts the following arguments: - **b**: `[in] double` second shape parameter. ```c -double stdlib_base_dists_kumaraswamy_quantile( const double p, const -double a, const double b ); +double stdlib_base_dists_kumaraswamy_quantile( const double p, const double a, const double b ); ``` diff --git a/lib/node_modules/@stdlib/stats/base/dists/kumaraswamy/quantile/examples/index.js b/lib/node_modules/@stdlib/stats/base/dists/kumaraswamy/quantile/examples/index.js index af11e2caa9af..667a70687650 100644 --- a/lib/node_modules/@stdlib/stats/base/dists/kumaraswamy/quantile/examples/index.js +++ b/lib/node_modules/@stdlib/stats/base/dists/kumaraswamy/quantile/examples/index.js @@ -20,19 +20,11 @@ var uniform = require( '@stdlib/random/array/uniform' ); var EPS = require( '@stdlib/constants/float64/eps' ); +var logEachMap = require( '@stdlib/console/log-each-map' ); var quantile = require( './../lib' ); -var a; -var b; -var p; -var y; -var i; +var p = uniform( 10, 0.0, 1.0 ); +var a = uniform( 10, EPS, 5.0 ); +var b = uniform( 10, EPS, 5.0 ); -p = uniform( 10, 0.0, 1.0 ); -a = uniform( 10, EPS, 5.0 ); -b = uniform( 10, EPS, 5.0 ); - -for ( i = 0; i < p.length; i++ ) { - y = quantile( p[ i ], a[ i ], b[ i ] ); - console.log( 'p: %d, a: %d, b: %d, Q(p;a,b): %d', p[ i ].toFixed( 4 ), a[ i ].toFixed( 4 ), b[ i ].toFixed( 4 ), y.toFixed( 4 ) ); -} +logEachMap( 'p: %0.4f, a: %0.4f, b: %0.4f, Q(p;a,b): %0.4f', p, a, b, quantile ); diff --git a/lib/node_modules/@stdlib/stats/base/dists/laplace/mean/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/laplace/mean/test/test.native.js index 2c3ad550ecfb..9437df79e258 100644 --- a/lib/node_modules/@stdlib/stats/base/dists/laplace/mean/test/test.native.js +++ b/lib/node_modules/@stdlib/stats/base/dists/laplace/mean/test/test.native.js @@ -86,7 +86,7 @@ tape( 'if provided a nonpositive `b`, the function returns `NaN`', opts, functio t.end(); }); -tape( 'the function returns the mean of a Laplace distribution', opts, function test( t ) { +tape( 'the function returns the expected value of a Laplace distribution', opts, function test( t ) { var expected; var mu; var b; diff --git a/lib/node_modules/@stdlib/stats/base/dists/negative-binomial/kurtosis/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/negative-binomial/kurtosis/test/test.native.js index e6fe71419d21..9c9b786e649d 100644 --- a/lib/node_modules/@stdlib/stats/base/dists/negative-binomial/kurtosis/test/test.native.js +++ b/lib/node_modules/@stdlib/stats/base/dists/negative-binomial/kurtosis/test/test.native.js @@ -92,7 +92,7 @@ tape( 'if provided a success probability `p` outside of `[0,1]`, the function re t.end(); }); -tape( 'the function returns the kurtosis of a negative binomial distribution', opts, function test( t ) { +tape( 'the function returns the excess kurtosis of a negative binomial distribution', opts, function test( t ) { var expected; var r; var p; diff --git a/lib/node_modules/@stdlib/stats/base/dists/negative-binomial/variance/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/negative-binomial/variance/test/test.native.js index 24dd0753faca..dbc3fef031e7 100644 --- a/lib/node_modules/@stdlib/stats/base/dists/negative-binomial/variance/test/test.native.js +++ b/lib/node_modules/@stdlib/stats/base/dists/negative-binomial/variance/test/test.native.js @@ -75,7 +75,7 @@ tape( 'if provided `r <= 0` or `p <= 0` or `p > 1`, the function returns `NaN`', t.end(); }); -tape( 'the function evaluates the variance for a negative binomial distribution', opts, function test( t ) { +tape( 'the function returns the variance of a negative binomial distribution', opts, function test( t ) { var expected; var delta; var tol; diff --git a/lib/node_modules/@stdlib/stats/base/dists/planck/entropy/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/planck/entropy/test/test.native.js index b68e051730a8..1c04a206c328 100644 --- a/lib/node_modules/@stdlib/stats/base/dists/planck/entropy/test/test.native.js +++ b/lib/node_modules/@stdlib/stats/base/dists/planck/entropy/test/test.native.js @@ -67,7 +67,7 @@ tape( 'if provided a shape parameter `lambda` which is nonpositive, the function t.end(); }); -tape( 'the function returns the entropy of a Planck distribution', opts, function test( t ) { +tape( 'the function returns the differential entropy of a Planck distribution', opts, function test( t ) { var expected; var lambda; var delta; diff --git a/lib/node_modules/@stdlib/stats/base/dists/poisson/cdf/README.md b/lib/node_modules/@stdlib/stats/base/dists/poisson/cdf/README.md index 36847244b0af..6c9974e44cfb 100644 --- a/lib/node_modules/@stdlib/stats/base/dists/poisson/cdf/README.md +++ b/lib/node_modules/@stdlib/stats/base/dists/poisson/cdf/README.md @@ -115,6 +115,30 @@ y = mycdf( 8.0 ); +
+ +## Examples + + + +```javascript +var uniform = require( '@stdlib/random/array/uniform' ); +var logEachMap = require( '@stdlib/console/log-each-map' ); +var cdf = require( '@stdlib/stats/base/dists/poisson/cdf' ); + +var opts = { + 'dtype': 'float64' +}; +var lambda = uniform( 10, 0.0, 10.0, opts ); +var x = uniform( 10, 0.0, 10.0, opts ); + +logEachMap( 'x: %0.4f, λ: %0.4f, F(x;λ): %0.4f', x, lambda, cdf ); +``` + +
+ + + * * *
@@ -175,8 +199,8 @@ static double random_uniform( double min, double max ) { } int main( void ) { - double x; double lambda; + double x; double y; int i; @@ -197,35 +221,6 @@ int main( void ) { -* * * - -
- -## Examples - - - -```javascript -var randu = require( '@stdlib/random/base/randu' ); -var cdf = require( '@stdlib/stats/base/dists/poisson/cdf' ); - -var lambda; -var x; -var y; -var i; - -for ( i = 0; i < 10; i++ ) { - x = randu() * 10.0; - lambda = randu() * 10.0; - y = cdf( x, lambda ); - console.log( 'x: %d, λ: %d, F(x;λ): %d', x.toFixed( 4 ), lambda.toFixed( 4 ), y.toFixed( 4 ) ); -} -``` - -
- - -
diff --git a/lib/node_modules/@stdlib/stats/base/dists/poisson/cdf/benchmark/benchmark.js b/lib/node_modules/@stdlib/stats/base/dists/poisson/cdf/benchmark/benchmark.js index 6f238aa6f491..bff733c517e1 100644 --- a/lib/node_modules/@stdlib/stats/base/dists/poisson/cdf/benchmark/benchmark.js +++ b/lib/node_modules/@stdlib/stats/base/dists/poisson/cdf/benchmark/benchmark.js @@ -21,9 +21,7 @@ // MODULES // var bench = require( '@stdlib/bench' ); -var Float64Array = require( '@stdlib/array/float64' ); -var uniform = require( '@stdlib/random/base/uniform' ); -var discreteUniform = require( '@stdlib/random/base/discrete-uniform' ); +var uniform = require( '@stdlib/random/array/uniform' ); var isnan = require( '@stdlib/math/base/assert/is-nan' ); var pkg = require( './../package.json' ).name; var cdf = require( './../lib' ); @@ -33,21 +31,20 @@ var cdf = require( './../lib' ); bench( pkg, function benchmark( b ) { var lambda; - var len; + var opts; var x; var y; var i; - len = 100; - lambda = new Float64Array( len ); - x = new Float64Array( len ); - for ( i = 0; i < len; i++ ) { - x[ i ] = discreteUniform( 1, 100 ); - lambda[ i ] = uniform( 0.0, 100.0 ); - } + opts = { + 'dtype': 'float64' + }; + x = uniform( 100, 0.0, 10.0, opts ); + lambda = uniform( 100, 0.1, 20.0, opts ); + b.tic(); for ( i = 0; i < b.iterations; i++ ) { - y = cdf( x[ i % len ], lambda[ i % len ] ); + y = cdf( x[ i%x.length ], lambda[ i%lambda.length ] ); if ( isnan( y ) ) { b.fail( 'should not return NaN' ); } @@ -61,23 +58,22 @@ bench( pkg, function benchmark( b ) { }); bench( pkg+':factory', function benchmark( b ) { - var lambda; var mycdf; - var len; + var opts; var x; var y; var i; - lambda = 10.0; - mycdf = cdf.factory( lambda ); - len = 100; - x= new Float64Array( len ); - for ( i = 0; i < len; i++ ) { - x[ i ] = discreteUniform( 1, 50 ); - } + mycdf = cdf.factory( 10.0 ); + + opts = { + 'dtype': 'float64' + }; + x = uniform( 100, 0.0, 10.0, opts ); + b.tic(); for ( i = 0; i < b.iterations; i++ ) { - y = mycdf( x[ i % len ] ); + y = mycdf( x[ i%x.length ] ); if ( isnan( y ) ) { b.fail( 'should not return NaN' ); } diff --git a/lib/node_modules/@stdlib/stats/base/dists/poisson/cdf/benchmark/benchmark.native.js b/lib/node_modules/@stdlib/stats/base/dists/poisson/cdf/benchmark/benchmark.native.js index e2cbe41bd65a..a65581635178 100644 --- a/lib/node_modules/@stdlib/stats/base/dists/poisson/cdf/benchmark/benchmark.native.js +++ b/lib/node_modules/@stdlib/stats/base/dists/poisson/cdf/benchmark/benchmark.native.js @@ -38,22 +38,22 @@ var opts = { // MAIN // -bench( pkg + '::native', opts, function benchmark( b ) { +bench( pkg+'::native', opts, function benchmark( b ) { var lambda; + var opts; var x; var y; var i; - x = uniform( 100, 0.0, 10.0, { + opts = { 'dtype': 'float64' - }); - lambda = uniform( 100, 0.1, 20.0, { - 'dtype': 'float64' - }); + }; + x = uniform( 100, 0.0, 10.0, opts ); + lambda = uniform( 100, 0.1, 20.0, opts ); b.tic(); for ( i = 0; i < b.iterations; i++ ) { - y = cdf( x[ i % x.length ], lambda[ i % lambda.length ] ); + y = cdf( x[ i%x.length ], lambda[ i%lambda.length ] ); if ( isnan( y ) ) { b.fail( 'should not return NaN' ); } diff --git a/lib/node_modules/@stdlib/stats/base/dists/poisson/cdf/examples/index.js b/lib/node_modules/@stdlib/stats/base/dists/poisson/cdf/examples/index.js index d6bea7d615f7..c4910ff7c921 100644 --- a/lib/node_modules/@stdlib/stats/base/dists/poisson/cdf/examples/index.js +++ b/lib/node_modules/@stdlib/stats/base/dists/poisson/cdf/examples/index.js @@ -18,17 +18,14 @@ 'use strict'; -var randu = require( '@stdlib/random/base/randu' ); +var uniform = require( '@stdlib/random/array/uniform' ); +var logEachMap = require( '@stdlib/console/log-each-map' ); var cdf = require( './../lib' ); -var lambda; -var x; -var y; -var i; +var opts = { + 'dtype': 'float64' +}; +var lambda = uniform( 10, 0.0, 10.0, opts ); +var x = uniform( 10, 0.0, 10.0, opts ); -for ( i = 0; i < 10; i++ ) { - x = randu() * 10.0; - lambda = randu() * 10.0; - y = cdf( x, lambda ); - console.log( 'x: %d, λ: %d, F(x;λ): %d', x.toFixed( 4 ), lambda.toFixed( 4 ), y.toFixed( 4 ) ); -} +logEachMap( 'x: %0.4f, λ: %0.4f, F(x;λ): %0.4f', x, lambda, cdf ); diff --git a/lib/node_modules/@stdlib/stats/base/dists/poisson/cdf/lib/main.js b/lib/node_modules/@stdlib/stats/base/dists/poisson/cdf/lib/main.js index fbfdc8e9afe7..329680f470e4 100644 --- a/lib/node_modules/@stdlib/stats/base/dists/poisson/cdf/lib/main.js +++ b/lib/node_modules/@stdlib/stats/base/dists/poisson/cdf/lib/main.js @@ -67,10 +67,7 @@ function cdf( x, lambda ) { if ( x < 0.0 ) { return 0.0; } - if ( lambda === 0.0 ) { - return 1.0; - } - if ( x === PINF ) { + if ( lambda === 0.0 || x === PINF ) { return 1.0; } return gammainc( lambda, floor( x ) + 1.0, true, true ); diff --git a/lib/node_modules/@stdlib/stats/base/dists/poisson/cdf/src/main.c b/lib/node_modules/@stdlib/stats/base/dists/poisson/cdf/src/main.c index 74b6ae87737c..e78ad9f62d76 100644 --- a/lib/node_modules/@stdlib/stats/base/dists/poisson/cdf/src/main.c +++ b/lib/node_modules/@stdlib/stats/base/dists/poisson/cdf/src/main.c @@ -40,10 +40,7 @@ double stdlib_base_dists_poisson_cdf( const double x, const double lambda ) { if ( x < 0.0 ) { return 0.0; } - if ( lambda == 0.0 ) { - return 1.0; - } - if ( x == STDLIB_CONSTANT_FLOAT64_PINF ) { + if ( lambda == 0.0 || x == STDLIB_CONSTANT_FLOAT64_PINF ) { return 1.0; } return stdlib_base_gammainc( lambda, stdlib_base_floor( x ) + 1.0, true, true ); diff --git a/lib/node_modules/@stdlib/stats/base/dists/uniform/entropy/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/uniform/entropy/test/test.js index 1575dae692db..66a193ffc22d 100644 --- a/lib/node_modules/@stdlib/stats/base/dists/uniform/entropy/test/test.js +++ b/lib/node_modules/@stdlib/stats/base/dists/uniform/entropy/test/test.js @@ -70,7 +70,7 @@ tape( 'if provided `a >= b`, the function returns `NaN`', function test( t ) { t.end(); }); -tape( 'the function returns differential entropy of a uniform distribution', function test( t ) { +tape( 'the function returns the differential entropy of a uniform distribution', function test( t ) { var expected; var delta; var tol; diff --git a/lib/node_modules/@stdlib/stats/base/docs/types/index.d.ts b/lib/node_modules/@stdlib/stats/base/docs/types/index.d.ts index 0dababd47b23..7896823aca87 100644 --- a/lib/node_modules/@stdlib/stats/base/docs/types/index.d.ts +++ b/lib/node_modules/@stdlib/stats/base/docs/types/index.d.ts @@ -25,8 +25,6 @@ import cumaxabs = require( '@stdlib/stats/base/cumaxabs' ); import cumin = require( '@stdlib/stats/base/cumin' ); import cuminabs = require( '@stdlib/stats/base/cuminabs' ); import dists = require( '@stdlib/stats/base/dists' ); -import nanrange = require( '@stdlib/stats/base/nanrange' ); -import nanrangeBy = require( '@stdlib/stats/base/nanrange-by' ); import nanstdev = require( '@stdlib/stats/base/nanstdev' ); import nanstdevch = require( '@stdlib/stats/base/nanstdevch' ); import nanstdevpn = require( '@stdlib/stats/base/nanstdevpn' ); @@ -39,8 +37,6 @@ import nanvariancepn = require( '@stdlib/stats/base/nanvariancepn' ); import nanvariancetk = require( '@stdlib/stats/base/nanvariancetk' ); import nanvariancewd = require( '@stdlib/stats/base/nanvariancewd' ); import nanvarianceyc = require( '@stdlib/stats/base/nanvarianceyc' ); -import range = require( '@stdlib/stats/base/range' ); -import rangeBy = require( '@stdlib/stats/base/range-by' ); import sdsnanmean = require( '@stdlib/stats/base/sdsnanmean' ); import sdsnanmeanors = require( '@stdlib/stats/base/sdsnanmeanors' ); import snanmean = require( '@stdlib/stats/base/snanmean' ); @@ -190,75 +186,6 @@ interface Namespace { */ dists: typeof dists; - /** - * Computes the range of a strided array, ignoring `NaN` values. - * - * @param N - number of indexed elements - * @param x - input array - * @param strideX - stride length - * @returns range - * - * @example - * var x = [ 1.0, -2.0, NaN, 2.0 ]; - * - * var v = ns.nanrange( x.length, x, 1 ); - * // returns 4.0 - * - * @example - * var x = [ 1.0, -2.0, NaN, 2.0 ]; - * - * var v = ns.nanrange.ndarray( x.length, x, 1, 0 ); - * // returns 4.0 - */ - nanrange: typeof nanrange; - - /** - * Calculates the range of a strided array via a callback function, ignoring `NaN` values. - * - * ## Notes - * - * - The callback function is provided four arguments: - * - * - `value`: array element - * - `aidx`: array index - * - `sidx`: strided index (offset + aidx*stride) - * - `array`: input array - * - * - The callback function should return a numeric value. - * - * - If the callback function does not return any value (or equivalently, explicitly returns `undefined`), the value is ignored. - * - * - If the callback function returns `NaN`, the value is ignored. - * - * @param N - number of indexed elements - * @param x - input array - * @param stride - stride length - * @param clbk - callback - * @param thisArg - execution context - * @returns range - * - * @example - * var x = [ -2.0, 1.0, 3.0, -5.0, 4.0, NaN, 0.0, -1.0, -3.0 ]; - * - * function accessor( v ) { - * return v * 2.0; - * } - * - * var v = ns.nanrangeBy( x.length, x, 1, accessor ); - * // returns 18.0 - * - * @example - * var x = [ -2.0, 1.0, 3.0, -5.0, 4.0, NaN, 0.0, -1.0, -3.0 ]; - * - * function accessor( v ) { - * return v * 2.0; - * } - * - * var v = ns.nanrangeBy.ndarray( x.length, x, 1, 0, accessor ); - * // returns 18.0 - */ - nanrangeBy: typeof nanrangeBy; - /** * Computes the standard deviation of a strided array ignoring `NaN` values. * @@ -535,71 +462,6 @@ interface Namespace { */ nanvarianceyc: typeof nanvarianceyc; - /** - * Computes the range of a strided array. - * - * @param N - number of indexed elements - * @param x - input array - * @param stride - stride length - * @returns range - * - * @example - * var x = [ 1.0, -2.0, 2.0 ]; - * - * var v = ns.range( x.length, x, 1 ); - * // returns 4.0 - * - * @example - * var x = [ 1.0, -2.0, 2.0 ]; - * - * var v = ns.range.ndarray( x.length, x, 1, 0 ); - * // returns 4.0 - */ - range: typeof range; - - /** - * Calculates the range of a strided array via a callback function. - * - * ## Notes - * - * - The callback function is provided four arguments: - * - * - `value`: array element - * - `aidx`: array index - * - `sidx`: strided index (offset + aidx*stride) - * - `array`: input array - * - * - The callback function should return a numeric value. If the callback function does not return any value (or equivalently, explicitly returns `undefined`), the value is ignored. - * - * @param N - number of indexed elements - * @param x - input array - * @param stride - stride length - * @param clbk - callback - * @param thisArg - execution context - * @returns range - * - * @example - * var x = [ -2.0, 1.0, 3.0, -5.0, 4.0, 0.0, -1.0, -3.0 ]; - * - * function accessor( v ) { - * return v * 2.0; - * } - * - * var v = ns.rangeBy( x.length, x, 1, accessor ); - * // returns 18.0 - * - * @example - * var x = [ -2.0, 1.0, 3.0, -5.0, 4.0, 0.0, -1.0, -3.0 ]; - * - * function accessor( v ) { - * return v * 2.0; - * } - * - * var v = ns.rangeBy.ndarray( x.length, x, 1, 0, accessor ); - * // returns 18.0 - */ - rangeBy: typeof rangeBy; - /** * Computes the arithmetic mean of a single-precision floating-point strided array, ignoring `NaN` values and using extended accumulation. * diff --git a/lib/node_modules/@stdlib/stats/base/lib/index.js b/lib/node_modules/@stdlib/stats/base/lib/index.js index a7303101b1c7..72524f2661dd 100644 --- a/lib/node_modules/@stdlib/stats/base/lib/index.js +++ b/lib/node_modules/@stdlib/stats/base/lib/index.js @@ -81,24 +81,6 @@ setReadOnly( ns, 'cuminabs', require( '@stdlib/stats/base/cuminabs' ) ); */ setReadOnly( ns, 'dists', require( '@stdlib/stats/base/dists' ) ); -/** -* @name nanrange -* @memberof ns -* @readonly -* @type {Function} -* @see {@link module:@stdlib/stats/base/nanrange} -*/ -setReadOnly( ns, 'nanrange', require( '@stdlib/stats/base/nanrange' ) ); - -/** -* @name nanrangeBy -* @memberof ns -* @readonly -* @type {Function} -* @see {@link module:@stdlib/stats/base/nanrange-by} -*/ -setReadOnly( ns, 'nanrangeBy', require( '@stdlib/stats/base/nanrange-by' ) ); - /** * @name nanstdev * @memberof ns @@ -216,24 +198,6 @@ setReadOnly( ns, 'nanvarianceyc', require( '@stdlib/stats/base/nanvarianceyc' ) */ setReadOnly( ns, 'ndarray', require( '@stdlib/stats/base/ndarray' ) ); -/** -* @name range -* @memberof ns -* @readonly -* @type {Function} -* @see {@link module:@stdlib/stats/base/range} -*/ -setReadOnly( ns, 'range', require( '@stdlib/stats/base/range' ) ); - -/** -* @name rangeBy -* @memberof ns -* @readonly -* @type {Function} -* @see {@link module:@stdlib/stats/base/range-by} -*/ -setReadOnly( ns, 'rangeBy', require( '@stdlib/stats/base/range-by' ) ); - /** * @name sdsnanmean * @memberof ns diff --git a/lib/node_modules/@stdlib/stats/base/nanrange-by/README.md b/lib/node_modules/@stdlib/stats/base/nanrange-by/README.md index cb63285bcc88..ce74ee3181e2 100644 --- a/lib/node_modules/@stdlib/stats/base/nanrange-by/README.md +++ b/lib/node_modules/@stdlib/stats/base/nanrange-by/README.md @@ -38,9 +38,9 @@ The [**range**][range] is defined as the difference between the maximum and mini var nanrangeBy = require( '@stdlib/stats/base/nanrange-by' ); ``` -#### nanrangeBy( N, x, strideX, clbk\[, thisArg] ) +#### nanrangeBy( N, x, stride, clbk\[, thisArg] ) -Computes the [range][range] of a strided array via a callback function, ignoring `NaN` values. +Calculates the [range][range] of strided array `x` via a callback function, ignoring `NaN` values. ```javascript function accessor( v ) { @@ -57,7 +57,7 @@ The function has the following parameters: - **N**: number of indexed elements. - **x**: input [`Array`][mdn-array], [`typed array`][mdn-typed-array], or an array-like object (excluding strings and functions). -- **strideX**: stride length. +- **stride**: index increment. - **clbk**: callback function. - **thisArg**: execution context (_optional_). @@ -89,16 +89,19 @@ var cnt = context.count; // returns 10 ``` -The `N` and stride parameters determine which elements in the strided array are accessed at runtime. For example, to access every other element +The `N` and `stride` parameters determine which elements in `x` are accessed at runtime. For example, to access every other element ```javascript +var floor = require( '@stdlib/math/base/special/floor' ); + function accessor( v ) { return v * 2.0; } var x = [ -2.0, 1.0, 3.0, -5.0, 4.0, 0.0, -1.0, -3.0, NaN, NaN ]; +var N = floor( x.length / 2 ); -var v = nanrangeBy( 5, x, 2, accessor ); +var v = nanrangeBy( N, x, 2, accessor ); // returns 12.0 ``` @@ -106,6 +109,7 @@ Note that indexing is relative to the first index. To introduce an offset, use [ ```javascript var Float64Array = require( '@stdlib/array/float64' ); +var floor = require( '@stdlib/math/base/special/floor' ); function accessor( v ) { return v * 2.0; @@ -116,15 +120,16 @@ var x0 = new Float64Array( [ 1.0, -2.0, 3.0, -4.0, 5.0, -6.0 ] ); // Create an offset view... var x1 = new Float64Array( x0.buffer, x0.BYTES_PER_ELEMENT*1 ); // start at 2nd element +var N = floor( x0.length/2 ); // Access every other element... -var v = nanrangeBy( 3, x1, 2, accessor ); +var v = nanrangeBy( N, x1, 2, accessor ); // returns 8.0 ``` -#### nanrangeBy.ndarray( N, x, strideX, offsetX, clbk\[, thisArg] ) +#### nanrangeBy.ndarray( N, x, stride, offset, clbk\[, thisArg] ) -Computes the [range][range] of a strided array via a callback function, ignoring `NaN` values and using alternative indexing semantics. +Calculates the [range][range] of strided array `x` via a callback function, ignoring `NaN` values and using alternative indexing semantics. ```javascript function accessor( v ) { @@ -139,9 +144,9 @@ var v = nanrangeBy.ndarray( x.length, x, 1, 0, accessor ); The function has the following additional parameters: -- **offsetX**: starting index. +- **offset**: starting index. -While [`typed array`][mdn-typed-array] views mandate a view offset based on the underlying buffer, the offset parameter supports indexing semantics based on a starting index. For example, to access only the last three elements of `x` +While [`typed array`][mdn-typed-array] views mandate a view offset based on the underlying `buffer`, the `offset` parameter supports indexing semantics based on a starting index. For example, to access only the last three elements of `x` ```javascript function accessor( v ) { @@ -166,7 +171,6 @@ var v = nanrangeBy.ndarray( 3, x, 1, x.length-3, accessor ); - A provided callback function should return a numeric value. - If a provided callback function returns `NaN`, the value is ignored. - If a provided callback function does not return any value (or equivalently, explicitly returns `undefined`), the value is ignored. -- 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]). - When possible, prefer using [`dnanrange`][@stdlib/stats/strided/dnanrange], [`snanrange`][@stdlib/stats/strided/snanrange], and/or [`nanrange`][@stdlib/stats/base/nanrange], as, depending on the environment, these interfaces are likely to be significantly more performant.
@@ -180,23 +184,23 @@ var v = nanrangeBy.ndarray( 3, x, 1, x.length-3, accessor ); ```javascript -var uniform = require( '@stdlib/random/base/uniform' ); +var discreteUniform = require( '@stdlib/random/base/discrete-uniform' ); +var randu = require( '@stdlib/random/base/randu' ); var filledarrayBy = require( '@stdlib/array/filled-by' ); -var bernoulli = require( '@stdlib/random/base/bernoulli' ); var nanrangeBy = require( '@stdlib/stats/base/nanrange-by' ); -function rand() { - if ( bernoulli( 0.8 ) < 0.2 ) { +function fill() { + if ( randu() < 0.2 ) { return NaN; } - return uniform( -50.0, 50.0 ); + return discreteUniform( -50, 50 ); } function accessor( v ) { return v * 2.0; } -var x = filledarrayBy( 10, 'float64', rand ); +var x = filledarrayBy( 10, 'float64', fill ); console.log( x ); var v = nanrangeBy( x.length, x, 1, accessor ); @@ -236,8 +240,6 @@ console.log( v ); [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 - [@stdlib/stats/strided/dnanrange]: https://github.com/stdlib-js/stdlib/tree/develop/lib/node_modules/%40stdlib/stats/strided/dnanrange diff --git a/lib/node_modules/@stdlib/stats/base/nanrange-by/benchmark/benchmark.js b/lib/node_modules/@stdlib/stats/base/nanrange-by/benchmark/benchmark.js index 3931e4e384cf..497323944104 100644 --- a/lib/node_modules/@stdlib/stats/base/nanrange-by/benchmark/benchmark.js +++ b/lib/node_modules/@stdlib/stats/base/nanrange-by/benchmark/benchmark.js @@ -21,13 +21,11 @@ // MODULES // var bench = require( '@stdlib/bench' ); -var uniform = require( '@stdlib/random/base/uniform' ); -var filledarrayBy = require( '@stdlib/array/filled-by' ); -var bernoulli = require( '@stdlib/random/base/bernoulli' ); +var randu = require( '@stdlib/random/base/randu' ); var isnan = require( '@stdlib/math/base/assert/is-nan' ); var pow = require( '@stdlib/math/base/special/pow' ); var pkg = require( './../package.json' ).name; -var nanrangeBy = require( './../lib/main.js' ); +var nanrangeBy = require( './../lib/nanrange_by.js' ); // FUNCTIONS // @@ -43,19 +41,6 @@ function accessor( value ) { return value * 2.0; } -/** -* Returns a random number. -* -* @private -* @returns {number} random number -*/ -function rand() { - if ( bernoulli( 0.8 ) < 1 ) { - return NaN; - } - return uniform( -50.0, 50.0 ); -} - /** * Create a benchmark function. * @@ -64,7 +49,17 @@ function rand() { * @returns {Function} benchmark function */ function createBenchmark( len ) { - var x = filledarrayBy( len, 'generic', rand ); + var x; + var i; + + x = []; + for ( i = 0; i < len; i++ ) { + if ( randu() < 0.2 ) { + x.push( NaN ); + } else { + x.push( ( randu()*20.0 ) - 10.0 ); + } + } return benchmark; function benchmark( b ) { diff --git a/lib/node_modules/@stdlib/stats/base/nanrange-by/benchmark/benchmark.ndarray.js b/lib/node_modules/@stdlib/stats/base/nanrange-by/benchmark/benchmark.ndarray.js index cec2b32c4fa0..8b8c84d3bdb2 100644 --- a/lib/node_modules/@stdlib/stats/base/nanrange-by/benchmark/benchmark.ndarray.js +++ b/lib/node_modules/@stdlib/stats/base/nanrange-by/benchmark/benchmark.ndarray.js @@ -21,9 +21,7 @@ // MODULES // var bench = require( '@stdlib/bench' ); -var uniform = require( '@stdlib/random/base/uniform' ); -var filledarrayBy = require( '@stdlib/array/filled-by' ); -var bernoulli = require( '@stdlib/random/base/bernoulli' ); +var randu = require( '@stdlib/random/base/randu' ); var isnan = require( '@stdlib/math/base/assert/is-nan' ); var pow = require( '@stdlib/math/base/special/pow' ); var pkg = require( './../package.json' ).name; @@ -43,19 +41,6 @@ function accessor( value ) { return value * 2.0; } -/** -* Returns a random number. -* -* @private -* @returns {number} random number -*/ -function rand() { - if ( bernoulli( 0.8 ) < 1 ) { - return NaN; - } - return uniform( -50.0, 50.0 ); -} - /** * Create a benchmark function. * @@ -64,7 +49,17 @@ function rand() { * @returns {Function} benchmark function */ function createBenchmark( len ) { - var x = filledarrayBy( len, 'generic', rand ); + var x; + var i; + + x = []; + for ( i = 0; i < len; i++ ) { + if ( randu() < 0.2 ) { + x.push( NaN ); + } else { + x.push( ( randu()*20.0 ) - 10.0 ); + } + } return benchmark; function benchmark( b ) { diff --git a/lib/node_modules/@stdlib/stats/base/nanrange-by/docs/repl.txt b/lib/node_modules/@stdlib/stats/base/nanrange-by/docs/repl.txt index 3425fd2e6bcf..306a3a977dd2 100644 --- a/lib/node_modules/@stdlib/stats/base/nanrange-by/docs/repl.txt +++ b/lib/node_modules/@stdlib/stats/base/nanrange-by/docs/repl.txt @@ -1,10 +1,10 @@ -{{alias}}( N, x, strideX, clbk[, thisArg] ) - Computes the range of a strided array via a callback function, ignoring +{{alias}}( N, x, stride, clbk[, thisArg] ) + Calculates the range of a strided array via a callback function, ignoring `NaN` values. - The `N` and stride parameters determine which elements in the strided array - are accessed at runtime. + The `N` and `stride` parameters determine which elements in `x` are accessed + at runtime. Indexing is relative to the first index. To introduce an offset, use typed array views. @@ -34,8 +34,8 @@ Input array/collection. If provided an object, the object must be array- like (excluding strings and functions). - strideX: integer - Stride length. + stride: integer + Index increment for `x`. clbk: Function Callback function. @@ -56,24 +56,25 @@ > {{alias}}( x.length, x, 1, accessor ) 18.0 - // Using `N` and stride parameters: + // Using `N` and `stride` parameters: > x = [ -2.0, 1.0, 3.0, -5.0, 4.0, -1.0, -3.0, 1.0 ]; - > {{alias}}( 4, x, 2, accessor ) + > var N = {{alias:@stdlib/math/base/special/floor}}( x.length / 2 ); + > {{alias}}( N, x, 2, accessor ) 14.0 // Using view offsets: > var x0 = new {{alias:@stdlib/array/float64}}( [ 1.0, -2.0, 3.0, -4.0, 5.0, -6.0 ] ); > var x1 = new {{alias:@stdlib/array/float64}}( x0.buffer, x0.BYTES_PER_ELEMENT*1 ); - > {{alias}}( 3, x1, 2, accessor ) + > N = {{alias:@stdlib/math/base/special/floor}}( x0.length / 2 ); + > {{alias}}( N, x1, 2, accessor ) 8.0 - -{{alias}}.ndarray( N, x, strideX, offsetX, clbk[, thisArg] ) +{{alias}}.ndarray( N, x, stride, offset, clbk[, thisArg] ) Calculates the range of a strided array via a callback function, ignoring `NaN` values and 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 + buffer, the `offset` parameter supports indexing semantics based on a starting index. Parameters @@ -85,11 +86,11 @@ Input array/collection. If provided an object, the object must be array- like (excluding strings and functions). - strideX: integer - Stride length. + stride: integer + Index increment for `x`. - offsetX: integer - Starting index. + offset: integer + Starting index of `x`. clbk: Function Callback function. @@ -112,7 +113,8 @@ // Using an index offset: > x = [ 1.0, -2.0, 3.0, -4.0, 5.0, -6.0 ]; - > {{alias}}.ndarray( 3, x, 2, 1, accessor ) + > var N = {{alias:@stdlib/math/base/special/floor}}( x.length / 2 ); + > {{alias}}.ndarray( N, x, 2, 1, accessor ) 8.0 See Also diff --git a/lib/node_modules/@stdlib/stats/base/nanrange-by/docs/types/index.d.ts b/lib/node_modules/@stdlib/stats/base/nanrange-by/docs/types/index.d.ts index caa6d2312b59..502636524eb1 100644 --- a/lib/node_modules/@stdlib/stats/base/nanrange-by/docs/types/index.d.ts +++ b/lib/node_modules/@stdlib/stats/base/nanrange-by/docs/types/index.d.ts @@ -20,12 +20,7 @@ /// -import { Collection, AccessorArrayLike } from '@stdlib/types/array'; - -/** -* Input array. -*/ -type InputArray = Collection | AccessorArrayLike; +import { Collection } from '@stdlib/types/array'; /** * Returns an accessed value. @@ -88,7 +83,7 @@ type Callback = Nullary | Unary | Binary | Ternary | */ interface Routine { /** - * Computes the range of a strided array via a callback function, ignoring `NaN` values. + * Calculates the range of a strided array via a callback function, ignoring `NaN` values. * * ## Notes * @@ -107,7 +102,7 @@ interface Routine { * * @param N - number of indexed elements * @param x - input array - * @param strideX - stride length + * @param stride - stride length * @param clbk - callback * @param thisArg - execution context * @returns range @@ -122,10 +117,10 @@ interface Routine { * var v = nanrangeBy( x.length, x, 1, accessor ); * // returns 18.0 */ - ( N: number, x: InputArray, strideX: number, clbk: Callback, thisArg?: ThisParameterType> ): number; + ( N: number, x: Collection, stride: number, clbk: Callback, thisArg?: ThisParameterType> ): number; /** - * Computes the range of a strided array via a callback function, ignoring `NaN` values and using alternative indexing semantics. + * Calculates the range of a strided array via a callback function, ignoring `NaN` values and using alternative indexing semantics. * * ## Notes * @@ -144,8 +139,8 @@ interface Routine { * * @param N - number of indexed elements * @param x - input array - * @param strideX - stride length - * @param offsetX - starting index + * @param stride - stride length + * @param offset - starting index * @param clbk - callback * @param thisArg - execution context * @returns range @@ -160,11 +155,11 @@ interface Routine { * var v = nanrangeBy.ndarray( x.length, x, 1, 0, accessor ); * // returns 18.0 */ - ndarray( N: number, x: InputArray, strideX: number, offsetX: number, clbk: Callback, thisArg?: ThisParameterType> ): number; + ndarray( N: number, x: Collection, stride: number, offset: number, clbk: Callback, thisArg?: ThisParameterType> ): number; } /** -* Computes the range of a strided array via a callback function, ignoring `NaN` values. +* Calculates the range of a strided array via a callback function, ignoring `NaN` values. * * ## Notes * @@ -183,7 +178,7 @@ interface Routine { * * @param N - number of indexed elements * @param x - input array -* @param strideX - stride length +* @param stride - stride length * @param clbk - callback * @param thisArg - execution context * @returns range diff --git a/lib/node_modules/@stdlib/stats/base/nanrange-by/docs/types/test.ts b/lib/node_modules/@stdlib/stats/base/nanrange-by/docs/types/test.ts index 309fa8677c85..076af8773ea2 100644 --- a/lib/node_modules/@stdlib/stats/base/nanrange-by/docs/types/test.ts +++ b/lib/node_modules/@stdlib/stats/base/nanrange-by/docs/types/test.ts @@ -16,7 +16,6 @@ * limitations under the License. */ -import AccessorArray = require( '@stdlib/array/base/accessor' ); import nanrangeBy = require( './index' ); const accessor = (): number => { @@ -31,10 +30,7 @@ const accessor = (): number => { const x = new Float64Array( 10 ); nanrangeBy( x.length, x, 1, accessor ); // $ExpectType number - nanrangeBy( x.length, new AccessorArray( x ), 1, accessor ); // $ExpectType number - nanrangeBy( x.length, x, 1, accessor, {} ); // $ExpectType number - nanrangeBy( x.length, new AccessorArray( x ), 1, accessor, {} ); // $ExpectType number } // The compiler throws an error if the function is provided a first argument which is not a number... @@ -74,7 +70,7 @@ const accessor = (): number => { nanrangeBy( x.length, x, undefined, accessor ); // $ExpectError nanrangeBy( x.length, x, [], accessor ); // $ExpectError nanrangeBy( x.length, x, {}, accessor ); // $ExpectError - nanrangeBy( x.length, x, ( x: number ): number => x, accessor ); // $ExpectError + nanrangeBy( x.length, x, ( x: number, accessor ): number => x, accessor ); // $ExpectError } // The compiler throws an error if the function is provided a fourth argument which is not a function... @@ -106,10 +102,7 @@ const accessor = (): number => { const x = new Float64Array( 10 ); nanrangeBy.ndarray( x.length, x, 1, 0, accessor ); // $ExpectType number - nanrangeBy.ndarray( x.length, new AccessorArray( x ), 1, 0, accessor ); // $ExpectType number - nanrangeBy.ndarray( x.length, x, 1, 0, accessor, {} ); // $ExpectType number - nanrangeBy.ndarray( x.length, new AccessorArray( x ), 1, 0, accessor, {} ); // $ExpectType number } // The compiler throws an error if the `ndarray` method is provided a first argument which is not a number... diff --git a/lib/node_modules/@stdlib/stats/base/nanrange-by/examples/index.js b/lib/node_modules/@stdlib/stats/base/nanrange-by/examples/index.js index 6f2b6c34b546..8aaaf469c7a4 100644 --- a/lib/node_modules/@stdlib/stats/base/nanrange-by/examples/index.js +++ b/lib/node_modules/@stdlib/stats/base/nanrange-by/examples/index.js @@ -18,23 +18,23 @@ 'use strict'; -var uniform = require( '@stdlib/random/base/uniform' ); +var discreteUniform = require( '@stdlib/random/base/discrete-uniform' ); +var randu = require( '@stdlib/random/base/randu' ); var filledarrayBy = require( '@stdlib/array/filled-by' ); -var bernoulli = require( '@stdlib/random/base/bernoulli' ); var nanrangeBy = require( './../lib' ); -function rand() { - if ( bernoulli( 0.8 ) < 0.2 ) { +function fill() { + if ( randu() < 0.2 ) { return NaN; } - return uniform( -50.0, 50.0 ); + return discreteUniform( -50, 50 ); } function accessor( v ) { return v * 2.0; } -var x = filledarrayBy( 10, 'float64', rand ); +var x = filledarrayBy( 10, 'float64', fill ); console.log( x ); var v = nanrangeBy( x.length, x, 1, accessor ); diff --git a/lib/node_modules/@stdlib/stats/base/nanrange-by/lib/index.js b/lib/node_modules/@stdlib/stats/base/nanrange-by/lib/index.js index 3ae440117e2e..dfc81b840c2f 100644 --- a/lib/node_modules/@stdlib/stats/base/nanrange-by/lib/index.js +++ b/lib/node_modules/@stdlib/stats/base/nanrange-by/lib/index.js @@ -19,7 +19,7 @@ 'use strict'; /** -* Compute the range of a strided array via a callback function and ignoring `NaN` values. +* Calculate the range of a strided array via a callback function and ignoring `NaN` values. * * @module @stdlib/stats/base/nanrange-by * @@ -50,14 +50,7 @@ // 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 // diff --git a/lib/node_modules/@stdlib/stats/base/nanrange-by/lib/main.js b/lib/node_modules/@stdlib/stats/base/nanrange-by/lib/main.js index e25596b0f392..806353376607 100644 --- a/lib/node_modules/@stdlib/stats/base/nanrange-by/lib/main.js +++ b/lib/node_modules/@stdlib/stats/base/nanrange-by/lib/main.js @@ -20,35 +20,14 @@ // MODULES // -var stride2offset = require( '@stdlib/strided/base/stride2offset' ); +var setReadOnly = require( '@stdlib/utils/define-nonenumerable-read-only-property' ); +var nanrangeBy = require( './nanrange_by.js' ); var ndarray = require( './ndarray.js' ); // MAIN // -/** -* Computes the range of a strided array via a callback function, ignoring `NaN` values. -* -* @param {PositiveInteger} N - number of indexed elements -* @param {Collection} x - input array -* @param {integer} strideX - index increment -* @param {Callback} clbk - callback -* @param {*} [thisArg] - execution context -* @returns {number} range -* -* @example -* var x = [ -2.0, 1.0, 3.0, -5.0, 4.0, NaN, 0.0, -1.0, -3.0 ]; -* -* function accessor( v ) { -* return v * 2.0; -* } -* -* var v = nanrangeBy( x.length, x, 1, accessor ); -* // returns 18.0 -*/ -function nanrangeBy( N, x, strideX, clbk, thisArg ) { - return ndarray( N, x, strideX, stride2offset( N, strideX ), clbk, thisArg ); -} +setReadOnly( nanrangeBy, 'ndarray', ndarray ); // EXPORTS // diff --git a/lib/node_modules/@stdlib/stats/base/nanrange-by/lib/nanrange_by.js b/lib/node_modules/@stdlib/stats/base/nanrange-by/lib/nanrange_by.js new file mode 100644 index 000000000000..b7b9dd146f9f --- /dev/null +++ b/lib/node_modules/@stdlib/stats/base/nanrange-by/lib/nanrange_by.js @@ -0,0 +1,100 @@ +/** +* @license Apache-2.0 +* +* Copyright (c) 2020 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 isnan = require( '@stdlib/math/base/assert/is-nan' ); + + +// MAIN // + +/** +* Calculates the range of a strided array via a callback function, ignoring `NaN` values. +* +* @param {PositiveInteger} N - number of indexed elements +* @param {Collection} x - input array/collection +* @param {integer} stride - index increment +* @param {Callback} clbk - callback +* @param {*} [thisArg] - execution context +* @returns {number} range +* +* @example +* var x = [ -2.0, 1.0, 3.0, -5.0, 4.0, NaN, 0.0, -1.0, -3.0 ]; +* +* function accessor( v ) { +* return v * 2.0; +* } +* +* var v = nanrangeBy( x.length, x, 1, accessor ); +* // returns 18.0 +*/ +function nanrangeBy( N, x, stride, clbk, thisArg ) { + var max; + var min; + var ix; + var v; + var i; + + if ( N <= 0 ) { + return NaN; + } + if ( N === 1 || stride === 0 ) { + v = clbk.call( thisArg, x[ 0 ], 0, 0, x ); + if ( v === void 0 || isnan( v ) ) { + return NaN; + } + return 0.0; + } + if ( stride < 0 ) { + ix = (1-N) * stride; + } else { + ix = 0; + } + for ( i = 0; i < N; i++ ) { + min = clbk.call( thisArg, x[ ix ], i, ix, x ); + if ( min === min && min !== void 0 ) { + break; + } + ix += stride; + } + if ( i === N ) { + return NaN; + } + max = min; + i += 1; + for ( i; i < N; i++ ) { + ix += stride; + v = clbk.call( thisArg, x[ ix ], i, ix, x ); + if ( v === void 0 || isnan( v ) ) { + continue; + } + if ( v < min ) { + min = v; + } else if ( v > max ) { + max = v; + } + } + return max - min; +} + + +// EXPORTS // + +module.exports = nanrangeBy; diff --git a/lib/node_modules/@stdlib/stats/base/nanrange-by/lib/ndarray.js b/lib/node_modules/@stdlib/stats/base/nanrange-by/lib/ndarray.js index 1d517958bcd8..8d7bcbae67df 100644 --- a/lib/node_modules/@stdlib/stats/base/nanrange-by/lib/ndarray.js +++ b/lib/node_modules/@stdlib/stats/base/nanrange-by/lib/ndarray.js @@ -21,19 +21,17 @@ // MODULES // var isnan = require( '@stdlib/math/base/assert/is-nan' ); -var arraylike2object = require( '@stdlib/array/base/arraylike2object' ); -var accessors = require( './accessors.js' ); // MAIN // /** -* Computes the range of a strided array via a callback function, ignoring `NaN` values. +* Calculates the range of a strided array via a callback function, ignoring `NaN` values. * * @param {PositiveInteger} N - number of indexed elements -* @param {Collection} x - input array -* @param {integer} strideX - stride length -* @param {NonNegativeInteger} offsetX - starting index +* @param {Collection} x - input array/collection +* @param {integer} stride - index increment +* @param {NonNegativeInteger} offset - starting index * @param {Callback} clbk - callback * @param {*} [thisArg] - execution context * @returns {number} range @@ -48,35 +46,30 @@ var accessors = require( './accessors.js' ); * var v = nanrangeBy( x.length, x, 1, 0, accessor ); * // returns 18.0 */ -function nanrangeBy( N, x, strideX, offsetX, clbk, thisArg ) { +function nanrangeBy( N, x, stride, offset, clbk, thisArg ) { var max; var min; var ix; - var o; var v; var i; if ( N <= 0 ) { return NaN; } - o = arraylike2object( x ); - if ( o.accessorProtocol ) { - return accessors( N, o, strideX, offsetX, clbk, thisArg ); - } - if ( N === 1 || strideX === 0 ) { - v = clbk.call( thisArg, x[ offsetX ], 0, offsetX, x ); + if ( N === 1 || stride === 0 ) { + v = clbk.call( thisArg, x[ 0 ], 0, 0, x ); if ( v === void 0 || isnan( v ) ) { return NaN; } return 0.0; } - ix = offsetX; + ix = offset; for ( i = 0; i < N; i++ ) { min = clbk.call( thisArg, x[ ix ], i, ix, x ); if ( min === min && min !== void 0 ) { break; } - ix += strideX; + ix += stride; } if ( i === N ) { return NaN; @@ -84,7 +77,7 @@ function nanrangeBy( N, x, strideX, offsetX, clbk, thisArg ) { max = min; i += 1; for ( i; i < N; i++ ) { - ix += strideX; + ix += stride; v = clbk.call( thisArg, x[ ix ], i, ix, x ); if ( v === void 0 || isnan( v ) ) { continue; diff --git a/lib/node_modules/@stdlib/stats/base/nanrange-by/test/test.nanrange_by.js b/lib/node_modules/@stdlib/stats/base/nanrange-by/test/test.nanrange_by.js new file mode 100644 index 000000000000..ce1e4d8fe3ed --- /dev/null +++ b/lib/node_modules/@stdlib/stats/base/nanrange-by/test/test.nanrange_by.js @@ -0,0 +1,233 @@ +/** +* @license Apache-2.0 +* +* Copyright (c) 2020 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 floor = require( '@stdlib/math/base/special/floor' ); +var isnan = require( '@stdlib/math/base/assert/is-nan' ); +var isPositiveZero = require( '@stdlib/math/base/assert/is-positive-zero' ); +var Float64Array = require( '@stdlib/array/float64' ); +var nanrangeBy = require( './../lib/nanrange_by.js' ); + + +// FUNCTIONS // + +function accessor( v ) { + if ( v === void 0 ) { + return; + } + return v * 2.0; +} + + +// TESTS // + +tape( 'main export is a function', function test( t ) { + t.ok( true, __filename ); + t.strictEqual( typeof nanrangeBy, 'function', 'main export is a function' ); + t.end(); +}); + +tape( 'the function has an arity of 5', function test( t ) { + t.strictEqual( nanrangeBy.length, 5, 'has expected arity' ); + t.end(); +}); + +tape( 'the function calculates the range of a strided array via a callback function, ignoring NaN values', function test( t ) { + var x; + var v; + + x = [ 1.0, -2.0, -4.0, NaN, 5.0, 0.0, NaN, 3.0 ]; + v = nanrangeBy( x.length, x, 1, accessor ); + t.strictEqual( v, 18.0, 'returns expected value' ); + + x = [ -4.0, NaN, -5.0 ]; + v = nanrangeBy( x.length, x, 1, accessor ); + t.strictEqual( v, 2.0, 'returns expected value' ); + + x = [ -0.0, 0.0, NaN, -0.0 ]; + v = nanrangeBy( x.length, x, 1, accessor ); + t.strictEqual( isPositiveZero( v ), true, 'returns expected value' ); + + x = [ NaN ]; + v = nanrangeBy( x.length, x, 1, accessor ); + t.strictEqual( isnan( v ), true, 'returns expected value' ); + + x = [ NaN, NaN ]; + v = nanrangeBy( x.length, x, 1, accessor ); + t.strictEqual( isnan( v ), true, 'returns expected value' ); + + x = new Array( 5 ); // sparse array + v = nanrangeBy( x.length, x, 1, accessor ); + t.strictEqual( isnan( v ), true, 'returns expected value' ); + + x = new Array( 5 ); // sparse array + x[ 2 ] = 1.0; + v = nanrangeBy( x.length, x, 1, accessor ); + t.strictEqual( v, 0.0, 'returns expected value' ); + + t.end(); +}); + +tape( 'if provided an `N` parameter less than or equal to `0`, the function returns `NaN`', function test( t ) { + var x; + var v; + + x = [ 1.0, -2.0, -4.0, 5.0, 3.0 ]; + + v = nanrangeBy( 0, x, 1, accessor ); + t.strictEqual( isnan( v ), true, 'returns expected value' ); + + v = nanrangeBy( -1, x, 1, accessor ); + t.strictEqual( isnan( v ), true, 'returns expected value' ); + + t.end(); +}); + +tape( 'if provided an `N` parameter equal to `1`, the function returns `0`', function test( t ) { + var x; + var v; + + x = [ 1.0, -2.0, -4.0, 5.0, 3.0 ]; + + v = nanrangeBy( 1, x, 1, accessor ); + t.strictEqual( v, 0.0, 'returns expected value' ); + + x = new Array( 1 ); // sparse array + v = nanrangeBy( 1, x, 1, accessor ); + t.strictEqual( isnan( v ), true, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function supports a `stride` parameter', function test( t ) { + var N; + var x; + var v; + + x = [ + 1.0, // 0 + 2.0, + 2.0, // 1 + -7.0, + -2.0, // 2 + 3.0, + 4.0, // 3 + 2.0, + NaN, // 4 + NaN + ]; + + N = floor( x.length / 2 ); + v = nanrangeBy( N, x, 2, accessor ); + + t.strictEqual( v, 12.0, 'returns expected value' ); + t.end(); +}); + +tape( 'the function supports a negative `stride` parameter', function test( t ) { + var N; + var x; + var v; + + x = [ + NaN, // 4 + NaN, + 1.0, // 3 + 2.0, + 2.0, // 2 + -7.0, + -2.0, // 1 + 3.0, + 4.0, // 0 + 2.0 + ]; + + N = floor( x.length / 2 ); + v = nanrangeBy( N, x, -2, accessor ); + + t.strictEqual( v, 12.0, 'returns expected value' ); + t.end(); +}); + +tape( 'if provided a `stride` parameter equal to `0`, the function returns `0`', function test( t ) { + var x; + var v; + + x = [ 1.0, -2.0, -4.0, 5.0, 3.0 ]; + + v = nanrangeBy( x.length, x, 0, accessor ); + t.strictEqual( v, 0.0, 'returns expected value' ); + + x = new Array( 1 ); // sparse array + v = nanrangeBy( 1, x, 0, accessor ); + t.strictEqual( isnan( v ), true, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function supports view offsets', function test( t ) { + var x0; + var x1; + var N; + var v; + + x0 = new Float64Array([ + 2.0, + 1.0, // 0 + 2.0, + -2.0, // 1 + -2.0, + 2.0, // 2 + 3.0, + 4.0, // 3 + 6.0, + NaN, // 4 + NaN + ]); + + x1 = new Float64Array( x0.buffer, x0.BYTES_PER_ELEMENT*1 ); // start at 2nd element + N = floor(x1.length / 2); + + v = nanrangeBy( N, x1, 2, accessor ); + t.strictEqual( v, 12.0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function supports providing a callback execution context', function test( t ) { + var ctx; + var x; + + x = [ 1.0, 2.0, 3.0, NaN, 4.0, 5.0 ]; + ctx = { + 'count': 0 + }; + nanrangeBy( x.length, x, 1, accessor, ctx ); + + t.strictEqual( ctx.count, x.length, 'returns expected value' ); + t.end(); + + function accessor( v ) { + this.count += 1; // eslint-disable-line no-invalid-this + return v * 2.0; + } +}); diff --git a/lib/node_modules/@stdlib/stats/base/nanrange-by/test/test.ndarray.js b/lib/node_modules/@stdlib/stats/base/nanrange-by/test/test.ndarray.js index e56dff487a70..33f6c629025d 100644 --- a/lib/node_modules/@stdlib/stats/base/nanrange-by/test/test.ndarray.js +++ b/lib/node_modules/@stdlib/stats/base/nanrange-by/test/test.ndarray.js @@ -21,7 +21,7 @@ // MODULES // var tape = require( 'tape' ); -var toAccessorArray = require( '@stdlib/array/base/to-accessor-array' ); +var floor = require( '@stdlib/math/base/special/floor' ); var isnan = require( '@stdlib/math/base/assert/is-nan' ); var isPositiveZero = require( '@stdlib/math/base/assert/is-positive-zero' ); var nanrangeBy = require( './../lib/ndarray.js' ); @@ -74,11 +74,11 @@ tape( 'the function calculates the range of a strided array via a callback funct v = nanrangeBy( x.length, x, 1, 0, accessor ); t.strictEqual( isnan( v ), true, 'returns expected value' ); - x = new Array( 5 ); // eslint-disable-line stdlib/no-new-array + x = new Array( 5 ); // sparse array v = nanrangeBy( x.length, x, 1, 0, accessor ); t.strictEqual( isnan( v ), true, 'returns expected value' ); - x = new Array( 5 ); // eslint-disable-line stdlib/no-new-array + x = new Array( 5 ); // sparse array x[ 2 ] = 1.0; v = nanrangeBy( x.length, x, 1, 0, accessor ); t.strictEqual( v, 0.0, 'returns expected value' ); @@ -86,42 +86,6 @@ tape( 'the function calculates the range of a strided array via a callback funct t.end(); }); -tape( 'the function calculates the range of a strided array via a callback function, ignoring NaN values (accessors)', function test( t ) { - var x; - var v; - - x = [ 1.0, -2.0, -4.0, NaN, 5.0, 0.0, NaN, 3.0 ]; - v = nanrangeBy( x.length, toAccessorArray( x ), 1, 0, accessor ); - t.strictEqual( v, 18.0, 'returns expected value' ); - - x = [ -4.0, NaN, -5.0 ]; - v = nanrangeBy( x.length, toAccessorArray( x ), 1, 0, accessor ); - t.strictEqual( v, 2.0, 'returns expected value' ); - - x = [ -0.0, 0.0, NaN, -0.0 ]; - v = nanrangeBy( x.length, toAccessorArray( x ), 1, 0, accessor ); - t.strictEqual( isPositiveZero( v ), true, 'returns expected value' ); - - x = [ NaN ]; - v = nanrangeBy( x.length, toAccessorArray( x ), 1, 0, accessor ); - t.strictEqual( isnan( v ), true, 'returns expected value' ); - - x = [ NaN, NaN ]; - v = nanrangeBy( x.length, toAccessorArray( x ), 1, 0, accessor ); - t.strictEqual( isnan( v ), true, 'returns expected value' ); - - x = new Array( 5 ); // eslint-disable-line stdlib/no-new-array - v = nanrangeBy( x.length, toAccessorArray( x ), 1, 0, accessor ); - t.strictEqual( isnan( v ), true, 'returns expected value' ); - - x = new Array( 5 ); // eslint-disable-line stdlib/no-new-array - x[ 2 ] = 1.0; - v = nanrangeBy( x.length, toAccessorArray( x ), 1, 0, accessor ); - t.strictEqual( v, 0.0, 'returns expected value' ); - - t.end(); -}); - tape( 'if provided an `N` parameter less than or equal to `0`, the function returns `NaN`', function test( t ) { var x; var v; @@ -137,21 +101,6 @@ tape( 'if provided an `N` parameter less than or equal to `0`, the function retu t.end(); }); -tape( 'if provided an `N` parameter less than or equal to `0`, the function returns `NaN` (accessors)', function test( t ) { - var x; - var v; - - x = [ 1.0, -2.0, -4.0, 5.0, 3.0 ]; - - v = nanrangeBy( 0, toAccessorArray( x ), 1, 0, accessor ); - t.strictEqual( isnan( v ), true, 'returns expected value' ); - - v = nanrangeBy( -1, toAccessorArray( x ), 1, 0, accessor ); - t.strictEqual( isnan( v ), true, 'returns expected value' ); - - t.end(); -}); - tape( 'if provided an `N` parameter equal to `1`, the function returns `0`', function test( t ) { var x; var v; @@ -161,30 +110,15 @@ tape( 'if provided an `N` parameter equal to `1`, the function returns `0`', fun v = nanrangeBy( 1, x, 1, 0, accessor ); t.strictEqual( v, 0.0, 'returns expected value' ); - x = new Array( 1 ); // eslint-disable-line stdlib/no-new-array + x = new Array( 1 ); // sparse array v = nanrangeBy( 1, x, 1, 0, accessor ); t.strictEqual( isnan( v ), true, 'returns expected value' ); t.end(); }); -tape( 'if provided an `N` parameter equal to `1`, the function returns `0` (accessors)', function test( t ) { - var x; - var v; - - x = [ 1.0, -2.0, -4.0, 5.0, 3.0 ]; - - v = nanrangeBy( 1, toAccessorArray( x ), 1, 0, accessor ); - t.strictEqual( v, 0.0, 'returns expected value' ); - - x = new Array( 1 ); // eslint-disable-line stdlib/no-new-array - v = nanrangeBy( 1, toAccessorArray( x ), 1, 0, accessor ); - t.strictEqual( isnan( v ), true, 'returns expected value' ); - - t.end(); -}); - tape( 'the function supports a `stride` parameter', function test( t ) { + var N; var x; var v; @@ -201,36 +135,15 @@ tape( 'the function supports a `stride` parameter', function test( t ) { NaN ]; - v = nanrangeBy( 5, x, 2, 0, accessor ); - - t.strictEqual( v, 12.0, 'returns expected value' ); - t.end(); -}); - -tape( 'the function supports a `stride` parameter (accessors)', function test( t ) { - var x; - var v; - - x = [ - 1.0, // 0 - 2.0, - 2.0, // 1 - -7.0, - -2.0, // 2 - 3.0, - 4.0, // 3 - 2.0, - NaN, // 4 - NaN - ]; - - v = nanrangeBy( 5, toAccessorArray( x ), 2, 0, accessor ); + N = floor( x.length / 2 ); + v = nanrangeBy( N, x, 2, 0, accessor ); t.strictEqual( v, 12.0, 'returns expected value' ); t.end(); }); tape( 'the function supports a negative `stride` parameter', function test( t ) { + var N; var x; var v; @@ -247,30 +160,8 @@ tape( 'the function supports a negative `stride` parameter', function test( t ) 2.0 ]; - v = nanrangeBy( 5, x, -2, 8, accessor ); - - t.strictEqual( v, 12.0, 'returns expected value' ); - t.end(); -}); - -tape( 'the function supports a negative `stride` parameter (accessors)', function test( t ) { - var x; - var v; - - x = [ - NaN, // 4 - NaN, - 1.0, // 3 - 2.0, - 2.0, // 2 - -7.0, - -2.0, // 1 - 3.0, - 4.0, // 0 - 2.0 - ]; - - v = nanrangeBy( 5, toAccessorArray( x ), -2, 8, accessor ); + N = floor( x.length / 2 ); + v = nanrangeBy( N, x, -2, 8, accessor ); t.strictEqual( v, 12.0, 'returns expected value' ); t.end(); @@ -285,29 +176,13 @@ tape( 'if provided a `stride` parameter equal to `0`, the function returns `0`', v = nanrangeBy( x.length, x, 0, 0, accessor ); t.strictEqual( v, 0.0, 'returns expected value' ); - x = new Array( 1 ); // eslint-disable-line stdlib/no-new-array + x = new Array( 1 ); // sparse array v = nanrangeBy( 1, x, 0, 0, accessor ); t.strictEqual( isnan( v ), true, 'returns expected value' ); t.end(); }); -tape( 'if provided a `stride` parameter equal to `0`, the function returns `0` (accessors)', function test( t ) { - var x; - var v; - - x = [ 1.0, -2.0, -4.0, 5.0, 3.0 ]; - - v = nanrangeBy( x.length, toAccessorArray( x ), 0, 0, accessor ); - t.strictEqual( v, 0.0, 'returns expected value' ); - - x = new Array( 1 ); // eslint-disable-line stdlib/no-new-array - v = nanrangeBy( 1, toAccessorArray( x ), 0, 0, accessor ); - t.strictEqual( isnan( v ), true, 'returns expected value' ); - - t.end(); -}); - tape( 'the function supports an offset parameter', function test( t ) { var x; var v; @@ -329,27 +204,6 @@ tape( 'the function supports an offset parameter', function test( t ) { t.end(); }); -tape( 'the function supports an offset parameter (accessors)', function test( t ) { - var x; - var v; - - x = [ - 1.0, - -2.0, // 0 - 3.0, - 4.0, // 1 - 5.0, - -6.0, // 2 - NaN, - NaN // 3 - ]; - - v = nanrangeBy( 4, toAccessorArray( x ), 2, 1, accessor ); - t.strictEqual( v, 20.0, 'returns expected value' ); - - t.end(); -}); - tape( 'the function supports providing a callback execution context', function test( t ) { var ctx; var x; @@ -368,22 +222,3 @@ tape( 'the function supports providing a callback execution context', function t return v * 2.0; } }); - -tape( 'the function supports providing a callback execution context (accessors)', function test( t ) { - var ctx; - var x; - - x = [ 1.0, 2.0, 3.0, NaN, 4.0, 5.0 ]; - ctx = { - 'count': 0 - }; - nanrangeBy( x.length, toAccessorArray( x ), 1, 0, accessor, ctx ); - - t.strictEqual( ctx.count, x.length, 'returns expected value' ); - t.end(); - - function accessor( v ) { - this.count += 1; // eslint-disable-line no-invalid-this - return v * 2.0; - } -}); diff --git a/lib/node_modules/@stdlib/stats/base/ndarray/drange/README.md b/lib/node_modules/@stdlib/stats/base/ndarray/drange/README.md new file mode 100644 index 000000000000..b113d5e594d7 --- /dev/null +++ b/lib/node_modules/@stdlib/stats/base/ndarray/drange/README.md @@ -0,0 +1,116 @@ + + +# drange + +> Compute the [range][range] of a one-dimensional double-precision floating-point ndarray. + +
+ +The [**range**][range] is defined as the difference between the maximum and minimum values. + +
+ + + +
+ +## Usage + +```javascript +var drange = require( '@stdlib/stats/base/ndarray/drange' ); +``` + +#### drange( arrays ) + +Computes the [range][range] of a one-dimensional double-precision floating-point ndarray. + +```javascript +var Float64Array = require( '@stdlib/array/float64' ); +var ndarray = require( '@stdlib/ndarray/base/ctor' ); + +var xbuf = new Float64Array( [ 1.0, 3.0, 4.0, 2.0 ] ); +var x = new ndarray( 'float64', xbuf, [ 4 ], [ 1 ], 0, 'row-major' ); + +var v = drange( [ x ] ); +// returns 3.0 +``` + +The function has the following parameters: + +- **arrays**: array-like object containing a one-dimensional input ndarray. + +
+ + + +
+ +## Notes + +- If provided an empty one-dimensional ndarray, the function returns `NaN`. + +
+ + + +
+ +## Examples + + + +```javascript +var discreteUniform = require( '@stdlib/random/array/discrete-uniform' ); +var ndarray = require( '@stdlib/ndarray/base/ctor' ); +var ndarray2array = require( '@stdlib/ndarray/to-array' ); +var drange = require( '@stdlib/stats/base/ndarray/drange' ); + +var xbuf = discreteUniform( 10, -50, 50, { + 'dtype': 'float64' +}); +var x = new ndarray( 'float64', xbuf, [ xbuf.length ], [ 1 ], 0, 'row-major' ); +console.log( ndarray2array( x ) ); + +var v = drange( [ x ] ); +console.log( v ); +``` + +
+ + + + + +
+ +
+ + + + + +
+ +[range]: https://en.wikipedia.org/wiki/Range_%28statistics%29 + +
+ + diff --git a/lib/node_modules/@stdlib/stats/base/ndarray/drange/benchmark/benchmark.js b/lib/node_modules/@stdlib/stats/base/ndarray/drange/benchmark/benchmark.js new file mode 100644 index 000000000000..88b2461a05e3 --- /dev/null +++ b/lib/node_modules/@stdlib/stats/base/ndarray/drange/benchmark/benchmark.js @@ -0,0 +1,102 @@ +/** +* @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 bench = require( '@stdlib/bench' ); +var uniform = require( '@stdlib/random/array/uniform' ); +var isnan = require( '@stdlib/math/base/assert/is-nan' ); +var pow = require( '@stdlib/math/base/special/pow' ); +var ndarray = require( '@stdlib/ndarray/base/ctor' ); +var pkg = require( './../package.json' ).name; +var drange = require( './../lib' ); + + +// VARIABLES // + +var options = { + 'dtype': 'float64' +}; + + +// FUNCTIONS // + +/** +* Creates a benchmark function. +* +* @private +* @param {PositiveInteger} len - array length +* @returns {Function} benchmark function +*/ +function createBenchmark( len ) { + var xbuf; + var x; + + xbuf = uniform( len, -10.0, 10.0, options ); + x = new ndarray( options.dtype, xbuf, [ len ], [ 1 ], 0, 'row-major' ); + + return benchmark; + + function benchmark( b ) { + var v; + var i; + + b.tic(); + for ( i = 0; i < b.iterations; i++ ) { + v = drange( [ x ] ); + if ( isnan( v ) ) { + b.fail( 'should not return NaN' ); + } + } + b.toc(); + if ( isnan( v ) ) { + 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( pkg+':len='+len, f ); + } +} + +main(); diff --git a/lib/node_modules/@stdlib/stats/base/ndarray/drange/docs/repl.txt b/lib/node_modules/@stdlib/stats/base/ndarray/drange/docs/repl.txt new file mode 100644 index 000000000000..f6d7e68428bc --- /dev/null +++ b/lib/node_modules/@stdlib/stats/base/ndarray/drange/docs/repl.txt @@ -0,0 +1,32 @@ + +{{alias}}( arrays ) + Computes the range of a one-dimensional double-precision floating-point + ndarray. + + If provided an empty ndarray, the function returns `NaN`. + + Parameters + ---------- + arrays: ArrayLikeObject + Array-like object containing a one-dimensional input ndarray. + + Returns + ------- + out: number + Range. + + Examples + -------- + > var xbuf = new {{alias:@stdlib/array/float64}}( [ 1.0, -2.0, 2.0 ] ); + > var dt = 'float64'; + > var sh = [ xbuf.length ]; + > var sx = [ 1 ]; + > var ox = 0; + > var ord = 'row-major'; + > var x = new {{alias:@stdlib/ndarray/ctor}}( dt, xbuf, sh, sx, ox, ord ); + > {{alias}}( [ x ] ) + 4.0 + + See Also + -------- + diff --git a/lib/node_modules/@stdlib/stats/base/ndarray/drange/docs/types/index.d.ts b/lib/node_modules/@stdlib/stats/base/ndarray/drange/docs/types/index.d.ts new file mode 100644 index 000000000000..5f15df5f50af --- /dev/null +++ b/lib/node_modules/@stdlib/stats/base/ndarray/drange/docs/types/index.d.ts @@ -0,0 +1,46 @@ +/* +* @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. +*/ + +// TypeScript Version: 4.1 + +/// + +import { float64ndarray } from '@stdlib/types/ndarray'; + +/** +* Computes the range of a one-dimensional double-precision floating-point ndarray. +* +* @param arrays - array-like object containing an input ndarray +* @returns range +* +* @example +* var Float64Array = require( '@stdlib/array/float64' ); +* var ndarray = require( '@stdlib/ndarray/base/ctor' ); +* +* var xbuf = new Float64Array( [ 1.0, 3.0, 4.0, 2.0 ] ); +* var x = new ndarray( 'float64', xbuf, [ 4 ], [ 1 ], 0, 'row-major' ); +* +* var v = drange( [ x ] ); +* // returns 3.0 +*/ +declare function drange( arrays: [ float64ndarray ] ): number; + + +// EXPORTS // + +export = drange; diff --git a/lib/node_modules/@stdlib/stats/base/ndarray/drange/docs/types/test.ts b/lib/node_modules/@stdlib/stats/base/ndarray/drange/docs/types/test.ts new file mode 100644 index 000000000000..db79162f0f5c --- /dev/null +++ b/lib/node_modules/@stdlib/stats/base/ndarray/drange/docs/types/test.ts @@ -0,0 +1,57 @@ +/* +* @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. +*/ + +/* eslint-disable space-in-parens */ + +import zeros = require( '@stdlib/ndarray/zeros' ); +import drange = require( './index' ); + + +// TESTS // + +// The function returns a number... +{ + const x = zeros( [ 10 ], { + 'dtype': 'float64' + }); + + drange( [ x ] ); // $ExpectType number +} + +// The compiler throws an error if the function is provided a first argument which is not an array of ndarrays... +{ + drange( '10' ); // $ExpectError + drange( 10 ); // $ExpectError + drange( true ); // $ExpectError + drange( false ); // $ExpectError + drange( null ); // $ExpectError + drange( undefined ); // $ExpectError + drange( [] ); // $ExpectError + drange( {} ); // $ExpectError + drange( ( x: number ): number => x ); // $ExpectError +} + +// The compiler throws an error if the function is provided an unsupported number of arguments... +{ + const x = zeros( [ 10 ], { + 'dtype': 'float64' + }); + + drange(); // $ExpectError + drange( [ x ], {} ); // $ExpectError +} diff --git a/lib/node_modules/@stdlib/stats/base/ndarray/drange/examples/index.js b/lib/node_modules/@stdlib/stats/base/ndarray/drange/examples/index.js new file mode 100644 index 000000000000..4e0c668da739 --- /dev/null +++ b/lib/node_modules/@stdlib/stats/base/ndarray/drange/examples/index.js @@ -0,0 +1,33 @@ +/** +* @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'; + +var discreteUniform = require( '@stdlib/random/array/discrete-uniform' ); +var ndarray = require( '@stdlib/ndarray/base/ctor' ); +var ndarray2array = require( '@stdlib/ndarray/to-array' ); +var drange = require( './../lib' ); + +var xbuf = discreteUniform( 10, -50, 50, { + 'dtype': 'float64' +}); +var x = new ndarray( 'float64', xbuf, [ xbuf.length ], [ 1 ], 0, 'row-major' ); +console.log( ndarray2array( x ) ); + +var v = drange( [ x ] ); +console.log( v ); diff --git a/lib/node_modules/@stdlib/stats/base/ndarray/drange/lib/index.js b/lib/node_modules/@stdlib/stats/base/ndarray/drange/lib/index.js new file mode 100644 index 000000000000..0d877e359044 --- /dev/null +++ b/lib/node_modules/@stdlib/stats/base/ndarray/drange/lib/index.js @@ -0,0 +1,45 @@ +/** +* @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'; + +/** +* Compute the range of a one-dimensional double-precision floating-point ndarray. +* +* @module @stdlib/stats/base/ndarray/drange +* +* @example +* var Float64Array = require( '@stdlib/array/float64' ); +* var ndarray = require( '@stdlib/ndarray/base/ctor' ); +* var drange = require( '@stdlib/stats/base/ndarray/drange' ); +* +* var xbuf = new Float64Array( [ 1.0, 3.0, 4.0, 2.0 ] ); +* var x = new ndarray( 'float64', xbuf, [ 4 ], [ 1 ], 0, 'row-major' ); +* +* var v = drange( [ x ] ); +* // returns 3.0 +*/ + +// MODULES // + +var main = require( './main.js' ); + + +// EXPORTS // + +module.exports = main; diff --git a/lib/node_modules/@stdlib/stats/base/ndarray/drange/lib/main.js b/lib/node_modules/@stdlib/stats/base/ndarray/drange/lib/main.js new file mode 100644 index 000000000000..1993542ffbb7 --- /dev/null +++ b/lib/node_modules/@stdlib/stats/base/ndarray/drange/lib/main.js @@ -0,0 +1,56 @@ +/** +* @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 strided = require( '@stdlib/stats/strided/drange' ).ndarray; + + +// MAIN // + +/** +* Computes the range of a one-dimensional double-precision floating-point ndarray. +* +* @param {ArrayLikeObject} arrays - array-like object containing an input ndarray +* @returns {number} range +* +* @example +* var Float64Array = require( '@stdlib/array/float64' ); +* var ndarray = require( '@stdlib/ndarray/base/ctor' ); +* +* var xbuf = new Float64Array( [ 1.0, 3.0, 4.0, 2.0 ] ); +* var x = new ndarray( 'float64', xbuf, [ 4 ], [ 1 ], 0, 'row-major' ); +* +* var v = drange( [ x ] ); +* // returns 3.0 +*/ +function drange( arrays ) { + var x = arrays[ 0 ]; + return strided( numelDimension( x, 0 ), getData( x ), getStride( x, 0 ), getOffset( x ) ); // eslint-disable-line max-len +} + + +// EXPORTS // + +module.exports = drange; diff --git a/lib/node_modules/@stdlib/stats/base/ndarray/drange/package.json b/lib/node_modules/@stdlib/stats/base/ndarray/drange/package.json new file mode 100644 index 000000000000..31dc5ef1ff72 --- /dev/null +++ b/lib/node_modules/@stdlib/stats/base/ndarray/drange/package.json @@ -0,0 +1,71 @@ +{ + "name": "@stdlib/stats/base/ndarray/drange", + "version": "0.0.0", + "description": "Compute the range of a one-dimensional double-precision floating-point ndarray.", + "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", + "statistics", + "stats", + "mathematics", + "math", + "maximum", + "max", + "minimum", + "min", + "range", + "extremes", + "domain", + "extent", + "float64", + "double", + "ndarray" + ], + "__stdlib__": {} +} diff --git a/lib/node_modules/@stdlib/stats/base/ndarray/drange/test/test.js b/lib/node_modules/@stdlib/stats/base/ndarray/drange/test/test.js new file mode 100644 index 000000000000..9fafb4c440d3 --- /dev/null +++ b/lib/node_modules/@stdlib/stats/base/ndarray/drange/test/test.js @@ -0,0 +1,173 @@ +/** +* @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 tape = require( 'tape' ); +var isnan = require( '@stdlib/math/base/assert/is-nan' ); +var isPositiveZero = require( '@stdlib/math/base/assert/is-positive-zero' ); +var Float64Array = require( '@stdlib/array/float64' ); +var ndarray = require( '@stdlib/ndarray/base/ctor' ); +var drange = require( './../lib' ); + + +// FUNCTIONS // + +/** +* Returns a one-dimensional ndarray. +* +* @private +* @param {Collection} buffer - underlying data buffer +* @param {NonNegativeInteger} length - number of indexed elements +* @param {integer} stride - stride length +* @param {NonNegativeInteger} offset - index offset +* @returns {ndarray} one-dimensional ndarray +*/ +function vector( buffer, length, stride, offset ) { + return new ndarray( 'float64', buffer, [ length ], [ stride ], offset, 'row-major' ); +} + + +// TESTS // + +tape( 'main export is a function', function test( t ) { + t.ok( true, __filename ); + t.strictEqual( typeof drange, 'function', 'main export is a function' ); + t.end(); +}); + +tape( 'the function has an arity of 1', function test( t ) { + t.strictEqual( drange.length, 1, 'has expected arity' ); + t.end(); +}); + +tape( 'the function calculates the range of a one-dimensional ndarray', function test( t ) { + var x; + var v; + + x = new Float64Array( [ 1.0, -2.0, -4.0, 5.0, 0.0, 3.0 ] ); + v = drange( [ vector( x, 6, 1, 0 ) ] ); + t.strictEqual( v, 9.0, 'returns expected value' ); + + x = new Float64Array( [ -4.0, -5.0 ] ); + v = drange( [ vector( x, 2, 1, 0 ) ] ); + t.strictEqual( v, 1.0, 'returns expected value' ); + + x = new Float64Array( [ -0.0, 0.0, -0.0 ] ); + v = drange( [ vector( x, 3, 1, 0 ) ] ); + t.strictEqual( isPositiveZero( v ), true, 'returns expected value' ); + + x = new Float64Array( [ NaN ] ); + v = drange( [ vector( x, 1, 1, 0 ) ] ); + t.strictEqual( isnan( v ), true, 'returns expected value' ); + + x = new Float64Array( [ NaN, NaN ] ); + v = drange( [ vector( x, 2, 1, 0 ) ] ); + t.strictEqual( isnan( v ), true, 'returns expected value' ); + + t.end(); +}); + +tape( 'if provided an empty vector, the function returns `NaN`', function test( t ) { + var x; + var v; + + x = new Float64Array( [] ); + + v = drange( [ vector( x, 0, 1, 0 ) ] ); + t.strictEqual( isnan( v ), true, 'returns expected value' ); + + t.end(); +}); + +tape( 'if provided a vector containing a single element, the function returns `0`', function test( t ) { + var x; + var v; + + x = new Float64Array( [ 1.0 ] ); + + v = drange( [ vector( x, 1, 1, 0 ) ] ); + t.strictEqual( v, 0.0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function supports one-dimensional ndarrays having non-unit strides', function test( t ) { + var x; + var v; + + x = new Float64Array([ + 1.0, // 0 + 2.0, + 2.0, // 1 + -7.0, + -2.0, // 2 + 3.0, + 4.0, // 3 + 2.0 + ]); + + v = drange( [ vector( x, 4, 2, 0 ) ] ); + + t.strictEqual( v, 6.0, 'returns expected value' ); + t.end(); +}); + +tape( 'the function supports one-dimensional ndarrays having negative strides', function test( t ) { + var x; + var v; + + x = new Float64Array([ + 1.0, // 3 + 2.0, + 2.0, // 2 + -7.0, + -2.0, // 1 + 3.0, + 4.0, // 0 + 2.0 + ]); + + v = drange( [ vector( x, 4, -2, 6 ) ] ); + + t.strictEqual( v, 6.0, 'returns expected value' ); + t.end(); +}); + +tape( 'the function supports one-dimensional ndarrays having non-zero offsets', function test( t ) { + var x; + var v; + + x = new Float64Array([ + 2.0, + 1.0, // 0 + 2.0, + -2.0, // 1 + -2.0, + 2.0, // 2 + 3.0, + 4.0 // 3 + ]); + + v = drange( [ vector( x, 4, 2, 1 ) ] ); + t.strictEqual( v, 6.0, 'returns expected value' ); + + t.end(); +}); diff --git a/lib/node_modules/@stdlib/stats/base/ndarray/range/README.md b/lib/node_modules/@stdlib/stats/base/ndarray/range/README.md new file mode 100644 index 000000000000..b63491b39ef0 --- /dev/null +++ b/lib/node_modules/@stdlib/stats/base/ndarray/range/README.md @@ -0,0 +1,115 @@ + + +# range + +> Compute the [range][range] of a one-dimensional ndarray. + +
+ +The [**range**][range] is defined as the difference between the maximum and minimum values. + +
+ + + +
+ +## Usage + +```javascript +var range = require( '@stdlib/stats/base/ndarray/range' ); +``` + +#### range( arrays ) + +Computes the [range][range] of a one-dimensional ndarray. + +```javascript +var ndarray = require( '@stdlib/ndarray/base/ctor' ); + +var xbuf = [ 1.0, 3.0, 4.0, 2.0 ]; +var x = new ndarray( 'generic', xbuf, [ 4 ], [ 1 ], 0, 'row-major' ); + +var v = range( [ x ] ); +// returns 3.0 +``` + +The function has the following parameters: + +- **arrays**: array-like object containing a one-dimensional input ndarray. + +
+ + + +
+ +## Notes + +- If provided an empty one-dimensional ndarray, the function returns `NaN`. + +
+ + + +
+ +## Examples + + + +```javascript +var discreteUniform = require( '@stdlib/random/array/discrete-uniform' ); +var ndarray = require( '@stdlib/ndarray/base/ctor' ); +var ndarray2array = require( '@stdlib/ndarray/to-array' ); +var range = require( '@stdlib/stats/base/ndarray/range' ); + +var xbuf = discreteUniform( 10, -50, 50, { + 'dtype': 'generic' +}); +var x = new ndarray( 'generic', xbuf, [ xbuf.length ], [ 1 ], 0, 'row-major' ); +console.log( ndarray2array( x ) ); + +var v = range( [ x ] ); +console.log( v ); +``` + +
+ + + + + +
+ +
+ + + + + +
+ +[range]: https://en.wikipedia.org/wiki/Range_%28statistics%29 + +
+ + diff --git a/lib/node_modules/@stdlib/stats/base/ndarray/range/benchmark/benchmark.js b/lib/node_modules/@stdlib/stats/base/ndarray/range/benchmark/benchmark.js new file mode 100644 index 000000000000..7c7285d38d4e --- /dev/null +++ b/lib/node_modules/@stdlib/stats/base/ndarray/range/benchmark/benchmark.js @@ -0,0 +1,102 @@ +/** +* @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 bench = require( '@stdlib/bench' ); +var uniform = require( '@stdlib/random/array/uniform' ); +var isnan = require( '@stdlib/math/base/assert/is-nan' ); +var pow = require( '@stdlib/math/base/special/pow' ); +var ndarray = require( '@stdlib/ndarray/base/ctor' ); +var pkg = require( './../package.json' ).name; +var range = require( './../lib' ); + + +// VARIABLES // + +var options = { + 'dtype': 'generic' +}; + + +// FUNCTIONS // + +/** +* Creates a benchmark function. +* +* @private +* @param {PositiveInteger} len - array length +* @returns {Function} benchmark function +*/ +function createBenchmark( len ) { + var xbuf; + var x; + + xbuf = uniform( len, -10.0, 10.0, options ); + x = new ndarray( options.dtype, xbuf, [ len ], [ 1 ], 0, 'row-major' ); + + return benchmark; + + function benchmark( b ) { + var v; + var i; + + b.tic(); + for ( i = 0; i < b.iterations; i++ ) { + v = range( [ x ] ); + if ( isnan( v ) ) { + b.fail( 'should not return NaN' ); + } + } + b.toc(); + if ( isnan( v ) ) { + 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( pkg+':len='+len, f ); + } +} + +main(); diff --git a/lib/node_modules/@stdlib/stats/base/ndarray/range/docs/repl.txt b/lib/node_modules/@stdlib/stats/base/ndarray/range/docs/repl.txt new file mode 100644 index 000000000000..28a63c29add9 --- /dev/null +++ b/lib/node_modules/@stdlib/stats/base/ndarray/range/docs/repl.txt @@ -0,0 +1,31 @@ + +{{alias}}( arrays ) + Computes the range of a one-dimensional ndarray. + + If provided an empty ndarray, the function returns `NaN`. + + Parameters + ---------- + arrays: ArrayLikeObject + Array-like object containing a one-dimensional input ndarray. + + Returns + ------- + out: number + Range. + + Examples + -------- + > var xbuf = [ 1.0, -2.0, 2.0 ]; + > var dt = 'generic'; + > var sh = [ xbuf.length ]; + > var sx = [ 1 ]; + > var ox = 0; + > var ord = 'row-major'; + > var x = new {{alias:@stdlib/ndarray/ctor}}( dt, xbuf, sh, sx, ox, ord ); + > {{alias}}( [ x ] ) + 4.0 + + See Also + -------- + diff --git a/lib/node_modules/@stdlib/stats/base/ndarray/range/docs/types/index.d.ts b/lib/node_modules/@stdlib/stats/base/ndarray/range/docs/types/index.d.ts new file mode 100644 index 000000000000..8edb2d9ad8e9 --- /dev/null +++ b/lib/node_modules/@stdlib/stats/base/ndarray/range/docs/types/index.d.ts @@ -0,0 +1,45 @@ +/* +* @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. +*/ + +// TypeScript Version: 4.1 + +/// + +import { ndarray } from '@stdlib/types/ndarray'; + +/** +* Computes the range of a one-dimensional ndarray. +* +* @param arrays - array-like object containing an input ndarray +* @returns range +* +* @example +* var ndarray = require( '@stdlib/ndarray/base/ctor' ); +* +* var xbuf = [ 1.0, 3.0, 4.0, 2.0 ]; +* var x = new ndarray( 'generic', xbuf, [ 4 ], [ 1 ], 0, 'row-major' ); +* +* var v = range( [ x ] ); +* // returns 3.0 +*/ +declare function range( arrays: [ T ] ): number; + + +// EXPORTS // + +export = range; diff --git a/lib/node_modules/@stdlib/stats/base/ndarray/range/docs/types/test.ts b/lib/node_modules/@stdlib/stats/base/ndarray/range/docs/types/test.ts new file mode 100644 index 000000000000..9aa0fa4489e5 --- /dev/null +++ b/lib/node_modules/@stdlib/stats/base/ndarray/range/docs/types/test.ts @@ -0,0 +1,57 @@ +/* +* @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. +*/ + +/* eslint-disable space-in-parens */ + +import zeros = require( '@stdlib/ndarray/zeros' ); +import range = require( './index' ); + + +// TESTS // + +// The function returns a number... +{ + const x = zeros( [ 10 ], { + 'dtype': 'generic' + }); + + range( [ x ] ); // $ExpectType number +} + +// The compiler throws an error if the function is provided a first argument which is not an array of ndarrays... +{ + range( '10' ); // $ExpectError + range( 10 ); // $ExpectError + range( true ); // $ExpectError + range( false ); // $ExpectError + range( null ); // $ExpectError + range( undefined ); // $ExpectError + range( [] ); // $ExpectError + range( {} ); // $ExpectError + range( ( x: number ): number => x ); // $ExpectError +} + +// The compiler throws an error if the function is provided an unsupported number of arguments... +{ + const x = zeros( [ 10 ], { + 'dtype': 'generic' + }); + + range(); // $ExpectError + range( [ x ], {} ); // $ExpectError +} diff --git a/lib/node_modules/@stdlib/stats/base/ndarray/range/examples/index.js b/lib/node_modules/@stdlib/stats/base/ndarray/range/examples/index.js new file mode 100644 index 000000000000..f9fcfcd3c7cf --- /dev/null +++ b/lib/node_modules/@stdlib/stats/base/ndarray/range/examples/index.js @@ -0,0 +1,33 @@ +/** +* @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'; + +var discreteUniform = require( '@stdlib/random/array/discrete-uniform' ); +var ndarray = require( '@stdlib/ndarray/base/ctor' ); +var ndarray2array = require( '@stdlib/ndarray/to-array' ); +var range = require( './../lib' ); + +var xbuf = discreteUniform( 10, -50, 50, { + 'dtype': 'generic' +}); +var x = new ndarray( 'generic', xbuf, [ xbuf.length ], [ 1 ], 0, 'row-major' ); +console.log( ndarray2array( x ) ); + +var v = range( [ x ] ); +console.log( v ); diff --git a/lib/node_modules/@stdlib/stats/base/ndarray/range/lib/index.js b/lib/node_modules/@stdlib/stats/base/ndarray/range/lib/index.js new file mode 100644 index 000000000000..039dbde30fe9 --- /dev/null +++ b/lib/node_modules/@stdlib/stats/base/ndarray/range/lib/index.js @@ -0,0 +1,44 @@ +/** +* @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'; + +/** +* Compute the range of a one-dimensional ndarray. +* +* @module @stdlib/stats/base/ndarray/range +* +* @example +* var ndarray = require( '@stdlib/ndarray/base/ctor' ); +* var range = require( '@stdlib/stats/base/ndarray/range' ); +* +* var xbuf = [ 1.0, 3.0, 4.0, 2.0 ]; +* var x = new ndarray( 'generic', xbuf, [ 4 ], [ 1 ], 0, 'row-major' ); +* +* var v = range( [ x ] ); +* // returns 3.0 +*/ + +// MODULES // + +var main = require( './main.js' ); + + +// EXPORTS // + +module.exports = main; diff --git a/lib/node_modules/@stdlib/stats/base/ndarray/range/lib/main.js b/lib/node_modules/@stdlib/stats/base/ndarray/range/lib/main.js new file mode 100644 index 000000000000..0e731d8cd874 --- /dev/null +++ b/lib/node_modules/@stdlib/stats/base/ndarray/range/lib/main.js @@ -0,0 +1,55 @@ +/** +* @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 strided = require( '@stdlib/stats/strided/range' ).ndarray; + + +// MAIN // + +/** +* Computes the range of a one-dimensional ndarray. +* +* @param {ArrayLikeObject} arrays - array-like object containing an input ndarray +* @returns {number} range +* +* @example +* var ndarray = require( '@stdlib/ndarray/base/ctor' ); +* +* var xbuf = [ 1.0, 3.0, 4.0, 2.0 ]; +* var x = new ndarray( 'generic', xbuf, [ 4 ], [ 1 ], 0, 'row-major' ); +* +* var v = range( [ x ] ); +* // returns 3.0 +*/ +function range( arrays ) { + var x = arrays[ 0 ]; + return strided( numelDimension( x, 0 ), getData( x ), getStride( x, 0 ), getOffset( x ) ); // eslint-disable-line max-len +} + + +// EXPORTS // + +module.exports = range; diff --git a/lib/node_modules/@stdlib/stats/base/ndarray/range/package.json b/lib/node_modules/@stdlib/stats/base/ndarray/range/package.json new file mode 100644 index 000000000000..6d855003a391 --- /dev/null +++ b/lib/node_modules/@stdlib/stats/base/ndarray/range/package.json @@ -0,0 +1,69 @@ +{ + "name": "@stdlib/stats/base/ndarray/range", + "version": "0.0.0", + "description": "Compute the range of a one-dimensional ndarray.", + "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", + "statistics", + "stats", + "mathematics", + "math", + "maximum", + "max", + "minimum", + "min", + "range", + "extremes", + "domain", + "extent", + "ndarray" + ], + "__stdlib__": {} +} diff --git a/lib/node_modules/@stdlib/stats/base/ndarray/range/test/test.js b/lib/node_modules/@stdlib/stats/base/ndarray/range/test/test.js new file mode 100644 index 000000000000..1d6761d3c867 --- /dev/null +++ b/lib/node_modules/@stdlib/stats/base/ndarray/range/test/test.js @@ -0,0 +1,172 @@ +/** +* @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 tape = require( 'tape' ); +var isnan = require( '@stdlib/math/base/assert/is-nan' ); +var isPositiveZero = require( '@stdlib/math/base/assert/is-positive-zero' ); +var ndarray = require( '@stdlib/ndarray/base/ctor' ); +var range = require( './../lib' ); + + +// FUNCTIONS // + +/** +* Returns a one-dimensional ndarray. +* +* @private +* @param {Collection} buffer - underlying data buffer +* @param {NonNegativeInteger} length - number of indexed elements +* @param {integer} stride - stride length +* @param {NonNegativeInteger} offset - index offset +* @returns {ndarray} one-dimensional ndarray +*/ +function vector( buffer, length, stride, offset ) { + return new ndarray( 'generic', buffer, [ length ], [ stride ], offset, 'row-major' ); +} + + +// TESTS // + +tape( 'main export is a function', function test( t ) { + t.ok( true, __filename ); + t.strictEqual( typeof range, 'function', 'main export is a function' ); + t.end(); +}); + +tape( 'the function has an arity of 1', function test( t ) { + t.strictEqual( range.length, 1, 'has expected arity' ); + t.end(); +}); + +tape( 'the function calculates the range of a one-dimensional ndarray', function test( t ) { + var x; + var v; + + x = [ 1.0, -2.0, -4.0, 5.0, 0.0, 3.0 ]; + v = range( [ vector( x, 6, 1, 0 ) ] ); + t.strictEqual( v, 9.0, 'returns expected value' ); + + x = [ -4.0, -5.0 ]; + v = range( [ vector( x, 2, 1, 0 ) ] ); + t.strictEqual( v, 1.0, 'returns expected value' ); + + x = [ -0.0, 0.0, -0.0 ]; + v = range( [ vector( x, 3, 1, 0 ) ] ); + t.strictEqual( isPositiveZero( v ), true, 'returns expected value' ); + + x = [ NaN ]; + v = range( [ vector( x, 1, 1, 0 ) ] ); + t.strictEqual( isnan( v ), true, 'returns expected value' ); + + x = [ NaN, NaN ]; + v = range( [ vector( x, 2, 1, 0 ) ] ); + t.strictEqual( isnan( v ), true, 'returns expected value' ); + + t.end(); +}); + +tape( 'if provided an empty vector, the function returns `NaN`', function test( t ) { + var x; + var v; + + x = []; + + v = range( [ vector( x, 0, 1, 0 ) ] ); + t.strictEqual( isnan( v ), true, 'returns expected value' ); + + t.end(); +}); + +tape( 'if provided a vector containing a single element, the function returns `0`', function test( t ) { + var x; + var v; + + x = [ 1.0 ]; + + v = range( [ vector( x, 1, 1, 0 ) ] ); + t.strictEqual( v, 0.0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function supports one-dimensional ndarrays having non-unit strides', function test( t ) { + var x; + var v; + + x = [ + 1.0, // 0 + 2.0, + 2.0, // 1 + -7.0, + -2.0, // 2 + 3.0, + 4.0, // 3 + 2.0 + ]; + + v = range( [ vector( x, 4, 2, 0 ) ] ); + + t.strictEqual( v, 6.0, 'returns expected value' ); + t.end(); +}); + +tape( 'the function supports one-dimensional ndarrays having negative strides', function test( t ) { + var x; + var v; + + x = [ + 1.0, // 3 + 2.0, + 2.0, // 2 + -7.0, + -2.0, // 1 + 3.0, + 4.0, // 0 + 2.0 + ]; + + v = range( [ vector( x, 4, -2, 6 ) ] ); + + t.strictEqual( v, 6.0, 'returns expected value' ); + t.end(); +}); + +tape( 'the function supports one-dimensional ndarrays having non-zero offsets', function test( t ) { + var x; + var v; + + x = [ + 2.0, + 1.0, // 0 + 2.0, + -2.0, // 1 + -2.0, + 2.0, // 2 + 3.0, + 4.0 // 3 + ]; + + v = range( [ vector( x, 4, 2, 1 ) ] ); + t.strictEqual( v, 6.0, 'returns expected value' ); + + t.end(); +}); diff --git a/lib/node_modules/@stdlib/stats/base/ndarray/srange/README.md b/lib/node_modules/@stdlib/stats/base/ndarray/srange/README.md new file mode 100644 index 000000000000..2a781e522fec --- /dev/null +++ b/lib/node_modules/@stdlib/stats/base/ndarray/srange/README.md @@ -0,0 +1,116 @@ + + +# srange + +> Compute the [range][range] of a one-dimensional single-precision floating-point ndarray. + +
+ +The [**range**][range] is defined as the difference between the maximum and minimum values. + +
+ + + +
+ +## Usage + +```javascript +var srange = require( '@stdlib/stats/base/ndarray/srange' ); +``` + +#### srange( arrays ) + +Computes the [range][range] of a one-dimensional single-precision floating-point ndarray. + +```javascript +var Float32Array = require( '@stdlib/array/float32' ); +var ndarray = require( '@stdlib/ndarray/base/ctor' ); + +var xbuf = new Float32Array( [ 1.0, 3.0, 4.0, 2.0 ] ); +var x = new ndarray( 'float32', xbuf, [ 4 ], [ 1 ], 0, 'row-major' ); + +var v = srange( [ x ] ); +// returns 3.0 +``` + +The function has the following parameters: + +- **arrays**: array-like object containing a one-dimensional input ndarray. + +
+ + + +
+ +## Notes + +- If provided an empty one-dimensional ndarray, the function returns `NaN`. + +
+ + + +
+ +## Examples + + + +```javascript +var discreteUniform = require( '@stdlib/random/array/discrete-uniform' ); +var ndarray = require( '@stdlib/ndarray/base/ctor' ); +var ndarray2array = require( '@stdlib/ndarray/to-array' ); +var srange = require( '@stdlib/stats/base/ndarray/srange' ); + +var xbuf = discreteUniform( 10, -50, 50, { + 'dtype': 'float32' +}); +var x = new ndarray( 'float32', xbuf, [ xbuf.length ], [ 1 ], 0, 'row-major' ); +console.log( ndarray2array( x ) ); + +var v = srange( [ x ] ); +console.log( v ); +``` + +
+ + + + + +
+ +
+ + + + + +
+ +[range]: https://en.wikipedia.org/wiki/Range_%28statistics%29 + +
+ + diff --git a/lib/node_modules/@stdlib/stats/base/ndarray/srange/benchmark/benchmark.js b/lib/node_modules/@stdlib/stats/base/ndarray/srange/benchmark/benchmark.js new file mode 100644 index 000000000000..db5d035e9ab4 --- /dev/null +++ b/lib/node_modules/@stdlib/stats/base/ndarray/srange/benchmark/benchmark.js @@ -0,0 +1,102 @@ +/** +* @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 bench = require( '@stdlib/bench' ); +var uniform = require( '@stdlib/random/array/uniform' ); +var isnan = require( '@stdlib/math/base/assert/is-nan' ); +var pow = require( '@stdlib/math/base/special/pow' ); +var ndarray = require( '@stdlib/ndarray/base/ctor' ); +var pkg = require( './../package.json' ).name; +var srange = require( './../lib' ); + + +// VARIABLES // + +var options = { + 'dtype': 'float32' +}; + + +// FUNCTIONS // + +/** +* Creates a benchmark function. +* +* @private +* @param {PositiveInteger} len - array length +* @returns {Function} benchmark function +*/ +function createBenchmark( len ) { + var xbuf; + var x; + + xbuf = uniform( len, -10.0, 10.0, options ); + x = new ndarray( options.dtype, xbuf, [ len ], [ 1 ], 0, 'row-major' ); + + return benchmark; + + function benchmark( b ) { + var v; + var i; + + b.tic(); + for ( i = 0; i < b.iterations; i++ ) { + v = srange( [ x ] ); + if ( isnan( v ) ) { + b.fail( 'should not return NaN' ); + } + } + b.toc(); + if ( isnan( v ) ) { + 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( pkg+':len='+len, f ); + } +} + +main(); diff --git a/lib/node_modules/@stdlib/stats/base/ndarray/srange/docs/repl.txt b/lib/node_modules/@stdlib/stats/base/ndarray/srange/docs/repl.txt new file mode 100644 index 000000000000..6254ed4c2aa3 --- /dev/null +++ b/lib/node_modules/@stdlib/stats/base/ndarray/srange/docs/repl.txt @@ -0,0 +1,32 @@ + +{{alias}}( arrays ) + Computes the range of a one-dimensional single-precision floating-point + ndarray. + + If provided an empty ndarray, the function returns `NaN`. + + Parameters + ---------- + arrays: ArrayLikeObject + Array-like object containing a one-dimensional input ndarray. + + Returns + ------- + out: number + Range. + + Examples + -------- + > var xbuf = new {{alias:@stdlib/array/float32}}( [ 1.0, -2.0, 2.0 ] ); + > var dt = 'float32'; + > var sh = [ xbuf.length ]; + > var sx = [ 1 ]; + > var ox = 0; + > var ord = 'row-major'; + > var x = new {{alias:@stdlib/ndarray/ctor}}( dt, xbuf, sh, sx, ox, ord ); + > {{alias}}( [ x ] ) + 4.0 + + See Also + -------- + diff --git a/lib/node_modules/@stdlib/stats/base/ndarray/srange/docs/types/index.d.ts b/lib/node_modules/@stdlib/stats/base/ndarray/srange/docs/types/index.d.ts new file mode 100644 index 000000000000..bc7e62d6ad2b --- /dev/null +++ b/lib/node_modules/@stdlib/stats/base/ndarray/srange/docs/types/index.d.ts @@ -0,0 +1,46 @@ +/* +* @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. +*/ + +// TypeScript Version: 4.1 + +/// + +import { float32ndarray } from '@stdlib/types/ndarray'; + +/** +* Computes the range of a one-dimensional single-precision floating-point ndarray. +* +* @param arrays - array-like object containing an input ndarray +* @returns range +* +* @example +* var Float32Array = require( '@stdlib/array/float32' ); +* var ndarray = require( '@stdlib/ndarray/base/ctor' ); +* +* var xbuf = new Float32Array( [ 1.0, 3.0, 4.0, 2.0 ] ); +* var x = new ndarray( 'float32', xbuf, [ 4 ], [ 1 ], 0, 'row-major' ); +* +* var v = srange( [ x ] ); +* // returns 3.0 +*/ +declare function srange( arrays: [ float32ndarray ] ): number; + + +// EXPORTS // + +export = srange; diff --git a/lib/node_modules/@stdlib/stats/base/ndarray/srange/docs/types/test.ts b/lib/node_modules/@stdlib/stats/base/ndarray/srange/docs/types/test.ts new file mode 100644 index 000000000000..66e4ed7a30d3 --- /dev/null +++ b/lib/node_modules/@stdlib/stats/base/ndarray/srange/docs/types/test.ts @@ -0,0 +1,57 @@ +/* +* @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. +*/ + +/* eslint-disable space-in-parens */ + +import zeros = require( '@stdlib/ndarray/zeros' ); +import srange = require( './index' ); + + +// TESTS // + +// The function returns a number... +{ + const x = zeros( [ 10 ], { + 'dtype': 'float32' + }); + + srange( [ x ] ); // $ExpectType number +} + +// The compiler throws an error if the function is provided a first argument which is not an array of ndarrays... +{ + srange( '10' ); // $ExpectError + srange( 10 ); // $ExpectError + srange( true ); // $ExpectError + srange( false ); // $ExpectError + srange( null ); // $ExpectError + srange( undefined ); // $ExpectError + srange( [] ); // $ExpectError + srange( {} ); // $ExpectError + srange( ( x: number ): number => x ); // $ExpectError +} + +// The compiler throws an error if the function is provided an unsupported number of arguments... +{ + const x = zeros( [ 10 ], { + 'dtype': 'float32' + }); + + srange(); // $ExpectError + srange( [ x ], {} ); // $ExpectError +} diff --git a/lib/node_modules/@stdlib/stats/base/ndarray/srange/examples/index.js b/lib/node_modules/@stdlib/stats/base/ndarray/srange/examples/index.js new file mode 100644 index 000000000000..cf2beb86a819 --- /dev/null +++ b/lib/node_modules/@stdlib/stats/base/ndarray/srange/examples/index.js @@ -0,0 +1,33 @@ +/** +* @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'; + +var discreteUniform = require( '@stdlib/random/array/discrete-uniform' ); +var ndarray = require( '@stdlib/ndarray/base/ctor' ); +var ndarray2array = require( '@stdlib/ndarray/to-array' ); +var srange = require( './../lib' ); + +var xbuf = discreteUniform( 10, -50, 50, { + 'dtype': 'float32' +}); +var x = new ndarray( 'float32', xbuf, [ xbuf.length ], [ 1 ], 0, 'row-major' ); +console.log( ndarray2array( x ) ); + +var v = srange( [ x ] ); +console.log( v ); diff --git a/lib/node_modules/@stdlib/stats/base/ndarray/srange/lib/index.js b/lib/node_modules/@stdlib/stats/base/ndarray/srange/lib/index.js new file mode 100644 index 000000000000..e31bef09ffeb --- /dev/null +++ b/lib/node_modules/@stdlib/stats/base/ndarray/srange/lib/index.js @@ -0,0 +1,45 @@ +/** +* @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'; + +/** +* Compute the range of a one-dimensional single-precision floating-point ndarray. +* +* @module @stdlib/stats/base/ndarray/srange +* +* @example +* var Float32Array = require( '@stdlib/array/float32' ); +* var ndarray = require( '@stdlib/ndarray/base/ctor' ); +* var srange = require( '@stdlib/stats/base/ndarray/srange' ); +* +* var xbuf = new Float32Array( [ 1.0, 3.0, 4.0, 2.0 ] ); +* var x = new ndarray( 'float32', xbuf, [ 4 ], [ 1 ], 0, 'row-major' ); +* +* var v = srange( [ x ] ); +* // returns 3.0 +*/ + +// MODULES // + +var main = require( './main.js' ); + + +// EXPORTS // + +module.exports = main; diff --git a/lib/node_modules/@stdlib/stats/base/ndarray/srange/lib/main.js b/lib/node_modules/@stdlib/stats/base/ndarray/srange/lib/main.js new file mode 100644 index 000000000000..f14fd0379842 --- /dev/null +++ b/lib/node_modules/@stdlib/stats/base/ndarray/srange/lib/main.js @@ -0,0 +1,56 @@ +/** +* @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 strided = require( '@stdlib/stats/strided/srange' ).ndarray; + + +// MAIN // + +/** +* Computes the range of a one-dimensional single-precision floating-point ndarray. +* +* @param {ArrayLikeObject} arrays - array-like object containing an input ndarray +* @returns {number} range +* +* @example +* var Float32Array = require( '@stdlib/array/float32' ); +* var ndarray = require( '@stdlib/ndarray/base/ctor' ); +* +* var xbuf = new Float32Array( [ 1.0, 3.0, 4.0, 2.0 ] ); +* var x = new ndarray( 'float32', xbuf, [ 4 ], [ 1 ], 0, 'row-major' ); +* +* var v = srange( [ x ] ); +* // returns 3.0 +*/ +function srange( arrays ) { + var x = arrays[ 0 ]; + return strided( numelDimension( x, 0 ), getData( x ), getStride( x, 0 ), getOffset( x ) ); // eslint-disable-line max-len +} + + +// EXPORTS // + +module.exports = srange; diff --git a/lib/node_modules/@stdlib/stats/base/ndarray/srange/package.json b/lib/node_modules/@stdlib/stats/base/ndarray/srange/package.json new file mode 100644 index 000000000000..ce73218d30fc --- /dev/null +++ b/lib/node_modules/@stdlib/stats/base/ndarray/srange/package.json @@ -0,0 +1,71 @@ +{ + "name": "@stdlib/stats/base/ndarray/srange", + "version": "0.0.0", + "description": "Compute the range of a one-dimensional single-precision floating-point ndarray.", + "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", + "statistics", + "stats", + "mathematics", + "math", + "maximum", + "max", + "minimum", + "min", + "range", + "extremes", + "domain", + "extent", + "float32", + "float", + "ndarray" + ], + "__stdlib__": {} +} diff --git a/lib/node_modules/@stdlib/stats/base/ndarray/srange/test/test.js b/lib/node_modules/@stdlib/stats/base/ndarray/srange/test/test.js new file mode 100644 index 000000000000..2460b742f955 --- /dev/null +++ b/lib/node_modules/@stdlib/stats/base/ndarray/srange/test/test.js @@ -0,0 +1,173 @@ +/** +* @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 tape = require( 'tape' ); +var isnanf = require( '@stdlib/math/base/assert/is-nanf' ); +var isPositiveZerof = require( '@stdlib/math/base/assert/is-positive-zerof' ); +var Float32Array = require( '@stdlib/array/float32' ); +var ndarray = require( '@stdlib/ndarray/base/ctor' ); +var srange = require( './../lib' ); + + +// FUNCTIONS // + +/** +* Returns a one-dimensional ndarray. +* +* @private +* @param {Collection} buffer - underlying data buffer +* @param {NonNegativeInteger} length - number of indexed elements +* @param {integer} stride - stride length +* @param {NonNegativeInteger} offset - index offset +* @returns {ndarray} one-dimensional ndarray +*/ +function vector( buffer, length, stride, offset ) { + return new ndarray( 'float32', buffer, [ length ], [ stride ], offset, 'row-major' ); +} + + +// TESTS // + +tape( 'main export is a function', function test( t ) { + t.ok( true, __filename ); + t.strictEqual( typeof srange, 'function', 'main export is a function' ); + t.end(); +}); + +tape( 'the function has an arity of 1', function test( t ) { + t.strictEqual( srange.length, 1, 'has expected arity' ); + t.end(); +}); + +tape( 'the function calculates the range of a one-dimensional ndarray', function test( t ) { + var x; + var v; + + x = new Float32Array( [ 1.0, -2.0, -4.0, 5.0, 0.0, 3.0 ] ); + v = srange( [ vector( x, 6, 1, 0 ) ] ); + t.strictEqual( v, 9.0, 'returns expected value' ); + + x = new Float32Array( [ -4.0, -5.0 ] ); + v = srange( [ vector( x, 2, 1, 0 ) ] ); + t.strictEqual( v, 1.0, 'returns expected value' ); + + x = new Float32Array( [ -0.0, 0.0, -0.0 ] ); + v = srange( [ vector( x, 3, 1, 0 ) ] ); + t.strictEqual( isPositiveZerof( v ), true, 'returns expected value' ); + + x = new Float32Array( [ NaN ] ); + v = srange( [ vector( x, 1, 1, 0 ) ] ); + t.strictEqual( isnanf( v ), true, 'returns expected value' ); + + x = new Float32Array( [ NaN, NaN ] ); + v = srange( [ vector( x, 2, 1, 0 ) ] ); + t.strictEqual( isnanf( v ), true, 'returns expected value' ); + + t.end(); +}); + +tape( 'if provided an empty vector, the function returns `NaN`', function test( t ) { + var x; + var v; + + x = new Float32Array( [] ); + + v = srange( [ vector( x, 0, 1, 0 ) ] ); + t.strictEqual( isnanf( v ), true, 'returns expected value' ); + + t.end(); +}); + +tape( 'if provided a vector containing a single element, the function returns `0`', function test( t ) { + var x; + var v; + + x = new Float32Array( [ 1.0 ] ); + + v = srange( [ vector( x, 1, 1, 0 ) ] ); + t.strictEqual( v, 0.0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function supports one-dimensional ndarrays having non-unit strides', function test( t ) { + var x; + var v; + + x = new Float32Array([ + 1.0, // 0 + 2.0, + 2.0, // 1 + -7.0, + -2.0, // 2 + 3.0, + 4.0, // 3 + 2.0 + ]); + + v = srange( [ vector( x, 4, 2, 0 ) ] ); + + t.strictEqual( v, 6.0, 'returns expected value' ); + t.end(); +}); + +tape( 'the function supports one-dimensional ndarrays having negative strides', function test( t ) { + var x; + var v; + + x = new Float32Array([ + 1.0, // 3 + 2.0, + 2.0, // 2 + -7.0, + -2.0, // 1 + 3.0, + 4.0, // 0 + 2.0 + ]); + + v = srange( [ vector( x, 4, -2, 6 ) ] ); + + t.strictEqual( v, 6.0, 'returns expected value' ); + t.end(); +}); + +tape( 'the function supports one-dimensional ndarrays having non-zero offsets', function test( t ) { + var x; + var v; + + x = new Float32Array([ + 2.0, + 1.0, // 0 + 2.0, + -2.0, // 1 + -2.0, + 2.0, // 2 + 3.0, + 4.0 // 3 + ]); + + v = srange( [ vector( x, 4, 2, 1 ) ] ); + t.strictEqual( v, 6.0, 'returns expected value' ); + + t.end(); +}); diff --git a/lib/node_modules/@stdlib/stats/base/range-by/lib/accessors.js b/lib/node_modules/@stdlib/stats/base/range-by/lib/accessors.js index 85bfabd0bb72..d9f95e3aa0d6 100644 --- a/lib/node_modules/@stdlib/stats/base/range-by/lib/accessors.js +++ b/lib/node_modules/@stdlib/stats/base/range-by/lib/accessors.js @@ -67,7 +67,7 @@ function rangeBy( N, x, strideX, offsetX, clbk, thisArg) { get = x.accessors[ 0 ]; if ( N === 1 || strideX === 0 ) { - v = clbk.call( thisArg, get( xbuf, offsetX ), 0, offsetX, xbuf ); + v = clbk.call( thisArg, get( xbuf, offsetX ), 0, offsetX, x ); if ( v === void 0 || isnan( v ) ) { return NaN; } @@ -75,7 +75,7 @@ function rangeBy( N, x, strideX, offsetX, clbk, thisArg) { } ix = offsetX; for ( i = 0; i < N; i++ ) { - min = clbk.call( thisArg, get( xbuf, ix ), i, ix, xbuf ); + min = clbk.call( thisArg, get( xbuf, ix ), i, ix, x ); if ( min !== void 0 ) { break; } @@ -88,7 +88,7 @@ function rangeBy( N, x, strideX, offsetX, clbk, thisArg) { i += 1; for ( i; i < N; i++ ) { ix += strideX; - v = clbk.call( thisArg, get( xbuf, ix ), i, ix, xbuf ); + v = clbk.call( thisArg, get( xbuf, ix ), i, ix, x ); if ( v === void 0 ) { continue; } diff --git a/lib/node_modules/@stdlib/stats/base/stdevwd/test/test.stdevwd.js b/lib/node_modules/@stdlib/stats/base/stdevwd/test/test.stdevwd.js new file mode 100644 index 000000000000..dcf840ce4032 --- /dev/null +++ b/lib/node_modules/@stdlib/stats/base/stdevwd/test/test.stdevwd.js @@ -0,0 +1,207 @@ +/** +* @license Apache-2.0 +* +* Copyright (c) 2020 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 floor = require( '@stdlib/math/base/special/floor' ); +var sqrt = require( '@stdlib/math/base/special/sqrt' ); +var isnan = require( '@stdlib/math/base/assert/is-nan' ); +var Float64Array = require( '@stdlib/array/float64' ); +var stdevwd = require( './../lib/stdevwd.js' ); + + +// TESTS // + +tape( 'main export is a function', function test( t ) { + t.ok( true, __filename ); + t.strictEqual( typeof stdevwd, 'function', 'main export is a function' ); + t.end(); +}); + +tape( 'the function has an arity of 4', function test( t ) { + t.strictEqual( stdevwd.length, 4, 'has expected arity' ); + t.end(); +}); + +tape( 'the function calculates the population standard deviation of a strided array', function test( t ) { + var x; + var v; + + x = [ 1.0, -2.0, -4.0, 5.0, 0.0, 3.0 ]; + v = stdevwd( x.length, 0, x, 1 ); + t.strictEqual( v, sqrt( 53.5/x.length ), 'returns expected value' ); + + x = [ -4.0, -4.0 ]; + v = stdevwd( x.length, 0, x, 1 ); + t.strictEqual( v, 0.0, 'returns expected value' ); + + x = [ NaN, 4.0 ]; + v = stdevwd( x.length, 0, x, 1 ); + t.strictEqual( isnan( v ), true, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function calculates the sample standard deviation of a strided array', function test( t ) { + var x; + var v; + + x = [ 1.0, -2.0, -4.0, 5.0, 0.0, 3.0 ]; + v = stdevwd( x.length, 1, x, 1 ); + t.strictEqual( v, sqrt( 53.5/(x.length-1) ), 'returns expected value' ); + + x = [ -4.0, -4.0 ]; + v = stdevwd( x.length, 1, x, 1 ); + t.strictEqual( v, 0.0, 'returns expected value' ); + + x = [ NaN, 4.0 ]; + v = stdevwd( x.length, 1, x, 1 ); + t.strictEqual( isnan( v ), true, 'returns expected value' ); + + t.end(); +}); + +tape( 'if provided an `N` parameter less than or equal to `0`, the function returns `NaN`', function test( t ) { + var x; + var v; + + x = [ 1.0, -2.0, -4.0, 5.0, 3.0 ]; + + v = stdevwd( 0, 1, x, 1 ); + t.strictEqual( isnan( v ), true, 'returns expected value' ); + + v = stdevwd( -1, 1, x, 1 ); + t.strictEqual( isnan( v ), true, 'returns expected value' ); + + t.end(); +}); + +tape( 'if provided an `N` parameter equal to `1`, the function returns a population standard deviation of `0`', function test( t ) { + var x; + var v; + + x = [ 1.0, -2.0, -4.0, 5.0, 3.0 ]; + + v = stdevwd( 1, 0, x, 1 ); + t.strictEqual( v, 0.0, 'returns expected value' ); + + t.end(); +}); + +tape( 'if provided a `correction` parameter yielding `N-correction` less than or equal to `0`, the function returns `NaN`', function test( t ) { + var x; + var v; + + x = [ 1.0, -2.0, -4.0, 5.0, 3.0 ]; + + v = stdevwd( x.length, x.length, x, 1 ); + t.strictEqual( isnan( v ), true, 'returns expected value' ); + + v = stdevwd( x.length, x.length+1, x, 1 ); + t.strictEqual( isnan( v ), true, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function supports a `stride` parameter', function test( t ) { + var N; + var x; + var v; + + x = [ + 1.0, // 0 + 2.0, + 2.0, // 1 + -7.0, + -2.0, // 2 + 3.0, + 4.0, // 3 + 2.0 + ]; + + N = floor( x.length / 2 ); + v = stdevwd( N, 1, x, 2 ); + + t.strictEqual( v, 2.5, 'returns expected value' ); + t.end(); +}); + +tape( 'the function supports a negative `stride` parameter', function test( t ) { + var N; + var x; + var v; + + x = [ + 1.0, // 3 + 2.0, + 2.0, // 2 + -7.0, + -2.0, // 1 + 3.0, + 4.0, // 0 + 2.0 + ]; + + N = floor( x.length / 2 ); + v = stdevwd( N, 1, x, -2 ); + + t.strictEqual( v, 2.5, 'returns expected value' ); + t.end(); +}); + +tape( 'if provided a `stride` parameter equal to `0`, the function returns `0`', function test( t ) { + var x; + var v; + + x = [ 1.0, -2.0, -4.0, 5.0, 3.0 ]; + + v = stdevwd( x.length, 1, x, 0 ); + t.strictEqual( v, 0.0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function supports view offsets', function test( t ) { + var x0; + var x1; + var N; + var v; + + x0 = new Float64Array([ + 2.0, + 1.0, // 0 + 2.0, + -2.0, // 1 + -2.0, + 2.0, // 2 + 3.0, + 4.0, // 3 + 6.0 + ]); + + x1 = new Float64Array( x0.buffer, x0.BYTES_PER_ELEMENT*1 ); // start at 2nd element + N = floor(x1.length / 2); + + v = stdevwd( N, 1, x1, 2 ); + t.strictEqual( v, 2.5, 'returns expected value' ); + + t.end(); +});