wiimote.stats Namespace Reference

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

Functions
def	abetacf (a, b, x, verbose=1)
def	abetai (a, b, x, verbose=1)
def	achisqprob (chisq, df)
	APROBABILITY CALCULATIONS ####. More...
def	achisquare (f_obs, f_exp=None)
def	acorrelation (X)
def	acov (x, y, dimension=None, keepdims=0)
def	acovariance (X)
	ACORRELATION FUNCTIONS ######. More...
def	acumfreq (a, numbins=10, defaultreallimits=None)
def	acumsum (a, dimension=None)
def	adescribe (inarray, dimension=None)
def	aerfcc (x)
def	aF_oneway (args)
def	aF_value (ER, EF, dfR, dfF)
def	afindwithin (data)
def	afprob (dfnum, dfden, F)
def	afriedmanchisquare (args)
def	agammln (xx)
def	ageometricmean (inarray, dimension=None, keepdims=0)
	ACENTRAL TENDENCY ########. More...
def	aglm (data, para)
def	aharmonicmean (inarray, dimension=None, keepdims=0)
def	ahistogram (inarray, numbins=10, defaultlimits=None, printextras=1)
def	aitemfreq (a)
	AFREQUENCY FUNCTIONS #######. More...
def	akendalltau (x, y)
def	akruskalwallish (args)
def	aks_2samp (data1, data2)
def	aksprob (alam)
def	akurtosis (a, dimension=None)
def	akurtosistest (a, dimension=None)
def	alincc (x, y)
def	alinregress (args)
def	amannwhitneyu (x, y)
def	amasslinregress (args)
def	amean (inarray, dimension=None, keepdims=0)
def	amedian (inarray, numbins=1000)
def	amedianscore (inarray, dimension=None)
def	amode (a, dimension=None)
def	amoment (a, moment=1, dimension=None)
	AMOMENTS #############. More...
def	anormaltest (a, dimension=None)
def	aobrientransform (args)
	AVARIABILITY FUNCTIONS #####. More...
def	ap2t (pval, df)
def	apaired (x, y)
def	apearsonr (x, y, verbose=1)
def	apercentileofscore (inarray, score, histbins=10, defaultlimits=None)
def	apointbiserialr (x, y)
def	arankdata (inarray)
def	aranksums (x, y)
def	arelfreq (a, numbins=10, defaultreallimits=None)
def	asamplestdev (inarray, dimension=None, keepdims=0)
def	asamplevar (inarray, dimension=None, keepdims=0)
def	ascoreatpercentile (inarray, percent)
def	asem (inarray, dimension=None, keepdims=0)
def	ashellsort (inarray)
def	asign (a)
	ASUPPORT FUNCTIONS ########. More...
def	asignaltonoise (instack, dimension=0)
def	askew (a, dimension=None)
def	askewtest (a, dimension=None)
	NORMALITY TESTS ##########. More...
def	aspearmanr (x, y)
def	asquare_of_sums (inarray, dimension=None, keepdims=0)
def	ass (inarray, dimension=None, keepdims=0)
def	astdev (inarray, dimension=None, keepdims=0)
def	asterr (inarray, dimension=None, keepdims=0)
def	asum (a, dimension=None, keepdims=0)
def	asumdiffsquared (a, b, dimension=None, keepdims=0)
def	asummult (array1, array2, dimension=None, keepdims=0)
def	athreshold (a, threshmin=None, threshmax=None, newval=0)
	ATRIMMING FUNCTIONS #######. More...
def	atiecorrect (rankvals)
def	atmax (a, upperlimit, dimension=None, inclusive=1)
def	atmean (a, limits=None, inclusive=(1, 1))
def	atmin (a, lowerlimit=None, dimension=None, inclusive=1)
def	atrim1 (a, proportiontocut, tail='right')
def	atrimboth (a, proportiontocut)
def	atsem (a, limits=None, inclusive=(1, 1))
def	atstdev (a, limits=None, inclusive=(1, 1))
def	attest_1samp (a, popmean, printit=0, name='Sample', writemode='a')
	AINFERENTIAL STATISTICS #####. More...
