## New Documentation in the Pipeline!!

You **really** want to look at this

## Session 1: Some matrix/vector types and what you can do with them...

This session is a quick tour through FLENS. It introduces some of its matrix and vector types and how to use them. Well, these types have some nice features. But wait until you see our BLAS and LAPACK interface!

- Initalize a general matrix, some methods and element access.
- Specify index ranges.
- Efficiency of element access compared to C-arrays.
- Vector type for dense vectors.
- Low-level BLAS interface.
- Higher-level BLAS interface.
- The really cool FLENS to BLAS interface.
- Some notes about why the 'really cool FLENS to BLAS interface' is so efficient.
- Vector views: referencing vector slices
- More about the concept of views...
- Matrix views: referencing rows, columns and rectangular parts
- COOL STUFF: Triangular and Symmetric Matrix Views!

## Session 2: SPARSE matrices!

Gives a brief overview about sparse matrices in FLENS.

- Example for using sparse matrix classes...
- What is going on behind the scenes: storage formats for sparse matrices
- 'Behind the scenes RELOADED': implementation of the matrix-vector product
- Benchmark sparse matrices
- Symmetric sparse matrices.

## Session 3: What FLENS does, what FLENS does NOT ... why that's a good thing!

This short session is dedicated to the **purpose of using overloaded operators** in FLENS.
Here the brief version of what will be discussed in this session:

- Overloaded operators are
**just**used to provide an**expressive notation**to use BLAS and LAPACK, - FLENS is
**just a high-level, efficient C++ interface for BLAS and LAPACK**. - FLENS
**must be compared**to using BLAS and LAPACK directly. - That's why
**you**still**have to know what you are doing**. - FLENS
**MUST NOT be compared**to software packages like Matlab. - Software packages like Matlab have a different intension.

So here we go:

- Why there is still use for your own brain...
- Why you still want to know a bit about BLAS and LAPACK...
- Simple, easy, fast: How expressions are evaluated in FLENS!

## Session 4: Iterative Solvers and why it is so cool to implement your own matrix type.

In this session I will show you:

- generic implementation of the cg and pcg method,
- how to implement you own matrix types and why you want to do this,
- generic implementation of the multigrid method and
**some very nice pictures!****If you are not familiar with the multigrid method:**- Have a look at the famous A Multigrid Tutorial, Second Edition.
- On the multigrid home page you also can find these excellent slides giving you a quick head start.

The examples are kept very simple. E.g. there are now template parameters for element types. Such generalizations are left as exercise to the alerted user ;-)

So here we go:

- Generic Implementation of the Conjugated Gradient Method.
- Small example: Using the cg-method, just to see that it works...
- Poisson1D: A matrix type for the 'fruit fly of numerical analysis'. So simple, so useful and so nice.
- Poisson2D: Going to 2 dimensions: Using the same generic cg-method!
- pcg: Using a preconditioner
- Smoother: Smoothing properties of the Gauss-Seidel method
- Getting ready for multigrid! Restriction and prolongation
- Here we go: MULTIGRID for the 2D Poisson Problem

## Session 5: __Off Topic:__ How this tutorial was created.

So here the overview:

- I didn't do the syntax highlighting by hand.
- I didn't copy paste the output of programs by hand.
- I didn't start gnuplot manually.
- ...and so on
- Instead all these happens automatically

Here some examples showing 'what I wrote by hand' and 'what was created by my scripts':