Merge last trunk modifications

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

Former-commit-id: 213c7b76c5f8c3248b24a2ac9250ed59034d8076

17 files changed, 336 insertions, 106 deletions

diff --git a/src/common/include/gudhi/Clock.h b/src/common/include/gudhi/Clock.h
index b83de2f5..cdf18cb2 100644
--- a/src/common/include/gudhi/Clock.h
+++ b/src/common/include/gudhi/Clock.h
@@ -4,7 +4,7 @@
  *
  *    Author(s):       David Salinas
  *
- *    Copyright (C) 2014  INRIA Sophia Antipolis-Mediterranee (France)
+ *    Copyright (C) 2014 Inria
  *
  *    This program is free software: you can redistribute it and/or modify
  *    it under the terms of the GNU General Public License as published by
diff --git a/src/common/include/gudhi/Debug_utils.h b/src/common/include/gudhi/Debug_utils.h
index 8ed3b7b3..3f5cb04f 100644
--- a/src/common/include/gudhi/Debug_utils.h
+++ b/src/common/include/gudhi/Debug_utils.h
@@ -4,7 +4,7 @@
  *
  *    Author(s):       David Salinas
  *
- *    Copyright (C) 2014  INRIA Sophia Antipolis-Mediterranee (France)
+ *    Copyright (C) 2014 Inria
  *
  *    This program is free software: you can redistribute it and/or modify
  *    it under the terms of the GNU General Public License as published by
@@ -32,7 +32,7 @@
 // GUDHI_CHECK throw an exception if expression is false in debug mode, but does nothing in release mode
 // Could assert in release mode, but cmake sets NDEBUG (for "NO DEBUG") in this mode, means assert does nothing.
 #ifdef GUDHI_DEBUG
-  #define GUDHI_CHECK(expression, excpt) if ((expression) == 0) throw excpt
+  #define GUDHI_CHECK(expression, excpt) ((expression) ? (void) 0 : (throw excpt))
   #define GUDHI_CHECK_code(CODE) CODE
 #else
   #define GUDHI_CHECK(expression, excpt) (void) 0
diff --git a/src/common/include/gudhi/Null_output_iterator.h b/src/common/include/gudhi/Null_output_iterator.h
index 42e6e449..c700af5f 100644
--- a/src/common/include/gudhi/Null_output_iterator.h
+++ b/src/common/include/gudhi/Null_output_iterator.h
@@ -4,7 +4,7 @@
  *
  *    Author(s):       Marc Glisse
  *
- *    Copyright (C) 2017  INRIA
+ *    Copyright (C) 2017 Inria
  *
  *    This program is free software: you can redistribute it and/or modify
  *    it under the terms of the GNU General Public License as published by
diff --git a/src/common/include/gudhi/Off_reader.h b/src/common/include/gudhi/Off_reader.h
index 4fcd2af2..05a1e145 100644
--- a/src/common/include/gudhi/Off_reader.h
+++ b/src/common/include/gudhi/Off_reader.h
@@ -4,7 +4,7 @@
  *
  *    Author(s):       David Salinas
  *
- *    Copyright (C) 2014  INRIA Sophia Antipolis-Mediterranee (France)
+ *    Copyright (C) 2014 Inria
  *
  *    This program is free software: you can redistribute it and/or modify
  *    it under the terms of the GNU General Public License as published by
