Softpedia >Windows >Programming >Components & Libraries >NMath >  Changelog

NMath Changelog

What's new in NMath 6.2.0

Apr 11, 2016
  • Added Discrete Wavelet Transforms (DWT)
  • Stiff ODE solver
  • Improved peak finder

New in NMath 6.1.0 (May 1, 2015)

  • Upgraded to Intel MKL 11.2 Update 2 with resulting performance increases.
  • 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.

New in NMath 6.0 (Aug 26, 2014)

  • Upgraded to Intel MKL 11.1 Update 3 with resulting performance increases.
  • 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.
  • 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).
  • 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.

New in NMath 5.3.0 (Jun 12, 2013)

  • Upgraded to Intel MKL 11.0 Update 3 with resulting performance increases
  • See http://software.intel.com/en-us/articles/intel-mkl-110-release-notes
  • 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()

New in NMath 5.2.0 (Aug 9, 2012)

  • 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.
  • 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.

New in NMath 5.1.0 (Nov 9, 2011)

  • 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)

New in NMath 5.0.0 (Nov 9, 2011)

  • 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
  • Sobal 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

New in NMath 4.1.0 (Nov 9, 2011)

  • 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

New in NMath 4.0 (Nov 16, 2009)

  • Merged NMath Core, Matrix, Analysis into NMath.
  • Added Fast Fourier Transforms (FFT), convolution and correlation.
  • Simpler configuration and deployment.
  • Performance improvements.

New in NMath 2.6 (Apr 14, 2009)

  • Added visualizers for easier debugging, some additional convenience methods, performance improvments and a switch to Intel MKL 10.1 Update 2. Calculations distributed to all cores on multi-core machines.

New in NMath 2.5 (Apr 3, 2009)

  • Now ships with 64-bit prebuilt assemblies. Miscellaneous bug fixes especially with respect to threading. Faster computation.