﻿StatsFunctions Members

The StatsFunctions type exposes the following members.

# Constructors

NameDescription
StatsFunctions
Initializes a new instance of the StatsFunctions class

# Methods

NameDescription
ArrayOfRandomNumbers(Int32, Double, Double)
Constructs an array of uniformly distributed random numbers whose values lie between the given minimum and maximum values.
(Inherited from NMathFunctions.)
ArrayOfRandomNumbers(Int32, Double, Double, Int32)
Constructs an array of uniformly distributed random numbers whose values lie between the given minimum and maximum values.
(Inherited from NMathFunctions.)
Beta
Returns the value of the beta function at a given value.
Binomial
Returns the binomial coefficient ("n choose m"), the number of ways of picking m unordered outcomes from n possibilities.
BinomialLn
Returns the natural log of the binomial coefficient ("n choose m"), the number of ways of picking m unordered outcomes from n possibilities.
CentralMoment(array<Double>[]()[][], Int32)
Calculates the specified central moment about the mean for the the given data.
CentralMoment(array<Int32>[]()[][], Int32)
Calculates the specified central moment about the mean for the the given data.
CentralMoment(DoubleVector, Int32)
Calculates the specified central moment about the mean for the the given data.
CentralMoment(IDFColumn, Int32)
Calculates the specified central moment about the mean for the the given data.
CorrelatedRandomInputs(DoubleMatrix, DoubleMatrix)
Accepts a set of input varaibles, each stored as a row in a matrix, and constructs a corresponding matrix of input variable values whose Spearmans rank correlation matrix is approximately equal to the specified correlation matrix. The resulting correlated inputs with their marginal distributions intact. InputVariableCorrelator
CorrelatedRandomInputs(DoubleMatrix, DoubleSymmetricMatrix)
Accepts a set of input varaibles, each stored as a row in a matrix, and constructs a corresponding matrix of input variable values whose Spearmans rank correlation matrix is approximately equal to the specified correlation matrix. The resulting correlated inputs marginal distributions are the same as the original inputs. InputVariableCorrelator
CorrelatedRandomInputs(Int32, Double, RandomNumberGenerator, RandomNumberGenerator)
Creates two sequences of correlated random numbers using the specified random number generators. The created sequence's Spearman rank correlation will be approximately equal to the specified number.
Correlation(array<Double>[]()[][], array<Double>[]()[][])
Computes the Pearson correlation of two data sets.
Correlation(array<Int32>[]()[][], array<Int32>[]()[][])
Computes the Pearson correlation of two data sets.
Correlation(DoubleVector, DoubleVector)
Computes the Pearson correlation of two data sets.
Correlation(IDFColumn, IDFColumn)
Computes the Pearson correlation of two data sets.
CorrelationMatrix
Computes the Pearson correlation matrix for a set of random inputs. The random inputs are taken to be the columns of the input matrix. The symmetric, positive definite matrix whose i,j entry is the Spearman correlation coefficient between the inputs in column i and column j is computed and returned.
Count(array<Double>[]()[][])
Returns the number of elements in a data set.
Count(array<Int32>[]()[][])
Returns the number of elements in a data set.
Count(DoubleVector)
Returns the number of elements in a data set.
Count(IDFColumn)
Returns the number of elements in a data set.
CountIf(array<Double>[]()[][], StatsFunctions..::..LogicalDoubleFunction) Obsolete.
Calculates how many elements in an array return true when a logical function is applied.
CountIf(array<Double>[]()[][], Func<(Of <<'(Double, Boolean>)>>))
Calculates how many elements in an array return true when a logical function is applied.
CountIf(array<Int32>[]()[][], StatsFunctions..::..LogicalDoubleFunction) Obsolete.
Calculates how many elements in an array return true when a logical function is applied.
CountIf(array<Int32>[]()[][], StatsFunctions..::..LogicalIntFunction) Obsolete.
Calculates how many elements in an array return true when a logical function is applied.
CountIf(array<Int32>[]()[][], Func<(Of <<'(Double, Boolean>)>>))
Calculates how many elements in an array return true when a logical function is applied.
CountIf(array<Int32>[]()[][], Func<(Of <<'(Int32, Boolean>)>>))
Calculates how many elements in an array return true when a logical function is applied.
CountIf(DoubleVector, StatsFunctions..::..LogicalDoubleFunction) Obsolete.
Calculates how many elements in a vector return true when a logical function is applied.
CountIf(DoubleVector, Func<(Of <<'(Double, Boolean>)>>))
Calculates how many elements in a vector return true when a logical function is applied.
CountIf(IDFColumn, StatsFunctions..::..LogicalDoubleFunction) Obsolete.
Calculates how many elements in a column return true when a logical function is applied.
CountIf(IDFColumn, StatsFunctions..::..LogicalIntFunction) Obsolete.
Calculates how many elements in a column return true when a logical function is applied.
CountIf(IDFColumn, StatsFunctions..::..LogicalStringFunction) Obsolete.
Calculates how many elements in a column return true when a logical function is applied.
CountIf(IDFColumn, Func<(Of <<'(Double, Boolean>)>>))
Calculates how many elements in a column return true when a logical function is applied.
CountIf(IDFColumn, Func<(Of <<'(Int32, Boolean>)>>))
Calculates how many elements in a column return true when a logical function is applied.
CountIf(IDFColumn, Func<(Of <<'(String, Boolean>)>>))
Calculates how many elements in a column return true when a logical function is applied.
Counts(array<Double>[]()[][])
Returns a dictionary in which the keys are the unique elements in a given data set and the values are how many times they occur.
Counts(array<Int32>[]()[][])
Returns a dictionary in which the keys are the unique elements in a given data set and the values are how many times they occur.
Counts(DoubleVector)
Returns a dictionary in which the keys are the unique elements in a given data set and the values are how many times they occur.
Counts(IDFColumn)
Returns a dictionary in which the keys are the unique elements in a given data set and the values are how many times they occur.
Covariance(array<Double>[]()[][], array<Double>[]()[][])
Computes the covariance of two data sets.
Covariance(array<Int32>[]()[][], array<Int32>[]()[][])
Computes the covariance of two data sets.
Covariance(DoubleVector, DoubleVector)
Computes the covariance of two data sets.
Covariance(FloatVector, FloatVector)
Computes the covariance of two data sets.
Covariance(IDFColumn, IDFColumn)
Computes the covariance of two data sets.
Covariance(array<Double>[]()[][], array<Double>[]()[][], BiasType)
Computes the covariance of two data sets using the specified bias.
Covariance(array<Int32>[]()[][], array<Int32>[]()[][], BiasType)
Computes the covariance of two data sets using the specified bias.
Covariance(DoubleVector, DoubleVector, BiasType)
Computes the covariance of two data sets using the specified bias.
Covariance(FloatVector, FloatVector, BiasType)
Computes the covariance of two data sets using the specified bias.
Covariance(IDFColumn, IDFColumn, BiasType)
Computes the covariance of two data sets using the specified bias.
CovarianceMatrix(DoubleMatrix)
Creates a square, symmetric matrix containing the variances and covariances of the columns in data.
CovarianceMatrix(FloatMatrix)
Creates a square, symmetric matrix containing the variances and covariances of the columns in data.
CovarianceMatrix(DoubleMatrix, BiasType)
Creates a square, symmetric matrix containing the variances and covariances of the columns in data.
CovarianceMatrix(DoubleMatrix, Boolean)
Creates a square, symmetric matrix containing the variances and covariances of the columns in data.
CovarianceMatrix(FloatMatrix, BiasType)
Creates a square, symmetric matrix containing the variances and covariances of the columns in data.
CovarianceMatrix(FloatMatrix, Boolean)
Creates a square, symmetric matrix containing the variances and covariances of the columns in data.
CovarianceMatrix(DoubleMatrix, BiasType, Boolean)
Creates a square, symmetric matrix containing the variances and covariances of the columns in data.
CovarianceMatrix(FloatMatrix, BiasType, Boolean)
Creates a square, symmetric matrix containing the variances and covariances of the columns in data.
CovarianceMatrixMemoized(DoubleMatrix, BiasType)
Creates a square, symmetric matrix containing the variances and covariances of the columns in data. Intermediate calculations are memoized.
CovarianceMatrixMemoized(FloatMatrix, BiasType)
Creates a square, symmetric matrix containing the variances and covariances of the columns in data. Intermediate calculations are memoized.
Cronbach(DoubleMatrix)
Standardized Cronbach alpha test for reliability.
Cronbach(FloatMatrix)
Standardized Cronbach alpha test for reliability.
Decile(array<Double>[]()[][], Int32)
Calculates the specified decile of the given data.
Decile(array<Int32>[]()[][], Int32)
Calculates the specified decile of the given data.
Decile(DoubleVector, Int32)
Calculates the specified decile of the given data.
Decile(IDFColumn, Int32)
Calculates the specified decile of the given data.
DurbinWatson(array<Double>[]()[][])
Calculates the Durbin-Watson statistic of the given data.
DurbinWatson(array<Int32>[]()[][])
Calculates the Durbin-Watson statistic of the given data.
DurbinWatson(DoubleVector)
Calculates the Durbin-Watson statistic of the given data.
DurbinWatson(IDFColumn)
Calculates the Durbin-Watson statistic of the given data.
Equals
Determines whether the specified Object is equal to the current Object.
(Inherited from Object.)
Factorial
Returns n!, the number of ways that n objects can be permuted.
FactorialLn
Returns the natural log factorial of n, ln( n! ).
Fisher
Calculates the Fisher transformation of the given value.
FisherInv
Calculates the inverse Fisher transformation of the given value.
FishersExactTest(array<Int32,2>[,](,)[,][,])
Returns the one-tailed Fisher's Exact Test p-value for the specified 2 x 2 contingency table and alternative hypothesis.
FishersExactTest(DataFrame)
Returns the one-tailed Fisher's Exact Test p-value for the specified 2 x 2 contingency table and alternative hypothesis.
FishersExactTest(array<Int32,2>[,](,)[,][,], HypothesisType)
Returns the Fisher's Exact Test p-value for the specified 2 x 2 contingency table and alternative hypothesis.
FishersExactTest(DataFrame, HypothesisType)
Returns the Fisher's Exact Test p-value for the specified 2 x 2 contingency table and alternative hypothesis.
FishersExactTest(Int32, Int32, Int32, Int32)
Returns the one-tailed Fisher's Exact Test p-value for the specified 2 x 2 contingency table.
FishersExactTest(Int32, Int32, Int32, Int32, HypothesisType)
Returns the Fisher's Exact Test p-value for the specified 2 x 2 contingency table and alternative hypothesis.
GammaLn
Returns the log of the gamma function at a given value.
GeometricMean(array<Double>[]()[][])
Calculates the geometric mean of the given data.
GeometricMean(array<Int32>[]()[][])
Calculates the geometric mean of the given data.
GeometricMean(DoubleVector)
Calculates the geometric mean of the given data.
GeometricMean(IDFColumn)
Calculates the geometric mean of the given data.
GetHashCode
Serves as a hash function for a particular type.
(Inherited from Object.)
GetType
Gets the type of the current instance.
(Inherited from Object.)
HarmonicMean(array<Double>[]()[][])
Calculates the harmonic mean of the given data.
HarmonicMean(array<Int32>[]()[][])
Calculates the harmonic mean of the given data.
HarmonicMean(DoubleVector)
Calculates the harmonic mean of the given data.
HarmonicMean(IDFColumn)
Calculates the harmonic mean of the given data.
If(array<Double>[]()[][], StatsFunctions..::..LogicalDoubleFunction) Obsolete.
Creates an array of boolean values determined by applying a logical function to the elements of an array.
If(array<Double>[]()[][], Func<(Of <<'(Double, Boolean>)>>))
Creates an array of boolean values determined by applying a logical function to the elements of an array.
If(array<Int32>[]()[][], StatsFunctions..::..LogicalDoubleFunction) Obsolete.
Creates an array of boolean values determined by applying a logical function to the elements of an array.
If(array<Int32>[]()[][], StatsFunctions..::..LogicalIntFunction) Obsolete.
Creates an array of boolean values determined by applying a logical function to the elements of an array.
If(array<Int32>[]()[][], Func<(Of <<'(Double, Boolean>)>>))
Creates an array of boolean values determined by applying a logical function to the elements of an array.
If(array<Int32>[]()[][], Func<(Of <<'(Int32, Boolean>)>>))
Creates an array of boolean values determined by applying a logical function to the elements of an array.
If(DoubleVector, StatsFunctions..::..LogicalDoubleFunction) Obsolete.
Creates an array of boolean values determined by applying a logical function to the elements of a vector.
If(DoubleVector, Func<(Of <<'(Double, Boolean>)>>))
Creates an array of boolean values determined by applying a logical function to the elements of a vector.
If(IDFColumn, StatsFunctions..::..LogicalDoubleFunction) Obsolete.
Creates an array of boolean values determined by applying a logical function to the elements of a column.
If(IDFColumn, StatsFunctions..::..LogicalIntFunction) Obsolete.
Creates an array of boolean values determined by applying a logical function to the elements of a column.
If(IDFColumn, StatsFunctions..::..LogicalStringFunction) Obsolete.
Creates an array of boolean values determined by applying a logical function to the elements of a column.
If(IDFColumn, Func<(Of <<'(Double, Boolean>)>>))
Creates an array of boolean values determined by applying a logical function to the elements of a column.
If(IDFColumn, Func<(Of <<'(Int32, Boolean>)>>))
Creates an array of boolean values determined by applying a logical function to the elements of a column.
If(IDFColumn, Func<(Of <<'(String, Boolean>)>>))
Creates an array of boolean values determined by applying a logical function to the elements of a column.
If(array<Double>[]()[][], StatsFunctions..::..LogicalDoubleFunction, Double) Obsolete.
Creates a new array by applying a logical function to the elements of an array. Elements in the original array that return true are set to the given true value in the new array; elements that return false are not changed.
If(array<Double>[]()[][], Func<(Of <<'(Double, Boolean>)>>), Double)
Creates a new array by applying a logical function to the elements of an array. Elements in the original array that return true are set to the given true value in the new array; elements that return false are not changed.
If(array<Int32>[]()[][], StatsFunctions..::..LogicalDoubleFunction, Double) Obsolete.
Creates a new array by applying a logical function to the elements of an array. Elements in the original array that return true are set to the given true value in the new array; elements that return false are not changed.
If(array<Int32>[]()[][], StatsFunctions..::..LogicalIntFunction, Int32) Obsolete.
Creates a new array by applying a logical function to the elements of an array. Elements in the original array that return true are set to the given true value in the new array; elements that return false are not changed.
If(array<Int32>[]()[][], Func<(Of <<'(Double, Boolean>)>>), Double)
Creates a new array by applying a logical function to the elements of an array. Elements in the original array that return true are set to the given true value in the new array; elements that return false are not changed.
If(array<Int32>[]()[][], Func<(Of <<'(Int32, Boolean>)>>), Int32)
Creates a new array by applying a logical function to the elements of an array. Elements in the original array that return true are set to the given true value in the new array; elements that return false are not changed.
If(DoubleVector, StatsFunctions..::..LogicalDoubleFunction, Double) Obsolete.
Creates a new vector by applying a logical function to the elements of a vector. Elements in the original vector that return true are set to the given true value in the new vector; elements that return false are not changed.
If(DoubleVector, Func<(Of <<'(Double, Boolean>)>>), Double)
Creates a new vector by applying a logical function to the elements of a vector. Elements in the original vector that return true are set to the given true value in the new vector; elements that return false are not changed.
If(IDFColumn, StatsFunctions..::..LogicalDoubleFunction, Double) Obsolete.
Creates a new column by applying a logical function to the elements of a column. Elements in the original column that return true are set to the given true value in the new column; elements that return false are not changed.
If(IDFColumn, StatsFunctions..::..LogicalIntFunction, Int32) Obsolete.
Creates a new column by applying a logical function to the elements of a column. Elements in the original column that return true are set to the given true value in the new column; elements that return false are not changed.
If(IDFColumn, StatsFunctions..::..LogicalStringFunction, String) Obsolete.
Creates a new column by applying a logical function to the elements of a column. Elements in the original column that return true are set to the given true value in the new column; elements that return false are not changed.
If(IDFColumn, Func<(Of <<'(Double, Boolean>)>>), Double)
Creates a new column by applying a logical function to the elements of a column. Elements in the original column that return true are set to the given true value in the new column; elements that return false are not changed.
If(IDFColumn, Func<(Of <<'(Int32, Boolean>)>>), Int32)
Creates a new column by applying a logical function to the elements of a column. Elements in the original column that return true are set to the given true value in the new column; elements that return false are not changed.
If(IDFColumn, Func<(Of <<'(String, Boolean>)>>), String)
Creates a new column by applying a logical function to the elements of a column. Elements in the original column that return true are set to the given true value in the new column; elements that return false are not changed.
If(array<Double>[]()[][], StatsFunctions..::..LogicalDoubleFunction, Double, Double) Obsolete.
Creates a new array by applying a logical function to the elements of an array. Elements in the original array that return true are set to the given true value in the new array; elements that return false are set to the given false value.
If(array<Double>[]()[][], Func<(Of <<'(Double, Boolean>)>>), Double, Double)
Creates a new array by applying a logical function to the elements of an array. Elements in the original array that return true are set to the given true value in the new array; elements that return false are set to the given false value.
If(array<Int32>[]()[][], StatsFunctions..::..LogicalDoubleFunction, Double, Double) Obsolete.
Creates a new array by applying a logical function to the elements of an array. Elements in the original array that return true are set to the given true value in the new array; elements that return false are set to the given false value.
If(array<Int32>[]()[][], StatsFunctions..::..LogicalIntFunction, Int32, Int32) Obsolete.
Creates a new array by applying a logical function to the elements of an array. Elements in the original array that return true are set to the given true value in the new array; elements that return false are set to the given false value.
If(array<Int32>[]()[][], Func<(Of <<'(Double, Boolean>)>>), Double, Double)
Creates a new array by applying a logical function to the elements of an array. Elements in the original array that return true are set to the given true value in the new array; elements that return false are set to the given false value.
If(array<Int32>[]()[][], Func<(Of <<'(Int32, Boolean>)>>), Int32, Int32)
Creates a new array by applying a logical function to the elements of an array. Elements in the original array that return true are set to the given true value in the new array; elements that return false are set to the given false value.
If(DoubleVector, StatsFunctions..::..LogicalDoubleFunction, Double, Double) Obsolete.
Creates a new vector by applying a logical function to the elements of a vector. Elements in the original vector that return true are set to the given true value in the new vector; elements that return false are set to the given false value.
If(DoubleVector, Func<(Of <<'(Double, Boolean>)>>), Double, Double)
Creates a new vector by applying a logical function to the elements of a vector. Elements in the original vector that return true are set to the given true value in the new vector; elements that return false are set to the given false value.
If(IDFColumn, StatsFunctions..::..LogicalDoubleFunction, Double, Double) Obsolete.
Creates a new column by applying a logical function to the elements of a column. Elements in the original column that return true are set to the given true value in the new column; elements that return false are set to the given false value.
If(IDFColumn, StatsFunctions..::..LogicalIntFunction, Int32, Int32) Obsolete.
Creates a new column by applying a logical function to the elements of a column. Elements in the original column that return true are set to the given true value in the new column; elements that return false are set to the given false value.
If(IDFColumn, StatsFunctions..::..LogicalStringFunction, String, String) Obsolete.
Creates a new column by applying a logical function to the elements of a column. Elements in the original column that return true are set to the given true value in the new column; elements that return false are set to the given false value.
If(IDFColumn, Func<(Of <<'(Double, Boolean>)>>), Double, Double)
Creates a new column by applying a logical function to the elements of a column. Elements in the original column that return true are set to the given true value in the new column; elements that return false are set to the given false value.
If(IDFColumn, Func<(Of <<'(Int32, Boolean>)>>), Int32, Int32)
Creates a new column by applying a logical function to the elements of a column. Elements in the original column that return true are set to the given true value in the new column; elements that return false are set to the given false value.
If(IDFColumn, Func<(Of <<'(String, Boolean>)>>), String, String)
Creates a new column by applying a logical function to the elements of a column. Elements in the original column that return true are set to the given true value in the new column; elements that return false are set to the given false value.
IncompleteBeta
Returns the value of the incomplete beta function at a given value.
IncompleteGamma(Double, Double)
Returns the incomplete gamma function at a given value.
IncompleteGamma(Double, Double, Boolean)
Returns the incomplete gamma function P(a,x) or its complement 1.0 - P(a,x) for for the parameter a and value x.
IncompleteGammaComplement
Returns the complement of the incomplete gamma function, P(a,x), at a given value. The complement of the incomplete gamma function P(a,x) is defined to be 1.0 - P(a,x)
InitialCenters
Chooses the specified number of initial centers from the given data matrix, for clustering algorithms such as k-means.
InterquartileRange(array<Double>[]()[][])
Calculates the interquartile range of the given data, the difference between the median of the highest half and the median of the lowest half.
InterquartileRange(array<Int32>[]()[][])
Calculates the interquartile range of the given data, the difference between the median of the highest half and the median of the lowest half.
InterquartileRange(DoubleVector)
Calculates the interquartile range of the given data, the difference between the median of the highest half and the median of the lowest half.
InterquartileRange(IDFColumn)
Calculates the interquartile range of the given data, the difference between the median of the highest half and the median of the lowest half.
Kurtosis(array<Double>[]()[][])
Calculates the biased kurtosis of the given data.
Kurtosis(array<Int32>[]()[][])
Calculates the biased kurtosis of the given data.
Kurtosis(DoubleVector)
Calculates the biased kurtosis of the given data.
Kurtosis(IDFColumn)
Calculates the biased kurtosis of the given data.
Kurtosis(array<Double>[]()[][], BiasType)
Calculates the kurtosis of the given data, using the specified bias type.
Kurtosis(array<Int32>[]()[][], BiasType)
Calculates the kurtosis of the given data, using the specified bias type.
Kurtosis(DoubleVector, BiasType)
Calculates the kurtosis of the given data, using the specified bias type.
Kurtosis(IDFColumn, BiasType)
Calculates the kurtosis of the given data, using the specified bias type.
MaxAbsIndex(array<Double>[]()[][])
Calculates the index of the maximum absolute value in the given data set.
MaxAbsIndex(array<Int32>[]()[][])
Calculates the index of the maximum absolute value in the given data set.
MaxAbsIndex(IDFColumn)
Calculates the index of the maximum absolute value in the given data set.
MaxAbsValue(array<Double>[]()[][])
Calculates the maximum absolute value in the given data set.
MaxAbsValue(array<Int32>[]()[][])
Calculates the maximum absolute value in the given data set.
MaxAbsValue(IDFColumn)
Calculates the maximum absolute value in the given data set.
MaxIndex(array<Double>[]()[][])
Calculates the index of the maximum value in the given data set.
MaxIndex(array<Int32>[]()[][])
Calculates the index of the maximum value in the given data set.
MaxIndex(IDFColumn)
Calculates the index of the maximum value in the given data set.
MaxValue(array<Double>[]()[][])
Calculates the maximum value in the given data set.
MaxValue(array<Int32>[]()[][])
Calculates the maximum value in the given data set.
MaxValue(IDFColumn)
Calculates the maximum value in the given data set.
Mean(array<Double>[]()[][])
Calculates the arithmetic mean of the given data.
Mean(array<Int32>[]()[][])
Calculates the arithmetic mean of the given data.
Mean(IDFColumn)
Calculates the arithmetic mean of the given data.
MeanDeviation(array<Double>[]()[][])
Calculates the average absolute deviation of the given data.
MeanDeviation(array<Int32>[]()[][])
Calculates the average absolute deviation of the given data.
MeanDeviation(DoubleVector)
Calculates the average absolute deviation of the given data.
MeanDeviation(IDFColumn)
Calculates the average absolute deviation of the given data.
Median
Returns the median of the given data.
MedianDeviationFromMean(array<Double>[]()[][])
Calculates the median of the absolute deviations from the mean.
MedianDeviationFromMean(array<Int32>[]()[][])
Calculates the median of the absolute deviations from the mean.
MedianDeviationFromMean(DoubleVector)
Calculates the median of the absolute deviations from the mean.
MedianDeviationFromMean(IDFColumn)
Calculates the median of the absolute deviations from the mean.
MedianDeviationFromMedian(array<Double>[]()[][])
Calculates the median of the absolute deviations from the median.
MedianDeviationFromMedian(array<Int32>[]()[][])
Calculates the median of the absolute deviations from the median.
MedianDeviationFromMedian(array<Single>[]()[][])
Calculates the median of the absolute deviations from the median.
MedianDeviationFromMedian(DoubleVector)
Calculates the median of the absolute deviations from the median.
MedianDeviationFromMedian(FloatVector)
Calculates the median of the absolute deviations from the median.
MedianDeviationFromMedian(IDFColumn)
Calculates the median of the absolute deviations from the median.
MinAbsIndex(array<Double>[]()[][])
Calculates the index of the minimum absolute value in the given data set.
MinAbsIndex(array<Int32>[]()[][])
Calculates the index of the minimum absolute value in the given data set.
MinAbsIndex(IDFColumn)
Calculates the index of the minimum absolute value in the given data set.
MinAbsValue(array<Double>[]()[][])
Calculates the minimum absolute value in the given data set.
MinAbsValue(array<Int32>[]()[][])
Calculates the minimum absolute value in the given data set.
MinAbsValue(IDFColumn)
Calculates the minimum absolute value in the given data set.
MinIndex(array<Double>[]()[][])
Calculates the index of the minimum value in the given data set.
MinIndex(array<Int32>[]()[][])
Calculates the index of the minimum value in the given data set.
MinIndex(IDFColumn)
Calculates the index of the minimum value in the given data set.
MinValue(array<Double>[]()[][])
Calculates the minimum value in the given data set.
MinValue(array<Int32>[]()[][])
Calculates the minimum value in the given data set.
MinValue(IDFColumn)
Calculates the minimum value in the given data set.
Mode(array<Double>[]()[][])
Determines the most common element in a data set.
Mode(array<Int32>[]()[][])
Determines the most common element in a data set.
Mode(DoubleVector)
Determines the most common element in a data set.
Mode(IDFColumn)
Determines the most common element in a data set.
NaNCentralMoment(array<Double>[]()[][], Int32)
Calculates the specified central moment about the mean for the the given data, excluding NaN values.
NaNCentralMoment(DoubleVector, Int32)
Calculates the specified central moment about the mean for the the given data, excluding NaN values.
NaNCentralMoment(IDFColumn, Int32)
Calculates the specified central moment about the mean for the the given data, excluding missing values.
NaNCheck(array<Double>[]()[][])
Checks whether a data set contains any NaN values.
NaNCheck(DoubleVector)
Checks whether a data set contains any NaN values.
NaNCheck(IDFColumn)
Checks whether a data set contains any missing values.
NaNCorrelation(array<Double>[]()[][], array<Double>[]()[][])
Computes the Pearson correlation of two data sets, excluding pairs where either value is missing.
NaNCorrelation(array<Double>[]()[][], array<Int32>[]()[][])
Computes the Pearson correlation of two data sets, excluding pairs where either value is missing.
NaNCorrelation(array<Int32>[]()[][], array<Double>[]()[][])
Computes the Pearson correlation of two data sets, excluding pairs where either value is missing.
NaNCorrelation(DoubleVector, DoubleVector)
Computes the Pearson correlation of two data sets, excluding pairs where either value is missing.
NaNCorrelation(IDFColumn, IDFColumn)
Computes the Pearson correlation of two data sets, excluding pairs where either value is missing.
NaNCount(array<Double>[]()[][])
Returns the number of elements in a data set, excluding NaN values.
NaNCount(DoubleVector)
Returns the number of elements in a data set, excluding NaN values.
NaNCount(IDFColumn)
Returns the number of elements in a data set, excluding missing values.
NaNCountIf(array<Double>[]()[][], StatsFunctions..::..LogicalDoubleFunction) Obsolete.
Calculates how many elements in an array return true when a logical function is applied to the elements that are not NaN.
NaNCountIf(array<Double>[]()[][], Func<(Of <<'(Double, Boolean>)>>))
Calculates how many elements in an array return true when a logical function is applied to the elements that are not NaN.
NaNCountIf(DoubleVector, StatsFunctions..::..LogicalDoubleFunction) Obsolete.
Calculates how many elements in a vector return true when a logical function is applied to the elements that are not NaN.
NaNCountIf(DoubleVector, Func<(Of <<'(Double, Boolean>)>>))
Calculates how many elements in a vector return true when a logical function is applied to the elements that are not NaN.
NaNCountIf(IDFColumn, StatsFunctions..::..LogicalDoubleFunction) Obsolete.
Calculates how many elements in a column return true when a logical function is applied to the elements that are not missing.
NaNCountIf(IDFColumn, StatsFunctions..::..LogicalIntFunction) Obsolete.
Calculates how many elements in a column return true when a logical function is applied to values that are not missing.
NaNCountIf(IDFColumn, StatsFunctions..::..LogicalStringFunction) Obsolete.
Calculates how many elements in a column return true when a logical function is applied to the elements that are not missing.
NaNCountIf(IDFColumn, Func<(Of <<'(Double, Boolean>)>>))
Calculates how many elements in a column return true when a logical function is applied to the elements that are not missing.
NaNCountIf(IDFColumn, Func<(Of <<'(Int32, Boolean>)>>))
Calculates how many elements in a column return true when a logical function is applied to values that are not missing.
NaNCountIf(IDFColumn, Func<(Of <<'(String, Boolean>)>>))
Calculates how many elements in a column return true when a logical function is applied to the elements that are not missing.
NaNCovariance(array<Double>[]()[][], array<Double>[]()[][])
Computes the covariance of two data sets, excluding pairs where either value is missing.
NaNCovariance(DoubleVector, DoubleVector)
Computes the covariance of two data sets, excluding pairs where either value is missing.
NaNCovariance(IDFColumn, IDFColumn)
Computes the covariance of two data sets, excluding pairs where either value is missing.
NaNCovariance(array<Double>[]()[][], array<Double>[]()[][], BiasType)
Computes the covariance of two data sets using the specified bias, excluding pairs where either value is missing.
NaNCovariance(DoubleVector, DoubleVector, BiasType)
Computes the covariance of two data sets using the specified bias, excluding pairs where either value is missing.
NaNCovariance(IDFColumn, IDFColumn, BiasType)
Computes the covariance of two data sets using the specified bias, excluding pairs where either value is missing.
NaNDurbinWatson(array<Double>[]()[][])
Calculates the Durbin-Watson statistic of the given data, excluding NaN values.
NaNDurbinWatson(DoubleVector)
Calculates the Durbin-Watson statistic of the given data, excluding NaN values.
NaNDurbinWatson(IDFColumn)
Calculates the Durbin-Watson statistic of the given data, excluding missing values.
NaNGeometricMean(array<Double>[]()[][])
Calculates the geometric mean of the given data, excluding NaN values.
NaNGeometricMean(DoubleVector)
Calculates the geometric mean of the given data, excluding NaN values.
NaNGeometricMean(IDFColumn)
Calculates the geometric mean of the given data, excluding missing values.
NaNHarmonicMean(array<Double>[]()[][])
Calculates the harmonic mean of the given data, excluding NaN values.
NaNHarmonicMean(DoubleVector)
Calculates the harmonic mean of the given data, excluding NaN values.
NaNHarmonicMean(IDFColumn)
Calculates the harmonic mean of the given data, excluding missing values.
NaNIf(array<Double>[]()[][], StatsFunctions..::..LogicalDoubleFunction) Obsolete.
Creates an array of boolean values determined by applying a logical function to the elements of an array that are not NaN.
NaNIf(array<Double>[]()[][], Func<(Of <<'(Double, Boolean>)>>))
Creates an array of boolean values determined by applying a logical function to the elements of an array that are not NaN.
NaNIf(DoubleVector, StatsFunctions..::..LogicalDoubleFunction) Obsolete.
Creates an array of boolean values determined by applying a logical function to the elements of a vector that are not NaN.
NaNIf(DoubleVector, Func<(Of <<'(Double, Boolean>)>>))
Creates an array of boolean values determined by applying a logical function to the elements of a vector that are not NaN.
NaNIf(IDFColumn, StatsFunctions..::..LogicalDoubleFunction) Obsolete.
Creates an array of boolean values determined by applying a logical function to the elements of a column that are not missing.
NaNIf(IDFColumn, StatsFunctions..::..LogicalIntFunction) Obsolete.
Creates an array of boolean values determined by applying a logical function to the elements of a column that are not missing.
NaNIf(IDFColumn, StatsFunctions..::..LogicalStringFunction) Obsolete.
Creates an array of boolean values determined by applying a logical function to the elements of a column that are not missing.
NaNIf(IDFColumn, Func<(Of <<'(Double, Boolean>)>>))
Creates an array of boolean values determined by applying a logical function to the elements of a column that are not missing.
NaNIf(IDFColumn, Func<(Of <<'(Int32, Boolean>)>>))
Creates an array of boolean values determined by applying a logical function to the elements of a column that are not missing.
NaNIf(IDFColumn, Func<(Of <<'(String, Boolean>)>>))
Creates an array of boolean values determined by applying a logical function to the elements of a column that are not missing.
NaNKurtosis(array<Double>[]()[][])
Calculates the biased kurtosis of the given data, excluding NaN values.
NaNKurtosis(DoubleVector)
Calculates the biased kurtosis of the given data, excluding NaN values.
NaNKurtosis(IDFColumn)
Calculates the biased kurtosis of the given data, excluding missing values.
NaNKurtosis(array<Double>[]()[][], BiasType)
Calculates the kurtosis of the given data, using the specified bias type and excluding NaN values.
NaNKurtosis(DoubleVector, BiasType)
Calculates the kurtosis of the given data, using the specified bias type and excluding NaN values.
NaNKurtosis(IDFColumn, BiasType)
Calculates the kurtosis of the given data, using the specified bias type and excluding missing values.
NaNMaxAbsIndex(array<Double>[]()[][])
Calculates the index of the maximum absolute value in the given data set, excluding NaN values.
NaNMaxAbsIndex(DoubleVector)
Calculates the index of the maximum absolute value in the given data set, excluding NaN values.
NaNMaxAbsIndex(IDFColumn)
Calculates the index of the maximum absolute value in the given data set, excluding missing values.
NaNMaxAbsValue(array<Double>[]()[][])
Calculates the maximum absolute value in the given data set, excluding NaN values.
NaNMaxAbsValue(DoubleVector)
Calculates the maximum absolute value in the given data set, excluding NaN values.
NaNMaxAbsValue(IDFColumn)
Calculates the maximum absolute value in the given data set, excluding missing values.
NaNMaxIndex(array<Double>[]()[][])
Calculates the index of the maximum value in the given data set, excluding NaN values.
NaNMaxIndex(IDFColumn)
Calculates the index of the maximum value in the given data set, excluding missing values.
NaNMaxValue(array<Double>[]()[][])
Calculates the maximum value in the given data set, excluding NaN values.
NaNMaxValue(IDFColumn)
Calculates the maximum value in the given data set, excluding missing values.
NaNMean(array<Double>[]()[][])
Calculates the arithmetic mean of the given data, excluding NaN values.
NaNMean(IDFColumn)
Calculates the arithmetic mean of the given data, excluding missing values.
NaNMeanDeviation(array<Double>[]()[][])
Calculates the average absolute deviation of the given data, excluding NaN values.
NaNMeanDeviation(DoubleVector)
Calculates the average absolute deviation of the given data, excluding NaN values.
NaNMeanDeviation(IDFColumn)
Calculates the average absolute deviation of the given data, excluding missing values.
NaNMedian
Calculates the median value of column elements that are not equal to NaN.
NaNMinAbsIndex(array<Double>[]()[][])
Calculates the index of the minimum absolute value in the given data set, excluding NaN values.
NaNMinAbsIndex(DoubleVector)
Calculates the index of the minimum absolute value in the given data set, excluding NaN values.
NaNMinAbsIndex(IDFColumn)
Calculates the index of the minimum absolute value in the given data set, excluding missing values.
NaNMinAbsValue(array<Double>[]()[][])
Calculates the minimum absolute value in the given data set, excluding NaN values.
NaNMinAbsValue(DoubleVector)
Calculates the minimum absolute value in the given data set, excluding NaN values.
NaNMinAbsValue(IDFColumn)
Calculates the minimum absolute value in the given data set, excluding missing values.
NaNMinIndex(array<Double>[]()[][])
Calculates the index of the minimum value in the given data set, excluding NaN values.
NaNMinIndex(IDFColumn)
Calculates the index of the minimum value in the given data set, excluding missing values.
NaNMinValue(array<Double>[]()[][])
Calculates the minimum value in the given data set, excluding NaN values.
NaNMinValue(IDFColumn)
Calculates the minimum value in the given data set, excluding missing values.
NaNMode(array<Double>[]()[][])
Determines the most common element in a data set, excluding NaN values.
NaNMode(DoubleVector)
Determines the most common element in a data set, excluding NaN values.
NaNMode(IDFColumn)
Determines the most common element in a data set, excluding missing values.
NaNRemove(array<Double>[]()[][])
Creates a copy of a data set with NaN values removed.
NaNRemove(DoubleVector)
Creates a copy of a data set with NaN values removed.
NaNRemove(IDFColumn)
Creates a copy of a data set with missing values removed.
NaNRemoveCols(DataFrame)
Creates a copy of the data frame with only those columns that do not contain NaN values.
NaNRemoveCols(DoubleMatrix)
Creates a copy of the matrix with only those columns that do not contain NaN values.
NaNRemoveRows(DataFrame)
Creates a copy of the data frame with only those rows that do not contain NaN values.
NaNRemoveRows(DoubleMatrix)
Creates a copy of the matrix with only those rows that do not contain NaN values.
NaNSkewness(array<Double>[]()[][])
Calculates the biased skewness, a measure of the symmetry of the data, of the elements in a data set. NaN values are excluded.
NaNSkewness(DoubleVector)
Calculates the biased skewness, a measure of the symmetry of the data, of the elements in a data set. NaN values are excluded.
NaNSkewness(IDFColumn)
Calculates the biased skewness, a measure of the symmetry of the data, of the elements in a data set. Missing values are excluded.
NaNSkewness(array<Double>[]()[][], BiasType)
Calculates the skewness, a measure of the symmetry of the data, of the the elements in a data set using the given bias type. NaN values are excluded.
NaNSkewness(DoubleVector, BiasType)
Calculates the skewness, a measure of the symmetry of the data, of the the elements in a data set using the given bias type. NaN values are excluded.
NaNSkewness(IDFColumn, BiasType)
Calculates the skewness, a measure of the symmetry of the data, of the the elements in a data set using the given bias type. Missing values are excluded.
NaNStandardDeviation(array<Double>[]()[][])
Calculates the biased standard deviation of the elements in the given data set, excluding NaN values.
NaNStandardDeviation(DoubleVector)
Calculates the biased standard deviation of the elements in the given data set, excluding NaN values.
NaNStandardDeviation(IDFColumn)
Calculates the biased standard deviation of the elements in the given data set, excluding missing values.
NaNStandardDeviation(array<Double>[]()[][], BiasType)
Calculates the biased standard deviation of the elements in the given data set, using the specified bias and excluding NaN values.
NaNStandardDeviation(DoubleVector, BiasType)
Calculates the biased standard deviation of the elements in the given data set, using the specified bias and excluding NaN values.
NaNStandardDeviation(IDFColumn, BiasType)
Calculates the biased standard deviation of the elements in the given data set, using the specified bias and excluding missing values.
NaNSum(array<Double>[]()[][])
Calculates the sum of the elements in the given data set that are not NaN.
NaNSum(IDFColumn)
Calculates the sum of the elements in the given data set excluding missing values.
NaNSumIf(array<Double>[]()[][], StatsFunctions..::..LogicalDoubleFunction) Obsolete.
Calculates the sum of the elements in an array that are not NaN that return true when a given logical function is applied.
NaNSumIf(array<Double>[]()[][], Func<(Of <<'(Double, Boolean>)>>))
Calculates the sum of the elements in an array that are not NaN that return true when a given logical function is applied.
NaNSumIf(DoubleVector, StatsFunctions..::..LogicalDoubleFunction) Obsolete.
Calculates the sum of the elements in a vector that are not NaN that return true when a given logical function is applied.
NaNSumIf(DoubleVector, Func<(Of <<'(Double, Boolean>)>>))
Calculates the sum of the elements in a vector that are not NaN that return true when a given logical function is applied.
NaNSumIf(IDFColumn, StatsFunctions..::..LogicalDoubleFunction) Obsolete.
Calculates the sum of the elements in a column that are not missing that return true when a given logical function is applied.
NaNSumIf(IDFColumn, StatsFunctions..::..LogicalIntFunction) Obsolete.
Calculates the sum of the elements in a column that return true when a given logical function is applied to values that are not missing.
NaNSumIf(IDFColumn, Func<(Of <<'(Double, Boolean>)>>))
Calculates the sum of the elements in a column that are not missing that return true when a given logical function is applied.
NaNSumIf(IDFColumn, Func<(Of <<'(Int32, Boolean>)>>))
Calculates the sum of the elements in a column that return true when a given logical function is applied to values that are not missing.
NaNSumIf(array<Double>[]()[][], StatsFunctions..::..LogicalDoubleFunction, array<Double>[]()[][]) Obsolete.
Calculates the sum of elements in one array based on evaluating a logical function on corresponding elements in another array that are not NaN.
NaNSumIf(array<Double>[]()[][], Func<(Of <<'(Double, Boolean>)>>), array<Double>[]()[][])
Calculates the sum of elements in one array based on evaluating a logical function on corresponding elements in another array that are not NaN.
NaNSumIf(DoubleVector, StatsFunctions..::..LogicalDoubleFunction, DoubleVector) Obsolete.
Calculates the sum of elements in one vector based on evaluating a logical function on corresponding elements in another vector that are not NaN.
NaNSumIf(DoubleVector, Func<(Of <<'(Double, Boolean>)>>), DoubleVector)
Calculates the sum of elements in one vector based on evaluating a logical function on corresponding elements in another vector that are not NaN.
NaNSumIf(IDFColumn, StatsFunctions..::..LogicalDoubleFunction, IDFColumn) Obsolete.
Calculates the sum of elements in one column that are not missing based on evaluating a logical function on corresponding elements in another column.
NaNSumIf(IDFColumn, StatsFunctions..::..LogicalIntFunction, IDFColumn) Obsolete.
Calculates the sum of elements in one column that are not missing based on evaluating a logical function on corresponding elements in another column.
NaNSumIf(IDFColumn, Func<(Of <<'(Double, Boolean>)>>), IDFColumn)
Calculates the sum of elements in one column that are not missing based on evaluating a logical function on corresponding elements in another column.
NaNSumIf(IDFColumn, Func<(Of <<'(Int32, Boolean>)>>), IDFColumn)
Calculates the sum of elements in one column that are not missing based on evaluating a logical function on corresponding elements in another column.
NaNSumOfSquaredErrors(array<Double>[]()[][])
Calculates the sum of squared errors (SSE) of the elements in the given data set, excluding NaN values.
NaNSumOfSquaredErrors(DoubleVector)
Calculates the sum of squared errors (SSE) of the elements in the given data set, excluding NaN values.
NaNSumOfSquaredErrors(IDFColumn)
Calculates the sum of squared errors (SSE) of the elements in the given data set, excluding missing values.
NaNVariance(array<Double>[]()[][])
Calculates the variance of the given data, excluding NaN values.
NaNVariance(IDFColumn)
Calculates the variance of the given data, excluding missing values.
NaNVariance(array<Double>[]()[][], BiasType)
Calculates the variance of the given data, using the specified bias type and excluding NaN values.
NaNVariance(DoubleVector, BiasType)
Calculates the variance of the given data, using the specified bias type and excluding NaN values.
NaNVariance(IDFColumn, BiasType)
Calculates the variance of the given data, using the specified bias type and excluding missing values.
NaNVonNeumannRatio(array<Double>[]()[][])
Calculates the Von Neumann ratio of the given data, excluding NaN values.
NaNVonNeumannRatio(DoubleVector)
Calculates the Von Neumann ratio of the given data, excluding NaN values.
NaNVonNeumannRatio(IDFColumn)
Calculates the Von Neumann ratio of the given data, excluding missing values.
Percentile(array<Double>[]()[][], Double)
Calculates the nth percentile of the elements in a data set.
Percentile(array<Int32>[]()[][], Double)
Calculates the nth percentile of the elements in a data set.
Percentile(DoubleVector, Double)
Calculates the nth percentile of the elements in a data set.
Percentile(IDFColumn, Double)
Calculates the nth percentile of the elements in a data set.
PercentileRank(array<Double>[]()[][], Double)
Calculates the percentile in which a given value would fall, if it were in the given data set.
PercentileRank(array<Int32>[]()[][], Double)
Calculates the percentile in which a given value would fall, if it were in the given data set.
PercentileRank(DoubleVector, Double)
Calculates the percentile in which a given value would fall, if it were in the given data set.
PercentileRank(IDFColumn, Double)
Calculates the percentile in which a given value would fall, if it were in the given data set.
Quartile(array<Double>[]()[][], Int32)
Calculates the specified quartile of the elements in a data set.
Quartile(array<Int32>[]()[][], Int32)
Calculates the specified quartile of the elements in a data set.
Quartile(DoubleVector, Int32)
Calculates the specified quartile of the elements in a data set.
Quartile(IDFColumn, Int32)
Calculates the specified quartile of the elements in a data set.
Rank(array<Double>[]()[][], Double)
Calculates the rank of a value within a given data set using ascending order.
Rank(array<Int32>[]()[][], Double)
Calculates the rank of a value within a given data set using ascending order.
Rank(DoubleVector, Double)
Calculates the rank of a value within a given data set using ascending order.
Rank(IDFColumn, Double)
Calculates the rank of the value within a given data set using the specified order.
Rank(array<Double>[]()[][], Double, SortingType)
Calculates the rank of the value within a given data set using the specified order.
Rank(array<Int32>[]()[][], Double, SortingType)
Calculates the rank of the value within a given data set using the specified order.
Rank(DoubleVector, Double, SortingType)
Calculates the rank of a value within a given data set using ascending order.
Rank(IDFColumn, Double, SortingType)
Calculates the rank of the value within a given data set using the specified order.
Ranks(array<Double>[]()[][])
Returns the ranks of each element in a data set using ascending sort order.
Ranks(array<Int32>[]()[][])
Returns the ranks of each element in a data set using ascending sort order.
Ranks(DoubleVector)
Returns the ranks of each element in a data set using ascending sort order.
Ranks(IDFColumn)
Returns the ranks of each element in a data set using ascending sort order.
Ranks(array<Double>[]()[][], SortingType)
Returns the ranks of each element in a data set using the specified sort order.
Ranks(array<Int32>[]()[][], SortingType)
Returns the ranks of each element in a data set using the specified sort order.
Ranks(DoubleVector, SortingType)
Returns the ranks of each element in a data set using the specified sort order.
Ranks(IDFColumn, SortingType)
Returns the ranks of each element in a data set using the specified sort order.
RMS(array<Double>[]()[][])
Calculates the root mean square of the given data.
RMS(array<Int32>[]()[][])
Calculates the root mean square of the given data.
RMS(DoubleVector)
Calculates the root mean square of the given data.
RMS(IDFColumn)
Calculates the root mean square of the given data.
Skewness(array<Double>[]()[][])
Calculates the biased skewness, a measure of the symmetry of the data, of the elements in a data set.
Skewness(array<Int32>[]()[][])
Calculates the biased skewness, a measure of the symmetry of the data, of the elements in a data set.
Skewness(DoubleVector)
Calculates the biased skewness, a measure of the symmetry of the data, of the elements in a data set.
Skewness(IDFColumn)
Calculates the biased skewness, a measure of the symmetry of the data, of the elements in a data set.
Skewness(array<Double>[]()[][], BiasType)
Calculates the skewness, a measure of the symmetry of the data, of the the elements in a data set using the given bias type.
Skewness(array<Int32>[]()[][], BiasType)
Calculates the skewness, a measure of the symmetry of the data, of the the elements in a data set using the given bias type.
Skewness(DoubleVector, BiasType)
Calculates the skewness, a measure of the symmetry of the data, of the the elements in a data set using the given bias type.
Skewness(IDFColumn, BiasType)
Calculates the skewness, a measure of the symmetry of the data, of the the elements in a data set using the given bias type.
Sort(array<Double>[]()[][])
Returns a sorted copy of the given data in ascending order.
Sort(array<Int32>[]()[][])
Returns a sorted copy of the given data in ascending order.
Sort(IDFColumn)
Returns a sorted copy of the given data in ascending order.
Sort(array<Double>[]()[][], SortingType)
Returns a sorted copy of the given data in the specified order.
Sort(array<Int32>[]()[][], SortingType)
Returns a sorted copy of the given data in the specified order.
Sort(DoubleVector, SortingType)
Returns a sorted copy of the given data in the specified order.
Sort(IDFColumn, SortingType)
Returns a sorted copy of the given data in the specified order.
Spearmans(DoubleMatrix)
Calculates Spearman's Rho for the given data.
Spearmans(array<Double>[]()[][], array<Double>[]()[][])
Calculates Spearman's Rho for the given data sets.
Spearmans(array<Int32>[]()[][], array<Int32>[]()[][])
Calculates Spearman's Rho for the given data sets.
Spearmans(DoubleVector, DoubleVector)
Calculates Spearman's Rho for the given data sets.
Spearmans(IDFColumn, IDFColumn)
Calculates Spearman's Rho for the given data sets.
StandardDeviation(array<Double>[]()[][])
Calculates the biased standard deviation of the elements in the given data set.
StandardDeviation(array<Int32>[]()[][])
Calculates the biased standard deviation of the elements in the given data set.
StandardDeviation(DoubleVector)
Calculates the biased standard deviation of the elements in the given data set.
StandardDeviation(IDFColumn)
Calculates the biased standard deviation of the elements in the given data set.
StandardDeviation(array<Double>[]()[][], BiasType)
Calculates the biased standard deviation of the elements in the given data set, using the specified bias.
StandardDeviation(array<Int32>[]()[][], BiasType)
Calculates the biased standard deviation of the elements in the given data set, using the specified bias.
StandardDeviation(DoubleVector, BiasType)
Calculates the biased standard deviation of the elements in the given data set, using the specified bias.
StandardDeviation(IDFColumn, BiasType)
Calculates the biased standard deviation of the elements in the given data set, using the specified bias.
Sum(array<Double>[]()[][])
Calculates the sum of the elements in the given data set.
Sum(array<Int32>[]()[][])
Calculates the sum of the elements in the given data set.
Sum(IDFColumn)
Calculates the sum of the elements in the given data set.
SumIf(array<Double>[]()[][], StatsFunctions..::..LogicalDoubleFunction) Obsolete.
Calculates the sum of the elements in an array that return true when a given logical function is applied.
SumIf(array<Double>[]()[][], Func<(Of <<'(Double, Boolean>)>>))
Calculates the sum of the elements in an array that return true when a given logical function is applied.
SumIf(array<Int32>[]()[][], StatsFunctions..::..LogicalDoubleFunction) Obsolete.
Calculates the sum of the elements in an array that return true when a given logical function is applied.
SumIf(array<Int32>[]()[][], StatsFunctions..::..LogicalIntFunction) Obsolete.
Calculates the sum of the elements in an array that return true when a given logical function is applied.
SumIf(array<Int32>[]()[][], Func<(Of <<'(Double, Boolean>)>>))
Calculates the sum of the elements in an array that return true when a given logical function is applied.
SumIf(array<Int32>[]()[][], Func<(Of <<'(Int32, Boolean>)>>))
Calculates the sum of the elements in an array that return true when a given logical function is applied.
SumIf(DoubleVector, StatsFunctions..::..LogicalDoubleFunction) Obsolete.
Calculates the sum of the elements in a vector that return true when a given logical function is applied.
SumIf(DoubleVector, Func<(Of <<'(Double, Boolean>)>>))
Calculates the sum of the elements in a vector that return true when a given logical function is applied.
SumIf(IDFColumn, StatsFunctions..::..LogicalDoubleFunction) Obsolete.
Calculates the sum of the elements in a column that return true when a given logical function is applied.
SumIf(IDFColumn, StatsFunctions..::..LogicalIntFunction) Obsolete.
Calculates the sum of the elements in a column that return true when a given logical function is applied.
SumIf(IDFColumn, Func<(Of <<'(Double, Boolean>)>>))
Calculates the sum of the elements in a column that return true when a given logical function is applied.
SumIf(IDFColumn, Func<(Of <<'(Int32, Boolean>)>>))
Calculates the sum of the elements in a column that return true when a given logical function is applied.
SumIf(array<Double>[]()[][], StatsFunctions..::..LogicalDoubleFunction, array<Double>[]()[][]) Obsolete.
Calculates the sum of elements in one array based on evaluating a logical function on corresponding elements in another data.
SumIf(array<Double>[]()[][], StatsFunctions..::..LogicalDoubleFunction, array<Int32>[]()[][]) Obsolete.
Calculates the sum of elements in one array based on evaluating a logical function on corresponding elements in another data.
SumIf(array<Double>[]()[][], Func<(Of <<'(Double, Boolean>)>>), array<Double>[]()[][])
Calculates the sum of elements in one array based on evaluating a logical function on corresponding elements in another data.
SumIf(array<Double>[]()[][], Func<(Of <<'(Double, Boolean>)>>), array<Int32>[]()[][])
Calculates the sum of elements in one array based on evaluating a logical function on corresponding elements in another data.
SumIf(array<Int32>[]()[][], StatsFunctions..::..LogicalDoubleFunction, array<Double>[]()[][]) Obsolete.
Calculates the sum of elements in one array based on evaluating a logical function on corresponding elements in another data.
SumIf(array<Int32>[]()[][], StatsFunctions..::..LogicalDoubleFunction, array<Int32>[]()[][]) Obsolete.
Calculates the sum of elements in one array based on evaluating a logical function on corresponding elements in another data.
SumIf(array<Int32>[]()[][], StatsFunctions..::..LogicalIntFunction, array<Double>[]()[][]) Obsolete.
Calculates the sum of elements in one array based on evaluating a logical function on corresponding elements in another data.
SumIf(array<Int32>[]()[][], StatsFunctions..::..LogicalIntFunction, array<Int32>[]()[][]) Obsolete.
Calculates the sum of elements in one array based on evaluating a logical function on corresponding elements in another data.
SumIf(array<Int32>[]()[][], Func<(Of <<'(Double, Boolean>)>>), array<Double>[]()[][])
Calculates the sum of elements in one array based on evaluating a logical function on corresponding elements in another data.
SumIf(array<Int32>[]()[][], Func<(Of <<'(Double, Boolean>)>>), array<Int32>[]()[][])
Calculates the sum of elements in one array based on evaluating a logical function on corresponding elements in another data.
SumIf(array<Int32>[]()[][], Func<(Of <<'(Int32, Boolean>)>>), array<Double>[]()[][])
Calculates the sum of elements in one array based on evaluating a logical function on corresponding elements in another data.
SumIf(array<Int32>[]()[][], Func<(Of <<'(Int32, Boolean>)>>), array<Int32>[]()[][])
Calculates the sum of elements in one array based on evaluating a logical function on corresponding elements in another data.
SumIf(DoubleVector, StatsFunctions..::..LogicalDoubleFunction, DoubleVector) Obsolete.
Calculates the sum of elements in one vector based on evaluating a logical function on corresponding elements in another vector.
SumIf(DoubleVector, Func<(Of <<'(Double, Boolean>)>>), DoubleVector)
Calculates the sum of elements in one vector based on evaluating a logical function on corresponding elements in another vector.
SumIf(IDFColumn, StatsFunctions..::..LogicalDoubleFunction, IDFColumn) Obsolete.
Calculates the sum of elements in one column based on evaluating a logical function on corresponding elements in another data.
SumIf(IDFColumn, StatsFunctions..::..LogicalIntFunction, IDFColumn) Obsolete.
Calculates the sum of elements in one column based on evaluating a logical function on corresponding elements in another data.
SumIf(IDFColumn, Func<(Of <<'(Double, Boolean>)>>), IDFColumn)
Calculates the sum of elements in one column based on evaluating a logical function on corresponding elements in another data.
SumIf(IDFColumn, Func<(Of <<'(Int32, Boolean>)>>), IDFColumn)
Calculates the sum of elements in one column based on evaluating a logical function on corresponding elements in another data.
SumOfSquaredErrors(array<Double>[]()[][])
Calculates the sum of squared errors (SSE) of the elements in the given data set.
SumOfSquaredErrors(array<Int32>[]()[][])
Calculates the sum of squared errors (SSE) of the elements in the given data set.
SumOfSquaredErrors(DoubleVector)
Calculates the sum of squared errors (SSE) of the elements in the given data set.
SumOfSquaredErrors(IDFColumn)
Calculates the sum of squared errors (SSE) of the elements in the given data set.
ToString
Returns a string that represents the current object.
(Inherited from Object.)
TrimmedMean(array<Double>[]()[][], Double)
Calculates the mean of the given data after the specified trimming.
TrimmedMean(array<Int32>[]()[][], Double)
Calculates the mean of the given data after the specified trimming.
TrimmedMean(DoubleVector, Double)
Calculates the mean of the given data after the specified trimming.
TrimmedMean(IDFColumn, Double)
Calculates the mean of the given data after the specified trimming.
VanDerWaerdenScores(Int32)
Returns a vector of Van Der Waerden scores. Van der Waerden scores are the quantiles of a standard normal distribution. These scores are also known as quantile normal scores. The scores are computed from the standard normal distribution with mean 0 and variance 1.
VanDerWaerdenScores(Int32, Double, Double)
Returns a vector of Van Der Waerden scores. Van der Waerden scores are the quantiles of a standard normal distribution. These scores are also known as quantile normal scores.
Variance(array<Double>[]()[][])
Calculates the variance of the given data.
Variance(array<Int32>[]()[][])
Calculates the variance of the given data.
Variance(IDFColumn)
Calculates the variance of the given data.
Variance(array<Double>[]()[][], BiasType)
Calculates the variance of the given data, using the specified bias type.
Variance(array<Int32>[]()[][], BiasType)
Calculates the variance of the given data, using the specified bias type.
Variance(DoubleVector, BiasType)
Calculates the variance of the given data, using the specified bias type.
Variance(FloatVector, BiasType)
Calculates the variance of the given data, using the specified bias type.
Variance(IDFColumn, BiasType)
Calculates the variance of the given data, using the specified bias type.
VonNeumannRatio(array<Double>[]()[][])
Calculates the Von Neumann ratio of the given data.
VonNeumannRatio(array<Int32>[]()[][])
Calculates the Von Neumann ratio of the given data.
VonNeumannRatio(DoubleVector)
Calculates the Von Neumann ratio of the given data.
VonNeumannRatio(IDFColumn)
Calculates the Von Neumann ratio of the given data.
WeightedMean(array<Double>[]()[][], array<Double>[]()[][])
Calculates the weighted average of the given data.
WeightedMean(array<Double>[]()[][], array<Int32>[]()[][])
Calculates the weighted average of the given data.
WeightedMean(array<Int32>[]()[][], array<Double>[]()[][])
Calculates the weighted average of the given data.
WeightedMean(array<Int32>[]()[][], array<Int32>[]()[][])
Calculates the weighted average of the given data.
WeightedMean(DoubleVector, DoubleVector)
Calculates the weighted average of the given data.
WeightedMean(IDFColumn, IDFColumn)
Calculates the weighted average of the given data.

# Fields

NameDescription
NMATH_STATS_VERSION
NMath Stats version.