multipers 2.3.3b6__cp313-cp313-macosx_11_0_arm64.whl

multipers/multiparameter_module_approximation/heap_column.h

@@ -0,0 +1,238 @@
+/*    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 HEAPCOLUMN_H
+#define HEAPCOLUMN_H
+
+#include <iostream>
+#include <algorithm>
+#include <cmath>
+#include <vector>
+#include <unordered_map>
+#include <unordered_set>
+
+#include "utilities.h"
+
+namespace Vineyard {
+
+class Heap_column
+{
+public:
+    Heap_column();
+    Heap_column(boundary_type& boundary);
+    Heap_column(Heap_column& column);
+    Heap_column(Heap_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(Heap_column& column);
+
+    Heap_column& operator=(Heap_column other);
+
+    friend void swap(Heap_column& col1, Heap_column& col2);
+
+private:
+    int dim_;
+    std::vector<unsigned int> column_;
+    unsigned int insertsSinceLastPrune_;
+    std::unordered_set<unsigned int> erasedValues_;
+
+    void _prune();
+    int _pop_pivot();
+};
+
+inline Heap_column::Heap_column() : dim_(0), insertsSinceLastPrune_(0)
+{}
+
+inline Heap_column::Heap_column(boundary_type& boundary)
+    : dim_(boundary.size() == 0 ? 0 : boundary.size() - 1),
+      column_(boundary),
+      insertsSinceLastPrune_(0)
+{
+    std::make_heap(column_.begin(), column_.end());
+}
+
+inline Heap_column::Heap_column(Heap_column& column)
+    : dim_(column.dim_),
+      column_(column.column_),
+      insertsSinceLastPrune_(column.insertsSinceLastPrune_),
+      erasedValues_(column.erasedValues_)
+{}
+
+inline Heap_column::Heap_column(Heap_column&& column) noexcept
+    : dim_(std::exchange(column.dim_, 0)),
+      column_(std::move(column.column_)),
+      insertsSinceLastPrune_(std::exchange(column.insertsSinceLastPrune_, 0)),
+      erasedValues_(std::move(column.erasedValues_))
+{}
+
+inline void Heap_column::get_content(boundary_type &container)
+{
+    _prune();
+    container = column_;
+    std::sort_heap(container.begin(), container.end());
+}
+
+inline bool Heap_column::contains(unsigned int value) const
+{
+    if (erasedValues_.find(value) != erasedValues_.end()) return false;
+
+    unsigned int c = 0;
+
+    for (unsigned int v : column_){
+        if (v == value) c++;
+    }
+
+    return c % 2 != 0;
+}
+
+inline bool Heap_column::is_empty()
+{
+    int pivot = _pop_pivot();
+    if (pivot != -1){
+        column_.push_back(pivot);
+        std::push_heap(column_.begin(), column_.end());
+        return false;
+    }
+    return true;
+}
+
+inline dimension_type Heap_column::get_dimension() const
+{
+    return dim_;
+}
+
+inline int Heap_column::get_pivot()
+{
+    int pivot = _pop_pivot();
+    if (pivot != -1){
+        column_.push_back(pivot);
+        std::push_heap(column_.begin(), column_.end());
+    }
+    return pivot;
+}
+
+inline void Heap_column::clear()
+{
+    column_.clear();
+    insertsSinceLastPrune_ = 0;
+    erasedValues_.clear();
+}
+
+inline void Heap_column::clear(unsigned int value)
+{
+    erasedValues_.insert(value);
+}
+
+inline void Heap_column::reorder(std::vector<index> &valueMap)
+{
+    std::vector<unsigned int> tempCol;
+    int pivot = _pop_pivot();
+    while (pivot != -1) {
+        tempCol.push_back(valueMap.at(pivot));
+        pivot = _pop_pivot();
+    }
+    column_.swap(tempCol);
+    std::make_heap(column_.begin(), column_.end());
+
+    insertsSinceLastPrune_ = 0;
+    erasedValues_.clear();
+}
+
+inline void Heap_column::add(Heap_column &column)
+{
+    std::vector<unsigned int>& colToAdd = column.column_;
+    const unsigned int size = colToAdd.size();
+
+    if (size == 0) return;
+
+    for (unsigned int v : colToAdd) {
+        if (column.erasedValues_.find(v) == column.erasedValues_.end()){
+            column_.push_back(v);
+            std::push_heap(column_.begin(), column_.end());
+            erasedValues_.erase(v);
+        }
+    }
+    insertsSinceLastPrune_ += size;
+
+    if (2 * insertsSinceLastPrune_ > column_.size()) _prune();
+}
+
+inline Heap_column& Heap_column::operator=(Heap_column other)
+{
+    std::swap(dim_, other.dim_);
+    std::swap(column_, other.column_);
+    std::swap(insertsSinceLastPrune_, other.insertsSinceLastPrune_);
+    std::swap(erasedValues_, other.erasedValues_);
+    return *this;
+}
+
+inline void Heap_column::_prune()
+{
+    if (insertsSinceLastPrune_ == 0 && erasedValues_.empty()) return;
+
+    std::vector<unsigned int> tempCol;
+    int pivot = _pop_pivot();
+    while (pivot != -1) {
+        tempCol.push_back(pivot);
+        pivot = _pop_pivot();
+    }
+    column_.swap(tempCol);
+    std::make_heap(column_.begin(), column_.end());
+
+    insertsSinceLastPrune_ = 0;
+    erasedValues_.clear();
+}
+
+inline int Heap_column::_pop_pivot()
+{
+    if (column_.empty()) {
+        return -1;
+    }
+
+    unsigned int pivot = column_.front();
+    std::pop_heap(column_.begin(), column_.end());
+    column_.pop_back();
+    while (!column_.empty() && column_.front() == pivot)
+    {
+        std::pop_heap(column_.begin(), column_.end());
+        column_.pop_back();
+
+        if (column_.empty()) {
+            return -1;
+        }
+        pivot = column_.front();
+        std::pop_heap(column_.begin(), column_.end());
+        column_.pop_back();
+    }
+
+    if (erasedValues_.find(pivot) != erasedValues_.end())
+        pivot = _pop_pivot();
+
+    return pivot;
+}
+
+inline void swap(Heap_column& col1, Heap_column& col2)
+{
+    std::swap(col1.dim_, col2.dim_);
+    col1.column_.swap(col2.column_);
+    std::swap(col1.insertsSinceLastPrune_, col2.insertsSinceLastPrune_);
+    std::swap(col1.erasedValues_, col2.erasedValues_);
+}
+
+}   //namespace Vineyard
+
+#endif // HEAPCOLUMN_H

multipers/multiparameter_module_approximation/images.h

@@ -0,0 +1,79 @@
+/*    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 images.h
+ * @author David Loiseaux, Hannah Schreiber
+ * @brief Functions to generate multipersistence images
+ */
+
+#ifndef IMAGES_H_INCLUDED
+#define IMAGES_H_INCLUDED
+
+#include <vector>
+
+#include "approximation.h"
+#include "utilities.h"
+namespace Gudhi::multiparameter::mma::representation{
+
+
+using Gudhi::multiparameter::mma::boundary_matrix;
+using Gudhi::multiparameter::mma::filtration_type;
+using Gudhi::multiparameter::mma::dimension_type;
+using Gudhi::multiparameter::mma::Module;
+using Gudhi::multiparameter::mma::Box;
+
+struct ImageArgs{
+private:
+	unsigned int module_dim;				// number of persistent parameters.	
+public:
+	std::vector<unsigned int> resolution;	// resolution of the image
+	double p;								// sum smoothing
+	bool normalize;							// Enforce image to take values in [0,1]
+	int dimension;							// if negative -> all dim
+	Box box;								// Possible sub-box.
+};
+
+
+
+std::vector<std::vector<std::vector<double> > > get_2D_image_from_boundary_matrix(
+		boundary_matrix &boundaryMatrix,
+		std::vector<filtration_type> &filtersList,
+		const double precision,
+		const Box &box,
+		const double delta,
+		const double p,
+		const bool normalize, 
+		const std::vector<unsigned int> &resolution,
+		const dimension_type dimension,
+		const bool complete = true,
+		const bool verbose = false)
+{
+	Box bbox(box);
+	bbox.inflate(delta);
+	Module approximation =
+			Gudhi::multiparameter::mma::compute_vineyard_barcode_approximation(
+				boundaryMatrix,
+				filtersList,
+				precision,
+				bbox,
+				true,
+				complete,
+				false,
+				verbose);
+
+	if (dimension < 0)
+		return approximation.get_vectorization(delta, p, normalize, resolution[0], resolution[1]);
+
+	return {approximation.get_vectorization_in_dimension(dimension, delta, p, normalize,  resolution[0], resolution[1])};
+}
+
+} //namespace
+
+#endif // IMAGES_H_INCLUDED

