# doc-cache created by Octave 6.4.0
# name: cache
# type: cell
# rows: 3
# columns: 4
# name: <cell-element>
# type: sq_string
# elements: 1
# length: 4
mean


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1789
 -- statistics: Y = mean (X)
 -- statistics: Y = mean (X, "all")
 -- statistics: Y = mean (X, DIM)
 -- statistics: Y = mean (X, VECDIM)
 -- statistics: Y = mean (..., OUTTYPE)
 -- statistics: Y = mean (..., NANFLAG)

     Compute the mean of the elements of X.

        * If X is a vector, then 'mean(X)' returns the mean of the
          elements in X defined as

               mean (X) = SUM_i X(i) / N

          where N is the length of the X vector.

        * If X is a matrix, then 'mean(X)' returns a row vector with the
          mean of each columns in X.

        * If X is a multidimensional array, then 'mean(X)' operates
          along the first nonsingleton dimension of X.

     'mean (X, "all")' returns the mean of all the elements in X.

     'mean (X, DIM)' returns the mean along the operating dimension DIM
     of X.

     'mean (X, VECDIM)' returns the mean over the dimensions specified
     in the vector VECDIM.  For example, if X is a 2-by-3-by-4 array,
     then 'mean (X, [1 2])' returns a 1-by-1-by-4 array.  Each element
     of the output array is the mean of the elements on the
     corresponding page of X.  If VECDIM indexes all dimensions of X,
     then it is equivalent to 'mean (X, "all")'.

     'mean (..., OUTTYPE)' returns the mean with a specified data type,
     using any of the input arguments in the previous syntaxes.  OUTTYPE
     can be "default", "double", or "native".

     'mean (..., NANFLAG)' specifies whether to exclude NaN values from
     the calculation, using any of the input argument combinations in
     previous syntaxes.  By default, NaN values are included in the
     calculation (NANFLAG has the value "includenan").  To exclude NaN
     values, set the value of NANFLAG to "omitnan".

     See also: median, mode.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 38
Compute the mean of the elements of X.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 6
median


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1861
 -- statistics: Y = median (X)
 -- statistics: Y = median (X, "all")
 -- statistics: Y = median (X, DIM)
 -- statistics: Y = median (X, VECDIM)
 -- statistics: Y = median (..., OUTTYPE)
 -- statistics: Y = median (..., NANFLAG)

     Compute the median of the elements of X.

     When the elements of X are sorted, say 'S = sort (X)', the median
     is defined as

                       |  S(ceil(N/2))           N odd
          median (X) = |
                       | (S(N/2) + S(N/2+1))/2   N even

        * If X is a matrix, then 'median(X)' returns a row vector with
          the mean of each columns in X.

        * If X is a multidimensional array, then 'median(X)' operates
          along the first nonsingleton dimension of X.

     'median (X, "all")' returns the median of all the elements in X.

     'median (X, DIM)' returns the median along the operating dimension
     DIM of X.

     'median (X, VECDIM)' returns the median over the dimensions
     specified in the vector VECDIM.  For example, if X is a 2-by-3-by-4
     array, then 'median (X, [1 2])' returns a 1-by-1-by-4 array.  Each
     element of the output array is the median of the elements on the
     corresponding page of X.  If VECDIM indexes all dimensions of X,
     then it is equivalent to 'median (X, "all")'.

     'median (..., OUTTYPE)' returns the median with a specified data
     type, using any of the input arguments in the previous syntaxes.
     OUTTYPE can be "default", "double", or "native".

     'median (..., NANFLAG)' specifies whether to exclude NaN values
     from the calculation, using any of the input argument combinations
     in previous syntaxes.  By default, NaN values are included in the
     calculation (NANFLAG has the value "includenan").  To exclude NaN
     values, set the value of NANFLAG to "omitnan".

     See also: mean, mode.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 40