def	attest_ind (a, b, dimension=None, printit=0, name1='Samp1', name2='Samp2', writemode='a')
def	attest_rel (a, b, dimension=None, printit=0, name1='Samp1', name2='Samp2', writemode='a')
def	atvar (a, limits=None, inclusive=(1, 1))
def	avar (inarray, dimension=None, keepdims=0)
def	avariation (a, dimension=None)
def	awilcoxont (x, y)
def	az (a, score)
def	azmap (scores, compare, dimension=0)
def	azprob (z)
def	azs (a)
def	dices (x, y)
def	F_value_multivariate (ER, EF, dfnum, dfden)
def	icc (x, y=None, verbose=0)
def	lbetacf (a, b, x)
def	lbetai (a, b, x)
def	lchisqprob (chisq, df)
	PROBABILITY CALCULATIONS ####. More...
def	lchisquare (f_obs, f_exp=None)
def	lcov (x, y, keepdims=0)
def	lcumfreq (inlist, numbins=10, defaultreallimits=None)
def	lcumsum (inlist)
def	ldescribe (inlist)
def	lerfcc (x)
def	lF_oneway (lists)
	ANOVA CALCULATIONS #######. More...
def	lF_value (ER, EF, dfnum, dfden)
def	lfindwithin (data)
def	lfprob (dfnum, dfden, F)
def	lfriedmanchisquare (args)
def	lgammln (xx)
def	lgeometricmean (inlist)
def	lharmonicmean (inlist)
def	lhistogram (inlist, numbins=10, defaultreallimits=None, printextras=0)
def	lincr (l, cap)
def	litemfreq (inlist)
	FREQUENCY STATS ##########. More...
def	lkendalltau (x, y)
def	lkruskalwallish (args)
def	lks_2samp (data1, data2)
def	lksprob (alam)
def	lkurtosis (inlist)
def	llincc (x, y)
def	llinregress (x, y)
def	lmannwhitneyu (x, y)
def	lmean (inlist)
def	lmedian (inlist, numbins=1000)
def	lmedianscore (inlist)
def	lmode (inlist)
def	lmoment (inlist, moment=1)
	MOMENTS #############. More...
def	lobrientransform (args)
	VARIABILITY FUNCTIONS ######. More...
def	lpaired (x, y)
	CORRELATION FUNCTIONS ######. More...
def	lpearsonr (x, y)
def	lpercentileofscore (inlist, score, histbins=10, defaultlimits=None)
def	lpointbiserialr (x, y)
def	lrankdata (inlist)
def	lranksums (x, y)
def	lrelfreq (inlist, numbins=10, defaultreallimits=None)
def	lsamplestdev (inlist)
def	lsamplevar (inlist)
def	lscoreatpercentile (inlist, percent)
def	lsem (inlist)
def	lshellsort (inlist)
def	lskew (inlist)
def	lspearmanr (x, y)
def	lsquare_of_sums (inlist)
def	lss (inlist)
def	lstdev (inlist)
def	lsterr (inlist)
def	lsum (inlist)
def	lsumdiffsquared (x, y)
def	lsummult (list1, list2)
def	ltiecorrect (rankvals)
def	ltrim1 (l, proportiontocut, tail='right')
def	ltrimboth (l, proportiontocut)
	TRIMMING FUNCTIONS #######. More...
def	lttest_1samp (a, popmean, printit=0, name='Sample', writemode='a')
	INFERENTIAL STATISTICS #####. More...
def	lttest_ind (a, b, printit=0, name1='Samp1', name2='Samp2', writemode='a')
def	lttest_rel (a, b, printit=0, name1='Sample1', name2='Sample2', writemode='a')
def	lvar (inlist)
def	lvariation (inlist)
def	lwilcoxont (x, y)
def	lz (inlist, score)
def	lzprob (z)
def	lzs (inlist)
def	outputfstats (Enum, Eden, dfnum, dfden, f, prob)
def	outputpairedstats (fname, writemode, name1, n1, m1, se1, min1, max1, name2, n2, m2, se2, min2, max2, statname, stat, prob)
def	writecc (listoflists, file, writetype='w', extra=2)
	SUPPORT FUNCTIONS #######. More...

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

Function Documentation

def wiimote.stats.abetacf	(		a,
			b,
			x,
			verbose = 1
	)

Evaluates the continued fraction form of the incomplete Beta function,
betai.  (Adapted from: Numerical Recipies in C.)  Can handle multiple
dimensions for x.

Usage:   abetacf(a,b,x,verbose=1)

Definition at line 3893 of file stats.py.

def wiimote.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 Recipies in
C.)  Can handle multiple dimensions.

