Version 7.4
– Upgraded to MKL 2022.0
– Added Stationary Wavelet Transform (SWT)

Version 7.3
– Added Schur decomposition
– Removed old namespaces
– Updated examples
– Improved handling of NaN and infinity in trust-region minimizer

Version 7.2
– Upgraded to MKL 2021.1
– Pardiso fixes
– Improved precision in normal distribution
– Fixes for FFT on linux
– Google ORTools referenced as Nuget package
– Improved Bairstow root finder
– Opened up internal constructors

Version 7.1
– Improved ARPACK
– Upgraded to MKL 2020.4
– Charting improvements

Version 7.0
– 32-bit support has been dropped. Demand for this has been waning for years. Dropping it has made library usage simpler and easier.
– GPU support has been dropped. As developers, we liked the automatic GPU offloading. However, the technical advantages have dissipated as multi-core processors have improved. We believe that this is no longer compelling for a general math library.
– NMath Stats has been merged into NMath. This is for ease of use for our users as nearly all customers bought both libraries.
– In summer of 2019, our pricing will be streamlined to reflect these changes. There will be one price for a perpetual NMath license and there will be one price for annual NMath maintenance which includes technical support and all upgrades available on NuGet. NMath Stats will no longer be sold separately.
– To simplify development, we have merged the four NMath namespaces into one, CenterSpace.NMath.Core. Originally, CenterSpace had four NMath products and four namespaces, these namespaces CenterSpace.NMath.Core, CenterSpace.NMath.Matrix, CenterSpace.NMath.Stats, CenterSpace.NMath.Analysis reflect that history. We have left namespace stubs so users won’t experience any breaking changes during library upgrades.
– We have dropped charting. The ecosystem is full of powerful visualization packages. We have only three main data structures in NMath: vectors, matrices and data frames; all of which can be easily visualized with different charting packages.
– Some of our optimizations use Microsoft Solver Foundation. If you use these, you’ll need be on the .NET Framework track and not on the .NET Core track.
– We have dropped the installers. The ubiquity and compelling ease of NuGet for our users has made these obsolete.

Version 6.2
– Upgraded to Intel MKL 11.3 Update 2 with resulting performance increases. See
– Updated NMath Premium GPU code to CUDA 7.5.
– NMath Premium no longer supports GPU computation on 32-bit systems. 32-bit machines automatically revert to CPU-only mode.
– Added Visual Studio 2015 example solutions and visualizers.
– Added classes FloatWavelet, DoubleWavelet, FloatDWT, DoubleDWT, and other related classes for performing Discrete Wavelet Transforms (DWTs) using most common wavelet families, including Harr, Daubechies, Symlet, Best Localized, and Coiflet.
– Added class VariableOrderOdeSolver for solving stiff and non-stiff ordinary differential equations. The algorithm uses higher order methods and smaller step size when the solution varies rapidly.
– Added class PeakFinderRuleBased for finding peaks subject to rules about peak height and peak separation (analogous to MATLAB’s findpeaks() function).
– Added class FZero for finding roots of univariate functions using the zeroin() root finder published originally in Computer Methods for Mathematical Computations by Forsythe, Malcolm and Moler in 1977. This class is similar to MATLAB’s fzero() function.
– Added MaxSeconds property to ActiveSetQPSolver for getting and setting the maximum number of seconds to spend in the inequality constrained QP solver.
– Added static FromPolar() methods to FloatComplexVector and DoubleComplexVector.
– Added PDF() and CDF() methods to class Histogram.
– Added ToGeneralMatrix() methods to structured sparse matrix types, equivalent to calling MatrixFunctions.ToGeneralMatrix().
– Added overloads of MatrixFunctions.Conj() method for calculating the complex conjugates of a general sparse matrix’s elements.
– Added function IsLinear() to QuadraticProgrammingProblem to check whether the problem is in fact a linear programming problem.

