Nauseating Pumpkin Mush

    compute-prod

    2.0.3 • Public • Published

    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 );
    = 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 ]
    */
     
    = prod( mat );
    /*
        [  6
           120
           504 ]
    */

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

    = 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.

    = 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' );
    = prod( mat );
    // returns 40
     
    // Column vector:
    mat = matrix( new Int8Array( data ), [3,1], 'int8' );
    = prod( mat );
    // returns 40

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

    = prod( [] );
    // returns 1
     
    = prod( new Int8Array( [] ) );
    // returns 1
     
    = prod( matrix( [0,0] ) );
    // returns 1
     
    = prod( matrix( [0,10] ) );
    // returns 1
     
    = 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 );
    }
    = prod( data );
     
    // Object arrays (accessors)...
    function getValue( d ) {
        return d.x;
    }
    for ( i = 0; i < data.length; i++ ) {
        data[ i ] = {
            'x': data[ i ]
        };
    }
    = 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 );
    }
    = prod( data );
     
    // Matrices (along rows)...
    mat = matrix( data, [10,10], 'int32' );
    = prod( mat, {
        'dim': 1
    });
     
    // Matrices (along columns)...
    = prod( mat, {
        'dim': 2
    });
     
    // Matrices (custom output data type)...
    = 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.

    Install

    npm i compute-prod

    DownloadsWeekly Downloads

    234

    Version

    2.0.3

    License

    MIT

    Last publish

    Collaborators

    • kgryte
    • planeshifter