Usage:   abetai(a,b,x,verbose=1)

Definition at line 3966 of file stats.py.

def wiimote.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

Definition at line 3702 of file stats.py.

def wiimote.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

Definition at line 3472 of file stats.py.

def wiimote.stats.acorrelation

(

X

)

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

Usage:   acorrelation(X)
Returns: correlation matrix of X

Definition at line 2982 of file stats.py.

def wiimote.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)

Definition at line 2762 of file stats.py.

def wiimote.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

Definition at line 2968 of file stats.py.

def wiimote.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

Definition at line 2636 of file stats.py.

def wiimote.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)

Definition at line 4181 of file stats.py.

def wiimote.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

Definition at line 2444 of file stats.py.

def wiimote.stats.aerfcc

(

x

)

Returns the complementary error function erfc(x) with fractional error
everywhere less than 1.2e-7.  Adapted from Numerical Recipies.  Can
handle multiple dimensions.

Usage:   aerfcc(x)

Definition at line 3784 of file stats.py.

def wiimote.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

Definition at line 4045 of file stats.py.

def wiimote.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

Definition at line 4080 of file stats.py.

def wiimote.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

Definition at line 4328 of file stats.py.

def wiimote.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

Definition at line 3879 of file stats.py.

def wiimote.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

Definition at line 3673 of file stats.py.

def wiimote.stats.agammln

(

xx

)

Returns the gamma function of xx.
Gamma(z) = Integral(0,infinity) of t^(z-1)exp(-t) dt.
Adapted from: Numerical Recipies in C.  Can handle multiple dims ... but
probably doesn't normally have to.

Usage:   agammln(xx)

Definition at line 3945 of file stats.py.

def wiimote.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

Definition at line 2002 of file stats.py.

def wiimote.stats.aglm	(		data,
			para
	)

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 ???

Definition at line 4011 of file stats.py.

def wiimote.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

Definition at line 2045 of file stats.py.

def wiimote.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)

Definition at line 2597 of file stats.py.

def wiimote.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)

Definition at line 2549 of file stats.py.

def wiimote.stats.akendalltau	(		x,
			y
	)

Calculates Kendall's tau ... correlation of ordinal data.  Adapted
from function kendl1 in Numerical Recipies.  Needs good test-cases.@@@

Usage:   akendalltau(x,y)
Returns: Kendall's tau, two-tailed p-value

Definition at line 3190 of file stats.py.

def wiimote.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

Definition at line 3637 of file stats.py.

def wiimote.stats.aks_2samp	(		data1,
			data2
	)

Computes the Kolmogorov-Smirnof statistic on 2 samples.  Modified from
Numerical Recipies 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

Definition at line 3491 of file stats.py.

def wiimote.stats.aksprob

(

alam

)

Returns the probability value for a K-S statistic computed via ks_2samp.
Adapted from Numerical Recipies.  Can handle multiple dimensions.

Usage:   aksprob(alam)

Definition at line 3837 of file stats.py.

def wiimote.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

Definition at line 2425 of file stats.py.

def wiimote.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

Definition at line 2494 of file stats.py.

def wiimote.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

Definition at line 3101 of file stats.py.

def wiimote.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

Definition at line 3225 of file stats.py.

def wiimote.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)))

Definition at line 3531 of file stats.py.

def wiimote.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

Definition at line 3261 of file stats.py.

def wiimote.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

Definition at line 2099 of file stats.py.

def wiimote.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

Definition at line 2141 of file stats.py.

def wiimote.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

Definition at line 2165 of file stats.py.

def wiimote.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

Definition at line 2190 of file stats.py.

def wiimote.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

Definition at line 2372 of file stats.py.

def wiimote.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

Definition at line 2526 of file stats.py.

def wiimote.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

Definition at line 2668 of file stats.py.

def wiimote.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

Definition at line 3392 of file stats.py.

def wiimote.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

Definition at line 2994 of file stats.py.

def wiimote.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

Definition at line 3117 of file stats.py.

def wiimote.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

Definition at line 2582 of file stats.py.

def wiimote.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

Definition at line 3160 of file stats.py.

def wiimote.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

Definition at line 4303 of file stats.py.

def wiimote.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

Definition at line 3585 of file stats.py.

def wiimote.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

Definition at line 2650 of file stats.py.

def wiimote.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)

Definition at line 2734 of file stats.py.

def wiimote.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)