Version 6.1
– Upgraded to Intel MKL 11.2 Update 2 with resulting performance increases. See
– Updated NMath Premium GPU code to CUDA 6.
– Improved logging of dependency checks for Visual C++ runtime and Intel OMP threading library.
– Added class MixedIntegerLinearProgrammingProblem and related classes for solving linear programming problems with integer or binary constraints.
– Added class MixedIntegerNonlinearProgrammingProblem and related classes for solving nonlinear programming problems with integer or binary constraints.
– Added class SpecialFunctions containing special functions such as factorial, binomial, the gamma function and related functions, Bessel functions, elliptic integrals, and many more. (Prior versions of a few these functions, such as StatsFunctions.IncompleteGamma, are now deprecated.) Added a new native library, nmath_sf_x86.dll and nmath_sf_x64.dll, with C language implementations of the special functions.
– Added single-precision versions of general sparse matrix and vector types.
– Added Conj() method to DoubleComplex and FloatComplex types and deprecated the static function Conj() on the same types.
– Fixed a bug in FFT configuration disposal in highly threaded applications.
– Changed the default seed in RandGenMTwist to use current ticks rather than milliseconds.
– Added a constructor to RandomNumberStream specifying the BasicRandGenType, but not the seed.
– Added an overload to RombergIntegrator.Integrate() which takes x, y values, equivalent to the MATLAB ‘trapz’ functions.
– Added property SecondDerivativeAtControlPoints to CubicSpine to expose the computed second derivative of the spine at each control point.

Version 6.0
– Upgraded to Intel MKL 11.1 Update 3 with resulting performance increases. See
– Added Adaptive Bridge™ technology to NMath Premium edition, with support for multiple GPUs, per-thread control for binding threads to GPUs, and automatic performance tuning of individual CPU–GPU routing to insure optimal hardware usage. See Chapter 33 in the NMath User’s Guide for more information.
– NMath linear programming, nonlinear programming, and quadratic programming classes are now built on the Microsoft Solver Foundation (MSF). The Standard Edition of MSF is included with NMath (Microsoft.Solver.Foundation.dll).
– Added class StochasticHillClimbingSolver for solving nonlinear programming problems using the Stochastic Hill Climbing algorithm.
– Added class InteriorPointQPSolver for solving quadratic programming problems using an interior point algorithm.
– Added classes ConstrainedLeastSquaresProblem and ConstrainedLeastSquares for solving constrained least squares problems using quadratic programming methods.
– Added method NMathConfiguration.SetMKLNumThreads(), and equivalent environment variable and app config setting, for specifying the suggested number of threads used by MKL. NMath single-threaded (sequential) natives are no longer available–instead, set the number of MKL threads to 1.
– Added support for MKL Conditional Numerical Reproducibility (CNR). For more information see Section 1.6 in the NMath User’s Guide.
– Added class SmoothCubicSpline with a smoothing factor in the range 0 to 1, where 0 results in zero curvature (linear interpolation), and 1 results in a conventional cubic spline.
– Added class SparseMatrixBuilder with matrix-like row and column indexing for setting and retrieving sparse matrix values.
– Fixed bug with repeated calls to NMathConfiguration.NativeLocation overflowing the PATH length.
– More robust sum of squares implementation for floats and doubles. Leads to more robust variance and standard deviation.

Version 5.3
– Upgraded to Intel MKL 11.0 Update 3 with resulting performance increases. See
– Added GPU acceleration of linear algebra (dense) and 1D and 2D FFT. Requires NMath Premium edition and CUDA-enabled NVIDIA graphics card. For more information, see CenterSpace whitepaper “NMath Premium: GPU-Accelerated Math Libraries for .NET”, or the NMath User’s Guide.
– The NMath kernel assembly and platform-specific native libraries are now loaded at runtime from an /x86 or /x64 subdirectory of the specified native location (as set, for example, by property NMathConfiguration.NativeLocation).
– Deprecated configuration property NMathConfiguration.UseExternalThreading. The default NMath native assembly (nmath_native_[x86|x64].dll) is now built with dynamically-linked Intel OMP threading library (libiomp).
– Implemented IEnumerable for matrix classes, and fixed issues with generic iterator for vector classes, such as implmenting Reset().
– Added matrix and vector visualizers for Visual Studio 2012 debugging, with support complex types.
– Fixed a bug in the FloatSymmetricSignalReader related to using signal vectors longer than necessary.
– Added an in-place solve option to LU factorization classes.
– Added vectorized performance enhancement to NMathFunction.Abs()
– Implemented ICloneable on DoubleFunctional, DoubleMultivariableFunctional and DoubleParameterizedFunctional.
– Improved support for NMath configuration paths when deploying web applications.
– Exposed filename for NMathConfiguration log file.
– Added a check for OMP threading library in PATH if external threading is specified.
– Throw LicenseException on expired license, rather than Environment.Exit().

