jStat/doc/md/core.md

## Core Functionality

Core functionality include methods that generate and analyse vectors or matrices.

### jStat()

The jStat object can function in several capacities, as demonstrated below.
In all cases, jStat will always return an instance of itself.

**jStat( array[, fn] )**

Creates a new jStat object from either an existing array or jStat object.
For example, create a new jStat matrix by doing the following:

    var matrix = jStat([[ 1, 2, 3 ],[ 4, 5, 6 ],[ 7, 8, 9 ]]);

If an existing jStat object is passed as an argument then it will be cloned into a new object:

    var stat1 = jStat([[ 1, 2 ],[ 3, 4 ]]),
        stat2 = jStat( stat1 );


To transform the data on creation, pass a function as the final argument:

    jStat([[ 1, 2 ],[ 3, 4 ]], function( x ) {
        return x * 2;
    });

**jStat( start, stop, count[, fn ])**

To create a sequence then pass numeric values in the same form `jStat.seq()` would be used:

    var vector = jStat( 0, 1, 5 );
    // vector === [[ 0, 0.25, 0.5, 0.75, 1 ]]

By passing a function the sequence value can be manipulated:

    var vector = jStat( 0, 1, 5, function( x ) {
        return x * 2;
    });
    // vector === [[ 0, 0.5, 1, 1.5, 2 ]];

The second argument passed to the function is the count (starting from 0).
Using this we can create a multidimensional array (useful for plotting data):

    var betaGraph = jStat( 0, 1, 11, function( x, cnt ) {
        return [ jStat.beta.pdf( x, alpha, beta ), cnt ];
    });

**jStat()**

A chainable shortcut in the API exists to allow for filling in the data after object creation.
So creating `jStat` objects from methods like `rand()` can be accomplished in one of the following ways:

    // pass the generated random 3x3 matrix to jStat
    jStat( jStat.rand( 3 ));
    // or create an empty instance that is filled in afterwards
    jStat().rand( 3 );


### rows()

Returns the count of rows in a matrix.

**rows( array )**

    var matrix = [[1,2,3],[4,5,6]];
    jStat.rows( matrix ) === 2;

**fn.rows( [callback] )**

    jStat( matrix ).rows() === 2;

Or pass a callback to run the calculation asynchronously and pass on the calculation.
This allows for continued chaining of methods to the jStat object.
Also note `this` within the callback refers to the calling jStat object.

    jStat( matrix ).rows(function( d ) {
        // d === 2
    });

### rowa()

Returns a array from matrix row.

    rowa([[1,2],[3,4]]) === [1,2];

### cols()

Returns the number of columns in a matrix.

**cols( array )**

    var matrix = [[1,2,3],[4,5,6]];
    jStat.cols( matrix ) === 3;

**fn.cols( [callback] )**

    jStat( matrix ).cols() === 3;

Or pass a callback to run the calculation asynchronously and pass on the calculation.
This allows for continued chaining of methods to the jStat object.
Also note `this` within the callback refers to the calling jStat object.

    jStat( matrix ).cols(function( d ) {
        // d === 3
    });

### cola()

Returns an array from matrix column (`col()` will return a matrix form instead of an array form).

    cola([[1,2],[3,4]]) === [1,3];

### slice()

Slices matrix as numpy style.

    A=[[1,2,3],[4,5,6],[7,8,9]];
    slice(A,{row:{end:2},col:{start:1}}) === [[2,3],[5,6]];
    slice(A,1,{start:1}) === [5,6];

### sliceAssign()

Do slice assign as numpy style.

    A = [[1,2,3],[4,5,6],[7,8,9]];
    sliceAssign(A,{row : {start : 1}, col : {start : 1}},[[0,0],[0,0]]);
    A = [[1,2,3],[4,0,0],[7,0,0]];


### dimensions()

Returns an object with the dimensions of a matrix.

**dimensions( array )**

    var matrix = [[1,2,3],[4,5,6]];
    jStat.dimensions( matrix ) === { cols: 3, rows: 2 };

**fn.dimensions( [callback] )**

    jStat( matrix ).dimensions() === { cols: 3, rows: 2 };

