PersistenceMatrixColumn.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) 2024 Inria
 *
 *    Modification(s):
 *      - YYYY/MM Author: Description of the modification
 */
 
namespace Gudhi {
namespace persistence_matrix {
 
using Row_access_option = Row_access;
using Column_dimension_option = Column_dimension_holder;
using Chain_column_option = Chain_column_extra_properties;
 
class PersistenceMatrixColumn :
    public Row_access_option,
    public Column_dimension_option,
    public Chain_column_option
{
 public:
  using Master = unspecified;                 
  using Index = unspecified;                  
  using ID_index = unspecified;               
  using Dimension = unspecified;              
  using Field_element = unspecified;          
  using Entry = unspecified;                  
  using Column_settings = unspecified;        
  using iterator = unspecified;               
  using const_iterator = unspecified;         
  using reverse_iterator = unspecified;       
  using const_reverse_iterator = unspecified; 
  PersistenceMatrixColumn(Column_settings* colSettings = nullptr);
  template <class Container = typename Master_matrix::Boundary>
  PersistenceMatrixColumn(const Container& nonZeroRowIndices,
                          Column_settings* colSettings);
  template <class Container = typename Master_matrix::Boundary, class Row_container>
  PersistenceMatrixColumn(Index columnIndex,
                          const Container& nonZeroRowIndices,
                          Row_container* rowContainer,
                          Column_settings* colSettings);
  template <class Container = typename Master_matrix::Boundary>
  PersistenceMatrixColumn(const Container& nonZeroChainRowIndices,
                          Dimension dimension,
                          Column_settings* colSettings);
  template <class Container = typename Master_matrix::Boundary, class Row_container>
  PersistenceMatrixColumn(Index columnIndex,
                          const Container& nonZeroChainRowIndices,
                          Dimension dimension,
                          Row_container* rowContainer,
                          Column_settings* colSettings);
  PersistenceMatrixColumn(const PersistenceMatrixColumn& column,
                          Column_settings* colSettings = nullptr);
  template <class Row_container>
  PersistenceMatrixColumn(const PersistenceMatrixColumn& column,
                          Index columnIndex,
                          Row_container* rowContainer,
                          Column_settings* colSettings = nullptr);
  PersistenceMatrixColumn(PersistenceMatrixColumn&& column) noexcept;
  ~PersistenceMatrixColumn();
 
  std::vector<Field_element> get_content(int columnLength = -1) const;
  bool is_non_zero(ID_index rowIndex) const;
  bool is_empty();
  std::size_t size() const;
 
  template <class Row_index_map>
  void reorder(const Row_index_map& valueMap, [[maybe_unused]] Index columnIndex = Matrix::get_null_value<Index>());
  void clear();
  void clear(ID_index rowIndex);
 
  ID_index get_pivot();
  Field_element get_pivot_value();
 
  iterator begin() noexcept;
  const_iterator begin() const noexcept;
  iterator end() noexcept;
  const_iterator end() const noexcept;
  reverse_iterator rbegin() noexcept;
  const_reverse_iterator rbegin() const noexcept;
  reverse_iterator rend() noexcept;
  const_reverse_iterator rend() const noexcept;
 
  template <class Entry_range>
  PersistenceMatrixColumn& operator+=(const Entry_range& column);
  PersistenceMatrixColumn& operator+=(PersistenceMatrixColumn& column);
 
  PersistenceMatrixColumn& operator*=(const Field_element& val);
 
  template <class Entry_range>
  PersistenceMatrixColumn& multiply_target_and_add(const Field_element& val, const Entry_range& column);
 
  template <class Entry_range>
  PersistenceMatrixColumn& multiply_source_and_add(const Entry_range& column, const Field_element& val);
 
  void push_back(const Entry& entry);
 
  friend bool operator==(const PersistenceMatrixColumn& c1, const PersistenceMatrixColumn& c2);
  friend bool operator<(const PersistenceMatrixColumn& c1, const PersistenceMatrixColumn& c2);
 
  PersistenceMatrixColumn& operator=(const PersistenceMatrixColumn& other);
  friend void swap(PersistenceMatrixColumn& col1, PersistenceMatrixColumn& col2);
};
 
}  // namespace persistence_matrix
}  // namespace Gudhi