Definition at line 2706 of file stats.py.

def wiimote.stats.ascoreatpercentile	(		inarray,
			percent
	)

Usage:   ascoreatpercentile(inarray,percent)   0<percent<100
Returns: score at given percentile, relative to inarray distribution

Definition at line 2566 of file stats.py.

def wiimote.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)

Definition at line 2844 of file stats.py.

def wiimote.stats.ashellsort

(

inarray

)

Shellsort algorithm.  Sorts a 1D-array.

Usage:   ashellsort(inarray)
Returns: sorted-inarray, sorting-index-vector (for original array)

Definition at line 4277 of file stats.py.

def wiimote.stats.asign

(

a

)

ASUPPORT FUNCTIONS ########.

Usage:   asign(a)
Returns: array shape of a, with -1 where a<0 and +1 where a>=0

Definition at line 4131 of file stats.py.

def wiimote.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

Definition at line 2747 of file stats.py.

def wiimote.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

Definition at line 2406 of file stats.py.

def wiimote.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

Definition at line 2469 of file stats.py.

def wiimote.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

Definition at line 3138 of file stats.py.

def wiimote.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

Definition at line 4239 of file stats.py.

def wiimote.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)

Definition at line 4204 of file stats.py.

def wiimote.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)

Definition at line 2815 of file stats.py.

def wiimote.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)

Definition at line 2828 of file stats.py.

def wiimote.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

Definition at line 4143 of file stats.py.

def wiimote.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]

Definition at line 4260 of file stats.py.

def wiimote.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)

Definition at line 4222 of file stats.py.

def wiimote.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

Definition at line 2911 of file stats.py.

def wiimote.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

Definition at line 3559 of file stats.py.

def wiimote.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)

Definition at line 2302 of file stats.py.

def wiimote.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))

Definition at line 2218 of file stats.py.

def wiimote.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)

Definition at line 2282 of file stats.py.

def wiimote.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

Definition at line 2945 of file stats.py.

def wiimote.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

Definition at line 2928 of file stats.py.

def wiimote.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))

Definition at line 2335 of file stats.py.

def wiimote.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))

Definition at line 2322 of file stats.py.

def wiimote.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

Definition at line 3311 of file stats.py.

def wiimote.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 Recipies, 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

Definition at line 3341 of file stats.py.

def wiimote.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 Recipies, 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

Definition at line 3422 of file stats.py.

def wiimote.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))

Definition at line 2250 of file stats.py.

def wiimote.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)

Definition at line 2790 of file stats.py.

def wiimote.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)

Definition at line 2394 of file stats.py.

def wiimote.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

Definition at line 3606 of file stats.py.

def wiimote.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)

Definition at line 2867 of file stats.py.

def wiimote.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)

Definition at line 2892 of file stats.py.

def wiimote.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

Definition at line 3798 of file stats.py.

def wiimote.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)

Definition at line 2879 of file stats.py.

def wiimote.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)

Definition at line 3058 of file stats.py.

def wiimote.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.

Definition at line 4109 of file stats.py.

def wiimote.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

Definition at line 3073 of file stats.py.

def wiimote.stats.lbetacf	(		a,
			b,
			x
	)

This function evaluates the continued fraction form of the incomplete
Beta function, betai.  (Adapted from: Numerical Recipies in C.)

Usage:   lbetacf(a,b,x)

Definition at line 1473 of file stats.py.

def wiimote.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 Recipies in C.)

Usage:   lbetai(a,b,x)

Definition at line 1528 of file stats.py.

def wiimote.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)

Definition at line 1322 of file stats.py.

def wiimote.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

Definition at line 1091 of file stats.py.

def wiimote.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)

Definition at line 632 of file stats.py.

def wiimote.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

Definition at line 542 of file stats.py.

def wiimote.stats.lcumsum

(

inlist

)

Returns a list consisting of the cumulative sum of the items in the
passed list.

Usage:   lcumsum(inlist)

Definition at line 1680 of file stats.py.

def wiimote.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

Definition at line 432 of file stats.py.

def wiimote.stats.lerfcc

(

x

)

Returns the complementary error function erfc(x) with fractional
error everywhere less than 1.2e-7.  Adapted from Numerical Recipies.

Usage:   lerfcc(x)

Definition at line 1382 of file stats.py.

def wiimote.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

Definition at line 1557 of file stats.py.

def wiimote.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)

