1. LAPACK++ (Linear Algebra PACKage in C++) is a software library for numerical linear algebra that solves systems of linear equations and eigenvalue problems on high performance computer architectures.
Computational support is provided for supports various matrix classes for vectors, non-symmetric matrices, SPD matrices, symmetric matrices, banded, triangular, and tridiagonal matrices; however, it does not include all of the capabilities of original f77 LAPACK. Emphasis is given to routines for solving linear systems consisting of non-symmetric matrices, symmetric positive definite systems, and solving linear least-square systems. (from http://math.nist.gov/lapack++/)
2. The GNU Scientific Library (GSL) is a numerical library for C and C++ programmers. It is free software under the GNU General Public License.
The library provides a wide range of mathematical routines such as random number generators, special functions and least-squares fitting. There are over 1000 functions in total with an extensive test suite.
The complete range of subject areas covered by the library includes,
| Complex Numbers | Roots of Polynomials |
| Special Functions | Vectors and Matrices |
| Permutations | Sorting |
| BLAS Support | Linear Algebra |
| Eigensystems | Fast Fourier Transforms |
| Quadrature | Random Numbers |
| Quasi-Random Sequences | Random Distributions |
| Statistics | Histograms |
| N-Tuples | Monte Carlo Integration |
| Simulated Annealing | Differential Equations |
| Interpolation | Numerical Differentiation |
| Chebyshev Approximation | Series Acceleration |
| Discrete Hankel Transforms | Root-Finding |
| Minimization | Least-Squares Fitting |
| Physical Constants | IEEE Floating-Point |
| Discrete Wavelet Transforms |
(from http://www.gnu.org/software/gsl/)
3. POOMA (Parallel Object-Oriented Methods and Applications) is a collection of templated C++ classes for writing parallel PDE solvers using finite-difference and particle methods (see also Overture).
POOMA programs are written at a very high-level, using data-parallel array expression in the style of HPF or at a serial level using iterators on each CPU. They can achieve high performance (comparable to Fortran) thanks to a clever compilation technique called expression templates. Moreover, they achieve true portability across serial, parallel and distributed architectures.
POOMA offers two main parameterized types, Fields and Particles, and many other supporting types.
Fields. Fields are multidimensional arrays representing grids with definable centering. They may be fully contained within a processing node, or spread across nodes, according to user directives. POOMA predefines field types for the most common element types: scalars (double, int, etc.) vectors, tensors, and symmetric tensors. POOMA users may specify other arbitrary element types, although this is not completely straightforward (it requires familiarity with a technique called Traits, described by N. Meyers in A New and Useful Template Technique: "Traits", C++ Report 7, 32-35, June 1995).
Particles. An instance of the Particle class actually stands for a set of particles, with user-definable characteristics. Particle sets may also be distributed across nodes, and operations on them are expressed in a data-parallel style.
POOMA II includes functionality for unstructured and adaptively refined meshes. In summary, POOMA provides high-level data-parallel types that make it easy to write parallel PDE solvers without worrying about the low-level details of layout, data transfer, and synchronization. (from POOMA)
4. The Matrix Template Library (MTL) is a high-performance generic component library that provides comprehensive linear algebra functionality for a wide variety of matrix formats.
As with the Standard Template Library (STL), MTL uses a five-fold approach, consisting of generic functions, containers, iterators, adaptors, and function objects, all developed specifically for high performance numerical linear algebra. Within this framework, MTL provides generic algorithms corresponding to the mathematical operations that define linear algebra. Similarly, the containers, adaptors, and iterators are used to represent and to manipulate concrete linear algebra objects such as matrices and vectors. (from The Matrix Template Library)
5. The goal of the CGAL Open Source Project is to provide easy access to efficient and reliable geometric algorithms in the form of a C++ library. CGAL is used in various areas needing geometric computation, such as: computer graphics, scientific visualization, computer aided design and modeling, geographic information systems, molecular biology, medical imaging, robotics and motion planning, mesh generation, numerical methods... More on the projects using CGAL web page.
The Computational Geometry Algorithms Library (CGAL), offers data structures and algorithms like triangulations (2D constrained triangulations and Delaunay triangulations in 2D and 3D), Voronoi diagrams (for 2D and 3D points, 2D additively weighted Voronoi diagrams, and segment Voronoi diagrams), Boolean operations on polygons and polyhedra, arrangements of curves and their applications (2D and 3D envelopes, Minkowski sums), mesh generation (2D Delaunay mesh generation and 3D surface mesh generation, skin surfaces), geometry processing (surface mesh simplification, subdivision and parameterization, as well as estimation of local differential properties, and approximation of ridges and umbilics), alpha shapes, convex hull algorithms (in 2D, 3D and dD), operations on polygons (straight skeleton and offset polygon), search structures (kd trees for nearest neighbor search, and range and segment trees), interpolation (natural neighbor interpolation and placement of streamlines), shape analysis, fitting, and distances (smallest enclosing sphere of points or spheres, smallest enclosing ellipsoid of points, principal component analysis), and kinetic data structures. (from http://www.cgal.org/)
6. Blitz++ Numerical Library: to develop techniques which will enable C++ to rival -- and in some cases even exceed -- the speed of Fortran for numerical computing, while preserving an object-oriented interface.