Skip to content

# compute-io / mean

Computes the arithmetic mean.

## Files

Failed to load latest commit information.
Type
Name
Commit time

# Mean

Computes the arithmetic mean.

The arithmetic mean is defined as

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`

## Copyright

Copyright © 2014-2015. The Compute.io Authors.

## About

Computes the arithmetic mean.

4 tags

•
•

## Languages

You can’t perform that action at this time.