matrix.hh

// -*- c++ -*-

// Copyright (C) 2009 Tom Drummond (twd20@cam.ac.uk),
// Ed Rosten (er258@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.

namespace TooN {

template <int Rows=Dynamic, int Cols=Rows, class Precision=DefaultPrecision, class Layout = RowMajor>
struct Matrix : public Layout::template MLayout<Rows, Cols, Precision>
{
public:

    using Layout::template MLayout<Rows, Cols, Precision>::my_data;
    using Layout::template MLayout<Rows, Cols, Precision>::num_rows;
    using Layout::template MLayout<Rows, Cols, Precision>::num_cols;

    //Use Tom's sneaky constructor hack...


    Matrix(){}
    
    Matrix(int rows, int cols) :
        Layout::template MLayout<Rows,Cols,Precision>(rows, cols)
    {}
    
    Matrix(Precision* p) :
        Layout::template MLayout<Rows, Cols, Precision>(p)
    {}

    Matrix(Precision* p, int r, int c) :
        Layout::template MLayout<Rows, Cols, Precision>(p, r, c)
    {}

    Matrix(Precision* data, int rows, int cols, int rowstride, int colstride, Internal::Slicing)
    :Layout::template MLayout<Rows, Cols, Precision>(data, rows, cols, rowstride, colstride){}


    //See vector.hh and allocator.hh for details about why the
    //copy constructor should be default.
    template <class Op>
    inline Matrix(const Operator<Op>& op)
        :Layout::template MLayout<Rows,Cols,Precision>(op)
    {
        op.eval(*this);
    }

    template<int Rows2, int Cols2, typename Precision2, typename Base2>
    inline Matrix(const Matrix<Rows2, Cols2,Precision2,Base2>& from)
    :Layout::template MLayout<Rows,Cols,Precision>(from.num_rows(), from.num_cols())
    {
        operator=(from);
    }

    inline Matrix& operator= (const Matrix& from)
    {
        SizeMismatch<Rows, Rows>::test(num_rows(), from.num_rows());
        SizeMismatch<Cols, Cols>::test(num_cols(), from.num_cols());

        for(int r=0; r < num_rows(); r++)
          for(int c=0; c < num_cols(); c++)
            (*this)[r][c] = from[r][c];

        return *this;
    }

    // operator = 0-ary operator
    template<class Op> inline Matrix& operator= (const Operator<Op>& op)
    {
        op.eval(*this);
        return *this;
    }

    // operator =
    template<int Rows2, int Cols2, typename Precision2, typename Base2>
    Matrix& operator= (const Matrix<Rows2, Cols2, Precision2, Base2>& from)
    {
        SizeMismatch<Rows, Rows2>::test(num_rows(), from.num_rows());
        SizeMismatch<Cols, Cols2>::test(num_cols(), from.num_cols());

        for(int r=0; r < num_rows(); r++)
          for(int c=0; c < num_cols(); c++)
            (*this)[r][c] = from[r][c];

        return *this;
    }


    Matrix& operator*=(const Precision rhs)
    {
          for(int r=0; r < num_rows(); r++)
              for(int c=0; c < num_cols(); c++)
                (*this)[r][c] *= rhs;

          return *this;
    }

    Matrix& operator/=(const Precision rhs)
    {
          for(int r=0; r < num_rows(); r++)
              for(int c=0; c < num_cols(); c++)
                (*this)[r][c] /= rhs;

          return *this;
    }

    template<int Rows2, int Cols2, typename Precision2, typename Base2>
    Matrix& operator+= (const Matrix<Rows2, Cols2, Precision2, Base2>& from)
    {
        SizeMismatch<Rows, Rows2>::test(num_rows(), from.num_rows());
        SizeMismatch<Cols, Cols2>::test(num_cols(), from.num_cols());

        for(int r=0; r < num_rows(); r++)
          for(int c=0; c < num_cols(); c++)
            (*this)[r][c] += from[r][c];

        return *this;
    }

    template<class Op>
    Matrix& operator+=(const Operator<Op>& op)
    {
        op.plusequals(*this);
        return *this;
    }

    template<class Op>
    Matrix& operator-=(const Operator<Op>& op)
    {
        op.minusequals(*this);
        return *this;
    }

    template<int Rows2, int Cols2, typename Precision2, typename Base2>
    Matrix& operator-= (const Matrix<Rows2, Cols2, Precision2, Base2>& from)
    {
        SizeMismatch<Rows, Rows2>::test(num_rows(), from.num_rows());
        SizeMismatch<Cols, Cols2>::test(num_cols(), from.num_cols());

        for(int r=0; r < num_rows(); r++)
          for(int c=0; c < num_cols(); c++)
            (*this)[r][c] -= from[r][c];

        return *this;
    }

    template<int Rows2, int Cols2, typename Precision2, typename Base2>
    bool operator== (const Matrix<Rows2, Cols2, Precision2, Base2>& rhs) const
    {
        SizeMismatch<Rows, Rows2>::test(num_rows(), rhs.num_rows());
        SizeMismatch<Cols, Cols2>::test(num_cols(), rhs.num_cols());

        for(int r=0; r < num_rows(); r++)
          for(int c=0; c < num_cols(); c++)
            if((*this)[r][c] != rhs[r][c])
              return 0;
        return 1;
    }

    template<int Rows2, int Cols2, typename Precision2, typename Base2>
    bool operator!= (const Matrix<Rows2, Cols2, Precision2, Base2>& rhs) const
    {
        SizeMismatch<Rows, Rows2>::test(num_rows(), rhs.num_rows());
        SizeMismatch<Cols, Cols2>::test(num_cols(), rhs.num_cols());

        for(int r=0; r < num_rows(); r++)
          for(int c=0; c < num_cols(); c++)
            if((*this)[r][c] != rhs[r][c])
              return 1;
        return 0;
    }

    template<class Op>
    bool operator!=(const Operator<Op>& op)
    {
        return op.notequal(*this);
    }

    
    

    Matrix& ref()
    {
        return *this;
    }

    #ifdef DOXYGEN_INCLUDE_ONLY_FOR_DOCS
  
        const double& operator() (int r, int c) const;

        const double& operator[](const std::pair<int,int>& row_col) const;
        double& operator[](const std::pair<int,int>& row_col);

        double& operator() (int r, int c);

        const Vector& operator[] (int r) const;

        Vector& operator[] (int r);

        int num_rows() const;

        int num_cols() const;



        const Matrix<Cols, Rows>& T() const;

        Matrix<Cols, Rows>& T();

        template<Rstart, Cstart, Rsize, Csize>
        const Matrix<Rsize, Csize>& slice() const;

        template<Rstart, Cstart, Rsize, Csize>
        Matrix<Rsize, Csize>& slice();

        const Matrix<>& slice(int rstart, int cstart, int rsize, int csize) const;

        Matrix<>& slice(int rstart, int cstart, int rsize, int csize);



    #endif
};

}