Definition at line 1594 of file stats.py.

def wiimote.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

Definition at line 1856 of file stats.py.

def wiimote.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

Definition at line 1461 of file stats.py.

def wiimote.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

Definition at line 1292 of file stats.py.

def wiimote.stats.lgammln

(

xx

)

Returns the gamma function of xx.
Gamma(z) = Integral(0,infinity) of t^(z-1)exp(-t) dt.
(Adapted from: Numerical Recipies in C.)

Usage:   lgammln(xx)

Definition at line 1507 of file stats.py.

def wiimote.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)

Definition at line 269 of file stats.py.

def wiimote.stats.lharmonicmean

(

inlist

)

Calculates the harmonic mean of the values in the passed list.
That is:  n / (1/x1 + 1/x2 + ... + 1/xn).  Assumes a '1D' list.

Usage:   lharmonicmean(inlist)

Definition at line 283 of file stats.py.

def wiimote.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

Definition at line 503 of file stats.py.

def wiimote.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)

Definition at line 1651 of file stats.py.

def wiimote.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)

Definition at line 452 of file stats.py.

def wiimote.stats.lkendalltau	(		x,
			y
	)

Calculates Kendall's tau ... correlation of ordinal data.  Adapted
from function kendl1 in Numerical Recipies.  Needs good test-routine.@@@

Usage:   lkendalltau(x,y)
Returns: Kendall's tau, two-tailed p-value

Definition at line 930 of file stats.py.

def wiimote.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

Definition at line 1257 of file stats.py.

def wiimote.stats.lks_2samp	(		data1,
			data2
	)

Computes the Kolmogorov-Smirnof statistic on 2 samples.  From
Numerical Recipies 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

Definition at line 1109 of file stats.py.

def wiimote.stats.lksprob

(

alam

)

Computes a Kolmolgorov-Smirnov t-test significance level.  Adapted from
Numerical Recipies.

Usage:   lksprob(alam)

Definition at line 1440 of file stats.py.

def wiimote.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)

Definition at line 422 of file stats.py.

def wiimote.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

Definition at line 860 of file stats.py.

def wiimote.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

Definition at line 965 of file stats.py.

def wiimote.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)))

Definition at line 1148 of file stats.py.

def wiimote.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)

Definition at line 296 of file stats.py.

def wiimote.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)

Definition at line 309 of file stats.py.

def wiimote.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)

Definition at line 331 of file stats.py.

def wiimote.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)

Definition at line 350 of file stats.py.

def wiimote.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)

Definition at line 383 of file stats.py.

def wiimote.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

Definition at line 571 of file stats.py.

def wiimote.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

Definition at line 770 of file stats.py.

def wiimote.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

Definition at line 834 of file stats.py.

def wiimote.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)

Definition at line 488 of file stats.py.

def wiimote.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

Definition at line 898 of file stats.py.

def wiimote.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

Definition at line 1774 of file stats.py.

def wiimote.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

Definition at line 1202 of file stats.py.

def wiimote.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

Definition at line 554 of file stats.py.

def wiimote.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)

Definition at line 622 of file stats.py.

def wiimote.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)

Definition at line 607 of file stats.py.

def wiimote.stats.lscoreatpercentile	(		inlist,
			percent
	)

Returns the score at a given percentile relative to the distribution
given by inlist.

Usage:   lscoreatpercentile(inlist,percent)

Definition at line 468 of file stats.py.

def wiimote.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)

Definition at line 692 of file stats.py.

def wiimote.stats.lshellsort

(

inlist

)

Shellsort algorithm.  Sorts a 1D-list.

Usage:   lshellsort(inlist)
Returns: sorted-inlist, sorting-index-vector (for original list)

Definition at line 1748 of file stats.py.

def wiimote.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)

Definition at line 412 of file stats.py.

def wiimote.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

Definition at line 874 of file stats.py.

def wiimote.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

Definition at line 1736 of file stats.py.

def wiimote.stats.lss

(

inlist

)

Squares each value in the passed list, adds up these squares and
returns the result.

Usage:   lss(inlist)

Definition at line 1693 of file stats.py.

def wiimote.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)

Definition at line 672 of file stats.py.

def wiimote.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)

Definition at line 682 of file stats.py.

def wiimote.stats.lsum

(

inlist

)

Returns the sum of the items in the passed list.

Usage:   lsum(inlist)

Definition at line 1668 of file stats.py.

