Learn about our RFC process, Open RFC meetings & more.Join in the discussion! »

compute-mean

3.0.0 • Public • Published

Mean

NPM version Build Status Coverage Dependencies

Computes the arithmetic mean.

The arithmetic mean is defined as

Equation for the arithmetic mean.

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-mean

Usage

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

mean( x[, opts] )

Computes the arithmetic mean. x may be either an array, typed array, or matrix.

var data, mu;
 
data = [ 2, 4, 5, 3, 8, 2 ];
mu = mean( data );
// returns 4
 
data = new Int8Array( data );
mu = mean( data );
// returns 4

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

var data = [
    {'x':2},
    {'x':4},
    {'x':5},
    {'x':3},
    {'x':8},
    {'x':2}
];
 
function getValue( d, i ) {
    return d.x;
}
 
var mu = mean( data, {
    'accessor': getValue
});
// returns 4

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

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

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

var matrix = require( 'dstructs-matrix' ),
    data,
    mat,
    mu,
    i;
 
data = new Int8Array( 25 );
for ( i = 0; i < data.length; i++ ) {
    data[ i ] = i;
}
mat = matrix( data, [5,5], 'int8' );
/*
    [  0  1  2  3  4
       5  6  7  8  9
      10 11 12 13 14
      15 16 17 18 19
      20 21 22 23 24 ]
*/
 
mu = mean( mat );
/*
    [  2
       7
      12
      17
      22 ]
*/

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

mu = mean( mat, {
    'dim': 1
});
/*
    [ 10, 11, 12, 13, 14 ]
*/

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

mu = mean( mat, {
    'dim': 1,
    'dtype': 'uint8'
});
/*
    [ 10, 11, 12, 13, 14 ]
*/
 
var dtype = mu.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, 3, 8, 2 ];
 
// Row vector:
mat = matrix( new Int8Array( data ), [1,6], 'int8' );
mu = mean( mat );
// returns 4
 
// Column vector:
mat = matrix( new Int8Array( data ), [6,1], 'int8' );
mu = mean( mat );
// returns 4

If provided an empty array, typed array, or matrix, the function returns null.

mu = mean( [] );
// returns null
 
mu = mean( new Int8Array( [] ) );
// returns null
 
mu = mean( matrix( [0,0] ) );
// returns null
 
mu = mean( matrix( [0,10] ) );
// returns null
 
mu = mean( matrix( [10,0] ) );
// returns null

Examples

var matrix = require( 'dstructs-matrix' ),
    mean = require( 'compute-mean' );
 
var data,
    mat,
    mu,
    i;
 
// Plain arrays...
data = new Array( 1000 );
for ( i = 0; i < data.length; i++ ) {
    data[ i ] = Math.random() * 100;
}
mu = mean( data );
 
// Object arrays (accessors)...
function getValue( d ) {
    return d.x;
}
for ( i = 0; i < data.length; i++ ) {
    data[ i ] = { 'x': data[ i ] };
}
mu = mean( data, {
    'accessor': getValue
});
 
// Typed arrays...
data = new Int32Array( 1000 );
for ( i = 0; i < data.length; i++ ) {
    data[ i ] = Math.random() * 100;
}
mu = mean( data );
 
// Matrices (along rows)...
mat = matrix( data, [100,10], 'int32' );
mu = mean( mat, {
    'dim': 1
});
 
// Matrices (along columns)...
mu = mean( mat, {
    'dim': 2
});
 
// Matrices (custom output data type)...
mu = mean( 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 © 2014-2015. The Compute.io Authors.

Install

npm i compute-mean

DownloadsWeekly Downloads

56

Version

3.0.0

License

MIT

Last publish

Collaborators

  • avatar