Matrix.h

//-*- C++ -*-
//-*- coding: utf-8 -*-
//
// Author: Bryan V. Riel
// Copyright 2017-2018

#pragma once

#include "forward.h"

#include <cmath>
#include <valarray>
#include <vector>

#include <pyre/grid.h>

#include "EMatrix.h"

template <typename cell_t>
class isce3::core::Matrix {

    public:
        // Types for interfacing with pyre::grid
        using rep_t = std::array<size_t, 2>;
        using index_t = pyre::grid::index_t<rep_t>;
        using layout_t = pyre::grid::layout_t<index_t>;

        // Use a grid with view memory storage
        using grid_t = pyre::grid::grid_t<cell_t, layout_t, pyre::memory::view_t<cell_t>>;

        // Dependent types
        using view_t = typename grid_t::view_type;
        using shape_t = typename layout_t::shape_type;
        using slice_t = typename layout_t::slice_type;
        using packing_t = typename layout_t::packing_type;

    public:
        inline Matrix();

        inline Matrix(size_t nrows, size_t ncols);

        inline Matrix(const Matrix<cell_t> & m);

        inline Matrix(Matrix<cell_t> & m);

        inline Matrix(const view_t & view);

        inline Matrix(cell_t * data, size_t nrows, size_t ncols);

        inline Matrix(std::valarray<cell_t> & data, size_t ncols);

        inline Matrix(std::vector<cell_t> & data, size_t ncols);

        inline ~Matrix();

        inline Matrix<cell_t> & operator=(const Matrix<cell_t> & m);

        inline Matrix<cell_t> & operator=(Matrix<cell_t> & m);
        
        inline Matrix<cell_t> & operator=(const view_t & view);

        inline void resize(size_t nrows, size_t ncols);

        inline const view_t submat(size_t row, size_t col, size_t rowspan, size_t colspan);
            
        inline cell_t * data();

        inline const cell_t * data() const;

        inline cell_t * rowptr(size_t row);

        inline const cell_t * rowptr(size_t row) const;

        inline cell_t & operator()(size_t row, size_t col);

        inline const cell_t & operator()(size_t row, size_t col) const;

        inline cell_t & operator()(size_t index);

        inline const cell_t & operator()(size_t index) const;

        inline cell_t & operator[](const index_t & index);

        inline const cell_t & operator[](const index_t & index) const;

        inline void zeros();

        inline void fill(cell_t value);

        inline shape_t shape() const;

        inline size_t width() const;

        inline size_t length() const;

        inline shape_t byteoffset() const;

        auto map() const
        {
            return Eigen::Map<const EArray2D<cell_t>> {
                    _buffer, static_cast<Eigen::Index>(_nrows),
                    static_cast<Eigen::Index>(_ncols)};
        }

    // Data members
    private:
        // Shape information
        size_t _nrows;
        size_t _ncols;

        // Dynamic memory data
        cell_t* _buffer = nullptr;
        bool _owner;

        // grid pointer for slicing support
        grid_t * _grid;

    // Utility functions
    private:
        // Reset grid pointer
        inline void _resetGrid();
};

// Get inline implementations for Matrix
#define ISCE_CORE_MATRIX_ICC
#include "Matrix.icc"
#undef ISCE_CORE_MATRIX_ICC