def wiimote.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]

Definition at line 1722 of file stats.py.

def wiimote.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)

Definition at line 1706 of file stats.py.

def wiimote.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

Definition at line 1177 of file stats.py.

def wiimote.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

Definition at line 747 of file stats.py.

def wiimote.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

Definition at line 731 of file stats.py.

def wiimote.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

Definition at line 997 of file stats.py.

def wiimote.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 Recipies, 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

Definition at line 1024 of file stats.py.

def wiimote.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 Recipies, 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

Definition at line 1055 of file stats.py.

def wiimote.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)

Definition at line 657 of file stats.py.

def wiimote.stats.lvariation

(

inlist

)

Returns the coefficient of variation, as defined in CRC Standard
Probability and Statistics, p.6.

Usage:   lvariation(inlist)

Definition at line 402 of file stats.py.

def wiimote.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

Definition at line 1224 of file stats.py.

def wiimote.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)

Definition at line 704 of file stats.py.

def wiimote.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)

Definition at line 1398 of file stats.py.

def wiimote.stats.lzs

(

inlist

)

Returns a list of z-scores, one for each score in the passed list.

Usage:   lzs(inlist)

Definition at line 715 of file stats.py.

def wiimote.stats.outputfstats	(		Enum,
			Eden,
			dfnum,
			dfden,
			f,
			prob
	)

Definition at line 4091 of file stats.py.

def wiimote.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

Definition at line 1799 of file stats.py.

def wiimote.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

Definition at line 1611 of file stats.py.

Variable Documentation

float wiimote.stats.__version__ = 0.6

private

Definition at line 229 of file stats.py.

wiimote.stats.betacf = Dispatch( (lbetacf, (IntType, FloatType)), )

Definition at line 1951 of file stats.py.

wiimote.stats.betai = Dispatch( (lbetai, (IntType, FloatType)), )

Definition at line 1952 of file stats.py.

wiimote.stats.chisqprob = Dispatch( (lchisqprob, (IntType, FloatType)), )

PROBABILITY CALCS:

Definition at line 1947 of file stats.py.

wiimote.stats.chisquare = Dispatch( (lchisquare, (ListType, TupleType)), )

Definition at line 1937 of file stats.py.

wiimote.stats.cumfreq = Dispatch( (lcumfreq, (ListType, TupleType)), )

Definition at line 1907 of file stats.py.

wiimote.stats.cumsum = Dispatch( (lcumsum, (ListType, TupleType)), )

Definition at line 1963 of file stats.py.

wiimote.stats.describe = Dispatch( (ldescribe, (ListType, TupleType)), )

Definition at line 1900 of file stats.py.

wiimote.stats.erfcc = Dispatch( (lerfcc, (IntType, FloatType)), )

Definition at line 1953 of file stats.py.

wiimote.stats.F_oneway = Dispatch( (lF_oneway, (ListType, TupleType)), )

ANOVA FUNCTIONS:

Definition at line 1957 of file stats.py.

wiimote.stats.F_value = Dispatch( (lF_value, (ListType, TupleType)), )

Definition at line 1958 of file stats.py.

wiimote.stats.findwithin = Dispatch( (lfindwithin, (ListType, TupleType)), )

Definition at line 1970 of file stats.py.

wiimote.stats.fprob = Dispatch( (lfprob, (IntType, FloatType)), )

Definition at line 1950 of file stats.py.

wiimote.stats.friedmanchisquare = Dispatch( (lfriedmanchisquare, (ListType, TupleType)), )

Definition at line 1944 of file stats.py.

wiimote.stats.gammln = Dispatch( (lgammln, (IntType, FloatType)), )

Definition at line 1954 of file stats.py.

wiimote.stats.geometricmean = Dispatch( (lgeometricmean, (ListType, TupleType)), )

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

RE-DEFINE DISPATCHES TO INCLUDE ARRAYS #########.

CENTRAL TENDENCY:

Definition at line 1888 of file stats.py.

wiimote.stats.harmonicmean = Dispatch( (lharmonicmean, (ListType, TupleType)), )

Definition at line 1889 of file stats.py.

wiimote.stats.histogram = Dispatch( (lhistogram, (ListType, TupleType)), )

Definition at line 1906 of file stats.py.

wiimote.stats.incr = Dispatch( (lincr, (ListType, TupleType)), )

SUPPORT FUNCTIONS:

