NMath Reference Guide

## Center |

Classes

Class | Description | |
---|---|---|

AbstractRandomNumberStream | Class AbstractRandomNumberStream may be used to construct a RandomNumberStream object which uses a user defined function for the generation of uniformly distributed random numbers in the interval (0, 1). | |

ActiveSetLineSearchSQP | Class ActiveSetLineSearchSQP solves nonlinear programming problems using a Sequential Quadratic Programming (SQP) iterative algorithm. | |

ActiveSetLineSearchSQPOptions | Contains the options available to the ActiveSetLineSearchSQP Nonlinear Program Solver (NLP). | |

ActiveSetQPSolver | Class ActiveSetQPSolver solves convex quadratic programming (QP) problems. | |

AnalysisFunctions | Obsolete.No longer used. Please use NMathFunctions. | |

AnnealingHistory | Class AnnealingHistory encapsulates all of the data generated during a series of steps through an annealing schedule. | |

AnnealingHistoryStep | Class AnnealingHistory.Step encapsulates all of the data associated with a step in an AnnealingHistory. | |

AnnealingMinimizer | Class AnnealingMinimizer minimizes a multivariable function using the simulated annealing method. | |

AnnealingScheduleBase | Class AnnealingScheduleBase is the abstract base class for annealing schedules. | |

AnovaRegressionFactorParam | Class AnovaRegressionFactorParam provides information about a regression parameter associated with a specific level of an ANOVA factor. | |

AnovaRegressionInteractionParam | Class AnovaRegressionInteractionParam provides information about a regression parameter associated with the interaction between the level of one ANOVA factor and the level of another ANOVA factor. | |

AnovaRegressionParameter | Class AnovaRegressionParameter provides information about a regression parameter used to perform an analysis of variance by class TwoWayAnova. | |

AnovaRegressionSubjectParam | Class AnovaRegressionSubjectParam provides information about a regression parameter associated with a subject dummy regression variable. | |

ArnoldiEigenvalueOptions | Options for solving symmetric eigenvalue problems using the shift and invert spectral transformation. | |

ArnoldiEigenvalueSolution | Class contianing solution information for an Arnoldi iteration eigenvalue problem. | |

ArnoldiEigenvalueSolver | Solve the generalized eigenvalue problem Ax = Mx(lambda) Where A is sparse symmetric and M is sparse symmetric semi position definite. Solve is accomplished using a shift and invert spectral transformation and implicitly restarted Arnoldi iteration. | |

BairstowRootFinder | Class implementing Bairstows method finds roots for polynomials of degree greater than 3. | |

BairstowRootFinderSolveResult | Class encapsulating information about the result of applying Bairstows method to a polynomial. | |

BetaDistribution | Class BetaDistribution represents the beta probability distribution. | |

BinomialDistribution | Class BinomialDistribution represents the discrete probability distribution of obtaining exactly n successes in N trials where the probability of success on each trial is P. | |

BoundedMultiVariableFunctionFitterM | Class MultiVariableFunctionFitter< M > fits a parameterized multivariable function to a set of points where the parameters have inequality constraints. | |

BoundedOneVariableFunctionFitterM | Class BoundedOneVariableFunctionFitter fits a parameterized one variable function to a set of points, where the functions parameters are constrained by upper and lower bounds. | |

BoundedVariableProblem | Abstract class for representing a problem with bounded variables. | |

BoxCox | Class for computing the Box-Cox power tranformations defined for a set of data points, {yi}, and parameter value lambda by yi(lambda) = (yi^lambda - 1)/lambda. In addition methods for computing the corresponding log-likelihood function and the value of lambda which maximizes it are provided. | |

BoxCoxTransformation | Class BoxCoxTransformation performs a Box-Cox power transformation, which can be used to make non-normal data resemble normally-distributed data. | |

Bracket | Class Bracket searches in the downhill direction for two points that bracket a minimum of a univariate function. | |

BrentMinimizer | Class BrentMinimizer uses Brent's Method to minimize a function within an interval known to contain a minimum. | |

CentralDifferenceHessianUpdater | Class CentralDifferenceHessianUpdater updates the Hessian of the Lagrangian while solving a nonlinear programming problem using a Sequential Quadratic Programming algorithm. | |

ChiSquareDistribution | Class ChiSquareDistribution represents the chi-square probability distribution. | |

ClampedCubicSpline | Class ClampedCubicSpline represents a function determined by tabulated values. Function values are calculated using clamped cubic spline interpolation. | |

ClosedInterval | Class ClosedInterval represents a numeric interval with inclusive lower and upper bounds. | |

ClosedOpenInterval | Class ClosedOpenInterval represents a numeric interval with an inclusive lower bound and an exclusive upper bound. | |

ClusterAnalysis | Class ClusterAnalysis perform hierarchical cluster analysis. | |

ClusterSet | Class ClusterSet represents a collection of objects assigned to a finite number of clusters. | |

CompressedSparseRowT | Class CompressedSparseRow stores general sparse matrix data in compressed row format. | |

ConjugateGradientMinimizer | Class ConjugateGradientMinimizer minimizes a multivariable function using the Polak-Ribiere variant of the Fletcher-Reeves conjugate gradient method. | |

ConnectivityMatrix | Class ConnectivityMatrix represents a symmetric matrix of double-precision floating point values. | |

ConstantSQPStepSize | Class ConstantSQPStepSize computes the step size for a Sequential Quadratic Programming solver. Simply returns a constant step size regardless of iteration values. | |

ConstrainedLeastSquares | Class for solver constrained least squares problems. | |

ConstrainedLeastSquaresProblem | Class that encapsulates a constrained least squares problem. | |

ConstrainedOptimizer | Base class for linear Microsoft Solver Foundation based linear solvers. | |

ConstrainedOptimizerORTools | Base class for linear Google OR-Tools based linear solvers. | |

Constraint | Class Constraint represents a constraint in a constrained optimization problem. | |

ConvolutionBase | Abstract base class for all concrete convolution classes. | |

CORegressionCalculation | Class CORegressionCalculation computes linear regression parameters by the method of least squares using a complete orthogonal decomposition. | |

CorrelationBase | Abstract base class for all concrete correlation classes. | |

CorrelationFilter | The base correlation filter which provides basic correlation services. | |

CubicSpline | Class CublicSpline represents a function whose values are determined by cubic spline interpolation between tabulated values. | |

CurveFitDataSet | Class for aggregating data used in curve fitting. Contains x-values with their corresponding y-values along with with weights to be applied to the y-values during curve fitting. | |

CustomAnnealingSchedule | Class CustomAnnealingSchedule encapsulates a series of iterations and temperatures. | |

DampedBFGSHessianUpdater | Class DampedBFGSHessianUpdater updates the value of the Lagrangian Hessian based on iterate values using a quasi-Newton approximation. | |

DataFrame | Class DataFrame represents a two-dimensional data object consisting of a list of columns of the same length. | |

DBrentMinimizer | Class DBrentMinimizer minimizes a function using Brent's method as well as the first derivative. | |

DFBoolColumn | Class DFBoolColumn represents a column of logical data in a data frame. | |

DFColumn | Abstract base class for data frame column types. | |

DFDateTimeColumn | Class DFDataTimeColumn represents a column of DataTime data in a data frame. | |

DFGenericColumn | Class DFGenericColumn represents a column of generic data in a data frame. | |

DFIntColumn | Class DFIntColumn represents a column of integer data in a data frame. | |

DFNumericColumn | Class DFNumericColumn represents a column of numeric data in a data frame. | |

DFStringColumn | Class DFStringColumn represents a column of string data in a data frame. | |

DiscreteDataIntegrator | Integrates discrete data for either unit-spaced or arbitrarily spaced data. | |

DiscreteWaveletTransform | This abstract class represents all discrete wavelet transforms objects. | |

Distance | Class Distance provides functions for computing the distance between objects. | |

DistancePowerDistance | Class PowerDistance compute the power distance between two vectors. | |

Double1DConvolution | Double1DConvolution represents a 1D convolution, with a specified kernel and data length. | |

Double1DCorrelation | Double1DCorrelation represents a 1D correlation, with a specified kernel and data length. | |

DoubleBandFact | Class DoubleBandFact represents the factorization of a banded matrix of double-precision floating point numbers. | |

DoubleBandMatrix | Class DoubleBandMatrix represents a banded matrix of double-precision floating point values. A banded matrix is a matrix that has all its non-zero entries near the diagonal. | |

DoubleBisquareWeightingFunction | Class DoubleBisquareWeightingFunction implements the bisquare weighting function for Iteratively Reweighted Least Squares (IRLS). | |

DoubleCholeskyLeastSq | Class DoubleCholeskyLeastSq solves least square problems by using the Cholesky factorization to solve the normal equations. | |

DoubleComplex1DConvolution | DoubleComplex1DConvolution represents a 1D convolution, with a specified kernel and data length. | |

DoubleComplex1DCorrelation | DoubleComplex1DCorrelation represents a 1D correlation, with a specified kernel and data length. | |

DoubleComplexBackward1DFFT | DoubleComplexBackward1DFFT represents the backward discrete fourier transform of a 1D complex signal vector. | |

DoubleComplexBackward2DFFT | DoubleComplexBackward2DFFT represents the backward discrete fourier transform of a 2D complex signal vector. | |

DoubleComplexBandFact | Class DoubleComplexBandFact represents the factorization of a banded matrix of complex double-precision floating point numbers. | |

DoubleComplexBandMatrix | Class DoubleComplexBandMatrix represents a banded matrix of double-precision complex numbers. A banded matrix is a matrix that has all its non-zero entries near the diagonal. | |

DoubleComplexCholeskyLeastSq | Class DoubleComplexCholeskyLeastSq solves least square problems by using the Cholesky factorization to solve the normal equations. | |

DoubleComplexCsrSparseMatrix | Class DoubleComplexCsrSparseMatrix stores a general sparse matrix using Compressed Row (CSR) Storage format. | |

DoubleComplexDataBlock | The DoubleComplexDataBlock struct defines a contiguous subset of an array of DoubleComplex numbers. A DoubleComplexDataBlock instance contains a reference to an array and an offset into the array. | |

DoubleComplexEigDecomp | Class DoubleComplexEigDecomp computes the eigenvalues and left and right eigenvectors of a general matrix, with preliminary balancing. | |

DoubleComplexEigDecompServer | Class DoubleComplexEigDecompServer creates eigenvalue decompositions. A server instance can be configured to perform preliminary balancing, and to compute left eigenvectors, right eigenvectors, both, or neither. | |

DoubleComplexForward1DFFT | DoubleComplexForward1DFFT represents the forward discrete fourier transform of a 1D complex signal vector. | |

DoubleComplexForward2DFFT | DoubleComplexForward2DFFT represents the forward discrete fourier transform of a 2D complex signal vector. | |

DoubleComplexGSVDecomp | Class DoubleComplexGSVDecomp computes the generalized singular value decomposition (GSVD) of a pair of general rectangular matrices. | |

DoubleComplexGSVDecompServer | Class for serving up generalized singular value decompositions (GSVD) in the form of DoubleComplexGSVDecomp instances. | |

DoubleComplexLeastSquares | Class DoubleComplexLeastSquares computes the minimum-norm solution to a linear system Ax = y. | |

DoubleComplexLowerTriMatrix | Class DoubleComplexLowerTriMatrix represents a lower triangular matrix of double-precision complex numbers. A lower triangular matrix is a square matrix with all elements above the main diagonal equal to zero. | |

DoubleComplexLUFact | Class DoubleComplexLUFact represents the LU factorization of a matrix of DoubleComplex numbers. | |

DoubleComplexMatrix | Class DoubleComplexMatrix represents a general mathematical matrix class of DoubleComplex numbers. Methods are provided for performing algebraic operations, data manipulation, and slicing. | |

DoubleComplexQRDecomp | Class DoubleComplexQRDecomp represents the QR decomposition of a general matrix. | |

DoubleComplexQRDecompServer | Class DoubleComplexQRDecompServer allows control over how the pivoting is done in the creation of DoubleComplexQRDecomp objects. | |

DoubleComplexQRLeastSq | Class DoubleComplexQRLeastSq solves least squares problems by using a QR decomposition. | |

DoubleComplexSchurDecomp | Class DoubleComplexSchurDecomp represents the Schur decomposition of a general matrix. | |

DoubleComplexSparseFact | Class DoubleComplexSparseFact performs general sparse matrix factorizations. | |

DoubleComplexSparseVector | Class DoubleComplexSparseVector encapsulates a general sparse vector. | |

DoubleComplexSVDecomp | Class DoubleComplexSVDecomp represents the singular value decomposition (SVD) of a matrix. | |

DoubleComplexSVDecompServer | Class DoubleComplexSVDecompServer constructs instances of the DoubleComplexSVDecomp class. | |

DoubleComplexSVDLeastSq | Class DoubleComplexSVDLeastSq solves least squares problems by using a singular value decomposition. | |

DoubleComplexTriDiagFact | Class DoubleComplexTriDiagFact represents the LU factorization of a tridiagonal matrix of double-precision complex floating point numbers. | |

DoubleComplexTriDiagMatrix | Class DoubleComplexTriDiagMatrix represents a tridiagonal matrix of double-precision complex numbers. A tridiagonal matrix is a matrix which has all its non-zero entries on the main diagonal, the super diagonal, and the subdiagonal. | |

DoubleComplexUpperTriMatrix | Class DoubleComplexComplexUpperTriMatrix represents an upper triangular matrix of double-precision complex numbers. An upper triangular matrix is a square matrix with all elements below the main diagonal equal to zero. | |

DoubleComplexVector | Class DoubleComplexVector represents a mathematical vector of DoubleComplex numbers. | |

DoubleCOWeightedLeastSq | Class DoubleCOWeightedLeastSq solves weighted least squares problems by using a Complete Orthogonal (CO) decomposition technique. | |

DoubleCsrSparseMatrix | Class DoubleCsrSparseMatrix stores a general sparse matrix using Compressed Row (CSR) storage format. | |

DoubleDataBlock | The DoubleDataBlock struct defines a contiguous subset of an array of double-precision floating point numbers. A DoubleDataBlock instance contains a reference to an array and an offset into the array. | |

DoubleDWT | This class represents a double precision discrete wavelet transform. It supports both single step forward and reverse DWT's and multilevel signal deconstruction and reconstruction. Details thresholding at any level and threshold calculations are also supported. | |

DoubleEigDecomp | Class DoubleEigDecomp computes the eigenvalues and left and right eigenvectors of a general matrix, with preliminary balancing. | |

DoubleEigDecompServer | Class DoubleEigDecompServer creates eigenvalue decompositions. A server instance can be configured to perform preliminary balancing, and to compute left eigenvectors, right eigenvectors, both, or neither. | |

DoubleFactorAnalysisExtraction, Rotation |
Class C# DoubleFactorAnalysis | |

DoubleFairWeightingFunction | Class DoubleFairWeightingFunction implements the fair weighting function for Iteratively Reweighted Least Squares (IRLS). | |

DoubleForward1DFFT | DoubleForward1DFFT represents the forward discrete fourier transform of a 1D real signal vector. | |

DoubleForward2DFFT | DoubleForward2DFFT represents the forward discrete fourier transform of a 2D real signal vector. | |

DoubleFunctional | Class DoubleFunctional represents a double precision functional. | |

DoubleFunctionalDelegate | Class DoubleFunctionalDelegate wraps a functional delegate specified by a delegate in a DoubleFunctional object. | |

DoubleGeneral1DFFT | General 1D FFT class assuming the behavior of the provided FFT configuration instance. | |

DoubleGSVDecomp | Class DoubleGSVDecomp computes the generalized singular value decomposition (GSVD) of a pair of general rectangular matrices. | |

DoubleGSVDecompServer | Class for serving up generalized singular value decompositions (GSVD) in the form of DoubleGSVDecomp instances. | |

DoubleHermCsrSparseMatrix | Class DoubleHermCsrSparseMatrix stores a general sparse Hermitian matrix using the Compressed Row (CSR) storage format. | |

DoubleHermitianBandMatrix | Class DoubleHermitianBandMatrix represents an Hermitian banded matrix of double-precision floating point values. An Hermitian banded matrix is an Hermitian matrix that has all its non-zero entries near the diagonal. | |

DoubleHermitianEigDecomp | Class DoubleHermitianEigDecomp computes the eigenvalues and eigenvectors of a symmetrix matrix. | |

DoubleHermitianEigDecompServer | Class DoubleHermitianEigDecompServer creates eigenvalue decompositions. A server instance can be configured to compute eigenvalues only, or both eigenvalues and eigenvectors. In addition, the server can be configured to compute only the eigenvalues in a given range. A tolerance for the convergence of the algorithm may also be specified. | |

DoubleHermitianFact | Class DoubleHermitianFact represents the factorization of a Hermitian, matrix of complex double-precision floating point numbers. | |

DoubleHermitianMatrix | Class DoubleHermitianMatrix represents a matrix of double-precision floating point complex values. | |

DoubleHermitianPDBandFact | Class DoubleHermitianPDBandFact represents the factorization of a Hermitian, positive definite, banded matrix of complex double-precision floating point numbers. | |

DoubleHermitianPDFact | Class DoubleHermitianPDFact represents the Cholesky factorization of a Hermitian, positive definite, matrix of double-precision complex floating point numbers. In a Cholesky factorization a Hermitian, positive definite matrix A is factored as A = UU' where U is upper triangular and U' is the conjugate transpose of U. | |

DoubleHermPDTriDiagFact | Class DoubleHermPDTriDiagFact represents the LDL' factorization of a Hermitian, positive definite, tridiagonal matrix of complex double-precision floating point numbers. | |

DoubleIterativelyReweightedLeastSq | Class DoubleIterativelyReweightedLeastSq solves a least squares problems by iteratively applying a weighted least squares fit. | |

DoubleLeastSquares | Class DoubleLeastSquares computes the minimum-norm solution to a linear system Ax = y. | |

DoubleLeastSqWeightingFunction | Abstract base class for least squares weighting functions used in the Iteratively Reweighted Least Squares algorithm. | |

DoubleLowerTriMatrix | Class DoubleLowerTriMatrix represents a lower triangular matrix of double-precision floating point values. A lower triangular matrix is a square matrix with all elements above the main diagonal equal to zero. | |

DoubleLUFact | Class DoubleLUFact represents the LU factorization of a matrix of double-precision floating point numbers. | |

DoubleMatrix | Class DoubleMatrix represents a general mathematical matrix class of double-precision floating point numbers. Methods are provided for performing algebraic operations, data manipulation, and slicing. | |

DoubleMultiVariableFunction | Abstract class for representing a multi-variable function. | |

DoubleNonnegativeLeastSqResult | Class containing the results of a nonnegative least squares solve attempt. Double precision version. | |

DoubleNonnegativeLeastSquares | Class DoubleNonnegativeLeastSquares computes the minimum-norm solution to a linear system Ax = y subject to the constraint that all the elements, x[i], are nonnegative. | |

DoubleParameterizedDelegate | Class which creates a DoubleParameterizedFunction instance from delegates. | |

DoubleParameterizedFunction | Abstract class representing a parameterized function. | |

DoubleParameterizedFunctional | Abstract class representing a parameterized functional. | |

DoublePCA | Class DoublePCA performs a principal component analysis on a given double-precision data matrix, or data frame. | |

DoubleQRDecomp | Class DoubleQRDecomp represents the QR decomposition of a general matrix. | |

DoubleQRDecompServer | Class DoubleQRDecompServer allows control over how the pivoting is done in the creation of DoubleQRDecomp objects. | |

DoubleQRLeastSq | Class DoubleQRLeastSq solves least squares problems by using a QR decomposition. | |

DoubleRandomBetaDistribution | Class DoubleRandomBetaDistribution generates random numbers from a beta distribution. | |

DoubleRandomCauchyDistribution | Class DoubleRandomCauchyDistribution generates random numbers from a Cauchy distribution. | |

DoubleRandomExponentialDistribution | Class DoubleRandomExponentialDistribution generates random numbers from an exponential distribution. | |

DoubleRandomGammaDistribution | Class DoubleRandomGammaDistribution generates random numbers from a gamma distribution. | |

DoubleRandomGaussianDistribution | Class DoubleRandomGaussianDistribution generates random numbers from a Gaussian distribution. | |

DoubleRandomGumbelDistribution | Class DoubleRandomGumbelDistribution generates random numbers from a Gumbel distribution. | |

DoubleRandomLaplaceDistribution | Class DoubleRandomLaplaceDistribution generates random numbers from a Laplace distribution. | |

DoubleRandomLogNormalDistribution | Class DoubleRandomLogNormalDistribution generates random numbers from a lognormal distribution. | |

DoubleRandomRayleighDistribution | Class DoubleRandomRayleighDistribution generates random numbers from an Rayleigh distribution. | |

DoubleRandomUniformDistribution | Class DoubleRandomUniformDistribution generates random numbers uniformly distributed over an interval. | |

DoubleRandomWeibullDistribution | Class DoubleRandomWeibullDistribution generates random numbers from a Weibull distribution. | |

DoubleSchurDecomp | Class DoubleSchurDecomp represents the Schur decomposition of a general matrix. | |

DoubleSparseFact | Class DoubleSparseFact performs general sparse matrix factorizations. | |

DoubleSparseHermFact | Class DoubleSparseHermFact performs Hermitian sparse matrix factorizations. | |

DoubleSparseHermPDFact | Class DoubleSparseHermPDFact performs sparse Hermitian Positive Definite matrix factorizations. | |

DoubleSparseSymFact | Class DoubleSparseSymFact performs sparse symmetric matrix factorizations. | |

DoubleSparseSymPDFact | Class DoubleSparseSymPDFact performs sparse positive definite symmetric matrix factorizations. | |

DoubleSparseVector | Class DoubleSparseVector encapsulates a general sparse vector. | |

DoubleSVDecomp | Class DoubleSVDecomp represents the singular value decomposition (SVD) of a matrix. | |

DoubleSVDecompServer | Class DoubleSVDecompServer constructs instances of the DoubleSVDecomp class. | |

DoubleSVDLeastSq | Class DoubleSVDLeastSq solves least squares problems by using a singular value decomposition. | |

DoubleSWT | The stationary wavelet transform (SWT) is an advanced development of the discrete wavelet transfrom (DWT). The DWT lacks signal translation-invariance. By using an up and down sampling strategy, often refered to by its french name of "algorithme à trous", the SWT gains translation-invariance. | |

DoubleSymBandMatrix | Class DoubleSymBandMatrix represents a symmetric banded matrix of double-precision floating point values. A symmetric banded matrix is a symmetric matrix that has all its non-zero entries near the diagonal. | |

DoubleSymCsrSparseMatrix | Class DoubleSymCsrSparseMatrix stores a sparse symmetric matrix using the CompreSsed Row (CSR) storage format. | |

DoubleSymEigDecomp | Class DoubleSymEigDecomp computes the eigenvalues and eigenvectors of a symmetrix matrix. | |

DoubleSymEigDecompServer | Class DoubleSymEigDecompServer creates eigenvalue decompositions. A server instance can be configured to compute eigenvalues only, or both eigenvalues and eigenvectors. In addition, the server can be configured to compute only the eigenvalues in a given range. A tolerance for the convergence of the algorithm may also be specified. | |

DoubleSymFact | Class DoubleSymFact represents the factorization of a symmetric, matrix of double-precision floating point numbers. | |

DoubleSymmetric2DSignalReader | Provides symmetric complex conjugate signal unpacking services. Typically used for unpacking 2D FFT's of real signals. | |

DoubleSymmetricBackward1DFFT | DoubleSymmetricBackward1DFFT represents the backward discrete fourier transform of a 1D real signal vector, and inverses packed conjugate symmetric signals back to the real domain. | |

DoubleSymmetricMatrix | Class DoubleSymmetricMatrix represents a symmetric matrix of double-precision floating point values. | |

DoubleSymmetricSignalReader | Provides symmetric complex conjugate signal unpacking services. Typically used for unpacking 1D FFT's of real signals. | |

DoubleSymPDBandFact | Class DoubleSymPDBandFact represents the factorization of a symmetric, positive definite, banded matrix of double-precision floating point numbers. | |

DoubleSymPDFact | Class DoubleSymPDFact represents the Cholesky factorization of a symmetric, positive definite, matrix of double-precision floating point numbers. In a Cholesky factorization a symmetric, positive definite matrix A is factored as A = UU' where U is upper triangular and U' is the transpose of U. | |

DoubleSymPDTriDiagFact | Class DoubleSymPDTriDiagFact represents the LDL' factorization of a symmetric, positive definite, tridiagonal matrix of double-precision floating point numbers. | |

DoubleSymSemiPDFact | Given a real symmetric, positive semidefinite matrix A, class DoubleSymSemiPDFact performs a Cholesky factorization with complete pivoting. In the following ' denotes matrix transposition. The form of the factorization is: P'AP = U'U if upper is specified, and P'AP = LL' if lower is specified. where P is a permutation matrix, and U and L are upper and lower triangular matrices, respectively. The algorithm does not attempt to check if the matrix A is positive semidefinite. | |

DoubleTriDiagFact | Class DoubleTriDiagFact represents the LU factorization of a tridiagonal matrix of double-precision floating point numbers. | |

DoubleTriDiagMatrix | Class DoubleTriDiagMatrix represents a tridiagonal matrix of double-precision floating point values. A tridiagonal matrix is a matrix which has all its non-zero entries on the main diagonal, the super diagonal, and the subdiagonal. | |

DoubleUpperTriMatrix | Class DoubleUpperTriMatrix represents an upper triangular matrix of double-precision floating point values. An upper triangular matrix is a square matrix with all elements below the main diagonal equal to zero. | |

DoubleVector | Class DoubleVector represents a mathematical vector of double-precision floating point numbers. | |

DoubleVectorParameterizedDelegate | Class DoubleVectorParameterizedDelegate creates a DoubleParameterizedFunctional instance from delegates. | |

DoubleWavelet | This class represents a double precision wavelet. There are fives types of built in wavelets avaiable: Harr, Daubechies, Least Asymmetric, Best Localized, and Coiflet. User generated wavelets can be created by provided the low-pass decimation filter parameters in the constructor. | |

DownhillSimplexMinimizer | Class DownhillSimplexMinimizer minimizes a multivariable function using the downhill simplex method of Nelder and Mead. | |

DualSimplexSolver | Obsolete.Class DualSimplexSolver is a class for solving linear programming prolems using the dual simplex method. | |

DualSimplexSolverORTools | Class DualSimplexSolverORTools is a class for solving linear programming prolems using the dual simplex method. | |

DualSimplexSolverParams | Obsolete.Dual simplex algorithm parameters. | |

EqualityConstrainedQPProblem | Class representing an equality constrained Quadratic Programming problem. Minimize 0.5 * x'Hx + x'c Subject to Ax = b where x is a vector of unknows, H a symmetric matrix, and A matrix. | |

ExponentialDistribution | Class ExponentialDistribution represents the Exponential probability distribution. | |

Factor | Class Factor represents a categorical vector in which all elements are drawn from a finite number of factor levels. | |

FactorAnalysisCorrelationExtraction, Rotation | Class FactorAnalysisCorrelation performs a factor analysis on a set of case data using the correlation matrix and specified factor extraction and rotation algorithms. | |

FactorAnalysisCovarianceExtraction, Rotation | Class FactorAnalysisCovariance performs a factor analysis on a set of case data using the covariance matrix and specified factor extraction and rotation algorithms. | |

FDistribution | Class FDistribution represents the F probability distribution. | |

FFT2DBase | Abstract base class for all 2D discrete FFT transform classes. This class manages the setup and tear down of all discrete fourier resources. | |

FFTBase | Abstract base class for all 1D discrete FFT transform classes. This class manages the setup and tear down of all discrete fourier resources. | |

FFTConfiguration | FFTConfiguration contains all of the FFT configuration state to efficiently compute a FFT. This class is typically used in conjunction with the GeneralxDFFT set of classes to configure FFT's with offset and strided signal data. | |

FFTKernelException | Exception thrown when MKL or CUDA returns an error condition when computing a FFT | |

Float1DConvolution | Float1DConvolution represents a 1D convolution, with a specified kernel and data length. | |

Float1DCorrelation | Float1DCorrelation represents a 1D correlation, with a specified kernel and data length. | |

FloatBandFact | Class FloatBandFact represents the factorization of a banded matrix of single-precision floating point numbers. | |

FloatBandMatrix | Class FloatBandMatrix represents a banded matrix of single-precision floating point values. A banded matrix is a matrix that has all its non-zero entries near the diagonal. | |

FloatCholeskyLeastSq | Class FloatCholeskyLeastSq solves least square problems by using the Cholesky factorization to solve the normal equations. | |

FloatComplex1DConvolution | FloatComplex1DConvolution represents a 1D convolution, with a specified kernel and data length. | |

FloatComplex1DCorrelation | FloatComplex1DCorrelation represents a 1D correlation, with a specified kernel and data length. | |

FloatComplexBackward1DFFT | FloatComplexBackward1DFFT represents the backward discrete fourier transform of a 1D complex signal vector. | |

FloatComplexBackward2DFFT | FloatComplexBackward2DFFT represents the backward discrete fourier transform of a 2D complex signal vector. | |

FloatComplexBandFact | Class FloatComplexBandFact represents the factorization of a banded matrix of complex single-precision floating point numbers. | |

FloatComplexBandMatrix | Class FloatComplexBandMatrix represents a banded matrix of single-precision complex numbers. A banded matrix is a matrix that has all its non-zero entries near the diagonal. | |

FloatComplexCholeskyLeastSq | Class FloatComplexCholeskyLeastSq solves least square problems by using the Cholesky factorization to solve the normal equations. | |

FloatComplexCsrSparseMatrix | Class FloatComplexCsrSparseMatrix stores a general sparse matrix using Compressed Row (CSR) Storage format. | |

FloatComplexDataBlock | The FloatComplexDataBlock struct defines a contiguous subset of an array of FloatComplex numbers. A FloatComplexDataBlock instance contains a reference to an array and an offset into the array. | |

FloatComplexEigDecomp | Class FloatComplexEigDecomp computes the eigenvalues and left and right eigenvectors of a general matrix, with preliminary balancing. | |

FloatComplexEigDecompServer | Class FloatComplexEigDecompServer creates eigenvalue decompositions. A server instance can be configured to perform preliminary balancing, and to compute left eigenvectors, right eigenvectors, both, or neither. | |

FloatComplexForward1DFFT | FloatComplexForward1DFFT represents the forward discrete fourier transform of a 1D complex signal vector. | |

FloatComplexForward2DFFT | FloatComplexForward2DFFT represents the forward discrete fourier transform of a 2D complex signal vector. | |

FloatComplexGSVDecomp | Class FloatComplexGSVDecomp computes the generalized singular value decomposition (GSVD) of a pair of general rectangular matrices. | |

FloatComplexGSVDecompServer | Class for serving up generalized singular value decompositions (GSVD) in the form of FloatComplexGSVDecomp instances. | |

FloatComplexLeastSquares | Class FloatComplexLeastSquares computes the minimum-norm solution to a linear system Ax = y. | |

FloatComplexLowerTriMatrix | Class FloatComplexLowerTriMatrix represents a lower triangular matrix of single-precision complex numbers. A lower triangular matrix is a square matrix with all elements above the main diagonal equal to zero. | |

FloatComplexLUFact | Class FloatComplexFact represents the LU factorization of a matrix of FloatComplex numbers. | |

FloatComplexMatrix | Class FloatComplexMatrix represents a general mathematical matrix class of FloatComplex numbers. Methods are provided for performing algebraic operations, data manipulation, and slicing. | |

FloatComplexQRDecomp | Class FloatComplexQRDecomp represents the QR decomposition of a general matrix. | |

FloatComplexQRDecompServer | Class FloatComplexQRDecompServer allows control over how the pivoting is done in the creation of FloatComplexQRDecomp objects. | |

FloatComplexQRLeastSq | Class FloatComplexQRLeastSq solves least squares problems by using a QR decomposition. | |

FloatComplexSchurDecomp | Class FloatComplexSchurDecomp represents the Schur decomposition of a general matrix. | |

FloatComplexSparseFact | Class FloatComplexSparseFact performs general sparse matrix factorizations. | |

FloatComplexSparseVector | Class FloatComplexSparseVector encapsulates a general sparse vector. | |

FloatComplexSVDecomp | Class FloatComplexSVDecomp represents the singular value decomposition (SVD) of a matrix. | |

FloatComplexSVDecompServer | Class FloatComplexSVDecompServer constructs instances of the FloatComplexSVDecomp class. | |

FloatComplexSVDLeastSq | Class FloatComplexSVDLeastSq solves least squares problems by using a singular value decomposition. | |

FloatComplexTriDiagFact | Class FloatComplexTriDiagFact represents the LU factorization of a tridiagonal matrix of single-precision complex floating point numbers. | |

FloatComplexTriDiagMatrix | Class FloatComplexTriDiagMatrix represents a tridiagonal matrix of single-precision complex numbers. A tridiagonal matrix is a matrix which has all its non-zero entries on the main diagonal, the super diagonal, and the subdiagonal. | |

FloatComplexUpperTriMatrix | Class FloatComplexUpperTriMatrix represents an upper triangular matrix of single-precision complex numbers. An upper triangular matrix is a square matrix with all elements below the main diagonal equal to zero. | |

FloatComplexVector | Class FloatComplexVector represents a mathematical vector of FloatComplex numbers. | |

FloatCsrSparseMatrix | Class FloatCsrSparseMatrix stores a general sparse matrix using Compressed Row (CSR) storage format. | |

FloatDataBlock | The FloatDataBlock struct defines a contiguous subset of an array of floating point numbers. A FloatDataBlock instance contains a reference to an array, and an offset into the array. | |

FloatDWT | This class represents a single precision discrete wavelet transform. It supports both single step forward and reverse DWT's and multilevel signal deconstruction and reconstruction. Details thresholding at any level and threshold calculations are also supported. | |

FloatEigDecomp | Class FloatEigDecomp computes the eigenvalues and left and right eigenvectors of a general matrix, with preliminary balancing. | |

FloatEigDecompServer | Class FloatEigDecompServer creates eigenvalue decompositions. A server instance can be configured to perform preliminary balancing, and to compute left eigenvectors, right eigenvectors, both, or neither. | |

FloatForward1DFFT | FloatForward1DFFT represents the forward discrete fourier transform of a 1D real signal vector. | |

FloatForward2DFFT | FloatForward2DFFT represents the forward discrete fourier transform of a 2D real signal vector. | |

FloatGeneral1DFFT | General 1D FFT class assuming the behavior of the provided FFT configuration instance. | |

FloatGSVDecomp | Class FloatGSVDecomp computes the generalized singular value decomposition (GSVD) of a pair of general rectangular matrices. | |

FloatGSVDecompServer | Class for serving up generalized singular value decompositions (GSVD) in the form of FloatGSVDecomp instances. | |

FloatHermCsrSparseMatrix | Class FloatHermCsrSparseMatrix stores a general sparse Hermitian matrix using the Compressed Row (CSR) storage format. | |

FloatHermitianBandMatrix | Class FloatHermitianBandMatrix represents an Hermitian banded matrix of double-precision floating point values. An Hermitian banded matrix is an Hermitian matrix that has all its non-zero entries near the diagonal. | |

FloatHermitianEigDecomp | Class FloatHermitianEigDecomp computes the eigenvalues and eigenvectors of a symmetrix matrix. | |

FloatHermitianEigDecompServer | Class FloatHermitianEigDecompServer creates eigenvalue decompositions. A server instance can be configured to compute eigenvalues only, or both eigenvalues and eigenvectors. In addition, the server can be configured to compute only the eigenvalues in a given range. A tolerance for the convergence of the algorithm may also be specified. | |

FloatHermitianFact | Class FloatHermitianFact represents the factorization of a Hermitian, matrix of complex single-precision floating point numbers. | |

