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(i < this->xdim_);
            //assert(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 = nullptr)
            : mat_(xdim * ydim), xdim_(xdim), ydim_(ydim) {
            if (from == nullptr) return;
 
            std::copy(from, from + xdim_ * ydim_, mat_.begin());
        }
 
        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