@@ -105,25 +105,26 @@ class Off_reader {
     bool is_off_file = (line.find("OFF") != std::string::npos);
     bool is_noff_file = (line.find("nOFF") != std::string::npos);
 
+
+
     if (!is_off_file && !is_noff_file) {
       std::cerr << line << std::endl;
       std::cerr << "missing off header\n";
       return false;
     }
 
+    if (is_noff_file) {
+      // Should be on a separate line, but we accept it on the same line as the number of vertices
+      stream_ >> off_info_.dim;
+    } else {
+      off_info_.dim = 3;
+    }
+
     if (!goto_next_uncomment_line(line)) return false;
     std::istringstream iss(line);
-    if ((is_off_file) && (!is_noff_file)) {
-      off_info_.dim = 3;
-      if (!(iss >> off_info_.num_vertices >> off_info_.num_faces >> off_info_.num_edges)) {
-        std::cerr << "incorrect number of vertices/faces/edges\n";
-        return false;
-      }
-    } else {
-      if (!(iss >> off_info_.dim >> off_info_.num_vertices >> off_info_.num_faces >> off_info_.num_edges)) {
+    if (!(iss >> off_info_.num_vertices >> off_info_.num_faces >> off_info_.num_edges)) {
       std::cerr << "incorrect number of vertices/faces/edges\n";
       return false;
-      }
     }
     off_visitor.init(off_info_.dim, off_info_.num_vertices, off_info_.num_faces, off_info_.num_edges);
 
@@ -131,10 +132,12 @@ class Off_reader {
   }
 
   bool goto_next_uncomment_line(std::string& uncomment_line) {
-    uncomment_line.clear();
-    do
-      std::getline(stream_, uncomment_line); while (uncomment_line[0] == '%');
-    return (uncomment_line.size() > 0 && uncomment_line[0] != '%');
+    do {
+      // skip whitespace, including empty lines
+      if (!std::ifstream::sentry(stream_)) return false;
+      std::getline(stream_, uncomment_line);
+    } while (uncomment_line[0] == '#');
+    return static_cast<bool>(stream_);
   }
 
   template<typename OffVisitor>
diff --git a/src/common/include/gudhi/Point.h b/src/common/include/gudhi/Point.h
index 0479e71e..345a8465 100644
--- a/src/common/include/gudhi/Point.h
+++ b/src/common/include/gudhi/Point.h
@@ -4,7 +4,7 @@
  *
  *    Author(s):       David Salinas
  *
- *    Copyright (C) 2014  INRIA Sophia Antipolis-Mediterranee (France)
+ *    Copyright (C) 2014 Inria
  *
  *    This program is free software: you can redistribute it and/or modify
  *    it under the terms of the GNU General Public License as published by
diff --git a/src/common/include/gudhi/Points_3D_off_io.h b/src/common/include/gudhi/Points_3D_off_io.h
index b0d24998..704f73a7 100644
--- a/src/common/include/gudhi/Points_3D_off_io.h
+++ b/src/common/include/gudhi/Points_3D_off_io.h
@@ -4,7 +4,7 @@
  *
  *    Author(s):       Vincent Rouvreau
  *
- *    Copyright (C) 2015  INRIA Saclay (France)
+ *    Copyright (C) 2015 Inria
  *
  *    This program is free software: you can redistribute it and/or modify
  *    it under the terms of the GNU General Public License as published by
diff --git a/src/common/include/gudhi/Points_fvecs_reader.h b/src/common/include/gudhi/Points_fvecs_reader.h
deleted file mode 100644
index eb03bb72..00000000
--- a/src/common/include/gudhi/Points_fvecs_reader.h
+++ /dev/null
@@ -1,68 +0,0 @@
-/*    This file is part of the Gudhi Library. The Gudhi library
- *    (Geometric Understanding in Higher Dimensions) is a generic C++
- *    library for computational topology.
- *
- *    Author(s):       Vincent Rouvreau
- *
- *    Copyright (C) 2015  INRIA Saclay (France)
- *
- *    This program is free software: you can redistribute it and/or modify
- *    it under the terms of the GNU General Public License as published by
- *    the Free Software Foundation, either version 3 of the License, or
- *    (at your option) any later version.
- *
- *    This program is distributed in the hope that it will be useful,
- *    but WITHOUT ANY WARRANTY; without even the implied warranty of
- *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *    GNU General Public License for more details.
- *
- *    You should have received a copy of the GNU General Public License
- *    along with this program.  If not, see <http://www.gnu.org/licenses/>.
- */
-#ifndef POINTS_FVECS_READER_H_
-#define POINTS_FVECS_READER_H_
-
-namespace Gudhi {
-
-template<typename Kernel, typename OutputIteratorPoints>
-bool load_points_from_fvecs_file(const std::string &filename, OutputIteratorPoints points, int only_the_first_n_points = -1)
-{
-  typedef typename Kernel::Point_d Point;
-
-  std::ifstream in(filename, std::ios::binary);
-  if (!in.is_open()) {
-    std::cerr << "Could not open '" << filename << "'" << std::endl;
-    return false;
-  }
-
-  Kernel k;
-  unsigned long pt_dim = 0;
-
-  in.read(reinterpret_cast<char*>(&pt_dim), 4);
-  std::vector<float> current_pt;
-  current_pt.reserve(pt_dim);
-  for (int c = 0; !in.fail() && c != only_the_first_n_points; ++c) {
-
-    for (int j = 0; j < pt_dim; ++j)
-    {
-      float coord = 0.f;
-      in.read(reinterpret_cast<char*>(&coord), 4);
-      current_pt.push_back(coord);
-    }
-
-    *points++ = Point(current_pt.begin(), current_pt.end());
-    current_pt.clear();
-    in.read(reinterpret_cast<char*>(&pt_dim), 4);
-  }
-
-#ifdef DEBUG_TRACES
-  std::cerr << "'" << filename << "' loaded." << std::endl;
-#endif
-
-  return true;
-}
-
-
-}  // namespace Gudhi
-
-#endif  // POINTS_FVECS_READER_H_
diff --git a/src/common/include/gudhi/Points_off_io.h b/src/common/include/gudhi/Points_off_io.h
index 29af8a8a..38029658 100644
--- a/src/common/include/gudhi/Points_off_io.h
+++ b/src/common/include/gudhi/Points_off_io.h
@@ -4,7 +4,7 @@
  *
  *    Author(s):       Vincent Rouvreau
  *
- *    Copyright (C) 2015  INRIA Saclay (France)
+ *    Copyright (C) 2015 Inria
  *
  *    This program is free software: you can redistribute it and/or modify
  *    it under the terms of the GNU General Public License as published by
@@ -126,9 +126,9 @@ class Points_off_visitor_reader {
  * \code $> ./vector_double_off_reader ../../data/points/alphacomplexdoc.off
  * \endcode
  *
- * the program output is:
+ * the program outputs a file ../../data/points/alphacomplexdoc.off.txt:
  * 
- * \include common/cgaloffreader_result.txt
+ * \include common/vectordoubleoffreader_result.txt
  */
 template<typename Point_d>
 class Points_off_reader {
diff --git a/src/common/include/gudhi/Simple_object_pool.h b/src/common/include/gudhi/Simple_object_pool.h
index fb9c8e23..47283521 100644
--- a/src/common/include/gudhi/Simple_object_pool.h
+++ b/src/common/include/gudhi/Simple_object_pool.h
@@ -4,7 +4,7 @@
  *
  *    Author(s):       Marc Glisse
  *
- *    Copyright (C) 2015  INRIA Saclay - Ile de France
+ *    Copyright (C) 2015 Inria
  *
  *    This program is free software: you can redistribute it and/or modify
  *    it under the terms of the GNU General Public License as published by
diff --git a/src/common/include/gudhi/Unitary_tests_utils.h b/src/common/include/gudhi/Unitary_tests_utils.h
new file mode 100644
index 00000000..e07c8d42
--- /dev/null
+++ b/src/common/include/gudhi/Unitary_tests_utils.h
@@ -0,0 +1,40 @@
+/*    This file is part of the Gudhi Library. The Gudhi library
+ *    (Geometric Understanding in Higher Dimensions) is a generic C++
+ *    library for computational topology.
+ *
+ *    Author(s):       Vincent Rouvreau
+ *
+ *    Copyright (C) 2017 Inria
+ *
+ *    This program is free software: you can redistribute it and/or modify
+ *    it under the terms of the GNU General Public License as published by
+ *    the Free Software Foundation, either version 3 of the License, or
+ *    (at your option) any later version.
+ *
+ *    This program is distributed in the hope that it will be useful,
+ *    but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *    GNU General Public License for more details.
+ *
+ *    You should have received a copy of the GNU General Public License
+ *    along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+#ifndef UNITARY_TESTS_UTILS_H_
+#define UNITARY_TESTS_UTILS_H_
+
+#include <boost/test/unit_test.hpp>
+
+#include <iostream>
+#include <limits>  // for std::numeric_limits<>
+
+template<typename FloatingType >
+void GUDHI_TEST_FLOAT_EQUALITY_CHECK(FloatingType a, FloatingType b,
+                                     FloatingType epsilon = std::numeric_limits<FloatingType>::epsilon()) {
+#ifdef DEBUG_TRACES
+  std::cout << "GUDHI_TEST_FLOAT_EQUALITY_CHECK - " << a << " versus " << b
+            << " | diff = " << std::fabs(a - b) << " - epsilon = " << epsilon << std::endl;
+#endif
+  BOOST_CHECK(std::fabs(a - b) < epsilon);
+}
+
+#endif  // UNITARY_TESTS_UTILS_H_
diff --git a/src/common/include/gudhi/allocator.h b/src/common/include/gudhi/allocator.h
index 4ede14e4..3de16a49 100644
--- a/src/common/include/gudhi/allocator.h
+++ b/src/common/include/gudhi/allocator.h
@@ -4,7 +4,7 @@
  *
  *    Author(s):       Marc Glisse
  *
- *    Copyright (C) 2015  INRIA Saclay - Ile de France
+ *    Copyright (C) 2015 Inria
  *
  *    This program is free software: you can redistribute it and/or modify
  *    it under the terms of the GNU General Public License as published by
diff --git a/src/common/include/gudhi/console_color.h b/src/common/include/gudhi/console_color.h
index c4671da3..a493e0d0 100644
--- a/src/common/include/gudhi/console_color.h
+++ b/src/common/include/gudhi/console_color.h
@@ -4,7 +4,7 @@
  *
  *    Author(s):       Clement Jamin
  *
- *    Copyright (C) 2016  INRIA Sophia-Antipolis (France)
+ *    Copyright (C) 2016 Inria
  *
  *    This program is free software: you can redistribute it and/or modify
  *    it under the terms of the GNU General Public License as published by
diff --git a/src/common/include/gudhi/distance_functions.h b/src/common/include/gudhi/distance_functions.h
index f6e2ab5a..5ef12f2e 100644
--- a/src/common/include/gudhi/distance_functions.h
+++ b/src/common/include/gudhi/distance_functions.h
@@ -4,7 +4,7 @@
  *
  *    Author(s):       Clément Maria
  *
- *    Copyright (C) 2014  INRIA
+ *    Copyright (C) 2014 Inria
  *
  *    This program is free software: you can redistribute it and/or modify
  *    it under the terms of the GNU General Public License as published by
@@ -23,9 +23,17 @@
 #ifndef DISTANCE_FUNCTIONS_H_
 #define DISTANCE_FUNCTIONS_H_
 
+#include <gudhi/Debug_utils.h>
+
+#include <gudhi/Miniball.hpp>
+
+#include <boost/range/metafunctions.hpp>
+#include <boost/range/size.hpp>
+
 #include <cmath>  // for std::sqrt
 #include <type_traits>  // for std::decay
 #include <iterator>  // for std::begin, std::end
+#include <utility>
 
 namespace Gudhi {
 
@@ -37,16 +45,76 @@ namespace Gudhi {
  * have the same dimension. */
 class Euclidean_distance {
  public:
+  // boost::range_value is not SFINAE-friendly so we cannot use it in the return type
   template< typename Point >
-  auto operator()(const Point& p1, const Point& p2) const -> typename std::decay<decltype(*std::begin(p1))>::type {
-    auto it1 = p1.begin();
-    auto it2 = p2.begin();
-    typename Point::value_type dist = 0.;
-    for (; it1 != p1.end(); ++it1, ++it2) {
-      typename Point::value_type tmp = (*it1) - (*it2);
+  typename std::iterator_traits<typename boost::range_iterator<Point>::type>::value_type
+  operator()(const Point& p1, const Point& p2) const {
+    auto it1 = std::begin(p1);
+    auto it2 = std::begin(p2);
+    typedef typename boost::range_value<Point>::type NT;
+    NT dist = 0;
+    for (; it1 != std::end(p1); ++it1, ++it2) {
+      GUDHI_CHECK(it2 != std::end(p2), "inconsistent point dimensions");
+      NT tmp = *it1 - *it2;
       dist += tmp*tmp;
     }
-    return std::sqrt(dist);
+    GUDHI_CHECK(it2 == std::end(p2), "inconsistent point dimensions");
+    using std::sqrt;
+    return sqrt(dist);
+  }
+  template< typename T >
+  T operator() (const std::pair< T, T >& f, const std::pair< T, T >& s) const {
+    T dx = f.first - s.first;
+    T dy = f.second - s.second;
+    using std::sqrt;
+    return sqrt(dx*dx + dy*dy);
+  }
+};
+
+/** @brief Compute the radius of the minimal enclosing ball between Points given by a range of coordinates.
+ * The points are assumed to have the same dimension. */
+class Minimal_enclosing_ball_radius {
+ public:
+  /** \brief Minimal_enclosing_ball_radius from two points.
+   *
+   * @param[in] point_1 First point.
+   * @param[in] point_2 second point.
+   * @return The minimal enclosing ball radius for the two points (aka. Euclidean distance / 2.).
+   *
+   * \tparam Point must be a range of Cartesian coordinates.
+   *
+   */
+  template< typename Point >
+  typename std::iterator_traits<typename boost::range_iterator<Point>::type>::value_type
+  operator()(const Point& point_1, const Point& point_2) const {
+    return Euclidean_distance()(point_1, point_2) / 2.;
+  }
+  /** \brief Minimal_enclosing_ball_radius from a point cloud.
+   *
+   * @param[in] point_cloud The points.
+   * @return The minimal enclosing ball radius for the points.
+   *
+   * \tparam Point_cloud must be a range of points with Cartesian coordinates.
+   * Point_cloud is a range over a range of Coordinate.
+   *
+   */
+  template< typename Point_cloud,
+            typename Point_iterator = typename boost::range_const_iterator<Point_cloud>::type,
+            typename Point = typename std::iterator_traits<Point_iterator>::value_type,
+            typename Coordinate_iterator = typename boost::range_const_iterator<Point>::type,
+            typename Coordinate = typename std::iterator_traits<Coordinate_iterator>::value_type>
+  Coordinate
+  operator()(const Point_cloud& point_cloud) const {
+    using Min_sphere = Miniball::Miniball<Miniball::CoordAccessor<Point_iterator, Coordinate_iterator>>;
+
+    Min_sphere ms(boost::size(*point_cloud.begin()), point_cloud.begin(), point_cloud.end());
+#ifdef DEBUG_TRACES
+    std::cout << "Minimal_enclosing_ball_radius = " << std::sqrt(ms.squared_radius()) << " | nb points = "
+              << boost::size(point_cloud) << " | dimension = "
+              << boost::size(*point_cloud.begin()) << std::endl;
+#endif  // DEBUG_TRACES
+
+    return std::sqrt(ms.squared_radius());
   }
 };
 
diff --git a/src/common/include/gudhi/graph_simplicial_complex.h b/src/common/include/gudhi/graph_simplicial_complex.h
index 5fe7c826..49fe56cc 100644
--- a/src/common/include/gudhi/graph_simplicial_complex.h
+++ b/src/common/include/gudhi/graph_simplicial_complex.h
@@ -4,7 +4,7 @@
  *
  *    Author(s):       Clément Maria
  *
- *    Copyright (C) 2014  INRIA
+ *    Copyright (C) 2014 Inria
  *
  *    This program is free software: you can redistribute it and/or modify
  *    it under the terms of the GNU General Public License as published by
@@ -28,6 +28,9 @@
 #include <utility>  // for pair<>
 #include <vector>
 #include <map>
+#include <tuple>  // for std::tie
+
+namespace Gudhi {
 
 /* Edge tag for Boost PropertyGraph. */
 struct edge_filtration_t {
@@ -39,4 +42,70 @@ struct vertex_filtration_t {
   typedef boost::vertex_property_tag kind;
 };
 
+/** \brief Proximity_graph contains the vertices and edges with their filtration values in order to store the result
+ * of `Gudhi::compute_proximity_graph` function.
+ *
+ * \tparam SimplicialComplexForProximityGraph furnishes `Filtration_value` type definition.
+ *
+ */
+template <typename SimplicialComplexForProximityGraph>
+using Proximity_graph = typename boost::adjacency_list < boost::vecS, boost::vecS, boost::undirectedS
+, boost::property < vertex_filtration_t, typename SimplicialComplexForProximityGraph::Filtration_value >
+, boost::property < edge_filtration_t, typename SimplicialComplexForProximityGraph::Filtration_value >>;
+
+/** \brief Computes the proximity graph of the points.
+ *
+ * If points contains n elements, the proximity graph is the graph with n vertices, and an edge [u,v] iff the
+ * distance function between points u and v is smaller than threshold.
+ *
+ * \tparam ForwardPointRange furnishes `.begin()` and `.end()` methods.
+ *
+ * \tparam Distance furnishes `operator()(const Point& p1, const Point& p2)`, where
+ * `Point` is a point from the `ForwardPointRange`, and that returns a `Filtration_value`.
+ */
+template< typename SimplicialComplexForProximityGraph
+          , typename ForwardPointRange
+          , typename Distance >
+Proximity_graph<SimplicialComplexForProximityGraph> compute_proximity_graph(
+    const ForwardPointRange& points,
+    typename SimplicialComplexForProximityGraph::Filtration_value threshold,
+    Distance distance) {
+  using Vertex_handle = typename SimplicialComplexForProximityGraph::Vertex_handle;
+  using Filtration_value = typename SimplicialComplexForProximityGraph::Filtration_value;
+
+  std::vector<std::pair< Vertex_handle, Vertex_handle >> edges;
+  std::vector< Filtration_value > edges_fil;
+  std::map< Vertex_handle, Filtration_value > vertices;
+
+  Vertex_handle idx_u, idx_v;
+  Filtration_value fil;
+  idx_u = 0;
+  for (auto it_u = points.begin(); it_u != points.end(); ++it_u) {
+    idx_v = idx_u + 1;
+    for (auto it_v = it_u + 1; it_v != points.end(); ++it_v, ++idx_v) {
+      fil = distance(*it_u, *it_v);
+      if (fil <= threshold) {
+        edges.emplace_back(idx_u, idx_v);
+        edges_fil.push_back(fil);
+      }
+    }
+    ++idx_u;
+  }
+
+  // Points are labeled from 0 to idx_u-1
+  Proximity_graph<SimplicialComplexForProximityGraph> skel_graph(edges.begin(), edges.end(), edges_fil.begin(), idx_u);
+
+  auto vertex_prop = boost::get(vertex_filtration_t(), skel_graph);
+
+  typename boost::graph_traits<Proximity_graph<SimplicialComplexForProximityGraph>>::vertex_iterator vi, vi_end;
+  for (std::tie(vi, vi_end) = boost::vertices(skel_graph);
+       vi != vi_end; ++vi) {
+    boost::put(vertex_prop, *vi, 0.);
+  }
+
+  return skel_graph;
+}
+
+}  // namespace Gudhi
+
 #endif  // GRAPH_SIMPLICIAL_COMPLEX_H_
diff --git a/src/common/include/gudhi/random_point_generators.h b/src/common/include/gudhi/random_point_generators.h
index 9df77760..f8107c8b 100644
--- a/src/common/include/gudhi/random_point_generators.h
+++ b/src/common/include/gudhi/random_point_generators.h
@@ -4,7 +4,7 @@
  *
  *    Author(s):       Clement Jamin
  *
- *    Copyright (C) 2016 INRIA
+ *    Copyright (C) 2016 Inria
  *
  *    This program is free software: you can redistribute it and/or modify
  *    it under the terms of the GNU General Public License as published by
@@ -190,7 +190,8 @@ template <typename Kernel, typename OutputIterator>
 static void generate_uniform_points_on_torus_d(const Kernel &k, int dim, std::size_t num_slices,
                                                OutputIterator out,
                                                double radius_noise_percentage = 0.,
-                                               std::vector<typename Kernel::FT> current_point = std::vector<typename Kernel::FT>()) {
+                                               std::vector<typename Kernel::FT> current_point =
+                                                       std::vector<typename Kernel::FT>()) {
   CGAL::Random rng;
   int point_size = static_cast<int>(current_point.size());
   if (point_size == 2 * dim) {
diff --git a/src/common/include/gudhi/reader_utils.h b/src/common/include/gudhi/reader_utils.h
index 90be4fc7..26eeb76d 100644
--- a/src/common/include/gudhi/reader_utils.h
+++ b/src/common/include/gudhi/reader_utils.h
@@ -4,7 +4,7 @@
  *
  *    Author(s):       Clement Maria, Pawel Dlotko, Clement Jamin
  *
- *    Copyright (C) 2014  INRIA
+ *    Copyright (C) 2014 Inria
  *
  *    This program is free software: you can redistribute it and/or modify
  *    it under the terms of the GNU General Public License as published by
diff --git a/src/common/include/gudhi/writing_persistence_to_file.h b/src/common/include/gudhi/writing_persistence_to_file.h
new file mode 100644
index 00000000..34448576
--- /dev/null
+++ b/src/common/include/gudhi/writing_persistence_to_file.h
@@ -0,0 +1,117 @@
+/*    This file is part of the Gudhi Library. The Gudhi library
+ *    (Geometric Understanding in Higher Dimensions) is a generic C++
+ *    library for computational topology.
+ *
+ *    Author(s):       Pawel Dlotko
+ *
+ *    Copyright (C) 2017  Swansea University, UK
+ *
+ *    This program is free software: you can redistribute it and/or modify
+ *    it under the terms of the GNU General Public License as published by
+ *    the Free Software Foundation, either version 3 of the License, or
+ *    (at your option) any later version.
+ *
+ *    This program is distributed in the hope that it will be useful,
+ *    but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *    GNU General Public License for more details.
+ *
+ *    You should have received a copy of the GNU General Public License
+ *    along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef WRITING_PERSISTENCE_TO_FILE_H_
+#define WRITING_PERSISTENCE_TO_FILE_H_
+
+#include <iostream>
+#include <string>
+#include <limits>
+
+namespace Gudhi {
+
+/**
+* This is a class to store persistence intervals. Its main purpose is to
+* exchange data in between different packages and provide unified way
+* of writing a collection of persistence intervals to file.
+**/
+template <typename Filtration_type, typename Coefficient_field>
+class Persistence_interval_common {
+ public:
+  /**
+   * Constructor taking as an input birth and death of the pair.
+  **/
+  Persistence_interval_common(Filtration_type birth, Filtration_type death)
+      : birth_(birth),
+        death_(death),
+        dimension_(std::numeric_limits<unsigned>::max()),
+        arith_element_(std::numeric_limits<Coefficient_field>::max()) {}
+
+  /**
+   * Constructor taking as an input birth, death and dimension of the pair.
+  **/
+  Persistence_interval_common(Filtration_type birth, Filtration_type death, unsigned dim)
+      : birth_(birth), death_(death), dimension_(dim), arith_element_(std::numeric_limits<Coefficient_field>::max()) {}
+
+  /**
+* Constructor taking as an input birth, death, dimension of the pair as well
+* as the number p such that this interval is present over Z_p field.
+**/
+  Persistence_interval_common(Filtration_type birth, Filtration_type death, unsigned dim, Coefficient_field field)
+      : birth_(birth), death_(death), dimension_(dim), arith_element_(field) {}
+
+  /**
+   * Operator to compare two persistence pairs. During the comparision all the
+   * fields: birth, death, dimensiona and arith_element_ are taken into account
+   * and they all have to be equal for two pairs to be equal.
+  **/
+  bool operator==(const Persistence_interval_common& i2) const {
+    return ((this->birth_ == i2.birth_) && (this->death_ == i2.death_) && (this->dimension_ == i2.dimension_) &&
+            (this->arith_element_ == i2.arith_element_));
+  }
+
+  /**
+   * Check if two persistence paris are not equal.
+  **/
+  bool operator!=(const Persistence_interval_common& i2) const { return (!((*this) == i2)); }
+
+  /**
+   * Operator to compare objects of a type Persistence_interval_common.
+   * One intervals is smaller than the other if it has lower persistence.
+   * Note that this operator do not take Arith_element into account when doing comparisions.
+  **/
+  bool operator<(const Persistence_interval_common& i2) const {
+    return fabs(this->death_ - this->birth_) < fabs(i2.death_ - i2.birth_);
+  }
+
+  friend std::ostream& operator<<(std::ostream& out, const Persistence_interval_common& it) {
+    if (it.arith_element_ != std::numeric_limits<Coefficient_field>::max()) {
+      out << it.arith_element_ << "  ";
+    }
+    if (it.dimension_ != std::numeric_limits<unsigned>::max()) {
+      out << it.dimension_ << " ";
+    }
+    out << it.birth_ << " " << it.death_ << " ";
+    return out;
+  }
+
+ private:
+  Filtration_type birth_;
+  Filtration_type death_;
+  unsigned dimension_;
+  Coefficient_field arith_element_;
+};
+
+/**
+ * This function write a vector<Persistence_interval_common> to a stream
+**/
+template <typename Persistence_interval_range>
+void write_persistence_intervals_to_stream(const Persistence_interval_range& intervals,
+                                           std::ostream& out = std::cout) {
+  for (auto interval : intervals) {
+    out << interval << "\n";
+  }
+}
+
+}  // namespace Gudhi
+
+#endif  // WRITING_PERSISTENCE_TO_FILE_H_