Or pass a callback to run the calculation asynchronously and pass on the calculation.
This allows for continued chaining of methods to the jStat object.
Also note `this` within the callback refers to the calling jStat object.

    jStat( matrix ).dimensions(function( d ) {
        // d === { cols: 3, rows: 2 }
    });

### row()

Returns a specified row of a matrix.

**row( array, index )**

    var matrix = [[1,2,3],[4,5,6],[7,8,9]];
    jStat.row( matrix, 0 ) === [1,2,3];
    jStat.row( matrix, [0,1] ) === [[1,2,3],[4,5,6]]

**fn.row( index[, callback] )**

    jStat( matrix ).row( 0 ) === jStat([1,2,3]);

Or pass a callback to run the calculation asynchronously and pass on the calculation.
This allows for continued chaining of methods to the jStat object.
Also note `this` within the callback refers to the calling jStat object.

    jStat( matrix ).row( 0, function( d ) {
        // d === jStat([1,2,3])
    });

### col()

Returns the specified column as a column vector.

**col( index )**

    var matrix = [[1,2,3],[4,5,6],[7,8,9]];
    jStat.col( matrix, 0 ) === [[1],[4],[7]];
    jStat.col( matrix,[0,1] ) === [[1,2],[4,5],[7,8]]

**fn.col( index[, callback] )**

    jStat( matrix ).col( 0 ) === jStat([[1],[4],[7]]);

Or pass a callback to run the calculation asynchronously and pass on the calculation.
This allows for continued chaining of methods to the jStat object.
Also note `this` within the callback refers to the calling jStat object.

    jStat( matrix ).col( 0, function( d ) {
        // d === jStat([[1],[3]])
    })

### diag()

Returns the diagonal of a matrix.

**diag( array )**

    var matrix = [[1,2,3],[4,5,6],[7,8,9]];
    jStat.diag( matrix ) === [[1],[5],[9]];

**fn.diag( [callback] )**

    jStat( matrix ).diag() === jStat([[1],[5],[9]]);

Or pass a callback to run the calculation asynchronously and pass on the calculation.
This allows for continued chaining of methods to the jStat object.
Also note `this` within the callback refers to the calling jStat object.

    jStat( matrix ).diag(function( d ) {
        // d === jStat([[1],[5],[9]])
    });

### antidiag()

Returns the anti-diagonal of the matrix.

**antidiag( array )**

    var matrix = [[1,2,3],[4,5,6],[7,8,9]];
    jStat.antidiag( matrix ) === [[3],[5],[7]];

**fn.antidiag( [callback] )**

    jStat( matrix ).antidiag() === jStat([[3],[5],[7]]);

Or pass a callback to run the calculation asynchronously and pass on the calculation.
This allows for continued chaining of methods to the jStat object.
Also note `this` within the callback refers to the calling jStat object.

    jStat( matrix ).antidiag(function( d ) {
        // d === jStat([[3],[5],[7]])
    });

### diagonal()

Creates a new diagonal matrix by given 1d diag array.

    jStat.diagonal([1,2,3]) === [[1,0,0],[0,2,0],[0,0,3]];

### transpose()

Transposes a matrix.

**transpose( array )**

    var matrix = [[1,2],[3,4]];
    jStat.transpose( matrix ) === [[1,3],[2,4]];

**fn.transpose( [callback] )**

    jStat( matrix ).transpose() === [[1,3],[2,4]];

Or pass a callback to run the calculation asynchronously and pass on the calculation.
This allows for continued chaining of methods to the jStat object.
Also note `this` within the callback refers to the calling jStat object.

    jStat( matrix ).transpose(function( d ) {
        // d === jStat([[1,3],[2,4]])
    })

### map( func )

Maps a function to all values and return a new object.

**map( array, fn )**

    var matrix = [[1,2],[3,4]];
    jStat.map( matrix, function( x ) {
        return x * 2;
    });
    // returns [[2,4],[6,8]]

**fn.map( fn )**

    jStat( matrix ).map(function( x ) {
        return x * 2;
    });

### cumreduce( func )

Cumulatively reduces values using a function and return a new object.

**cumreduce( array, fn )**

    var matrix = [[1,2],[3,4]];
    jStat.cumreduce( matrix, function( a, b ) {
        return a + b;
    });
    // returns [[1,3],[3,7]]

