20

I’ve been searching Google and Stack Overflow like crazy for days and have yet to find any recent, completely relevant information to answer the following question: What are the best C#/F#/.NET math libraries (specifically, those that wrap or implement the same functionality as Lapack, etc.)?

One of the better posts on Stack Overflow that I did see was: https://stackoverflow.com/questions/3227647/open-source-math-library-for-f

The reason that that post, and other previous posts, didn’t sufficiently answer my question was that no systematic comparison of user experiences with various libraries was given.

I’m interested in how completely the following libraries (in real-world usage) implement Lapack (or a broad set of equivalent linear algebra of functionality); and, I’m curious about their performance relative to each other particularly on very large matrices. Also, I’d like to hear about others’ experiences utilizing the various libraries: difficulties, ease of use, etc.

Below is a comprehensive list of the “free”/opensource/affordable .NET/F#/C# math libraries which – as far as I know – have a linear algebra feature set. I’d deeply appreciate it if the community here on Stack Overflow would chip in with any experiences they have with the following libraries:

I’m interested in F# for Numerics (since I’m working with F#) but I’m having difficulty ascertaining the strengths and weaknesses of the various libraries. Like, which features are missing or included in various libraries, and how easily they are used and how well they perform.

DotNumerics seems like a comprehensive implementation of Lapack in C#, but I can’t find anyone who’s shared their experiences with it anywhere. Math.NET seems like it could eventually be an excellent, comprehensive math library for .NET, but it’s difficult to tell how active the project is and it seems that it’s very much in flux in its current stage. Alglib has been spoken of once or twice as being solid, but I’d like to hear more about them relative to others. I like the idea of supporting a native F# numerics library, but I’m not certain how committed the developer (Flying Frog Consultancy) is to supporting and developing F# for Numerics… and what functionality they plan to include in their 1.0 release and what their target date is for a 1.0 release.

Community
  • 1
  • 1
Abe
  • 156
  • 5
  • 17
  • 1
    I added .net tag since this problem concerns .Net math libraries. – Yin Zhu Nov 12 '10 at 02:52
  • 3
    dnAnalytics is no longer supported, so it shouldn't be used. All its functionality has been moved into Math.NET Numerics (except for native library support). Math.NET Numerics has been in flux but the API has finally stabilized and we'll be releasing a 1.0 beta soon (managed code only). We are now working on improving performance of the managed code and adding native wrappers (MKL, ATLAS, and ACML). We'll be releasing 1.0 in the next several months. And we are working on a F# interface to the library. – cuda Nov 12 '10 at 04:27
  • 1
    Copy that cuda. I'll definitely keep Math.NET on my radar for the future. I like a lot of what I've seen (feature wise, implemented or planned) for Math.NET so I'm optomistic that you and the other contributors will be able to make the library's performance competitive, and incorporate the native wrappers in a digestible/accessible manner. Whenever you do get Math.NET out the door--assuming its performance is good--it will be a major boon to the community. Thanks very much for your and the other contributors' hard work! – Abe Nov 14 '10 at 22:31

4 Answers4

18

One common pitfall of choosing math library is that we hope there exists a math library for everything.

Before finding a library, you should first ask "what kind of math library do I want?". Then you will have a list of criteria, such as open source or not, high performance or not, portable or not, easy to use or not.

Following are my comments on the libraries in your list (I haven't used the last two):

1) DotNumerics

