# jStat v1.9.3 Documentation

## Overview

### Description

jStat is a statistical library written in JavaScript that allows you to perform advanced statistical operations without the need of a dedicated statistical language (e.g. MATLAB or R). It is available for download on Github.

### Architecture

Calculations are done by static methods, while working with groups of numbers is handled by the instance methods. Here is a pseudo example of what is happening in `core.js`:

``````jStat.min = function( arr ) {
return Math.min.apply( null, arr );
}

jStat.prototype.min = function() {
var i = 0,
newval = [];
while( newval.push( jStat.min( this[i] )), ++i < this.length );
return newval;
}``````

`jStat.min` does the actual calculation on the array, while `jStat.prototype.min` is a wrapper to help work with the jStat object. The reason for this approach is to allow for maxium flexibility to other developers who want to extend jStat, while allowing for easy creation of wrappers. This way extending jStat requires minimal performance overhead and allows for more unique wrappers to be created.

Remember: Static methods almost always return native JavaScript types. Instance methods always return a jStat object.

Here is a simple example on the difference in usage between the static and instance methods:

``````var myVect = [2,6,4,7,2,7,4],
jObj = jStat( myVect );

// calculate the sum of the the vector
jStat.sum( myVect ) === 32;
jObj.sum() === 32;``````

Now say we want to do several operations on the vector (e.g. sum, min, max, and standard deviation). This can be accomplished using the static methods, but each will need to be called separately. By using the jStat object we can pass callback functions and chain the execution of each operation:

``````jObj.sum( function( val ) {
// val === sum
}).min( function( val ) {
// val === min
}).max( function( val ) {
// val === max
}).stdev( function( val ) {
// val === st. dev.
});``````

This method sets each calculation to be executed in an asynchronous queue. Very useful method of preventing blocking when working with large data sets.

Let's look at a few chaining and shorthand examples:

``````jStat( 0, 1, 11 ) === jStat( jStat.seq( 0, 1, 11 ));
jStat().rand( 4, 4 ) === jStat( jStat.rand( 4, 4 ));

jStat().create( 5, function( x, y ) {
return ( x + Math.random()) / ( y + Math.random());
}).min( true, function( x ) {
// do something with the min value
}).beta( 0.5, 0.5 ).pdf();  // generate and return the pdf
// of the beta function for all values``````

## 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 ) === [,,];
jStat.col( matrix,[0,1] ) === [[1,2],[4,5],[7,8]]``````

fn.col( index[, callback] )

``jStat( matrix ).col( 0 ) === jStat([,,]);``

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([,])
})``````

### diag()

Returns the diagonal of a matrix.

diag( array )

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

fn.diag( [callback] )

``jStat( matrix ).diag() === jStat([,,]);``

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([,,])
});``````

### antidiag()

Returns the anti-diagonal of the matrix.

antidiag( array )

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

fn.antidiag( [callback] )

``jStat( matrix ).antidiag() === jStat([,,]);``

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([,,])
});``````

### 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]``````

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

## Vector Functionality

### sum()

sum( array )

Returns the sum of the `array` vector.

``jStat.sum([1,2,3]) === 6``

fn.sum( [bool][, callback] )

Returns the sum of a vector or matrix columns.

``````jStat( 1, 5, 5 ).sum() === 15
jStat([[1,2],[3,4]]).sum() === [ 4, 6 ]``````

If callback is passed then will pass result as first argument.

``````jStat( 1, 5, 5 ).sum(function( result ) {
// result === 15
});``````

If pass boolean true as first argument, then return sum of entire matrix.

``jStat([[1,2],[3,4]]).sum( true ) === 10``

And the two can be combined.

``````jStat([[1,2],[3,4]]).sum(true, function( result ) {
// result === 10
});``````

### sumsqrd()

sumsqrd( array )

Returns the sum squared of the `array` vector.

``jStat.sumsqrd([1,2,3]) === 14``

fn.sumsqrd( [bool][, callback] )

Returns the sum squared of a vector or matrix columns.

``````jStat( 1, 5, 5 ).sumsqrd() === 55
jStat([[1,2],[3,4]]).sumsqrd() === [ 10, 20 ]``````

If callback is passed then will pass result as first argument.

``````jStat( 1, 5, 5 ).sumsqrd(function( result ) {
// result === 55
});``````

If pass boolean true as first argument, then return sum squared of entire matrix.

``jStat([[1,2],[3,4]]).sumsqrd( true ) === 650``

And the two can be combined.

``````jStat([[1,2],[3,4]]).sumsqrd(true,function( result ) {
// result === 650
});``````

### sumsqerr()

sumsqerr( array )

Returns the sum of squared errors of prediction of the `array` vector.

``jStat.sumsqerr([1,2,3]) === 2``

fn.sumsqerr( [bool][, callback] )

Returns the sum of squared errors of prediction of a vector or matrix columns.

``````jStat( 1, 5, 5 ).sumsqerr() === 10
jStat([[1,2],[3,4]]).sumsqerr() === [ 2, 2 ]``````

If callback is passed then will pass result as first argument.

``````jStat( 1, 5, 5 ).sumsqerr(function( result ) {
// result === 55
});``````

If pass boolean true as first argument, then return sum of squared errors of entire matrix.

``jStat([[1,2],[3,4]]).sumsqerr( true ) === 0``

And the two can be combined.

``````jStat([[1,2],[3,4]]).sumsqerr(true,function( result ) {
// result === 0
});``````

### sumrow()

sumrow( array )

Returns the sum of the `array` vector in row-based order.

``jStat.sumrow([1,2,3]) === 6``

fn.sumrow( [bool][, callback] )

Returns the sum of a vector or matrix rows.

``````jStat( 1, 5, 5 ).sumrow() === 15
jStat([[1,2],[3,4]]).sumrow() === [ 3, 7 ]``````

If callback is passed then will pass result as first argument.

``````jStat( 1, 5, 5 ).sumrow(function( result ) {
// result === 15
});``````

If pass boolean true as first argument, then return sum of entire matrix.

``jStat([[1,2],[3,4]]).sumrow( true ) === 10``

And the two can be combined.

``````jStat([[1,2],[3,4]]).sumrow(true,function( result ) {
// result === 10
});``````

### product()

product( array )

Returns the product of the `array` vector.

``jStat.product([1,2,3]) === 6``

fn.product( [bool][, callback] )

Returns the product of a vector or matrix columns.

``````jStat( 1, 5, 5 ).product() === 120
jStat([[1,2],[3,4]]).product() === [ 3, 8 ]``````

If callback is passed then will pass result as first argument.

``````jStat( 1, 5, 5 ).product(function( result ) {
// result === 120
});``````

If pass boolean true as first argument, then return sumsqerr of entire matrix.

``jStat([[1,2],[3,4]]).product( true ) === 24``

And the two can be combined.

``````jStat([[1,2],[3,4]]).product(true,function( result ) {
// result === 24
});``````

### min()

min( array )

Returns the minimum value of the `array` vector.

``jStat.min([1,2,3]) === 1``

fn.min( [bool][, callback] )

Returns the minimum value of a vector or matrix columns.

``````jStat( 1, 5, 5 ).min() === 1
jStat([[1,2],[3,4]]).min() === [ 1, 2 ]``````

If callback is passed then will pass result as first argument.

``````jStat( 1, 5, 5 ).min(function( result ) {
// result === 1
});``````

If pass boolean true as first argument, then return minimum of entire matrix.

``jStat([[1,2],[3,4]]).min( true ) === 1``

And the two can be combined.

``````jStat([[1,2],[3,4]]).min(true,function( result ) {
// result === 1
});``````

### max()

max( array )

Returns the maximum value of the `array` vector.

``jStat.max([1,2,3]) === 3``

