/*
 * $Id: intro.dox,v 1.12 2004/11/30 09:05:53 opetzold Exp $
 */

/**
   \mainpage

   \section intro_contents Contents
   - \ref introduction
   - \ref license
   - \ref news
   - \ref changelog
   - \ref benchmark
   - \ref build
   - \ref usage
   - \ref faq
   - \ref notes
   - \ref compiler
   - \ref works
   - \ref credits
   - \ref projects
   - \ref links

*/

/**
   \page introduction Introduction

   This Tiny %Vector and %Matrix template library uses
   <a href=http://extreme.indiana.edu/~tveldhui/papers/Template-Metaprograms/meta-art.html>Meta Templates</a>
   (MT) and <a href=http://extreme.indiana.edu/~tveldhui/papers/Expression-Templates/exprtmpl.html>
   Expression Templates</a> (ET) to evaluate results at compile time -- which
   makes it fast for low order (tiny) systems. "Tiny" is a subjective term,
   but typically means vectors and matrices of size ten (10) or less.

   The technique used internally by tvmet is described by Todd Veldhuizen:

   - <a href=http://osl.iu.edu/~tveldhui/papers/techniques/>
     Techniques for Scientific C++</a>
   - <a href=http://osl.iu.edu/~tveldhui/papers/Expression-Templates/exprtmpl.html>
     Expression Templates</a>
   - <a href=http://osl.iu.edu/~tveldhui/papers/Template-Metaprograms/meta-art.html>
     Template Metaprograms</a>

   and is used by his <a href=http://oonumerics.org/blitz/>blitz++</a>, too.
   Therefore, the speed achieved by tvmet is similar to the speed of blitz++.
   Unfortunately, blitz++ isn't developed any more (year 2001, 2002)
   because of other interests being pursued by Todd Veldhuizen (like his Ph.D.).
   Furthermore, blitz++'s TinyVector is mainly developed for use by the blitz++
   Array class -- and not for minimalistic/tiny fast math support for which
   tvmet <b>is</b> designed. Because of this, the operators and functions are
   incomplete or not supported well. blitz::TinyMatrix supports a few lesser
   operators and functions (as with blitz::TinyVector). blitz++ doesn't conform
   to STL (e.g. Container<>::value_type isn't defined), it defines a T_numtype
   or, for blitz::TinyVector, it does have an iterator begin() - but the end()
   is missing (blitz::TinyMatrix doesn't have anything).

   These were reasons why I developed tvmet. Still, tvmet is designed to be more
   than a mere rehashing of blitz++.  The primary design goals are:

   -# mathematical notation and correctness,
   -# high efficiency for small/tiny vector and matrices,
   -# functionality and wide range of supported operators and functions, and
   -# compatibility and portability.

   The dimensions for vectors and matrices are statically bound at compile
   time using template arguments. The bounded dimensions feature a <b>compile
   time dimension check</b> to force adherence to proper dimensional sizes
   between operands (even in the night if you are sleepy).  For example, you
   can't assign a %Vector or %Matrix with dimension = 3 to a %Vector or %Matrix
   of dimension = 4; nor can you create an expression using a binary operation
   between arguments with incompatible dimensions. This is a major difference
   between tvmet (which features this) and blitz++ (which does not prevent
   from this). Nevertheless, tvmet isn't a matlab, maple or octave for C++.

   tvmet is a general purpose library and is not (yet) a linear algebra library.
   It does not have an interface to other numerical libraries as BLAS or LAPACK.
   <a href="http://sourceforge.net/projects/tvmet">Tiny Vector Matrix template
   library</a> offers these features:

   -# Matrices and Vectors with fixed sizes (of course), the data is stored in
      a static array.
   -# compile time dimension check for Vectors and Matrices to preserve the
      mathematical meaning.
   -# vector, matrix, matrix-matrix and matrix-vector fast operations:
      - complete set of standard arithmetic operations for Vectors and Matrices
        (<a href=http://oonumerics.org/blitz/>blitz++</a> supports this only for
        TinyVector).
      - complete set of standard compare operations for Vectors and Matrices
        as well as ternary functions like <tt>a ? b : c</tt>  (see eval for use).
      - binary and unary operations.
      - meta template use for %Matrix-Matrix-Product \f$M\,M\f$,
        %Matrix-Transpose \f$M^T\f$ and %Matrix-Vector-Product \f$M\,x\f$
        functions and operators.
      - meta template for special functions like
        \f$M^T\, x\f$, \f$M^T\,M\f$, \f$M\,M^T\f$ and \f$(M\,M)^T\f$
        functions, see \ref spec_meta_func.
      - simple %Matrix rows and column access as a %Vector.
      - chaining of matrix and vector expressions is possible and working.
      - %Vector inner and outer product (dot and cross product).
   -# special handling for the aliasing problem - see \ref alias.
   -# STL iterator interface.  This opens the door to all sorts of great STL
      applications.
   -# type promotion (for handling Matrices and Vectors of differing types).
   -# works on self defined types such as the std::complex<> type.
   -# makes no use of exceptions. Therefore you can use it for embedded systems
      or in Linux kernel space.
   -# nice expression level printing for debugging purposes (print the expanded
      expression tree).
   -# good documentation with examples.
   -# regression tests for nearly all operations and functions.
   -# support for several compilers (see \ref compiler).
   -# written as a pure class and template library, no binary libraries and
      versioning are needed - designed to avoid code blot due to the use of
      templates.
   -# ISO/IEC 14882:1998 compliant.

   Although there are many advantages and features, tvmet has some limitations.
   Due to the expression template and meta template programming, the compilation
   time increases for higher dimensional constructs.  This can cause resource
   limitations, especially for memory (during compilation). On the other hand,
   the runtime performance will also decrease on higher order. Therefore only
   use tvmet only tiny (typically less than 10) sizes. (The maximum useful
   size/dimension depends on the operation, of course.) The \ref benchmark
   gives a good entry point about these problem.
   <a href=http://www.oonumerics.org/oon/#libraries>Other</a>
   general purpose libraries and linear algebra libraries will do a better job
   for larger matrix/vector problems.


*/

/**
   \bugs regression test TestUnFunc::Arc and TestUnFunc::Log fails due to
   precision errors.
 */

// Local Variables:
// mode:c++
// End: