What's New in Numerics.NET Version 10.0

Version 10 of Numerics.NET continues our focus on clarity, consistency, and solid engineering. This release aligns with .NET 10 and consolidates the improvements introduced throughout the 9.x cycle into a unified, long-term support milestone. It introduces new capabilities, refines long-standing APIs, and extends the numerical and statistical toolbox in several useful directions.

If you’re upgrading from v9, the transition should be smooth. Most APIs are unchanged, and newly added features are additive.

Updated .NET Support

Numerics.NET v10 supports the following frameworks:

  • .NET 10 (new)
  • .NET 8 and .NET 9
  • .NET Framework 4.6.2
  • .NET Standard 2.0

Two older, out-of-support platforms have been removed:

  • Dropped: .NET Core 3.1
  • Dropped: .NET 6.0

This ensures consistency with Microsoft’s current support policies.

v10 also supports C# 14 features like compound assignment operators for vectors, matrices, and tensors.

Modern Matrix and Vector Construction

v10 introduces a more consistent and intention-revealing API for creating matrices and vectors. The goal is to remove ambiguity, make intent crystal clear, and make code easier to read and maintain.

Generative constructors

The new static factory methods create matrices and vectors from scratch:

C# 
var zeros  = Matrix.Zeros<double>(5, 5);
var random = Matrix.Random(3, 4);

You can also create matrices and vectors from collection expressions:

C# 
Vector&lt;double&gt; v = [1.0, 2.0, 3.0, 4.0, 5.0];
Matrix&lt;double&gt; m =
   [[1.0, 2.0],
    [3.0, 4.0]];

Clear copy vs. wrap semantics

The previous Create* methods combined both copy and wrap semantics, which could lead to confusion about whether data was being duplicated or referenced.

The new factory methods make this distinction explicit: methods that copy data into a new matrix are prefixed with CopyFrom, while those that wrap existing buffers without copying use the Wrap prefix.

C# 
// Copy data into a new matrix
var A = Matrix.CopyFrom(data);

// Wrap an existing buffer without copying
var B = Matrix.Wrap(buffer, rows: 100, cols: 100);

Shape-aware creation

New methods allow you to create matrices directly from collections of rows or columns:

C# 
var C = Matrix.FromRows(rowArrays);
var D = Matrix.FromColumns(columnArrays);

Specialized constructors are also available for symmetric, Hermitian, triangular, and diagonal matrices.

Legacy Create* methods remain available in v10 but are now marked obsolete and will be removed in a future release.

Interpolation

v10 introduces a new static Interpolation class for common one-off interpolation tasks and simple curve creation.

One-off interpolation

In some scenarios, all you need is a quick interpolation result. The new Interpolation class allows you to perform interpolation without creating a full interpolator object. The new static methods cover the most common cases:

C# 
var smooth  = Interpolation.Cubic(x, y, xQuery);
var linear  = Interpolation.Linear(x, y, xQuery);
var inverse = Interpolation.InverseLinear(x, y, yQuery);

Transformed interpolation

Several new transformed interpolation methods are included:

  • Log-linear: Interpolates linearly in log(x) space, suitable for data spanning orders of magnitude on the x-axis.
  • Log-log: Interpolates linearly in log(x)–log(y) space, preserving power-law relationships.
  • Periodic: Treats the data as repeating seamlessly across the domain; endpoints are joined smoothly.
  • Circular: Interpolates angular data (e.g., degrees or radians) using the shortest arc across the 2π wrap-around.

Examples:

C# 
var hourly = Interpolation.Periodic(x, y, xQuery, period: 24);
var logfit = Interpolation.LogLinear(x, y, xQuery);

Convenience methods

For scenarios where you need to create an interpolating curve for repeated use, the Interpolation class provides static methods that return fully configured interpolator instances:

C# 
var linear  = Interpolation.PiecewiseLinearCurve(x, y);
var spline = Interpolation.CubicSpline(x, y);
var akima  = Interpolation.AkimaSpline(x, y);

1D Signal Processing

v10 adds two significant improvements for signal processing:

1. A new SignalMath convenience class

