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