Compute the median of the elements of X.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 3
std


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 2781
 -- statistics: S = std (X)
 -- statistics: S = std (X, W)
 -- statistics: S = std (X, W, "all")
 -- statistics: S = std (X, W, DIM)
 -- statistics: S = std (X, W, VECDIM)
 -- statistics: S = std (..., NANFLAG)
 -- statistics: [S, M] = std (...)

     Compute the standard deviation of the elements of X.

        * If X is a vector, then 'var(X)' returns the standard deviation
          of the elements in X defined as

               std (S) = sqrt ((1 / (N-1)) * SUM_i (|X(i) - mean (X)|^2))

          where N is the length of the X vector.

        * If X is a matrix, then 'std(X)' returns a row vector with the
          standard deviation of each columns in X.

        * If X is a multidimensional array, then 'var(X)' operates along
          the first nonsingleton dimension of X.

     'var (X, W)' specifies a weighting scheme.  When W = 0 (default),
     the standard deviation is normalized by N-1 (population standard
     deviation), where N is the number of observations.  When W = 1, the
     standard deviation is normalized by the number of observations
     (sample standard deviation).  To use the default value you may pass
     an empty input argument [] before entering other options.

     W can also be a weight vector, matrix or N-D array containing
     nonnegative elements.  When W is a vector, its length must equal
     the length of the dimension over which var is operating.  When
     "all" flag is used, the length of W must equal the elements in X.
     When W is a matrix or N-D array, its size must equal the size of X.
     NaN values in W are treated accordingly to those in X.

     'std (X, "all")' returns the standard deviation of all the elements
     in X.

     'std (X, [], DIM)' returns the standard deviation along the
     operating dimension DIM of X.

     'std (X, [], VECDIM)' returns the standard deviation over the
     dimensions specified in the vector VECDIM.  For example, if X is a
     2-by-3-by-4 array, then 'var (X, [1 2])' returns a 1-by-1-by-4
     array.  Each element of the output array is the standard deviation
     of the elements on the corresponding page of X.  If VECDIM indexes
     all dimensions of X, then it is equivalent to 'std (X, "all")'.

     'std (..., NANFLAG)' specifies whether to exclude NaN values from
     the calculation, using any of the input argument combinations in
     previous syntaxes.  By default, NaN values are included in the
     calculation (NANFLAG has the value "includenan").  To exclude NaN
     values, set the value of NANFLAG to "omitnan".

     '[S, M] = std (...)' also returns the mean of the elements of X
     used to calculate the standard deviation.  If S is the weighted
     standard deviation, then M is the weighted mean.

     See also: var, mean.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 52
Compute the standard deviation of the elements of X.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 3
var


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 2641
 -- statistics: V = var (X)
 -- statistics: V = var (X, W)
 -- statistics: V = var (X, W, "all")
 -- statistics: V = var (X, W, DIM)
 -- statistics: V = var (X, W, VECDIM)
 -- statistics: V = var (..., NANFLAG)
 -- statistics: [V, M] = var (...)

     Compute the variance of the elements of X.

        * If X is a vector, then 'var(X)' returns the variance of the
          elements in X defined as

               var (V) = (1 / (N-1)) * SUM_i (|X(i) - mean (X)|^2)

          where N is the length of the X vector.

        * If X is a matrix, then 'var (X)' returns a row vector with the
          variance of each columns in X.

        * If X is a multidimensional array, then 'var (X)' operates
          along the first nonsingleton dimension of X.

     'var (X, W)' specifies a weighting scheme.  When W = 0 (default),
     the variance is normalized by N-1 (population variance), where N is
     the number of observations.  When W = 1, the variance is normalized
     by the number of observations (sample variance).  To use the
     default value you may pass an empty input argument [] before
     entering other options.

     W can also be a weight vector, matrix or N-D array containing
     nonnegative elements.  When W is a vector, its length must equal
     the length of the dimension over which var is operating.  When
     "all" flag is used, the length of W must equal the elements in X.
     When W is a matrix or N-D array, its size must equal the size of X.
     NaN values in W are treated accordingly to those in X.

     'var (X, "all")' returns the variance of all the elements in X.

     'var (X, [], DIM)' returns the variance along the operating
     dimension DIM of X.

     'var (X, [], VECDIM)' returns the variance over the dimensions
     specified in the vector VECDIM.  For example, if X is a 2-by-3-by-4
     array, then 'var (X, [1 2])' returns a 1-by-1-by-4 array.  Each
     element of the output array is the variance of the elements on the
     corresponding page of X.  If VECDIM indexes all dimensions of X,
     then it is equivalent to 'var (X, "all")'.

     'var (..., NANFLAG)' specifies whether to exclude NaN values from
     the calculation, using any of the input argument combinations in
     previous syntaxes.  By default, NaN values are included in the
     calculation (NANFLAG has the value "includenan").  To exclude NaN
     values, set the value of NANFLAG to "omitnan".

     '[V, M] = var (...)' also returns the mean of the elements of X
     used to calculate the variance.  If V is the weighted variance,
     then M is the weighted mean.

     See also: std, mean.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 42
Compute the variance of the elements of X.





