multipers 2.3.3b6__cp313-cp313-macosx_10_13_x86_64.whl

multipers/multiparameter_module_approximation/ru_matrix.h

@@ -0,0 +1,347 @@
+/*    This file is part of the MMA Library -
+ * https://gitlab.inria.fr/dloiseau/multipers - which is released under MIT. See
+ * file LICENSE for full license details. Author(s):       Hannah Schreiber
+ *
+ *    Copyright (C) 2022 Inria
+ *
+ *    Modification(s):
+ *      - YYYY/MM Author: Description of the modification
+ */
+
+#ifndef RU_MATRIX_H
+#define RU_MATRIX_H
+
+#include <vector>
+
+#include "utilities.h" //type definitions
+#include "vector_matrix.h"
+
+namespace Gudhi::multiparameter::mma {
+
+template <class Column_type> class RU_matrix {
+public:
+  RU_matrix();
+  RU_matrix(boundary_matrix &orderedBoundaries);
+  RU_matrix(int numberOfColumns);
+  RU_matrix(RU_matrix &matrixToCopy);
+  RU_matrix(RU_matrix &&other) noexcept;
+
+  void insert_boundary(index columnIndex, boundary_type &boundary);
+  dimension_type get_dimension(index index);
+  unsigned int get_number_of_simplices();
+
+  void initialize();
+  void vine_swap(index index);
+  const barcode_type &get_current_barcode();
+
+  void print_matrices(); // for debug
+
+  RU_matrix<Column_type> &operator=(RU_matrix<Column_type> other);
+  template <class Friend_column_type>
+  friend void swap(RU_matrix<Column_type> &matrix1,
+                   RU_matrix<Friend_column_type> &matrix2);
+
+private:
+  Vector_matrix<Column_type> reducedMatrixR_;
+  Vector_matrix<Column_type> mirrorMatrixU_;
+  barcode_type barcode_;
+  std::vector<int> indexToBar_;
+
+  void _initialize_U();
+  void _swap_at_index(index index);
+  void _add_to(index sourceIndex, index targetIndex);
+  void _positive_vine_swap(index index);
+  void _negative_vine_swap(index index);
+  void _positive_negative_vine_swap(index index);
+  void _negative_positive_vine_swap(index index);
+};
+
+template <class Column_type> inline RU_matrix<Column_type>::RU_matrix() {}
+
+template <class Column_type>
+inline RU_matrix<Column_type>::RU_matrix(boundary_matrix &orderedBoundaries)
+    : reducedMatrixR_(orderedBoundaries),
+      mirrorMatrixU_(orderedBoundaries.size()) {
+  _initialize_U();
+}
+
+template <class Column_type>
+inline RU_matrix<Column_type>::RU_matrix(int numberOfColumns)
+    : reducedMatrixR_(numberOfColumns), mirrorMatrixU_(numberOfColumns) {
+  _initialize_U();
+}
+
+template <class Column_type>
+inline RU_matrix<Column_type>::RU_matrix(RU_matrix &matrixToCopy)
+    : reducedMatrixR_(matrixToCopy.reducedMatrixR_),
+      mirrorMatrixU_(matrixToCopy.mirrorMatrixU_),
+      barcode_(matrixToCopy.barcode_), indexToBar_(matrixToCopy.indexToBar_) {}
+
+template <class Column_type>
+inline RU_matrix<Column_type>::RU_matrix(
+    RU_matrix<Column_type> &&other) noexcept
+    : reducedMatrixR_(std::move(other.reducedMatrixR_)),
+      mirrorMatrixU_(std::move(other.mirrorMatrixU_)),
+      barcode_(std::move(other.barcode_)),
+      indexToBar_(std::move(other.indexToBar_)) {}
+
+template <class Column_type>
+inline void RU_matrix<Column_type>::insert_boundary(index columnIndex,
+                                                    boundary_type &boundary) {
+  reducedMatrixR_.insert_boundary(columnIndex, boundary);
+  boundary_type id(1, columnIndex);
+  mirrorMatrixU_.insert_column(columnIndex, Column_type(id));
+}
+
+template <class Column_type>
+inline dimension_type RU_matrix<Column_type>::get_dimension(index index) {
+  return reducedMatrixR_.get_column_dimension(index);
+}
+
+template <class Column_type>
+inline unsigned int RU_matrix<Column_type>::get_number_of_simplices() {
+  return reducedMatrixR_.get_number_of_columns();
+}
+
+template <class Column_type> inline void RU_matrix<Column_type>::initialize() {
+  std::unordered_map<index, index> pivotsToColumn;
+  indexToBar_.resize(reducedMatrixR_.get_number_of_columns(), -1);
+
+  for (unsigned int i = 0; i < reducedMatrixR_.get_number_of_columns(); i++) {
+    if (!(reducedMatrixR_.is_zero_column(i))) {
+      Column_type &curr = reducedMatrixR_.get_column(i);
+      int pivot = curr.get_pivot();
+
+      while (pivot != -1 &&
+             pivotsToColumn.find(pivot) != pivotsToColumn.end()) {
+        curr.add(reducedMatrixR_.get_column(pivotsToColumn.at(pivot)));
+        mirrorMatrixU_.get_column(pivotsToColumn.at(pivot))
+            .add(mirrorMatrixU_.get_column(i));
+        pivot = curr.get_pivot();
+      }
+
+      if (pivot != -1) {
+        pivotsToColumn.emplace(pivot, i);
+        barcode_.at(indexToBar_.at(pivot)).death = i;
+        indexToBar_.at(i) = indexToBar_.at(pivot);
+      } else {
+        barcode_.push_back(Bar(get_dimension(i), i, -1));
+        indexToBar_.at(i) = barcode_.size() - 1;
+      }
+    } else {
+      barcode_.push_back(Bar(get_dimension(i), i, -1));
+      indexToBar_.at(i) = barcode_.size() - 1;
+    }
+  }
+}
+
+template <class Column_type>
+inline void RU_matrix<Column_type>::vine_swap(index index) {
+  if (index >= reducedMatrixR_.get_number_of_columns() - 1)
+    return;
+
+  bool iIsPositive =
+      (barcode_.at(indexToBar_.at(index)).birth == static_cast<int>(index));
+  bool iiIsPositive = (barcode_.at(indexToBar_.at(index + 1)).birth ==
+                       static_cast<int>(index) + 1);
+
+  if (iIsPositive && iiIsPositive)
+    _positive_vine_swap(index);
+  else if (!iIsPositive && !iiIsPositive)
+    _negative_vine_swap(index);
+  else if (iIsPositive && !iiIsPositive)
+    _positive_negative_vine_swap(index);
+  else
+    _negative_positive_vine_swap(index);
+}
+
+template <class Column_type>
+inline const barcode_type &RU_matrix<Column_type>::get_current_barcode() {
+  return barcode_;
+}
+
+template <class Column_type>
+inline void RU_matrix<Column_type>::print_matrices() {
+  boundary_type b;
+
+  std::cout << "R:\n";
+  for (unsigned int i = 0; i < reducedMatrixR_.get_number_of_columns(); i++) {
+    reducedMatrixR_.get_boundary(i, b);
+    if (b.empty()) {
+      std::cout << "-\n";
+    } else {
+      for (unsigned int i : b)
+        std::cout << i << " ";
+      std::cout << "\n";
+      b.clear();
+    }
+  }
+  std::cout << "\n";
+
+  std::cout << "U:\n";
+  for (unsigned int i = 0; i < mirrorMatrixU_.get_number_of_columns(); i++) {
+    mirrorMatrixU_.get_boundary(i, b);
+    if (b.empty()) {
+      std::cout << "-\n";
+    } else {
+      for (unsigned int i : b)
+        std::cout << i << " ";
+      std::cout << "\n";
+      b.clear();
+    }
+  }
+  std::cout << "\n";
+}
+
+template <class Column_type>
+inline RU_matrix<Column_type> &
+RU_matrix<Column_type>::operator=(RU_matrix<Column_type> other) {
+  std::swap(reducedMatrixR_, other.reducedMatrixR_);
+  std::swap(mirrorMatrixU_, other.mirrorMatrixU_);
+  std::swap(barcode_, other.barcode_);
+  std::swap(indexToBar_, other.indexToBar_);
+  return *this;
+}
+
+template <class Column_type>
+inline void RU_matrix<Column_type>::_initialize_U() {
+  boundary_type id(1);
+  for (unsigned int i = 0; i < reducedMatrixR_.get_number_of_columns(); i++) {
+    id.at(0) = i;
+    mirrorMatrixU_.insert_column(i, Column_type(id));
+  }
+}
+
+template <class Column_type>
+inline void RU_matrix<Column_type>::_swap_at_index(index index) {
+  reducedMatrixR_.swap_at_indices(index, index + 1);
+  mirrorMatrixU_.swap_at_indices(index, index + 1);
+}
+
+template <class Column_type>
+inline void RU_matrix<Column_type>::_add_to(index sourceIndex,
+                                            index targetIndex) {
+  reducedMatrixR_.add_to(sourceIndex, targetIndex);
+  mirrorMatrixU_.add_to(targetIndex, sourceIndex);
+}
+
+template <class Column_type>
+inline void RU_matrix<Column_type>::_positive_vine_swap(index index) {
+  int iDeath = barcode_.at(indexToBar_.at(index)).death;
+  int iiDeath = barcode_.at(indexToBar_.at(index + 1)).death;
+
+  if (get_dimension(index) == get_dimension(index + 1)) {
+    if (!mirrorMatrixU_.is_zero_cell(index, index + 1))
+      mirrorMatrixU_.zero_cell(index, index + 1);
+
+    if (iDeath != -1 && iiDeath != -1 &&
+        !(reducedMatrixR_.is_zero_cell(iiDeath, index))) {
+      if (iDeath < iiDeath) {
+        _swap_at_index(index);
+        _add_to(iDeath, iiDeath);
+
+        barcode_.at(indexToBar_.at(index)).birth = index + 1;
+        barcode_.at(indexToBar_.at(index + 1)).birth = index;
+        std::swap(indexToBar_.at(index), indexToBar_.at(index + 1));
+
+        return;
+      }
+
+      if (iiDeath < iDeath) {
+        _swap_at_index(index);
+        _add_to(iiDeath, iDeath);
+
+        return;
+      }
+    }
+
+    _swap_at_index(index);
+
+    if (iDeath != -1 || iiDeath == -1 ||
+        reducedMatrixR_.is_zero_cell(iiDeath, index + 1)) {
+      barcode_.at(indexToBar_.at(index)).birth = index + 1;
+      barcode_.at(indexToBar_.at(index + 1)).birth = index;
+      std::swap(indexToBar_.at(index), indexToBar_.at(index + 1));
+    }
+
+    return;
+  }
+
+  _swap_at_index(index);
+
+  barcode_.at(indexToBar_.at(index)).birth = index + 1;
+  barcode_.at(indexToBar_.at(index + 1)).birth = index;
+  std::swap(indexToBar_.at(index), indexToBar_.at(index + 1));
+}
+
+template <class Column_type>
+inline void RU_matrix<Column_type>::_negative_vine_swap(index index) {
+  if (get_dimension(index) == get_dimension(index + 1) &&
+      !mirrorMatrixU_.is_zero_cell(index, index + 1)) {
+    _add_to(index, index + 1);
+    _swap_at_index(index);
+
+    if (barcode_.at(indexToBar_.at(index)).birth <
+        barcode_.at(indexToBar_.at(index + 1)).birth) {
+      barcode_.at(indexToBar_.at(index)).death = index + 1;
+      barcode_.at(indexToBar_.at(index + 1)).death = index;
+      std::swap(indexToBar_.at(index), indexToBar_.at(index + 1));
+
+      return;
+    }
+
+    _add_to(index, index + 1);
+
+    return;
+  }
+
+  _swap_at_index(index);
+
+  barcode_.at(indexToBar_.at(index)).death = index + 1;
+  barcode_.at(indexToBar_.at(index + 1)).death = index;
+  std::swap(indexToBar_.at(index), indexToBar_.at(index + 1));
+}
+
+template <class Column_type>
+inline void RU_matrix<Column_type>::_positive_negative_vine_swap(index index) {
+  if (get_dimension(index) == get_dimension(index + 1) &&
+      !mirrorMatrixU_.is_zero_cell(index, index + 1))
+    mirrorMatrixU_.zero_cell(index, index + 1);
+
+  _swap_at_index(index);
+
+  barcode_.at(indexToBar_.at(index)).birth = index + 1;
+  barcode_.at(indexToBar_.at(index + 1)).death = index;
+  std::swap(indexToBar_.at(index), indexToBar_.at(index + 1));
+}
+
+template <class Column_type>
+inline void RU_matrix<Column_type>::_negative_positive_vine_swap(index index) {
+  if (get_dimension(index) == get_dimension(index + 1) &&
+      !mirrorMatrixU_.is_zero_cell(index, index + 1)) {
+    _add_to(index, index + 1);
+    _swap_at_index(index);
+    _add_to(index, index + 1);
+
+    return;
+  }
+
+  _swap_at_index(index);
+
+  barcode_.at(indexToBar_.at(index)).death = index + 1;
+  barcode_.at(indexToBar_.at(index + 1)).birth = index;
+  std::swap(indexToBar_.at(index), indexToBar_.at(index + 1));
+}
+
+template <class Column_type>
+inline void swap(RU_matrix<Column_type> &matrix1,
+                 RU_matrix<Column_type> &matrix2) {
+  std::swap(matrix1.reducedMatrixR_, matrix2.reducedMatrixR_);
+  std::swap(matrix1.mirrorMatrixU_, matrix2.mirrorMatrixU_);
+  matrix1.barcode_.swap(matrix2.barcode_);
+  matrix1.indexToBar_.swap(matrix2.indexToBar_);
+}
+
+} // namespace Gudhi::multiparameter::mma
+
+#endif // RU_MATRIX_H

