matrix.hh

#ifndef LOCARNA_MATRIX_HH
#define LOCARNA_MATRIX_HH

#ifdef HAVE_CONFIG_H
#  include <config.h>
#endif

/* @file Define simple, generic matrix class (with templated element
   type)
 */

#include <iostream>
#include <vector>
#include <assert.h>

#include <algorithm>

namespace LocARNA {

    /*
      Define classes for the dynamic programming
      matrices.

      The structures support offsets and moving
      of the offset, while maintaining the entries
      in the overlapping sub-matrix
    */

    template <class T>
    class Matrix {
    public:
        typedef T elem_t; 
        typedef typename std::vector<elem_t>::size_type size_type; 
        
        typedef std::pair<size_type,size_type> size_pair_type; 
    
    protected:
        std::vector<elem_t> mat_; 
        size_type xdim_; 
        size_type ydim_; 
    
        size_type addr(size_type i, size_type j) const {
            assert(0<=i && i<this->xdim_);
            assert(0<=j && j<this->ydim_);
            return i*ydim_+j;
        }

    public:
        Matrix() 
            : mat_(),xdim_(0),ydim_(0) {
        }
    
        Matrix(size_type xdim, size_type ydim, const elem_t *from=0L)
            : mat_(xdim*ydim),xdim_(xdim),ydim_(ydim) {
            if (from!=0L) {
                for (size_type i=0; i<xdim_; i++) {
                    for (size_type j=0; j<ydim_; j++) {
                        (*this)(i,j)=from[i*ydim+j];
                    }
                }
            }
        }
    
        size_pair_type sizes() const {
            return size_pair_type(xdim_,ydim_);
        }

        void
        resize(size_type xdim, size_type ydim) {
            xdim_=xdim;
            ydim_=ydim;
        
            mat_.resize(xdim_*ydim_);
        }
    
        const elem_t & operator() (size_type i,size_type j) const {
            return mat_[addr(i,j)];
        }
    
        elem_t & operator() (size_type i,size_type j) {
            return mat_[addr(i,j)];
        }

        const elem_t get(size_type i,size_type j) const {
            return mat_[addr(i,j)];
        }

        void
        set(size_type i,size_type j, const elem_t &x) {
            mat_[addr(i,j)]=x;
        }

        void 
        fill(const elem_t &val) {
            for (size_type i=0; i<xdim_*ydim_; ++i)
                mat_[i]=val;
        }

        void
        clear() {
            resize(0,0);
            mat_.clear();
        }
    
        template<class UnaryOperator>
        void transform(UnaryOperator f) {
            std::transform(mat_.begin(),mat_.end(),mat_.begin(),f);
        }
    };

    template <class T>
    std::ostream & operator << (std::ostream &out, Matrix<T> mat) {
        typename Matrix<T>::size_pair_type sizes = mat.sizes();
    
        for (typename Matrix<T>::size_type i=0; i<sizes.first; i++) {
            for (typename Matrix<T>::size_type j=0; j<sizes.second; j++) {
                out << mat(i,j) << " ";
            }
            out << std::endl;
        }
        return out;
    }

    template <class T>
    std::istream & operator >> (std::istream &in, Matrix<T> &mat) {
        typename Matrix<T>::size_pair_type sizes = mat.sizes();
        for (typename Matrix<T>::size_type i=0; i<=mat.sizes().first; i++) {
            for (typename Matrix<T>::size_type j=0; j<=mat.sizes().second; j++) {
                in >> mat(i,j);
            }
        }
        return in;
    }



} // end namespace LocARNA

#endif // LOCARNA_MATRIX_HH