fn.max( [bool][, callback] )

Returns the maximum value of a vector or matrix columns.

``````jStat( 1, 5, 5 ).max() === 5
jStat([[1,2],[3,4]]).max() === [ 3, 4 ]``````

If callback is passed then will pass result as first argument.

``````jStat( 1, 5, 5 ).max(function( result ) {
// result === 5
});``````

If pass boolean true as first argument, then return maximum of entire matrix.

``jStat([[1,2],[3,4]]).max( true ) === 4``

And the two can be combined.

``````jStat([[1,2],[3,4]]).max(true,function( result ) {
// result === 4
});``````

### mean()

mean( array )

Returns the mean of the `array` vector.

``jStat.mean([1,2,3]) === 2``

fn.max( [bool,][callback] )

Returns the max of a vector or matrix columns.

``````jStat( 1, 5, 5 ).mean() === 3
jStat([[1,2],[3,4]]).mean() === [ 2, 3 ]``````

If callback is passed then will pass result as first argument.

``````jStat( 1, 5, 5 ).mean(function( result ) {
// result === 3
});``````

If pass boolean true as first argument, then return mean of entire matrix.

``jStat([[1,2],[3,4]]).mean( true ) === 2.5``

And the two can be combined.

``````jStat([[1,2],[3,4]]).mean(true,function( result ) {
// result === 2.5
});``````

### meansqerr()

meansqerr( array )

Returns the mean squared error of the `array` vector.

``jStat.meansqerr([1,2,3]) === 0.66666...``

fn.meansqerr( [bool][, callback] )

Returns the mean squared error of a vector or matrix columns.

``````jStat( 1, 5, 5 ).meansqerr() === 2
jStat([[1,2],[3,4]]).meansqerr() === [ 1, 1 ]``````

If callback is passed then will pass result as first argument.

``````jStat( 1, 5, 5 ).meansqerr(function( result ) {
// result === 2
});``````

If pass boolean true as first argument, then return mean squared error of entire matrix.

``jStat([[1,2],[3,4]]).meansqerr( true ) === 0``

And the two can be combined.

``````jStat([[1,2],[3,4]]).meansqerr(true,function( result ) {
// result === 0
});``````

### geomean()

geomean( array )

Returns the geometric mean of the `array` vector.

``jStat.geomean([4,1,1/32]) === 0.5``

fn.geomean( [bool][, callback] )

Returns the geometric mean of a vector or matrix columns.

``````jStat([4,1,1\32]).geomean() === 0.5
jStat([[1,2],[3,4]]).geomean() === [ 1.732..., 2.828... ]``````

If callback is passed then will pass result as first argument.

``````jStat([4,1,1\32]).geomean(function( result ) {
// result === 0.5
});``````

If pass boolean true as first argument, then return geometric mean of entire matrix.

``jStat([[1,2],[3,4]]).geomean( true ) === 2.213...``

And the two can be combined.

``````jStat([[1,2],[3,4]]).geomean(true,function( result ) {
// result === 2.213...
});``````

### median()

median( array )

Returns the median of the `array` vector.

``jStat.median([1,2,3]) === 2``

fn.median( [bool][, callback] )

Returns the median of a vector or matrix columns.

``````jStat( 1, 5, 5 ).median() === 3
jStat([[1,2],[3,4]]).median() === [ 2, 3 ]``````

If callback is passed then will pass result as first argument.

``````jStat( 1, 5, 5 ).median(function( result ) {
// result === 3
});``````

If pass boolean true as first argument, then return median of entire matrix.

``jStat([[1,2],[3,4]]).median( true ) === 2.5``

And the two can be combined.

``````jStat([[1,2],[3,4]]).median(true,function( result ) {
// result === 2.5
});``````

### cumsum()

cumsum( array )

Returns an array of partial sums in the sequence.

``jStat.cumsum([1,2,3]) === [1,3,6]``

fn.cumsum( [bool][, callback] )

Returns an array of partial sums for a vector or matrix columns.

``````jStat( 1, 5, 5 ).cumsum() === [1,3,6,10,15]
jStat([[1,2],[3,4]]).cumsum() === [[1,4],[2,6]]``````

If callback is passed then will pass result as first argument.

``````jStat( 1, 5, 5 ).cumsum(function( result ) {
// result === [1,3,6,10,15]
});``````

If pass boolean true as first argument, then return cumulative sums of the matrix.

``jStat([[1,2],[3,4]]).cumsum( true ) === [[1,3],[3,7]]``

And the two can be combined.

``````jStat([[1,2],[3,4]]).cumsum(true,function( result ) {
// result === ...
});``````

### cumprod()

cumprod( array )

Returns an array of partial products in the sequence.

``jStat.cumprod([2,3,4]) === [2,6,24]``

fn.cumprod( [bool][, callback] )

Returns an array of partial products for a vector or matrix columns.

``````jStat( 1, 5, 5 ).cumprod() === [1,2,6,24,120]
jStat([[1,2],[3,4]]).cumprod() === [[1,3],[2,8]]``````

If callback is passed then will pass result as first argument.

``````jStat( 1, 5, 5 ).cumprod(function( result ) {
// result === [1,2,6,24,120]
});``````

If pass boolean true as first argument, then return cumulative products of the matrix.

``jStat([[1,2],[3,4]]).cumprod( true ) === [[1,2],[3,12]]``

And the two can be combined.

``````jStat([[1,2],[3,4]]).cumprod(true,function( result ) {
// result === ...
});``````

### diff()

diff( array )

Returns an array of the successive differences of the array.

``jStat.diff([1,2,2,3]) === [1,0,1]``

fn.diff( [bool][, callback] )

Returns an array of successive differences for a vector or matrix columns.

``````jStat([1,2,2,3]).diff() === [1,0,1]
jStat([[1,2],[3,4],[1,4]]).diff() === [[2,-2],[2,0]]``````

If callback is passed then will pass result as first argument.

``````jStat([[1,2],[3,4],[1,4]]).diff(function( result ) {
// result === [[2,-2],[2,0]]
});``````

If pass boolean true as first argument, then return successive difference for the whole matrix.

``jStat([[1,2],[3,4],[1,4]]).diff(true) === [0,2]``

And the two can be combined.

``````jStat([[1,2],[3,4],[1,4]]).diff(true,function( result ) {
// result === [0,2]
});``````

### rank()

rank( array )

Returns an array of the ranks of the array.

``jStat.rank([1, 2, 2, 3]) === [1, 2.5, 2.5, 4]``

fn.rank( [bool][, callback] )

Returns an array of ranks for a vector or matrix columns.

``````jStat([1, 2, 2, 3]).rank() === [1, 2.5, 2.5, 4]
jStat([[1, 2], [3, 4], [1, 4]]).rank() === [[1.5, 3, 1.5], [1, 2.5, 2.5]]``````

If callback is passed then will pass result as first argument.

``````jStat([[1, 2], [3, 4], [1, 4]]).rank(function( result ) {
// result === [[1.5, 3, 1.5], [1, 2.5, 2.5]]
});``````

If pass boolean true as first argument, then return rank for the whole matrix.

``jStat([[1, 2], [3, 4], [1, 4]]).rank(true) === [2, 5, 2, 5, 2, 5]``

And the two can be combined.

``````jStat([[1, 2], [3, 4], [1, 4]]).rank(true, function( result ) {
// result === [2, 5, 2, 5, 2, 5]
});``````

### mode()

mode( array )

Returns the mode of the `array` vector. If there are multiple modes then `mode()` will return all of them.

``````jStat.mode([1,2,2,3]) === 2
jStat.mode([1,2,3]) === [1,2,3]``````

fn.mode( [bool][, callback] )

Returns the mode for a vector or matrix columns.

