matrix.hpp

Go to the documentation of this file.

/***************************************************************************
*                                                                          *
*   Copyright (C) 2018 by David B. Blumenthal                              *
*                                                                          *
*   This file is part of GEDLIB.                                           *
*                                                                          *
*   GEDLIB is free software: you can redistribute it and/or modify it      *
*   under the terms of the GNU Lesser General Public License as published  *
*   by the Free Software Foundation, either version 3 of the License, or   *
*   (at your option) any later version.                                    *
*                                                                          *
*   GEDLIB is distributed in the hope that it will be useful,              *
*   but WITHOUT ANY WARRANTY; without even the implied warranty of         *
*   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the           *
*   GNU Lesser General Public License for more details.                    *
*                                                                          *
*   You should have received a copy of the GNU Lesser General Public       *
*   License along with GEDLIB. If not, see <http://www.gnu.org/licenses/>. *
*                                                                          *
***************************************************************************/

#ifndef SRC_ENV_MATRIX_HPP_
#define SRC_ENV_MATRIX_HPP_

#include "common_types.hpp"

namespace ged {

template<class ScalarT>
class Matrix {

public:
    Matrix();

    Matrix(std::size_t num_rows, std::size_t num_cols, ScalarT val = 0);

    Matrix(const Matrix & matrix);

    void operator=(const Matrix & matrix);

    void swap(Matrix& matrix);

    const ScalarT & operator() (std::size_t row, std::size_t col) const;

    ScalarT & operator() (std::size_t row, std::size_t col);


    ScalarT * data();

    const ScalarT * data() const;


    std::size_t num_rows() const;

    std::size_t num_cols() const;

    void resize(std::size_t num_rows, std::size_t num_cols);

    void set_to_val(const ScalarT & val);

    void power(std::size_t n);

    ScalarT max() const;

    ScalarT min() const;

    void transpose();

    Matrix<ScalarT> transposed() const;

    Matrix<ScalarT> & operator*=(const ScalarT & scalar);

    Matrix<ScalarT> & operator+=(const Matrix<ScalarT> & matrix);

    Matrix<ScalarT> & operator-=(const Matrix<ScalarT> & matrix);

    Matrix<ScalarT> operator*(const ScalarT & scalar) const;

    Matrix<ScalarT> operator+(const Matrix<ScalarT> & matrix) const;

    Matrix<ScalarT> operator-(const Matrix<ScalarT> & matrix) const;

    Eigen::Matrix<ScalarT, Eigen::Dynamic, Eigen::Dynamic> & matrix();

    const Eigen::Matrix<ScalarT, Eigen::Dynamic, Eigen::Dynamic> & matrix() const;

private:
    Eigen::Matrix<ScalarT, Eigen::Dynamic, Eigen::Dynamic> matrix_;

};

typedef Matrix<double> DMatrix;

typedef Matrix<int> IMatrix;

template<typename ScalarT>
std::ostream & operator<<(std::ostream & os, const Matrix<ScalarT> & matrix);

}

#include "matrix.ipp"

#endif /* SRC_ENV_MATRIX_HPP_ */