Matrix.h

Go to the documentation of this file.

// Copyright (c) 2002-present, OpenMS Inc. -- EKU Tuebingen, ETH Zurich, and FU Berlin
// SPDX-License-Identifier: BSD-3-Clause
//
// --------------------------------------------------------------------------
// $Maintainer: Timo Sachsenberg $
// $Authors: Timo Sachsenberg $
// --------------------------------------------------------------------------
 
#pragma once
 
#include <OpenMS/CONCEPT/Macros.h>
 
#include <Eigen/Dense>
 
#include <algorithm>
#include <iostream>
#include <iomanip>
 
namespace OpenMS
{
  template <typename Value>
  class Matrix : public Eigen::Matrix<Value, Eigen::Dynamic, Eigen::Dynamic>
  {
  public:
    using EigenMatrixType = Eigen::Matrix<Value, Eigen::Dynamic, Eigen::Dynamic>;
    using EigenMatrixType::fill;
    using EigenMatrixType::innerStride;
    using EigenMatrixType::outerStride;
 
    // Default constructor. Creates the "null" matrix.
    Matrix() = default;
 
    // Destructor
    ~Matrix() = default;
 
    // Copy constructor
    Matrix(const Matrix& other) = default;
 
    // Copy assignment operator
    Matrix& operator=(const Matrix& other) = default;
 
    // Move constructor
    Matrix(Matrix&& other) noexcept = default;
 
    // Move assignment operator
    Matrix& operator=(Matrix&& other) noexcept = default;
 
    Matrix(Size rows, Size cols, Value value = Value()) : EigenMatrixType(rows, cols)
    {
      fill(value);
    }
 
    /*
      @brief get matrix entry
      Note: pyOpenMS can't easily wrap operator() so we provide additional getter / setter.
    */
    const Value& getValue(size_t const i, size_t const j) const
    {
      return *this(i, j);
    }
 
    /*
      @brief get matrix entry
      Note: pyOpenMS can't easily wrap operator() so we provide additional getter / setter.
    */
    Value& getValue(size_t const i, size_t const j)
    {
      return this->operator()(i, j);
    }    
 
    /*
      @brief set matrix entry
      Note: pyOpenMS can't easily wrap operator() so we provide additional getter / setter.
    */
    void setValue(size_t const i, size_t const j, const Value& value)
    {
      this->operator()(i, j) = value;
    }
 
    // apparently needed for cython
    void resize(size_t rows, size_t cols)
    {
      EigenMatrixType::resize(rows, cols);
    }
 
    int innerStride() const
    {
      return EigenMatrixType::innerStride();
    }
 
    int outerStride() const
    {
      return EigenMatrixType::outerStride();
    }
 
    bool rowMajor() const
    {
      return EigenMatrixType::IsRowMajor;
    }
 
    template <typename T, long int ROWS, long int COLS>
    void setMatrix(T const (&array)[ROWS][COLS]) 
    {
      resize(ROWS, COLS);
      for (int i = 0; i < ROWS; ++i) 
      {
        for (int j = 0; j < COLS; ++j) 
        {
          this->operator()(i, j) = array[i][j];
        }
      }
    }
 
    bool operator==(const Matrix& rhs) const { 
      return EigenMatrixType::operator==(rhs);
    }
 
    friend std::ostream& operator<<(std::ostream& os, const Matrix<Value>& matrix)
    {
      for (long int i = 0; i < matrix.rows(); ++i)
      {
        for (long int j = 0; j < matrix.cols(); ++j)
        {
          os << std::setprecision(6) << std::setw(6) << matrix(i, j) << ' ';
        }
        os << '\n';
      }
      return os;
    }
 
    const EigenMatrixType& getEigenMatrix() const
    {
      return *this;
    }
 
    EigenMatrixType& getEigenMatrix()
    {
      return *this;
    }
  };
} // namespace OpenMS