Definition at line 1961 of file stats.py.

wiimote.stats.itemfreq = Dispatch( (litemfreq, (ListType, TupleType)), )

FREQUENCY STATISTICS:

FREQUENCY STATS:

Definition at line 1903 of file stats.py.

wiimote.stats.kendalltau = Dispatch( (lkendalltau, (ListType, TupleType)), )

Definition at line 1930 of file stats.py.

wiimote.stats.kruskalwallish = Dispatch( (lkruskalwallish, (ListType, TupleType)), )

Definition at line 1943 of file stats.py.

wiimote.stats.ks_2samp = Dispatch( (lks_2samp, (ListType, TupleType)), )

Definition at line 1938 of file stats.py.

wiimote.stats.ksprob = Dispatch( (lksprob, (IntType, FloatType)), )

Definition at line 1949 of file stats.py.

wiimote.stats.kurtosis = Dispatch( (lkurtosis, (ListType, TupleType)), )

Definition at line 1899 of file stats.py.

wiimote.stats.kurtosistest

Initial value:

= Dispatch( (akurtosistest, (ListType, TupleType)),
                           (akurtosistest, (N.ndarray,)) )

Definition at line 4385 of file stats.py.

wiimote.stats.LA = LinearAlgebra

Definition at line 4009 of file stats.py.

wiimote.stats.lincc

Initial value:

= Dispatch( (llincc, (ListType, TupleType)),
                       (alincc, (N.ndarray,)) )

Definition at line 4435 of file stats.py.

wiimote.stats.linregress = Dispatch( (llinregress, (ListType, TupleType)), )

Definition at line 1931 of file stats.py.

wiimote.stats.mannwhitneyu = Dispatch( (lmannwhitneyu, (ListType, TupleType)), )

Definition at line 1939 of file stats.py.

wiimote.stats.mean = Dispatch( (lmean, (ListType, TupleType)), )

Definition at line 1890 of file stats.py.

wiimote.stats.median = Dispatch( (lmedian, (ListType, TupleType)), )

Definition at line 1891 of file stats.py.

wiimote.stats.medianscore = Dispatch( (lmedianscore, (ListType, TupleType)), )

Definition at line 1892 of file stats.py.

wiimote.stats.mode = Dispatch( (lmode, (ListType, TupleType)), )

Definition at line 1893 of file stats.py.

wiimote.stats.moment = Dispatch( (lmoment, (ListType, TupleType)), )

MOMENTS:

VARIATION:

Definition at line 1896 of file stats.py.

wiimote.stats.normaltest

Initial value:

= Dispatch( (anormaltest, (ListType, TupleType)),
                         (anormaltest, (N.ndarray,)) )

Definition at line 4387 of file stats.py.

wiimote.stats.obrientransform = Dispatch( (lobrientransform, (ListType, TupleType)), )

VARIABILITY:

Definition at line 1911 of file stats.py.

wiimote.stats.paired = Dispatch( (lpaired, (ListType, TupleType)), )

CORRELATION FCNS:

Definition at line 1926 of file stats.py.

wiimote.stats.pearsonr = Dispatch( (lpearsonr, (ListType, TupleType)), )

Definition at line 1927 of file stats.py.

wiimote.stats.percentileofscore = Dispatch( (lpercentileofscore, (ListType, TupleType)), )

Definition at line 1905 of file stats.py.

wiimote.stats.pointbiserialr = Dispatch( (lpointbiserialr, (ListType, TupleType)), )

Definition at line 1929 of file stats.py.

wiimote.stats.rankdata = Dispatch( (lrankdata, (ListType, TupleType)), )

Definition at line 1969 of file stats.py.

wiimote.stats.ranksums = Dispatch( (lranksums, (ListType, TupleType)), )

Definition at line 1940 of file stats.py.

wiimote.stats.relfreq = Dispatch( (lrelfreq, (ListType, TupleType)), )

Definition at line 1908 of file stats.py.

wiimote.stats.samplestdev = Dispatch( (lsamplestdev, (ListType, TupleType)), )

Definition at line 1913 of file stats.py.

wiimote.stats.samplevar = Dispatch( (lsamplevar, (ListType, TupleType)), )

Definition at line 1912 of file stats.py.

wiimote.stats.scoreatpercentile = Dispatch( (lscoreatpercentile, (ListType, TupleType)), )

Definition at line 1904 of file stats.py.