multipers/multiparameter_module_approximation/list_column.h

@@ -0,0 +1,174 @@
+/*    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 LISTCOLUMN_H
+#define LISTCOLUMN_H
+
+#include <iostream>
+#include <list>
+#include <unordered_set>
+
+#include "utilities.h"
+
+namespace Vineyard {
+
+class List_column
+{
+public:
+    List_column();
+    List_column(boundary_type& boundary);
+    List_column(List_column& column);
+    List_column(List_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(List_column& column);
+
+    List_column& operator=(List_column other);
+
+    friend void swap(List_column& col1, List_column& col2);
+
+private:
+    int dim_;
+    std::list<unsigned int> column_;
+};
+
+inline List_column::List_column() : dim_(0)
+{}
+
+inline List_column::List_column(boundary_type &boundary)
+    : dim_(boundary.size() == 0 ? 0 : boundary.size() - 1),
+      column_(boundary.begin(), boundary.end())
+{}
+
+inline List_column::List_column(List_column &column)
+    : dim_(column.dim_),
+	  column_(column.column_)
+{}
+
+inline List_column::List_column(List_column &&column) noexcept
+    : dim_(std::exchange(column.dim_, 0)),
+	  column_(std::move(column.column_))
+{}
+
+inline void List_column::get_content(boundary_type &container)
+{
+    std::copy(column_.begin(), column_.end(), std::back_inserter(container));
+}
+
+inline bool List_column::contains(unsigned int value) const
+{
+	for (unsigned int v : column_){
+        if (v == value) return true;
+    }
+    return false;
+}
+
+inline bool List_column::is_empty()
+{
+    return column_.empty();
+}
+
+inline dimension_type List_column::get_dimension() const
+{
+    return dim_;
+}
+
+inline int List_column::get_pivot()
+{
+	if (column_.empty()) return -1;
+
+    return column_.back();
+}
+
+inline void List_column::clear()
+{
+    column_.clear();
+}
+
+inline void List_column::clear(unsigned int value)
+{
+    auto it = column_.begin();
+    while (it != column_.end() && *it != value) it++;
+    if (it != column_.end()) column_.erase(it);
+}
+
+inline void List_column::reorder(std::vector<index> &valueMap)
+{
+	std::list<unsigned int>::iterator it = column_.begin();
+	while (it != column_.end()) {
+		*it = valueMap.at(*it);
+		it++;
+	}
+	column_.sort();
+}
+
+inline void List_column::add(List_column &column)
+{
+    if (column.is_empty()) return;
+    if (column_.empty()){
+        std::copy(column.column_.begin(), column.column_.end(), std::back_inserter(column_));
+        return;
+    }
+
+    std::list<unsigned int>::iterator itToAdd = column.column_.begin();
+    std::list<unsigned int>::iterator itTarget = column_.begin();
+    unsigned int valToAdd = *itToAdd;
+    unsigned int valTarget = *itTarget;
+
+    while (itToAdd != column.column_.end() && itTarget != column_.end())
+    {
+        if (itToAdd != column.column_.end() && itTarget != column_.end()){
+            if (valToAdd == valTarget){
+                column_.erase(itTarget++);
+                itToAdd++;
+            } else if (valToAdd < valTarget){
+                column_.insert(itTarget, valToAdd);
+                itToAdd++;
+            } else {
+                itTarget++;
+            }
+        }
+
+        valToAdd = *itToAdd;
+        valTarget = *itTarget;
+    }
+
+    while (itToAdd != column.column_.end()){
+        valToAdd = *itToAdd;
+        if (itToAdd != column.column_.end()){
+            column_.push_back(valToAdd);
+            itToAdd++;
+        }
+    }
+}
+
+inline List_column &List_column::operator=(List_column other)
+{
+    std::swap(dim_, other.dim_);
+    std::swap(column_, other.column_);
+    return *this;
+}
+
+inline void swap(List_column& col1, List_column& col2)
+{
+    std::swap(col1.dim_, col2.dim_);
+    col1.column_.swap(col2.column_);
+}
+
+}   //namespace Vineyard
+
+#endif // LISTCOLUMN_H

multipers/multiparameter_module_approximation/list_column_2.h

@@ -0,0 +1,232 @@
+/*    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 LISTCOLUMN_H
+#define LISTCOLUMN_H
+
+#include <iostream>
+#include <list>
+#include <unordered_set>
+
+#include "utilities.h"
+
+namespace Vineyard {
+
+class List_column
+{
+public:
+    List_column();
+    List_column(boundary_type& boundary);
+    List_column(List_column& column);
+    List_column(List_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(List_column& column);
+
+    List_column& operator=(List_column other);
+
+    friend void swap(List_column& col1, List_column& col2);
+
+private:
+    int dim_;
+    std::list<unsigned int> column_;
+    std::unordered_set<unsigned int> erasedValues_;
+
+    void _cleanValues();
+};
+
+inline List_column::List_column() : dim_(0)
+{}
+
+inline List_column::List_column(boundary_type &boundary)
+    : dim_(boundary.size() == 0 ? 0 : boundary.size() - 1),
+      column_(boundary.begin(), boundary.end())
+{}
+
+inline List_column::List_column(List_column &column)
+    : dim_(column.dim_),
+      column_(column.column_),
+      erasedValues_(column.erasedValues_)
+{}
+
+inline List_column::List_column(List_column &&column) noexcept
+    : dim_(std::exchange(column.dim_, 0)),
+      column_(std::move(column.column_)),
+      erasedValues_(std::move(column.erasedValues_))
+{}
+
+inline void List_column::get_content(boundary_type &container)
+{
+    _cleanValues();
+    std::copy(column_.begin(), column_.end(), std::back_inserter(container));
+}
+
+inline bool List_column::contains(unsigned int value) const
+{
+    if (erasedValues_.find(value) != erasedValues_.end()) return false;
+
+    for (unsigned int v : column_){
+        if (v == value) return true;
+    }
+    return false;
+}
+
+inline bool List_column::is_empty()
+{
+    _cleanValues();
+    return column_.empty();
+}
+
+inline dimension_type List_column::get_dimension() const
+{
+    return dim_;
+}
+
+inline int List_column::get_pivot()
+{
+    while (!column_.empty() &&
+           erasedValues_.find(column_.back()) != erasedValues_.end()) {
+        erasedValues_.erase(column_.back());
+        column_.pop_back();
+    }
+
+    if (column_.empty()) return -1;
+
+    return column_.back();
+}
+
+inline void List_column::clear()
+{
+    column_.clear();
+    erasedValues_.clear();
+}
+
+inline void List_column::clear(unsigned int value)
+{
+    erasedValues_.insert(value);
+}
+
+inline void List_column::reorder(std::vector<index> &valueMap)
+{
+    std::list<unsigned int>::iterator it = column_.begin();
+    while (it != column_.end()) {
+        unsigned int erased = erasedValues_.erase(*it);
+        if (erased > 0)
+            it = column_.erase(it);
+        else {
+            *it = valueMap.at(*it);
+            it++;
+        }
+    }
+    column_.sort();
+    erasedValues_.clear();
+}
+
+inline void List_column::add(List_column &column)
+{
+    if (column.is_empty()) return;
+    if (column_.empty()){
+        std::copy(column.column_.begin(), column.column_.end(), std::back_inserter(column_));
+        return;
+    }
+
+    std::list<unsigned int>::iterator itToAdd = column.column_.begin();
+    std::list<unsigned int>::iterator itTarget = column_.begin();
+    unsigned int valToAdd = *itToAdd;
+    unsigned int valTarget = *itTarget;
+
+    while (itToAdd != column.column_.end() && itTarget != column_.end())
+    {
+        while (itToAdd != column.column_.end() &&
+               column.erasedValues_.find(valToAdd) != column.erasedValues_.end()) {
+            column.column_.erase(itToAdd++);
+            column.erasedValues_.erase(valToAdd);
+            valToAdd = *itToAdd;
+        }
+
+        while (itTarget != column_.end() &&
+               erasedValues_.find(valTarget) != erasedValues_.end()) {
+            column_.erase(itTarget++);
+            valTarget = *itTarget;
+        }
+
+        if (itToAdd != column.column_.end() && itTarget != column_.end()){
+            if (valToAdd == valTarget){
+                column_.erase(itTarget++);
+                itToAdd++;
+            } else if (valToAdd < valTarget){
+                column_.insert(itTarget, valToAdd);
+                itToAdd++;
+            } else {
+                itTarget++;
+            }
+        }
+
+        valToAdd = *itToAdd;
+        valTarget = *itTarget;
+    }
+
+    while (itToAdd != column.column_.end()){
+        valToAdd = *itToAdd;
+
+        while (itToAdd != column.column_.end() &&
+               column.erasedValues_.find(valToAdd) != column.erasedValues_.end()) {
+            column.column_.erase(itToAdd++);
+            column.erasedValues_.erase(valToAdd);
+            valToAdd = *itToAdd;
+        }
+
+        if (itToAdd != column.column_.end()){
+            column_.push_back(valToAdd);
+            itToAdd++;
+        }
+    }
+
+    erasedValues_.clear();
+}
+
+inline List_column &List_column::operator=(List_column other)
+{
+    std::swap(dim_, other.dim_);
+    std::swap(column_, other.column_);
+    std::swap(erasedValues_, other.erasedValues_);
+    return *this;
+}
+
+inline void List_column::_cleanValues()
+{
+    std::list<unsigned int>::iterator it = column_.begin();
+    while (it != column_.end() && !erasedValues_.empty()) {
+        unsigned int erased = erasedValues_.erase(*it);
+        if (erased > 0)
+            it = column_.erase(it);
+        else
+            it++;
+    }
+    erasedValues_.clear();
+}
+
+inline void swap(List_column& col1, List_column& col2)
+{
+    std::swap(col1.dim_, col2.dim_);
+    col1.column_.swap(col2.column_);
+    std::swap(col1.erasedValues_, col2.erasedValues_);
+}
+
+}   //namespace Vineyard
+
+#endif // LISTCOLUMN_H