LFMat

This is a simple hello world program:

#include "lfmat/matrix.h"

int main() {
  LFMat::Matrix<const char *> mat(3,3);

  mat.fill(".....");
  mat(0,0)="hello";
  mat(1,1)="world";
  mat(2,2)="!!!!!";

  std::cout << mat << std::endl;
}

This produces the following output:

     hello      .....      .....
     .....      world      .....
     .....      .....      !!!!!

It does not need particular linkage parameter since all data are in the headers in this case. liblfmat.a is needed only for some double and float operations. In fact, the matrix class is declared as following:

template<
  class T=float,
  class Structure=Generic<>,
  class Storage_style=Dense<>,
  class Orientation=Row_oriented>
class Matrix {};

Template parameters

	The kind of data which is stored in each element of the matrix. It can be `float`, `double`, `complex<cln::...>`, `banana`, ... For solvers or operators on matrix and vectors, `T` must support +, -, *, / and `sqrt()`, depending on procedures. Let's note that there's a parameter in storage style definition classes which allow to specify if allocation must be done using the `new` operator or the `malloc()` procedure (faster than `new`).
	The structure represents the properties of the matrix. Is it square, symmetric, triangular, diagonal ? Furthermore, the structure parameter allow to specify if the matrix is of fixed size (see the section called “Structure”).
	The storage style represents how data is stored (as one can guess...). There's several possibilities: it can be dense, sparse, sky line, band, ... The storage style influence considerably the speed of procedures like `solve(mat,vec)` (often faster with sky line if matrices are not full) or `multiply(mat,vec)` (often faster with a sparse matrix), ...
	For now, matrices can be `row_oriented`, `col_oriented`, or `diag_oriented`. Differences are shown in

It means as example that if one wants a triangular float matrix, row_oriented and with a sky_line storage style, it could be declared as:

Matrix<float,Triangular<>,Sky_line<> > mat;

It is recommended to look on examples in the ./src directory in order to get a better idea on how to use some particular storage...

Here is one another simple example :

#include "lfmat/matrix.h"
#include "lfmat/solve_skyline.h"
#include <iostream>

using namespace std;
using namespace LFMat;

void my_example(unsigned size) {
  cout << "example_solve_simple" << endl;
  
  Matrix<float,Symmetric<>,Sky_line<> > mat(size);
  Vector<float> vec(size);

  for(int i=0;i<size;++i)
    mat.data.set_bounds( i, max(0,i-5) );
  
  mat.set_values(0.1);
  vec.set_values(1.0);
  for(int i=0;i<size;++i)
    mat(i,i) = size;

  cout << mat << endl;    
  solve(mat,vec);
  cout << vec << endl;
}

struct SIMD_Alignment {}; template<class T> struct Alignment<SIMD_Alignment,T> { static const int val = 1; }; /// #if HAS_SSE==1 struct Alignment<SIMD_Alignment,double> { static const int val = 2; }; struct Alignment<SIMD_Alignment,float> { static const int val = 4; }; struct Alignment<SIMD_Alignment,int> { static const int val = 4; }; #else #if HAS_MMX==1 struct Alignment<SIMD_Alignment,float> { static const int val = 2; }; struct Alignment<SIMD_Alignment,int> { static const int val = 2; }; #endif #endif

Matrix<...,...,Sparse_line<...> > mat; mat.resize(nb_rows); mat.data.reserve(nb_values); size_type ind=0; for(size_type line=0;line<nb_rows;++line) { mat.data.row_ind[i]=ind; for(...;...;...,++ind) { // for each value in $line mat.data.ind[ind]=ind; mat.data.values[ind]=val; } }

Hello world

Structure

Storage styles

Warning

Warning