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 <OpenMS/CONCEPT/Types.h>
 
#include <vector>
#include <algorithm>
#include <iostream>
#include <iomanip>
#include <stdexcept>
 
namespace OpenMS
{
  template <typename Value>
  class Matrix
  {
  public:
    using value_type = Value;
    using iterator = typename std::vector<Value>::iterator;
    using const_iterator = typename std::vector<Value>::const_iterator;
 
 
    Matrix() : rows_(0), cols_(0) {}
 
    Matrix(Size rows, Size cols, Value value = Value())
      : data_(rows * cols, value), rows_(rows), cols_(cols) {}
 
    Matrix(const Matrix&) = default;
 
    Matrix(Matrix&&) noexcept = default;
 
    Matrix& operator=(const Matrix&) = default;
 
    Matrix& operator=(Matrix&&) noexcept = default;
 
    ~Matrix() = default;
 
 
 
    Size rows() const { return rows_; }
 
    Size cols() const { return cols_; }
 
    Size size() const { return data_.size(); }
 
    bool empty() const { return data_.empty(); }
 
 
 
    const Value& getValue(size_t const row, size_t const col) const
    {
      return data_[col * rows_ + row];  // Column-major
    }
 
    Value& getValue(size_t const row, size_t const col)
    {
      return data_[col * rows_ + row];  // Column-major
    }
 
    void setValue(size_t const row, size_t const col, const Value& value)
    {
      data_[col * rows_ + row] = value;  // Column-major
    }
 
    Value& operator()(size_t row, size_t col)
    {
      return data_[col * rows_ + row];
    }
 
    const Value& operator()(size_t row, size_t col) const
    {
      return data_[col * rows_ + row];
    }
 
 
 
    Value* data() { return data_.data(); }
 
    const Value* data() const { return data_.data(); }
 
    int innerStride() const { return 1; }
 
    int outerStride() const { return static_cast<int>(rows_); }
 
    static constexpr bool rowMajor() { return false; }
 
 
 
    void resize(size_t rows, size_t cols)
    {
      rows_ = rows;
      cols_ = cols;
      data_.resize(rows * cols);
    }
 
    void fill(Value value)
    {
      std::fill(data_.begin(), data_.end(), value);
    }
 
    void clear()
    {
      data_.clear();
      rows_ = 0;
      cols_ = 0;
    }
 
    template <typename T, long int ROWS, long int COLS>
    void setMatrix(T const (&array)[ROWS][COLS])
    {
      resize(ROWS, COLS);
      for (long int i = 0; i < ROWS; ++i)
      {
        for (long int j = 0; j < COLS; ++j)
        {
          (*this)(i, j) = array[i][j];
        }
      }
    }
 
 
    iterator begin() { return data_.begin(); }
    iterator end() { return data_.end(); }
    const_iterator begin() const { return data_.begin(); }
    const_iterator end() const { return data_.end(); }
    const_iterator cbegin() const { return data_.cbegin(); }
    const_iterator cend() const { return data_.cend(); }
 
 
    Value maxValue() const
    {
      if (data_.empty()) return Value();
      return *std::max_element(data_.begin(), data_.end());
    }
 
    Value minValue() const
    {
      if (data_.empty()) return Value();
      return *std::min_element(data_.begin(), data_.end());
    }
 
 
 
    bool operator==(const Matrix& rhs) const
    {
      OPENMS_PRECONDITION(rows_ == rhs.rows_ && cols_ == rhs.cols_,
                          "Matrices must have the same dimensions for comparison.");
      return data_ == rhs.data_;
    }
 
    bool operator!=(const Matrix& rhs) const
    {
      return !(*this == rhs);
    }
 
 
    friend std::ostream& operator<<(std::ostream& os, const Matrix<Value>& matrix)
    {
      for (Size i = 0; i < matrix.rows(); ++i)
      {
        for (Size j = 0; j < matrix.cols(); ++j)
        {
          os << std::setprecision(6) << std::setw(6) << matrix(i, j) << ' ';
        }
        os << '\n';
      }
      return os;
    }
 
  private:
    std::vector<Value> data_;  
    Size rows_;                
    Size cols_;                
  };
 
} // namespace OpenMS