77 results found
-
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 Fixed-Point Numeric Type
A fixed-point 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 floating-point math doesn't guarantee reproducibility across machines (http://stackoverflow.com/a/328651/154766).
Authors of real-time strategy games in .NET have typically come up with their own fixed-point math class or found some work-around. There is no fixed-point 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/Studentized_range_distribution
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.pcg-random.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 multiply-add, 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 Miller-Rabin 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?