(http://www.dotnumerics.com/)

They use a fortran2C# translator that translates the Lapack procedures code into C# classes. User friendly C# wrappers are written for the raw Lapack classes.

2) Alglib (http://www.alglib.net/)

This library is available in several languages, like delphi, c++ and c#. I believe it has longer history than any other libraries you listed.

Most of the functions are translated from Lapack. And its interface is not so user friendly. (But you have the flexibility of Lapack style interface.) Using lapack style interface means that you need to know more about the matrix and its operations.

3) dnAnalytics (http://dnanalytics.codeplex.com/)

This library is merging into Math.Net now. It seems that the merging is not done yet. A few functions in dnA is still not available in Math.Net.

4) Math.NET (http://www.mathdotnet.com/) Its implementation is from scratch, i.e., it is not a direct translation from Lapack. They aim to provide a purely managed library for .Net platform. That means easy usage and portability are two primary goals. One concern is that whether their own implementation is correct or not. One good thing is that this library is portable in the sense that you can use it on Mono, XNA, Windows Mobile Phone with little effort.

The above libraries dont' focus on F#. However one of the team members in Math.Net works for MS Research Cambridge and is an F# expert. Like Cuda said, they will work out an F# interface for the library. Also they will provide native wrappers. But maybe you will wait a long time, longer than "several months" :)

For the concern of high performance, the above libraries don't provide native wrappers (at least now). If you want native performance + .Net, you had better use a commercial library. There are some open source solutions:

1. http://ilnumerics.net/ This is a numpy like solution for .Net. They PInvoke to Lapack dlls (e.g. the non-optimized lapack at netlib, the optimized versions from AMD and Intel.)

2. math provider in F#. read my answer in this question. Since F# source code is now open sourced. I may revise the library and release my updates :)

Usually you don't need a big math library. You just need some functionality, e.g., if you need a fast matrix multiplication procedure, using PInovke to a platform optimized BLAS dll is the easiest way. If you need do a education oriented math software for kids, then the quality of Math.net is enough. If you are in a company and developing reliable math components, then why don't use a commercial one backed by a high-quality team?

Finding a perfect math library is hard. But finding a library solution to your problem is usually easy.

Tarik
  • 10,810
  • 2
  • 26
  • 40
Yin Zhu
  • 16,980
  • 13
  • 75
  • 117
  • Thank you, Yin, for your insight into so many of the libraries I was interested in, and for sharing your thoughts on math libraries in .Net in general. Also, thank you for the additional suggestion of Ilnumerics--I'll take a look at that library too. I did visit your blog and attempt to follow your Math Provider in F# Tutorial, but it was beyond my beginner skill level. I got BLAS to compile to .dll, but I didn't succeed in compiling LAPACK, so I gave up and turned my search to libraries which might be easier to use. Currently I'm a student who wants to use F# to do modeling and simulation. – Abe Nov 13 '10 at 03:59
  • When I have some spare time, I will make a release of this library containing all necessary runtimes. – Yin Zhu Nov 13 '10 at 06:20
  • That'd be wonderful Yin! Your site/blog is a valuable resource for those like me learning F# for technical intentions. I'll look for that release (and perhaps a tutorial on its usage from F#? *hint hint* :)) on your website. For those who are following this thread--or happen across it later--Yin's site is at: http://fdatamining.blogspot.com/. But yes, the compiled dlls would be helpful as would an example of utilizing them. Typically, I can figure things out if I have at least one comprehensive example to follow and analyze. Thanks so much for your contributions to the F# community, Yin! – Abe Nov 14 '10 at 22:19
  • Also see this answer: http://stackoverflow.com/questions/2336701/recommendation-for-c-sharp-matrix-library – Shital Shah Sep 22 '16 at 04:43
10

F# for Numerics is a product of my company, written in 100% F#. Our emphasis is on general techniques (everything from FFTs to random number generation) and not specifically linear algebra although basic linear algebra routines are provided (Cholesky, LU, QR, SVD on various matrix/element types) and we are particularly interested in ease of use from F#.

If you're after the full breadth of LAPACK then my recommendations are Alglib if you're on a budget or Extreme Optimization if you can afford it. Alglib is entirely managed code with an, umm, "quirky" API so it is relatively slow to run and cumbersome to use. Extreme Optimization is a nicer API wrapping the Intel MKL and some extra routines so it is easier to use and much faster to run.

I should warn you that the general quality of .NET libraries (free, commercial and even the framework itself) is comparatively poor if you are coming from an open source background. I tried many of the other libraries that you mentioned and was not at all impressed with them.

J D
  • 48,105
  • 13
  • 171
  • 274
  • 4
    can you provide some evidence that the framework is not well implemented or designed? – Yin Zhu Nov 12 '10 at 15:23
  • 1
    Sure, look at the way serialization is implemented by reflecting on every value at every step rather than by reflecting on type and run-time generating code once per-type and reusing it. That's why serialization is over 170× slower on .NET than in OCaml. According to the F# team, `[1..1000000].GetHashCode()` stack overflows due to a design flaw in the framework that cannot be worked around. These are just a couple of recent issues I've run into. Overall, I'd say the interoperability between components is better on .NET but the quality of the components themselves is worse. – J D Nov 12 '10 at 23:37
  • 1
    According to a colleage, the COM interop in .NET 4 leaks strings. I've never seen a GC bug as serious as the one I reported in .NET 4 in any other system: http://flyingfrogblog.blogspot.com/2010/10/can-you-repro-this-64-bit-net-gc-bug.html – J D Nov 12 '10 at 23:41
  • 1
    Jon, thanks very much for the insight into what F# for Numerics offers, and for sharing your opinions on the best of the commercial and open source math libraries out there. I find your thoughts on the quality (or lack thereof) of .Net libraries--both commercial and free--horrifying. I was hoping for better given the commercial backing of MS, and the broad adoption of .Net/C#, etc. In the interest of fairness I should state that I am a relative newcomer to F#, C#, .Net, and still a fairly new programmer in general; So accessing quirky C# libraries from F# is proving exceedingly difficult. :) – Abe Nov 13 '10 at 04:06
  • @Abe: Although Microsoft have a lot of money, this is not their remit and they obviously look for profit-making ventures. Their foray into High Performance Computing (HPC) burned a lot of money but they only gained about 1% market share. So I would not expect them to invest significantly in better numerical libraries or support in .NET or any .NET language. Their most closely related current ventures are Azure and Hadoop. – J D Nov 15 '11 at 16:26
1

A few notes of correction on previous replies: ALGLIB is not a translation of LAPACK, though it did include some routines in its matrix core also seen in LAPACK. It does a lot more, e.g. rational function and radial basis function interpolation, convex non-linear programming, as well as non-convex optimization, neural nets, a solver for differential equations and integration and it has a subset of the functionality of FFTW. This is more akin to MKL - which it accepts a hook to as a library plug-in for some of its routines. In contrast, LAPACK focuses almost exclusively on linear and matrix algebra - which mostly corresponds to the LinAlg module in ALGLIB. There is nothing like optimization, or iterative solvers in it. ALGLIB has a large number of iterative routines, particularly for its optimization routines.

ALGLIB is written in an internal language (AlgoPascal) and translated automatically to its target languages. In particular, there are a lot of translator artifacts in the C++ version, and it's not fully nativized C++, but more like C, with C++ capability simulated on top of it much like what you would get if you had used a cleaner, more intelligent, version of cfront (or of f2c or of some "Pascal to C" convertor). Then, a C++ API wrapper is put on top of it all. The translation is good enough, but sorely misses out on language features of C++ that it could take advantage of by making direct use of them and directly translating the core package to C++.

The AlgoPascal to C/C++ translator has not kept pace with the changes in the target languages. In addition to native multi-threading (including thread-local variables) in C and C++, there is now support for "tuples" in C++, which would really come in handy for the parameter-laden routines!

If you're working with ALGLIB, a quick speed-up would be to replace the floating point comparison functions by macros or in-line functions that equates them to C++'s native point comparison operators. The reason functions were used for floating point comparisons was to get around problems that older compilers had in implementing the comparisons in ways that worked consistently with the quirky architecture of the floating point co-processor on the Intel-based CPU's.

LAPACK includes a default implementation of BLAS, plus room to plug in an external, high-powered, BLAS library, and recommends against using its own default BLAS library, in favor of plugging in an external library, if you can. Its core is in Fortran, though it comes with API shells for C and C++. It supersedes the older EISPACK and LINPACK libraries (according to the cover pages, themselves, of the respective libraries on NetLib).

A front end for those latter two libraries was developed in the 1970's and early 1980's and distributed with version 10 UNIX - and was also written in Fortran - with core functionality for an interactive CLI user interface. Its name is MatLab.

The MatLab you know of today, by MathWorks, is a direct descendant of this, though it has evolved substantially both in terms of its source language (C or almost certainly C++ now), its user interface (GUI written on QT, now) and routines. Like LAPACK has done in recent times, it has also moved into the world of parallelism.

SciLab has more evolved versions of the old MatLab routines and also has a graphics and GUI core, and a large variety of code covering a wide range of fields (e.g. a multi-threaded C++ class for co-routines - which would come in handy for iterative solvers). It is both open and open-ended: I believe that it accepts contributions of new modules. Potentially that could even include a fully-nativized C++ version of ALGLIB or a C++ translation of LAPACK's core, if those were ever produced and provided.

The old MatLab had 3 main set of files, "Mat" had the parser for the front-end language. "Lib" had the core library routines, and "Sys" had the system-dependent routines - including the CLI user interface. It was about 8000 lines in all. There wasn't much in it beyond what you would find in LINPACK, particularly since it was one of the LINPACK/EISPACK co-authors who wrote it.

Since it is now proprietary in its later evolved forms, I can't say what these look like today in source form. However, there is also the freely-distributed answer to MatLab: Octave. Roughly speaking, "Mat" is now "libinterp", "Lib" is "liboctave" and "Sys" is "libgui", and the driver routine is in "src". Each of the lib directories is about 100000-250000 lines, with a lot more functionality in it, in an attempt to keep pace with MatLab. A small part of it is translated from Fortran, bearing heavy imprint of translator artifacts. A quick glance shows that it looks more like LAPACK, in terms of functionality, than MKL or ALGLIB. I don't see any iterative solvers, neural net routines or optimization routines in it.

NinjaDarth
  • 287
  • 1
  • 3
1

I also can suggest to view new one .net numerical library called FinMath, which I used in my development. It provides easy to use .net class wrappers for a lot of MKL (Intel Math Kernel Library on which it based) functionality, such as linear algebra (BLAS and LAPACK), statistics and FFT. Also, in addition it contains number of advanced methods such as linear and quadratic programming solver, cluster analysis and others. It also includes various .net to native c marshaling optimization which leads to high performance and easy to use single dll solution.

But unfortunately it's not open source, not free and in contrast to LAPACK, most methods supports only double precision floating point reals. And for few rarely used LAPACK methods wrapper are not provided.

Wisdom's Wind
  • 1,448
  • 9
  • 10