LTL Little Template Library
===========================

   (c) 2000-2004 Niv Drory, Claus A. Goessl, Jan Snigula
   released under the GNU Public License (GPL)

   LTL provides dynamic arrays of up to 7-dimensions, subarrays and
   slicing, support for fixed size vectors and matrices including
   basic linear algebra operations, expression templates based
   evaluation, and I/O facilities for ascii and FITS format files.

   Although the library is developed with application to astronomical
   image and data processing in mind (therefore FITS format I/O), it
   is by no means restricted to these fields of application. In fact,
   it qualifies as a fully general array processing package.

   Focus is laid on a high abstraction level regarding the handling of
   expressions involving arrays or parts thereof and linear algebra
   related operations without the usually involved negative impact on
   performance. Hence the use of expression templates throughout the
   library. The price to pay is dependence on a compiler implementing
   enough of the current ANSI C++ specification, as well as
   significantly higher demand on resources at compile time compared
   to a hand coded C implementation.

   A new feature as of LTL 1.7 is the automatic use of the vector 
   execution unit present in some modern processors in the evaluation
   of array expressions. This is basically a compiler independent 
   auto-vectorizer. Currently PowerPC processors (Altivec) and x86 
   processors (MMX/SSE/SSE2) are supported.

   As of version 1.7, LTL supports GCC versions 2.95.2 to 3.4.x
   (Linux/IA32, Mac OS X/PPC, Solaris/SPARC), Intel ICC version 7.1
   and 8 (Linux/IA32), Sun C++ version 5.5 (Solaris/SPARC), and IBM
   VisualAge xlC version 6 (AIX/PPC, Mac OS X/PPC). DEC/Compaq/HP
   (whatever) compiler support is on the way. Other sufficiently ANSI
   complient C++ compilers should also do, but might require small
   modifications. Patches welcome.

   The array class has the following features:
      - creating subarrays (rank preserving), e.g. a submatrix
      - slicing (rank reducing), e.g. a column vector of a matrix
      - mixing subarrays and slices in the same indexing expression
        e.g. a submatrix of a slice of a cube
      - referencing the data of other arrays ('views')
      - reference counting for the memory chunks holding the actual data
      - STL-compatible iterators
      - arbitrary complex arithmetic expressions without creation of 
        temporary objects: 'expression templates'
      - support for all standard library math functions
      - user supplied functions can be added easily
      - auto-vectorization of expressions (Altivec, SSE2)
      - indexing arbitrary sets of elements: 'where()'
      - conditional expression evaluation: 'merge( A!=0, 1/A, 0 )'
      - optional bounds checking for debugging
      - stream I/O
      - ascii-file I/O for columnar data
      - FITS file I/O
      - transparent mapped-memory arrays

   The fixed vector and matrix classes provide:
      - expression template based evaluation of arithmetic and
        linear algebra expression
      - referencing column and row vectors of a matrix
      - vector dot product
      - matrix-vector and matrix-matrix dot-product
      - all operations on small enough objects are automatically 
        unrolled by template metaprograms

   Additionally, there are some utility classes providing: 
      - command line and config file parsing
      - output formatting utilities
      - date format handling

   See doc/* for full documentation.
