
7 votes
spike in a fork

Optimized DenseLU solve
/// <summary>
/// Solves A*X=B for X using LU factorization.
/// </summary>
/// <param name="columnsOfB">The number of columns of B.</param>
/// <param name="a">The square matrix A.</param>
/// <param name="order">The order of the square matrix <paramref name="a"/>.</param>
/// <param name="b">On entry the B matrix; on exit the X matrix.</param>
/// <remarks>This is equivalent to the GETRF and GETRS LAPACK routines.</remarks>
public static unsafe void LUSolveUnsafe(int columnsOfB, double[] aIn, int order, double[] bIn)
{
#region Initialize
if (aIn == null)
throw new ArgumentNullException("a");
if (bIn == null)
throw new ArgumentNullException("b");int i;
int j;
int k;double* a = stackalloc double[aIn.Length];
double*…6 votes 
Add a FixedPoint Numeric Type
A fixedpoint numeric type is essential for deterministic calculations with fractional parts. This is essential for running accurate simulations across different machines with various CPUs, OSes, because the IEEE standard for floatingpoint math doesn't guarantee reproducibility across machines (http://stackoverflow.com/a/328651/154766).
Authors of realtime strategy games in .NET have typically come up with their own fixedpoint math class or found some workaround. There is no fixedpoint type in the BCL even though the documentation for System.Decimal at some point labeled it so, erroneously.
6 votes 
Implement the Studentized range distribution
https://en.wikipedia.org/wiki/Studentizedrangedistribution
This distribution is used in the Tukey test for post hoc analysis of an ANOVA test.
6 votes 
Allow interpolation over complex numbers
Currently interpolation only supports real numbers. Consider also to provide special schemes like Laurent interpolation around the unit circle.
6 votes 
6 votes

PCG Random support
Implement support for the PCG random routine as specified here:
PCG, A Family of Better Random Number Generators
http://www.pcgrandom.org/6 votes 
4 votes

4 votes

support infinite precision
I really love the infinite precision feature of Google's Android Calculator. If you enter a number like π, e, φ, √2, √3, √5, etc., you can scroll to the right to get an infinite number of digits.
Such calculations should be supported by Math.NET Numerics, where results can get queried to get more (decimal) digits. Something like an IEnumerable<DecimalDigit> interface.
4 votes 
Introduce support for homogeneous coordinates
The usage of homogeneous coordinates is quite natural.in drawing software, so support for vector manipulations using homogeneous coordinates would be intersting.
4 votes 
Please consider implementing excel functions PPMT,IPMT,PMT,CUMIPMT,CUMPRINC
These are the financial functions used by banks. The applications using math.net will be more richer if it can have below functions PPMT,IPMT,PMT,CUMIPMT,CUMPRINC
4 votes 
Implement Selected MATLAB Core Functionality
Implement a new class which is intended to provide syntax matched core MATLAB functionalities, such as flip(), linspace(), etc. I know linspace() and logspace() are already present with reordered inputs, but matching MATLAB syntax would prevent a lot of rewriting. Some of these could simply be wrappers for existing Math.NET functions, just so syntax matches.
Validation of this functionality would be such that inputs/outputs match the MATLAB implementation. Simple functions at the start, and more complex ones as time goes on.
3 votes 
add a distributed multidimensional array type (or at least matrix)
Languages like Fortran 2008, Julia & Spark framework have a distributed array type. This allows to describe distributed algorithms in a natural way close to the underlying mathematics instead in a convoluted way (map reduce like Hadoop). I'd like to have the same in .NET.
3 votes 
Matrix multiplyadd, like DGEMM
BLAS has something like DGEMM which does X = aAB + b*X in one loop. This can be very fast, so allowing direct use of this would be handy.
3 votes 
3 votes
We do some computations in parallel, however, in practice parallel execution is often not very efficient (other than e.g. concurrent execution at application level). However, we should review places where parallelization would be interesting for v3

3 votes

Implement finding extrema for cubic splines
I wanted to find extrema for a spline and had to implement it by myself, using the CubicSpline.cs of MathNet.Numerics. Unfortunately the Class is constructes thus, that I could not access the spline parameters which would have allowed my to simply write an extension method.
I propose the following addition to the class "CubicSpline":
public enum eExtremePointType
{
Minimum, Maximum
}public class cExtremePointResult
{
public eExtremePointType Type { get; private set; }
public double x { get; private set; }public double y [get;private set;}
public cExtremePointResult(double in_x, double in_y, eExtremePointType in_type)
{x=inx;
y=iny;
Type=in_type;
…}
3 votes 
Add primality test
Add a fast primality test, for example based on MillerRabin or similar efficient method.
3 votes 
Multidimensional Arrays Support
Support multidimensional array and tensors with higher than 2D (i.e. Matrix). This would open Math.Net to more users who need this functionality daily.
3 votes
 Don't see your idea?