FloatHermitianMatrix | Class FloatHermitianMatrix represents a matrix of single-precision floating point complex values. | |

FloatHermitianPDBandFact | Class FloatHermitianPDBandFact represents the factorization of a Hermitian, positive definite, banded matrix of complex single-precision floating point numbers. | |

FloatHermitianPDFact | Class FloatHermitianPDFact represents the Cholesky factorization of a Hermitian, positive definite, matrix of single-precision complex floating point numbers. In a Cholesky factorization a Hermitian, positive definite matrix A is factored as A = UU' where U is upper triangular and U' is the conjugate transpose of U. | |

FloatHermPDTriDiagFact | Class FloatHermPDTriDiagFact represents the LDL' factorization of a Hermitian, positive definite, tridiagonal matrix of complex single-precision floating point numbers. | |

FloatLeastSquares | Class FloatLeastSquares computes the minimum-norm solution to a linear system Ax = y. | |

FloatLowerTriMatrix | Class FloatLowerTriMatrix represents a lower triangular matrix of single-precision floating point values. A lower triangular matrix is a square matrix with all elements above the main diagonal equal to zero. | |

FloatLUFact | Class FloatLUFact represents the LU factorization of a matrix of floating point numbers. | |

FloatMatrix | Class FloatMatrix represents a general mathematical matrix class of floating point numbers. Methods are provided for performing algebraic operations, data manipulation, and slicing. | |

FloatNonnegativeLeastSqResult | Class containing the results of a nonnegative least squares solve attempt. Single precision version. | |

FloatNonnegativeLeastSquares | Class FloatNonnegativeLeastSquares computes the minimum-norm solution to a linear system Ax = y subject to the constraint that all the elements, x[i], are nonnegative. | |

FloatPCA | Class FloatPCA performs a principal component analysis on a given single-precision data matrix. | |

FloatQRDecomp | Class FloatQRDecomp represents the QR decomposition of a general matrix. | |

FloatQRDecompServer | Class FloatQRDecompServer allows control over how the pivoting is done in the creation of FloatQRDecomp objects. | |

FloatQRLeastSq | Class FloatQRLeastSq solves least squares problems by using a QR decomposition. | |

FloatRandomBetaDistribution | Class FloatRandomBetaDistribution generates random numbers from a beta distribution. | |

FloatRandomCauchyDistribution | Class FloatRandomCauchyDistribution generates random numbers from a Cauchy distribution. | |

FloatRandomExponentialDistribution | Class FloatRandomExponentialDistribution generates random numbers from an exponential distribution. | |

FloatRandomGammaDistribution | Class FloatRandomGammaDistribution generates random numbers from a gamma distribution. | |

FloatRandomGaussianDistribution | Class FloatRandomGaussianDistribution generates random numbers from a Gaussian distribution. | |

FloatRandomGumbelDistribution | Class FloatRandomGumbelDistribution generates random numbers from a Gumbel distribution. | |

FloatRandomLaplaceDistribution | Class FloatRandomLaplaceDistribution generates random numbers from a Laplace distribution. | |

FloatRandomLogNormalDistribution | Class FloatRandomLogNormalDistribution generates random numbers from a lognormal distribution. | |

FloatRandomRayleighDistribution | Class FloatRandomRayleighDistribution generates random numbers from an Rayleigh distribution. | |

FloatRandomUniformDistribution | Class DoubleRandomUniformDistribution generates random numbers uniformly distributed over an interval. | |

FloatRandomWeibullDistribution | Class FloatRandomWeibullDistribution generates random numbers from a Weibull distribution. | |

FloatSchurDecomp | Class FloatSchurDecomp represents the Schur decomposition of a general matrix. | |

FloatSparseFact | Class FloatSparseFact performs general sparse matrix factorizations. | |

FloatSparseHermFact | Class FloatSparseHermFact performs Hermitian sparse matrix factorizations. | |

FloatSparseHermPDFact | Class FloatSparseHermPDFact performs sparse Hermitian Positive Definite matrix factorizations. | |

FloatSparseSymFact | Class FloatSparseSymFact performs sparse symmetric matrix factorizations. | |

FloatSparseSymPDFact | Class FloatSparseSymPDFact performs sparse positive definite symmetric matrix factorizations. | |

FloatSparseVector | Class FloatSparseVector encapsulates a general sparse vector. | |

FloatSVDecomp | Class FloatSVDecomp represents the singular value decomposition (SVD) of a matrix. | |

FloatSVDecompServer | Class FloatSVDecompServer constructs instances of the FloatSVDecomp class. | |

FloatSVDLeastSq | Class FloatSVDLeastSq solves least squares problems by using a singular value decomposition. | |

FloatSWT | The stationary wavelet transform (SWT) is an advanced development of the discrete wavelet transfrom (DWT). The DWT lacks signal translation-invariance. By using an up and down sampling strategy, often refered to by its french name of "algorithme à trous", the SWT gains translation-invariance. | |

FloatSymBandMatrix | Class FloatSymBandMatrix represents a symmetric banded matrix of single-precision floating point values. A symmetric banded matrix is a symmetric matrix that has all its non-zero entries near the diagonal. | |

FloatSymCsrSparseMatrix | Class FloatSymCsrSparseMatrix stores a sparse symmetric matrix using the CompreSsed Row (CSR) storage format. | |

FloatSymEigDecomp | Class FloatSymEigDecomp computes the eigenvalues and eigenvectors of a symmetrix matrix. | |

FloatSymEigDecompServer | Class FloatSymEigDecompServer creates eigenvalue decompositions. A server instance can be configured to compute eigenvalues only, or both eigenvalues and eigenvectors. In addition the server can be configured to compute only the eigenvalues in a given range. A tolerance for the convergence of the algorithm may also be specified. | |

FloatSymFact | Class FloatSymFact represents the factorization of a symmetric matrix of single-precision floating point numbers. | |

FloatSymmetric2DSignalReader | Provides symmetric complex conjugate signal unpacking services. Typically used for unpacking 2D FFT's of real signals. | |

FloatSymmetricBackward1DFFT | FloatSymmetricBackward1DFFT represents the backward discrete fourier transform of a 1D real signal vector. This class and inverts packed conjugate symmetric signals in the freqency domain back to the real domain. | |

FloatSymmetricMatrix | Class FloatSymmetricMatrix represents a symmetric matrix of float-precision floating point values. | |

FloatSymmetricSignalReader | Provides symmetric complex conjugate signal unpacking services. Typically used for unpacking 1D FFT's of real signals. | |

FloatSymPDBandFact | Class FloatSymPDBandFact represents the factorization of a symmetric, positive definite, banded matrix of single-precision floating point numbers. | |

FloatSymPDFact | Class FloatSymPDFact represents the Cholesky factorization of a symmetric, positive definite, matrix of single-precision floating point numbers. In a Cholesky factorization a symmetric, positive definite matrix A is factored as A = UU' where U is upper triangular and U' is the transpose of U. | |

FloatSymPDTriDiagFact | Class FloatSymPDTriDiagFact represents the LDL' factorization of a symmetric, positive definite, tridiagonal matrix of single-precision floating point numbers. | |

FloatTriDiagFact | Class FloatTriDiagFact represents the LU factorization of a tridiagonal matrix of single-precision floating point numbers. | |

FloatTriDiagMatrix | Class FloatTriDiagMatrix represents a tridiagonal matrix of single-precision floating point values. A tridiagonal matrix is a matrix which has all its non-zero entries on the main diagonal, the super diagonal, and the subdiagonal. | |

FloatUpperTriMatrix | Class FloatUpperTriMatrix represents an upper triangular matrix of single-precision floating point values. An upper triangular matrix is a square matrix with all elements below the main diagonal equal to zero. | |

FloatVector | Class FloatVector represents a mathematical vector of floating point numbers. | |

FloatWavelet | This class represents a single precision wavelet. There are fives types of built in wavelets avaiable: Harr, Daubechies, Least Asymmetric, Best Localized, and Coiflet. User generated wavelets can be created by provided the low-pass decimation filter parameters in the constructor. | |

FZero | FZero finds a zero of the function in the given interval. Repeated roots are not found, FZero can find only bracketed single roots. | |

GammaDistribution | Class GammaDistribution represents the gamma probability distribution. | |

GaussKronrod21Integrator | Class GaussKronrod21Integrator calculates an approximation of the integral of a function over a finite interval using the Gauss 10-point and the Kronrod 21-point rule. | |

GaussKronrod43Integrator | Class GaussKronrod43Integrator calculates an approximation of the integral of a function over a finite interval using the Gauss 21-point and the Kronrod 43-point rule. | |

GaussKronrod87Integrator | Class GaussKronrod87Integrator calculates an approximation of the integral of a function over a finite interval using the Gauss 43-point and the Kronrod 87-point rule. | |

GaussKronrodIntegrator | Class GaussKronrodIntegrator calculates an approximation of the integral of a function over a finite interval using Gauss-Kronrod rules. | |

GeometricDistribution | Class GeometricDistribution represents the goemetric probability distribution. | |

GlobalCurveFitAnova | Class GlobalCurveFitAnova computes ANOVA style statistics for the least squares model fit that result from a global curve fit. Available statistics include the residual standard error, the coefficient of determination (R2 and "adjusted" R2), the F-statistic and p-value for the overall model, and degrees of freedom. | |

GlobalCurveFitter | Global fitting in involves fitting multiple datasets with the same fitting function. Parameters in the fitting function can optionally be shared amongst all datasets. If a parameter is shared, the fitting procedure will yield the same value for that parameter for all datasets. If a parameter is not shared, the fitting procedure will yield a unique value for that parameter for each dataset. | |

GlobalFitParameterInfo | Contains information about a parameter in a global curve fit: name, description, shared or not shared. Only the sharing information is required. | |

GlobalFittedParameter | Class for providing fit statistics about a global fit parameter after the fit has been performed. | |

GlobalFixedFitParameterInfo | Contains information about a parameter with fixed value(s) in a global curve fit: name, description, shared or not shared, and the fixed value(s). If the parameter is not shared, then its values may be fixed for specific datasets. In this case the fixed values must be specified in using an IDictionary parameter. For example if the dictionary contained entries { 1, 1.0 }, { 3, 1.2 } this would mean the parameter has a fixed value of 1.0 in second dataset (zero based indexing) and a fixed value of 1.2 in the fourth dataset. If the parameter info object is constructed with a dictionary of fixed values it is assumed to be non-shared. If it is constructed with a single fixed value it is assumed to be shared. If a GlobalFixedFitParameterInfo has multiple fixed values and its sharing property is set to ParameterSharing.Shared, The first entry in the dictionary will be taken as the shared fixed value. | |

GoldenMinimizer | Class GoldenMinimizer performs a golden section search for a minimium of a function within an interval known to contain a minimum. | |

GoodnessOfFit | Class GoodnessOfFit tests goodness of fit for least squares model-fitting classes, such as LinearRegression, PolynomialLeastSquares, and OneVariableFunctionFitter. | |

GoodnessOfFitParameter | Class GoodnessOfFitParameter tests statistical hypotheses about estimated parameters in regression models. | |

Histogram | Class Histogram constructs and maintains a histogram of input data. Input data is sorted into bins and a count is kept of how many data points fall into each bin. | |

IActiveSetQPSolver | Class IActiveSetQPSolver is an interface for classes that solver convex quadratic programming (QP) problems. In particular, classes that implement this abstract class may be used in the Active Set Sequential Quadratic Programming solver for general linear programming problems. | |

IndependentRandomStreams | Base class for creating streams of independent random numbers. Deriving classes must construct the streams_ array. | |

IndexArray | Class IndexArray presents 0-based indices to the user, but uses 1-based indices internally. | |

IndexOutOfRangeException | Exception thrown when an out of range index is passed to an NMath function. | |

InputVariableCorrelator | Instances of the InputVariableCorrelator class are used to induce a desired rank correlation among input variables. | |

InteriorPointQPSolver | Class for sovling quadratic programming (QP) problems using an interior point algorithm. | |

InteriorPointQPSolverParams | Parameters controlling the behavior of the interior point quadratic programming algorithm in the InteriorPointQPSolver class. | |

