BigBrotherBot v1.8.0
System Development Information for the BigBrotherBot project.

b3::lib::statlib::stats Namespace Reference

Classes

class  Dispatch
 DISPATCH CODE ##############. More...

Functions

def lgeometricmean
def lharmonicmean
def lmean
def lmedian
def lmedianscore
def lmode
def lmoment
 MOMENTS #############.
def lvariation
def lskew
def lkurtosis
def ldescribe
def litemfreq
 FREQUENCY STATS ##########.
def lscoreatpercentile
def lpercentileofscore
def lhistogram
def lcumfreq
def lrelfreq
def lobrientransform
 VARIABILITY FUNCTIONS ######.
def lsamplevar
def lsamplestdev
def lcov
def lvar
def lstdev
def lsterr
def lsem
def lz
def lzs
def ltrimboth
 TRIMMING FUNCTIONS #######.
def ltrim1
def lpaired
 CORRELATION FUNCTIONS ######.
def lpearsonr
def llincc
def lspearmanr
def lpointbiserialr
def lkendalltau
def llinregress
def lttest_1samp
 INFERENTIAL STATISTICS #####.
def lttest_ind
def lttest_rel
def lchisquare
def lks_2samp
def lmannwhitneyu
def ltiecorrect
def lranksums
def lwilcoxont
def lkruskalwallish
def lfriedmanchisquare
def lchisqprob
 PROBABILITY CALCULATIONS ####.
def lerfcc
def lzprob
def lksprob
def lfprob
def lbetacf
def lgammln
def lbetai
def lF_oneway
 ANOVA CALCULATIONS #######.
def lF_value
def writecc
 SUPPORT FUNCTIONS #######.
def lincr
def lsum
def lcumsum
def lss
def lsummult
def lsumdiffsquared
def lsquare_of_sums
def lshellsort
def lrankdata
def outputpairedstats
def lfindwithin
def ageometricmean
 ACENTRAL TENDENCY ########.
def aharmonicmean
def amean
def amedian
def amedianscore
def amode
def atmean
def atvar
def atmin
def atmax
def atstdev
def atsem
def amoment
 AMOMENTS #############.
def avariation
def askew
def akurtosis
def adescribe
def askewtest
 NORMALITY TESTS ##########.
def akurtosistest
def anormaltest
def aitemfreq
 AFREQUENCY FUNCTIONS #######.
def ascoreatpercentile
def apercentileofscore
def ahistogram
def acumfreq
def arelfreq
def aobrientransform
 AVARIABILITY FUNCTIONS #####.
def asamplevar
def asamplestdev
def asignaltonoise
def acov
def avar
def astdev
def asterr
def asem
def az
def azs
def azmap
def athreshold
 ATRIMMING FUNCTIONS #######.
def atrimboth
def atrim1
def acovariance
 ACORRELATION FUNCTIONS ######.
def acorrelation
def apaired
def dices
def icc
def alincc
def apearsonr
def aspearmanr
def apointbiserialr
def akendalltau
def alinregress
def amasslinregress
def attest_1samp
 AINFERENTIAL STATISTICS #####.
def attest_ind
def ap2t
def attest_rel
def achisquare
def aks_2samp
def amannwhitneyu
def atiecorrect
def aranksums
def awilcoxont
def akruskalwallish
def afriedmanchisquare
def achisqprob
 APROBABILITY CALCULATIONS ####.
def aerfcc
def azprob
def aksprob
def afprob
def abetacf
def agammln
def abetai
def aglm
 AANOVA CALCULATIONS #######.
def aF_oneway
def aF_value
def outputfstats
def F_value_multivariate
def asign
 ASUPPORT FUNCTIONS ########.
def asum
def acumsum
def ass
def asummult
def asquare_of_sums
def asumdiffsquared
def ashellsort
def arankdata
def afindwithin

Variables

float __version__ = 0.6
tuple geometricmean = Dispatch( (lgeometricmean, (ListType, TupleType)), )
 DISPATCH LISTS AND TUPLES TO ABOVE FCNS #########.
tuple harmonicmean = Dispatch( (lharmonicmean, (ListType, TupleType)), )
tuple mean = Dispatch( (lmean, (ListType, TupleType)), )
tuple median = Dispatch( (lmedian, (ListType, TupleType)), )
tuple medianscore = Dispatch( (lmedianscore, (ListType, TupleType)), )
tuple mode = Dispatch( (lmode, (ListType, TupleType)), )
tuple moment = Dispatch( (lmoment, (ListType, TupleType)), )
 MOMENTS:
tuple variation = Dispatch( (lvariation, (ListType, TupleType)), )
tuple skew = Dispatch( (lskew, (ListType, TupleType)), )
tuple kurtosis = Dispatch( (lkurtosis, (ListType, TupleType)), )
tuple describe = Dispatch( (ldescribe, (ListType, TupleType)), )
tuple itemfreq = Dispatch( (litemfreq, (ListType, TupleType)), )
 FREQUENCY STATISTICS:
tuple scoreatpercentile = Dispatch( (lscoreatpercentile, (ListType, TupleType)), )
tuple percentileofscore = Dispatch( (lpercentileofscore, (ListType, TupleType)), )
tuple histogram = Dispatch( (lhistogram, (ListType, TupleType)), )
tuple cumfreq = Dispatch( (lcumfreq, (ListType, TupleType)), )
tuple relfreq = Dispatch( (lrelfreq, (ListType, TupleType)), )
tuple obrientransform = Dispatch( (lobrientransform, (ListType, TupleType)), )
 VARIABILITY:
tuple samplevar = Dispatch( (lsamplevar, (ListType, TupleType)), )
tuple samplestdev = Dispatch( (lsamplestdev, (ListType, TupleType)), )
tuple var = Dispatch( (lvar, (ListType, TupleType)), )
tuple stdev = Dispatch( (lstdev, (ListType, TupleType)), )
tuple sterr = Dispatch( (lsterr, (ListType, TupleType)), )
tuple sem = Dispatch( (lsem, (ListType, TupleType)), )
tuple z = Dispatch( (lz, (ListType, TupleType)), )
tuple zs = Dispatch( (lzs, (ListType, TupleType)), )
tuple trimboth = Dispatch( (ltrimboth, (ListType, TupleType)), )
 TRIMMING FCNS:
tuple trim1 = Dispatch( (ltrim1, (ListType, TupleType)), )
tuple paired = Dispatch( (lpaired, (ListType, TupleType)), )
 CORRELATION FCNS:
tuple pearsonr = Dispatch( (lpearsonr, (ListType, TupleType)), )
tuple spearmanr = Dispatch( (lspearmanr, (ListType, TupleType)), )
tuple pointbiserialr = Dispatch( (lpointbiserialr, (ListType, TupleType)), )
tuple kendalltau = Dispatch( (lkendalltau, (ListType, TupleType)), )
tuple linregress = Dispatch( (llinregress, (ListType, TupleType)), )
tuple ttest_1samp = Dispatch( (lttest_1samp, (ListType, TupleType)), )
 INFERENTIAL STATS:
tuple ttest_ind = Dispatch( (lttest_ind, (ListType, TupleType)), )
tuple ttest_rel = Dispatch( (lttest_rel, (ListType, TupleType)), )
tuple chisquare = Dispatch( (lchisquare, (ListType, TupleType)), )
tuple ks_2samp = Dispatch( (lks_2samp, (ListType, TupleType)), )
tuple mannwhitneyu = Dispatch( (lmannwhitneyu, (ListType, TupleType)), )
tuple ranksums = Dispatch( (lranksums, (ListType, TupleType)), )
tuple tiecorrect = Dispatch( (ltiecorrect, (ListType, TupleType)), )
tuple wilcoxont = Dispatch( (lwilcoxont, (ListType, TupleType)), )
tuple kruskalwallish = Dispatch( (lkruskalwallish, (ListType, TupleType)), )
tuple friedmanchisquare = Dispatch( (lfriedmanchisquare, (ListType, TupleType)), )
tuple chisqprob = Dispatch( (lchisqprob, (IntType, FloatType)), )
 PROBABILITY CALCS:
tuple zprob = Dispatch( (lzprob, (IntType, FloatType)), )
tuple ksprob = Dispatch( (lksprob, (IntType, FloatType)), )
tuple fprob = Dispatch( (lfprob, (IntType, FloatType)), )
tuple betacf = Dispatch( (lbetacf, (IntType, FloatType)), )
tuple betai = Dispatch( (lbetai, (IntType, FloatType)), )
tuple erfcc = Dispatch( (lerfcc, (IntType, FloatType)), )
tuple gammln = Dispatch( (lgammln, (IntType, FloatType)), )
tuple F_oneway = Dispatch( (lF_oneway, (ListType, TupleType)), )
 ANOVA FUNCTIONS:
tuple F_value = Dispatch( (lF_value, (ListType, TupleType)), )
tuple incr = Dispatch( (lincr, (ListType, TupleType)), )
 SUPPORT FUNCTIONS:
tuple sum = Dispatch( (lsum, (ListType, TupleType)), )
tuple cumsum = Dispatch( (lcumsum, (ListType, TupleType)), )
tuple ss = Dispatch( (lss, (ListType, TupleType)), )
tuple summult = Dispatch( (lsummult, (ListType, TupleType)), )
tuple square_of_sums = Dispatch( (lsquare_of_sums, (ListType, TupleType)), )
tuple sumdiffsquared = Dispatch( (lsumdiffsquared, (ListType, TupleType)), )
tuple shellsort = Dispatch( (lshellsort, (ListType, TupleType)), )
tuple rankdata = Dispatch( (lrankdata, (ListType, TupleType)), )
tuple findwithin = Dispatch( (lfindwithin, (ListType, TupleType)), )

Detailed Description

Module stats.py
===============

A collection of basic statistical functions for python.  