Version 5.2
– Upgraded to Intel MKL 10.3 Update 11 with resulting performance increases.
– Added class NMathConfiguration for controlling the loading of the NMath license key, kernel assembly, and native library. License files are no longer used. Logging can be enabled for debugging configuration issues. See Chp 1 in the NMath User’s Guide for more information.
– Replaced all custom NMath delegate types in the API with Func<>/Action<> equivalents, and deprecated the older signatures.
– Added support for postive and negative strided signals in all FFT classes.
– Fixed bug in DoubleSymmetricSignalReader.UnpackSymmetricHalfToVector(), in which the last element was not read.
– Fixed bug in ResizeAndClear() of vector classes.
– Removed previously deprecated OneVariableFunctionFitter and MultiVariableFunctionFitter classes. Use templatized OneVariableFunctionFitter and MultiVariableFunctionFitter instead.
– Made Slice.All and Range.All singletons for greater efficiency.
– Exposed OptimalX property of quadratic programmming classes.
– Added Set() method to all matrix and vector classes for setting all elements to a given value.

Version 5.1
– Simplified the NMath installer. Updated license keys will be issued upon upgrade. A license file must now be deployed with your NMath applications.
– Upgraded to Intel MKL 10.3 Update 6 with resulting performance increases.
– Removed assembly NMathShared.dll.
– Added assembly NMathChartMicrosoft.dll containing class NMathChart, which provides static methods for plotting NMath types using the Microsoft Chart Controls for .NET. (For more information, see whitepaper “NMath Visualization Using the Microsoft Chart Controls.”)
– Added classes for solving first order initial value differential equations by the Runge-Kutta method. Class FirstOrderInitialValueProblem encapsulates a first order initial value differential equation, and class RungeKuttaSolver solves them.
– Added static method NMathFunctions.NaNSort() for sorting vectors containing NaN’s. NMathFunctions.Sort() no longer supports vectors containing NaN’s.
– NMathFunctions.Sort() now does a much faster in-place sort for compact vectors and an out-of-place sort for strided vectors. Previously all sorting was done out-of-place.
– Added method NMathFunctions.Sign() that applies the signum function over real vectors.
– Redesigned method NMathFunctions.Median(), which is now approximately 25X faster.
– Added new Fill() method to vectorized random number generators for filling a DoubleVector.
– Added NMathFunctions.CumulativeProduct() methods.
– Improved performance of NMathFunctions.OuterProduct().
– Added exponential moving average filter weights to class MovingWindowFilter.
– Added MatrixFunctions.Solve() methods for factoring and solving general sparse matrices.
– Added class LevenbergMarquardtMinimizer and deprecated LevenburgMarquardtMinimizer.
– Added static method NMathKernel.Init() for explicitly loading the kernel assembly (for example, on application start-up).

Version 5.0
– Upgraded to Intel MKL 10.3 Update 2 with resulting performance increases.
– Added a new set of random number generator classes based on MKL vectorized random number generators.
Continuous distributions: FloatRandomBetaDistribution, DoubleRandomBetaDistribution FloatRandomCauchyDistribution, DoubleRandomCauchyDistribution FloatRandomExponentialDistribution, DoubleRandomExponentialDistribution FloatRandomGammaDistribution, DoubleRandomGammaDistribution FloatRandomGaussianDistribution, DoubleRandomGaussianDistribution FloatRandomGumbelDistribution, DoubleRandomGumbelDistribution FloatRandomLaplaceDistribution, DoubleRandomLaplaceDistribution FloatRandomLogNormalDistribution, DoubleRandomLogNormalDistribution FloatRandomRayleighDistribution, DoubleRandomRayleighDistribution FloatRandomUniformDistribution, DoubleRandomUniformDistribution FloatRandomWeibullDistribution, DoubleRandomWeibullDistribution
Discrete distributions: IntRandomBernoulliDistribution IntRandomBinomialDistribution IntRandomGeometricDistribution IntRandomHypergeometricDistribution IntRandomNegativeBionomialDistribution IntRandomPoissonDistribution IntRandomPoissonVaryingMeanDistribution IntRandomUniformBitsDistribution IntRandomUniformDistribution
– Added class RandomNumberStream to encapsulate a stream of random numbers, and class RandomNumbers, an adapter for the RandomNumberStream class to give the same behavior as a scalar-type random number generator.
– Added class IndependentRandomStreams for creating streams of independent random numbers, classes LeapfrogStream and LeapfrogRandomStreams for creating independent random streams using the leapfrog method, and classes SkipAheadStream and SkipAheadRandomStreams for creating streams of independent random numbers using the skip-ahead method.
– Added classes QuasiRandomNumberGenerator for generating sequences of quasirandom points, class NiederreiterQuasiRandomGenerator for generating quasirandom numbers using the Niederreiter method, and class SobolQuasiRandomGenerator for generating quasirandom numbers using the Sobol method.
– Added classes for solving quadratic programming (QP) and nonlinear programming (NLP) problems. Classes DoubleFunctional and DoubleFunctionalDelegate encapsulate objective functions. Classes LinearConstraint and NonlinearConstraint derive from abstract base class Constraint and encapsulate problem constraints. Class QuadraticProgrammingProblem encapsulates a QP problem, and class ActiveSetQPSolver solves QP problems using an active set algorithm. Class NonlinearProgrammingProblem encapsulates an NLP problem. NMath solves NLP problems iteratively, using a sequential quadratic programming (SQP) algorithm. Class SequentialQuadraticProgrammingSolver is the abstract base class for SQP solvers, and concrete implementation ActiveSetLineSearchSQP solves NLP problems using an active set algorithm. Class ConstantSQPStepSize computes a constant step size for a SQP solver, and class L1MeritStepSize computes the step size based on sufficient decrease in the L1 merit function. Class LagrangianFunction represents the Lagrangian function associated with a NLP, and class DampedBFGSHessianUpdater updates the value of the Lagrangian Hessian based on iterate values using a quasi-Newton approximation.
– Added new class KFoldsSubsets and deprecated the class KFoldSubsets to fix error with cross-validation subsets.
– Added two-argument NMathFunctions.Cross() method.
– Added NMathFunctions methods for complex numbers MaxAbs1Value(), MaxAbs1Index(), MinAbs1Value(), and MinAbs1Index() which compute the absolute value of a complex number as the sum of magnitudes of the real and imaginary parts, and modified methods MaxAbsValue(), MaxAbsIndex(), MinAbsValue(), and MinAbsIndex() to use the Euclidean distance.
– Fixed a memory leak in convolution code.

