compute-prod

Computes the product.


Keywords
compute.io, compute, computation, statistics, stats, mathematics, math, arithmetic, prod, product, array, matrix, matrices, accessor
License
MIT
Install
npm install compute-prod@2.0.3

Documentation

Product

NPM version Build Status Coverage Status Dependencies

Computes the product.

The product is defined as

Equation for the sequence product.

where x_0, x_1,...,x_{N-1} are individual data values and N is the total number of values in the data set.

Installation

$ npm install compute-prod

For use in the browser, use browserify.

Usage

var prod = require( 'compute-prod' );

prod( x[, options] )

Computes the product of the elements in x. x may be either an array, typed array, or matrix.

var data = [ 1, 2, 3, 4 ];

var p = prod( data );
// returns 24

data = new Int8Array( data );
p = prod( data );
// returns 24

For non-numeric arrays, provide an accessor function for accessing array values.

var arr = [
    {'x':1},
    {'x':2},
    {'x':3},
    {'x':4}
];

function getValue( d ) {
    return d.x;
}

var value = prod( arr, {
    'accessor': getValue
});
// returns 24

If provided a matrix, the function accepts the following options:

  • dim: dimension along which to compute the product. Default: 2 (along the columns).
  • dtype: output matrix data type. Default: float64.

By default, the function computes the product along the columns (dim=2).

var matrix = require( 'dstructs-matrix' ),
    data,
    mat,
    p,
    i;

data = new Int8Array( 9 );
for ( i = 0; i < data.length; i++ ) {
    data[ i ] = i + 1;
}
mat = matrix( data, [3,3], 'int8' );
/*
    [  1 2 3
       4 5 6
       7 8 9 ]
*/

p = prod( mat );
/*
    [  6
       120
       504 ]
*/

To compute the product along the rows, set the dim option to 1.

p = prod( mat, {
    'dim': 1
});
/*
    [ 28 80 162 ]
*/

By default, the output matrix data type is float64. To specify a different output data type, set the dtype option.

p = prod( mat, {
    'dim': 1,
    'dtype': 'uint8'
});
/*
    [ 28 80 162 ]
*/

var dtype = p.dtype;
// returns 'uint8'

If provided a matrix having either dimension equal to 1, the function treats the matrix as a typed array and returns a numeric value.

data = [ 2, 4, 5 ];

// Row vector:
mat = matrix( new Int8Array( data ), [1,3], 'int8' );
p = prod( mat );
// returns 40

// Column vector:
mat = matrix( new Int8Array( data ), [3,1], 'int8' );
p = prod( mat );
// returns 40

If provided an empty array, typed array, or matrix, the function returns the empty product which is equal to 1.

p = prod( [] );
// returns 1

p = prod( new Int8Array( [] ) );
// returns 1

p = prod( matrix( [0,0] ) );
// returns 1

p = prod( matrix( [0,10] ) );
// returns 1

p = prod( matrix( [10,0] ) );
// returns 1

Examples

var matrix = require( 'dstructs-matrix' ),
    prod = require( 'compute-prod' );

var data,
    mat,
    p,
    i;

// Plain arrays...
var data = new Array( 100 );
for ( var i = 0; i < data.length; i++ ) {
    data[ i ] = Math.round( Math.random() * 10 + 1 );
}
p = prod( data );

// Object arrays (accessors)...
function getValue( d ) {
    return d.x;
}
for ( i = 0; i < data.length; i++ ) {
    data[ i ] = {
        'x': data[ i ]
    };
}
p = prod( data, {
    'accessor': getValue
});

// Typed arrays...
data = new Int32Array( 100 );
for ( i = 0; i < data.length; i++ ) {
    data[ i ] = Math.round( Math.random() * 10 + 1 );
}
p = prod( data );

// Matrices (along rows)...
mat = matrix( data, [10,10], 'int32' );
p = prod( mat, {
    'dim': 1
});

// Matrices (along columns)...
p = prod( mat, {
    'dim': 2
});

// Matrices (custom output data type)...
p = prod( mat, {
    'dtype': 'uint8'
});

To run the example code from the top-level application directory,

$ node ./examples/index.js

Tests

Unit

Unit tests use the Mocha test framework with Chai assertions. To run the tests, execute the following command in the top-level application directory:

$ make test

All new feature development should have corresponding unit tests to validate correct functionality.

Test Coverage

This repository uses Istanbul as its code coverage tool. To generate a test coverage report, execute the following command in the top-level application directory:

$ make test-cov

Istanbul creates a ./reports/coverage directory. To access an HTML version of the report,

$ make view-cov

License

MIT license.

Copyright

Copyright © 2015. The Compute.io Authors.