multipers 2.3.3b6__cp313-cp313-macosx_11_0_arm64.whl

multipers/gudhi/gudhi/persistence_matrix_options.h

@@ -0,0 +1,170 @@
+/*    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-24 Inria
+ *
+ *    Modification(s):
+ *      - YYYY/MM Author: Description of the modification
+ */
+
+/**
+ * @file persistence_matrix_options.h
+ * @author Hannah Schreiber
+ * @brief Contains the options for the matrix template.
+ */
+
+#ifndef PM_OPTIONS_INCLUDED
+#define PM_OPTIONS_INCLUDED
+
+#include "Fields/Zp_field_operators.h"
+
+namespace Gudhi {
+namespace persistence_matrix {
+
+/**
+ * @ingroup persistence_matrix
+ *
+ * @brief List of column types.
+ */
+enum class Column_types { 
+  LIST,           /**< @ref List_column "": Underlying container is a std::list<@ref Entry*>. */
+  SET,            /**< @ref Set_column "": Underlying container is a std::set<@ref Entry*>. */
+  HEAP,           /**< @ref Heap_column "": Underlying container is a std::vector<@ref Entry*> ordered as a heap.
+                       Is not compatible with row access and column compression. */
+  VECTOR,         /**< @ref Vector_column "": Underlying container is a std::vector<@ref Entry*>
+                       with a lazy removal method. */
+  NAIVE_VECTOR,   /**< @ref Naive_vector_column "": Underlying container is a std::vector<@ref Entry*>. */
+  UNORDERED_SET,  /**< @ref Unordered_set_column "": Underlying container is a std::unordered_set<@ref Entry*>. */
+  INTRUSIVE_LIST, /**< @ref Intrusive_list_column "": Underlying container is a boost::intrusive::list<@ref Entry>. */
+  INTRUSIVE_SET,   /**< @ref Intrusive_set_column "": Underlying container is a boost::intrusive::set<@ref Entry>. */
+  SMALL_VECTOR
+};
+
+/**
+ * @ingroup persistence_matrix
+ *
+ * @brief List if indexation schemes. See @ref mp_indexation "description of indexation schemes" for more details
+ * about the meaning of the indexation types.
+ */
+enum class Column_indexation_types { 
+  CONTAINER,  /**< Default use of @ref MatIdx indices. */
+  POSITION,   /**< All input and output @ref MatIdx indices are replaced with @ref PosIdx indices. */
+  IDENTIFIER  /**< All input and output @ref MatIdx indices are replaced with @ref IDIdx indices. */
+};
+
+/**
+ * @struct Default_options persistence_matrix_options.h gudhi/persistence_matrix_options.h
+ * @ingroup persistence_matrix
+ *
+ * @brief Default option structure for @ref Matrix class.
+ * See the @ref PersistenceMatrixOptions concept for a more detailed description of the fields.
+ * Produces a @ref basematrix "base matrix" with no enabled option.
+ *
+ * To create other matrix types, the easiest is to simply inherit from this structure and overwrite only the options
+ * one is interested in.
+ * 
+ * @tparam col_type Column type for the matrix. Default value: @ref Column_types::INTRUSIVE_SET
+ * @tparam is_z2_only Flag indicating if only \f$Z_2\f$ coefficient will be used with the matrix. Set to true if it
+ * is the case, false otherwise. Default value: true.
+ * @tparam FieldOperators Field operators used by the matrix, see FieldOperators concept.
+ * Only necessary if @p is_z2_only is false. 
+ * Default value: @ref Gudhi::persistence_fields::Zp_field_operators<>.
+ */
+template <Column_types col_type = Column_types::INTRUSIVE_SET, 
+          bool is_z2_only = true,
+          class FieldOperators = persistence_fields::Zp_field_operators<> >
+struct Default_options 
+{
+  using Field_coeff_operators = FieldOperators;
+  using Dimension = int;
+  using Index = unsigned int;
+
+  static const bool is_z2 = is_z2_only;
+  static const Column_types column_type = col_type;
+
+  static const Column_indexation_types column_indexation_type = Column_indexation_types::CONTAINER;
+
+  static const bool has_column_compression = false;
+  static const bool has_column_and_row_swaps = false;
+
+  static const bool has_map_column_container = false;
+  static const bool has_removable_columns = false;
+
+  static const bool has_row_access = false;
+  static const bool has_intrusive_rows = true;
+  static const bool has_removable_rows = false;
+
+  static const bool is_of_boundary_type = true;
+
+  static const bool has_matrix_maximal_dimension_access = false;
+  static const bool has_column_pairings = false;
+  static const bool has_vine_update = false;
+  static const bool can_retrieve_representative_cycles = false;
+};
+
+//TODO: The following structures are the one used by the other modules or debug tests.
+// They will probably be removed once the module was properly integrated.
+
+/**
+ * @brief Options used for the Zigzag persistence module.
+ * 
+ * @tparam column_type Column type for the matrix.
+ */
+template <Column_types column_type = Column_types::INTRUSIVE_LIST>
+struct Zigzag_options : Default_options<column_type, true> 
+{
+  static const bool has_row_access = true;
+  static const bool has_column_pairings = false;
+  static const bool has_vine_update = true;
+  static const bool is_of_boundary_type = false;
+  static const bool has_map_column_container = true;
+  static const bool has_removable_columns = true;
+  static const bool has_removable_rows = true;
+};
+
+/**
+ * @brief Options needed to use the representative cycles.
+ * 
+ * @tparam col_type Column type for the matrix.
+ */
+template <Column_types col_type = Column_types::INTRUSIVE_SET>
+struct Representative_cycles_options : Default_options<col_type, true> 
+{
+  static const bool has_column_pairings = true;
+  static const bool can_retrieve_representative_cycles = true;
+};
+
+/**
+ * @brief Options used by the Multipersistence module.
+ * 
+ * @tparam column_type Column type for the matrix.
+ */
+template <Column_types column_type = Column_types::INTRUSIVE_SET>
+struct Multi_persistence_options : Default_options<column_type, true> 
+{
+  static const bool has_column_pairings = true;
+  static const bool has_vine_update = true;
+};
+
+/**
+ * @brief Options used by the cohomology module.
+ * 
+ * @tparam column_type Column type for the matrix.
+ * @tparam is_z2_only True if Z2.
+ * @tparam FieldOperators Field operator.
+ */
+template <Column_types column_type = Column_types::INTRUSIVE_LIST, 
+          bool is_z2_only = true,
+          class FieldOperators = persistence_fields::Zp_field_operators<> >
+struct Cohomology_persistence_options : Default_options<column_type, is_z2_only, FieldOperators> 
+{
+  static const bool has_row_access = true;
+  static const bool has_column_compression = true;
+  static const bool has_removable_rows = true;
+};
+
+}  // namespace persistence_matrix
+}  // namespace Gudhi
+
+#endif  // PM_OPTIONS_INCLUDED

