From ab0a354aa3ac3984b6cca43862c1c0b46cd60f36 Mon Sep 17 00:00:00 2001 From: AtharvaPatange <164712914+AtharvaPatange@users.noreply.github.com> Date: Thu, 22 Oct 2026 11:27:02 +0530 Subject: [PATCH 1/2] feat: add C implementation for blas/ext/base/ndarray/ssort --- .../blas/ext/base/ndarray/ssort/README.md | 176 ++++++++++++++- .../base/ndarray/ssort/benchmark/benchmark.js | 2 +- .../ssort/benchmark/benchmark.native.js | 113 ++++++++++ .../base/ndarray/ssort/benchmark/c/Makefile | 146 +++++++++++++ .../ssort/benchmark/c/benchmark.length.c | 195 +++++++++++++++++ .../blas/ext/base/ndarray/ssort/binding.gyp | 170 +++++++++++++++ .../base/ndarray/ssort/docs/types/index.d.ts | 2 +- .../ext/base/ndarray/ssort/docs/types/test.ts | 4 +- .../base/ndarray/ssort/examples/c/Makefile | 146 +++++++++++++ .../base/ndarray/ssort/examples/c/example.c | 87 ++++++++ .../ext/base/ndarray/ssort/examples/index.js | 4 +- .../blas/ext/base/ndarray/ssort/include.gypi | 53 +++++ .../stdlib/blas/ext/base/ndarray/ssort.h | 40 ++++ .../blas/ext/base/ndarray/ssort/lib/index.js | 18 +- .../blas/ext/base/ndarray/ssort/lib/main.js | 2 +- .../blas/ext/base/ndarray/ssort/lib/native.js | 76 +++++++ .../blas/ext/base/ndarray/ssort/manifest.json | 109 ++++++++++ .../blas/ext/base/ndarray/ssort/package.json | 4 + .../blas/ext/base/ndarray/ssort/src/Makefile | 70 ++++++ .../blas/ext/base/ndarray/ssort/src/addon.c | 64 ++++++ .../blas/ext/base/ndarray/ssort/src/main.c | 50 +++++ .../blas/ext/base/ndarray/ssort/test/test.js | 72 +++--- .../ext/base/ndarray/ssort/test/test.main.js | 196 +++++++++++++++++ .../base/ndarray/ssort/test/test.native.js | 205 ++++++++++++++++++ 24 files changed, 1953 insertions(+), 51 deletions(-) create mode 100644 lib/node_modules/@stdlib/blas/ext/base/ndarray/ssort/benchmark/benchmark.native.js create mode 100644 lib/node_modules/@stdlib/blas/ext/base/ndarray/ssort/benchmark/c/Makefile create mode 100644 lib/node_modules/@stdlib/blas/ext/base/ndarray/ssort/benchmark/c/benchmark.length.c create mode 100644 lib/node_modules/@stdlib/blas/ext/base/ndarray/ssort/binding.gyp create mode 100644 lib/node_modules/@stdlib/blas/ext/base/ndarray/ssort/examples/c/Makefile create mode 100644 lib/node_modules/@stdlib/blas/ext/base/ndarray/ssort/examples/c/example.c create mode 100644 lib/node_modules/@stdlib/blas/ext/base/ndarray/ssort/include.gypi create mode 100644 lib/node_modules/@stdlib/blas/ext/base/ndarray/ssort/include/stdlib/blas/ext/base/ndarray/ssort.h create mode 100644 lib/node_modules/@stdlib/blas/ext/base/ndarray/ssort/lib/native.js create mode 100644 lib/node_modules/@stdlib/blas/ext/base/ndarray/ssort/manifest.json create mode 100644 lib/node_modules/@stdlib/blas/ext/base/ndarray/ssort/src/Makefile create mode 100644 lib/node_modules/@stdlib/blas/ext/base/ndarray/ssort/src/addon.c create mode 100644 lib/node_modules/@stdlib/blas/ext/base/ndarray/ssort/src/main.c create mode 100644 lib/node_modules/@stdlib/blas/ext/base/ndarray/ssort/test/test.main.js create mode 100644 lib/node_modules/@stdlib/blas/ext/base/ndarray/ssort/test/test.native.js diff --git a/lib/node_modules/@stdlib/blas/ext/base/ndarray/ssort/README.md b/lib/node_modules/@stdlib/blas/ext/base/ndarray/ssort/README.md index 52ab80db6ed0..9cadde0f4137 100644 --- a/lib/node_modules/@stdlib/blas/ext/base/ndarray/ssort/README.md +++ b/lib/node_modules/@stdlib/blas/ext/base/ndarray/ssort/README.md @@ -47,7 +47,7 @@ var scalar2ndarray = require( '@stdlib/ndarray/from-scalar' ); var x = new Float32Vector( [ 1.0, -2.0, 3.0, -4.0 ] ); var order = scalar2ndarray( 1.0, { - 'dtype': 'generic' + 'dtype': 'float32' }); var out = ssort( [ x, order ] ); @@ -97,14 +97,14 @@ var x = uniform( [ 10 ], -100, 100, { console.log( ndarray2array( x ) ); var order = scalar2ndarray( 1.0, { - 'dtype': 'generic' + 'dtype': 'float32' }); ssort( [ x, order ] ); console.log( ndarray2array( x ) ); order = scalar2ndarray( -1.0, { - 'dtype': 'generic' + 'dtype': 'float32' }); ssort( [ x, order ] ); @@ -115,6 +115,176 @@ console.log( ndarray2array( x ) ); + + +* * * + +
+ +## C APIs + + + +
+ +
+ + + + + +
+ +### Usage + +```c +#include "stdlib/blas/ext/base/ndarray/ssort.h" +``` + +#### stdlib_blas_ext_ssort( arrays ) + +Sorts a one-dimensional single-precision floating-point ndarray. + +```c +#include "stdlib/ndarray/ctor.h" +#include "stdlib/ndarray/dtypes.h" +#include "stdlib/ndarray/index_modes.h" +#include "stdlib/ndarray/orders.h" +#include "stdlib/ndarray/base/bytes_per_element.h" +#include + +// Create an ndarray: +float data[] = { 1.0f, -2.0f, 3.0f, -4.0f }; +int64_t shape[] = { 4 }; +int64_t strides[] = { STDLIB_NDARRAY_FLOAT32_BYTES_PER_ELEMENT }; +int8_t submodes[] = { STDLIB_NDARRAY_INDEX_ERROR }; + +struct ndarray *x = stdlib_ndarray_allocate( STDLIB_NDARRAY_FLOAT32, (uint8_t *)data, 1, shape, strides, 0, STDLIB_NDARRAY_ROW_MAJOR, STDLIB_NDARRAY_INDEX_ERROR, 1, submodes ); + +// Create an ndarray specifying the sort order: +const float odata[] = { 1.0f }; +int64_t ostrides[] = { 0 }; + +struct ndarray *order = stdlib_ndarray_allocate( STDLIB_NDARRAY_FLOAT32, (uint8_t *)odata, 0, NULL, ostrides, 0, STDLIB_NDARRAY_ROW_MAJOR, STDLIB_NDARRAY_INDEX_ERROR, 1, submodes ); + +// Sort the ndarray: +const struct ndarray *arrays[] = { x, order }; +stdlib_blas_ext_ssort( arrays ); + +// Free allocated memory: +stdlib_ndarray_free( x ); +stdlib_ndarray_free( order ); +``` + +The function accepts the following arguments: + +- **arrays**: `[in] struct ndarray**` list containing the following ndarrays: + + - `[inout] struct ndarray*` a one-dimensional input ndarray. + - `[in] struct ndarray*` a zero-dimensional ndarray specifying the sort order. + +```c +void stdlib_blas_ext_ssort( const struct ndarray *arrays[] ); +``` + +
+ + + + + +
+ +
+ + + + + +
+ +### Examples + +```c +#include "stdlib/blas/ext/base/ndarray/ssort.h" +#include "stdlib/ndarray/ctor.h" +#include "stdlib/ndarray/dtypes.h" +#include "stdlib/ndarray/index_modes.h" +#include "stdlib/ndarray/orders.h" +#include "stdlib/ndarray/base/bytes_per_element.h" +#include +#include +#include + +int main( void ) { + // Create a data buffer: + float data[] = { 1.0f, -2.0f, 3.0f, -4.0f }; + + // Specify the number of array dimensions: + const int64_t ndims = 1; + + // Specify the array shape: + int64_t shape[] = { 4 }; + + // Specify the array strides: + int64_t strides[] = { STDLIB_NDARRAY_FLOAT32_BYTES_PER_ELEMENT }; + + // Specify the byte offset: + const int64_t offset = 0; + + // Specify the array order: + const enum STDLIB_NDARRAY_ORDER order = STDLIB_NDARRAY_ROW_MAJOR; + + // Specify the index mode: + const enum STDLIB_NDARRAY_INDEX_MODE imode = STDLIB_NDARRAY_INDEX_ERROR; + + // Specify the subscript index modes: + int8_t submodes[] = { STDLIB_NDARRAY_INDEX_ERROR }; + const int64_t nsubmodes = 1; + + // Create an ndarray: + // cppcheck-suppress invalidPointerCast + struct ndarray *x = stdlib_ndarray_allocate( STDLIB_NDARRAY_FLOAT32, (uint8_t *)data, ndims, shape, strides, offset, order, imode, nsubmodes, submodes ); + + // Create a data buffer for an ndarray specifying the sort order: + const float odata[] = { 1.0f }; + + // Specify the array strides for a zero-dimensional ndarray: + int64_t ostrides[] = { 0 }; + + // Create an ndarray specifying the sort order: + // cppcheck-suppress invalidPointerCast + struct ndarray *ord = stdlib_ndarray_allocate( STDLIB_NDARRAY_FLOAT32, (uint8_t *)odata, 0, NULL, ostrides, 0, order, imode, nsubmodes, submodes ); + if ( x == NULL || ord == NULL ) { + fprintf( stderr, "Error allocating memory.\n" ); + exit( 1 ); + } + + // Define a list of ndarrays: + const struct ndarray *arrays[] = { x, ord }; + + // Sort the ndarray: + stdlib_blas_ext_ssort( arrays ); + + // Print the result: + for ( int i = 0; i < 4; i++ ) { + printf( "x[ %i ] = %f\n", i, data[ i ] ); + } + + // Free allocated memory: + stdlib_ndarray_free( x ); + stdlib_ndarray_free( ord ); +} +``` + +
+ + + +
+ + +
diff --git a/lib/node_modules/@stdlib/blas/ext/base/ndarray/ssort/benchmark/benchmark.js b/lib/node_modules/@stdlib/blas/ext/base/ndarray/ssort/benchmark/benchmark.js index e008968a4bfd..c73f8c0620fa 100644 --- a/lib/node_modules/@stdlib/blas/ext/base/ndarray/ssort/benchmark/benchmark.js +++ b/lib/node_modules/@stdlib/blas/ext/base/ndarray/ssort/benchmark/benchmark.js @@ -26,7 +26,7 @@ var pow = require( '@stdlib/math/base/special/pow' ); var format = require( '@stdlib/string/format' ); var scalar2ndarray = require( '@stdlib/ndarray/from-scalar' ); var pkg = require( './../package.json' ).name; -var ssort = require( './../lib' ); +var ssort = require( './../lib/main.js' ); // VARIABLES // diff --git a/lib/node_modules/@stdlib/blas/ext/base/ndarray/ssort/benchmark/benchmark.native.js b/lib/node_modules/@stdlib/blas/ext/base/ndarray/ssort/benchmark/benchmark.native.js new file mode 100644 index 000000000000..4b8bf00448ee --- /dev/null +++ b/lib/node_modules/@stdlib/blas/ext/base/ndarray/ssort/benchmark/benchmark.native.js @@ -0,0 +1,113 @@ +/** +* @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/uniform' ); +var pow = require( '@stdlib/math/base/special/pow' ); +var format = require( '@stdlib/string/format' ); +var scalar2ndarray = require( '@stdlib/ndarray/from-scalar' ); +var tryRequire = require( '@stdlib/utils/try-require' ); +var pkg = require( './../package.json' ).name; + + +// VARIABLES // + +var ssort = tryRequire( resolve( __dirname, './../lib/native.js' ) ); +var opts = { + 'skip': ( ssort instanceof Error ) +}; +var options = { + 'dtype': 'float32' +}; + + +// FUNCTIONS // + +/** +* Creates a benchmark function. +* +* @private +* @param {PositiveInteger} len - array length +* @returns {Function} benchmark function +*/ +function createBenchmark( len ) { + var order; + var x; + + x = uniform( [ len ], 0.0, 100.0, options ); + order = scalar2ndarray( -1.0, options ); + + return benchmark; + + /** + * Benchmark function. + * + * @private + * @param {Benchmark} b - benchmark instance + */ + function benchmark( b ) { + var out; + var i; + + b.tic(); + for ( i = 0; i < b.iterations; i++ ) { + out = ssort( [ x, order ] ); + if ( typeof out !== 'object' ) { + b.fail( 'should return an ndarray' ); + } + } + b.toc(); + if ( typeof out !== 'object' ) { + b.fail( 'should return an ndarray' ); + } + b.pass( 'benchmark finished' ); + b.end(); + } +} + + +// MAIN // + +/** +* Main execution sequence. +* +* @private +*/ +function main() { + var len; + var min; + var max; + var f; + var i; + + min = 1; // 10^min + max = 6; // 10^max + + for ( i = min; i <= max; i++ ) { + len = pow( 10, i ); + f = createBenchmark( len ); + bench( format( '%s::native:len=%d', pkg, len ), opts, f ); + } +} + +main(); diff --git a/lib/node_modules/@stdlib/blas/ext/base/ndarray/ssort/benchmark/c/Makefile b/lib/node_modules/@stdlib/blas/ext/base/ndarray/ssort/benchmark/c/Makefile new file mode 100644 index 000000000000..a660387d65c8 --- /dev/null +++ b/lib/node_modules/@stdlib/blas/ext/base/ndarray/ssort/benchmark/c/Makefile @@ -0,0 +1,146 @@ +#/ +# @license Apache-2.0 +# +# Copyright (c) 2026 The Stdlib Authors. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +#/ + +# VARIABLES # + +ifndef VERBOSE + QUIET := @ +else + QUIET := +endif + +# Determine the OS ([1][1], [2][2]). +# +# [1]: https://en.wikipedia.org/wiki/Uname#Examples +# [2]: http://stackoverflow.com/a/27776822/2225624 +OS ?= $(shell uname) +ifneq (, $(findstring MINGW,$(OS))) + OS := WINNT +else +ifneq (, $(findstring MSYS,$(OS))) + OS := WINNT +else +ifneq (, $(findstring CYGWIN,$(OS))) + OS := WINNT +else +ifneq (, $(findstring Windows_NT,$(OS))) + OS := WINNT +endif +endif +endif +endif + +# Define the program used for compiling C source files: +ifdef C_COMPILER + CC := $(C_COMPILER) +else + CC := gcc +endif + +# Define the command-line options when compiling C files: +CFLAGS ?= \ + -std=c99 \ + -O3 \ + -Wall \ + -pedantic + +# Determine whether to generate position independent code ([1][1], [2][2]). +# +# [1]: https://gcc.gnu.org/onlinedocs/gcc/Code-Gen-Options.html#Code-Gen-Options +# [2]: http://stackoverflow.com/questions/5311515/gcc-fpic-option +ifeq ($(OS), WINNT) + fPIC ? +else + fPIC ?= -fPIC +endif + +# List of includes (e.g., `-I /foo/bar -I /beep/boop/include`): +INCLUDE ?= + +# List of source files: +SOURCE_FILES ?= + +# List of libraries (e.g., `-lopenblas -lpthread`): +LIBRARIES ?= + +# List of library paths (e.g., `-L /foo/bar -L /beep/boop`): +LIBPATH ?= + +# List of C targets: +c_targets := benchmark.length.out + + +# RULES # + +#/ +# Compiles source files. +# +# @param {string} [C_COMPILER] - C compiler (e.g., `gcc`) +# @param {string} [CFLAGS] - C compiler options +# @param {(string|void)} [fPIC] - compiler flag determining whether to generate position independent code (e.g., `-fPIC`) +# @param {string} [INCLUDE] - list of includes (e.g., `-I /foo/bar -I /beep/boop/include`) +# @param {string} [SOURCE_FILES] - list of source files +# @param {string} [LIBPATH] - list of library paths (e.g., `-L /foo/bar -L /beep/boop`) +# @param {string} [LIBRARIES] - list of libraries (e.g., `-lopenblas -lpthread`) +# +# @example +# make +# +# @example +# make all +#/ +all: $(c_targets) + +.PHONY: all + +#/ +# Compiles C source files. +# +# @private +# @param {string} CC - C compiler (e.g., `gcc`) +# @param {string} CFLAGS - C compiler options +# @param {(string|void)} fPIC - compiler flag determining whether to generate position independent code (e.g., `-fPIC`) +# @param {string} INCLUDE - list of includes (e.g., `-I /foo/bar`) +# @param {string} SOURCE_FILES - list of source files +# @param {string} LIBPATH - list of library paths (e.g., `-L /foo/bar`) +# @param {string} LIBRARIES - list of libraries (e.g., `-lopenblas`) +#/ +$(c_targets): %.out: %.c + $(QUIET) $(CC) $(CFLAGS) $(fPIC) $(INCLUDE) -o $@ $(SOURCE_FILES) $< $(LIBPATH) -lm $(LIBRARIES) + +#/ +# Runs compiled benchmarks. +# +# @example +# make run +#/ +run: $(c_targets) + $(QUIET) ./$< + +.PHONY: run + +#/ +# Removes generated files. +# +# @example +# make clean +#/ +clean: + $(QUIET) -rm -f *.o *.out + +.PHONY: clean diff --git a/lib/node_modules/@stdlib/blas/ext/base/ndarray/ssort/benchmark/c/benchmark.length.c b/lib/node_modules/@stdlib/blas/ext/base/ndarray/ssort/benchmark/c/benchmark.length.c new file mode 100644 index 000000000000..4a0d32bb697e --- /dev/null +++ b/lib/node_modules/@stdlib/blas/ext/base/ndarray/ssort/benchmark/c/benchmark.length.c @@ -0,0 +1,195 @@ +/** +* @license Apache-2.0 +* +* Copyright (c) 2026 The Stdlib Authors. +* +* Licensed under the Apache License, Version 2.0 (the "License"); +* you may not use this file except in compliance with the License. +* You may obtain a copy of the License at +* +* http://www.apache.org/licenses/LICENSE-2.0 +* +* Unless required by applicable law or agreed to in writing, software +* distributed under the License is distributed on an "AS IS" BASIS, +* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +* See the License for the specific language governing permissions and +* limitations under the License. +*/ + +#include "stdlib/blas/ext/base/ndarray/ssort.h" +#include "stdlib/ndarray/ctor.h" +#include "stdlib/ndarray/dtypes.h" +#include "stdlib/ndarray/index_modes.h" +#include "stdlib/ndarray/orders.h" +#include "stdlib/ndarray/base/bytes_per_element.h" +#include +#include +#include +#include +#include +#include + +#define NAME "ssort" +#define ITERATIONS 1000000 +#define REPEATS 3 +#define MIN 1 +#define MAX 6 + +/** +* Prints the TAP version. +*/ +static void print_version( void ) { + printf( "TAP version 13\n" ); +} + +/** +* Prints the TAP summary. +* +* @param total total number of tests +* @param passing total number of passing tests +*/ +static void print_summary( int total, int passing ) { + printf( "#\n" ); + printf( "1..%d\n", total ); // TAP plan + printf( "# total %d\n", total ); + printf( "# pass %d\n", passing ); + printf( "#\n" ); + printf( "# ok\n" ); +} + +/** +* Prints benchmarks results. +* +* @param iterations number of iterations +* @param elapsed elapsed time in seconds +*/ +static void print_results( int iterations, double elapsed ) { + double rate = (double)iterations / elapsed; + printf( " ---\n" ); + printf( " iterations: %d\n", iterations ); + printf( " elapsed: %0.9f\n", elapsed ); + printf( " rate: %0.9f\n", rate ); + printf( " ...\n" ); +} + +/** +* Returns a clock time. +* +* @return clock time +*/ +static double tic( void ) { + struct timeval now; + gettimeofday( &now, NULL ); + return (double)now.tv_sec + (double)now.tv_usec/1.0e6; +} + +/** +* Generates a random number on the interval [0,1). +* +* @return random number +*/ +static float rand_float( void ) { + int r = rand(); + return (float)r / ( (float)RAND_MAX + 1.0f ); +} + +/** +* Runs a benchmark. +* +* @param iterations number of iterations +* @param len array length +* @return elapsed time in seconds +*/ +static double benchmark( int iterations, int len ) { + enum STDLIB_NDARRAY_INDEX_MODE imode; + const struct ndarray *arrays[ 2 ]; + enum STDLIB_NDARRAY_ORDER order; + int8_t submodes[ 1 ]; + int64_t strides[ 1 ]; + int64_t shape[ 1 ]; + int64_t nsubmodes; + struct ndarray *x; + struct ndarray *ord_arr; + int64_t offset; + double elapsed; + int64_t ndims; + float *data; + float *ord_data; + double t; + int i; + + ndims = 1; + shape[ 0 ] = len; + strides[ 0 ] = STDLIB_NDARRAY_FLOAT32_BYTES_PER_ELEMENT; + offset = 0; + order = STDLIB_NDARRAY_ROW_MAJOR; + imode = STDLIB_NDARRAY_INDEX_ERROR; + submodes[ 0 ] = imode; + nsubmodes = 1; + + data = (float *) malloc( len * sizeof( float ) ); + for ( i = 0; i < len; i++ ) { + data[ i ] = ( rand_float() * 20000.0f ) - 10000.0f; + } + // cppcheck-suppress invalidPointerCast + x = stdlib_ndarray_allocate( STDLIB_NDARRAY_FLOAT32, (uint8_t *)data, ndims, shape, strides, offset, order, imode, nsubmodes, submodes ); + arrays[ 0 ] = x; + + ord_data = (float *) malloc( 1 * sizeof( float ) ); + ord_data[ 0 ] = 1.0f; + + // cppcheck-suppress invalidPointerCast + ord_arr = stdlib_ndarray_allocate( STDLIB_NDARRAY_FLOAT32, (uint8_t *)ord_data, 0, NULL, NULL, 0, order, imode, nsubmodes, submodes ); + arrays[ 1 ] = ord_arr; + + t = tic(); + for ( i = 0; i < iterations; i++ ) { + stdlib_blas_ext_ssort( arrays ); + if ( data[ 0 ] != data[ 0 ] ) { + printf( "should not return NaN\n" ); + break; + } + } + elapsed = tic() - t; + if ( data[ 0 ] != data[ 0 ] ) { + printf( "should not return NaN\n" ); + } + stdlib_ndarray_free( x ); + stdlib_ndarray_free( ord_arr ); + free( data ); + free( ord_data ); + arrays[ 0 ] = NULL; + arrays[ 1 ] = NULL; + + return elapsed; +} + +/** +* Main execution sequence. +*/ +int main( void ) { + double elapsed; + int count; + int iter; + int len; + int i; + int j; + + // Use the current time to seed the random number generator: + srand( time( NULL ) ); + + print_version(); + count = 0; + for ( i = MIN; i <= MAX; i++ ) { + len = pow( 10, i ); + iter = ITERATIONS / pow( 10, i-1 ); + for ( j = 0; j < REPEATS; j++ ) { + count += 1; + printf( "# c::%s:len=%d\n", NAME, len ); + elapsed = benchmark( iter, len ); + print_results( iter, elapsed ); + printf( "ok %d benchmark finished\n", count ); + } + } + print_summary( count, count ); +} diff --git a/lib/node_modules/@stdlib/blas/ext/base/ndarray/ssort/binding.gyp b/lib/node_modules/@stdlib/blas/ext/base/ndarray/ssort/binding.gyp new file mode 100644 index 000000000000..0d6508a12e99 --- /dev/null +++ b/lib/node_modules/@stdlib/blas/ext/base/ndarray/ssort/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/blas/ext/base/ndarray/ssort/docs/types/index.d.ts b/lib/node_modules/@stdlib/blas/ext/base/ndarray/ssort/docs/types/index.d.ts index 2b801b0ca90b..fd10a8beadd5 100644 --- a/lib/node_modules/@stdlib/blas/ext/base/ndarray/ssort/docs/types/index.d.ts +++ b/lib/node_modules/@stdlib/blas/ext/base/ndarray/ssort/docs/types/index.d.ts @@ -44,7 +44,7 @@ import { typedndarray, float32ndarray } from '@stdlib/types/ndarray'; * var x = new Float32Vector( [ 1.0, -2.0, 3.0, -4.0 ] ); * * var ord = scalar2ndarray( 1.0, { -* 'dtype': 'generic' +* 'dtype': 'float32' * }); * * var out = ssort( [ x, ord ] ); diff --git a/lib/node_modules/@stdlib/blas/ext/base/ndarray/ssort/docs/types/test.ts b/lib/node_modules/@stdlib/blas/ext/base/ndarray/ssort/docs/types/test.ts index 4997bbe6aae0..16984bb72060 100644 --- a/lib/node_modules/@stdlib/blas/ext/base/ndarray/ssort/docs/types/test.ts +++ b/lib/node_modules/@stdlib/blas/ext/base/ndarray/ssort/docs/types/test.ts @@ -31,7 +31,7 @@ import ssort = require( './index' ); 'dtype': 'float32' }); const order = scalar2ndarray( 1.0, { - 'dtype': 'generic' + 'dtype': 'float32' }); ssort( [ x, order ] ); // $ExpectType float32ndarray @@ -56,7 +56,7 @@ import ssort = require( './index' ); 'dtype': 'float32' }); const order = scalar2ndarray( 1.0, { - 'dtype': 'generic' + 'dtype': 'float32' }); ssort(); // $ExpectError diff --git a/lib/node_modules/@stdlib/blas/ext/base/ndarray/ssort/examples/c/Makefile b/lib/node_modules/@stdlib/blas/ext/base/ndarray/ssort/examples/c/Makefile new file mode 100644 index 000000000000..c8f8e9a1517b --- /dev/null +++ b/lib/node_modules/@stdlib/blas/ext/base/ndarray/ssort/examples/c/Makefile @@ -0,0 +1,146 @@ +#/ +# @license Apache-2.0 +# +# Copyright (c) 2026 The Stdlib Authors. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +#/ + +# VARIABLES # + +ifndef VERBOSE + QUIET := @ +else + QUIET := +endif + +# Determine the OS ([1][1], [2][2]). +# +# [1]: https://en.wikipedia.org/wiki/Uname#Examples +# [2]: http://stackoverflow.com/a/27776822/2225624 +OS ?= $(shell uname) +ifneq (, $(findstring MINGW,$(OS))) + OS := WINNT +else +ifneq (, $(findstring MSYS,$(OS))) + OS := WINNT +else +ifneq (, $(findstring CYGWIN,$(OS))) + OS := WINNT +else +ifneq (, $(findstring Windows_NT,$(OS))) + OS := WINNT +endif +endif +endif +endif + +# Define the program used for compiling C source files: +ifdef C_COMPILER + CC := $(C_COMPILER) +else + CC := gcc +endif + +# Define the command-line options when compiling C files: +CFLAGS ?= \ + -std=c99 \ + -O3 \ + -Wall \ + -pedantic + +# Determine whether to generate position independent code ([1][1], [2][2]). +# +# [1]: https://gcc.gnu.org/onlinedocs/gcc/Code-Gen-Options.html#Code-Gen-Options +# [2]: http://stackoverflow.com/questions/5311515/gcc-fpic-option +ifeq ($(OS), WINNT) + fPIC ?= +else + fPIC ?= -fPIC +endif + +# List of includes (e.g., `-I /foo/bar -I /beep/boop/include`): +INCLUDE ?= + +# List of source files: +SOURCE_FILES ?= + +# List of libraries (e.g., `-lopenblas -lpthread`): +LIBRARIES ?= + +# List of library paths (e.g., `-L /foo/bar -L /beep/boop`): +LIBPATH ?= + +# List of C targets: +c_targets := example.out + + +# RULES # + +#/ +# Compiles source files. +# +# @param {string} [C_COMPILER] - C compiler (e.g., `gcc`) +# @param {string} [CFLAGS] - C compiler options +# @param {(string|void)} [fPIC] - compiler flag determining whether to generate position independent code (e.g., `-fPIC`) +# @param {string} [INCLUDE] - list of includes (e.g., `-I /foo/bar -I /beep/boop/include`) +# @param {string} [SOURCE_FILES] - list of source files +# @param {string} [LIBPATH] - list of library paths (e.g., `-L /foo/bar -L /beep/boop`) +# @param {string} [LIBRARIES] - list of libraries (e.g., `-lopenblas -lpthread`) +# +# @example +# make +# +# @example +# make all +#/ +all: $(c_targets) + +.PHONY: all + +#/ +# Compiles C source files. +# +# @private +# @param {string} CC - C compiler (e.g., `gcc`) +# @param {string} CFLAGS - C compiler options +# @param {(string|void)} fPIC - compiler flag determining whether to generate position independent code (e.g., `-fPIC`) +# @param {string} INCLUDE - list of includes (e.g., `-I /foo/bar`) +# @param {string} SOURCE_FILES - list of source files +# @param {string} LIBPATH - list of library paths (e.g., `-L /foo/bar`) +# @param {string} LIBRARIES - list of libraries (e.g., `-lopenblas`) +#/ +$(c_targets): %.out: %.c + $(QUIET) $(CC) $(CFLAGS) $(fPIC) $(INCLUDE) -o $@ $(SOURCE_FILES) $< $(LIBPATH) -lm $(LIBRARIES) + +#/ +# Runs compiled examples. +# +# @example +# make run +#/ +run: $(c_targets) + $(QUIET) ./$< + +.PHONY: run + +#/ +# Removes generated files. +# +# @example +# make clean +#/ +clean: + $(QUIET) -rm -f *.o *.out + +.PHONY: clean diff --git a/lib/node_modules/@stdlib/blas/ext/base/ndarray/ssort/examples/c/example.c b/lib/node_modules/@stdlib/blas/ext/base/ndarray/ssort/examples/c/example.c new file mode 100644 index 000000000000..173ef032e7d1 --- /dev/null +++ b/lib/node_modules/@stdlib/blas/ext/base/ndarray/ssort/examples/c/example.c @@ -0,0 +1,87 @@ +/** +* @license Apache-2.0 +* +* Copyright (c) 2026 The Stdlib Authors. +* +* Licensed under the Apache License, Version 2.0 (the "License"); +* you may not use this file except in compliance with the License. +* You may obtain a copy of the License at +* +* http://www.apache.org/licenses/LICENSE-2.0 +* +* Unless required by applicable law or agreed to in writing, software +* distributed under the License is distributed on an "AS IS" BASIS, +* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +* See the License for the specific language governing permissions and +* limitations under the License. +*/ + +#include "stdlib/blas/ext/base/ndarray/ssort.h" +#include "stdlib/ndarray/ctor.h" +#include "stdlib/ndarray/dtypes.h" +#include "stdlib/ndarray/index_modes.h" +#include "stdlib/ndarray/orders.h" +#include "stdlib/ndarray/base/bytes_per_element.h" +#include +#include +#include + +int main( void ) { + // Create a data buffer: + float data[] = { 1.0f, -2.0f, 3.0f, -4.0f }; + + // Specify the number of array dimensions: + const int64_t ndims = 1; + + // Specify the array shape: + int64_t shape[] = { 4 }; + + // Specify the array strides: + int64_t strides[] = { STDLIB_NDARRAY_FLOAT32_BYTES_PER_ELEMENT }; + + // Specify the byte offset: + const int64_t offset = 0; + + // Specify the array order: + const enum STDLIB_NDARRAY_ORDER order = STDLIB_NDARRAY_ROW_MAJOR; + + // Specify the index mode: + const enum STDLIB_NDARRAY_INDEX_MODE imode = STDLIB_NDARRAY_INDEX_ERROR; + + // Specify the subscript index modes: + int8_t submodes[] = { STDLIB_NDARRAY_INDEX_ERROR }; + const int64_t nsubmodes = 1; + + // Create an ndarray: + // cppcheck-suppress invalidPointerCast + struct ndarray *x = stdlib_ndarray_allocate( STDLIB_NDARRAY_FLOAT32, (uint8_t *)data, ndims, shape, strides, offset, order, imode, nsubmodes, submodes ); + + // Create a data buffer for an ndarray specifying the sort order: + const float odata[] = { 1.0f }; + + // Specify the array strides for a zero-dimensional ndarray: + int64_t ostrides[] = { 0 }; + + // Create an ndarray specifying the sort order: + // cppcheck-suppress invalidPointerCast + struct ndarray *ord = stdlib_ndarray_allocate( STDLIB_NDARRAY_FLOAT32, (uint8_t *)odata, 0, NULL, ostrides, 0, order, imode, nsubmodes, submodes ); + if ( x == NULL || ord == NULL ) { + fprintf( stderr, "Error allocating memory.\n" ); + exit( 1 ); + } + + // Define a list of ndarrays: + const struct ndarray *arrays[] = { x, ord }; + + // Sort the ndarray: + stdlib_blas_ext_ssort( arrays ); + + // Print the result: + for ( int i = 0; i < 4; i++ ) { + printf( "x[ %i ] = %f\n", i, data[ i ] ); + } + + // Free allocated memory: + stdlib_ndarray_free( x ); + stdlib_ndarray_free( ord ); +} diff --git a/lib/node_modules/@stdlib/blas/ext/base/ndarray/ssort/examples/index.js b/lib/node_modules/@stdlib/blas/ext/base/ndarray/ssort/examples/index.js index 23dd271a1461..6d1cc554afa2 100644 --- a/lib/node_modules/@stdlib/blas/ext/base/ndarray/ssort/examples/index.js +++ b/lib/node_modules/@stdlib/blas/ext/base/ndarray/ssort/examples/index.js @@ -30,7 +30,7 @@ var x = uniform( [ 10 ], -100, 100, { console.log( ndarray2array( x ) ); var order = scalar2ndarray( 1.0, { - 'dtype': 'generic' + 'dtype': 'float32' }); console.log( 'Order:', ndarraylike2scalar( order ) ); @@ -38,7 +38,7 @@ ssort( [ x, order ] ); console.log( ndarray2array( x ) ); order = scalar2ndarray( -1.0, { - 'dtype': 'generic' + 'dtype': 'float32' }); console.log( 'Order:', ndarraylike2scalar( order ) ); diff --git a/lib/node_modules/@stdlib/blas/ext/base/ndarray/ssort/include.gypi b/lib/node_modules/@stdlib/blas/ext/base/ndarray/ssort/include.gypi new file mode 100644 index 000000000000..bee8d41a2caf --- /dev/null +++ b/lib/node_modules/@stdlib/blas/ext/base/ndarray/ssort/include.gypi @@ -0,0 +1,53 @@ +# @license Apache-2.0 +# +# Copyright (c) 2026 The Stdlib Authors. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +# A GYP include file for building a Node.js native add-on. +# +# Main documentation: +# +# [1]: https://gyp.gsrc.io/docs/InputFormatReference.md +# [2]: https://gyp.gsrc.io/docs/UserDocumentation.md +{ + # Define variables to be used throughout the configuration for all targets: + 'variables': { + # Source directory: + 'src_dir': './src', + + # Include directories: + 'include_dirs': [ + '} arrays - array-like object containing ndarrays +* @returns {ndarray} input ndarray +* +* @example +* var Float32Vector = require( '@stdlib/ndarray/vector/float32' ); +* var scalar2ndarray = require( '@stdlib/ndarray/from-scalar' ); +* +* var x = new Float32Vector( [ 1.0, -2.0, 3.0, -4.0 ] ); +* +* var order = scalar2ndarray( 1.0, { +* 'dtype': 'float32' +* }); +* +* var out = ssort( [ x, order ] ); +* // returns [ -4.0, -2.0, 1.0, 3.0 ] +* +* var bool = ( out === x ); +* // returns true +*/ +function ssort( arrays ) { + var order; + var x; + + x = arrays[ 0 ]; + order = arrays[ 1 ]; + + addon( getData( x ), serialize( x ), getData( order ), serialize( order ) ); + return x; +} + + +// EXPORTS // + +module.exports = ssort; diff --git a/lib/node_modules/@stdlib/blas/ext/base/ndarray/ssort/manifest.json b/lib/node_modules/@stdlib/blas/ext/base/ndarray/ssort/manifest.json new file mode 100644 index 000000000000..6d9c4ef9b169 --- /dev/null +++ b/lib/node_modules/@stdlib/blas/ext/base/ndarray/ssort/manifest.json @@ -0,0 +1,109 @@ +{ + "options": { + "task": "build", + "wasm": false + }, + "fields": [ + { + "field": "src", + "resolve": true, + "relative": true + }, + { + "field": "include", + "resolve": true, + "relative": true + }, + { + "field": "libraries", + "resolve": false, + "relative": false + }, + { + "field": "libpath", + "resolve": true, + "relative": false + } + ], + "confs": [ + { + "task": "build", + "wasm": false, + "src": [ + "./src/main.c" + ], + "include": [ + "./include" + ], + "libraries": [], + "libpath": [], + "dependencies": [ + "@stdlib/blas/base/shared", + "@stdlib/blas/ext/base/ssort", + "@stdlib/ndarray/ctor", + "@stdlib/ndarray/base/napi/addon-arguments", + "@stdlib/napi/export", + "@stdlib/napi/argv" + ] + }, + { + "task": "benchmark", + "wasm": false, + "src": [ + "./src/main.c" + ], + "include": [ + "./include" + ], + "libraries": [], + "libpath": [], + "dependencies": [ + "@stdlib/blas/base/shared", + "@stdlib/blas/ext/base/ssort", + "@stdlib/ndarray/ctor", + "@stdlib/ndarray/dtypes", + "@stdlib/ndarray/index-modes", + "@stdlib/ndarray/orders", + "@stdlib/ndarray/base/bytes-per-element" + ] + }, + { + "task": "examples", + "wasm": false, + "src": [ + "./src/main.c" + ], + "include": [ + "./include" + ], + "libraries": [], + "libpath": [], + "dependencies": [ + "@stdlib/blas/base/shared", + "@stdlib/blas/ext/base/ssort", + "@stdlib/ndarray/ctor", + "@stdlib/ndarray/dtypes", + "@stdlib/ndarray/index-modes", + "@stdlib/ndarray/orders", + "@stdlib/ndarray/base/bytes-per-element" + ] + }, + { + "task": "", + "wasm": true, + "src": [ + "./src/main.c" + ], + "include": [ + "./include" + ], + "libraries": [], + "libpath": [], + "dependencies": [ + "@stdlib/blas/base/shared", + "@stdlib/blas/ext/base/ssort", + "@stdlib/ndarray/ctor" + ] + } + ] +} diff --git a/lib/node_modules/@stdlib/blas/ext/base/ndarray/ssort/package.json b/lib/node_modules/@stdlib/blas/ext/base/ndarray/ssort/package.json index 4e0c3d12ea0e..89d48806a2c2 100644 --- a/lib/node_modules/@stdlib/blas/ext/base/ndarray/ssort/package.json +++ b/lib/node_modules/@stdlib/blas/ext/base/ndarray/ssort/package.json @@ -14,11 +14,15 @@ } ], "main": "./lib", + "browser": "./lib/main.js", + "gypfile": true, "directories": { "benchmark": "./benchmark", "doc": "./docs", "example": "./examples", + "include": "./include", "lib": "./lib", + "src": "./src", "test": "./test" }, "types": "./docs/types", diff --git a/lib/node_modules/@stdlib/blas/ext/base/ndarray/ssort/src/Makefile b/lib/node_modules/@stdlib/blas/ext/base/ndarray/ssort/src/Makefile new file mode 100644 index 000000000000..2caf905cedbe --- /dev/null +++ b/lib/node_modules/@stdlib/blas/ext/base/ndarray/ssort/src/Makefile @@ -0,0 +1,70 @@ +#/ +# @license Apache-2.0 +# +# Copyright (c) 2026 The Stdlib Authors. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +#/ + +# VARIABLES # + +ifndef VERBOSE + QUIET := @ +else + QUIET := +endif + +# Determine the OS ([1][1], [2][2]). +# +# [1]: https://en.wikipedia.org/wiki/Uname#Examples +# [2]: http://stackoverflow.com/a/27776822/2225624 +OS ?= $(shell uname) +ifneq (, $(findstring MINGW,$(OS))) + OS := WINNT +else +ifneq (, $(findstring MSYS,$(OS))) + OS := WINNT +else +ifneq (, $(findstring CYGWIN,$(OS))) + OS := WINNT +else +ifneq (, $(findstring Windows_NT,$(OS))) + OS := WINNT +endif +endif +endif +endif + + +# RULES # + +#/ +# Removes generated files for building an add-on. +# +# @example +# make clean-addon +#/ +clean-addon: + $(QUIET) -rm -f *.o *.node + +.PHONY: clean-addon + +#/ +# Removes generated files. +# +# @example +# make clean +#/ +clean: clean-addon + +.PHONY: clean diff --git a/lib/node_modules/@stdlib/blas/ext/base/ndarray/ssort/src/addon.c b/lib/node_modules/@stdlib/blas/ext/base/ndarray/ssort/src/addon.c new file mode 100644 index 000000000000..da478b3c56cf --- /dev/null +++ b/lib/node_modules/@stdlib/blas/ext/base/ndarray/ssort/src/addon.c @@ -0,0 +1,64 @@ +/** +* @license Apache-2.0 +* +* Copyright (c) 2026 The Stdlib Authors. +* +* Licensed under the Apache License, Version 2.0 (the "License"); +* you may not use this file except in compliance with the License. +* You may obtain a copy of the License at +* +* http://www.apache.org/licenses/LICENSE-2.0 +* +* Unless required by applicable law or agreed to in writing, software +* distributed under the License is distributed on an "AS IS" BASIS, +* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +* See the License for the specific language governing permissions and +* limitations under the License. +*/ + +#include "stdlib/blas/ext/base/ndarray/ssort.h" +#include "stdlib/ndarray/ctor.h" +#include "stdlib/ndarray/base/napi/addon_arguments.h" +#include "stdlib/napi/export.h" +#include "stdlib/napi/argv.h" +#include +#include + +/** +* Receives JavaScript callback invocation data. +* +* @param env environment under which the function is invoked +* @param info callback data +* @return Node-API value +*/ +static napi_value addon( napi_env env, napi_callback_info info ) { + STDLIB_NAPI_ARGV( env, info, argv, argc, 4 ); + + // Process provided arguments: + struct ndarray *arrays[ 2 ]; + napi_value err; + napi_status status = stdlib_ndarray_napi_addon_arguments( env, argv, 4, 2, arrays, &err ); + assert( status == napi_ok ); + if ( err != NULL ) { + status = napi_throw( env, err ); + assert( status == napi_ok ); + return NULL; + } + // Create a const-qualified view of the argument pointer list: + const struct ndarray *arr[ 2 ] = { + arrays[ 0 ], + arrays[ 1 ] + }; + // Perform computation: + stdlib_blas_ext_ssort( arr ); + + // Free allocated memory: + stdlib_ndarray_free( arrays[ 0 ] ); + stdlib_ndarray_free( arrays[ 1 ] ); + arrays[ 0 ] = NULL; + arrays[ 1 ] = NULL; + + return NULL; +} + +STDLIB_NAPI_MODULE_EXPORT_FCN( addon ) diff --git a/lib/node_modules/@stdlib/blas/ext/base/ndarray/ssort/src/main.c b/lib/node_modules/@stdlib/blas/ext/base/ndarray/ssort/src/main.c new file mode 100644 index 000000000000..72b3ddf52d8f --- /dev/null +++ b/lib/node_modules/@stdlib/blas/ext/base/ndarray/ssort/src/main.c @@ -0,0 +1,50 @@ +/** +* @license Apache-2.0 +* +* Copyright (c) 2026 The Stdlib Authors. +* +* Licensed under the Apache License, Version 2.0 (the "License"); +* you may not use this file except in compliance with the License. +* You may obtain a copy of the License at +* +* http://www.apache.org/licenses/LICENSE-2.0 +* +* Unless required by applicable law or agreed to in writing, software +* distributed under the License is distributed on an "AS IS" BASIS, +* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +* See the License for the specific language governing permissions and +* limitations under the License. +*/ + +#include "stdlib/blas/ext/base/ndarray/ssort.h" +#include "stdlib/blas/ext/base/ssort.h" +#include "stdlib/ndarray/ctor.h" +#include "stdlib/blas/base/shared.h" + +/** +* Sorts a one-dimensional single-precision floating-point ndarray. +* +* ## Notes +* +* - The function expects the following ndarrays: +* +* - a one-dimensional input ndarray. +* - a zero-dimensional ndarray specifying the sort order. +* +* - When the sort order is less than zero, the input ndarray is sorted in decreasing order. When the sort order is greater than zero, the input ndarray is sorted in increasing order. When the sort order is equal to zero, the input ndarray is left unchanged. +* +* @param arrays list containing ndarrays +*/ +void stdlib_blas_ext_ssort( const struct ndarray *arrays[] ) { + const struct ndarray *x = arrays[ 0 ]; + + float order; + stdlib_ndarray_get_float32( arrays[ 1 ], NULL, &order ); + + const CBLAS_INT N = stdlib_ndarray_dimension( x, 0 ); + const CBLAS_INT strideX = stdlib_ndarray_stride_elements( x, 0 ); + const CBLAS_INT offsetX = stdlib_ndarray_offset_elements( x ); + + float *dataX = (float *)stdlib_ndarray_data( x ); + API_SUFFIX(stdlib_strided_ssort_ndarray)( N, order, dataX, strideX, offsetX ); +} diff --git a/lib/node_modules/@stdlib/blas/ext/base/ndarray/ssort/test/test.js b/lib/node_modules/@stdlib/blas/ext/base/ndarray/ssort/test/test.js index f8815e6ea34e..6c721f7bbbf7 100644 --- a/lib/node_modules/@stdlib/blas/ext/base/ndarray/ssort/test/test.js +++ b/lib/node_modules/@stdlib/blas/ext/base/ndarray/ssort/test/test.js @@ -21,17 +21,18 @@ // MODULES // var tape = require( 'tape' ); -var Float32Array = require( '@stdlib/array/float32' ); -var scalar2ndarray = require( '@stdlib/ndarray/from-scalar' ); -var getData = require( '@stdlib/ndarray/data-buffer' ); -var getDType = require( '@stdlib/ndarray/dtype' ); -var getStrides = require( '@stdlib/ndarray/strides' ); -var getOffset = require( '@stdlib/ndarray/offset' ); -var getShape = require( '@stdlib/ndarray/shape' ); -var ndarray = require( '@stdlib/ndarray/base/ctor' ); +var proxyquire = require( 'proxyquire' ); +var IS_BROWSER = require( '@stdlib/assert/is-browser' ); var ssort = require( './../lib' ); +// VARIABLES // + +var opts = { + 'skip': IS_BROWSER +}; + + // TESTS // tape( 'main export is a function', function test( t ) { @@ -40,44 +41,37 @@ tape( 'main export is a function', function test( t ) { t.end(); }); -tape( 'the function sorts a one-dimensional ndarray (increasing order)', function test( t ) { - var actual; - var order; - var x; - - x = ndarray( 'float32', new Float32Array( [ 3.0, 1.0, 2.0, 5.0, 4.0 ] ), [ 5 ], [ 1 ], 0, 'row-major' ); - order = scalar2ndarray( 1.0, { - 'dtype': 'generic' +tape( 'if a native implementation is available, the main export is the native implementation', opts, function test( t ) { + var ssort = proxyquire( './../lib', { + '@stdlib/utils/try-require': tryRequire }); - actual = ssort( [ x, order ] ); - t.strictEqual( actual, x, 'returns expected value' ); - t.strictEqual( String( getDType( actual ) ), 'float32', 'returns expected value' ); - t.deepEqual( getData( actual ), new Float32Array( [ 1.0, 2.0, 3.0, 4.0, 5.0 ] ), 'returns expected value' ); - t.deepEqual( getShape( actual ), [ 5 ], 'returns expected value' ); - t.deepEqual( getStrides( actual ), [ 1 ], 'returns expected value' ); - t.strictEqual( getOffset( actual ), 0, 'returns expected value' ); - + t.strictEqual( ssort, mock, 'returns expected value' ); t.end(); + + function tryRequire() { + return mock; + } + + function mock() { + // Mock... + } }); -tape( 'the function sorts a one-dimensional ndarray (decreasing order)', function test( t ) { - var actual; - var order; - var x; +tape( 'if a native implementation is not available, the main export is a JavaScript implementation', opts, function test( t ) { + var ssort; + var main; - x = ndarray( 'float32', new Float32Array( [ 3.0, 1.0, 2.0, 5.0, 4.0 ] ), [ 5 ], [ 1 ], 0, 'row-major' ); - order = scalar2ndarray( -1.0, { - 'dtype': 'generic' - }); + main = require( './../lib/main.js' ); - actual = ssort( [ x, order ] ); - t.strictEqual( actual, x, 'returns expected value' ); - t.strictEqual( String( getDType( actual ) ), 'float32', 'returns expected value' ); - t.deepEqual( getData( actual ), new Float32Array( [ 5.0, 4.0, 3.0, 2.0, 1.0 ] ), 'returns expected value' ); - t.deepEqual( getShape( actual ), [ 5 ], 'returns expected value' ); - t.deepEqual( getStrides( actual ), [ 1 ], 'returns expected value' ); - t.strictEqual( getOffset( actual ), 0, 'returns expected value' ); + ssort = proxyquire( './../lib', { + '@stdlib/utils/try-require': tryRequire + }); + t.strictEqual( ssort, main, 'returns expected value' ); t.end(); + + function tryRequire() { + return new Error( 'Cannot find module' ); + } }); diff --git a/lib/node_modules/@stdlib/blas/ext/base/ndarray/ssort/test/test.main.js b/lib/node_modules/@stdlib/blas/ext/base/ndarray/ssort/test/test.main.js new file mode 100644 index 000000000000..f66309d2d837 --- /dev/null +++ b/lib/node_modules/@stdlib/blas/ext/base/ndarray/ssort/test/test.main.js @@ -0,0 +1,196 @@ +/** +* @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 Float32Array = require( '@stdlib/array/float32' ); +var scalar2ndarray = require( '@stdlib/ndarray/from-scalar' ); +var getData = require( '@stdlib/ndarray/data-buffer' ); +var getDType = require( '@stdlib/ndarray/dtype' ); +var getStrides = require( '@stdlib/ndarray/strides' ); +var getOffset = require( '@stdlib/ndarray/offset' ); +var getShape = require( '@stdlib/ndarray/shape' ); +var ndarray = require( '@stdlib/ndarray/base/ctor' ); +var ssort = require( './../lib/main.js' ); + + +// FUNCTIONS // + +/** +* Returns a one-dimensional ndarray. +* +* @private +* @param {Float32Array} buffer - underlying data buffer +* @param {NonNegativeInteger} length - number of indexed elements +* @param {integer} stride - stride length +* @param {NonNegativeInteger} offset - index offset +* @returns {ndarray} one-dimensional ndarray +*/ +function vector( buffer, length, stride, offset ) { + return new ndarray( 'float32', buffer, [ length ], [ stride ], offset, 'row-major' ); +} + + +// TESTS // + +tape( 'main export is a function', function test( t ) { + t.ok( true, __filename ); + t.strictEqual( typeof ssort, 'function', 'main export is a function' ); + t.end(); +}); + +tape( 'the function sorts a one-dimensional ndarray (increasing order)', function test( t ) { + var expected; + var actual; + var order; + var xbuf; + var x; + + xbuf = new Float32Array( [ 3.0, 1.0, 2.0, 5.0, 4.0 ] ); + x = vector( xbuf, 5, 1, 0 ); + order = scalar2ndarray( 1.0, { + 'dtype': 'float32' + }); + + actual = ssort( [ x, order ] ); + t.strictEqual( actual, x, 'returns expected value' ); + t.strictEqual( String( getDType( actual ) ), 'float32', 'returns expected value' ); + expected = new Float32Array( [ 1.0, 2.0, 3.0, 4.0, 5.0 ] ); + t.deepEqual( getData( actual ), expected, 'returns expected value' ); + t.deepEqual( getShape( actual ), [ 5 ], 'returns expected value' ); + t.deepEqual( getStrides( actual ), [ 1 ], 'returns expected value' ); + t.strictEqual( getOffset( actual ), 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function sorts a one-dimensional ndarray (decreasing order)', function test( t ) { + var expected; + var actual; + var order; + var xbuf; + var x; + + xbuf = new Float32Array( [ 3.0, 1.0, 2.0, 5.0, 4.0 ] ); + x = vector( xbuf, 5, 1, 0 ); + order = scalar2ndarray( -1.0, { + 'dtype': 'float32' + }); + + actual = ssort( [ x, order ] ); + t.strictEqual( actual, x, 'returns expected value' ); + t.strictEqual( String( getDType( actual ) ), 'float32', 'returns expected value' ); + expected = new Float32Array( [ 5.0, 4.0, 3.0, 2.0, 1.0 ] ); + t.deepEqual( getData( actual ), expected, 'returns expected value' ); + t.deepEqual( getShape( actual ), [ 5 ], 'returns expected value' ); + t.deepEqual( getStrides( actual ), [ 1 ], 'returns expected value' ); + t.strictEqual( getOffset( actual ), 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function leaves the input ndarray unchanged when the sort order is zero', function test( t ) { + var expected; + var actual; + var order; + var xbuf; + var x; + + xbuf = new Float32Array( [ 3.0, 1.0, 2.0, 5.0, 4.0 ] ); + x = vector( xbuf, 5, 1, 0 ); + order = scalar2ndarray( 0.0, { + 'dtype': 'float32' + }); + + actual = ssort( [ x, order ] ); + t.strictEqual( actual, x, 'returns expected value' ); + + expected = new Float32Array( [ 3.0, 1.0, 2.0, 5.0, 4.0 ] ); + t.deepEqual( xbuf, expected, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function supports an input ndarray having a non-unit stride', function test( t ) { + var expected; + var actual; + var order; + var xbuf; + var x; + + xbuf = new Float32Array( [ 3.0, 99.0, 1.0, 99.0, 2.0, 99.0, 5.0, 99.0, 4.0, 99.0 ] ); + x = vector( xbuf, 5, 2, 0 ); + order = scalar2ndarray( 1.0, { + 'dtype': 'float32' + }); + + actual = ssort( [ x, order ] ); + t.strictEqual( actual, x, 'returns expected value' ); + + expected = new Float32Array( [ 1.0, 99.0, 2.0, 99.0, 3.0, 99.0, 4.0, 99.0, 5.0, 99.0 ] ); + t.deepEqual( xbuf, expected, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function supports an input ndarray having a negative stride', function test( t ) { + var expected; + var actual; + var order; + var xbuf; + var x; + + xbuf = new Float32Array( [ 3.0, 1.0, 2.0, 5.0, 4.0 ] ); + x = vector( xbuf, 5, -1, 4 ); + order = scalar2ndarray( 1.0, { + 'dtype': 'float32' + }); + + actual = ssort( [ x, order ] ); + t.strictEqual( actual, x, 'returns expected value' ); + + expected = new Float32Array( [ 5.0, 4.0, 3.0, 2.0, 1.0 ] ); + t.deepEqual( xbuf, expected, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function returns the input ndarray unchanged when the input ndarray is empty', function test( t ) { + var expected; + var actual; + var order; + var xbuf; + var x; + + xbuf = new Float32Array( [] ); + x = vector( xbuf, 0, 1, 0 ); + order = scalar2ndarray( 1.0, { + 'dtype': 'float32' + }); + + actual = ssort( [ x, order ] ); + t.strictEqual( actual, x, 'returns expected value' ); + + expected = new Float32Array( [] ); + t.deepEqual( xbuf, expected, 'returns expected value' ); + + t.end(); +}); diff --git a/lib/node_modules/@stdlib/blas/ext/base/ndarray/ssort/test/test.native.js b/lib/node_modules/@stdlib/blas/ext/base/ndarray/ssort/test/test.native.js new file mode 100644 index 000000000000..5088f8f952a5 --- /dev/null +++ b/lib/node_modules/@stdlib/blas/ext/base/ndarray/ssort/test/test.native.js @@ -0,0 +1,205 @@ +/** +* @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 Float32Array = require( '@stdlib/array/float32' ); +var scalar2ndarray = require( '@stdlib/ndarray/from-scalar' ); +var getData = require( '@stdlib/ndarray/data-buffer' ); +var getDType = require( '@stdlib/ndarray/dtype' ); +var getStrides = require( '@stdlib/ndarray/strides' ); +var getOffset = require( '@stdlib/ndarray/offset' ); +var getShape = require( '@stdlib/ndarray/shape' ); +var ndarray = require( '@stdlib/ndarray/base/ctor' ); +var tryRequire = require( '@stdlib/utils/try-require' ); + + +// VARIABLES // + +var ssort = tryRequire( resolve( __dirname, './../lib/native.js' ) ); +var opts = { + 'skip': ( ssort instanceof Error ) +}; + + +// FUNCTIONS // + +/** +* Returns a one-dimensional ndarray. +* +* @private +* @param {Float32Array} buffer - underlying data buffer +* @param {NonNegativeInteger} length - number of indexed elements +* @param {integer} stride - stride length +* @param {NonNegativeInteger} offset - index offset +* @returns {ndarray} one-dimensional ndarray +*/ +function vector( buffer, length, stride, offset ) { + return new ndarray( 'float32', buffer, [ length ], [ stride ], offset, 'row-major' ); +} + + +// TESTS // + +tape( 'main export is a function', opts, function test( t ) { + t.ok( true, __filename ); + t.strictEqual( typeof ssort, 'function', 'main export is a function' ); + t.end(); +}); + +tape( 'the function sorts a one-dimensional ndarray (increasing order)', opts, function test( t ) { + var expected; + var actual; + var order; + var xbuf; + var x; + + xbuf = new Float32Array( [ 3.0, 1.0, 2.0, 5.0, 4.0 ] ); + x = vector( xbuf, 5, 1, 0 ); + order = scalar2ndarray( 1.0, { + 'dtype': 'float32' + }); + + actual = ssort( [ x, order ] ); + t.strictEqual( actual, x, 'returns expected value' ); + t.strictEqual( String( getDType( actual ) ), 'float32', 'returns expected value' ); + expected = new Float32Array( [ 1.0, 2.0, 3.0, 4.0, 5.0 ] ); + t.deepEqual( getData( actual ), expected, 'returns expected value' ); + t.deepEqual( getShape( actual ), [ 5 ], 'returns expected value' ); + t.deepEqual( getStrides( actual ), [ 1 ], 'returns expected value' ); + t.strictEqual( getOffset( actual ), 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function sorts a one-dimensional ndarray (decreasing order)', opts, function test( t ) { + var expected; + var actual; + var order; + var xbuf; + var x; + + xbuf = new Float32Array( [ 3.0, 1.0, 2.0, 5.0, 4.0 ] ); + x = vector( xbuf, 5, 1, 0 ); + order = scalar2ndarray( -1.0, { + 'dtype': 'float32' + }); + + actual = ssort( [ x, order ] ); + t.strictEqual( actual, x, 'returns expected value' ); + t.strictEqual( String( getDType( actual ) ), 'float32', 'returns expected value' ); + expected = new Float32Array( [ 5.0, 4.0, 3.0, 2.0, 1.0 ] ); + t.deepEqual( getData( actual ), expected, 'returns expected value' ); + t.deepEqual( getShape( actual ), [ 5 ], 'returns expected value' ); + t.deepEqual( getStrides( actual ), [ 1 ], 'returns expected value' ); + t.strictEqual( getOffset( actual ), 0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function leaves the input ndarray unchanged when the sort order is zero', opts, function test( t ) { + var expected; + var actual; + var order; + var xbuf; + var x; + + xbuf = new Float32Array( [ 3.0, 1.0, 2.0, 5.0, 4.0 ] ); + x = vector( xbuf, 5, 1, 0 ); + order = scalar2ndarray( 0.0, { + 'dtype': 'float32' + }); + + actual = ssort( [ x, order ] ); + t.strictEqual( actual, x, 'returns expected value' ); + + expected = new Float32Array( [ 3.0, 1.0, 2.0, 5.0, 4.0 ] ); + t.deepEqual( xbuf, expected, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function supports an input ndarray having a non-unit stride', opts, function test( t ) { + var expected; + var actual; + var order; + var xbuf; + var x; + + xbuf = new Float32Array( [ 3.0, 99.0, 1.0, 99.0, 2.0, 99.0, 5.0, 99.0, 4.0, 99.0 ] ); + x = vector( xbuf, 5, 2, 0 ); + order = scalar2ndarray( 1.0, { + 'dtype': 'float32' + }); + + actual = ssort( [ x, order ] ); + t.strictEqual( actual, x, 'returns expected value' ); + + expected = new Float32Array( [ 1.0, 99.0, 2.0, 99.0, 3.0, 99.0, 4.0, 99.0, 5.0, 99.0 ] ); + t.deepEqual( xbuf, expected, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function supports an input ndarray having a negative stride', opts, function test( t ) { + var expected; + var actual; + var order; + var xbuf; + var x; + + xbuf = new Float32Array( [ 3.0, 1.0, 2.0, 5.0, 4.0 ] ); + x = vector( xbuf, 5, -1, 4 ); + order = scalar2ndarray( 1.0, { + 'dtype': 'float32' + }); + + actual = ssort( [ x, order ] ); + t.strictEqual( actual, x, 'returns expected value' ); + + expected = new Float32Array( [ 5.0, 4.0, 3.0, 2.0, 1.0 ] ); + t.deepEqual( xbuf, expected, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function returns the input ndarray unchanged when the input ndarray is empty', opts, function test( t ) { + var expected; + var actual; + var order; + var xbuf; + var x; + + xbuf = new Float32Array( [] ); + x = vector( xbuf, 0, 1, 0 ); + order = scalar2ndarray( 1.0, { + 'dtype': 'float32' + }); + + actual = ssort( [ x, order ] ); + t.strictEqual( actual, x, 'returns expected value' ); + + expected = new Float32Array( [] ); + t.deepEqual( xbuf, expected, 'returns expected value' ); + + t.end(); +}); From 27fdf7bde9c35ef5ca02498edd6260db382276ce Mon Sep 17 00:00:00 2001 From: AtharvaPatange <164712914+AtharvaPatange@users.noreply.github.com> Date: Fri, 23 Oct 2026 14:05:43 +0530 Subject: [PATCH 2/2] fix: resolve ssort lint and test failures --- .../ndarray/ssort/benchmark/c/benchmark.length.c | 16 ++++++++-------- .../ext/base/ndarray/ssort/test/test.main.js | 8 ++++++-- .../ext/base/ndarray/ssort/test/test.native.js | 8 ++++++-- 3 files changed, 20 insertions(+), 12 deletions(-) diff --git a/lib/node_modules/@stdlib/blas/ext/base/ndarray/ssort/benchmark/c/benchmark.length.c b/lib/node_modules/@stdlib/blas/ext/base/ndarray/ssort/benchmark/c/benchmark.length.c index 4a0d32bb697e..8e63307eeede 100644 --- a/lib/node_modules/@stdlib/blas/ext/base/ndarray/ssort/benchmark/c/benchmark.length.c +++ b/lib/node_modules/@stdlib/blas/ext/base/ndarray/ssort/benchmark/c/benchmark.length.c @@ -89,8 +89,8 @@ static double tic( void ) { * @return random number */ static float rand_float( void ) { - int r = rand(); - return (float)r / ( (float)RAND_MAX + 1.0f ); + int r = rand(); + return (float)r / ( (float)RAND_MAX + 1.0f ); } /** @@ -129,18 +129,18 @@ static double benchmark( int iterations, int len ) { data = (float *) malloc( len * sizeof( float ) ); for ( i = 0; i < len; i++ ) { - data[ i ] = ( rand_float() * 20000.0f ) - 10000.0f; - } + data[ i ] = ( rand_float() * 20000.0f ) - 10000.0f; + } // cppcheck-suppress invalidPointerCast x = stdlib_ndarray_allocate( STDLIB_NDARRAY_FLOAT32, (uint8_t *)data, ndims, shape, strides, offset, order, imode, nsubmodes, submodes ); arrays[ 0 ] = x; ord_data = (float *) malloc( 1 * sizeof( float ) ); - ord_data[ 0 ] = 1.0f; + ord_data[ 0 ] = 1.0f; // cppcheck-suppress invalidPointerCast - ord_arr = stdlib_ndarray_allocate( STDLIB_NDARRAY_FLOAT32, (uint8_t *)ord_data, 0, NULL, NULL, 0, order, imode, nsubmodes, submodes ); - arrays[ 1 ] = ord_arr; + ord_arr = stdlib_ndarray_allocate( STDLIB_NDARRAY_FLOAT32, (uint8_t *)ord_data, 0, NULL, NULL, 0, order, imode, nsubmodes, submodes ); + arrays[ 1 ] = ord_arr; t = tic(); for ( i = 0; i < iterations; i++ ) { @@ -159,7 +159,7 @@ static double benchmark( int iterations, int len ) { free( data ); free( ord_data ); arrays[ 0 ] = NULL; - arrays[ 1 ] = NULL; + arrays[ 1 ] = NULL; return elapsed; } diff --git a/lib/node_modules/@stdlib/blas/ext/base/ndarray/ssort/test/test.main.js b/lib/node_modules/@stdlib/blas/ext/base/ndarray/ssort/test/test.main.js index f66309d2d837..73e1d6ec0472 100644 --- a/lib/node_modules/@stdlib/blas/ext/base/ndarray/ssort/test/test.main.js +++ b/lib/node_modules/@stdlib/blas/ext/base/ndarray/ssort/test/test.main.js @@ -136,7 +136,9 @@ tape( 'the function supports an input ndarray having a non-unit stride', functio var xbuf; var x; - xbuf = new Float32Array( [ 3.0, 99.0, 1.0, 99.0, 2.0, 99.0, 5.0, 99.0, 4.0, 99.0 ] ); + xbuf = new Float32Array( [ + 3.0, 99.0, 1.0, 99.0, 2.0, 99.0, 5.0, 99.0, 4.0, 99.0 + ] ); x = vector( xbuf, 5, 2, 0 ); order = scalar2ndarray( 1.0, { 'dtype': 'float32' @@ -145,7 +147,9 @@ tape( 'the function supports an input ndarray having a non-unit stride', functio actual = ssort( [ x, order ] ); t.strictEqual( actual, x, 'returns expected value' ); - expected = new Float32Array( [ 1.0, 99.0, 2.0, 99.0, 3.0, 99.0, 4.0, 99.0, 5.0, 99.0 ] ); + expected = new Float32Array( [ + 1.0, 99.0, 2.0, 99.0, 3.0, 99.0, 4.0, 99.0, 5.0, 99.0 + ] ); t.deepEqual( xbuf, expected, 'returns expected value' ); t.end(); diff --git a/lib/node_modules/@stdlib/blas/ext/base/ndarray/ssort/test/test.native.js b/lib/node_modules/@stdlib/blas/ext/base/ndarray/ssort/test/test.native.js index 5088f8f952a5..5dbd48b5c44d 100644 --- a/lib/node_modules/@stdlib/blas/ext/base/ndarray/ssort/test/test.native.js +++ b/lib/node_modules/@stdlib/blas/ext/base/ndarray/ssort/test/test.native.js @@ -145,7 +145,9 @@ tape( 'the function supports an input ndarray having a non-unit stride', opts, f var xbuf; var x; - xbuf = new Float32Array( [ 3.0, 99.0, 1.0, 99.0, 2.0, 99.0, 5.0, 99.0, 4.0, 99.0 ] ); + xbuf = new Float32Array( [ + 3.0, 99.0, 1.0, 99.0, 2.0, 99.0, 5.0, 99.0, 4.0, 99.0 + ] ); x = vector( xbuf, 5, 2, 0 ); order = scalar2ndarray( 1.0, { 'dtype': 'float32' @@ -154,7 +156,9 @@ tape( 'the function supports an input ndarray having a non-unit stride', opts, f actual = ssort( [ x, order ] ); t.strictEqual( actual, x, 'returns expected value' ); - expected = new Float32Array( [ 1.0, 99.0, 2.0, 99.0, 3.0, 99.0, 4.0, 99.0, 5.0, 99.0 ] ); + expected = new Float32Array( [ + 1.0, 99.0, 2.0, 99.0, 3.0, 99.0, 4.0, 99.0, 5.0, 99.0 + ] ); t.deepEqual( xbuf, expected, 'returns expected value' ); t.end();