TooN.h

//-*- c++ -*-

// Copyright (C) 2005,2009 Tom Drummond (twd20@cam.ac.uk),
// Ed Rosten (er258@cam.ac.uk), Gerhard Reitmayr (gr281@cam.ac.uk)

//All rights reserved.
//
//Redistribution and use in source and binary forms, with or without
//modification, are permitted provided that the following conditions
//are met:
//1. Redistributions of source code must retain the above copyright
//    notice, this list of conditions and the following disclaimer.
//2. Redistributions in binary form must reproduce the above copyright
//   notice, this list of conditions and the following disclaimer in the
//   documentation and/or other materials provided with the distribution.
//
//THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND OTHER CONTRIBUTORS ``AS IS''
//AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
//IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
//ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR OTHER CONTRIBUTORS BE
//LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
//CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
//SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
//INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
//CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
//ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
//POSSIBILITY OF SUCH DAMAGE.


#ifndef TOON_INCLUDE_TOON_H
#define TOON_INCLUDE_TOON_H
#include <iostream>
#include <cstdlib>
#include <limits>
#include <new>
#include <utility>
#include <vector>
#include <initializer_list>
#include <complex>
#include <TooN/internal/config.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;
        };
    }
    
#if defined TOON_DEFAULT_PRECISION_TYPE
        typedef TOON_DEFAULT_PRECISION_TYPE DefaultPrecision;
#else
        typedef double DefaultPrecision;
#endif

#if defined  TOON_FORTRAN_INTEGER && defined TOON_CLAPACK
    #error Error: both TOON_FORTRAN_INTEGER and TOON_CLAPACK defined
#elif defined TOON_CLAPACK
    typedef long FortranInteger;
#elif defined TOON_FORTRAN_INTEGER
    typedef TOON_FORTRAN_INTEGER FortranInteger;
#else
    typedef int FortranInteger;
#endif

}

#include <TooN/internal/size_mismatch.hh>
#include <TooN/internal/debug.hh>

#include <TooN/internal/introspection.hh>


#include <TooN/internal/dchecktest.hh>
#include <TooN/internal/allocator.hh>

#include <TooN/internal/overfill_error.hh>
#include <TooN/internal/slice_error.hh>

#include <TooN/internal/comma.hh>

#include <TooN/internal/vbase.hh>
#include <TooN/internal/vector.hh>
    
#include <TooN/internal/mbase.hh>
#include <TooN/internal/matrix.hh>
#include <TooN/internal/reference.hh>

#include <TooN/internal/make_vector.hh>
#include <TooN/internal/operators.hh>
    
#include <TooN/internal/objects.h>

#include <TooN/internal/diagmatrix.h>

#include <TooN/internal/data.hh>
#include <TooN/internal/data_functions.hh>

#include <TooN/helpers.h>
#include <TooN/determinant.h>

namespace std
{
    //Specialising std templates is explicitly allowed.
    using TooN::swap;
}

#endif