Next: Statistical Plots, Previous: Descriptive Statistics, Up: Statistics [Contents][Index]

Octave supports various helpful statistical functions. Many are useful as initial steps to prepare a data set for further analysis. Others provide different measures from those of the basic descriptive statistics.

- :
**center***(*`x`) - :
**center***(*`x`,`dim`) Center data by subtracting its mean.

If

`x`is a vector, subtract its mean.If

`x`is a matrix, do the above for each column.If the optional argument

`dim`is given, operate along this dimension.Programming Note:

`center`

has obvious application for normalizing statistical data. It is also useful for improving the precision of general numerical calculations. Whenever there is a large value that is common to a batch of data, the mean can be subtracted off, the calculation performed, and then the mean added back to obtain the final answer.**See also:**zscore.

- :
`z`=**zscore***(*`x`) - :
`z`=**zscore***(*`x`,`opt`) - :
`z`=**zscore***(*`x`,`opt`,`dim`) - :
*[*`z`,`mu`,`sigma`] =**zscore***(…)* Compute the Z score of

`x`If

`x`is a vector, subtract its mean and divide by its standard deviation. If the standard deviation is zero, divide by 1 instead.The optional parameter

`opt`determines the normalization to use when computing the standard deviation and has the same definition as the corresponding parameter for`std`

.If

`x`is a matrix, calculate along the first non-singleton dimension. If the third optional argument`dim`is given, operate along this dimension.The optional outputs

`mu`and`sigma`contain the mean and standard deviation.

- :
`n`=**histc***(*`x`,`edges`) - :
`n`=**histc***(*`x`,`edges`,`dim`) - :
*[*`n`,`idx`] =**histc***(…)* Compute histogram counts.

When

`x`is a vector, the function counts the number of elements of`x`that fall in the histogram bins defined by`edges`. This must be a vector of monotonically increasing values that define the edges of the histogram bins.

contains the number of elements in`n`(k)`x`for which

. The final element of`edges`(k) <=`x`<`edges`(k+1)`n`contains the number of elements of`x`exactly equal to the last element of`edges`.When

`x`is an*N*-dimensional array, the computation is carried out along dimension`dim`. If not specified`dim`defaults to the first non-singleton dimension.When a second output argument is requested an index matrix is also returned. The

`idx`matrix has the same size as`x`. Each element of`idx`contains the index of the histogram bin in which the corresponding element of`x`was counted.**See also:**hist.

`unique`

function documented at unique is often
useful for statistics.

- :
`c`=**nchoosek***(*`n`,`k`) - :
`c`=**nchoosek***(*`set`,`k`) -
Compute the binomial coefficient of

`n`or list all possible combinations of a`set`of items.If

`n`is a scalar then calculate the binomial coefficient of`n`and`k`which is defined as/ \ | n | n (n-1) (n-2) … (n-k+1) n! | | = ------------------------- = --------- | k | k! k! (n-k)! \ /

This is the number of combinations of

`n`items taken in groups of size`k`.If the first argument is a vector,

`set`, then generate all combinations of the elements of`set`, taken`k`at a time, with one row per combination. The result`c`has`k`columns and`nchoosek (length (`

rows.`set`),`k`)For example:

How many ways can three items be grouped into pairs?

nchoosek (3, 2) ⇒ 3

What are the possible pairs?

nchoosek (1:3, 2) ⇒ 1 2 1 3 2 3

Programming Note: When calculating the binomial coefficient

`nchoosek`

works only for non-negative, integer arguments. Use`bincoeff`

for non-integer and negative scalar arguments, or for computing many binomial coefficients at once with vector inputs for`n`or`k`.

- :
**perms***(*`v`) Generate all permutations of

`v`with one row per permutation.The result has size

`factorial (`

, where`n`) *`n``n`is the length of`v`.Example

perms ([1, 2, 3]) ⇒ 1 2 3 2 1 3 1 3 2 2 3 1 3 1 2 3 2 1

Programming Note: The maximum length of

`v`should be less than or equal to 10 to limit memory consumption.

- :
**ranks***(*`x`,`dim`) Return the ranks of

`x`along the first non-singleton dimension adjusted for ties.If the optional argument

`dim`is given, operate along this dimension.

- :
**run_count***(*`x`,`n`) - :
**run_count***(*`x`,`n`,`dim`) Count the upward runs along the first non-singleton dimension of

`x`of length 1, 2, …,`n`-1 and greater than or equal to`n`.If the optional argument

`dim`is given then operate along this dimension.**See also:**runlength.

- :
*count =***runlength***(*`x`) - :
*[count, value] =***runlength***(*`x`) Find the lengths of all sequences of common values.

`count`is a vector with the lengths of each repeated value.The optional output

`value`contains the value that was repeated in the sequence.runlength ([2, 2, 0, 4, 4, 4, 0, 1, 1, 1, 1]) ⇒ [2, 1, 3, 1, 4]

**See also:**run_count.

- :
**probit***(*`p`) Return the probit (the quantile of the standard normal distribution) for each element of

`p`.**See also:**logit.

- :
**logit***(*`p`) Compute the logit for each value of

`p`The logit is defined as

logit (

`p`) = log (`p`/ (1-`p`))**See also:**probit, logistic_cdf.

- :
**cloglog***(*`x`) Return the complementary log-log function of

`x`.The complementary log-log function is defined as

cloglog (x) = - log (- log (

`x`))

- :
*[*`t`,`l_x`] =**table***(*`x`) - :
*[*`t`,`l_x`,`l_y`] =**table***(*`x`,`y`) Create a contingency table

`t`from data vectors.The

`l_x`and`l_y`vectors are the corresponding levels.Currently, only 1- and 2-dimensional tables are supported.

Next: Statistical Plots, Previous: Descriptive Statistics, Up: Statistics [Contents][Index]