GUDHI 2.0.0 as released by upstream in a tarball.upstream/2.0.0

6 files changed, 402 insertions, 182 deletions

diff --git a/concept/Alpha_complex/SimplicialComplexForAlpha.h b/concept/Alpha_complex/SimplicialComplexForAlpha.h
new file mode 100644
index 00000000..2b8bff94
--- /dev/null
+++ b/concept/Alpha_complex/SimplicialComplexForAlpha.h
@@ -0,0 +1,89 @@
+/*    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) 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
+ *    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 CONCEPT_ALPHA_COMPLEX_SIMPLICIAL_COMPLEX_FOR_ALPHA_H_
+#define CONCEPT_ALPHA_COMPLEX_SIMPLICIAL_COMPLEX_FOR_ALPHA_H_
+
+namespace Gudhi {
+
+namespace alpha_complex {
+
+/** \brief The concept SimplicialComplexForAlpha describes the requirements for a type to implement a simplicial
+ * complex, that can be created from a `Alpha_complex`.
+ */
+struct SimplicialComplexForAlpha {
+  /** Handle to specify a simplex. */
+  typedef unspecified Simplex_handle;
+  /** Handle to specify a vertex. Must be a non-negative integer. */
+  typedef unspecified Vertex_handle;
+  /** Handle to specify the simplex filtration value. */
+  typedef unspecified Filtration_value;
+
+  /** Returns the number of vertices in the simplicial complex. */
+  std::size_t num_vertices();
+
+  /** Sets the simplicial complex dimension. */
+  void set_dimension(int dimension);
+
+  /** Gets the 'simplex' dimension. */
+  int dimension(Simplex_handle simplex);
+
+  /** Assigns the 'simplex' with the given 'filtration' value. */
+  int assign_filtration(Simplex_handle simplex, Filtration_value filtration);
+
+  /** \brief Inserts a simplex with vertices from a given simplex (represented by a vector of Vertex_handle) in the
+   * simplicial complex with the given 'filtration' value. */
+  void insert_simplex_and_subfaces(std::vector<Vertex_handle> const & vertex_range, Filtration_value filtration);
+
+  /** Browses the simplicial complex to make the filtration non-decreasing. */
+  void make_filtration_non_decreasing();
+
+  /** Prune the simplicial complex above 'filtration' value given as parameter. */
+  void prune_above_filtration(Filtration_value filtration);
+
+  /** \brief Iterator over vertices of a simplex.
+   *
+   * 'value type' must be 'Vertex_handle'.*/
+  typedef unspecified Simplex_vertex_range;
+
+  /** \brief Returns a range over vertices of a given
+   *  simplex. */
+  Simplex_vertex_range simplex_vertex_range(Simplex_handle const & simplex);
+
+  /** \brief Iterator over the boundaries of the complex, in an arbitrary order.
+   *
+   * 'value_type' must be 'Simplex_handle'.*/
+  typedef unspecified Boundary_simplex_range;
+
+  /** \brief Returns a range over boundaries of a given simplex. */
+  Boundary_simplex_range boundary_simplex_range(Simplex_handle const & simplex);
+
+  /** \brief Return type of an insertion of a simplex
+   */
+  typedef unspecified Insertion_result_type;
+};
+
+}  // namespace alpha_complex
+
+}  // namespace Gudhi
+
+#endif  // CONCEPT_ALPHA_COMPLEX_SIMPLICIAL_COMPLEX_FOR_ALPHA_H_
diff --git a/concept/Bottleneck_distance/Persistence_diagram.h b/concept/Bottleneck_distance/Persistence_diagram.h
new file mode 100644
index 00000000..b157f22a
--- /dev/null
+++ b/concept/Bottleneck_distance/Persistence_diagram.h
@@ -0,0 +1,50 @@
+/*    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:       François Godi
+ *
+ *    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
+ *    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 CONCEPT_BOTTLENECK_DISTANCE_PERSISTENCE_DIAGRAM_H_
+#define CONCEPT_BOTTLENECK_DISTANCE_PERSISTENCE_DIAGRAM_H_
+
+namespace Gudhi {
+
+namespace persistence_diagram {
+
+/** \brief Concept of point in a persistence diagram. std::get<0>(point) must return the birth of the corresponding component and std::get<1>(point) its death.
+ * Both should be convertible to `double`.
+ * A valid implementation of this concept is std::pair<double,double>.
+ * Death should be larger than birth, death can be std::numeric_limits<double>::infinity() for components which stay alive.
+ *
+ * \ingroup bottleneck_distance
+ */
+struct DiagramPoint{};
+
+/** \brief Concept of persistence diagram. It is a range of `DiagramPoint`.
+ * std::begin(diagram) and std::end(diagram) must return corresponding iterators.
+ *
+ * \ingroup bottleneck_distance
+ */
+struct PersistenceDiagram{};
+
+}  // namespace persistence_diagram
+
+}  // namespace Gudhi
+
+#endif  // CONCEPT_BOTTLENECK_DISTANCE_PERSISTENCE_DIAGRAM_H_
diff --git a/concept/Rips_complex/SimplicialComplexForRips.h b/concept/Rips_complex/SimplicialComplexForRips.h
new file mode 100644
index 00000000..7dab0615
--- /dev/null
+++ b/concept/Rips_complex/SimplicialComplexForRips.h
@@ -0,0 +1,54 @@
+/*    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) 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
+ *    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 CONCEPT_RIPS_COMPLEX_SIMPLICIAL_COMPLEX_FOR_RIPS_H_
+#define CONCEPT_RIPS_COMPLEX_SIMPLICIAL_COMPLEX_FOR_RIPS_H_
+
+namespace Gudhi {
+
+namespace rips_complex {
+
+/** \brief The concept SimplicialComplexForRips describes the requirements for a type to implement a simplicial
+ * complex, that can be created from a `Rips_complex`. The only available model for the moment is the `Simplex_tree`.
+ */
+struct SimplicialComplexForRips {
+  /** \brief Type used to store the filtration values of the simplicial complex. */
+  typedef unspecified Filtration_value;
+
+  /** \brief Inserts a given `Gudhi::rips_complex::Rips_complex::OneSkeletonGraph` in the simplicial complex. */
+  template<class OneSkeletonGraph>
+  void insert_graph(const OneSkeletonGraph& skel_graph);
+
+  /** \brief Expands the simplicial complex containing only its one skeleton until a given maximal dimension as
+   * explained in \ref ripsdefinition. */
+  void expansion(int max_dim);
+
+  /** \brief Returns the number of vertices in the simplicial complex. */
+  std::size_t num_vertices();
+
+};
+
+}  // namespace rips_complex
+
+}  // namespace Gudhi
+
+#endif  // CONCEPT_RIPS_COMPLEX_SIMPLICIAL_COMPLEX_FOR_RIPS_H_
diff --git a/concept/Skeleton_blocker/SkeletonBlockerDS.h b/concept/Skeleton_blocker/SkeletonBlockerDS.h
index 3c650f99..d82425a0 100644
--- a/concept/Skeleton_blocker/SkeletonBlockerDS.h
+++ b/concept/Skeleton_blocker/SkeletonBlockerDS.h
@@ -1,128 +1,129 @@
-/*
- * SkeletonBlockerDS.h
+/*    This file is part of the Gudhi Library. The Gudhi library
+ *    (Geometric Understanding in Higher Dimensions) is a generic C++
+ *    library for computational topology.
  *
- *  Created on: Feb 20, 2014 
- *      Author: David Salinas
- *  Copyright 2013 INRIA. All rights reserved
+ *    Author(s):       David Salinas
+ *
+ *    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
+ *    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 GUDHI_SKELETONBLOCKERDS_H_
-#define GUDHI_SKELETONBLOCKERDS_H_
-
+#ifndef CONCEPT_SKELETON_BLOCKER_SKELETONBLOCKERDS_H_
+#define CONCEPT_SKELETON_BLOCKER_SKELETONBLOCKERDS_H_
 
 namespace Gudhi {
 
 namespace skeleton_blocker {
 
-
-
 /** \brief Concept for the template class passed for Skeleton_blocker_complex.
  * Most importantly, it contains the nodes for vertices and edges
  * (Graph_vertex and Graph_edge) that are stored in the simplicial 
  * complex. The user can redefine these classes to attach
  * additional information to vertices and edges.
  */
-struct SkeletonBlockerDS
-{
-	/**
-	 * @brief index that allows to find the vertex in the boost graph
-	 */
-	typedef int boost_vertex_handle;
-
-
-	/**
-	 * @brief Root_vertex_handle and Vertex_handle are similar to global and local vertex descriptor
-	 * used in <a href="http://www.boost.org/doc/libs/1_38_0/libs/graph/doc/subgraph.html">boost subgraphs</a>
-	 * and allow to localize a vertex of a subcomplex on its parent root complex.
-	 *
-	 * In gross, vertices are stored in a vector
-	 * and the Root_vertex_handle and Vertex_handle store indices of a vertex in this vector.
-	 *
-	 * For the root simplicial complex, the Root_vertex_handle and Vertex_handle of a vertex
-	 * are the same.
-	 *
-	 *
-	 * For a subcomplex L of a simplicial complex K, the local descriptor, ie the Vertex_handle, of a
-	 * vertex v (that belongs to L)  is its position in the vector of vertices
-	 * of the subcomplex L whereas its Root_vertex_handle (global descriptor) is the position of v in the vector of the
-	 * vertices of the root simplicial complex K.
-	 */
-	struct Root_vertex_handle{
-
-		boost_vertex_handle vertex;
-
-		friend ostream& operator << (ostream& o, const Root_vertex_handle & v);
-	};
-
-	/**
-	 * A Vertex_handle must be Default Constructible, Assignable and Equality Comparable.
-	 */
-	struct Vertex_handle{
-		boost_vertex_handle vertex;
-
-		friend ostream& operator << (ostream& o, const Vertex_handle & v);
-	};
-
-
-	/**
-	 * \brief The type of vertices that are stored the boost graph.
-	 * A Vertex must be Default Constructible and Equality Comparable.
-	 *
-	 */
-	struct Graph_vertex{
-		/** \brief Used to deactivate a vertex for example when contracting an edge.
-		 * It allows in some cases to remove the vertex at low cost.
-		 */
-		void deactivate();
-
-		/** \brief Used to activate a vertex.
-		 */
-		void activate();
-
-		/** \brief Tells if the vertex is active.
-		 */
-		bool is_active() const;
-
-		void set_id(Root_vertex_handle i);
-		Root_vertex_handle get_id() const;
-		virtual string to_string() const ;
-		friend ostream& operator << (ostream& o, const Graph_vertex & v);
-	};
-
-
-	/**
-	 * \brief The type of edges that are stored the boost graph.
-	 * An Edge must be Default Constructible and Equality Comparable.
-	 */
-	struct Graph_edge{
-		/**
-		 * @brief Allows to modify vertices of the edge.
-		 */
-		void setId(Root_vertex_handle a,Root_vertex_handle b);
-
-		/**
-		 * @brief Returns the first vertex of the edge.
-		 */
-		Root_vertex_handle first() const ;
-
-		/**
-		 * @brief Returns the second vertex of the edge.
-		 */
-		Root_vertex_handle second() const ;
-
-		friend ostream& operator << (ostream& o, const Simple_edge & v);
-	};
-
-
+struct SkeletonBlockerDS {
+  /**
+   * @brief index that allows to find the vertex in the boost graph
+   */
+  typedef int boost_vertex_handle;
+
+  /**
+   * @brief Root_vertex_handle and Vertex_handle are similar to global and local vertex descriptor
+   * used in <a href="http://www.boost.org/doc/libs/1_38_0/libs/graph/doc/subgraph.html">boost subgraphs</a>
+   * and allow to localize a vertex of a subcomplex on its parent root complex.
+   *
+   * In gross, vertices are stored in a vector
+   * and the Root_vertex_handle and Vertex_handle store indices of a vertex in this vector.
+   *
+   * For the root simplicial complex, the Root_vertex_handle and Vertex_handle of a vertex
+   * are the same.
+   *
+   *
+   * For a subcomplex L of a simplicial complex K, the local descriptor, ie the Vertex_handle, of a
+   * vertex v (that belongs to L)  is its position in the vector of vertices
+   * of the subcomplex L whereas its Root_vertex_handle (global descriptor) is the position of v in the vector of the
+   * vertices of the root simplicial complex K.
+   */
+  struct Root_vertex_handle {
+    boost_vertex_handle vertex;
+
+    friend ostream& operator<<(ostream& o, const Root_vertex_handle & v);
+  };
+
+  /**
+   * A Vertex_handle must be Default Constructible, Assignable and Equality Comparable.
+   */
+  struct Vertex_handle {
+    boost_vertex_handle vertex;
+
+    friend ostream& operator<<(ostream& o, const Vertex_handle & v);
+  };
+
+  /**
+   * \brief The type of vertices that are stored the boost graph.
+   * A Vertex must be Default Constructible and Equality Comparable.
+   *
+   */
+  struct Graph_vertex {
+    /** \brief Used to deactivate a vertex for example when contracting an edge.
+     * It allows in some cases to remove the vertex at low cost.
+     */
+    void deactivate();
+
+    /** \brief Used to activate a vertex.
+     */
+    void activate();
+
+    /** \brief Tells if the vertex is active.
+     */
+    bool is_active() const;
+
+    void set_id(Root_vertex_handle i);
+    Root_vertex_handle get_id() const;
+    virtual string to_string() const;
+    friend ostream& operator<<(ostream& o, const Graph_vertex & v);
+  };
+
+  /**
+   * \brief The type of edges that are stored the boost graph.
+   * An Edge must be Default Constructible and Equality Comparable.
+   */
+  struct Graph_edge {
+    /**
+     * @brief Allows to modify vertices of the edge.
+     */
+    void setId(Root_vertex_handle a, Root_vertex_handle b);
+
+    /**
+     * @brief Returns the first vertex of the edge.
+     */
+    Root_vertex_handle first() const;
+
+    /**
+     * @brief Returns the second vertex of the edge.
+     */
+    Root_vertex_handle second() const;
+
+    friend ostream& operator<<(ostream& o, const Simple_edge & v);
+  };
 };
 
-
-
 }  // namespace skeleton_blocker
 
 namespace skbl = skeleton_blocker;
 
 }  // namespace Gudhi
 
