matrices.hh

#ifndef LOCARNA_MATRICES_HH
#define LOCARNA_MATRICES_HH

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

/* @file Define various generic matrix classes (with templated element
   type): simple matrix, matrix with range restriction, matrix with
   offset, rotatable matrix.
 */

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

#include <algorithm>

#include "matrix.hh"

namespace LocARNA {

    // ----------------------------------------
    template <class elem_t>
    class RMatrix : public Matrix<elem_t> {
        typedef typename Matrix<elem_t>::size_type size_type; 
    protected:
        size_type xl_; 
        size_type xr_; 
        size_type yl_; 
        size_type yr_; 

        size_type xfactor_; 
        size_type offset_;  
    
        size_type addr(size_type i, size_type j) const {
            assert(xl_<=i && i<=xr_);
            assert(yl_<=j && j<=yr_);
        
            return i*xfactor_ + j - offset_;
        }
    
    public:
        
        RMatrix() 
            : Matrix<elem_t>()
        {}
    
        
        void
        resize(size_type xdim, size_type ydim) {
            this->xdim_=xdim;
            this->ydim_=ydim;
            this->mat_.resize(xdim*ydim);
        
            restrict(0,xdim-1,0,ydim-1);
        }

        void restrict(size_type xl,size_type xr,size_type yl,size_type yr) {
            assert(xl>=0);
            assert(yl>=0);
            assert(xr<this->xdim_);
            assert(yr<this->ydim_);
            assert(xl<=xr);
            assert(yl<=yr);
        
            this->xl_=xl;
            this->xr_=xr;
            this->yl_=yl;
            this->yr_=yr;

            this->xfactor_ = (yr-yl)+1;
            this->offset_  = 0;
            this->offset_  = addr(xl,yl);
        }
    
        const elem_t & operator() (size_type i,size_type j) const {
            return this->mat_[addr(i,j)];
        }
    
        elem_t & operator() (size_type i,size_type j) {
            return this->mat_[addr(i,j)];
        }

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

        void
        set(size_type i,size_type j, const elem_t &x) {
            this->mat_[addr(i,j)]=x;
        }
        
        void 
        fill(const elem_t &val) {
            for (size_type i=xl_; i<xr_; ++i)
                for (size_type j=yl_; j<yr_; ++j)
                    this->mat_(i,j)=val;
        }
    };


    // ----------------------------------------
    template <class elem_t>
    class OMatrix : public Matrix<elem_t> {
    protected:
        size_t off_; 
        size_t xoff_; 
        size_t yoff_; 

        size_t addr(size_t i, size_t j) const {
            assert(xoff_<=i && i<xoff_+this->xdim_);
            assert(yoff_<=j && j<yoff_+this->ydim_);
            return i*this->ydim_ + j - off_;
        }
    
    public:
        
        OMatrix()
            : Matrix<elem_t>(),
              off_(0), 
              xoff_(0),yoff_(0) {
        }
        
        void
        resize(size_t xdim, size_t ydim, size_t xoff=0, size_t yoff=0) {
            xoff_=xoff;
            yoff_=yoff;
            off_=xoff*ydim+yoff;
            this->xdim_=xdim;
            this->ydim_=ydim;
            this->mat_.resize(xdim*ydim);
        }

        const elem_t & 
        operator() (size_t i,size_t j) const {
            return this->mat_[addr(i,j)];
        }
    
        elem_t & 
        operator() (size_t i,size_t j) {
            return this->mat_[addr(i,j)];
        }

        const elem_t get(size_t i,size_t j) const {
            return this->mat_[addr(i,j)];
        }

        void
        set(size_t i,size_t j, const elem_t &x) {
            this->mat_[addr(i,j)]=x;
        }
        
    };


    // ----------------------------------------
    template <class elem_t>
    class RotMatrix: public Matrix<elem_t> {

    protected:
        size_t xrot_; 
        size_t yrot_; 

        size_t rot(size_t x, size_t r, size_t d) {
            assert(r<d);
            return (x+d-r)%d;
        }
    
        size_t addr(size_t i, size_t j) const {
            assert(xrot_<=i && i<xrot_+this->xdim_);
            assert(yrot_<=j && j<yrot_+this->ydim_);
            return rot(i,xrot_,this->xdim_)*this->xdim_ + rot(j,yrot_,this->ydim_);
        }

    public:    

        RotMatrix() :
            Matrix<elem_t>(0),
            xrot_(0),
            yrot_(0) {
        }
        
        void
        resize(size_t xdim, size_t ydim, size_t xrot=0, size_t yrot=0) {
            xrot_=xrot;
            yrot_=yrot;
            this->xdim_=xdim;
            this->ydim_=ydim;
            this->mat_.resize(xdim*ydim);
        }

        void move(size_t xrot, size_t yrot) {
            xrot_=xrot;
            yrot_=yrot;
        }
    
        const elem_t & operator() (size_t i,size_t j) const {
            return this->mat_[addr(i,j)];
        }
    
        elem_t & operator() (size_t i,size_t j) {
            return this->mat_[addr(i,j)];
        }

        const elem_t get(size_t i,size_t j) const {
            return this->mat_[addr(i,j)];
        }

        void
        set(size_t i,size_t j, const elem_t &x) {
            this->mat_[addr(i,j)]=x;
        }
        
    };

} // end namespace LocARNA

#endif // LOCARNA_MATRICES_HH