diff --git a/lib/node_modules/@stdlib/math/base/special/exp2f/README.md b/lib/node_modules/@stdlib/math/base/special/exp2f/README.md new file mode 100644 index 000000000000..784f18676abf --- /dev/null +++ b/lib/node_modules/@stdlib/math/base/special/exp2f/README.md @@ -0,0 +1,202 @@ + + +# exp2f + +> Single-precision base `2` [exponential function][exponential-function]. + +
+ +## Usage + +```javascript +var exp2f = require( '@stdlib/math/base/special/exp2f' ); +``` + +#### exp2f( x ) + +Evaluates the base 2 [exponential function][exponential-function] (single-precision). + +```javascript +var v = exp2f( 3.0 ); +// returns ~5.657 + +v = exp2f( -9.0 ); +// returns ~0.0014 + +v = exp2f( 0.0 ); +// returns 1.0 + +v = exp2f( NaN ); +// returns NaN +``` + +
+ + + +
+ +## Examples + + + +```javascript +var uniform = require( '@stdlib/random/array/uniform' ); +var logEachMap = require( '@stdlib/console/log-each-map' ); +var exp2f = require( '@stdlib/math/base/special/exp2f' ); + +var opts = { + 'dtype': 'float32' +}; +var x = uniform( 100, -50.0, 50.0, opts ); + +logEachMap( '2^%0.4f = %0.4f', x, exp2f ); +``` + +
+ + + + + +* * * + +
+ +## C APIs + + + +
+ +
+ + + + + +
+ +### Usage + +```c +#include "stdlib/math/base/special/exp2f.h" +``` + +#### stdlib_base_exp2f( x ) + +Evaluates the base 2 [exponential function][exponential-function] (single-precision). + +```c +float out = stdlib_base_exp2f( 3.0f ); +// returns ~5.657f + +out = stdlib_base_exp2f( -9.0f ); +// returns ~0.0014f +``` + +The function accepts the following arguments: + +- **x**: `[in] float` input value. + +```c +float stdlib_base_exp2f( const float x ); +``` + +
+ + + + + +
+ +
+ + + + + +
+ +### Examples + +```c +#include "stdlib/math/base/special/exp2f.h" +#include +#include + +int main( void ) { + float x; + float v; + int i; + + for ( i = 0; i < 100; i++ ) { + x = ( ( (float)rand() / (float)RAND_MAX ) * 100.0f ) - 50.0f; + v = stdlib_base_exp2f( x ); + printf( "exp2f(%f) = %f\n", x, v ); + } +} +``` + +
+ + + +
+ + + + + +
+ +* * * + +## See Also + +- [`@stdlib/math/base/special/exp`][@stdlib/math/base/special/exp]: natural exponential function. +- [`@stdlib/math/base/special/exp10`][@stdlib/math/base/special/exp10]: base 10 exponential function. +- [`@stdlib/math/base/special/log2`][@stdlib/math/base/special/log2]: binary logarithm (base 2). + +
+ + + + + +
+ +[exponential-function]: https://en.wikipedia.org/wiki/Exponential_function + + + +[@stdlib/math/base/special/exp]: https://github.com/stdlib-js/stdlib/tree/develop/lib/node_modules/%40stdlib/math/base/special/exp + +[@stdlib/math/base/special/exp10]: https://github.com/stdlib-js/stdlib/tree/develop/lib/node_modules/%40stdlib/math/base/special/exp10 + +[@stdlib/math/base/special/log2]: https://github.com/stdlib-js/stdlib/tree/develop/lib/node_modules/%40stdlib/math/base/special/log2 + + + +
+ + diff --git a/lib/node_modules/@stdlib/math/base/special/exp2f/benchmark/benchmark.js b/lib/node_modules/@stdlib/math/base/special/exp2f/benchmark/benchmark.js new file mode 100644 index 000000000000..1fe72c8c3001 --- /dev/null +++ b/lib/node_modules/@stdlib/math/base/special/exp2f/benchmark/benchmark.js @@ -0,0 +1,52 @@ +/** +* @license Apache-2.0 +* +* Copyright (c) 2026 The Stdlib Authors. +* +* Licensed under the Apache License, Version 2.0 (the "License"); +* you may not use this file except in compliance with the License. +* You may obtain a copy of the License at +* +* http://www.apache.org/licenses/LICENSE-2.0 +* +* Unless required by applicable law or agreed to in writing, software +* distributed under the License is distributed on an "AS IS" BASIS, +* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +* See the License for the specific language governing permissions and +* limitations under the License. +*/ + +'use strict'; + +var bench = require( '@stdlib/bench' ); +var uniform = require( '@stdlib/random/array/uniform' ); +var isnan = require( '@stdlib/math/base/assert/is-nanf' ); +var pkg = require( './../package.json' ).name; +var exp2f = require( './../lib' ); + + +// MAIN // + +bench( pkg, function benchmark( b ) { + var x; + var y; + var i; + + x = uniform( 10, -127.0, 127.0, { + 'dtype': 'generic' + }); + + b.tic(); + for ( i = 0; i < b.iterations; i++ ) { + y = exp2f( x[ i%x.length ] ); + if ( isnan( y ) ) { + b.fail( 'should not return NaN' ); + } + } + b.toc(); + if ( isnan( y ) ) { + b.fail( 'should not return NaN' ); + } + b.pass( 'benchmark finished' ); + b.end(); +}); diff --git a/lib/node_modules/@stdlib/math/base/special/exp2f/benchmark/benchmark.native.js b/lib/node_modules/@stdlib/math/base/special/exp2f/benchmark/benchmark.native.js new file mode 100644 index 000000000000..1b71bad486fc --- /dev/null +++ b/lib/node_modules/@stdlib/math/base/special/exp2f/benchmark/benchmark.native.js @@ -0,0 +1,63 @@ +/** +* @license Apache-2.0 +* +* Copyright (c) 2026 The Stdlib Authors. +* +* Licensed under the Apache License, Version 2.0 (the "License"); +* you may not use this file except in compliance with the License. +* You may obtain a copy of the License at +* +* http://www.apache.org/licenses/LICENSE-2.0 +* +* Unless required by applicable law or agreed to in writing, software +* distributed under the License is distributed on an "AS IS" BASIS, +* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +* See the License for the specific language governing permissions and +* limitations under the License. +*/ + +'use strict'; + +// MODULES // + +var resolve = require( 'path' ).resolve; +var bench = require( '@stdlib/bench' ); +var uniform = require( '@stdlib/random/array/uniform' ); +var isnan = require( '@stdlib/math/base/assert/is-nanf' ); +var tryRequire = require( '@stdlib/utils/try-require' ); +var pkg = require( './../package.json' ).name; + + +// VARIABLES // + +var exp2f = tryRequire( resolve( __dirname, './../lib/native.js' ) ); +var opts = { + 'skip': ( exp2f instanceof Error ) +}; + + +// MAIN // + +bench( pkg+'::native', opts, function benchmark( b ) { + var x; + var y; + var i; + + x = uniform( 10, -127.0, 127.0, { + 'dtype': 'generic' + }); + + b.tic(); + for ( i = 0; i < b.iterations; i++ ) { + y = exp2f( x[ i%x.length ] ); + if ( isnan( y ) ) { + b.fail( 'should not return NaN' ); + } + } + b.toc(); + if ( isnan( y ) ) { + b.fail( 'should not return NaN' ); + } + b.pass( 'benchmark finished' ); + b.end(); +}); diff --git a/lib/node_modules/@stdlib/math/base/special/exp2f/benchmark/c/Makefile b/lib/node_modules/@stdlib/math/base/special/exp2f/benchmark/c/Makefile new file mode 100644 index 000000000000..928de45a1a06 --- /dev/null +++ b/lib/node_modules/@stdlib/math/base/special/exp2f/benchmark/c/Makefile @@ -0,0 +1,127 @@ +#/ +# @license Apache-2.0 +# +# Copyright (c) 2026 The Stdlib Authors. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +#/ + + +# VARIABLES # + +ifndef VERBOSE + QUIET := @ +else + QUIET := +endif + +# Determine the OS ([1][1], [2][2]). +# +# [1]: https://en.wikipedia.org/wiki/Uname#Examples +# [2]: http://stackoverflow.com/a/27776822/2225624 +OS ?= $(shell uname) +ifneq (, $(findstring MINGW,$(OS))) + OS := WINNT +else +ifneq (, $(findstring MSYS,$(OS))) + OS := WINNT +else +ifneq (, $(findstring CYGWIN,$(OS))) + OS := WINNT +else +ifneq (, $(findstring Windows_NT,$(OS))) + OS := WINNT +endif +endif +endif +endif + +# Define the program used for compiling C source files: +ifdef C_COMPILER + CC := $(C_COMPILER) +else + CC := gcc +endif + +# Define the command-line options when compiling C files: +CFLAGS ?= \ + -std=c99 \ + -O3 \ + -Wall \ + -pedantic + +# Determine whether to generate position independent code ([1][1], [2][2]). +# +# [1]: https://gcc.gnu.org/onlinedocs/gcc/Code-Gen-Options.html#Code-Gen-Options +# [2]: http://stackoverflow.com/questions/5311515/gcc-fpic-option +ifeq ($(OS), WINNT) + fPIC ?= +else + fPIC ?= -fPIC +endif + +# List of C targets: +c_targets := benchmark.out + + +# RULES # + +#/ +# Compiles C source files. +# +# @param {string} [C_COMPILER] - C compiler +# @param {string} [CFLAGS] - C compiler flags +# @param {(string|void)} [fPIC] - compiler flag indicating whether to generate position independent code +# +# @example +# make +# +# @example +# make all +#/ +all: $(c_targets) + +.PHONY: all + +#/ +# Compiles C source files. +# +# @private +# @param {string} CC - C compiler +# @param {string} CFLAGS - C compiler flags +# @param {(string|void)} fPIC - compiler flag indicating whether to generate position independent code +#/ +$(c_targets): %.out: %.c + $(QUIET) $(CC) $(CFLAGS) $(fPIC) -o $@ $< -lm + +#/ +# 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/math/base/special/exp2f/benchmark/c/benchmark.c b/lib/node_modules/@stdlib/math/base/special/exp2f/benchmark/c/benchmark.c new file mode 100644 index 000000000000..e7e68f690d4b --- /dev/null +++ b/lib/node_modules/@stdlib/math/base/special/exp2f/benchmark/c/benchmark.c @@ -0,0 +1,136 @@ +/** +* @license Apache-2.0 +* +* Copyright (c) 2026 The Stdlib Authors. +* +* Licensed under the Apache License, Version 2.0 (the "License"); +* you may not use this file except in compliance with the License. +* You may obtain a copy of the License at +* +* http://www.apache.org/licenses/LICENSE-2.0 +* +* Unless required by applicable law or agreed to in writing, software +* distributed under the License is distributed on an "AS IS" BASIS, +* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +* See the License for the specific language governing permissions and +* limitations under the License. +*/ + +#include +#include +#include +#include +#include + +#include "stdlib/math/base/special/exp2f.h" + +#define NAME "exp2f" +#define ITERATIONS 1000000 +#define REPEATS 3 + +/** +* 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 elapsed elapsed time in seconds +*/ +static void print_results( 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 float rand_float( void ) { + int r = rand(); + return (float)r / ( (float)RAND_MAX + 1.0f ); +} + +/** +* Runs a benchmark. +* +* @return elapsed time in seconds +*/ +static double benchmark( void ) { + double elapsed; + float x[ 10 ]; + float y; + double t; + int i; + + for ( i = 0; i < 10; i++ ) { + x[ i ] = ( 254.0f * rand_float() ) - 127.0f; + } + t = tic(); + for ( i = 0; i < ITERATIONS; i++ ) { + y = stdlib_base_exp2f( x[ i%10 ] ); + if ( y != y ) { + printf( "should not return NaN\n" ); + break; + } + } + elapsed = tic() - t; + if ( y != y ) { + printf( "should not return NaN\n" ); + } + return elapsed; +} + +/** +* Main execution sequence. +*/ +int main( void ) { + double elapsed; + int i; + + // Use the current time to seed the random number generator: + srand( time( NULL ) ); + + print_version(); + for ( i = 0; i < REPEATS; i++ ) { + printf( "# c::stdlib::%s\n", NAME ); + elapsed = benchmark(); + print_results( elapsed ); + printf( "ok %d benchmark finished\n", i+1 ); + } + print_summary( REPEATS, REPEATS ); +} diff --git a/lib/node_modules/@stdlib/math/base/special/exp2f/binding.gyp b/lib/node_modules/@stdlib/math/base/special/exp2f/binding.gyp new file mode 100644 index 000000000000..0d6508a12e99 --- /dev/null +++ b/lib/node_modules/@stdlib/math/base/special/exp2f/binding.gyp @@ -0,0 +1,170 @@ +# @license Apache-2.0 +# +# Copyright (c) 2026 The Stdlib Authors. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +# A `.gyp` file for building a Node.js native add-on. +# +# [1]: https://gyp.gsrc.io/docs/InputFormatReference.md +# [2]: https://gyp.gsrc.io/docs/UserDocumentation.md +{ + # List of files to include in this file: + 'includes': [ + './include.gypi', + ], + + # Define variables to be used throughout the configuration for all targets: + 'variables': { + # Target name should match the add-on export name: + 'addon_target_name%': 'addon', + + # 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 + }, # 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/math/base/special/exp2f/docs/repl.txt b/lib/node_modules/@stdlib/math/base/special/exp2f/docs/repl.txt new file mode 100644 index 000000000000..87fb4ae8659d --- /dev/null +++ b/lib/node_modules/@stdlib/math/base/special/exp2f/docs/repl.txt @@ -0,0 +1,27 @@ + +{{alias}}( x ) + Evaluates the base 2 exponential function (single-precision). + + Parameters + ---------- + x: number + Input value. + + Returns + ------- + y: number + Function value. + + Examples + -------- + > var y = {{alias}}( 3.0 ) + ~5.657 + > y = {{alias}}( -9.0 ) + ~0.0014 + > y = {{alias}}( 0.0 ) + 1.0 + > y = {{alias}}( NaN ) + NaN + + See Also + -------- diff --git a/lib/node_modules/@stdlib/math/base/special/exp2f/docs/types/index.d.ts b/lib/node_modules/@stdlib/math/base/special/exp2f/docs/types/index.d.ts new file mode 100644 index 000000000000..3cb81d71dfa6 --- /dev/null +++ b/lib/node_modules/@stdlib/math/base/special/exp2f/docs/types/index.d.ts @@ -0,0 +1,48 @@ +/* +* @license Apache-2.0 +* +* Copyright (c) 2026 The Stdlib Authors. +* +* Licensed under the Apache License, Version 2.0 (the "License"); +* you may not use this file except in compliance with the License. +* You may obtain a copy of the License at +* +* http://www.apache.org/licenses/LICENSE-2.0 +* +* Unless required by applicable law or agreed to in writing, software +* distributed under the License is distributed on an "AS IS" BASIS, +* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +* See the License for the specific language governing permissions and +* limitations under the License. +*/ + +// TypeScript Version: 4.1 + +/** +* Evaluates the base 2 exponential function (single-precision). +* +* @param x - input value +* @returns function value +* +* @example +* var v = exp2f( 3.0 ); +* // returns ~5.657 +* +* @example +* var v = exp2f( -9.0 ); +* // returns ~0.0014 +* +* @example +* var v = exp2f( 0.0 ); +* // returns 1.0 +* +* @example +* var v = exp2f( NaN ); +* // returns NaN +*/ +declare function exp2f( x: number ): number; + + +// EXPORTS // + +export = exp2f; diff --git a/lib/node_modules/@stdlib/math/base/special/exp2f/docs/types/test.ts b/lib/node_modules/@stdlib/math/base/special/exp2f/docs/types/test.ts new file mode 100644 index 000000000000..a5cebb62f808 --- /dev/null +++ b/lib/node_modules/@stdlib/math/base/special/exp2f/docs/types/test.ts @@ -0,0 +1,44 @@ +/* +* @license Apache-2.0 +* +* Copyright (c) 2026 The Stdlib Authors. +* +* Licensed under the Apache License, Version 2.0 (the "License"); +* you may not use this file except in compliance with the License. +* You may obtain a copy of the License at +* +* http://www.apache.org/licenses/LICENSE-2.0 +* +* Unless required by applicable law or agreed to in writing, software +* distributed under the License is distributed on an "AS IS" BASIS, +* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +* See the License for the specific language governing permissions and +* limitations under the License. +*/ + +import exp2f = require( './index' ); + + +// TESTS // + +// The function returns a number... +{ + exp2f( 0.5 ); // $ExpectType number +} + +// The compiler throws an error if the function is provided a value other than a number... +{ + exp2f( true ); // $ExpectError + exp2f( false ); // $ExpectError + exp2f( null ); // $ExpectError + exp2f( undefined ); // $ExpectError + exp2f( '5' ); // $ExpectError + exp2f( [] ); // $ExpectError + exp2f( {} ); // $ExpectError + exp2f( ( x: number ): number => x ); // $ExpectError +} + +// The compiler throws an error if the function is provided insufficient arguments... +{ + exp2f(); // $ExpectError +} diff --git a/lib/node_modules/@stdlib/math/base/special/exp2f/examples/c/Makefile b/lib/node_modules/@stdlib/math/base/special/exp2f/examples/c/Makefile new file mode 100644 index 000000000000..c8f8e9a1517b --- /dev/null +++ b/lib/node_modules/@stdlib/math/base/special/exp2f/examples/c/Makefile @@ -0,0 +1,146 @@ +#/ +# @license Apache-2.0 +# +# Copyright (c) 2026 The Stdlib Authors. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +#/ + +# VARIABLES # + +ifndef VERBOSE + QUIET := @ +else + QUIET := +endif + +# Determine the OS ([1][1], [2][2]). +# +# [1]: https://en.wikipedia.org/wiki/Uname#Examples +# [2]: http://stackoverflow.com/a/27776822/2225624 +OS ?= $(shell uname) +ifneq (, $(findstring MINGW,$(OS))) + OS := WINNT +else +ifneq (, $(findstring MSYS,$(OS))) + OS := WINNT +else +ifneq (, $(findstring CYGWIN,$(OS))) + OS := WINNT +else +ifneq (, $(findstring Windows_NT,$(OS))) + OS := WINNT +endif +endif +endif +endif + +# Define the program used for compiling C source files: +ifdef C_COMPILER + CC := $(C_COMPILER) +else + CC := gcc +endif + +# Define the command-line options when compiling C files: +CFLAGS ?= \ + -std=c99 \ + -O3 \ + -Wall \ + -pedantic + +# Determine whether to generate position independent code ([1][1], [2][2]). +# +# [1]: https://gcc.gnu.org/onlinedocs/gcc/Code-Gen-Options.html#Code-Gen-Options +# [2]: http://stackoverflow.com/questions/5311515/gcc-fpic-option +ifeq ($(OS), WINNT) + fPIC ?= +else + fPIC ?= -fPIC +endif + +# List of includes (e.g., `-I /foo/bar -I /beep/boop/include`): +INCLUDE ?= + +# List of source files: +SOURCE_FILES ?= + +# List of libraries (e.g., `-lopenblas -lpthread`): +LIBRARIES ?= + +# List of library paths (e.g., `-L /foo/bar -L /beep/boop`): +LIBPATH ?= + +# List of C targets: +c_targets := example.out + + +# RULES # + +#/ +# Compiles source files. +# +# @param {string} [C_COMPILER] - C compiler (e.g., `gcc`) +# @param {string} [CFLAGS] - C compiler options +# @param {(string|void)} [fPIC] - compiler flag determining whether to generate position independent code (e.g., `-fPIC`) +# @param {string} [INCLUDE] - list of includes (e.g., `-I /foo/bar -I /beep/boop/include`) +# @param {string} [SOURCE_FILES] - list of source files +# @param {string} [LIBPATH] - list of library paths (e.g., `-L /foo/bar -L /beep/boop`) +# @param {string} [LIBRARIES] - list of libraries (e.g., `-lopenblas -lpthread`) +# +# @example +# make +# +# @example +# make all +#/ +all: $(c_targets) + +.PHONY: all + +#/ +# Compiles C source files. +# +# @private +# @param {string} CC - C compiler (e.g., `gcc`) +# @param {string} CFLAGS - C compiler options +# @param {(string|void)} fPIC - compiler flag determining whether to generate position independent code (e.g., `-fPIC`) +# @param {string} INCLUDE - list of includes (e.g., `-I /foo/bar`) +# @param {string} SOURCE_FILES - list of source files +# @param {string} LIBPATH - list of library paths (e.g., `-L /foo/bar`) +# @param {string} LIBRARIES - list of libraries (e.g., `-lopenblas`) +#/ +$(c_targets): %.out: %.c + $(QUIET) $(CC) $(CFLAGS) $(fPIC) $(INCLUDE) -o $@ $(SOURCE_FILES) $< $(LIBPATH) -lm $(LIBRARIES) + +#/ +# Runs compiled examples. +# +# @example +# make run +#/ +run: $(c_targets) + $(QUIET) ./$< + +.PHONY: run + +#/ +# Removes generated files. +# +# @example +# make clean +#/ +clean: + $(QUIET) -rm -f *.o *.out + +.PHONY: clean diff --git a/lib/node_modules/@stdlib/math/base/special/exp2f/examples/c/example.c b/lib/node_modules/@stdlib/math/base/special/exp2f/examples/c/example.c new file mode 100644 index 000000000000..e8f242d3d659 --- /dev/null +++ b/lib/node_modules/@stdlib/math/base/special/exp2f/examples/c/example.c @@ -0,0 +1,33 @@ +/** +* @license Apache-2.0 +* +* Copyright (c) 2026 The Stdlib Authors. +* +* Licensed under the Apache License, Version 2.0 (the "License"); +* you may not use this file except in compliance with the License. +* You may obtain a copy of the License at +* +* http://www.apache.org/licenses/LICENSE-2.0 +* +* Unless required by applicable law or agreed to in writing, software +* distributed under the License is distributed on an "AS IS" BASIS, +* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +* See the License for the specific language governing permissions and +* limitations under the License. +*/ + +#include "stdlib/math/base/special/exp2f.h" +#include +#include + +int main( void ) { + float x; + float v; + int i; + + for ( i = 0; i < 100; i++ ) { + x = ( ( (float)rand() / (float)RAND_MAX ) * 100.0f ) - 50.0f; + v = stdlib_base_exp2f( x ); + printf( "2^%f = %f\n", x, v ); + } +} diff --git a/lib/node_modules/@stdlib/math/base/special/exp2f/examples/index.js b/lib/node_modules/@stdlib/math/base/special/exp2f/examples/index.js new file mode 100644 index 000000000000..ccd8f806541f --- /dev/null +++ b/lib/node_modules/@stdlib/math/base/special/exp2f/examples/index.js @@ -0,0 +1,30 @@ +/** +* @license Apache-2.0 +* +* Copyright (c) 2026 The Stdlib Authors. +* +* Licensed under the Apache License, Version 2.0 (the "License"); +* you may not use this file except in compliance with the License. +* You may obtain a copy of the License at +* +* http://www.apache.org/licenses/LICENSE-2.0 +* +* Unless required by applicable law or agreed to in writing, software +* distributed under the License is distributed on an "AS IS" BASIS, +* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +* See the License for the specific language governing permissions and +* limitations under the License. +*/ + +'use strict'; + +var uniform = require( '@stdlib/random/array/uniform' ); +var logEachMap = require( '@stdlib/console/log-each-map' ); +var exp2f = require( './../lib' ); + +var opts = { + 'dtype': 'float32' +}; +var x = uniform( 100, -50.0, 50.0, opts ); + +logEachMap( '2^%0.4f = %0.4f', x, exp2f ); diff --git a/lib/node_modules/@stdlib/math/base/special/exp2f/include.gypi b/lib/node_modules/@stdlib/math/base/special/exp2f/include.gypi new file mode 100644 index 000000000000..eef3d570b908 --- /dev/null +++ b/lib/node_modules/@stdlib/math/base/special/exp2f/include.gypi @@ -0,0 +1,53 @@ +# @license Apache-2.0 +# +# Copyright (c) 2026 The Stdlib Authors. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +# A GYP include file for building a Node.js native add-on for exp2f. +# +# Main documentation: +# +# [1]: https://gyp.gsrc.io/docs/InputFormatReference.md +# [2]: https://gyp.gsrc.io/docs/UserDocumentation.md +{ + # Define variables to be used throughout the configuration for all targets: + 'variables': { + # Source directory: + 'src_dir': './src', + + # Include directories: + 'include_dirs': [ + ' +* All rights reserved. +* +* Redistribution and use in source and binary forms, with or without +* modification, are permitted provided that the following conditions +* are met: +* 1. Redistributions of source code must retain the above copyright +* notice, this list of conditions and the following disclaimer. +* 2. Redistributions in binary form must reproduce the above copyright +* notice, this list of conditions and the following disclaimer in the +* documentation and/or other materials provided with the distribution. +* +* THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND +* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE +* ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE +* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL +* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS +* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) +* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT +* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY +* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF +* SUCH DAMAGE. +* ``` +*/ + +'use strict'; + +// MODULES // + +var FLOAT32_MAX_BASE2_EXPONENT = require( '@stdlib/constants/float32/max-base2-exponent' ); // ≈127 +var FLOAT32_MIN_BASE2_EXPONENT = require( '@stdlib/constants/float32/min-base2-exponent' ); // ≈-149 +var roundf = require( '@stdlib/math/base/special/roundf' ); +var ldexpf = require( '@stdlib/math/base/special/ldexpf' ); +var isnanf = require( '@stdlib/math/base/assert/is-nanf' ); +var PINF = require( '@stdlib/constants/float32/pinf' ); +var Float64Array = require( '@stdlib/array/float64' ); +var abs = require( '@stdlib/math/base/special/abs' ); +var floor = require( '@stdlib/math/base/special/floor' ); + + +// VARIABLES // + +var TBLBITS = 4; +var TBLSIZE = 1 << TBLBITS; +var redux = 12582912 / TBLSIZE; +var P1 = 0.6931471805599453; +var P2 = 0.240226506959101; +var P3 = 0.05550410866482158; +var P4 = 0.009618129107628477; + +var exp2ft = new Float64Array([ + 0.7071067811865476, + 0.7653668647301795, + 0.8264462809917354, + 0.8908987181403393, + 0.9594929736144974, + 1.032006899548349, + 1.108225367074009, + 1.187939392393399, + 1.0, + 1.044273782427414, + 1.0905077326652577, + 1.1387886347566916, + 1.189207115002721, + 1.241857812073484, + 1.2968395546510096, + 1.3542555469368927 +]); + + +// MAIN // + +/** +* Evaluates the base `2` exponential function (single-precision). +* +* ## Method +* +* - Range reduction is accomplished by separating the argument into an integer \\( k \\) and fraction \\( f \\) such that +* +* ```tex +* 2^x = 2^k 2^f +* ``` +* +* - Uses a table lookup for \\( 2^{i / TBLSIZE} \\) and a degree-4 polynomial approximation for the fractional part. +* +* ## Notes +* +* - Peak error < 0.501 ulp (from FreeBSD reference implementation). +* +* @param {number} x - input value +* @returns {number} function value +* +* @example +* var v = exp2f( 3.0 ); +* // returns ~5.657 +* +* @example +* var v = exp2f( -9.0 ); +* // returns ~0.0014 +* +* @example +* var v = exp2f( 0.0 ); +* // returns 1.0 +* +* @example +* var v = exp2f( NaN ); +* // returns NaN +*/ +function exp2f( x ) { + var px; + var xx; + var tv; + var i0; + var n; + var t; + var u; + var z; + + if ( isnanf( x ) ) { + return x; + } + if ( x > FLOAT32_MAX_BASE2_EXPONENT ) { + return PINF; + } + if ( x < FLOAT32_MIN_BASE2_EXPONENT ) { + return 0.0; + } + + // Small x: 1 + x + if ( abs( x ) <= 1.0 / (1 << 23) ) { // 2^-23 + return 1.0 + x; + } + + // Reduce x: x = n + f, |f| <= 0.5 + n = roundf( x ); + x -= n; + + // Table lookup + polynomial + t = x + redux; + i0 = floor( ( t * TBLSIZE ) + 0.5 ) & ( TBLSIZE - 1 ); + t -= redux; + z = x - t; + + tv = exp2ft[ i0 ]; + u = tv * z; + xx = z * z; + px = u * ( P1 + ( z * P2 ) + ( xx * ( P3 + ( z * P4 ) ) ) ); + x = tv + px; + + // Scale by 2^n + return ldexpf( x, n ); +} + + +// EXPORTS // + +module.exports = exp2f; diff --git a/lib/node_modules/@stdlib/math/base/special/exp2f/lib/native.js b/lib/node_modules/@stdlib/math/base/special/exp2f/lib/native.js new file mode 100644 index 000000000000..d4e0020c7de5 --- /dev/null +++ b/lib/node_modules/@stdlib/math/base/special/exp2f/lib/native.js @@ -0,0 +1,58 @@ +/** +* @license Apache-2.0 +* +* Copyright (c) 2026 The Stdlib Authors. +* +* Licensed under the Apache License, Version 2.0 (the "License"); +* you may not use this file except in compliance with the License. +* You may obtain a copy of the License at +* +* http://www.apache.org/licenses/LICENSE-2.0 +* +* Unless required by applicable law or agreed to in writing, software +* distributed under the License is distributed on an "AS IS" BASIS, +* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +* See the License for the specific language governing permissions and +* limitations under the License. +*/ + +'use strict'; + +// MODULES // + +var addon = require( './../src/addon.node' ); + + +// MAIN // + +/** +* Evaluates the base `2` exponential function (single-precision). +* +* @private +* @param {number} x - input value +* @returns {number} function value +* +* @example +* var v = exp2f( 3.0 ); +* // returns ~5.657 +* +* @example +* var v = exp2f( -9.0 ); +* // returns ~0.0014 +* +* @example +* var v = exp2f( 0.0 ); +* // returns 1.0 +* +* @example +* var v = exp2f( NaN ); +* // returns NaN +*/ +function exp2f( x ) { + return addon( x ); +} + + +// EXPORTS // + +module.exports = exp2f; diff --git a/lib/node_modules/@stdlib/math/base/special/exp2f/lib/polyval_p.js b/lib/node_modules/@stdlib/math/base/special/exp2f/lib/polyval_p.js new file mode 100644 index 000000000000..46fbec13f733 --- /dev/null +++ b/lib/node_modules/@stdlib/math/base/special/exp2f/lib/polyval_p.js @@ -0,0 +1,47 @@ +/** +* @license Apache-2.0 +* +* Copyright (c) 2026 The Stdlib Authors. +* +* Licensed under the Apache License, Version 2.0 (the "License"); +* you may not use this file except in compliance with the License. +* You may obtain a copy of the License at +* +* http://www.apache.org/licenses/LICENSE-2.0 +* +* Unless required by applicable law or agreed to in writing, software +* distributed under the License is distributed on an "AS IS" BASIS, +* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +* See the License for the specific language governing permissions and +* limitations under the License. +*/ + +/* This is a generated file. Do not edit directly. */ +'use strict'; + +// MAIN // + +/** +* Evaluates a polynomial. +* +* ## Notes +* +* - The implementation uses [Horner's rule][horners-method] for efficient computation. +* +* [horners-method]: https://en.wikipedia.org/wiki/Horner%27s_method +* +* @private +* @param {number} x - value at which to evaluate the polynomial +* @returns {number} evaluated polynomial +*/ +function evalpoly( x ) { + if ( x === 0.0 ) { + return 0.6931471805599453; + } + return 0.6931471805599453 + (x * (0.24022650718688965 + (x * 0.05550411343574524))); // eslint-disable-line max-len +} + + +// EXPORTS // + +module.exports = evalpoly; diff --git a/lib/node_modules/@stdlib/math/base/special/exp2f/lib/polyval_q.js b/lib/node_modules/@stdlib/math/base/special/exp2f/lib/polyval_q.js new file mode 100644 index 000000000000..2f29494eeb72 --- /dev/null +++ b/lib/node_modules/@stdlib/math/base/special/exp2f/lib/polyval_q.js @@ -0,0 +1,47 @@ +/** +* @license Apache-2.0 +* +* Copyright (c) 2026 The Stdlib Authors. +* +* Licensed under the Apache License, Version 2.0 (the "License"); +* you may not use this file except in compliance with the License. +* You may obtain a copy of the License at +* +* http://www.apache.org/licenses/LICENSE-2.0 +* +* Unless required by applicable law or agreed to in writing, software +* distributed under the License is distributed on an "AS IS" BASIS, +* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +* See the License for the specific language governing permissions and +* limitations under the License. +*/ + +/* This is a generated file. Do not edit directly. */ +'use strict'; + +// MAIN // + +/** +* Evaluates a polynomial. +* +* ## Notes +* +* - The implementation uses [Horner's rule][horners-method] for efficient computation. +* +* [horners-method]: https://en.wikipedia.org/wiki/Horner%27s_method +* +* @private +* @param {number} x - value at which to evaluate the polynomial +* @returns {number} evaluated polynomial +*/ +function evalpoly( x ) { + if ( x === 0.0 ) { + return 1.0; + } + return 1.0 + (x * (0.5 + (x * 0.041666666666666664))); +} + + +// EXPORTS // + +module.exports = evalpoly; diff --git a/lib/node_modules/@stdlib/math/base/special/exp2f/manifest.json b/lib/node_modules/@stdlib/math/base/special/exp2f/manifest.json new file mode 100644 index 000000000000..13a36410b49e --- /dev/null +++ b/lib/node_modules/@stdlib/math/base/special/exp2f/manifest.json @@ -0,0 +1,111 @@ +{ + "options": { + "task": "build", + "wasm": false + }, + "fields": [ + { + "field": "src", + "resolve": true, + "relative": true + }, + { + "field": "include", + "resolve": true, + "relative": true + }, + { + "field": "libraries", + "resolve": false, + "relative": false + }, + { + "field": "libpath", + "resolve": true, + "relative": false + } + ], + "confs": [ + { + "task": "build", + "wasm": false, + "src": [ + "./src/main.c" + ], + "include": [ + "./include" + ], + "libraries": [], + "libpath": [], + "dependencies": [ + "@stdlib/math/base/napi/unary", + "@stdlib/math/base/assert/is-nanf", + "@stdlib/constants/float32/max-base2-exponent", + "@stdlib/constants/float32/pinf", + "@stdlib/math/base/special/roundf", + "@stdlib/math/base/special/ldexpf", + "@stdlib/constants/float32/min-base2-exponent" + ] + }, + { + "task": "benchmark", + "wasm": false, + "src": [ + "./src/main.c" + ], + "include": [ + "./include" + ], + "libraries": [], + "libpath": [], + "dependencies": [ + "@stdlib/math/base/assert/is-nanf", + "@stdlib/constants/float32/max-base2-exponent", + "@stdlib/constants/float32/pinf", + "@stdlib/math/base/special/roundf", + "@stdlib/math/base/special/ldexpf", + "@stdlib/constants/float32/min-base2-exponent" + ] + }, + { + "task": "examples", + "wasm": false, + "src": [ + "./src/main.c" + ], + "include": [ + "./include" + ], + "libraries": [], + "libpath": [], + "dependencies": [ + "@stdlib/math/base/assert/is-nanf", + "@stdlib/constants/float32/max-base2-exponent", + "@stdlib/constants/float32/pinf", + "@stdlib/math/base/special/roundf", + "@stdlib/math/base/special/ldexpf", + "@stdlib/constants/float32/min-base2-exponent" + ] + }, + { + "task": "build", + "wasm": true, + "src": [ + "./src/main.c" + ], + "include": [ + "./include" + ], + "libraries": [], + "libpath": [], + "dependencies": [ + "@stdlib/math/base/assert/is-nanf", + "@stdlib/constants/float32/max-base2-exponent", + "@stdlib/constants/float32/pinf", + "@stdlib/math/base/special/roundf", + "@stdlib/math/base/special/ldexpf", + "@stdlib/constants/float32/min-base2-exponent" + ] + } + ] +} diff --git a/lib/node_modules/@stdlib/math/base/special/exp2f/package.json b/lib/node_modules/@stdlib/math/base/special/exp2f/package.json new file mode 100644 index 000000000000..95dd47f010d7 --- /dev/null +++ b/lib/node_modules/@stdlib/math/base/special/exp2f/package.json @@ -0,0 +1,149 @@ +{ + "name": "@stdlib/math/base/special/exp2f", + "version": "0.0.0", + "description": "Single-precision base 2 exponential function.", + "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", + "gypfile": true, + "directories": { + "benchmark": "./benchmark", + "doc": "./docs", + "example": "./examples", + "include": "./include", + "lib": "./lib", + "scripts": "./scripts", + "src": "./src", + "test": "./test" + }, + "types": "./docs/types", + "scripts": {}, + "homepage": "https://github.com/stdlib-js/stdlib", + "repository": { + "type": "git", + "url": "git://github.com/stdlib-js/stdlib.git" + }, + "bugs": { + "url": "https://github.com/stdlib-js/stdlib/issues" + }, + "dependencies": {}, + "devDependencies": {}, + "engines": { + "node": ">=0.10.0", + "npm": ">2.7.0" + }, + "os": [ + "aix", + "darwin", + "freebsd", + "linux", + "macos", + "openbsd", + "sunos", + "win32", + "windows" + ], + "keywords": [ + "stdlib", + "stdmath", + "mathematics", + "math", + "special", + "function", + "exp2f", + "exp2", + "base 2", + "single-precision", + "float32", + "exponential", + "power-of-two" + ], + "__stdlib__": { + "scaffold": { + "$schema": "math/base@v1.0", + "base_alias": "exp2f", + "alias": "exp2f", + "pkg_desc": "evaluate the base 2 exponential function for a single-precision floating-point number", + "desc": "evaluates the base 2 exponential function for a single-precision floating-point number", + "short_desc": "base 2 exponential function (single-precision)", + "parameters": [ + { + "name": "x", + "desc": "input value", + "type": { + "javascript": "number", + "jsdoc": "number", + "c": "float", + "dtype": "float32" + }, + "domain": [ + { + "min": "-infinity", + "max": "infinity" + } + ], + "rand": { + "prng": "random/base/uniform", + "parameters": [ + -5, + 5 + ] + }, + "example_values": [ + -4.62, + 3.17, + -2.41, + 1.28, + -0.73, + 2.56, + -3.09, + 0.41, + 4.12, + -1.85, + 2.93, + -4.37, + 1.67, + -0.28, + 3.74, + -2.96, + 0.83, + -1.12, + 4.89, + -3.51 + ] + } + ], + "output_policy": "real_floating_point_and_generic", + "returns": { + "desc": "function value", + "type": { + "javascript": "number", + "jsdoc": "number", + "c": "float", + "dtype": "float32" + } + }, + "keywords": [ + "exp2f", + "exp2", + "base 2", + "single-precision", + "float32", + "exponential", + "power-of-two" + ], + "extra_keywords": [ + "math.exp2" + ] + } + } +} diff --git a/lib/node_modules/@stdlib/math/base/special/exp2f/scripts/evalpoly.js b/lib/node_modules/@stdlib/math/base/special/exp2f/scripts/evalpoly.js new file mode 100644 index 000000000000..11b92033ed51 --- /dev/null +++ b/lib/node_modules/@stdlib/math/base/special/exp2f/scripts/evalpoly.js @@ -0,0 +1,132 @@ +/** +* @license Apache-2.0 +* +* Copyright (c) 2026 The Stdlib Authors. +* +* Licensed under the Apache License, Version 2.0 (the "License"); +* you may not use this file except in compliance with the License. +* You may obtain a copy of the License at +* +* http://www.apache.org/licenses/LICENSE-2.0 +* +* Unless required by applicable law or agreed to in writing, software +* distributed under the License is distributed on an "AS IS" BASIS, +* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +* See the License for the specific language governing permissions and +* limitations under the License. +*/ + +/* +* This script compiles modules for evaluating polynomial functions for exp2f (single-precision). If any polynomial coefficients change, this script should be rerun to update the compiled files. +*/ +'use strict'; + +// MODULES // + +var resolve = require( 'path' ).resolve; +var readFileSync = require( '@stdlib/fs/read-file' ).sync; +var writeFileSync = require( '@stdlib/fs/write-file' ).sync; +var currentYear = require( '@stdlib/time/current-year' ); +var substringBefore = require( '@stdlib/string/substring-before' ); +var substringAfter = require( '@stdlib/string/substring-after' ); +var format = require( '@stdlib/string/format' ); +var licenseHeader = require( '@stdlib/_tools/licenses/header' ); +var compile = require( '@stdlib/math/base/tools/evalpoly-compile' ); +var compileC = require( '@stdlib/math/base/tools/evalpoly-compile-c' ); + + +// VARIABLES // + +// Polynomial coefficients ordered in ascending degree (single-precision tuned)... +var P = [ + 0.6931471805599453, + 0.24022650718688965, + 0.05550411343574524 +]; +var Q = [ + 1.0, + 0.5, + 0.041666666666666664 +]; + +// Header to add to output files: +var header = licenseHeader( 'Apache-2.0', 'js', { + 'year': currentYear(), + 'copyright': 'The Stdlib Authors' +}); +header += '\n/* This is a generated file. Do not edit directly. */\n'; + + +// FUNCTIONS // + +/** +* Inserts a compiled function into file content. +* +* @private +* @param {string} text - source content +* @param {string} id - function identifier +* @param {string} str - function string +* @returns {string} updated content +*/ +function insert( text, id, str ) { + var before; + var after; + var begin; + var end; + + begin = '// BEGIN: '+id; + end = '// END: '+id; + + before = substringBefore( text, begin ); + after = substringAfter( text, end ); + + return format( '%s// BEGIN: %s\n\n%s\n%s%s', before, id, str, end, after ); +} + + +// MAIN // + +/** +* Main execution sequence. +* +* @private +*/ +function main() { + var fpath; + var copts; + var opts; + var file; + var str; + + opts = { + 'encoding': 'utf8' + }; + + fpath = resolve( __dirname, '..', 'lib', 'polyval_p.js' ); + str = header + compile( P ); + writeFileSync( fpath, str, opts ); + + fpath = resolve( __dirname, '..', 'lib', 'polyval_q.js' ); + str = header + compile( Q ); + writeFileSync( fpath, str, opts ); + + copts = { + 'dtype': 'float', + 'name': '' + }; + + fpath = resolve( __dirname, '..', 'src', 'main.c' ); + file = readFileSync( fpath, opts ); + + copts.name = 'polyval_p'; + str = compileC( P, copts ); + file = insert( file, copts.name, str ); + + copts.name = 'polyval_q'; + str = compileC( Q, copts ); + file = insert( file, copts.name, str ); + + writeFileSync( fpath, file, opts ); +} + +main(); diff --git a/lib/node_modules/@stdlib/math/base/special/exp2f/src/Makefile b/lib/node_modules/@stdlib/math/base/special/exp2f/src/Makefile new file mode 100644 index 000000000000..2caf905cedbe --- /dev/null +++ b/lib/node_modules/@stdlib/math/base/special/exp2f/src/Makefile @@ -0,0 +1,70 @@ +#/ +# @license Apache-2.0 +# +# Copyright (c) 2026 The Stdlib Authors. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +#/ + +# VARIABLES # + +ifndef VERBOSE + QUIET := @ +else + QUIET := +endif + +# Determine the OS ([1][1], [2][2]). +# +# [1]: https://en.wikipedia.org/wiki/Uname#Examples +# [2]: http://stackoverflow.com/a/27776822/2225624 +OS ?= $(shell uname) +ifneq (, $(findstring MINGW,$(OS))) + OS := WINNT +else +ifneq (, $(findstring MSYS,$(OS))) + OS := WINNT +else +ifneq (, $(findstring CYGWIN,$(OS))) + OS := WINNT +else +ifneq (, $(findstring Windows_NT,$(OS))) + OS := WINNT +endif +endif +endif +endif + + +# RULES # + +#/ +# Removes generated files for building an add-on. +# +# @example +# make clean-addon +#/ +clean-addon: + $(QUIET) -rm -f *.o *.node + +.PHONY: clean-addon + +#/ +# Removes generated files. +# +# @example +# make clean +#/ +clean: clean-addon + +.PHONY: clean diff --git a/lib/node_modules/@stdlib/math/base/special/exp2f/src/addon.c b/lib/node_modules/@stdlib/math/base/special/exp2f/src/addon.c new file mode 100644 index 000000000000..92e80855030a --- /dev/null +++ b/lib/node_modules/@stdlib/math/base/special/exp2f/src/addon.c @@ -0,0 +1,22 @@ +/** +* @license Apache-2.0 +* +* Copyright (c) 2026 The Stdlib Authors. +* +* Licensed under the Apache License, Version 2.0 (the "License"); +* you may not use this file except in compliance with the License. +* You may obtain a copy of the License at +* +* http://www.apache.org/licenses/LICENSE-2.0 +* +* Unless required by applicable law or agreed to in writing, software +* distributed under the License is distributed on an "AS IS" BASIS, +* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +* See the License for the specific language governing permissions and +* limitations under the License. +*/ + +#include "stdlib/math/base/napi/unary.h" +#include "stdlib/math/base/special/exp2f.h" + +STDLIB_MATH_BASE_NAPI_MODULE_F_F( stdlib_base_exp2f ) diff --git a/lib/node_modules/@stdlib/math/base/special/exp2f/src/main.c b/lib/node_modules/@stdlib/math/base/special/exp2f/src/main.c new file mode 100644 index 000000000000..80d8d902b90e --- /dev/null +++ b/lib/node_modules/@stdlib/math/base/special/exp2f/src/main.c @@ -0,0 +1,131 @@ +/** +* @license Apache-2.0 +* +* Copyright (c) 2026 The Stdlib Authors. +* +* Licensed under the Apache License, Version 2.0 (the "License"); +* you may not use this file except in compliance with the License. +* You may obtain a copy of the License at +* +* http://www.apache.org/licenses/LICENSE-2.0 +* +* Unless required by applicable law or agreed to in writing, software +* distributed under the License is distributed on an "AS IS" BASIS, +* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +* See the License for the specific language governing permissions and +* limitations under the License. +*/ + +#include "stdlib/math/base/special/exp2f.h" +#include "stdlib/constants/float32/max_base2_exponent.h" +#include "stdlib/constants/float32/min_base2_exponent.h" +#include "stdlib/math/base/special/roundf.h" +#include "stdlib/math/base/special/ldexpf.h" +#include "stdlib/math/base/assert/is_nanf.h" +#include "stdlib/constants/float32/pinf.h" + +/* Begin auto-generated functions. The following functions are auto-generated. Do not edit directly. */ + +// BEGIN: polyval_p + +/** +* Evaluates a polynomial. +* +* ## Notes +* +* - The implementation uses [Horner's rule][horners-method] for efficient computation. +* +* [horners-method]: https://en.wikipedia.org/wiki/Horner%27s_method +* +* @param x value at which to evaluate the polynomial +* @return evaluated polynomial +*/ +static float polyval_p( const float x ) { + return 0.6931471805599453f + (x * (0.24022650718688965f + (x * 0.05550411343574524f))); +} + +// END: polyval_p + +// BEGIN: polyval_q + +/** +* Evaluates a polynomial. +* +* ## Notes +* +* - The implementation uses [Horner's rule][horners-method] for efficient computation. +* +* [horners-method]: https://en.wikipedia.org/wiki/Horner%27s_method +* +* @param x value at which to evaluate the polynomial +* @return evaluated polynomial +*/ +static float polyval_q( const float x ) { + return 1.0f + (x * (0.5f + (x * 0.041666666666666664f))); +} + +// END: polyval_q + +/* End auto-generated functions. */ + +/** +* Evaluates the base `2` exponential function (single-precision). +* +* ## Method +* +* - Range reduction is accomplished by separating the argument into an integer \\( k \\) and fraction \\( f \\) such that +* +* ```tex +* 2^x = 2^k 2^f +* ``` +* +* - A Pade' approximate +* +* ```tex +* 1 + 2x \frac{\mathrm{P}\left(x^2\right)}{\mathrm{Q}\left(x^2\right) - x \mathrm{P}\left(x^2\right)} +* ``` +* +* approximates \\( 2^x \\) in the basic range \\( \[-0.5, 0.5] \\). +* +* ## Notes +* +* - Relative error: +* +* | arithmetic | domain | # trials | peak | rms | +* |:----------:|:-----------:|:--------:|:-------:|:-------:| +* | IEEE | -127,+128 | 30000 | ~1 ulp | ~0.5 ulp| +* +* @param x input value +* @return function value +* +* @example +* float out = stdlib_base_exp2f( 3.0f ); +* // returns ~5.657f +*/ +float stdlib_base_exp2f( const float x ) { + float px; + float ax; + float xx; + float n; + + if ( stdlib_base_is_nanf( x ) ) { + return x; + } + if ( x > STDLIB_CONSTANT_FLOAT32_MAX_BASE2_EXPONENT ) { + return STDLIB_CONSTANT_FLOAT32_PINF; + } + if ( x < STDLIB_CONSTANT_FLOAT32_MIN_BASE2_EXPONENT ) { + return 0.0f; + } + + // Separate into integer and fractional parts... + n = stdlib_base_roundf( x ); + ax = x - n; + xx = ax * ax; + px = ax * polyval_p( xx ); + ax = px / ( polyval_q( xx ) - px ); + ax = 1.0f + stdlib_base_ldexpf( ax, 1 ); + + // Scale by power of 2: + return stdlib_base_ldexpf( ax, n ); +} diff --git a/lib/node_modules/@stdlib/math/base/special/exp2f/test/fixtures/julia/REQUIRE b/lib/node_modules/@stdlib/math/base/special/exp2f/test/fixtures/julia/REQUIRE new file mode 100644 index 000000000000..308c3be89c85 --- /dev/null +++ b/lib/node_modules/@stdlib/math/base/special/exp2f/test/fixtures/julia/REQUIRE @@ -0,0 +1,2 @@ +julia 1.5 +JSON 0.21 diff --git a/lib/node_modules/@stdlib/math/base/special/exp2f/test/fixtures/julia/medium_negative.json b/lib/node_modules/@stdlib/math/base/special/exp2f/test/fixtures/julia/medium_negative.json new file mode 100644 index 000000000000..0ea6bc0a58c2 --- /dev/null +++ b/lib/node_modules/@stdlib/math/base/special/exp2f/test/fixtures/julia/medium_negative.json @@ -0,0 +1 @@ +{"expected":[1.1754944e-38,1.3969382e-38,1.6601071e-38,1.972844e-38,2.3445078e-38,2.7861746e-38,3.3110614e-38,3.934811e-38,4.6760895e-38,5.556988e-38,6.603868e-38,7.847928e-38,9.3263487e-38,1.1083338e-37,1.3171256e-37,1.5652588e-37,1.8601278e-37,2.2105568e-37,2.6269896e-37,3.1218876e-37,3.71e-37,4.408903e-37,5.2394953e-37,6.22653e-37,7.399545e-37,8.793498e-37,1.0450104e-36,1.2418731e-36,1.4758294e-36,1.7538513e-36,2.0842591e-36,2.4768993e-36,2.9435065e-36,3.498033e-36,4.157005e-36,4.9401427e-36,5.8707843e-36,6.976781e-36,8.291091e-36,9.853048e-36,1.1709201e-35,1.3915022e-35,1.653647e-35,1.965167e-35,2.3353844e-35,2.7753324e-35,3.2981769e-35,3.9194994e-35,4.6578932e-35,5.535364e-35,6.5781697e-35,7.8173887e-35,9.2900564e-35,1.1040209e-34,1.3120002e-34,1.5591678e-34,1.8528894e-34,2.2019548e-34,2.616767e-34,3.1097393e-34,3.695563e-34,4.3917465e-34,5.2191068e-34,6.202301e-34,7.370751e-34,8.75928e-34,1.0409439e-33,1.2370406e-33,1.4700865e-33,1.7470265e-33,2.0761486e-33,2.4672609e-33,2.9320523e-33,3.4844213e-33,4.1408287e-33,4.9209187e-33,5.847939e-33,6.949631e-33,8.258828e-33,9.814707e-33,1.1663636e-32,1.3860874e-32,1.6472122e-32,1.9575197e-32,2.3262967e-32,2.7645326e-32,3.2853427e-32,3.904247e-32,4.6397676e-32,5.513824e-32,6.5525717e-32,7.786969e-32,9.2539053e-32,1.0997247e-31,1.3068948e-31,1.5531005e-31,1.8456791e-31,2.1933862e-31,2.6065842e-31,3.0976383e-31,3.6811823e-31,4.3746563e-31,5.1987973e-31,6.178165e-31,7.342069e-31,8.725194e-31,1.0368932e-30,1.2322268e-30,1.4643658e-30,1.7402284e-30,2.0680696e-30,2.4576598e-30,2.9206427e-30,3.470862e-30,4.1247153e-30,4.9017697e-30,5.8251828e-30,6.922588e-30,8.2266895e-30,9.776515e-30,1.1618249e-29,1.3806936e-29,1.6408023e-29,1.9499024e-29,2.3172443e-29,2.753775e-29,3.2725582e-29,3.8890544e-29,4.6217128e-29,5.4923676e-29,6.5270735e-29,7.756667e-29,9.2178955e-29,1.0954454e-28,1.3018092e-28,1.5470568e-28,1.8384969e-28,2.184851e-28,2.596441e-28,3.0855841e-28,3.6668575e-28,4.357633e-28,5.178567e-28,6.154124e-28,7.3134984e-28,8.691241e-28,1.0328583e-27,1.2274318e-27,1.4586675e-27,1.7334564e-27,2.060022e-27,2.4480964e-27,2.9092774e-27,3.457356e-27,4.1086645e-27,4.8826954e-27,5.802515e-27,6.89565e-27,8.194677e-27,9.738471e-27,1.15730386e-26,1.3753209e-26,1.6344173e-26,1.9423147e-26,2.308227e-26,2.7430592e-26,3.2598235e-26,3.8739206e-26,4.6037278e-26,5.4709944e-26,6.5016745e-26,7.7264833e-26,9.1820254e-26,1.0911826e-25,1.2967434e-25,1.5410367e-25,1.8313427e-25,2.1763492e-25,2.5863374e-25,3.073577e-25,3.6525884e-25,4.340676e-25,5.158415e-25,6.130176e-25,7.285039e-25,8.65742e-25,1.0288391e-24,1.2226554e-24,1.4529913e-24,1.726711e-24,2.0520057e-24,2.4385698e-24,2.8979563e-24,3.443902e-24,4.0926762e-24,4.863695e-24,5.7799353e-24,6.868816e-24,8.162789e-24,9.7005744e-24,1.1528004e-23,1.369969e-23,1.6280573e-23,1.9347565e-23,2.2992449e-23,2.7323848e-23,3.2471383e-23,3.858846e-23,4.585813e-23,5.449705e-23,6.476374e-23,7.6964167e-23,9.146295e-23,1.0869364e-22,1.2916974e-22,1.53504e-22,1.8242162e-22,2.1678801e-22,2.576273e-22,3.0616166e-22,3.638375e-22,4.323785e-22,5.138342e-22,6.106321e-22,7.2566903e-22,8.623731e-22,1.0248355e-21,1.2178976e-21,1.4473372e-21,1.7199916e-21,2.0440206e-21,2.4290805e-21,2.8866794e-21,3.4305006e-21,4.0767504e-21,4.8447686e-21,5.7574436e-21,6.8420874e-21,8.131024e-21,9.662827e-21,1.1483144e-20,1.364638e-20,1.6217218e-20,1.9272276e-20,2.2902977e-20,2.7217522e-20,3.2345027e-20,3.8438298e-20,4.5679683e-20,5.428498e-20,6.451155e-20,7.666467e-20,9.1107275e-20,1.0827067e-19,1.2866743e-19,1.5290666e-19,1.8171225e-19,2.1594384e-19,2.566248e-19,3.049695e-19,3.624217e-19,4.306971e-19,5.118347e-19,6.0825754e-19,7.2284517e-19,8.590196e-19,1.0208475e-18,1.2131584e-18,1.4417013e-18,1.7132987e-18,2.0360612e-18,2.4196282e-18,2.875454e-18,3.4171511e-18,4.0608972e-18,4.825916e-18,5.7350545e-18,6.8154442e-18,8.099384e-18,9.625199e-18,1.14384595e-17,1.3593313e-17,1.6154113e-17,1.9197332e-17,2.2813855e-17,2.711168e-17,3.221916e-17,3.828872e-17,4.5501806e-17,5.4073743e-17,6.426051e-17,7.636634e-17,9.0752744e-17,1.0784936e-16,1.2816674e-16,1.5231165e-16,1.8100513e-16,2.1510353e-16,2.5562618e-16,3.0378275e-16,3.6101137e-16,4.290211e-16,5.09843e-16,6.058906e-16,7.200324e-16,8.5567687e-16,1.016875e-15,1.2084376e-15,1.4360911e-15,1.7066315e-15,2.0281382e-15,2.4102126e-15,2.8642646e-15,3.4038538e-15,4.0450948e-15,4.807137e-15,5.7127375e-15,6.788923e-15,8.067866e-15,9.587745e-15,1.1393948e-14,1.3540416e-14,1.6091251e-14,1.9122628e-14,2.2725077e-14,2.700618e-14,3.2093784e-14,3.8139725e-14,4.5324743e-14,5.3863323e-14,6.4010456e-14,7.6069176e-14,9.03996e-14,1.07429677e-13,1.27668e-13,1.5171894e-13,1.8030079e-13,2.1426648e-13,2.5463144e-13,3.026006e-13,3.5960655e-13,4.2735165e-13,5.07859e-13,6.035329e-13,7.172305e-13,8.5234716e-13,1.012918e-12,1.2037351e-12,1.4305027e-12,1.6999905e-12,2.0202462e-12,2.4008337e-12,2.8531188e-12,3.3906083e-12,4.0293537e-12,4.7884305e-12,5.690507e-12,6.762505e-12,8.036471e-12,9.550435e-12,1.13496105e-11,1.3487726e-11,1.6028633e-11,1.9048216e-11,2.2636646e-11,2.6901089e-11,3.1968896e-11,3.799131e-11,4.5148368e-11,5.365372e-11,6.376137e-11,7.5773166e-11,9.0047816e-11,1.0701163e-10,1.2717119e-10,1.5112855e-10,1.7959917e-10,2.134327e-10,2.536409e-10,3.014235e-10,3.582072e-10,4.2568865e-10,5.058827e-10,6.011843e-10,7.1443945e-10,8.4902924e-10,1.008975e-9,1.1990525e-9,1.4249381e-9,1.6933774e-9,2.0123845e-9,2.391491e-9,2.8420162e-9,3.3774141e-9,4.0136743e-9,4.769791e-9,5.668356e-9,6.7361987e-9,8.005209e-9,9.5132835e-9,1.1305445e-8,1.34352405e-8,1.5966261e-8,1.8974092e-8,2.2548559e-8,2.6796371e-8,3.184445e-8,3.7843524e-8,4.497274e-8,5.3445007e-8,6.351325e-8,7.5478304e-8,8.969741e-8,1.0659521e-7,1.2667633e-7,1.5054026e-7,1.7890005e-7,2.1260244e-7,2.526539e-7,3.0025055e-7,3.5681327e-7,4.2403215e-7,5.039142e-7,5.988449e-7,7.116593e-7,8.4572537e-7,1.0050487e-6,1.1943866e-6,1.4193931e-6,1.686788e-6,2.0045536e-6,2.382185e-6,2.8309569e-6,3.3642716e-6,3.9980555e-6,4.75123e-6,5.646298e-6,6.709986e-6,7.974058e-6,9.4762645e-6,1.1261452e-5,1.3382959e-5,1.590413e-5,1.8900257e-5,2.24608e-5,2.6692116e-5,3.1720534e-5,3.769626e-5,4.4797736e-5,5.3236996e-5,6.326614e-5,7.518459e-5,8.934837e-5,0.000106180414,0.00012618331,0.00014995456,0.00017820389,0.00021177513,0.00025167075,0.00029908196,0.00035542503,0.00042238212,0.0005019533,0.0005965146,0.0007088895,0.0008424349,0.0010011378,0.0011897389,0.0014138698,0.0016802229,0.0019967547,0.0023729152,0.0028199407,0.0033511799,0.003982495,0.0047327443,0.0056243283,0.006683875,0.007943026,0.009439383,0.011217637,0.013330886,0.015842242,0.018826704,0.022373397,0.026588248,0.031597108,0.03754957,0.044623397,0.053029835,0.06301994,0.074892044,0.08900068,0.10576719,0.12569231,0.14937101,0.1775105,0.21095103,0.25069135,0.2979182,0.3540419,0.42073858,0.5],"x":[-126.0,-125.751,-125.50199,-125.25299,-125.00398,-124.75498,-124.505974,-124.25697,-124.007965,-123.758965,-123.50996,-123.260956,-123.011955,-122.76295,-122.51395,-122.26494,-122.01594,-121.76693,-121.51793,-121.26892,-121.01992,-120.77092,-120.52191,-120.27291,-120.0239,-119.7749,-119.525894,-119.27689,-119.027885,-118.778885,-118.52988,-118.280876,-118.031876,-117.78287,-117.53387,-117.28486,-117.03586,-116.78685,-116.53785,-116.28884,-116.03984,-115.79084,-115.54183,-115.29283,-115.04382,-114.79482,-114.545815,-114.296814,-114.047806,-113.798805,-113.5498,-113.3008,-113.051796,-112.80279,-112.55379,-112.30478,-112.05578,-111.80677,-111.55777,-111.30876,-111.05976,-110.81076,-110.56175,-110.31275,-110.06374,-109.81474,-109.565735,-109.316734,-109.067726,-108.818726,-108.56972,-108.32072,-108.07172,-107.82271,-107.57371,-107.3247,-107.0757,-106.82669,-106.57769,-106.32868,-106.07968,-105.83068,-105.58167,-105.33267,-105.083664,-104.83466,-104.585655,-104.336655,-104.08765,-103.838646,-103.58964,-103.34064,-103.09164,-102.84263,-102.59363,-102.34462,-102.09562,-101.84661,-101.59761,-101.3486,-101.0996,-100.8506,-100.60159,-100.35259,-100.103584,-99.85458,-99.605576,-99.356575,-99.10757,-98.85857,-98.60956,-98.36056,-98.11156,-97.86255,-97.61355,-97.36454,-97.11554,-96.86653,-96.61753,-96.36852,-96.11952,-95.87052,-95.62151,-95.37251,-95.123505,-94.874504,-94.625496,-94.376495,-94.12749,-93.87849,-93.62948,-93.38048,-93.13148,-92.88247,-92.63347,-92.38446,-92.13546,-91.88645,-91.63745,-91.38844,-91.13944,-90.89044,-90.64143,-90.39243,-90.143425,-89.894424,-89.64542,-89.396416,-89.14741,-88.89841,-88.6494,-88.4004,-88.1514,-87.90239,-87.65339,-87.40438,-87.15538,-86.90637,-86.65737,-86.40836,-86.15936,-85.91036,-85.661354,-85.41235,-85.163345,-84.914345,-84.66534,-84.416336,-84.16733,-83.91833,-83.66932,-83.42032,-83.17132,-82.92231,-82.67331,-82.4243,-82.1753,-81.92629,-81.67729,-81.42828,-81.17928,-80.93028,-80.681274,-80.432274,-80.183266,-79.934265,-79.68526,-79.43626,-79.18725,-78.93825,-78.68924,-78.44024,-78.19124,-77.94223,-77.69323,-77.44422,-77.19522,-76.94621,-76.69721,-76.448204,-76.1992,-75.9502,-75.701195,-75.452194,-75.203186,-74.954185,-74.70518,-74.45618,-74.20717,-73.95817,-73.70916,-73.46016,-73.21116,-72.96215,-72.71315,-72.46414,-72.21514,-71.96613,-71.71713,-71.468124,-71.219124,-70.97012,-70.721115,-70.472115,-70.22311,-69.974106,-69.7251,-69.4761,-69.22709,-68.97809,-68.72908,-68.48008,-68.23108,-67.98207,-67.73307,-67.48406,-67.23506,-66.98605,-66.73705,-66.488045,-66.239044,-65.99004,-65.741035,-65.492035,-65.24303,-64.994026,-64.74502,-64.49602,-64.24701,-63.99801,-63.749004,-63.5,-63.250996,-63.00199,-62.752987,-62.503983,-62.25498,-62.005978,-61.756973,-61.50797,-61.258965,-61.00996,-60.760956,-60.51195,-60.262947,-60.013943,-59.76494,-59.515938,-59.266933,-59.01793,-58.768925,-58.51992,-58.270916,-58.02191,-57.772907,-57.523903,-57.2749,-57.025898,-56.776894,-56.52789,-56.278885,-56.02988,-55.780876,-55.53187,-55.282867,-55.033863,-54.78486,-54.53586,-54.286854,-54.03785,-53.788845,-53.53984,-53.290836,-53.041832,-52.792828,-52.543823,-52.29482,-52.04582,-51.796814,-51.54781,-51.298805,-51.0498,-50.800797,-50.551792,-50.302788,-50.053783,-49.80478,-49.55578,-49.306774,-49.05777,-48.808765,-48.55976,-48.310757,-48.061752,-47.812748,-47.563744,-47.31474,-47.06574,-46.816734,-46.56773,-46.318726,-46.06972,-45.820717,-45.571712,-45.32271,-45.073704,-44.8247,-44.5757,-44.326694,-44.07769,-43.828686,-43.57968,-43.330677,-43.081673,-42.83267,-42.583664,-42.33466,-42.08566,-41.836655,-41.58765,-41.338646,-41.08964,-40.840637,-40.591633,-40.34263,-40.093624,-39.84462,-39.59562,-39.346615,-39.09761,-38.848606,-38.5996,-38.350597,-38.101593,-37.85259,-37.603584,-37.35458,-37.10558,-36.856575,-36.60757,-36.358566,-36.109562,-35.860558,-35.611553,-35.36255,-35.113544,-34.86454,-34.61554,-34.366535,-34.11753,-33.868526,-33.619522,-33.370518,-33.121513,-32.87251,-32.623505,-32.3745,-32.1255,-31.876493,-31.62749,-31.378487,-31.129482,-30.880478,-30.631474,-30.38247,-30.133467,-29.884462,-29.635458,-29.386454,-29.13745,-28.888447,-28.639442,-28.390438,-28.141434,-27.89243,-27.643427,-27.394423,-27.145418,-26.896414,-26.64741,-26.398407,-26.149403,-25.900398,-25.651394,-25.40239,-25.153387,-24.904383,-24.655378,-24.406374,-24.15737,-23.908367,-23.659363,-23.410358,-23.161354,-22.91235,-22.663347,-22.414343,-22.165339,-21.916334,-21.66733,-21.418327,-21.169323,-20.920319,-20.671314,-20.42231,-20.173307,-19.924303,-19.675299,-19.426294,-19.17729,-18.928288,-18.679283,-18.430279,-18.181274,-17.93227,-17.683268,-17.434263,-17.185259,-16.936255,-16.68725,-16.438248,-16.189243,-15.940239,-15.691235,-15.442231,-15.193227,-14.944223,-14.695219,-14.446215,-14.197211,-13.948207,-13.6992035,-13.450199,-13.201195,-12.952191,-12.703187,-12.454184,-12.205179,-11.956175,-11.707171,-11.458167,-11.209164,-10.960159,-10.711155,-10.462152,-10.213147,-9.964144,-9.715139,-9.466135,-9.217132,-8.968127,-8.719124,-8.470119,-8.221115,-7.9721117,-7.7231073,-7.4741035,-7.2250996,-6.9760957,-6.727092,-6.4780874,-6.2290835,-5.9800797,-5.731076,-5.482072,-5.2330675,-4.9840636,-4.7350597,-4.486056,-4.237052,-3.9880478,-3.7390437,-3.4900398,-3.241036,-2.9920318,-2.743028,-2.4940238,-2.24502,-1.9960159,-1.7470119,-1.498008,-1.249004,-1.0]} diff --git a/lib/node_modules/@stdlib/math/base/special/exp2f/test/fixtures/julia/medium_positive.json b/lib/node_modules/@stdlib/math/base/special/exp2f/test/fixtures/julia/medium_positive.json new file mode 100644 index 000000000000..6a9c99c43214 --- /dev/null +++ b/lib/node_modules/@stdlib/math/base/special/exp2f/test/fixtures/julia/medium_positive.json @@ -0,0 +1 @@ +{"expected":[2.0,2.3800569,2.8323352,3.3705595,4.011061,4.7732773,5.680336,6.7597604,8.044308,9.572953,11.392087,13.556909,16.133106,19.19885,22.84718,27.188793,32.35544,38.503895,45.820717,54.527958,64.889824,77.22074,91.89488,109.35749,130.13853,154.86856,184.29799,219.31985,260.9968,310.59372,369.61526,439.85254,523.43726,622.905,741.27496,882.138,1049.769,1249.2555,1486.649,1769.1554,2105.3447,2505.4192,2981.5212,3548.094,4222.3345,5024.697,5979.5303,7115.8135,8468.019,10077.187,11992.135,14270.978,16982.875,20210.098,24050.602,28620.89,34059.664,40531.984,48234.2,57400.09,68307.72,81288.11,96735.13,115117.68,136993.27,163025.84,194005.33,230871.8,274744.28,326953.4,389083.75,463020.6,551007.5,655715.3,780319.6,928602.3,1.1050628e6,1.3150558e6,1.5649554e6,1.8623409e6,2.216238e6,2.6373855e6,3.1385628e6,3.734983e6,4.4447345e6,5.289359e6,6.294486e6,7.490615e6,8.914054e6,1.0607975e7,1.2623788e7,1.5022663e7,1.787739e7,2.1274626e7,2.5317402e7,3.012842e7,3.5853664e7,4.2666868e7,5.077484e7,6.042349e7,7.190565e7,8.556974e7,1.0183039e8,1.2118119e8,1.4420902e8,1.7161278e8,2.0422405e8,2.4303235e8,2.892157e8,3.4417482e8,4.095777e8,4.8740896e8,5.8003034e8,6.902533e8,8.2142086e8,9.775139e8,1.163269e9,1.3843228e9,1.6473852e9,1.9604347e9,2.3329723e9,2.7763028e9,3.3038781e9,3.931713e9,4.678843e9,5.5679544e9,6.62604e9,7.885174e9,9.383578e9,1.1166722e10,1.3288712e10,1.5813941e10,1.8819035e10,2.239518e10,2.6650892e10,3.1715312e10,3.774221e10,4.491429e10,5.344927e10,6.3606133e10,7.569308e10,9.00769e10,1.0719404e11,1.27563915e11,1.5180464e11,1.806518e11,2.1498128e11,2.5583377e11,3.0444936e11,3.623033e11,4.3115112e11,5.1308193e11,6.1058194e11,7.266096e11,8.6468585e11,1.02900046e12,1.2245428e12,1.4572403e12,1.7341569e12,2.0636953e12,2.4558554e12,2.922537e12,3.4779011e12,4.1388e12,4.9252883e12,5.8612316e12,6.975049e12,8.300504e12,9.877833e12,1.1754899e13,1.398866e13,1.6646898e13,1.9810277e13,2.3574786e13,2.8054657e13,3.338583e13,3.973018e13,4.728003e13,5.6264567e13,6.6956414e13,7.9680015e13,9.482145e13,1.128402e14,1.3428301e14,1.5980055e14,1.9016714e14,2.2630485e14,2.6930911e14,3.2048543e14,3.8138665e14,4.5386084e14,5.4010714e14,6.4274266e14,7.648819e14,9.102309e14,1.08320035e15,1.2890422e15,1.5339964e15,1.825499e15,2.172395e15,2.5852111e15,3.0764738e15,3.6610903e15,4.3568003e15,5.184715e15,6.169956e15,7.3424404e15,8.7377105e15,1.0398121e16,1.2374056e16,1.4725475e16,1.7523729e16,2.0853728e16,2.4816523e16,2.953236e16,3.5144339e16,4.1822863e16,4.977038e16,5.9228153e16,7.048316e16,8.387695e16,9.9815925e16,1.18783754e17,1.41356e17,1.6821762e17,2.0018368e17,2.3822485e17,2.8349425e17,3.3736614e17,4.0147516e17,4.7776673e17,5.6855585e17,6.765974e17,8.0516996e17,9.5817484e17,1.140255e18,1.356939e18,1.6147956e18,1.921652e18,2.2868201e18,2.72138e18,3.238519e18,3.8539284e18,4.586283e18,5.457806e18,6.494942e18,7.729184e18,9.1979464e18,1.0945814e19,1.3025826e19,1.55011e19,1.8446744e19,2.1952203e19,2.6123668e19,3.108798e19,3.6995474e19,4.402577e19,5.2391764e19,6.2347833e19,7.419548e19,8.8294935e19,1.0507318e20,1.2504037e20,1.4880194e20,1.7707802e20,2.1072837e20,2.5077204e20,2.9842656e20,3.5513504e20,4.226218e20,5.0293048e20,5.98503e20,7.1223724e20,8.475801e20,1.0086468e21,1.2003149e21,1.4284122e21,1.6998461e21,2.02287e21,2.4072658e21,2.8647214e21,3.40909e21,4.0569236e21,4.827866e21,5.745281e21,6.837064e21,8.136276e21,9.682423e21,1.1522326e22,1.3711927e22,1.6317536e22,1.9418378e22,2.3108474e22,2.7499662e22,3.2725456e22,3.894411e22,4.6344706e22,5.515136e22,6.563184e22,7.810352e22,9.294564e22,1.1060762e23,1.31626535e23,1.5663968e23,1.8640514e23,2.2182793e23,2.6398078e23,3.141454e23,3.738408e23,4.4488225e23,5.2942098e23,6.300275e23,7.497524e23,8.922241e23,1.06177456e24,1.2635383e24,1.50365e24,1.789381e24,2.1294192e24,2.534062e24,3.015613e24,3.5886547e24,4.2706112e24,5.082161e24,6.047898e24,7.1971874e24,8.564833e24,1.0192419e25,1.2129232e25,1.4434166e25,1.7177018e25,2.0441188e25,2.4325652e25,2.8948132e25,3.4449182e25,4.0995385e25,4.878579e25,5.805631e25,6.908882e25,8.221742e25,9.78413e25,1.1643359e26,1.3855961e26,1.6489026e26,1.9622353e26,2.3351213e26,2.7788526e26,3.3069212e26,3.9353188e26,4.6831524e26,5.5730683e26,6.6321254e26,7.8924365e26,9.392196e26,1.1177007e27,1.3300917e27,1.5828508e27,1.8836319e27,2.2415808e27,2.667537e27,3.1744524e27,3.7776774e27,4.4955542e27,5.34985e27,6.366455e27,7.57628e27,9.015963e27,1.0729277e28,1.2768108e28,1.5194447e28,1.8081771e28,2.1517871e28,2.560694e28,3.0472897e28,3.6263702e28,4.315471e28,5.135545e28,6.111427e28,7.272789e28,8.6548e28,1.0299483e29,1.2256642e29,1.4585786e29,1.7357542e29,2.0655907e29,2.4581176e29,2.9252212e29,3.4811045e29,4.142601e29,4.929825e29,5.8666148e29,6.9814544e29,8.308149e29,9.886905e29,1.17657255e30,1.4001507e30,1.6662232e30,1.982847e30,2.35965e30,2.8080424e30,3.341658e30,3.9766566e30,4.7323456e30,5.631639e30,6.701791e30,7.9753405e30,9.490854e30,1.1294414e31,1.3440633e31,1.5994774e31,1.9034179e31,2.2651268e31,2.6955716e31,3.2077976e31,3.8173794e31,4.5427767e31,5.4060464e31,6.4333297e31,7.6558637e31,9.110669e31,1.084198e32,1.2902227e32,1.5354053e32,1.8271803e32,2.1743902e32,2.5875922e32,3.0792993e32,3.6644623e32,4.3608016e32,5.1894903e32,6.175623e32,7.349184e32,8.7457586e32,1.04076714e33,1.2385454e33,1.4738999e33,1.753987e33,2.0872882e33,2.4839381e33,2.9559486e33,3.517671e33,4.1861162e33,4.981609e33,5.928271e33,7.05479e33,8.39542e33,9.99076e33,1.1889316e34,1.4148583e34,1.6837256e34,2.0036754e34,2.3844364e34,2.8375537e34,3.3767597e34,4.0184497e34,4.7820554e34,5.690795e34,6.772188e34,8.0591154e34,9.590548e34,1.1413053e35,1.3581817e35,1.6162787e35,1.9234221e35,2.2889202e35,2.7238866e35,3.2414931e35,3.8574782e35,4.590495e35,5.462833e35,6.5009072e35,7.736283e35,9.206418e35,1.09558676e36,1.30378245e36,1.5515337e36,1.8463735e36,2.1972305e36,2.6147729e36,3.1116452e36,3.7029548e36,4.4066086e36,5.244002e36,6.240526e36,7.426382e36,8.8376264e36,1.0516996e37,1.2515554e37,1.4893821e37,1.7724112e37,2.1092137e37,2.51003e37,2.9870143e37,3.5546216e37,4.2301108e37,5.0339374e37,5.9905425e37,7.1288953e37,8.483608e37,1.0095705e38,1.2014204e38,1.4297203e38,1.7014118e38],"x":[1.0,1.250996,1.501992,1.7529881,2.003984,2.25498,2.5059762,2.756972,3.0079682,3.258964,3.5099602,3.7609563,4.0119524,4.262948,4.513944,4.7649403,5.0159364,5.2669325,5.517928,5.768924,6.0199203,6.2709165,6.5219126,6.772908,7.0239043,7.2749004,7.5258965,7.7768927,8.027888,8.278885,8.529881,8.780876,9.031873,9.282868,9.533865,9.784861,10.035856,10.286853,10.537848,10.788845,11.039841,11.290836,11.541833,11.792829,12.043825,12.294821,12.545816,12.796813,13.047809,13.298805,13.549801,13.8007965,14.051793,14.302789,14.553785,14.804781,15.055777,15.306773,15.557769,15.808765,16.059761,16.310757,16.561752,16.81275,17.063745,17.314741,17.565737,17.816732,18.06773,18.318726,18.569721,18.820717,19.071712,19.32271,19.573706,19.824701,20.075697,20.326693,20.57769,20.828686,21.079681,21.330677,21.581673,21.83267,22.083666,22.334661,22.585657,22.836653,23.08765,23.338646,23.589642,23.840637,24.091633,24.34263,24.593626,24.844622,25.095617,25.346613,25.59761,25.848606,26.099602,26.350597,26.601593,26.85259,27.103586,27.354582,27.605577,27.856573,28.10757,28.358566,28.609562,28.860558,29.111553,29.36255,29.613546,29.864542,30.115538,30.366533,30.61753,30.868526,31.119522,31.370518,31.621513,31.87251,32.123505,32.3745,32.6255,32.876495,33.12749,33.378487,33.629482,33.880478,34.131474,34.38247,34.633465,34.88446,35.13546,35.386456,35.63745,35.888447,36.139442,36.390438,36.641434,36.89243,37.143425,37.39442,37.64542,37.896416,38.14741,38.398407,38.649403,38.9004,39.151394,39.40239,39.653385,39.90438,40.15538,40.406376,40.65737,40.908367,41.159363,41.41036,41.661354,41.91235,42.163345,42.41434,42.66534,42.916336,43.16733,43.418327,43.669323,43.92032,44.171314,44.42231,44.673306,44.9243,45.1753,45.426296,45.67729,45.928288,46.179283,46.43028,46.681274,46.93227,47.183266,47.43426,47.68526,47.936256,48.187252,48.438248,48.689243,48.94024,49.191235,49.44223,49.693226,49.94422,50.19522,50.446217,50.697212,50.948208,51.199203,51.4502,51.701195,51.95219,52.203186,52.45418,52.70518,52.956177,53.207172,53.458168,53.709164,53.96016,54.211155,54.46215,54.713146,54.96414,55.21514,55.466137,55.717133,55.96813,56.219124,56.47012,56.721115,56.97211,57.223106,57.474102,57.7251,57.976097,58.227093,58.47809,58.729084,58.98008,59.231075,59.48207,59.733067,59.984062,60.23506,60.486057,60.737053,60.98805,61.239044,61.49004,61.741035,61.99203,62.243027,62.494022,62.74502,62.996017,63.247013,63.49801,63.749004,64.0,64.251,64.50199,64.75299,65.00398,65.25498,65.505974,65.75697,66.007965,66.258965,66.50996,66.760956,67.011955,67.26295,67.51395,67.76494,68.01594,68.26693,68.51793,68.76892,69.01992,69.27092,69.52191,69.77291,70.0239,70.2749,70.525894,70.77689,71.027885,71.278885,71.52988,71.780876,72.031876,72.28287,72.53387,72.78486,73.03586,73.28685,73.53785,73.78884,74.03984,74.29084,74.54183,74.79283,75.04382,75.29482,75.545815,75.796814,76.047806,76.298805,76.5498,76.8008,77.051796,77.30279,77.55379,77.80478,78.05578,78.30677,78.55777,78.80876,79.05976,79.31076,79.56175,79.81275,80.06374,80.31474,80.565735,80.816734,81.067726,81.318726,81.56972,81.82072,82.07172,82.32271,82.57371,82.8247,83.0757,83.32669,83.57769,83.82868,84.07968,84.33068,84.58167,84.83267,85.083664,85.33466,85.585655,85.836655,86.08765,86.338646,86.58964,86.84064,87.09164,87.34263,87.59363,87.84462,88.09562,88.34661,88.59761,88.8486,89.0996,89.3506,89.60159,89.85259,90.103584,90.35458,90.605576,90.856575,91.10757,91.35857,91.60956,91.86056,92.11156,92.36255,92.61355,92.86454,93.11554,93.36653,93.61753,93.86852,94.11952,94.37052,94.62151,94.87251,95.123505,95.374504,95.625496,95.876495,96.12749,96.37849,96.62948,96.88048,97.13148,97.38247,97.63347,97.88446,98.13546,98.38645,98.63745,98.88844,99.13944,99.39044,99.64143,99.89243,100.143425,100.394424,100.64542,100.896416,101.14741,101.39841,101.6494,101.9004,102.1514,102.40239,102.65339,102.90438,103.15538,103.40637,103.65737,103.90836,104.15936,104.41036,104.661354,104.91235,105.163345,105.414345,105.66534,105.916336,106.16733,106.41833,106.66932,106.92032,107.17132,107.42231,107.67331,107.9243,108.1753,108.42629,108.67729,108.92828,109.17928,109.43028,109.681274,109.932274,110.183266,110.434265,110.68526,110.93626,111.18725,111.43825,111.68924,111.94024,112.19124,112.44223,112.69323,112.94422,113.19522,113.44621,113.69721,113.948204,114.1992,114.4502,114.701195,114.952194,115.203186,115.454185,115.70518,115.95618,116.20717,116.45817,116.70916,116.96016,117.21116,117.46215,117.71315,117.96414,118.21514,118.46613,118.71713,118.968124,119.219124,119.47012,119.721115,119.972115,120.22311,120.474106,120.7251,120.9761,121.22709,121.47809,121.72908,121.98008,122.23108,122.48207,122.73307,122.98406,123.23506,123.48605,123.73705,123.988045,124.239044,124.49004,124.741035,124.992035,125.24303,125.494026,125.74502,125.99602,126.24701,126.49801,126.749,127.0]} diff --git a/lib/node_modules/@stdlib/math/base/special/exp2f/test/fixtures/julia/runner.jl b/lib/node_modules/@stdlib/math/base/special/exp2f/test/fixtures/julia/runner.jl new file mode 100644 index 000000000000..a403bd6b2e82 --- /dev/null +++ b/lib/node_modules/@stdlib/math/base/special/exp2f/test/fixtures/julia/runner.jl @@ -0,0 +1,79 @@ +#!/usr/bin/env julia +# +# @license Apache-2.0 +# +# Copyright (c) 2026 The Stdlib Authors. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +import JSON + +""" + gen( domain, name ) + +Generate fixture data for exp2f (single-precision, Float32) and write to file. + +# Arguments + +* `domain`: domain of input values +* `name::AbstractString`: output filename + +# Examples + +``` julia +julia> x = range( -10.0, stop = 10.0, length = 201 ); +julia> gen( x, "data.json" ); +``` +""" +function gen(domain, name) + x = Float32.(collect(domain)) + y = exp2.(x) + + data = Dict([ + ("x", x), + ("expected", y) + ]) + + filepath = joinpath(dir, name) + + outfile = open(filepath, "w") + write(outfile, JSON.json(data)) + write(outfile, "\n") + close(outfile) +end + +# Get the filename: +file = @__FILE__ + +# Extract the directory in which this file resides: +dir = dirname(file) + +# Medium negative values: +x = range(-126.0, stop=-1.0, length=503) +gen(x, "medium_negative.json") + +# Medium positive values: +x = range(1.0, stop=127.0, length=503) +gen(x, "medium_positive.json") + +# Small negative values: +x = range(-1.0, stop=-2.0^-23, length=503) +gen(x, "small_negative.json") + +# Small positive values: +x = range(2.0^-23, stop=1.0, length=503) +gen(x, "small_positive.json") + +# Tiny values: +x = range(-2.0^-23, stop=2.0^-23, length=503) +gen(x, "tiny.json") diff --git a/lib/node_modules/@stdlib/math/base/special/exp2f/test/fixtures/julia/small_negative.json b/lib/node_modules/@stdlib/math/base/special/exp2f/test/fixtures/julia/small_negative.json new file mode 100644 index 000000000000..85ab79ef77e1 --- /dev/null +++ b/lib/node_modules/@stdlib/math/base/special/exp2f/test/fixtures/julia/small_negative.json @@ -0,0 +1 @@ +{"expected":[0.5,0.5006909,0.50138265,0.50207543,0.5027692,0.50346386,0.5041595,0.5048561,0.5055537,0.5062522,0.50695175,0.5076522,0.50835365,0.50905603,0.5097594,0.5104638,0.5111691,0.5118754,0.51258266,0.5132909,0.5140001,0.51471037,0.5154215,0.51613367,0.51684684,0.517561,0.5182761,0.51899225,0.51970935,0.52042747,0.52114654,0.5218666,0.52258766,0.52330977,0.52403283,0.5247569,0.52548194,0.52620804,0.5269351,0.5276632,0.52839226,0.52912235,0.52985346,0.5305856,0.5313187,0.5320529,0.532788,0.53352416,0.53426135,0.53499955,0.53573877,0.536479,0.5372203,0.53796256,0.5387059,0.5394502,0.5401956,0.540942,0.5416894,0.5424379,0.5431874,0.5439379,0.5446895,0.5454421,0.54619575,0.54695046,0.5477062,0.548463,0.5492208,0.5499797,0.5507396,0.55150056,0.5522626,0.55302566,0.5537898,0.554555,0.5553212,0.5560885,0.5568569,0.5576263,0.5583968,0.55916834,0.55994093,0.56071466,0.5614894,0.5622652,0.5630421,0.56382006,0.56459916,0.5653792,0.56616044,0.56694275,0.5677261,0.56851053,0.56929606,0.57008266,0.57087034,0.57165915,0.572449,0.57324,0.57403207,0.57482517,0.57561946,0.5764148,0.5772112,0.5780088,0.5788074,0.5796072,0.58040804,0.58121,0.5820131,0.58281726,0.5836225,0.58442897,0.5852365,0.58604515,0.5868549,0.58766574,0.58847773,0.58929086,0.59010506,0.59092045,0.5917369,0.59255457,0.5933733,0.59419316,0.5950142,0.59583634,0.5966596,0.59748405,0.5983096,0.5991363,0.59996414,0.6007931,0.60162324,0.60245454,0.603287,0.60412055,0.60495526,0.60579115,0.6066282,0.6074664,0.60830575,0.60914624,0.6099879,0.6108307,0.6116747,0.6125199,0.61336625,0.61421376,0.6150624,0.61591226,0.6167633,0.61761546,0.6184689,0.61932343,0.6201792,0.62103605,0.6218942,0.62275344,0.62361395,0.6244756,0.62533844,0.62620246,0.62706774,0.62793416,0.6288018,0.6296706,0.63054067,0.6314119,0.63228434,0.63315797,0.63403285,0.63490885,0.6357862,0.6366646,0.63754433,0.63842523,0.6393074,0.6401907,0.6410753,0.6419611,0.6428481,0.6437363,0.6446258,0.6455165,0.64640844,0.64730155,0.648196,0.6490916,0.6499885,0.65088654,0.6517859,0.65268654,0.65358835,0.6544914,0.65539575,0.6563013,0.65720814,0.6581162,0.65902555,0.6599362,0.66084796,0.6617611,0.6626755,0.66359115,0.664508,0.6654262,0.6663456,0.6672663,0.6681883,0.66911155,0.6700361,0.6709619,0.67188895,0.67281735,0.673747,0.6746779,0.6756101,0.67654365,0.67747843,0.6784146,0.6793519,0.6802906,0.68123055,0.6821719,0.6831144,0.6840583,0.68500346,0.68595,0.68689775,0.68784684,0.6887973,0.689749,0.690702,0.6916564,0.6926121,0.6935691,0.6945274,0.6954871,0.696448,0.69741035,0.698374,0.6993389,0.7003052,0.70127285,0.7022418,0.7032121,0.70418376,0.70515674,0.7061311,0.70710677,0.70808375,0.70906216,0.7100419,0.711023,0.71200544,0.7129892,0.71397436,0.7149609,0.71594876,0.716938,0.7179286,0.7189206,0.7199139,0.72090864,0.72190475,0.72290224,0.72390103,0.7249013,0.7259029,0.72690594,0.72791034,0.7289161,0.72992325,0.7309318,0.7319417,0.7329531,0.7339658,0.7349799,0.7359955,0.73701245,0.7380308,0.73905057,0.7400717,0.7410943,0.74211824,0.7431437,0.7441705,0.7451987,0.7462284,0.7472595,0.74829197,0.74932593,0.75036126,0.7513981,0.7524363,0.75347596,0.7545171,0.7555596,0.7566036,0.757649,0.75869584,0.75974417,0.7607939,0.7618451,0.7628978,0.7639519,0.76500744,0.76606447,0.767123,0.76818293,0.7692444,0.77030724,0.7713716,0.7724374,0.77350473,0.7745735,0.77564377,0.77671546,0.77778864,0.7788634,0.77993953,0.7810172,0.7820964,0.78317696,0.78425914,0.78534275,0.78642786,0.7875145,0.78860265,0.7896923,0.7907834,0.791876,0.7929702,0.7940659,0.79516304,0.7962617,0.79736197,0.7984637,0.799567,0.80067176,0.801778,0.8028859,0.80399525,0.80510616,0.80621856,0.8073326,0.8084481,0.8095651,0.8106837,0.8118039,0.8129255,0.81404877,0.81517357,0.8162999,0.8174278,0.81855726,0.8196883,0.82082087,0.821955,0.82309073,0.82422805,0.8253669,0.82650733,0.82764935,0.8287929,0.82993805,0.83108485,0.83223313,0.8333831,0.8345346,0.8356877,0.83684236,0.8379986,0.83915657,0.840316,0.8414771,0.8426398,0.8438041,0.84497,0.8461375,0.84730667,0.84847736,0.8496497,0.85082376,0.85199934,0.8531766,0.8543554,0.8555359,0.856718,0.85790175,0.85908717,0.8602742,0.86146283,0.86265314,0.8638451,0.8650387,0.86623394,0.8674308,0.8686294,0.8698296,0.87103146,0.872235,0.87344015,0.874647,0.87585557,0.8770657,0.8782776,0.87949115,0.88070637,0.88192326,0.8831418,0.8843621,0.88558406,0.8868077,0.888033,0.88926,0.8904887,0.8917191,0.89295125,0.89418507,0.89542055,0.89665776,0.8978967,0.8991374,0.9003797,0.9016238,0.9028696,0.9041171,0.90536636,0.90661734,0.90787,0.90912443,0.9103806,0.9116385,0.9128981,0.9141595,0.9154226,0.9166875,0.9179541,0.9192225,0.9204926,0.92176443,0.92303807,0.9243134,0.9255906,0.9268695,0.9281502,0.92943263,0.9307169,0.93200284,0.9332906,0.93458015,0.9358715,0.9371646,0.9384595,0.9397562,0.9410547,0.942355,0.94365704,0.94496095,0.9462666,0.9475741,0.94888335,0.9501945,0.9515074,0.9528221,0.95413864,0.955457,0.95677716,0.9580992,0.959423,0.9607487,0.9620761,0.9634055,0.96473664,0.96606964,0.9674045,0.9687412,0.9700797,0.9714201,0.97276235,0.97410643,0.97545236,0.97680014,0.97814983,0.97950137,0.98085475,0.98221004,0.9835672,0.9849262,0.9862871,0.98764986,0.9890145,0.99038106,0.9917495,0.99311984,0.99449205,0.9958662,0.9972422,0.9986201,0.99999994],"x":[-1.0,-0.99800795,-0.99601597,-0.9940239,-0.9920319,-0.9900398,-0.98804784,-0.9860558,-0.98406374,-0.9820717,-0.9800797,-0.97808766,-0.9760956,-0.97410357,-0.9721116,-0.97011954,-0.9681275,-0.96613544,-0.96414346,-0.9621514,-0.96015936,-0.9581673,-0.9561753,-0.9541833,-0.95219123,-0.9501992,-0.9482072,-0.94621515,-0.9442231,-0.94223106,-0.9402391,-0.938247,-0.936255,-0.93426293,-0.93227094,-0.9302789,-0.92828685,-0.9262948,-0.9243028,-0.92231077,-0.9203187,-0.9183267,-0.9163347,-0.91434264,-0.9123506,-0.91035855,-0.90836656,-0.9063745,-0.90438247,-0.9023904,-0.90039843,-0.8984064,-0.89641434,-0.89442235,-0.8924303,-0.89043826,-0.8884462,-0.8864542,-0.8844622,-0.88247013,-0.8804781,-0.8784861,-0.87649405,-0.874502,-0.87250996,-0.87051797,-0.8685259,-0.8665339,-0.8645418,-0.86254984,-0.8605578,-0.85856575,-0.8565737,-0.8545817,-0.85258967,-0.8505976,-0.8486056,-0.8466136,-0.84462154,-0.8426295,-0.84063745,-0.83864546,-0.8366534,-0.83466136,-0.8326693,-0.83067733,-0.8286853,-0.82669324,-0.8247012,-0.8227092,-0.82071716,-0.8187251,-0.81673306,-0.8147411,-0.812749,-0.810757,-0.80876493,-0.80677295,-0.8047809,-0.80278885,-0.8007968,-0.7988048,-0.7968128,-0.7948207,-0.79282874,-0.7908367,-0.78884465,-0.7868526,-0.7848606,-0.78286856,-0.7808765,-0.7788845,-0.7768925,-0.77490044,-0.7729084,-0.77091634,-0.76892436,-0.7669323,-0.76494026,-0.7629482,-0.7609562,-0.7589642,-0.75697213,-0.7549801,-0.7529881,-0.75099605,-0.749004,-0.74701196,-0.74502,-0.7430279,-0.7410359,-0.73904383,-0.73705184,-0.7350598,-0.73306775,-0.7310757,-0.7290837,-0.72709167,-0.7250996,-0.7231076,-0.7211156,-0.71912354,-0.7171315,-0.71513945,-0.71314746,-0.7111554,-0.70916337,-0.7071713,-0.70517933,-0.7031873,-0.70119524,-0.69920325,-0.6972112,-0.69521916,-0.6932271,-0.6912351,-0.6892431,-0.68725103,-0.685259,-0.683267,-0.68127495,-0.6792829,-0.67729086,-0.67529887,-0.6733068,-0.6713148,-0.6693227,-0.66733074,-0.6653387,-0.66334665,-0.6613546,-0.6593626,-0.65737057,-0.6553785,-0.6533865,-0.6513945,-0.64940244,-0.6474104,-0.64541835,-0.64342636,-0.6414343,-0.63944227,-0.6374502,-0.63545823,-0.6334662,-0.63147414,-0.6294821,-0.6274901,-0.62549806,-0.623506,-0.62151396,-0.619522,-0.6175299,-0.6155379,-0.61354584,-0.61155385,-0.6095618,-0.60756975,-0.6055777,-0.6035857,-0.6015937,-0.5996016,-0.59760964,-0.5956176,-0.59362555,-0.5916335,-0.5896415,-0.58764946,-0.5856574,-0.5836654,-0.5816734,-0.57968134,-0.5776893,-0.57569724,-0.57370526,-0.5717132,-0.56972116,-0.5677291,-0.5657371,-0.5637451,-0.56175303,-0.559761,-0.557769,-0.55577695,-0.5537849,-0.55179286,-0.5498009,-0.5478088,-0.5458168,-0.54382473,-0.54183275,-0.5398407,-0.53784865,-0.5358566,-0.5338646,-0.5318726,-0.5298805,-0.5278885,-0.5258965,-0.52390444,-0.5219124,-0.51992035,-0.51792836,-0.5159363,-0.51394427,-0.5119522,-0.50996023,-0.5079682,-0.50597614,-0.5039841,-0.5019921,-0.50000006,-0.49800804,-0.496016,-0.49402398,-0.49203193,-0.4900399,-0.48804787,-0.48605585,-0.4840638,-0.4820718,-0.48007974,-0.47808772,-0.47609568,-0.47410366,-0.4721116,-0.4701196,-0.46812755,-0.46613553,-0.46414348,-0.46215147,-0.46015942,-0.4581674,-0.45617536,-0.45418334,-0.4521913,-0.45019928,-0.44820723,-0.4462152,-0.44422317,-0.44223115,-0.4402391,-0.43824708,-0.43625504,-0.43426302,-0.43227097,-0.43027896,-0.4282869,-0.4262949,-0.42430285,-0.42231083,-0.42031878,-0.41832677,-0.41633472,-0.4143427,-0.41235065,-0.41035864,-0.4083666,-0.40637457,-0.40438253,-0.4023905,-0.40039846,-0.39840645,-0.39641443,-0.39442238,-0.39243037,-0.39043832,-0.3884463,-0.38645425,-0.38446224,-0.3824702,-0.38047817,-0.37848613,-0.3764941,-0.37450206,-0.37251005,-0.370518,-0.36852598,-0.36653394,-0.36454192,-0.36254987,-0.36055785,-0.3585658,-0.3565738,-0.35458174,-0.35258973,-0.35059768,-0.34860566,-0.34661362,-0.3446216,-0.34262955,-0.34063753,-0.3386455,-0.33665347,-0.33466142,-0.3326694,-0.33067736,-0.32868534,-0.3266933,-0.32470128,-0.32270923,-0.32071722,-0.31872517,-0.31673315,-0.3147411,-0.3127491,-0.31075704,-0.30876502,-0.30677298,-0.30478096,-0.3027889,-0.3007969,-0.29880488,-0.29681283,-0.29482082,-0.29282877,-0.29083675,-0.2888447,-0.2868527,-0.28486064,-0.28286862,-0.28087658,-0.27888456,-0.2768925,-0.2749005,-0.27290845,-0.27091643,-0.2689244,-0.26693237,-0.26494032,-0.2629483,-0.26095626,-0.25896424,-0.2569722,-0.25498018,-0.25298813,-0.2509961,-0.24900408,-0.24701205,-0.24502002,-0.24302799,-0.24103595,-0.23904392,-0.23705189,-0.23505986,-0.23306783,-0.2310758,-0.22908376,-0.22709173,-0.2250997,-0.22310767,-0.22111563,-0.2191236,-0.21713157,-0.21513954,-0.2131475,-0.21115547,-0.20916344,-0.20717141,-0.20517938,-0.20318735,-0.20119531,-0.19920328,-0.19721125,-0.19521922,-0.19322719,-0.19123515,-0.18924312,-0.18725109,-0.18525906,-0.18326703,-0.181275,-0.17928296,-0.17729093,-0.1752989,-0.17330687,-0.17131484,-0.1693228,-0.16733077,-0.16533874,-0.16334671,-0.16135468,-0.15936264,-0.15737061,-0.15537858,-0.15338655,-0.15139452,-0.1494025,-0.14741047,-0.14541844,-0.1434264,-0.14143437,-0.13944234,-0.13745031,-0.13545828,-0.13346624,-0.13147421,-0.12948218,-0.12749015,-0.12549812,-0.123506084,-0.12151405,-0.11952202,-0.11752999,-0.11553796,-0.113545924,-0.11155389,-0.10956186,-0.10756983,-0.1055778,-0.103585765,-0.10159373,-0.0996017,-0.09760967,-0.09561764,-0.093625605,-0.09163357,-0.08964154,-0.08764951,-0.08565748,-0.083665445,-0.08167341,-0.07968138,-0.07768935,-0.07569732,-0.07370529,-0.07171326,-0.06972123,-0.0677292,-0.065737166,-0.06374513,-0.0617531,-0.05976107,-0.057769038,-0.055777006,-0.053784974,-0.051792942,-0.04980091,-0.047808878,-0.045816846,-0.043824814,-0.041832782,-0.03984075,-0.03784872,-0.03585669,-0.03386466,-0.031872626,-0.029880594,-0.027888563,-0.02589653,-0.023904499,-0.021912467,-0.019920435,-0.017928405,-0.015936373,-0.013944341,-0.011952309,-0.009960277,-0.007968246,-0.005976214,-0.0039841826,-0.001992151,-1.1920929e-7]} diff --git a/lib/node_modules/@stdlib/math/base/special/exp2f/test/fixtures/julia/small_positive.json b/lib/node_modules/@stdlib/math/base/special/exp2f/test/fixtures/julia/small_positive.json new file mode 100644 index 000000000000..764a0125aa48 --- /dev/null +++ b/lib/node_modules/@stdlib/math/base/special/exp2f/test/fixtures/julia/small_positive.json @@ -0,0 +1 @@ +{"expected":[1.0000001,1.0013818,1.0027654,1.004151,1.0055385,1.0069278,1.0083191,1.0097123,1.0111074,1.0125046,1.0139036,1.0153044,1.0167074,1.0181122,1.019519,1.0209277,1.0223383,1.0237509,1.0251654,1.0265819,1.0280004,1.0294207,1.0308431,1.0322675,1.0336938,1.035122,1.0365523,1.0379846,1.0394188,1.0408549,1.0422931,1.0437332,1.0451754,1.0466195,1.0480658,1.0495138,1.050964,1.0524162,1.0538703,1.0553265,1.0567846,1.0582448,1.059707,1.0611713,1.0626374,1.0641057,1.0655761,1.0670484,1.0685228,1.0699992,1.0714777,1.0729581,1.0744406,1.0759252,1.0774119,1.0789006,1.0803913,1.081884,1.0833789,1.0848758,1.0863749,1.087876,1.0893791,1.0908843,1.0923916,1.093901,1.0954125,1.096926,1.0984417,1.0999594,1.1014793,1.1030012,1.1045252,1.1060514,1.1075797,1.10911,1.1106426,1.1121771,1.1137139,1.1152527,1.1167936,1.1183368,1.119882,1.1214293,1.1229788,1.1245306,1.1260843,1.1276402,1.1291983,1.1307585,1.132321,1.1338855,1.1354523,1.1370211,1.1385921,1.1401654,1.1417408,1.1433184,1.1448982,1.1464801,1.1480641,1.1496505,1.151239,1.1528296,1.1544225,1.1560177,1.157615,1.1592145,1.1608162,1.1624202,1.1640263,1.1656346,1.1672451,1.168858,1.1704731,1.1720903,1.1737099,1.1753316,1.1769556,1.1785818,1.1802102,1.181841,1.183474,1.1851093,1.1867467,1.1883864,1.1900285,1.1916728,1.1933193,1.1949682,1.1966193,1.1982727,1.1999284,1.2015864,1.2032466,1.2049092,1.2065741,1.2082412,1.2099106,1.2115824,1.2132565,1.2149328,1.2166116,1.2182926,1.219976,1.2216616,1.2233496,1.22504,1.2267326,1.2284276,1.230125,1.2318246,1.2335267,1.235231,1.2369378,1.238647,1.2403584,1.2420722,1.2437885,1.245507,1.2472279,1.2489513,1.250677,1.252405,1.2541356,1.2558684,1.2576036,1.2593414,1.2610815,1.2628239,1.2645688,1.266316,1.2680657,1.2698178,1.2715725,1.2733294,1.2750888,1.2768506,1.2786149,1.2803816,1.2821506,1.2839222,1.2856963,1.2874727,1.2892517,1.291033,1.2928169,1.2946032,1.2963921,1.2981833,1.2999771,1.3017732,1.3035719,1.3053731,1.3071768,1.308983,1.3107916,1.3126028,1.3144164,1.3162326,1.3180512,1.3198724,1.3216962,1.3235223,1.3253511,1.3271823,1.3290161,1.3308525,1.3326913,1.3345327,1.3363768,1.3382232,1.3400723,1.3419238,1.3437781,1.3456348,1.3474941,1.3493559,1.3512204,1.3530874,1.354957,1.3568292,1.358704,1.3605813,1.3624612,1.3643438,1.3662289,1.3681167,1.370007,1.3719001,1.3737956,1.3756938,1.3775947,1.3794981,1.3814043,1.383313,1.3852243,1.3871382,1.3890549,1.3909742,1.3928962,1.3948208,1.3967481,1.398678,1.4006106,1.4025458,1.4044837,1.4064243,1.4083676,1.4103136,1.4122623,1.4142137,1.4161676,1.4181244,1.4200839,1.4220461,1.4240109,1.4259785,1.4279488,1.4299219,1.4318976,1.433876,1.4358573,1.4378413,1.439828,1.4418174,1.4438096,1.4458046,1.4478023,1.4498028,1.451806,1.453812,1.4558208,1.4578322,1.4598466,1.4618636,1.4638836,1.4659063,1.4679317,1.4699601,1.4719912,1.474025,1.4760617,1.4781013,1.4801435,1.4821887,1.4842367,1.4862875,1.4883411,1.4903976,1.4924569,1.4945191,1.4965842,1.498652,1.5007226,1.5027963,1.5048728,1.506952,1.5090343,1.5111194,1.5132073,1.5152981,1.5173918,1.5194885,1.521588,1.5236903,1.5257957,1.5279039,1.530015,1.5321292,1.5342461,1.536366,1.5384889,1.5406146,1.5427433,1.544875,1.5470096,1.5491471,1.5512877,1.553431,1.5555774,1.5577269,1.5598792,1.5620346,1.5641928,1.566354,1.5685184,1.5706856,1.5728558,1.5750291,1.5772054,1.5793847,1.5815669,1.5837523,1.5859406,1.5881319,1.5903262,1.5925236,1.594724,1.5969275,1.599134,1.6013436,1.6035563,1.6057719,1.6079906,1.6102124,1.6124372,1.6146653,1.6168963,1.6191304,1.6213676,1.6236079,1.6258512,1.6280977,1.6303473,1.6326,1.6348557,1.6371148,1.6393768,1.6416419,1.6439102,1.6461817,1.6484562,1.650734,1.6530148,1.6552988,1.657586,1.6598762,1.6621698,1.6644665,1.6667663,1.6690693,1.6713755,1.6736848,1.6759975,1.6783131,1.6806322,1.6829543,1.6852797,1.6876082,1.6899401,1.6922752,1.6946135,1.6969548,1.6992996,1.7016476,1.7039988,1.7063532,1.708711,1.711072,1.7134362,1.7158036,1.7181745,1.7205485,1.7229258,1.7253064,1.7276903,1.7300775,1.732468,1.7348617,1.7372589,1.7396593,1.742063,1.7444701,1.7468805,1.7492942,1.7517111,1.7541316,1.7565553,1.7589824,1.7614129,1.7638466,1.7662838,1.7687243,1.7711681,1.7736155,1.7760661,1.7785201,1.7809775,1.7834383,1.7859026,1.7883703,1.7908412,1.7933156,1.7957937,1.7982749,1.8007596,1.8032477,1.8057394,1.8082345,1.8107328,1.8132348,1.8157402,1.8182491,1.8207613,1.8232771,1.8257965,1.8283192,1.8308454,1.8333751,1.8359084,1.8384451,1.8409853,1.843529,1.8460763,1.8486271,1.8511813,1.8537391,1.8563006,1.8588655,1.8614339,1.8640058,1.8665814,1.8691604,1.8717431,1.8743294,1.8769193,1.8795125,1.8821095,1.8847101,1.8873143,1.889922,1.8925333,1.8951483,1.897767,1.9003891,1.9030149,1.9056443,1.9082775,1.9109141,1.9135544,1.9161985,1.9188461,1.9214975,1.9241525,1.9268111,1.9294734,1.9321394,1.9348091,1.9374825,1.9401596,1.9428403,1.9455248,1.948213,1.9509048,1.9536004,1.9562998,1.9590029,1.9617097,1.9644202,1.9671345,1.9698526,1.9725744,1.9752998,1.9780293,1.9807624,1.9834993,1.9862398,1.9889842,1.9917325,1.9944845,1.9972403,2.0],"x":[1.1920929e-7,0.001992151,0.0039841826,0.005976214,0.007968246,0.009960277,0.011952309,0.013944341,0.015936373,0.017928405,0.019920435,0.021912467,0.023904499,0.02589653,0.027888563,0.029880594,0.031872626,0.03386466,0.03585669,0.03784872,0.03984075,0.041832782,0.043824814,0.045816846,0.047808878,0.04980091,0.051792942,0.053784974,0.055777006,0.057769038,0.05976107,0.0617531,0.06374513,0.065737166,0.0677292,0.06972123,0.07171326,0.07370529,0.07569732,0.07768935,0.07968138,0.08167341,0.083665445,0.08565748,0.08764951,0.08964154,0.09163357,0.093625605,0.09561764,0.09760967,0.0996017,0.10159373,0.103585765,0.1055778,0.10756983,0.10956186,0.11155389,0.113545924,0.11553796,0.11752999,0.11952202,0.12151405,0.123506084,0.12549812,0.12749015,0.12948218,0.13147421,0.13346624,0.13545828,0.13745031,0.13944234,0.14143437,0.1434264,0.14541844,0.14741047,0.1494025,0.15139452,0.15338655,0.15537858,0.15737061,0.15936264,0.16135468,0.16334671,0.16533874,0.16733077,0.1693228,0.17131484,0.17330687,0.1752989,0.17729093,0.17928296,0.181275,0.18326703,0.18525906,0.18725109,0.18924312,0.19123515,0.19322719,0.19521922,0.19721125,0.19920328,0.20119531,0.20318735,0.20517938,0.20717141,0.20916344,0.21115547,0.2131475,0.21513954,0.21713157,0.2191236,0.22111563,0.22310767,0.2250997,0.22709173,0.22908376,0.2310758,0.23306783,0.23505986,0.23705189,0.23904392,0.24103595,0.24302799,0.24502002,0.24701205,0.24900408,0.2509961,0.25298813,0.25498018,0.2569722,0.25896424,0.26095626,0.2629483,0.26494032,0.26693237,0.2689244,0.27091643,0.27290845,0.2749005,0.2768925,0.27888456,0.28087658,0.28286862,0.28486064,0.2868527,0.2888447,0.29083675,0.29282877,0.29482082,0.29681283,0.29880488,0.3007969,0.3027889,0.30478096,0.30677298,0.30876502,0.31075704,0.3127491,0.3147411,0.31673315,0.31872517,0.32071722,0.32270923,0.32470128,0.3266933,0.32868534,0.33067736,0.3326694,0.33466142,0.33665347,0.3386455,0.34063753,0.34262955,0.3446216,0.34661362,0.34860566,0.35059768,0.35258973,0.35458174,0.3565738,0.3585658,0.36055785,0.36254987,0.36454192,0.36653394,0.36852598,0.370518,0.37251005,0.37450206,0.3764941,0.37848613,0.38047817,0.3824702,0.38446224,0.38645425,0.3884463,0.39043832,0.39243037,0.39442238,0.39641443,0.39840645,0.40039846,0.4023905,0.40438253,0.40637457,0.4083666,0.41035864,0.41235065,0.4143427,0.41633472,0.41832677,0.42031878,0.42231083,0.42430285,0.4262949,0.4282869,0.43027896,0.43227097,0.43426302,0.43625504,0.43824708,0.4402391,0.44223115,0.44422317,0.4462152,0.44820723,0.45019928,0.4521913,0.45418334,0.45617536,0.4581674,0.46015942,0.46215147,0.46414348,0.46613553,0.46812755,0.4701196,0.4721116,0.47410366,0.47609568,0.47808772,0.48007974,0.4820718,0.4840638,0.48605585,0.48804787,0.4900399,0.49203193,0.49402398,0.496016,0.49800804,0.50000006,0.5019921,0.5039841,0.50597614,0.5079682,0.50996023,0.5119522,0.51394427,0.5159363,0.51792836,0.51992035,0.5219124,0.52390444,0.5258965,0.5278885,0.5298805,0.5318726,0.5338646,0.5358566,0.53784865,0.5398407,0.54183275,0.54382473,0.5458168,0.5478088,0.5498009,0.55179286,0.5537849,0.55577695,0.557769,0.559761,0.56175303,0.5637451,0.5657371,0.5677291,0.56972116,0.5717132,0.57370526,0.57569724,0.5776893,0.57968134,0.5816734,0.5836654,0.5856574,0.58764946,0.5896415,0.5916335,0.59362555,0.5956176,0.59760964,0.5996016,0.6015937,0.6035857,0.6055777,0.60756975,0.6095618,0.61155385,0.61354584,0.6155379,0.6175299,0.619522,0.62151396,0.623506,0.62549806,0.6274901,0.6294821,0.63147414,0.6334662,0.63545823,0.6374502,0.63944227,0.6414343,0.64342636,0.64541835,0.6474104,0.64940244,0.6513945,0.6533865,0.6553785,0.65737057,0.6593626,0.6613546,0.66334665,0.6653387,0.66733074,0.6693227,0.6713148,0.6733068,0.67529887,0.67729086,0.6792829,0.68127495,0.683267,0.685259,0.68725103,0.6892431,0.6912351,0.6932271,0.69521916,0.6972112,0.69920325,0.70119524,0.7031873,0.70517933,0.7071713,0.70916337,0.7111554,0.71314746,0.71513945,0.7171315,0.71912354,0.7211156,0.7231076,0.7250996,0.72709167,0.7290837,0.7310757,0.73306775,0.7350598,0.73705184,0.73904383,0.7410359,0.7430279,0.74502,0.74701196,0.749004,0.75099605,0.7529881,0.7549801,0.75697213,0.7589642,0.7609562,0.7629482,0.76494026,0.7669323,0.76892436,0.77091634,0.7729084,0.77490044,0.7768925,0.7788845,0.7808765,0.78286856,0.7848606,0.7868526,0.78884465,0.7908367,0.79282874,0.7948207,0.7968128,0.7988048,0.8007968,0.80278885,0.8047809,0.80677295,0.80876493,0.810757,0.812749,0.8147411,0.81673306,0.8187251,0.82071716,0.8227092,0.8247012,0.82669324,0.8286853,0.83067733,0.8326693,0.83466136,0.8366534,0.83864546,0.84063745,0.8426295,0.84462154,0.8466136,0.8486056,0.8505976,0.85258967,0.8545817,0.8565737,0.85856575,0.8605578,0.86254984,0.8645418,0.8665339,0.8685259,0.87051797,0.87250996,0.874502,0.87649405,0.8784861,0.8804781,0.88247013,0.8844622,0.8864542,0.8884462,0.89043826,0.8924303,0.89442235,0.89641434,0.8984064,0.90039843,0.9023904,0.90438247,0.9063745,0.90836656,0.91035855,0.9123506,0.91434264,0.9163347,0.9183267,0.9203187,0.92231077,0.9243028,0.9262948,0.92828685,0.9302789,0.93227094,0.93426293,0.936255,0.938247,0.9402391,0.94223106,0.9442231,0.94621515,0.9482072,0.9501992,0.95219123,0.9541833,0.9561753,0.9581673,0.96015936,0.9621514,0.96414346,0.96613544,0.9681275,0.97011954,0.9721116,0.97410357,0.9760956,0.97808766,0.9800797,0.9820717,0.98406374,0.9860558,0.98804784,0.9900398,0.9920319,0.9940239,0.99601597,0.99800795,1.0]} diff --git a/lib/node_modules/@stdlib/math/base/special/exp2f/test/fixtures/julia/tiny.json b/lib/node_modules/@stdlib/math/base/special/exp2f/test/fixtures/julia/tiny.json new file mode 100644 index 000000000000..17bd5a7ccc29 --- /dev/null +++ b/lib/node_modules/@stdlib/math/base/special/exp2f/test/fixtures/julia/tiny.json @@ -0,0 +1 @@ +{"expected":[0.99999994,0.99999994,0.99999994,0.99999994,0.99999994,0.99999994,0.99999994,0.99999994,0.99999994,0.99999994,0.99999994,0.99999994,0.99999994,0.99999994,0.99999994,0.99999994,0.99999994,0.99999994,0.99999994,0.99999994,0.99999994,0.99999994,0.99999994,0.99999994,0.99999994,0.99999994,0.99999994,0.99999994,0.99999994,0.99999994,0.99999994,0.99999994,0.99999994,0.99999994,0.99999994,0.99999994,0.99999994,0.99999994,0.99999994,0.99999994,0.99999994,0.99999994,0.99999994,0.99999994,0.99999994,0.99999994,0.99999994,0.99999994,0.99999994,0.99999994,0.99999994,0.99999994,0.99999994,0.99999994,0.99999994,0.99999994,0.99999994,0.99999994,0.99999994,0.99999994,0.99999994,0.99999994,0.99999994,0.99999994,0.99999994,0.99999994,0.99999994,0.99999994,0.99999994,0.99999994,0.99999994,0.99999994,0.99999994,0.99999994,0.99999994,0.99999994,0.99999994,0.99999994,0.99999994,0.99999994,0.99999994,0.99999994,0.99999994,0.99999994,0.99999994,0.99999994,0.99999994,0.99999994,0.99999994,0.99999994,0.99999994,0.99999994,0.99999994,0.99999994,0.99999994,0.99999994,0.99999994,0.99999994,0.99999994,0.99999994,0.99999994,0.99999994,0.99999994,0.99999994,0.99999994,0.99999994,0.99999994,0.99999994,0.99999994,0.99999994,0.99999994,0.99999994,0.99999994,0.99999994,0.99999994,0.99999994,0.99999994,0.99999994,0.99999994,0.99999994,0.99999994,0.99999994,0.99999994,0.99999994,0.99999994,0.99999994,0.99999994,0.99999994,0.99999994,0.99999994,0.99999994,0.99999994,0.99999994,0.99999994,0.99999994,0.99999994,0.99999994,0.99999994,0.99999994,0.99999994,0.99999994,0.99999994,0.99999994,0.99999994,0.99999994,0.99999994,0.99999994,0.99999994,0.99999994,0.99999994,0.99999994,0.99999994,0.99999994,0.99999994,0.99999994,0.99999994,0.99999994,0.99999994,0.99999994,0.99999994,0.99999994,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0000001,1.0000001,1.0000001,1.0000001,1.0000001,1.0000001,1.0000001,1.0000001,1.0000001,1.0000001,1.0000001,1.0000001,1.0000001,1.0000001,1.0000001,1.0000001,1.0000001,1.0000001,1.0000001,1.0000001,1.0000001,1.0000001,1.0000001,1.0000001,1.0000001,1.0000001,1.0000001,1.0000001,1.0000001,1.0000001,1.0000001,1.0000001,1.0000001,1.0000001,1.0000001,1.0000001,1.0000001,1.0000001,1.0000001,1.0000001,1.0000001,1.0000001,1.0000001,1.0000001,1.0000001,1.0000001,1.0000001,1.0000001,1.0000001,1.0000001,1.0000001,1.0000001,1.0000001,1.0000001,1.0000001,1.0000001,1.0000001,1.0000001,1.0000001,1.0000001,1.0000001,1.0000001,1.0000001,1.0000001,1.0000001,1.0000001,1.0000001,1.0000001,1.0000001,1.0000001],"x":[-1.1920929e-7,-1.18734356e-7,-1.18259415e-7,-1.1778448e-7,-1.1730954e-7,-1.16834606e-7,-1.16359665e-7,-1.1588473e-7,-1.1540979e-7,-1.14934856e-7,-1.14459915e-7,-1.1398498e-7,-1.1351004e-7,-1.1303511e-7,-1.12560166e-7,-1.1208523e-7,-1.1161029e-7,-1.1113536e-7,-1.10660416e-7,-1.1018548e-7,-1.0971054e-7,-1.0923561e-7,-1.08760666e-7,-1.0828573e-7,-1.0781079e-7,-1.0733586e-7,-1.0686092e-7,-1.0638598e-7,-1.0591104e-7,-1.0543611e-7,-1.0496117e-7,-1.0448623e-7,-1.0401129e-7,-1.0353636e-7,-1.0306142e-7,-1.0258648e-7,-1.0211154e-7,-1.0163661e-7,-1.0116167e-7,-1.00686734e-7,-1.0021179e-7,-9.973686e-8,-9.926192e-8,-9.8786984e-8,-9.831204e-8,-9.783711e-8,-9.736217e-8,-9.6887234e-8,-9.641229e-8,-9.593736e-8,-9.546242e-8,-9.4987485e-8,-9.4512544e-8,-9.403761e-8,-9.356267e-8,-9.3087735e-8,-9.2612794e-8,-9.213786e-8,-9.166292e-8,-9.1187985e-8,-9.0713044e-8,-9.023811e-8,-8.976317e-8,-8.9288235e-8,-8.8813294e-8,-8.833836e-8,-8.786342e-8,-8.7388486e-8,-8.6913545e-8,-8.643861e-8,-8.596367e-8,-8.5488736e-8,-8.5013795e-8,-8.453886e-8,-8.406392e-8,-8.3588986e-8,-8.3114045e-8,-8.263911e-8,-8.216417e-8,-8.168924e-8,-8.1214296e-8,-8.073936e-8,-8.026442e-8,-7.978949e-8,-7.9314546e-8,-7.883961e-8,-7.836467e-8,-7.788974e-8,-7.7414796e-8,-7.693986e-8,-7.646492e-8,-7.598999e-8,-7.551505e-8,-7.504011e-8,-7.456517e-8,-7.409024e-8,-7.36153e-8,-7.314036e-8,-7.266542e-8,-7.219049e-8,-7.171555e-8,-7.124061e-8,-7.076567e-8,-7.029074e-8,-6.98158e-8,-6.9340864e-8,-6.886592e-8,-6.839099e-8,-6.791605e-8,-6.7441114e-8,-6.696617e-8,-6.649124e-8,-6.60163e-8,-6.5541364e-8,-6.506642e-8,-6.459149e-8,-6.411655e-8,-6.3641615e-8,-6.3166674e-8,-6.269174e-8,-6.22168e-8,-6.1741865e-8,-6.1266924e-8,-6.079199e-8,-6.031705e-8,-5.9842115e-8,-5.9367178e-8,-5.889224e-8,-5.8417303e-8,-5.7942366e-8,-5.7467428e-8,-5.699249e-8,-5.6517553e-8,-5.6042616e-8,-5.556768e-8,-5.509274e-8,-5.4617804e-8,-5.4142866e-8,-5.366793e-8,-5.319299e-8,-5.2718054e-8,-5.2243116e-8,-5.176818e-8,-5.129324e-8,-5.0818304e-8,-5.0343367e-8,-4.986843e-8,-4.9393492e-8,-4.8918555e-8,-4.8443617e-8,-4.796868e-8,-4.7493742e-8,-4.7018805e-8,-4.6543867e-8,-4.606893e-8,-4.5593993e-8,-4.5119055e-8,-4.4644118e-8,-4.416918e-8,-4.3694243e-8,-4.3219305e-8,-4.2744368e-8,-4.226943e-8,-4.1794493e-8,-4.1319556e-8,-4.084462e-8,-4.036968e-8,-3.9894744e-8,-3.9419806e-8,-3.894487e-8,-3.846993e-8,-3.7994994e-8,-3.7520056e-8,-3.704512e-8,-3.657018e-8,-3.6095244e-8,-3.5620307e-8,-3.514537e-8,-3.4670432e-8,-3.4195494e-8,-3.3720557e-8,-3.324562e-8,-3.2770682e-8,-3.2295745e-8,-3.1820807e-8,-3.134587e-8,-3.0870932e-8,-3.0395995e-8,-2.9921058e-8,-2.944612e-8,-2.8971183e-8,-2.8496245e-8,-2.8021308e-8,-2.754637e-8,-2.7071433e-8,-2.6596496e-8,-2.6121558e-8,-2.564662e-8,-2.5171683e-8,-2.4696746e-8,-2.4221809e-8,-2.3746871e-8,-2.3271934e-8,-2.2796996e-8,-2.2322059e-8,-2.1847121e-8,-2.1372184e-8,-2.0897247e-8,-2.042231e-8,-1.9947372e-8,-1.9472434e-8,-1.8997497e-8,-1.852256e-8,-1.8047622e-8,-1.7572685e-8,-1.7097747e-8,-1.662281e-8,-1.6147872e-8,-1.5672935e-8,-1.5197998e-8,-1.472306e-8,-1.4248123e-8,-1.3773185e-8,-1.3298248e-8,-1.282331e-8,-1.2348373e-8,-1.1873436e-8,-1.1398498e-8,-1.0923561e-8,-1.0448623e-8,-9.973686e-9,-9.4987485e-9,-9.023811e-9,-8.548874e-9,-8.073936e-9,-7.598999e-9,-7.1240613e-9,-6.649124e-9,-6.1741865e-9,-5.699249e-9,-5.2243116e-9,-4.7493742e-9,-4.274437e-9,-3.7994994e-9,-3.324562e-9,-2.8496245e-9,-2.3746871e-9,-1.8997497e-9,-1.4248123e-9,-9.498748e-10,-4.749374e-10,0.0,4.749374e-10,9.498748e-10,1.4248123e-9,1.8997497e-9,2.3746871e-9,2.8496245e-9,3.324562e-9,3.7994994e-9,4.274437e-9,4.7493742e-9,5.2243116e-9,5.699249e-9,6.1741865e-9,6.649124e-9,7.1240613e-9,7.598999e-9,8.073936e-9,8.548874e-9,9.023811e-9,9.4987485e-9,9.973686e-9,1.0448623e-8,1.0923561e-8,1.1398498e-8,1.1873436e-8,1.2348373e-8,1.282331e-8,1.3298248e-8,1.3773185e-8,1.4248123e-8,1.472306e-8,1.5197998e-8,1.5672935e-8,1.6147872e-8,1.662281e-8,1.7097747e-8,1.7572685e-8,1.8047622e-8,1.852256e-8,1.8997497e-8,1.9472434e-8,1.9947372e-8,2.042231e-8,2.0897247e-8,2.1372184e-8,2.1847121e-8,2.2322059e-8,2.2796996e-8,2.3271934e-8,2.3746871e-8,2.4221809e-8,2.4696746e-8,2.5171683e-8,2.564662e-8,2.6121558e-8,2.6596496e-8,2.7071433e-8,2.754637e-8,2.8021308e-8,2.8496245e-8,2.8971183e-8,2.944612e-8,2.9921058e-8,3.0395995e-8,3.0870932e-8,3.134587e-8,3.1820807e-8,3.2295745e-8,3.2770682e-8,3.324562e-8,3.3720557e-8,3.4195494e-8,3.4670432e-8,3.514537e-8,3.5620307e-8,3.6095244e-8,3.657018e-8,3.704512e-8,3.7520056e-8,3.7994994e-8,3.846993e-8,3.894487e-8,3.9419806e-8,3.9894744e-8,4.036968e-8,4.084462e-8,4.1319556e-8,4.1794493e-8,4.226943e-8,4.2744368e-8,4.3219305e-8,4.3694243e-8,4.416918e-8,4.4644118e-8,4.5119055e-8,4.5593993e-8,4.606893e-8,4.6543867e-8,4.7018805e-8,4.7493742e-8,4.796868e-8,4.8443617e-8,4.8918555e-8,4.9393492e-8,4.986843e-8,5.0343367e-8,5.0818304e-8,5.129324e-8,5.176818e-8,5.2243116e-8,5.2718054e-8,5.319299e-8,5.366793e-8,5.4142866e-8,5.4617804e-8,5.509274e-8,5.556768e-8,5.6042616e-8,5.6517553e-8,5.699249e-8,5.7467428e-8,5.7942366e-8,5.8417303e-8,5.889224e-8,5.9367178e-8,5.9842115e-8,6.031705e-8,6.079199e-8,6.1266924e-8,6.1741865e-8,6.22168e-8,6.269174e-8,6.3166674e-8,6.3641615e-8,6.411655e-8,6.459149e-8,6.506642e-8,6.5541364e-8,6.60163e-8,6.649124e-8,6.696617e-8,6.7441114e-8,6.791605e-8,6.839099e-8,6.886592e-8,6.9340864e-8,6.98158e-8,7.029074e-8,7.076567e-8,7.124061e-8,7.171555e-8,7.219049e-8,7.266542e-8,7.314036e-8,7.36153e-8,7.409024e-8,7.456517e-8,7.504011e-8,7.551505e-8,7.598999e-8,7.646492e-8,7.693986e-8,7.7414796e-8,7.788974e-8,7.836467e-8,7.883961e-8,7.9314546e-8,7.978949e-8,8.026442e-8,8.073936e-8,8.1214296e-8,8.168924e-8,8.216417e-8,8.263911e-8,8.3114045e-8,8.3588986e-8,8.406392e-8,8.453886e-8,8.5013795e-8,8.5488736e-8,8.596367e-8,8.643861e-8,8.6913545e-8,8.7388486e-8,8.786342e-8,8.833836e-8,8.8813294e-8,8.9288235e-8,8.976317e-8,9.023811e-8,9.0713044e-8,9.1187985e-8,9.166292e-8,9.213786e-8,9.2612794e-8,9.3087735e-8,9.356267e-8,9.403761e-8,9.4512544e-8,9.4987485e-8,9.546242e-8,9.593736e-8,9.641229e-8,9.6887234e-8,9.736217e-8,9.783711e-8,9.831204e-8,9.8786984e-8,9.926192e-8,9.973686e-8,1.0021179e-7,1.00686734e-7,1.0116167e-7,1.0163661e-7,1.0211154e-7,1.0258648e-7,1.0306142e-7,1.0353636e-7,1.0401129e-7,1.0448623e-7,1.0496117e-7,1.0543611e-7,1.0591104e-7,1.0638598e-7,1.0686092e-7,1.0733586e-7,1.0781079e-7,1.0828573e-7,1.08760666e-7,1.0923561e-7,1.0971054e-7,1.1018548e-7,1.10660416e-7,1.1113536e-7,1.1161029e-7,1.1208523e-7,1.12560166e-7,1.1303511e-7,1.1351004e-7,1.1398498e-7,1.14459915e-7,1.14934856e-7,1.1540979e-7,1.1588473e-7,1.16359665e-7,1.16834606e-7,1.1730954e-7,1.1778448e-7,1.18259415e-7,1.18734356e-7,1.1920929e-7]} diff --git a/lib/node_modules/@stdlib/math/base/special/exp2f/test/test.js b/lib/node_modules/@stdlib/math/base/special/exp2f/test/test.js new file mode 100644 index 000000000000..b8e824deac85 --- /dev/null +++ b/lib/node_modules/@stdlib/math/base/special/exp2f/test/test.js @@ -0,0 +1,189 @@ +/** +* @license Apache-2.0 +* +* Copyright (c) 2026 The Stdlib Authors. +* +* Licensed under the Apache License, Version 2.0 (the "License"); +* you may not use this file except in compliance with the License. +* You may obtain a copy of the License at +* +* http://www.apache.org/licenses/LICENSE-2.0 +* +* Unless required by applicable law or agreed to in writing, software +* distributed under the License is distributed on an "AS IS" BASIS, +* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +* See the License for the specific language governing permissions and +* limitations under the License. +*/ + +'use strict'; + +// MODULES // + +var tape = require( 'tape' ); +var isnanf = require( '@stdlib/math/base/assert/is-nanf' ); +var abs = require( '@stdlib/math/base/special/abs' ); +var PINF = require( '@stdlib/constants/float32/pinf' ); +var NINF = require( '@stdlib/constants/float32/ninf' ); +var EPS = require( '@stdlib/constants/float32/eps' ); +var isPositiveZero = require( '@stdlib/assert/is-positive-zero' ); +var exp2f = require( './../lib' ); + + +// FIXTURES // + +var mediumNegative = require( './fixtures/julia/medium_negative.json' ); +var mediumPositive = require( './fixtures/julia/medium_positive.json' ); +var smallNegative = require( './fixtures/julia/small_negative.json' ); +var smallPositive = require( './fixtures/julia/small_positive.json' ); +var tiny = require( './fixtures/julia/tiny.json' ); + + +// TESTS // + +tape( 'main export is a function', function test( t ) { + t.ok( true, __filename ); + t.strictEqual( typeof exp2f, 'function', 'main export is a function' ); + t.end(); +}); + +tape( 'the function accurately computes `2**x` for negative medium numbers', function test( t ) { + var expected; + var delta; + var tol; + var x; + var v; + var i; + + x = mediumNegative.x; + expected = mediumNegative.expected; + + for ( i = 0; i < x.length; i++ ) { + v = exp2f( x[ i ] ); + delta = abs( v - expected[ i ] ); + tol = EPS * abs( expected[ i ] ); + t.ok( delta <= tol, 'within tolerance. x: ' + x[ i ] + '. Value: ' + v + '. Expected: ' + expected[ i ] + '. Delta: ' + delta + '. Tolerance: ' + tol + '.' ); + } + t.end(); +}); + +tape( 'the function accurately computes `2**x` for positive medium numbers', function test( t ) { + var expected; + var delta; + var tol; + var x; + var v; + var i; + + x = mediumPositive.x; + expected = mediumPositive.expected; + + for ( i = 0; i < x.length; i++ ) { + v = exp2f( x[ i ] ); + delta = abs( v - expected[ i ] ); + tol = EPS * abs( expected[ i ] ); + t.ok( delta <= tol, 'within tolerance. x: ' + x[ i ] + '. Value: ' + v + '. Expected: ' + expected[ i ] + '. Delta: ' + delta + '. Tolerance: ' + tol + '.' ); + } + t.end(); +}); + +tape( 'the function accurately computes `2**x` for negative small numbers', function test( t ) { + var expected; + var delta; + var tol; + var x; + var v; + var i; + + x = smallNegative.x; + expected = smallNegative.expected; + + for ( i = 0; i < x.length; i++ ) { + v = exp2f( x[ i ] ); + delta = abs( v - expected[ i ] ); + tol = EPS * abs( expected[ i ] ); + t.ok( delta <= tol, 'within tolerance. x: ' + x[ i ] + '. Value: ' + v + '. Expected: ' + expected[ i ] + '. Delta: ' + delta + '. Tolerance: ' + tol + '.' ); + } + t.end(); +}); + +tape( 'the function accurately computes `2**x` for positive small numbers', function test( t ) { + var expected; + var delta; + var tol; + var x; + var v; + var i; + + x = smallPositive.x; + expected = smallPositive.expected; + + for ( i = 0; i < x.length; i++ ) { + v = exp2f( x[ i ] ); + delta = abs( v - expected[ i ] ); + tol = EPS * abs( expected[ i ] ); + t.ok( delta <= tol, 'within tolerance. x: ' + x[ i ] + '. Value: ' + v + '. Expected: ' + expected[ i ] + '. Delta: ' + delta + '. Tolerance: ' + tol + '.' ); + } + t.end(); +}); + +tape( 'the function accurately computes `2**x` for very small `x`', function test( t ) { + var expected; + var delta; + var tol; + var x; + var v; + var i; + + x = tiny.x; + expected = tiny.expected; + + for ( i = 0; i < x.length; i++ ) { + v = exp2f( x[ i ] ); + delta = abs( v - expected[ i ] ); + tol = EPS * abs( expected[ i ] ); + t.ok( delta <= tol, 'within tolerance. x: ' + x[ i ] + '. Value: ' + v + '. Expected: ' + expected[ i ] + '. Delta: ' + delta + '. Tolerance: ' + tol + '.' ); + } + t.end(); +}); + +tape( 'the function returns `+infinity` for very large `x`', function test( t ) { + t.strictEqual( exp2f( 200.0 ), PINF, 'equals +infinity' ); + t.strictEqual( exp2f( 300.0 ), PINF, 'equals +infinity' ); + t.end(); +}); + +tape( 'the function returns `0.0` for negative large `x`', function test( t ) { + t.strictEqual( exp2f( -200.0 ), 0.0, 'equals 0' ); + t.strictEqual( exp2f( -300.0 ), 0.0, 'equals 0' ); + t.end(); +}); + +tape( 'the function returns `0.0` if provided `-infinity`', function test( t ) { + var val = exp2f( NINF ); + t.strictEqual( isPositiveZero( val ), true, 'returns expected value' ); + t.end(); +}); + +tape( 'the function returns `+infinity` if provided `+infinity`', function test( t ) { + t.strictEqual( exp2f( PINF ), PINF, 'equals +infinity' ); + t.end(); +}); + +tape( 'the function returns `1` if provided `+-0`', function test( t ) { + var v; + + v = exp2f( -0.0 ); + t.strictEqual( v, 1.0, 'returns expected value' ); + + v = exp2f( +0.0 ); + t.strictEqual( v, 1.0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function returns `NaN` if provided `NaN`', function test( t ) { + var val = exp2f( NaN ); + t.strictEqual( isnanf( val ), true, 'equals NaN' ); + t.end(); +}); diff --git a/lib/node_modules/@stdlib/math/base/special/exp2f/test/test.native.js b/lib/node_modules/@stdlib/math/base/special/exp2f/test/test.native.js new file mode 100644 index 000000000000..30fd094f0ba7 --- /dev/null +++ b/lib/node_modules/@stdlib/math/base/special/exp2f/test/test.native.js @@ -0,0 +1,198 @@ +/** +* @license Apache-2.0 +* +* Copyright (c) 2026 The Stdlib Authors. +* +* Licensed under the Apache License, Version 2.0 (the "License"); +* you may not use this file except in compliance with the License. +* You may obtain a copy of the License at +* +* http://www.apache.org/licenses/LICENSE-2.0 +* +* Unless required by applicable law or agreed to in writing, software +* distributed under the License is distributed on an "AS IS" BASIS, +* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +* See the License for the specific language governing permissions and +* limitations under the License. +*/ + +'use strict'; + +// MODULES // + +var resolve = require( 'path' ).resolve; +var tape = require( 'tape' ); +var isnanf = require( '@stdlib/math/base/assert/is-nanf' ); +var abs = require( '@stdlib/math/base/special/abs' ); +var PINF = require( '@stdlib/constants/float32/pinf' ); +var NINF = require( '@stdlib/constants/float32/ninf' ); +var EPS = require( '@stdlib/constants/float32/eps' ); +var isPositiveZero = require( '@stdlib/assert/is-positive-zero' ); +var tryRequire = require( '@stdlib/utils/try-require' ); + + +// FIXTURES // + +var mediumNegative = require( './fixtures/julia/medium_negative.json' ); +var mediumPositive = require( './fixtures/julia/medium_positive.json' ); +var smallNegative = require( './fixtures/julia/small_negative.json' ); +var smallPositive = require( './fixtures/julia/small_positive.json' ); +var tiny = require( './fixtures/julia/tiny.json' ); + + +// VARIABLES // + +var exp2f = tryRequire( resolve( __dirname, './../lib/native.js' ) ); +var opts = { + 'skip': ( exp2f instanceof Error ) +}; + + +// TESTS // + +tape( 'main export is a function', opts, function test( t ) { + t.ok( true, __filename ); + t.strictEqual( typeof exp2f, 'function', 'main export is a function' ); + t.end(); +}); + +tape( 'the function accurately computes `2**x` for negative medium numbers', opts, function test( t ) { + var expected; + var delta; + var tol; + var x; + var v; + var i; + + x = mediumNegative.x; + expected = mediumNegative.expected; + + for ( i = 0; i < x.length; i++ ) { + v = exp2f( x[ i ] ); + delta = abs( v - expected[ i ] ); + tol = EPS * abs( expected[ i ] ); + t.ok( delta <= tol, 'within tolerance. x: ' + x[ i ] + '. Value: ' + v + '. Expected: ' + expected[ i ] + '. Delta: ' + delta + '. Tolerance: ' + tol + '.' ); + } + t.end(); +}); + +tape( 'the function accurately computes `2**x` for positive medium numbers', opts, function test( t ) { + var expected; + var delta; + var tol; + var x; + var v; + var i; + + x = mediumPositive.x; + expected = mediumPositive.expected; + + for ( i = 0; i < x.length; i++ ) { + v = exp2f( x[ i ] ); + delta = abs( v - expected[ i ] ); + tol = EPS * abs( expected[ i ] ); + t.ok( delta <= tol, 'within tolerance. x: ' + x[ i ] + '. Value: ' + v + '. Expected: ' + expected[ i ] + '. Delta: ' + delta + '. Tolerance: ' + tol + '.' ); + } + t.end(); +}); + +tape( 'the function accurately computes `2**x` for negative small numbers', opts, function test( t ) { + var expected; + var delta; + var tol; + var x; + var v; + var i; + + x = smallNegative.x; + expected = smallNegative.expected; + + for ( i = 0; i < x.length; i++ ) { + v = exp2f( x[ i ] ); + delta = abs( v - expected[ i ] ); + tol = EPS * abs( expected[ i ] ); + t.ok( delta <= tol, 'within tolerance. x: ' + x[ i ] + '. Value: ' + v + '. Expected: ' + expected[ i ] + '. Delta: ' + delta + '. Tolerance: ' + tol + '.' ); + } + t.end(); +}); + +tape( 'the function accurately computes `2**x` for positive small numbers', opts, function test( t ) { + var expected; + var delta; + var tol; + var x; + var v; + var i; + + x = smallPositive.x; + expected = smallPositive.expected; + + for ( i = 0; i < x.length; i++ ) { + v = exp2f( x[ i ] ); + delta = abs( v - expected[ i ] ); + tol = EPS * abs( expected[ i ] ); + t.ok( delta <= tol, 'within tolerance. x: ' + x[ i ] + '. Value: ' + v + '. Expected: ' + expected[ i ] + '. Delta: ' + delta + '. Tolerance: ' + tol + '.' ); + } + t.end(); +}); + +tape( 'the function accurately computes `2**x` for very small `x`', opts, function test( t ) { + var expected; + var delta; + var tol; + var x; + var v; + var i; + + x = tiny.x; + expected = tiny.expected; + + for ( i = 0; i < x.length; i++ ) { + v = exp2f( x[ i ] ); + delta = abs( v - expected[ i ] ); + tol = EPS * abs( expected[ i ] ); + t.ok( delta <= tol, 'within tolerance. x: ' + x[ i ] + '. Value: ' + v + '. Expected: ' + expected[ i ] + '. Delta: ' + delta + '. Tolerance: ' + tol + '.' ); + } + t.end(); +}); + +tape( 'the function returns `+infinity` for very large `x`', opts, function test( t ) { + t.strictEqual( exp2f( 200.0 ), PINF, 'equals +infinity' ); + t.strictEqual( exp2f( 300.0 ), PINF, 'equals +infinity' ); + t.end(); +}); + +tape( 'the function returns `0.0` for negative large `x`', opts, function test( t ) { + t.strictEqual( exp2f( -200.0 ), 0.0, 'equals 0' ); + t.strictEqual( exp2f( -300.0 ), 0.0, 'equals 0' ); + t.end(); +}); + +tape( 'the function returns `0.0` if provided `-infinity`', opts, function test( t ) { + var val = exp2f( NINF ); + t.strictEqual( isPositiveZero( val ), true, 'returns expected value' ); + t.end(); +}); + +tape( 'the function returns `+infinity` if provided `+infinity`', opts, function test( t ) { + t.strictEqual( exp2f( PINF ), PINF, 'equals +infinity' ); + t.end(); +}); + +tape( 'the function returns `1` if provided `+-0`', opts, function test( t ) { + var v; + + v = exp2f( -0.0 ); + t.strictEqual( v, 1.0, 'returns expected value' ); + + v = exp2f( +0.0 ); + t.strictEqual( v, 1.0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function returns `NaN` if provided `NaN`', opts, function test( t ) { + var val = exp2f( NaN ); + t.strictEqual( isnanf( val ), true, 'equals NaN' ); + t.end(); +});