matrix_dimension_holders.h

Go to the documentation of this file.

/*    This file is part of the Gudhi Library - https://gudhi.inria.fr/ - which is released under MIT.
 *    See file LICENSE or go to https://gudhi.inria.fr/licensing/ for full license details.
 *    Author(s):       Hannah Schreiber
 *
 *    Copyright (C) 2022 Inria
 *
 *    Modification(s):
 *      - YYYY/MM Author: Description of the modification
 */

 
#ifndef PM_MATRIX_DIM_HOLDER_H
#define PM_MATRIX_DIM_HOLDER_H
 
#include <utility>  //std::swap, std::move & std::exchange
#include <vector>
 
namespace Gudhi {
namespace persistence_matrix {

struct Dummy_matrix_dimension_holder {
  template <typename Dimension>
  Dummy_matrix_dimension_holder([[maybe_unused]] Dimension maximalDimension)
  {}
 
  friend void swap([[maybe_unused]] Dummy_matrix_dimension_holder& d1,
                   [[maybe_unused]] Dummy_matrix_dimension_holder& d2) noexcept
  {}
};
 
// TODO: find an easy way to give access to get_null_value<Dimension>() to replace the -1s

template <typename Dimension>
class Matrix_max_dimension_holder
{
 public:
  Matrix_max_dimension_holder(Dimension maximalDimension = -1) : maxDim_(maximalDimension) {};
  Matrix_max_dimension_holder(const Matrix_max_dimension_holder& toCopy) = default;
  Matrix_max_dimension_holder(Matrix_max_dimension_holder&& other) noexcept
      : maxDim_(std::exchange(other.maxDim_, -1)) {};
 
  ~Matrix_max_dimension_holder() = default;

  Dimension get_max_dimension() const { return maxDim_; };

  Matrix_max_dimension_holder& operator=(const Matrix_max_dimension_holder& other) = default;

  Matrix_max_dimension_holder& operator=(Matrix_max_dimension_holder&& other) noexcept
  {
    if (this == &other) return *this;
 
    maxDim_ = std::exchange(other.maxDim_, -1);
    return *this;
  };

  friend void swap(Matrix_max_dimension_holder& matrix1, Matrix_max_dimension_holder& matrix2) noexcept
  {
    std::swap(matrix1.maxDim_, matrix2.maxDim_);
  }
 
 protected:
  void _update_up(Dimension dimension)
  {
    if (maxDim_ == -1 || maxDim_ < dimension) maxDim_ = dimension;
  };
 
  void _reset() { maxDim_ = -1; }
 
 private:
  Dimension maxDim_; 
};

template <typename Dimension>
class Matrix_all_dimension_holder
{
 public:
  Matrix_all_dimension_holder(Dimension maximalDimension = -1)
      : dimensions_(maximalDimension < 0 ? 0 : maximalDimension + 1, 0), maxDim_(maximalDimension)
  {
    if (maxDim_ != -1) dimensions_[maxDim_] = 1;
  };

  Matrix_all_dimension_holder(const Matrix_all_dimension_holder& toCopy) = default;
  Matrix_all_dimension_holder(Matrix_all_dimension_holder&& other) noexcept
      : dimensions_(std::move(other.dimensions_)), maxDim_(std::exchange(other.maxDim_, -1)) {};
 
  ~Matrix_all_dimension_holder() = default;

  Dimension get_max_dimension() const { return maxDim_; };

  Matrix_all_dimension_holder& operator=(const Matrix_all_dimension_holder& other) = default;

  Matrix_all_dimension_holder& operator=(Matrix_all_dimension_holder&& other) noexcept
  {
    if (this == &other) return *this;
 
    dimensions_ = std::move(other.dimensions_);
    maxDim_ = std::exchange(other.maxDim_, -1);
    return *this;
  };

  friend void swap(Matrix_all_dimension_holder& matrix1, Matrix_all_dimension_holder& matrix2) noexcept
  {
    std::swap(matrix1.maxDim_, matrix2.maxDim_);
    matrix1.dimensions_.swap(matrix2.dimensions_);
  }
 
 protected:
  void _update_up(unsigned int dimension)
  {
    if (dimensions_.size() <= dimension) dimensions_.resize(dimension + 1, 0);
    ++(dimensions_[dimension]);
    maxDim_ = dimensions_.size() - 1;
  };
 
  void _update_down(unsigned int dimension)
  {
    --(dimensions_[dimension]);  // assumes dimension already exists and is not 0
    while (!dimensions_.empty() && dimensions_.back() == 0) dimensions_.pop_back();
    maxDim_ = dimensions_.size() - 1;
  };
 
  void _reset()
  {
    dimensions_.clear();
    maxDim_ = -1;
  }
 
 private:
  std::vector<unsigned int> dimensions_; 
  Dimension maxDim_;                     
};
 
}  // namespace persistence_matrix
}  // namespace Gudhi
 
#endif  // PM_MATRIX_DIM_HOLDER_H