src/LocARNA/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