Composyx index
Table of Contents
- 1. General overview
- 2. Documentation and tutorials
- 3. The composyx library
- 4. Context
- 5. Coding tools
- 6. Matrix interface
- 7. Datatypes
- 8. MPI wrapper
- 9. Parallel domain decomposition
- 10. Solvers
- 11. Preconditioners
- 12. Operator interfaces
- 13. I/O
- 14. Linear algebra tools
- 15. Kernels
- 16. Graph and partitioning
- 17. Unit test matrices
- 18. CUDA
- 19. Wrappers
- 20. Benchmark results
Browsing Composyx
Some fuzzy searching in the Composyx web pages
1. General overview
Go upstream.
See the pdf version.
Composyx (previsouly Compose, or Maphys++) is a linear
algebra C++ library focused on composability. Its purpose is to
allow the user to express a large pannel of algorithms using a
high-level interface to range from laptop prototypes to many node
supercomputer parallel computations.
2. Documentation and tutorials
2.1. Quick start tutorial
A quick presentation of composyx, and how to get started with the library.
2.2. GMRES parameters
A description of parameters for iterative solvers (with a focus on GMRES).
2.3. Operators
How to define a operator in composyx.
2.4. Fortran and C drivers
Usage of C and Fortran drivers.
2.5. Using CUDA
How to use composyx CUDA implementations.
3. The composyx library
3.1. Introduction
composyx provides its own basic linear algebra datatypes for matrices, vector,
… It is also possible to use external datatypes with composyx tools.
3.2. Namespace
The C++ namespace used by Composyx is composyx.
using namespace composyx;
3.3. Scalar types
In the rest of the documentation, we refer to Scalar for the following C++ types:
float: single precision (32 bits) real;double: double precision (64 bits) real;std::complex<float>: single precision (64 bits) complex;std::complex<double>: double precision (128 bits) complex.
Those are the types supported by composyx datatypes, in other words the types
of data that can be stored in a vector or a matrix.
We may also refer to Real as the real type associated to the Scalar type. It
is for example the type you should use for a norm or a tolerance criterion for
an iterative method. For real types (float and double), Scalar and Real
are the same, but not for complex types. For instance, the Real type
associated to std::complex<float> is float.
In composyx, one can access the Real type associated to a Scalar as follows:
using Real = typename composyx::arithmetic_real<Scalar>::type;
See Arithmetic for more details.
3.4. Linear algebra conventions
3.4.1. Functions on vector
With two vectors \(u, v\)
composyx::dot(u, v)is the scalar product of \(u\) and \(v\).composyx::size(u)is the size of the vector \(u\).
3.4.2. Functions on matrices
For a matrix A, when it's relevant to do so, we define the following
functions in the namespace composyx:
n_rows(A)andn_cols(A)respectively the number of rows and columns of the matrix.transpose(A)the transpose ofA. IfAhas complex coefficients, the imaginary part is kept the same. For objects defined incomposyxtype, we can also useA.t().adjoint(A)the conjugate transpose ofA. IfAhas real coefficients, it is equivalent astranspose(A). For objects defined incomposyxtype, we can also useA.h().
3.4.3. Arithmetic operators
The usual operators (\(+, -, *\)) should be defined for vectors and matrices. If dimensions are not consistent an exception will be thrown. The operator \(/\) can also be used for division by a scalar value.
3.4.4. Special operators for pseudo-inverses
On composyx objects, operators ~ and % have special semantics.
3.4.4.1. Operator~
The unary operator ~ is used as an equivalent of the
pseudo-inverse \(A^+\) of a matrix \(A\). When it's possible and
relevant, writing
auto A_pi = ~A;
will create an instance of an operator pseudo-inverse of A in
A_pi. For example, if A is a square matrix, A_pi will be a
linear solver that can be called on a vector b to return x such
that \(A x = b\), in other word you can see A_pi as the operator
\(A^{-1}\).
3.4.4.2. Operator%
The binary operator % is inspired from matlab's \ operator:
auto x = A % b;
is equivalent computing \(x = A^+ b\). It's also equivalent of writing:
auto x = ~A * b;
It is recommended to use ~A rather than this operator, especially if
you want to use several times the solver instance ~A. For example,
if you want to solve a system with successive right-hand sides, using
~A to keep an instance of the solver is better. It will possibly
store a factorization of \(A\) or some data about \(A\) to accelerate the
solving phase. If you use the % operator, this information will be
computed again at every solve.
3.4.4.3. Choosing implicit kernels and solver to use
For the selection of the dense kernels and solvers used by default with these operators, see dense kernel selection
For the sparse solver selection, see sparse solver selection
For sparse kernel selection, see sparse kernels.
4. Context
5. Coding tools
5.1. Arithmetics
5.2. Error management
5.3. Algorithms for 1D arrays
5.4. Fortran arrays
5.5. Cross product iterator
5.6. Cast operator
5.7. Macros
5.8. SZ compressor wrapper
5.9. SZ compressor wrapper
5.10. ZFP compressor wrapper
6. Matrix interface
6.1. Basic concepts
6.2. Linear algebra concepts
6.3. Distribution concepts
6.4. Common traits and definitions
6.5. Implicit dense kernels and solver
6.6. Implicit sparse solver
6.7. Eigen wrapper
6.8. Eigen dense solver
6.9. Eigen sparse solver
6.10. Armadillo wrapper
7. Datatypes
7.1. Matrix properties
7.2. Dense vectors and matrices
7.2.1. Dense data
7.2.2. Dense matrix
7.2.3. Expression templates for dense matrices
7.2.4. Compressed basis
7.3. Diagonal matrices
7.4. Sparse matrices
7.4.1. Base sparse matrix class
7.4.2. Sparse matrix COO
7.4.3. Sparse matrix CSC
7.4.4. Sparse matrix CSR
7.4.5. Sparse matrix LIL
7.4.6. Sparse matrix BSR
7.6. Partitioned vectors and matrices
7.6.1. Partitioned base class
7.6.2. Partitioned operator
7.6.3. Partitioned vector
7.6.4. Partitioned matrix (domain decomposition style)
7.6.5. Partitioned dense matrix
Experimental feature. Interface is expected to change.