multipers/multiparameter_module_approximation/set_column.h

@@ -0,0 +1,135 @@
+/*    This file is part of the MMA Library - https://gitlab.inria.fr/dloiseau/multipers - which is released under MIT.
+ *    See file LICENSE for full license details.
+ *    Author(s):       Hannah Schreiber
+ *
+ *    Copyright (C) 2022 Inria
+ *
+ *    Modification(s):
+ *      - YYYY/MM Author: Description of the modification
+ */
+
+#ifndef SETCOLUMN_H
+#define SETCOLUMN_H
+
+#include <iostream>
+#include <list>
+#include <set>
+
+#include "utilities.h"
+
+namespace Gudhi::multiparameter::mma {
+
+class Set_column
+{
+public:
+    Set_column();
+    Set_column(boundary_type& boundary);
+    Set_column(Set_column& column);
+    Set_column(Set_column&& column) noexcept;
+
+    void get_content(boundary_type& container);
+    bool contains(unsigned int value) const;
+    bool is_empty();
+    dimension_type get_dimension() const;
+    int get_pivot();
+    void clear();
+    void clear(unsigned int value);
+    void reorder(std::vector<index>& valueMap);
+    void add(Set_column& column);
+
+    Set_column& operator=(Set_column other);
+
+    friend void swap(Set_column& col1, Set_column& col2);
+
+private:
+    int dim_;
+    std::set<unsigned int> column_;
+};
+
+inline Set_column::Set_column() : dim_(0)
+{}
+
+inline Set_column::Set_column(boundary_type &boundary)
+    : dim_(boundary.size() == 0 ? 0 : boundary.size() - 1),
+      column_(boundary.begin(), boundary.end())
+{}
+
+inline Set_column::Set_column(Set_column &column)
+    : dim_(column.dim_),
+      column_(column.column_)
+{}
+
+inline Set_column::Set_column(Set_column &&column) noexcept
+    : dim_(std::exchange(column.dim_, 0)),
+      column_(std::move(column.column_))
+{}
+
+inline void Set_column::get_content(boundary_type &container)
+{
+    std::copy(column_.begin(), column_.end(), std::back_inserter(container));
+}
+
+inline bool Set_column::contains(unsigned int value) const
+{
+    return column_.find(value) != column_.end();
+}
+
+inline bool Set_column::is_empty()
+{
+    return column_.empty();
+}
+
+inline dimension_type Set_column::get_dimension() const
+{
+    return dim_;
+}
+
+inline int Set_column::get_pivot()
+{
+    if (column_.empty()) return -1;
+    return *(column_.rbegin());
+}
+
+inline void Set_column::clear()
+{
+    column_.clear();
+}
+
+inline void Set_column::clear(unsigned int value)
+{
+    column_.erase(value);
+}
+
+inline void Set_column::reorder(std::vector<index> &valueMap)
+{
+    std::set<unsigned int> newSet;
+    for (const unsigned int& v : column_) newSet.insert(valueMap.at(v));
+    column_.swap(newSet);
+}
+
+inline void Set_column::add(Set_column &column)
+{
+    for (const unsigned int& v : column.column_){
+        if (column_.find(v) != column_.end())
+            column_.erase(v);
+        else
+            column_.insert(v);
+    }
+}
+
+inline Set_column &Set_column::operator=(Set_column other)
+{
+    std::swap(dim_, other.dim_);
+    std::swap(column_, other.column_);
+    return *this;
+}
+
+inline void swap(Set_column& col1, Set_column& col2)
+{
+    std::swap(col1.dim_, col2.dim_);
+    col1.column_.swap(col2.column_);
+}
+
+}   //namespace Vineyard
+
+#endif // SETCOLUMN_H