``````jStat([1,2,2,3]).mode() === 2
jStat([[1,2],[3,4],[1,4]]).mode() === [1,4]``````

If callback is passed then will pass result as first argument.

``````jStat( 1, 5, 5 ).mode(function( result ) {
// result === false
});``````

If pass boolean true as first argument, then the matrix will be treated as one dimensional.

``jStat([[5,4],[5, 2], [5,2]]).mode( true ) === 5``

### range()

range( array )

Returns the range of the `array` vector.

``jStat.range([1,2,3]) === 2``

fn.range( [bool][, callback] )

Returns the range for a vector or matrix columns.

``````jStat([1,2,3]).range() === 2
jStat([[1,2],[3,4]]).range() === [2,2]``````

If callback is passed then will pass result as first argument.

``````jStat( 1, 5, 5 ).range(function( result ) {
// result === 4
});``````

If pass boolean true as first argument, then return range of the matrix.

``jStat([[1,2],[3,5]]).range( true ) === true``

And the two can be combined.

``````jStat([[1,2],[3,5]]).range(true,function( result ) {
// result === 1
});``````

### variance()

variance( array[, flag] )

Returns the variance of the `array` vector. By default, the population variance is calculated. Passing `true` to `flag` indicates to compute the sample variance instead.

``````jStat.variance([1,2,3,4]) === 1.25
jStat.variance([1,2,3,4],true) === 1.66666...``````

fn.variance( [bool][, callback] )

Returns the variance for a vector or matrix columns.

Note: Cannot pass flag to indicate between population or sample for matrices. There is a feature request for this on Issue #51.

``````jStat([1,2,3,4]).variance() === 1.25
jStat([[1,2],[3,4]]).variance() === [1,1]``````

If callback is passed then will pass result as first argument.

``````jStat( 1, 5, 5 ).variance(function( result ) {
// result === 2
});``````

If pass boolean true as first argument, then return variance of the matrix.

``jStat([[1,2],[3,5]]).variance( true ) === 0.140625``

And the two can be combined.

``````jStat([[1,2],[3,5]]).variance(true,function( result ) {
// result === 0.140625
});``````

### pooledvariance()

pooledvariance( arrays )

Returns the pooled (sample) variance of an array of vectors. Assumes the population variance of the vectors are the same.

``jStat.pooledvariance([[1,2],[3,4]]) === 0.5``

### deviation()

deviation( array )

Returns the deviation of the `array` vector.

``jStat.deviation([1,2,3,4]) === [-1.5, -0.5, 0.5, 1.5]``

fn.deviation( [bool][, callback] )

Returns the deviation for a vector or matrix columns.

``````jStat([1,2,3,4]).deviation() === [-1.5, -0.5, 0.5, 1.5]
jStat([[1,2],[3,4]]).deviation() === [[-1,1],[-1,1]]``````

If callback is passed then will pass result as first argument.

``````jStat( 1, 4, 4 ).deviation(function( result ) {
// result === [-1.5, -0.5, 0.5, 1.5]
});``````

If pass boolean true as first argument, then return variance of the matrix.

``jStat([[1,2],[3,5]]).deviation( true ) === [-0.5, 0.5, -1, 1]``

And the two can be combined.

``````jStat([[1,2],[3,5]]).deviation(true,function( result ) {
// result === [-0.5, 0.5, -1, 1]
});``````

### stdev()

stdev( array[, flag] )

Returns the standard deviation of the `array` vector. By default, the population standard deviation is returned. Passing `true` to `flag` returns the sample standard deviation.

The 'sample' standard deviation is also called the 'corrected standard deviation', and is an unbiased estimator of the population standard deviation. The population standard deviation is also the 'uncorrected standard deviation', and is a biased but minimum-mean-squared-error estimator.

``````jStat.stdev([1,2,3,4]) === 1.118...
jStat.stdev([1,2,3,4],true) === 1.290...``````

fn.stdev( [bool][, callback] )

Returns the standard deviation for a vector or matrix columns.

Note: Cannot pass `flag` to indicate between population or sample for matrices. There is a feature request for this on Issue #51.

``````jStat([1,2,3,4]).stdev() === 1.118...
jStat([1,2,3,4]).stdev(true) === 1.290...
jStat([[1,2],[3,4]]).stdev() === [1,1]``````

If callback is passed then will pass result as first argument.

``````jStat( 1, 4, 4 ).stdev(function( result ) {
// result === 1.118...
});
jStat( 1, 4, 4 ).stdev(true,function( result ) {
// result === 1.290...
});``````

If pass boolean true as first argument, then return variance of the matrix.

``jStat([[1,2],[3,5]]).stdev( true ) === 0.25``

And the two can be combined.

``````jStat([[1,2],[3,5]]).stdev(true,function( result ) {
// result === 0.25
});``````

### pooledstdev()

pooledstdev( arrays )

Returns the pooled (sample) standard deviation of an array of vectors. Assumes the population standard deviation of the vectors are the same.

``jStat.pooledstdev([[1,2],[3,4]]) === 0.707...``

### meandev()

meandev( array )

Returns the mean absolute deviation of the `array` vector.

``jStat.meandev([1,2,3,4]) === 1``

fn.meandev( [bool][, callback] )

Returns the mean absolute deviation for a vector or matrix columns.

``````jStat([1,2,3,4]).meandev() === 1
jStat([[1,2],[3,4]]).meandev() === [1,1]``````

If callback is passed then will pass result as first argument.

``````jStat( 1, 4, 4 ).meandev(function( result ) {
// result === 1
});``````

If pass boolean true as first argument, then return mean absolute deviation of the matrix.

``jStat([[1,2],[3,5]]).meandev( true ) === 0.25``

And the two can be combined.

``````jStat([[1,2],[3,5]]).meandev(true,function( result ) {
// result === 0.25
});``````

### meddev()

meddev( array )

Returns the median absolute deviation of the `array` vector.

``jStat.meddev([1,2,3,4]) === 1``

fn.meddev( [bool][, callback] )

Returns the median absolute deviation for a vector or matrix columns.

``````jStat([1,2,3,4]).meddev() === 1
jStat([[1,2],[3,4]]).meddev() === [1,1]``````

If callback is passed then will pass result as first argument.

``````jStat( 1, 4, 4 ).meddev(function( result ) {
// result === 1
});``````

If pass boolean true as first argument, then return median absolute deviation of the matrix.

``jStat([[1,2],[3,5]]).meddev( true ) === 0.25``

And the two can be combined.

``````jStat([[1,2],[3,5]]).meddev(true,function( result ) {
// result === 0.25
});``````

### skewness()

skewness( array )

Returns the skewness of the `array` vector (third standardized moment).

``jStat.skewness([1,2,2,3,5]) === 0.75003...``

### kurtosis()

kurtosis( array )

Returns the excess kurtosis of the `array` vector (fourth standardized moment - 3).

``jStat.kurtosis([1,2,3,4]) === -0.63610...``

### coeffvar()

coeffvar( array )

Returns the coefficient of variation of the `array` vector.

``jStat.coeffvar([1,2,3,4]) === 0.447...``

fn.coeffvar( [bool][, callback] )

Returns the coefficient of variation for a vector or matrix columns.

``````jStat([1,2,3,4]).coeffvar() === 0.447...
jStat([[1,2],[3,4]]).coeffvar() === [0.5,0.333...]``````

If callback is passed then will pass result as first argument.

``````jStat( 1, 4, 4 ).coeffvar(function( result ) {
// result === 0.447...
});``````

If pass boolean true as first argument, then return coefficient of variation of the matrix.

``jStat([[1,2],[3,5]]).coeffvar( true ) === 0.142...``

And the two can be combined.

``````jStat([[1,2],[3,5]]).coeffvar(true,function( result ) {
// result === 0.142...
});``````