B{Important:}  There are really B{3} sets of functions.  The first set has an C{l}
prefix, which can be used with list or tuple arguments.  The second set has
an C{a} prefix, which can accept U{numpy <http://numpy.scipy.org>} array arguments.  These latter
functions are defined only when C{numpy} is available on the system.  The third
type has NO prefix (i.e., has the name that appears below).  Functions of
this set are members of a L{Dispatch} class, c/o David Ascher.  This class
allows different functions to be called depending on the type of the passed
arguments.  Thus, L{stats.mean} is a member of the L{Dispatch} class and
C{stats.mean(range(20))} will call L{stats.lmean} while
C{stats.mean(numpy.arange(20))} will call L{stats.amean}.

This is a handy way to keep consistent function names when different
argument types require different functions to be called. Having
implementated the L{Dispatch} class, however, means that to get info on
a given function, you must use the REAL function name ... that is
C{print stats.lmean.__doc__} or C{print stats.amean.__doc__} work fine,
while C{print stats.mean.__doc__} will print the doc for the L{Dispatch}
class.  U{Numpy <http://numpy.scipy.org>} functions (C{a} prefix) 
generally have more argument options but 
should otherwise be consistent with the corresponding list functions.

Function List
=============

Central Tendency
----------------
- geometricmean
- harmonicmean
- mean
- median
- medianscore
- mode

Moments
-------
- moment
- variation
- skew
- kurtosis
- skewtest   (for Numpy arrays only)
- kurtosistest (for Numpy arrays only)
- normaltest (for Numpy arrays only)

Altered Versions
----------------
- tmean  (for Numpy arrays only)
- tvar   (for Numpy arrays only)
- tmin   (for Numpy arrays only)
- tmax   (for Numpy arrays only)
- tstdev (for Numpy arrays only)
- tsem   (for Numpy arrays only)
- describe

Frequency Stats
---------------
- itemfreq
- scoreatpercentile
- percentileofscore
- histogram
- cumfreq
- relfreq

Variability
-----------
- obrientransform
- samplevar
- samplestdev
- signaltonoise (for Numpy arrays only)
- var
- stdev
- sterr
- sem
- z
- zs
- zmap (for Numpy arrays only)

Trimming Fcns
-------------
- threshold (for Numpy arrays only)
- trimboth
- trim1
- round (round all vals to 'n' decimals; Numpy only)

Correlation Fcns
----------------
- covariance  (for Numpy arrays only)
- correlation (for Numpy arrays only)
- paired
- pearsonr
- spearmanr
- pointbiserialr
- kendalltau
- linregress

Inferential Stats
-----------------
- ttest_1samp
- ttest_ind
- ttest_rel
- chisquare
- ks_2samp
- mannwhitneyu
- ranksums
- wilcoxont
- kruskalwallish
- friedmanchisquare

Probability Calcs
-----------------
- chisqprob
- erfcc
- zprob
- ksprob
- fprob
- betacf
- gammln 
- betai

Anova Functions
---------------
- F_oneway
- F_value

Support Functions
-----------------
- writecc
- incr
- sign  (for Numpy arrays only)
- sum
- cumsum
- ss
- summult
- sumdiffsquared
- square_of_sums
- shellsort
- rankdata
- outputpairedstats
- findwithin

B{Disclaimer:}  The function list is obviously incomplete and, worse, the
functions are not optimized.  All functions have been tested (some more
so than others), but they are far from bulletproof.  Thus, as with any
free software, no warranty or guarantee is expressed or implied. :-)  A
few extra functions that don't appear in the list below can be found by
interested treasure-hunters.  These functions don't necessarily have
both list and array versions but were deemed useful. 

For further references see the U{python-statlib homepage 
<http://python-statlib.googlecode.com>}

@author: Gary Strangman
@copyright: (c) 1999-2007 Gary Strangman; All Rights Reserved.
@license: MIT license

Function Documentation

def b3::lib::statlib::stats::abetacf (   a,
  b,
  x,
  verbose = 1 
)
Evaluates the continued fraction form of the incomplete Beta function,
betai.  (Adapted from: Numerical Recipes in C.)  Can handle multiple
dimensions for x.

Usage:   abetacf(a,b,x,verbose=1)
def b3::lib::statlib::stats::abetai (   a,
  b,
  x,
  verbose = 1 
)
Returns the incomplete beta function:

I-sub-x(a,b) = 1/B(a,b)*(Integral(0,x) of t^(a-1)(1-t)^(b-1) dt)

where a,b>0 and B(a,b) = G(a)*G(b)/(G(a+b)) where G(a) is the gamma
function of a.  The continued fraction formulation is implemented
here, using the betacf function.  (Adapted from: Numerical Recipes in
C.)  Can handle multiple dimensions.

Usage:   abetai(a,b,x,verbose=1)
def b3::lib::statlib::stats::achisqprob (   chisq,
  df 
)

APROBABILITY CALCULATIONS ####.

Returns the (1-tail) probability value associated with the provided chi-square
value and df.  Heavily modified from chisq.c in Gary Perlman's |Stat.  Can
handle multiple dimensions.

Usage:   achisqprob(chisq,df)    chisq=chisquare stat., df=degrees of freedom
def b3::lib::statlib::stats::achisquare (   f_obs,
  f_exp = None 
)
Calculates a one-way chi square for array of observed frequencies and returns
the result.  If no expected frequencies are given, the total N is assumed to
be equally distributed across all groups (NOT RIGHT??)

Usage:   achisquare(f_obs, f_exp=None)   f_obs = array of observed cell freq.
Returns: chisquare-statistic, associated p-value
def b3::lib::statlib::stats::acorrelation (   X)
Computes the correlation matrix of a matrix X.  Requires a 2D matrix input.

Usage:   acorrelation(X)
Returns: correlation matrix of X
def b3::lib::statlib::stats::acov (   x,
  y,
  dimension = None,
  keepdims = 0 
)
Returns the estimated covariance of the values in the passed
array (i.e., N-1).  Dimension can equal None (ravel array first), an
integer (the dimension over which to operate), or a sequence (operate
over multiple dimensions).  Set keepdims=1 to return an array with the
same number of dimensions as inarray.

Usage:   acov(x,y,dimension=None,keepdims=0)
def b3::lib::statlib::stats::acovariance (   X)

ACORRELATION FUNCTIONS ######.

Computes the covariance matrix of a matrix X.  Requires a 2D matrix input.

Usage:   acovariance(X)
Returns: covariance matrix of X
def b3::lib::statlib::stats::acumfreq (   a,
  numbins = 10,
  defaultreallimits = None 
)
Returns a cumulative frequency histogram, using the histogram function.
Defaultreallimits can be None (use all data), or a 2-sequence containing
lower and upper limits on values to include.

Usage:   acumfreq(a,numbins=10,defaultreallimits=None)
Returns: array of cumfreq bin values, lowerreallimit, binsize, extrapoints
def b3::lib::statlib::stats::acumsum (   a,
  dimension = None 
)
Returns an array consisting of the cumulative sum of the items in the
passed array.  Dimension can equal None (ravel array first), an
integer (the dimension over which to operate), or a sequence (operate
over multiple dimensions, but this last one just barely makes sense).

Usage:   acumsum(a,dimension=None)
def b3::lib::statlib::stats::adescribe (   inarray,
  dimension = None 
)
   Returns several descriptive statistics of the passed array.  Dimension
   can equal None (ravel array first), an integer (the dimension over
   which to operate), or a sequence (operate over multiple dimensions).
   
   Usage:   adescribe(inarray,dimension=None)
   Returns: n, (min,max), mean, standard deviation, skew, kurtosis
   
def b3::lib::statlib::stats::aerfcc (   x)
Returns the complementary error function erfc(x) with fractional error
everywhere less than 1.2e-7.  Adapted from Numerical Recipes.  Can
handle multiple dimensions.

Usage:   aerfcc(x)
def b3::lib::statlib::stats::aF_oneway (   args)
Performs a 1-way ANOVA, returning an F-value and probability given
any number of groups.  From Heiman, pp.394-7.

Usage:   aF_oneway (*args)    where *args is 2 or more arrays, one per treatment group
Returns: f-value, probability
def b3::lib::statlib::stats::aF_value (   ER,
  EF,
  dfR,
  dfF 
)
Returns an F-statistic given the following:
ER  = error associated with the null hypothesis (the Restricted model)
EF  = error associated with the alternate hypothesis (the Full model)
dfR = degrees of freedom the Restricted model
dfF = degrees of freedom associated with the Restricted model
def b3::lib::statlib::stats::afindwithin (   data)
Returns a binary vector, 1=within-subject factor, 0=between.  Input
equals the entire data array (i.e., column 1=random factor, last
column = measured values.

Usage:   afindwithin(data)     data in |Stat format
def b3::lib::statlib::stats::afprob (   dfnum,
  dfden,
  F 
)
Returns the 1-tailed significance level (p-value) of an F statistic
given the degrees of freedom for the numerator (dfR-dfF) and the degrees
of freedom for the denominator (dfF).  Can handle multiple dims for F.

Usage:   afprob(dfnum, dfden, F)   where usually dfnum=dfbn, dfden=dfwn
def b3::lib::statlib::stats::afriedmanchisquare (   args)
Friedman Chi-Square is a non-parametric, one-way within-subjects
ANOVA.  This function calculates the Friedman Chi-square test for
repeated measures and returns the result, along with the associated
probability value.  It assumes 3 or more repeated measures.  Only 3
levels requires a minimum of 10 subjects in the study.  Four levels
requires 5 subjects per level(??).

Usage:   afriedmanchisquare(*args)   args are separate arrays for 2+ conditions
Returns: chi-square statistic, associated p-value
def b3::lib::statlib::stats::agammln (   xx)
Returns the gamma function of xx.
Gamma(z) = Integral(0,infinity) of t^(z-1)exp(-t) dt.

Adapted from: Numerical Recipes in C.  Can handle multiple dims ... but
probably doesn't normally have to.

Usage:   agammln(xx)
def b3::lib::statlib::stats::ageometricmean (   inarray,
  dimension = None,
  keepdims = 0 
)

ACENTRAL TENDENCY ########.

Calculates the geometric mean of the values in the passed array.
That is:  n-th root of (x1 * x2 * ... * xn).  Defaults to ALL values in
the passed array.  Use dimension=None to flatten array first.  REMEMBER: if
dimension=0, it collapses over dimension 0 ('rows' in a 2D array) only, and
if dimension is a sequence, it collapses over all specified dimensions.  If
keepdims is set to 1, the resulting array will have as many dimensions as
inarray, with only 1 'level' per dim that was collapsed over.

Usage:   ageometricmean(inarray,dimension=None,keepdims=0)
Returns: geometric mean computed over dim(s) listed in dimension
def b3::lib::statlib::stats::aglm (   data,
  para 
)

AANOVA CALCULATIONS #######.

Calculates a linear model fit ... anova/ancova/lin-regress/t-test/etc. Taken
from:

Peterson et al. Statistical limitations in functional neuroimaging
I. Non-inferential methods and statistical models.  Phil Trans Royal Soc
Lond B 354: 1239-1260.

Usage:   aglm(data,para)
Returns: statistic, p-value ???
def b3::lib::statlib::stats::aharmonicmean (   inarray,
  dimension = None,
  keepdims = 0 
)
Calculates the harmonic mean of the values in the passed array.
That is:  n / (1/x1 + 1/x2 + ... + 1/xn).  Defaults to ALL values in
the passed array.  Use dimension=None to flatten array first.  REMEMBER: if
dimension=0, it collapses over dimension 0 ('rows' in a 2D array) only, and
if dimension is a sequence, it collapses over all specified dimensions.  If
keepdims is set to 1, the resulting array will have as many dimensions as
inarray, with only 1 'level' per dim that was collapsed over.

Usage:   aharmonicmean(inarray,dimension=None,keepdims=0)
Returns: harmonic mean computed over dim(s) in dimension
def b3::lib::statlib::stats::ahistogram (   inarray,
  numbins = 10,
  defaultlimits = None,
  printextras = 1 
)
Returns (i) an array of histogram bin counts, (ii) the smallest value
of the histogram binning, and (iii) the bin width (the last 2 are not
necessarily integers).  Default number of bins is 10.  Defaultlimits
can be None (the routine picks bins spanning all the numbers in the
inarray) or a 2-sequence (lowerlimit, upperlimit).  Returns all of the
following: array of bin values, lowerreallimit, binsize, extrapoints.

Usage:   ahistogram(inarray,numbins=10,defaultlimits=None,printextras=1)
Returns: (array of bin counts, bin-minimum, min-width, #-points-outside-range)
def b3::lib::statlib::stats::aitemfreq (   a)

AFREQUENCY FUNCTIONS #######.

Returns a 2D array of item frequencies.  Column 1 contains item values,
column 2 contains their respective counts.  Assumes a 1D array is passed.
(sorting OK?)

Usage:   aitemfreq(a)
Returns: a 2D frequency table (col [0:n-1]=scores, col n=frequencies)
def b3::lib::statlib::stats::akendalltau (   x,
  y 
)
Calculates Kendall's tau ... correlation of ordinal data.  Adapted
from function kendl1 in Numerical Recipes.  Needs good test-cases.@@@

Usage:   akendalltau(x,y)
Returns: Kendall's tau, two-tailed p-value
def b3::lib::statlib::stats::akruskalwallish (   args)
The Kruskal-Wallis H-test is a non-parametric ANOVA for 3 or more
groups, requiring at least 5 subjects in each group.  This function
calculates the Kruskal-Wallis H and associated p-value for 3 or more
independent samples.

Usage:   akruskalwallish(*args)     args are separate arrays for 3+ conditions
Returns: H-statistic (corrected for ties), associated p-value
def b3::lib::statlib::stats::aks_2samp (   data1,
  data2 
)
Computes the Kolmogorov-Smirnof statistic on 2 samples.  Modified from
Numerical Recipes in C, page 493.  Returns KS D-value, prob.  Not ufunc-
like.

Usage:   aks_2samp(data1,data2)  where data1 and data2 are 1D arrays
Returns: KS D-value, p-value
def b3::lib::statlib::stats::aksprob (   alam)
   Returns the probability value for a K-S statistic computed via ks_2samp.
   Adapted from Numerical Recipes.  Can handle multiple dimensions.
   
   Usage:   aksprob(alam)
   
def b3::lib::statlib::stats::akurtosis (   a,
  dimension = None 
)
Returns the kurtosis of a distribution (normal ==> 3.0; >3 means
heavier in the tails, and usually more peaked).  Use akurtosistest()
to see if it's close enough.  Dimension can equal None (ravel array
first), an integer (the dimension over which to operate), or a
sequence (operate over multiple dimensions).

Usage:   akurtosis(a,dimension=None)
Returns: kurtosis of values in a along dimension, and ZERO where all vals equal
def b3::lib::statlib::stats::akurtosistest (   a,
  dimension = None 
)
Tests whether a dataset has normal kurtosis (i.e.,
kurtosis=3(n-1)/(n+1)) Valid only for n>20.  Dimension can equal None
(ravel array first), an integer (the dimension over which to operate),
or a sequence (operate over multiple dimensions).

Usage:   akurtosistest(a,dimension=None)
Returns: z-score and 2-tail z-probability, returns 0 for bad pixels
def b3::lib::statlib::stats::alincc (   x,
  y 
)
Calculates Lin's concordance correlation coefficient.

Usage:   alincc(x,y)    where x, y are equal-length arrays
Returns: Lin's CC
def b3::lib::statlib::stats::alinregress (   args)
Calculates a regression line on two arrays, x and y, corresponding to x,y
pairs.  If a single 2D array is passed, alinregress finds dim with 2 levels
and splits data into x,y pairs along that dim.

Usage:   alinregress(*args)    args=2 equal-length arrays, or one 2D array
Returns: slope, intercept, r, two-tailed prob, sterr-of-the-estimate, n
def b3::lib::statlib::stats::amannwhitneyu (   x,
  y 
)
Calculates a Mann-Whitney U statistic on the provided scores and
returns the result.  Use only when the n in each condition is < 20 and
you have 2 independent samples of ranks.  REMEMBER: Mann-Whitney U is
significant if the u-obtained is LESS THAN or equal to the critical
value of U.

Usage:   amannwhitneyu(x,y)     where x,y are arrays of values for 2 conditions
Returns: u-statistic, one-tailed p-value (i.e., p(z(U)))
def b3::lib::statlib::stats::amasslinregress (   args)
Calculates a regression line on one 1D array (x) and one N-D array (y).

Returns: slope, intercept, r, two-tailed prob, sterr-of-the-estimate, n
def b3::lib::statlib::stats::amean (   inarray,
  dimension = None,
  keepdims = 0 
)
Calculates the arithmatic mean of the values in the passed array.
That is:  1/n * (x1 + x2 + ... + xn).  Defaults to ALL values in the
passed array.  Use dimension=None to flatten array first.  REMEMBER: if
dimension=0, it collapses over dimension 0 ('rows' in a 2D array) only, and
if dimension is a sequence, it collapses over all specified dimensions.  If
keepdims is set to 1, the resulting array will have as many dimensions as
inarray, with only 1 'level' per dim that was collapsed over.

Usage:   amean(inarray,dimension=None,keepdims=0)
Returns: arithematic mean calculated over dim(s) in dimension
def b3::lib::statlib::stats::amedian (   inarray,
  numbins = 1000 
)
Calculates the COMPUTED median value of an array of numbers, given the
number of bins to use for the histogram (more bins approaches finding the
precise median value of the array; default number of bins = 1000).  From
G.W. Heiman's Basic Stats, or CRC Probability & Statistics.
NOTE:  THIS ROUTINE ALWAYS uses the entire passed array (flattens it first).

Usage:   amedian(inarray,numbins=1000)
Returns: median calculated over ALL values in inarray
def b3::lib::statlib::stats::amedianscore (   inarray,
  dimension = None 
)
Returns the 'middle' score of the passed array.  If there is an even
number of scores, the mean of the 2 middle scores is returned.  Can function
with 1D arrays, or on the FIRST dimension of 2D arrays (i.e., dimension can
be None, to pre-flatten the array, or else dimension must equal 0).

Usage:   amedianscore(inarray,dimension=None)
Returns: 'middle' score of the array, or the mean of the 2 middle scores
def b3::lib::statlib::stats::amode (   a,
  dimension = None 
)
Returns an array of the modal (most common) score in the passed array.
If there is more than one such score, ONLY THE FIRST is returned.
The bin-count for the modal values is also returned.  Operates on whole
array (dimension=None), or on a given dimension.

Usage:   amode(a, dimension=None)
Returns: array of bin-counts for mode(s), array of corresponding modal values
def b3::lib::statlib::stats::amoment (   a,
  moment = 1,
  dimension = None 
)

AMOMENTS #############.

Calculates the nth moment about the mean for a sample (defaults to the
1st moment).  Generally used to calculate coefficients of skewness and
kurtosis.  Dimension can equal None (ravel array first), an integer
(the dimension over which to operate), or a sequence (operate over
multiple dimensions).

Usage:   amoment(a,moment=1,dimension=None)
Returns: appropriate moment along given dimension
def b3::lib::statlib::stats::anormaltest (   a,
  dimension = None 
)
Tests whether skew and/OR kurtosis of dataset differs from normal
curve.  Can operate over multiple dimensions.  Dimension can equal
None (ravel array first), an integer (the dimension over which to
operate), or a sequence (operate over multiple dimensions).

Usage:   anormaltest(a,dimension=None)
Returns: z-score and 2-tail probability
def b3::lib::statlib::stats::aobrientransform (   args)

AVARIABILITY FUNCTIONS #####.

Computes a transform on input data (any number of columns).  Used to
test for homogeneity of variance prior to running one-way stats.  Each
array in *args is one level of a factor.  If an F_oneway() run on the
transformed data and found significant, variances are unequal.   From
Maxwell and Delaney, p.112.

Usage:   aobrientransform(*args)    *args = 1D arrays, one per level of factor
Returns: transformed data for use in an ANOVA
def b3::lib::statlib::stats::ap2t (   pval,
  df 
)
Tries to compute a t-value from a p-value (or pval array) and associated df.
SLOW for large numbers of elements(!) as it re-computes p-values 20 times
(smaller step-sizes) at which point it decides it's done. Keeps the signs
of the input array. Returns 1000 (or -1000) if t>100.

Usage:  ap2t(pval,df)
Returns: an array of t-values with the shape of pval
def b3::lib::statlib::stats::apaired (   x,
  y 
)
Interactively determines the type of data in x and y, and then runs the
appropriated statistic for paired group data.

Usage:   apaired(x,y)     x,y = the two arrays of values to be compared
Returns: appropriate statistic name, value, and probability
def b3::lib::statlib::stats::apearsonr (   x,
  y,
  verbose = 1 
)
Calculates a Pearson correlation coefficient and returns p.  Taken
from Heiman's Basic Statistics for the Behav. Sci (2nd), p.195.

Usage:   apearsonr(x,y,verbose=1)      where x,y are equal length arrays
Returns: Pearson's r, two-tailed p-value
def b3::lib::statlib::stats::apercentileofscore (   inarray,
  score,
  histbins = 10,
  defaultlimits = None 
)
Note: result of this function depends on the values used to histogram
the data(!).

Usage:   apercentileofscore(inarray,score,histbins=10,defaultlimits=None)
Returns: percentile-position of score (0-100) relative to inarray
def b3::lib::statlib::stats::apointbiserialr (   x,
  y 
)
Calculates a point-biserial correlation coefficient and the associated
probability value.  Taken from Heiman's Basic Statistics for the Behav.
Sci (1st), p.194.

Usage:   apointbiserialr(x,y)      where x,y are equal length arrays
Returns: Point-biserial r, two-tailed p-value
def b3::lib::statlib::stats::arankdata (   inarray)
Ranks the data in inarray, dealing with ties appropritely.  Assumes
a 1D inarray.  Adapted from Gary Perlman's |Stat ranksort.

Usage:   arankdata(inarray)
Returns: array of length equal to inarray, containing rank scores
def b3::lib::statlib::stats::aranksums (   x,
  y 
)
Calculates the rank sums statistic on the provided scores and returns
the result.

Usage:   aranksums(x,y)     where x,y are arrays of values for 2 conditions
Returns: z-statistic, two-tailed p-value
def b3::lib::statlib::stats::arelfreq (   a,
  numbins = 10,
  defaultreallimits = None 
)
Returns a relative frequency histogram, using the histogram function.
Defaultreallimits can be None (use all data), or a 2-sequence containing
lower and upper limits on values to include.

Usage:   arelfreq(a,numbins=10,defaultreallimits=None)
Returns: array of cumfreq bin values, lowerreallimit, binsize, extrapoints
def b3::lib::statlib::stats::asamplestdev (   inarray,
  dimension = None,
  keepdims = 0 
)
Returns the sample standard deviation of the values in the passed
array (i.e., using N).  Dimension can equal None (ravel array first),
an integer (the dimension over which to operate), or a sequence
(operate over multiple dimensions).  Set keepdims=1 to return an array
with the same number of dimensions as inarray.

Usage:   asamplestdev(inarray,dimension=None,keepdims=0)
def b3::lib::statlib::stats::asamplevar (   inarray,
  dimension = None,
  keepdims = 0 
)
Returns the sample standard deviation of the values in the passed
array (i.e., using N).  Dimension can equal None (ravel array first),
an integer (the dimension over which to operate), or a sequence
(operate over multiple dimensions).  Set keepdims=1 to return an array
with the same number of dimensions as inarray.

Usage:   asamplevar(inarray,dimension=None,keepdims=0)
def b3::lib::statlib::stats::ascoreatpercentile (   inarray,
  percent 
)
Usage:   ascoreatpercentile(inarray,percent)   0<percent<100
Returns: score at given percentile, relative to inarray distribution
def b3::lib::statlib::stats::asem (   inarray,
  dimension = None,
  keepdims = 0 
)
Returns the standard error of the mean (i.e., using N) of the values
in the passed array.  Dimension can equal None (ravel array first), an
integer (the dimension over which to operate), or a sequence (operate
over multiple dimensions).  Set keepdims=1 to return an array with the
same number of dimensions as inarray.

Usage:   asem(inarray,dimension=None, keepdims=0)
def b3::lib::statlib::stats::ashellsort (   inarray)
Shellsort algorithm.  Sorts a 1D-array.

Usage:   ashellsort(inarray)
Returns: sorted-inarray, sorting-index-vector (for original array)
def b3::lib::statlib::stats::asign (   a)

ASUPPORT FUNCTIONS ########.

Usage:   asign(a)
Returns: array shape of a, with -1 where a<0 and +1 where a>=0
def b3::lib::statlib::stats::asignaltonoise (   instack,
  dimension = 0 
)
Calculates signal-to-noise.  Dimension can equal None (ravel array
first), an integer (the dimension over which to operate), or a
sequence (operate over multiple dimensions).

Usage:   asignaltonoise(instack,dimension=0):
Returns: array containing the value of (mean/stdev) along dimension, or 0 when stdev=0
def b3::lib::statlib::stats::askew (   a,
  dimension = None 
)
Returns the skewness of a distribution (normal ==> 0.0; >0 means extra
weight in left tail).  Use askewtest() to see if it's close enough.
Dimension can equal None (ravel array first), an integer (the
dimension over which to operate), or a sequence (operate over multiple
dimensions).

Usage:   askew(a, dimension=None)
Returns: skew of vals in a along dimension, returning ZERO where all vals equal
def b3::lib::statlib::stats::askewtest (   a,
  dimension = None 
)

NORMALITY TESTS ##########.

Tests whether the skew is significantly different from a normal
distribution.  Dimension can equal None (ravel array first), an
integer (the dimension over which to operate), or a sequence (operate
over multiple dimensions).

Usage:   askewtest(a,dimension=None)
Returns: z-score and 2-tail z-probability
def b3::lib::statlib::stats::aspearmanr (   x,
  y 
)
Calculates a Spearman rank-order correlation coefficient.  Taken
from Heiman's Basic Statistics for the Behav. Sci (1st), p.192.

Usage:   aspearmanr(x,y)      where x,y are equal-length arrays
Returns: Spearman's r, two-tailed p-value
def b3::lib::statlib::stats::asquare_of_sums (   inarray,
  dimension = None,
  keepdims = 0 
)
Adds the values in the passed array, squares that sum, and returns the
result.  Dimension can equal None (ravel array first), an integer (the
dimension over which to operate), or a sequence (operate over multiple
dimensions).  If keepdims=1, the returned array will have the same
NUMBER of dimensions as the original.

Usage:   asquare_of_sums(inarray, dimension=None, keepdims=0)
Returns: the square of the sum over dim(s) in dimension
def b3::lib::statlib::stats::ass (   inarray,
  dimension = None,
  keepdims = 0 
)
Squares each value in the passed array, adds these squares & returns
the result.  Unfortunate function name. :-) Defaults to ALL values in
the array.  Dimension can equal None (ravel array first), an integer
(the dimension over which to operate), or a sequence (operate over
multiple dimensions).  Set keepdims=1 to maintain the original number
of dimensions.

Usage:   ass(inarray, dimension=None, keepdims=0)
Returns: sum-along-'dimension' for (inarray*inarray)
def b3::lib::statlib::stats::astdev (   inarray,
  dimension = None,
  keepdims = 0 
)
Returns the estimated population standard deviation of the values in
the passed array (i.e., N-1).  Dimension can equal None (ravel array
first), an integer (the dimension over which to operate), or a
sequence (operate over multiple dimensions).  Set keepdims=1 to return
an array with the same number of dimensions as inarray.

Usage:   astdev(inarray,dimension=None,keepdims=0)
def b3::lib::statlib::stats::asterr (   inarray,
  dimension = None,
  keepdims = 0 
)
Returns the estimated population standard error of the values in the
passed array (i.e., N-1).  Dimension can equal None (ravel array
first), an integer (the dimension over which to operate), or a
sequence (operate over multiple dimensions).  Set keepdims=1 to return
an array with the same number of dimensions as inarray.

Usage:   asterr(inarray,dimension=None,keepdims=0)
def b3::lib::statlib::stats::asum (   a,
  dimension = None,
  keepdims = 0 
)
   An alternative to the Numeric.add.reduce function, which allows one to
   (1) collapse over multiple dimensions at once, and/or (2) to retain
   all dimensions in the original array (squashing one down to size.
   Dimension can equal None (ravel array first), an integer (the
   dimension over which to operate), or a sequence (operate over multiple
   dimensions).  If keepdims=1, the resulting array will have as many
   dimensions as the input array.
   
   Usage:   asum(a, dimension=None, keepdims=0)
   Returns: array summed along 'dimension'(s), same _number_ of dims if keepdims=1
   
def b3::lib::statlib::stats::asumdiffsquared (   a,
  b,
  dimension = None,
  keepdims = 0 
)
Takes pairwise differences of the values in arrays a and b, squares
these differences, and returns the sum of these squares.  Dimension
can equal None (ravel array first), an integer (the dimension over
which to operate), or a sequence (operate over multiple dimensions).
keepdims=1 means the return shape = len(a.shape) = len(b.shape)

Usage:   asumdiffsquared(a,b)
Returns: sum[ravel(a-b)**2]
def b3::lib::statlib::stats::asummult (   array1,
  array2,
  dimension = None,
  keepdims = 0 
)
Multiplies elements in array1 and array2, element by element, and
returns the sum (along 'dimension') of all resulting multiplications.
Dimension can equal None (ravel array first), an integer (the
dimension over which to operate), or a sequence (operate over multiple
dimensions).  A trivial function, but included for completeness.

Usage:   asummult(array1,array2,dimension=None,keepdims=0)
def b3::lib::statlib::stats::athreshold (   a,
  threshmin = None,
  threshmax = None,
  newval = 0 
)

ATRIMMING FUNCTIONS #######.

deleted around() as it's in numpy now

Like Numeric.clip() except that values <threshmid or >threshmax are replaced
by newval instead of by threshmin/threshmax (respectively).

Usage:   athreshold(a,threshmin=None,threshmax=None,newval=0)
Returns: a, with values <threshmin or >threshmax replaced with newval
def b3::lib::statlib::stats::atiecorrect (   rankvals)
Tie-corrector for ties in Mann Whitney U and Kruskal Wallis H tests.
See Siegel, S. (1956) Nonparametric Statistics for the Behavioral
Sciences.  New York: McGraw-Hill.  Code adapted from |Stat rankind.c
code.

Usage:   atiecorrect(rankvals)
Returns: T correction factor for U or H
def b3::lib::statlib::stats::atmax (   a,
  upperlimit,
  dimension = None,
  inclusive = 1 
)
   Returns the maximum value of a, along dimension, including only values greater
   than (or equal to, if inclusive=1) upperlimit.  If the limit is set to None,
   a limit larger than the max value in the array is used.
   
   Usage:   atmax(a,upperlimit,dimension=None,inclusive=1)
   
def b3::lib::statlib::stats::atmean (   a,
  limits = None,
  inclusive = (1,1 
)
   Returns the arithmetic mean of all values in an array, ignoring values
   strictly outside the sequence passed to 'limits'.   Note: either limit
   in the sequence, or the value of limits itself, can be set to None.  The
   inclusive list/tuple determines whether the lower and upper limiting bounds
   (respectively) are open/exclusive (0) or closed/inclusive (1).
   
   Usage:   atmean(a,limits=None,inclusive=(1,1))
   
def b3::lib::statlib::stats::atmin (   a,
  lowerlimit = None,
  dimension = None,
  inclusive = 1 
)
   Returns the minimum value of a, along dimension, including only values less
   than (or equal to, if inclusive=1) lowerlimit.  If the limit is set to None,
   all values in the array are used.
   
   Usage:   atmin(a,lowerlimit=None,dimension=None,inclusive=1)
   
def b3::lib::statlib::stats::atrim1 (   a,
  proportiontocut,
  tail = 'right' 
)
Slices off the passed proportion of items from ONE end of the passed
array (i.e., if proportiontocut=0.1, slices off 'leftmost' or 'rightmost'
10% of scores).  Slices off LESS if proportion results in a non-integer
slice index (i.e., conservatively slices off proportiontocut).

Usage:   atrim1(a,proportiontocut,tail='right')  or set tail='left'
Returns: trimmed version of array a
def b3::lib::statlib::stats::atrimboth (   a,
  proportiontocut 
)
Slices off the passed proportion of items from BOTH ends of the passed
array (i.e., with proportiontocut=0.1, slices 'leftmost' 10% AND
'rightmost' 10% of scores.  You must pre-sort the array if you want
"proper" trimming.  Slices off LESS if proportion results in a
non-integer slice index (i.e., conservatively slices off
proportiontocut).

Usage:   atrimboth (a,proportiontocut)
Returns: trimmed version of array a
def b3::lib::statlib::stats::atsem (   a,
  limits = None,
  inclusive = (1,1 
)
   Returns the standard error of the mean for the values in an array,
   (i.e., using N for the denominator), ignoring values strictly outside
   the sequence passed to 'limits'.   Note: either limit in the sequence,
   or the value of limits itself, can be set to None.  The inclusive list/tuple
   determines whether the lower and upper limiting bounds (respectively) are
   open/exclusive (0) or closed/inclusive (1).
   
   Usage:   atsem(a,limits=None,inclusive=(1,1))
   
def b3::lib::statlib::stats::atstdev (   a,
  limits = None,
  inclusive = (1,1 
)
   Returns the standard deviation of all values in an array, ignoring values
   strictly outside the sequence passed to 'limits'.   Note: either limit
   in the sequence, or the value of limits itself, can be set to None.  The
   inclusive list/tuple determines whether the lower and upper limiting bounds
   (respectively) are open/exclusive (0) or closed/inclusive (1).
   
   Usage:   atstdev(a,limits=None,inclusive=(1,1))
   
def b3::lib::statlib::stats::attest_1samp (   a,
  popmean,
  printit = 0,
  name = 'Sample',
  writemode = 'a' 
)

AINFERENTIAL STATISTICS #####.

Calculates the t-obtained for the independent samples T-test on ONE group
of scores a, given a population mean.  If printit=1, results are printed
to the screen.  If printit='filename', the results are output to 'filename'
using the given writemode (default=append).  Returns t-value, and prob.

Usage:   attest_1samp(a,popmean,Name='Sample',printit=0,writemode='a')
Returns: t-value, two-tailed prob
def b3::lib::statlib::stats::attest_ind (   a,
  b,
  dimension = None,
  printit = 0,
  name1 = 'Samp1',
  name2 = 'Samp2',
  writemode = 'a' 
)
Calculates the t-obtained T-test on TWO INDEPENDENT samples of scores
a, and b.  From Numerical Recipes, p.483.  If printit=1, results are
printed to the screen.  If printit='filename', the results are output
to 'filename' using the given writemode (default=append).  Dimension
can equal None (ravel array first), or an integer (the dimension over
which to operate on a and b).

Usage:   attest_ind (a,b,dimension=None,printit=0, Name1='Samp1',Name2='Samp2',writemode='a')
Returns: t-value, two-tailed p-value
def b3::lib::statlib::stats::attest_rel (   a,
  b,
  dimension = None,
  printit = 0,
  name1 = 'Samp1',
  name2 = 'Samp2',
  writemode = 'a' 
)
Calculates the t-obtained T-test on TWO RELATED samples of scores, a
and b.  From Numerical Recipes, p.483.  If printit=1, results are
printed to the screen.  If printit='filename', the results are output
to 'filename' using the given writemode (default=append).  Dimension
can equal None (ravel array first), or an integer (the dimension over
which to operate on a and b).

Usage:   attest_rel(a,b,dimension=None,printit=0, name1='Samp1',name2='Samp2',writemode='a')
Returns: t-value, two-tailed p-value
def b3::lib::statlib::stats::atvar (   a,
  limits = None,
  inclusive = (1,1 
)
   Returns the sample variance of values in an array, (i.e., using N-1),
   ignoring values strictly outside the sequence passed to 'limits'.  
   Note: either limit in the sequence, or the value of limits itself,
   can be set to None.  The inclusive list/tuple determines whether the lower
   and upper limiting bounds (respectively) are open/exclusive (0) or
   closed/inclusive (1). ASSUMES A FLAT ARRAY (OR ELSE PREFLATTENS).
   
   Usage:   atvar(a,limits=None,inclusive=(1,1))
   
def b3::lib::statlib::stats::avar (   inarray,
  dimension = None,
  keepdims = 0 
)
Returns the estimated population variance of the values in the passed
array (i.e., N-1).  Dimension can equal None (ravel array first), an
integer (the dimension over which to operate), or a sequence (operate
over multiple dimensions).  Set keepdims=1 to return an array with the
same number of dimensions as inarray.

Usage:   avar(inarray,dimension=None,keepdims=0)
def b3::lib::statlib::stats::avariation (   a,
  dimension = None 
)
Returns the coefficient of variation, as defined in CRC Standard
Probability and Statistics, p.6. Dimension can equal None (ravel array
first), an integer (the dimension over which to operate), or a
sequence (operate over multiple dimensions).

Usage:   avariation(a,dimension=None)
def b3::lib::statlib::stats::awilcoxont (   x,
  y 
)
Calculates the Wilcoxon T-test for related samples and returns the
result.  A non-parametric T-test.

Usage:   awilcoxont(x,y)     where x,y are equal-length arrays for 2 conditions
Returns: t-statistic, two-tailed p-value
def b3::lib::statlib::stats::az (   a,
  score 
)
Returns the z-score of a given input score, given thearray from which
that score came.  Not appropriate for population calculations, nor for
arrays > 1D.

Usage:   az(a, score)
def b3::lib::statlib::stats::azmap (   scores,
  compare,
  dimension = 0 
)
Returns an array of z-scores the shape of scores (e.g., [x,y]), compared to
array passed to compare (e.g., [time,x,y]).  Assumes collapsing over dim 0
of the compare array.

Usage:   azs(scores, compare, dimension=0)
def b3::lib::statlib::stats::azprob (   z)
Returns the area under the normal curve 'to the left of' the given z value.
Thus, 
    - for z < 0, zprob(z) = 1-tail probability
    - for z > 0, 1.0-zprob(z) = 1-tail probability
    - for any z, 2.0*(1.0-zprob(abs(z))) = 2 - tail probability
Adapted from z.c in Gary Perlman's |Stat.  Can handle multiple dimensions.

Usage:   azprob(z)    where z is a z-value
def b3::lib::statlib::stats::azs (   a)
Returns a 1D array of z-scores, one for each score in the passed array,
computed relative to the passed array.

Usage:   azs(a)
def b3::lib::statlib::stats::dices (   x,
  y 
)
Calculates Dice's coefficient ... (2*number of common terms)/(number of terms in x +
number of terms in y). Returns a value between 0 (orthogonal) and 1.

Usage:  dices(x,y)
def b3::lib::statlib::stats::F_value_multivariate (   ER,
  EF,
  dfnum,
  dfden 
)
Returns an F-statistic given the following:
ER  = error associated with the null hypothesis (the Restricted model)
EF  = error associated with the alternate hypothesis (the Full model)
dfR = degrees of freedom the Restricted model
dfF = degrees of freedom associated with the Restricted model
where ER and EF are matrices from a multivariate F calculation.
def b3::lib::statlib::stats::icc (   x,
  y = None,
  verbose = 0 
)
Calculates intraclass correlation coefficients using simple, Type I sums of squares.
If only one variable is passed, assumed it's an Nx2 matrix

Usage:   icc(x,y=None,verbose=0)
Returns: icc rho, prob ####PROB IS A GUESS BASED ON PEARSON
def b3::lib::statlib::stats::lbetacf (   a,
  b,
  x 
)
This function evaluates the continued fraction form of the incomplete
Beta function, betai.  (Adapted from: Numerical Recipes in C.)

Usage:   lbetacf(a,b,x)
def b3::lib::statlib::stats::lbetai (   a,
  b,
  x 
)
Returns the incomplete beta function:

I-sub-x(a,b) = 1/B(a,b)*(Integral(0,x) of t^(a-1)(1-t)^(b-1) dt)

where a,b>0 and B(a,b) = G(a)*G(b)/(G(a+b)) where G(a) is the gamma
function of a.  The continued fraction formulation is implemented here,
using the betacf function.  (Adapted from: Numerical Recipes in C.)

Usage:   lbetai(a,b,x)
def b3::lib::statlib::stats::lchisqprob (   chisq,
  df 
)

PROBABILITY CALCULATIONS ####.

Returns the (1-tailed) probability value associated with the provided
chi-square value and df.  Adapted from chisq.c in Gary Perlman's |Stat.

Usage:   lchisqprob(chisq,df)
def b3::lib::statlib::stats::lchisquare (   f_obs,
  f_exp = None 
)
Calculates a one-way chi square for list of observed frequencies and returns
the result.  If no expected frequencies are given, the total N is assumed to
be equally distributed across all groups.

Usage:   lchisquare(f_obs, f_exp=None)   f_obs = list of observed cell freq.
Returns: chisquare-statistic, associated p-value
def b3::lib::statlib::stats::lcov (   x,
  y,
  keepdims = 0 
)
Returns the estimated covariance of the values in the passed
array (i.e., N-1).  Dimension can equal None (ravel array first), an
integer (the dimension over which to operate), or a sequence (operate
over multiple dimensions).  Set keepdims=1 to return an array with the
same number of dimensions as inarray.

Usage:   lcov(x,y,keepdims=0)
def b3::lib::statlib::stats::lcumfreq (   inlist,
  numbins = 10,
  defaultreallimits = None 
)
Returns a cumulative frequency histogram, using the histogram function.

Usage:   lcumfreq(inlist,numbins=10,defaultreallimits=None)
Returns: list of cumfreq bin values, lowerreallimit, binsize, extrapoints
def b3::lib::statlib::stats::lcumsum (   inlist)
Returns a list consisting of the cumulative sum of the items in the
passed list.

Usage:   lcumsum(inlist)
def b3::lib::statlib::stats::ldescribe (   inlist)
Returns some descriptive statistics of the passed list (assumed to be 1D).

Usage:   ldescribe(inlist)
Returns: n, mean, standard deviation, skew, kurtosis
def b3::lib::statlib::stats::lerfcc (   x)
Returns the complementary error function erfc(x) with fractional
error everywhere less than 1.2e-7.  Adapted from Numerical Recipes.

Usage:   lerfcc(x)
def b3::lib::statlib::stats::lF_oneway (   lists)

ANOVA CALCULATIONS #######.

Performs a 1-way ANOVA, returning an F-value and probability given
any number of groups.  From Heiman, pp.394-7.

Usage:   F_oneway(*lists)    where *lists is any number of lists, one per treatment group
Returns: F value, one-tailed p-value
def b3::lib::statlib::stats::lF_value (   ER,
  EF,
  dfnum,
  dfden 
)
Returns an F-statistic given the following:
ER  = error associated with the null hypothesis (the Restricted model)
EF  = error associated with the alternate hypothesis (the Full model)
dfR-dfF = degrees of freedom of the numerator
dfF = degrees of freedom associated with the denominator/Full model

Usage:   lF_value(ER,EF,dfnum,dfden)
def b3::lib::statlib::stats::lfindwithin (   data)
Returns an integer representing a binary vector, where 1=within-
subject factor, 0=between.  Input equals the entire data 2D list (i.e.,
column 0=random factor, column -1=measured values (those two are skipped).
Note: input data is in |Stat format ... a list of lists ("2D list") with 
one row per measured value, first column=subject identifier, last column=
score, one in-between column per factor (these columns contain level
designations on each factor).  See also stats.anova.__doc__.

Usage:   lfindwithin(data)     data in |Stat format
def b3::lib::statlib::stats::lfprob (   dfnum,
  dfden,
  F 
)
Returns the (1-tailed) significance level (p-value) of an F
statistic given the degrees of freedom for the numerator (dfR-dfF) and
the degrees of freedom for the denominator (dfF).

Usage:   lfprob(dfnum, dfden, F)   where usually dfnum=dfbn, dfden=dfwn
def b3::lib::statlib::stats::lfriedmanchisquare (   args)
Friedman Chi-Square is a non-parametric, one-way within-subjects
ANOVA.  This function calculates the Friedman Chi-square test for repeated
measures and returns the result, along with the associated probability
value.  It assumes 3 or more repeated measures.  Only 3 levels requires a
minimum of 10 subjects in the study.  Four levels requires 5 subjects per
level(??).

Usage:   lfriedmanchisquare(*args)
Returns: chi-square statistic, associated p-value
def b3::lib::statlib::stats::lgammln (   xx)
Returns the gamma function of xx.
Gamma(z) = Integral(0,infinity) of t^(z-1)exp(-t) dt.
(Adapted from: Numerical Recipes in C.)

Usage:   lgammln(xx)
def b3::lib::statlib::stats::lgeometricmean (   inlist)
Calculates the geometric mean of the values in the passed list.
That is:  n-th root of (x1 * x2 * ... * xn).  Assumes a '1D' list.

Usage:   lgeometricmean(inlist)
def b3::lib::statlib::stats::lharmonicmean (   inlist)
The harmonic mean is defined as:  C{n / (1/x1 + 1/x2 + ... + 1/xn)}.  
@parameter inlist: assumes a '1D' list.
@return: the harmonic mean of the values in the passed list.
def b3::lib::statlib::stats::lhistogram (   inlist,
  numbins = 10,
  defaultreallimits = None,
  printextras = 0 
)
Returns (i) a list of histogram bin counts, (ii) the smallest value
of the histogram binning, and (iii) the bin width (the last 2 are not
necessarily integers).  Default number of bins is 10.  If no sequence object
is given for defaultreallimits, the routine picks (usually non-pretty) bins
spanning all the numbers in the inlist.

Usage:   lhistogram (inlist, numbins=10, defaultreallimits=None,suppressoutput=0)
Returns: list of bin values, lowerreallimit, binsize, extrapoints
def b3::lib::statlib::stats::lincr (   l,
  cap 
)
Simulate a counting system from an n-dimensional list.

Usage:   lincr(l,cap)   l=list to increment, cap=max values for each list pos'n
Returns: next set of values for list l, OR -1 (if overflow)
def b3::lib::statlib::stats::litemfreq (   inlist)

FREQUENCY STATS ##########.

Returns a list of pairs.  Each pair consists of one of the scores in inlist
and it's frequency count.  Assumes a 1D list is passed.

Usage:   litemfreq(inlist)
Returns: a 2D frequency table (col [0:n-1]=scores, col n=frequencies)
def b3::lib::statlib::stats::lkendalltau (   x,
  y 
)
Calculates Kendall's tau ... correlation of ordinal data.  Adapted
from function kendl1 in Numerical Recipes.  Needs good test-routine.@@@

Usage:   lkendalltau(x,y)
Returns: Kendall's tau, two-tailed p-value
def b3::lib::statlib::stats::lkruskalwallish (   args)
The Kruskal-Wallis H-test is a non-parametric ANOVA for 3 or more
groups, requiring at least 5 subjects in each group.  This function
calculates the Kruskal-Wallis H-test for 3 or more independent samples
and returns the result.  

Usage:   lkruskalwallish(*args)
Returns: H-statistic (corrected for ties), associated p-value
def b3::lib::statlib::stats::lks_2samp (   data1,
  data2 
)
Computes the Kolmogorov-Smirnof statistic on 2 samples.  From
Numerical Recipes in C, page 493.

Usage:   lks_2samp(data1,data2)   data1&2 are lists of values for 2 conditions
Returns: KS D-value, associated p-value
def b3::lib::statlib::stats::lksprob (   alam)
Computes a Kolmolgorov-Smirnov t-test significance level.  Adapted from
Numerical Recipes.

Usage:   lksprob(alam)
def b3::lib::statlib::stats::lkurtosis (   inlist)
Returns the kurtosis of a distribution, as defined in Numerical
Recipies (alternate defn in CRC Standard Probability and Statistics, p.6.)

Usage:   lkurtosis(inlist)
def b3::lib::statlib::stats::llincc (   x,
  y 
)
Calculates Lin's concordance correlation coefficient.

Usage:   alincc(x,y)    where x, y are equal-length arrays
Returns: Lin's CC
def b3::lib::statlib::stats::llinregress (   x,
  y 
)
Calculates a regression line on x,y pairs.  

Usage:   llinregress(x,y)      x,y are equal-length lists of x-y coordinates
Returns: slope, intercept, r, two-tailed prob, sterr-of-estimate
def b3::lib::statlib::stats::lmannwhitneyu (   x,
  y 
)
Calculates a Mann-Whitney U statistic on the provided scores and
returns the result.  Use only when the n in each condition is < 20 and
you have 2 independent samples of ranks.  NOTE: Mann-Whitney U is
significant if the u-obtained is LESS THAN or equal to the critical
value of U found in the tables.  Equivalent to Kruskal-Wallis H with
just 2 groups.

Usage:   lmannwhitneyu(data)
Returns: u-statistic, one-tailed p-value (i.e., p(z(U)))
def b3::lib::statlib::stats::lmean (   inlist)
Returns the arithematic mean of the values in the passed list.
Assumes a '1D' list, but will function on the 1st dim of an array(!).

Usage:   lmean(inlist)
def b3::lib::statlib::stats::lmedian (   inlist,
  numbins = 1000 
)
Returns the computed median value of a list of numbers, given the
number of bins to use for the histogram (more bins brings the computed value
closer to the median score, default number of bins = 1000).  See G.W.
Heiman's Basic Stats (1st Edition), or CRC Probability & Statistics.

Usage:   lmedian (inlist, numbins=1000)
def b3::lib::statlib::stats::lmedianscore (   inlist)
Returns the 'middle' score of the passed list.  If there is an even
number of scores, the mean of the 2 middle scores is returned.

Usage:   lmedianscore(inlist)
def b3::lib::statlib::stats::lmode (   inlist)
Returns a list of the modal (most common) score(s) in the passed
list.  If there is more than one such score, all are returned.  The
bin-count for the mode(s) is also returned.

Usage:   lmode(inlist)
Returns: bin-count for mode(s), a list of modal value(s)
def b3::lib::statlib::stats::lmoment (   inlist,
  moment = 1 
)

MOMENTS #############.

Calculates the nth moment about the mean for a sample (defaults to
the 1st moment).  Used to calculate coefficients of skewness and kurtosis.

Usage:   lmoment(inlist,moment=1)
Returns: appropriate moment (r) from ... 1/n * SUM((inlist(i)-mean)**r)
def b3::lib::statlib::stats::lobrientransform (   args)

VARIABILITY FUNCTIONS ######.

Computes a transform on input data (any number of columns).  Used to
test for homogeneity of variance prior to running one-way stats.  From
Maxwell and Delaney, p.112.

Usage:   lobrientransform(*args)
Returns: transformed data for use in an ANOVA
def b3::lib::statlib::stats::lpaired (   x,
  y 
)

CORRELATION FUNCTIONS ######.

Interactively determines the type of data and then runs the
appropriated statistic for paired group data.

Usage:   lpaired(x,y)
Returns: appropriate statistic name, value, and probability
def b3::lib::statlib::stats::lpearsonr (   x,
  y 
)
Calculates a Pearson correlation coefficient and the associated
probability value.  Taken from Heiman's Basic Statistics for the Behav.
Sci (2nd), p.195.

Usage:   lpearsonr(x,y)      where x and y are equal-length lists
Returns: Pearson's r value, two-tailed p-value
def b3::lib::statlib::stats::lpercentileofscore (   inlist,
  score,
  histbins = 10,
  defaultlimits = None 
)
Returns the percentile value of a score relative to the distribution
given by inlist.  Formula depends on the values used to histogram the data(!).

Usage:   lpercentileofscore(inlist,score,histbins=10,defaultlimits=None)
def b3::lib::statlib::stats::lpointbiserialr (   x,
  y 
)
Calculates a point-biserial correlation coefficient and the associated
probability value.  Taken from Heiman's Basic Statistics for the Behav.
Sci (1st), p.194.

Usage:   lpointbiserialr(x,y)      where x,y are equal-length lists
Returns: Point-biserial r, two-tailed p-value
def b3::lib::statlib::stats::lrankdata (   inlist)
Ranks the data in inlist, dealing with ties appropritely.  Assumes
a 1D inlist.  Adapted from Gary Perlman's |Stat ranksort.

Usage:   lrankdata(inlist)
Returns: a list of length equal to inlist, containing rank scores
def b3::lib::statlib::stats::lranksums (   x,
  y 
)
Calculates the rank sums statistic on the provided scores and
returns the result.  Use only when the n in each condition is > 20 and you
have 2 independent samples of ranks.

Usage:   lranksums(x,y)
Returns: a z-statistic, two-tailed p-value
def b3::lib::statlib::stats::lrelfreq (   inlist,
  numbins = 10,
  defaultreallimits = None 
)
Returns a relative frequency histogram, using the histogram function.

Usage:   lrelfreq(inlist,numbins=10,defaultreallimits=None)
Returns: list of cumfreq bin values, lowerreallimit, binsize, extrapoints
def b3::lib::statlib::stats::lsamplestdev (   inlist)
Returns the standard deviation of the values in the passed list using
N for the denominator (i.e., DESCRIBES the sample stdev only).

Usage:   lsamplestdev(inlist)
def b3::lib::statlib::stats::lsamplevar (   inlist)
Returns the variance of the values in the passed list using
N for the denominator (i.e., DESCRIBES the sample variance only).

Usage:   lsamplevar(inlist)
def b3::lib::statlib::stats::lscoreatpercentile (   inlist,
  percent 
)
Returns the score at a given percentile relative to the distribution
given by inlist.

Usage:   lscoreatpercentile(inlist,percent)
def b3::lib::statlib::stats::lsem (   inlist)
Returns the estimated standard error of the mean (sx-bar) of the
values in the passed list.  sem = stdev / sqrt(n)

Usage:   lsem(inlist)
def b3::lib::statlib::stats::lshellsort (   inlist)
Shellsort algorithm.  Sorts a 1D-list.

Usage:   lshellsort(inlist)
Returns: sorted-inlist, sorting-index-vector (for original list)
def b3::lib::statlib::stats::lskew (   inlist)
Returns the skewness of a distribution, as defined in Numerical
Recipies (alternate defn in CRC Standard Probability and Statistics, p.6.)

Usage:   lskew(inlist)
def b3::lib::statlib::stats::lspearmanr (   x,
  y 
)
Calculates a Spearman rank-order correlation coefficient.  Taken
from Heiman's Basic Statistics for the Behav. Sci (1st), p.192.

Usage:   lspearmanr(x,y)      where x and y are equal-length lists
Returns: Spearman's r, two-tailed p-value
def b3::lib::statlib::stats::lsquare_of_sums (   inlist)
Adds the values in the passed list, squares the sum, and returns
the result.

Usage:   lsquare_of_sums(inlist)
Returns: sum(inlist[i])**2
def b3::lib::statlib::stats::lss (   inlist)
Squares each value in the passed list, adds up these squares and
returns the result.

Usage:   lss(inlist)
def b3::lib::statlib::stats::lstdev (   inlist)
Returns the standard deviation of the values in the passed list
using N-1 in the denominator (i.e., to estimate population stdev).

Usage:   lstdev(inlist)
def b3::lib::statlib::stats::lsterr (   inlist)
Returns the standard error of the values in the passed list using N-1
in the denominator (i.e., to estimate population standard error).

Usage:   lsterr(inlist)
def b3::lib::statlib::stats::lsum (   inlist)
Returns the sum of the items in the passed list.

Usage:   lsum(inlist)
def b3::lib::statlib::stats::lsumdiffsquared (   x,
  y 
)
Takes pairwise differences of the values in lists x and y, squares
these differences, and returns the sum of these squares.

Usage:   lsumdiffsquared(x,y)
Returns: sum[(x[i]-y[i])**2]
def b3::lib::statlib::stats::lsummult (   list1,
  list2 
)
Multiplies elements in list1 and list2, element by element, and
returns the sum of all resulting multiplications.  Must provide equal
length lists.

Usage:   lsummult(list1,list2)
def b3::lib::statlib::stats::ltiecorrect (   rankvals)
Corrects for ties in Mann Whitney U and Kruskal Wallis H tests.  See
Siegel, S. (1956) Nonparametric Statistics for the Behavioral Sciences.
New York: McGraw-Hill.  Code adapted from |Stat rankind.c code.

Usage:   ltiecorrect(rankvals)
Returns: T correction factor for U or H
def b3::lib::statlib::stats::ltrim1 (   l,
  proportiontocut,
  tail = 'right' 
)
Slices off the passed proportion of items from ONE end of the passed
list (i.e., if proportiontocut=0.1, slices off 'leftmost' or 'rightmost'
10% of scores).  Slices off LESS if proportion results in a non-integer
slice index (i.e., conservatively slices off proportiontocut).

Usage:   ltrim1 (l,proportiontocut,tail='right')  or set tail='left'
Returns: trimmed version of list l
def b3::lib::statlib::stats::ltrimboth (   l,
  proportiontocut 
)

TRIMMING FUNCTIONS #######.

Slices off the passed proportion of items from BOTH ends of the passed
list (i.e., with proportiontocut=0.1, slices 'leftmost' 10% AND 'rightmost'
10% of scores.  Assumes list is sorted by magnitude.  Slices off LESS if
proportion results in a non-integer slice index (i.e., conservatively
slices off proportiontocut).

Usage:   ltrimboth (l,proportiontocut)
Returns: trimmed version of list l
def b3::lib::statlib::stats::lttest_1samp (   a,
  popmean,
  printit = 0,
  name = 'Sample',
  writemode = 'a' 
)

INFERENTIAL STATISTICS #####.

Calculates the t-obtained for the independent samples T-test on ONE group
of scores a, given a population mean.  If printit=1, results are printed
to the screen.  If printit='filename', the results are output to 'filename'
using the given writemode (default=append).  Returns t-value, and prob.

Usage:   lttest_1samp(a,popmean,Name='Sample',printit=0,writemode='a')
Returns: t-value, two-tailed prob
def b3::lib::statlib::stats::lttest_ind (   a,
  b,
  printit = 0,
  name1 = 'Samp1',
  name2 = 'Samp2',
  writemode = 'a' 
)
Calculates the t-obtained T-test on TWO INDEPENDENT samples of
scores a, and b.  From Numerical Recipes, p.483.  If printit=1, results
are printed to the screen.  If printit='filename', the results are output
to 'filename' using the given writemode (default=append).  Returns t-value,
and prob.

Usage:   lttest_ind(a,b,printit=0,name1='Samp1',name2='Samp2',writemode='a')
Returns: t-value, two-tailed prob
def b3::lib::statlib::stats::lttest_rel (   a,
  b,
  printit = 0,
  name1 = 'Sample1',
  name2 = 'Sample2',
  writemode = 'a' 
)
Calculates the t-obtained T-test on TWO RELATED samples of scores,
a and b.  From Numerical Recipes, p.483.  If printit=1, results are
printed to the screen.  If printit='filename', the results are output to
'filename' using the given writemode (default=append).  Returns t-value,
and prob.

Usage:   lttest_rel(a,b,printit=0,name1='Sample1',name2='Sample2',writemode='a')
Returns: t-value, two-tailed prob
def b3::lib::statlib::stats::lvar (   inlist)
Returns the variance of the values in the passed list using N-1
for the denominator (i.e., for estimating population variance).

Usage:   lvar(inlist)
def b3::lib::statlib::stats::lvariation (   inlist)
Returns the coefficient of variation, as defined in CRC Standard
Probability and Statistics, p.6.

Usage:   lvariation(inlist)
def b3::lib::statlib::stats::lwilcoxont (   x,
  y 
)
Calculates the Wilcoxon T-test for related samples and returns the
result.  A non-parametric T-test.

Usage:   lwilcoxont(x,y)
Returns: a t-statistic, two-tail probability estimate
def b3::lib::statlib::stats::lz (   inlist,
  score 
)
Returns the z-score for a given input score, given that score and the
list from which that score came.  Not appropriate for population calculations.

Usage:   lz(inlist, score)
def b3::lib::statlib::stats::lzprob (   z)
Returns the area under the normal curve 'to the left of' the given z value.
Thus, 
    - for z<0, zprob(z) = 1-tail probability
    - for z>0, 1.0-zprob(z) = 1-tail probability
    - for any z, 2.0*(1.0-zprob(abs(z))) = 2-tail probability
Adapted from z.c in Gary Perlman's |Stat.

Usage:   lzprob(z)
def b3::lib::statlib::stats::lzs (   inlist)
Returns a list of z-scores, one for each score in the passed list.

Usage:   lzs(inlist)
def b3::lib::statlib::stats::outputfstats (   Enum,
  Eden,
  dfnum,
  dfden,
  f,
  prob 
)
def b3::lib::statlib::stats::outputpairedstats (   fname,
  writemode,
  name1,
  n1,
  m1,
  se1,
  min1,
  max1,
  name2,
  n2,
  m2,
  se2,
  min2,
  max2,
  statname,
  stat,
  prob 
)
Prints or write to a file stats for two groups, using the name, n,
mean, sterr, min and max for each group, as well as the statistic name,
its value, and the associated p-value.

Usage:   outputpairedstats(fname,writemode, name1,n1,mean1,stderr1,min1,max1, name2,n2,mean2,stderr2,min2,max2,statname,stat,prob)
Returns: None
def b3::lib::statlib::stats::writecc (   listoflists,
  file,
  writetype = 'w',
  extra = 2 
)

SUPPORT FUNCTIONS #######.

Writes a list of lists to a file in columns, customized by the max
size of items within the columns (max size of items in col, +2 characters)
to specified file.  File-overwrite is the default.

Usage:   writecc (listoflists,file,writetype='w',extra=2)
Returns: None

Variable Documentation

tuple b3::lib::statlib::stats::betacf = Dispatch( (lbetacf, (IntType, FloatType)), )
tuple b3::lib::statlib::stats::betai = Dispatch( (lbetai, (IntType, FloatType)), )
tuple b3::lib::statlib::stats::chisqprob = Dispatch( (lchisqprob, (IntType, FloatType)), )

PROBABILITY CALCS:

tuple b3::lib::statlib::stats::chisquare = Dispatch( (lchisquare, (ListType, TupleType)), )
tuple b3::lib::statlib::stats::cumfreq = Dispatch( (lcumfreq, (ListType, TupleType)), )
tuple b3::lib::statlib::stats::cumsum = Dispatch( (lcumsum, (ListType, TupleType)), )
tuple b3::lib::statlib::stats::describe = Dispatch( (ldescribe, (ListType, TupleType)), )
tuple b3::lib::statlib::stats::erfcc = Dispatch( (lerfcc, (IntType, FloatType)), )
tuple b3::lib::statlib::stats::F_oneway = Dispatch( (lF_oneway, (ListType, TupleType)), )

ANOVA FUNCTIONS:

tuple b3::lib::statlib::stats::F_value = Dispatch( (lF_value, (ListType, TupleType)), )
tuple b3::lib::statlib::stats::findwithin = Dispatch( (lfindwithin, (ListType, TupleType)), )
tuple b3::lib::statlib::stats::fprob = Dispatch( (lfprob, (IntType, FloatType)), )
tuple b3::lib::statlib::stats::friedmanchisquare = Dispatch( (lfriedmanchisquare, (ListType, TupleType)), )
tuple b3::lib::statlib::stats::gammln = Dispatch( (lgammln, (IntType, FloatType)), )
tuple b3::lib::statlib::stats::geometricmean = Dispatch( (lgeometricmean, (ListType, TupleType)), )

DISPATCH LISTS AND TUPLES TO ABOVE FCNS #########.

CENTRAL TENDENCY:

tuple b3::lib::statlib::stats::harmonicmean = Dispatch( (lharmonicmean, (ListType, TupleType)), )
tuple b3::lib::statlib::stats::histogram = Dispatch( (lhistogram, (ListType, TupleType)), )
tuple b3::lib::statlib::stats::incr = Dispatch( (lincr, (ListType, TupleType)), )

SUPPORT FUNCTIONS:

tuple b3::lib::statlib::stats::itemfreq = Dispatch( (litemfreq, (ListType, TupleType)), )

FREQUENCY STATISTICS:

tuple b3::lib::statlib::stats::kendalltau = Dispatch( (lkendalltau, (ListType, TupleType)), )
tuple b3::lib::statlib::stats::kruskalwallish = Dispatch( (lkruskalwallish, (ListType, TupleType)), )
tuple b3::lib::statlib::stats::ks_2samp = Dispatch( (lks_2samp, (ListType, TupleType)), )
tuple b3::lib::statlib::stats::ksprob = Dispatch( (lksprob, (IntType, FloatType)), )
tuple b3::lib::statlib::stats::kurtosis = Dispatch( (lkurtosis, (ListType, TupleType)), )
tuple b3::lib::statlib::stats::linregress = Dispatch( (llinregress, (ListType, TupleType)), )
tuple b3::lib::statlib::stats::mannwhitneyu = Dispatch( (lmannwhitneyu, (ListType, TupleType)), )
tuple b3::lib::statlib::stats::mean = Dispatch( (lmean, (ListType, TupleType)), )
tuple b3::lib::statlib::stats::median = Dispatch( (lmedian, (ListType, TupleType)), )
tuple b3::lib::statlib::stats::medianscore = Dispatch( (lmedianscore, (ListType, TupleType)), )
tuple b3::lib::statlib::stats::mode = Dispatch( (lmode, (ListType, TupleType)), )
tuple b3::lib::statlib::stats::moment = Dispatch( (lmoment, (ListType, TupleType)), )

MOMENTS:

tuple b3::lib::statlib::stats::obrientransform = Dispatch( (lobrientransform, (ListType, TupleType)), )

VARIABILITY:

tuple b3::lib::statlib::stats::paired = Dispatch( (lpaired, (ListType, TupleType)), )

CORRELATION FCNS:

tuple b3::lib::statlib::stats::pearsonr = Dispatch( (lpearsonr, (ListType, TupleType)), )
tuple b3::lib::statlib::stats::percentileofscore = Dispatch( (lpercentileofscore, (ListType, TupleType)), )
tuple b3::lib::statlib::stats::pointbiserialr = Dispatch( (lpointbiserialr, (ListType, TupleType)), )
tuple b3::lib::statlib::stats::rankdata = Dispatch( (lrankdata, (ListType, TupleType)), )
tuple b3::lib::statlib::stats::ranksums = Dispatch( (lranksums, (ListType, TupleType)), )
tuple b3::lib::statlib::stats::relfreq = Dispatch( (lrelfreq, (ListType, TupleType)), )
tuple b3::lib::statlib::stats::samplestdev = Dispatch( (lsamplestdev, (ListType, TupleType)), )
tuple b3::lib::statlib::stats::samplevar = Dispatch( (lsamplevar, (ListType, TupleType)), )
tuple b3::lib::statlib::stats::scoreatpercentile = Dispatch( (lscoreatpercentile, (ListType, TupleType)), )
tuple b3::lib::statlib::stats::sem = Dispatch( (lsem, (ListType, TupleType)), )
tuple b3::lib::statlib::stats::shellsort = Dispatch( (lshellsort, (ListType, TupleType)), )
tuple b3::lib::statlib::stats::skew = Dispatch( (lskew, (ListType, TupleType)), )
tuple b3::lib::statlib::stats::spearmanr = Dispatch( (lspearmanr, (ListType, TupleType)), )
tuple b3::lib::statlib::stats::square_of_sums = Dispatch( (lsquare_of_sums, (ListType, TupleType)), )
tuple b3::lib::statlib::stats::ss = Dispatch( (lss, (ListType, TupleType)), )
tuple b3::lib::statlib::stats::stdev = Dispatch( (lstdev, (ListType, TupleType)), )
tuple b3::lib::statlib::stats::sterr = Dispatch( (lsterr, (ListType, TupleType)), )
tuple b3::lib::statlib::stats::sum = Dispatch( (lsum, (ListType, TupleType)), )
tuple b3::lib::statlib::stats::sumdiffsquared = Dispatch( (lsumdiffsquared, (ListType, TupleType)), )
tuple b3::lib::statlib::stats::summult = Dispatch( (lsummult, (ListType, TupleType)), )
tuple b3::lib::statlib::stats::tiecorrect = Dispatch( (ltiecorrect, (ListType, TupleType)), )
tuple b3::lib::statlib::stats::trim1 = Dispatch( (ltrim1, (ListType, TupleType)), )
tuple b3::lib::statlib::stats::trimboth = Dispatch( (ltrimboth, (ListType, TupleType)), )

TRIMMING FCNS:

tuple b3::lib::statlib::stats::ttest_1samp = Dispatch( (lttest_1samp, (ListType, TupleType)), )

INFERENTIAL STATS:

tuple b3::lib::statlib::stats::ttest_ind = Dispatch( (lttest_ind, (ListType, TupleType)), )
tuple b3::lib::statlib::stats::ttest_rel = Dispatch( (lttest_rel, (ListType, TupleType)), )
tuple b3::lib::statlib::stats::var = Dispatch( (lvar, (ListType, TupleType)), )
tuple b3::lib::statlib::stats::variation = Dispatch( (lvariation, (ListType, TupleType)), )
tuple b3::lib::statlib::stats::wilcoxont = Dispatch( (lwilcoxont, (ListType, TupleType)), )
tuple b3::lib::statlib::stats::z = Dispatch( (lz, (ListType, TupleType)), )
tuple b3::lib::statlib::stats::zprob = Dispatch( (lzprob, (IntType, FloatType)), )
tuple b3::lib::statlib::stats::zs = Dispatch( (lzs, (ListType, TupleType)), )
 All Classes Namespaces Files Functions Variables Properties