This class provides high-level operations for common signal processing workflows:

  • Fourier transforms (real and complex)
  • Convolution, cross-correlation and autocorrelation
  • Windowing (Hamming, Hanning, Blackman, and others)
  • Power spectral density estimation

Example:

C# 
var spectrum = SignalMath.FourierTransform(signal);
var corr = SignalMath.Convolve(signal, kernel, mode: ConvolutionMode.Same);

2. Optimized convolution and cross-correlation

Behind the convenience methods, v10 introduces implementations with:

  • Configurable padding modes (zero, constant, reflect, replicate, wrap)
  • Control over the anchor/origin of the kernel
  • Automatic selection between direct and FFT-based methods
  • Optimized application of the same kernel to multiple signals
  • Support for both real and complex signals

These improvements offer more control when needed and better performance for large inputs.

3. Other Improvements

  • Discrete Cosine Transform (DCT/IDCT) and Discrete Sine Transform (DST/IDST) implementations.
  • Improved performance of the managed FFT implementation, especially for arbitrary lengths.

Global Optimization

Version 9.1 added a set of global optimizers for problems with multiple local minima or non-smooth objective functions.

Available optimizers

  • Particle Swarm Optimization (PSO)
  • Differential Evolution (DE)
  • Covariance Matrix Adaptation Evolution Strategy (CMA-ES)
  • Simulated Annealing

Example:

C# 
int n = 4;
var optimizer = new ParticleSwarmOptimizer() { 
    ObjectiveFunction = Rastrigin,
    LowerBounds = Vector.CreateConstant(n, -1.0),
    UpperBounds = Vector.CreateConstant(n, -1.0),
    CognitiveCoefficient = 1.5,
    SocialCoefficient = 1.5
};
optimizer.FindMinimum();
var report = optimizer.SolutionReport;

Console.WriteLine(report.Result);
Console.WriteLine(report.OptimalValue);

These solvers complement the existing local optimization and least-squares algorithms.

Nonlinear Curve Fitting

This release adds several new curve models across scientific, engineering, and reliability domains:

  • Michaelis–Menten (enzyme kinetics)
  • Gompertz and Richards curves (growth models)
  • Weibull CDF (reliability and life-testing)
  • Exponentially Modified Gaussian (EMG)
  • Pseudo-Voigt (line-shapes and spectroscopy)
  • Damped Sine
  • Power law
  • Double Sigmoid

Example:

C# 
var curve = new MichaelisMentenCurve();
var fitter = new NonlinearCurveFitter() { 
    XValues = x,
    YValues = y,
    Curve = curve
};
fitter.Fit();

Statistical Enhancements

Several improvements introduced during the 9.x cycle are now consolidated in v10:

1. Models

  • Quadratic Discriminant Analysis (QDA)
  • FastICA for independent component analysis
  • Refinements to logistic regression, PCA, and LDA

2. Other Improvements

  • New distributions: Burr XII, Chi, Folded Normal, Hyperbolic Secant, Zipf, Zipfian
  • Effect size measures: Cohen’s d, Hedges’ g, η², ω²
  • Multiple testing corrections (Bonferroni, Holm, and others)
  • Automatic bin selection for histograms

These additions strengthen Numerics.NET’s statistical modeling and data analysis capabilities.

Other Improvements

Several smaller enhancements accumulated through the v9 cycle are included:

  • New special functions (scaled Airy and Bessel functions, exponential integrals, inverse digamma, harmonic numbers)
  • Improvements to sparse matrix operations
  • Several new solvers with increased convergence and robustness properties (Halley, Regula Falsi variants)
  • Expanded tensor operators with better performance

Compatibility Notes

  • Version 10 removes all binary serialization APIs.
  • Many matrix and vector factory Create* methods are now obsolete.

Conclusion

Numerics.NET v10 brings together a year of incremental improvements, introduces new APIs for interpolation, signal processing, curve fitting, and statistical analysis, and refines core abstractions to make numerical programming more consistent and expressive.

The upgrade path from v9 is straightforward, and full migration guidance is available in the documentation.

Release Notes

You can find details about the latest updates since the release of version 10 in the release notes.