# Created by Octave 3.2.4, Tue Nov 23 12:53:42 2010 EST <mockbuild@jetta.math.Princeton.EDU.private>
# name: cache
# type: cell
# rows: 3
# columns: 57
# name: <cell-element>
# type: string
# elements: 1
# length: 6
center
# name: <cell-element>
# type: string
# elements: 1
# length: 505
 CENTER removes the mean 

 [z,mu] = center(x,DIM,W)
   removes mean x along dimension DIM

 x	input data 
 DIM	dimension
	1: column
	2: row
	default or []: first DIMENSION, with more than 1 element
 W	weights to computed weighted mean (default: [], all weights = 1)
	numel(W) must be equal to size(x,DIM)

 features:
 - can deal with NaN's (missing values)
 - weighting of data 
 - dimension argument 
 - compatible to Matlab and Octave

 see also: SUMSKIPNAN, MEAN, STD, DETREND, ZSCORE

 REFERENCE(S):

# name: <cell-element>
# type: string
# elements: 1
# length: 26
 CENTER removes the mean 


# name: <cell-element>
# type: string
# elements: 1
# length: 24
coefficient_of_variation
# name: <cell-element>
# type: string
# elements: 1
# length: 221
 COEFFICIENT_OF_VARIATION returns STD(X)/MEAN(X)
 
 cv=coefficient_of_variation(x [,DIM])
  cv=std(x)/mean(x) 

 see also: SUMSKIPNAN, MEAN, STD

   REFERENCE(S):
   http://mathworld.wolfram.com/VariationCoefficient.html