Interval | Class Interval represents a numeric interval with inclusive or exclusive lower and upper bounds. | |

IntRandomBernoulliDistribution | Class IntRandomBernoulliDistribution generates random numbers from a discrete binomial distribution. | |

IntRandomBinomialDistribution | Class IntRandomBinomialDistribution generates random numbers from a discrete binomial distribution. | |

IntRandomGeometricDistribution | Class IntRandomGeometricDistribution generates random numbers from a discrete geometric distribution. | |

IntRandomHypergeometricDistribution | Class IntRandomHypergeometricDistribution generates random numbers from a discrete hypergeometric distribution. | |

IntRandomNegativeBinomialDistribution | Class IntRandomNegativeBinomialDistribution generates random numbers from a discrete negative binomial distribution. | |

IntRandomPoissonDistribution | Class IntRandomPoissonDistribution generates random numbers from a discrete Poisson distribution. | |

IntRandomPoissonVaryingMeanDistribution | Class IntRandomPoissonVaryingMeanDistribution generates random numbers from a discrete Poisson distribution with varying mean. | |

IntRandomUniformBitsDistribution | Class IntRandomUniformBitsDistribution generates integer values with uniform bit distribution. | |

IntRandomUniformDistribution | Class IntRandomUniformDistribution generates random numbers uniformly distributed over an interval. | |

InvalidArgumentException | Exception thrown when an invalid argument is passed to an NMath function. | |

InvalidBinBdryException | Exception thrown when a histogram operation results in invalid bin boundaries. | |

IPLS1Calc | Interface for performing a Partial Least Squares (PLS) calculation. | |

IPLS2Calc | Interface for performing a Partial Least Squares (PLS) calculation. | |

JohnsonDistribution | Class JohnsonDistribution represents the Johnson system of distributions. | |

KFoldsSubsets | Class KFoldsSubsets generates k-fold subsets for cross validation. | |

KMeansClustering | Class KMeansClustering performs k-means clustering on a set of data points. | |

KruskalWallisTable | Class KruskalWallisTable summarizes the information of Kruskal-Wallis rank sum test. | |

KruskalWallisTest | Class KruskalWallisTest performs a Kruskal-Wallis rank sum test. | |

L1MeritStepSize | Class L1MeritStepSize computes the step size for a Sequential Quadratic Programming solver based on sufficient decrease in the L1 merit function. | |

LagrangianFunction | Class LagrangianFunction represents the Lagrangian function associated with a nonlinear programming problem. | |

LagrangianFunctionLagrangianGradientFunction | Class LagrangianGradientFunction derives from DoubleMultiVariableFunction for evaluating the gradient of the Lagrangian functions. | |

LeapfrogRandomStreams | Class LeapfrogRandomStreams creates several independent streams of random numbers using the method know as leapfrogging. | |

LeapfrogStream | Class LeapfrogStream represents a single leapfrog stream. | |

LeaveOneOutSubsets | Class LeaveOneOutSubsets generates the index subsets for a leave-one-out cross validations calculation. | |

LevenbergMarquardtMinimizer | Class for minimizing the L2 norm of a function using the Levenberg Marquardt algorithm. | |

LikelihoodRatioStatistic | Class LikelihoodRatioStatistic computes the Likelihood Ratio Statistic values for a logistic regression. | |

LinearAnnealingSchedule | Class LinearAnnealingSchedule encapsulates the linear descent of a starting temperature to zero. Each step has a specified number of iterations. | |

LinearConstrainedProblem | Abstract class for representing an optimization problem with linear constraints. | |

LinearConstraint | Class LinearConstraint represents a linear constraint for a constrained optimization problem. | |

LinearProgrammingProblem | Class LinearProgrammingProblem encapsulates a Linear programming problem. | |

LinearRegression | Class LinearRegression computes a multiple linear regression from an input matrix of independent variable values and vector of dependent variable values. | |

LinearRegressionAnova | Class LinearRegressionAnova tests overall model significance for linear regressions computed by class LinearRegression. | |

LinearRegressionParameter | Class LinearRegressionParameter tests statistical hypotheses about estimated parameters in linear regressions computed by class LinearRegression. | |

LinearSpline | Class LinearSpline represents a function whose values are determined by linear interpolation between tabulated values. | |

Linkage | Class Linkage provides functions for computing the distance between clusters of objects. | |

LogisticDistribution | Class LogisticDistribution represents the logistic probability distribution with a specifed location (mean) and scale. | |

LogisticRegressionParameterCalc | Class for performing a binomial logistic regression. | |

LogisticRegressionAuxiliaryStatsParameterCalc | Class LogisticRegressionAuxiliaryStats computes pseudo R-squared metrics for a logistic regression, and odds ratios for the computed coefficients. | |

LogisticRegressionFitAnalysisParameterCalc | Class for for calculating "goodness of fit" statistics for a logistic regression model. | |

LogisticRegressionFitAnalysisParameterCalcHosmerLemeshowGroup | Class representing a group used in computing the Hosmer Lemeshow statistic for a logistic regression model. | |

LogisticRegressionFitAnalysisParameterCalcHosmerLemeshowStatistic | Class containing the attributes of the Hosmer Lemeshow statistic for a logistic regression model. | |

LogisticRegressionFitAnalysisParameterCalcPearsonChiSqrStatistic | Class containing the attributes of the Pearson chi-square statistic associated with a logistic regression model. | |

LogisticRegressionFitAnalysisParameterCalcPearsonResidual | Class containing Pearson Residual attributes. The Pearson Residual is calculated for each covariate pattern. | |

LogisticRegressionParameterParameterCalc | Class LogisticRegressionParameter tests statistical hypotheses about estimated parameters in linear regressions computed by class LogisticRegression. | |

LognormalDistribution | Class LognormalDistribution represents the lognormal probability distribution. | |

MarginalEffect | Class containing marginal effect values and statistics for a model parameter | |

MarginalEffectsParameterCalc | Marginal effects are use a logistic regression model to predict how changing the value of a predictor, or covariate, effects the predicted outcome. It is the slope of the regression surface with respect to a given covariate and communicates the rate at which the outcome computed by the regression model changes at a given point in covariate space, with respect to one covariate dimension and holding all covariate values constant. Marginal effects for categorical covariates, including binary covariates, are straightforward - it is simply the difference in the predicted outcomes as the the design or dummy variable's value changes from 0 to 1. For continuous valued covariates it is the derivate dy/dx where y is the models prediction function and x is the covariate we are computing the marginal effects for. Note that the marginal effect for a predictor is computed at specific observation. | |

MatrixFunctions | Obsolete.No longer used. Please use NMathFunctions. | |

MatrixNotSquareException | Exception thrown when a matrix operation requiring a square matrix is presented with a non-square one. | |

MinimizerBase | Class MinimizerBase is the abstract base class for classes that perform function minimization. | |

MismatchedSizeException | Exception thrown when an operation is performed with operands whose sizes are incompatible with the operation. | |

MixedIntegerLinearProgrammingProblem | Class MixedIntegerLinearProgrammingProblem encapsulates a Linear programming problem which may contain integral constraints. | |

MixedIntegerNonlinearProgrammingProblem | Class MixedIntegerNonlinearProgrammingProblem represents a nonlinear programming problem. | |

ModifiedLevenbergMarquardtMinimizer | Class for minimizing the L2 norm of a function using the a modified Levenberg Marquardt algorithm. | |

MovingWindowFilter | Class implementing data filtering by replacing data points f(i) with a linear combination of the data points immediately to the left and right of f(i). The user provides the coefficients to use in the linear combination. Static class methods are provided for generating coefficients to implement a moving average filter and a Savitzky-Golay smoothing filter. | |

MultipleCurveFit | Class for performing simulatenous fitting of multiple data sets with shared fitting parameters. As an example suppose we have two sets of data points- dataset 1 = { (x11,y11), (x12,y12),...,(x1n,y1n) } dataset 2 = { (x21,y21), (x22,y22),...,(x2n,y2m) } And suppose we have two parameterized functions f1(beta,x) = cos(2*pi*beta(0)*x)*exp(-x/beta(1)) f2(beta,x) = beta(3) + beta(2)*exp(-(x/beta(1))) where beta is a vector of four parameters. The MultiCurveFit class solves the problem of finding the parameter values beta that best fit, in the least squares sense, the function f1 to dataset 1 and the function f2 to dataset 2 with the parameter beta(1) being the same for both datasets. | |

MultipleCurveFitFunction | Function for simulatenous fitting of multiple data sets with shared fitting parameters. MultipleCurveFit | |

MultipleCurveFitResidual | Calculates the residuals of a MultipleCurveFitFunction with a given set of parameters and data sets. | |

MultipleFitCurveInfo | Class for pairing a parameterized function with a data set for use in performing a simulatenous fitting of multiple data sets with shared fitting parameters. MultipleCurveFit | |

MultiVariableFunction | Obsolete.Class MultiVariableFunction represents multivariate functions. | |

MultiVariableFunctionFitterM | Class MultiVariableFunctionFitter fits a generalized multivariable function to a set of points. | |

MultiVariableFunctionFitterMResidualFunction | Residual function. This is the function that is minimized to produce the parameters for the best fit. | |

NaturalCubicSpline | Class NaturalCubicSpline represents a function determined by tabulated values. Function values are calculated using natural cubic spline interpolation. | |

NegativeBinomialDistribution | Class NegativeBinomialDistribution represents the discrete probability distribution of obtaining N successes in a series of x trials, where the probability of success on each trial is P. | |

NewtonRaphsonParameterCalc | Parameter calculation for a logistic regression model. The parameters are computed to maximize the log likelihood function for the model, using the Newton Raphson algorithm to compute the zeros of the first order partial derivaties of the log likelihood function. | |

NewtonRaphsonRootFinder | Class NewtonRaphsonRootFinder finds roots of univariate functions using the Newton-Raphson algorithm. | |

NiederreiterQuasiRandomGenerator | Class NiederreiterQuasiRandomGenerator is a quasi-random number generator which can be used for generating sequences of quasi-random point in n-dimensional space. | |

NMathConfiguration | Class NMathConfiguration provides properties for controlling the loading of the NMath kernel assembly and native library, and specifying license keys. | |

NMathException | Base class for exceptions thrown by the NMath product suite. | |

NMathFormatException | Exception thrown when a method encounters a faulty text representation. | |

NMathFunctions | Class NMathFunctions provides standard mathematical functions for NMath types. Trigonometric functions, exponents, logarithms, powers, and square roots are provided for vector, matrix, and complex number types. | |

NMathFunctionsFiveParameterLogisticFtn | Computes the 5-parameter logistic (5PL) function, using the given vector of function parameters, at the specified point. | |

NMathFunctionsFourParameterLogisticFtn | Computes the 4-parameter logistic (4PL) function, using the given vector of function parameters, at the specified point. | |

NMathFunctionsThreeParameterExponentialFtn | Evaluates the three parameter exponential function for the given parameter values at the given point. | |

NMathFunctionsThreeParameterSineFtn | Computes the three parameter sine function, using the given vector of function parameters, at the specified point. | |

NMathFunctionsTwoParameterAsymptoticFtn | Computes the asymptotic function, using the given vector of function parameters, at the specified point. | |

NMathSettings | Class NMathSettings contains global settings for NMath classes. | |

NMFact | Class NMFact performs non-negative matrix factorization. | |

NMFAlsUpdate | Class NMFAlsUpdate encapsulates the Alternating Least Squares (ALS) update algorithm. | |

NMFClusteringAlg | Class NMFClustering performs a Non-negative Matrix Factorization (NMF) of a given matrix. | |

NMFConsensusMatrixAlg | Class NMFConsensusMatrix uses a non-negative matrix factorization to cluster samples. | |

NMFDivergenceUpdate | Class NMFDivergenceUpdate encapulates an NMF update algorithm which minimizes a divergence functional. | |

NMFGdClsUpdate | Class NMFGdClsUpdate encapsulates the Gradient Descent - Constrained Least Squares (GDCLS) algorithm for Nonnegative Matrix Facotorization (NMF). | |