-
-#endif /* GUDHI_SKELETONBLOCKERDS_H_ */
+#endif  // CONCEPT_SKELETON_BLOCKER_SKELETONBLOCKERDS_H_
diff --git a/concept/Skeleton_blocker/SkeletonBlockerGeometricDS.h b/concept/Skeleton_blocker/SkeletonBlockerGeometricDS.h
index c5d52800..477464c4 100644
--- a/concept/Skeleton_blocker/SkeletonBlockerGeometricDS.h
+++ b/concept/Skeleton_blocker/SkeletonBlockerGeometricDS.h
@@ -1,13 +1,27 @@
-/*
- * SkeletonBlockerGeometricDS.h
+/*    This file is part of the Gudhi Library. The Gudhi library
+ *    (Geometric Understanding in Higher Dimensions) is a generic C++
+ *    library for computational topology.
  *
- *  Created on: Feb 20, 2014 
- *      Author: David Salinas
- *  Copyright 2013 INRIA. All rights reserved
+ *    Author(s):       David Salinas
+ *
+ *    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
+ *    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 GUDHI_SKELETONBLOCKERGEOMETRICDS_H_
-#define GUDHI_SKELETONBLOCKERGEOMETRICDS_H_
+#ifndef CONCEPT_SKELETON_BLOCKER_SKELETONBLOCKERGEOMETRICDS_H_
+#define CONCEPT_SKELETON_BLOCKER_SKELETONBLOCKERGEOMETRICDS_H_
 
 namespace Gudhi {
 namespace skeleton_blocker {
@@ -20,52 +34,51 @@ namespace skeleton_blocker {
  * Graph_edge must specify how to access to an index.
  * 
  */