multipers/gudhi/gudhi/reader_utils.h

@@ -0,0 +1,367 @@
+/*    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):       Clement Maria, Pawel Dlotko, Clement Jamin
+ *
+ *    Copyright (C) 2014 Inria
+ *
+ *    Modification(s):
+ *      - YYYY/MM Author: Description of the modification
+ */
+
+#ifndef READER_UTILS_H_
+#define READER_UTILS_H_
+
+#include <gudhi/graph_simplicial_complex.h>
+#include <gudhi/Debug_utils.h>
+
+# include <boost/iterator/function_output_iterator.hpp>
+#include <boost/graph/adjacency_list.hpp>
+
+#include <iostream>
+#include <fstream>
+#include <map>
+#include <limits>  // for numeric_limits
+#include <string>
+#include <vector>
+#include <utility>  // for pair
+#include <tuple>  // for std::make_tuple
+
+namespace Gudhi {
+
+// Keep this file tag for Doxygen to parse the code, otherwise, functions are not documented.
+// It is required for global functions and variables.
+
+/** @file
+ * @brief This file includes common file reader for GUDHI
+ */
+
+/**
+ * @brief Read a set of points to turn it into a vector< vector<double> > by filling points.
+ *
+ * File format: 1 point per line<br>
+ * X11 X12 ... X1d<br>
+ * X21 X22 ... X2d<br>
+ * etc<br>
+ */
+inline void read_points(std::string file_name, std::vector<std::vector<double>>& points) {
+  std::ifstream in_file(file_name.c_str(), std::ios::in);
+  if (!in_file.is_open()) {
+    std::cerr << "Unable to open file " << file_name << std::endl;
+    return;
+  }
+
+  std::string line;
+  double x;
+  while (getline(in_file, line)) {
+    std::vector<double> point;
+    std::istringstream iss(line);
+    while (iss >> x) {
+      point.push_back(x);
+    }
+    // Check for empty lines
+    if (!point.empty()) points.push_back(point);
+  }
+  in_file.close();
+}
+
+/**
+ * @brief Read a graph from a file.
+ *
+ * \tparam Graph_t Type for the return graph. Must be constructible from iterators on pairs of Vertex_handle
+ * \tparam Filtration_value Type for the value of the read filtration
+ * \tparam Vertex_handle Type for the value of the read vertices
+ *
+ * File format: 1 simplex per line<br>
+ * Dim1 X11 X12 ... X1d Fil1<br>
+ * Dim2 X21 X22 ... X2d Fil2<br>
+ * etc<br>
+ *
+ * The vertices must be labeled from 0 to n-1.
+ * Every simplex must appear exactly once.
+ * Simplices of dimension more than 1 are ignored.
+ */
+template <typename Graph_t, typename Filtration_value, typename Vertex_handle>
+Graph_t read_graph(std::string file_name) {
+  std::ifstream in_(file_name.c_str(), std::ios::in);
+  if (!in_.is_open()) {
+    std::string error_str("read_graph - Unable to open file ");
+    error_str.append(file_name);
+    std::cerr << error_str << std::endl;
+    throw std::invalid_argument(error_str);
+  }
+
+  typedef std::pair<Vertex_handle, Vertex_handle> Edge_t;
+  std::vector<Edge_t> edges;
+  std::vector<Filtration_value> edges_fil;
+  std::map<Vertex_handle, Filtration_value> vertices;
+
+  std::string line;
+  int dim;
+  Vertex_handle u, v, max_h = -1;
+  Filtration_value fil;
+  while (getline(in_, line)) {
+    std::istringstream iss(line);
+    while (iss >> dim) {
+      switch (dim) {
+        case 0: {
+          iss >> u;
+          iss >> fil;
+          vertices[u] = fil;
+          if (max_h < u) {
+            max_h = u;
+          }
+          break;
+        }
+        case 1: {
+          iss >> u;
+          iss >> v;
+          iss >> fil;
+          edges.push_back(Edge_t(u, v));
+          edges_fil.push_back(fil);
+          break;
+        }
+        default: { break; }
+      }
+    }
+  }
+  in_.close();
+
+  if ((size_t)(max_h + 1) != vertices.size()) {
+    std::cerr << "Error: vertices must be labeled from 0 to n-1 \n";
+  }
+
+  Graph_t skel_graph(edges.begin(), edges.end(), edges_fil.begin(), vertices.size());
+  auto vertex_prop = boost::get(vertex_filtration_t(), skel_graph);
+
+  typename boost::graph_traits<Graph_t>::vertex_iterator vi, vi_end;
+  auto v_it = vertices.begin();
+  for (std::tie(vi, vi_end) = boost::vertices(skel_graph); vi != vi_end; ++vi, ++v_it) {
+    boost::put(vertex_prop, *vi, v_it->second);
+  }
+
+  return skel_graph;
+}
+
+/**
+ * @brief Read a face from a file.
+ *
+ * File format: 1 simplex per line<br>
+ * Dim1 X11 X12 ... X1d Fil1<br>
+ * Dim2 X21 X22 ... X2d Fil2<br>
+ * etc<br>
+ *
+ * The vertices must be labeled from 0 to n-1.
+ * Every simplex must appear exactly once.
+ * Simplices of dimension more than 1 are ignored.
+ */
+template <typename Vertex_handle, typename Filtration_value>
+bool read_simplex(std::istream& in_, std::vector<Vertex_handle>& simplex, Filtration_value& fil) {
+  int dim = 0;
+  if (!(in_ >> dim)) return false;
+  Vertex_handle v;
+  for (int i = 0; i < dim + 1; ++i) {
+    if (!(in_ >> v)) return false;
+    simplex.push_back(v);
+  }
+  if (!(in_ >> fil)) return false;
+  in_.ignore((std::numeric_limits<std::streamsize>::max)(), '\n');  // ignore until the carriage return
+  return true;
+}
+
+/**
+ * @brief Read a hasse simplex from a file.
+ *
+ * File format: 1 simplex per line<br>
+ * Dim1 k11 k12 ... k1Dim1 Fil1<br>
+ * Dim2 k21 k22 ... k2Dim2 Fil2<br>
+ * etc<br>
+ *
+ * The key of a simplex is its position in the filtration order and also the number of its row in the file.
+ * Dimi ki1 ki2 ... kiDimi Fili means that the ith simplex in the filtration has dimension Dimi, filtration value
+ * fil1 and simplices with key ki1 ... kiDimi in its boundary.*/
+template <typename Simplex_key, typename Filtration_value>
+bool read_hasse_simplex(std::istream& in_, std::vector<Simplex_key>& boundary, Filtration_value& fil) {
+  int dim;
+  if (!(in_ >> dim)) return false;
+  if (dim == 0) {
+    in_ >> fil;
+    return true;
+  }
+  Simplex_key key;
+  for (int i = 0; i < dim + 1; ++i) {
+    in_ >> key;
+    boundary.push_back(key);
+  }
+  in_ >> fil;
+  return true;
+}
+
+/**
+ * @brief Read a lower triangular distance matrix from a csv file. We assume that the .csv store the whole
+ * (square) matrix.
+ *
+ * @author Pawel Dlotko
+ *
+ * Square matrix file format:<br>
+ * 0;D12;...;D1j<br>
+ * D21;0;...;D2j<br>
+ * ...<br>
+ * Dj1;Dj2;...;0<br>
+ *
+ * lower matrix file format:<br>
+ * 0<br>
+ * D21;<br>
+ * D31;D32;<br>
+ * ...<br>
+ * Dj1;Dj2;...;Dj(j-1);<br>
+ *
+ **/
+template <typename Filtration_value>
+std::vector<std::vector<Filtration_value>> read_lower_triangular_matrix_from_csv_file(const std::string& filename,
+                                                                                      const char separator = ';') {
+#ifdef DEBUG_TRACES
+  std::clog << "Using procedure read_lower_triangular_matrix_from_csv_file \n";
+#endif  // DEBUG_TRACES
+  std::vector<std::vector<Filtration_value>> result;
+  std::ifstream in;
+  in.open(filename.c_str());
+  if (!in.is_open()) {
+    return result;
+  }
+
+  std::string line;
+
+  // the first line is empty, so we ignore it:
+  std::getline(in, line);
+  std::vector<Filtration_value> values_in_this_line;
+  result.push_back(values_in_this_line);
+
+  int number_of_line = 0;
+
+  // first, read the file line by line to a string:
+  while (std::getline(in, line)) {
+    // if line is empty, break
+    if (line.size() == 0) break;
+
+    // if the last element of a string is comma:
+    if (line[line.size() - 1] == separator) {
+      // then shrink the string by one
+      line.pop_back();
+    }
+
+    // replace all commas with spaces
+    std::replace(line.begin(), line.end(), separator, ' ');
+
+    // put the new line to a stream
+    std::istringstream iss(line);
+    // and now read the doubles.
+
+    int number_of_entry = 0;
+    std::vector<Filtration_value> values_in_this_line;
+    while (iss.good()) {
+      double entry;
+      iss >> entry;
+      if (number_of_entry <= number_of_line) {
+        values_in_this_line.push_back(entry);
+      }
+      ++number_of_entry;
+    }
+    if (!values_in_this_line.empty()) result.push_back(values_in_this_line);
+    ++number_of_line;
+  }
+  in.close();
+
+#ifdef DEBUG_TRACES
+  std::clog << "Here is the matrix we read : \n";
+  for (size_t i = 0; i != result.size(); ++i) {
+    for (size_t j = 0; j != result[i].size(); ++j) {
+      std::clog << result[i][j] << " ";
+    }
+    std::clog << std::endl;
+  }
+#endif  // DEBUG_TRACES
+
+  return result;
+}  // read_lower_triangular_matrix_from_csv_file
+
+/**
+Reads a file containing persistence intervals.
+Each line might contain 2, 3 or 4 values: [[field] dimension] birth death
+The output iterator `out` is used this way: `*out++ = std::make_tuple(dim, birth, death);`
+where `dim` is an `int`, `birth` a `double`, and `death` a `double`.
+Note: the function does not check that birth <= death.
+**/
+template <typename OutputIterator>
+void read_persistence_intervals_and_dimension(std::string const& filename, OutputIterator out) {
+#ifdef DEBUG_TRACES
+  std::clog << "read_persistence_intervals_and_dimension - " << filename << std::endl;
+#endif  // DEBUG_TRACES
+  std::ifstream in(filename);
+  if (!in.is_open()) {
+    std::string error_str("read_persistence_intervals_and_dimension - Unable to open file ");
+    error_str.append(filename);
+    std::cerr << error_str << std::endl;
+    throw std::invalid_argument(error_str);
+  }
+
+  while (!in.eof()) {
+    std::string line;
+    getline(in, line);
+    if (line.length() != 0 && line[0] != '#') {
+      double numbers[4];
+      int n = sscanf(line.c_str(), "%lf %lf %lf %lf", &numbers[0], &numbers[1], &numbers[2], &numbers[3]);
+#ifdef DEBUG_TRACES
+      std::clog << "[" << n << "] = ";
+      for (int i = 0; i < n; i++) {
+        std::clog << numbers[i] << ",";
+      }
+      std::clog << std::endl;
+#endif  // DEBUG_TRACES
+      if (n >= 2) {
+        int dim = (n >= 3 ? static_cast<int>(numbers[n - 3]) : -1);
+        *out++ = std::make_tuple(dim, numbers[n - 2], numbers[n - 1]);
+      }
+    }
+  }
+}
+
+/**
+Reads a file containing persistence intervals.
+Each line might contain 2, 3 or 4 values: [[field] dimension] birth death
+The return value is an `std::map<dim, std::vector<std::pair<birth, death>>>`
+where `dim` is an `int`, `birth` a `double`, and `death` a `double`.
+Note: the function does not check that birth <= death.
+**/
+inline std::map<int, std::vector<std::pair<double, double>>> read_persistence_intervals_grouped_by_dimension(
+    std::string const& filename) {
+  std::map<int, std::vector<std::pair<double, double>>> ret;
+  read_persistence_intervals_and_dimension(
+      filename, boost::make_function_output_iterator([&ret](std::tuple<int, double, double> t) {
+        ret[get<0>(t)].push_back(std::make_pair(get<1>(t), get<2>(t)));
+      }));
+  return ret;
+}
+
+/**
+Reads a file containing persistence intervals.
+Each line might contain 2, 3 or 4 values: [[field] dimension] birth death
+If `only_this_dim` = -1, dimension is ignored and all lines are returned.
+If `only_this_dim` is >= 0, only the lines where dimension = `only_this_dim`
+(or where dimension is not specified) are returned.
+The return value is an `std::vector<std::pair<birth, death>>`
+where `dim` is an `int`, `birth` a `double`, and `death` a `double`.
+Note: the function does not check that birth <= death.
+**/
+inline std::vector<std::pair<double, double>> read_persistence_intervals_in_dimension(std::string const& filename,
+                                                                                      int only_this_dim = -1) {
+  std::vector<std::pair<double, double>> ret;
+  read_persistence_intervals_and_dimension(
+      filename, boost::make_function_output_iterator([only_this_dim, &ret](std::tuple<int, double, double> t) {
+        if (only_this_dim == get<0>(t) || only_this_dim == -1) ret.emplace_back(get<1>(t), get<2>(t));
+      }));
+  return ret;
+}
+
+}  // namespace Gudhi
+
+#endif  // READER_UTILS_H_