# name: <cell-element>
# type: string
# elements: 1
# length: 80
 COEFFICIENT_OF_VARIATION returns STD(X)/MEAN(X)
 
 cv=coefficient_of_variation(

# name: <cell-element>
# type: string
# elements: 1
# length: 8
conv2nan
# name: <cell-element>
# type: string
# elements: 1
# length: 308
 CONV2 2-dimensional convolution 
 X and Y can contain missing values encoded with NaN.
 NaN's are skipped, NaN do not result in a NaN output. 
 The output gives NaN only if there are insufficient input data

 [...] = CONV2NAN(X,Y);
      calculates 2-dim convolution between X and Y
 [C]   = CONV2NAN(X,Y);

# name: <cell-element>
# type: string
# elements: 1
# length: 80
 CONV2 2-dimensional convolution 
 X and Y can contain missing values encoded wi

# name: <cell-element>
# type: string
# elements: 1
# length: 3
cor
# name: <cell-element>
# type: string
# elements: 1
# length: 755
 COR calculates the correlation matrix
 X and Y can contain missing values encoded with NaN.
 NaN's are skipped, NaN do not result in a NaN output. 
 (Its assumed that the occurence of NaN's is uncorrelated) 
 The output gives NaN only if there are insufficient input data

 COR(X);
      calculates the (auto-)correlation matrix of X
 COR(X,Y);
      calculates the crosscorrelation between X and Y

 c = COR(...);
 	c is the correlation matrix

 NOTE: Under certain circumstances (Missing values and small number of samples) 
   abs(COR) can be larger than 1.  
   If you need abs(COR)<=1, use CORRCOEF. CORRCOEF garantees abs(COR)<=1. 

 see also: SUMSKIPNAN, COVM, COV, CORRCOEF

 REFERENCES:
 http://mathworld.wolfram.com/CorrelationCoefficient.html

# name: <cell-element>
# type: string
# elements: 1
# length: 80
 COR calculates the correlation matrix
 X and Y can contain missing values encod

# name: <cell-element>
# type: string
# elements: 1
# length: 8
corrcoef
# name: <cell-element>
# type: string
# elements: 1
# length: 4503
 CORRCOEF calculates the correlation matrix from pairwise correlations.
   The input data can contain missing values encoded with NaN.
   Missing data (NaN's) are handled by pairwise deletion [15]. 
   In order to avoid possible pitfalls, use case-wise deletion or 
   or check the correlation of NaN's with your data (see below). 
   A significance test for testing the Hypothesis  
   'correlation coefficient R is significantly different to zero' 
   is included. 

 [...] = CORRCOEF(X);
      calculates the (auto-)correlation matrix of X
 [...] = CORRCOEF(X,Y);
      calculates the crosscorrelation between X and Y

 [...] = CORRCOEF(..., Mode);
       Mode='Pearson' or 'parametric' [default]
       	gives the correlation coefficient  
       	also known as the 'product-moment coefficient of correlation' 
               or 'Pearson''s correlation' [1]
       Mode='Spearman' 	gives 'Spearman''s Rank Correlation Coefficient'
	        This replaces SPEARMAN.M
       Mode='Rank' 		gives a nonparametric Rank Correlation Coefficient
	        This replaces RANKCORR.M

 [...] = CORRCOEF(..., param1, value1, param2, value2, ... );
	param 		value
	'Mode'		type of correlation 
		'Pearson','parametric'
		'Spearman'
		'rank'
	'rows'		how do deal with missing values encoded as NaN's. 	
		'complete': remove all rows with at least one NaN
		'pairwise': [default]
	'alpha'		0.01	: significance level to compute confidence interval

 [R,p,ci1,ci2,nansig] = CORRCOEF(...);
 	R is the correlation matrix
	R(i,j) is the correlation coefficient r between X(:,i) and Y(:,j)
  p    gives the significance of R
	It tests the null hypothesis that the product moment correlation coefficient is zero 
       using Student's t-test on the statistic t = r*sqrt(N-2)/sqrt(1-r^2) 
       where N is the number of samples (Statistics, M. Spiegel, Schaum series).
  p > alpha: do not reject the Null hypothesis: 'R is zero'.
  p < alpha: The alternative hypothesis 'R is larger than zero' is true with probability (1-alpha).
  ci1	lower (1-alpha) confidence interval 
  ci2	upper (1-alpha) confidence interval
	If no alpha is provided, the default alpha is 0.01. This can be changed with function flag_implicit_significance. 
  nan_sig 	p-value whether H0: 'NaN''s are not correlated' could be correct
       if nan_sig < alpha, H1 ('NaNs are correlated') is very likely. 
 
 The result is only valid if the occurence of NaN's is uncorrelated. In
 order to avoid this pitfall, the correlation of NaN's should be checked 
 or case-wise deletion should be applied. 
   Case-Wise deletion can be implemented 
    ix = ~any(isnan([X,Y]),2);
    [...] = CORRCOEF(X(ix,:),Y(ix,:),...); 

  Correlation (non-random distribution) of NaN's can be checked with 
       [nan_R,nan_sig]=corrcoef(X,isnan(X))
   or  [nan_R,nan_sig]=corrcoef([X,Y],isnan([X,Y]))
   or  [R,p,ci1,ci2] = CORRCOEF(...);

 Further recommandation related to the correlation coefficient: 
 + LOOK AT THE SCATTERPLOTS to make sure that the relationship is linear
 + Correlation is not causation because 
	it is not clear which parameter is 'cause' and which is 'effect' and
       the observed correlation between two variables might be due to the action of other, unobserved variables.

 see also: SUMSKIPNAN, COVM, COV, COR, SPEARMAN, RANKCORR, RANKS,
       PARTCORRCOEF, flag_implicit_significance

 REFERENCES:
 on the correlation coefficient 
 [ 1] http://mathworld.wolfram.com/CorrelationCoefficient.html
 [ 2] http://www.geography.btinternet.co.uk/spearman.htm
 [ 3] Hogg, R. V. and Craig, A. T. Introduction to Mathematical Statistics, 5th ed.  New York: Macmillan, pp. 338 and 400, 1995.
 [ 4] Lehmann, E. L. and D'Abrera, H. J. M. Nonparametrics: Statistical Methods Based on Ranks, rev. ed. Englewood Cliffs, NJ: Prentice-Hall, pp. 292, 300, and 323, 1998.
 [ 5] Press, W. H.; Flannery, B. P.; Teukolsky, S. A.; and Vetterling, W. T. Numerical Recipes in FORTRAN: The Art of Scientific Computing, 2nd ed. Cambridge, England: Cambridge University Press, pp. 634-637, 1992
 [ 6] http://mathworld.wolfram.com/SpearmanRankCorrelationCoefficient.html
 on the significance test of the correlation coefficient
 [11] http://www.met.rdg.ac.uk/cag/STATS/corr.html
 [12] http://www.janda.org/c10/Lectures/topic06/L24-significanceR.htm
 [13] http://faculty.vassar.edu/lowry/ch4apx.html
 [14] http://davidmlane.com/hyperstat/B134689.html
 [15] http://www.statsoft.com/textbook/stbasic.html%Correlations
 others
 [20] http://www.tufts.edu/~gdallal/corr.htm

# name: <cell-element>
# type: string
# elements: 1
# length: 71
 CORRCOEF calculates the correlation matrix from pairwise correlations.

# name: <cell-element>
# type: string
# elements: 1
# length: 3
cov
# name: <cell-element>
# type: string
# elements: 1
# length: 1106
 COV covariance matrix
 X and Y can contain missing values encoded with NaN.
 NaN's are skipped, NaN do not result in a NaN output. 
 The output gives NaN only if there are insufficient input data
 The mean is removed from the data. 

 C = COV(X [,Mode]);
      calculates the (auto-)correlation matrix of X
 C = COV(X,Y [,Mode]);
      calculates the crosscorrelation between X and Y. 
      C(i,j) is the correlation between the i-th and jth 
      column of X and Y, respectively. 
   NOTE: Octave and Matlab have (in some special cases) incompatible implemenations. 
       This implementation follows Octave. If the result could be ambigous or  
       incompatible, a warning will be presented in Matlab. To avoid this warning use: 
       a) use COV([X(:),Y(:)]) if you want the traditional Matlab result. 
       b) use C = COV([X,Y]), C = C(1:size(X,2),size(X,2)+1:size(C,2)); if you want to be compatible with this software.  

 Mode = 0 [default] scales C by (N-1)
 Mode = 1 scales C by N. 

 see also: COVM, COR, CORRCOEF, SUMSKIPNAN

 REFERENCES:
 http://mathworld.wolfram.com/Covariance.html

# name: <cell-element>
# type: string
# elements: 1
# length: 76
 COV covariance matrix
 X and Y can contain missing values encoded with NaN.

# name: <cell-element>
# type: string
# elements: 1
# length: 4
covm
# name: <cell-element>
# type: string
# elements: 1
# length: 1182
 COVM generates covariance matrix
 X and Y can contain missing values encoded with NaN.
 NaN's are skipped, NaN do not result in a NaN output. 
 The output gives NaN only if there are insufficient input data

 COVM(X,Mode);
      calculates the (auto-)correlation matrix of X
 COVM(X,Y,Mode);
      calculates the crosscorrelation between X and Y
 COVM(...,W);
	weighted crosscorrelation 

 Mode = 'M' minimum or standard mode [default]
 	C = X'*X; or X'*Y correlation matrix

 Mode = 'E' extended mode
 	C = [1 X]'*[1 X]; % l is a matching column of 1's
 	C is additive, i.e. it can be applied to subsequent blocks and summed up afterwards
 	the mean (or sum) is stored on the 1st row and column of C

 Mode = 'D' or 'D0' detrended mode
	the mean of X (and Y) is removed. If combined with extended mode (Mode='DE'), 
 	the mean (or sum) is stored in the 1st row and column of C. 
 	The default scaling is factor (N-1). 
 Mode = 'D1' is the same as 'D' but uses N for scaling. 

 C = covm(...); 
 	C is the scaled by N in Mode M and by (N-1) in mode D.
 [C,N] = covm(...);
	C is not scaled, provides the scaling factor N  
	C./N gives the scaled version. 

 see also: DECOVM, XCOVF

# name: <cell-element>
# type: string
# elements: 1
# length: 80
 COVM generates covariance matrix
 X and Y can contain missing values encoded wi

# name: <cell-element>
# type: string
# elements: 1
# length: 7
detrend
# name: <cell-element>
# type: string
# elements: 1
# length: 837
 DETREND removes the trend from data, NaN's are considered as missing values
 
 DETREND is fully compatible to previous Matlab and Octave DETREND with the following features added:
 - handles NaN's by assuming that these are missing values
 - handles unequally spaced data
 - second output parameter gives the trend of the data
 - compatible to Matlab and Octave 

 [...]=detrend([t,] X [,p])
	removes trend for unequally spaced data
	t represents the time points
	X(i) is the value at time t(i)
	p must be a scalar

 [...]=detrend(X,0)
 [...]=detrend(X,'constant')
	removes the mean

 [...]=detrend(X,p)
	removes polynomial of order p (default p=1)

 [...]=detrend(X,1) - default
 [...]=detrend(X,'linear')
	removes linear trend 

 [X,T]=detrend(...) 

 X is the detrended data
 T is the removed trend
 
 see also: SUMSKIPNAN, ZSCORE		

# name: <cell-element>
# type: string
# elements: 1
# length: 80
 DETREND removes the trend from data, NaN's are considered as missing values
 
 

# name: <cell-element>
# type: string
# elements: 1
# length: 4
ecdf
# name: <cell-element>
# type: string
# elements: 1
# length: 443
 ECDF empirical cumulative function  
  NaN's are considered Missing values and are ignored. 

  [F,X] = ecdf(Y)
	calculates empirical cumulative distribution functions (i.e Kaplan-Meier estimate)
  ecdf(Y)
  ecdf(gca,Y)
	without output arguments plots the empirical cdf, in axis gca. 

 Y 	input data
	must be a vector or matrix, in case Y is a matrix, the ecdf for every column is computed. 

 see also: HISTO2, HISTO3, PERCENTILE, QUANTILE

# name: <cell-element>
# type: string
# elements: 1
# length: 80
 ECDF empirical cumulative function  
  NaN's are considered Missing values and 

# name: <cell-element>
# type: string
# elements: 1
# length: 26
flag_implicit_significance
# name: <cell-element>
# type: string
# elements: 1
# length: 928
 The use of FLAG_IMPLICIT_SIGNIFICANCE is in experimental state. 
 flag_implicit_significance might even become obsolete.

 FLAG_IMPLICIT_SIGNIFICANCE sets and gets default alpha (level) of any significance test
 The default alpha-level is stored in the global variable FLAG_implicit_significance
 The idea is that the significance must not be assigned explicitely. 
 This might yield more readable code. 

 Choose alpha low enough, because in alpha*100% of the cases, you will 
 reject the Null hypothesis just by change. For this reason, the default
 alpha is 0.01. 
 
   flag_implicit_significance(0.01) 
	sets the alpha-level for the significance test
 
 alpha = flag_implicit_significance()
 	gets default alpha

 flag_implicit_significance(alpha)
 	sets default alpha-level

 alpha = flag_implicit_significance(alpha)
	gets and sets alpha 

 features:
 - compatible to Matlab and Octave

 see also: CORRCOEF, PARTCORRCOEF

# name: <cell-element>
# type: string
# elements: 1
# length: 64
 The use of FLAG_IMPLICIT_SIGNIFICANCE is in experimental state.

# name: <cell-element>
# type: string
# elements: 1
# length: 22
flag_implicit_skip_nan
# name: <cell-element>
# type: string
# elements: 1
# length: 934
 FLAG_IMPLICIT_SKIP_NAN sets and gets default mode for handling NaNs
	1 skips NaN's (the default mode if no mode is set)
 	0 NaNs are propagated; input NaN's give NaN's at the output
 
 FLAG = flag_implicit_skip_nan()
 	gets current mode

 flag_implicit_skip_nan(FLAG)
 sets mode 

 prevFLAG = flag_implicit_skip_nan(nextFLAG)
	gets previous set FLAG and sets FLAG for the future
 flag_implicit_skip_nan(prevFLAG)
	resets FLAG to previous mode

 It is used in: 
	SUMSKIPNAN, MEDIAN, QUANTILES, TRIMEAN
 and affects many other functions like: 
	CENTER, KURTOSIS, MAD, MEAN, MOMENT, RMS, SEM, SKEWNESS, 
	STATISTIC, STD, VAR, ZSCORE etc. 

 The mode is stored in the global variable FLAG_implicit_skip_nan
 It is recommended to use flag_implicit_skip_nan(1) as default and
 flag_implicit_skip_nan(0) should be used for exceptional cases only.
 This feature might disappear without further notice, so you should really not
 rely on it. 

# name: <cell-element>
# type: string
# elements: 1
# length: 80
 FLAG_IMPLICIT_SKIP_NAN sets and gets default mode for handling NaNs
	1 skips Na

# name: <cell-element>
# type: string
# elements: 1
# length: 17
flag_nans_occured
# name: <cell-element>
# type: string
# elements: 1
# length: 430
 FLAG_NANS_OCCURED checks whether the last call(s) to sumskipnan or covm 
 contained any not-a-numbers in the input argument. Because many other 
 functions like mean, std, etc. are also using sumskipnan, 
 also these functions can be checked for NaN's in the input data. 
 
 A call to FLAG_NANS_OCCURED() resets also the flag whether NaN's occured. 
 Only sumskipnan or covm can set the flag again. 

 see also: SUMSKIPNAN, COVM

# name: <cell-element>
# type: string
# elements: 1
# length: 80
 FLAG_NANS_OCCURED checks whether the last call(s) to sumskipnan or covm 
 conta

# name: <cell-element>
# type: string
# elements: 1
# length: 7
geomean
# name: <cell-element>
# type: string
# elements: 1
# length: 1207
 GEOMEAN calculates the geomentric mean of data elements. 
 
 	y = geomean(x [,DIM [,W]])   is the same as 
 	y = mean(x,'G' [,DIM]) 

 DIM	dimension
	1 STD of columns
	2 STD of rows
	default or []: first DIMENSION, with more than 1 element
 W	weights to compute weighted mean (default: [])
	if W=[], all weights are 1. 
	number of elements in W must match size(x,DIM) 

 features:
 - can deal with NaN's (missing values)
 - weighting of data 
 - dimension argument also in Octave
 - compatible to Matlab and Octave

 see also: SUMSKIPNAN, MEAN, HARMMEAN

    This program is free software; you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation; either version 3 of the License, or
    (at your option) any later version.

    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.

    You should have received a copy of the GNU General Public License
    along with this program; If not, see <http://www.gnu.org/licenses/>.

# name: <cell-element>
# type: string
# elements: 1
# length: 57
 GEOMEAN calculates the geomentric mean of data elements.

# name: <cell-element>
# type: string
# elements: 1
# length: 8
harmmean
# name: <cell-element>
# type: string
# elements: 1
# length: 629
 HARMMEAN calculates the harmonic mean of data elements. 
 The harmonic mean is the inverse of the mean of the inverse elements.
 
 	y = harmmean(x [,DIM [,W]]) is the same as 
 	y = mean(x,'H' [,DIM [,W]]) 

 DIM	dimension
	1 STD of columns
	2 STD of rows
	default or []: first DIMENSION, with more than 1 element
 W	weights to compute weighted mean (default: [])
	if W=[], all weights are 1. 
	number of elements in W must match size(x,DIM) 

 features:
 - can deal with NaN's (missing values)
 - weighting of data 
 - dimension argument also in Octave
 - compatible to Matlab and Octave

 see also: SUMSKIPNAN, MEAN, GEOMEAN


# name: <cell-element>
# type: string
# elements: 1
# length: 56
 HARMMEAN calculates the harmonic mean of data elements.

# name: <cell-element>
# type: string
# elements: 1
# length: 3
iqr
# name: <cell-element>
# type: string
# elements: 1
# length: 372
 IQR calculates the interquartile range  
  Missing values (encoded as NaN) are ignored. 

  Q = iqr(Y)
  Q = iqr(Y,DIM)
     returns the IQR along dimension DIM of sample array Y.

  Q = iqr(HIS)
     returns the IQR from the histogram HIS. 
     HIS must be a HISTOGRAM struct as defined in HISTO2 or HISTO3.

 see also: MAD, RANGE, HISTO2, HISTO3, PERCENTILE, QUANTILE

# name: <cell-element>
# type: string
# elements: 1
# length: 80
 IQR calculates the interquartile range  
  Missing values (encoded as NaN) are 

# name: <cell-element>
# type: string
# elements: 1
# length: 8
kurtosis
# name: <cell-element>
# type: string
# elements: 1
# length: 461
 KURTOSIS estimates the kurtosis

 y = kurtosis(x,DIM)
   calculates kurtosis of x in dimension DIM

 DIM	dimension
	1: STATS of columns
	2: STATS of rows
	default or []: first DIMENSION, with more than 1 element

 features:
 - can deal with NaN's (missing values)
 - dimension argument 
 - compatible to Matlab and Octave

 see also: SUMSKIPNAN, VAR, STD, VAR, SKEWNESS, MOMENT, STATISTIC, 
    IMPLICIT_SKIP_NAN

 REFERENCE(S):
 http://mathworld.wolfram.com/

# name: <cell-element>
# type: string
# elements: 1
# length: 33
 KURTOSIS estimates the kurtosis


# name: <cell-element>
# type: string
# elements: 1
# length: 3
mad
# name: <cell-element>
# type: string
# elements: 1
# length: 855
 MAD estimates the Mean Absolute deviation
 (note that according to [1,2] this is the mean deviation; 
 not the mean absolute deviation)

 y = mad(x,DIM)
   calculates the mean deviation of x in dimension DIM

 DIM	dimension
	1: STATS of columns
	2: STATS of rows
	default or []: first DIMENSION, with more than 1 element

 features:
 - can deal with NaN's (missing values)
 - dimension argument 
 - compatible to Matlab and Octave

 see also: SUMSKIPNAN, VAR, STD, 

 REFERENCE(S):
 [1] http://mathworld.wolfram.com/MeanDeviation.html
 [2] L. Sachs, "Applied Statistics: A Handbook of Techniques", Springer-Verlag, 1984, page 253.

 [3] http://mathworld.wolfram.com/MeanAbsoluteDeviation.html
 [4] Kenney, J. F. and Keeping, E. S. "Mean Absolute Deviation." 6.4 in Mathematics of Statistics, Pt. 1, 3rd ed. Princeton, NJ: Van Nostrand, pp. 76-77 1962. 

# name: <cell-element>
# type: string
# elements: 1
# length: 80
 MAD estimates the Mean Absolute deviation
 (note that according to [1,2] this i

# name: <cell-element>
# type: string
# elements: 1
# length: 4
mean
# name: <cell-element>
# type: string
# elements: 1
# length: 735
 MEAN calculates the mean of data elements. 
 
  y = mean(x [,DIM] [,opt] [, W])

 DIM	dimension
	1 MEAN of columns
	2 MEAN of rows
 	N MEAN of  N-th dimension 
	default or []: first DIMENSION, with more than 1 element

 opt	options 
	'A' arithmetic mean
	'G' geometric mean
	'H' harmonic mean

 W	weights to compute weighted mean (default: [])
	if W=[], all weights are 1. 
	number of elements in W must match size(x,DIM) 

 usage: 
	mean(x)
	mean(x,DIM)
	mean(x,opt)
	mean(x,opt,DIM)
	mean(x,DIM,opt)
	mean(x,DIM,W)
	mean(x,DIM,opt,W); '

 features:
 - can deal with NaN's (missing values)
 - weighting of data 
 - dimension argument also in Octave
 - compatible to Matlab and Octave

 see also: SUMSKIPNAN, MEAN, GEOMEAN, HARMMEAN


# name: <cell-element>
# type: string
# elements: 1
# length: 43
 MEAN calculates the mean of data elements.

# name: <cell-element>
# type: string
# elements: 1
# length: 7
meandev
# name: <cell-element>
# type: string
# elements: 1
# length: 856
 MEANDEV estimates the Mean deviation
 (note that according to [1,2] this is the mean deviation; 
 not the mean absolute deviation)

 y = meandev(x,DIM)
   calculates the mean deviation of x in dimension DIM

 DIM	dimension
	1: STATS of columns
	2: STATS of rows
	default or []: first DIMENSION, with more than 1 element

 features:
 - can deal with NaN's (missing values)
 - dimension argument 
 - compatible to Matlab and Octave

 see also: SUMSKIPNAN, VAR, STD, MAD

 REFERENCE(S):
 [1] http://mathworld.wolfram.com/MeanDeviation.html
 [2] L. Sachs, "Applied Statistics: A Handbook of Techniques", Springer-Verlag, 1984, page 253.
 [3] http://mathworld.wolfram.com/MeanAbsoluteDeviation.html
 [4] Kenney, J. F. and Keeping, E. S. "Mean Absolute Deviation." 6.4 in Mathematics of Statistics, Pt. 1, 3rd ed. Princeton, NJ: Van Nostrand, pp. 76-77 1962. 

# name: <cell-element>
# type: string
# elements: 1
# length: 80
 MEANDEV estimates the Mean deviation
 (note that according to [1,2] this is the

# name: <cell-element>
# type: string
# elements: 1
# length: 6
meansq
# name: <cell-element>
# type: string
# elements: 1
# length: 527
 MEANSQ calculates the mean of the squares

 y = meansq(x,DIM,W)

 DIM	dimension
	1 STD of columns
	2 STD of rows
 	N STD of  N-th dimension 
	default or []: first DIMENSION, with more than 1 element
 W	weights to compute weighted mean (default: [])
	if W=[], all weights are 1. 
	number of elements in W must match size(x,DIM) 

 features:
 - can deal with NaN's (missing values)
 - weighting of data  
 - dimension argument also in Octave
 - compatible to Matlab and Octave

 see also: SUMSQ, SUMSKIPNAN, MEAN, VAR, STD, RMS

# name: <cell-element>
# type: string
# elements: 1
# length: 43
 MEANSQ calculates the mean of the squares


# name: <cell-element>
# type: string
# elements: 1
# length: 9
medAbsDev
# name: <cell-element>
# type: string
# elements: 1
# length: 373
 medAbsDev calculates the median absolute deviation 

 Usage:  D = medAbsDev(X, DIM)  
    or:  [D, M] = medAbsDev(X, DIM)
 Input:  X  : data
         DIM: dimension along which mad should be calculated (1=columns, 2=rows) 
               (optional, default=first dimension with more than 1 element
 Output: D  : median absolute deviations
         M  : medians (optional)

# name: <cell-element>
# type: string
# elements: 1
# length: 53
 medAbsDev calculates the median absolute deviation 


# name: <cell-element>
# type: string
# elements: 1
# length: 6
median
# name: <cell-element>
# type: string
# elements: 1
# length: 366
 MEDIAN data elements, 
 [y]=median(x [,DIM])

 DIM	dimension
	1: median of columns
	2: median of rows
 	N: median of  N-th dimension 
	default or []: first DIMENSION, with more than 1 element

 features:
 - can deal with NaN's (missing values)
 - accepts dimension argument like in Matlab in Octave, too. 
 - compatible to Matlab and Octave 

 see also: SUMSKIPNAN

# name: <cell-element>
# type: string
# elements: 1
# length: 46
 MEDIAN data elements, 
 [y]=median(x [,DIM])


# name: <cell-element>
# type: string
# elements: 1
# length: 3
mod
# name: <cell-element>
# type: string
# elements: 1
# length: 291
 MOD(x,y) calculates Modules Y from X 

     z = x - y * floor(x/y);
     e = eps * floor(x/y);

    [z,e] = MOD(X,Y)
	z is the modulus of Y for X
	e is the error tolerance, for checking the accuracy
		z(e > abs(y)) is not defined 

 	z has always the same sign than y	
     
 see also: REM

# name: <cell-element>
# type: string
# elements: 1
# length: 39
 MOD(x,y) calculates Modules Y from X 


# name: <cell-element>
# type: string
# elements: 1
# length: 6
moment
# name: <cell-element>
# type: string
# elements: 1
# length: 627
 MOMENT estimates the p-th moment 
 
 M = moment(x, p [,opt] [,DIM])
 M = moment(H, p [,opt])
   calculates p-th central moment from data x in dimension DIM
	of from Histogram H

 p	moment of order p
 opt   'ac': absolute 'a' and/or central ('c') moment
	DEFAULT: '' raw moments are estimated
 DIM	dimension
	1: STATS of columns
	2: STATS of rows
	default or []: first DIMENSION, with more than 1 element

 features:
 - can deal with NaN's (missing values)
 - dimension argument 
 - compatible to Matlab and Octave

 see also: STD, VAR, SKEWNESS, KURTOSIS, STATISTIC, 

 REFERENCE(S):
 http://mathworld.wolfram.com/Moment.html

# name: <cell-element>
# type: string
# elements: 1
# length: 80
 MOMENT estimates the p-th moment 
 
 M = moment(x, p [,opt] [,DIM])
 M = moment

# name: <cell-element>
# type: string
# elements: 1
# length: 11
naninsttest
# name: <cell-element>
# type: string
# elements: 1
# length: 112
 NANINSTTEST checks whether the functions from NaN-toolbox have been
 correctly installed. 

 see also: NANTEST

# name: <cell-element>
# type: string
# elements: 1
# length: 80
 NANINSTTEST checks whether the functions from NaN-toolbox have been
 correctly 

# name: <cell-element>
# type: string
# elements: 1
# length: 7
nanmean
# name: <cell-element>
# type: string
# elements: 1
# length: 330
 NANMEAN same as SUM but ignores NaN's. 
 NANMEAN is OBSOLETE; use MEAN instead. NANMEAN is included 
    to provide backward compatibility 

 Y = nanmean(x [,DIM])
 
 DIM	dimension
	1 sum of columns
	2 sum of rows
	default or []: first DIMENSION with more than 1 element
 Y	resulting mean

 
 see also: MEAN, SUMSKIPNAN, NANSUM 

# name: <cell-element>
# type: string
# elements: 1
# length: 39
 NANMEAN same as SUM but ignores NaN's.

# name: <cell-element>
# type: string
# elements: 1
# length: 6
nanstd
# name: <cell-element>
# type: string
# elements: 1
# length: 518
 NANSTD same as STD but ignores NaN's. 
 NANSTD is OBSOLETE; use NaN/STD instead. NANSTD is included 
    to fix a bug in alternative implementations and to 
    provide some compatibility. 

 Y = nanstd(x, FLAG, [,DIM])
 
 x     data
 FLAG  0: [default] normalizes with (N-1), N = sample size
 FLAG  1: normalizes with N, N = sample size
 DIM	dimension
	1 sum of columns
	2 sum of rows
	default or []: first DIMENSION with more than 1 element
 Y	resulting standard deviation
 
 see also: SUM, SUMSKIPNAN, NANSUM, STD

# name: <cell-element>
# type: string
# elements: 1
# length: 38
 NANSTD same as STD but ignores NaN's.

# name: <cell-element>
# type: string
# elements: 1
# length: 6
nansum
# name: <cell-element>
# type: string
# elements: 1
# length: 333
 NANSUM same as SUM but ignores NaN's. 
 NANSUM is OBSOLETE; use SUMSKIPNAN instead. NANSUM is included 
    to fix a bug in some other versions. 

 Y = nansum(x [,DIM])
 
 DIM	dimension
	1 sum of columns
	2 sum of rows
	default or []: first DIMENSION with more than 1 element
 Y	resulting sum

 
 see also: SUM, SUMSKIPNAN, NANSUM 

# name: <cell-element>
# type: string
# elements: 1
# length: 38
 NANSUM same as SUM but ignores NaN's.

# name: <cell-element>
# type: string
# elements: 1
# length: 7
nantest
# name: <cell-element>
# type: string
# elements: 1
# length: 366
 NANTEST checks several mathematical operations and a few 
 statistical functions for their correctness related to NaN's.
 e.g. it checks norminv, normcdf, normpdf, sort, matrix division and multiplication.


 see also: NANINSTTEST

 REFERENCE(S): 
 [1] W. Kahan (1996) Lecture notes on the Status of "IEEE Standard 754 for 
     Binary Floating-point Arithmetic. 


# name: <cell-element>
# type: string
# elements: 1
# length: 80
 NANTEST checks several mathematical operations and a few 
 statistical function

# name: <cell-element>
# type: string
# elements: 1
# length: 7
normcdf
# name: <cell-element>
# type: string
# elements: 1
# length: 290
 NORMCDF returns normal cumulative distribtion function

 cdf = normcdf(x,m,s);

 Computes the CDF of a the normal distribution 
    with mean m and standard deviation s
    default: m=0; s=1;
 x,m,s must be matrices of same size, or any one can be a scalar. 

 see also: NORMPDF, NORMINV 

# name: <cell-element>
# type: string
# elements: 1
# length: 56
 NORMCDF returns normal cumulative distribtion function


# name: <cell-element>
# type: string
# elements: 1
# length: 7
norminv
# name: <cell-element>
# type: string
# elements: 1
# length: 341
 NORMINV returns inverse cumulative function of the normal distribution

 x = norminv(p,m,s);

 Computes the quantile (inverse of the CDF) of a the normal 
    cumulative distribution with mean m and standard deviation s
    default: m=0; s=1;
 p,m,s must be matrices of same size, or any one can be a scalar. 

 see also: NORMPDF, NORMCDF 

# name: <cell-element>
# type: string
# elements: 1
# length: 72
 NORMINV returns inverse cumulative function of the normal distribution


# name: <cell-element>
# type: string
# elements: 1
# length: 7
normpdf
# name: <cell-element>
# type: string
# elements: 1
# length: 279
 NORMPDF returns normal probability density 

 pdf = normpdf(x,m,s);

 Computes the PDF of a the normal distribution 
    with mean m and standard deviation s
    default: m=0; s=1;
 x,m,s must be matrices of same size, or any one can be a scalar. 

 see also: NORMCDF, NORMINV 

# name: <cell-element>
# type: string
# elements: 1
# length: 45
 NORMPDF returns normal probability density 


# name: <cell-element>
# type: string
# elements: 1
# length: 12
partcorrcoef
# name: <cell-element>
# type: string
# elements: 1
# length: 2117
 PARTCORRCOEF calculates the partial correlation coefficient.
 X and Y can contain missing values encoded with NaN.
 NaN's are skipped, NaN do not result in a NaN output. 
 (Its assumed that the occurence of NaN's is uncorrelated) 
 The output gives NaN, only if there are insufficient input data.

  The partial correlation  is defined as 
  pcc(xy|z)=(cc(x,y)-cc(x,z)*cc(y,z))/sqrt((1-cc(x,y))*((1-cc(x,z))))


 PARTCORRCOEF(X [,Mode]);
      calculates the (auto-)correlation matrix of X
 PARTCORRCOEF(X,Y,Z [,Mode]);
      calculates the crosscorrelation between X and Y

 Mode='Pearson' or 'parametric' [default]
	gives the correlation coefficient  
	also known as the "product-moment coefficient of correlation" or "Pearson's correlation" [1]
 Mode='Spearman' 	gives "Spearman's Rank Correlation Coefficient"
	This replaces SPEARMAN.M
 Mode='Rank' 		gives a nonparametric Rank Correlation Coefficient
	This replaces RANKCORR.M

 [R,p,ci1,ci2] = PARTCORRCOEF(...);
  r is the partialcorrelation matrix
	r(i,j) is the partial correlation coefficient r between X(:,i) and Y(:,j) 
	when influence of Z is removed. 
  p    gives the significance of PCC
	It tests the null hypothesis that the product moment correlation coefficient is zero 
       using Student's t-test on the statistic t = r sqrt(N-Nz-2)/sqrt(1-r^2) 
       where N is the number of samples (Statistics, M. Spiegel, Schaum series).
  p > alpha: do not reject the Null hypothesis: "R is zero".
  p < alpha: The alternative hypothesis "R2 is larger than zero" is true with probability (1-alpha).
  ci1	lower 0.95 confidence interval 
  ci2	upper 0.95 confidence interval 

 Further recommandation related to the correlation coefficient 
 + LOOK AT THE SCATTERPLOTS!
 + Correlation is not causation. The observed correlation between two variables 
	might be due to the action of other, unobserved variables.

 see also: SUMSKIPNAN, COVM, COV, COR, SPEARMAN, RANKCORR, RANKS, CORRCOEF

 REFERENCES:
 on the partial correlation coefficient 
 [1] http://www.tufts.edu/~gdallal/partial.htm
 [2] http://www.nag.co.uk/numeric/fl/manual/pdf/G02/g02byf.pdf

# name: <cell-element>
# type: string
# elements: 1
# length: 61
 PARTCORRCOEF calculates the partial correlation coefficient.

# name: <cell-element>
# type: string
# elements: 1
# length: 10
percentile
# name: <cell-element>
# type: string
# elements: 1
# length: 554
 PERCENTILE calculates the percentiles of histograms and sample arrays.  

  Q = percentile(Y,q)      
  Q = percentile(Y,q,DIM)      
     returns the q-th percentile along dimension DIM of sample array Y.
     size(Q) is equal size(Y) except for dimension DIM which is size(Q,DIM)=length(Q)

  Q = percentile(HIS,q)
     returns the q-th percentile from the histogram HIS. 
     HIS must be a HISTOGRAM struct as defined in HISTO2 or HISTO3.
     If q is a vector, the each row of Q returns the q(i)-th percentile 

 see also: HISTO2, HISTO3, QUANTILE

# name: <cell-element>
# type: string
# elements: 1
# length: 71
 PERCENTILE calculates the percentiles of histograms and sample arrays.

# name: <cell-element>
# type: string
# elements: 1
# length: 7
prctile
# name: <cell-element>
# type: string
# elements: 1
# length: 576
 PRCTILE calculates the percentiles of histograms and sample arrays.  
 (its the same than PERCENTILE.M)

  Q = prctile(Y,q)      
  Q = prctile(Y,q,DIM)      
     returns the q-th percentile along dimension DIM of sample array Y.
     size(Q) is equal size(Y) except for dimension DIM which is size(Q,DIM)=length(Q)

  Q = prctile(HIS,q)
     returns the q-th percentile from the histogram HIS. 
     HIS must be a HISTOGRAM struct as defined in HISTO2 or HISTO3.
     If q is a vector, the each row of Q returns the q(i)-th percentile 

 see also: HISTO2, HISTO3, QUANTILE

# name: <cell-element>
# type: string
# elements: 1
# length: 68
 PRCTILE calculates the percentiles of histograms and sample arrays.

# name: <cell-element>
# type: string
# elements: 1
# length: 8
quantile
# name: <cell-element>
# type: string
# elements: 1
# length: 528
 QUANTILE calculates the quantiles of histograms and sample arrays.  

  Q = quantile(Y,q)
  Q = quantile(Y,q,DIM)
     returns the q-th quantile along dimension DIM of sample array Y.
     size(Q) is equal size(Y) except for dimension DIM which is size(Q,DIM)=length(Q)

  Q = quantile(HIS,q)
     returns the q-th quantile from the histogram HIS. 
     HIS must be a HISTOGRAM struct as defined in HISTO2 or HISTO3.
     If q is a vector, the each row of Q returns the q(i)-th quantile 

 see also: HISTO2, HISTO3, PERCENTILE

# name: <cell-element>
# type: string
# elements: 1
# length: 67
 QUANTILE calculates the quantiles of histograms and sample arrays.

# name: <cell-element>
# type: string
# elements: 1
# length: 8
rankcorr
# name: <cell-element>
# type: string
# elements: 1
# length: 668
 RANKCORR calculated the rank correlation coefficient.
 This function is replaced by CORRCOEF. 
 Significance test and confidence intervals can be obtained from CORRCOEF, too. 

 R = CORRCOEF(X, [Y, ] 'Rank');

 The rank correlation   r = corrcoef(ranks(x)). 
 is often confused with Spearman's rank correlation.  
 Spearman's correlation is defined as 
   r(x,y) = 1-6*sum((ranks(x)-ranks(y)).^2)/(N*(N*N-1))
 The results are different. Here, the former version is implemented. 

 see also: CORRCOEF, SPEARMAN, RANKS

 REFERENCES:
 [1] http://mathworld.wolfram.com/SpearmanRankCorrelationCoefficient.html
 [2] http://mathworld.wolfram.com/CorrelationCoefficient.html

# name: <cell-element>
# type: string
# elements: 1
# length: 54
 RANKCORR calculated the rank correlation coefficient.

# name: <cell-element>
# type: string
# elements: 1
# length: 5
ranks
# name: <cell-element>
# type: string
# elements: 1
# length: 857
 RANKS gives the rank of each element in a vector.
 This program uses an advanced algorithm with averge effort O(m.n.log(n)) 
 NaN in the input yields NaN in the output.
 
 r = ranks(X[,DIM])
   if X is a vector, return the vector of ranks of X adjusted for ties.
   if X is matrix, the rank is calculated along dimension DIM. 
   if DIM is zero or empty, the lowest dimension with more then 1 element is used. 
 r = ranks(X,DIM,'traditional')
   implements the traditional algorithm with O(n^2) computational 
   and O(n^2) memory effort
 r = ranks(X,DIM,'mtraditional')
   implements the traditional algorithm with O(n^2) computational 
   and O(n) memory effort
 r = ranks(X,DIM,'advanced   ')
   implements an advanced algorithm with O(n*log(n)) computational 
   and O(n.log(n)) memory effort

 see also: CORRCOEF, SPEARMAN, RANKCORR

 REFERENCES:
 --

# name: <cell-element>
# type: string
# elements: 1
# length: 50
 RANKS gives the rank of each element in a vector.

# name: <cell-element>
# type: string
# elements: 1
# length: 3
rem
# name: <cell-element>
# type: string
# elements: 1
# length: 281
 REM calculates remainder of X / Y  

     z = x - y * fix(x/y);
     e = eps * fix(x/y);

    [z,e] = REM(X,Y)
	z is the remainder of X / Y
	e is the error tolerance, for checking the accuracy
		z(e > abs(y)) is not defined 

 	z has always the same sign than x	
 
 see also: MOD

# name: <cell-element>
# type: string
# elements: 1
# length: 37
 REM calculates remainder of X / Y  


# name: <cell-element>
# type: string
# elements: 1
# length: 3
rms
# name: <cell-element>
# type: string
# elements: 1
# length: 560
 RMS calculates the root mean square
   can deal with complex data. 

 y = rms(x,DIM,W)

 DIM	dimension
	1 STD of columns
	2 STD of rows
 	N STD of  N-th dimension 
	default or []: first DIMENSION, with more than 1 element
 W	weights to compute weighted s.d. (default: [])
	if W=[], all weights are 1. 
	number of elements in W must match size(x,DIM) 

 y	estimated standard deviation

 features:
 - can deal with NaN's (missing values)
 - weighting of data 
 - dimension argument also in Octave
 - compatible to Matlab and Octave

 see also: SUMSKIPNAN, MEAN

# name: <cell-element>
# type: string
# elements: 1
# length: 67
 RMS calculates the root mean square
   can deal with complex data.

# name: <cell-element>
# type: string
# elements: 1
# length: 3
sem
# name: <cell-element>
# type: string
# elements: 1
# length: 695
 SEM calculates the standard error of the mean
 
 [SE,M] = SEM(x [, DIM [,W]])
   calculates the standard error (SE) in dimension DIM
   the default DIM is the first non-single dimension
   M returns the mean. 
   Can deal with complex data, too. 

 DIM	dimension
	1: SEM of columns
	2: SEM of rows
 	N: SEM of  N-th dimension 
	default or []: first DIMENSION, with more than 1 element
 W	weights to compute weighted mean and s.d. (default: [])
	if W=[], all weights are 1. 
	number of elements in W must match size(x,DIM) 

 features:
 - can deal with NaN's (missing values)
 - weighting of data 
 - dimension argument 
 - compatible to Matlab and Octave

 see also: SUMSKIPNAN, MEAN, VAR, STD

# name: <cell-element>
# type: string
# elements: 1
# length: 80
 SEM calculates the standard error of the mean
 
 [SE,M] = SEM(x [, DIM [,W]])
 

# name: <cell-element>
# type: string
# elements: 1
# length: 8
skewness
# name: <cell-element>
# type: string
# elements: 1
# length: 405
 SKEWNESS estimates the skewness 

 y = skewness(x,DIM)
   calculates skewness of x in dimension DIM

 DIM	dimension
	1: STATS of columns
	2: STATS of rows
	default or []: first DIMENSION, with more than 1 element

 features:
 - can deal with NaN's (missing values)
 - dimension argument 
 - compatible to Matlab and Octave

 see also: SUMSKIPNAN, STATISTIC

 REFERENCE(S):
 http://mathworld.wolfram.com/

# name: <cell-element>
# type: string
# elements: 1
# length: 34
 SKEWNESS estimates the skewness 


# name: <cell-element>
# type: string
# elements: 1
# length: 8
spearman
# name: <cell-element>
# type: string
# elements: 1
# length: 683
 SPEARMAN Spearman's rank correlation coefficient.
 This function is replaced by CORRCOEF. 
 Significance test and confidence intervals can be obtained from CORRCOEF. 

 [R,p,ci1,ci2] = CORRCOEF(x, [y, ] 'Rank');

 For some (unknown) reason, in previous versions Spearman's rank correlation  
   r = corrcoef(ranks(x)). 
 But according to [1], Spearman's correlation is defined as 
   r = 1-6*sum((ranks(x)-ranks(y)).^2)/(N*(N*N-1))
 The results are different. Here, the later version is implemented. 

 see also: CORRCOEF, RANKCORR

 REFERENCES:
 [1] http://mathworld.wolfram.com/SpearmanRankCorrelationCoefficient.html
 [2] http://mathworld.wolfram.com/CorrelationCoefficient.html

# name: <cell-element>
# type: string
# elements: 1
# length: 50
 SPEARMAN Spearman's rank correlation coefficient.

# name: <cell-element>
# type: string
# elements: 1
# length: 9
statistic
# name: <cell-element>
# type: string
# elements: 1
# length: 938
 STATISTIC estimates various statistics at once.
 
 R = STATISTIC(x,DIM)
   calculates all statistic (see list of fun) in dimension DIM
   R is a struct with all statistics 

 y = STATISTIC(x,fun)
   estimate of fun on dimension DIM
   y gives the statistic of fun	

 DIM	dimension
	1: STATS of columns
	2: STATS of rows
 	N: STATS of  N-th dimension 
	default or []: first DIMENSION, with more than 1 element

 fun	'mean'	mean
	'std'	standard deviation
	'var'	variance
	'sem'	standard error of the mean
	'rms'	root mean square
	'meansq' mean of squares
	'sum'	sum
	'sumsq'	sum of squares
	'CM#'	central moment of order #
	'skewness' skewness 
	'kurtosis' excess coefficient (Fisher kurtosis)
	'mad'	mean absolute deviation

 features:
 - can deal with NaN's (missing values)
 - dimension argument 
 - compatible to Matlab and Octave

 see also: SUMSKIPNAN

 REFERENCE(S):
 [1] http://www.itl.nist.gov/
 [2] http://mathworld.wolfram.com/

# name: <cell-element>
# type: string
# elements: 1
# length: 48
 STATISTIC estimates various statistics at once.

# name: <cell-element>
# type: string
# elements: 1
# length: 3
std
# name: <cell-element>
# type: string
# elements: 1
# length: 983
 STD calculates the standard deviation.
 
 [y,v] = std(x [, opt[, DIM [, W]]])
 
 opt   option 
	0:  normalizes with N-1 [default]
		provides the square root of best unbiased estimator of the variance
	1:  normalizes with N, 
		this provides the square root of the second moment around the mean
 	otherwise: 
               best unbiased estimator of the standard deviation (see [1])      

 DIM	dimension
 	N STD of  N-th dimension 
	default or []: first DIMENSION, with more than 1 element
 W	weights to compute weighted s.d. (default: [])
	if W=[], all weights are 1. 
	number of elements in W must match size(x,DIM) 

 y	estimated standard deviation

 features:
 - provides an unbiased estimation of the S.D. 
 - can deal with NaN's (missing values)
 - weighting of data 
 - dimension argument also in Octave
 - compatible to Matlab and Octave

 see also: RMS, SUMSKIPNAN, MEAN, VAR, MEANSQ,


 References(s):
 [1] http://mathworld.wolfram.com/StandardDeviationDistribution.html

# name: <cell-element>
# type: string
# elements: 1
# length: 39
 STD calculates the standard deviation.

# name: <cell-element>
# type: string
# elements: 1
# length: 10
sumskipnan
# name: <cell-element>
# type: string
# elements: 1
# length: 1234
 SUMSKIPNAN adds all non-NaN values. 

 All NaN's are skipped; NaN's are considered as missing values. 
 SUMSKIPNAN of NaN's only  gives O; and the number of valid elements is return. 
 SUMSKIPNAN is also the elementary function for calculating 
 various statistics (e.g. MEAN, STD, VAR, RMS, MEANSQ, SKEWNESS, 
 KURTOSIS, MOMENT, STATISTIC etc.) from data with missing values.  
 SUMSKIPNAN implements the DIMENSION-argument for data with missing values.
 Also the second output argument return the number of valid elements (not NaNs) 
 
 Y = sumskipnan(x [,DIM])
 [Y,N,SSQ] = sumskipnan(x [,DIM])
 [...] = sumskipnan(x, DIM, W)
 
 x	input data 	
 DIM	dimension (default: [])
	empty DIM sets DIM to first non singleton dimension	
 W	weight vector for weighted sum, numel(W) must fit size(x,DIM)
 Y	resulting sum
 N	number of valid (not missing) elements
 SSQ	sum of squares

 the function FLAG_NANS_OCCURED() returns whether any value in x
  is a not-a-number (NaN)

 features:
 - can deal with NaN's (missing values)
 - implements dimension argument. 
 - computes weighted sum 
 - compatible with Matlab and Octave

 see also: FLAG_NANS_OCCURED, SUM, NANSUM, MEAN, STD, VAR, RMS, MEANSQ, 
      SSQ, MOMENT, SKEWNESS, KURTOSIS, SEM

# name: <cell-element>
# type: string
# elements: 1
# length: 36
 SUMSKIPNAN adds all non-NaN values.

# name: <cell-element>
# type: string
# elements: 1
# length: 5
sumsq
# name: <cell-element>
# type: string
# elements: 1
# length: 391
 SUMSQ calculates the sum of squares.
 
 [y] = sumsq(x [,  DIM])
 
 DIM	dimension
 	N STD of  N-th dimension 
	default or []: first DIMENSION, with more than 1 element

 y	estimated standard deviation

 features:
 - can deal with NaN's (missing values)
 - dimension argument also in Octave
 - compatible to Matlab and Octave

 see also: RMS, SUMSKIPNAN, MEAN, VAR, MEANSQ,


 References(s):

# name: <cell-element>
# type: string
# elements: 1
# length: 37
 SUMSQ calculates the sum of squares.

# name: <cell-element>
# type: string
# elements: 1
# length: 4
tcdf
# name: <cell-element>
# type: string
# elements: 1
# length: 254
 TCDF returns student cumulative distribtion function

 cdf = tcdf(x,DF);

 Computes the CDF of the students distribution 
    with DF degrees of freedom 
 x,DF must be matrices of same size, or any one can be a scalar. 

 see also: NORMCDF, TPDF, TINV 

# name: <cell-element>
# type: string
# elements: 1
# length: 54
 TCDF returns student cumulative distribtion function


# name: <cell-element>
# type: string
# elements: 1
# length: 8
tiedrank
# name: <cell-element>
# type: string
# elements: 1
# length: 272
 TIEDRANK compute rank of samples, the mean value is used in case of ties
  this function is just a wrapper for RANKS, and provided for compatibility 
  with the statistics toolbox of matlab(tm)
 
    R = tiedrank(X)
	computes the rank R of vector X
    
 see also: RANKS

# name: <cell-element>
# type: string
# elements: 1
# length: 80
 TIEDRANK compute rank of samples, the mean value is used in case of ties
  this

# name: <cell-element>
# type: string
# elements: 1
# length: 4
tinv
# name: <cell-element>
# type: string
# elements: 1
# length: 330
 TINV returns inverse cumulative function of the student distribution

 x = tinv(p,v);

 Computes the quantile (inverse of the CDF) of a the student
    cumulative distribution with mean m and standard deviation s
 p,v must be matrices of same size, or any one can be a scalar. 

 see also: TPDF, TCDF, NORMPDF, NORMCDF, NORMINV 

# name: <cell-element>
# type: string
# elements: 1
# length: 70
 TINV returns inverse cumulative function of the student distribution


# name: <cell-element>
# type: string
# elements: 1
# length: 4
tpdf
# name: <cell-element>
# type: string
# elements: 1
# length: 261
 TPDF returns student probability density 

 pdf = tpdf(x,DF);

 Computes the PDF of a the student distribution 
    with DF degreas of freedom
 x,DF must be matrices of same size, or any one can be a scalar. 

 see also: TINV, TCDF, NORMPDF, NORMCDF, NORMINV 

# name: <cell-element>
# type: string
# elements: 1
# length: 43
 TPDF returns student probability density 


# name: <cell-element>
# type: string
# elements: 1
# length: 7
trimean
# name: <cell-element>
# type: string
# elements: 1
# length: 253
 TRIMEAN evaluates basic statistics of a data series
    m = TRIMEAN(y).

 The trimean is  m = (Q1+2*MED+Q3)/4
    with quartile Q1 and Q3 and median MED   

 N-dimensional data is supported
 
 REFERENCES:
 [1] http://mathworld.wolfram.com/Trimean.html

# name: <cell-element>
# type: string
# elements: 1
# length: 72
 TRIMEAN evaluates basic statistics of a data series
    m = TRIMEAN(y).

# name: <cell-element>
# type: string
# elements: 1
# length: 8
trimmean
# name: <cell-element>
# type: string
# elements: 1
# length: 309
 TRIMMEAN calculates the trimmed mean by removing the upper and lower
 (p/2)% samples. Missing values (encoded as NaN) are also removed. 

  Q = trimmean(Y,p)
  Q = trimmean(Y,p,DIM)
     returns the TRIMMEAN along dimension DIM of sample array Y.

 see also: MAD, RANGE, HISTO2, HISTO3, PERCENTILE, QUANTILE

# name: <cell-element>
# type: string
# elements: 1
# length: 80
 TRIMMEAN calculates the trimmed mean by removing the upper and lower
 (p/2)% sa

# name: <cell-element>
# type: string
# elements: 1
# length: 3
var
# name: <cell-element>
# type: string
# elements: 1
# length: 772
 VAR calculates the variance.
 
 y = var(x [, opt[, DIM]])
   calculates the variance in dimension DIM
   the default DIM is the first non-single dimension

 opt   0: normalizes with N-1 [default]
	1: normalizes with N 
 DIM	dimension
	1: VAR of columns
	2: VAR of rows
 	N: VAR of  N-th dimension 
	default or []: first DIMENSION, with more than 1 element
 W	weights to compute weighted variance (default: [])
	if W=[], all weights are 1. 
	number of elements in W must match size(x,DIM) 
 
 usage: 
	var(x)	
	var(x, opt, DIM)	
	var(x, [], DIM)	
	var(x, W, DIM)
	var(x, opt, DIM, W)	

 features:
 - can deal with NaN's (missing values)
 - weighting of data 
 - dimension argument 
 - compatible to Matlab and Octave

 see also: MEANSQ, SUMSQ, SUMSKIPNAN, MEAN, RMS, STD,

# name: <cell-element>
# type: string
# elements: 1
# length: 29
 VAR calculates the variance.

# name: <cell-element>
# type: string
# elements: 1
# length: 5
xcovf
# name: <cell-element>
# type: string
# elements: 1
# length: 485
 XCOVF generates cross-covariance function. 
 XCOVF is the same as XCORR except 
   X and Y can contain missing values encoded with NaN.
   NaN's are skipped, NaN do not result in a NaN output. 
   The output gives NaN only if there are insufficient input data

 [C,N,LAGS] = xcovf(X,MAXLAG,SCALEOPT);
      calculates the (auto-)correlation function of X
 [C,N,LAGS] = xcovf(X,Y,MAXLAG,SCALEOPT);
      calculates the crosscorrelation function between X and Y

 see also: COVM, XCORR

# name: <cell-element>
# type: string
# elements: 1
# length: 43
 XCOVF generates cross-covariance function.

# name: <cell-element>
# type: string
# elements: 1
# length: 12
zScoreMedian
# name: <cell-element>
# type: string
# elements: 1
# length: 326
 zScoreMedian removes the median and standardizes by the 1.483*median absolute deviation

 Usage:  Z = zScoreMedian(X, DIM)
 Input:  X  : data
         DIM: dimension along which z-score should be calculated (1=columns, 2=rows) 
              (optional, default=first dimension with more than 1 element
 Output: Z  : z-scores

# name: <cell-element>
# type: string
# elements: 1
# length: 59
 zScoreMedian removes the median and standardizes by the 1.

# name: <cell-element>
# type: string
# elements: 1
# length: 6
zscore
# name: <cell-element>
# type: string
# elements: 1
# length: 622
 ZSCORE removes the mean and normalizes the data 
 to a variance of 1. Can be used for Pre-Whitening of the data, too. 

 [z,r,m] = zscore(x,DIM)
   z   z-score of x along dimension DIM
   r   is the inverse of the standard deviation
   m   is the mean of x

 The data x can be reconstrated with 
     x = z*diag(1./r) + repmat(m,size(z)./size(m))  
     z = x*diag(r) - repmat(m.*v,size(z)./size(m))  

 DIM	dimension
	1: STATS of columns
	2: STATS of rows
	default or []: first DIMENSION, with more than 1 element

 see also: SUMSKIPNAN, MEAN, STD, DETREND

 REFERENCE(S):
 [1] http://mathworld.wolfram.com/z-Score.html

# name: <cell-element>
# type: string
# elements: 1
# length: 70
 ZSCORE removes the mean and normalizes the data 
 to a variance of 1.