### quartiles()

quartiles( array )

Returns the quartiles of the `array` vector.

``jStat.quartiles( jStat.seq(1,100,100)) === [25,50,75]``

fn.quartiles( [callback] )

Returns the quartiles for a vector or matrix columns.

``````jStat(1,100,100).quartiles() === [25,50,75]
jStat(1,100,100,function( x ) {
return [x,x];
}).quartiles() === [[25,50,75],[25,50,75]]``````

If callback is passed then will pass result as first argument.

``````jStat(1,100,100).quartiles(function( result ) {
// result === [25,50,75]
});``````

### quantiles()

quantiles( dataArray, quantilesArray[, alphap[, betap]] )

Like quartiles, but calculate and return arbitrary quantiles of the `dataArray` vector or matrix (column-by-column).

``````jStat.quantiles([1, 2, 3, 4, 5, 6],
[0.25, 0.5, 0.75]) === [1.9375, 3.5, 5.0625]``````

Optional parameters alphap and betap govern the quantile estimation method. For more details see the Wikipedia page on quantiles or scipy.stats.mstats.mquantiles documentation.

### percentile()

percentile( dataArray, k, [exclusive] )

Returns the k-th percentile of values in the `dataArray` range, where k is in the range 0..1, exclusive. Passing true for the exclusive parameter excludes both endpoints of the range.

`````` jStat.percentile([1, 2, 3, 4], 0.3) === 1.9;
jStat.percentile([1, 2, 3, 4], 0.3, true) === 1.5;``````

### percentileOfScore()

percentileOfScore( dataArray, score[, kind] )

The percentile rank of score in a given array. Returns the percentage of all values in `dataArray` that are less than (if `kind == 'strict'`) or less or equal than (if `kind == 'weak'`) score. Default is `'weak'`.

`` jStat.percentileOfScore([1, 2, 3, 4, 5, 6], 3), 0.5, 'weak') === 0.5;``

### histogram()

histogram( dataArray[, numBins] )

The histogram data defined as the number of `dataArray` elements found in equally sized bins across the range of `dataArray`. Default number of bins is 4.

`` jStat.histogram([100, 101, 102, 230, 304, 305, 400], 3) === [3, 1, 3];``

### covariance()

covariance( array1, array2 )

Returns the covariance of the `array1` and `array2` vectors.

``````var seq = jStat.seq( 0, 10, 11 );
jStat.covariance( seq, seq ) === 11;``````

### corrcoeff()

corrcoeff( array1, array2 )