NMFMultiplicativeUpdate | Class NMFMultiplicativeUpdate encapsulates a multiplicative update algorithm for Nonnegative Matrix Factorization (NMF). | |

NMFNonsmoothUpdate | Class NMFNonsmoothUpdate encapulates an NMF update algorithm which minimizes a cost functional designed to explicitly represent sparseness, in the form on nonsmoothness, which is controlled by a single parameter. | |

NoncentralTDistribution | Class NoncentralTDistribution represents a generalized Student's t-distribution with the specified degrees of freedom and noncentrality parameter. | |

NonlinearConstraint | Class NonlinearConstraint represents a nonlinear constraint in an optimization problem. | |

NonlinearProgrammingProblem | Class NonlinearProgrammingProblem represents a nonlinear programming problem. | |

NonModifiableElementException | Exception thrown when an attempt is made to change the value of an element in a structured matrix that cannot be changed. | |

NormalDistribution | Class NormalDistribution represents the normal (Gaussian) probability distribution with a specifed mean and variance. | |

NoRotation | Used as a class type parameter value to factor analysis classes when no factor rotation is desired. | |

NumberOfFactors |
The C# NumberOfFactors | |

OdeSolverBase | Base class for ODE solvers which use a Runge-Kutta order 5 algorithm. Includes enums and functions for incorporating mass matrices into ODE's. | |

OdeSolverBaseConstMassMatrixOdeFcn | When solving ODE's of the form y' = M*f(t,y) where M is a constant "mass" matrix, this class provides a function g(t,y) for the right hand side of the above equation which incorporates the mass matrix M. | |

OdeSolverBaseMassMatrixOdeFcn | When solving ODE's of the form y' = M(t,y)*f(t,y) where M is a time-state dependent "mass" matrix, this class provides a function g(t,y) for the right hand side of the above equation which incorporates the mass matrix function M(t,y). | |

OneSampleAndersonDarlingTest | Class OneSampleAndersonDarlingTest performs a Anderson-Darling test of the distribution of one sample. | |

OneSampleKSTest | Class OneSampleKSTest performs a Kolmogorov-Smirnov test of the distribution of one sample. | |

OneSampleTTest | Class OneSampleTTest compares a single sample mean to an expected mean from a normal distribution with an unknown standard deviation. | |

OneSampleZTest | Class OneSampleZTest compares a single sample mean to an expected mean from a normal distribution with known standard deviation. | |

OneVariableFunction | Class OneVariableFunction represents functions of one variable. | |

OneVariableFunctionFitterM | Class OneVariableFunctionFitter fits a parameterized one variable function to a set of points. | |

OneVariableFunctionFitterMCurveFitResidualFunction | Class representing the residual function for the curve fit. | |

OneWayAnova | Class OneWayAnova computes and summarizes a traditional one-way (single factor) Analysis of Variance (ANOVA). | |

OneWayAnovaTable | Class OneWayAnovaTable summarizes the information of a traditional one-way Analysis of Variance (ANOVA) table. | |

OneWayRanova | Class OneWayRanova summarizes the information of a one-way repeated measures Analysis of Variance (RANOVA). | |

OneWayRanovaTable | Class OneWayRanovaTable summarizes the information of a traditional one-way repeated measures Analysis of Variance (RANOVA) table. | |

OpenClosedInterval | Class OpenClosedInterval represents a numeric interval with an exclusive lower bound and an inclusive upper bound. | |

OpenInterval | Class OpenInterval represents a numeric interval with exclusive lower and upper bounds. | |

OrderedConnectivityMatrix | Class OrderedConnectivityMatrix reorders the rows and columns of an connectivity matrix so that the most affiliated elements appear as clusters of higher values along the diagonal. | |

ParameterizedMultivariableFunction | Abstract class representing multi-variable a parameterized function. | |

PCFactorExtraction | Class implementing the principle components (PC) algorithm for factor extraction when performing factor analysis. Used as a class type parameter for the factor analysis classes. | |

PeakFinderBase | Abstract base class for all peak finding algorithms. The class is an enumerable collection of all found peaks. | |

PeakFinderRuleBased | Class PeakFinderRuleBased simply returns all of the peaks subject to rules about peak height and peak separation. A peak is defined as a point which is higher that both neighbors or infinity. Non-infinity end points are excluded as a peak. | |

PeakFinderSavitzkyGolay | Class PeakFinderSavitzkyGolay uses smooth Savitzky-Golay derivatives to find peaks in data and acts as a collection for the found peaks. | |

PearsonsChiSquareTest | Class PearsonsChiSquareTest tests whether the frequency distribution of experimental outcomes are consistant with a particular theoretical distribution. | |

PLS1 | Class PLS1 performs a Partial Least Squares (PLS) regression calculation on a set of predictive and one-dimensional response values. The result is used to predict response variable values. | |

PLS1Anova | Class PLS1Anova performs a standard ANalysis Of VAriance (ANOVA) for a Partial Least Squares 1 (PLS1) regression model. | |

PLS1CrossValidation | Class PLS1CrossValidation performs an evaluation of a PLS (Partial Least Squares) model. | |

PLS1CrossValidationData | Class PLS1CrossValidationData divides Partial Least Squares - one dimensional response variable,(PLS1), data into training and testing subsets. | |

PLS1CrossValidationResult | Class PLS2CrossValidationResult performs a Partial Least Squares - one dimensional response variable, (PLS1), cross validation calculation. | |

PLS1NipalsAlgorithm | Class PLS1NipalsAlgorithm encapsulates the Nonlinear Iterative PArtial Least Squares (NIPALS) algorithm for computing partial least squares regression components. | |

PLS2 | Class PLS2 performs a Partial Least Squares (PLS) regression calculation on a set of predictive and response values. The result is used to predict response variable values. | |

PLS2Anova | Class PLS2Anova performs a standard ANalysis Of VAriance (ANOVA) for a Partial Least Squares (PLS) regression model. | |

PLS2CrossValidation | Class PLS2CrossValidation performs an evaluation of a PLS (Partial Least Squares) model. | |

PLS2CrossValidationData | Class PLS2CrossValidationData divides Partial Least Squares (PLS) data into training and testing subsets. | |

PLS2CrossValidationResult | Class PLS2CrossValidationResult performs a Partial Least Squares (PLS) cross validation calculation. | |

PLS2CrossValidationWithJackknife | Class PLS2CrossValidationWithJackknife performs an evaluation of a PLS (Partial Least Squares) model with model coefficient variance estimates and confidence intervals. | |

PLS2NipalsAlgorithm | Class PLS2NipalsAlgorithm encapsulates the Nonlinear Iterative PArtial Least Squares (NIPALS) algorithm for computing partial least squares regression components. | |

PLS2SimplsAlgorithm | Class PLS2SimplsAlgorithm encapsulates the Straightforward IMplementation of Partial Least Squares, or SIMPLS, algorithm (de Jong, 1993) for computing partial least squares regression components. | |

PoissonDistribution | Class PoissonDistribution represents a poisson distribution with a specified lambda, which is both the mean and the variance of the distribution. The poisson distribution a discrete distribution representing the probability of obtaining exactly n successes in N trials. | |

Polynomial | Class Polynomial represents a polynomial function as a vector of coefficients. | |

PolynomialDifferentiator | Class PolynomialDifferentiator encapsulates exact differentiation of polynomials. | |

PolynomialIntegrator | Class PolynomialIntegration encapsulates exact integration of polynomials. | |

PolynomialLeastSquares | Class PolynomialLeastSquares performs a least squares fit of a polynomial to the data. | |

PowellMinimizer | Class PowellMinimizer minimizes a multivariable function using Powell's Method. | |

PowerMethod | Class for computing the dominant eigenvalue and eigenvector of a square matrix using the iterative power method. | |

PrimalSimplexSolver | Obsolete.Class PrimalSimplexSolver is a class for solving linear programming prolems using the primal simplex method. | |

PrimalSimplexSolverORTools | Class PrimalSimplexSolver is a class for solving linear programming prolems using the primal simplex method. | |

PrimalSimplexSolverParams | Obsolete.Primal simplex algorithm parameters. | |

ProbabilityDistribution | Class ProbabilityDistribution is the abstract base class for classes that represent distributions of random variables. | |

ProcessCapability | Computes the process capability parameters Cp, Cpm, Cp for normally distributed data. If the data is not normal the Box-Cox transform can be used. | |

ProcessPerformance | Computes process performance parameters Pp and Ppk for normally distributed data. If the data is not normal the Box-Cox transform can be used. | |

QRRegressionCalculation | Class QRRegressionCalculation computes linear regression parameters by the method of least squares using a QR decomposition. | |

QuadraticProgrammingProblem | Class QuadraticProgrammingProblem encapsulates a quadratic programming (QP) problem. | |

QuasiRandomNumberGenerator | Abstract base class for generating sequences of quasirandom points. A quasirandom sequence is a sequence of n-tuples that fills n-space more uniformly than uncorrelated random points. | |

RandGenBeta | Class RandGenBeta generates random numbers from a beta distribution. | |

RandGenBinomial | Class RandGenBinomial generates random numbers from a binomial distribution. | |

RandGenExponential | Class RandGenExponential generates random numbers from an exponential distribution. | |

RandGenGamma | Class RandGenGamma generates random numbers from an gamma distribution. | |

RandGenGeometric | Class RandGenGeometric generaties random numbers from a Geometric distribution. | |

RandGenJohnson | Class RandGenJohnson generates random numbers from a Johnson distribution. | |

RandGenLogNormal | Class RandGenLogNormal generates random numbers from a lognormal distribution. | |

RandGenMTwist | Class RandGenMTwist generates random numbers from a uniform distribution using the Mersenne Twister algorithm. | |

RandGenNormal | Class RandGenNormal generates random numbers from a normal distribution. | |

RandGenPareto | Class RandGenPareto generates random numbers from a Pareto distribution. | |

RandGenPoisson | Class RandGenPoisson generates random numbers from an Poisson distribution. | |

RandGenTriangular | Class RandGenTriangular generates random numbers from a triangular distribution. | |

RandGenUniform | Class RandGenUniform generates random numbers from a uniform distribution. | |

RandGenWeibull | Class RandGenWeibull generates random numbers from a Weibull distribution. | |

RandomNumberGenerator | Abstract base class for NMath random number generators. | |

RandomNumbersT, D | Class RandomNumbers is an adapter for the RandomNumberStream class to give the same behavior as a scalar-type random number generator. | |

RandomNumberStream | Class RandomNumberStream is a vectorized random number generator which yields a stream of random numbers from various probability distributions. | |

Range |
Class Range represents a collection of indices that can be used to view a subset of
data from another data structure. A Range is defined by a starting index, an ending
index or enumerated Position value, and a step increment called the stride.
| |

ReducedVarianceInputCorrelator | Instances of the ReducedVarianceInputCorrelator class are used to induce a desired rank correlation among input variables. | |

RegressionBase | Base class for linear and logistic regression. | |

RegressionFactorScores |
Class implementing the C# IFactorScores | |

RiddersDifferentiator | Class RidderDifferentiator encapsulates numerical differentiation of functions. | |

RiddersRootFinder | Class RiddersRootFinder finds roots of univariate functions using Ridders' Method. | |

RombergIntegrator | Class RombergIntegrator approximates integrals of functions over a given interval using the Romberg method. | |

RootFinderBase | Abstract base class for classes that perform root finding on univariate functions. | |

RungeKutta45OdeSolver | Class RungeKutta45OdeSolver solves an initial value, Ordinary Differential Equation (ODE) using an explicit Runge-Kutta (4,5) formula known as the Dormand-Prince pair. | |

RungeKutta45OdeSolverOptions | User settable options for RungeKutta45OdeSolver. | |

RungeKutta45OdeSolverSolutionYtype | Data structor contiaing solution values an statistics for an ODE solve. | |

RungeKutta5OdeSolver | Class RungeKutta5OdeSolver solves an initial value, Ordinary Differential Equation (ODE) using a non-adaptive explicit Runge-Kutta formula of order 5. | |

RungeKutta5OdeSolverOptions | User settable options for RungeKutta5OdeSolver. | |

