FazBrowse GitHub Viewer | Trending |
URL:
| Home
Tools: [Download Repo ZIP]   [Original HTTPS Page]

stdlib/lib/node_modules/@stdlib/ndarray/dispatch at develop · stdlib-js/stdlib · GitHub

/ stdlib Public

Breadcrumbs

  1. stdlib
  2. lib
  3. node_modules
  4. @stdlib
  5. ndarray

dispatch

Directory actions

More options

Directory actions

More options

Latest commit

 

History

History

Breadcrumbs

  1. stdlib
  2. lib
  3. node_modules
  4. @stdlib
  5. ndarray

dispatch

Folders and files

NameName
Last commit message
Last commit date

parent directory

..
benchmark
benchmark
 
 
docs
docs
 
 
examples
examples
 
 
lib
lib
 
 
test
test
 
 
README.md
README.md
 
 
package.json
package.json
 
 

README.md

Dispatch

Create an ndarray function interface which performs multiple dispatch.

Usage

var dispatch = require( '@stdlib/ndarray/dispatch' );

dispatch( fcns, types, data, nargs, nin, nout )

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 by nin+nout. If fcns is a function, rather than a list, the number of ndarray functions is computed as types.length / (nin+nout).
  • data: ndarray function data (e.g., callbacks). If a list, the length of data must equal the number of ndarray functions. If null, a returned ndarray function interface does not provide a data argument to an invoked ndarray function.
  • nargs: total number of ndarray function interface arguments.
  • nin: number of input ndarrays.
  • nout: number of output ndarrays.

Notes

  • 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 from nin, and the number of output ndarrays is derived from nout.

  • An ndarray function (i.e., a value provided for the fcns argument) should have the following signature:

    f( arrays[, data] )

    where

    • arrays: array containing input and output ndarrays.
    • data: ndarray function data (e.g., a callback).

  • 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 function data differs (e.g., callbacks which differ based on the array data types). For example, the following

    var 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 );

Examples

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 ]

See Also

Back | FazBrowse Home | New Git URL