From f5c97bc9fd1c247045d35ddf261f9afe4d024406 Mon Sep 17 00:00:00 2001
From: glisse <glisse@636b058d-ea47-450e-bf9e-a15bfbe3eedb>
Date: Fri, 20 Jul 2018 15:03:46 +0000
Subject: First try at interfacing the sparse rips in python. Needs at least
 documentation and tests.

git-svn-id: svn+ssh://scm.gforge.inria.fr/svnroot/gudhi/branches/sparserips-python@3697 636b058d-ea47-450e-bf9e-a15bfbe3eedb

Former-commit-id: 75bef59e90355853ee24807ca7453c4bb0a38f43
---
 src/cython/include/Rips_complex_interface.h | 39 +++++++++++++++++++----------
 1 file changed, 26 insertions(+), 13 deletions(-)

(limited to 'src/cython/include/Rips_complex_interface.h')

diff --git a/src/cython/include/Rips_complex_interface.h b/src/cython/include/Rips_complex_interface.h
index 8b6c9c35..f6fc79a1 100644
--- a/src/cython/include/Rips_complex_interface.h
+++ b/src/cython/include/Rips_complex_interface.h
@@ -25,8 +25,11 @@
 
 #include <gudhi/Simplex_tree.h>
 #include <gudhi/Rips_complex.h>
+#include <gudhi/Sparse_rips_complex.h>
 #include <gudhi/distance_functions.h>
 
+#include <boost/optional.hpp>
+
 #include "Simplex_tree_interface.h"
 
 #include <iostream>
@@ -43,28 +46,38 @@ class Rips_complex_interface {
   using Distance_matrix = std::vector<std::vector<Simplex_tree_interface<>::Filtration_value>>;
 
  public:
-  Rips_complex_interface(const std::vector<std::vector<double>>& values, double threshold, bool euclidean) {
-    if (euclidean) {
-      // Rips construction where values is a vector of points
-      rips_complex_ = new Rips_complex<Simplex_tree_interface<>::Filtration_value>(values, threshold,
-                                                                                   Gudhi::Euclidean_distance());
-    } else {
-      // Rips construction where values is a distance matrix
-      rips_complex_ = new Rips_complex<Simplex_tree_interface<>::Filtration_value>(values, threshold);
-    }
+  void init_points(const std::vector<std::vector<double>>& points, double threshold) {
+    rips_complex_.emplace(points, threshold, Gudhi::Euclidean_distance());
+  }
+  void init_matrix(const std::vector<std::vector<double>>& matrix, double threshold) {
+    rips_complex_.emplace(matrix, threshold);
   }
 
-  ~Rips_complex_interface() {
-    delete rips_complex_;
+  void init_points_sparse(const std::vector<std::vector<double>>& points, double threshold, double epsilon) {
+    sparse_rips_complex_.emplace(points, Gudhi::Euclidean_distance(), epsilon);
+    threshold_ = threshold;
+  }
+  void init_matrix_sparse(const std::vector<std::vector<double>>& matrix, double threshold, double epsilon) {
+    sparse_rips_complex_.emplace(matrix, epsilon);
+    threshold_ = threshold;
   }
 
   void create_simplex_tree(Simplex_tree_interface<>* simplex_tree, int dim_max) {
-    rips_complex_->create_complex(*simplex_tree, dim_max);
+    if (rips_complex_)
+      rips_complex_->create_complex(*simplex_tree, dim_max);
+    else {
+      sparse_rips_complex_->create_complex(*simplex_tree, dim_max);
+      // This pruning should be done much earlier! It isn't that useful for sparse Rips, but it would be inconsistent not to do it.
+      simplex_tree->prune_above_filtration(threshold_);
+    }
     simplex_tree->initialize_filtration();
   }
 
  private:
-  Rips_complex<Simplex_tree_interface<>::Filtration_value>* rips_complex_;
+  // std::variant would work, but we don't require C++17 yet, and boost::variant is not super convenient. Anyway, storing a graph would make more sense. Or changing the interface completely so there is no such storage.
+  boost::optional<Rips_complex<Simplex_tree_interface<>::Filtration_value>> rips_complex_;
+  boost::optional<Sparse_rips_complex<Simplex_tree_interface<>::Filtration_value>> sparse_rips_complex_;
+  double threshold_;
 };
 
 }  // namespace rips_complex
-- 
cgit v1.2.3