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