multipers/multiparameter_module_approximation/structure_higher_dim_barcode.h

@@ -0,0 +1,36 @@
+/*    This file is part of the MMA Library - https://gitlab.inria.fr/dloiseau/multipers - which is released under MIT.
+ *    See file LICENSE for full license details.
+ *    Author(s):       David Loiseaux
+ *
+ *    Copyright (C) 2021 Inria
+ *
+ *    Modification(s):
+ *      - 2022/03 Hannah Schreiber: Integration of the new Vineyard_persistence class, renaming and cleanup.
+ */
+/**
+ * @file structure_higher_dim_barcode.h
+ * @author David Loiseaux, Hannah Schreiber
+ * @brief Structures to handle higher dimensional persistence.
+ */
+
+#ifndef STRUCTURE_HIGHER_DIM_BARCODE_H_INCLUDED
+#define STRUCTURE_HIGHER_DIM_BARCODE_H_INCLUDED
+
+#include <vector>
+
+unsigned int get_index_from_position_and_size(
+        const std::vector<unsigned int> &position,
+        const std::vector<unsigned int> &size)
+{
+    unsigned int indice = 0;
+    assert(position.size() == size.size() &&
+           "Position and Size vector must be of the same size !");
+    unsigned int last_product = 1;
+    for (unsigned int i = 0; i < position.size(); i++){
+        indice += last_product * position[i];
+        last_product *= size[i];
+    }
+    return indice;
+}
+
+#endif // STRUCTURE_HIGHER_DIM_BARCODE_H_INCLUDED

