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_ */