========
Tutorial                                                                [TOC]
========

FLENS has many great features.  Looking through all the examples given in
this tutorial should give you a first impression and a quick start.

More tutorials are on the way ...

... so stay tuned.


General Matrix with Full Storage
================================

 *--[BOX]--------------------------------------------------------------------*
 |                                                                           |
 |                                                                           |
 |  __Page 1__    We show how to allocate and initialize a general matrix.   |
 |  __Page 2__    Shows how to change the default index base which is One.   |
 |  __Page 3__    We introduce the concept of matrix views.  Matrix views    |
 |                can be used to reference other matrix parts.  Furthermore  |
 |                it allows the creation of a FLENS matrix(view) from an     |
 |                existing C-array copying the C-array. The latter is very   |
 |                useful for interfacing with other libraries.               |
 |  __Page 4__    We introduce dense vectors.                                |
 |  __Page 5__    Working with complex vectors and matrices.                 |
 |  __Page 6__    Element-wise matrix/vector operations.                     |
 |  __Page 7__    How FLENS ensures const-correctness and MTL4 not.          |
 |  __Page 8__    Why matrix views are so important for numerical linear     |
 |                algebra and high performance computing:  Implementation of |
 |                a blocked and unblock $LU$ factorization.                  |
 |                                                                           |
 *---------------------------------------------------------------------------*

:links: __Page (\d)__       -> doc:flens/examples/tut01-page0$1


BLAS, CXXBLAS, FLENS-BLAS and Overloaded Operators
==================================================

 *--[BOX]--------------------------------------------------------------------*
 |                                                                           |
 |  __Page 1__    Using __CXXBLAS__ directly.  CXXBLAS provides a generic    |
 |                BLAS implementation but also can serve as a interface to   |
 |                high performance BLAS implementations.                     |
 |  __Page 2__    Using __FLENS-BLAS__ which is a high-level interface to    |
 |                CXXBLAS.                                                   |
 |  __Page 3__    Using overloaded operators for BLAS operations.  This is   |
 |                an even higher-level BLAS interface.  FLENS has some nice  |
 |                feature that allows logging how BLAS actually gets used    |
 |                for the evaluation of complicated linear algebra           |
 |                operations.                                                |
 |  __Page 4__    How FLENS helps you avoiding the creation of temporaries   |
 |                when evaluation linear algebra expressions.                |
 |  __Page 5__    Equivalence of __FLENS-BLAS__ and overloaded operation     |
 |                notation.                                                  |
 |                                                                           |
 *---------------------------------------------------------------------------*

:links: __Page (\d)__   -> doc:flens/examples/tut02-page0$1
        __CXXBLAS__     -> dir:cxxblas/
        __FLENS-BLAS__  -> doc:flens/blas/blas


Symmetric and Triangular Matrices with Full Storage
===================================================

 *--[BOX]--------------------------------------------------------------------*
 |                                                                           |
 |  __Page 1__    We show how to create triangular and symmetric views from  |
 |                a general matrix.                                          |
 |                                                                           |
 *---------------------------------------------------------------------------*

:links: __Page (\d)__     -> doc:flens/examples/tut03-page0$1


__FLENS-LAPACK__
================

 *--[BOX]--------------------------------------------------------------------*
 |                                                                           |
 |  __Page 1__    Computing a LU factorization.                              |
 |  __Page 2__    Computing a QR factorization.                              |
 |  __Page 3__    Solving systems of linear equations.                       |
 |  __Page 4__    Computing eigenvalues and eigenvectors.                    |
 |                                                                           |
 *---------------------------------------------------------------------------*

:links: __FLENS-LAPACK__  -> doc:flens/lapack/lapack
        __Page (\d)__     -> doc:flens/examples/tut04-page0$1

Using an external LAPACK implementation
=======================================

 *--[BOX]--------------------------------------------------------------------*
 |                                                                           |
 |  __Page 1__    Using CXXLAPACK (Low-Level LAPACK interface) directly.     |
 |  __Page 2__    Creating a high-level interface for CXXLAPACK.             |
 |  __Page 3__    Using FLENS-LAPACK as MKL, ACML or LAPACK Font-End.        |
 |                                                                           |
 *---------------------------------------------------------------------------*

:links: __Page (\d)__     -> doc:flens/examples/tut05-page0$1


Sparse Matrices (Experimental)
==============================

 *--[BOX]--------------------------------------------------------------------*
 |                                                                           |
 |  __Page 1__    Setup a matrix in coordinate storage and convert it to     |
 |                *compressed column storage*.                               |
 |  __Page 2__    Setup a matrix in coordinate storage, convert it to        |
 |                *compressed column storage* and finally use __SuperLU__ to |
 |                solve a sparse system of linear equations.                 |
 |  __Page 3__    Setup a matrix in coordinate storage and convert it to     |
 |                *compressed row storage*.                                  |
 |  __Page 4__    Setup a matrix in coordinate stoage, convert it to         |
 |                *compressed row storage* and finally use __SuperLU__ to    |
 |                solve a sparse system of linear equations.                 |
 |  __Page 5__    Iterative Solver: Conjugated Gradient Method.              |
 |                                                                           |
 *---------------------------------------------------------------------------*

:links: Page 1  -> doc:flens/examples/geccs-setup
        Page 2  -> doc:flens/examples/geccs-superlu
        Page 3  -> doc:flens/examples/gecrs-setup
        Page 4  -> doc:flens/examples/gecrs-superlu
        Page 5  -> doc:flens/examples/sycrs-cg
        SuperLU -> http://crd-legacy.lbl.gov/~xiaoye/SuperLU/


Define your own Matrix/Vector Types
===================================

 *--[BOX]--------------------------------------------------------------------*
 |                                                                           |
 |  __Page 1__    Define your own symmetric matrix type *MySyMatrix* and     |
 |                apply the conjugated gradient method on it.                |
 |  __Page 2__    We define a permutation matrix type.                       |
 |                                                                           |
 *---------------------------------------------------------------------------*

:links: Page 1  -> doc:flens/examples/my-symatrix
        Page 2  -> doc:flens/examples/my-permutation

#
# Session: Kick-Ass Interface for FLENS-LAPACK
# ============================================
#
#  *--[BOX]--------------------------------------------------------------------*
#  |                                                                           |
#  |  - __Page 1__: LU Factorization `tupel(P,L,U) = lu(A)`                    |
#  |                                                                           |
#  *---------------------------------------------------------------------------*
# 
# :links: __Page (\d)__     -> doc:flens/examples/tut07-page0$1