wiimote.stats.sem = Dispatch( (lsem, (ListType, TupleType)), )

Definition at line 1917 of file stats.py.

wiimote.stats.shellsort = Dispatch( (lshellsort, (ListType, TupleType)), )

Definition at line 1968 of file stats.py.

wiimote.stats.signaltonoise = Dispatch( (asignaltonoise, (N.ndarray,)),)

Definition at line 4411 of file stats.py.

wiimote.stats.skew = Dispatch( (lskew, (ListType, TupleType)), )

Definition at line 1898 of file stats.py.

wiimote.stats.skewtest

Initial value:

= Dispatch( (askewtest, (ListType, TupleType)),
                       (askewtest, (N.ndarray,)) )

DISTRIBUTION TESTS.

Definition at line 4383 of file stats.py.

wiimote.stats.spearmanr = Dispatch( (lspearmanr, (ListType, TupleType)), )

Definition at line 1928 of file stats.py.

wiimote.stats.square_of_sums = Dispatch( (lsquare_of_sums, (ListType, TupleType)), )

Definition at line 1966 of file stats.py.

wiimote.stats.ss = Dispatch( (lss, (ListType, TupleType)), )

Definition at line 1964 of file stats.py.

wiimote.stats.stdev = Dispatch( (lstdev, (ListType, TupleType)), )

Definition at line 1915 of file stats.py.

wiimote.stats.sterr = Dispatch( (lsterr, (ListType, TupleType)), )

Definition at line 1916 of file stats.py.

wiimote.stats.sum = Dispatch( (lsum, (ListType, TupleType)), )

Definition at line 1962 of file stats.py.

wiimote.stats.sumdiffsquared = Dispatch( (lsumdiffsquared, (ListType, TupleType)), )

Definition at line 1967 of file stats.py.

wiimote.stats.summult = Dispatch( (lsummult, (ListType, TupleType)), )

Definition at line 1965 of file stats.py.

wiimote.stats.threshold = Dispatch( (athreshold, (N.ndarray,)),)

TRIMMING FCNS:

Definition at line 4426 of file stats.py.

wiimote.stats.tiecorrect = Dispatch( (ltiecorrect, (ListType, TupleType)), )

Definition at line 1941 of file stats.py.

wiimote.stats.tmean = Dispatch( (atmean, (N.ndarray,)) )

Definition at line 4364 of file stats.py.

wiimote.stats.trim1 = Dispatch( (ltrim1, (ListType, TupleType)), )

Definition at line 1923 of file stats.py.

wiimote.stats.trimboth = Dispatch( (ltrimboth, (ListType, TupleType)), )

TRIMMING FCNS:

Definition at line 1922 of file stats.py.

wiimote.stats.tsem = Dispatch( (atsem, (N.ndarray,)) )

Definition at line 4367 of file stats.py.

wiimote.stats.tstdev = Dispatch( (atstdev, (N.ndarray,)) )

Definition at line 4366 of file stats.py.

wiimote.stats.ttest_1samp = Dispatch( (lttest_1samp, (ListType, TupleType)), )

INFERENTIAL STATS:

Definition at line 1934 of file stats.py.

wiimote.stats.ttest_ind = Dispatch( (lttest_ind, (ListType, TupleType)), )

Definition at line 1935 of file stats.py.

wiimote.stats.ttest_rel = Dispatch( (lttest_rel, (ListType, TupleType)), )

Definition at line 1936 of file stats.py.

wiimote.stats.tvar = Dispatch( (atvar, (N.ndarray,)) )

Definition at line 4365 of file stats.py.

wiimote.stats.var = Dispatch( (lvar, (ListType, TupleType)), )

Definition at line 1914 of file stats.py.

wiimote.stats.variation = Dispatch( (lvariation, (ListType, TupleType)), )

Definition at line 1897 of file stats.py.

wiimote.stats.wilcoxont = Dispatch( (lwilcoxont, (ListType, TupleType)), )

Definition at line 1942 of file stats.py.

wiimote.stats.z = Dispatch( (lz, (ListType, TupleType)), )

Definition at line 1918 of file stats.py.

wiimote.stats.zprob = Dispatch( (lzprob, (IntType, FloatType)), )

Definition at line 1948 of file stats.py.

wiimote.stats.zs = Dispatch( (lzs, (ListType, TupleType)), )

Definition at line 1919 of file stats.py.