About stdlib...
We believe in a future in which the web is a preferred environment for numerical computation. To help realize this future, we've built stdlib. stdlib is a standard library, with an emphasis on numerical and scientific computation, written in JavaScript (and C) for execution in browsers and in Node.js.
The library is fully decomposable, being architected in such a way that you can swap out and mix and match APIs and functionality to cater to your exact preferences and use cases.
When you use stdlib, you can be absolutely certain that you are using the most thorough, rigorous, well-written, studied, documented, tested, measured, and high-quality code out there.
To join us in bringing numerical computing to the web, get started by checking us out on GitHub, and please consider financially supporting stdlib. We greatly appreciate your continued support!
Create an ndarray function interface which performs multiple dispatch.
npm install @stdlib/ndarray-dispatch
var dispatch = require( '@stdlib/ndarray-dispatch' );
Returns an ndarray function interface which performs multiple dispatch.
var unary = require( '@stdlib/ndarray-base-unary' );
var Float64Array = require( '@stdlib/array-float64' );
var Float32Array = require( '@stdlib/array-float32' );
var ndarray = require( '@stdlib/ndarray-ctor' );
function foo( x ) {
return x * 10.0;
}
function bar( x ) {
return x * 5.0;
}
// Define a list of ndarray functions for applying a unary callback:
var fcns = [
unary,
unary
];
// Define a one-dimensional list of input and output array types:
var types = [
'float64', 'float64', // input, output
'float32', 'float32' // input, output
];
// Define a list of callbacks which should be applied based on the provided array types:
var data = [
foo,
bar
];
// Define the total number of input arguments:
var nargs = 2; // input_array + output_array
// Define the number of input ndarrays:
var nin = 1;
// Define the number of output ndarrays:
var nout = 1;
// Create an ndarray function interface:
var fcn = dispatch( fcns, types, data, nargs, nin, nout );
// ...
var xbuf = new Float64Array( [ 1.0, 2.0, 3.0 ] );
var ybuf = new Float64Array( xbuf.length );
var x = ndarray( 'float64', xbuf, [ 3 ], [ 1 ], 0, 'row-major' );
var y = ndarray( 'float64', ybuf, [ 3 ], [ 1 ], 0, 'row-major' );
fcn( x, y );
// ybuf => <Float64Array>[ 10.0, 20.0, 30.0 ]
xbuf = new Float32Array( [ 1.0, 2.0, 3.0 ] );
ybuf = new Float32Array( xbuf.length );
x = ndarray( 'float32', xbuf, [ 3 ], [ 1 ], 0, 'row-major' );
y = ndarray( 'float32', ybuf, [ 3 ], [ 1 ], 0, 'row-major' );
fcn( x, y );
// ybuf => <Float32Array>[ 5.0, 10.0, 15.0 ]
The function accepts the following arguments:
- fcns: list of ndarray functions.
-
types: one-dimensional list of ndarray argument data types. The length of
types
must be the number of ndarray functions multiplied bynin+nout
. Iffcns
is a function, rather than a list, the number of ndarray functions is computed astypes.length / (nin+nout)
. -
data: ndarray function data (e.g., callbacks). If a list, the length of
data
must equal the number of ndarray functions. Ifnull
, a returned ndarray function interface does not provide adata
argument to an invoked ndarray function. - nargs: total number of ndarray function interface arguments.
- nin: number of input ndarrays.
- nout: number of output ndarrays.
-
A returned ndarray function interface has the following signature:
f( x, y, ... )
where
-
The number of ndarray function interface parameters is derived from
nargs
, the number of input ndarrays is derived fromnin
, and the number of output ndarrays is derived fromnout
. -
An ndarray function (i.e., a value provided for the
fcns
argument) should have the following signature:f( arrays[, data] )
where
-
For convenience, a single ndarray function may be provided which will be invoked whenever the ndarray argument data types match a sequence of types in
types
. Providing a single ndarray function is particularly convenient for the case where, regardless of array data types, traversing arrays remains the same, but the ndarray functiondata
differs (e.g., callbacks which differ based on the array data types). For example, the followingvar unary = require( '@stdlib/ndarray-base-unary' ); function foo( x ) { return x * 10.0; } function bar( x ) { return x * 5.0; } var fcns = [ unary, unary ]; var types = [ 'float64', 'float64', 'float32', 'float32' ]; var data = [ foo, bar ]; var fcn = dispatch( fcns, types, data, 2, 1, 1 );
is equivalent to
var unary = require( '@stdlib/ndarray-base-unary' ); function foo( x ) { return x * 10.0; } function bar( x ) { return x * 5.0; } var types = [ 'float64', 'float64', 'float32', 'float32' ]; var data = [ foo, bar ]; var fcn = dispatch( unary, types, data, 2, 1, 1 );
var unary = require( '@stdlib/ndarray-base-unary' );
var ndarray = require( '@stdlib/ndarray-ctor' );
var abs = require( '@stdlib/math-base-special-abs' );
var Float64Array = require( '@stdlib/array-float64' );
var dispatch = require( '@stdlib/ndarray-dispatch' );
var types = [ 'float64', 'float64' ];
var data = [
abs
];
var absolute = dispatch( unary, types, data, 2, 1, 1 );
var xbuf = new Float64Array( [ -1.0, -2.0, -3.0, -4.0, -5.0 ] );
var ybuf = new Float64Array( [ 0.0, 0.0, 0.0, 0.0, 0.0 ] );
var x = ndarray( 'float64', xbuf, [ 5 ], [ 1 ], 0, 'row-major' );
var y = ndarray( 'float64', ybuf, [ 5 ], [ 1 ], 0, 'row-major' );
absolute( x, y );
console.log( ybuf );
// => <Float64Array>[ 1.0, 2.0, 3.0, 4.0, 5.0 ]
-
@stdlib/ndarray-array
: multidimensional arrays. -
@stdlib/ndarray-ctor
: multidimensional array constructor.
This package is part of stdlib, a standard library for JavaScript and Node.js, with an emphasis on numerical and scientific computing. The library provides a collection of robust, high performance libraries for mathematics, statistics, streams, utilities, and more.
For more information on the project, filing bug reports and feature requests, and guidance on how to develop stdlib, see the main project repository.
See LICENSE.
Copyright © 2016-2024. The Stdlib Authors.