multipers/multiparameter_module_approximation/unordered_set_column.h

@@ -0,0 +1,166 @@
+/*    This file is part of the MMA Library - https://gitlab.inria.fr/dloiseau/multipers - which is released under MIT.
+ *    See file LICENSE for full license details.
+ *    Author(s):       Hannah Schreiber
+ *
+ *    Copyright (C) 2022 Inria
+ *
+ *    Modification(s):
+ *      - YYYY/MM Author: Description of the modification
+ */
+
+#ifndef UNORDEREDSETCOLUMN_H
+#define UNORDEREDSETCOLUMN_H
+
+#include <iostream>
+#include <list>
+#include <unordered_set>
+#include <algorithm>
+
+#include "utilities.h"
+
+namespace Vineyard {
+
+class Unordered_set_column
+{
+public:
+    Unordered_set_column();
+    Unordered_set_column(boundary_type& boundary);
+    Unordered_set_column(Unordered_set_column& column);
+    Unordered_set_column(Unordered_set_column&& column) noexcept;
+
+    void get_content(boundary_type& container);
+    bool contains(unsigned int value) const;
+    bool is_empty();
+    dimension_type get_dimension() const;
+    int get_pivot();
+    void clear();
+    void clear(unsigned int value);
+    void reorder(std::vector<index>& valueMap);
+    void add(Unordered_set_column& column);
+
+    Unordered_set_column& operator=(Unordered_set_column other);
+
+    friend void swap(Unordered_set_column& col1, Unordered_set_column& col2);
+
+private:
+    int dim_;
+    std::unordered_set<unsigned int> column_;
+    bool pivotChanged_;
+    int pivot_;
+};
+
+inline Unordered_set_column::Unordered_set_column()
+    : dim_(0), pivotChanged_(false), pivot_(-1)
+{}
+
+inline Unordered_set_column::Unordered_set_column(boundary_type &boundary)
+    : dim_(boundary.size() == 0 ? 0 : boundary.size() - 1),
+      column_(boundary.begin(), boundary.end()),
+      pivotChanged_(false),
+      pivot_(boundary.size() == 0 ? -1 : *std::max_element(boundary.begin(), boundary.end()))
+{}
+
+inline Unordered_set_column::Unordered_set_column(Unordered_set_column &column)
+    : dim_(column.dim_),
+      column_(column.column_),
+      pivotChanged_(column.pivotChanged_),
+      pivot_(column.pivot_)
+{}
+
+inline Unordered_set_column::Unordered_set_column(Unordered_set_column &&column) noexcept
+    : dim_(std::exchange(column.dim_, 0)),
+      column_(std::move(column.column_)),
+      pivotChanged_(std::exchange(column.pivotChanged_, 0)),
+      pivot_(std::exchange(column.pivot_, 0))
+{}
+
+inline void Unordered_set_column::get_content(boundary_type &container)
+{
+    std::copy(column_.begin(), column_.end(), std::back_inserter(container));
+    std::sort(container.begin(), container.end());
+}
+
+inline bool Unordered_set_column::contains(unsigned int value) const
+{
+    return column_.find(value) != column_.end();
+}
+
+inline bool Unordered_set_column::is_empty()
+{
+    return column_.empty();
+}
+
+inline dimension_type Unordered_set_column::get_dimension() const
+{
+    return dim_;
+}
+
+inline int Unordered_set_column::get_pivot()
+{
+    if (pivotChanged_){
+        pivot_ = column_.size() == 0 ?
+                    -1
+                  : *std::max_element(column_.begin(), column_.end());
+        pivotChanged_ = false;
+    }
+
+    return pivot_;
+}
+
+inline void Unordered_set_column::clear()
+{
+    column_.clear();
+    pivot_ = -1;
+    pivotChanged_ = false;
+}
+
+inline void Unordered_set_column::clear(unsigned int value)
+{
+    column_.erase(value);
+    if (static_cast<int>(value) == pivot_) pivotChanged_ = true;
+}
+
+inline void Unordered_set_column::reorder(std::vector<index> &valueMap)
+{
+    std::unordered_set<unsigned int> newSet;
+    for (const unsigned int& v : column_) newSet.insert(valueMap.at(v));
+    column_.swap(newSet);
+    pivotChanged_ = true;
+}
+
+inline void Unordered_set_column::add(Unordered_set_column &column)
+{
+    for (const unsigned int& v : column.column_){
+        if (column_.find(v) != column_.end()){
+            column_.erase(v);
+            if (static_cast<int>(v) == pivot_) pivotChanged_ = true;
+        } else {
+            column_.insert(v);
+            if (static_cast<int>(v) > pivot_){
+                pivot_ = v;
+                pivotChanged_ = false;
+            }
+        }
+    }
+}
+
+inline Unordered_set_column &Unordered_set_column::operator=(Unordered_set_column other)
+{
+    std::swap(dim_, other.dim_);
+    std::swap(column_, other.column_);
+    std::swap(pivotChanged_, other.pivotChanged_);
+    std::swap(pivot_, other.pivot_);
+    return *this;
+}
+
+inline void swap(Unordered_set_column& col1, Unordered_set_column& col2)
+{
+    std::swap(col1.dim_, col2.dim_);
+    col1.column_.swap(col2.column_);
+    std::swap(col1.pivotChanged_, col2.pivotChanged_);
+    std::swap(col1.pivot_, col2.pivot_);
+}
+
+}   //namespace Vineyard
+
+#endif // UNORDEREDSETCOLUMN_H