Matrix.h

//-*- C++ -*-
//-*- coding: utf-8 -*-
//
// Author: Bryan V. Riel
// Copyright 2017-2018
 
#pragma once
 
#include "forward.h"
 
#include <cassert>
#include <cmath>
#include <limits>
#include <valarray>
#include <vector>
 
#include "EMatrix.h"

template <typename T>
class isce3::core::Matrix :
    public Eigen::Array<T, Eigen::Dynamic, Eigen::Dynamic, Eigen::RowMajor>
{
 
        using super_t = Eigen::Array<T, Eigen::Dynamic, Eigen::Dynamic, Eigen::RowMajor>;
 
    public:
        using index_t = typename super_t::Index;
 
    public:
        Matrix() : super_t(0, 0) {}
 
        Matrix(index_t rows, index_t cols) : super_t(rows, cols) {}
 
        template<typename Derived>
        Matrix(const Eigen::Block<Derived>& b) : super_t(b) {}

        Matrix(T * data, size_t nrows, size_t ncols) :
            super_t(Eigen::Map<super_t>(data, nrows, ncols))
        {
            assert(ncols <= std::numeric_limits<Eigen::Index>::max());
            assert(nrows <= std::numeric_limits<Eigen::Index>::max());
        }

        Matrix(std::valarray<T> & data, size_t ncols) :
            super_t(Eigen::Map<super_t>(data.data(), data.size() / ncols, ncols))
        {
            assert(ncols <= std::numeric_limits<Eigen::Index>::max());
        }

        Matrix(std::vector<T> & data, size_t ncols) :
            super_t(Eigen::Map<super_t>(data.data(), data.size() / ncols, ncols))
        {
            assert(ncols <= std::numeric_limits<Eigen::Index>::max());
        }

        auto submat(size_t row, size_t col, size_t rowspan, size_t colspan) {
            assert(col <= std::numeric_limits<Eigen::Index>::max());
            assert(row <= std::numeric_limits<Eigen::Index>::max());
            assert(colspan <= std::numeric_limits<Eigen::Index>::max());
            assert(rowspan <= std::numeric_limits<Eigen::Index>::max());
            return this->block(row, col, rowspan, colspan);
        }

        void zeros() { this->fill(0); }

        size_t width() const { return this->cols(); }

        size_t length() const { return this->rows(); }
 
        auto map() const {
            return Eigen::Map<const super_t> {
                    this->data(),
                    this->rows(),
                    this->cols(),
            };
        }
 
};