Returns the population correlation coefficient of the `array1` and `array2` vectors (Pearson's Rho).

``````var seq = jStat.seq( 0, 10, 11 );
jStat.corrcoeff( seq, seq ) === 1;``````

spearmancoeff( array1, array2 )

Returns the rank correlation coefficient of the `array1` and `array2` vectors (Spearman's Rho).

``````jStat.spearmancoeff([1, 2, 3, 4], [5, 6, 9, 7]) == 0.8;
jStat.spearmancoeff([1, 2, 2, 4], [5, 2, 5, 7]) == 0.5;``````

## Distributions

### jStat.beta( alpha, beta )

#### jStat.beta.pdf( x, alpha, beta )

Returns the value of `x` in the Beta distribution with parameters `alpha` and `beta`.

#### jStat.beta.cdf( x, alpha, beta )

Returns the value of `x` in the cdf for the Beta distribution with parameters `alpha` and `beta`.

#### jStat.beta.inv( p, alpha, beta )

Returns the value of `p` in the inverse of the cdf for the Beta distribution with parameters `alpha` and `beta`.

#### jStat.beta.mean( alpha, beta )

Returns the mean of the Beta distribution with parameters `alpha` and `beta`.

#### jStat.beta.median( alpha, beta )

Returns the median of the Beta distribution with parameters `alpha` and `beta`.

#### jStat.beta.mode( alpha, beta )

Returns the mode of the Beta distribution with parameters `alpha` and `beta`.

#### jStat.beta.sample( alpha, beta )

Returns a random number whose distribution is the Beta distribution with parameters `alpha` and `beta`.

#### jStat.beta.variance( alpha, beta )

Returns the variance of the Beta distribution with parameters `alpha` and `beta`.

### jStat.centralF( df1, df2 )

The F Distrbution is used frequently in analyses of variance. The distribution is parameterized by two degrees of freedom (`df1` and `df2`). It is defined continuously on x in [0, infinity).

In all cases, `df1` is the "numerator degrees of freedom" and `df2` is the "denominator degrees of freedom", which parameterize the distribtuion.

#### jStat.centralF.pdf( x, df1, df2 )

Given `x` in the range [0, infinity), returns the probability density of the (central) F distribution at `x`.

This function corresponds to the `df(x, df1, df2)` function in R.

#### jStat.centralF.cdf( x, df1, df2 )

Given x in the range [0, infinity), returns the cumulative probability density of the central F distribution. That is, `jStat.centralF.cdf(2.5, 10, 20)` will return the probability that a number randomly selected from the central F distribution with `df1 = 10` and `df2 = 20` will be less than 2.5.

This function corresponds to the `pf(q, df1, df2)` function in R.

#### jStat.centralF.inv( p, df1, df2 )

Given `p` in [0, 1), returns the value of x for which the cumulative probability density of the central F distribution is p. That is, `jStat.centralF.inv(p, df1, df2) = x` if and only if `jStat.centralF.inv(x, df1, df2) = p`.

This function corresponds to the `qf(p, df1, df2)` function in R.

#### jStat.centralF.mean( df1, df2 )

Returns the mean of the (Central) F distribution.

#### jStat.centralF.mode( df1, df2 )

Returns the mode of the (Central) F distribution.

#### jStat.centralF.sample( df1, df2 )

Returns a random number whose distribution is the (Central) F distribution.

This function corresponds to the `rf(n, df1, df2)` function in R.

#### jStat.centralF.variance( df1, df2 )

Returns the variance of the (Central) F distribution.

### jStat.cauchy( local, scale )

#### jStat.cauchy.pdf( x, local, scale )

Returns the value of `x` in the pdf of the Cauchy distribution with a location (median) of `local` and scale factor of `scale`.

#### jStat.cauchy.cdf( x, local, scale )

Returns the value of `x` in the cdf of the Cauchy distribution with a location (median) of `local` and scale factor of `scale`.

#### jStat.cauchy.inv( p, local, scale )

Returns the value of `p` in the inverse of the cdf for the Cauchy distribution with a location (median) of `local` and scale factor of `scale`.

#### jStat.cauchy.median( local, scale )

Returns the value of the median for the Cauchy distribution with a location (median) of `local` and scale factor of `scale`.

#### jStat.cauchy.mode( local, scale )

Returns the value of the mode for the Cauchy distribution with a location (median) of `local` and scale factor of `scale`.

#### jStat.cauchy.sample( local, scale )

Returns a random number whose distribution is the Cauchy distribution with a location (median) of `local` and scale factor of `scale`.

#### jStat.cauchy.variance( local, scale )

Returns the value of the variance for the Cauchy distribution with a location (median) of `local` and scale factor of `scale`.

### jStat.chisquare( dof )

#### jStat.chisquare.pdf( x, dof )

Returns the value of `x` in the pdf of the Chi Square distribution with `dof` degrees of freedom.

#### jStat.chisquare.cdf( x, dof )

Returns the value of `x` in the cdf of the Chi Square distribution with `dof` degrees of freedom.

#### jStat.chisquare.inv( p, dof )

Returns the value of `x` in the inverse of the cdf for the Chi Square distribution with `dof` degrees of freedom.

#### jStat.chisquare.mean( dof )

Returns the value of the mean for the Chi Square distribution with `dof` degrees of freedom.

#### jStat.chisquare.median( dof )

Returns the value of the median for the Chi Square distribution with `dof` degrees of freedom.

#### jStat.chisquare.mode( dof )

Returns the value of the mode for the Chi Square distribution with `dof` degrees of freedom.

#### jStat.chisquare.sample( dof )

Returns a random number whose distribution is the Chi Square distribution with `dof` degrees of freedom.

#### jStat.chisquare.variance( dof )

Returns the value of the variance for the Chi Square distribution with `dof` degrees of freedom.

### jStat.exponential( rate )

#### jStat.exponential.pdf( x, rate )

Returns the value of `x` in the pdf of the Exponential distribution with the parameter `rate` (lambda).

#### jStat.exponential.cdf( x, rate )

Returns the value of `x` in the cdf of the Exponential distribution with the parameter `rate` (lambda).

#### jStat.exponential.inv( p, rate )

Returns the value of `p` in the inverse of the cdf for the Exponential distribution with the parameter `rate` (lambda).

#### jStat.exponential.mean( rate )

Returns the value of the mean for the Exponential distribution with the parameter `rate` (lambda).

#### jStat.exponential.median( rate )

Returns the value of the median for the Exponential distribution with the parameter `rate` (lambda)

#### jStat.exponential.mode( rate )

Returns the value of the mode for the Exponential distribution with the parameter `rate` (lambda).

#### jStat.exponential.sample( rate )

Returns a random number whose distribution is the Exponential distribution with the parameter `rate` (lambda).

#### jStat.exponential.variance( rate )

Returns the value of the variance for the Exponential distribution with the parameter `rate` (lambda).

### jStat.gamma( shape, scale )

#### jStat.gamma.pdf( x, shape, scale )

Returns the value of `x` in the pdf of the Gamma distribution with the parameters `shape` (k) and `scale` (theta). Notice that if using the alpha beta convention, `scale = 1/beta`.

#### jStat.gamma.cdf( x, shape, scale )

Returns the value of `x` in the cdf of the Gamma distribution with the parameters `shape` (k) and `scale` (theta). Notice that if using the alpha beta convention, `scale = 1/beta`.

This function is checked against R's `pgamma` function.

#### jStat.gamma.inv( p, shape, scale )

Returns the value of `p` in the inverse of the cdf for the Gamma distribution with the parameters `shape` (k) and `scale` (theta). Notice that if using the alpha beta convention, `scale = 1/beta`.

This function is checked against R's `qgamma` function.

#### jStat.gamma.mean( shape, scale )

Returns the value of the mean for the Gamma distribution with the parameters `shape` (k) and `scale` (theta). Notice that if using the alpha beta convention, `scale = 1/beta`.

#### jStat.gamma.mode( shape, scale )

Returns the value of the mode for the Gamma distribution with the parameters `shape` (k) and `scale` (theta). Notice that if using the alpha beta convention, `scale = 1/beta`.

#### jStat.gamma.sample( shape, scale )

Returns a random number whose distribution is the Gamma distribution with the parameters `shape` (k) and `scale` (theta). Notice that if using the alpha beta convention, `scale = 1/beta`.

#### jStat.gamma.variance( shape, scale )

Returns the value of the variance for the Gamma distribution with the parameters `shape` (k) and `scale` (theta). Notice that if using the alpha beta convention, `scale = 1/beta`.

### jStat.invgamma( shape, scale )

#### jStat.invgamma.pdf( x, shape, scale )

Returns the value of `x` in the pdf of the Inverse-Gamma distribution with parametres `shape` (alpha) and `scale` (beta).

#### jStat.invgamma.cdf( x, shape, scale )

Returns the value of `x` in the cdf of the Inverse-Gamma distribution with parametres `shape` (alpha) and `scale` (beta).

#### jStat.invgamma.inv( p, shape, scale )

Returns the value of `p` in the inverse of the cdf for the Inverse-Gamma distribution with parametres `shape` (alpha) and `scale` (beta).

#### jStat.invgamma.mean( shape, scale )

Returns the value of the mean for the Inverse-Gamma distribution with parametres `shape` (alpha) and `scale` (beta).

#### jStat.invgamma.mode( shape, scale )

Returns the value of the mode for the Inverse-Gamma distribution with parametres `shape` (alpha) and `scale` (beta).

#### jStat.invgamma.sample( shape, scale )

Returns a random number whose distribution is the Inverse-Gamma distribution with parametres `shape` (alpha) and `scale` (beta).

#### jStat.invgamma.variance( shape, scale )

Returns the value of the variance for the Inverse-Gamma distribution with parametres `shape` (alpha) and `scale` (beta).

### jStat.kumaraswamy( alpha, beta )

#### jStat.kumaraswamy.pdf( x, a, b )

Returns the value of `x` in the pdf of the Kumaraswamy distribution with parameters `a` and `b`.

#### jStat.kumaraswamy.cdf( x, alpha, beta )

Returns the value of `x` in the cdf of the Kumaraswamy distribution with parameters `alpha` and `beta`.

#### jStat.kumaraswamy.inv( p, alpha, beta )

Returns the value of `p` in the inverse of the pdf for the Kumaraswamy distribution with parametres `alpha` and `beta`.

This function corresponds to `qkumar(p, alpha, beta)` in R's VGAM package.

#### jStat.kumaraswamy.mean( alpha, beta )

Returns the value of the mean of the Kumaraswamy distribution with parameters `alpha` and `beta`.

#### jStat.kumaraswamy.median( alpha, beta )

Returns the value of the median of the Kumaraswamy distribution with parameters `alpha` and `beta`.

#### jStat.kumaraswamy.mode( alpha, beta )

Returns the value of the mode of the Kumaraswamy distribution with parameters `alpha` and `beta`.

#### jStat.kumaraswamy.variance( alpha, beta )

Returns the value of the variance of the Kumaraswamy distribution with parameters `alpha` and `beta`.

### jStat.lognormal( mu, sigma )

#### jStat.lognormal.pdf( x, mu, sigma )

Returns the value of `x` in the pdf of the Log-normal distribution with paramters `mu` (mean) and `sigma` (standard deviation).

#### jStat.lognormal.cdf( x, mu, sigma )

Returns the value of `x` in the cdf of the Log-normal distribution with paramters `mu` (mean) and `sigma` (standard deviation).

#### jStat.lognormal.inv( p, mu, sigma )

Returns the value of `x` in the inverse of the cdf for the Log-normal distribution with paramters `mu` (mean of the Normal distribution) and `sigma` (standard deviation of the Normal distribution).

#### jStat.lognormal.mean( mu, sigma )

Returns the value of the mean for the Log-normal distribution with paramters `mu` (mean of the Normal distribution) and `sigma` (standard deviation of the Normal distribution).

#### jStat.lognormal.median( mu, sigma )

Returns the value of the median for the Log-normal distribution with paramters `mu` (mean of the Normal distribution) and `sigma` (standard deviation of the Normal distribution).

#### jStat.lognormal.mode( mu, sigma )

Returns the value of the mode for the Log-normal distribution with paramters `mu` (mean of the Normal distribution) and `sigma` (standard deviation of the Normal distribution).

#### jStat.lognormal.sample( mu, sigma )

Returns a random number whose distribution is the Log-normal distribution with paramters `mu` (mean of the Normal distribution) and `sigma` (standard deviation of the Normal distribution).

#### jStat.lognormal.variance( mu, sigma )

Returns the value of the variance for the Log-normal distribution with paramters `mu` (mean of the Normal distribution) and `sigma` (standard deviation of the Normal distribution).

### jStat.normal( mean, std )

#### jStat.normal.pdf( x, mean, std )

Returns the value of `x` in the pdf of the Normal distribution with parameters `mean` and `std` (standard deviation).

#### jStat.normal.cdf( x, mean, std )

Returns the value of `x` in the cdf of the Normal distribution with parameters `mean` and `std` (standard deviation).

#### jStat.normal.inv( p, mean, std )

Returns the value of `p` in the inverse cdf for the Normal distribution with parameters `mean` and `std` (standard deviation).

#### jStat.normal.mean( mean, std )

Returns the value of the mean for the Normal distribution with parameters `mean` and `std` (standard deviation).

#### jStat.normal.median( mean, std )

Returns the value of the median for the Normal distribution with parameters `mean` and `std` (standard deviation).

#### jStat.normal.mode( mean, std )

Returns the value of the mode for the Normal distribution with parameters `mean` and `std` (standard deviation).

#### jStat.normal.sample( mean, std )

Returns a random number whose distribution is the Normal distribution with parameters `mean` and `std` (standard deviation).

#### jStat.normal.variance( mean, std )

Returns the value of the variance for the Normal distribution with parameters `mean` and `std` (standard deviation).

### jStat.pareto( scale, shape )

#### jStat.pareto.pdf( x, scale, shape )

Returns the value of `x` in the pdf of the Pareto distribution with parameters `scale` (x<sub>m</sub>) and `shape` (alpha).

#### jStat.pareto.inv( p, scale, shape )

Returns the inverse of the Pareto distribution with probability `p`, `scale`, `shape`.

This coresponds to `qpareto(p, scale, shape)` in R's VGAM package, and generally corresponds to the `q`<dist> function pattern in R.

#### jStat.pareto.cdf( x, scale, shape )

Returns the value of `x` in the cdf of the Pareto distribution with parameters `scale` (x<sub>m</sub>) and `shape` (alpha).

#### jStat.pareto.mean( scale, shape )

Returns the value of the mean of the Pareto distribution with parameters `scale` (x<sub>m</sub>) and `shape` (alpha).

#### jStat.pareto.median( scale, shape )

Returns the value of the median of the Pareto distribution with parameters `scale` (x<sub>m</sub>) and `shape` (alpha).

#### jStat.pareto.mode( scale, shape )

Returns the value of the mode of the Pareto distribution with parameters `scale` (x<sub>m</sub>) and `shape` (alpha).

#### jStat.pareto.variance( scale, shape )

Returns the value of the variance of the Pareto distribution with parameters `scale` (x<sub>m</sub>) and `shape` (alpha).

### jStat.studentt( dof )

#### jStat.studentt.pdf( x, dof )

Returns the value of `x` in the pdf of the Student's T distribution with `dof` degrees of freedom.

#### jStat.studentt.cdf( x, dof )

Returns the value of `x` in the cdf of the Student's T distribution with `dof` degrees of freedom.

#### jStat.studentt.inv( p, dof )

Returns the value of `p` in the inverse of the cdf for the Student's T distribution with `dof` degrees of freedom.

#### jStat.studentt.mean( dof )

Returns the value of the mean of the Student's T distribution with `dof` degrees of freedom.

#### jStat.studentt.median( dof )

Returns the value of the median of the Student's T distribution with `dof` degrees of freedom.

#### jStat.studentt.mode( dof )

Returns the value of the mode of the Student's T distribution with `dof` degrees of freedom.

#### jStat.studentt.sample( dof )

Returns a random number whose distribution is the Student's T distribution with `dof` degrees of freedom.

#### jStat.studentt.variance( dof )

Returns the value of the variance for the Student's T distribution with `dof` degrees of freedom.

### jStat.tukey( nmeans, dof )

#### jStat.tukey.cdf( q, nmeans, dof )

Returns the value of q in the cdf of the Studentized range distribution with `nmeans` number of groups nmeans and `dof` degrees of freedom.

#### jStat.tukey.inv( p, nmeans, dof )

Returns the value of `p` in the inverse of the cdf for the Studentized range distribution with `nmeans` number of groups and `dof` degrees of freedom. Only accurate to 4 decimal places.

### jStat.weibull( scale, shape )

#### jStat.weibull.pdf( x, scale, shape )

Returns the value `x` in the pdf for the Weibull distribution with parameters `scale` (lambda) and `shape` (k).

#### jStat.weibull.cdf( x, scale, shape )

Returns the value `x` in the cdf for the Weibull distribution with parameters `scale` (lambda) and `shape` (k).

#### jStat.weibull.inv( p, scale, shape )

Returns the value of `x` in the inverse of the cdf for the Weibull distribution with parameters `scale` (lambda) and `shape` (k).

#### jStat.weibull.mean( scale, shape )

Returns the value of the mean of the Weibull distribution with parameters `scale` (lambda) and `shape` (k).

#### jStat.weibull.median( scale, shape )

Returns the value of the median of the Weibull distribution with parameters `scale` (lambda) and `shape` (k).

#### jStat.weibull.mode( scale, shape )

Returns the mode of the Weibull distribution with parameters `scale` (lambda) and `shape` (k).

#### jStat.weibull.sample( scale, shape )

Returns a random number whose distribution is the Weibull distribution with parameters `scale` (lambda) and `shape` (k).

#### jStat.weibull.variance( scale, shape )

Returns the variance of the Weibull distribution with parameters `scale` (lambda) and `shape` (k).

### jStat.uniform( a, b )

#### jStat.uniform.pdf( x, a, b )

Returns the value of `x` in the pdf of the Uniform distribution from `a` to `b`.

#### jStat.uniform.cdf( x, a, b )

Returns the value of `x` in the cdf of the Uniform distribution from `a` to `b`.

#### jStat.uniform.inv( p, a, b)

Returns the inverse of the `uniform.cdf` function; i.e. the value of `x` for which `uniform.cdf(x, a, b) == p`.

#### jStat.uniform.mean( a, b )

Returns the value of the mean of the Uniform distribution from `a` to `b`.

#### jStat.uniform.median( a, b )

Returns the value of the median of the Uniform distribution from `a` to `b`.

#### jStat.uniform.mode( a, b )

Returns the value of the mode of the Uniform distribution from `a` to `b`.

#### jStat.uniform.sample( a, b )

Returns a random number whose distribution is the Uniform distribution from `a` to `b`.

#### jStat.uniform.variance( a, b )

Returns the variance of the Uniform distribution from `a` to `b`.

### jStat.binomial

#### jStat.binomial.pdf( k, n, p )

Returns the value of `k` in the pdf of the Binomial distribution with parameters `n` and `p`.

#### jStat.binomial.cdf( k, n, p )

Returns the value of `k` in the cdf of the Binomial distribution with parameters `n` and `p`.

### jStat.negbin

#### jStat.negbin.pdf( k, r, p )

Returns the value of `k` in the pdf of the Negative Binomial distribution with parameters `n` and `p`.

#### jStat.negbin.cdf( x, r, p )

Returns the value of `x` in the cdf of the Negative Binomial distribution with parameters `n` and `p`.

### jStat.hypgeom

#### jStat.hypgeom.pdf( k, N, m, n )

Returns the value of `k` in the pdf of the Hypergeometric distribution with parameters `N` (the population size), `m` (the success rate), and `n` (the number of draws).

#### jStat.hypgeom.cdf( x, N, m, n )

Returns the value of `x` in the cdf of the Hypergeometric distribution with parameters `N` (the population size), `m` (the success rate), and `n` (the number of draws).

### jStat.poisson

#### jStat.poisson.pdf( k, l )

Returns the value of `k` in the pdf of the Poisson distribution with parameter `l` (lambda).

#### jStat.poisson.cdf( x, l )

Returns the value of `x` in the cdf of the Poisson distribution with parameter `l` (lambda).

#### jStat.poisson.sample( l )

Returns a random number whose distribution is the Poisson distribution with rate parameter l (lamda)

### jStat.triangular

#### jStat.triangular.pdf( x, a, b, c )

Returns the value of `x` in the pdf of the Triangular distribution with the parameters `a`, `b`, and `c`.

#### jStat.triangular.cdf( x, a, b, c )

Returns the value of `x` in the cdf of the Triangular distribution with the parameters `a`, `b`, and `c`.

#### jStat.triangular.mean( a, b, c )

Returns the value of the mean of the Triangular distribution with the parameters `a`, `b`, and `c`.

#### jStat.triangular.median( a, b, c )

Returns the value of the median of the Triangular distribution with the parameters `a`, `b`, and `c`.

#### jStat.triangular.mode( a, b, c )

Returns the value of the mode of the Triangular distribution with the parameters `a`, `b`, and `c`.

#### jStat.triangular.sample( a, b, c )

Returns a random number whose distribution is the Triangular distribution with the parameters `a`, `b`, and `c`.

#### jStat.triangular.variance( a, b, c )

Returns the value of the variance of the Triangular distribution with the parameters `a`, `b`, and `c`.

### jStat.arcsine( a, b )

#### jStat.arcsine.pdf( x, a, b )

Returns the value of `x` in the pdf of the arcsine distribution from `a` to `b`.

#### jStat.arcsine.cdf( x, a, b )

Returns the value of `x` in the cdf of the arcsine distribution from `a` to `b`.

#### jStat.arcsine.inv(p, a, b)

Returns the inverse of the `arcsine.cdf` function; i.e. the value of `x` for which `arcsine.cdf(x, a, b) == p`.

#### jStat.arcsine.mean( a, b )

Returns the value of the mean of the arcsine distribution from `a` to `b`.

#### jStat.arcsine.median( a, b )

Returns the value of the median of the arcsine distribution from `a` to `b`.

#### jStat.arcsine.mode( a, b )

Returns the value of the mode of the arcsine distribution from `a` to `b`.

#### jStat.arcsine.sample( a, b )

Returns a random number whose distribution is the arcsine distribution from `a` to `b`.

#### jStat.arcsine.variance( a, b )

Returns the variance of the Uniform distribution from `a` to `b`.

## Special Functions

### betafn( x, y )

Evaluates the Beta function at `(x,y)`.

### betaln( x, y )

Evaluates the log Beta function at `(x,y)`.

### betacf( x, a, b )

Returns the continued fraction for the incomplete Beta function with parameters a and b modified by Lentz's method evaluated at `x`.

### ibetainv( p, a, b)

Returns the inverse of the incomplete Beta function evaluated at `(p,a,b)`.

### ibeta( x, a, b)

Returns the incomplete Beta function evaluated at `(x,a,b)`.

### gammafn( x )

Returns the Gamma function evaluated at `x`. This is sometimes called the 'complete' gamma function.

This function is tested against Mathematica's Gamma[x].

### gammaln( x )

Returns the Log-Gamma function evaluated at `x`.

### gammap( a, x )

Returns the lower incomplete gamma function evaluated at `(a,x)`. This function is usually written with a lower case greek gamma character, and is one of the two incomplete gamma functions.

This function is tested against Mathematica's Gamma[a, 0, x]. It is additionally tested against gammainc(a,x)'s 'lowinc' output from teh 'pracma' library for R.

### lowRegGamma(a, x)

Returns the lower regularized incomplete gamma function evaluated at `(a,x)`. It is defined as the quotient of the lower incomplete gamma function evaluated at (a, x) and the upper incomplete gamma function ('the gamma function') evaluated at (a). This function is usually written as P(x, a); and is one of the two regularized gamma functions.

This function is tested against gammainc(x, a)'s 'reginc' output from the 'pracma' library for R. Note that R and jStat switch the order of operators for this function.

### gammapinv( p, a )

Returns the inverse of the lower regularized incomplete Gamma function evaluated at `(p,a)`. This function is the inverse of lowerRegularizedGamma(x, a).

### factorialln( n )

Returns the natural log factorial of `n`.

### factorial( n )

Returns the factorial of `n`.

### combination( n, m )

Returns the number of combinations of `n`, `m`.

### permutation( n, m )

Returns the number of permutations of `n`, `m`.

### erf( x )

Returns the error function evaluated at `x`.

### erfc( x )

Returns the complementary error function evaluated at `x`.

### erfcinv( p )

Returns the inverse of the complementary error function evaluated at `p`.

### randn( n, m )

Returns a normal deviate (mean 0 and standard deviation 1).

### randg( shape, n, m )

Returns a Gamma deviate by the method of Marsaglia and Tsang.

## Instance Functionality

``jStat([[1,2,3]]).add( 2 ) === [[3,4,5]];``

### subtract( arg )

Subtracts all entries by value.

``jStat([[4,5,6]]).subtract( 2 ) === [[2,3,4]];``

### divide( arg )

Divides all entries by value.

``jStat([[2,4,6]]).divide( 2 ) === [[1,2,3]];``

### multiply( arg )

Multiplies all entries by value.

``jStat([[1,2,3]]).multiply( 2 ) === [[2,4,6]];``

### dot( arg )

Takes dot product.

### pow( arg )

Raises all entries by value.

``jStat([[1,2,3]]).pow( 2 ) === [[1,4,9]];``

### exp()

Exponentiates all entries.

``jStat([[0,1]]).exp() === [[1, 2.718281828459045]]``

### log()

Returns the natural logarithm of all entries.

``jStat([[1, 2.718281828459045]]).log() === [[0,1]];``

### abs()

Returns the absolute values of all entries.

``jStat([[1,-2,-3]]).abs() === [[1,2,3]];``

### norm()

Computes the norm of a vector. Note that if a matrix is passed, then the first row of the matrix will be used as a vector for `norm()`.

### angle( arg )

Computes the angle between two vectors. Note that if a matrix is passed, then the first row of the matrix will be used as the vector for `angle()`.

## Static Functionality

Adds `arg` to all entries of `arr` array.

### subtract( arr, arg )

Subtracts all entries of the `arr` array by `arg`.

### divide( arr, arg )

Divides all entries of the `arr` array by `arg`.

### multiply( arr, arg )

Multiplies all entries of the `arr` array by `arg`.

### dot( arr1, arr2 )

Takes the dot product of the `arr1` and `arr2` arrays.

### outer( A, B )

Takes the outer product of the `A` and `B` arrays.

``outer([1,2,3],[4,5,6]) === [[4,5,6],[8,10,12],[12,15,18]]``

### pow( arr, arg )

Raises all entries of the `arr` array to the power of `arg`.

### exp( arr )

Exponentiates all entries in the `arr` array.

### log( arr )

Returns the natural logarithm of all entries in the `arr` array

### abs( arr )

Returns the absolute values of all entries in the `arr` array

### norm( arr )

Computes the norm of the `arr` vector.

### angle( arr1, arr2 )

Computes the angle between the `arr1` and `arr2` vectors.

### aug( A, B )

Augments matrix `A` by matrix `B`. Note that this method returns a plain matrix, not a jStat object.

### det( A )

Calculates the determinant of matrix `A`.

### inv( A )

Returns the inverse of the matrix `A`.

### gauss_elimination( A, B )

Performs Gaussian Elimination on matrix `A` augmented by matrix `B`.

### gauss_jordan( A, B )

Performs Gauss-Jordan Elimination on matrix `A` augmented by matrix `B`.

### lu( A )

Perform the LU decomposition on matrix `A`.

`A` -> `[L,U]`

st.

`A = LU`

`L` is lower triangular matrix.

`U` is upper triangular matrix.

### cholesky( A )

Performs the Cholesky decomposition on matrix `A`.

`A` -> `T`

st.

`A = TT'`

`T` is lower triangular matrix.

### gauss_jacobi( A, b, x, r )

Solves the linear system `Ax = b` using the Gauss-Jacobi method with an initial guess of `r`.

### gauss_seidel( A, b, x, r )

Solves the linear system `Ax = b` using the Gauss-Seidel method with an initial guess of `r`.

### SOR( A, b, x, r, w )

Solves the linear system `Ax = b` using the sucessive over-relaxation method with an initial guess of `r` and parameter `w` (omega).

### householder( A )

Performs the householder transformation on the matrix `A`.

### QR( A )

Performs the Cholesky decomposition on matrix `A`.

`A` -> `[Q,R]`

`Q` is the orthogonal matrix.

`R` is the upper triangular.

### lstsq( A, b )

Solves least squard problem for Ax=b as QR decomposition way.

If `b` is of the `[[b1], [b2], [b3]]` form, the method will return an array of the `[[x1], [x2], [x3]]` form solution.

Otherwise, if `b` is of the `[b1, b2, b3]` form, the method will return an array of the `[x1,x2,x3]` form solution.

## Statistical Tests

The test module includes methods that enact popular statistical tests. The tests that are implemented are Z tests, T tests, and F tests. Also included are methods for developing confidence intervals. Currently regression is not included but it should be included soon (once matrix inversion is fixed).

## Statistics Instance Functionality

### zscore( value[, flag] )

Returns the z-score of `value` taking the jStat object as the observed values. `flag===true` denotes use of sample standard deviation.

### ztest( value, sides[, flag] )

Returns the p-value of `value` taking the jStat object as the observed values. `sides` is an integer value 1 or 2 denoting a 1 or 2 sided z-test. The test defaults to a 2 sided z-test if `sides` is not specified. `flag===true` denotes use of sample standard deviation.

### tscore( value )

Returns the t-score of `value` taking the jStat object as the observed values.

### ttest( value, sides )

Returns the p-value of `value` taking the jStat object as the observed values. `sides` is an integer value 1 or 2 denoting a 1 or 2 sided t-test. The test defaults to a 2 sided t-test if `sides` is not specified.

### anovafscore()

Returns the f-score of the ANOVA test on the arrays of the jStat object.

### anovaftest()

Returns the p-value of an ANOVA test on the arrays of the jStat object.

## Z Statistics

### jStat.zscore( value, mean, sd )

Returns the z-score of `value` given the `mean` mean and the `sd` standard deviation of the test.

### jStat.zscore( value, array[, flag] )

Returns the z-score of `value` given the data from `array`. `flag===true` denotes use of the sample standard deviation.

### jStat.ztest( value, mean, sd, sides )

Returns the p-value of a the z-test of `value` given the `mean` mean and `sd` standard deviation of the test. `sides` is an integer value 1 or 2 denoting a one or two sided z-test. If `sides` is not specified the test defaults to a two sided z-test.

### jStat.ztest( zscore, sides )

Returns the p-value of the `zscore` z-score. `sides` is an integer value 1 or 2 denoting a one or two sided z-test. If `sides` is not specified the test defaults to a two sided z-test

### jStat.ztest( value, array, sides[, flag] )

Returns the p-value of `value` given the data from `array`. `sides` is an integer value 1 or 2 denoting a one or two sided z-test. If `sides` is not specified the test defaults to a two sided z-test. `flag===true` denotes the use of the sample standard deviation.

## T Statistics

### jStat.tscore( value, mean, sd, n )

Returns the t-score of `value` given the `mean` mean, `sd` standard deviation, and the sample size `n`.

### jStat.tscore( value, array )

Returns the t-score of `value` given the data from `array`.

### jStat.ttest( value, mean, sd, n, sides )

Returns the p-value of `value` given the `mean` mean, `sd` standard deviation, and the sample size `n`. `sides` is an integer value 1 or 2 denoting a one or two sided t-test. If `sides` is not specified the test defaults to a two sided t-test.

### jStat.ttest( tscore, n, sides )

Returns the p-value of the `tscore` t-score given the sample size `n`. `sides` is an integer value 1 or 2 denoting a one or two sided t-test. If `sides` is not specified the test defaults to a two sided t-test.

### jStat.ttest( value, array, sides )

Returns the p-value of `value` given the data in `array`. `sides` is an integer value 1 or 2 denoting a one or two sided t-test. If `sides` is not specified the test defaults to a two sided t-test.

## F Statistics

### jStat.anovafscore( array1, array2, ..., arrayn )

Returns the f-score of an ANOVA on the arrays.

### jStat.anovafscore( [array1,array2, ...,arrayn] )

Returns the f-score of an ANOVA on the arrays.

### jStat.anovaftest( array1, array2, ...., arrayn )

Returns the p-value of the f-statistic from the ANOVA test on the arrays.

### jStat.ftest( fscore, df1, df2)

Returns the p-value for the `fscore` f-score with a `df1` numerator degrees of freedom and a `df2` denominator degrees of freedom.

## Tukey's Range Test

### jStat.qscore( mean1, mean2, n1, n2, sd )

Returns the q-score of a single pairwise comparison between arrays of mean `mean1` and `mean2`, size `n1` and `n2`, and standard deviation (of all vectors) `sd`.

### jStat.qscore( array1, array2, sd )

Same as above, but the means and sizes are calculated automatically from the arrays.

### jStat.qtest( qscore, n, k )

Returns the p-value of the q-score given the total sample size `n` and `k` number of populations.

### jStat.qtest( mean1, mean2, n1, n2, sd, n, k )

Returns the p-value of a single pairwise comparison between arrays of mean `mean1` and `mean2`, size `n1` and `n2`, and standard deviation (of all vectors) `sd`, where the total sample size is `n` and the number of populations is `k`.

### jStat.qtest( array1, array2, sd, n, k )

Same as above, but the means and sizes are calculated automatically from the arrays.

### jStat.tukeyhsd( arrays )

Performs the full Tukey's range test returning p-values for every pairwise combination of the arrays in the format of `[[[index1, index2], pvalue], ...]`

For example:

``````> jStat.tukeyhsd([[1, 2], [3, 4, 5], , [7, 8]])
[ [ [ 0, 1 ], 0.10745283896120883 ],
[ [ 0, 2 ], 0.04374051946838586 ],
[ [ 0, 3 ], 0.007850804224287633 ],
[ [ 1, 2 ], 0.32191548545694226 ],
[ [ 1, 3 ], 0.03802747415485819 ],
[ [ 2, 3 ], 0.5528665999257486 ] ]``````

## Confidence Intervals

### jStat.normalci( value, alpha, sd, n )

Returns a 1-alpha confidence interval for `value` given a normal distribution with a standard deviation `sd` and a sample size `n`

### jStat.normalci( value, alpha, array )

Returns a 1-alpha confidence interval for `value` given a normal distribution in the data from `array`.

### jStat.tci( value, alpha, sd, n )

Returns a 1-alpha confidence interval for `value` given the standard deviation `sd` and the sample size `n`.

### jStat.tci( value, alpha, array )

Returns a 1-alpha confidence interval for `value` given the data from `array`.

### jStat.fn.oneSidedDifferenceOfProportions( p1, n1, p2, n2 )

Returns the p-value for a 1-sided test for the difference between two proportions. `p1` is the sample proportion for the first sample, whereas `p2` is the sample proportion for the second sample. Similiarly, `n1` is the sample size of the first sample and `n2` is the sample size for the second sample.

### jStat.fn.twoSidedDifferenceOfProportions( p1, n1, p2, n2 )

Returns the p-value for a 2-sided test for the difference between two proportions. `p1` is the sample proportion for the first sample, whereas `p2` is the sample proportion for the second sample. Similiarly, `n1` is the sample size of the first sample and `n2` is the sample size for the second sample.