TMV is a free and open source linear algebra library that uses operator overloading, views and delayed evaluation to simplify vector and matrix expressions in C++.
TMV is well documented and can optionally call optimized BLAS/LAPACK for faster execution times.
Here are some key features of "TMV":
· Operator overloading: An expression like v2 = x * m * v1 should produce correct and fast code. (No temporaries)
· Complex types: Mixing complex and real types in an arithmetic statement should be legal.
· Decompositions: Division should mean solving a matrix equation, automatically performing an LU, QR, Cholesky, or singular value decomposition to do so.
· Speed: The code should be fast for large matrices. Typically, this means calling BLAS and LAPACK routines behind the scenes.
· Delayed evaluation: (aka lazy evaluation) The expression v2 = x * m * v1 for example inlines directly to MultMV(x,m,v1,v2) which does the actual calculation, so there is no performance hit from the legibility of the operators.
· Templates: As the name TMV indicates, the type of the elements in a vector or matrix is a template. So you can have Matrix, Matrix, Matrix, or even use some user-defined type (eg. Quad for some 16 byte quad-precision class) Matrix.
· Views: There are both constant and mutable views into a vector or matrix. So expressions like m.row(3) += 4. * m.row(0) and m2 *= m.Transpose() do the obvious things.
· Matrix division: The expression x = b/A can be used to solve the matrix equation Ax = b. Control methods for A can be used to tell it which decomposition to use to find the solution. There are also controls to save the decomposition for later repeated use, and even to do the decomposition in place to save on storage.
· Flexible storage: A matrix may be declared either row-major or column-major. Band matrices also allow for diagonal-major storage.
· Flexible indexing: You can specify that you want to access a matrix using either the normal C convention (0-based indexing) or the Fortran convention (1-based indexing).
· Alias checking: Many matrix packages calculate m *= m incorrectly. TMV automatically checks if two objects in a calculation use the same storage and creates temporaries as needed. It only checks the address of the first element, so you can still screw up. But most of the time this is good enough.
· BLAS/LAPACK: The library can be compiled to call BLAS and/or LAPACK routines. But if you don`t have them, the internal code will also work. Most of the internal algorithms are as fast as LAPACK. But optimized BLAS routines are generally significantly faster. So compiling with at least a BLAS library is recommended if speed is important for you.
What`s New in This Release: [ read full changelog ]
New features:
· Made integer determinants calculate correctly. The previous code
· used division, which produced wrong answers for integers. Probably
· anyone who tried to do this would consider this a bug fix, but
· it was (somewhat poorly) documented that this wouldn`t work.
· The code now uses Bareiss`s algorithm for these matrices, instead
· of the LU decomposition that floating point matrices use.
· Added m.sumAbs2Elements()
· Added m.addToAll(x)
· Added m.resize(nrows,ncols) and v.resize(n) (and similar for other Matrix
· types).
· Added ability to make the libraries shared libraries, rather than static
· with the SHARED=true scons option.
· Added ability to turn off TMV debug statements with TMVNDEBUG.
· Defining NDEBUG also still turns off TMV debugging, but this allows
· the user to turn off just the TMV debug statements without turning off
· the debug statements in their own code.
· Skip compilation of functions for that it will never use.
· Also specialized some methods for and complex to make s...