- //todo the index is just for contraction, to remove
-template<typename GeometryTrait>
-struct SkeletonBlockerGeometricDS : public SkeletonBlockerDS
-{
+// TODO(DS): the index is just for contraction, to remove
 
-	/**
-	 * Geometry information.
-	 */
-	typedef GeometryTrait GT ;
+template<typename GeometryTrait>
+struct SkeletonBlockerGeometricDS : public SkeletonBlockerDS {
+  /**
+   * Geometry information.
+   */
+  typedef GeometryTrait GT;
 
-	/**
-	 * Type of point (should be the same as GT::Point).
-	 */
-	typedef typename GeometryTrait::Point Point;
+  /**
+   * Type of point (should be the same as GT::Point).
+   */
+  typedef typename GeometryTrait::Point Point;
 
-	/**
-	 * @brief Vertex that stores a point.
-	 */
-	class Graph_vertex : public SkeletonBlockerDS::Graph_vertex{
-	public:
-		/**
-		 * @brief Access to the point.
-		 */
-		Point& point();
-		/**
-		 * @brief Access to the point.
-		 */
-		const Point& point();
-	};
+  /**
+   * @brief Vertex that stores a point.
+   */
+  class Graph_vertex : public SkeletonBlockerDS::Graph_vertex {
+   public:
+    /**
+     * @brief Access to the point.
+     */
+    Point& point();
+    /**
+     * @brief Access to the point.
+     */
+    const Point& point();
+  };
 
-	/**
-	 * @brief Edge that allows to access to an index.
-	 * The indices of the edges are used to store heap information
-	 * in the edge contraction algorithm.
-	 */
-	class Graph_Edge : public SkeletonBlockerDS::Graph_edge{
-	public:
-		/**
-		 * @brief Access to the index.
-		 */
-		int& index();
-		/**
-		 * @brief Access to the index.
-		 */
-		int index();
-	};
+  /**
+   * @brief Edge that allows to access to an index.
+   * The indices of the edges are used to store heap information
+   * in the edge contraction algorithm.
+   */
+  class Graph_Edge : public SkeletonBlockerDS::Graph_edge {
+   public:
+    /**
+     * @brief Access to the index.
+     */
+    int& index();
+    /**
+     * @brief Access to the index.
+     */
+    int index();
+  };
 };
 
 }  // namespace skeleton_blocker