Version 4.1
– Upgraded to Intel MKL 10.2 Update 5 with resulting performance increases.
– Replaced CLI C++ kernel with a pure C# kernel that invokes MKL using PInvoke() to improve .NET 4.0 experience.
– Added class FirstOrderInitialValueProblem to encapsulate a first order initial value differential equation.
– Added class RungeKuttaSolver for solving first order initial value differential equations by the Runge-Kutta method.
– Added SavitzkyGolay class to generate filtering coefficients for data smoothing or for computing smooth Nth-derivatives in noisy data.
– Added a SavitzkyGolayFilter class to both smooth data or compute the smoothed n-derivative of the the data. New boundary handling options for smooth transitions to the data boundaries.
– Added INonlinearLeastSqMinimizer and IBoundedNonlinearLeastSqMinimizer interfaces. Class TrustRegionMinimizer now implements IBoundedNonlinearLeastSqMinimizer. Class LevenburgMarquardtMinimizer now implements INonlinearLeastSqMinimizer.
– Added classes BoundedOneVariableFunctionFitter and BoundedMultiVariableFunctionFitter which derive from OneVariableFunctionFitter and MultiVariableFunctionFitter, respectively, and accept linear bounds on the solution.
– Class OneVariableFunctionFitter is now templatized on INonlinearLeastSqMinimizer, and BoundedOneVariableFunctionFitter is templatized on IBoundedNonlinearLeastSqMinimizer.
– Class MultiVariableFunctionFitter is now templatized on INonlinearLeastSqMinimizer, and class BoundedMultiVariableFunction is templatized on IBoundedNonlinearLeastSqMinimizer.
– Added GSVDecomp and GSVDecompServer classes to compute the generalized singular value decomposition (GSVD) of a pair of general rectangular matrices.
– Added class BoxCoxTransformation which performs a Box-Cox power transformation to make non-normal data resemble normally-distributed data.
– Added accessor for the Hessian in class VariableMetricMinimizer.
– Added “force through origin” option to class PolynomialLeastSquares.
– Fixed several minor issues with CLS compliance.

