Matrix.hpp

/*
 * Matrix.hpp
 *
 *  Created on: Jun 3, 2015
 *      Author: Pietro Incardona
 */

#ifndef MATRIX_HPP_
#define MATRIX_HPP_


#include <boost/fusion/sequence/intrinsic/at_c.hpp>
#include <boost/fusion/include/at_c.hpp>
#include <boost/fusion/container/vector.hpp>
#include <boost/fusion/include/vector.hpp>
#include <boost/fusion/container/vector/vector_fwd.hpp>
#include <boost/fusion/include/vector_fwd.hpp>
#include "boost/multi_array.hpp"
#include "Grid/grid_key.hpp"

template<unsigned int dim ,typename T> class Matrix
{
    public:

    typedef T coord_type;

    typedef boost::fusion::vector<T[dim][dim]> type;

    type data;

    static const unsigned int mat = 0;

    inline T get(size_t i,size_t j) const
    {
        return boost::fusion::at_c<mat>(data)[i][j];
    }

    inline T& get(size_t i,size_t j)
    {
        return boost::fusion::at_c<mat>(data)[i][j];
    }

    inline Matrix<dim,T> & operator=(const Matrix<dim,T> & m)
    {
        for (size_t i = 0 ; i < dim ; i++)
        {
            for (size_t j = 0 ; j < dim ; j++)
                get(i,j) = m.get(i,j);
        }

        return *this;
    }

    void zero()
    {
        for (size_t i = 0 ; i < dim ; i++)
        {
            for (size_t j = 0 ; j < dim ; j++)
            {
                get(i,j) = 0;
            }
        }
    }

    Matrix(const Matrix<dim,T> && p)
    {
        for(size_t i = 0; i < dim ; i++)
        {
            for (size_t j = 0 ; j < dim ; j++)
            {
                get(i,j) = p.get(i,j);
            }
        }
    }

    Matrix(const Matrix<dim,T> & p)
    {
        for(size_t i = 0; i < dim ; i++)
        {
            for (size_t j = 0 ; j < dim ; j++)
            {
                get(i,j) = p.get(i,j);
            }
        }
    }

    Matrix(const T (&p)[dim][dim])
    {
        for(size_t i = 0; i < dim ; i++)
        {
            for (size_t j = 0 ; j < dim ; j++)
            {
                get(i,j) = p[i][j];
            }
        }
    }

    Matrix()
    {}

    inline static Matrix<dim,T> identity()
    {
        Matrix<dim,T> ret;

        for (size_t i = 0 ; i < dim ; i++)
        {
            for (size_t j = 0 ; j < dim ; j++)
            {
                /* coverity[dead_error_line] */
                ret.get(i,j) = (i == j)?1:0;
            }
        }

        return ret;
    }

    static const unsigned int max_prop = 1;

    static const unsigned int dims = dim;
};


#endif /* MATRIX_HPP_ */