**fn.cumreduce( fn )**

    jStat( matrix ).cumreduce(function( a, b ) {
        return a + b;
    });

### alter( func )

Destructively maps to an array.

**alter( array, fn )**

    var matrix = [[1,2],[3,4]];
    jStat.alter( matrix, function( x ) {
        return x * 2;
    });
    // matrix === [[2,4],[6,8]]

**fn.alter( fn )**

    var matrix = [[1,2],[3,4]];
    jStat( matrix ).alter( function( x ) {
        return x * 2;
    });

### create()

Creates a row by col matrix using the supplied function.
If `col` is omitted then it will default to value `row`.

**create( row[, col], fn )**

    jStat.create( 2, function( row, col ) {
        return row + col;
    });
    // returns [[0,1],[1,2]]

**fn.create( row[, col], fn )**

Use this technique to create matrices in jStat instances.

    jStat().create( 2, function( row, col ) {
        return row + col;
    });
    // returns jStat([[0,1],[1,2]])

### zeros()

Creates a row by col matrix of all zeros.
If `col` is omitted then it will default to value `row`.

**zeros( row[, col] )**

    jStat.zeros( 2 );
    // returns [[0,0],[0,0]]

**fn.zeros( row[, col] )**

Use this technique to create matrices in jStat instances.

    jStat().zeros( 2 );
    // returns jStat([[0,0],[0,0]])

### ones()

Creates a row by col matrix of all ones.
If `col` is omitted then it will default to value `row`.

**ones( row[, col] )**

    jStat.zeros( 2 );
    // returns [[0,0],[0,0]]

**fn.ones( row[, col] )**

Use this technique to create matrices in jStat instances.

    jStat().ones( 2 );
    // returns jStat([[0,0],[0,0]])

### rand()

Creates a matrix of normally distributed random numbers.
If `col` is omitted then it will default to value `row`.

**rand( row[, col] )**

    jStat.rand( 3 );

**fn.rand( row[, col] )**

Use this technique to create matrices in jStat instances.

    jStat().rand( 3 );

### copy()

Returns a copy of given matrix.

### identity()

Creates an identity matrix of row by col.
If `col` is omitted then it will default to value `row`.

**identity( row[, col] )**

    jStat.identity( 2 );
    // returns [[1,0],[0,1]]

**fn.identity( row[, col] )**

Use this technique to create matrices in jStat instances.

    jStat().identity( 2 );

### seq()

Creates an arithmetic sequence by given length.

    jStat.seq(1,5,9) === [1, 1.5, 2, 2.5, 3, 3.5, 4, 4.5, 5];

### arange()

Creates an arithmetic sequence by given step.

    arange(5) === [0,1,2,3,4]
    arange(1,5) === [1,2,3,4]
    arange(5,1,-1) === [5,4,3,2]



### clear()

Sets all values in the vector or matrix to zero.

**clear( array )**

    var tmp = [1,2,3];
    jStat.clear( tmp );
    // tmp === [0,0,0]

**fn.clear( [callback] )**

    jStat( 0, 1, 3 ).clear();
    // returns [[0,0,0]]

If a callback is passed then the original object is not altered.

    var obj = jStat( 0, 1, 3 );
    obj.clear(function() {
        // this === [ 0, 0, 0 ]
    });
    // obj === [ 0, 0.5, 1 ]

### symmetric()

Tests if a matrix is symmetric.

**symmetric( array )**

    jStat.symmetric([[1,2],[2,1]]) === true

**fn.symmetric( [callback] )**

    jStat([[1,2],[2,1]]).symmetric() === true

Can pass a callback to maintain chainability.

    jStat([[1,2],[2,1]]).symmetric(function( result ) {
        // result === true
    });

## jStat Utility Methods

Utilities that are used throughout the jStat library.

### utils.calcRdx( num0, num1 )

Calculates the decimal shift for the IEEE 754 floating point calculation correction.

### utils.isArray( arg )

Tests if `arg` is an array.

### utils.isFunction( arg )

Tests if `arg` is a function.

### utils.isNumber( arg )

Tests if `arg` is a number and not `NaN`.