Version 4.0
– Upgraded to Intel MKL 10.2 Update 1.
– Repackaged CenterSpace.NMath.Core, CenterSpace.NMath.Matrix, and CenterSpace.NMath.Analysis namespaces into a single product to simplify product dependencies.
– Reconfigured the NMath CLI C++ kernel to load the appropriate native kernel (32-bit or 64-bit) at runtime. You can now build your NMath application using the “Any CPU” build configuration, and deploy to either 32-bit or 64-bit environments.
– Added classes FloatForward1DFFT, DoubleForward1DFFT, FloatComplexForward1DFFT, and DoubleComplexForward1DFFT to the CenterSpace.NMath.Core namespace for calculating the 1D discrete fourier transform (DFT).
– Added classes FloatComplexBackward1DFFT and DoubleComplexBackward1DFFT to the CenterSpace.NMath.Core namespace for calculating the inverse 1D DFT.
– Added classes FloatForward2DFFT, DoubleForward2DFFT, FloatComplexForward2DFFT, and DoubleComplexForward2DFFT to the CenterSpace.NMath.Core namespace for calculating the 2D discrete fourier transform (DFT).
– Added classes FloatComplexBackward2DFFT and and DoubleComplexBackward2DFFT to the CenterSpace.NMath.Core namespace for calculating the inverse 2D DFT.
– Added classes FloatSymmetricBackward1DFFT and DoubleSymmetricBackward1DFFT to the CenterSpace.NMath.Core namespace for exploiting the complex conjugate symmetry of forward FFT results computed on real data when inverting this data back to the real domain.
– Added classes FloatSymmetricSignalReader, FloatSymmetric2DSignalReader, DoubleSymmetricSignalReader, and DoubleSymmetric2DSignalReader to the CenterSpace.NMath.Core namespace for unpacking symmetric complex conjugate signals.
– Added advanced, highly configurable classes FFTConfiguration, FloatGeneral1DFFT, and DoubleGeneral1DFFT to the CenterSpace.NMath.Core namespace for computing FFTs with strided signal data.
– Added classes Float1DConvolution, Double1DConvolution, FloatComplex1DConvolution, and DoubleComplex1DConvolution to the CenterSpace.NMath.Core namespace for performing linear convolutions on real and complex 1D data.
– Added classes Float1DCorrelation, Double1DCorrelation, FloatComplex1DCorrelation, and DoubleComplex1DCorrelation to the CenterSpace.NMath.Core namespace for performing linear correlation on real and complex 1D data.
– Added FrobeniusNorm() methods to NMath general matrix classes for computing the Frobenius norm.
– Added class LevenburgMarquardtMinimizer to the CenterSpace.NMath.Analysis namespace for solving nonlinear least squares problems using the Levenberg-Marquardt method.

NMath was previously distributed as three separate products:
NMath Core, NMath Matrix, and NMath Analysis.

NMath Core Version 2.6
– Upgraded to Intel MKL 10.1 Update 2.
– Added custom visualizers for matrix and vector classes.
– Added overload to DoubleVector.Add() method for adding a vector to another vector in place.
– Improved efficiency of NMathFunctions.SumOfSquares().
– Added MNMathFunctions.Pseudoinverse() method using transpose and inverse.
– Organized classes into solution folders inside Visual Studio.
– Added VS 2008 solutions for all examples and source editions.
– Added Add(System.Object) method to all types which implement IEnumerable.

NMath Matrix Version 3.0
– Upgraded to Intel MKL 10.1 Update 1.
– Added class DoubleCOWeightedLeastSq for solving weighted least squares (WLS) problems using a complete orthogonal (CO) decomposition technique.
– Added class DoubleIterativelyReweightedLeastSq for solving iteratively reweighted least squares (IRLS) problems.
– Added classes DoubleLeastSqWeightingFunction, DoubleBisquareWeightingFunction, and DoubleFairWeightingFunction for least squares weighting functions.
– Added classes DoubleSparseVector, DoubleComplexSparseVector, and SparseVectorData for storing sparse vectors.
– Added classes DoubleCsrSparseMatrix, DoubleSymCsrSparseMatrix, DoubleComplexCsrSparseMatrix, DoubleHermCsrSparseMatrix, SparseMatrixData, ISparseMatrixStorage, and CompressedSparseRow for storing general sparse matrices in compressed sparse row (CSR) format.
– Added classes SparseMatrixFact, DoubleSparseFact, DoubleSparseSymFact, DoubleSparseSymPDFact, DoubleComplexSparseFact, DoubleSparseHermFact, and DoubleSparseHermPDFact for factoring general sparse matrices.
– Added MatrixFunctions.Pseudoinverse() method using SVD.
– Organized classes into solution folders inside Visual Studio.
– Added VS 2008 solutions for all examples and source editions.
– Added Add(System.Object) method to all types which implement IEnumerable.

NMath Analysis Version 2.0
– Upgraded to Intel MKL 10.1 Update 1.
– Added class TrustRegionMinimizer for solving both constrained and unconstrained nonlinear least squares problems using the Trust Region method, a variant of the Levenberg-Marquardt method.
– Added class OneVariableFunctionFitter for fitting generalized one variable functions to data.
– Added class MultiVariableFunctionFitter for fitting generalized multivariable functions to data.
– Organized classes into solution folders inside Visual Studio.
– Added VS 2008 solutions for all examples and source editions.
– Added Add(System.Object) method to all types which implement IEnumerable.