TooN.h

Go to the documentation of this file.

//-*- c++ -*-

// Copyright (C) 2005,2009 Tom Drummond (twd20@cam.ac.uk),
// Ed Rosten (er258@cam.ac.uk), Gerhard Reitmayr (gr281@cam.ac.uk)
//
// This file is part of the TooN Library.  This library is free
// software; you can redistribute it and/or modify it under the
// terms of the GNU General Public License as published by the
// Free Software Foundation; either version 2, or (at your option)
// any later version.

// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.

// You should have received a copy of the GNU General Public License along
// with this library; see the file COPYING.  If not, write to the Free
// Software Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307,
// USA.

// As a special exception, you may use this file as part of a free software
// library without restriction.  Specifically, if other files instantiate
// templates or use macros or inline functions from this file, or you compile
// this file and link it with other files to produce an executable, this
// file does not by itself cause the resulting executable to be covered by
// the GNU General Public License.  This exception does not however
// invalidate any other reasons why the executable file might be covered by
// the GNU General Public License.


#ifndef TOON_INCLUDE_TOON_H
#define TOON_INCLUDE_TOON_H
#include <iostream>
#include <cstdlib>
#include <limits>
#include <new>
#include <utility>
#include <vector>
#include <complex>
#include "config.hh"
#include "typeof.hh"
#include "deprecated.hh"

#if defined TOON_NDEBUG || defined NDEBUG
    #define TOON_NDEBUG_MISMATCH
    #define TOON_NDEBUG_SLICE
    #define TOON_NDEBUG_SIZE
    #define TOON_NDEBUG_FILL
#endif

#ifdef TOON_INITIALIZE_RANDOM
#include <ctime>
#endif

#ifdef TOON_USE_LAPACK
    #ifndef TOON_DETERMINANT_LAPACK
        #define TOON_DETERMINANT_LAPACK 35
    #endif
#endif

namespace TooN {

#ifdef TOON_TEST_INTERNALS
    namespace Internal
    {
        struct BadIndex{};
        struct SliceError{};
        struct StaticSliceError{};
        struct SizeMismatch{};
        struct StaticSizeMismatch{};
        struct VectorOverfill{};
        struct StaticVectorOverfill{};
        struct MatrixOverfill{};
        struct StaticMatrixOverfill{};
        struct Underfill{};
    }
#endif
    
    using std::numeric_limits;
    template<class C> struct IsField
    {
        static const int value = numeric_limits<C>::is_specialized; 
    };

    template<class C> struct IsField<std::complex<C> >
    {
        static const int value = numeric_limits<C>::is_specialized; 
    };
    
    template<class C> struct IsField<const C>
    {
        static const int value = IsField<C>::value; 
    };

    template<class C, class D> struct These_Types_Do_Not_Form_A_Field;
    
    namespace Internal
    {
        static const unsigned int max_bytes_on_stack=1000;
        struct Slicing{};
        template<int RowStride, int ColStride> struct Slice;
        template<int Size, typename Precision, int Stride, typename Mem> struct GenericVBase;
    }

    template<int Size, class Precision, class Base> struct Vector;
    template<int Rows, int Cols, class Precision, class Base> struct Matrix;
    template<int Size, class Precision, class Base> struct DiagonalMatrix;


    #ifdef DOXYGEN_INCLUDE_ONLY_FOR_DOCS
        template<typename T> struct Operator{

            int size() const;
            int num_rows() const; 
            int num_cols() const;
            

            template<int Size, class Precision, class Base>
            void eval(Vector<Size, Precision, Base>& v) const;

            template <int Size, typename P1, typename B1> 
            void plusequals(Vector<Size, P1, B1>& v) const;

            template <int Size, typename P1, typename B1>
            void minusequals(Vector<Size, P1, B1>& v) const;

            template <int Size, typename P1, typename B1> 
            Operator<T> add(const Vector<Size, P1, B1>& v) const;

            template <int Size, typename P1, typename B1> 
            Operator<T> rsubtract(const Vector<Size, P1, B1>& v) const;

            template <int Size, typename P1, typename B1> 
            Operator<T> lsubtract(const Vector<Size, P1, B1>& v) const;


            template<int R, int C, class P, class B>
            void eval(Matrix<R,C,P,B>& m) const; 

            template <int Rows, int Cols, typename P1, typename B1> 
            Operator<T> add(const Matrix<Rows,Cols, P1, B1>& m) const;


            template <int Rows, int Cols, typename P1, typename B1> 
            Operator<T> rsubtract(const Matrix<Rows,Cols, P1, B1>& m) const;

            template <int Rows, int Cols, typename P1, typename B1> 
            Operator<T> lsubtract(const Matrix<Rows,Cols, P1, B1>& m) const;

            template <int Rows, int Cols, typename P1, typename B1> 
            void plusequals(Matrix<Rows,Cols, P1, B1>& m) const;

            template <int Rows, int Cols, typename P1, typename B1> 
            void minusequals(Matrix<Rows,Cols, P1, B1>& m) const;



            Operator<T> operator()(int size) const;
            
            Operator<T> operator()(int num_rows, int num_cols) const;
            
            typedef T Precision; 
            
            template<class Pout, class Pmult> Operator<Internal::Identity<Pout> > scale_me(const Pmult& m) const
            {
                return Operator<Internal::Identity<Pout> >(val*m);
            }

        };
    #else
        template<typename T> struct Operator;
    #endif

    static const int Dynamic = -1;
    static const int Resizable = -0x7fffffff;

    namespace Internal
    {
        template<int i, int j> struct SimpleSizer{static const int size=i;};
        template<int i> struct SimpleSizer<Dynamic, i>{static const int size=i;};
        template<int i> struct SimpleSizer<i, Dynamic>{static const int size=i;};
        template<> struct SimpleSizer<Dynamic, Dynamic>    {static const int size=-1;};

        template<int i> struct IsStatic
        {
            static const bool is = (i!=Dynamic && i != Resizable);
        };

        //Choose an output size, given a pair of input sizes. Be static if possible.
        template<int i, int j=i> struct Sizer{
            static const int size=SimpleSizer<Sizer<i>::size, Sizer<j>::size>::size;
        };

        //Choose an output size, given an input size. Be static if possible.
        //Otherwise be dynamic. Never generate a resizable vector.
        template<int i> struct Sizer<i,i>{
            static const int size = IsStatic<i>::is?i:Dynamic;
        };
    }
    
#ifndef TOON_DEFAULT_PRECISION
    typedef double DefaultPrecision;
#else
    typedef TOON_DEFAULT_PRECISION DefaultPrecision;
#endif
}

#include "dchecktest.hh"
#include "allocator.hh"

#include "size_mismatch.hh"
#include "overfill_error.hh"
#include "slice_error.hh"
#include "debug.hh"

#include "comma.hh"

#include "vbase.hh"
#include "vector.hh"
    
#include "mbase.hh"
#include "matrix.hh"
#include "reference.hh"

#include "make_vector.hh"
#include "operators.hh"
    
#include "objects.h"

#include "diagmatrix.h"

#include "data.hh"
#include "data_functions.hh"

#include "helpers.h"

#endif