SavitzkyGolay | Class generates the Savitzy-Golay filter coefficients for smoothing data or computing smoothed derivatives. Smoothed derivatives can be found up to the order of the fitting polynomial. | |

SavitzkyGolayFilter | Class SavitzkyGolayFilter is a correlation filter specialized for filtering with Savitzky-Golay coefficients with additional boundary options for better edge continuity. The default boundary option ShiftFilterCenter provides data smoothing all the way boundary ends. | |

SecantRootFinder | Class SecantRootFinder finds roots of univariate functions using the secant method. | |

SequentialQuadraticProgrammingSolver | Base class for sequential quadratic programming solvers. | |

SequentialQuadraticProgrammingSolverIteration | Data structure containing various values for an iteration of a Sequential Quadratic Programming algorithm. | |

ShapiroWilkTest | Class ShapiroWilkTest tests the null hypothesis that the sample comes from a normally distributed population. | |

SimplexSolverBase | Obsolete.Class SimplexSolverBase is an abstract base class for classes solving mixed integer linear programming prolems using variants of the simplex method. | |

SimplexSolverBaseORTools | Class SimplexSolverBase is an abstract base class for classes solving mixed integer linear programming prolems using variants of the simplex method. | |

SimplexSolverMixedIntParams | Obsolete.Class containing parameters for simplex based mixed integer linear programming solvers. | |

SimplexSolverParamsBase | Obsolete.Base class for simplex solver parameters. | |

SingularMatrixException | Exception thrown when a matrix operation requiring a non-singular matrix is presented with a singular one. | |

SkipAheadRandomStreams | Class for creating several independent streams of random numbers using the method know as skip-ahead, or block-splitting. | |

SkipAheadStream | Class SkipAheadStream represents a single skip-ahead stream. | |

Slice |
Class Slice represents a collection of indices that can be used to view
a subset of data from another data structure. A slice is defined by a starting
index, a total number of elements, and a step increment called the stride.
| |

SmoothCubicSpline | Class SmoothCubicSpline calculates smoothing splines. | |

SobolQuasiRandomGenerator | Class SobolQuasiRandomGenerator is quasi-random number generator which can be used for generating sequences of quasi-random point in n-dimensional space. | |

SparseConstraintCoefficients | Class implementing the ILinearConstraintCoefficients for sparse linear constraint coefficients. Only the non-zero coefficients are stored. | |

SparseMatrixBuilderT | Class SparseMatrixBuilder{T} serves as the base class for the sparse matrix builder classes of specific types. This class implements the interface System.Collections.Generic.IDictionary{IntPair,T}, providing matrix-like row/column indexing for setting and retrieving values. Only nonzero values are stored. | |

SparseMatrixDataStorage, Type | Class SparseMatrixData stores general sparse matrix data. | |

SparseMatrixFactT | Abstract base class for sparse matrix factorizations using the Parallel Direct Sparse Solver Interface (PARDISO). | |

SparsePls | Class SparsePls performs a Partial Least Squares (PLS) calculation for the model X ~ Y with variable selection. The LASSO penalization is used on the pairs of loading vectors. SparsePls allows matrices with missing values in them by using the NIPALS algorithm to estimate them. Missing values are represented as Double.NaN. | |

SparsePlsDa | Class for performing Discriminant Analysis (DA) using sparse Partial Least Squares (sPLS). This is a classical sPLS regression, but where the response variable is catagorical. The response vector Y is qualitative and is recoded as a dummy block matrix where each of the response categories are coded via an indicator variable. PLS-DA is then run as if Y was a continuous matrix. | |

SparsePLSDACrossValidation | Class SparsePLSDACrossValidation performs an evaluation of a PLS (Partial Least Squares) model. | |

SparseVectorDataT | Class SparseVectorData stores sparse vector data. | |

SpecialFunctions | This class contains a collection of special functions. | |

StatsFunctions | Obsolete.No longer used. Please use NMathFunctions. | |

StatsSettings | Class StatsSettings contains global settings for NMath Stats classes. | |

StochasticHillClimbingParameters | Parameter class for the StochasticHillClimbingSolver class. | |

StochasticHillClimbingSolver | Nonlinear programming solver that uses a stocastic hill climbing algorithm. It starts from a random set of decision values, and repeatedly tries small random changes to the decision values. It keeps changes that make the answer better, and rejects changes that make it worse. | |

Subset | Class Subset represents a collection of indices that can be used to view a subset of data from another data structure. | |

SVDRegressionCalculation | Class SVDRegressionCalculation computes linear regression parameters by the method of least squares using a singular value decomposition. | |

TabulatedFunction | Class TabulatedFunction is an abstract class representing a function determined by tabulated values. | |

TDistribution | Class TDistribution represents Student's t-distribution with the specified degrees of freedom. | |

TriangularDistribution | Class TriangularDistribution represents the triangular probability distribution. | |

TrustRegionMinimizer | Class TrustRegionMinimizer solves both constrained and unconstrained nonlinear least squares problems using the Trust Region method. | |

TrustRegionParameterCalc | Parameter calculation for a logistic regression model. The parameters are computed to maximize the log likelihood function for the model, using a trust region optimization algorithm to compute the zeros of the first order partial derivaties of the log likelihood function. The minimization is performed by an instance of the class CenterSpace.NMath.Core.TrustRegionMinimizer and algorithms parameters may be controlled through this object. It is accessible through the Minimizer class property, and a TrustRegionParameterCalc instace may be constructed with a give TrustRegionMinimizer object which has the desired properties. TrustRegionMinimizer | |

TwoSampleFTest | Class TwoSampleFTest tests if the variances of two populations are equal. | |

TwoSampleKSTest | Class TwoSampleKSTest performs a two-sample Kolmogorov-Smirnov test to compare the distributions of values in two data sets. | |

TwoSamplePairedTTest | Class TwoSamplePairedTTest tests if two paired sets of observed values differ from each other in a significant way. | |

TwoSampleUnpairedTTest | Class TwoSampleUnpairedTTest tests the null hypothesis that the two population means corresponding to two random samples are equal. | |

TwoSampleUnpairedUnequalTTest | Class TwoSampleUnpairedUnequalTTest tests the null hypothesis that the two population means corresponding to two random samples are equal. | |

TwoVariableIntegrator | Class TwoVariableIntegrator integrates functions of two variables. | |

TwoWayAnova | Class TwoWayAnova performs a balanced two-way analysis of variance. | |

TwoWayAnovaBase | Base class for both balanced and unbalanced two way ANOVA. | |

TwoWayAnovaTable | Class TwoWayAnovaTable summarizes the information of a traditional two-way Analysis of Variance (ANOVA) table. | |

TwoWayAnovaTypeI | Class for performing a Type I ANOVA on unbalanced data. See the description of the base class TwoWayAnovaUnbalanced for a description of the notation. Type I, also called "sequential" sum of squares: SS(A) for factor A. SS(B | A) for factor B. SS(AB | B, A) for interaction AB. This tests the main effect of factor A, followed by the main effect of factor B after the main effect of A, followed by the interaction effect AB after the main effects. | |

TwoWayAnovaTypeII | Class for performing a Type II ANOVA on unbalanced data. See the description of the base class TwoWayAnovaUnbalanced for a description of the notation. SS(A | B) for factor A. SS(B | A) for factor B. SS(AB | A, B) for interaction. This type tests for each main effect after the other main effect. Note that no significant interaction is assumed and you should look look at the test for interaction first (SS(AB | A, B)) and only if interaction after the main effects AB is not significant continue with the analysis for main effects. | |

TwoWayAnovaTypeIII | Class for performing a Type III ANOVA on unbalanced data. See the description of the base class TwoWayAnovaUnbalanced for a description of the notation. SS(A | B, AB) for factor A. SS(B | A, AB) for factor B. SS(AB | A, B) for interaction. This type tests for the presence of a main effect after the other main effect and interaction. This approach is therefore valid in the presence of significant interactions. However, it is often not interesting to interpret a main effect if interactions are present (generally speaking, if a significant interaction is present, the main effects should not be further analysed). | |

TwoWayAnovaUnbalanced | Class TwoWayAnovaUnbalanced is the base class for performing a two way ANOVA when the number of observations in each cell is not the same (an unbalanced design). In this case the main and interaction effects are interdependent, and we must obtain the marginal sum of squares associated with each factor after all the other factors have already been included in the model (the marginal sum of squares for each variable equals the incremental sum of squares for that variable when it is entered into the equation last). In terms of a regression approach to ANOVA, the marginal sum of squares due to a factor is the sum of squares for the set of dummy variables associated with that factor when those dummy variables are entered into the model last, after all other dummy variables. Classes deriving from TwoWayAnovaUnbalanced provide the ordering of dummy regression variables and use the base class to compute the resulting regressions and sums of squares. | |

TwoWayAnovaUnbalancedOrderedLinearRegression | Class containing the linear regression object computed from a particular ordering of factor and interaction parameters. Note that a factor parameter or interaction parameters may be absent depending on which type of sum of squares is being computed. | |

TwoWayAnovaUnbalancedParameterSlices | As long as the dummy regression parameters are the same, we may use the same regression matrix to compute the various marginal sums of squares. Since the dummy variables for a given factor, or the interaction parameters, will always be contiguous columns in the regression matrix, their location can be specified with slices. The ParameterSlices class specifies the slices where factor A, factor B, and interaction dummy variables are located in the regression matrix. The following terminology is used throughout: Regression matrix - the matrix of regression parameters include the intercept parameter, which is expressed as a leading column of 1's in the matrix. Predictor matrix - The matrix of regression parameters excluding the intercept parameter. Thus regression parameters start at column 1 in the regression matrix and column 0 in the predictor matrix. | |

TwoWayAnovaUnbalancedTable | Class TwoWayAnovaUnbalancedTable summarizes the information of a traditional two-way Analysis of Variance (ANOVA) table. | |

TwoWayRanova | Class TwoWayRanova performs a balanced two-way analysis of variance with repeated measures on one factor. | |

TwoWayRanovaTable | Class TwoWayRanovaTable summarizes the information of a traditional two-way Analysis of Variance (RANOVA) table. | |

TwoWayRanovaTwo | Class TwoWayRanovaTwo performs a balanced two-way analysis of variance with repeated measures on both factors. | |

TwoWayRanovaTwoTable | Class TwoWayRanovaTwoTable summarizes the information of a traditional two-way Analysis of Variance, with repeated measures on both factors, table, | |

UniformDistribution | Class UniformDistribution represents the Uniform probability distribution. | |

VariableBounds | Class specifying a variable ID, lower and upper bounds, and a tolerance used in testing bounds compliance. | |

VariableMetricMinimizer | Class VariableMetricMinimizer uses the Broyden-Fletcher-Goldfarb-Shanno variable metric algorithm to minimize multivariable functions. | |

VariableOrderOdeSolver | Solver for stiff and non-stiff ordinary differential equations. The algorithm uses higher order methods and smaller step size when the solution varies rapidly. | |

VariableOrderOdeSolverOptions | Class containing available options for the VariableOrderOdeSolver. | |

VariableOrderOdeSolverSolutionYtype | Data structor contianing solution values and statistics for an ODE solve. | |

VarimaxRotation | Class for computing the varimax rotation of the factor from a factor analysis. Rotates the coordinates to maximize the sum of the variances of the squared loadings. Kaiser normalization is optionally performed, and the default stopping tolerance (1e-12) is used. | |

Wavelet | This abstract class represents a wavelet. There are fives types of built in wavelets avaiable: Harr, Daubechies, Least Asymmetric, Best Localized, and Coiflet. | |

WeibullDistribution | Class WeibullDistribution represents the Weibull probability distribution. | |

WeibullParameterFunction | Distribution function. | |

WeightedRegressionAnova | Class for performing an Analysis Of Variance on a weighted linear least squares fit. | |

WilcoxonSignedRankTest | Class WilcoxonSignedRankTest tests if two paired sets of observed values differ from each other in a significant way. | |

ZBenchNormal | Computes the ZBench for normally distributed data, percent defective, and the parts per million defective. |

Structures

Structure | Description | |
---|---|---|

DiscreteWaveletTransformLevelT | Represents one level of a DWT decomposition. | |

DoubleComplex | The DoubleComplex struct represents a complex number, consisting of a real part and an imaginary part. | |

Extrema | Represents an imutable extrema of a function in two dimensions. | |

FloatComplex | The FloatComplex struct represents a complex number, consisting of a real part and an imaginary part. | |

IntPair | Class IntPair represents a pair of integers. |

Interfaces

Interface | Description | |
---|---|---|

IArnoldiShiftInvertOperations | Eigenvalue Arnoldi solver shift invert operations. | |

IBoundedNonlinearLeastSqMinimizer | Interface for nonlinear least squares minimizer where the solution is constrained by upper and lower bounds. | |

ICrossValidationSubsets | Interface for generating subsets of data to be used in a cross validation process. | |

IDFColumn | Interface for data frame column types. | |

IDifferentiator | Interface for classes that perform differentiation of a function at a point. | |

IDoubleComplexEnumerator | Classes that implement the IDoubleComplexEnumerator interface behave like regular IEnumerator implementations except that they return a DoubleComplex instead of an object. They avoid casting and are therefore much faster. | |

IDoubleEnumerator | Classes that implement the IDoubleEnumerator interface behave like regular IEnumerator implementations except that they return a double instead of an object. They avoid casting and are therefore much faster. | |

IDoubleLeastSqWeightingFunction | Interface for least squares weighting functions. | |

IFactorExtraction | Interface for factor extration algorithms used in factor analysis. | |

IFactorRotation | Interface for factor analysis factor rotation algorithms. Factors are rotated in order to maximize the relationship between the variables and some of the factors. | |

IFactorScores | Interface for factor score computation in a factor analysis. | |

IFloatComplexEnumerator | Classes that implement the IFloatComplexEnumerator interface behave like regular IEnumerator implementations except that they return a FloatComplex instead of an object. They avoid casting and are therefore much faster. | |

IFloatEnumerator | Classes that implement the IFloatEnumerator interface behave like regular IEnumerator implementations except that they return a float instead of an object. They avoid casting and are therefore much faster. | |

IIntegrator | Interface for classes that perform integration of a function over an interval. | |

ILinearConstraintCoefficients | Interface for the coefficients for a linear constraint in a non-linear optimization problem. The interface is an abstraction of a vector of real numbers representing the coefficients of a linear constraint and thus defines the indexer property [int index]. This interface allows for both sparse and dense implementations. | |

ILogisticRegressionCalc | Interface class for calculating the parameters of a logistic regression model. | |

IMultiVariableDMinimizer | Interface for classes that perform minimization of multivariate functions using derivative information. | |

IMultiVariableMinimizer | Interface for classes that perform minimization of multivariate functions. | |

INMFUpdateAlgorithm | Interface to be implemented by all Non-negative Matrix Factorization (NMF) update algorithms used by the NMFact class. | |

INonlinearLeastSqMinimizer | Interface for nonlinear least squares minimizer. | |

IOneVariableDMinimizer | Interface for classes that perform minimization of univariate functions using derivative information. | |

IOneVariableDRootFinder | Interface for classes that find roots of univariate functions using derivative information. | |

IOneVariableMinimizer | Interface for classes that perform minimization of univariate functions. | |

IOneVariableRootFinder | Interface for classes that find roots of univariate functions using only function evaluations. | |

IRandomNumberDistributionT | Interface for random number distributions. | |

IRandomVariableMoments | Interface implemented by probablility distributions. | |

IRegressionCalculation | Interface for classes used by class LinearRegression to calculate regression parameters. | |

ISliceableT | Implement this interface to indicate support of range slicing in a vector. | |

ISparseMatrixStorageT | Interface for general sparse matrix storage formats. | |

ISpecialFunctions | ||

SequentialQuadraticProgrammingSolverILagrangianHessianUpdater | Interface for classes which provide a method for obtaining the updated value of the Hessian of the Lagrangian based on the current iteration data for a Sequentail Quadratic Programming algorithm. | |

SequentialQuadraticProgrammingSolverIStepSizeCalculator | Computes a step size alphak for performing the update xk+1 = xk + alphak*pk, where pk is the step direction vector. |

Delegates

Delegate | Description | |
---|---|---|

DistanceFunction | Functor that takes two vectors and returns a measure of the distance (similarity) between them. | |

DoubleIterativelyReweightedLeastSqToleranceMetFunction | Tolerance met function delegate. | |

LinkageFunction | Functor that computes the linkage (similarity) between two groups. | |

OrderedConnectivityMatrixElementDistance | Given an entry aij in the connectivity matrix A, this delegate must return the distance between the elements i and j to be used for performing the hierarchical cluster analysis. | |

RandomNumberGeneratorUniformRandomNumber | Functor for generating uniform deviates between zero and one. |

Enumerations

Enumeration | Description | |
---|---|---|

ActiveSetLineSearchSQPTerminationStatus | Enum for possible algorithm termination reasons. | |

ArnoldiSolveStatus | Result of eigenvalue problem solve attempt using implicitly restarted Arnoldi iteration. | |

BairstowRootFinderSolveResultStatus | Status values indicating why iteration was terminated. | |

BalanceOption | Enumeration for specifying balancing options in eigenvalue decompositions. | |

BiasType | Enumeration for specifying a biased or unbiased estimator. | |

ConjugateTransposeOption | Enum specifying a particualr conjugate transpose option. | |

ConstrainedOptimizerSolveResult | Enum whose value indicate the status of the solution. | |

ConstrainedOptimizerORToolsSolveResult | Enum whose value indicate the status of the solution. | |

ConstraintType | Enumeration for specifying constraint types possible for the Constraint class and other constrained optimization classes.> | |

ControlLimits | Emum specifics types of control limits. | |

ConvolutionBaseWindowing | Options for handling the various convolution/correlation result boundaries. | |

ConvolutionMode | Controls internal funtion of convolution class. | |

CorrelationBaseWindowing | Options for handling the various convolution/correlation result boundaries. | |

CorrelationMode | ||

DiscreteDataIntegratorStrategy | Discrete data integration strategies. | |

DiscreteWaveletTransformThresholdMethod | Details thresholding methods. | |

DiscreteWaveletTransformThresholdPolicy | Thresholding policy to apply to details thresholding. | |

DiscreteWaveletTransformWaveletCoefficientType | The two types of wavelet coefficients. | |

DiscreteWaveletTransformWaveletMode | Method for padding the signal edges for improved DWT accuracy near signal edges. | |

DoubleRandomBetaDistributionGenerationMethod | Enumeration specifying different methods of random number generation. | |

DoubleRandomExponentialDistributionGenerationMethod | Enumeration specifying different methods of random number generation. | |

DoubleRandomGammaDistributionGenerationMethod | Enumeration specifying different methods of random number generation. | |

DoubleRandomGaussianDistributionGenerationMethod | Enumeration specifying different methods of random number generation. | |

DoubleRandomLogNormalDistributionGenerationMethod | Enumeration specifying different methods of random number generation. | |

DoubleRandomRayleighDistributionGenerationMethod | Enumeration specifying different methods of random number generation. | |

DoubleRandomUniformDistributionGenerationMethod | Enumeration specifying different methods of random number generation. | |

DoubleRandomWeibullDistributionGenerationMethod | Enumeration specifying different methods of random number generation. | |

DualSimplexCosting | Obsolete.Possible values for the dual simplex solver costing parameter. These values specify the pivoting strategy used by the solver. | |

FFTDirection | Direction of FFT. Used for building FFTConfiguration types. | |

FFTDomain | Forward Domain of FFT. Used for building FFTConfiguration types. | |

FFTPrecision | Precision of FFT transform. Used for building FFTConfiguration types. | |

FloatRandomBetaDistributionGenerationMethod | Enumeration specifying different methods of random number generation. | |

FloatRandomExponentialDistributionGenerationMethod | Enumeration specifying different methods of random number generation. | |

FloatRandomGammaDistributionGenerationMethod | Enumeration specifying different methods of random number generation. | |

FloatRandomGaussianDistributionGenerationMethod | Enumeration specifying different methods of random number generation. | |

FloatRandomLogNormalDistributionGenerationMethod | Enumeration specifying different methods of random number generation. | |

FloatRandomRayleighDistributionGenerationMethod | Enumeration specifying different methods of random number generation. | |

FloatRandomUniformDistributionGenerationMethod | Enumeration specifying different methods of random number generation. | |

FloatRandomWeibullDistributionGenerationMethod | Enumeration specifying different methods of random number generation. | |

HypothesisType | Enumeration for specifying the form of an alternative hypothesis in a hypothesis test. | |

IActiveSetQPSolverAlgorithmStatus | Enum whose value indicate the status of the solution. | |

InteriorPointQPSolverParamsKktFormOption | KKT form options for the interior point quadratic programming solver. | |

InteriorPointQPSolverParamsPresolveLevelOption | Presolve options for the interior point quadratic programming solver. | |

InteriorPointQPSolverParamsSymbolicOrderingOption | Options for symbolic ordering for the interior point quadratic programming solver. | |

IntervalType | An enumeration representing the possible interval types classified according to whether or not the endpoints are included in the interval. | |

IntRandomPoissonDistributionGenerationMethod | Enumeration specifying different methods of random number generation. | |

IntRandomUniformDistributionGenerationMethod | Enumeration specifying different methods of random number generation. | |

JohnsonTransformationType | Enumeration for specifying the type of transformation of a normal random variate in the Johnson system. | |

KMeansClusteringStart | An enumeration representing methods used to choose the initial cluster centers. | |

MovingWindowFilterBoundaryOption | Options for handling the boundaries in a moving window filter. | |

NonnegLeastSqTermination | Enumeration of possible nonnegative least squares algorithm termination states. | |

NormType | Enumeration for specifying different types of norms. | |

OdeSolverBaseOutputFunctionFlag | Output functions are functions supplied by the user to derived ODE solvers. These functions are called by solver during 1. Initialization. Before the first integration step is performed. 2. After each integration step. 3. When the solver is complete. Output functions are called with an OutputFunctionFlag parameter indicating under which of the above conditions it is being invoked. | |

ParameterSharing | Enum for indicating whether a parameter is shared or not in a global curve fit calculation. | |

PeakFinderBasePeakSortOrder | Enumeration for specifying sorting order. | |

PeakFinderRuleBasedRules | Rules to filter peaks. | |

Position | Enumeration for specifying different view positions of underlying data. | |

PrimalSimplexCosting | Costing algorithms supported by the primal simplex algorithm. | |

ProductTransposeOption | Enum for specifying transpose operations to be performed on the operands of a matrix-matrix multiply operation. | |

RandomNumberStreamBasicRandGenType | Enumeration for the various algorithms available for generating random numbers uniformly dstributed in the interval [0, 1] | |

RandomNumberStreamStreamStatus | Enum indicating the status of a random number stream. | |

SavitzkyGolayFilterSavitzyGolayBoundaryOptions | Enumeration specifying Savitsky-Golay boundary options. | |

SimplexSolverMixedIntParamsBranchingStrategies | Enumeration of branching strategies used in the branch-and-bound algorithm. | |

SimplexSolverMixedIntParamsSearchStrategies | Enumeration of options for search strategies for the mixed integer linear programming solver. | |

SortingType | Enumeration for specifying different sorting types, such as ascending or descending order. | |

SparseMatrixFactTError | Enumeration for specifying possible return values for errors. | |

SparseMatrixFactTMatrixType | Enumeration for specifying the types of matrices that can be factored. | |

SparsePLSMode | Partial Least Squares Mode. | |

StorageType | Enumeration for specifying the storage scheme of a matrix. | |

TriangularMatrixTypes | Enumeration for specifying the storage scheme of a matrix. | |

TrustRegionMinimizerCheck | Options for checking the arrays passed into the solver as input parameters. If an array contains any INF or NaN values an exception will be thrown. | |

TrustRegionMinimizerCriterion | Enumeration for specifying the stop criterion. | |

TwoWayAnovaUnbalancedParameterOrder | Enumeration indicating the factors and their order in a sum of squares computation. | |

WaveletWavelets | Built-in wavelets organized by short name. The first letter abbreviates the wavelet family name, and number that follows, the wavelet length. |