What’s new in NMath V6?
- Upgraded to Intel MKL 11.1 Update 3 with resulting performance increases.
- 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.
- Added classes for solving nonlinear programming problems using the Stochastic Hill Climbing algorithm, for solving quadratic programming problems using an interior point algorithm, and for solving constrained least squares problems using quadratic programming methods.
- Added support for MKL Conditional Numerical Reproducibility (CNR).
What’s new in NMath V5.3?
- IEnumerable support for matrix classes, facilitating their use with LINQ.
- An in-place solve option for LU factorization.
- Improved support for NMath configuration within ASP.NET web applications.
- Matrix and vector visualizers for debugging in Visual Studio 2012.
- Performance increases in several areas, due to an upgrade to Intel MKL 11.0 Update 3.
What's new in NMath V5.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. Logging can be enabled for debugging configuration issues
- Replaced all custom NMath delegate types in the API with Func or Action equivalents, and deprecated the older signatures
- Added support for postive and negative strided signals in all FFT classes
NMath and NMath Stats libraries are now available for use in developing applications on Mono. The Mono versions include all of the same features as the .NET/Windows libraries, with native code compiled for Linux and Mac OS X.
What's new in NMath V5.1?
- Added assembly NMathChartMicrosoft.dll containing class NMathChart, which provides static methods for plotting NMath types using the Microsoft Chart Controls for .NET.
- Upgraded to Intel MKL 10.3 Update 6 with resulting performance increases.
- 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).
What's new in NMath V5.0?
- A new set of random number generator classes based on MKL vectorized random number generators
- Classes for creating independent streams of random numbers using the leapfrop and skip-ahead methods
- Classes for generating quasirandom sequences using Niederreiter and Sobal methods
- Classes for solving quadratic programming (QP) and nonlinear programming (NLP) problems
What's new in NMath V4.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 <Type>GSVDecomp and <Type>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.
What's new in NMath V4.0?
- Fast Fourier Transforms (FFTs)- NMath 4.0 contains high performance, multi-core aware FFT classes. This set of classes will support all common 1D and 2D FFT computations in a robust easy-to-use object-oriented interface. All classes will efficiently support FFT’s of arbitrary length, with a simple interface for both in-place and out-of-place computations. Additionally, there is a parallel set of classes for single precision computation.
- Levenberg-Marquardt Nonlinear Least Squares - NMath 4.0 includes class LevenbergMarquardtMinimizer for minimizing the L2 norm of a function using the Levenberg-Marquardt algorithm (LMA). LMA is a standard in non-linear optimization, and is widely used for solving generic curve-fitting problems. LMA significantly outperforms gradient descent and conjugate gradient methods for medium sized problems, and complements the Trust Region minimizer already in NMath.
- Linear Spline Interpolation- NMath 4.0 includes a class LinearSpline for representing a function whose values are determined by linear interpolation between tabulated values.
- MKL Version 10.2 - NMath 4.0 now leverages Intel’s MKL Version 10.2. This provides many performance improvements for faster execution and taking advantage of more cores. It now also can take advantage of threading on more cores and more CPUs. These speed improvements generally range from 10% to 25%, and if you have a 24 core machine, the improvement can be as high as 130 times as great.
- AnyCPU configuration - Use AnyCPU configuration to build one application that automatically loads native x86 or x64 code as required.
What's new in NMath?
- Custom debug visualizers for matrix and vector classes.
- Improved performance on multi-core computers.
- General sparse matrix classes and factorizations (NMath Matrix)
- Weighted least squares (WLS) by complete orthogonal (CO) decomposition.
- Iteratively reweighted least squares (IRLS)
- Nonlinear least squares minimization using the Trust-Region method, a variant of the Levenberg-Marquardt method.
- Curve and surface fitting by nonlinear least squares.
NMath Core is part of CenterSpace Software’s NMath product suite, which provides object-oriented components for math, engineering, scientific, and financial applications on the .NET platform. NMath Core is the foundational library in the suite, and provides basic numerical building blocks such as vector and matrix classes, complex number classes, and random number generators. For most computations, NMath Core uses machine-specific, highly-optimized versions of the C and FORTRAN public domain computing packages known as the BLAS (Basic Linear Algebra Subroutines) and LAPACK (Linear Algebra PACKage). This gives NMath Core classes performance levels comparable to C, and often results in performance an order of magnitude faster than non-platformoptimized implementations.
Fully compliant with the Microsoft Common Language Specification, all NMath Core routines are callable from any .NET language, including C#, Visual Basic.NET, and Managed C++.
NMath Core Product features include:
- Single- and double-precision complex number classes
- Full-featured vector and matrix classes for single- and double-precision floating point numbers and single- and double-precision complex numbers
- Flexible indexing using slices and ranges
- Cubic spline interpolation
- Extension of standard mathematical functions, such as Cos(), Sqrt(), and Exp(), to work with vectors, matrices, and complex number classes
- LU factorization for a matrix, as well as functions for solving linear systems, computing determinants, inverses, and condition numbers
- Least squares solutions
- Random number generation from various probability distributions, including the uniform, normal, Poisson, gamma, binomial, exponential, Pareto, and log normal distributions
- Classes for encapsulating functions of one variable, with support for numerical integration (Romberg and Gauss-Kronrod methods), differentiation (Ridders' method), and algebraic manipulation of functions
- Polynomial encapsulation, interpolation, and exact differentiation and integration.
- Source code version available
- Prebuilt 64-bit assemblies are included
NMath Analysis contains classes for function minimization, root-finding, and linear programming.
NMath Analysis Product features include:
- Classes for minimizing univariate functions using golden section search and Brent's method.
- Classes for minimizing multivariate functions using the downhill simplex method, Powell's direction set method, the conjugate gradient method, and the variable metric (or quasi-Newton) method.
- Simulated annealing.
- Linear programming using the simplex method.
- Least squares polynomial fitting.
- Classes for finding roots of univariate functions using the secant method, Ridders' method, and the Newton-Raphson method.
- Numerical methods for double integration of functions of two variables.
NMath Matrix is part of CenterSpace Software’s NMath product suite, which provides object-oriented components for mathematical, engineering, scientific, and financial applications on the .NET platform. NMath Matrix extends the foundational library NMath Core to include structured sparse matrix classes and factorizations, general matrix decompositions, advanced least squares solutions, and solutions to eigenvalue problems.
Like NMath Core, NMath Matrix uses machine-specific, highly-optimized versions of the BLAS and LAPACK for most computations. This gives NMath Matrix classes performance levels comparable to C or Fortran. NMath Matrix is an advanced matrix manipulation library that extends NMath Core to include structured sparse matrix classes (triangular, symmetric, Hermitian, banded, tridiagonal, symmetric banded, and Hermitian banded), factorizations (LU, Bunch-Kaufman, and Cholesky), orthogonal decompositions (QR and SVD), advanced least squares classes (Cholesky, QR, and SVD), and solutions to symmetric, Hermitian, and nonsymmetric eigenvalue problems.
Fully compliant with the Microsoft Common Language Specification, all NMath routines are callable from any .NET language, including C# and Visual Basic.NET. For most computations, NMath libraries use proven, highly optimized versions of public domain linear algebra subroutine libraries, such as the BLAS and LAPACK. This gives NMath routines accuracy you can trust, and performance levels comparable to C or Fortran, combined with state of the art, object-oriented interfaces that leverage the full power of the .NET platform.