@@ -74,4 +87,4 @@ namespace skbl = skeleton_blocker;
 
 }  // namespace Gudhi
 
-#endif /* GUDHI_SKELETONBLOCKERGEOMETRICDS_H_ */
+#endif  // CONCEPT_SKELETON_BLOCKER_SKELETONBLOCKERGEOMETRICDS_H_
diff --git a/concept/Witness_complex/Simplicial_complex_for_witness.h b/concept/Witness_complex/SimplicialComplexForWitness.h
index caaf0db6..d78cc83f 100644
--- a/concept/Witness_complex/Simplicial_complex_for_witness.h
+++ b/concept/Witness_complex/SimplicialComplexForWitness.h
@@ -27,57 +27,70 @@ namespace Gudhi {
 
 namespace witness_complex {
 
-/** \brief The concept Simplicial_Complex describes the requirements 
+/** \brief The concept SimplicialComplexForWitness describes the requirements 
  * for a type to implement a simplicial complex, 
- * used for example to build a 'Witness_complex'. 
+ * used for example to build a Witness_complex or Strong_witness_complex. 
  */
 struct SimplicialComplexForWitness {
   /** Handle to specify a simplex. */
   typedef unspecified Simplex_handle;
-  /** Handle to specify a vertex. Must be a non-negative integer. */
-  typedef unspecified Vertex_handle;
+  // /** Handle to specify a vertex. Must be a non-negative integer. */
+  // typedef unspecified Vertex_handle;
 
-  /** Returns a Simplex_hanlde that is different from all simplex handles 
+  /** \brief Returns a Simplex_hanlde that is different from all simplex handles 
    * of the simplices. */
   Simplex_handle null_simplex();
 
-  /** \brief Iterator over the simplices of the complex,
-   * in an arbitrary order.
-   *
-   * 'value_type' must be 'Simplex_handle'.*/
-  typedef unspecified Complex_simplex_range;
-
-  /**
-   * \brief Returns a range over all the simplices of a
-   * complex.
+  /** Returns the number of vertices in the simplicial complex
    */
-  Complex_simplex_range complex_simplex_range();
-
-  /** \brief Iterator over vertices of a simplex.
-   *
-   * 'value type' must be 'Vertex_handle'.*/
-  typedef unspecified Simplex_vertex_range;
-
-  /** \brief Returns a range over vertices of a given
-   *  simplex. */
-  Simplex_vertex_range simplex_vertex_range(Simplex_handle const & simplex);
-
+  std::size_t num_vertices();
+  
   /** \brief Return type of an insertion of a simplex
    */
   typedef unspecified Insertion_result_type;
 
   /** \brief Inserts a simplex with vertices from a given range
    *  'vertex_range' in the simplicial complex.
+   *  The function is only used in Witness_complex class
+   *  and by construction, it is not necessary to check if 
+   *  the faces are in the simplicial complex before insertion. 
+   *  The simplex is given the filtration value 'filtration'.
+   *  Filtration_value should be convertible from double.
+   *  The return type is not used.
    *  */
   template< typedef Input_vertex_range >
-  Insertion_result_type insert_simplex(Input_vertex_range const & vertex_range);
+  Insertion_result_type insert_simplex(Input_vertex_range const & vertex_range, Filtration_value filtration);
 
+  /** \brief Inserts a simplex and all its faces
+   *  with vertices from a given range
+   *  'vertex_range' in the simplicial complex.
+   *  The function is only used in Strong_witness_complex class.
+   *  All inserted simplices are given the filtration
+   *  value 'filtration'.
+   *  Filtration_value should be convertible from double.
+   *  The return type is not used.
+   */
+
+  template< typedef Input_vertex_range,
+            typedef Filtration_value>
+  Insertion_result_type insert_simplex_and_subfaces(Input_vertex_range const & vertex_range, Filtration_value filtration);
+  
   /** \brief Finds a simplex with vertices given by a range
    *
    * If a simplex exists, its Simplex_handle is returned.
    * Otherwise null_simplex() is returned. */
   template< typedef Input_vertex_range >
   Simplex_handle find(Input_vertex_range const & vertex_range);
+
+  /** \brief Sets the dimension of the simplicial complex to 
+   * 'dimension'.
+   */
+  void set_dimension(int dimension);
+
+  /** \brief Returns the filtration of the simplex given by
+   *  the simplex handle 'sh'.
+   */
+  double filtration(Simplex_handle sh);
 };
 
 }  // namespace witness_complex