We've added two new static methods in the Matrix<T> class, CreateFromRows and CreateFromColumns.
Example:
var row1 = new DenseVector(new [] { 1.0 });
var row2 = new DenseVector(new [] { 1.0, 2.0, 3.0, 4.0 });
var row3 = new DenseVector(new [] { 1.0, 2.0 });
var rowVectors = new List>{row1, row2, row3 };
var matrix = Matrix.CreateFromRows(rowVectors);
This will create a 3x4 dense matrix. The number of columns is determined by the maximum length of the given vectors (zero is used to pad short rows). Note that the storage type of the first vector determines the storage type of the matrix (i.e. a sparse vector creates a sparse matrix). CreateFromColumns works similarly.
]]>Additional terms:
1) documentation or resource string typos don't count as bugs.
2) bug fixes must include a unit test that demostrates the bug.
3) all new features must include unit tests.
4) only tasks and feature requests that are added by or accepted by the Math.NET team are eligible.
5) bounties will be paid via PayPal.
6) a maximum of 30 boutnites will be paid.
7) the Math.NET Numerics team must accept the submitted fix or feature code. The team can reject any submission for any reason.
]]>
Since the standard deviation is defined as E[(X - E[X])2] we could compute the mean of our list of doubles, subtract it from each element in the list, and average the resulting list. The problem with this method is that not only is it numerically suboptimal to do so (recall, when the standard deviation is small, we are potentially subtracting the two very similar numbers X and E[X] = catastrophic cancellation), it is also inefficient as it requires two passes over our data.
In a little Math.Net Numerics program (get it here), I use the Statistics class to compute the standard deviation for an array of 100,000,000 doubles (that's about 800MB of data). The code is extremely simple, except for some IO code which you can find in the full source, you only need to write
var sdev = Statistics.StandardDeviation(ReadFile(sr));
Math.Net Numerics is guaranteed to only loop over your data once, as well as be numerically stable. When streaming the data from file, no extra memory is used beyond a handful of doubles for bookkeeping and the computation finishes in 57 seconds (that's streaming from my laptop's hard drive at around 13MB/sec). When reading the whole array into memory, the computation finishes in about 5 seconds (but ofcourse will consume almost 800MB of RAM).
Check out the rest of MathNet.Numerics.Statistics for methods to compute other statistics efficiently. Enjoy! -Jurgen
]]>We also created a general Math.NET Numerics project for future bounties or user posted bounties - http://www.fossfactory.org/project/p252 . If you are wondering why the ATLAS bounty wasn't posted to this project, it is because the ATLAS script will usefully to people we'll beyond Math.NET Numerics.
]]>We released Numerics Beta 1 about two months ago. Since then we’ve:
Two items are left for the Beta 2 release, adding the native interface and improved managed matrix multiplication. The initial native interface will just focus on linear algebra. We are half way done with the Intel Math Kernel Library (MKL) wrapper. We’ll then move on to the AMD Core Math Library (ACML) and then ATLAS/LAPACK. All three libraries share a similar interface, so once the MKL wrapper is compete the other two will be simple to add.
We have an outstanding issue with the ATLAS/LAPACK library. We are using Cygwin to build ATLAS. The threading library depends on the Cygwin runtime – which is released under the GPL. Users who use Numerics with a threaded version of ATLAS will be bound by the terms of the GPL even though Math.NET Numerics is released under the X11/MIT license. We are looking for ways to not include the Cygwin runtime library (other than only using a serial build of ATLAS). One way we are exploring is to use MinGW to build ATLAS. But so far we haven’t been successful. If anybody wants to give us a hand on finding a way around using the Cygwin runtime, let us know.
]]>