clang format all sources

git-svn-id: svn+ssh://scm.gforge.inria.fr/svnroot/gudhi/branches/persistence_representation_integration@2477 636b058d-ea47-450e-bf9e-a15bfbe3eedb Former-commit-id: 326d664483d6700f82be824f79a0bf5c082b4945
author: vrouvrea <vrouvrea@636b058d-ea47-450e-bf9e-a15bfbe3eedb> 2017-05-30 15:52:00 +0000
committer: vrouvrea <vrouvrea@636b058d-ea47-450e-bf9e-a15bfbe3eedb> 2017-05-30 15:52:00 +0000
commit: 9d1a526de85694b5f075bb88dbd7097a40abf10a (patch)
tree: bbcd0cef32610d2f5e9c0209b48c58f73fbf379a
parent: 2bcb3d7cb47ce71803f2464cc822346ed2e1b039 (diff)
57 files changed, 7594 insertions, 8709 deletions
diff --git a/src/Persistence_representations/concept/Real_valued_topological_data.h b/src/Persistence_representations/concept/Real_valued_topological_data.h
index 5a15c769..e60f28ac 100644
--- a/src/Persistence_representations/concept/Real_valued_topological_data.h
+++ b/src/Persistence_representations/concept/Real_valued_topological_data.h
@@ -27,23 +27,21 @@ namespace Gudhi {
 
 namespace Persistence_representations {
 
-
-/** \brief The concept Real_valued_topological_data describes the requirements 
-  * for a type to implement a container that allows computations of its projections to R. 
+/** \brief The concept Real_valued_topological_data describes the requirements
+  * for a type to implement a container that allows computations of its projections to R.
   */
-class Real_valued_topological_data
-{
-public:
-	/**
-   * Typically there are various ways data can be projected to R. This function gives us the number of functions for
-   * vectorization provided by a given class.
-	**/ 
-	 size_t number_of_projections_to_R();
-	   /**
-     * This is a function to compute the projection from this container to reals. The parameter of a function have to
-     * be between 0 and the value returned by number_of_projections_to_R().
-    **/ 
-     double project_to_R( size_t number_of_projection );
+class Real_valued_topological_data {
+ public:
+  /**
+* Typically there are various ways data can be projected to R. This function gives us the number of functions for
+* vectorization provided by a given class.
+  **/
+  size_t number_of_projections_to_R();
+  /**
+* This is a function to compute the projection from this container to reals. The parameter of a function have to
+* be between 0 and the value returned by number_of_projections_to_R().
+**/
+  double project_to_R(size_t number_of_projection);
 };
 
 }  // namespace Persistence_representations
diff --git a/src/Persistence_representations/concept/Topological_data_with_averages.h b/src/Persistence_representations/concept/Topological_data_with_averages.h
index 0501c306..2b6d46c4 100644
--- a/src/Persistence_representations/concept/Topological_data_with_averages.h
+++ b/src/Persistence_representations/concept/Topological_data_with_averages.h
@@ -28,14 +28,13 @@ namespace Gudhi {
 
 namespace Persistence_representations {
 
-/** \brief The concept Topological_data_with_averages describes the requirements 
-  * for a type to implement a container that allows computations of averages. 
-  * Note that the average object after being computed is stored in *this. 
+/** \brief The concept Topological_data_with_averages describes the requirements
+  * for a type to implement a container that allows computations of averages.
+  * Note that the average object after being computed is stored in *this.
   */
-class Topological_data_with_averages 
-{
-public:
-    void compute_average( const std::vector< Topological_data_with_averages* >& to_average ); 
+class Topological_data_with_averages {
+ public:
+  void compute_average(const std::vector<Topological_data_with_averages*>& to_average);
 };
 
 }  // namespace Persistence_representations
diff --git a/src/Persistence_representations/concept/Topological_data_with_distances.h b/src/Persistence_representations/concept/Topological_data_with_distances.h
index 2e6de729..c2078403 100644
--- a/src/Persistence_representations/concept/Topological_data_with_distances.h
+++ b/src/Persistence_representations/concept/Topological_data_with_distances.h
@@ -27,21 +27,19 @@ namespace Gudhi {
 
 namespace Persistence_representations {
 
-
-/** \brief The concept Topological_data_with_distances describes the requirements 
+/** \brief The concept Topological_data_with_distances describes the requirements
   * for a type to implement a container that allows computations of distance to another contained of that type.
   * \details
-  * The second parameter of the distance function allow to declare power of a distance. The exact meaning of that 
+  * The second parameter of the distance function allow to declare power of a distance. The exact meaning of that
   * number will be different for different distances. A few examples are given below:
   * In case of p-Wasserstein distance, the power is equal to p. power = std::limit<double>::max() for bottleneck
   * distance.
   *
   * In case of L^p landscape distance, the power is equal to p. s
   */
-class Topological_data_with_distances
-{
-public:
-    double distance( const Topological_data_with_distances& second , double power = 1);    
+class Topological_data_with_distances {
+ public:
+  double distance(const Topological_data_with_distances& second, double power = 1);
 };
 
 }  // namespace Persistence_representations
diff --git a/src/Persistence_representations/concept/Topological_data_with_scalar_product.h b/src/Persistence_representations/concept/Topological_data_with_scalar_product.h
index 203a1d91..a0677fb2 100644
--- a/src/Persistence_representations/concept/Topological_data_with_scalar_product.h
+++ b/src/Persistence_representations/concept/Topological_data_with_scalar_product.h
@@ -27,14 +27,12 @@ namespace Gudhi {
 
 namespace Persistence_representations {
 
-
-/** \brief The concept Topological_data_with_scalar_product describes the requirements 
-  * for a type to implement a container that allows computations of scalar products. 
+/** \brief The concept Topological_data_with_scalar_product describes the requirements
+  * for a type to implement a container that allows computations of scalar products.
   */
-class Topological_data_with_scalar_product
-{
-public:  
-    double compute_scalar_product( const Topological_data_with_scalar_product& second );    
+class Topological_data_with_scalar_product {
+ public:
+  double compute_scalar_product(const Topological_data_with_scalar_product& second);
 };
 
 }  // namespace Persistence_representations
diff --git a/src/Persistence_representations/concept/Vectorized_topological_data.h b/src/Persistence_representations/concept/Vectorized_topological_data.h
index 8d4105a2..0d4591d1 100644
--- a/src/Persistence_representations/concept/Vectorized_topological_data.h
+++ b/src/Persistence_representations/concept/Vectorized_topological_data.h
@@ -27,20 +27,21 @@ namespace Gudhi {
 
 namespace Persistence_representations {
 
-/** \brief The concept Vectorized_topological_data describes the requirements 
-  * for a type to implement a container that allows vectorization. 
+/** \brief The concept Vectorized_topological_data describes the requirements
+  * for a type to implement a container that allows vectorization.
   */
-class Vectorized_topological_data  	
-{
-public:
-	/**
-	 * There are various ways data can be vectorized. This function give us the number of functions for vectorization provided by a given class. 
-	**/ 
-    size_t number_of_vectorize_functions();
-    /**
-     * This is a function to vectorize given container. The parameter of a function have to be between 0 and the value returned by number_of_vectorize_functions().
-    **/ 
-    std::vector<double> vectorize( int number_of_function );    
+class Vectorized_topological_data {
+ public:
+  /**
+   * There are various ways data can be vectorized. This function give us the number of functions for vectorization
+   *provided by a given class.
+  **/
+  size_t number_of_vectorize_functions();
+  /**
+   * This is a function to vectorize given container. The parameter of a function have to be between 0 and the value
+   *returned by number_of_vectorize_functions().
+  **/
+  std::vector<double> vectorize(int number_of_function);
 };
 
 }  // namespace Persistence_representations
diff --git a/src/Persistence_representations/doc/Persistence_representations_doc.h b/src/Persistence_representations/doc/Persistence_representations_doc.h
index bc11d2c4..60b9d6da 100644
--- a/src/Persistence_representations/doc/Persistence_representations_doc.h
+++ b/src/Persistence_representations/doc/Persistence_representations_doc.h
@@ -20,7 +20,6 @@
  *    along with this program.  If not, see <http://www.gnu.org/licenses/>.
  */
 
-
 #ifndef DOC_GUDHI_STAT_H_
 #define DOC_GUDHI_STAT_H_
 
@@ -35,24 +34,34 @@ namespace Persistence_representations {
  * @{
  *\section Persistence_representations_idea Idea
 
- *In order to perform most of the statistical tests and machine learning algorithms on a data one need to be able to perform only a very limited number of operations on them. Let us fix a representation of 
- * data of a type A. To perform most of the statistical and machine learning operations one need to be able to compute average of objects of type A (so that the averaged object is also of a type A), to 
- * compute distance between objects of a type A, to vectorize object of a type A and to compute scalar product of a pair objects of a type A.
- *
- *To put this statement into a context, let us assume we have two collections \f$ c_1,\ldots,c_n\f$ and \f$d_1,...,d_n\f$ of objects of a type A. We want to verify if the average of those two collections 
+ *In order to perform most of the statistical tests and machine learning algorithms on a data one need to be able to
+ perform only a very limited number of operations on them. Let us fix a representation of
+ * data of a type A. To perform most of the statistical and machine learning operations one need to be able to compute
+ average of objects of type A (so that the averaged object is also of a type A), to
+ * compute distance between objects of a type A, to vectorize object of a type A and to compute scalar product of a pair
+ objects of a type A.
+ *
+ *To put this statement into a context, let us assume we have two collections \f$ c_1,\ldots,c_n\f$ and
+ \f$d_1,...,d_n\f$ of objects of a type A. We want to verify if the average of those two collections
  * are different by performing a permutation test.
- *First of all, we compute averages of those two collections: C average of \f$ c_1,\ldots,c_n \f$ and D average of \f$d_1,\ldots,d_n\f$. Note that both C and D are of a type A. Then we compute \f$d(C,D)\f$, 
+ *First of all, we compute averages of those two collections: C average of \f$ c_1,\ldots,c_n \f$ and D average of
+ \f$d_1,\ldots,d_n\f$. Note that both C and D are of a type A. Then we compute \f$d(C,D)\f$,
  * a distance between C and D.
  *Later we put the two collections into one bin:
  *\f[B = \{ c_1,...,c_n,d_1,...,d_n \}\f]
- *Then we shuffle B, and we divide the shuffled version of B into two classes: \f$B_1\f$ and \f$B_2\f$ (in this case, of the same cardinality). Then we compute averages \f$\hat{B_1}\f$ and \f$\hat{B_2}\f$ 
- * of elements in \f$B_1\f$ and \f$B_2\f$. Note that again, \f$\hat{B_1}\f$ and \f$\hat{B_2}\f$ are of a type A. 
- *Then we compute their distance \f$d(\hat{B_1},\hat{B_2})\f$. The procedure of shuffling and dividing the set \f$B\f$ is repeated \f$N\f$ times (where \f$N\f$ is reasonably large number).
- *Then the p-value of a statement that the averages of  \f$c_1,...,c_n\f$ and \f$d_1,...,d_n\f$ is approximated by the number of times \f$d(\hat{B_1},\hat{B_2}) > d(C,D)\f$ divided by \f$N\f$.
+ *Then we shuffle B, and we divide the shuffled version of B into two classes: \f$B_1\f$ and \f$B_2\f$ (in this case, of
+ the same cardinality). Then we compute averages \f$\hat{B_1}\f$ and \f$\hat{B_2}\f$
+ * of elements in \f$B_1\f$ and \f$B_2\f$. Note that again, \f$\hat{B_1}\f$ and \f$\hat{B_2}\f$ are of a type A.
+ *Then we compute their distance \f$d(\hat{B_1},\hat{B_2})\f$. The procedure of shuffling and dividing the set \f$B\f$
+ is repeated \f$N\f$ times (where \f$N\f$ is reasonably large number).
+ *Then the p-value of a statement that the averages of  \f$c_1,...,c_n\f$ and \f$d_1,...,d_n\f$ is approximated by the
+ number of times \f$d(\hat{B_1},\hat{B_2}) > d(C,D)\f$ divided by \f$N\f$.
  *
- *The permutation test reminded above can be performed for any type A which can be averaged, and which allows for computations of distances. 
+ *The permutation test reminded above can be performed for any type A which can be averaged, and which allows for
+ computations of distances.
  *
- *The Persistence\_representations contains a collection of various representations of persistent homology that implements various concepts described below:
+ *The Persistence\_representations contains a collection of various representations of persistent homology that
+ implements various concepts described below:
  *
  *\li Concept of a representation of persistence that allows averaging (so that the average object is of the same type).
  *\li Concept of representation of persistence that allows computations of distances.
@@ -61,28 +70,38 @@ namespace Persistence_representations {
  *\li Concept of representation of persistence that allows computations of real--valued characteristics of objects.
  *
  *
- *At the moment an implementation of the following representations of persistence are available (further details of those representations will be discussed later):
+ *At the moment an implementation of the following representations of persistence are available (further details of
+ those representations will be discussed later):
  *
- *\li Exact persistence landscapes (allow averaging, computation of distances, scalar products, vectorizations and real value characteristics).
- *\li Persistence landscapes on a grid (allow averaging, computation of distances scalar products, vectorizations and real value characteristics).
- *\li Persistence heat maps – various representations where one put some weighted or not Gaussian kernel for each point of diagram (allow averaging, computation of distances, scalar products, 
+ *\li Exact persistence landscapes (allow averaging, computation of distances, scalar products, vectorizations and real
+ value characteristics).
+ *\li Persistence landscapes on a grid (allow averaging, computation of distances scalar products, vectorizations and
+ real value characteristics).
+ *\li Persistence heat maps – various representations where one put some weighted or not Gaussian kernel for each point
+ of diagram (allow averaging, computation of distances, scalar products,
  * vectorizations and real value characteristics).
- *\li Persistence vectors (allow averaging, computation of distances, scalar products, vectorizations and real value characteristics).
+ *\li Persistence vectors (allow averaging, computation of distances, scalar products, vectorizations and real value
+ characteristics).
  *\li Persistence diagrams / barcodes (allow computation of distances, vectorizations and real value characteristics).
  *
  *
- * Note that at the while functionalities like averaging, distances and scalar products are fixed, there is no canonical way of vectorizing and computing real valued characteristics of objects. Therefore the
- * vectorizations and computation of real value characteristics procedures are quite likely to evolve in the furthering versions of the library. 
+ * Note that at the while functionalities like averaging, distances and scalar products are fixed, there is no canonical
+ way of vectorizing and computing real valued characteristics of objects. Therefore the
+ * vectorizations and computation of real value characteristics procedures are quite likely to evolve in the furthering
+ versions of the library.
  *
- * The main aim of this implementation is to be able to implement various statistical methods, both on the level of C++ and on the level of python. The methods will operate on the functionalities offered
- * by concepts. That means that the statistical and ML methods will be able to operate on any representation that implement the required concept (including the ones that are not in the library at the moment). 
+ * The main aim of this implementation is to be able to implement various statistical methods, both on the level of C++
+ and on the level of python. The methods will operate on the functionalities offered
+ * by concepts. That means that the statistical and ML methods will be able to operate on any representation that
+ implement the required concept (including the ones that are not in the library at the moment).
  * That gives provides a framework, that is very easy to extend, for topological statistics.
  *
  * Below we are discussing the representations which are currently implemented in Persistence\_representations package:
  *
  * \section sec_persistence_landscapes Persistence Landscapes
  * <b>Reference manual:</b> \ref Gudhi::Persistence_representations::Persistence_landscape <br>
- * Persistence landscapes were originally proposed by Bubenik in \cite bubenik_landscapes_2015. Efficient algorithms to compute them rigorously were proposed by Bubenik and Dlotko in \cite bubenik_dlotko_landscapes_2016. The idea of
+ * Persistence landscapes were originally proposed by Bubenik in \cite bubenik_landscapes_2015. Efficient algorithms to
+ compute them rigorously were proposed by Bubenik and Dlotko in \cite bubenik_dlotko_landscapes_2016. The idea of
  * persistence landscapes is shortly summarized in below.
  *
  * To begin with, suppose we are given a point \f$(b,d) \in \mathbb{R}^2\f$ in a
@@ -102,47 +121,67 @@ namespace Persistence_representations {
  *
  * A persistence landscape of the birth-death
  * pairs \f$(b_i , d_i)\f$, where \f$i = 1,\ldots,m\f$, which constitute the given
- * persistence diagram is the sequence of functions \f$\lambda_k : \mathbb{R} \rightarrow [0,\infty)\f$ for \f$k \in \mathbb{N}\f$, where \f$\lambda_k(x)\f$
+ * persistence diagram is the sequence of functions \f$\lambda_k : \mathbb{R} \rightarrow [0,\infty)\f$ for \f$k \in
+ \mathbb{N}\f$, where \f$\lambda_k(x)\f$
  * denotes the \f$k^{\rm th}\f$ largest value of the numbers \f$f_{(b_i,d_i)}(x)\f$,
  * for \f$i = 1, \ldots, m\f$, and we define \f$\lambda_k(x) = 0\f$ if \f$k > m\f$.
  * Equivalently, this sequence of functions can be combined into a single
  * function \f$L : \mathbb{N} \times \mathbb{R} \to [0,\infty)\f$ of two
  * variables, if we define \f$L(k,t) = \lambda_k(t)\f$.
  *
- * The detailed description of algorithms used to compute persistence landscapes can be found in \cite bubenik_dlotko_landscapes_2016.
- * Note that this implementation provides exact representation of landscapes. That have many advantages, but also a few drawbacks. For instance, as discussed 
- * in \cite bubenik_dlotko_landscapes_2016, the exact representation of landscape may be of quadratic size with respect to the input persistence diagram. It may therefore happen 
- * that, for very large diagrams, using this representation may be memory--prohibitive. In such a case, there are two possible ways to proceed:
+ * The detailed description of algorithms used to compute persistence landscapes can be found in \cite
+ bubenik_dlotko_landscapes_2016.
+ * Note that this implementation provides exact representation of landscapes. That have many advantages, but also a few
+ drawbacks. For instance, as discussed
+ * in \cite bubenik_dlotko_landscapes_2016, the exact representation of landscape may be of quadratic size with respect
+ to the input persistence diagram. It may therefore happen
+ * that, for very large diagrams, using this representation may be memory--prohibitive. In such a case, there are two
+ possible ways to proceed:
  *
  *\li Use non exact representation on a grid described in the Section \ref sec_landscapes_on_grid.
- *\li Compute just a number of initial nonzero landscapes. This option is available from C++ level. 
- *
- * 
- * 
- *\section sec_landscapes_on_grid Persistence Landscapes on a grid
- * <b>Reference manual:</b> \ref Gudhi::Persistence_representations::Persistence_landscape_on_grid <br>
- * This is an alternative, not--exact, representation of persistence landscapes defined in the Section \ref sec_persistence_landscapes. Unlike in the Section \ref sec_persistence_landscapes we build a
- * representation of persistence landscape by sampling its values on a finite, equally distributed grid of points. 
- * Since, the persistence landscapes that originate from persistence diagrams have slope \f$1\f$ or \f$-1\f$, we have an estimate of a region between the grid points where the landscape cab be located. 
- * That allows to estimate an error make when performing various operations on landscape. Note that for average landscapes the slope is in range \f$[-1,1]\f$ and similar estimate can be used. 
+ *\li Compute just a number of initial nonzero landscapes. This option is available from C++ level.
  *
- * Due to a lack of rigorous description of the algorithms to deal with this non--rigorous representation of persistence landscapes in the literature, we are providing a short discussion of them in below.
  *
- *Let us assume that we want to compute persistence landscape on a interval \f$[x,y]\f$. Let us assume that we want to use \f$N\f$ grid points for that purpose. 
- * Then we will sample the persistence landscape on points \f$x_1 = x , x_2 = x + \frac{y-x}{N}, \ldots , x_{N} = y\f$. Persistence landscapes are represented as a vector of 
- * vectors of real numbers. Assume that i-th vector consist of \f$n_i\f$ numbers sorted from larger to smaller. They represent the values of the functions 
- \f$\lambda_1,\ldots,\lambda_{n_i}\f$ ,\f$\lambda_{n_i+1}\f$ and the functions with larger indices are then zero functions) on the i-th point of a grid, i.e. \f$x + i \frac{y-x}{N}\f$. 
  *
- *When averaging two persistence landscapes represented by a grid we need to make sure that they are defined in a compatible grids. I.e. the intervals \f$[x,y]\f$ on which they are defined are 
- * the same, and the numbers of grid points \f$N\f$ are the same in both cases. If this is the case, we simply compute point-wise averages of the entries of corresponding 
- * vectors (In this whole section we assume that if one vector of numbers is shorter than another, we extend the shorter one with zeros so that they have the same length.)
- *
- *Computations of distances between two persistence landscapes on a grid is not much different than in the rigorous case. In this case, we sum up the distances between the same levels of
- * corresponding landscapes. For fixed level, we approximate the landscapes between the corresponding constitutive points of landscapes by linear functions, and compute the \f$L^p\f$ distance between them.
- *
- *Similarly as in case of distance, when computing the scalar product of two persistence landscapes on a grid, we sum up the scalar products of corresponding levels of landscapes. For each level, 
- * we assume that the persistence landscape on a grid between two grid points is approximated by linear function. Therefore to compute scalar product of two corresponding levels of landscapes, 
- * we sum up the integrals of products of line segments for every pair of constitutive grid points. 
+ *\section sec_landscapes_on_grid Persistence Landscapes on a grid
+ * <b>Reference manual:</b> \ref Gudhi::Persistence_representations::Persistence_landscape_on_grid <br>
+ * This is an alternative, not--exact, representation of persistence landscapes defined in the Section \ref
+ sec_persistence_landscapes. Unlike in the Section \ref sec_persistence_landscapes we build a
+ * representation of persistence landscape by sampling its values on a finite, equally distributed grid of points.
+ * Since, the persistence landscapes that originate from persistence diagrams have slope \f$1\f$ or \f$-1\f$, we have an
+ estimate of a region between the grid points where the landscape cab be located.
+ * That allows to estimate an error make when performing various operations on landscape. Note that for average
+ landscapes the slope is in range \f$[-1,1]\f$ and similar estimate can be used.
+ *
+ * Due to a lack of rigorous description of the algorithms to deal with this non--rigorous representation of persistence
+ landscapes in the literature, we are providing a short discussion of them in below.
+ *
+ *Let us assume that we want to compute persistence landscape on a interval \f$[x,y]\f$. Let us assume that we want to
+ use \f$N\f$ grid points for that purpose.
+ * Then we will sample the persistence landscape on points \f$x_1 = x , x_2 = x + \frac{y-x}{N}, \ldots , x_{N} = y\f$.
+ Persistence landscapes are represented as a vector of
+ * vectors of real numbers. Assume that i-th vector consist of \f$n_i\f$ numbers sorted from larger to smaller. They
+ represent the values of the functions
+ \f$\lambda_1,\ldots,\lambda_{n_i}\f$ ,\f$\lambda_{n_i+1}\f$ and the functions with larger indices are then zero
+ functions) on the i-th point of a grid, i.e. \f$x + i \frac{y-x}{N}\f$.
+ *
+ *When averaging two persistence landscapes represented by a grid we need to make sure that they are defined in a
+ compatible grids. I.e. the intervals \f$[x,y]\f$ on which they are defined are
+ * the same, and the numbers of grid points \f$N\f$ are the same in both cases. If this is the case, we simply compute
+ point-wise averages of the entries of corresponding
+ * vectors (In this whole section we assume that if one vector of numbers is shorter than another, we extend the shorter
+ one with zeros so that they have the same length.)
+ *
+ *Computations of distances between two persistence landscapes on a grid is not much different than in the rigorous
+ case. In this case, we sum up the distances between the same levels of
+ * corresponding landscapes. For fixed level, we approximate the landscapes between the corresponding constitutive
+ points of landscapes by linear functions, and compute the \f$L^p\f$ distance between them.
+ *
+ *Similarly as in case of distance, when computing the scalar product of two persistence landscapes on a grid, we sum up
+ the scalar products of corresponding levels of landscapes. For each level,
+ * we assume that the persistence landscape on a grid between two grid points is approximated by linear function.
+ Therefore to compute scalar product of two corresponding levels of landscapes,
+ * we sum up the integrals of products of line segments for every pair of constitutive grid points.
  *
  *Note that for this representation we need to specify a few parameters:
  *
@@ -154,43 +193,62 @@ namespace Persistence_representations {
  *
  *\section sec_persistence_heat_maps Persistence heat maps
  * <b>Reference manual:</b> \ref Gudhi::Persistence_representations::Persistence_heat_maps <br>
- *This is a general class of discrete structures which are based on idea of placing a kernel in the points of persistence diagrams. 
- *This idea appeared in work by many authors over the last 15 years. As far as we know this idea was firstly described in the work of Bologna group in \cite Ferri_Frosini_comparision_sheme_1 and \cite Ferri_Frosini_comparision_sheme_2. 
- *Later it has been described by Colorado State University group in \cite Persistence_Images_2017. The presented paper in the first time provide a discussion of stability of the representation. 
- *Also, the same ideas are used in construction of two recent kernels used for machine learning: \cite Kusano_Fukumizu_Hiraoka_PWGK and \cite Reininghaus_Huber_ALL_PSSK. Both the kernel's construction uses interesting ideas to 
- *ensure stability of the representation with respect to Wasserstein metric. In the kernel presented in \cite Kusano_Fukumizu_Hiraoka_PWGK, a scaling function is used to multiply the Gaussian kernel in the 
- *way that the points close to diagonal got low weight and consequently do not have a big influence on the resulting distribution. In \cite Reininghaus_Huber_ALL_PSSK for every point \f$(b,d)\f$ two Gaussian kernels 
- *are added: first, with a weight 1 in a point \f$(b,d)\f$, and the second, with the weight -1 for a point \f$(b,d)\f$. In both cases, the representations are stable with respect to 1-Wasserstein distance.
- *
- *In Persistence\_representations package we currently implement a discretization of the distributions described above. The base of this implementation is 2-dimensional array of pixels. Each pixel have assigned a real value which 
- * is a sum of values of distributions induced by each point of the persistence diagram. At the moment we compute the sum of values on a center of a pixels. It can be easily extended to any other function 
- * (like for instance sum of integrals of the intermediate distribution on a pixel). 
+ *This is a general class of discrete structures which are based on idea of placing a kernel in the points of
+ persistence diagrams.
+ *This idea appeared in work by many authors over the last 15 years. As far as we know this idea was firstly described
+ in the work of Bologna group in \cite Ferri_Frosini_comparision_sheme_1 and \cite Ferri_Frosini_comparision_sheme_2.
+ *Later it has been described by Colorado State University group in \cite Persistence_Images_2017. The presented paper
+ in the first time provide a discussion of stability of the representation.
+ *Also, the same ideas are used in construction of two recent kernels used for machine learning: \cite
+ Kusano_Fukumizu_Hiraoka_PWGK and \cite Reininghaus_Huber_ALL_PSSK. Both the kernel's construction uses interesting
+ ideas to
+ *ensure stability of the representation with respect to Wasserstein metric. In the kernel presented in \cite
+ Kusano_Fukumizu_Hiraoka_PWGK, a scaling function is used to multiply the Gaussian kernel in the
+ *way that the points close to diagonal got low weight and consequently do not have a big influence on the resulting
+ distribution. In \cite Reininghaus_Huber_ALL_PSSK for every point \f$(b,d)\f$ two Gaussian kernels
+ *are added: first, with a weight 1 in a point \f$(b,d)\f$, and the second, with the weight -1 for a point \f$(b,d)\f$.
+ In both cases, the representations are stable with respect to 1-Wasserstein distance.
+ *
+ *In Persistence\_representations package we currently implement a discretization of the distributions described above.
+ The base of this implementation is 2-dimensional array of pixels. Each pixel have assigned a real value which
+ * is a sum of values of distributions induced by each point of the persistence diagram. At the moment we compute the
+ sum of values on a center of a pixels. It can be easily extended to any other function
+ * (like for instance sum of integrals of the intermediate distribution on a pixel).
  *
  *The parameters that determine the structure are the following:
  *
  *\li A positive integer k determining the size of the kernel we used (we always assume that the kernels are square).
- *\li A filter: in practice a square matrix of a size \f$2k+1 \times 2k+1\f$. By default, this is a discretization of N(0,1) kernel.
+ *\li A filter: in practice a square matrix of a size \f$2k+1 \times 2k+1\f$. By default, this is a discretization of
+ N(0,1) kernel.
  *\li The box \f$[x_0,x_1]\times [y_0,y_1]\f$ bounding the domain of the persistence image.
- *\li Scaling function. Each Gaussian kernel at point \f$(p,q)\f$ gets multiplied by the value of this function at the point \f$(p,q)\f$.
- *\li A boolean value determining if the space below diagonal should be erased or not. To be precise: when points close to diagonal are given then sometimes the kernel have support that reaches the region 
+ *\li Scaling function. Each Gaussian kernel at point \f$(p,q)\f$ gets multiplied by the value of this function at the
+ point \f$(p,q)\f$.
+ *\li A boolean value determining if the space below diagonal should be erased or not. To be precise: when points close
+ to diagonal are given then sometimes the kernel have support that reaches the region
  *below the diagonal. If the value of this parameter is true, then the values below diagonal can be erased.
  *
  *
  *\section sec_persistence_vectors Persistence vectors
  * <b>Reference manual:</b> \ref Gudhi::Persistence_representations::Vector_distances_in_diagram <br>
- *This is a representation of persistent homology in a form of a vector which was designed for an application in 3d graphic in \cite Carriere_Oudot_Ovsjanikov_top_signatures_3d. Below we provide a short description of this representation.
+ *This is a representation of persistent homology in a form of a vector which was designed for an application in 3d
+ graphic in \cite Carriere_Oudot_Ovsjanikov_top_signatures_3d. Below we provide a short description of this
+ representation.
  *
- *Given a persistence diagram \f$D = \{ (b_i,d_i) \}\f$, for every pair of birth--death points \f$(b_1,d_1)\f$ and \f$(b_2,d_2)\f$ we compute the following three distances:
+ *Given a persistence diagram \f$D = \{ (b_i,d_i) \}\f$, for every pair of birth--death points \f$(b_1,d_1)\f$ and
+ \f$(b_2,d_2)\f$ we compute the following three distances:
  *
  *\li \f$d( (b_1,d_1) , (b_2,d_2) )\f$.
  *\li \f$d( (b_1,d_1) , (\frac{b_1,d_1}{2},\frac{b_1,d_1}{2}) )\f$.
  *\li \f$d( (b_2,d_2) , (\frac{b_2,d_2}{2},\frac{b_2,d_2}{2}) )\f$.
  *
- *We pick the smallest of those and add it to a vector. The obtained vector of numbers is then sorted in decreasing order. This way we obtain a persistence vector representing the diagram.
+ *We pick the smallest of those and add it to a vector. The obtained vector of numbers is then sorted in decreasing
+ order. This way we obtain a persistence vector representing the diagram.
  *
- *Given two persistence vectors, the computation of distances, averages and scalar products is straightforward. Average is simply a coordinate-wise average of a collection of vectors. In this section we 
- * assume that the vectors are extended by zeros if they are of a different size. To compute distances we compute absolute value of differences between coordinates. A scalar product is a sum of products of 
- * values at the corresponding positions of two vectors. 
+ *Given two persistence vectors, the computation of distances, averages and scalar products is straightforward. Average
+ is simply a coordinate-wise average of a collection of vectors. In this section we
+ * assume that the vectors are extended by zeros if they are of a different size. To compute distances we compute
+ absolute value of differences between coordinates. A scalar product is a sum of products of
+ * values at the corresponding positions of two vectors.
  *
  * \copyright GNU General Public License v3.
  */
diff --git a/src/Persistence_representations/example/persistence_heat_maps.cpp b/src/Persistence_representations/example/persistence_heat_maps.cpp
index c75e2731..44227823 100644
--- a/src/Persistence_representations/example/persistence_heat_maps.cpp
+++ b/src/Persistence_representations/example/persistence_heat_maps.cpp
@@ -20,74 +20,63 @@
  *    along with this program.  If not, see <http://www.gnu.org/licenses/>.
  */
 
-
-
 #include <gudhi/reader_utils.h>
 #include <gudhi/Persistence_heat_maps.h>
 
 #include <iostream>
 #include <vector>
 
-
-
 using namespace Gudhi;
 using namespace Gudhi::Persistence_representations;
 
-
 double epsilon = 0.0000005;
 
+int main(int argc, char** argv) {
+  // create two simple vectors with birth--death pairs:
 
-	
-int main( int argc , char** argv )
-{	
-	//create two simple vectors with birth--death pairs:
-	
-	std::vector< std::pair< double , double > > persistence1;
-	std::vector< std::pair< double , double > > persistence2;
-	
-	persistence1.push_back( std::make_pair(1,2) );
-	persistence1.push_back( std::make_pair(6,8) );
-	persistence1.push_back( std::make_pair(0,4) );
-	persistence1.push_back( std::make_pair(3,8) );
-	
-	persistence2.push_back( std::make_pair(2,9) );
-	persistence2.push_back( std::make_pair(1,6) );
-	persistence2.push_back( std::make_pair(3,5) );
-	persistence2.push_back( std::make_pair(6,10) );
-	
-	//over here we define a function we sill put on a top on every birth--death pair in the persistence interval. It can be anything. Over here we will use standard Gaussian
-	std::vector< std::vector<double> > filter = create_Gaussian_filter(5,1);
-			
-	//creating two heat maps. 
-	Persistence_heat_maps<constant_scaling_function> hm1( persistence1 , filter , false , 20 , 0 , 11 );		
-	Persistence_heat_maps<constant_scaling_function> hm2( persistence2 , filter , false , 20 , 0 , 11 );
-	
-	std::vector<Persistence_heat_maps<constant_scaling_function>*> vector_of_maps;
-	vector_of_maps.push_back( &hm1 );
-	vector_of_maps.push_back( &hm2 );
-	
-	//compute median/mean of a vector of heat maps:	
-	Persistence_heat_maps<constant_scaling_function> mean;
-	mean.compute_mean( vector_of_maps );	
-	Persistence_heat_maps<constant_scaling_function> median;
-	median.compute_median( vector_of_maps );
-	
-	//to compute L^1 distance between hm1 and hm2:
-	std::cout << "The L^1 distance is : " << hm1.distance( hm2 , 1 ) << std::endl;
-	
-	//to average of hm1 and hm2:
-	std::vector< Persistence_heat_maps<constant_scaling_function>* > to_average;
-	to_average.push_back( &hm1 );
-	to_average.push_back( &hm2 );
-	Persistence_heat_maps<constant_scaling_function> av;	
-	av.compute_average( to_average );	
-	
-	//to compute scalar product of hm1 and hm2:
-	std::cout << "Scalar product is : " << hm1.compute_scalar_product( hm2 ) << std::endl;
-	
-	return 0;
-}
+  std::vector<std::pair<double, double> > persistence1;
+  std::vector<std::pair<double, double> > persistence2;
+
+  persistence1.push_back(std::make_pair(1, 2));
+  persistence1.push_back(std::make_pair(6, 8));
+  persistence1.push_back(std::make_pair(0, 4));
+  persistence1.push_back(std::make_pair(3, 8));
 
+  persistence2.push_back(std::make_pair(2, 9));
+  persistence2.push_back(std::make_pair(1, 6));
+  persistence2.push_back(std::make_pair(3, 5));
+  persistence2.push_back(std::make_pair(6, 10));
 
+  // over here we define a function we sill put on a top on every birth--death pair in the persistence interval. It can
+  // be anything. Over here we will use standard Gaussian
+  std::vector<std::vector<double> > filter = create_Gaussian_filter(5, 1);
 
+  // creating two heat maps.
+  Persistence_heat_maps<constant_scaling_function> hm1(persistence1, filter, false, 20, 0, 11);
+  Persistence_heat_maps<constant_scaling_function> hm2(persistence2, filter, false, 20, 0, 11);
 
+  std::vector<Persistence_heat_maps<constant_scaling_function>*> vector_of_maps;
+  vector_of_maps.push_back(&hm1);
+  vector_of_maps.push_back(&hm2);
+
+  // compute median/mean of a vector of heat maps:
+  Persistence_heat_maps<constant_scaling_function> mean;
+  mean.compute_mean(vector_of_maps);
+  Persistence_heat_maps<constant_scaling_function> median;
+  median.compute_median(vector_of_maps);
+
+  // to compute L^1 distance between hm1 and hm2:
+  std::cout << "The L^1 distance is : " << hm1.distance(hm2, 1) << std::endl;
+
+  // to average of hm1 and hm2:
+  std::vector<Persistence_heat_maps<constant_scaling_function>*> to_average;
+  to_average.push_back(&hm1);
+  to_average.push_back(&hm2);
+  Persistence_heat_maps<constant_scaling_function> av;
+  av.compute_average(to_average);
+
+  // to compute scalar product of hm1 and hm2:
+  std::cout << "Scalar product is : " << hm1.compute_scalar_product(hm2) << std::endl;
+
+  return 0;
+}
diff --git a/src/Persistence_representations/example/persistence_intervals.cpp b/src/Persistence_representations/example/persistence_intervals.cpp
index 947c9627..69870744 100644
--- a/src/Persistence_representations/example/persistence_intervals.cpp
+++ b/src/Persistence_representations/example/persistence_intervals.cpp
@@ -20,92 +20,70 @@
  *    along with this program.  If not, see <http://www.gnu.org/licenses/>.
  */
 
-
-
 #include <gudhi/reader_utils.h>
 #include <gudhi/Persistence_intervals.h>
 
 #include <iostream>
 
-
-
 using namespace Gudhi;
 using namespace Gudhi::Persistence_representations;
 
-	
-int main( int argc , char** argv )
-{
-	if ( argc != 2 )
-	{
-		std::cout << "To run this program, please provide the name of a file with persistence diagram \n";
-		return 1;
-	}
-	
-	Persistence_intervals p( argv[1] );
-	std::pair<double,double> min_max_ = p.get_x_range();	
-	std::cout << "Birth-death range : " <<  min_max_.first << " " << min_max_.second << std::endl;
-	
-	
-	std::vector<double> dominant_ten_intervals_length = p.length_of_dominant_intervals(10);
-	std::cout << "Length of ten dominant intervals : " <<std::endl;	
-	for ( size_t i = 0 ; i != dominant_ten_intervals_length.size() ; ++i )
-	{
-		std::cout << dominant_ten_intervals_length[i] <<std::endl;
-	}
-	
-	std::vector< std::pair<double,double> > ten_dominant_intervals = p.dominant_intervals( 10 );	
-	std::cout << "Here are the dominant intervals : " <<std::endl;
-	for ( size_t i = 0 ; i != ten_dominant_intervals.size() ; ++i )
-	{
-		std::cout << "( " << ten_dominant_intervals[i].first<< "," << ten_dominant_intervals[i].second <<std::endl;
-	}
-	
-	std::vector< size_t > histogram = p.histogram_of_lengths( 10  );
-	std::cout << "Here is the histogram of barcode's length : " <<std::endl;
-	for ( size_t i = 0 ; i != histogram.size() ; ++i )
-	{
-		std::cout << histogram[i]  << " ";
-	}		
-	std::cout <<std::endl;
-
-	
-	std::vector< size_t > cumulative_histogram = p.cumulative_histogram_of_lengths( 10  );
-	std::cout<< "Cumulative histogram : " <<std::endl;	
-	for ( size_t i = 0 ; i != cumulative_histogram.size() ; ++i )
-	{
-		std::cout << cumulative_histogram[i] << " ";
-	}		
-	std::cout <<std::endl;
-
-	std::vector< double  > char_funct_diag = p.characteristic_function_of_diagram( min_max_.first , min_max_.second );	
-	std::cout << "Characteristic function of diagram : " <<std::endl;
-	for ( size_t i = 0 ; i != char_funct_diag.size() ; ++i )
-	{
-		std::cout << char_funct_diag[i] << " ";
-	}		
-	std::cout <<std::endl;
-
-	std::vector< double  > cumul_char_funct_diag = p.cumulative_characteristic_function_of_diagram( min_max_.first , min_max_.second );
-	std::cout << "Cumulative characteristic function of diagram : " <<std::endl;
-	for ( size_t i = 0 ; i != cumul_char_funct_diag.size() ; ++i )
-	{		
-		std::cout << cumul_char_funct_diag[i] << " ";
-	}	
-	std::cout <<std::endl;
-
-	std::cout << "Persistence Betti numbers \n";
-	std::vector< std::pair< double , size_t > > pbns = p.compute_persistent_betti_numbers();	
-	for ( size_t i = 0 ; i != pbns.size() ; ++i )
-	{
-		std::cout <<  pbns[i].first << " " << pbns[i].second <<std::endl;	
-	}
-	
-	return 0;
+int main(int argc, char** argv) {
+  if (argc != 2) {
+    std::cout << "To run this program, please provide the name of a file with persistence diagram \n";
+    return 1;
+  }
+
+  Persistence_intervals p(argv[1]);
+  std::pair<double, double> min_max_ = p.get_x_range();
+  std::cout << "Birth-death range : " << min_max_.first << " " << min_max_.second << std::endl;
+
+  std::vector<double> dominant_ten_intervals_length = p.length_of_dominant_intervals(10);
+  std::cout << "Length of ten dominant intervals : " << std::endl;
+  for (size_t i = 0; i != dominant_ten_intervals_length.size(); ++i) {
+    std::cout << dominant_ten_intervals_length[i] << std::endl;
+  }
+
+  std::vector<std::pair<double, double> > ten_dominant_intervals = p.dominant_intervals(10);
+  std::cout << "Here are the dominant intervals : " << std::endl;
+  for (size_t i = 0; i != ten_dominant_intervals.size(); ++i) {
+    std::cout << "( " << ten_dominant_intervals[i].first << "," << ten_dominant_intervals[i].second << std::endl;
+  }
+
+  std::vector<size_t> histogram = p.histogram_of_lengths(10);
+  std::cout << "Here is the histogram of barcode's length : " << std::endl;
+  for (size_t i = 0; i != histogram.size(); ++i) {
+    std::cout << histogram[i] << " ";
+  }
+  std::cout << std::endl;
+
+  std::vector<size_t> cumulative_histogram = p.cumulative_histogram_of_lengths(10);
+  std::cout << "Cumulative histogram : " << std::endl;
+  for (size_t i = 0; i != cumulative_histogram.size(); ++i) {
+    std::cout << cumulative_histogram[i] << " ";
+  }
+  std::cout << std::endl;
+
+  std::vector<double> char_funct_diag = p.characteristic_function_of_diagram(min_max_.first, min_max_.second);
+  std::cout << "Characteristic function of diagram : " << std::endl;
+  for (size_t i = 0; i != char_funct_diag.size(); ++i) {
+    std::cout << char_funct_diag[i] << " ";
+  }
+  std::cout << std::endl;
+
+  std::vector<double> cumul_char_funct_diag =
+      p.cumulative_characteristic_function_of_diagram(min_max_.first, min_max_.second);
+  std::cout << "Cumulative characteristic function of diagram : " << std::endl;
+  for (size_t i = 0; i != cumul_char_funct_diag.size(); ++i) {
+    std::cout << cumul_char_funct_diag[i] << " ";
+  }
+  std::cout << std::endl;
+
+  std::cout << "Persistence Betti numbers \n";
+  std::vector<std::pair<double, size_t> > pbns = p.compute_persistent_betti_numbers();
+  for (size_t i = 0; i != pbns.size(); ++i) {
+    std::cout << pbns[i].first << " " << pbns[i].second << std::endl;
+  }
+
+  return 0;
 }
-
-
-
-
-
-
-
diff --git a/src/Persistence_representations/example/persistence_landscape.cpp b/src/Persistence_representations/example/persistence_landscape.cpp
index 3ce31918..e080154a 100644
--- a/src/Persistence_representations/example/persistence_landscape.cpp
+++ b/src/Persistence_representations/example/persistence_landscape.cpp
@@ -20,73 +20,66 @@
  *    along with this program.  If not, see <http://www.gnu.org/licenses/>.
  */
 
-
-
 #include <gudhi/Persistence_landscape.h>
 
-
-
 using namespace Gudhi;
 using namespace Gudhi::Persistence_representations;
 
 #include <iostream>
 
+int main(int argc, char** argv) {
+  // create two simple vectors with birth--death pairs:
 
-int main( int argc , char** argv )
-{	
-	//create two simple vectors with birth--death pairs:
-	
-	std::vector< std::pair< double , double > > persistence1;
-	std::vector< std::pair< double , double > > persistence2;
-	
-	persistence1.push_back( std::make_pair(1,2) );
-	persistence1.push_back( std::make_pair(6,8) );
-	persistence1.push_back( std::make_pair(0,4) );
-	persistence1.push_back( std::make_pair(3,8) );
-	
-	persistence2.push_back( std::make_pair(2,9) );
-	persistence2.push_back( std::make_pair(1,6) );
-	persistence2.push_back( std::make_pair(3,5) );
-	persistence2.push_back( std::make_pair(6,10) );
-	
-	//create two persistence landscapes based on persistence1 and persistence2:
-	Persistence_landscape l1( persistence1 );
-	Persistence_landscape l2( persistence2 );
-	
-	//This is how to compute integral of landscapes:
-	std::cout << "Integral of the first landscape : " << l1.compute_integral_of_landscape() << std::endl;
-	std::cout << "Integral of the second landscape : " << l2.compute_integral_of_landscape() << std::endl;
-	
-	//And here how to write landscapes to stream:
-	std::cout << "l1 : " << l1 << std::endl;
-	std::cout << "l2 : " << l2 << std::endl;
-	
-	//Arithmetic operations on landscapes:
-	Persistence_landscape sum = l1+l2;
-	std::cout << "sum : " << sum << std::endl;
-	
-	//here are the maxima of the functions:
-	std::cout << "Maximum of l1 : " << l1.compute_maximum() << std::endl;
-	std::cout << "Maximum of l2 : " << l2.compute_maximum() << std::endl;
-	
-	//here are the norms of landscapes:
-	std::cout << "L^1 Norm of l1 : " << l1.compute_norm_of_landscape( 1. ) << std::endl;
-	std::cout << "L^1 Norm of l2 : " << l2.compute_norm_of_landscape( 1. ) << std::endl;
-	
-	//here is the average of landscapes:
-	Persistence_landscape average;
-	average.compute_average( {&l1,&l2} );
-	std::cout << "average : " << average << std::endl;
-	
-	//here is the distance of landscapes:
-	std::cout << "Distance : " << l1.distance( l2 ) << std::endl;
-	
-	//here is the scalar product of landscapes:
-	std::cout << "Scalar product : " << l1.compute_scalar_product( l2 ) << std::endl;
-	
-	//here is how to create a file which is suitable for visualization via gnuplot:
-	average.plot( "average_landscape" );
-		
-	return 0;
-}
+  std::vector<std::pair<double, double> > persistence1;
+  std::vector<std::pair<double, double> > persistence2;
+
+  persistence1.push_back(std::make_pair(1, 2));
+  persistence1.push_back(std::make_pair(6, 8));
+  persistence1.push_back(std::make_pair(0, 4));
+  persistence1.push_back(std::make_pair(3, 8));
+
+  persistence2.push_back(std::make_pair(2, 9));
+  persistence2.push_back(std::make_pair(1, 6));
+  persistence2.push_back(std::make_pair(3, 5));
+  persistence2.push_back(std::make_pair(6, 10));
+
+  // create two persistence landscapes based on persistence1 and persistence2:
+  Persistence_landscape l1(persistence1);
+  Persistence_landscape l2(persistence2);
+
+  // This is how to compute integral of landscapes:
+  std::cout << "Integral of the first landscape : " << l1.compute_integral_of_landscape() << std::endl;
+  std::cout << "Integral of the second landscape : " << l2.compute_integral_of_landscape() << std::endl;
 
+  // And here how to write landscapes to stream:
+  std::cout << "l1 : " << l1 << std::endl;
+  std::cout << "l2 : " << l2 << std::endl;
+
+  // Arithmetic operations on landscapes:
+  Persistence_landscape sum = l1 + l2;
+  std::cout << "sum : " << sum << std::endl;
+
+  // here are the maxima of the functions:
+  std::cout << "Maximum of l1 : " << l1.compute_maximum() << std::endl;
+  std::cout << "Maximum of l2 : " << l2.compute_maximum() << std::endl;
+
+  // here are the norms of landscapes:
+  std::cout << "L^1 Norm of l1 : " << l1.compute_norm_of_landscape(1.) << std::endl;
+  std::cout << "L^1 Norm of l2 : " << l2.compute_norm_of_landscape(1.) << std::endl;
+
+  // here is the average of landscapes:
+  Persistence_landscape average;
+  average.compute_average({&l1, &l2});
+  std::cout << "average : " << average << std::endl;
+
+  // here is the distance of landscapes:
+  std::cout << "Distance : " << l1.distance(l2) << std::endl;
+
+  // here is the scalar product of landscapes:
+  std::cout << "Scalar product : " << l1.compute_scalar_product(l2) << std::endl;
+
+  // here is how to create a file which is suitable for visualization via gnuplot:
+  average.plot("average_landscape");
+
+  return 0;
+}
diff --git a/src/Persistence_representations/example/persistence_landscape_on_grid.cpp b/src/Persistence_representations/example/persistence_landscape_on_grid.cpp
index 276b7a44..75461fc6 100644
--- a/src/Persistence_representations/example/persistence_landscape_on_grid.cpp
+++ b/src/Persistence_representations/example/persistence_landscape_on_grid.cpp
@@ -20,69 +20,62 @@
  *    along with this program.  If not, see <http://www.gnu.org/licenses/>.
  */
 
-
-
 #include <gudhi/Persistence_landscape_on_grid.h>
 
-
-
 using namespace Gudhi;
 using namespace Gudhi::Persistence_representations;
 
 #include <iostream>
 
+int main(int argc, char** argv) {
+  // create two simple vectors with birth--death pairs:
+
+  std::vector<std::pair<double, double> > persistence1;
+  std::vector<std::pair<double, double> > persistence2;
+
+  persistence1.push_back(std::make_pair(1, 2));
+  persistence1.push_back(std::make_pair(6, 8));
+  persistence1.push_back(std::make_pair(0, 4));
+  persistence1.push_back(std::make_pair(3, 8));
+
+  persistence2.push_back(std::make_pair(2, 9));
+  persistence2.push_back(std::make_pair(1, 6));
+  persistence2.push_back(std::make_pair(3, 5));
+  persistence2.push_back(std::make_pair(6, 10));
+
+  // create two persistence landscapes based on persistence1 and persistence2:
+  Persistence_landscape_on_grid l1(persistence1, 0, 11, 20);
+  Persistence_landscape_on_grid l2(persistence2, 0, 11, 20);
+
+  // This is how to compute integral of landscapes:
+  std::cout << "Integral of the first landscape : " << l1.compute_integral_of_landscape() << std::endl;
+  std::cout << "Integral of the second landscape : " << l2.compute_integral_of_landscape() << std::endl;
+
+  // And here how to write landscapes to stream:
+  std::cout << "l1 : " << l1 << std::endl;
+  std::cout << "l2 : " << l2 << std::endl;
+
+  // here are the maxima of the functions:
+  std::cout << "Maximum of l1 : " << l1.compute_maximum() << std::endl;
+  std::cout << "Maximum of l2 : " << l2.compute_maximum() << std::endl;
+
+  // here are the norms of landscapes:
+  std::cout << "L^1 Norm of l1 : " << l1.compute_norm_of_landscape(1.) << std::endl;
+  std::cout << "L^1 Norm of l2 : " << l2.compute_norm_of_landscape(1.) << std::endl;
+
+  // here is the average of landscapes:
+  Persistence_landscape_on_grid average;
+  average.compute_average({&l1, &l2});
+  std::cout << "average : " << average << std::endl;
+
+  // here is the distance of landscapes:
+  std::cout << "Distance : " << l1.distance(l2) << std::endl;
+
+  // here is the scalar product of landscapes:
+  std::cout << "Scalar product : " << l1.compute_scalar_product(l2) << std::endl;
+
+  // here is how to create a file which is suitable for visualization via gnuplot:
+  average.plot("average_landscape");
 
-int main( int argc , char** argv )
-{
-	//create two simple vectors with birth--death pairs:
-	
-	std::vector< std::pair< double , double > > persistence1;
-	std::vector< std::pair< double , double > > persistence2;
-	
-	persistence1.push_back( std::make_pair(1,2) );
-	persistence1.push_back( std::make_pair(6,8) );
-	persistence1.push_back( std::make_pair(0,4) );
-	persistence1.push_back( std::make_pair(3,8) );
-	
-	persistence2.push_back( std::make_pair(2,9) );
-	persistence2.push_back( std::make_pair(1,6) );
-	persistence2.push_back( std::make_pair(3,5) );
-	persistence2.push_back( std::make_pair(6,10) );
-	
-	//create two persistence landscapes based on persistence1 and persistence2:
-	Persistence_landscape_on_grid l1( persistence1 , 0 , 11 , 20 );
-	Persistence_landscape_on_grid l2( persistence2 , 0 , 11 , 20 );
-	
-	//This is how to compute integral of landscapes:
-	std::cout << "Integral of the first landscape : " << l1.compute_integral_of_landscape() << std::endl;
-	std::cout << "Integral of the second landscape : " << l2.compute_integral_of_landscape() << std::endl;
-	
-	//And here how to write landscapes to stream:
-	std::cout << "l1 : " << l1 << std::endl;
-	std::cout << "l2 : " << l2 << std::endl;
-	
-	//here are the maxima of the functions:
-	std::cout << "Maximum of l1 : " << l1.compute_maximum() << std::endl;
-	std::cout << "Maximum of l2 : " << l2.compute_maximum() << std::endl;
-	
-	//here are the norms of landscapes:
-	std::cout << "L^1 Norm of l1 : " << l1.compute_norm_of_landscape( 1. ) << std::endl;
-	std::cout << "L^1 Norm of l2 : " << l2.compute_norm_of_landscape( 1. ) << std::endl;
-	
-	//here is the average of landscapes:
-	Persistence_landscape_on_grid average;	
-	average.compute_average( {&l1,&l2} );
-	std::cout << "average : " << average << std::endl;
-	
-	//here is the distance of landscapes:
-	std::cout << "Distance : " << l1.distance( l2 ) << std::endl;
-	
-	//here is the scalar product of landscapes:
-	std::cout << "Scalar product : " << l1.compute_scalar_product( l2 ) << std::endl;
-	
-	//here is how to create a file which is suitable for visualization via gnuplot:
-	average.plot( "average_landscape" );
-		
-		
-	return 0;
+  return 0;
 }
diff --git a/src/Persistence_representations/example/persistence_vectors.cpp b/src/Persistence_representations/example/persistence_vectors.cpp
index 028d95eb..c41d261b 100644
--- a/src/Persistence_representations/example/persistence_vectors.cpp
+++ b/src/Persistence_representations/example/persistence_vectors.cpp
@@ -20,12 +20,9 @@
  *    along with this program.  If not, see <http://www.gnu.org/licenses/>.
  */
 
-
-
 #include <gudhi/Persistence_vectors.h>
 #include <iostream>
 
-
 #include <gudhi/reader_utils.h>
 #include <vector>
 #include <cmath>
@@ -34,47 +31,45 @@
 using namespace Gudhi;
 using namespace Gudhi::Persistence_representations;
 
+int main(int argc, char** argv) {
+  // create two simple vectors with birth--death pairs:
+
+  std::vector<std::pair<double, double> > persistence1;
+  std::vector<std::pair<double, double> > persistence2;
+
+  persistence1.push_back(std::make_pair(1, 2));
+  persistence1.push_back(std::make_pair(6, 8));
+  persistence1.push_back(std::make_pair(0, 4));
+  persistence1.push_back(std::make_pair(3, 8));
+
+  persistence2.push_back(std::make_pair(2, 9));
+  persistence2.push_back(std::make_pair(1, 6));
+  persistence2.push_back(std::make_pair(3, 5));
+  persistence2.push_back(std::make_pair(6, 10));
+
+  // create two persistence vectors based on persistence1 and persistence2:
+  Vector_distances_in_diagram<Euclidean_distance> v1 =
+      Vector_distances_in_diagram<Euclidean_distance>(persistence1, std::numeric_limits<size_t>::max());
+  Vector_distances_in_diagram<Euclidean_distance> v2 =
+      Vector_distances_in_diagram<Euclidean_distance>(persistence2, std::numeric_limits<size_t>::max());
+
+  // writing to a stream:
+  std::cout << "v1 : " << v1 << std::endl;
+  std::cout << "v2 : " << v2 << std::endl;
+
+  // averages:
+  Vector_distances_in_diagram<Euclidean_distance> average;
+  average.compute_average({&v1, &v2});
+  std::cout << "Average : " << average << std::endl;
 
+  // computations of distances:
+  std::cout << "l^1 distance : " << v1.distance(v2) << std::endl;
 
+  // computations of scalar product:
+  std::cout << "Scalar product of l1 and l2 : " << v1.compute_scalar_product(v2) << std::endl;
 
-int main( int argc , char** argv )
-{
-	//create two simple vectors with birth--death pairs:
-	
-	std::vector< std::pair< double , double > > persistence1;
-	std::vector< std::pair< double , double > > persistence2;
-	
-	persistence1.push_back( std::make_pair(1,2) );
-	persistence1.push_back( std::make_pair(6,8) );
-	persistence1.push_back( std::make_pair(0,4) );
-	persistence1.push_back( std::make_pair(3,8) );
-	
-	persistence2.push_back( std::make_pair(2,9) );
-	persistence2.push_back( std::make_pair(1,6) );
-	persistence2.push_back( std::make_pair(3,5) );
-	persistence2.push_back( std::make_pair(6,10) );
-	
-	//create two persistence vectors based on persistence1 and persistence2:
-	Vector_distances_in_diagram<Euclidean_distance > v1 = Vector_distances_in_diagram<Euclidean_distance >( persistence1 , std::numeric_limits<size_t>::max() );
-	Vector_distances_in_diagram<Euclidean_distance > v2 = Vector_distances_in_diagram<Euclidean_distance >( persistence2 , std::numeric_limits<size_t>::max() );
-	
-	//writing to a stream:
-	std::cout << "v1 : " << v1 << std::endl;
-	std::cout << "v2 : " << v2 << std::endl;
-	
-	//averages:
-	Vector_distances_in_diagram<Euclidean_distance > average;
-	average.compute_average( {&v1,&v2} );
-	std::cout << "Average : " << average << std::endl;
-	
-	//computations of distances:
-	std::cout << "l^1 distance : " << v1.distance( v2 ) << std::endl;
-    
-   //computations of scalar product:
-    std::cout << "Scalar product of l1 and l2 : " << v1.compute_scalar_product( v2 ) << std::endl;
-    
-    //create a file with a gnuplot script:
-    v1.plot( "plot_of_vector_representation" );
+  // create a file with a gnuplot script:
+  v1.plot("plot_of_vector_representation");
 
-	return 0;
+  return 0;
 }
diff --git a/src/Persistence_representations/include/gudhi/PSSK.h b/src/Persistence_representations/include/gudhi/PSSK.h
index 42baa8ec..ece7e323 100644
--- a/src/Persistence_representations/include/gudhi/PSSK.h
+++ b/src/Persistence_representations/include/gudhi/PSSK.h
@@ -23,158 +23,141 @@
 #ifndef PSSK_H_
 #define PSSK_H_
 
-//gudhi include
+// gudhi include
 #include <gudhi/Persistence_heat_maps.h>
 
-
-namespace Gudhi
-{
-namespace Persistence_representations
-{
+namespace Gudhi {
+namespace Persistence_representations {
 
 /**
 * This is a version of a representation presented in https://arxiv.org/abs/1412.6821
-* In that paper the authors are using the representation just to compute kernel. Over here, we extend the usability by far.
+* In that paper the authors are using the representation just to compute kernel. Over here, we extend the usability by
+*far.
 * Note that the version presented here is not exact, since we are discretizing the kernel.
-* The only difference with respect to the original class is the method of creation. We have full (square) image, and for every point (p,q), we add a kernel at (p,q) and the negative kernel
+* The only difference with respect to the original class is the method of creation. We have full (square) image, and for
+*every point (p,q), we add a kernel at (p,q) and the negative kernel
 * at (q,p)
 **/
 
-class PSSK : public Persistence_heat_maps<constant_scaling_function>
-{
-public:
-	PSSK():Persistence_heat_maps(){}
-	
-	PSSK(const std::vector< std::pair< double,double > >  & interval , std::vector< std::vector<double> > filter = create_Gaussian_filter(5,1) , size_t number_of_pixels = 1000 , double min_ = -1 , double max_ = -1 )
-	:Persistence_heat_maps()
-	{
-		this->construct( interval  , filter , number_of_pixels , min_ , max_ );
-	}
-	
-	 
-	 PSSK( const char* filename , std::vector< std::vector<double> > filter = create_Gaussian_filter(5,1) , size_t number_of_pixels = 1000 , double min_ = -1 , double max_ = -1  , unsigned dimension = std::numeric_limits<unsigned>::max() ):
-	    Persistence_heat_maps()
-	    {
-			std::vector< std::pair< double , double > > intervals_;
-                        if ( dimension == std::numeric_limits<unsigned>::max() )
-                        {
-                           intervals_ = read_persistence_intervals_in_one_dimension_from_file( filename );
-                        }
-                        else
-                        {
-                           intervals_ = read_persistence_intervals_in_one_dimension_from_file( filename , dimension );
-                        }
-			this->construct( intervals_ , filter , number_of_pixels , min_ , max_ );
-		}
-
-protected:
-	void construct( const std::vector< std::pair<double,double> >& intervals_  , 
-					std::vector< std::vector<double> > filter = create_Gaussian_filter(5,1),
-                    size_t number_of_pixels = 1000 , double min_ = -1 , double max_ = -1 );
-};
-
-//if min_ == max_, then the program is requested to set up the values itself based on persistence intervals
-void PSSK::construct( const std::vector< std::pair<double,double> >& intervals_  ,  
-									   std::vector< std::vector<double> > filter,
-									   size_t number_of_pixels , double min_ , double max_ )
-{	
-    bool dbg = false;       
-    if ( dbg ){std::cerr << "Entering construct procedure \n";getchar();}
-
-    if ( min_ == max_ )
-    {
-        //in this case, we want the program to set up the min_ and max_ values by itself.
-        min_ = std::numeric_limits<int>::max();
-        max_ = -std::numeric_limits<int>::max();
-        
-        
-        for ( size_t i = 0 ; i != intervals_.size() ; ++i )
-        {
-			if ( intervals_[i].first < min_ )min_ = intervals_[i].first;
-			if ( intervals_[i].second > max_ )max_ = intervals_[i].second;
-		}
-        //now we have the structure filled in, and moreover we know min_ and max_ values of the interval, so we know the range.
-
-        //add some more space:
-        min_ -= fabs(max_ - min_)/100;
-        max_ += fabs(max_ - min_)/100;
+class PSSK : public Persistence_heat_maps<constant_scaling_function> {
+ public:
+  PSSK() : Persistence_heat_maps() {}
+
+  PSSK(const std::vector<std::pair<double, double> >& interval,
+       std::vector<std::vector<double> > filter = create_Gaussian_filter(5, 1), size_t number_of_pixels = 1000,
+       double min_ = -1, double max_ = -1)
+      : Persistence_heat_maps() {
+    this->construct(interval, filter, number_of_pixels, min_, max_);
+  }
+
+  PSSK(const char* filename, std::vector<std::vector<double> > filter = create_Gaussian_filter(5, 1),
+       size_t number_of_pixels = 1000, double min_ = -1, double max_ = -1,
+       unsigned dimension = std::numeric_limits<unsigned>::max())
+      : Persistence_heat_maps() {
+    std::vector<std::pair<double, double> > intervals_;
+    if (dimension == std::numeric_limits<unsigned>::max()) {
+      intervals_ = read_persistence_intervals_in_one_dimension_from_file(filename);
+    } else {
+      intervals_ = read_persistence_intervals_in_one_dimension_from_file(filename, dimension);
     }
+    this->construct(intervals_, filter, number_of_pixels, min_, max_);
+  }
 
-	if ( dbg )
-	{
-		std::cerr << "min_ : " << min_ << std::endl;
-		std::cerr << "max_ : " << max_ << std::endl;
-		std::cerr << "number_of_pixels : " << number_of_pixels << std::endl;
-		getchar();
-	}
-
-    this->min_ = min_;
-    this->max_ = max_;    
+ protected:
+  void construct(const std::vector<std::pair<double, double> >& intervals_,
+                 std::vector<std::vector<double> > filter = create_Gaussian_filter(5, 1),
+                 size_t number_of_pixels = 1000, double min_ = -1, double max_ = -1);
+};
 
+// if min_ == max_, then the program is requested to set up the values itself based on persistence intervals
+void PSSK::construct(const std::vector<std::pair<double, double> >& intervals_,
+                     std::vector<std::vector<double> > filter, size_t number_of_pixels, double min_, double max_) {
+  bool dbg = false;
+  if (dbg) {
+    std::cerr << "Entering construct procedure \n";
+    getchar();
+  }
+
+  if (min_ == max_) {
+    // in this case, we want the program to set up the min_ and max_ values by itself.
+    min_ = std::numeric_limits<int>::max();
+    max_ = -std::numeric_limits<int>::max();
+
+    for (size_t i = 0; i != intervals_.size(); ++i) {
+      if (intervals_[i].first < min_) min_ = intervals_[i].first;
+      if (intervals_[i].second > max_) max_ = intervals_[i].second;
+    }
+    // now we have the structure filled in, and moreover we know min_ and max_ values of the interval, so we know the
+    // range.
+
+    // add some more space:
+    min_ -= fabs(max_ - min_) / 100;
+    max_ += fabs(max_ - min_) / 100;
+  }
+
+  if (dbg) {
+    std::cerr << "min_ : " << min_ << std::endl;
+    std::cerr << "max_ : " << max_ << std::endl;
+    std::cerr << "number_of_pixels : " << number_of_pixels << std::endl;
+    getchar();
+  }
+
+  this->min_ = min_;
+  this->max_ = max_;
+
+  // initialization of the structure heat_map
+  std::vector<std::vector<double> > heat_map_;
+  for (size_t i = 0; i != number_of_pixels; ++i) {
+    std::vector<double> v(number_of_pixels, 0);
+    heat_map_.push_back(v);
+  }
+  this->heat_map = heat_map_;
+
+  if (dbg) std::cerr << "Done creating of the heat map, now we will fill in the structure \n";
+
+  for (size_t pt_nr = 0; pt_nr != intervals_.size(); ++pt_nr) {
+    // compute the value of intervals_[pt_nr] in the grid:
+    int x_grid = (int)((intervals_[pt_nr].first - this->min_) / (this->max_ - this->min_) * number_of_pixels);
+    int y_grid = (int)((intervals_[pt_nr].second - this->min_) / (this->max_ - this->min_) * number_of_pixels);
+
+    if (dbg) {
+      std::cerr << "point : " << intervals_[pt_nr].first << " , " << intervals_[pt_nr].second << std::endl;
+      std::cerr << "x_grid : " << x_grid << std::endl;
+      std::cerr << "y_grid : " << y_grid << std::endl;
+    }
 
+    // x_grid and y_grid gives a center of the kernel. We want to have its lower left corner. To get this, we need to
+    // shift x_grid and y_grid by a grid diameter.
+    x_grid -= filter.size() / 2;
+    y_grid -= filter.size() / 2;
+    // note that the numbers x_grid and y_grid may be negative.
+
+    if (dbg) {
+      std::cerr << "After shift : \n";
+      ;
+      std::cerr << "x_grid : " << x_grid << std::endl;
+      std::cerr << "y_grid : " << y_grid << std::endl;
+      std::cerr << "filter.size() : " << filter.size() << std::endl;
+      getchar();
+    }
 
-    //initialization of the structure heat_map
-    std::vector< std::vector<double> > heat_map_;
-    for ( size_t i = 0 ; i != number_of_pixels ; ++i )
-    {       
-		std::vector<double> v( number_of_pixels , 0 );
-        heat_map_.push_back( v );
+    for (size_t i = 0; i != filter.size(); ++i) {
+      for (size_t j = 0; j != filter.size(); ++j) {
+        // if the point (x_grid+i,y_grid+j) is the correct point in the grid.
+        if (((x_grid + i) >= 0) && (x_grid + i < this->heat_map.size()) && ((y_grid + j) >= 0) &&
+            (y_grid + j < this->heat_map.size())) {
+          if (dbg) {
+            std::cerr << y_grid + j << " " << x_grid + i << std::endl;
+          }
+          this->heat_map[y_grid + j][x_grid + i] += filter[i][j];
+          this->heat_map[x_grid + i][y_grid + j] += -filter[i][j];
+        }
+      }
     }
-    this->heat_map = heat_map_;
-
-    if (dbg)std::cerr << "Done creating of the heat map, now we will fill in the structure \n";
-
-	for ( size_t pt_nr = 0 ; pt_nr != intervals_.size() ; ++pt_nr )
-	{
-		//compute the value of intervals_[pt_nr] in the grid:
-		int x_grid = (int)((intervals_[pt_nr].first - this->min_)/( this->max_-this->min_ )*number_of_pixels);
-		int y_grid = (int)((intervals_[pt_nr].second - this->min_)/( this->max_-this->min_ )*number_of_pixels);
-		
-		if ( dbg )
-		{
-			std::cerr << "point : " << intervals_[pt_nr].first << " , " << intervals_[pt_nr].second << std::endl;
-			std::cerr << "x_grid : " << x_grid << std::endl;
-			std::cerr << "y_grid : " << y_grid << std::endl;
-		}
-		
-		//x_grid and y_grid gives a center of the kernel. We want to have its lower left corner. To get this, we need to shift x_grid and y_grid by a grid diameter.		
-		x_grid -= filter.size()/2;
-		y_grid -= filter.size()/2;
-		//note that the numbers x_grid and y_grid may be negative. 
-		
-		if ( dbg )
-		{
-			std::cerr << "After shift : \n";;
-			std::cerr << "x_grid : " << x_grid << std::endl;
-			std::cerr << "y_grid : " << y_grid << std::endl;
-			std::cerr << "filter.size() : " << filter.size() << std::endl;
-			getchar();
-		}					
-
-		
-		for ( size_t i = 0 ; i != filter.size() ; ++i )
-		{
-			for ( size_t j = 0 ; j != filter.size() ; ++j )
-			{			
-				//if the point (x_grid+i,y_grid+j) is the correct point in the grid.						
-				if ( 
-					  ((x_grid+i)>=0) && (x_grid+i<this->heat_map.size()) 
-					  &&
-					  ((y_grid+j)>=0) && (y_grid+j<this->heat_map.size()) 
-				   )
-				{
-					if ( dbg ){std::cerr << y_grid+j << " " <<  x_grid+i << std::endl;}
-					this->heat_map[ y_grid+j ][ x_grid+i ] += filter[i][j];
-					this->heat_map[ x_grid+i ][ y_grid+j ] += -filter[i][j];
-				}
-			}
-		}
-		
-	}
-}//construct
-
-}  //namespace Persistence_representations
-}  //namespace Gudhi
+  }
+}  // construct
 
+}  // namespace Persistence_representations
+}  // namespace Gudhi
 
 #endif  // PSSK_H_
diff --git a/src/Persistence_representations/include/gudhi/Persistence_heat_maps.h b/src/Persistence_representations/include/gudhi/Persistence_heat_maps.h
index a20702ff..55c94ec6 100644
--- a/src/Persistence_representations/include/gudhi/Persistence_heat_maps.h
+++ b/src/Persistence_representations/include/gudhi/Persistence_heat_maps.h
@@ -22,8 +22,8 @@
 
 #ifndef PERSISTENCE_HEAT_MAPS_H_
 #define PERSISTENCE_HEAT_MAPS_H_
- 
-//standard include
+
+// standard include
 #include <vector>
 #include <sstream>
 #include <iostream>
@@ -32,169 +32,146 @@
 #include <vector>
 #include <algorithm>
 
-//gudhi include
+// gudhi include
 #include <gudhi/read_persistence_from_file.h>
 #include <gudhi/common_persistence_representations.h>
 
-
-
-
-namespace Gudhi
-{
-namespace Persistence_representations
-{
-
+namespace Gudhi {
+namespace Persistence_representations {
 
 /**
- * This is a simple procedure to create n by n (or 2*pixel_radius times 2*pixel_radius cubical approximation of a Gaussian kernel.
-**/ 
-std::vector< std::vector<double> > create_Gaussian_filter( size_t pixel_radius , double sigma )
-{
-	bool dbg = false;
-	//we are computing the kernel mask to 2 standard deviations away from the center. We discretize it in a grid of a size 2*pixel_radius times 2*pixel_radius.
-	
-    double r = 0;
-    double sigma_sqr = sigma * sigma;
- 
-    // sum is for normalization
-    double sum = 0;
-    
-    //initialization of a kernel:
-    std::vector< std::vector<double> > kernel( 2*pixel_radius +1 );
-    for ( size_t i = 0 ; i != kernel.size() ; ++i )
-    {
-		std::vector<double> v( 2*pixel_radius +1 , 0 );
-		kernel[i] = v;
-	}
-	
-	if ( dbg )
-	{
-		std::cerr << "Kernel initialize \n";	
-		std::cerr << "pixel_radius : " << pixel_radius << std::endl; 
-		std::cerr << "kernel.size() : " << kernel.size() << std::endl;
-		getchar();
-	}
- 
-    for (int x = -pixel_radius; x <= (int)pixel_radius; x++)
-    {
-        for(int y = -pixel_radius; y <= (int)pixel_radius; y++)
-        {			
-			double real_x = 2*sigma*x/pixel_radius;
-			double real_y = 2*sigma*y/pixel_radius;						
-            r = sqrt(real_x*real_x + real_y*real_y);						
-            kernel[x + pixel_radius][y + pixel_radius] = (exp(-(r*r)/sigma_sqr))/(3.141592 * sigma_sqr);
-            sum += kernel[x + pixel_radius][y + pixel_radius];            
-        }
-    }      
- 
-    // normalize the kernel
-    for( size_t i = 0; i != kernel.size() ; ++i)
-    {
-        for( size_t j = 0; j != kernel[i].size() ; ++j)
-        {
-            kernel[i][j] /= sum;
-		}
-            
+ * This is a simple procedure to create n by n (or 2*pixel_radius times 2*pixel_radius cubical approximation of a
+ *Gaussian kernel.
+**/
+std::vector<std::vector<double> > create_Gaussian_filter(size_t pixel_radius, double sigma) {
+  bool dbg = false;
+  // we are computing the kernel mask to 2 standard deviations away from the center. We discretize it in a grid of a
+  // size 2*pixel_radius times 2*pixel_radius.
+
+  double r = 0;
+  double sigma_sqr = sigma * sigma;
+
+  // sum is for normalization
+  double sum = 0;
+
+  // initialization of a kernel:
+  std::vector<std::vector<double> > kernel(2 * pixel_radius + 1);
+  for (size_t i = 0; i != kernel.size(); ++i) {
+    std::vector<double> v(2 * pixel_radius + 1, 0);
+    kernel[i] = v;
+  }
+
+  if (dbg) {
+    std::cerr << "Kernel initialize \n";
+    std::cerr << "pixel_radius : " << pixel_radius << std::endl;
+    std::cerr << "kernel.size() : " << kernel.size() << std::endl;
+    getchar();
+  }
+
+  for (int x = -pixel_radius; x <= (int)pixel_radius; x++) {
+    for (int y = -pixel_radius; y <= (int)pixel_radius; y++) {
+      double real_x = 2 * sigma * x / pixel_radius;
+      double real_y = 2 * sigma * y / pixel_radius;
+      r = sqrt(real_x * real_x + real_y * real_y);
+      kernel[x + pixel_radius][y + pixel_radius] = (exp(-(r * r) / sigma_sqr)) / (3.141592 * sigma_sqr);
+      sum += kernel[x + pixel_radius][y + pixel_radius];
     }
-    
-    if ( dbg )
-    {
-		std::cerr << "Here is the kernel : \n";
-		for( size_t i = 0; i != kernel.size() ; ++i)
-		{
-			for( size_t j = 0; j != kernel[i].size() ; ++j)
-			{
-				std::cerr << kernel[i][j] << " ";
-			}
-			std::cerr << std::endl;
-		}
-	}
-    return kernel;
-}
+  }
 
+  // normalize the kernel
+  for (size_t i = 0; i != kernel.size(); ++i) {
+    for (size_t j = 0; j != kernel[i].size(); ++j) {
+      kernel[i][j] /= sum;
+    }
+  }
+
+  if (dbg) {
+    std::cerr << "Here is the kernel : \n";
+    for (size_t i = 0; i != kernel.size(); ++i) {
+      for (size_t j = 0; j != kernel[i].size(); ++j) {
+        std::cerr << kernel[i][j] << " ";
+      }
+      std::cerr << std::endl;
+    }
+  }
+  return kernel;
+}
 
 /*
 * There are various options to scale the points depending on their location. One can for instance:
 * (1) do nothing (scale all of them with the weight 1), as in the function constant_function
 * (2) Scale them by the distance to the diagonal. This is implemented in function
 * (3) Scale them with the square of their distance to diagonal. This is implemented in function
-* (4) Scale them with 
-*/ 
-
+* (4) Scale them with
+*/
 
 /**
- * This is one of a scaling functions used to weight points depending on their persistence and/or location in the diagram. 
+ * This is one of a scaling functions used to weight points depending on their persistence and/or location in the
+ *diagram.
  * This particular functionality is a function which always assign value 1 to a point in the diagram.
-**/ 
-class constant_scaling_function
-{
-public:
-	double operator()( const std::pair< double , double >& point_in_diagram )
-	{	
-		return 1;
-	}
+**/
+class constant_scaling_function {
+ public:
+  double operator()(const std::pair<double, double>& point_in_diagram) { return 1; }
 };
 
-
 /**
- * This is one of a scaling functions used to weight points depending on their persistence and/or location in the diagram. 
+ * This is one of a scaling functions used to weight points depending on their persistence and/or location in the
+ *diagram.
  * The scaling given by this function to a point (b,d) is Euclidean distance of (b,d) from diagonal.
-**/ 
-class distance_from_diagonal_scaling
-{
-public:
-	double operator()( const std::pair< double , double >& point_in_diagram )
-	{
-		//(point_in_diagram.first+point_in_diagram.second)/2.0
-		return sqrt( pow((point_in_diagram.first-(point_in_diagram.first+point_in_diagram.second)/2.0),2) + pow((point_in_diagram.second-(point_in_diagram.first+point_in_diagram.second)/2.0),2)  );
-	}
+**/
+class distance_from_diagonal_scaling {
+ public:
+  double operator()(const std::pair<double, double>& point_in_diagram) {
+    //(point_in_diagram.first+point_in_diagram.second)/2.0
+    return sqrt(pow((point_in_diagram.first - (point_in_diagram.first + point_in_diagram.second) / 2.0), 2) +
+                pow((point_in_diagram.second - (point_in_diagram.first + point_in_diagram.second) / 2.0), 2));
+  }
 };
 
 /**
- * This is one of a scaling functions used to weight points depending on their persistence and/or location in the diagram. 
+ * This is one of a scaling functions used to weight points depending on their persistence and/or location in the
+ *diagram.
  * The scaling given by this function to a point (b,d) is a square of Euclidean distance of (b,d) from diagonal.
-**/ 
-class squared_distance_from_diagonal_scaling
-{
-public:
-	double operator()( const std::pair< double , double >& point_in_diagram )
-	{
-		return pow((point_in_diagram.first-(point_in_diagram.first+point_in_diagram.second)/2.0),2) + pow((point_in_diagram.second-(point_in_diagram.first+point_in_diagram.second)/2.0),2);
-	}
+**/
+class squared_distance_from_diagonal_scaling {
+ public:
+  double operator()(const std::pair<double, double>& point_in_diagram) {
+    return pow((point_in_diagram.first - (point_in_diagram.first + point_in_diagram.second) / 2.0), 2) +
+           pow((point_in_diagram.second - (point_in_diagram.first + point_in_diagram.second) / 2.0), 2);
+  }
 };
 
 /**
- * This is one of a scaling functions used to weight points depending on their persistence and/or location in the diagram. 
+ * This is one of a scaling functions used to weight points depending on their persistence and/or location in the
+ *diagram.
  * The scaling given by this function to a point (b,d) is an arctan of a persistence of a point (i.e. arctan( b-d ).
-**/ 
-class arc_tan_of_persistence_of_point
-{
-public:
-	double operator()( const std::pair< double , double >& point_in_diagram )
-	{
-		return atan( point_in_diagram.second - point_in_diagram.first );
-	}
+**/
+class arc_tan_of_persistence_of_point {
+ public:
+  double operator()(const std::pair<double, double>& point_in_diagram) {
+    return atan(point_in_diagram.second - point_in_diagram.first);
+  }
 };
 
 /**
- * This is one of a scaling functions used to weight points depending on their persistence and/or location in the diagram. 
- * This scaling function do not only depend on a point (p,d) in the diagram, but it depends on the whole diagram. 
- * The longest persistence pair get a scaling 1. Any other pair get a scaling belong to [0,1], which is proportional 
+ * This is one of a scaling functions used to weight points depending on their persistence and/or location in the
+ *diagram.
+ * This scaling function do not only depend on a point (p,d) in the diagram, but it depends on the whole diagram.
+ * The longest persistence pair get a scaling 1. Any other pair get a scaling belong to [0,1], which is proportional
  * to the persistence of that pair.
-**/ 
-class weight_by_setting_maximal_interval_to_have_length_one
-{
-public:
-	weight_by_setting_maximal_interval_to_have_length_one( double len ):letngth_of_maximal_interval(len){}
-	double operator()( const std::pair< double , double >& point_in_diagram )
-	{
-		return (point_in_diagram.second-point_in_diagram.first)/this->letngth_of_maximal_interval;
-	}
-private:
-	double letngth_of_maximal_interval;
+**/
+class weight_by_setting_maximal_interval_to_have_length_one {
+ public:
+  weight_by_setting_maximal_interval_to_have_length_one(double len) : letngth_of_maximal_interval(len) {}
+  double operator()(const std::pair<double, double>& point_in_diagram) {
+    return (point_in_diagram.second - point_in_diagram.first) / this->letngth_of_maximal_interval;
+  }
+
+ private:
+  double letngth_of_maximal_interval;
 };
 
-
 /**
  * \class Persistence_heat_maps Persistence_heat_maps.h gudhi/Persistence_heat_maps.h
  * \brief A class implementing persistence heat maps.
@@ -202,840 +179,739 @@ private:
  * \ingroup Persistence_representations
 **/
 
-// This class implements the following concepts: Vectorized_topological_data, Topological_data_with_distances, Real_valued_topological_data, Topological_data_with_averages, Topological_data_with_scalar_product
+// This class implements the following concepts: Vectorized_topological_data, Topological_data_with_distances,
+// Real_valued_topological_data, Topological_data_with_averages, Topological_data_with_scalar_product
 template <typename Scalling_of_kernels = constant_scaling_function>
-class Persistence_heat_maps
-{
-public:
-    /**
-     * The default constructor. A scaling function from the diagonal is set up to a constant function. The image is not erased below the diagonal. The Gaussian have diameter 5. 	 
-    **/ 
-	Persistence_heat_maps()
-	{
-		Scalling_of_kernels f;
-		this->f = f;
-		this->erase_below_diagonal = false;		
-		this->min_ = this->max_ = 0;
-		this->set_up_parameters_for_basic_classes();
-	};
-	
-	/**
-	 * Construction that takes at the input the following parameters:
-	 * (1) A vector of pairs of doubles (representing persistence intervals). All other parameters are optional. They are:
-	 * (2) a Gaussian filter generated by create_Gaussian_filter filter (the default value of this variable is a Gaussian filter of a radius 5), 
-	 * (3) a boolean value which determines if the area of image below diagonal should, or should not be erased (it will be erased by default). 
-	 * (4) a number of pixels in each direction (set to 1000 by default). 
-	 * (5) a min x and y value of points that are to be taken into account. By default it is set to std::numeric_limits<double>::max(), in which case the program compute the values based on the data,
-	 * (6) a max x and y value of points that are to be taken into account. By default it is set to std::numeric_limits<double>::max(), in which case the program compute the values based on the data.
-	**/  
-    Persistence_heat_maps( const std::vector< std::pair< double,double > >  & interval , std::vector< std::vector<double> > filter = create_Gaussian_filter(5,1) , bool erase_below_diagonal = false , size_t number_of_pixels = 1000 , double min_ = std::numeric_limits<double>::max() , double max_ = std::numeric_limits<double>::max()  );
-    
-    /**
-	 * Construction that takes at the input a name of a file with persistence intervals, a filter (radius 5 by default), a scaling function (constant by default), a boolean value which determines if the area of image below diagonal should, or should not be erased (should by default). The next parameter is the number of pixels in each direction (set to 1000 by default) and min and max values of images (both set to std::numeric_limits<double>::max() by default. If this is the case, the program will pick the right values based on the data).
-	**/  
-	/**
-	 * Construction that takes at the input the following parameters:
-	 * (1) A name of a file with persistence intervals. The file should be readable by the function read_persistence_intervals_in_one_dimension_from_file. All other parameters are optional. They are:
-	 * (2) a Gaussian filter generated by create_Gaussian_filter filter (the default value of this variable is a Gaussian filter of a radius 5), 	
-	 * (3) a boolean value which determines if the area of image below diagonal should, or should not be erased (it will be erased by default). 
-	 * (4) a number of pixels in each direction (set to 1000 by default). 
-	 * (5) a min x and y value of points that are to be taken into account. By default it is set to std::numeric_limits<double>::max(), in which case the program compute the values based on the data,
-	 * (6) a max x and y value of points that are to be taken into account. By default it is set to std::numeric_limits<double>::max(), in which case the program compute the values based on the data.
-	**/ 	
-    Persistence_heat_maps( const char* filename , std::vector< std::vector<double> > filter = create_Gaussian_filter(5,1), bool erase_below_diagonal = false , size_t number_of_pixels = 1000 , double min_ = std::numeric_limits<double>::max() , double max_ = std::numeric_limits<double>::max()  , unsigned dimension = std::numeric_limits<unsigned>::max() );
-
-	
-	/**
-	 * Compute a mean value of a collection of heat maps and store it in the current object. Note that all the persistence maps send in a vector to this procedure need to have the same parameters. 
-	 * If this is not the case, the program will throw an exception. 
-	**/ 
-	void compute_mean( const std::vector<Persistence_heat_maps*>& maps );
-	
-	/**
-	 * Compute a median value of a collection of heat maps and store it in the current object. Note that all the persistence maps send in a vector to this procedure need to have the same parameters. 
-	 * If this is not the case, the program will throw an exception. 
-	**/ 
-	void compute_median( const std::vector<Persistence_heat_maps*>& maps );	
-	
-	/**
-	 * Compute a percentage of active (i.e) values above the cutoff of a collection of heat maps. 
-	**/ 
-	void compute_percentage_of_active( const std::vector<Persistence_heat_maps*>& maps , size_t cutoff = 1 );
-    
-    //put to file subroutine
-    /**
-     * The function outputs the persistence image to a text file. The format as follow:
-     * In the first line, the values min and max of the image are stored
-     * In the next lines, we have the persistence images in a form of a bitmap image. 
-    **/
-    void print_to_file( const char* filename )const;
-    
-    /**
-     * A function that load a heat map from file to the current object (and erase whatever was stored in the current object before).
-    **/
-    void load_from_file( const char* filename );
-    
-    
-    /**
-     * The procedure checks if min_, max_ and this->heat_maps sizes are the same. 
-    **/ 
-    inline bool check_if_the_same( const Persistence_heat_maps& second  )const
-    {
-		bool dbg = false;
-		if ( this->heat_map.size() != second.heat_map.size() )
-		{
-			if ( dbg )std::cerr << "this->heat_map.size() : " << this->heat_map.size()  << " \n second.heat_map.size() : " << second.heat_map.size() << std::endl;
-			return false;
-		}
-		if ( this->min_ != second.min_ )
-		{
-			if ( dbg )std::cerr << "this->min_ : " << this->min_ << ", second.min_ : " << second.min_ << std::endl;
-			return false;
-		}
-		if ( this->max_ != second.max_ )
-		{
-			if ( dbg )std::cerr << "this->max_ : " << this->max_ << ", second.max_ : " << second.max_ << std::endl;
-			return false;
-		}
-		//in the other case we may assume that the persistence images are defined on the same domain.
-		return true;
-	}
-	
-	
-	/**
-	 * Return minimal range value of persistent image.
-	**/ 
-	inline double get_min()const{return this->min_;}
-
-	/**
-	 * Return maximal range value of persistent image.
-	**/ 
-	inline double get_max()const{return this->max_;}
-	
-	
-	/**
-	 * Operator == to check if to persistence heat maps are the same.
-	**/ 
-	bool operator == ( const Persistence_heat_maps& rhs )const
-	{
-		bool dbg = false;
-		if ( !this->check_if_the_same(rhs) )
-		{
-			if ( dbg )std::cerr << "The domains are not the same \n";
-			return false;//in this case, the domains are not the same, so the maps cannot be the same.
-		}
-		for ( size_t i = 0 ; i != this->heat_map.size() ; ++i )
-		{
-			for ( size_t j = 0 ; j != this->heat_map[i].size() ; ++j )
-			{
-				if ( !almost_equal(this->heat_map[i][j] , rhs.heat_map[i][j]) )
-				{
-					if ( dbg )
-					{
-						std::cerr << "this->heat_map[" << i << "][" << j << "] = " << this->heat_map[i][j] << std::endl;
-						std::cerr << "rhs.heat_map[" << i << "][" << j << "] = " << rhs.heat_map[i][j] << std::endl;						
-					}
-					return false;
-				}
-			}
-		}
-		return true;
-	}
-	
-	/**
-	 * Operator != to check if to persistence heat maps are different.
-	**/ 
-	bool operator != ( const Persistence_heat_maps& rhs )const
-	{
-		return !( (*this) == rhs );
-	}
-    
-    
-    /**
-     * A function to generate a gnuplot script to visualize the persistent image.  
-    **/
-    void plot( const char* filename )const;
-    
-       
-    template<typename Operation_type>
-    friend Persistence_heat_maps operation_on_pair_of_heat_maps( const Persistence_heat_maps& first ,  const Persistence_heat_maps& second , Operation_type operation )
-    {
-		//first check if the heat maps are compatible 
-		if ( !first.check_if_the_same( second ) )
-		{
-			std::cerr << "Sizes of the heat maps are not compatible. The program will now terminate \n";
-			throw "Sizes of the heat maps are not compatible. The program will now terminate \n";
-		}
-		Persistence_heat_maps result;
-		result.min_ = first.min_;
-		result.max_ = first.max_;
-		result.heat_map.reserve( first.heat_map.size() );
-		for ( size_t i = 0 ; i != first.heat_map.size() ; ++i )
-		{ 
-			std::vector< double > v;
-			v.reserve( first.heat_map[i].size() );
-			for ( size_t j = 0 ; j != first.heat_map[i].size() ; ++j )
-			{
-				v.push_back( operation( first.heat_map[i][j] , second.heat_map[i][j] ) );
-			}
-			result.heat_map.push_back( v );
-		}
-		return result;
-	}//operation_on_pair_of_heat_maps
-	
-	
-	/**
-	 * Multiplication of Persistence_heat_maps by scalar (so that all values of the heat map gets multiplied by that scalar). 
-	**/ 
-	Persistence_heat_maps multiply_by_scalar( double scalar )const 
-    {
-		Persistence_heat_maps result;
-		result.min_ = this->min_;
-		result.max_ = this->max_;
-		result.heat_map.reserve( this->heat_map.size() );
-		for ( size_t i = 0 ; i != this->heat_map.size() ; ++i )
-		{ 
-			std::vector< double > v;
-			v.reserve( this->heat_map[i].size() );
-			for ( size_t j = 0 ; j != this->heat_map[i].size() ; ++j )
-			{
-				v.push_back( this->heat_map[i][j] * scalar );
-			}
-			result.heat_map.push_back( v );
-		}
-		return result;
-	}
-	
-    /**
-     * This function computes a sum of two objects of a type Persistence_heat_maps.
-    **/    
-    friend Persistence_heat_maps operator+( const Persistence_heat_maps& first , const Persistence_heat_maps& second )
-    {
-		return operation_on_pair_of_heat_maps( first , second , std::plus<double>() );
-	}	
-	/**
-     * This function computes a difference of two objects of a type Persistence_heat_maps.
-    **/
-    friend Persistence_heat_maps operator-( const Persistence_heat_maps& first , const Persistence_heat_maps& second )
-    {
-		return operation_on_pair_of_heat_maps( first , second , std::minus<double>() );
-	}
-	/**
-     * This function computes a product of an object of a type Persistence_heat_maps with real number.
-    **/
-	friend Persistence_heat_maps operator*( double scalar , const Persistence_heat_maps& A )
-	{
-		return A.multiply_by_scalar( scalar );
-	}
-	/**
-     * This function computes a product of an object of a type Persistence_heat_maps with real number.
-    **/
-	friend Persistence_heat_maps operator*( const Persistence_heat_maps& A , double scalar )
-	{
-		return A.multiply_by_scalar( scalar );
-	}
-	/**
-     * This function computes a product of an object of a type Persistence_heat_maps with real number.
-    **/
-	Persistence_heat_maps operator*( double scalar )
-	{
-		return this->multiply_by_scalar( scalar );
-	}
-	/**
-	 * += operator for Persistence_heat_maps.
-	**/ 
-    Persistence_heat_maps operator += ( const Persistence_heat_maps& rhs )
-    {
-        *this = *this + rhs;
-        return *this;
-    }    
-    /**
-	 * -= operator for Persistence_heat_maps.
-	**/ 
-    Persistence_heat_maps operator -= ( const Persistence_heat_maps& rhs )
-    {
-        *this = *this - rhs;
-        return *this;
+class Persistence_heat_maps {
+ public:
+  /**
+   * The default constructor. A scaling function from the diagonal is set up to a constant function. The image is not
+   *erased below the diagonal. The Gaussian have diameter 5.
+  **/
+  Persistence_heat_maps() {
+    Scalling_of_kernels f;
+    this->f = f;
+    this->erase_below_diagonal = false;
+    this->min_ = this->max_ = 0;
+    this->set_up_parameters_for_basic_classes();
+  };
+
+  /**
+   * Construction that takes at the input the following parameters:
+   * (1) A vector of pairs of doubles (representing persistence intervals). All other parameters are optional. They are:
+   * (2) a Gaussian filter generated by create_Gaussian_filter filter (the default value of this variable is a Gaussian
+   *filter of a radius 5),
+   * (3) a boolean value which determines if the area of image below diagonal should, or should not be erased (it will
+   *be erased by default).
+   * (4) a number of pixels in each direction (set to 1000 by default).
+   * (5) a min x and y value of points that are to be taken into account. By default it is set to
+   *std::numeric_limits<double>::max(), in which case the program compute the values based on the data,
+   * (6) a max x and y value of points that are to be taken into account. By default it is set to
+   *std::numeric_limits<double>::max(), in which case the program compute the values based on the data.
+  **/
+  Persistence_heat_maps(const std::vector<std::pair<double, double> >& interval,
+                        std::vector<std::vector<double> > filter = create_Gaussian_filter(5, 1),
+                        bool erase_below_diagonal = false, size_t number_of_pixels = 1000,
+                        double min_ = std::numeric_limits<double>::max(),
+                        double max_ = std::numeric_limits<double>::max());
+
+  /**
+       * Construction that takes at the input a name of a file with persistence intervals, a filter (radius 5 by
+    *default), a scaling function (constant by default), a boolean value which determines if the area of image below
+    *diagonal should, or should not be erased (should by default). The next parameter is the number of pixels in each
+    *direction (set to 1000 by default) and min and max values of images (both set to std::numeric_limits<double>::max()
+    *by default. If this is the case, the program will pick the right values based on the data).
+      **/
+  /**
+   * Construction that takes at the input the following parameters:
+   * (1) A name of a file with persistence intervals. The file should be readable by the function
+   *read_persistence_intervals_in_one_dimension_from_file. All other parameters are optional. They are:
+   * (2) a Gaussian filter generated by create_Gaussian_filter filter (the default value of this variable is a Gaussian
+   *filter of a radius 5),
+   * (3) a boolean value which determines if the area of image below diagonal should, or should not be erased (it will
+   *be erased by default).
+   * (4) a number of pixels in each direction (set to 1000 by default).
+   * (5) a min x and y value of points that are to be taken into account. By default it is set to
+   *std::numeric_limits<double>::max(), in which case the program compute the values based on the data,
+   * (6) a max x and y value of points that are to be taken into account. By default it is set to
+   *std::numeric_limits<double>::max(), in which case the program compute the values based on the data.
+  **/
+  Persistence_heat_maps(const char* filename, std::vector<std::vector<double> > filter = create_Gaussian_filter(5, 1),
+                        bool erase_below_diagonal = false, size_t number_of_pixels = 1000,
+                        double min_ = std::numeric_limits<double>::max(),
+                        double max_ = std::numeric_limits<double>::max(),
+                        unsigned dimension = std::numeric_limits<unsigned>::max());
+
+  /**
+   * Compute a mean value of a collection of heat maps and store it in the current object. Note that all the persistence
+   *maps send in a vector to this procedure need to have the same parameters.
+   * If this is not the case, the program will throw an exception.
+  **/
+  void compute_mean(const std::vector<Persistence_heat_maps*>& maps);
+
+  /**
+   * Compute a median value of a collection of heat maps and store it in the current object. Note that all the
+   *persistence maps send in a vector to this procedure need to have the same parameters.
+   * If this is not the case, the program will throw an exception.
+  **/
+  void compute_median(const std::vector<Persistence_heat_maps*>& maps);
+
+  /**
+   * Compute a percentage of active (i.e) values above the cutoff of a collection of heat maps.
+  **/
+  void compute_percentage_of_active(const std::vector<Persistence_heat_maps*>& maps, size_t cutoff = 1);
+
+  // put to file subroutine
+  /**
+   * The function outputs the persistence image to a text file. The format as follow:
+   * In the first line, the values min and max of the image are stored
+   * In the next lines, we have the persistence images in a form of a bitmap image.
+  **/
+  void print_to_file(const char* filename) const;
+
+  /**
+   * A function that load a heat map from file to the current object (and erase whatever was stored in the current
+   *object before).
+  **/
+  void load_from_file(const char* filename);
+
+  /**
+   * The procedure checks if min_, max_ and this->heat_maps sizes are the same.
+  **/
+  inline bool check_if_the_same(const Persistence_heat_maps& second) const {
+    bool dbg = false;
+    if (this->heat_map.size() != second.heat_map.size()) {
+      if (dbg)
+        std::cerr << "this->heat_map.size() : " << this->heat_map.size()
+                  << " \n second.heat_map.size() : " << second.heat_map.size() << std::endl;
+      return false;
     }
-    /**
-	 * *= operator for Persistence_heat_maps.
-	**/ 
-    Persistence_heat_maps operator *= ( double x )
-    {
-        *this = *this*x;
-        return *this;
+    if (this->min_ != second.min_) {
+      if (dbg) std::cerr << "this->min_ : " << this->min_ << ", second.min_ : " << second.min_ << std::endl;
+      return false;
     }
-    /**
-	 * /= operator for Persistence_heat_maps.
-	**/ 
-    Persistence_heat_maps operator /= ( double x )
-    {
-        if ( x == 0 )throw( "In operator /=, division by 0. Program terminated." );
-        *this = *this * (1/x);
-        return *this;
+    if (this->max_ != second.max_) {
+      if (dbg) std::cerr << "this->max_ : " << this->max_ << ", second.max_ : " << second.max_ << std::endl;
+      return false;
     }
-    
-    
-    //Implementations of functions for various concepts.  
-    
-    /**
-	 * This function produce a vector of doubles based on a persistence heat map. It is required in a concept Vectorized_topological_data
-	*/
-    std::vector<double> vectorize( int number_of_function )const;    
-    /**
-	 * This function return the number of functions that allows vectorization of persistence heat map. It is required in a concept Vectorized_topological_data.
-	 **/ 
-	size_t number_of_vectorize_functions()const
-	{
-		return this->number_of_functions_for_vectorization;	
-	}
-	
-	/**	 
-	 * This function is required by the Real_valued_topological_data concept. It returns various projections on the persistence heat map to a real line.
-         * At the moment this function is not tested, since it is quite likely to be changed in the future. Given this, when using it, keep in mind that it
-         * will be most likely changed in the next versions.
-	**/ 	
-	double project_to_R( int number_of_function )const;	
-	/**
-	 * The function gives the number of possible projections to R. This function is required by the Real_valued_topological_data concept.
-	**/ 
-	size_t number_of_projections_to_R()const
-	{
-		return this->number_of_functions_for_projections_to_reals;
-	}
-	
-	/**
-	* A function to compute distance between persistence heat maps.
-	* The parameter of this function is a const reference to an object of a class Persistence_heat_maps.
-	* This function is required in Topological_data_with_distances concept.
-    * For max norm distance, set power to std::numeric_limits<double>::max()
-	**/
-	double distance( const Persistence_heat_maps& second_ , double power = 1)const;
-	
-	/**
-	 * A function to compute averaged persistence heat map, based on vector of persistence heat maps.
-	 * This function is required by Topological_data_with_averages concept.
-	**/ 	
-	void compute_average( const std::vector< Persistence_heat_maps* >& to_average );	
-	
-	/**
-	* A function to compute scalar product of persistence heat maps.
-	* The parameter of this function is a const reference to an object of a class Persistence_heat_maps.
-	* This function is required in Topological_data_with_scalar_product concept.
-	**/
-	double compute_scalar_product( const Persistence_heat_maps& second_ )const;
-	
-	//end of implementation of functions needed for concepts.
-	
-	
-	/**
-	 * The x-range of the persistence heat map. 
-	**/ 
-	std::pair< double , double > get_x_range()const
-	{
-		return std::make_pair( this->min_ , this->max_ );
-	}
-	
-	/**
-	 * The y-range of the persistence heat map. 
-	**/ 
-	std::pair< double , double > get_y_range()const
-	{
-		return this->get_x_range();
-	}
-	
-	
-	
-	
-protected:
-	//private methods
-	std::vector< std::vector<double> > check_and_initialize_maps( const std::vector<Persistence_heat_maps*>& maps );
-	size_t number_of_functions_for_vectorization;
-	size_t number_of_functions_for_projections_to_reals;
-    void construct( const std::vector< std::pair<double,double> >& intervals_  , 
-					std::vector< std::vector<double> > filter = create_Gaussian_filter(5,1),
-					                    
-                    bool erase_below_diagonal = false , size_t number_of_pixels = 1000 , double min_ = std::numeric_limits<double>::max() , double max_ = std::numeric_limits<double>::max() );
-                    
-	void set_up_parameters_for_basic_classes()
-	{
-		this->number_of_functions_for_vectorization = 1;
-		this->number_of_functions_for_projections_to_reals = 1;
-	}
-    
-    //data    
-    Scalling_of_kernels f;
-    bool erase_below_diagonal;
-    double min_;
-    double max_;
-    std::vector< std::vector< double > > heat_map;    
+    // in the other case we may assume that the persistence images are defined on the same domain.
+    return true;
+  }
+
+  /**
+   * Return minimal range value of persistent image.
+  **/
+  inline double get_min() const { return this->min_; }
+
+  /**
+   * Return maximal range value of persistent image.
+  **/
+  inline double get_max() const { return this->max_; }
+
+  /**
+   * Operator == to check if to persistence heat maps are the same.
+  **/
+  bool operator==(const Persistence_heat_maps& rhs) const {
+    bool dbg = false;
+    if (!this->check_if_the_same(rhs)) {
+      if (dbg) std::cerr << "The domains are not the same \n";
+      return false;  // in this case, the domains are not the same, so the maps cannot be the same.
+    }
+    for (size_t i = 0; i != this->heat_map.size(); ++i) {
+      for (size_t j = 0; j != this->heat_map[i].size(); ++j) {
+        if (!almost_equal(this->heat_map[i][j], rhs.heat_map[i][j])) {
+          if (dbg) {
+            std::cerr << "this->heat_map[" << i << "][" << j << "] = " << this->heat_map[i][j] << std::endl;
+            std::cerr << "rhs.heat_map[" << i << "][" << j << "] = " << rhs.heat_map[i][j] << std::endl;
+          }
+          return false;
+        }
+      }
+    }
+    return true;
+  }
+
+  /**
+   * Operator != to check if to persistence heat maps are different.
+  **/
+  bool operator!=(const Persistence_heat_maps& rhs) const { return !((*this) == rhs); }
+
+  /**
+   * A function to generate a gnuplot script to visualize the persistent image.
+  **/
+  void plot(const char* filename) const;
+
+  template <typename Operation_type>
+  friend Persistence_heat_maps operation_on_pair_of_heat_maps(const Persistence_heat_maps& first,
+                                                              const Persistence_heat_maps& second,
+                                                              Operation_type operation) {
+    // first check if the heat maps are compatible
+    if (!first.check_if_the_same(second)) {
+      std::cerr << "Sizes of the heat maps are not compatible. The program will now terminate \n";
+      throw "Sizes of the heat maps are not compatible. The program will now terminate \n";
+    }
+    Persistence_heat_maps result;
+    result.min_ = first.min_;
+    result.max_ = first.max_;
+    result.heat_map.reserve(first.heat_map.size());
+    for (size_t i = 0; i != first.heat_map.size(); ++i) {
+      std::vector<double> v;
+      v.reserve(first.heat_map[i].size());
+      for (size_t j = 0; j != first.heat_map[i].size(); ++j) {
+        v.push_back(operation(first.heat_map[i][j], second.heat_map[i][j]));
+      }
+      result.heat_map.push_back(v);
+    }
+    return result;
+  }  // operation_on_pair_of_heat_maps
+
+  /**
+   * Multiplication of Persistence_heat_maps by scalar (so that all values of the heat map gets multiplied by that
+   *scalar).
+  **/
+  Persistence_heat_maps multiply_by_scalar(double scalar) const {
+    Persistence_heat_maps result;
+    result.min_ = this->min_;
+    result.max_ = this->max_;
+    result.heat_map.reserve(this->heat_map.size());
+    for (size_t i = 0; i != this->heat_map.size(); ++i) {
+      std::vector<double> v;
+      v.reserve(this->heat_map[i].size());
+      for (size_t j = 0; j != this->heat_map[i].size(); ++j) {
+        v.push_back(this->heat_map[i][j] * scalar);
+      }
+      result.heat_map.push_back(v);
+    }
+    return result;
+  }
+
+  /**
+   * This function computes a sum of two objects of a type Persistence_heat_maps.
+  **/
+  friend Persistence_heat_maps operator+(const Persistence_heat_maps& first, const Persistence_heat_maps& second) {
+    return operation_on_pair_of_heat_maps(first, second, std::plus<double>());
+  }
+  /**
+* This function computes a difference of two objects of a type Persistence_heat_maps.
+**/
+  friend Persistence_heat_maps operator-(const Persistence_heat_maps& first, const Persistence_heat_maps& second) {
+    return operation_on_pair_of_heat_maps(first, second, std::minus<double>());
+  }
+  /**
+* This function computes a product of an object of a type Persistence_heat_maps with real number.
+**/
+  friend Persistence_heat_maps operator*(double scalar, const Persistence_heat_maps& A) {
+    return A.multiply_by_scalar(scalar);
+  }
+  /**
+* This function computes a product of an object of a type Persistence_heat_maps with real number.
+**/
+  friend Persistence_heat_maps operator*(const Persistence_heat_maps& A, double scalar) {
+    return A.multiply_by_scalar(scalar);
+  }
+  /**
+* This function computes a product of an object of a type Persistence_heat_maps with real number.
+**/
+  Persistence_heat_maps operator*(double scalar) { return this->multiply_by_scalar(scalar); }
+  /**
+   * += operator for Persistence_heat_maps.
+  **/
+  Persistence_heat_maps operator+=(const Persistence_heat_maps& rhs) {
+    *this = *this + rhs;
+    return *this;
+  }
+  /**
+       * -= operator for Persistence_heat_maps.
+      **/
+  Persistence_heat_maps operator-=(const Persistence_heat_maps& rhs) {
+    *this = *this - rhs;
+    return *this;
+  }
+  /**
+       * *= operator for Persistence_heat_maps.
+      **/
+  Persistence_heat_maps operator*=(double x) {
+    *this = *this * x;
+    return *this;
+  }
+  /**
+       * /= operator for Persistence_heat_maps.
+      **/
+  Persistence_heat_maps operator/=(double x) {
+    if (x == 0) throw("In operator /=, division by 0. Program terminated.");
+    *this = *this * (1 / x);
+    return *this;
+  }
+
+  // Implementations of functions for various concepts.
+
+  /**
+       * This function produce a vector of doubles based on a persistence heat map. It is required in a concept
+   * Vectorized_topological_data
+      */
+  std::vector<double> vectorize(int number_of_function) const;
+  /**
+       * This function return the number of functions that allows vectorization of persistence heat map. It is required
+    *in a concept Vectorized_topological_data.
+       **/
+  size_t number_of_vectorize_functions() const { return this->number_of_functions_for_vectorization; }
+
+  /**
+   * This function is required by the Real_valued_topological_data concept. It returns various projections on the
+   *persistence heat map to a real line.
+   * At the moment this function is not tested, since it is quite likely to be changed in the future. Given this, when
+   *using it, keep in mind that it
+   * will be most likely changed in the next versions.
+  **/
+  double project_to_R(int number_of_function) const;
+  /**
+   * The function gives the number of possible projections to R. This function is required by the
+   *Real_valued_topological_data concept.
+  **/
+  size_t number_of_projections_to_R() const { return this->number_of_functions_for_projections_to_reals; }
+
+  /**
+  * A function to compute distance between persistence heat maps.
+  * The parameter of this function is a const reference to an object of a class Persistence_heat_maps.
+  * This function is required in Topological_data_with_distances concept.
+* For max norm distance, set power to std::numeric_limits<double>::max()
+  **/
+  double distance(const Persistence_heat_maps& second_, double power = 1) const;
+
+  /**
+   * A function to compute averaged persistence heat map, based on vector of persistence heat maps.
+   * This function is required by Topological_data_with_averages concept.
+  **/
+  void compute_average(const std::vector<Persistence_heat_maps*>& to_average);
+
+  /**
+  * A function to compute scalar product of persistence heat maps.
+  * The parameter of this function is a const reference to an object of a class Persistence_heat_maps.
+  * This function is required in Topological_data_with_scalar_product concept.
+  **/
+  double compute_scalar_product(const Persistence_heat_maps& second_) const;
+
+  // end of implementation of functions needed for concepts.
+
+  /**
+   * The x-range of the persistence heat map.
+  **/
+  std::pair<double, double> get_x_range() const { return std::make_pair(this->min_, this->max_); }
+
+  /**
+   * The y-range of the persistence heat map.
+  **/
+  std::pair<double, double> get_y_range() const { return this->get_x_range(); }
+
+ protected:
+  // private methods
+  std::vector<std::vector<double> > check_and_initialize_maps(const std::vector<Persistence_heat_maps*>& maps);
+  size_t number_of_functions_for_vectorization;
+  size_t number_of_functions_for_projections_to_reals;
+  void construct(const std::vector<std::pair<double, double> >& intervals_,
+                 std::vector<std::vector<double> > filter = create_Gaussian_filter(5, 1),
+
+                 bool erase_below_diagonal = false, size_t number_of_pixels = 1000,
+                 double min_ = std::numeric_limits<double>::max(), double max_ = std::numeric_limits<double>::max());
+
+  void set_up_parameters_for_basic_classes() {
+    this->number_of_functions_for_vectorization = 1;
+    this->number_of_functions_for_projections_to_reals = 1;
+  }
+
+  // data
+  Scalling_of_kernels f;
+  bool erase_below_diagonal;
+  double min_;
+  double max_;
+  std::vector<std::vector<double> > heat_map;
 };
 
-
-//if min_ == max_, then the program is requested to set up the values itself based on persistence intervals
+// if min_ == max_, then the program is requested to set up the values itself based on persistence intervals
 template <typename Scalling_of_kernels>
-void Persistence_heat_maps<Scalling_of_kernels>::construct( const std::vector< std::pair<double,double> >& intervals_  ,  
-									   std::vector< std::vector<double> > filter,									   
-									   bool erase_below_diagonal , size_t number_of_pixels , double min_ , double max_ )
-{
-    bool dbg = false;       
-    if ( dbg )std::cerr << "Entering construct procedure \n";
-    Scalling_of_kernels f;
-    this->f = f;
-    
-    if ( dbg )std::cerr << "min and max passed to construct() procedure: " << min_ << " " << max_ << std::endl;
-
-    if ( min_ == max_ )
-    {
-		if (dbg)std::cerr << "min and max parameters will be determined based on intervals \n";
-        //in this case, we want the program to set up the min_ and max_ values by itself.
-        min_ = std::numeric_limits<int>::max();
-        max_ = -std::numeric_limits<int>::max();
-        
-        
-        for ( size_t i = 0 ; i != intervals_.size() ; ++i )
-        {
-			if ( intervals_[i].first < min_ )min_ = intervals_[i].first;
-			if ( intervals_[i].second > max_ )max_ = intervals_[i].second;
-		}
-        //now we have the structure filled in, and moreover we know min_ and max_ values of the interval, so we know the range.
-
-        //add some more space:
-        min_ -= fabs(max_ - min_)/100;
-        max_ += fabs(max_ - min_)/100;
+void Persistence_heat_maps<Scalling_of_kernels>::construct(const std::vector<std::pair<double, double> >& intervals_,
+                                                           std::vector<std::vector<double> > filter,
+                                                           bool erase_below_diagonal, size_t number_of_pixels,
+                                                           double min_, double max_) {
+  bool dbg = false;
+  if (dbg) std::cerr << "Entering construct procedure \n";
+  Scalling_of_kernels f;
+  this->f = f;
+
+  if (dbg) std::cerr << "min and max passed to construct() procedure: " << min_ << " " << max_ << std::endl;
+
+  if (min_ == max_) {
+    if (dbg) std::cerr << "min and max parameters will be determined based on intervals \n";
+    // in this case, we want the program to set up the min_ and max_ values by itself.
+    min_ = std::numeric_limits<int>::max();
+    max_ = -std::numeric_limits<int>::max();
+
+    for (size_t i = 0; i != intervals_.size(); ++i) {
+      if (intervals_[i].first < min_) min_ = intervals_[i].first;
+      if (intervals_[i].second > max_) max_ = intervals_[i].second;
+    }
+    // now we have the structure filled in, and moreover we know min_ and max_ values of the interval, so we know the
+    // range.
+
+    // add some more space:
+    min_ -= fabs(max_ - min_) / 100;
+    max_ += fabs(max_ - min_) / 100;
+  }
+
+  if (dbg) {
+    std::cerr << "min_ : " << min_ << std::endl;
+    std::cerr << "max_ : " << max_ << std::endl;
+    std::cerr << "number_of_pixels : " << number_of_pixels << std::endl;
+    getchar();
+  }
+
+  this->min_ = min_;
+  this->max_ = max_;
+
+  // initialization of the structure heat_map
+  std::vector<std::vector<double> > heat_map_;
+  for (size_t i = 0; i != number_of_pixels; ++i) {
+    std::vector<double> v(number_of_pixels, 0);
+    heat_map_.push_back(v);
+  }
+  this->heat_map = heat_map_;
+
+  if (dbg) std::cerr << "Done creating of the heat map, now we will fill in the structure \n";
+
+  for (size_t pt_nr = 0; pt_nr != intervals_.size(); ++pt_nr) {
+    // compute the value of intervals_[pt_nr] in the grid:
+    int x_grid = (int)((intervals_[pt_nr].first - this->min_) / (this->max_ - this->min_) * number_of_pixels);
+    int y_grid = (int)((intervals_[pt_nr].second - this->min_) / (this->max_ - this->min_) * number_of_pixels);
+
+    if (dbg) {
+      std::cerr << "point : " << intervals_[pt_nr].first << " , " << intervals_[pt_nr].second << std::endl;
+      std::cerr << "x_grid : " << x_grid << std::endl;
+      std::cerr << "y_grid : " << y_grid << std::endl;
     }
 
-	if ( dbg )
-	{
-		std::cerr << "min_ : " << min_ << std::endl;
-		std::cerr << "max_ : " << max_ << std::endl;
-		std::cerr << "number_of_pixels : " << number_of_pixels << std::endl;
-		getchar();
-	}
-
-    this->min_ = min_;
-    this->max_ = max_;        
-
-    //initialization of the structure heat_map
-    std::vector< std::vector<double> > heat_map_;
-    for ( size_t i = 0 ; i != number_of_pixels ; ++i )
-    {       
-		std::vector<double> v( number_of_pixels , 0 );
-        heat_map_.push_back( v );
+    // x_grid and y_grid gives a center of the kernel. We want to have its lower left corner. To get this, we need to
+    // shift x_grid and y_grid by a grid diameter.
+    x_grid -= filter.size() / 2;
+    y_grid -= filter.size() / 2;
+    // note that the numbers x_grid and y_grid may be negative.
+
+    if (dbg) {
+      std::cerr << "After shift : \n";
+      ;
+      std::cerr << "x_grid : " << x_grid << std::endl;
+      std::cerr << "y_grid : " << y_grid << std::endl;
     }
-    this->heat_map = heat_map_;
-
-    if (dbg)std::cerr << "Done creating of the heat map, now we will fill in the structure \n";
-
-	for ( size_t pt_nr = 0 ; pt_nr != intervals_.size() ; ++pt_nr )
-	{
-		//compute the value of intervals_[pt_nr] in the grid:
-		int x_grid = (int)((intervals_[pt_nr].first - this->min_)/( this->max_-this->min_ )*number_of_pixels);
-		int y_grid = (int)((intervals_[pt_nr].second - this->min_)/( this->max_-this->min_ )*number_of_pixels);
-		
-		if ( dbg )
-		{
-			std::cerr << "point : " << intervals_[pt_nr].first << " , " << intervals_[pt_nr].second << std::endl;
-			std::cerr << "x_grid : " << x_grid << std::endl;
-			std::cerr << "y_grid : " << y_grid << std::endl;
-		}
-		
-		//x_grid and y_grid gives a center of the kernel. We want to have its lower left corner. To get this, we need to shift x_grid and y_grid by a grid diameter.		
-		x_grid -= filter.size()/2;
-		y_grid -= filter.size()/2;
-		//note that the numbers x_grid and y_grid may be negative. 
-		
-		if ( dbg )
-		{
-			std::cerr << "After shift : \n";;
-			std::cerr << "x_grid : " << x_grid << std::endl;
-			std::cerr << "y_grid : " << y_grid << std::endl;
-		}
-				
-		double scaling_value = this->f(intervals_[pt_nr]);
-
-		
-		for ( size_t i = 0 ; i != filter.size() ; ++i )
-		{
-			for ( size_t j = 0 ; j != filter.size() ; ++j )
-			{			
-				//if the point (x_grid+i,y_grid+j) is the correct point in the grid.						
-				if ( 
-					  ((x_grid+i)>=0) && (x_grid+i<this->heat_map.size()) 
-					  &&
-					  ((y_grid+j)>=0) && (y_grid+j<this->heat_map.size()) 
-				   )
-				{
-					if ( dbg ){std::cerr << y_grid+j << " " <<  x_grid+i << std::endl;}
-					this->heat_map[ y_grid+j ][ x_grid+i ] += scaling_value * filter[i][j];
-					if ( dbg )
-					{
-						std::cerr << "Position : (" << x_grid+i << "," << y_grid+j << ") got increased by the value : " << filter[i][j] << std::endl;
-					}					
-				}
-			}
-		}
-		
-	}
-	
-	//now it remains to cut everything below diagonal if the user wants us to. 
-	if ( erase_below_diagonal )
-	{
-		for ( size_t i = 0 ; i != this->heat_map.size() ; ++i )
-		{
-			for ( size_t j = i ; j != this->heat_map.size() ; ++j )
-			{
-				this->heat_map[i][j] = 0;
-			}
-		}
-	}
-}//construct
+
+    double scaling_value = this->f(intervals_[pt_nr]);
+
+    for (size_t i = 0; i != filter.size(); ++i) {
+      for (size_t j = 0; j != filter.size(); ++j) {
+        // if the point (x_grid+i,y_grid+j) is the correct point in the grid.
+        if (((x_grid + i) >= 0) && (x_grid + i < this->heat_map.size()) && ((y_grid + j) >= 0) &&
+            (y_grid + j < this->heat_map.size())) {
+          if (dbg) {
+            std::cerr << y_grid + j << " " << x_grid + i << std::endl;
+          }
+          this->heat_map[y_grid + j][x_grid + i] += scaling_value * filter[i][j];
+          if (dbg) {
+            std::cerr << "Position : (" << x_grid + i << "," << y_grid + j
+                      << ") got increased by the value : " << filter[i][j] << std::endl;
+          }
+        }
+      }
+    }
+  }
+
+  // now it remains to cut everything below diagonal if the user wants us to.
+  if (erase_below_diagonal) {
+    for (size_t i = 0; i != this->heat_map.size(); ++i) {
+      for (size_t j = i; j != this->heat_map.size(); ++j) {
+        this->heat_map[i][j] = 0;
+      }
+    }
+  }
+}  // construct
 
 template <typename Scalling_of_kernels>
-Persistence_heat_maps<Scalling_of_kernels>::Persistence_heat_maps( const std::vector< std::pair< double,double > >  & interval , 
-											  std::vector< std::vector<double> > filter,  
-											  bool erase_below_diagonal , size_t number_of_pixels , double min_ , double max_ )
-{
-    this->construct( interval ,  filter , erase_below_diagonal , number_of_pixels , min_ , max_ );
-    this->set_up_parameters_for_basic_classes();
+Persistence_heat_maps<Scalling_of_kernels>::Persistence_heat_maps(
+    const std::vector<std::pair<double, double> >& interval, std::vector<std::vector<double> > filter,
+    bool erase_below_diagonal, size_t number_of_pixels, double min_, double max_) {
+  this->construct(interval, filter, erase_below_diagonal, number_of_pixels, min_, max_);
+  this->set_up_parameters_for_basic_classes();
 }
 
-
 template <typename Scalling_of_kernels>
-Persistence_heat_maps<Scalling_of_kernels>::Persistence_heat_maps( const char* filename , 
-											  std::vector< std::vector<double> > filter, 											  
-											  bool erase_below_diagonal , size_t number_of_pixels  , double min_ , double max_ , unsigned dimension )
-{    
-    std::vector< std::pair< double , double > > intervals_;
-    if ( dimension == std::numeric_limits<unsigned>::max() )
-    {
-     intervals_ = read_persistence_intervals_in_one_dimension_from_file( filename );
-    }
-    else
-    {
-     intervals_ = read_persistence_intervals_in_one_dimension_from_file( filename , dimension );
-    }    
-    this->construct( intervals_ ,  filter, erase_below_diagonal , number_of_pixels , min_ , max_ );    
-    this->set_up_parameters_for_basic_classes();
+Persistence_heat_maps<Scalling_of_kernels>::Persistence_heat_maps(const char* filename,
+                                                                  std::vector<std::vector<double> > filter,
+                                                                  bool erase_below_diagonal, size_t number_of_pixels,
+                                                                  double min_, double max_, unsigned dimension) {
+  std::vector<std::pair<double, double> > intervals_;
+  if (dimension == std::numeric_limits<unsigned>::max()) {
+    intervals_ = read_persistence_intervals_in_one_dimension_from_file(filename);
+  } else {
+    intervals_ = read_persistence_intervals_in_one_dimension_from_file(filename, dimension);
+  }
+  this->construct(intervals_, filter, erase_below_diagonal, number_of_pixels, min_, max_);
+  this->set_up_parameters_for_basic_classes();
 }
 
-
 template <typename Scalling_of_kernels>
-std::vector< std::vector<double> > Persistence_heat_maps<Scalling_of_kernels>::check_and_initialize_maps( const std::vector<Persistence_heat_maps*>& maps )
-{
-	//checking if all the heat maps are of the same size:
-	for ( size_t i = 0 ; i != maps.size() ; ++i )
-    {
-		if ( maps[i]->heat_map.size() != maps[0]->heat_map.size() )
-		{
-			std::cerr << "Sizes of Persistence_heat_maps are not compatible. The program will terminate now \n";
-			throw "Sizes of Persistence_heat_maps are not compatible. The program will terminate now \n";
-		}
-		if ( maps[i]->heat_map[0].size() != maps[0]->heat_map[0].size() )
-		{
-			std::cerr << "Sizes of Persistence_heat_maps are not compatible. The program will terminate now \n";
-			throw "Sizes of Persistence_heat_maps are not compatible. The program will terminate now \n";			
-		}
-	} 	
-	std::vector< std::vector<double> > heat_maps( maps[0]->heat_map.size() );
-	for ( size_t i = 0 ; i != maps[0]->heat_map.size() ; ++i )
-    {
-		 std::vector<double> v( maps[0]->heat_map[0].size() , 0 );
-		 heat_maps[i] = v;
-	}
-	return heat_maps;
+std::vector<std::vector<double> > Persistence_heat_maps<Scalling_of_kernels>::check_and_initialize_maps(
+    const std::vector<Persistence_heat_maps*>& maps) {
+  // checking if all the heat maps are of the same size:
+  for (size_t i = 0; i != maps.size(); ++i) {
+    if (maps[i]->heat_map.size() != maps[0]->heat_map.size()) {
+      std::cerr << "Sizes of Persistence_heat_maps are not compatible. The program will terminate now \n";
+      throw "Sizes of Persistence_heat_maps are not compatible. The program will terminate now \n";
+    }
+    if (maps[i]->heat_map[0].size() != maps[0]->heat_map[0].size()) {
+      std::cerr << "Sizes of Persistence_heat_maps are not compatible. The program will terminate now \n";
+      throw "Sizes of Persistence_heat_maps are not compatible. The program will terminate now \n";
+    }
+  }
+  std::vector<std::vector<double> > heat_maps(maps[0]->heat_map.size());
+  for (size_t i = 0; i != maps[0]->heat_map.size(); ++i) {
+    std::vector<double> v(maps[0]->heat_map[0].size(), 0);
+    heat_maps[i] = v;
+  }
+  return heat_maps;
 }
 
 template <typename Scalling_of_kernels>
-void Persistence_heat_maps<Scalling_of_kernels>::compute_median( const std::vector<Persistence_heat_maps*>& maps )
-{
-	std::vector< std::vector<double> > heat_maps = this->check_and_initialize_maps( maps );
-	
-	std::vector<double> to_compute_median( maps.size() );
-    for ( size_t i = 0 ; i != heat_maps.size() ; ++i )
-    {
-        for ( size_t j = 0 ; j != heat_maps[i].size() ; ++j )
-        {
-			for ( size_t map_no = 0 ; map_no != maps.size() ; ++map_no )
-			{
-				to_compute_median[map_no] = maps[map_no]->heat_map[i][j];
-			}
-			std::nth_element(to_compute_median.begin(), to_compute_median.begin() + to_compute_median.size()/2, to_compute_median.end());
-            heat_maps[i][j] = to_compute_median[ to_compute_median.size()/2 ];
-        }       
+void Persistence_heat_maps<Scalling_of_kernels>::compute_median(const std::vector<Persistence_heat_maps*>& maps) {
+  std::vector<std::vector<double> > heat_maps = this->check_and_initialize_maps(maps);
+
+  std::vector<double> to_compute_median(maps.size());
+  for (size_t i = 0; i != heat_maps.size(); ++i) {
+    for (size_t j = 0; j != heat_maps[i].size(); ++j) {
+      for (size_t map_no = 0; map_no != maps.size(); ++map_no) {
+        to_compute_median[map_no] = maps[map_no]->heat_map[i][j];
+      }
+      std::nth_element(to_compute_median.begin(), to_compute_median.begin() + to_compute_median.size() / 2,
+                       to_compute_median.end());
+      heat_maps[i][j] = to_compute_median[to_compute_median.size() / 2];
     }
-	this->heat_map = heat_maps;
-	this->min_= maps[0]->min_;
-	this->max_= maps[0]->max_;
+  }
+  this->heat_map = heat_maps;
+  this->min_ = maps[0]->min_;
+  this->max_ = maps[0]->max_;
 }
 
-
 template <typename Scalling_of_kernels>
-void Persistence_heat_maps<Scalling_of_kernels>::compute_mean( const std::vector<Persistence_heat_maps*>& maps )
-{
-	std::vector< std::vector<double> > heat_maps = this->check_and_initialize_maps( maps );
-		    for ( size_t i = 0 ; i != heat_maps.size() ; ++i )
-    {
-        for ( size_t j = 0 ; j != heat_maps[i].size() ; ++j )
-        {
-			double mean = 0;
-			for ( size_t map_no = 0 ; map_no != maps.size() ; ++map_no )
-			{	
-				mean += maps[map_no]->heat_map[i][j];
-			}		
-            heat_maps[i][j] =  mean/(double)maps.size();
-        }       
+void Persistence_heat_maps<Scalling_of_kernels>::compute_mean(const std::vector<Persistence_heat_maps*>& maps) {
+  std::vector<std::vector<double> > heat_maps = this->check_and_initialize_maps(maps);
+  for (size_t i = 0; i != heat_maps.size(); ++i) {
+    for (size_t j = 0; j != heat_maps[i].size(); ++j) {
+      double mean = 0;
+      for (size_t map_no = 0; map_no != maps.size(); ++map_no) {
+        mean += maps[map_no]->heat_map[i][j];
+      }
+      heat_maps[i][j] = mean / (double)maps.size();
     }
-	this->heat_map = heat_maps;
-	this->min_ = maps[0]->min_;
-	this->max_ = maps[0]->max_;
+  }
+  this->heat_map = heat_maps;
+  this->min_ = maps[0]->min_;
+  this->max_ = maps[0]->max_;
 }
 
-
-
 template <typename Scalling_of_kernels>
-void Persistence_heat_maps<Scalling_of_kernels>::compute_percentage_of_active( const std::vector<Persistence_heat_maps*>& maps , size_t cutoff  )
-{
-	std::vector< std::vector<double> > heat_maps = this->check_and_initialize_maps( maps );
-
-    for ( size_t i = 0 ; i != heat_maps.size() ; ++i )
-    {
-        for ( size_t j = 0 ; j != heat_maps[i].size() ; ++j )
-        {
-            size_t number_of_active_levels = 0;
-            for ( size_t map_no = 0 ; map_no != maps.size() ; ++map_no )
-            {
-                if ( maps[map_no]->heat_map[i][j] ) number_of_active_levels++;
-            }
-            if ( number_of_active_levels > cutoff )
-            {
-                heat_maps[i][j] = number_of_active_levels;
-            }
-            else
-            {
-                heat_maps[i][j] = 0;
-            }
-        }       
+void Persistence_heat_maps<Scalling_of_kernels>::compute_percentage_of_active(
+    const std::vector<Persistence_heat_maps*>& maps, size_t cutoff) {
+  std::vector<std::vector<double> > heat_maps = this->check_and_initialize_maps(maps);
+
+  for (size_t i = 0; i != heat_maps.size(); ++i) {
+    for (size_t j = 0; j != heat_maps[i].size(); ++j) {
+      size_t number_of_active_levels = 0;
+      for (size_t map_no = 0; map_no != maps.size(); ++map_no) {
+        if (maps[map_no]->heat_map[i][j]) number_of_active_levels++;
+      }
+      if (number_of_active_levels > cutoff) {
+        heat_maps[i][j] = number_of_active_levels;
+      } else {
+        heat_maps[i][j] = 0;
+      }
     }
-    this->heat_map = heat_maps;
-    this->min_ = maps[0]->min_;
-	this->max_ = maps[0]->max_;
+  }
+  this->heat_map = heat_maps;
+  this->min_ = maps[0]->min_;
+  this->max_ = maps[0]->max_;
 }
 
-
 template <typename Scalling_of_kernels>
-void Persistence_heat_maps<Scalling_of_kernels>::plot( const char* filename )const
-{
-	std::ofstream out;
-	std::stringstream ss;
-	ss << filename << "_GnuplotScript";
-	
-    out.open( ss.str().c_str() );
-	out << "plot      '-' matrix with image" << std::endl;
-    for ( size_t i = 0 ; i != this->heat_map.size() ; ++i )
-    {
-        for ( size_t j = 0 ; j != this->heat_map[i].size() ; ++j )
-        {
-            out << this->heat_map[i][j] << " ";
-        }
-        out << std::endl;
+void Persistence_heat_maps<Scalling_of_kernels>::plot(const char* filename) const {
+  std::ofstream out;
+  std::stringstream ss;
+  ss << filename << "_GnuplotScript";
+
+  out.open(ss.str().c_str());
+  out << "plot      '-' matrix with image" << std::endl;
+  for (size_t i = 0; i != this->heat_map.size(); ++i) {
+    for (size_t j = 0; j != this->heat_map[i].size(); ++j) {
+      out << this->heat_map[i][j] << " ";
     }
-    out.close();
-    std::cout << "Gnuplot script have been created. Open gnuplot and type load \'" << ss.str().c_str() << "\' to see the picture." << std::endl; 
+    out << std::endl;
+  }
+  out.close();
+  std::cout << "Gnuplot script have been created. Open gnuplot and type load \'" << ss.str().c_str()
+            << "\' to see the picture." << std::endl;
 }
 
-
 template <typename Scalling_of_kernels>
-void Persistence_heat_maps<Scalling_of_kernels>::print_to_file( const char* filename )const
-{
-
-	std::ofstream out;
-	out.open( filename );
-	
-	//First we store this->min_ and this->max_ values:
-	out << this->min_ << " " << this->max_ << std::endl;	
-	for ( size_t i = 0 ; i != this->heat_map.size() ; ++i )
-    {
-        for ( size_t j = 0 ; j != this->heat_map[i].size() ; ++j )
-        {
-            out << this->heat_map[i][j] << " ";
-        }
-        out << std::endl;
+void Persistence_heat_maps<Scalling_of_kernels>::print_to_file(const char* filename) const {
+  std::ofstream out;
+  out.open(filename);
+
+  // First we store this->min_ and this->max_ values:
+  out << this->min_ << " " << this->max_ << std::endl;
+  for (size_t i = 0; i != this->heat_map.size(); ++i) {
+    for (size_t j = 0; j != this->heat_map[i].size(); ++j) {
+      out << this->heat_map[i][j] << " ";
     }
-	out.close();
+    out << std::endl;
+  }
+  out.close();
 }
 
 template <typename Scalling_of_kernels>
-void Persistence_heat_maps<Scalling_of_kernels>::load_from_file( const char* filename )
-{
-	bool dbg = false;	
-	
-	std::ifstream in;
-	in.open( filename );
-	
-	//checking if the file exist / if it was open. 
-	if ( !in.good() )
-	{
-		std::cerr << "The file : " << filename << " do not exist. The program will now terminate \n";
-		throw "The file from which you are trying to read the persistence landscape do not exist. The program will now terminate \n";
-	}
-	
-	//now we read the file one by one. 
-	
-	 
-	 
-	in >> this->min_ >> this->max_;	    
-	if ( dbg )
-	{
-		std::cerr << "Reading the following values of min and max : " << this->min_ << " , " << this->max_ << std::endl;
-	}
-
-	std::string temp;
-	std::getline(in, temp);
-         
-	while (!in.eof())
-	{
-		std::getline(in, temp);
-        std::stringstream lineSS;
-        lineSS << temp;
-        
-        std::vector<double> line_of_heat_map;    
-        while ( lineSS.good() )
-        {
-			double point;
-			
-			lineSS >> point;
-			line_of_heat_map.push_back( point );
-			if ( dbg )
-			{
-				std::cout << point << " ";
-			}
-		}
-		if ( dbg )
-		{
-			std::cout << std::endl;
-			getchar();
-		}
-
-		if ( in.good() )this->heat_map.push_back( line_of_heat_map );
-	}	
-	in.close();
-	if ( dbg )std::cout << "Done \n";
+void Persistence_heat_maps<Scalling_of_kernels>::load_from_file(const char* filename) {
+  bool dbg = false;
+
+  std::ifstream in;
+  in.open(filename);
+
+  // checking if the file exist / if it was open.
+  if (!in.good()) {
+    std::cerr << "The file : " << filename << " do not exist. The program will now terminate \n";
+    throw "The file from which you are trying to read the persistence landscape do not exist. The program will now terminate \n";
+  }
+
+  // now we read the file one by one.
+
+  in >> this->min_ >> this->max_;
+  if (dbg) {
+    std::cerr << "Reading the following values of min and max : " << this->min_ << " , " << this->max_ << std::endl;
+  }
+
+  std::string temp;
+  std::getline(in, temp);
+
+  while (!in.eof()) {
+    std::getline(in, temp);
+    std::stringstream lineSS;
+    lineSS << temp;
+
+    std::vector<double> line_of_heat_map;
+    while (lineSS.good()) {
+      double point;
+
+      lineSS >> point;
+      line_of_heat_map.push_back(point);
+      if (dbg) {
+        std::cout << point << " ";
+      }
+    }
+    if (dbg) {
+      std::cout << std::endl;
+      getchar();
+    }
+
+    if (in.good()) this->heat_map.push_back(line_of_heat_map);
+  }
+  in.close();
+  if (dbg) std::cout << "Done \n";
 }
 
+// Concretizations of virtual methods:
+template <typename Scalling_of_kernels>
+std::vector<double> Persistence_heat_maps<Scalling_of_kernels>::vectorize(int number_of_function) const {
+  // convert this->heat_map into one large vector:
+  size_t size_of_result = 0;
+  for (size_t i = 0; i != this->heat_map.size(); ++i) {
+    size_of_result += this->heat_map[i].size();
+  }
+
+  std::vector<double> result;
+  result.reserve(size_of_result);
+
+  for (size_t i = 0; i != this->heat_map.size(); ++i) {
+    for (size_t j = 0; j != this->heat_map[i].size(); ++j) {
+      result.push_back(this->heat_map[i][j]);
+    }
+  }
 
-//Concretizations of virtual methods:   
-template <typename Scalling_of_kernels> 
-std::vector<double> Persistence_heat_maps<Scalling_of_kernels>::vectorize( int number_of_function )const
-{
-	//convert this->heat_map into one large vector:
-	size_t size_of_result = 0;
-	for ( size_t i = 0 ; i != this->heat_map.size() ; ++i )
-	{
-		size_of_result += this->heat_map[i].size();
-	}
-	
-	std::vector< double > result;
-	result.reserve( size_of_result );
-	
-	for ( size_t i = 0 ; i != this->heat_map.size() ; ++i )
-	{
-		for ( size_t j = 0 ; j != this->heat_map[i].size() ; ++j )
-		{
-			result.push_back( this->heat_map[i][j] );
-		}
-	}
-	
-	return result;
+  return result;
 }
 
 template <typename Scalling_of_kernels>
-double Persistence_heat_maps<Scalling_of_kernels>::distance( const Persistence_heat_maps& second , double power )const
-{			
-	//first we need to check if (*this) and second are defined on the same domain and have the same dimensions:
-	if ( !this->check_if_the_same(second) )
-	{
-		std::cerr << "The persistence images are of non compatible sizes. We cannot therefore compute distance between them. The program will now terminate";
-		throw "The persistence images are of non compatible sizes. We cannot therefore compute distance between them. The program will now terminate";
-	}
-	
-	//if we are here, we know that the two persistence images are defined on the same domain, so we can start computing their distances:
-	
-	double distance = 0;
-	if ( power < std::numeric_limits<double>::max() )
-	{
-		for ( size_t i = 0 ; i != this->heat_map.size() ; ++i )
-		{
-			for ( size_t j = 0 ; j != this->heat_map[i].size() ; ++j )
-			{
-				distance += pow( fabs(this->heat_map[i][j] - second.heat_map[i][j]) , power );
-			}
-		}
-	}
-	else
-	{		
-		//in this case, we compute max norm distance
-		for ( size_t i = 0 ; i != this->heat_map.size() ; ++i )
-		{
-			for ( size_t j = 0 ; j != this->heat_map[i].size() ; ++j )
-			{
-				if ( distance < fabs(this->heat_map[i][j] - second.heat_map[i][j]) )
-				{
-					distance = fabs(this->heat_map[i][j] - second.heat_map[i][j]);
-				}
-			}
-		}
-	}
-	return distance;
+double Persistence_heat_maps<Scalling_of_kernels>::distance(const Persistence_heat_maps& second, double power) const {
+  // first we need to check if (*this) and second are defined on the same domain and have the same dimensions:
+  if (!this->check_if_the_same(second)) {
+    std::cerr << "The persistence images are of non compatible sizes. We cannot therefore compute distance between "
+                 "them. The program will now terminate";
+    throw "The persistence images are of non compatible sizes. We cannot therefore compute distance between them. The program will now terminate";
+  }
+
+  // if we are here, we know that the two persistence images are defined on the same domain, so we can start computing
+  // their distances:
+
+  double distance = 0;
+  if (power < std::numeric_limits<double>::max()) {
+    for (size_t i = 0; i != this->heat_map.size(); ++i) {
+      for (size_t j = 0; j != this->heat_map[i].size(); ++j) {
+        distance += pow(fabs(this->heat_map[i][j] - second.heat_map[i][j]), power);
+      }
+    }
+  } else {
+    // in this case, we compute max norm distance
+    for (size_t i = 0; i != this->heat_map.size(); ++i) {
+      for (size_t j = 0; j != this->heat_map[i].size(); ++j) {
+        if (distance < fabs(this->heat_map[i][j] - second.heat_map[i][j])) {
+          distance = fabs(this->heat_map[i][j] - second.heat_map[i][j]);
+        }
+      }
+    }
+  }
+  return distance;
 }
 
 template <typename Scalling_of_kernels>
-double Persistence_heat_maps<Scalling_of_kernels>::project_to_R( int number_of_function )const
-{
-	double result = 0;
-	for ( size_t i = 0 ; i != this->heat_map.size() ; ++i )
-	{
-		for ( size_t j = 0 ; j != this->heat_map[i].size() ; ++j )
-		{
-			result += this->heat_map[i][j];
-		}
-	}
-	return result;
+double Persistence_heat_maps<Scalling_of_kernels>::project_to_R(int number_of_function) const {
+  double result = 0;
+  for (size_t i = 0; i != this->heat_map.size(); ++i) {
+    for (size_t j = 0; j != this->heat_map[i].size(); ++j) {
+      result += this->heat_map[i][j];
+    }
+  }
+  return result;
 }
 
 template <typename Scalling_of_kernels>
-void Persistence_heat_maps<Scalling_of_kernels>::compute_average( const std::vector< Persistence_heat_maps* >& to_average )
-{				
-	this->compute_mean( to_average );
+void Persistence_heat_maps<Scalling_of_kernels>::compute_average(
+    const std::vector<Persistence_heat_maps*>& to_average) {
+  this->compute_mean(to_average);
 }
 
 template <typename Scalling_of_kernels>
-double Persistence_heat_maps<Scalling_of_kernels>::compute_scalar_product( const Persistence_heat_maps& second )const
-{		
-	//first we need to check if (*this) and second are defined on the same domain and have the same dimensions:
-	if ( !this->check_if_the_same(second) )
-	{
-		std::cerr << "The persistence images are of non compatible sizes. We cannot therefore compute distance between them. The program will now terminate";
-		throw "The persistence images are of non compatible sizes. We cannot therefore compute distance between them. The program will now terminate";
-	}
-	
-	//if we are here, we know that the two persistence images are defined on the same domain, so we can start computing their scalar product:
-	double scalar_prod = 0;
-	for ( size_t i = 0 ; i != this->heat_map.size() ; ++i )
-	{
-		for ( size_t j = 0 ; j != this->heat_map[i].size() ; ++j )
-		{
-			scalar_prod += this->heat_map[i][j]*second.heat_map[i][j];
-		}
-	}
-	return scalar_prod;
+double Persistence_heat_maps<Scalling_of_kernels>::compute_scalar_product(const Persistence_heat_maps& second) const {
+  // first we need to check if (*this) and second are defined on the same domain and have the same dimensions:
+  if (!this->check_if_the_same(second)) {
+    std::cerr << "The persistence images are of non compatible sizes. We cannot therefore compute distance between "
+                 "them. The program will now terminate";
+    throw "The persistence images are of non compatible sizes. We cannot therefore compute distance between them. The program will now terminate";
+  }
+
+  // if we are here, we know that the two persistence images are defined on the same domain, so we can start computing
+  // their scalar product:
+  double scalar_prod = 0;
+  for (size_t i = 0; i != this->heat_map.size(); ++i) {
+    for (size_t j = 0; j != this->heat_map[i].size(); ++j) {
+      scalar_prod += this->heat_map[i][j] * second.heat_map[i][j];
+    }
+  }
+  return scalar_prod;
 }
 
-
-
-
 }  // namespace Persistence_representations
 }  // namespace Gudhi
 
-
 #endif  // PERSISTENCE_HEAT_MAPS_H_
diff --git a/src/Persistence_representations/include/gudhi/Persistence_intervals.h b/src/Persistence_representations/include/gudhi/Persistence_intervals.h
index 40c24670..2a1c6283 100644
--- a/src/Persistence_representations/include/gudhi/Persistence_intervals.h
+++ b/src/Persistence_representations/include/gudhi/Persistence_intervals.h
@@ -23,10 +23,10 @@
 #ifndef PERSISTENCE_INTERVALS_H_
 #define PERSISTENCE_INTERVALS_H_
 
-//gudhi include
+// gudhi include
 #include <gudhi/read_persistence_from_file.h>
 
-//standard include
+// standard include
 #include <limits>
 #include <iostream>
 #include <fstream>
@@ -36,601 +36,532 @@
 #include <cmath>
 #include <functional>
 
-namespace Gudhi 
-{
-namespace Persistence_representations 
-{
+namespace Gudhi {
+namespace Persistence_representations {
 
 /**
- * This class implements the following concepts: Vectorized_topological_data, Topological_data_with_distances, Real_valued_topological_data
-**/ 
-class Persistence_intervals
-{
-public:	   
-	/**
-	 * This is a constructor of a class Persistence_intervals from a text file. Each line of the input file is supposed to contain two numbers of a type double (or convertible to double)
-	 * representing the birth and the death of the persistence interval. If the pairs are not sorted so that birth <= death, then the constructor will sort then that way. 
-	 * * The second parameter of a constructor is a dimension of intervals to be read from a file. If your file contains only birth-death pairs, use the default value.
-	**/ 
-    Persistence_intervals( const char* filename , unsigned dimension = std::numeric_limits<unsigned>::max() );
-    
-    /**
-     * This is a constructor of a class Persistence_intervals from a vector of pairs. Each pair is assumed to represent a persistence interval. We assume that the first elements of pairs 
-     * are smaller or equal the second elements of pairs.
-    **/ 
-    Persistence_intervals( const std::vector< std::pair< double,double > >& intervals );
-    
-    /**
-	 * This procedure returns x-range of a given persistence diagram. 
-	**/ 
-	std::pair< double , double > get_x_range()const
-	{
-		double min_ = std::numeric_limits<int>::max();
-		double max_ = -std::numeric_limits<int>::max();
-		for ( size_t i = 0 ; i != this->intervals.size() ; ++i )
-		{
-			if ( this->intervals[i].first < min_ )min_ = this->intervals[i].first;
-			if ( this->intervals[i].second > max_ )max_ = this->intervals[i].second;
-		}
-		return std::make_pair( min_ , max_ );		 
-	}
-	
-	/**
-	 * This procedure returns y-range of a given persistence diagram. 
-	**/ 
-	std::pair< double , double > get_y_range()const
-	{
-		 double min_ = std::numeric_limits<int>::max();
-		double max_ = -std::numeric_limits<int>::max();
-		for ( size_t i = 0 ; i != this->intervals.size() ; ++i )
-		{
-			if ( this->intervals[i].second < min_ )min_ = this->intervals[i].second;
-			if ( this->intervals[i].second > max_ )max_ = this->intervals[i].second;
-		}
-		return std::make_pair( min_ , max_ );
-	}
-
-	/**
-	 * Procedure that compute the vector of lengths of the dominant (i.e. the longest) persistence intervals. The list is truncated at the parameter of the call where_to_cut (set by default to 100).
-	**/ 
-    std::vector<double> length_of_dominant_intervals( size_t where_to_cut = 100 )const;
-    
-    
-    /**
-	 * Procedure that compute the vector of the dominant (i.e. the longest) persistence intervals. The parameter of the procedure (set by default to 100) is the number of dominant intervals returned by the procedure.
-	**/ 
-    std::vector< std::pair<double,double> > dominant_intervals( size_t where_to_cut = 100 )const;
-    
-    /**
-	 * Procedure to compute a histogram of interval's length. A histogram is a block plot. The number of blocks is determined by the first parameter of the function (set by default to 10). 
-	 * For the sake of argument let us assume that the length of the longest interval is 1 and the number of bins is 10. In this case the i-th block correspond to a range between i-1/10 and i10. 
-	 * The vale of a block supported at the interval is the number of persistence intervals of a length between x_0 and x_1.
-	**/
-    std::vector< size_t > histogram_of_lengths( size_t number_of_bins = 10  )const;
-    
-    /**
-     * Based on a histogram of intervals lengths computed by the function histogram_of_lengths H the procedure below computes the cumulative histogram. The i-th position of the resulting histogram
-     * is the sum of values of H for the positions from 0 to i. 
-    **/
-    std::vector< size_t > cumulative_histogram_of_lengths( size_t number_of_bins = 10 )const;
-    
-    /**
-     * In this procedure we assume that each barcode is a characteristic function of a hight equal to its length. The persistence diagram is a sum of such a functions. The procedure below construct a function being a 
-     * sum of the characteristic functions of persistence intervals. The first two parameters are the range in which the function is to be computed and the last parameter is the number of bins in 
-     * the discretization of the interval [_min,_max].
-    **/ 
-    std::vector< double > characteristic_function_of_diagram( double x_min , double x_max , size_t number_of_bins = 10 )const;
-    
-    /**
-     * Cumulative version of the function characteristic_function_of_diagram
-    **/ 
-    std::vector< double > cumulative_characteristic_function_of_diagram( double x_min , double x_max , size_t number_of_bins = 10 )const;
-    
-    /**
-     * Compute the function of persistence Betti numbers. The returned value is a vector of pair. First element of each pair is a place where persistence Betti numbers change. 
-     * Second element of each pair is the value of Persistence Betti numbers at that point.  
-    **/ 
-    std::vector< std::pair< double , size_t > > compute_persistent_betti_numbers()const;
-    
-    /**
-     *This is a non optimal procedure that compute vector of distances from each point of diagram to its k-th nearest neighbor (k is a parameter of the program). The resulting vector is by default truncated to 10 
-     *elements (this value can be changed by using the second parameter of the program). The points are returned in order from the ones which are farthest away from their k-th nearest neighbors. 
-    **/
-    std::vector< double > k_n_n( size_t k  , size_t where_to_cut = 10 )const;
-
-	/**
-     * Operator that send the diagram to a stream. 
-    **/    
-    friend std::ostream& operator << ( std::ostream& out , const Persistence_intervals& intervals )
-    {
-        for ( size_t i = 0 ; i != intervals.intervals.size() ; ++i )
-        {
-            out << intervals.intervals[i].first << " " << intervals.intervals[i].second << std::endl;
-        }
-        return out;
+ * This class implements the following concepts: Vectorized_topological_data, Topological_data_with_distances,
+ *Real_valued_topological_data
+**/
+class Persistence_intervals {
+ public:
+  /**
+   * This is a constructor of a class Persistence_intervals from a text file. Each line of the input file is supposed to
+   *contain two numbers of a type double (or convertible to double)
+   * representing the birth and the death of the persistence interval. If the pairs are not sorted so that birth <=
+   *death, then the constructor will sort then that way.
+   * * The second parameter of a constructor is a dimension of intervals to be read from a file. If your file contains
+   *only birth-death pairs, use the default value.
+  **/
+  Persistence_intervals(const char* filename, unsigned dimension = std::numeric_limits<unsigned>::max());
+
+  /**
+   * This is a constructor of a class Persistence_intervals from a vector of pairs. Each pair is assumed to represent a
+   *persistence interval. We assume that the first elements of pairs
+   * are smaller or equal the second elements of pairs.
+  **/
+  Persistence_intervals(const std::vector<std::pair<double, double> >& intervals);
+
+  /**
+       * This procedure returns x-range of a given persistence diagram.
+      **/
+  std::pair<double, double> get_x_range() const {
+    double min_ = std::numeric_limits<int>::max();
+    double max_ = -std::numeric_limits<int>::max();
+    for (size_t i = 0; i != this->intervals.size(); ++i) {
+      if (this->intervals[i].first < min_) min_ = this->intervals[i].first;
+      if (this->intervals[i].second > max_) max_ = this->intervals[i].second;
     }
-    
-    /**
-     * Generating gnuplot script to plot the interval. 
-    **/
-    void plot( const char* filename , double min_x = std::numeric_limits<double>::max() , double max_x = std::numeric_limits<double>::max() , double min_y = std::numeric_limits<double>::max() , double max_y = std::numeric_limits<double>::max()  ) const
-    {
-		//this program create a gnuplot script file that allows to plot persistence diagram.
-		std::ofstream out;
-		
-		std::ostringstream nameSS;
-		nameSS << filename << "_GnuplotScript";
-		std::string nameStr = nameSS.str();
-		out.open( nameStr );
-		
-		std::pair<double,double> min_max_values = this->get_x_range();
-		if ( min_x == max_x )
-		{	
-			out << "set xrange [" << min_max_values.first - 0.1*(min_max_values.second-min_max_values.first) << " : " << min_max_values.second + 0.1*(min_max_values.second-min_max_values.first) << " ]" << std::endl;
-			out << "set yrange [" << min_max_values.first - 0.1*(min_max_values.second-min_max_values.first) << " : " << min_max_values.second + 0.1*(min_max_values.second-min_max_values.first) << " ]" << std::endl;
-		}
-		else
-		{
-			out << "set xrange [" << min_x << " : " << max_x << " ]" << std::endl;
-			out << "set yrange [" << min_y << " : " << max_y << " ]" << std::endl;			
-		}
-		out << "plot '-' using 1:2 notitle \"" << filename << "\", \\" << std::endl;
-		out << "     '-' using 1:2 notitle with lp" << std::endl;
-		for ( size_t i = 0 ; i != this->intervals.size() ; ++i )
-		{
-			out << this->intervals[i].first << " " << this->intervals[i].second << std::endl;
-		}
-		out << "EOF" << std::endl;
-		out << min_max_values.first - 0.1*(min_max_values.second-min_max_values.first) << " " << min_max_values.first - 0.1*(min_max_values.second-min_max_values.first) << std::endl;
-		out << min_max_values.second + 0.1*(min_max_values.second-min_max_values.first) << " " << min_max_values.second + 0.1*(min_max_values.second-min_max_values.first) << std::endl;
-			
-		out.close();
-		
-		std::cout << "Gnuplot script to visualize persistence diagram written to the file: " << nameStr << ". Type load '" << nameStr << "' in gnuplot to visualize." << std::endl;
-	}
-
-	/**
-     * Return number of points in the diagram.
-    **/
-    size_t size()const{return this->intervals.size();}
-    
-    /**
-     * Return the persistence interval at the given position. Note that intervals are not sorted with respect to their lengths. 
-    **/
-    inline std::pair< double,double > operator [](size_t i)const
-    {
-        if ( i >= this->intervals.size() )throw("Index out of range! Operator [], one_d_gaussians class\n");
-        return this->intervals[i];
+    return std::make_pair(min_, max_);
+  }
+
+  /**
+   * This procedure returns y-range of a given persistence diagram.
+  **/
+  std::pair<double, double> get_y_range() const {
+    double min_ = std::numeric_limits<int>::max();
+    double max_ = -std::numeric_limits<int>::max();
+    for (size_t i = 0; i != this->intervals.size(); ++i) {
+      if (this->intervals[i].second < min_) min_ = this->intervals[i].second;
+      if (this->intervals[i].second > max_) max_ = this->intervals[i].second;
     }
-    
-    
-    //Implementations of functions for various concepts.  
-	/**
-	 * This is a simple function projecting the persistence intervals to a real number. The function we use here is a sum of squared lengths of intervals. It can be naturally interpreted as
-	 * sum of step function, where the step hight it equal to the length of the interval.
-         * At the moment this function is not tested, since it is quite likely to be changed in the future. Given this, when using it, keep in mind that it
-         * will be most likely changed in the next versions.
-	 **/ 
-	double project_to_R( int number_of_function )const;   
-	/**
-	 * The function gives the number of possible projections to R. This function is required by the Real_valued_topological_data concept.
-	**/ 
-	size_t number_of_projections_to_R()const
-	{
-		return this->number_of_functions_for_projections_to_reals;
-	} 
-    
-    /**
-     * Return a family of vectors obtained from the persistence diagram. The i-th vector consist of the length of i dominant persistence intervals. 
-    **/
-    std::vector<double> vectorize( int number_of_function )const
-    {
-        return this->length_of_dominant_intervals( number_of_function );
+    return std::make_pair(min_, max_);
+  }
+
+  /**
+   * Procedure that compute the vector of lengths of the dominant (i.e. the longest) persistence intervals. The list is
+   *truncated at the parameter of the call where_to_cut (set by default to 100).
+  **/
+  std::vector<double> length_of_dominant_intervals(size_t where_to_cut = 100) const;
+
+  /**
+       * Procedure that compute the vector of the dominant (i.e. the longest) persistence intervals. The parameter of
+    *the procedure (set by default to 100) is the number of dominant intervals returned by the procedure.
+      **/
+  std::vector<std::pair<double, double> > dominant_intervals(size_t where_to_cut = 100) const;
+
+  /**
+       * Procedure to compute a histogram of interval's length. A histogram is a block plot. The number of blocks is
+    *determined by the first parameter of the function (set by default to 10).
+       * For the sake of argument let us assume that the length of the longest interval is 1 and the number of bins is
+    *10. In this case the i-th block correspond to a range between i-1/10 and i10.
+       * The vale of a block supported at the interval is the number of persistence intervals of a length between x_0
+    *and x_1.
+      **/
+  std::vector<size_t> histogram_of_lengths(size_t number_of_bins = 10) const;
+
+  /**
+   * Based on a histogram of intervals lengths computed by the function histogram_of_lengths H the procedure below
+   *computes the cumulative histogram. The i-th position of the resulting histogram
+   * is the sum of values of H for the positions from 0 to i.
+  **/
+  std::vector<size_t> cumulative_histogram_of_lengths(size_t number_of_bins = 10) const;
+
+  /**
+   * In this procedure we assume that each barcode is a characteristic function of a hight equal to its length. The
+   *persistence diagram is a sum of such a functions. The procedure below construct a function being a
+   * sum of the characteristic functions of persistence intervals. The first two parameters are the range in which the
+   *function is to be computed and the last parameter is the number of bins in
+   * the discretization of the interval [_min,_max].
+  **/
+  std::vector<double> characteristic_function_of_diagram(double x_min, double x_max, size_t number_of_bins = 10) const;
+
+  /**
+   * Cumulative version of the function characteristic_function_of_diagram
+  **/
+  std::vector<double> cumulative_characteristic_function_of_diagram(double x_min, double x_max,
+                                                                    size_t number_of_bins = 10) const;
+
+  /**
+   * Compute the function of persistence Betti numbers. The returned value is a vector of pair. First element of each
+   *pair is a place where persistence Betti numbers change.
+   * Second element of each pair is the value of Persistence Betti numbers at that point.
+  **/
+  std::vector<std::pair<double, size_t> > compute_persistent_betti_numbers() const;
+
+  /**
+   *This is a non optimal procedure that compute vector of distances from each point of diagram to its k-th nearest
+   *neighbor (k is a parameter of the program). The resulting vector is by default truncated to 10
+   *elements (this value can be changed by using the second parameter of the program). The points are returned in order
+   *from the ones which are farthest away from their k-th nearest neighbors.
+  **/
+  std::vector<double> k_n_n(size_t k, size_t where_to_cut = 10) const;
+
+  /**
+* Operator that send the diagram to a stream.
+**/
+  friend std::ostream& operator<<(std::ostream& out, const Persistence_intervals& intervals) {
+    for (size_t i = 0; i != intervals.intervals.size(); ++i) {
+      out << intervals.intervals[i].first << " " << intervals.intervals[i].second << std::endl;
     }
-    /**
-	* This function return the number of functions that allows vectorization of a persistence diagram. It is required in a concept Vectorized_topological_data.
-	**/ 
-	size_t number_of_vectorize_functions()const
-	{
-		return this->number_of_functions_for_vectorization;	
-	}
-
-	//end of implementation of functions needed for concepts.
-
-    
-    //For visualization use output from vectorize and build histograms. 
-     std::vector< std::pair< double,double > > output_for_visualization()
-    {
-		return this->intervals;
-	}
-
-protected:
-	
-	void set_up_numbers_of_functions_for_vectorization_and_projections_to_reals()
-	{
-		//warning, this function can be only called after filling in the intervals vector.
-		this->number_of_functions_for_vectorization = this->intervals.size();
-		this->number_of_functions_for_projections_to_reals = 1;
-	}
-
-    std::vector< std::pair< double,double > > intervals;   
-    size_t number_of_functions_for_vectorization;
-	size_t number_of_functions_for_projections_to_reals; 
-};
-
-
-Persistence_intervals::Persistence_intervals( const char* filename , unsigned dimension )
-{
-    if ( dimension == std::numeric_limits<unsigned>::max() )
-    {
-       this->intervals = read_persistence_intervals_in_one_dimension_from_file( filename );
+    return out;
+  }
+
+  /**
+   * Generating gnuplot script to plot the interval.
+  **/
+  void plot(const char* filename, double min_x = std::numeric_limits<double>::max(),
+            double max_x = std::numeric_limits<double>::max(), double min_y = std::numeric_limits<double>::max(),
+            double max_y = std::numeric_limits<double>::max()) const {
+    // this program create a gnuplot script file that allows to plot persistence diagram.
+    std::ofstream out;
+
+    std::ostringstream nameSS;
+    nameSS << filename << "_GnuplotScript";
+    std::string nameStr = nameSS.str();
+    out.open(nameStr);
+
+    std::pair<double, double> min_max_values = this->get_x_range();
+    if (min_x == max_x) {
+      out << "set xrange [" << min_max_values.first - 0.1 * (min_max_values.second - min_max_values.first) << " : "
+          << min_max_values.second + 0.1 * (min_max_values.second - min_max_values.first) << " ]" << std::endl;
+      out << "set yrange [" << min_max_values.first - 0.1 * (min_max_values.second - min_max_values.first) << " : "
+          << min_max_values.second + 0.1 * (min_max_values.second - min_max_values.first) << " ]" << std::endl;
+    } else {
+      out << "set xrange [" << min_x << " : " << max_x << " ]" << std::endl;
+      out << "set yrange [" << min_y << " : " << max_y << " ]" << std::endl;
     }
-    else
-    {
-       this->intervals = read_persistence_intervals_in_one_dimension_from_file( filename , dimension );
+    out << "plot '-' using 1:2 notitle \"" << filename << "\", \\" << std::endl;
+    out << "     '-' using 1:2 notitle with lp" << std::endl;
+    for (size_t i = 0; i != this->intervals.size(); ++i) {
+      out << this->intervals[i].first << " " << this->intervals[i].second << std::endl;
     }
-    this->set_up_numbers_of_functions_for_vectorization_and_projections_to_reals();
-}//Persistence_intervals
-
+    out << "EOF" << std::endl;
+    out << min_max_values.first - 0.1 * (min_max_values.second - min_max_values.first) << " "
+        << min_max_values.first - 0.1 * (min_max_values.second - min_max_values.first) << std::endl;
+    out << min_max_values.second + 0.1 * (min_max_values.second - min_max_values.first) << " "
+        << min_max_values.second + 0.1 * (min_max_values.second - min_max_values.first) << std::endl;
+
+    out.close();
+
+    std::cout << "Gnuplot script to visualize persistence diagram written to the file: " << nameStr << ". Type load '"
+              << nameStr << "' in gnuplot to visualize." << std::endl;
+  }
+
+  /**
+* Return number of points in the diagram.
+**/
+  size_t size() const { return this->intervals.size(); }
+
+  /**
+   * Return the persistence interval at the given position. Note that intervals are not sorted with respect to their
+   *lengths.
+  **/
+  inline std::pair<double, double> operator[](size_t i) const {
+    if (i >= this->intervals.size()) throw("Index out of range! Operator [], one_d_gaussians class\n");
+    return this->intervals[i];
+  }
+
+  // Implementations of functions for various concepts.
+  /**
+   * This is a simple function projecting the persistence intervals to a real number. The function we use here is a sum
+   *of squared lengths of intervals. It can be naturally interpreted as
+   * sum of step function, where the step hight it equal to the length of the interval.
+   * At the moment this function is not tested, since it is quite likely to be changed in the future. Given this, when
+   *using it, keep in mind that it
+   * will be most likely changed in the next versions.
+   **/
+  double project_to_R(int number_of_function) const;
+  /**
+   * The function gives the number of possible projections to R. This function is required by the
+   *Real_valued_topological_data concept.
+  **/
+  size_t number_of_projections_to_R() const { return this->number_of_functions_for_projections_to_reals; }
+
+  /**
+   * Return a family of vectors obtained from the persistence diagram. The i-th vector consist of the length of i
+   *dominant persistence intervals.
+  **/
+  std::vector<double> vectorize(int number_of_function) const {
+    return this->length_of_dominant_intervals(number_of_function);
+  }
+  /**
+      * This function return the number of functions that allows vectorization of a persistence diagram. It is required
+    *in a concept Vectorized_topological_data.
+      **/
+  size_t number_of_vectorize_functions() const { return this->number_of_functions_for_vectorization; }
+
+  // end of implementation of functions needed for concepts.
+
+  // For visualization use output from vectorize and build histograms.
+  std::vector<std::pair<double, double> > output_for_visualization() { return this->intervals; }
+
+ protected:
+  void set_up_numbers_of_functions_for_vectorization_and_projections_to_reals() {
+    // warning, this function can be only called after filling in the intervals vector.
+    this->number_of_functions_for_vectorization = this->intervals.size();
+    this->number_of_functions_for_projections_to_reals = 1;
+  }
+
+  std::vector<std::pair<double, double> > intervals;
+  size_t number_of_functions_for_vectorization;
+  size_t number_of_functions_for_projections_to_reals;
+};
 
-Persistence_intervals::Persistence_intervals( const std::vector< std::pair< double , double > >& intervals_ ):intervals(intervals_)
-{
-    this->set_up_numbers_of_functions_for_vectorization_and_projections_to_reals();
+Persistence_intervals::Persistence_intervals(const char* filename, unsigned dimension) {
+  if (dimension == std::numeric_limits<unsigned>::max()) {
+    this->intervals = read_persistence_intervals_in_one_dimension_from_file(filename);
+  } else {
+    this->intervals = read_persistence_intervals_in_one_dimension_from_file(filename, dimension);
+  }
+  this->set_up_numbers_of_functions_for_vectorization_and_projections_to_reals();
+}  // Persistence_intervals
+
+Persistence_intervals::Persistence_intervals(const std::vector<std::pair<double, double> >& intervals_)
+    : intervals(intervals_) {
+  this->set_up_numbers_of_functions_for_vectorization_and_projections_to_reals();
 }
 
+std::vector<double> Persistence_intervals::length_of_dominant_intervals(size_t where_to_cut) const {
+  std::vector<double> result(this->intervals.size());
+  for (size_t i = 0; i != this->intervals.size(); ++i) {
+    result[i] = this->intervals[i].second - this->intervals[i].first;
+  }
+  std::sort(result.begin(), result.end(), std::greater<double>());
 
-std::vector< double > Persistence_intervals::length_of_dominant_intervals( size_t where_to_cut )const
-{	
-    std::vector< double > result( this->intervals.size() );
-    for ( size_t i = 0 ; i != this->intervals.size() ; ++i )
-    {
-        result[i] = this->intervals[i].second - this->intervals[i].first;
-    }
-    std::sort( result.begin() , result.end() ,  std::greater<double>() );
+  result.resize(std::min(where_to_cut, result.size()));
+  return result;
+}  // length_of_dominant_intervals
 
+bool compare(const std::pair<size_t, double>& first, const std::pair<size_t, double>& second) {
+  return first.second > second.second;
+}
 
-    result.resize( std::min(where_to_cut,result.size()) );
-    return result;
-}//length_of_dominant_intervals
+std::vector<std::pair<double, double> > Persistence_intervals::dominant_intervals(size_t where_to_cut) const {
+  bool dbg = false;
+  std::vector<std::pair<size_t, double> > position_length_vector(this->intervals.size());
+  for (size_t i = 0; i != this->intervals.size(); ++i) {
+    position_length_vector[i] = std::make_pair(i, this->intervals[i].second - this->intervals[i].first);
+  }
+
+  std::sort(position_length_vector.begin(), position_length_vector.end(), compare);
+
+  std::vector<std::pair<double, double> > result;
+  result.reserve(std::min(where_to_cut, position_length_vector.size()));
+
+  for (size_t i = 0; i != std::min(where_to_cut, position_length_vector.size()); ++i) {
+    result.push_back(this->intervals[position_length_vector[i].first]);
+    if (dbg)
+      std::cerr << "Position : " << position_length_vector[i].first << " length : " << position_length_vector[i].second
+                << std::endl;
+  }
+
+  return result;
+}  // dominant_intervals
+
+std::vector<size_t> Persistence_intervals::histogram_of_lengths(size_t number_of_bins) const {
+  bool dbg = false;
+
+  if (dbg) std::cerr << "this->intervals.size() : " << this->intervals.size() << std::endl;
+  // first find the length of the longest interval:
+  double lengthOfLongest = 0;
+  for (size_t i = 0; i != this->intervals.size(); ++i) {
+    if ((this->intervals[i].second - this->intervals[i].first) > lengthOfLongest) {
+      lengthOfLongest = this->intervals[i].second - this->intervals[i].first;
+    }
+  }
 
+  if (dbg) {
+    std::cerr << "lengthOfLongest : " << lengthOfLongest << std::endl;
+  }
 
+  // this is a container we will use to store the resulting histogram
+  std::vector<size_t> result(number_of_bins + 1, 0);
 
-bool compare( const std::pair< size_t , double >& first , const std::pair< size_t , double >& second )
-{
-	return first.second > second.second;
-}
+  // for every persistence interval in our collection.
+  for (size_t i = 0; i != this->intervals.size(); ++i) {
+    // compute its length relative to the length of the dominant interval:
+    double relative_length_of_this_interval = (this->intervals[i].second - this->intervals[i].first) / lengthOfLongest;
 
+    // given the relative length (between 0 and 1) compute to which bin should it contribute.
+    size_t position = (size_t)(relative_length_of_this_interval * number_of_bins);
 
-std::vector< std::pair<double,double> > Persistence_intervals::dominant_intervals( size_t where_to_cut )const
-{
-	bool dbg = false;
-	std::vector< std::pair< size_t , double > > position_length_vector( this->intervals.size() );
-	for ( size_t i = 0 ; i != this->intervals.size() ; ++i )
-    {
-        position_length_vector[i] = std::make_pair( i , this->intervals[i].second - this->intervals[i].first );
-    }
-    
-    std::sort( position_length_vector.begin() , position_length_vector.end() , compare );
-
-	std::vector< std::pair<double,double> > result;
-	result.reserve( std::min( where_to_cut , position_length_vector.size() ) );
-	
-	for ( size_t i = 0 ; i != std::min( where_to_cut , position_length_vector.size() ) ; ++i )
-	{
-		result.push_back( this->intervals[ position_length_vector[i].first ] );
-		if ( dbg )std::cerr << "Position : " << position_length_vector[i].first << " length : " << position_length_vector[i].second << std::endl;
-	}
-	
-	return result;
-}//dominant_intervals
-
-
-std::vector< size_t > Persistence_intervals::histogram_of_lengths( size_t number_of_bins )const
-{
-    bool dbg = false;
-
-    if ( dbg )std::cerr << "this->intervals.size() : " << this->intervals.size() << std::endl;
-    //first find the length of the longest interval:
-    double lengthOfLongest = 0;
-    for ( size_t i = 0  ; i != this->intervals.size() ; ++i )
-    {
-        if ( (this->intervals[i].second - this->intervals[i].first) > lengthOfLongest )
-        {
-            lengthOfLongest = this->intervals[i].second - this->intervals[i].first;
-        }
-    }
+    ++result[position];
 
-    if ( dbg ){std::cerr << "lengthOfLongest : " << lengthOfLongest << std::endl;}
-
-	//this is a container we will use to store the resulting histogram
-    std::vector< size_t > result( number_of_bins + 1 , 0 );
-    
-    //for every persistence interval in our collection.
-    for ( size_t i = 0  ; i != this->intervals.size() ; ++i )
-    {
-		//compute its length relative to the length of the dominant interval:
-        double relative_length_of_this_interval = (this->intervals[i].second - this->intervals[i].first)/lengthOfLongest;
-        
-        //given the relative length (between 0 and 1) compute to which bin should it contribute. 
-        size_t position = (size_t)(relative_length_of_this_interval*number_of_bins);
-        
-        
-        ++result[position];
-        
-        if ( dbg )
-        {
-            std::cerr << "i : " << i << std::endl;
-            std::cerr << "Interval : [" << this->intervals[i].first << " , " << this->intervals[i].second << " ] \n";
-            std::cerr << "relative_length_of_this_interval : " << relative_length_of_this_interval << std::endl;
-            std::cerr << "position : " << position << std::endl;
-            getchar();
-        }
+    if (dbg) {
+      std::cerr << "i : " << i << std::endl;
+      std::cerr << "Interval : [" << this->intervals[i].first << " , " << this->intervals[i].second << " ] \n";
+      std::cerr << "relative_length_of_this_interval : " << relative_length_of_this_interval << std::endl;
+      std::cerr << "position : " << position << std::endl;
+      getchar();
     }
+  }
 
-    
-    if ( dbg ){for ( size_t i = 0 ; i != result.size() ; ++i )std::cerr << result[i] << std::endl;}
-    return result;
+  if (dbg) {
+    for (size_t i = 0; i != result.size(); ++i) std::cerr << result[i] << std::endl;
+  }
+  return result;
 }
 
+std::vector<size_t> Persistence_intervals::cumulative_histogram_of_lengths(size_t number_of_bins) const {
+  std::vector<size_t> histogram = this->histogram_of_lengths(number_of_bins);
+  std::vector<size_t> result(histogram.size());
 
-std::vector< size_t > Persistence_intervals::cumulative_histogram_of_lengths( size_t number_of_bins )const
-{
-    std::vector< size_t > histogram = this->histogram_of_lengths( number_of_bins );
-    std::vector< size_t > result( histogram.size() );
-
-    size_t sum = 0;
-    for ( size_t i = 0 ; i != histogram.size() ; ++i )
-    {
-        sum += histogram[i];
-        result[i] = sum;
-    }
-    return result;
+  size_t sum = 0;
+  for (size_t i = 0; i != histogram.size(); ++i) {
+    sum += histogram[i];
+    result[i] = sum;
+  }
+  return result;
 }
 
+std::vector<double> Persistence_intervals::characteristic_function_of_diagram(double x_min, double x_max,
+                                                                              size_t number_of_bins) const {
+  bool dbg = false;
 
-std::vector< double > Persistence_intervals::characteristic_function_of_diagram( double x_min , double x_max , size_t number_of_bins )const
-{
-    bool dbg = false;
-
-    std::vector< double > result( number_of_bins );
-    std::fill( result.begin() , result.end() , 0 );
-
-    for ( size_t i = 0 ; i != this->intervals.size() ; ++i )
-    {
-        if ( dbg )
-        {
-            std::cerr << "Interval : " << this->intervals[i].first << " , " << this->intervals[i].second << std::endl;
-        }
-
-        size_t beginIt = 0;
-        if ( this->intervals[i].first < x_min )beginIt = 0;
-        if ( this->intervals[i].first >= x_max )beginIt = result.size();
-        if ( ( this->intervals[i].first > x_min ) && ( this->intervals[i].first < x_max ) )
-        {
-            beginIt = number_of_bins*(this->intervals[i].first-x_min)/(x_max - x_min);
-        }
-
-        size_t endIt = 0;
-        if ( this->intervals[i].second < x_min )endIt = 0;
-        if ( this->intervals[i].second >= x_max )endIt = result.size();
-        if ( ( this->intervals[i].second > x_min ) && ( this->intervals[i].second < x_max ) )
-        {
-            endIt = number_of_bins*( this->intervals[i].second - x_min )/(x_max - x_min);
-        }
-
-        if ( beginIt > endIt ){beginIt = endIt;}
-
-        if ( dbg )
-        {
-            std::cerr << "beginIt : " << beginIt << std::endl;
-            std::cerr << "endIt : " << endIt << std::endl;
-        }
+  std::vector<double> result(number_of_bins);
+  std::fill(result.begin(), result.end(), 0);
 
+  for (size_t i = 0; i != this->intervals.size(); ++i) {
+    if (dbg) {
+      std::cerr << "Interval : " << this->intervals[i].first << " , " << this->intervals[i].second << std::endl;
+    }
 
-        for ( size_t pos = beginIt ; pos != endIt ; ++pos )
-        {
-            result[pos] += ( (x_max - x_min)/(double)number_of_bins ) * ( this->intervals[i].second - this->intervals[i].first );
-        }
-        if ( dbg )
-        {	
-            std::cerr << "Result at this stage \n";
-            for ( size_t aa = 0 ; aa != result.size() ; ++aa )
-            {
-                std::cerr << result[aa] << " ";
-            }
-            std::cerr << std::endl;
-        }
+    size_t beginIt = 0;
+    if (this->intervals[i].first < x_min) beginIt = 0;
+    if (this->intervals[i].first >= x_max) beginIt = result.size();
+    if ((this->intervals[i].first > x_min) && (this->intervals[i].first < x_max)) {
+      beginIt = number_of_bins * (this->intervals[i].first - x_min) / (x_max - x_min);
     }
-    return result;
-}//characteristic_function_of_diagram
 
+    size_t endIt = 0;
+    if (this->intervals[i].second < x_min) endIt = 0;
+    if (this->intervals[i].second >= x_max) endIt = result.size();
+    if ((this->intervals[i].second > x_min) && (this->intervals[i].second < x_max)) {
+      endIt = number_of_bins * (this->intervals[i].second - x_min) / (x_max - x_min);
+    }
 
+    if (beginIt > endIt) {
+      beginIt = endIt;
+    }
 
-std::vector< double > Persistence_intervals::cumulative_characteristic_function_of_diagram( double x_min , double x_max , size_t number_of_bins )const
-{
-    std::vector< double > intsOfBars = this->characteristic_function_of_diagram( x_min , x_max , number_of_bins );    
-    std::vector< double > result( intsOfBars.size() );
-    double sum = 0;
-    for ( size_t i = 0 ; i != intsOfBars.size() ; ++i )
-    {
-        sum += intsOfBars[i];
-        result[i] = sum;
+    if (dbg) {
+      std::cerr << "beginIt : " << beginIt << std::endl;
+      std::cerr << "endIt : " << endIt << std::endl;
     }
-    return result;
-}//cumulative_characteristic_function_of_diagram
 
+    for (size_t pos = beginIt; pos != endIt; ++pos) {
+      result[pos] +=
+          ((x_max - x_min) / (double)number_of_bins) * (this->intervals[i].second - this->intervals[i].first);
+    }
+    if (dbg) {
+      std::cerr << "Result at this stage \n";
+      for (size_t aa = 0; aa != result.size(); ++aa) {
+        std::cerr << result[aa] << " ";
+      }
+      std::cerr << std::endl;
+    }
+  }
+  return result;
+}  // characteristic_function_of_diagram
+
+std::vector<double> Persistence_intervals::cumulative_characteristic_function_of_diagram(double x_min, double x_max,
+                                                                                         size_t number_of_bins) const {
+  std::vector<double> intsOfBars = this->characteristic_function_of_diagram(x_min, x_max, number_of_bins);
+  std::vector<double> result(intsOfBars.size());
+  double sum = 0;
+  for (size_t i = 0; i != intsOfBars.size(); ++i) {
+    sum += intsOfBars[i];
+    result[i] = sum;
+  }
+  return result;
+}  // cumulative_characteristic_function_of_diagram
 
 template <typename T>
-bool compare_first_element_of_pair( const std::pair< T , bool >& f, const std::pair< T , bool >& s )
-{
-    return (f.first < s.first);
+bool compare_first_element_of_pair(const std::pair<T, bool>& f, const std::pair<T, bool>& s) {
+  return (f.first < s.first);
 }
 
-
-std::vector< std::pair< double , size_t > > Persistence_intervals::compute_persistent_betti_numbers()const
-{	
-    std::vector< std::pair< double , bool > > places_where_pbs_change( 2*this->intervals.size() );
-
-    for ( size_t i = 0 ; i != this->intervals.size() ; ++i )
-    {
-        places_where_pbs_change[2*i] = std::make_pair( this->intervals[i].first , true );
-        places_where_pbs_change[2*i+1] = std::make_pair( this->intervals[i].second , false );
+std::vector<std::pair<double, size_t> > Persistence_intervals::compute_persistent_betti_numbers() const {
+  std::vector<std::pair<double, bool> > places_where_pbs_change(2 * this->intervals.size());
+
+  for (size_t i = 0; i != this->intervals.size(); ++i) {
+    places_where_pbs_change[2 * i] = std::make_pair(this->intervals[i].first, true);
+    places_where_pbs_change[2 * i + 1] = std::make_pair(this->intervals[i].second, false);
+  }
+
+  std::sort(places_where_pbs_change.begin(), places_where_pbs_change.end(), compare_first_element_of_pair<double>);
+  size_t pbn = 0;
+  std::vector<std::pair<double, size_t> > pbns(places_where_pbs_change.size());
+  for (size_t i = 0; i != places_where_pbs_change.size(); ++i) {
+    if (places_where_pbs_change[i].second == true) {
+      ++pbn;
+    } else {
+      --pbn;
     }
-
-    std::sort( places_where_pbs_change.begin() , places_where_pbs_change.end() , compare_first_element_of_pair<double> );
-    size_t pbn = 0;
-    std::vector< std::pair< double , size_t > > pbns( places_where_pbs_change.size() );
-    for ( size_t i = 0 ; i != places_where_pbs_change.size() ; ++i )
-    {
-        if ( places_where_pbs_change[i].second == true )
-        {
-            ++pbn;
-        }
-        else
-        {
-            --pbn;
-        }
-        pbns[i] = std::make_pair( places_where_pbs_change[i].first , pbn );
-    }    
-    return pbns;
+    pbns[i] = std::make_pair(places_where_pbs_change[i].first, pbn);
+  }
+  return pbns;
 }
 
-
-
-
-
-
-inline double compute_euclidean_distance( const std::pair< double,double > & f , const std::pair< double,double > & s )
-{
-    return sqrt( (f.first-s.first)*(f.first-s.first) + (f.second-s.second)*(f.second-s.second) );
+inline double compute_euclidean_distance(const std::pair<double, double>& f, const std::pair<double, double>& s) {
+  return sqrt((f.first - s.first) * (f.first - s.first) + (f.second - s.second) * (f.second - s.second));
 }
 
-
-std::vector< double > Persistence_intervals::k_n_n( size_t k , size_t where_to_cut )const
-{
-    bool dbg = false;
-    if ( dbg )
-    {
-        std::cerr << "Here are the intervals : \n";
-        for ( size_t i = 0 ; i != this->intervals.size() ; ++i )
-        {
-            std::cerr << "[ " << this->intervals[i].first << " , " << this->intervals[i].second << "] \n";
-        }
-        getchar();
+std::vector<double> Persistence_intervals::k_n_n(size_t k, size_t where_to_cut) const {
+  bool dbg = false;
+  if (dbg) {
+    std::cerr << "Here are the intervals : \n";
+    for (size_t i = 0; i != this->intervals.size(); ++i) {
+      std::cerr << "[ " << this->intervals[i].first << " , " << this->intervals[i].second << "] \n";
     }
-
-    std::vector< double > result;
-    //compute all to all distance between point in the diagram. Also, consider points in the diagonal with the infinite multiplicity.
-    std::vector< std::vector< double > > distances( this->intervals.size() );
-    for ( size_t i = 0 ; i != this->intervals.size() ; ++i )
-    {
-        std::vector<double> aa(this->intervals.size());
-        std::fill( aa.begin() , aa.end() , 0 );
-        distances[i] = aa;
+    getchar();
+  }
+
+  std::vector<double> result;
+  // compute all to all distance between point in the diagram. Also, consider points in the diagonal with the infinite
+  // multiplicity.
+  std::vector<std::vector<double> > distances(this->intervals.size());
+  for (size_t i = 0; i != this->intervals.size(); ++i) {
+    std::vector<double> aa(this->intervals.size());
+    std::fill(aa.begin(), aa.end(), 0);
+    distances[i] = aa;
+  }
+  std::vector<double> distances_from_diagonal(this->intervals.size());
+  std::fill(distances_from_diagonal.begin(), distances_from_diagonal.end(), 0);
+
+  for (size_t i = 0; i != this->intervals.size(); ++i) {
+    std::vector<double> distancesFromI;
+    for (size_t j = i + 1; j != this->intervals.size(); ++j) {
+      distancesFromI.push_back(compute_euclidean_distance(this->intervals[i], this->intervals[j]));
+    }
+    // also add a distance from this guy to diagonal:
+    double distanceToDiagonal = compute_euclidean_distance(
+        this->intervals[i], std::make_pair(0.5 * (this->intervals[i].first + this->intervals[i].second),
+                                           0.5 * (this->intervals[i].first + this->intervals[i].second)));
+    distances_from_diagonal[i] = distanceToDiagonal;
+
+    if (dbg) {
+      std::cerr << "Here are the distances form the point : [" << this->intervals[i].first << " , "
+                << this->intervals[i].second << "] in the diagram \n";
+      for (size_t aa = 0; aa != distancesFromI.size(); ++aa) {
+        std::cerr << "To : " << i + aa << " : " << distancesFromI[aa] << " ";
+      }
+      std::cerr << std::endl;
+      getchar();
     }
-    std::vector< double > distances_from_diagonal( this->intervals.size() );
-    std::fill( distances_from_diagonal.begin() , distances_from_diagonal.end() , 0 );
-
-    for ( size_t i = 0 ; i != this->intervals.size() ; ++i )
-    {
-        std::vector< double > distancesFromI;
-        for ( size_t j = i+1 ; j != this->intervals.size() ; ++j )
-        {
-            distancesFromI.push_back( compute_euclidean_distance( this->intervals[i] , this->intervals[j] ) );
-        }
-        //also add a distance from this guy to diagonal:
-        double distanceToDiagonal = compute_euclidean_distance( this->intervals[i] , std::make_pair( 0.5*(this->intervals[i].first + this->intervals[i].second) , 0.5*(this->intervals[i].first + this->intervals[i].second) ) );
-        distances_from_diagonal[i] = distanceToDiagonal;
-
-        if ( dbg )
-        {
-            std::cerr << "Here are the distances form the point : [" << this->intervals[i].first << " , " << this->intervals[i].second << "] in the diagram \n";
-            for ( size_t aa = 0 ; aa != distancesFromI.size() ; ++aa )
-            {
-                std::cerr << "To : " << i+aa << " : " << distancesFromI[aa] << " ";
-            }
-            std::cerr << std::endl;
-            getchar();
-        }
 
-        //filling in the distances matrix:
-        for ( size_t j = i+1 ; j != this->intervals.size() ; ++j  )
-        {
-            distances[i][j] = distancesFromI[j-i-1];
-            distances[j][i] = distancesFromI[j-i-1];
-        }
+    // filling in the distances matrix:
+    for (size_t j = i + 1; j != this->intervals.size(); ++j) {
+      distances[i][j] = distancesFromI[j - i - 1];
+      distances[j][i] = distancesFromI[j - i - 1];
     }
-    if ( dbg )
-    {
-        std::cerr << "Here is the distance matrix : \n";
-        for ( size_t i = 0 ; i != distances.size() ; ++i )
-        {
-            for ( size_t j = 0 ; j != distances.size() ; ++j )
-            {
-                std::cerr << distances[i][j] << " ";
-            }
-            std::cerr << std::endl;
-        }
-        std::cerr << std::endl << std::endl << "And here are the distances to the diagonal : " << std::endl;
-        for ( size_t i = 0 ; i != distances_from_diagonal. size() ; ++i )
-        {
-            std::cerr << distances_from_diagonal[i] << " ";
-        }
-        std::cerr << std::endl << std::endl;
-        getchar();
+  }
+  if (dbg) {
+    std::cerr << "Here is the distance matrix : \n";
+    for (size_t i = 0; i != distances.size(); ++i) {
+      for (size_t j = 0; j != distances.size(); ++j) {
+        std::cerr << distances[i][j] << " ";
+      }
+      std::cerr << std::endl;
     }
-
-    for ( size_t i = 0 ; i != this->intervals.size() ; ++i )
-    {
-        std::vector< double > distancesFromI = distances[i];
-        distancesFromI.push_back( distances_from_diagonal[i] );
-
-        //sort it:
-        std::sort( distancesFromI.begin() , distancesFromI.end() , std::greater<double>() );
-
-        if ( k > distancesFromI.size() )
-        {
-            if ( dbg )
-            {
-                std::cerr << "There are not enough neighbors in your set. We set the result to plus infty \n";
-            }
-            result.push_back( std::numeric_limits<double>::max() );
-        }
-        else
-        {
-            if ( distances_from_diagonal[i] > distancesFromI[k] )
-            {
-                if ( dbg )
-                {
-                    std::cerr << "The k-th n.n. is on a diagonal. Therefore we set up a distance to diagonal \n";
-                }
-                result.push_back( distances_from_diagonal[i] );
-            }
-            else
-            {
-                result.push_back( distancesFromI[k] );
-            }
+    std::cerr << std::endl << std::endl << "And here are the distances to the diagonal : " << std::endl;
+    for (size_t i = 0; i != distances_from_diagonal.size(); ++i) {
+      std::cerr << distances_from_diagonal[i] << " ";
+    }
+    std::cerr << std::endl << std::endl;
+    getchar();
+  }
+
+  for (size_t i = 0; i != this->intervals.size(); ++i) {
+    std::vector<double> distancesFromI = distances[i];
+    distancesFromI.push_back(distances_from_diagonal[i]);
+
+    // sort it:
+    std::sort(distancesFromI.begin(), distancesFromI.end(), std::greater<double>());
+
+    if (k > distancesFromI.size()) {
+      if (dbg) {
+        std::cerr << "There are not enough neighbors in your set. We set the result to plus infty \n";
+      }
+      result.push_back(std::numeric_limits<double>::max());
+    } else {
+      if (distances_from_diagonal[i] > distancesFromI[k]) {
+        if (dbg) {
+          std::cerr << "The k-th n.n. is on a diagonal. Therefore we set up a distance to diagonal \n";
         }
+        result.push_back(distances_from_diagonal[i]);
+      } else {
+        result.push_back(distancesFromI[k]);
+      }
     }
-    std::sort( result.begin() , result.end() , std::greater<double>() );
-    result.resize( std::min( result.size() , where_to_cut ) );
+  }
+  std::sort(result.begin(), result.end(), std::greater<double>());
+  result.resize(std::min(result.size(), where_to_cut));
 
-    return result;
+  return result;
 }
 
+double Persistence_intervals::project_to_R(int number_of_function) const {
+  double result = 0;
 
-double Persistence_intervals::project_to_R( int number_of_function )const
-{
-	double result = 0;
-	
-	for ( size_t i = 0 ; i != this->intervals.size() ; ++i )
-	{
-		result += ( this->intervals[i].second - this->intervals[i].first )*( this->intervals[i].second - this->intervals[i].first );
-	}
-	
-	return result;
-}
+  for (size_t i = 0; i != this->intervals.size(); ++i) {
+    result +=
+        (this->intervals[i].second - this->intervals[i].first) * (this->intervals[i].second - this->intervals[i].first);
+  }
 
+  return result;
+}
 
 }  // namespace Persistence_representations
 }  // namespace gudhi
diff --git a/src/Persistence_representations/include/gudhi/Persistence_intervals_with_distances.h b/src/Persistence_representations/include/gudhi/Persistence_intervals_with_distances.h
index 0da58399..f7664e8d 100644
--- a/src/Persistence_representations/include/gudhi/Persistence_intervals_with_distances.h
+++ b/src/Persistence_representations/include/gudhi/Persistence_intervals_with_distances.h
@@ -23,42 +23,38 @@
 #ifndef PERSISTENCE_INTERVALS_WITH_DISTANCES_H_
 #define PERSISTENCE_INTERVALS_WITH_DISTANCES_H_
 
-
 #include <gudhi/Persistence_intervals.h>
 #include <gudhi/Bottleneck.h>
 
-namespace Gudhi 
-{
-namespace Persistence_representations 
-{
-
-class Persistence_intervals_with_distances : public Persistence_intervals
-{
-public:
-	using Persistence_intervals::Persistence_intervals;
-
-    /**
-     *Computations of distance from the current persistnce diagram to the persistence diagram given as a parameter of this function.
-     *The last but one parameter, power, is here in case we would like to compute p=th Wasserstein distance. At the moment, this method only implement Bottleneck distance,
-     * which is infinity Wasserstein distance. Therefore any power which is not the default std::numeric_limits< double >::max() will be ignored and an
-     * exception will be thrown.
-     * The last parameter, tolerance, it is an additiv error of the approimation, set by default to zero.
-    **/
-    double distance( const Persistence_intervals_with_distances& second , double power = std::numeric_limits< double >::max() , double tolerance = 0) const
-    {
-		if ( power >= std::numeric_limits< double >::max() )
-		{
-			return Gudhi::persistence_diagram::bottleneck_distance(this->intervals, second.intervals, tolerance);			
-		}
-		else
-		{
-			std::cerr << "At the moment Gudhi do not support Wasserstein distances. We only support Bottleneck distance." << std::endl;
-			throw "At the moment Gudhi do not support Wasserstein distances. We only support Bottleneck distance.";
-		}
-	}
+namespace Gudhi {
+namespace Persistence_representations {
+
+class Persistence_intervals_with_distances : public Persistence_intervals {
+ public:
+  using Persistence_intervals::Persistence_intervals;
+
+  /**
+   *Computations of distance from the current persistnce diagram to the persistence diagram given as a parameter of this
+   *function.
+   *The last but one parameter, power, is here in case we would like to compute p=th Wasserstein distance. At the
+   *moment, this method only implement Bottleneck distance,
+   * which is infinity Wasserstein distance. Therefore any power which is not the default std::numeric_limits< double
+   *>::max() will be ignored and an
+   * exception will be thrown.
+   * The last parameter, tolerance, it is an additiv error of the approimation, set by default to zero.
+  **/
+  double distance(const Persistence_intervals_with_distances& second, double power = std::numeric_limits<double>::max(),
+                  double tolerance = 0) const {
+    if (power >= std::numeric_limits<double>::max()) {
+      return Gudhi::persistence_diagram::bottleneck_distance(this->intervals, second.intervals, tolerance);
+    } else {
+      std::cerr << "At the moment Gudhi do not support Wasserstein distances. We only support Bottleneck distance."
+                << std::endl;
+      throw "At the moment Gudhi do not support Wasserstein distances. We only support Bottleneck distance.";
+    }
+  }
 };
 
-
 }  // namespace Persistence_representations
 }  // namespace gudhi
 
diff --git a/src/Persistence_representations/include/gudhi/Persistence_landscape.h b/src/Persistence_representations/include/gudhi/Persistence_landscape.h
index 642bba84..01d44fec 100644
--- a/src/Persistence_representations/include/gudhi/Persistence_landscape.h
+++ b/src/Persistence_representations/include/gudhi/Persistence_landscape.h
@@ -20,11 +20,10 @@
  *    along with this program.  If not, see <http://www.gnu.org/licenses/>.
  */
 
-
 #ifndef PERSISTENCE_LANDSCAPE_H_
 #define PERSISTENCE_LANDSCAPE_H_
 
-//standard include
+// standard include
 #include <cmath>
 #include <iostream>
 #include <vector>
@@ -33,27 +32,18 @@
 #include <sstream>
 #include <algorithm>
 
-
-//gudhi include
+// gudhi include
 #include <gudhi/read_persistence_from_file.h>
 #include <gudhi/common_persistence_representations.h>
 
-
-
-
-namespace Gudhi
-{
-namespace Persistence_representations
-{
-
-
+namespace Gudhi {
+namespace Persistence_representations {
 
 // pre declaration
 class Persistence_landscape;
-template < typename operation > 
-Persistence_landscape operation_on_pair_of_landscapes( const Persistence_landscape& land1 ,  const Persistence_landscape& land2 );
-
-
+template <typename operation>
+Persistence_landscape operation_on_pair_of_landscapes(const Persistence_landscape& land1,
+                                                      const Persistence_landscape& land2);
 
 /**
  * \class Persistence_landscape Persistence_landscape.h gudhi/Persistence_landscape.h
@@ -76,1395 +66,1256 @@ Persistence_landscape operation_on_pair_of_landscapes( const Persistence_landsca
  * value, please rescale them before use this code.
  *
 **/
-class Persistence_landscape
-{
-public:
-	/**
-	 * Default constructor.
-	**/
-    Persistence_landscape()
-    {
-		this->set_up_numbers_of_functions_for_vectorization_and_projections_to_reals();
-	}
-
-    /**
-	 * Constructor that takes as an input a vector of birth-death pairs.
-	**/
-    Persistence_landscape( const std::vector< std::pair< double , double > >& p );
-
-    /**
-	 * Constructor that reads persistence intervals from file and creates persistence landscape. The format of the input file is the following: in each line we put birth-death pair. Last line is assumed
-	 * to be empty. Even if the points within a line are not ordered, they will be ordered while the input is read.
-	**/
-    Persistence_landscape(const char* filename , size_t dimension = std::numeric_limits<unsigned>::max() );
-
-
-
-    /**
-     * This procedure loads a landscape from file. It erase all the data that was previously stored in this landscape.
-    **/
-    void load_landscape_from_file( const char* filename );
-
-
-    /**
-     * The procedure stores a landscape to a file. The file can be later used by a procedure load_landscape_from_file.
-    **/
-    void print_to_file( const char* filename )const;
-
-
-
-	/**
-	 * This function compute integral of the landscape (defined formally as sum of integrals on R of all landscape functions)
-	**/
-    double compute_integral_of_landscape()const;
-
-
-    /**
-	 * This function compute integral of the 'level'-level of a landscape.
-	**/
-    double compute_integral_of_a_level_of_a_landscape( size_t level )const;
-
-
-    /**
-	 * This function compute integral of the landscape p-th power of a landscape (defined formally as sum of integrals on R of p-th powers of all landscape functions)
-	**/
-	double compute_integral_of_landscape( double p )const;//this function compute integral of p-th power of landscape.
-
-
-    /**
-     * A function that computes the value of a landscape at a given point. The parameters of the function are: unsigned level and double x.
-     * The procedure will compute the value of the level-landscape at the point x.
-    **/
-    double compute_value_at_a_given_point( unsigned level , double x )const;
-
-    /**
-     * Writing landscape into a stream. A i-th level landscape starts with a string "lambda_i". Then the discontinuity points of the landscapes follows.
-     * Shall those points be joined with lines, we will obtain the i-th landscape function.
-    **/
-    friend std::ostream& operator<<(std::ostream& out, Persistence_landscape& land );
-    
-    template < typename operation > 
-	friend Persistence_landscape operation_on_pair_of_landscapes( const Persistence_landscape& land1 ,  const Persistence_landscape& land2 );
-
-
-
-
-	/**
-	 *\private A function that compute sum of two landscapes.
-	**/
-    friend Persistence_landscape add_two_landscapes ( const Persistence_landscape& land1 ,  const Persistence_landscape& land2 )
-    {
-        return operation_on_pair_of_landscapes< std::plus<double> >(land1,land2);
+class Persistence_landscape {
+ public:
+  /**
+   * Default constructor.
+  **/
+  Persistence_landscape() { this->set_up_numbers_of_functions_for_vectorization_and_projections_to_reals(); }
+
+  /**
+       * Constructor that takes as an input a vector of birth-death pairs.
+      **/
+  Persistence_landscape(const std::vector<std::pair<double, double> >& p);
+
+  /**
+       * Constructor that reads persistence intervals from file and creates persistence landscape. The format of the
+    *input file is the following: in each line we put birth-death pair. Last line is assumed
+       * to be empty. Even if the points within a line are not ordered, they will be ordered while the input is read.
+      **/
+  Persistence_landscape(const char* filename, size_t dimension = std::numeric_limits<unsigned>::max());
+
+  /**
+   * This procedure loads a landscape from file. It erase all the data that was previously stored in this landscape.
+  **/
+  void load_landscape_from_file(const char* filename);
+
+  /**
+   * The procedure stores a landscape to a file. The file can be later used by a procedure load_landscape_from_file.
+  **/
+  void print_to_file(const char* filename) const;
+
+  /**
+   * This function compute integral of the landscape (defined formally as sum of integrals on R of all landscape
+   *functions)
+  **/
+  double compute_integral_of_landscape() const;
+
+  /**
+       * This function compute integral of the 'level'-level of a landscape.
+      **/
+  double compute_integral_of_a_level_of_a_landscape(size_t level) const;
+
+  /**
+       * This function compute integral of the landscape p-th power of a landscape (defined formally as sum of integrals
+    *on R of p-th powers of all landscape functions)
+      **/
+  double compute_integral_of_landscape(double p) const;  // this function compute integral of p-th power of landscape.
+
+  /**
+   * A function that computes the value of a landscape at a given point. The parameters of the function are: unsigned
+   *level and double x.
+   * The procedure will compute the value of the level-landscape at the point x.
+  **/
+  double compute_value_at_a_given_point(unsigned level, double x) const;
+
+  /**
+   * Writing landscape into a stream. A i-th level landscape starts with a string "lambda_i". Then the discontinuity
+   *points of the landscapes follows.
+   * Shall those points be joined with lines, we will obtain the i-th landscape function.
+  **/
+  friend std::ostream& operator<<(std::ostream& out, Persistence_landscape& land);
+
+  template <typename operation>
+  friend Persistence_landscape operation_on_pair_of_landscapes(const Persistence_landscape& land1,
+                                                               const Persistence_landscape& land2);
+
+  /**
+   *\private A function that compute sum of two landscapes.
+  **/
+  friend Persistence_landscape add_two_landscapes(const Persistence_landscape& land1,
+                                                  const Persistence_landscape& land2) {
+    return operation_on_pair_of_landscapes<std::plus<double> >(land1, land2);
+  }
+
+  /**
+       *\private A function that compute difference of two landscapes.
+      **/
+  friend Persistence_landscape subtract_two_landscapes(const Persistence_landscape& land1,
+                                                       const Persistence_landscape& land2) {
+    return operation_on_pair_of_landscapes<std::minus<double> >(land1, land2);
+  }
+
+  /**
+   * An operator +, that compute sum of two landscapes.
+  **/
+  friend Persistence_landscape operator+(const Persistence_landscape& first, const Persistence_landscape& second) {
+    return add_two_landscapes(first, second);
+  }
+
+  /**
+   * An operator -, that compute difference of two landscapes.
+  **/
+  friend Persistence_landscape operator-(const Persistence_landscape& first, const Persistence_landscape& second) {
+    return subtract_two_landscapes(first, second);
+  }
+
+  /**
+   * An operator * that allows multiplication of a landscape by a real number.
+  **/
+  friend Persistence_landscape operator*(const Persistence_landscape& first, double con) {
+    return first.multiply_lanscape_by_real_number_not_overwrite(con);
+  }
+
+  /**
+   * An operator * that allows multiplication of a landscape by a real number (order of parameters swapped).
+  **/
+  friend Persistence_landscape operator*(double con, const Persistence_landscape& first) {
+    return first.multiply_lanscape_by_real_number_not_overwrite(con);
+  }
+
+  /**
+   * Operator +=. The second parameter is persistence landscape.
+  **/
+  Persistence_landscape operator+=(const Persistence_landscape& rhs) {
+    *this = *this + rhs;
+    return *this;
+  }
+
+  /**
+   * Operator -=. The second parameter is a persistence landscape.
+  **/
+  Persistence_landscape operator-=(const Persistence_landscape& rhs) {
+    *this = *this - rhs;
+    return *this;
+  }
+
+  /**
+   * Operator *=. The second parameter is a real number by which the y values of all landscape functions are multiplied.
+   *The x-values remain unchanged.
+  **/
+  Persistence_landscape operator*=(double x) {
+    *this = *this * x;
+    return *this;
+  }
+
+  /**
+   * Operator /=. The second parameter is a real number.
+  **/
+  Persistence_landscape operator/=(double x) {
+    if (x == 0) throw("In operator /=, division by 0. Program terminated.");
+    *this = *this * (1 / x);
+    return *this;
+  }
+
+  /**
+   * An operator to compare two persistence landscapes.
+  **/
+  bool operator==(const Persistence_landscape& rhs) const;
+
+  /**
+       * An operator to compare two persistence landscapes.
+      **/
+  bool operator!=(const Persistence_landscape& rhs) const { return !((*this) == rhs); }
+
+  /**
+   * Computations of maximum (y) value of landscape.
+  **/
+  double compute_maximum() const {
+    double maxValue = 0;
+    if (this->land.size()) {
+      maxValue = -std::numeric_limits<int>::max();
+      for (size_t i = 0; i != this->land[0].size(); ++i) {
+        if (this->land[0][i].second > maxValue) maxValue = this->land[0][i].second;
+      }
     }
-
-    /**
-	 *\private A function that compute difference of two landscapes.
-	**/
-    friend Persistence_landscape subtract_two_landscapes ( const Persistence_landscape& land1 ,  const Persistence_landscape& land2 )
-    {
-        return operation_on_pair_of_landscapes< std::minus<double> >(land1,land2);
+    return maxValue;
+  }
+
+  /**
+       *\private Computations of minimum (y) value of landscape.
+      **/
+  double compute_minimum() const {
+    double minValue = 0;
+    if (this->land.size()) {
+      minValue = std::numeric_limits<int>::max();
+      for (size_t i = 0; i != this->land[0].size(); ++i) {
+        if (this->land[0][i].second < minValue) minValue = this->land[0][i].second;
+      }
     }
-
-	/**
-	 * An operator +, that compute sum of two landscapes.
-	**/
-    friend Persistence_landscape operator+( const Persistence_landscape& first , const Persistence_landscape& second )
-    {
-        return add_two_landscapes( first,second );
+    return minValue;
+  }
+
+  /**
+   *\private Computations of a \f$L^i\f$ norm of landscape, where i is the input parameter.
+  **/
+  double compute_norm_of_landscape(double i) {
+    Persistence_landscape l;
+    if (i < std::numeric_limits<double>::max()) {
+      return compute_distance_of_landscapes(*this, l, i);
+    } else {
+      return compute_max_norm_distance_of_landscapes(*this, l);
     }
-
-	/**
-	 * An operator -, that compute difference of two landscapes.
-	**/
-    friend Persistence_landscape operator-( const Persistence_landscape& first , const Persistence_landscape& second )
-    {
-        return subtract_two_landscapes( first,second );
+  }
+
+  /**
+   * An operator to compute the value of a landscape in the level 'level' at the argument 'x'.
+  **/
+  double operator()(unsigned level, double x) const { return this->compute_value_at_a_given_point(level, x); }
+
+  /**
+   *\private Computations of \f$L^{\infty}\f$ distance between two landscapes.
+  **/
+  friend double compute_max_norm_distance_of_landscapes(const Persistence_landscape& first,
+                                                        const Persistence_landscape& second);
+
+  /**
+   *\private Computations of \f$L^{p}\f$ distance between two landscapes. p is the parameter of the procedure.
+  **/
+  friend double compute_distance_of_landscapes(const Persistence_landscape& first, const Persistence_landscape& second,
+                                               double p);
+
+  /**
+   * Function to compute absolute value of a PL function. The representation of persistence landscapes allow to store
+   *general PL-function. When computing distance between two landscapes, we compute difference between
+   * them. In this case, a general PL-function with negative value can appear as a result. Then in order to compute
+   *distance, we need to take its absolute value. This is the purpose of this procedure.
+  **/
+  Persistence_landscape abs();
+
+  /**
+   * Computes the number of landscape functions.
+  **/
+  size_t size() const { return this->land.size(); }
+
+  /**
+   *  Compute maximal value of lambda-level landscape.
+  **/
+  double find_max(unsigned lambda) const;
+
+  /**
+   *\private Function to compute inner (scalar) product of two landscapes.
+  **/
+  friend double compute_inner_product(const Persistence_landscape& l1, const Persistence_landscape& l2);
+
+  // Implementations of functions for various concepts.
+
+  /**
+   * The number of projections to R is defined to the number of nonzero landscape functions. I-th projection is an
+   *integral of i-th landscape function over whole R.
+   * This function is required by the Real_valued_topological_data concept.
+   * At the moment this function is not tested, since it is quite likely to be changed in the future. Given this, when
+   *using it, keep in mind that it
+   * will be most likely changed in the next versions.
+  **/
+  double project_to_R(int number_of_function) const {
+    return this->compute_integral_of_a_level_of_a_landscape((size_t)number_of_function);
+  }
+
+  /**
+   * The function gives the number of possible projections to R. This function is required by the
+   *Real_valued_topological_data concept.
+  **/
+  size_t number_of_projections_to_R() const { return this->number_of_functions_for_projections_to_reals; }
+
+  /**
+   * This function produce a vector of doubles based on a landscape. It is required in a concept
+   * Vectorized_topological_data
+  */
+  std::vector<double> vectorize(int number_of_function) const {
+    // TODO, think of something smarter over here
+    std::vector<double> v;
+    if ((size_t)number_of_function > this->land.size()) {
+      return v;
     }
-
-	/**
-	 * An operator * that allows multiplication of a landscape by a real number.
-	**/
-    friend Persistence_landscape operator*( const Persistence_landscape& first , double con )
-    {
-        return first.multiply_lanscape_by_real_number_not_overwrite(con);
+    v.reserve(this->land[number_of_function].size());
+    for (size_t i = 0; i != this->land[number_of_function].size(); ++i) {
+      v.push_back(this->land[number_of_function][i].second);
     }
+    return v;
+  }
+  /**
+   * This function return the number of functions that allows vectorization of persistence landscape. It is required in
+   *a concept Vectorized_topological_data.
+   **/
+  size_t number_of_vectorize_functions() const { return this->number_of_functions_for_vectorization; }
+
+  /**
+   * A function to compute averaged persistence landscape, based on vector of persistence landscapes.
+   * This function is required by Topological_data_with_averages concept.
+  **/
+  void compute_average(const std::vector<Persistence_landscape*>& to_average) {
+    bool dbg = false;
 
-	/**
-	 * An operator * that allows multiplication of a landscape by a real number (order of parameters swapped).
-	**/
-    friend Persistence_landscape operator*( double con , const Persistence_landscape& first  )
-    {
-        return first.multiply_lanscape_by_real_number_not_overwrite(con);
+    if (dbg) {
+      std::cerr << "to_average.size() : " << to_average.size() << std::endl;
     }
 
-	/**
-	 * Operator +=. The second parameter is persistence landscape.
-	**/
-    Persistence_landscape operator += ( const Persistence_landscape& rhs )
-    {
-        *this = *this + rhs;
-        return *this;
+    std::vector<Persistence_landscape*> nextLevelMerge(to_average.size());
+    for (size_t i = 0; i != to_average.size(); ++i) {
+      nextLevelMerge[i] = to_average[i];
     }
-
-	/**
-	 * Operator -=. The second parameter is a persistence landscape.
-	**/
-    Persistence_landscape operator -= ( const Persistence_landscape& rhs )
-    {
-        *this = *this - rhs;
-        return *this;
+    bool is_this_first_level = true;  // in the loop, we will create dynamically a number of intermediate complexes. We
+                                      // have to clean that up, but we cannot erase the initial landscapes we have
+    // to average. In this case, we simply check if the nextLevelMerge are the input landscapes or the ones created in
+    // that loop by using this extra variable.
+
+    while (nextLevelMerge.size() != 1) {
+      if (dbg) {
+        std::cerr << "nextLevelMerge.size() : " << nextLevelMerge.size() << std::endl;
+      }
+      std::vector<Persistence_landscape*> nextNextLevelMerge;
+      nextNextLevelMerge.reserve(to_average.size());
+      for (size_t i = 0; i < nextLevelMerge.size(); i = i + 2) {
+        if (dbg) {
+          std::cerr << "i : " << i << std::endl;
+        }
+        Persistence_landscape* l = new Persistence_landscape;
+        if (i + 1 != nextLevelMerge.size()) {
+          (*l) = (*nextLevelMerge[i]) + (*nextLevelMerge[i + 1]);
+        } else {
+          (*l) = *nextLevelMerge[i];
+        }
+        nextNextLevelMerge.push_back(l);
+      }
+      if (dbg) {
+        std::cerr << "After this iteration \n";
+        getchar();
+      }
+
+      if (!is_this_first_level) {
+        // deallocate the memory if the vector nextLevelMerge do not consist of the initial landscapes
+        for (size_t i = 0; i != nextLevelMerge.size(); ++i) {
+          delete nextLevelMerge[i];
+        }
+      }
+      is_this_first_level = false;
+      nextLevelMerge.swap(nextNextLevelMerge);
     }
-
-
-	/**
-	 * Operator *=. The second parameter is a real number by which the y values of all landscape functions are multiplied. The x-values remain unchanged. 
-	**/
-    Persistence_landscape operator *= ( double x )
-    {
-        *this = *this*x;
-        return *this;
+    (*this) = (*nextLevelMerge[0]);
+    (*this) *= 1 / ((double)to_average.size());
+  }
+
+  /**
+  * A function to compute distance between persistence landscape.
+  * The parameter of this function is a Persistence_landscape.
+  * This function is required in Topological_data_with_distances concept.
+  * For max norm distance, set power to std::numeric_limits<double>::max()
+  **/
+  double distance(const Persistence_landscape& second, double power = 1) const {
+    if (power < std::numeric_limits<double>::max()) {
+      return compute_distance_of_landscapes(*this, second, power);
+    } else {
+      return compute_max_norm_distance_of_landscapes(*this, second);
     }
-
-	/**
-	 * Operator /=. The second parameter is a real number.
-	**/
-    Persistence_landscape operator /= ( double x )
-    {
-        if ( x == 0 )throw( "In operator /=, division by 0. Program terminated." );
-        *this = *this * (1/x);
-        return *this;
+  }
+
+  /**
+  * A function to compute scalar product of persistence landscapes.
+  * The parameter of this function is a Persistence_landscape.
+  * This function is required in Topological_data_with_scalar_product concept.
+  **/
+  double compute_scalar_product(const Persistence_landscape& second) const {
+    return compute_inner_product((*this), second);
+  }
+  // end of implementation of functions needed for concepts.
+
+  /**
+   * This procedure returns y-range of a given level persistence landscape. If a default value is used, the y-range
+   * of 0th level landscape is given (and this range contains the ranges of all other landscapes).
+  **/
+  std::pair<double, double> get_y_range(size_t level = 0) const {
+    std::pair<double, double> result;
+    if (level < this->land.size()) {
+      double maxx = this->compute_maximum();
+      double minn = this->compute_minimum();
+      result = std::make_pair(minn, maxx);
+    } else {
+      result = std::make_pair(0, 0);
     }
+    return result;
+  }
+
+  // a function used to create a gnuplot script for visualization of landscapes
+  void plot(const char* filename, double xRangeBegin = std::numeric_limits<double>::max(),
+            double xRangeEnd = std::numeric_limits<double>::max(),
+            double yRangeBegin = std::numeric_limits<double>::max(),
+            double yRangeEnd = std::numeric_limits<double>::max(), int from = std::numeric_limits<int>::max(),
+            int to = std::numeric_limits<int>::max());
+
+ protected:
+  std::vector<std::vector<std::pair<double, double> > > land;
+  size_t number_of_functions_for_vectorization;
+  size_t number_of_functions_for_projections_to_reals;
+
+  void construct_persistence_landscape_from_barcode(const std::vector<std::pair<double, double> >& p);
+  Persistence_landscape multiply_lanscape_by_real_number_not_overwrite(double x) const;
+  void multiply_lanscape_by_real_number_overwrite(double x);
+  friend double compute_maximal_distance_non_symmetric(const Persistence_landscape& pl1,
+                                                       const Persistence_landscape& pl2);
+
+  void set_up_numbers_of_functions_for_vectorization_and_projections_to_reals() {
+    // warning, this function can be only called after filling in the intervals vector.
+    this->number_of_functions_for_vectorization = this->land.size();
+    this->number_of_functions_for_projections_to_reals = this->land.size();
+  }
+};
 
-	/**
-	 * An operator to compare two persistence landscapes.
-	**/
-    bool operator == ( const Persistence_landscape& rhs  )const;
-
-
-    /**
-	 * An operator to compare two persistence landscapes.
-	**/
-    bool operator != ( const Persistence_landscape& rhs  )const
-    {
-		return !((*this) == rhs);
-	}
-
+Persistence_landscape::Persistence_landscape(const char* filename, size_t dimension) {
+  std::vector<std::pair<double, double> > barcode;
+  if (dimension < std::numeric_limits<double>::max()) {
+    barcode = read_persistence_intervals_in_one_dimension_from_file(filename, dimension);
+  } else {
+    barcode = read_persistence_intervals_in_one_dimension_from_file(filename);
+  }
+  this->construct_persistence_landscape_from_barcode(barcode);
+  this->set_up_numbers_of_functions_for_vectorization_and_projections_to_reals();
+}
 
-	/**
-	 * Computations of maximum (y) value of landscape.
-	**/
-    double compute_maximum()const
-    {
-        double maxValue = 0;
-        if ( this->land.size() )
-        {
-            maxValue = -std::numeric_limits<int>::max();
-            for ( size_t i = 0 ; i != this->land[0].size() ; ++i )
-            {
-                if ( this->land[0][i].second > maxValue )maxValue = this->land[0][i].second;
-            }
-        }
-        return maxValue;
-    }
-    
-    
-    /**
-	 *\private Computations of minimum (y) value of landscape.
-	**/
-    double compute_minimum()const
-    {
-        double minValue = 0;
-        if ( this->land.size() )
-        {
-            minValue = std::numeric_limits<int>::max();
-            for ( size_t i = 0 ; i != this->land[0].size() ; ++i )
-            {
-                if ( this->land[0][i].second < minValue )minValue = this->land[0][i].second;
-            }
-        }
-        return minValue;
+bool operatorEqualDbg = false;
+bool Persistence_landscape::operator==(const Persistence_landscape& rhs) const {
+  if (this->land.size() != rhs.land.size()) {
+    if (operatorEqualDbg) std::cerr << "1\n";
+    return false;
+  }
+  for (size_t level = 0; level != this->land.size(); ++level) {
+    if (this->land[level].size() != rhs.land[level].size()) {
+      if (operatorEqualDbg) std::cerr << "this->land[level].size() : " << this->land[level].size() << "\n";
+      if (operatorEqualDbg) std::cerr << "rhs.land[level].size() : " << rhs.land[level].size() << "\n";
+      if (operatorEqualDbg) std::cerr << "2\n";
+      return false;
     }
-
-	/**
-	 *\private Computations of a \f$L^i\f$ norm of landscape, where i is the input parameter.
-	**/
-    double compute_norm_of_landscape( double i )
-    {
-        Persistence_landscape l;
-        if ( i < std::numeric_limits< double >::max() )
-        {
-            return compute_distance_of_landscapes(*this,l,i);
-        }
-        else
-        {
-            return compute_max_norm_distance_of_landscapes(*this,l);
-        }
+    for (size_t i = 0; i != this->land[level].size(); ++i) {
+      if (!(almost_equal(this->land[level][i].first, rhs.land[level][i].first) &&
+            almost_equal(this->land[level][i].second, rhs.land[level][i].second))) {
+        if (operatorEqualDbg)
+          std::cerr << "this->land[level][i] : " << this->land[level][i].first << " " << this->land[level][i].second
+                    << "\n";
+        if (operatorEqualDbg)
+          std::cerr << "rhs.land[level][i] : " << rhs.land[level][i].first << " " << rhs.land[level][i].second << "\n";
+        if (operatorEqualDbg) std::cerr << "3\n";
+        return false;
+      }
     }
+  }
+  return true;
+}
 
-	/**
- 	 * An operator to compute the value of a landscape in the level 'level' at the argument 'x'.
-	**/
-    double operator()(unsigned level,double x)const{return this->compute_value_at_a_given_point(level,x);}
-
-	/**
-	 *\private Computations of \f$L^{\infty}\f$ distance between two landscapes.
-	**/
-    friend double compute_max_norm_distance_of_landscapes( const Persistence_landscape& first, const Persistence_landscape& second );
-
-
-	/**
-	 *\private Computations of \f$L^{p}\f$ distance between two landscapes. p is the parameter of the procedure.
-	**/
-    friend double compute_distance_of_landscapes( const Persistence_landscape& first, const Persistence_landscape& second , double p );
-
-
-
-	/**
-	 * Function to compute absolute value of a PL function. The representation of persistence landscapes allow to store general PL-function. When computing distance between two landscapes, we compute difference between
-	 * them. In this case, a general PL-function with negative value can appear as a result. Then in order to compute distance, we need to take its absolute value. This is the purpose of this procedure.
-	**/
-    Persistence_landscape abs();
-
-	/**
-	 * Computes the number of landscape functions.
-	**/
-    size_t size()const{return this->land.size(); }
+Persistence_landscape::Persistence_landscape(const std::vector<std::pair<double, double> >& p) {
+  this->construct_persistence_landscape_from_barcode(p);
+  this->set_up_numbers_of_functions_for_vectorization_and_projections_to_reals();
+}
 
-	/**
-	 *  Compute maximal value of lambda-level landscape.
-	**/
-    double find_max( unsigned lambda )const;
+void Persistence_landscape::construct_persistence_landscape_from_barcode(
+    const std::vector<std::pair<double, double> >& p) {
+  bool dbg = false;
+  if (dbg) {
+    std::cerr << "Persistence_landscape::Persistence_landscape( const std::vector< std::pair< double , double > >& p )"
+              << std::endl;
+  }
+
+  // this is a general algorithm to construct persistence landscapes.
+  std::vector<std::pair<double, double> > bars;
+  bars.insert(bars.begin(), p.begin(), p.end());
+  std::sort(bars.begin(), bars.end(), compare_points_sorting);
+
+  if (dbg) {
+    std::cerr << "Bars : \n";
+    for (size_t i = 0; i != bars.size(); ++i) {
+      std::cerr << bars[i].first << " " << bars[i].second << "\n";
+    }
+    getchar();
+  }
+
+  std::vector<std::pair<double, double> > characteristicPoints(p.size());
+  for (size_t i = 0; i != bars.size(); ++i) {
+    characteristicPoints[i] =
+        std::make_pair((bars[i].first + bars[i].second) / 2.0, (bars[i].second - bars[i].first) / 2.0);
+  }
+  std::vector<std::vector<std::pair<double, double> > > Persistence_landscape;
+  while (!characteristicPoints.empty()) {
+    if (dbg) {
+      for (size_t i = 0; i != characteristicPoints.size(); ++i) {
+        std::cout << "(" << characteristicPoints[i].first << " " << characteristicPoints[i].second << ")\n";
+      }
+      std::cin.ignore();
+    }
 
-	/**
-	 *\private Function to compute inner (scalar) product of two landscapes.
-	**/
-    friend double compute_inner_product( const Persistence_landscape& l1 , const Persistence_landscape& l2 );
+    std::vector<std::pair<double, double> > lambda_n;
+    lambda_n.push_back(std::make_pair(-std::numeric_limits<int>::max(), 0));
+    lambda_n.push_back(std::make_pair(minus_length(characteristicPoints[0]), 0));
+    lambda_n.push_back(characteristicPoints[0]);
 
-	//Implementations of functions for various concepts. 
+    if (dbg) {
+      std::cerr << "1 Adding to lambda_n : (" << -std::numeric_limits<int>::max() << " " << 0 << ") , ("
+                << minus_length(characteristicPoints[0]) << " " << 0 << ") , (" << characteristicPoints[0].first << " "
+                << characteristicPoints[0].second << ") \n";
+    }
 
-	/**
-	 * The number of projections to R is defined to the number of nonzero landscape functions. I-th projection is an integral of i-th landscape function over whole R.
-	 * This function is required by the Real_valued_topological_data concept.
-         * At the moment this function is not tested, since it is quite likely to be changed in the future. Given this, when using it, keep in mind that it
-         * will be most likely changed in the next versions.
-	**/
-    double project_to_R( int number_of_function )const
-    {
-		return this->compute_integral_of_a_level_of_a_landscape( (size_t)number_of_function );
-	}
-	
-	/**
-	 * The function gives the number of possible projections to R. This function is required by the Real_valued_topological_data concept.
-	**/ 
-	size_t number_of_projections_to_R()const
-	{
-		return this->number_of_functions_for_projections_to_reals;
-	}
-
-	/**
-	 * This function produce a vector of doubles based on a landscape. It is required in a concept Vectorized_topological_data
-	*/
-    std::vector<double> vectorize( int number_of_function )const
-    {
-		//TODO, think of something smarter over here
-		std::vector<double> v;
-		if ( (size_t)number_of_function > this->land.size() )
-		{
-			return v;
-		}
-		v.reserve( this->land[number_of_function].size() );
-		for ( size_t i = 0 ; i != this->land[number_of_function].size() ; ++i )
-		{
-			v.push_back( this->land[number_of_function][i].second );
-		}
-		return v;
-	}
-	/**
-	 * This function return the number of functions that allows vectorization of persistence landscape. It is required in a concept Vectorized_topological_data.
-	 **/ 
-	size_t number_of_vectorize_functions()const
-	{
-		return this->number_of_functions_for_vectorization;	
-	}
-	
-	/**
-	 * A function to compute averaged persistence landscape, based on vector of persistence landscapes.
-	 * This function is required by Topological_data_with_averages concept.
-	**/ 
-    void compute_average( const std::vector< Persistence_landscape* >& to_average )
-    {
-		bool dbg = false;		
-		
-		if ( dbg ){std::cerr << "to_average.size() : " << to_average.size() << std::endl;}
-
-		std::vector< Persistence_landscape* > nextLevelMerge( to_average.size() );
-        for ( size_t i = 0 ; i != to_average.size() ; ++i )
-        {
-            nextLevelMerge[i] = to_average[i];            
-        }
-        bool is_this_first_level = true;//in the loop, we will create dynamically a number of intermediate complexes. We have to clean that up, but we cannot erase the initial landscapes we have
-										//to average. In this case, we simply check if the nextLevelMerge are the input landscapes or the ones created in that loop by using this extra variable.
-
-        while ( nextLevelMerge.size() != 1 )
-        {
-            if ( dbg ){std::cerr << "nextLevelMerge.size() : " << nextLevelMerge.size() << std::endl;}
-            std::vector< Persistence_landscape* > nextNextLevelMerge;
-            nextNextLevelMerge.reserve( to_average.size() );
-            for ( size_t i = 0 ; i < nextLevelMerge.size() ; i=i+2 )
-            {
-                if ( dbg ){std::cerr << "i : " << i << std::endl;}
-                Persistence_landscape* l = new Persistence_landscape;
-                if ( i+1 != nextLevelMerge.size() )
-                {					
-                    (*l) = (*nextLevelMerge[i])+(*nextLevelMerge[i+1]);                    
-                }
-                else
-                {
-                    (*l) = *nextLevelMerge[i];
-                }
-                nextNextLevelMerge.push_back( l );
+    size_t i = 1;
+    std::vector<std::pair<double, double> > newCharacteristicPoints;
+    while (i < characteristicPoints.size()) {
+      size_t p = 1;
+      if ((minus_length(characteristicPoints[i]) >= minus_length(lambda_n[lambda_n.size() - 1])) &&
+          (birth_plus_deaths(characteristicPoints[i]) > birth_plus_deaths(lambda_n[lambda_n.size() - 1]))) {
+        if (minus_length(characteristicPoints[i]) < birth_plus_deaths(lambda_n[lambda_n.size() - 1])) {
+          std::pair<double, double> point = std::make_pair(
+              (minus_length(characteristicPoints[i]) + birth_plus_deaths(lambda_n[lambda_n.size() - 1])) / 2,
+              (birth_plus_deaths(lambda_n[lambda_n.size() - 1]) - minus_length(characteristicPoints[i])) / 2);
+          lambda_n.push_back(point);
+          if (dbg) {
+            std::cerr << "2 Adding to lambda_n : (" << point.first << " " << point.second << ")\n";
+          }
+
+          if (dbg) {
+            std::cerr << "characteristicPoints[i+p] : " << characteristicPoints[i + p].first << " "
+                      << characteristicPoints[i + p].second << "\n";
+            std::cerr << "point : " << point.first << " " << point.second << "\n";
+            getchar();
+          }
+
+          while ((i + p < characteristicPoints.size()) &&
+                 (almost_equal(minus_length(point), minus_length(characteristicPoints[i + p]))) &&
+                 (birth_plus_deaths(point) <= birth_plus_deaths(characteristicPoints[i + p]))) {
+            newCharacteristicPoints.push_back(characteristicPoints[i + p]);
+            if (dbg) {
+              std::cerr << "3.5 Adding to newCharacteristicPoints : (" << characteristicPoints[i + p].first << " "
+                        << characteristicPoints[i + p].second << ")\n";
+              getchar();
+            }
+            ++p;
+          }
+
+          newCharacteristicPoints.push_back(point);
+          if (dbg) {
+            std::cerr << "4 Adding to newCharacteristicPoints : (" << point.first << " " << point.second << ")\n";
+          }
+
+          while ((i + p < characteristicPoints.size()) &&
+                 (minus_length(point) <= minus_length(characteristicPoints[i + p])) &&
+                 (birth_plus_deaths(point) >= birth_plus_deaths(characteristicPoints[i + p]))) {
+            newCharacteristicPoints.push_back(characteristicPoints[i + p]);
+            if (dbg) {
+              std::cerr << "characteristicPoints[i+p] : " << characteristicPoints[i + p].first << " "
+                        << characteristicPoints[i + p].second << "\n";
+              std::cerr << "point : " << point.first << " " << point.second << "\n";
+              std::cerr << "characteristicPoints[i+p] birth and death : " << minus_length(characteristicPoints[i + p])
+                        << " , " << birth_plus_deaths(characteristicPoints[i + p]) << "\n";
+              std::cerr << "point birth and death : " << minus_length(point) << " , " << birth_plus_deaths(point)
+                        << "\n";
+
+              std::cerr << "3 Adding to newCharacteristicPoints : (" << characteristicPoints[i + p].first << " "
+                        << characteristicPoints[i + p].second << ")\n";
+              getchar();
             }
-            if ( dbg ){std::cerr << "After this iteration \n";getchar();}
-
-            if ( !is_this_first_level )
-            {
-				//deallocate the memory if the vector nextLevelMerge do not consist of the initial landscapes
-				for ( size_t i = 0 ; i != nextLevelMerge.size() ; ++i )
-				{
-					delete nextLevelMerge[i];
-				}
-			}
-			is_this_first_level = false;
-            nextLevelMerge.swap(nextNextLevelMerge);
+            ++p;
+          }
+
+        } else {
+          lambda_n.push_back(std::make_pair(birth_plus_deaths(lambda_n[lambda_n.size() - 1]), 0));
+          lambda_n.push_back(std::make_pair(minus_length(characteristicPoints[i]), 0));
+          if (dbg) {
+            std::cerr << "5 Adding to lambda_n : (" << birth_plus_deaths(lambda_n[lambda_n.size() - 1]) << " " << 0
+                      << ")\n";
+            std::cerr << "5 Adding to lambda_n : (" << minus_length(characteristicPoints[i]) << " " << 0 << ")\n";
+          }
         }
-        (*this) = (*nextLevelMerge[0]);
-        (*this) *= 1/( (double)to_average.size() );
-	}
-
-
-	/**
-	* A function to compute distance between persistence landscape.
-	* The parameter of this function is a Persistence_landscape.
-	* This function is required in Topological_data_with_distances concept.
-	* For max norm distance, set power to std::numeric_limits<double>::max()
-	**/
-    double distance( const Persistence_landscape& second , double power = 1 )const
-    {
-		if ( power < std::numeric_limits<double>::max() )
-		{
-			return compute_distance_of_landscapes( *this , second , power );
-		}
-		else
-		{
-			return compute_max_norm_distance_of_landscapes( *this , second );
-		}
-	}
-
-
-	/**
-	* A function to compute scalar product of persistence landscapes.
-	* The parameter of this function is a Persistence_landscape.
-	* This function is required in Topological_data_with_scalar_product concept.
-	**/
-	double compute_scalar_product( const Persistence_landscape& second )const
-	{
-		return compute_inner_product( (*this) , second );
-	}	
-	//end of implementation of functions needed for concepts.
-	
-	/**
-	 * This procedure returns y-range of a given level persistence landscape. If a default value is used, the y-range
-	 * of 0th level landscape is given (and this range contains the ranges of all other landscapes). 
-	**/ 
-	std::pair< double , double > get_y_range( size_t level = 0 )const
-	{
-		std::pair< double , double > result;
-		if ( level < this->land.size() )
-		{
-			double maxx = this->compute_maximum();
-			double minn = this->compute_minimum();
-			result = std::make_pair( minn , maxx );
-		}
-		else
-		{
-			result = std::make_pair( 0,0 );
-		}
-		return result;
-	}
-
-	
-	
-	//a function used to create a gnuplot script for visualization of landscapes
-	void plot( const char* filename,  double xRangeBegin = std::numeric_limits<double>::max() , double xRangeEnd = std::numeric_limits<double>::max() , 
-									  double yRangeBegin = std::numeric_limits<double>::max() , double yRangeEnd = std::numeric_limits<double>::max(),
-									  int from = std::numeric_limits<int>::max(), int to = std::numeric_limits<int>::max()  );
-
-
-protected:
-    std::vector< std::vector< std::pair<double,double> > > land;
-    size_t number_of_functions_for_vectorization;
-	size_t number_of_functions_for_projections_to_reals;
-
-    void construct_persistence_landscape_from_barcode( const std::vector< std::pair< double , double > > & p );
-    Persistence_landscape multiply_lanscape_by_real_number_not_overwrite( double x )const;
-    void multiply_lanscape_by_real_number_overwrite( double x );    
-    friend double compute_maximal_distance_non_symmetric( const Persistence_landscape& pl1, const Persistence_landscape& pl2 );
-
-    void set_up_numbers_of_functions_for_vectorization_and_projections_to_reals()
-	{
-		//warning, this function can be only called after filling in the intervals vector.
-		this->number_of_functions_for_vectorization = this->land.size();
-		this->number_of_functions_for_projections_to_reals = this->land.size();
-	}
-};
-
-
-
-
-
-
-
-Persistence_landscape::Persistence_landscape(const char* filename , size_t dimension)
-{    
-    std::vector< std::pair< double , double > > barcode;    
-    if ( dimension < std::numeric_limits<double>::max() )
-    {
-		barcode = read_persistence_intervals_in_one_dimension_from_file( filename , dimension );	
-	}
-    else
-    {
-		barcode = read_persistence_intervals_in_one_dimension_from_file( filename );
-    }    
-    this->construct_persistence_landscape_from_barcode( barcode );
-    this->set_up_numbers_of_functions_for_vectorization_and_projections_to_reals();
-}
-
-
-bool operatorEqualDbg = false;
-bool Persistence_landscape::operator == ( const Persistence_landscape& rhs  )const
-{
-    if ( this->land.size() != rhs.land.size() )
-    {
-        if (operatorEqualDbg)std::cerr << "1\n";
-        return false;
-    }
-    for ( size_t level = 0 ; level != this->land.size() ; ++level )
-    {
-        if ( this->land[level].size() != rhs.land[level].size() )
-        {
-            if (operatorEqualDbg)std::cerr << "this->land[level].size() : " << this->land[level].size() <<  "\n";
-            if (operatorEqualDbg)std::cerr << "rhs.land[level].size() : " << rhs.land[level].size() <<  "\n";
-            if (operatorEqualDbg)std::cerr << "2\n";
-            return false;
+        lambda_n.push_back(characteristicPoints[i]);
+        if (dbg) {
+          std::cerr << "6 Adding to lambda_n : (" << characteristicPoints[i].first << " "
+                    << characteristicPoints[i].second << ")\n";
         }
-        for ( size_t i = 0 ; i != this->land[level].size() ; ++i )
-        {
-            if ( !( almost_equal(this->land[level][i].first , rhs.land[level][i].first) && almost_equal(this->land[level][i].second , rhs.land[level][i].second) ) )
-            {
-                if (operatorEqualDbg)std::cerr << "this->land[level][i] : " << this->land[level][i].first << " " << this->land[level][i].second << "\n";
-                if (operatorEqualDbg)std::cerr << "rhs.land[level][i] : " << rhs.land[level][i].first << " " << rhs.land[level][i].second	 << "\n";
-                if (operatorEqualDbg)std::cerr << "3\n";
-                return false;
-            }
+      } else {
+        newCharacteristicPoints.push_back(characteristicPoints[i]);
+        if (dbg) {
+          std::cerr << "7 Adding to newCharacteristicPoints : (" << characteristicPoints[i].first << " "
+                    << characteristicPoints[i].second << ")\n";
         }
+      }
+      i = i + p;
     }
-    return true;
-}
-
-
+    lambda_n.push_back(std::make_pair(birth_plus_deaths(lambda_n[lambda_n.size() - 1]), 0));
+    lambda_n.push_back(std::make_pair(std::numeric_limits<int>::max(), 0));
 
+    characteristicPoints = newCharacteristicPoints;
 
-Persistence_landscape::Persistence_landscape( const std::vector< std::pair< double , double > > & p )
-{
-    this->construct_persistence_landscape_from_barcode( p );
-    this->set_up_numbers_of_functions_for_vectorization_and_projections_to_reals();
+    lambda_n.erase(std::unique(lambda_n.begin(), lambda_n.end()), lambda_n.end());
+    this->land.push_back(lambda_n);
+  }
 }
 
-
-void Persistence_landscape::construct_persistence_landscape_from_barcode( const std::vector< std::pair< double , double > > & p )
-{
-	bool dbg = false;
-    if ( dbg ){std::cerr << "Persistence_landscape::Persistence_landscape( const std::vector< std::pair< double , double > >& p )" << std::endl;}
-
-	//this is a general algorithm to construct persistence landscapes.
-	std::vector< std::pair<double,double> > bars;
-	bars.insert( bars.begin() , p.begin() , p.end() );
-	std::sort( bars.begin() , bars.end() , compare_points_sorting );
-
-	if (dbg)
-	{
-		std::cerr << "Bars : \n";
-		for ( size_t i = 0 ; i != bars.size() ; ++i )
-		{
-			std::cerr << bars[i].first << " " << bars[i].second << "\n";
-		}
-		getchar();
-	}
-
-	std::vector< std::pair<double,double> > characteristicPoints(p.size());
-	for ( size_t i = 0 ; i != bars.size() ; ++i )
-	{
-		characteristicPoints[i] = std::make_pair((bars[i].first+bars[i].second)/2.0 , (bars[i].second - bars[i].first)/2.0);
-	}
-	std::vector< std::vector< std::pair<double,double> > > Persistence_landscape;
-	while ( !characteristicPoints.empty() )
-	{
-		if(dbg)
-		{
-			for ( size_t i = 0 ; i != characteristicPoints.size() ; ++i )
-			{
-				std::cout << "("  << characteristicPoints[i].first << " " << characteristicPoints[i].second << ")\n";
-			}
-			std::cin.ignore();
-		}
-
-		std::vector< std::pair<double,double> > lambda_n;
-		lambda_n.push_back( std::make_pair( -std::numeric_limits<int>::max() , 0 ) );
-		lambda_n.push_back( std::make_pair(minus_length(characteristicPoints[0]),0) );
-		lambda_n.push_back( characteristicPoints[0] );
-
-		if (dbg)
-		{
-			std::cerr << "1 Adding to lambda_n : (" << -std::numeric_limits<int>::max() << " " << 0  << ") , (" << minus_length(characteristicPoints[0]) << " " << 0 << ") , (" << characteristicPoints[0].first << " " << characteristicPoints[0].second << ") \n";
-		}
-
-		size_t i = 1;
-		std::vector< std::pair<double,double> >  newCharacteristicPoints;
-		while ( i < characteristicPoints.size() )
-		{
-			size_t p = 1;
-			if ( (minus_length(characteristicPoints[i]) >= minus_length(lambda_n[lambda_n.size()-1])) && (birth_plus_deaths(characteristicPoints[i]) > birth_plus_deaths(lambda_n[lambda_n.size()-1])) )
-			{
-				if ( minus_length(characteristicPoints[i]) < birth_plus_deaths(lambda_n[lambda_n.size()-1]) )
-				{
-					std::pair<double,double> point = std::make_pair( (minus_length(characteristicPoints[i])+birth_plus_deaths(lambda_n[lambda_n.size()-1]))/2 , (birth_plus_deaths(lambda_n[lambda_n.size()-1])-minus_length(characteristicPoints[i]))/2 );
-					lambda_n.push_back( point );
-					if (dbg)
-					{
-						std::cerr << "2 Adding to lambda_n : (" << point.first << " " << point.second << ")\n";
-					}
-
-
-					if ( dbg )
-					{
-						std::cerr << "characteristicPoints[i+p] : " << characteristicPoints[i+p].first << " " << characteristicPoints[i+p].second << "\n";
-						std::cerr << "point : " << point.first << " " << point.second << "\n";
-						getchar();
-					}
-
-					while ( (i+p < characteristicPoints.size() ) && ( almost_equal(minus_length(point),minus_length(characteristicPoints[i+p])) ) && ( birth_plus_deaths(point) <= birth_plus_deaths(characteristicPoints[i+p]) ) )
-					{
-						newCharacteristicPoints.push_back( characteristicPoints[i+p] );
-						if (dbg)
-						{
-							std::cerr << "3.5 Adding to newCharacteristicPoints : (" << characteristicPoints[i+p].first << " " << characteristicPoints[i+p].second << ")\n";
-							getchar();
-						}
-						++p;
-					}
-
-
-					newCharacteristicPoints.push_back( point );
-					if (dbg)
-					{
-						std::cerr << "4 Adding to newCharacteristicPoints : (" << point.first << " " << point.second << ")\n";
-					}
-
-
-					while ( (i+p < characteristicPoints.size() ) && ( minus_length(point) <= minus_length(characteristicPoints[i+p]) ) && (birth_plus_deaths(point)>=birth_plus_deaths(characteristicPoints[i+p])) )
-					{
-						newCharacteristicPoints.push_back( characteristicPoints[i+p] );
-						if (dbg)
-						{
-							std::cerr << "characteristicPoints[i+p] : " << characteristicPoints[i+p].first << " " << characteristicPoints[i+p].second << "\n";
-							std::cerr << "point : " << point.first << " " << point.second << "\n";
-							std::cerr << "characteristicPoints[i+p] birth and death : " << minus_length(characteristicPoints[i+p]) << " , " << birth_plus_deaths(characteristicPoints[i+p]) << "\n";
-							std::cerr << "point birth and death : " << minus_length(point) << " , " << birth_plus_deaths(point) << "\n";
-
-							std::cerr << "3 Adding to newCharacteristicPoints : (" << characteristicPoints[i+p].first << " " << characteristicPoints[i+p].second << ")\n";
-							getchar();
-						}
-						++p;
-					}
-
-				}
-				else
-				{
-					lambda_n.push_back( std::make_pair( birth_plus_deaths(lambda_n[lambda_n.size()-1]) , 0 ) );
-					lambda_n.push_back( std::make_pair( minus_length(characteristicPoints[i]) , 0 ) );
-					if (dbg)
-					{
-						std::cerr << "5 Adding to lambda_n : (" << birth_plus_deaths(lambda_n[lambda_n.size()-1]) << " " <<  0 << ")\n";
-						std::cerr << "5 Adding to lambda_n : (" << minus_length(characteristicPoints[i]) << " " << 0  << ")\n";
-					}
-				}
-				lambda_n.push_back( characteristicPoints[i] );
-				if (dbg)
-				{
-					std::cerr << "6 Adding to lambda_n : (" << characteristicPoints[i].first << " " << characteristicPoints[i].second << ")\n";
-				}
-			}
-			else
-			{
-				newCharacteristicPoints.push_back( characteristicPoints[i] );
-				if (dbg)
-				{
-					std::cerr << "7 Adding to newCharacteristicPoints : (" << characteristicPoints[i].first << " " << characteristicPoints[i].second << ")\n";
-				}
-			}
-			i = i+p;
-		}
-		lambda_n.push_back( std::make_pair(birth_plus_deaths(lambda_n[lambda_n.size()-1]),0) );
-		lambda_n.push_back( std::make_pair( std::numeric_limits<int>::max() , 0 ) );
-
-		characteristicPoints = newCharacteristicPoints;
-
-		lambda_n.erase(std::unique(lambda_n.begin(), lambda_n.end()), lambda_n.end());
-		this->land.push_back( lambda_n );
-	}
+// this function find maximum of lambda_n
+double Persistence_landscape::find_max(unsigned lambda) const {
+  if (this->land.size() < lambda) return 0;
+  double maximum = -std::numeric_limits<int>::max();
+  for (size_t i = 0; i != this->land[lambda].size(); ++i) {
+    if (this->land[lambda][i].second > maximum) maximum = this->land[lambda][i].second;
+  }
+  return maximum;
 }
 
-
-
-//this function find maximum of lambda_n
-double Persistence_landscape::find_max( unsigned lambda )const
-{
-    if ( this->land.size() < lambda )return 0;
-    double maximum = -std::numeric_limits<int>::max();
-    for ( size_t i = 0 ; i != this->land[lambda].size() ; ++i )
-    {
-        if ( this->land[lambda][i].second > maximum )maximum = this->land[lambda][i].second;
+double Persistence_landscape::compute_integral_of_landscape() const {
+  double result = 0;
+  for (size_t i = 0; i != this->land.size(); ++i) {
+    for (size_t nr = 2; nr != this->land[i].size() - 1; ++nr) {
+      // it suffices to compute every planar integral and then sum them up for each lambda_n
+      result += 0.5 * (this->land[i][nr].first - this->land[i][nr - 1].first) *
+                (this->land[i][nr].second + this->land[i][nr - 1].second);
     }
-    return maximum;
+  }
+  return result;
 }
 
-
-double Persistence_landscape::compute_integral_of_landscape()const
-{
-    double result = 0;
-    for ( size_t i = 0 ; i != this->land.size() ; ++i )
-    {
-        for ( size_t nr = 2 ; nr != this->land[i].size()-1 ; ++nr )
-        {
-            //it suffices to compute every planar integral and then sum them up for each lambda_n
-            result += 0.5*( this->land[i][nr].first - this->land[i][nr-1].first )*(this->land[i][nr].second + this->land[i][nr-1].second);
-        }
-    }
+double Persistence_landscape::compute_integral_of_a_level_of_a_landscape(size_t level) const {
+  double result = 0;
+  if (level >= this->land.size()) {
+    // this landscape function is constantly equal 0, so is the integral.
     return result;
-}
+  }
+  // also negative landscapes are assumed to be zero.
+  if (level < 0) return 0;
 
-double Persistence_landscape::compute_integral_of_a_level_of_a_landscape( size_t  level )const
-{
-    double result = 0;
-    if ( level >= this->land.size() )
-    {
-		//this landscape function is constantly equal 0, so is the integral.
-		return result;
-	}
-	//also negative landscapes are assumed to be zero.
-	if ( level < 0 )return 0;
-
-	for ( size_t nr = 2 ; nr != this->land[ level ].size()-1 ; ++nr )
-	{
-		//it suffices to compute every planar integral and then sum them up for each lambda_n
-		result += 0.5*( this->land[ level ][nr].first - this->land[ level ][nr-1].first )*(this->land[ level ][nr].second + this->land[ level ][nr-1].second);
-	}
+  for (size_t nr = 2; nr != this->land[level].size() - 1; ++nr) {
+    // it suffices to compute every planar integral and then sum them up for each lambda_n
+    result += 0.5 * (this->land[level][nr].first - this->land[level][nr - 1].first) *
+              (this->land[level][nr].second + this->land[level][nr - 1].second);
+  }
 
-    return result;
+  return result;
 }
 
-
-double Persistence_landscape::compute_integral_of_landscape( double p )const
-{
-	bool dbg = false;
-    double result = 0;
-    for ( size_t i = 0 ; i != this->land.size() ; ++i )
-    {
-        for ( size_t nr = 2 ; nr != this->land[i].size()-1 ; ++nr )
-        {
-            if (dbg)std::cout << "nr : " << nr << "\n";
-            //In this interval, the landscape has a form f(x) = ax+b. We want to compute integral of (ax+b)^p = 1/a * (ax+b)^{p+1}/(p+1)
-            std::pair<double,double> coef = compute_parameters_of_a_line( this->land[i][nr] , this->land[i][nr-1] );
-            double a = coef.first;
-            double b = coef.second;
-
-            if (dbg)std::cout << "(" << this->land[i][nr].first << "," << this->land[i][nr].second << ") , " << this->land[i][nr-1].first << "," << this->land[i][nr].second << ")" << std::endl;
-            if ( this->land[i][nr].first == this->land[i][nr-1].first )continue;
-            if ( a != 0 )
-            {
-                result += 1/(a*(p+1)) * ( pow((a*this->land[i][nr].first+b),p+1) - pow((a*this->land[i][nr-1].first+b),p+1));
-            }
-            else
-            {
-                result += ( this->land[i][nr].first - this->land[i][nr-1].first )*( pow(this->land[i][nr].second,p) );
-            }
-            if ( dbg )
-            {
-                std::cout << "a : " <<a << " , b : " << b << std::endl;
-                std::cout << "result : " << result << std::endl;
-            }
-        }
+double Persistence_landscape::compute_integral_of_landscape(double p) const {
+  bool dbg = false;
+  double result = 0;
+  for (size_t i = 0; i != this->land.size(); ++i) {
+    for (size_t nr = 2; nr != this->land[i].size() - 1; ++nr) {
+      if (dbg) std::cout << "nr : " << nr << "\n";
+      // In this interval, the landscape has a form f(x) = ax+b. We want to compute integral of (ax+b)^p = 1/a *
+      // (ax+b)^{p+1}/(p+1)
+      std::pair<double, double> coef = compute_parameters_of_a_line(this->land[i][nr], this->land[i][nr - 1]);
+      double a = coef.first;
+      double b = coef.second;
+
+      if (dbg)
+        std::cout << "(" << this->land[i][nr].first << "," << this->land[i][nr].second << ") , "
+                  << this->land[i][nr - 1].first << "," << this->land[i][nr].second << ")" << std::endl;
+      if (this->land[i][nr].first == this->land[i][nr - 1].first) continue;
+      if (a != 0) {
+        result += 1 / (a * (p + 1)) *
+                  (pow((a * this->land[i][nr].first + b), p + 1) - pow((a * this->land[i][nr - 1].first + b), p + 1));
+      } else {
+        result += (this->land[i][nr].first - this->land[i][nr - 1].first) * (pow(this->land[i][nr].second, p));
+      }
+      if (dbg) {
+        std::cout << "a : " << a << " , b : " << b << std::endl;
+        std::cout << "result : " << result << std::endl;
+      }
     }
-    return result;
+  }
+  return result;
 }
 
-
-//this is O(log(n)) algorithm, where n is number of points in this->land.
-double Persistence_landscape::compute_value_at_a_given_point( unsigned level , double x )const
-{
-	bool compute_value_at_a_given_pointDbg = false;
-    //in such a case lambda_level = 0.
-    if ( level > this->land.size() ) return 0;
-
-    //we know that the points in this->land[level] are ordered according to x coordinate. Therefore, we can find the point by using bisection:
-    unsigned coordBegin = 1;
-    unsigned coordEnd = this->land[level].size()-2;
-
-    if ( compute_value_at_a_given_pointDbg )
-    {
-        std::cerr << "Here \n";
-        std::cerr << "x : " << x << "\n";
-        std::cerr << "this->land[level][coordBegin].first : " << this->land[level][coordBegin].first << "\n";
-        std::cerr << "this->land[level][coordEnd].first : " << this->land[level][coordEnd].first << "\n";
+// this is O(log(n)) algorithm, where n is number of points in this->land.
+double Persistence_landscape::compute_value_at_a_given_point(unsigned level, double x) const {
+  bool compute_value_at_a_given_pointDbg = false;
+  // in such a case lambda_level = 0.
+  if (level > this->land.size()) return 0;
+
+  // we know that the points in this->land[level] are ordered according to x coordinate. Therefore, we can find the
+  // point by using bisection:
+  unsigned coordBegin = 1;
+  unsigned coordEnd = this->land[level].size() - 2;
+
+  if (compute_value_at_a_given_pointDbg) {
+    std::cerr << "Here \n";
+    std::cerr << "x : " << x << "\n";
+    std::cerr << "this->land[level][coordBegin].first : " << this->land[level][coordBegin].first << "\n";
+    std::cerr << "this->land[level][coordEnd].first : " << this->land[level][coordEnd].first << "\n";
+  }
+
+  // in this case x is outside the support of the landscape, therefore the value of the landscape is 0.
+  if (x <= this->land[level][coordBegin].first) return 0;
+  if (x >= this->land[level][coordEnd].first) return 0;
+
+  if (compute_value_at_a_given_pointDbg) std::cerr << "Entering to the while loop \n";
+
+  while (coordBegin + 1 != coordEnd) {
+    if (compute_value_at_a_given_pointDbg) {
+      std::cerr << "coordBegin : " << coordBegin << "\n";
+      std::cerr << "coordEnd : " << coordEnd << "\n";
+      std::cerr << "this->land[level][coordBegin].first : " << this->land[level][coordBegin].first << "\n";
+      std::cerr << "this->land[level][coordEnd].first : " << this->land[level][coordEnd].first << "\n";
     }
 
-    //in this case x is outside the support of the landscape, therefore the value of the landscape is 0.
-    if ( x <= this->land[level][coordBegin].first )return 0;
-    if ( x >= this->land[level][coordEnd].first )return 0;
-
-    if (compute_value_at_a_given_pointDbg)std::cerr << "Entering to the while loop \n";
-
-    while ( coordBegin+1 != coordEnd )
-    {
-        if (compute_value_at_a_given_pointDbg)
-        {
-            std::cerr << "coordBegin : " << coordBegin << "\n";
-            std::cerr << "coordEnd : " << coordEnd << "\n";
-            std::cerr << "this->land[level][coordBegin].first : " << this->land[level][coordBegin].first << "\n";
-            std::cerr << "this->land[level][coordEnd].first : " << this->land[level][coordEnd].first << "\n";
-        }
-
+    unsigned newCord = (unsigned)floor((coordEnd + coordBegin) / 2.0);
 
-        unsigned newCord = (unsigned)floor((coordEnd+coordBegin)/2.0);
-
-        if (compute_value_at_a_given_pointDbg)
-        {
-            std::cerr << "newCord : " << newCord << "\n";
-            std::cerr << "this->land[level][newCord].first : " << this->land[level][newCord].first << "\n";
-            std::cin.ignore();
-        }
-
-        if ( this->land[level][newCord].first <= x )
-        {
-            coordBegin = newCord;
-            if ( this->land[level][newCord].first == x )return this->land[level][newCord].second;
-        }
-        else
-        {
-            coordEnd = newCord;
-        }
+    if (compute_value_at_a_given_pointDbg) {
+      std::cerr << "newCord : " << newCord << "\n";
+      std::cerr << "this->land[level][newCord].first : " << this->land[level][newCord].first << "\n";
+      std::cin.ignore();
     }
 
-    if (compute_value_at_a_given_pointDbg)
-    {
-        std::cout << "x : " << x << " is between : " << this->land[level][coordBegin].first << " a  " << this->land[level][coordEnd].first << "\n";
-        std::cout << "the y coords are : " << this->land[level][coordBegin].second << " a  " << this->land[level][coordEnd].second << "\n";
-        std::cerr << "coordBegin : " << coordBegin << "\n";
-        std::cerr << "coordEnd : " << coordEnd << "\n";
-        std::cin.ignore();
+    if (this->land[level][newCord].first <= x) {
+      coordBegin = newCord;
+      if (this->land[level][newCord].first == x) return this->land[level][newCord].second;
+    } else {
+      coordEnd = newCord;
     }
-    return function_value( this->land[level][coordBegin] , this->land[level][coordEnd] , x );
+  }
+
+  if (compute_value_at_a_given_pointDbg) {
+    std::cout << "x : " << x << " is between : " << this->land[level][coordBegin].first << " a  "
+              << this->land[level][coordEnd].first << "\n";
+    std::cout << "the y coords are : " << this->land[level][coordBegin].second << " a  "
+              << this->land[level][coordEnd].second << "\n";
+    std::cerr << "coordBegin : " << coordBegin << "\n";
+    std::cerr << "coordEnd : " << coordEnd << "\n";
+    std::cin.ignore();
+  }
+  return function_value(this->land[level][coordBegin], this->land[level][coordEnd], x);
 }
 
-std::ostream& operator<<(std::ostream& out, Persistence_landscape& land )
-{
-    for ( size_t level = 0 ; level != land.land.size() ; ++level )
-    {
-        out << "Lambda_" << level << ":" << std::endl;
-        for ( size_t i = 0 ; i != land.land[level].size() ; ++i )
-        {
-            if ( land.land[level][i].first == -std::numeric_limits<int>::max() )
-            {
-                out << "-inf";
-            }
-            else
-            {
-                if ( land.land[level][i].first == std::numeric_limits<int>::max() )
-                {
-                    out << "+inf";
-                }
-                else
-                {
-                    out << land.land[level][i].first;
-                }
-            }
-            out << " , " << land.land[level][i].second << std::endl;
+std::ostream& operator<<(std::ostream& out, Persistence_landscape& land) {
+  for (size_t level = 0; level != land.land.size(); ++level) {
+    out << "Lambda_" << level << ":" << std::endl;
+    for (size_t i = 0; i != land.land[level].size(); ++i) {
+      if (land.land[level][i].first == -std::numeric_limits<int>::max()) {
+        out << "-inf";
+      } else {
+        if (land.land[level][i].first == std::numeric_limits<int>::max()) {
+          out << "+inf";
+        } else {
+          out << land.land[level][i].first;
         }
+      }
+      out << " , " << land.land[level][i].second << std::endl;
     }
-    return out;
+  }
+  return out;
 }
 
-
-
-
-void Persistence_landscape::multiply_lanscape_by_real_number_overwrite( double x )
-{
-    for ( size_t dim = 0 ; dim != this->land.size() ; ++dim )
-    {
-        for ( size_t i = 0 ; i != this->land[dim].size() ; ++i )
-        {
-             this->land[dim][i].second *= x;
-        }
+void Persistence_landscape::multiply_lanscape_by_real_number_overwrite(double x) {
+  for (size_t dim = 0; dim != this->land.size(); ++dim) {
+    for (size_t i = 0; i != this->land[dim].size(); ++i) {
+      this->land[dim][i].second *= x;
     }
+  }
 }
 
 bool AbsDbg = false;
-Persistence_landscape Persistence_landscape::abs()
-{
-    Persistence_landscape result;
-    for ( size_t level = 0 ; level != this->land.size() ; ++level )
-    {
-        if ( AbsDbg ){ std::cout << "level: " << level << std::endl; }
-        std::vector< std::pair<double,double> > lambda_n;
-        lambda_n.push_back( std::make_pair( -std::numeric_limits<int>::max() , 0 ) );
-        for ( size_t i = 1 ; i != this->land[level].size() ; ++i )
-        {
-            if ( AbsDbg ){std::cout << "this->land[" << level << "][" << i << "] : " << this->land[level][i].first << " " << this->land[level][i].second << std::endl;}
-            //if a line segment between this->land[level][i-1] and this->land[level][i] crosses the x-axis, then we have to add one landscape point t o result
-            if ( (this->land[level][i-1].second)*(this->land[level][i].second)  < 0 )
-            {
-                double zero = find_zero_of_a_line_segment_between_those_two_points( this->land[level][i-1] , this->land[level][i] );
-
-                lambda_n.push_back( std::make_pair(zero , 0) );
-                lambda_n.push_back( std::make_pair(this->land[level][i].first , fabs(this->land[level][i].second)) );
-                if ( AbsDbg )
-                {
-                    std::cout << "Adding pair : (" << zero << ",0)" << std::endl;
-                    std::cout << "In the same step adding pair : (" << this->land[level][i].first << "," << fabs(this->land[level][i].second) << ") " << std::endl;
-                    std::cin.ignore();
-                }
-            }
-            else
-            {
-                lambda_n.push_back( std::make_pair(this->land[level][i].first , fabs(this->land[level][i].second)) );
-                if ( AbsDbg )
-                {
-                    std::cout << "Adding pair : (" << this->land[level][i].first << "," << fabs(this->land[level][i].second) << ") " << std::endl;
-                    std::cin.ignore();
-                }
-            }
+Persistence_landscape Persistence_landscape::abs() {
+  Persistence_landscape result;
+  for (size_t level = 0; level != this->land.size(); ++level) {
+    if (AbsDbg) {
+      std::cout << "level: " << level << std::endl;
+    }
+    std::vector<std::pair<double, double> > lambda_n;
+    lambda_n.push_back(std::make_pair(-std::numeric_limits<int>::max(), 0));
+    for (size_t i = 1; i != this->land[level].size(); ++i) {
+      if (AbsDbg) {
+        std::cout << "this->land[" << level << "][" << i << "] : " << this->land[level][i].first << " "
+                  << this->land[level][i].second << std::endl;
+      }
+      // if a line segment between this->land[level][i-1] and this->land[level][i] crosses the x-axis, then we have to
+      // add one landscape point t o result
+      if ((this->land[level][i - 1].second) * (this->land[level][i].second) < 0) {
+        double zero =
+            find_zero_of_a_line_segment_between_those_two_points(this->land[level][i - 1], this->land[level][i]);
+
+        lambda_n.push_back(std::make_pair(zero, 0));
+        lambda_n.push_back(std::make_pair(this->land[level][i].first, fabs(this->land[level][i].second)));
+        if (AbsDbg) {
+          std::cout << "Adding pair : (" << zero << ",0)" << std::endl;
+          std::cout << "In the same step adding pair : (" << this->land[level][i].first << ","
+                    << fabs(this->land[level][i].second) << ") " << std::endl;
+          std::cin.ignore();
+        }
+      } else {
+        lambda_n.push_back(std::make_pair(this->land[level][i].first, fabs(this->land[level][i].second)));
+        if (AbsDbg) {
+          std::cout << "Adding pair : (" << this->land[level][i].first << "," << fabs(this->land[level][i].second)
+                    << ") " << std::endl;
+          std::cin.ignore();
         }
-        result.land.push_back( lambda_n );
+      }
     }
-    return result;
+    result.land.push_back(lambda_n);
+  }
+  return result;
 }
 
-
-Persistence_landscape Persistence_landscape::multiply_lanscape_by_real_number_not_overwrite( double x )const
-{
-    std::vector< std::vector< std::pair<double,double> > > result(this->land.size());
-    for ( size_t dim = 0 ; dim != this->land.size() ; ++dim )
-    {
-        std::vector< std::pair<double,double> > lambda_dim( this->land[dim].size() );
-        for ( size_t i = 0 ; i != this->land[dim].size() ; ++i )
-        {
-            lambda_dim[i] = std::make_pair( this->land[dim][i].first , x*this->land[dim][i].second );
-        }
-        result[dim] = lambda_dim;
+Persistence_landscape Persistence_landscape::multiply_lanscape_by_real_number_not_overwrite(double x) const {
+  std::vector<std::vector<std::pair<double, double> > > result(this->land.size());
+  for (size_t dim = 0; dim != this->land.size(); ++dim) {
+    std::vector<std::pair<double, double> > lambda_dim(this->land[dim].size());
+    for (size_t i = 0; i != this->land[dim].size(); ++i) {
+      lambda_dim[i] = std::make_pair(this->land[dim][i].first, x * this->land[dim][i].second);
     }
-    Persistence_landscape res;
-    //CHANGE
-    //res.land = result;
-    res.land.swap(result);
-    return res;
-}//multiply_lanscape_by_real_number_overwrite
-
-
-void Persistence_landscape::print_to_file( const char* filename )const
-{
-    std::ofstream write;
-    write.open(filename);
-    for ( size_t dim = 0 ; dim != this->land.size() ; ++dim )
-    {
-        write << "#lambda_" << dim << std::endl;
-        for ( size_t i = 1 ; i != this->land[dim].size()-1 ; ++i )
-        {
-            write << this->land[dim][i].first << "  " << this->land[dim][i].second << std::endl;
-        }
+    result[dim] = lambda_dim;
+  }
+  Persistence_landscape res;
+  // CHANGE
+  // res.land = result;
+  res.land.swap(result);
+  return res;
+}  // multiply_lanscape_by_real_number_overwrite
+
+void Persistence_landscape::print_to_file(const char* filename) const {
+  std::ofstream write;
+  write.open(filename);
+  for (size_t dim = 0; dim != this->land.size(); ++dim) {
+    write << "#lambda_" << dim << std::endl;
+    for (size_t i = 1; i != this->land[dim].size() - 1; ++i) {
+      write << this->land[dim][i].first << "  " << this->land[dim][i].second << std::endl;
     }
-    write.close();
+  }
+  write.close();
 }
 
-void Persistence_landscape::load_landscape_from_file( const char* filename )
-{
-	bool dbg = false;
-	//removing the current content of the persistence landscape.
-	this->land.clear();
-
-
-	//this constructor reads persistence landscape form a file. This file have to be created by this software before head
-        std::ifstream in;
-        in.open( filename );
-	if ( !in.good() )
-	{
-		std::cerr << "The file : " << filename << " do not exist. The program will now terminate \n";
-		throw "The file from which you are trying to read the persistence landscape do not exist. The program will now terminate \n";
-	}
-
-    std::string line;
-    std::vector< std::pair<double,double> > landscapeAtThisLevel;
-
-    bool isThisAFirsLine = true;
-    while ( !in.eof() )
-    {
-        getline(in,line);
-        if ( !(line.length() == 0 || line[0] == '#') )
-        {
-            std::stringstream lineSS;
-            lineSS << line;
-            double beginn, endd;
-            lineSS >> beginn;
-            lineSS >> endd;
-            landscapeAtThisLevel.push_back( std::make_pair( beginn , endd ) );
-            if (dbg){std::cerr << "Reading a point : " << beginn << " , " << endd << std::endl;}
-        }
-        else
-        {
-            if (dbg)
-            {
-                std::cout << "IGNORE LINE\n";
-                getchar();
-            }
-            if ( !isThisAFirsLine )
-            {
-                landscapeAtThisLevel.push_back( std::make_pair( std::numeric_limits<int>::max() , 0 ) );
-                this->land.push_back(landscapeAtThisLevel);
-                std::vector< std::pair<double,double> > newLevelOdLandscape;
-                landscapeAtThisLevel.swap(newLevelOdLandscape);
-            }
-            landscapeAtThisLevel.push_back( std::make_pair( -std::numeric_limits<int>::max() , 0 ) );
-            isThisAFirsLine = false;
-        }
-	}
-	if ( landscapeAtThisLevel.size() > 1 )
-    {
-        //seems that the last line of the file is not finished with the newline sign. We need to put what we have in landscapeAtThisLevel to the constructed landscape.
-        landscapeAtThisLevel.push_back( std::make_pair( std::numeric_limits<int>::max() , 0 ) );
+void Persistence_landscape::load_landscape_from_file(const char* filename) {
+  bool dbg = false;
+  // removing the current content of the persistence landscape.
+  this->land.clear();
+
+  // this constructor reads persistence landscape form a file. This file have to be created by this software before head
+  std::ifstream in;
+  in.open(filename);
+  if (!in.good()) {
+    std::cerr << "The file : " << filename << " do not exist. The program will now terminate \n";
+    throw "The file from which you are trying to read the persistence landscape do not exist. The program will now terminate \n";
+  }
+
+  std::string line;
+  std::vector<std::pair<double, double> > landscapeAtThisLevel;
+
+  bool isThisAFirsLine = true;
+  while (!in.eof()) {
+    getline(in, line);
+    if (!(line.length() == 0 || line[0] == '#')) {
+      std::stringstream lineSS;
+      lineSS << line;
+      double beginn, endd;
+      lineSS >> beginn;
+      lineSS >> endd;
+      landscapeAtThisLevel.push_back(std::make_pair(beginn, endd));
+      if (dbg) {
+        std::cerr << "Reading a point : " << beginn << " , " << endd << std::endl;
+      }
+    } else {
+      if (dbg) {
+        std::cout << "IGNORE LINE\n";
+        getchar();
+      }
+      if (!isThisAFirsLine) {
+        landscapeAtThisLevel.push_back(std::make_pair(std::numeric_limits<int>::max(), 0));
         this->land.push_back(landscapeAtThisLevel);
+        std::vector<std::pair<double, double> > newLevelOdLandscape;
+        landscapeAtThisLevel.swap(newLevelOdLandscape);
+      }
+      landscapeAtThisLevel.push_back(std::make_pair(-std::numeric_limits<int>::max(), 0));
+      isThisAFirsLine = false;
     }
-
-    in.close();
+  }
+  if (landscapeAtThisLevel.size() > 1) {
+    // seems that the last line of the file is not finished with the newline sign. We need to put what we have in
+    // landscapeAtThisLevel to the constructed landscape.
+    landscapeAtThisLevel.push_back(std::make_pair(std::numeric_limits<int>::max(), 0));
+    this->land.push_back(landscapeAtThisLevel);
+  }
+
+  in.close();
 }
 
-
-template < typename T >
-Persistence_landscape operation_on_pair_of_landscapes ( const Persistence_landscape& land1 ,  const Persistence_landscape& land2 )
-{
-	bool operation_on_pair_of_landscapesDBG = false;
-    if ( operation_on_pair_of_landscapesDBG ){std::cout << "operation_on_pair_of_landscapes\n";std::cin.ignore();}
-    Persistence_landscape result;
-    std::vector< std::vector< std::pair<double,double> > > land( std::max( land1.land.size() , land2.land.size() ) );
-    result.land = land;
-    T oper;
-    
-    if ( operation_on_pair_of_landscapesDBG )
-    {
-		for ( size_t i = 0 ; i != std::min( land1.land.size() , land2.land.size() ) ; ++i )
-		{
-			std::cerr << "land1.land[" << i << "].size() : " << land1.land[i].size() << std::endl;
-            std::cerr << "land2.land[" << i << "].size() : " << land2.land[i].size() << std::endl;             
-		}
-		getchar();
-	}
-
-    for ( size_t i = 0 ; i != std::min( land1.land.size() , land2.land.size() ) ; ++i )
-    {
-        std::vector< std::pair<double,double> > lambda_n;
-        size_t p = 0;
-        size_t q = 0;
-        while ( (p+1 < land1.land[i].size()) && (q+1 < land2.land[i].size()) )
-        {
-            if ( operation_on_pair_of_landscapesDBG )
-            {
-                std::cerr << "p : " << p << "\n";
-                std::cerr << "q : " << q << "\n";
-                std::cerr << "land1.land.size() : " << land1.land.size() << std::endl;
-                std::cerr << "land2.land.size() : " << land2.land.size() << std::endl;
-                std::cerr << "land1.land[" << i << "].size() : " << land1.land[i].size() << std::endl;
-                std::cerr << "land2.land[" << i << "].size() : " << land2.land[i].size() << std::endl;
-                std::cout << "land1.land[i][p].first : " << land1.land[i][p].first << "\n";
-                std::cout << "land2.land[i][q].first : " << land2.land[i][q].first << "\n";
-            }
-
-            if ( land1.land[i][p].first < land2.land[i][q].first )
-            {
-                if ( operation_on_pair_of_landscapesDBG )
-                {
-                    std::cout << "first \n";
-                    std::cout << " function_value(land2.land[i][q-1],land2.land[i][q],land1.land[i][p].first) : "<<  function_value(land2.land[i][q-1],land2.land[i][q],land1.land[i][p].first) << "\n";
-                }
-                lambda_n.push_back( 
-									std::make_pair( 
-									              land1.land[i][p].first , 
-									              oper( (double)land1.land[i][p].second , function_value(land2.land[i][q-1],land2.land[i][q],land1.land[i][p].first) ) 
-												  ) 
-								  );
-                ++p;
-                continue;
-            }
-            if ( land1.land[i][p].first > land2.land[i][q].first )
-            {
-                if ( operation_on_pair_of_landscapesDBG )
-                {
-                    std::cout << "Second \n";
-                    std::cout << "function_value("<< land1.land[i][p-1].first << " " << land1.land[i][p-1].second <<" ,"<< land1.land[i][p].first << " " << land1.land[i][p].second <<", " << land2.land[i][q].first<<" ) : " << function_value( land1.land[i][p-1] , land1.land[i][p-1] ,land2.land[i][q].first ) << "\n";
-                    std::cout << "oper( " << function_value( land1.land[i][p] , land1.land[i][p-1] ,land2.land[i][q].first ) <<"," << land2.land[i][q].second <<" : " << oper( land2.land[i][q].second , function_value( land1.land[i][p] , land1.land[i][p-1] ,land2.land[i][q].first ) ) << "\n";
-                }
-                lambda_n.push_back( std::make_pair( land2.land[i][q].first , oper( function_value( land1.land[i][p] , land1.land[i][p-1] ,land2.land[i][q].first ) , land2.land[i][q].second )  )  );
-                ++q;
-                continue;
-            }
-            if ( land1.land[i][p].first == land2.land[i][q].first )
-            {
-                if (operation_on_pair_of_landscapesDBG)std::cout << "Third \n";
-                lambda_n.push_back( std::make_pair( land2.land[i][q].first , oper( land1.land[i][p].second , land2.land[i][q].second ) ) );
-                ++p;++q;
-            }
-            if (operation_on_pair_of_landscapesDBG){std::cout << "Next iteration \n";}
-        }
-        while ( (p+1 < land1.land[i].size())&&(q+1 >= land2.land[i].size()) )
-        {
-            if (operation_on_pair_of_landscapesDBG)
-            {
-                std::cout << "New point : " << land1.land[i][p].first << "  oper(land1.land[i][p].second,0) : " <<  oper(land1.land[i][p].second,0) << std::endl;
-            }
-            lambda_n.push_back( std::make_pair(land1.land[i][p].first , oper(land1.land[i][p].second,0) ) );
-            ++p;
+template <typename T>
+Persistence_landscape operation_on_pair_of_landscapes(const Persistence_landscape& land1,
+                                                      const Persistence_landscape& land2) {
+  bool operation_on_pair_of_landscapesDBG = false;
+  if (operation_on_pair_of_landscapesDBG) {
+    std::cout << "operation_on_pair_of_landscapes\n";
+    std::cin.ignore();
+  }
+  Persistence_landscape result;
+  std::vector<std::vector<std::pair<double, double> > > land(std::max(land1.land.size(), land2.land.size()));
+  result.land = land;
+  T oper;
+
+  if (operation_on_pair_of_landscapesDBG) {
+    for (size_t i = 0; i != std::min(land1.land.size(), land2.land.size()); ++i) {
+      std::cerr << "land1.land[" << i << "].size() : " << land1.land[i].size() << std::endl;
+      std::cerr << "land2.land[" << i << "].size() : " << land2.land[i].size() << std::endl;
+    }
+    getchar();
+  }
+
+  for (size_t i = 0; i != std::min(land1.land.size(), land2.land.size()); ++i) {
+    std::vector<std::pair<double, double> > lambda_n;
+    size_t p = 0;
+    size_t q = 0;
+    while ((p + 1 < land1.land[i].size()) && (q + 1 < land2.land[i].size())) {
+      if (operation_on_pair_of_landscapesDBG) {
+        std::cerr << "p : " << p << "\n";
+        std::cerr << "q : " << q << "\n";
+        std::cerr << "land1.land.size() : " << land1.land.size() << std::endl;
+        std::cerr << "land2.land.size() : " << land2.land.size() << std::endl;
+        std::cerr << "land1.land[" << i << "].size() : " << land1.land[i].size() << std::endl;
+        std::cerr << "land2.land[" << i << "].size() : " << land2.land[i].size() << std::endl;
+        std::cout << "land1.land[i][p].first : " << land1.land[i][p].first << "\n";
+        std::cout << "land2.land[i][q].first : " << land2.land[i][q].first << "\n";
+      }
+
+      if (land1.land[i][p].first < land2.land[i][q].first) {
+        if (operation_on_pair_of_landscapesDBG) {
+          std::cout << "first \n";
+          std::cout << " function_value(land2.land[i][q-1],land2.land[i][q],land1.land[i][p].first) : "
+                    << function_value(land2.land[i][q - 1], land2.land[i][q], land1.land[i][p].first) << "\n";
         }
-        while ( (p+1 >= land1.land[i].size())&&(q+1 < land2.land[i].size()) )
-        {
-            if (operation_on_pair_of_landscapesDBG)
-            {
-                std::cout << "New point : " << land2.land[i][q].first << " oper(0,land2.land[i][q].second) : " <<  oper(0,land2.land[i][q].second) << std::endl;
-            }
-            lambda_n.push_back( std::make_pair(land2.land[i][q].first , oper(0,land2.land[i][q].second) ) );
-            ++q;
+        lambda_n.push_back(
+            std::make_pair(land1.land[i][p].first,
+                           oper((double)land1.land[i][p].second,
+                                function_value(land2.land[i][q - 1], land2.land[i][q], land1.land[i][p].first))));
+        ++p;
+        continue;
+      }
+      if (land1.land[i][p].first > land2.land[i][q].first) {
+        if (operation_on_pair_of_landscapesDBG) {
+          std::cout << "Second \n";
+          std::cout << "function_value(" << land1.land[i][p - 1].first << " " << land1.land[i][p - 1].second << " ,"
+                    << land1.land[i][p].first << " " << land1.land[i][p].second << ", " << land2.land[i][q].first
+                    << " ) : " << function_value(land1.land[i][p - 1], land1.land[i][p - 1], land2.land[i][q].first)
+                    << "\n";
+          std::cout << "oper( " << function_value(land1.land[i][p], land1.land[i][p - 1], land2.land[i][q].first) << ","
+                    << land2.land[i][q].second << " : "
+                    << oper(land2.land[i][q].second,
+                            function_value(land1.land[i][p], land1.land[i][p - 1], land2.land[i][q].first))
+                    << "\n";
         }
-        lambda_n.push_back( std::make_pair( std::numeric_limits<int>::max() , 0 ) );
-        //CHANGE
-        //result.land[i] = lambda_n;
-        result.land[i].swap(lambda_n);
+        lambda_n.push_back(std::make_pair(
+            land2.land[i][q].first, oper(function_value(land1.land[i][p], land1.land[i][p - 1], land2.land[i][q].first),
+                                         land2.land[i][q].second)));
+        ++q;
+        continue;
+      }
+      if (land1.land[i][p].first == land2.land[i][q].first) {
+        if (operation_on_pair_of_landscapesDBG) std::cout << "Third \n";
+        lambda_n.push_back(
+            std::make_pair(land2.land[i][q].first, oper(land1.land[i][p].second, land2.land[i][q].second)));
+        ++p;
+        ++q;
+      }
+      if (operation_on_pair_of_landscapesDBG) {
+        std::cout << "Next iteration \n";
+      }
     }
-    if ( land1.land.size() > std::min( land1.land.size() , land2.land.size() ) )
-    {
-        if (operation_on_pair_of_landscapesDBG){std::cout << "land1.land.size() > std::min( land1.land.size() , land2.land.size() )" << std::endl;}
-        for ( size_t i = std::min( land1.land.size() , land2.land.size() ) ; i != std::max( land1.land.size() , land2.land.size() ) ; ++i )
-        {
-            std::vector< std::pair<double,double> > lambda_n( land1.land[i] );
-            for ( size_t nr = 0 ; nr != land1.land[i].size() ; ++nr )
-            {
-                lambda_n[nr] = std::make_pair( land1.land[i][nr].first , oper( land1.land[i][nr].second , 0 ) );
-            }
-            //CHANGE
-            //result.land[i] = lambda_n;
-            result.land[i].swap(lambda_n);
-        }
+    while ((p + 1 < land1.land[i].size()) && (q + 1 >= land2.land[i].size())) {
+      if (operation_on_pair_of_landscapesDBG) {
+        std::cout << "New point : " << land1.land[i][p].first
+                  << "  oper(land1.land[i][p].second,0) : " << oper(land1.land[i][p].second, 0) << std::endl;
+      }
+      lambda_n.push_back(std::make_pair(land1.land[i][p].first, oper(land1.land[i][p].second, 0)));
+      ++p;
     }
-    if ( land2.land.size() > std::min( land1.land.size() , land2.land.size() ) )
-    {
-        if (operation_on_pair_of_landscapesDBG){std::cout << "( land2.land.size() > std::min( land1.land.size() , land2.land.size() ) ) " << std::endl;}
-        for ( size_t i = std::min( land1.land.size() , land2.land.size() ) ; i != std::max( land1.land.size() , land2.land.size() ) ; ++i )
-        {
-            std::vector< std::pair<double,double> > lambda_n( land2.land[i] );
-            for ( size_t nr = 0 ; nr != land2.land[i].size() ; ++nr )
-            {
-                lambda_n[nr] = std::make_pair( land2.land[i][nr].first , oper( 0 , land2.land[i][nr].second ) );
-            }
-            //CHANGE
-            //result.land[i] = lambda_n;
-            result.land[i].swap(lambda_n);
-        }
+    while ((p + 1 >= land1.land[i].size()) && (q + 1 < land2.land[i].size())) {
+      if (operation_on_pair_of_landscapesDBG) {
+        std::cout << "New point : " << land2.land[i][q].first
+                  << " oper(0,land2.land[i][q].second) : " << oper(0, land2.land[i][q].second) << std::endl;
+      }
+      lambda_n.push_back(std::make_pair(land2.land[i][q].first, oper(0, land2.land[i][q].second)));
+      ++q;
+    }
+    lambda_n.push_back(std::make_pair(std::numeric_limits<int>::max(), 0));
+    // CHANGE
+    // result.land[i] = lambda_n;
+    result.land[i].swap(lambda_n);
+  }
+  if (land1.land.size() > std::min(land1.land.size(), land2.land.size())) {
+    if (operation_on_pair_of_landscapesDBG) {
+      std::cout << "land1.land.size() > std::min( land1.land.size() , land2.land.size() )" << std::endl;
+    }
+    for (size_t i = std::min(land1.land.size(), land2.land.size()); i != std::max(land1.land.size(), land2.land.size());
+         ++i) {
+      std::vector<std::pair<double, double> > lambda_n(land1.land[i]);
+      for (size_t nr = 0; nr != land1.land[i].size(); ++nr) {
+        lambda_n[nr] = std::make_pair(land1.land[i][nr].first, oper(land1.land[i][nr].second, 0));
+      }
+      // CHANGE
+      // result.land[i] = lambda_n;
+      result.land[i].swap(lambda_n);
+    }
+  }
+  if (land2.land.size() > std::min(land1.land.size(), land2.land.size())) {
+    if (operation_on_pair_of_landscapesDBG) {
+      std::cout << "( land2.land.size() > std::min( land1.land.size() , land2.land.size() ) ) " << std::endl;
+    }
+    for (size_t i = std::min(land1.land.size(), land2.land.size()); i != std::max(land1.land.size(), land2.land.size());
+         ++i) {
+      std::vector<std::pair<double, double> > lambda_n(land2.land[i]);
+      for (size_t nr = 0; nr != land2.land[i].size(); ++nr) {
+        lambda_n[nr] = std::make_pair(land2.land[i][nr].first, oper(0, land2.land[i][nr].second));
+      }
+      // CHANGE
+      // result.land[i] = lambda_n;
+      result.land[i].swap(lambda_n);
+    }
+  }
+  if (operation_on_pair_of_landscapesDBG) {
+    std::cout << "operation_on_pair_of_landscapes END\n";
+    std::cin.ignore();
+  }
+  return result;
+}  // operation_on_pair_of_landscapes
+
+double compute_maximal_distance_non_symmetric(const Persistence_landscape& pl1, const Persistence_landscape& pl2) {
+  bool dbg = false;
+  if (dbg) std::cerr << " compute_maximal_distance_non_symmetric \n";
+  // this distance is not symmetric. It compute ONLY distance between inflection points of pl1 and pl2.
+  double maxDist = 0;
+  size_t minimalNumberOfLevels = std::min(pl1.land.size(), pl2.land.size());
+  for (size_t level = 0; level != minimalNumberOfLevels; ++level) {
+    if (dbg) {
+      std::cerr << "Level : " << level << std::endl;
+      std::cerr << "PL1 : \n";
+      for (size_t i = 0; i != pl1.land[level].size(); ++i) {
+        std::cerr << "(" << pl1.land[level][i].first << "," << pl1.land[level][i].second << ") \n";
+      }
+      std::cerr << "PL2 : \n";
+      for (size_t i = 0; i != pl2.land[level].size(); ++i) {
+        std::cerr << "(" << pl2.land[level][i].first << "," << pl2.land[level][i].second << ") \n";
+      }
+      std::cin.ignore();
     }
-    if ( operation_on_pair_of_landscapesDBG ){std::cout << "operation_on_pair_of_landscapes END\n";std::cin.ignore();}
-    return result;
-}//operation_on_pair_of_landscapes
-
-
 
-double compute_maximal_distance_non_symmetric( const Persistence_landscape& pl1, const Persistence_landscape& pl2 )
-{
-    bool dbg = false;
-    if (dbg)std::cerr << " compute_maximal_distance_non_symmetric \n";
-    //this distance is not symmetric. It compute ONLY distance between inflection points of pl1 and pl2.
-    double maxDist = 0;
-    size_t minimalNumberOfLevels = std::min( pl1.land.size() , pl2.land.size() );
-    for ( size_t level = 0 ; level != minimalNumberOfLevels ; ++ level )
+    int p2Count = 0;
+    for (size_t i = 1; i != pl1.land[level].size() - 1; ++i)  // In this case, I consider points at the infinity
     {
-        if (dbg)
-        {
-            std::cerr << "Level : " << level << std::endl;
-            std::cerr << "PL1 : \n";
-            for ( size_t i = 0 ; i  != pl1.land[level].size() ; ++i )
-            {
-                std::cerr << "(" <<pl1.land[level][i].first << "," << pl1.land[level][i].second << ") \n";
-            }
-            std::cerr << "PL2 : \n";
-            for ( size_t i = 0 ; i  != pl2.land[level].size() ; ++i )
-            {
-                std::cerr << "(" <<pl2.land[level][i].first << "," << pl2.land[level][i].second << ") \n";
-            }
-            std::cin.ignore();
-        }
-
-        int p2Count = 0;
-        for ( size_t i = 1 ; i != pl1.land[level].size()-1 ; ++i ) // In this case, I consider points at the infinity
-        {
-            while ( true )
-            {
-                if (  (pl1.land[level][i].first>=pl2.land[level][p2Count].first) && (pl1.land[level][i].first<=pl2.land[level][p2Count+1].first)  )break;
-                p2Count++;
-            }
-            double val = fabs( function_value( pl2.land[level][p2Count] , pl2.land[level][p2Count+1] , pl1.land[level][i].first ) - pl1.land[level][i].second);
-            if ( maxDist <= val )maxDist = val;
-
-            if (dbg)
-            {
-                std::cerr << pl1.land[level][i].first <<"in [" << pl2.land[level][p2Count].first << "," <<  pl2.land[level][p2Count+1].first <<"] \n";
-                std::cerr << "pl1[level][i].second : " << pl1.land[level][i].second << std::endl;
-                std::cerr << "function_value( pl2[level][p2Count] , pl2[level][p2Count+1] , pl1[level][i].first ) : " << function_value( pl2.land[level][p2Count] , pl2.land[level][p2Count+1] , pl1.land[level][i].first ) << std::endl;
-                std::cerr << "val : "  << val << std::endl;
-                std::cin.ignore();
-            }
-        }
+      while (true) {
+        if ((pl1.land[level][i].first >= pl2.land[level][p2Count].first) &&
+            (pl1.land[level][i].first <= pl2.land[level][p2Count + 1].first))
+          break;
+        p2Count++;
+      }
+      double val =
+          fabs(function_value(pl2.land[level][p2Count], pl2.land[level][p2Count + 1], pl1.land[level][i].first) -
+               pl1.land[level][i].second);
+      if (maxDist <= val) maxDist = val;
+
+      if (dbg) {
+        std::cerr << pl1.land[level][i].first << "in [" << pl2.land[level][p2Count].first << ","
+                  << pl2.land[level][p2Count + 1].first << "] \n";
+        std::cerr << "pl1[level][i].second : " << pl1.land[level][i].second << std::endl;
+        std::cerr << "function_value( pl2[level][p2Count] , pl2[level][p2Count+1] , pl1[level][i].first ) : "
+                  << function_value(pl2.land[level][p2Count], pl2.land[level][p2Count + 1], pl1.land[level][i].first)
+                  << std::endl;
+        std::cerr << "val : " << val << std::endl;
+        std::cin.ignore();
+      }
     }
+  }
 
-    if (dbg)std::cerr << "minimalNumberOfLevels : " << minimalNumberOfLevels << std::endl;
+  if (dbg) std::cerr << "minimalNumberOfLevels : " << minimalNumberOfLevels << std::endl;
 
-    if ( minimalNumberOfLevels < pl1.land.size() )
-    {
-        for ( size_t level = minimalNumberOfLevels ; level != pl1.land.size() ; ++ level )
-        {
-            for ( size_t i = 0 ; i != pl1.land[level].size() ; ++i )
-            {
-                if (dbg)std::cerr << "pl1[level][i].second  : " << pl1.land[level][i].second << std::endl;
-                if ( maxDist < pl1.land[level][i].second )maxDist = pl1.land[level][i].second;
-            }
-        }
+  if (minimalNumberOfLevels < pl1.land.size()) {
+    for (size_t level = minimalNumberOfLevels; level != pl1.land.size(); ++level) {
+      for (size_t i = 0; i != pl1.land[level].size(); ++i) {
+        if (dbg) std::cerr << "pl1[level][i].second  : " << pl1.land[level][i].second << std::endl;
+        if (maxDist < pl1.land[level][i].second) maxDist = pl1.land[level][i].second;
+      }
     }
-    return maxDist;
+  }
+  return maxDist;
 }
 
-
-
-
-double compute_distance_of_landscapes( const Persistence_landscape& first, const Persistence_landscape& second , double p )
-{
-	bool dbg = false;
-    //This is what we want to compute: (\int_{- \infty}^{+\infty}| first-second |^p)^(1/p). We will do it one step at a time:
-
-    //first-second :
-    Persistence_landscape lan = first-second;
-
-    //| first-second |:
-    lan = lan.abs();
-    
-    if ( dbg ){std::cerr << "Abs of difference ; " << lan << std::endl;getchar();}
-    
-	if ( p < std::numeric_limits<double>::max() )
-	{
-		//\int_{- \infty}^{+\infty}| first-second |^p
-		double result;
-		if ( p != 1 )
-		{
-			if ( dbg )std::cerr << "Power != 1, compute integral to the power p\n";
-			result = lan.compute_integral_of_landscape( (double)p );
-		}
-		else
-		{
-			if ( dbg )std::cerr << "Power = 1, compute integral \n";
-			result = lan.compute_integral_of_landscape();
-		}
-		//(\int_{- \infty}^{+\infty}| first-second |^p)^(1/p)
-		return pow( result , 1/(double)p );
-	}
-	else
-	{
-		//p == infty
-		if ( dbg )std::cerr << "Power = infty, compute maximum \n";
-		return lan.compute_maximum();
-	}
+double compute_distance_of_landscapes(const Persistence_landscape& first, const Persistence_landscape& second,
+                                      double p) {
+  bool dbg = false;
+  // This is what we want to compute: (\int_{- \infty}^{+\infty}| first-second |^p)^(1/p). We will do it one step at a
+  // time:
+
+  // first-second :
+  Persistence_landscape lan = first - second;
+
+  //| first-second |:
+  lan = lan.abs();
+
+  if (dbg) {
+    std::cerr << "Abs of difference ; " << lan << std::endl;
+    getchar();
+  }
+
+  if (p < std::numeric_limits<double>::max()) {
+    //\int_{- \infty}^{+\infty}| first-second |^p
+    double result;
+    if (p != 1) {
+      if (dbg) std::cerr << "Power != 1, compute integral to the power p\n";
+      result = lan.compute_integral_of_landscape((double)p);
+    } else {
+      if (dbg) std::cerr << "Power = 1, compute integral \n";
+      result = lan.compute_integral_of_landscape();
+    }
+    //(\int_{- \infty}^{+\infty}| first-second |^p)^(1/p)
+    return pow(result, 1 / (double)p);
+  } else {
+    // p == infty
+    if (dbg) std::cerr << "Power = infty, compute maximum \n";
+    return lan.compute_maximum();
+  }
 }
 
-double compute_max_norm_distance_of_landscapes( const Persistence_landscape& first, const Persistence_landscape& second )
-{
-    return std::max( compute_maximal_distance_non_symmetric(first,second) , compute_maximal_distance_non_symmetric(second,first) );
+double compute_max_norm_distance_of_landscapes(const Persistence_landscape& first,
+                                               const Persistence_landscape& second) {
+  return std::max(compute_maximal_distance_non_symmetric(first, second),
+                  compute_maximal_distance_non_symmetric(second, first));
 }
 
-
-bool comparePairsForMerging( std::pair< double , unsigned > first , std::pair< double , unsigned > second )
-{
-    return (first.first < second.first);
+bool comparePairsForMerging(std::pair<double, unsigned> first, std::pair<double, unsigned> second) {
+  return (first.first < second.first);
 }
 
+double compute_inner_product(const Persistence_landscape& l1, const Persistence_landscape& l2) {
+  bool dbg = false;
+  double result = 0;
 
+  for (size_t level = 0; level != std::min(l1.size(), l2.size()); ++level) {
+    if (dbg) {
+      std::cerr << "Computing inner product for a level : " << level << std::endl;
+      getchar();
+    }
+    if (l1.land[level].size() * l2.land[level].size() == 0) continue;
+
+    // endpoints of the interval on which we will compute the inner product of two locally linear functions:
+    double x1 = -std::numeric_limits<int>::max();
+    double x2;
+    if (l1.land[level][1].first < l2.land[level][1].first) {
+      x2 = l1.land[level][1].first;
+    } else {
+      x2 = l2.land[level][1].first;
+    }
 
-
-double compute_inner_product( const Persistence_landscape& l1 , const Persistence_landscape& l2 )
-{
-    bool dbg = false;
-    double result = 0;
-
-    for ( size_t level = 0 ; level != std::min( l1.size() , l2.size() ) ; ++level )
-    {
-        if ( dbg ){std::cerr << "Computing inner product for a level : " << level << std::endl;getchar();}
-        if ( l1.land[level].size() * l2.land[level].size() == 0 )continue;
-
-        //endpoints of the interval on which we will compute the inner product of two locally linear functions:
-        double x1 = -std::numeric_limits<int>::max();
-        double x2;
-        if ( l1.land[level][1].first < l2.land[level][1].first )
-        {
-            x2 = l1.land[level][1].first;
+    // iterators for the landscapes l1 and l2
+    size_t l1It = 0;
+    size_t l2It = 0;
+
+    while ((l1It < l1.land[level].size() - 1) && (l2It < l2.land[level].size() - 1)) {
+      // compute the value of a inner product on a interval [x1,x2]
+
+      double a, b, c, d;
+
+      if (l1.land[level][l1It + 1].first != l1.land[level][l1It].first) {
+        a = (l1.land[level][l1It + 1].second - l1.land[level][l1It].second) /
+            (l1.land[level][l1It + 1].first - l1.land[level][l1It].first);
+      } else {
+        a = 0;
+      }
+      b = l1.land[level][l1It].second - a * l1.land[level][l1It].first;
+      if (l2.land[level][l2It + 1].first != l2.land[level][l2It].first) {
+        c = (l2.land[level][l2It + 1].second - l2.land[level][l2It].second) /
+            (l2.land[level][l2It + 1].first - l2.land[level][l2It].first);
+      } else {
+        c = 0;
+      }
+      d = l2.land[level][l2It].second - c * l2.land[level][l2It].first;
+
+      double contributionFromThisPart = (a * c * x2 * x2 * x2 / 3 + (a * d + b * c) * x2 * x2 / 2 + b * d * x2) -
+                                        (a * c * x1 * x1 * x1 / 3 + (a * d + b * c) * x1 * x1 / 2 + b * d * x1);
+
+      result += contributionFromThisPart;
+
+      if (dbg) {
+        std::cerr << "[l1.land[level][l1It].first,l1.land[level][l1It+1].first] : " << l1.land[level][l1It].first
+                  << " , " << l1.land[level][l1It + 1].first << std::endl;
+        std::cerr << "[l2.land[level][l2It].first,l2.land[level][l2It+1].first] : " << l2.land[level][l2It].first
+                  << " , " << l2.land[level][l2It + 1].first << std::endl;
+        std::cerr << "a : " << a << ", b : " << b << " , c: " << c << ", d : " << d << std::endl;
+        std::cerr << "x1 : " << x1 << " , x2 : " << x2 << std::endl;
+        std::cerr << "contributionFromThisPart : " << contributionFromThisPart << std::endl;
+        std::cerr << "result : " << result << std::endl;
+        getchar();
+      }
+
+      // we have two intervals in which functions are constant:
+      //[l1.land[level][l1It].first , l1.land[level][l1It+1].first]
+      // and
+      //[l2.land[level][l2It].first , l2.land[level][l2It+1].first]
+      // We also have an interval [x1,x2]. Since the intervals in the landscapes cover the whole R, then it is clear
+      // that x2
+      // is either l1.land[level][l1It+1].first of l2.land[level][l2It+1].first or both. Lets test it.
+      if (x2 == l1.land[level][l1It + 1].first) {
+        if (x2 == l2.land[level][l2It + 1].first) {
+          // in this case, we increment both:
+          ++l2It;
+          if (dbg) {
+            std::cerr << "Incrementing both \n";
+          }
+        } else {
+          if (dbg) {
+            std::cerr << "Incrementing first \n";
+          }
         }
-        else
-        {
-            x2 = l2.land[level][1].first;
+        ++l1It;
+      } else {
+        // in this case we increment l2It
+        ++l2It;
+        if (dbg) {
+          std::cerr << "Incrementing second \n";
         }
-
-        //iterators for the landscapes l1 and l2
-        size_t l1It = 0;
-        size_t l2It = 0;
-
-        while ( (l1It < l1.land[level].size()-1) && (l2It < l2.land[level].size()-1) )
-        {
-            //compute the value of a inner product on a interval [x1,x2]
-
-            double a,b,c,d;
-
-			if ( l1.land[level][l1It+1].first != l1.land[level][l1It].first )
-			{
-				a = (l1.land[level][l1It+1].second - l1.land[level][l1It].second)/(l1.land[level][l1It+1].first - l1.land[level][l1It].first);
-			}
-			else
-			{
-				a = 0;
-			}
-            b = l1.land[level][l1It].second - a*l1.land[level][l1It].first;
-            if ( l2.land[level][l2It+1].first != l2.land[level][l2It].first )
-            {
-				c = (l2.land[level][l2It+1].second - l2.land[level][l2It].second)/(l2.land[level][l2It+1].first - l2.land[level][l2It].first);
-			}
-			else
-			{
-				c = 0;
-			}
-            d = l2.land[level][l2It].second - c*l2.land[level][l2It].first;
-
-            double contributionFromThisPart
-            =
-            (a*c*x2*x2*x2/3 + (a*d+b*c)*x2*x2/2 + b*d*x2) - (a*c*x1*x1*x1/3 + (a*d+b*c)*x1*x1/2 + b*d*x1);
-
-            result += contributionFromThisPart;
-
-            if ( dbg )
-            {
-                std::cerr << "[l1.land[level][l1It].first,l1.land[level][l1It+1].first] : " << l1.land[level][l1It].first << " , " << l1.land[level][l1It+1].first << std::endl;
-                std::cerr << "[l2.land[level][l2It].first,l2.land[level][l2It+1].first] : " << l2.land[level][l2It].first << " , " << l2.land[level][l2It+1].first << std::endl;
-                std::cerr << "a : " << a << ", b : " << b << " , c: " << c << ", d : " << d << std::endl;
-                std::cerr << "x1 : " << x1 << " , x2 : " << x2 << std::endl;
-                std::cerr << "contributionFromThisPart : " << contributionFromThisPart << std::endl;
-                std::cerr << "result : " << result << std::endl;
-                getchar();
-            }
-
-            //we have two intervals in which functions are constant:
-            //[l1.land[level][l1It].first , l1.land[level][l1It+1].first]
-            //and
-            //[l2.land[level][l2It].first , l2.land[level][l2It+1].first]
-            //We also have an interval [x1,x2]. Since the intervals in the landscapes cover the whole R, then it is clear that x2
-            //is either l1.land[level][l1It+1].first of l2.land[level][l2It+1].first or both. Lets test it.
-            if ( x2 == l1.land[level][l1It+1].first )
-            {
-                if ( x2 == l2.land[level][l2It+1].first )
-                {
-                    //in this case, we increment both:
-                    ++l2It;
-                    if ( dbg ){std::cerr << "Incrementing both \n";}
-                }
-                else
-                {
-                    if ( dbg ){std::cerr << "Incrementing first \n";}
-                }
-                ++l1It;
-            }
-            else
-            {
-                //in this case we increment l2It
-                ++l2It;
-                if ( dbg ){std::cerr << "Incrementing second \n";}
-            }
-            //Now, we shift x1 and x2:
-            x1 = x2;
-            if ( l1.land[level][l1It+1].first < l2.land[level][l2It+1].first )
-            {
-                x2 = l1.land[level][l1It+1].first;
-            }
-            else
-            {
-                x2 = l2.land[level][l2It+1].first;
-            }
-
-        }
-
+      }
+      // Now, we shift x1 and x2:
+      x1 = x2;
+      if (l1.land[level][l1It + 1].first < l2.land[level][l2It + 1].first) {
+        x2 = l1.land[level][l1It + 1].first;
+      } else {
+        x2 = l2.land[level][l2It + 1].first;
+      }
     }
-    return result;
+  }
+  return result;
 }
 
-
-void Persistence_landscape::plot( const char* filename,  double xRangeBegin , double xRangeEnd , double yRangeBegin , double yRangeEnd , int from , int to )
-{
-    //this program create a gnuplot script file that allows to plot persistence diagram.
-    std::ofstream out;
-
-    std::ostringstream nameSS;
-    nameSS << filename << "_GnuplotScript";
-    std::string nameStr = nameSS.str();
-    out.open( nameStr );
-
-    if ( (xRangeBegin != std::numeric_limits<double>::max()) || (xRangeEnd != std::numeric_limits<double>::max()) || (yRangeBegin != std::numeric_limits<double>::max()) || (yRangeEnd != std::numeric_limits<double>::max())  )
-    {
-        out << "set xrange [" << xRangeBegin << " : " << xRangeEnd << "]" << std::endl;
-        out << "set yrange [" << yRangeBegin << " : " << yRangeEnd << "]" << std::endl;
+void Persistence_landscape::plot(const char* filename, double xRangeBegin, double xRangeEnd, double yRangeBegin,
+                                 double yRangeEnd, int from, int to) {
+  // this program create a gnuplot script file that allows to plot persistence diagram.
+  std::ofstream out;
+
+  std::ostringstream nameSS;
+  nameSS << filename << "_GnuplotScript";
+  std::string nameStr = nameSS.str();
+  out.open(nameStr);
+
+  if ((xRangeBegin != std::numeric_limits<double>::max()) || (xRangeEnd != std::numeric_limits<double>::max()) ||
+      (yRangeBegin != std::numeric_limits<double>::max()) || (yRangeEnd != std::numeric_limits<double>::max())) {
+    out << "set xrange [" << xRangeBegin << " : " << xRangeEnd << "]" << std::endl;
+    out << "set yrange [" << yRangeBegin << " : " << yRangeEnd << "]" << std::endl;
+  }
+
+  if (from == std::numeric_limits<int>::max()) {
+    from = 0;
+  }
+  if (to == std::numeric_limits<int>::max()) {
+    to = this->land.size();
+  }
+
+  out << "plot ";
+  for (size_t lambda = std::min((size_t)from, this->land.size()); lambda != std::min((size_t)to, this->land.size());
+       ++lambda) {
+    // out << "     '-' using 1:2 title 'l" << lambda << "' with lp";
+    out << "     '-' using 1:2 notitle with lp";
+    if (lambda + 1 != std::min((size_t)to, this->land.size())) {
+      out << ", \\";
     }
+    out << std::endl;
+  }
 
-    if ( from == std::numeric_limits<int>::max() ){from = 0;}
-    if ( to == std::numeric_limits<int>::max() ){to = this->land.size();}
-
-    out << "plot ";
-    for ( size_t lambda= std::min((size_t)from,this->land.size()) ; lambda != std::min((size_t)to,this->land.size()) ; ++lambda )
-    {
-        //out << "     '-' using 1:2 title 'l" << lambda << "' with lp";
-        out << "     '-' using 1:2 notitle with lp";
-        if ( lambda+1 != std::min((size_t)to,this->land.size()) )
-        {
-            out << ", \\";
-        }
-        out << std::endl;
+  for (size_t lambda = std::min((size_t)from, this->land.size()); lambda != std::min((size_t)to, this->land.size());
+       ++lambda) {
+    for (size_t i = 1; i != this->land[lambda].size() - 1; ++i) {
+      out << this->land[lambda][i].first << " " << this->land[lambda][i].second << std::endl;
     }
-
-    for ( size_t lambda= std::min((size_t)from,this->land.size()) ; lambda != std::min((size_t)to,this->land.size()) ; ++lambda )
-    {
-        for ( size_t i = 1 ; i != this->land[lambda].size()-1 ; ++i )
-        {
-            out << this->land[lambda][i].first << " " << this->land[lambda][i].second << std::endl;
-        }
-        out << "EOF" << std::endl;
-    }
-    std::cout << "Gnuplot script to visualize persistence diagram written to the file: " << nameStr << ". Type load '" << nameStr << "' in gnuplot to visualize." << std::endl;
+    out << "EOF" << std::endl;
+  }
+  std::cout << "Gnuplot script to visualize persistence diagram written to the file: " << nameStr << ". Type load '"
+            << nameStr << "' in gnuplot to visualize." << std::endl;
 }
 
 }  // namespace Persistence_representations
 }  // namespace gudhi
 
-
 #endif  // PERSISTENCE_LANDSCAPE_H_
diff --git a/src/Persistence_representations/include/gudhi/Persistence_landscape_on_grid.h b/src/Persistence_representations/include/gudhi/Persistence_landscape_on_grid.h
index d663b543..64385846 100644
--- a/src/Persistence_representations/include/gudhi/Persistence_landscape_on_grid.h
+++ b/src/Persistence_representations/include/gudhi/Persistence_landscape_on_grid.h
@@ -10,7 +10,7 @@
  *    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
@@ -24,8 +24,7 @@
 #ifndef PERSISTENCE_LANDSCAPE_ON_GRID_H_
 #define PERSISTENCE_LANDSCAPE_ON_GRID_H_
 
- 
-//standard include
+// standard include
 #include <iostream>
 #include <vector>
 #include <limits>
@@ -37,23 +36,19 @@
 #include <functional>
 #include <functional>
 
-
-//gudhi include
+// gudhi include
 
 #include <gudhi/read_persistence_from_file.h>
 #include <gudhi/common_persistence_representations.h>
 
-
-
-namespace Gudhi
-{
-namespace Persistence_representations
-{
+namespace Gudhi {
+namespace Persistence_representations {
 
 // pre declaration
 class Persistence_landscape_on_grid;
-template < typename operation > 
-Persistence_landscape_on_grid operation_on_pair_of_landscapes_on_grid( const Persistence_landscape_on_grid& land1 ,  const Persistence_landscape_on_grid& land2 );
+template <typename operation>
+Persistence_landscape_on_grid operation_on_pair_of_landscapes_on_grid(const Persistence_landscape_on_grid& land1,
+                                                                      const Persistence_landscape_on_grid& land2);
 
 /**
  * \class Persistence_landscape_on_grid Persistence_landscape_on_grid.h gudhi/Persistence_landscape_on_grid.h
@@ -72,1408 +67,1285 @@ Persistence_landscape_on_grid operation_on_pair_of_landscapes_on_grid( const Per
  * is comparable to this value, please rescale them before use this code.
 **/
 
-//this class implements the following concepts: Vectorized_topological_data, Topological_data_with_distances, Real_valued_topological_data, Topological_data_with_averages, Topological_data_with_scalar_product
-class Persistence_landscape_on_grid  
-{
-public:
-	/**
-	 * Default constructor.
-	**/
-    Persistence_landscape_on_grid()
-    {
-		this->set_up_numbers_of_functions_for_vectorization_and_projections_to_reals();
-		this->grid_min = this->grid_max = 0;
-	}
-
-    /**
-	 * Constructor that takes as an input a vector of birth-death pairs.
-	**/
-    Persistence_landscape_on_grid( const std::vector< std::pair< double , double > >& p , double grid_min_ , double grid_max_ , size_t number_of_points_ );
-    
-    
-    /**
-	 * Constructor that takes as an input a vector of birth-death pairs, parameters of the grid and number of landscape function to be created.
-	**/
-    Persistence_landscape_on_grid( const std::vector< std::pair< double , double > >& p , double grid_min_ , double grid_max_ , size_t number_of_points_ , unsigned number_of_levels_of_landscape );
-    
-    /**
-	 * Constructor that reads persistence intervals from file and creates persistence landscape. The format of the input file is the following: in each line we put birth-death pair. Last line is assumed
-	 * to be empty. Even if the points within a line are not ordered, they will be ordered while the input is read. The additional parameters of this procedure are: ranges of grid, resolution of a grid
-	 * number of landscape functions to be created and the dimension of intervals that are need to be read from a file (in case of Gudhi format files). 
-	**/
-    Persistence_landscape_on_grid(const char* filename , double grid_min_, double grid_max_ , size_t number_of_points_ , unsigned number_of_levels_of_landscape , unsigned short dimension_ = std::numeric_limits<unsigned short>::max() );
-    
-     /**
-	 * Constructor that reads persistence intervals from file and creates persistence landscape. The format of the input file is the following: in each line we put birth-death pair. Last line is assumed
-	 * to be empty. Even if the points within a line are not ordered, they will be ordered while the input is read. The additional parameters of this procedure are: ranges of grid, resolution of a grid
-	 * and the dimension of intervals that are need to be read from a file (in case of Gudhi format files). 
-	**/
-    Persistence_landscape_on_grid(const char* filename , double grid_min_, double grid_max_ , size_t number_of_points_ , unsigned short dimension_ = std::numeric_limits<unsigned short>::max() );
-
-        
-    /**
-	 * Constructor that reads persistence intervals from file and creates persistence landscape. The format of the input file is the following: in each line we put birth-death pair. Last line is assumed
-	 * to be empty. Even if the points within a line are not ordered, they will be ordered while the input is read. The additional parameter is the resolution of a grid and the number of landscape
-	 * functions to be created. The remaining parameters are calculated based on data. 
-	**/
-    Persistence_landscape_on_grid(const char* filename , size_t number_of_points , unsigned number_of_levels_of_landscape , unsigned short dimension = std::numeric_limits<unsigned short>::max() );
-    
-      /**
-	 * Constructor that reads persistence intervals from file and creates persistence landscape. The format of the input file is the following: in each line we put birth-death pair. Last line is assumed
-	 * to be empty. Even if the points within a line are not ordered, they will be ordered while the input is read. The additional parameter is the resolution of a grid. The last parameter is the dimension
-	 * of a persistence to read from the file. If your file contains only persistence pair in a single dimension, please set it up to std::numeric_limits<unsigned>::max().
-	 * The remaining parameters are calculated based on data. 
-	**/
-    Persistence_landscape_on_grid(const char* filename , size_t number_of_points , unsigned short dimension = std::numeric_limits<unsigned short>::max() );
-
-
-    /**
-     * This procedure loads a landscape from file. It erase all the data that was previously stored in this landscape.
-    **/
-    void load_landscape_from_file( const char* filename );
-
-
-    /**
-     * The procedure stores a landscape to a file. The file can be later used by a procedure load_landscape_from_file.
-    **/
-    void print_to_file( const char* filename )const;
-
-
-
-	/**
-	 * This function compute integral of the landscape (defined formally as sum of integrals on R of all landscape functions)
-	**/
-    double compute_integral_of_landscape()const
-    {
-		size_t maximal_level = this->number_of_nonzero_levels();
-		double result = 0;
-		for ( size_t i = 0 ; i != maximal_level ; ++i )
-		{
-			result += this->compute_integral_of_landscape(i);
-		}
-		return result;
-	}
-
-
-    /**
-	 * This function compute integral of the 'level'-level of a landscape.
-	**/
-    double compute_integral_of_landscape( size_t level )const
-    {
-		bool dbg = false;
-		double result = 0;		
-		double dx = (this->grid_max - this->grid_min)/(double)(this->values_of_landscapes.size()-1);
-		
-		if ( dbg )
-		{			
-			std::cerr << "this->grid_max : " << this->grid_max << std::endl;
-			std::cerr << "this->grid_min : " << this->grid_min << std::endl;
-			std::cerr << "this->values_of_landscapes.size() : " << this->values_of_landscapes.size() << std::endl;
-			getchar();
-		}
-		
-		
-		double previous_x = this->grid_min-dx;
-		double previous_y = 0;
-		for ( size_t i = 0 ; i != this->values_of_landscapes.size() ; ++i )
-		{
-			double current_x = previous_x + dx;
-			double current_y = 0;
-			if ( this->values_of_landscapes[i].size() > level )current_y = this->values_of_landscapes[i][level];
-		
-			if ( dbg )
-			{
-				std::cerr << "this->values_of_landscapes[i].size() : " << this->values_of_landscapes[i].size() << " , level : " << level << std::endl;	
-				if ( this->values_of_landscapes[i].size() > level )std::cerr << "this->values_of_landscapes[i][level] : " << this->values_of_landscapes[i][level] << std::endl;
-				std::cerr << "previous_y : " << previous_y << std::endl;
-				std::cerr << "current_y : " << current_y << std::endl;
-				std::cerr << "dx : " << dx << std::endl;
-				std::cerr << "0.5*dx*( previous_y + current_y ); " << 0.5*dx*( previous_y + current_y ) << std::endl;
-			}
-			
-			result += 0.5*dx*( previous_y + current_y );			
-			previous_x = current_x;
-			previous_y = current_y;
-		}
-		return result;
-	}
-
-	/**
-	 * This function compute integral of the landscape p-th power of a landscape (defined formally as sum of integrals on R of p-th powers of all landscape functions)
-	**/
-	double compute_integral_of_landscape( double p )const
-	{
-		size_t maximal_level = this->number_of_nonzero_levels();
-		double result = 0;
-		for ( size_t i = 0 ; i != maximal_level ; ++i )
-		{
-			result += this->compute_integral_of_landscape(p,i);
-		}
-		return result;
-	}
-
-    /**
-	 * This function compute integral of the landscape p-th power of a level of a landscape (defined formally as sum of integrals on R of p-th powers of all landscape functions)
-	**/	
-	double compute_integral_of_landscape( double p , size_t level )const
-	{
-		bool dbg = false;
-		
-		double result = 0;				
-		double dx = (this->grid_max - this->grid_min)/(double)(this->values_of_landscapes.size()-1);		
-		double previous_x = this->grid_min;
-		double previous_y = 0;
-		if ( this->values_of_landscapes[0].size() > level )previous_y = this->values_of_landscapes[0][level];
-		
-		if ( dbg )
-		{
-			std::cerr << "dx : " << dx << std::endl;
-			std::cerr << "previous_x : " << previous_x << std::endl;
-			std::cerr << "previous_y : " << previous_y << std::endl;
-			std::cerr << "power : " << p << std::endl;
-			getchar();
-		}
-		
-		for ( size_t i = 0 ; i != this->values_of_landscapes.size() ; ++i )
-		{
-			double current_x = previous_x + dx;
-			double current_y = 0;
-			if ( this->values_of_landscapes[i].size() > level )current_y = this->values_of_landscapes[i][level];
-			
-			if ( dbg )std::cerr << "current_y : " << current_y << std::endl;
-			
-			if ( current_y == previous_y )continue; 
-			
-			std::pair<double,double> coef = compute_parameters_of_a_line( std::make_pair( previous_x , previous_y ) , std::make_pair( current_x , current_y ) );
-			double a = coef.first;
-			double b = coef.second;
-			
-			if ( dbg )
-			{
-				std::cerr << "A line passing through points : (" << previous_x << "," << previous_y << ") and (" << current_x << "," << current_y << ") is : " << a << "x+" << b << std::endl;
-			}
-			
-			//In this interval, the landscape has a form f(x) = ax+b. We want to compute integral of (ax+b)^p = 1/a * (ax+b)^{p+1}/(p+1)
-			double value_to_add = 0;
-			if ( a != 0 )
-			{			
-				value_to_add = 1/(a*(p+1)) * ( pow((a*current_x+b),p+1) - pow((a*previous_x+b),p+1));				
-			}
-			else
-			{
-				value_to_add = ( current_x - previous_x )*( pow(b,p) );
-			}				
-			result += value_to_add;
-			if ( dbg )
-			{
-				std::cerr << "Increasing result by : " << value_to_add << std::endl;
-				std::cerr << "result : " << result << std::endl;
-				getchar();
-			}		
-			previous_x = current_x;
-			previous_y = current_y;
-		}		
-		if ( dbg )std::cerr << "The total result is : " << result << std::endl;
-		return result;
-	}
-	
-	/**
-     * Writing landscape into a stream. A i-th level landscape starts with a string "lambda_i". Then the discontinuity points of the landscapes follows.
-     * Shall those points be joined with lines, we will obtain the i-th landscape function.
+// this class implements the following concepts: Vectorized_topological_data, Topological_data_with_distances,
+// Real_valued_topological_data, Topological_data_with_averages, Topological_data_with_scalar_product
+class Persistence_landscape_on_grid {
+ public:
+  /**
+   * Default constructor.
+  **/
+  Persistence_landscape_on_grid() {
+    this->set_up_numbers_of_functions_for_vectorization_and_projections_to_reals();
+    this->grid_min = this->grid_max = 0;
+  }
+
+  /**
+       * Constructor that takes as an input a vector of birth-death pairs.
+      **/
+  Persistence_landscape_on_grid(const std::vector<std::pair<double, double> >& p, double grid_min_, double grid_max_,
+                                size_t number_of_points_);
+
+  /**
+       * Constructor that takes as an input a vector of birth-death pairs, parameters of the grid and number of
+    *landscape function to be created.
+      **/
+  Persistence_landscape_on_grid(const std::vector<std::pair<double, double> >& p, double grid_min_, double grid_max_,
+                                size_t number_of_points_, unsigned number_of_levels_of_landscape);
+
+  /**
+       * Constructor that reads persistence intervals from file and creates persistence landscape. The format of the
+    *input file is the following: in each line we put birth-death pair. Last line is assumed
+       * to be empty. Even if the points within a line are not ordered, they will be ordered while the input is read.
+    *The additional parameters of this procedure are: ranges of grid, resolution of a grid
+       * number of landscape functions to be created and the dimension of intervals that are need to be read from a file
+    *(in case of Gudhi format files).
+      **/
+  Persistence_landscape_on_grid(const char* filename, double grid_min_, double grid_max_, size_t number_of_points_,
+                                unsigned number_of_levels_of_landscape,
+                                unsigned short dimension_ = std::numeric_limits<unsigned short>::max());
+
+  /**
+      * Constructor that reads persistence intervals from file and creates persistence landscape. The format of the
+    *input file is the following: in each line we put birth-death pair. Last line is assumed
+      * to be empty. Even if the points within a line are not ordered, they will be ordered while the input is read. The
+    *additional parameters of this procedure are: ranges of grid, resolution of a grid
+      * and the dimension of intervals that are need to be read from a file (in case of Gudhi format files).
+     **/
+  Persistence_landscape_on_grid(const char* filename, double grid_min_, double grid_max_, size_t number_of_points_,
+                                unsigned short dimension_ = std::numeric_limits<unsigned short>::max());
+
+  /**
+       * Constructor that reads persistence intervals from file and creates persistence landscape. The format of the
+    *input file is the following: in each line we put birth-death pair. Last line is assumed
+       * to be empty. Even if the points within a line are not ordered, they will be ordered while the input is read.
+    *The additional parameter is the resolution of a grid and the number of landscape
+       * functions to be created. The remaining parameters are calculated based on data.
+      **/
+  Persistence_landscape_on_grid(const char* filename, size_t number_of_points, unsigned number_of_levels_of_landscape,
+                                unsigned short dimension = std::numeric_limits<unsigned short>::max());
+
+  /**
+     * Constructor that reads persistence intervals from file and creates persistence landscape. The format of the input
+    *file is the following: in each line we put birth-death pair. Last line is assumed
+     * to be empty. Even if the points within a line are not ordered, they will be ordered while the input is read. The
+    *additional parameter is the resolution of a grid. The last parameter is the dimension
+     * of a persistence to read from the file. If your file contains only persistence pair in a single dimension, please
+    *set it up to std::numeric_limits<unsigned>::max().
+     * The remaining parameters are calculated based on data.
     **/
-    friend std::ostream& operator<<(std::ostream& out, const Persistence_landscape_on_grid& land )
-	{
-		double dx = (land.grid_max - land.grid_min)/(double)(land.values_of_landscapes.size()-1);
-		double x = land.grid_min;
-		for ( size_t i = 0 ; i != land.values_of_landscapes.size() ; ++i )
-		{
-			out << x << " : ";
-			for ( size_t j = 0 ; j != land.values_of_landscapes[i].size() ; ++j )
-			{
-				out << land.values_of_landscapes[i][j] << " ";
-			}
-			out << std::endl;
-			x += dx;
-		}
-		return out;
-	}
-	
-	template < typename oper > 
-	friend Persistence_landscape_on_grid operation_on_pair_of_landscapes_on_grid( const Persistence_landscape_on_grid& land1 ,  const Persistence_landscape_on_grid& land2 );
-
-
-    /**
-     * A function that computes the value of a landscape at a given point. The parameters of the function are: unsigned level and double x.
-     * The procedure will compute the value of the level-landscape at the point x.
-    **/
-    double compute_value_at_a_given_point( unsigned level , double x )const
-    {
-		bool dbg = false;
-		if ( (x < this->grid_min) || (x > this->grid_max) )return 0;
-		
-		//find a position of a vector closest to x:
-		double dx = (this->grid_max - this->grid_min)/(double)(this->values_of_landscapes.size()-1);
-		size_t position = size_t((x-this->grid_min)/dx);
-		
-		if ( dbg )
-		{
-			std::cerr << "This is a procedure compute_value_at_a_given_point \n";
-			std::cerr << "level : " << level << std::endl;
-			std::cerr << "x : " << x << std::endl;
-			std::cerr << "position : " << position << std::endl;
-		}
-		//check if we are not exactly in the grid point:
-		if ( almost_equal( position*dx+ this->grid_min ,  x) )
-		{
-			if ( this->values_of_landscapes[position].size() < level )
-			{
-				return this->values_of_landscapes[position][level];
-			}
-			else
-			{
-				return 0;
-			}
-		}
-		//in the other case, approximate with a line:
-		std::pair<double,double> line;
-		if ( (this->values_of_landscapes[position].size() > level) && (this->values_of_landscapes[position+1].size() > level) )
-		{
-			line = compute_parameters_of_a_line( std::make_pair( position*dx+ this->grid_min , this->values_of_landscapes[position][level] ) , std::make_pair( (position+1)*dx+ this->grid_min , this->values_of_landscapes[position+1][level] ) );
-		}
-		else
-		{
-			if ( (this->values_of_landscapes[position].size() > level) || (this->values_of_landscapes[position+1].size() > level) )
-			{
-				if ( (this->values_of_landscapes[position].size() > level) )
-				{
-						line = compute_parameters_of_a_line( std::make_pair( position*dx+ this->grid_min , this->values_of_landscapes[position][level] ) , std::make_pair( (position+1)*dx+ this->grid_min , 0 ) );
-				}
-				else
-				{
-					//(this->values_of_landscapes[position+1].size() > level)
-					line = compute_parameters_of_a_line( std::make_pair( position*dx+ this->grid_min , 0 ) , std::make_pair( (position+1)*dx+ this->grid_min , this->values_of_landscapes[position+1][level] ) );	
-				}
-			}
-			else
-			{
-				return 0;
-			}
-		}
-		//compute the value of the linear function parametrized by line on a point x:
-		return line.first*x+line.second;
-	}
-     
-    
-    public:
-	/**
-	 *\private A function that compute sum of two landscapes.
-	**/
-    friend Persistence_landscape_on_grid add_two_landscapes ( const Persistence_landscape_on_grid& land1 ,  const Persistence_landscape_on_grid& land2 )
-    {
-        return operation_on_pair_of_landscapes_on_grid< std::plus<double> >(land1,land2);
+  Persistence_landscape_on_grid(const char* filename, size_t number_of_points,
+                                unsigned short dimension = std::numeric_limits<unsigned short>::max());
+
+  /**
+   * This procedure loads a landscape from file. It erase all the data that was previously stored in this landscape.
+  **/
+  void load_landscape_from_file(const char* filename);
+
+  /**
+   * The procedure stores a landscape to a file. The file can be later used by a procedure load_landscape_from_file.
+  **/
+  void print_to_file(const char* filename) const;
+
+  /**
+   * This function compute integral of the landscape (defined formally as sum of integrals on R of all landscape
+   *functions)
+  **/
+  double compute_integral_of_landscape() const {
+    size_t maximal_level = this->number_of_nonzero_levels();
+    double result = 0;
+    for (size_t i = 0; i != maximal_level; ++i) {
+      result += this->compute_integral_of_landscape(i);
     }
-
-    /**
-	 *\private A function that compute difference of two landscapes.
-	**/
-    friend Persistence_landscape_on_grid subtract_two_landscapes ( const Persistence_landscape_on_grid& land1 ,  const Persistence_landscape_on_grid& land2 )
-    {
-        return operation_on_pair_of_landscapes_on_grid< std::minus<double> >(land1,land2);
+    return result;
+  }
+
+  /**
+       * This function compute integral of the 'level'-level of a landscape.
+      **/
+  double compute_integral_of_landscape(size_t level) const {
+    bool dbg = false;
+    double result = 0;
+    double dx = (this->grid_max - this->grid_min) / (double)(this->values_of_landscapes.size() - 1);
+
+    if (dbg) {
+      std::cerr << "this->grid_max : " << this->grid_max << std::endl;
+      std::cerr << "this->grid_min : " << this->grid_min << std::endl;
+      std::cerr << "this->values_of_landscapes.size() : " << this->values_of_landscapes.size() << std::endl;
+      getchar();
     }
 
-	/**
-	 * An operator +, that compute sum of two landscapes.
-	**/
-    friend Persistence_landscape_on_grid operator+( const Persistence_landscape_on_grid& first , const Persistence_landscape_on_grid& second )
-    {
-        return add_two_landscapes( first,second );
+    double previous_x = this->grid_min - dx;
+    double previous_y = 0;
+    for (size_t i = 0; i != this->values_of_landscapes.size(); ++i) {
+      double current_x = previous_x + dx;
+      double current_y = 0;
+      if (this->values_of_landscapes[i].size() > level) current_y = this->values_of_landscapes[i][level];
+
+      if (dbg) {
+        std::cerr << "this->values_of_landscapes[i].size() : " << this->values_of_landscapes[i].size()
+                  << " , level : " << level << std::endl;
+        if (this->values_of_landscapes[i].size() > level)
+          std::cerr << "this->values_of_landscapes[i][level] : " << this->values_of_landscapes[i][level] << std::endl;
+        std::cerr << "previous_y : " << previous_y << std::endl;
+        std::cerr << "current_y : " << current_y << std::endl;
+        std::cerr << "dx : " << dx << std::endl;
+        std::cerr << "0.5*dx*( previous_y + current_y ); " << 0.5 * dx * (previous_y + current_y) << std::endl;
+      }
+
+      result += 0.5 * dx * (previous_y + current_y);
+      previous_x = current_x;
+      previous_y = current_y;
     }
-
-	/**
-	 * An operator -, that compute difference of two landscapes.
-	**/
-    friend Persistence_landscape_on_grid operator-( const Persistence_landscape_on_grid& first , const Persistence_landscape_on_grid& second )
-    {
-        return subtract_two_landscapes( first,second );
+    return result;
+  }
+
+  /**
+   * This function compute integral of the landscape p-th power of a landscape (defined formally as sum of integrals on
+   *R of p-th powers of all landscape functions)
+  **/
+  double compute_integral_of_landscape(double p) const {
+    size_t maximal_level = this->number_of_nonzero_levels();
+    double result = 0;
+    for (size_t i = 0; i != maximal_level; ++i) {
+      result += this->compute_integral_of_landscape(p, i);
+    }
+    return result;
+  }
+
+  /**
+       * This function compute integral of the landscape p-th power of a level of a landscape (defined formally as sum
+    *of integrals on R of p-th powers of all landscape functions)
+      **/
+  double compute_integral_of_landscape(double p, size_t level) const {
+    bool dbg = false;
+
+    double result = 0;
+    double dx = (this->grid_max - this->grid_min) / (double)(this->values_of_landscapes.size() - 1);
+    double previous_x = this->grid_min;
+    double previous_y = 0;
+    if (this->values_of_landscapes[0].size() > level) previous_y = this->values_of_landscapes[0][level];
+
+    if (dbg) {
+      std::cerr << "dx : " << dx << std::endl;
+      std::cerr << "previous_x : " << previous_x << std::endl;
+      std::cerr << "previous_y : " << previous_y << std::endl;
+      std::cerr << "power : " << p << std::endl;
+      getchar();
     }
 
-	/**
-	 * An operator * that allows multiplication of a landscape by a real number.
-	**/
-    friend Persistence_landscape_on_grid operator*( const Persistence_landscape_on_grid& first , double con )
-    {
-        return first.multiply_lanscape_by_real_number_not_overwrite(con);
+    for (size_t i = 0; i != this->values_of_landscapes.size(); ++i) {
+      double current_x = previous_x + dx;
+      double current_y = 0;
+      if (this->values_of_landscapes[i].size() > level) current_y = this->values_of_landscapes[i][level];
+
+      if (dbg) std::cerr << "current_y : " << current_y << std::endl;
+
+      if (current_y == previous_y) continue;
+
+      std::pair<double, double> coef =
+          compute_parameters_of_a_line(std::make_pair(previous_x, previous_y), std::make_pair(current_x, current_y));
+      double a = coef.first;
+      double b = coef.second;
+
+      if (dbg) {
+        std::cerr << "A line passing through points : (" << previous_x << "," << previous_y << ") and (" << current_x
+                  << "," << current_y << ") is : " << a << "x+" << b << std::endl;
+      }
+
+      // In this interval, the landscape has a form f(x) = ax+b. We want to compute integral of (ax+b)^p = 1/a *
+      // (ax+b)^{p+1}/(p+1)
+      double value_to_add = 0;
+      if (a != 0) {
+        value_to_add = 1 / (a * (p + 1)) * (pow((a * current_x + b), p + 1) - pow((a * previous_x + b), p + 1));
+      } else {
+        value_to_add = (current_x - previous_x) * (pow(b, p));
+      }
+      result += value_to_add;
+      if (dbg) {
+        std::cerr << "Increasing result by : " << value_to_add << std::endl;
+        std::cerr << "result : " << result << std::endl;
+        getchar();
+      }
+      previous_x = current_x;
+      previous_y = current_y;
+    }
+    if (dbg) std::cerr << "The total result is : " << result << std::endl;
+    return result;
+  }
+
+  /**
+* Writing landscape into a stream. A i-th level landscape starts with a string "lambda_i". Then the discontinuity points
+*of the landscapes follows.
+* Shall those points be joined with lines, we will obtain the i-th landscape function.
+**/
+  friend std::ostream& operator<<(std::ostream& out, const Persistence_landscape_on_grid& land) {
+    double dx = (land.grid_max - land.grid_min) / (double)(land.values_of_landscapes.size() - 1);
+    double x = land.grid_min;
+    for (size_t i = 0; i != land.values_of_landscapes.size(); ++i) {
+      out << x << " : ";
+      for (size_t j = 0; j != land.values_of_landscapes[i].size(); ++j) {
+        out << land.values_of_landscapes[i][j] << " ";
+      }
+      out << std::endl;
+      x += dx;
+    }
+    return out;
+  }
+
+  template <typename oper>
+  friend Persistence_landscape_on_grid operation_on_pair_of_landscapes_on_grid(
+      const Persistence_landscape_on_grid& land1, const Persistence_landscape_on_grid& land2);
+
+  /**
+   * A function that computes the value of a landscape at a given point. The parameters of the function are: unsigned
+   *level and double x.
+   * The procedure will compute the value of the level-landscape at the point x.
+  **/
+  double compute_value_at_a_given_point(unsigned level, double x) const {
+    bool dbg = false;
+    if ((x < this->grid_min) || (x > this->grid_max)) return 0;
+
+    // find a position of a vector closest to x:
+    double dx = (this->grid_max - this->grid_min) / (double)(this->values_of_landscapes.size() - 1);
+    size_t position = size_t((x - this->grid_min) / dx);
+
+    if (dbg) {
+      std::cerr << "This is a procedure compute_value_at_a_given_point \n";
+      std::cerr << "level : " << level << std::endl;
+      std::cerr << "x : " << x << std::endl;
+      std::cerr << "position : " << position << std::endl;
+    }
+    // check if we are not exactly in the grid point:
+    if (almost_equal(position * dx + this->grid_min, x)) {
+      if (this->values_of_landscapes[position].size() < level) {
+        return this->values_of_landscapes[position][level];
+      } else {
+        return 0;
+      }
+    }
+    // in the other case, approximate with a line:
+    std::pair<double, double> line;
+    if ((this->values_of_landscapes[position].size() > level) &&
+        (this->values_of_landscapes[position + 1].size() > level)) {
+      line = compute_parameters_of_a_line(
+          std::make_pair(position * dx + this->grid_min, this->values_of_landscapes[position][level]),
+          std::make_pair((position + 1) * dx + this->grid_min, this->values_of_landscapes[position + 1][level]));
+    } else {
+      if ((this->values_of_landscapes[position].size() > level) ||
+          (this->values_of_landscapes[position + 1].size() > level)) {
+        if ((this->values_of_landscapes[position].size() > level)) {
+          line = compute_parameters_of_a_line(
+              std::make_pair(position * dx + this->grid_min, this->values_of_landscapes[position][level]),
+              std::make_pair((position + 1) * dx + this->grid_min, 0));
+        } else {
+          //(this->values_of_landscapes[position+1].size() > level)
+          line = compute_parameters_of_a_line(
+              std::make_pair(position * dx + this->grid_min, 0),
+              std::make_pair((position + 1) * dx + this->grid_min, this->values_of_landscapes[position + 1][level]));
+        }
+      } else {
+        return 0;
+      }
+    }
+    // compute the value of the linear function parametrized by line on a point x:
+    return line.first * x + line.second;
+  }
+
+ public:
+  /**
+   *\private A function that compute sum of two landscapes.
+  **/
+  friend Persistence_landscape_on_grid add_two_landscapes(const Persistence_landscape_on_grid& land1,
+                                                          const Persistence_landscape_on_grid& land2) {
+    return operation_on_pair_of_landscapes_on_grid<std::plus<double> >(land1, land2);
+  }
+
+  /**
+       *\private A function that compute difference of two landscapes.
+      **/
+  friend Persistence_landscape_on_grid subtract_two_landscapes(const Persistence_landscape_on_grid& land1,
+                                                               const Persistence_landscape_on_grid& land2) {
+    return operation_on_pair_of_landscapes_on_grid<std::minus<double> >(land1, land2);
+  }
+
+  /**
+   * An operator +, that compute sum of two landscapes.
+  **/
+  friend Persistence_landscape_on_grid operator+(const Persistence_landscape_on_grid& first,
+                                                 const Persistence_landscape_on_grid& second) {
+    return add_two_landscapes(first, second);
+  }
+
+  /**
+   * An operator -, that compute difference of two landscapes.
+  **/
+  friend Persistence_landscape_on_grid operator-(const Persistence_landscape_on_grid& first,
+                                                 const Persistence_landscape_on_grid& second) {
+    return subtract_two_landscapes(first, second);
+  }
+
+  /**
+   * An operator * that allows multiplication of a landscape by a real number.
+  **/
+  friend Persistence_landscape_on_grid operator*(const Persistence_landscape_on_grid& first, double con) {
+    return first.multiply_lanscape_by_real_number_not_overwrite(con);
+  }
+
+  /**
+   * An operator * that allows multiplication of a landscape by a real number (order of parameters swapped).
+  **/
+  friend Persistence_landscape_on_grid operator*(double con, const Persistence_landscape_on_grid& first) {
+    return first.multiply_lanscape_by_real_number_not_overwrite(con);
+  }
+
+  friend bool check_if_defined_on_the_same_domain(const Persistence_landscape_on_grid& land1,
+                                                  const Persistence_landscape_on_grid& land2) {
+    if (land1.values_of_landscapes.size() != land2.values_of_landscapes.size()) return false;
+    if (land1.grid_min != land2.grid_min) return false;
+    if (land1.grid_max != land2.grid_max) return false;
+    return true;
+  }
+
+  /**
+   * Operator +=. The second parameter is persistence landscape.
+  **/
+  Persistence_landscape_on_grid operator+=(const Persistence_landscape_on_grid& rhs) {
+    *this = *this + rhs;
+    return *this;
+  }
+
+  /**
+   * Operator -=. The second parameter is persistence landscape.
+  **/
+  Persistence_landscape_on_grid operator-=(const Persistence_landscape_on_grid& rhs) {
+    *this = *this - rhs;
+    return *this;
+  }
+
+  /**
+   * Operator *=. The second parameter is a real number by which the y values of all landscape functions are multiplied.
+   *The x-values remain unchanged.
+  **/
+  Persistence_landscape_on_grid operator*=(double x) {
+    *this = *this * x;
+    return *this;
+  }
+
+  /**
+   * Operator /=. The second parameter is a real number.
+  **/
+  Persistence_landscape_on_grid operator/=(double x) {
+    if (x == 0) throw("In operator /=, division by 0. Program terminated.");
+    *this = *this * (1 / x);
+    return *this;
+  }
+
+  /**
+   * An operator to compare two persistence landscapes.
+  **/
+  bool operator==(const Persistence_landscape_on_grid& rhs) const {
+    bool dbg = true;
+    if (this->values_of_landscapes.size() != rhs.values_of_landscapes.size()) {
+      if (dbg) std::cerr << "values_of_landscapes of incompatible sizes\n";
+      return false;
+    }
+    if (!almost_equal(this->grid_min, rhs.grid_min)) {
+      if (dbg) std::cerr << "grid_min not equal\n";
+      return false;
     }
+    if (!almost_equal(this->grid_max, rhs.grid_max)) {
+      if (dbg) std::cerr << "grid_max not equal\n";
+      return false;
+    }
+    for (size_t i = 0; i != this->values_of_landscapes.size(); ++i) {
+      for (size_t aa = 0; aa != this->values_of_landscapes[i].size(); ++aa) {
+        if (!almost_equal(this->values_of_landscapes[i][aa], rhs.values_of_landscapes[i][aa])) {
+          if (dbg) {
+            std::cerr << "Problem in the position : " << i << " of values_of_landscapes. \n";
+            std::cerr << this->values_of_landscapes[i][aa] << " " << rhs.values_of_landscapes[i][aa] << std::endl;
+          }
+          return false;
+        }
+      }
+    }
+    return true;
+  }
+
+  /**
+       * An operator to compare two persistence landscapes.
+      **/
+  bool operator!=(const Persistence_landscape_on_grid& rhs) const { return !((*this) == rhs); }
+
+  /**
+   * Computations of maximum (y) value of landscape.
+  **/
+  double compute_maximum() const {
+    // since the function can only be entirely positive or negative, the maximal value will be an extremal value in the
+    // arrays:
+    double max_value = -std::numeric_limits<double>::max();
+    for (size_t i = 0; i != this->values_of_landscapes.size(); ++i) {
+      if (this->values_of_landscapes[i].size()) {
+        if (this->values_of_landscapes[i][0] > max_value) max_value = this->values_of_landscapes[i][0];
+        if (this->values_of_landscapes[i][this->values_of_landscapes[i].size() - 1] > max_value)
+          max_value = this->values_of_landscapes[i][this->values_of_landscapes[i].size() - 1];
+      }
+    }
+    return max_value;
+  }
+
+  /**
+       * Computations of minimum and maximum value of landscape.
+      **/
+  std::pair<double, double> compute_minimum_maximum() const {
+    // since the function can only be entirely positive or negative, the maximal value will be an extremal value in the
+    // arrays:
+    double max_value = -std::numeric_limits<double>::max();
+    double min_value = 0;
+    for (size_t i = 0; i != this->values_of_landscapes.size(); ++i) {
+      if (this->values_of_landscapes[i].size()) {
+        if (this->values_of_landscapes[i][0] > max_value) max_value = this->values_of_landscapes[i][0];
+        if (this->values_of_landscapes[i][this->values_of_landscapes[i].size() - 1] > max_value)
+          max_value = this->values_of_landscapes[i][this->values_of_landscapes[i].size() - 1];
+
+        if (this->values_of_landscapes[i][0] < min_value) min_value = this->values_of_landscapes[i][0];
+        if (this->values_of_landscapes[i][this->values_of_landscapes[i].size() - 1] < min_value)
+          min_value = this->values_of_landscapes[i][this->values_of_landscapes[i].size() - 1];
+      }
+    }
+    return std::make_pair(min_value, max_value);
+  }
+
+  /**
+       * This procedure returns x-range of a given level persistence landscape. If a default value is used, the x-range
+       * of 0th level landscape is given (and this range contains the ranges of all other landscapes).
+      **/
+  std::pair<double, double> get_x_range(size_t level = 0) const {
+    return std::make_pair(this->grid_min, this->grid_max);
+  }
+
+  /**
+   * This procedure returns y-range of a persistence landscape. If a default value is used, the y-range
+   * of 0th level landscape is given (and this range contains the ranges of all other landscapes).
+  **/
+  std::pair<double, double> get_y_range(size_t level = 0) const { return this->compute_minimum_maximum(); }
+
+  /**
+   * This function computes maximal lambda for which lambda-level landscape is nonzero.
+  **/
+  size_t number_of_nonzero_levels() const {
+    size_t result = 0;
+    for (size_t i = 0; i != this->values_of_landscapes.size(); ++i) {
+      if (this->values_of_landscapes[i].size() > result) result = this->values_of_landscapes[i].size();
+    }
+    return result;
+  }
+
+  /**
+   * Computations of a \f$L^i\f$ norm of landscape, where i is the input parameter.
+  **/
+  double compute_norm_of_landscape(double i) const {
+    std::vector<std::pair<double, double> > p;
+    Persistence_landscape_on_grid l(p, this->grid_min, this->grid_max, this->values_of_landscapes.size() - 1);
+
+    if (i < std::numeric_limits<double>::max()) {
+      return compute_distance_of_landscapes_on_grid(*this, l, i);
+    } else {
+      return compute_max_norm_distance_of_landscapes(*this, l);
+    }
+  }
+
+  /**
+   * An operator to compute the value of a landscape in the level 'level' at the argument 'x'.
+  **/
+  double operator()(unsigned level, double x) const { return this->compute_value_at_a_given_point(level, x); }
+
+  /**
+   * Computations of \f$L^{\infty}\f$ distance between two landscapes.
+  **/
+  friend double compute_max_norm_distance_of_landscapes(const Persistence_landscape_on_grid& first,
+                                                        const Persistence_landscape_on_grid& second);
+
+  /**
+   * Function to compute absolute value of a PL function. The representation of persistence landscapes allow to store
+   *general PL-function. When computing distance between two landscapes, we compute difference between
+   * them. In this case, a general PL-function with negative value can appear as a result. Then in order to compute
+   *distance, we need to take its absolute value. This is the purpose of this procedure.
+  **/
+  void abs() {
+    for (size_t i = 0; i != this->values_of_landscapes.size(); ++i) {
+      for (size_t j = 0; j != this->values_of_landscapes[i].size(); ++j) {
+        this->values_of_landscapes[i][j] = std::abs(this->values_of_landscapes[i][j]);
+      }
+    }
+  }
+
+  /**
+   * Computes the number of landscape functions.
+  **/
+  size_t size() const { return this->number_of_nonzero_levels(); }
+
+  /**
+   *  Compute maximal value of lambda-level landscape.
+  **/
+  double find_max(unsigned lambda) const {
+    double max_value = -std::numeric_limits<double>::max();
+    for (size_t i = 0; i != this->values_of_landscapes.size(); ++i) {
+      if (this->values_of_landscapes[i].size() > lambda) {
+        if (this->values_of_landscapes[i][lambda] > max_value) max_value = this->values_of_landscapes[i][lambda];
+      }
+    }
+    return max_value;
+  }
+
+  /**
+   * Function to compute inner (scalar) product of two landscapes.
+  **/
+  friend double compute_inner_product(const Persistence_landscape_on_grid& l1,
+                                      const Persistence_landscape_on_grid& l2) {
+    if (!check_if_defined_on_the_same_domain(l1, l2))
+      throw "Landscapes are not defined on the same grid, the program will now terminate";
+    size_t maximal_level = l1.number_of_nonzero_levels();
+    double result = 0;
+    for (size_t i = 0; i != maximal_level; ++i) {
+      result += compute_inner_product(l1, l2, i);
+    }
+    return result;
+  }
+
+  /**
+   * Function to compute inner (scalar) product of given levels of two landscapes.
+  **/
+  friend double compute_inner_product(const Persistence_landscape_on_grid& l1, const Persistence_landscape_on_grid& l2,
+                                      size_t level) {
+    bool dbg = false;
+
+    if (!check_if_defined_on_the_same_domain(l1, l2))
+      throw "Landscapes are not defined on the same grid, the program will now terminate";
+    double result = 0;
+
+    double dx = (l1.grid_max - l1.grid_min) / (double)(l1.values_of_landscapes.size() - 1);
+
+    double previous_x = l1.grid_min - dx;
+    double previous_y_l1 = 0;
+    double previous_y_l2 = 0;
+    for (size_t i = 0; i != l1.values_of_landscapes.size(); ++i) {
+      if (dbg) std::cerr << "i : " << i << std::endl;
+
+      double current_x = previous_x + dx;
+      double current_y_l1 = 0;
+      if (l1.values_of_landscapes[i].size() > level) current_y_l1 = l1.values_of_landscapes[i][level];
+
+      double current_y_l2 = 0;
+      if (l2.values_of_landscapes[i].size() > level) current_y_l2 = l2.values_of_landscapes[i][level];
+
+      if (dbg) {
+        std::cerr << "previous_x  : " << previous_x << std::endl;
+        std::cerr << "previous_y_l1 : " << previous_y_l1 << std::endl;
+        std::cerr << "current_y_l1 : " << current_y_l1 << std::endl;
+        std::cerr << "previous_y_l2 : " << previous_y_l2 << std::endl;
+        std::cerr << "current_y_l2 : " << current_y_l2 << std::endl;
+      }
+
+      std::pair<double, double> l1_coords = compute_parameters_of_a_line(std::make_pair(previous_x, previous_y_l1),
+                                                                         std::make_pair(current_x, current_y_l1));
+      std::pair<double, double> l2_coords = compute_parameters_of_a_line(std::make_pair(previous_x, previous_y_l2),
+                                                                         std::make_pair(current_x, current_y_l2));
+
+      // let us assume that the first line is of a form y = ax+b, and the second one is of a form y = cx + d. Then here
+      // are a,b,c,d:
+      double a = l1_coords.first;
+      double b = l1_coords.second;
+
+      double c = l2_coords.first;
+      double d = l2_coords.second;
+
+      if (dbg) {
+        std::cerr << "Here are the formulas for a line: \n";
+        std::cerr << "a : " << a << std::endl;
+        std::cerr << "b : " << b << std::endl;
+        std::cerr << "c : " << c << std::endl;
+        std::cerr << "d : " << d << std::endl;
+      }
+
+      // now, to compute the inner product in this interval we need to compute the integral of (ax+b)(cx+d) = acx^2 +
+      // (ad+bc)x + bd in the interval from previous_x to current_x:
+      // The integral is ac/3*x^3 + (ac+bd)/2*x^2 + bd*x
+
+      double added_value = (a * c / 3 * current_x * current_x * current_x +
+                            (a * d + b * c) / 2 * current_x * current_x + b * d * current_x) -
+                           (a * c / 3 * previous_x * previous_x * previous_x +
+                            (a * d + b * c) / 2 * previous_x * previous_x + b * d * previous_x);
+
+      if (dbg) {
+        std::cerr << "Value of the integral on the left end i.e. : " << previous_x << " is : "
+                  << a * c / 3 * previous_x * previous_x * previous_x + (a * d + b * c) / 2 * previous_x * previous_x +
+                         b * d * previous_x
+                  << std::endl;
+        std::cerr << "Value of the integral on the right end i.e. : " << current_x << " is "
+                  << a * c / 3 * current_x * current_x * current_x + (a * d + b * c) / 2 * current_x * current_x +
+                         b * d * current_x
+                  << std::endl;
+      }
+
+      result += added_value;
+
+      if (dbg) {
+        std::cerr << "added_value : " << added_value << std::endl;
+        std::cerr << "result : " << result << std::endl;
+        getchar();
+      }
+
+      previous_x = current_x;
+      previous_y_l1 = current_y_l1;
+      previous_y_l2 = current_y_l2;
+    }
+    return result;
+  }
+
+  /**
+   * Computations of \f$L^{p}\f$ distance between two landscapes on a grid. p is the parameter of the procedure.
+   * FIXME: Note that, due to the grid representation, the method below may give non--accurate results in case when the
+   *landscape P and Q the difference of which we want to compute
+   * are intersecting. This is a consequence of a general way they are computed. In the future, an integral of absolute
+   *value of a difference of P and Q will be given as a separated
+   * function to fix that inaccuracy.
+  **/
+  friend double compute_distance_of_landscapes_on_grid(const Persistence_landscape_on_grid& first,
+                                                       const Persistence_landscape_on_grid& second, double p) {
+    bool dbg = false;
+    // This is what we want to compute: (\int_{- \infty}^{+\infty}| first-second |^p)^(1/p). We will do it one step at a
+    // time:
+
+    if (dbg) {
+      std::cerr << "first : " << first << std::endl;
+      std::cerr << "second : " << second << std::endl;
+      getchar();
+    }
+
+    // first-second :
+    Persistence_landscape_on_grid lan = first - second;
 
-	/**
-	 * An operator * that allows multiplication of a landscape by a real number (order of parameters swapped).
-	**/
-    friend Persistence_landscape_on_grid operator*( double con , const Persistence_landscape_on_grid& first  )
-    {
-        return first.multiply_lanscape_by_real_number_not_overwrite(con);
+    if (dbg) {
+      std::cerr << "Difference : " << lan << std::endl;
     }
 
-	friend bool check_if_defined_on_the_same_domain( const Persistence_landscape_on_grid& land1, const Persistence_landscape_on_grid& land2 )
-	{
-		if ( land1.values_of_landscapes.size() != land2.values_of_landscapes.size() )return false;
-		if ( land1.grid_min != land2.grid_min )return false;
-		if ( land1.grid_max != land2.grid_max )return false;
-		return true;
-	}
-
-	/**
-	 * Operator +=. The second parameter is persistence landscape.
-	**/
-    Persistence_landscape_on_grid operator += ( const Persistence_landscape_on_grid& rhs )
-    {
-        *this = *this + rhs;
-        return *this;
+    //| first-second |:
+    lan.abs();
+
+    if (dbg) {
+      std::cerr << "Abs : " << lan << std::endl;
     }
 
-	/**
-	 * Operator -=. The second parameter is persistence landscape.
-	**/
-    Persistence_landscape_on_grid operator -= ( const Persistence_landscape_on_grid& rhs )
-    {
-        *this = *this - rhs;
-        return *this;
+    if (p < std::numeric_limits<double>::max()) {
+      //\int_{- \infty}^{+\infty}| first-second |^p
+      double result;
+      if (p != 1) {
+        if (dbg) {
+          std::cerr << "p : " << p << std::endl;
+          getchar();
+        }
+        result = lan.compute_integral_of_landscape((double)p);
+        if (dbg) {
+          std::cerr << "integral : " << result << std::endl;
+          getchar();
+        }
+      } else {
+        result = lan.compute_integral_of_landscape();
+        if (dbg) {
+          std::cerr << "integral, without power : " << result << std::endl;
+          getchar();
+        }
+      }
+      //(\int_{- \infty}^{+\infty}| first-second |^p)^(1/p)
+      return pow(result, 1 / (double)p);
+    } else {
+      // p == infty
+      return lan.compute_maximum();
+    }
+  }
+
+  // Functions that are needed for that class to implement the concept.
+
+  /**
+   * The number of projections to R is defined to the number of nonzero landscape functions. I-th projection is an
+   *integral of i-th landscape function over whole R.
+   * This function is required by the Real_valued_topological_data concept.
+   * At the moment this function is not tested, since it is quite likely to be changed in the future. Given this, when
+   *using it, keep in mind that it
+   * will be most likely changed in the next versions.
+  **/
+  double project_to_R(int number_of_function) const {
+    return this->compute_integral_of_landscape((size_t)number_of_function);
+  }
+
+  /**
+   * The function gives the number of possible projections to R. This function is required by the
+   *Real_valued_topological_data concept.
+  **/
+  size_t number_of_projections_to_R() const { return number_of_functions_for_projections_to_reals; }
+
+  /**
+   * This function produce a vector of doubles based on a landscape. It is required in a concept
+   * Vectorized_topological_data
+  */
+  std::vector<double> vectorize(int number_of_function) const {
+    // TODO, think of something smarter over here
+    if ((number_of_function < 0) || ((size_t)number_of_function >= this->values_of_landscapes.size())) {
+      throw "Wrong number of function\n";
+    }
+    std::vector<double> v(this->values_of_landscapes.size());
+    for (size_t i = 0; i != this->values_of_landscapes.size(); ++i) {
+      v[i] = 0;
+      if (this->values_of_landscapes[i].size() > (size_t)number_of_function) {
+        v[i] = this->values_of_landscapes[i][number_of_function];
+      }
+    }
+    return v;
+  }
+
+  /**
+   * This function return the number of functions that allows vectorization of persistence landscape. It is required in
+   *a concept Vectorized_topological_data.
+   **/
+  size_t number_of_vectorize_functions() const { return number_of_functions_for_vectorization; }
+
+  /**
+   * A function to compute averaged persistence landscape on a grid, based on vector of persistence landscapes on grid.
+   * This function is required by Topological_data_with_averages concept.
+  **/
+  void compute_average(const std::vector<Persistence_landscape_on_grid*>& to_average) {
+    bool dbg = false;
+    // After execution of this procedure, the average is supposed to be in the current object. To make sure that this is
+    // the case, we need to do some cleaning first.
+    this->values_of_landscapes.clear();
+    this->grid_min = this->grid_max = 0;
+
+    // if there is nothing to average, then the average is a zero landscape.
+    if (to_average.size() == 0) return;
+
+    // now we need to check if the grids in all objects of to_average are the same:
+    for (size_t i = 0; i != to_average.size(); ++i) {
+      if (!check_if_defined_on_the_same_domain(*(to_average[0]), *(to_average[i])))
+        throw "Two grids are not compatible";
     }
 
+    this->values_of_landscapes = std::vector<std::vector<double> >((to_average[0])->values_of_landscapes.size());
+    this->grid_min = (to_average[0])->grid_min;
+    this->grid_max = (to_average[0])->grid_max;
 
-	/**
-	 * Operator *=. The second parameter is a real number by which the y values of all landscape functions are multiplied. The x-values remain unchanged. 
-	**/
-    Persistence_landscape_on_grid operator *= ( double x )
-    {
-        *this = *this*x;
-        return *this;
+    if (dbg) {
+      std::cerr << "Computations of average. The data from the current landscape have been cleared. We are ready to do "
+                   "the computations. \n";
     }
 
-	/**
-	 * Operator /=. The second parameter is a real number.
-	**/
-    Persistence_landscape_on_grid operator /= ( double x )
-    {
-        if ( x == 0 )throw( "In operator /=, division by 0. Program terminated." );
-        *this = *this * (1/x);
-        return *this;
+    // for every point in the grid:
+    for (size_t grid_point = 0; grid_point != (to_average[0])->values_of_landscapes.size(); ++grid_point) {
+      // set up a vector of the correct size:
+      size_t maximal_size_of_vector = 0;
+      for (size_t land_no = 0; land_no != to_average.size(); ++land_no) {
+        if ((to_average[land_no])->values_of_landscapes[grid_point].size() > maximal_size_of_vector)
+          maximal_size_of_vector = (to_average[land_no])->values_of_landscapes[grid_point].size();
+      }
+      this->values_of_landscapes[grid_point] = std::vector<double>(maximal_size_of_vector);
+
+      if (dbg) {
+        std::cerr << "We are considering the point : " << grid_point
+                  << " of the grid. In this point, there are at most : " << maximal_size_of_vector
+                  << " nonzero landscape functions \n";
+      }
+
+      // and compute an arithmetic average:
+      for (size_t land_no = 0; land_no != to_average.size(); ++land_no) {
+        // summing:
+        for (size_t i = 0; i != (to_average[land_no])->values_of_landscapes[grid_point].size(); ++i) {
+          // compute the average in a smarter way.
+          this->values_of_landscapes[grid_point][i] += (to_average[land_no])->values_of_landscapes[grid_point][i];
+        }
+      }
+      // normalizing:
+      for (size_t i = 0; i != this->values_of_landscapes[grid_point].size(); ++i) {
+        this->values_of_landscapes[grid_point][i] /= (double)to_average.size();
+      }
+    }
+  }  // compute_average
+
+  /**
+  * A function to compute distance between persistence landscape on a grid.
+  * The parameter of this function is a Persistence_landscape_on_grid.
+  * This function is required in Topological_data_with_distances concept.
+  * For max norm distance, set power to std::numeric_limits<double>::max()
+  **/
+  double distance(const Persistence_landscape_on_grid& second, double power = 1) const {
+    if (power < std::numeric_limits<double>::max()) {
+      return compute_distance_of_landscapes_on_grid(*this, second, power);
+    } else {
+      return compute_max_norm_distance_of_landscapes(*this, second);
     }
+  }
+
+  /**
+  * A function to compute scalar product of persistence landscape on a grid.
+  * The parameter of this function is a Persistence_landscape_on_grid.
+  * This function is required in Topological_data_with_scalar_product concept.
+  **/
+  double compute_scalar_product(const Persistence_landscape_on_grid& second) {
+    return compute_inner_product((*this), second);
+  }
+
+  // end of implementation of functions needed for concepts.
+
+  /**
+  * A function that returns values of landscapes. It can be used for visualization
+  **/
+  std::vector<std::vector<double> > output_for_visualization() const { return this->values_of_landscapes; }
+
+  /**
+  * function used to create a gnuplot script for visualization of landscapes. Over here we need to specify which
+  *landscapes do we want to plot.
+  * In addition, the user may specify the range (min and max) where landscape is plot. The default values for min and
+  *max are std::numeric_limits<double>::max(). If the procedure detect those
+  * values, it will determine the range so that the whole landscape is supported there. If at least one min or max value
+  *is different from std::numeric_limits<double>::max(), then the values
+  * provided by the user will be used.
+  **/
+  void plot(const char* filename, size_t from_, size_t to_) const {
+    this->plot(filename, std::numeric_limits<double>::max(), std::numeric_limits<double>::max(),
+               std::numeric_limits<double>::max(), std::numeric_limits<double>::max(), from_, to_);
+  }
+
+  /**
+  * function used to create a gnuplot script for visualization of landscapes. Over here we can restrict also x and y
+  *range of the landscape.
+  **/
+  void plot(const char* filename, double min_x = std::numeric_limits<double>::max(),
+            double max_x = std::numeric_limits<double>::max(), double min_y = std::numeric_limits<double>::max(),
+            double max_y = std::numeric_limits<double>::max(), size_t from_ = std::numeric_limits<size_t>::max(),
+            size_t to_ = std::numeric_limits<size_t>::max()) const;
+
+ protected:
+  double grid_min;
+  double grid_max;
+  std::vector<std::vector<double> > values_of_landscapes;
+  size_t number_of_functions_for_vectorization;
+  size_t number_of_functions_for_projections_to_reals;
+
+  void set_up_numbers_of_functions_for_vectorization_and_projections_to_reals() {
+    // warning, this function can be only called after filling in the values_of_landscapes vector.
+    this->number_of_functions_for_vectorization = this->values_of_landscapes.size();
+    this->number_of_functions_for_projections_to_reals = this->values_of_landscapes.size();
+  }
+  void set_up_values_of_landscapes(const std::vector<std::pair<double, double> >& p, double grid_min_, double grid_max_,
+                                   size_t number_of_points_,
+                                   unsigned number_of_levels = std::numeric_limits<unsigned>::max());
+  Persistence_landscape_on_grid multiply_lanscape_by_real_number_not_overwrite(double x) const;
+};
 
-	/**
-	 * An operator to compare two persistence landscapes.
-	**/
-    bool operator == ( const Persistence_landscape_on_grid& rhs  )const
-    {
-		bool dbg = true;
-		if ( this->values_of_landscapes.size() != rhs.values_of_landscapes.size() )
-		{
-			if (dbg) std::cerr << "values_of_landscapes of incompatible sizes\n";
-			return false;
-		}
-		if ( !almost_equal( this->grid_min , rhs.grid_min ) )
-		{
-			if (dbg) std::cerr << "grid_min not equal\n";
-			return false; 
-		}
-		if ( !almost_equal(this->grid_max,rhs.grid_max ) )
-		{	
-			if (dbg) std::cerr << "grid_max not equal\n";
-			return false;		
-		}
-		for ( size_t i = 0 ; i != this->values_of_landscapes.size() ; ++i )
-		{					
-			for ( size_t aa = 0 ; aa != this->values_of_landscapes[i].size() ; ++aa )
-			{
-				if ( !almost_equal( this->values_of_landscapes[i][aa]  , rhs.values_of_landscapes[i][aa]  ) )
-				{					
-					if (dbg) 
-					{
-						std::cerr << "Problem in the position : " << i << " of values_of_landscapes. \n";
-						std::cerr << this->values_of_landscapes[i][aa]   << " " <<  rhs.values_of_landscapes[i][aa] << std::endl;
-					}
-					return false;
-				}
-			}				
-		}	
-		return true;
-	}
-
-
-    /**
-	 * An operator to compare two persistence landscapes.
-	**/
-    bool operator != ( const Persistence_landscape_on_grid& rhs  )const
-    {
-		return !((*this) == rhs);
-	}
-
-
-	/**
-	 * Computations of maximum (y) value of landscape.
-	**/
-    double compute_maximum()const
-    {
-       //since the function can only be entirely positive or negative, the maximal value will be an extremal value in the arrays:
-		double max_value = -std::numeric_limits<double>::max();
-		for ( size_t i = 0 ; i != this->values_of_landscapes.size() ; ++i )
-		{
-			if ( this->values_of_landscapes[i].size() )
-			{
-				if ( this->values_of_landscapes[i][0] > max_value )max_value = this->values_of_landscapes[i][0];
-				if ( this->values_of_landscapes[i][ this->values_of_landscapes[i].size()-1 ] > max_value )max_value = this->values_of_landscapes[i][ this->values_of_landscapes[i].size()-1 ];
-			}
-		}
-		return max_value;        
+void Persistence_landscape_on_grid::set_up_values_of_landscapes(const std::vector<std::pair<double, double> >& p,
+                                                                double grid_min_, double grid_max_,
+                                                                size_t number_of_points_, unsigned number_of_levels) {
+  bool dbg = false;
+  if (dbg) {
+    std::cerr << "Here is the procedure : set_up_values_of_landscapes. The parameters are : grid_min_ : " << grid_min_
+              << ", grid_max_ : " << grid_max_ << ", number_of_points_ : " << number_of_points_
+              << ", number_of_levels: " << number_of_levels << std::endl;
+    std::cerr << "Here are the intervals at our disposal : \n";
+    for (size_t i = 0; i != p.size(); ++i) {
+      std::cerr << p[i].first << " , " << p[i].second << std::endl;
     }
-    
-    /**
-	 * Computations of minimum and maximum value of landscape.
-	**/
-    std::pair<double,double> compute_minimum_maximum()const
-    {        
-       //since the function can only be entirely positive or negative, the maximal value will be an extremal value in the arrays:
-		double max_value = -std::numeric_limits<double>::max();
-		double min_value = 0;
-		for ( size_t i = 0 ; i != this->values_of_landscapes.size() ; ++i )
-		{
-			if ( this->values_of_landscapes[i].size() )
-			{
-				if ( this->values_of_landscapes[i][0] > max_value )max_value = this->values_of_landscapes[i][0];
-				if ( this->values_of_landscapes[i][ this->values_of_landscapes[i].size()-1 ] > max_value )max_value = this->values_of_landscapes[i][ this->values_of_landscapes[i].size()-1 ];
-				
-				if ( this->values_of_landscapes[i][0] < min_value )min_value = this->values_of_landscapes[i][0];
-				if ( this->values_of_landscapes[i][ this->values_of_landscapes[i].size()-1 ] < min_value )min_value = this->values_of_landscapes[i][ this->values_of_landscapes[i].size()-1 ];
-			}
-		}
-		return std::make_pair(min_value , max_value);
+  }
+
+  if ((grid_min_ == std::numeric_limits<double>::max()) || (grid_max_ == std::numeric_limits<double>::max())) {
+    // in this case, we need to find grid_min_ and grid_min_ based on the data.
+    double min = std::numeric_limits<double>::max();
+    double max = std::numeric_limits<double>::min();
+    for (size_t i = 0; i != p.size(); ++i) {
+      if (p[i].first < min) min = p[i].first;
+      if (p[i].second > max) max = p[i].second;
     }
-    
-    /**
-	 * This procedure returns x-range of a given level persistence landscape. If a default value is used, the x-range
-	 * of 0th level landscape is given (and this range contains the ranges of all other landscapes). 
-	**/ 
-	std::pair< double , double > get_x_range( size_t level = 0 )const
-	{
-		return std::make_pair( this->grid_min , this->grid_max );
-	}
-	
-	/**
-	 * This procedure returns y-range of a persistence landscape. If a default value is used, the y-range
-	 * of 0th level landscape is given (and this range contains the ranges of all other landscapes). 
-	**/ 
-	std::pair< double , double > get_y_range( size_t level = 0 )const
-	{
-		return this->compute_minimum_maximum();
-	}
-    
-    /**
-     * This function computes maximal lambda for which lambda-level landscape is nonzero.
-    **/
-    size_t number_of_nonzero_levels()const
-    {
-		size_t result = 0;
-		for ( size_t i = 0 ; i != this->values_of_landscapes.size() ; ++i )
-		{
-			if ( this->values_of_landscapes[i].size() > result )result = this->values_of_landscapes[i].size();
-		}
-		return result;
-	}
-
-	/**
-	 * Computations of a \f$L^i\f$ norm of landscape, where i is the input parameter.
-	**/
-    double compute_norm_of_landscape( double i )const
-    {
-		std::vector< std::pair< double , double > > p;
-        Persistence_landscape_on_grid l(p,this->grid_min,this->grid_max,this->values_of_landscapes.size()-1);       
-        
-        if ( i < std::numeric_limits<double>::max() )
-        {
-            return compute_distance_of_landscapes_on_grid(*this,l,i);
-        }
-        else
-        {
-            return compute_max_norm_distance_of_landscapes(*this,l);
-        }
+    if (grid_min_ == std::numeric_limits<double>::max()) {
+      grid_min_ = min;
+    } else {
+      // in this case grid_max_ == std::numeric_limits<double>::max()
+      grid_max_ = max;
     }
+  }
 
-	/**
- 	 * An operator to compute the value of a landscape in the level 'level' at the argument 'x'.
-	**/
-    double operator()(unsigned level,double x)const{return this->compute_value_at_a_given_point(level,x);}
-
-	/**
-	 * Computations of \f$L^{\infty}\f$ distance between two landscapes.
-	**/
-    friend double compute_max_norm_distance_of_landscapes( const Persistence_landscape_on_grid& first, const Persistence_landscape_on_grid& second );
-
-
-
-	/**
-	 * Function to compute absolute value of a PL function. The representation of persistence landscapes allow to store general PL-function. When computing distance between two landscapes, we compute difference between
-	 * them. In this case, a general PL-function with negative value can appear as a result. Then in order to compute distance, we need to take its absolute value. This is the purpose of this procedure.
-	**/
-    void abs()
-    {		
-		for ( size_t i = 0 ; i != this->values_of_landscapes.size() ; ++i )
-		{
-			for ( size_t j = 0 ; j != this->values_of_landscapes[i].size() ; ++j )
-			{
-				this->values_of_landscapes[i][j] = std::abs( this->values_of_landscapes[i][j] );
-			}
-		}
-	}
-
-	/**
-	 * Computes the number of landscape functions.
-	**/
-    size_t size()const{return this->number_of_nonzero_levels(); }
-
-	/**
-	 *  Compute maximal value of lambda-level landscape.
-	**/
-    double find_max( unsigned lambda )const
-    {		
-		double max_value = -std::numeric_limits<double>::max();
-		for ( size_t i = 0 ; i != this->values_of_landscapes.size() ; ++i )
-		{
-			if ( this->values_of_landscapes[i].size() > lambda )
-			{
-				if ( this->values_of_landscapes[i][lambda] > max_value )max_value = this->values_of_landscapes[i][lambda];				
-			}
-		}
-		return max_value;
-	}
-
-	/**
-	 * Function to compute inner (scalar) product of two landscapes.
-	**/
-    friend double compute_inner_product( const Persistence_landscape_on_grid& l1 , const Persistence_landscape_on_grid& l2 )
-    {
-		if ( !check_if_defined_on_the_same_domain(l1,l2) )throw "Landscapes are not defined on the same grid, the program will now terminate";
-		size_t maximal_level = l1.number_of_nonzero_levels();
-		double result = 0;
-		for ( size_t i = 0 ; i != maximal_level ; ++i )
-		{
-			result += compute_inner_product(l1,l2,i);
-		}
-		return result;
-	}
-
-	
-	
-	/**
-	 * Function to compute inner (scalar) product of given levels of two landscapes.
-	**/
-    friend double compute_inner_product( const Persistence_landscape_on_grid& l1 , const Persistence_landscape_on_grid& l2 , size_t level )
-    {
-		bool dbg = false;
-		
-		if ( !check_if_defined_on_the_same_domain(l1,l2) )throw "Landscapes are not defined on the same grid, the program will now terminate";
-		double result = 0;
-		
-		double dx = (l1.grid_max - l1.grid_min)/(double)(l1.values_of_landscapes.size()-1);
-		
-		double previous_x = l1.grid_min-dx;
-		double previous_y_l1 = 0;
-		double previous_y_l2 = 0;
-		for ( size_t i = 0 ; i != l1.values_of_landscapes.size() ; ++i )
-		{
-			if ( dbg )std::cerr << "i : " << i << std::endl;
-			
-			double current_x = previous_x + dx;
-			double current_y_l1 = 0;
-			if ( l1.values_of_landscapes[i].size() > level )current_y_l1 = l1.values_of_landscapes[i][level];
-			
-			double current_y_l2 = 0;
-			if ( l2.values_of_landscapes[i].size() > level )current_y_l2 = l2.values_of_landscapes[i][level];
-			
-			if ( dbg )
-			{
-				std::cerr << "previous_x  : " << previous_x << std::endl;
-				std::cerr << "previous_y_l1 : " << previous_y_l1 << std::endl;
-				std::cerr << "current_y_l1 : " << current_y_l1 << std::endl;
-				std::cerr << "previous_y_l2 : " << previous_y_l2 << std::endl;
-				std::cerr << "current_y_l2 : " << current_y_l2 << std::endl;
-			}
-			
-			std::pair<double,double> l1_coords = compute_parameters_of_a_line( std::make_pair( previous_x , previous_y_l1 ) , std::make_pair( current_x , current_y_l1 ) );			
-			std::pair<double,double> l2_coords = compute_parameters_of_a_line( std::make_pair( previous_x , previous_y_l2 ) , std::make_pair( current_x , current_y_l2 ) );
-			
-			//let us assume that the first line is of a form y = ax+b, and the second one is of a form y = cx + d. Then here are a,b,c,d:
-			double a = l1_coords.first;
-			double b = l1_coords.second;
-			
-			double c = l2_coords.first;
-			double d = l2_coords.second;
-			
-			if ( dbg )
-			{
-				std::cerr << "Here are the formulas for a line: \n";
-				std::cerr << "a : " << a << std::endl;
-				std::cerr << "b : " << b << std::endl;
-				std::cerr << "c : " << c << std::endl;
-				std::cerr << "d : " << d << std::endl;				
-			}
-			
-			//now, to compute the inner product in this interval we need to compute the integral of (ax+b)(cx+d) = acx^2 + (ad+bc)x + bd in the interval from previous_x to current_x:
-			//The integral is ac/3*x^3 + (ac+bd)/2*x^2 + bd*x
-		
-			double added_value = (a*c/3*current_x*current_x*current_x + (a*d+b*c)/2*current_x*current_x + b*d*current_x)-
-			          (a*c/3*previous_x*previous_x*previous_x + (a*d+b*c)/2*previous_x*previous_x + b*d*previous_x);
-
-			if ( dbg )
-			{
-				std::cerr << "Value of the integral on the left end i.e. : " << previous_x << " is : " <<  a*c/3*previous_x*previous_x*previous_x + (a*d+b*c)/2*previous_x*previous_x + b*d*previous_x << std::endl;
-				std::cerr << "Value of the integral on the right end i.e. : " << current_x << " is " << a*c/3*current_x*current_x*current_x + (a*d+b*c)/2*current_x*current_x + b*d*current_x << std::endl;
-			}
-		
-			result += added_value;
-			
-			if ( dbg )
-			{
-				std::cerr << "added_value : " << added_value << std::endl;
-				std::cerr << "result : " << result << std::endl;
-				getchar();
-			}
-			
-			
-			previous_x = current_x;
-			previous_y_l1 = current_y_l1;
-			previous_y_l2 = current_y_l2;
-			
-			}		
-		return result;
-	}
-	
-	
-	/**
-	 * Computations of \f$L^{p}\f$ distance between two landscapes on a grid. p is the parameter of the procedure.
-	 * FIXME: Note that, due to the grid representation, the method below may give non--accurate results in case when the landscape P and Q the difference of which we want to compute
-	 * are intersecting. This is a consequence of a general way they are computed. In the future, an integral of absolute value of a difference of P and Q will be given as a separated
-	 * function to fix that inaccuracy. 
-	**/
-	friend double compute_distance_of_landscapes_on_grid( const Persistence_landscape_on_grid& first, const Persistence_landscape_on_grid& second , double p )
-	{		
-		bool dbg = false;
-		//This is what we want to compute: (\int_{- \infty}^{+\infty}| first-second |^p)^(1/p). We will do it one step at a time:
-
-		if ( dbg )
-		{
-			std::cerr << "first : " << first << std::endl;
-			std::cerr << "second : " << second << std::endl;
-			getchar();
-		}
-
-		//first-second :
-		Persistence_landscape_on_grid lan = first-second;
-		
-		if ( dbg )
-		{
-			std::cerr << "Difference : " << lan << std::endl;
-		}
-
-		//| first-second |:
-		lan.abs();
-		
-		if ( dbg )
-		{
-			std::cerr << "Abs : " << lan << std::endl;
-		}
-		
-		if ( p < std::numeric_limits< double >::max() )
-		{
-			//\int_{- \infty}^{+\infty}| first-second |^p
-			double result;
-			if ( p != 1 )
-			{
-				if (dbg){std::cerr << "p : " << p << std::endl; getchar();}
-				result = lan.compute_integral_of_landscape( (double)p );				
-				if (dbg){std::cerr << "integral : " << result << std::endl;getchar();}
-			}
-			else
-			{
-				result = lan.compute_integral_of_landscape();			
-				if (dbg){std::cerr << "integral, without power : " << result << std::endl;getchar();}
-			}
-			//(\int_{- \infty}^{+\infty}| first-second |^p)^(1/p)
-			return pow( result , 1/(double)p );
-		}
-		else
-		{
-			//p == infty
-			return lan.compute_maximum();
-		}
-	}
-
-	//Functions that are needed for that class to implement the concept.
-
-	/**
-	 * The number of projections to R is defined to the number of nonzero landscape functions. I-th projection is an integral of i-th landscape function over whole R.
-	 * This function is required by the Real_valued_topological_data concept.
-         * At the moment this function is not tested, since it is quite likely to be changed in the future. Given this, when using it, keep in mind that it
-         * will be most likely changed in the next versions.
-	**/
-    double project_to_R( int number_of_function )const
-    {
-		return this->compute_integral_of_landscape( (size_t)number_of_function );
-	}
-	
-	/**
-	 * The function gives the number of possible projections to R. This function is required by the Real_valued_topological_data concept.
-	**/ 
-	size_t number_of_projections_to_R()const
-	{
-		return number_of_functions_for_projections_to_reals;
-	}
-
-
-	/**
-	 * This function produce a vector of doubles based on a landscape. It is required in a concept Vectorized_topological_data
-	*/ 
-    std::vector<double> vectorize( int number_of_function )const
-    {
-		//TODO, think of something smarter over here
-		if ( ( number_of_function < 0 ) || ( (size_t)number_of_function >= this->values_of_landscapes.size() ) )
-		{
-			throw "Wrong number of function\n";
-		}
-		std::vector<double> v( this->values_of_landscapes.size() );
-		for ( size_t i = 0 ; i != this->values_of_landscapes.size() ; ++i )
-		{
-			v[i] = 0;
-			if ( this->values_of_landscapes[i].size() > (size_t)number_of_function )
-			{
-				v[ i ] = this->values_of_landscapes[i][number_of_function];
-			}
-		}
-		return v;
-	}
-	
-	/**
-	 * This function return the number of functions that allows vectorization of persistence landscape. It is required in a concept Vectorized_topological_data.
-	 **/ 
-	size_t number_of_vectorize_functions()const
-	{
-		return number_of_functions_for_vectorization;	
-	}
-
-	
-	/**
-	 * A function to compute averaged persistence landscape on a grid, based on vector of persistence landscapes on grid.
-	 * This function is required by Topological_data_with_averages concept.
-	**/  
-    void compute_average( const std::vector< Persistence_landscape_on_grid* >& to_average )
-    {
-		
-		bool dbg = false;
-		//After execution of this procedure, the average is supposed to be in the current object. To make sure that this is the case, we need to do some cleaning first.
-		this->values_of_landscapes .clear();
-		this->grid_min = this->grid_max = 0;
-		
-		//if there is nothing to average, then the average is a zero landscape. 
-		if ( to_average.size() == 0 )return;
-		
-		//now we need to check if the grids in all objects of to_average are the same:
-		for ( size_t i = 0 ; i != to_average.size() ; ++i )
-		{	
-			if ( !check_if_defined_on_the_same_domain(*(to_average[0]),*(to_average[i])) )throw "Two grids are not compatible"; 				
-		}
-		
-		this->values_of_landscapes = std::vector< std::vector<double> >( (to_average[0])->values_of_landscapes.size() );
-		this->grid_min = (to_average[0])->grid_min;
-		this->grid_max = (to_average[0])->grid_max;
-		
-		if ( dbg )
-		{
-			std::cerr << "Computations of average. The data from the current landscape have been cleared. We are ready to do the computations. \n";
-		}
-						
-		//for every point in the grid:
-		for ( size_t grid_point = 0 ; grid_point != (to_average[0])->values_of_landscapes.size() ; ++grid_point )
-		{
-			
-			//set up a vector of the correct size:
-			size_t maximal_size_of_vector = 0;
-			for ( size_t land_no = 0 ; land_no != to_average.size() ; ++land_no )
-			{
-				if ( (to_average[land_no])->values_of_landscapes[grid_point].size() > maximal_size_of_vector )
-				maximal_size_of_vector = (to_average[land_no])->values_of_landscapes[grid_point].size();
-			}
-			this->values_of_landscapes[grid_point] = std::vector<double>( maximal_size_of_vector );
-			
-			if ( dbg )
-			{
-				std::cerr << "We are considering the point : " << grid_point << " of the grid. In this point, there are at most : " << maximal_size_of_vector << " nonzero landscape functions \n";
-			}
-		
-			//and compute an arithmetic average:
-			for ( size_t land_no = 0 ; land_no != to_average.size() ; ++land_no )
-			{
-				//summing:				
-				for ( size_t i = 0 ; i != (to_average[land_no])->values_of_landscapes[grid_point].size() ; ++i )
-				{
-					//compute the average in a smarter way.
-					this->values_of_landscapes[grid_point][i] += (to_average[land_no])->values_of_landscapes[grid_point][i];
-				}								
-			}
-			//normalizing:
-			for ( size_t i = 0 ; i != this->values_of_landscapes[grid_point].size() ; ++i )
-			{
-				this->values_of_landscapes[grid_point][i] /= (double)to_average.size();
-			}			 
-		}
-	}//compute_average
-	
-	
-	/**
-	* A function to compute distance between persistence landscape on a grid.
-	* The parameter of this function is a Persistence_landscape_on_grid.
-	* This function is required in Topological_data_with_distances concept.
-	* For max norm distance, set power to std::numeric_limits<double>::max()
-	**/
-    double distance( const Persistence_landscape_on_grid& second , double power = 1 )const
-    {
-		if ( power < std::numeric_limits<double>::max() )
-		{
-			return compute_distance_of_landscapes_on_grid( *this , second , power );
-		}
-		else
-		{
-			return compute_max_norm_distance_of_landscapes( *this , second );
-		}
-	}
-
-	/**
-	* A function to compute scalar product of persistence landscape on a grid.
-	* The parameter of this function is a Persistence_landscape_on_grid.
-	* This function is required in Topological_data_with_scalar_product concept.
-	**/
-	double compute_scalar_product( const Persistence_landscape_on_grid& second )
-	{
-		return compute_inner_product( (*this) , second );
-	}
-
-	//end of implementation of functions needed for concepts. 
-
-	/**
-	* A function that returns values of landscapes. It can be used for visualization
-	**/
-	std::vector< std::vector< double > > output_for_visualization()const
-	{
-		return this->values_of_landscapes;
-	}
-	
-	/**
-	* function used to create a gnuplot script for visualization of landscapes. Over here we need to specify which landscapes do we want to plot.
-	* In addition, the user may specify the range (min and max) where landscape is plot. The default values for min and max are std::numeric_limits<double>::max(). If the procedure detect those
-	* values, it will determine the range so that the whole landscape is supported there. If at least one min or max value is different from std::numeric_limits<double>::max(), then the values
-	* provided by the user will be used. 
-	**/ 
-	void plot( const char* filename , size_t from_ , size_t to_ )const
-	{
-		this->plot( filename , std::numeric_limits<double>::max() , std::numeric_limits<double>::max(), std::numeric_limits<double>::max() , std::numeric_limits<double>::max() , from_ , to_ );
-	}
-	
-	/**
-	* function used to create a gnuplot script for visualization of landscapes. Over here we can restrict also x and y range of the landscape. 
-	**/ 
-	void plot( const char* filename, double min_x = std::numeric_limits<double>::max() , double max_x = std::numeric_limits<double>::max() , double min_y = std::numeric_limits<double>::max() , double max_y = std::numeric_limits<double>::max() , size_t from_ = std::numeric_limits<size_t>::max(), size_t to_= std::numeric_limits<size_t>::max()  )const;
-
-
-protected:
-	double grid_min;
-	double grid_max;
-	std::vector< std::vector< double > > values_of_landscapes;
-	size_t number_of_functions_for_vectorization;
-	size_t number_of_functions_for_projections_to_reals;
-	
-	void set_up_numbers_of_functions_for_vectorization_and_projections_to_reals()
-	{
-		//warning, this function can be only called after filling in the values_of_landscapes vector.
-		this->number_of_functions_for_vectorization = this->values_of_landscapes.size();
-		this->number_of_functions_for_projections_to_reals = this->values_of_landscapes.size();
-	}
-	void set_up_values_of_landscapes( const std::vector< std::pair< double , double > >& p , double grid_min_ , double grid_max_ , size_t number_of_points_ , unsigned number_of_levels = std::numeric_limits<unsigned>::max() );	
-	Persistence_landscape_on_grid multiply_lanscape_by_real_number_not_overwrite( double x )const;
-};
+  // if number_of_levels == std::numeric_limits<size_t>::max(), then we will have all the nonzero values of landscapes,
+  // and will store them in a vector
+  // if number_of_levels != std::numeric_limits<size_t>::max(), then we will use those vectors as heaps.
+  this->values_of_landscapes = std::vector<std::vector<double> >(number_of_points_ + 1);
 
+  this->grid_min = grid_min_;
+  this->grid_max = grid_max_;
 
-void Persistence_landscape_on_grid::set_up_values_of_landscapes( const std::vector< std::pair< double , double > >& p , double grid_min_ , double grid_max_ , size_t number_of_points_, unsigned number_of_levels )
-{			
-	bool dbg = false;
-	if ( dbg )
-	{
-		std::cerr << "Here is the procedure : set_up_values_of_landscapes. The parameters are : grid_min_ : " << grid_min_ << ", grid_max_ : " << grid_max_ << ", number_of_points_ : " << number_of_points_ << ", number_of_levels: " << number_of_levels << std::endl;
-		std::cerr << "Here are the intervals at our disposal : \n";
-		for ( size_t i = 0 ; i != p.size() ; ++i )
-		{
-			std::cerr << p[i].first << " , " << p[i].second << std::endl;
-		} 
-	}
-	
-	if ( (grid_min_ == std::numeric_limits<double>::max()) || (grid_max_ == std::numeric_limits<double>::max()) )
-	{
-		//in this case, we need to find grid_min_ and grid_min_ based on the data.
-		double min = std::numeric_limits<double>::max();
-		double max = std::numeric_limits<double>::min();
-		for ( size_t i = 0 ; i != p.size() ; ++i )
-		{
-			if ( p[i].first < min )min = p[i].first;
-			if ( p[i].second > max )max = p[i].second;
-		}
-		if ( grid_min_ == std::numeric_limits<double>::max() )
-		{
-			grid_min_ = min;
-		}
-		else
-		{
-			//in this case grid_max_ == std::numeric_limits<double>::max()
-			grid_max_ = max;
-		}
-	}
-	
-	//if number_of_levels == std::numeric_limits<size_t>::max(), then we will have all the nonzero values of landscapes, and will store them in a vector
-	//if number_of_levels != std::numeric_limits<size_t>::max(), then we will use those vectors as heaps.
-	this->values_of_landscapes = std::vector< std::vector< double > >( number_of_points_+1 );
-	
-	
-	this->grid_min = grid_min_;
-	this->grid_max = grid_max_;
-	
-	if ( grid_max_ <= grid_min_ )
-	{
-		throw "Wrong parameters of grid_min and grid_max given to the procedure. The grid have negative, or zero size. The program will now terminate.\n";
-	}
-	
-	double dx = ( grid_max_ - grid_min_ )/(double)(number_of_points_);		
-	//for every interval in the diagram:
-	for ( size_t int_no = 0 ; int_no != p.size() ; ++int_no )
-	{		
-		size_t grid_interval_begin = (p[int_no].first-grid_min_)/dx;
-		size_t grid_interval_end = (p[int_no].second-grid_min_)/dx;
-		size_t grid_interval_midpoint = (size_t)(0.5*(grid_interval_begin+grid_interval_end));
-		
-		if ( dbg )
-		{
-			std::cerr << "Considering an interval : " << p[int_no].first << "," << p[int_no].second << std::endl;
-		
-			std::cerr << "grid_interval_begin : " << grid_interval_begin << std::endl;
-			std::cerr << "grid_interval_end : " << grid_interval_end << std::endl;
-			std::cerr << "grid_interval_midpoint : " << grid_interval_midpoint << std::endl;	
-		}
-		
-		double landscape_value = dx;
-		for ( size_t i = grid_interval_begin+1 ; i < grid_interval_midpoint ; ++i )
-		{
-			if ( dbg )
-			{
-				std::cerr << "Adding landscape value (going up) for a point : " << i << " equal : " << landscape_value << std::endl;
-			}
-			if ( number_of_levels != std::numeric_limits<unsigned>::max() )
-			{
-				//we have a heap of no more that number_of_levels values.
-				//Note that if we are using heaps, we want to know the shortest distance in the heap.
-				//This is achieved by putting -distance to the heap. 
-				if ( this->values_of_landscapes[i].size() >= number_of_levels )
-				{
-					//in this case, the full heap is build, and we need to check if the landscape_value is not larger than the smallest element in the heap.
-					if ( -landscape_value < this->values_of_landscapes[i].front() )
-					{
-						//if it is, we remove the largest value in the heap, and move on. 
-						std::pop_heap (this->values_of_landscapes[i].begin(),this->values_of_landscapes[i].end());            
-						this->values_of_landscapes[i][ this->values_of_landscapes[i].size()-1 ] = -landscape_value;
-						std::push_heap (this->values_of_landscapes[i].begin(),this->values_of_landscapes[i].end());
-					}
-				}
-				else
-				{
-					
-					//in this case we are still filling in the array.
-					this->values_of_landscapes[i].push_back( -landscape_value );
-					if ( this->values_of_landscapes[i].size() == number_of_levels-1 )
-					{
-						//this->values_of_landscapes[i].size() == number_of_levels
-						//in this case we need to create the heap. 
-						std::make_heap (this->values_of_landscapes[i].begin(),this->values_of_landscapes[i].end());
-					}
-				}						
-			}
-			else
-			{
-				//we have vector of all values
-				this->values_of_landscapes[i].push_back( landscape_value );
-			}
-			landscape_value += dx;
-		}
-		for ( size_t i = grid_interval_midpoint ; i <= grid_interval_end ; ++i )
-		{						
-			if ( landscape_value > 0 ) 
-			{ 
-				if ( number_of_levels != std::numeric_limits< unsigned >::max() )
-				{
-					//we have a heap of no more that number_of_levels values
-					if ( this->values_of_landscapes[i].size() >= number_of_levels )
-					{
-						//in this case, the full heap is build, and we need to check if the landscape_value is not larger than the smallest element in the heap.
-						if ( -landscape_value < this->values_of_landscapes[i].front() )
-						{
-							//if it is, we remove the largest value in the heap, and move on. 
-							std::pop_heap (this->values_of_landscapes[i].begin(),this->values_of_landscapes[i].end());            
-							this->values_of_landscapes[i][ this->values_of_landscapes[i].size()-1 ] = -landscape_value;
-							std::push_heap (this->values_of_landscapes[i].begin(),this->values_of_landscapes[i].end());
-						}
-					}
-					else
-					{
-						
-						//in this case we are still filling in the array.
-						this->values_of_landscapes[i].push_back( -landscape_value );
-						if ( this->values_of_landscapes[i].size() == number_of_levels-1 )
-						{
-							//this->values_of_landscapes[i].size() == number_of_levels
-							//in this case we need to create the heap. 
-							std::make_heap (this->values_of_landscapes[i].begin(),this->values_of_landscapes[i].end());
-						}
-					}		
-				}
-				else
-				{
-					this->values_of_landscapes[i].push_back( landscape_value );	
-				}
-				
-				
-				if ( dbg )
-				{				
-					std::cerr << "Adding landscape value (going down) for a point : " << i << " equal : " << landscape_value << std::endl;
-				}
-			}
-			landscape_value -= dx;				
-		}  
-	}
-	
-	if ( number_of_levels != std::numeric_limits< unsigned >::max() )
-	{
-		//in this case, vectors are used as heaps. And, since we want to have the smallest element at the top of 
-		//each heap, we store minus distances. To get if right at the end, we need to multiply each value
-		//in the heap by -1 to get real vector of distances.		
-		for ( size_t pt = 0 ; pt != this->values_of_landscapes.size() ; ++pt )
-		{
-			for ( size_t j = 0 ; j != this->values_of_landscapes[pt].size() ; ++j )  
-			{
-				this->values_of_landscapes[pt][j] *= -1;
-			}
-		}
-	}
-		
-	//and now we need to sort the values:
-	for ( size_t pt = 0 ; pt != this->values_of_landscapes.size() ; ++pt )
-	{
-		std::sort( this->values_of_landscapes[pt].begin() , this->values_of_landscapes[pt].end() , std::greater<double>() );	
-	}
-}//set_up_values_of_landscapes
-
-
-
-Persistence_landscape_on_grid::Persistence_landscape_on_grid( const std::vector< std::pair< double , double > >& p , double grid_min_ , double grid_max_ , size_t number_of_points_ )
-{
-	this->set_up_values_of_landscapes( p , grid_min_ , grid_max_ , number_of_points_ );
-}//Persistence_landscape_on_grid
-
-
-Persistence_landscape_on_grid::Persistence_landscape_on_grid( const std::vector< std::pair< double , double > >& p , double grid_min_ , double grid_max_ , size_t number_of_points_ , unsigned number_of_levels_of_landscape )
-{
-	this->set_up_values_of_landscapes( p , grid_min_ , grid_max_ , number_of_points_ , number_of_levels_of_landscape );
-}
+  if (grid_max_ <= grid_min_) {
+    throw "Wrong parameters of grid_min and grid_max given to the procedure. The grid have negative, or zero size. The program will now terminate.\n";
+  }
 
+  double dx = (grid_max_ - grid_min_) / (double)(number_of_points_);
+  // for every interval in the diagram:
+  for (size_t int_no = 0; int_no != p.size(); ++int_no) {
+    size_t grid_interval_begin = (p[int_no].first - grid_min_) / dx;
+    size_t grid_interval_end = (p[int_no].second - grid_min_) / dx;
+    size_t grid_interval_midpoint = (size_t)(0.5 * (grid_interval_begin + grid_interval_end));
 
-Persistence_landscape_on_grid::Persistence_landscape_on_grid(const char* filename , double grid_min_, double grid_max_ , size_t number_of_points_ , unsigned short dimension )
-{
-    std::vector< std::pair< double , double > > p;
-    if ( dimension == std::numeric_limits<unsigned short>::max() )
-    {
-       p = read_persistence_intervals_in_one_dimension_from_file( filename );
+    if (dbg) {
+      std::cerr << "Considering an interval : " << p[int_no].first << "," << p[int_no].second << std::endl;
+
+      std::cerr << "grid_interval_begin : " << grid_interval_begin << std::endl;
+      std::cerr << "grid_interval_end : " << grid_interval_end << std::endl;
+      std::cerr << "grid_interval_midpoint : " << grid_interval_midpoint << std::endl;
     }
-    else
-    {
-       p = read_persistence_intervals_in_one_dimension_from_file( filename , dimension );
+
+    double landscape_value = dx;
+    for (size_t i = grid_interval_begin + 1; i < grid_interval_midpoint; ++i) {
+      if (dbg) {
+        std::cerr << "Adding landscape value (going up) for a point : " << i << " equal : " << landscape_value
+                  << std::endl;
+      }
+      if (number_of_levels != std::numeric_limits<unsigned>::max()) {
+        // we have a heap of no more that number_of_levels values.
+        // Note that if we are using heaps, we want to know the shortest distance in the heap.
+        // This is achieved by putting -distance to the heap.
+        if (this->values_of_landscapes[i].size() >= number_of_levels) {
+          // in this case, the full heap is build, and we need to check if the landscape_value is not larger than the
+          // smallest element in the heap.
+          if (-landscape_value < this->values_of_landscapes[i].front()) {
+            // if it is, we remove the largest value in the heap, and move on.
+            std::pop_heap(this->values_of_landscapes[i].begin(), this->values_of_landscapes[i].end());
+            this->values_of_landscapes[i][this->values_of_landscapes[i].size() - 1] = -landscape_value;
+            std::push_heap(this->values_of_landscapes[i].begin(), this->values_of_landscapes[i].end());
+          }
+        } else {
+          // in this case we are still filling in the array.
+          this->values_of_landscapes[i].push_back(-landscape_value);
+          if (this->values_of_landscapes[i].size() == number_of_levels - 1) {
+            // this->values_of_landscapes[i].size() == number_of_levels
+            // in this case we need to create the heap.
+            std::make_heap(this->values_of_landscapes[i].begin(), this->values_of_landscapes[i].end());
+          }
+        }
+      } else {
+        // we have vector of all values
+        this->values_of_landscapes[i].push_back(landscape_value);
+      }
+      landscape_value += dx;
     }
-    this->set_up_values_of_landscapes( p , grid_min_ , grid_max_ , number_of_points_ );
-}
+    for (size_t i = grid_interval_midpoint; i <= grid_interval_end; ++i) {
+      if (landscape_value > 0) {
+        if (number_of_levels != std::numeric_limits<unsigned>::max()) {
+          // we have a heap of no more that number_of_levels values
+          if (this->values_of_landscapes[i].size() >= number_of_levels) {
+            // in this case, the full heap is build, and we need to check if the landscape_value is not larger than the
+            // smallest element in the heap.
+            if (-landscape_value < this->values_of_landscapes[i].front()) {
+              // if it is, we remove the largest value in the heap, and move on.
+              std::pop_heap(this->values_of_landscapes[i].begin(), this->values_of_landscapes[i].end());
+              this->values_of_landscapes[i][this->values_of_landscapes[i].size() - 1] = -landscape_value;
+              std::push_heap(this->values_of_landscapes[i].begin(), this->values_of_landscapes[i].end());
+            }
+          } else {
+            // in this case we are still filling in the array.
+            this->values_of_landscapes[i].push_back(-landscape_value);
+            if (this->values_of_landscapes[i].size() == number_of_levels - 1) {
+              // this->values_of_landscapes[i].size() == number_of_levels
+              // in this case we need to create the heap.
+              std::make_heap(this->values_of_landscapes[i].begin(), this->values_of_landscapes[i].end());
+            }
+          }
+        } else {
+          this->values_of_landscapes[i].push_back(landscape_value);
+        }
 
-Persistence_landscape_on_grid::Persistence_landscape_on_grid(const char* filename , double grid_min_, double grid_max_ , size_t number_of_points_, unsigned number_of_levels_of_landscape, unsigned short dimension )
-{
-    std::vector< std::pair< double , double > > p;
-    if ( dimension == std::numeric_limits<unsigned short>::max() )
-    {
-       p = read_persistence_intervals_in_one_dimension_from_file( filename );
+        if (dbg) {
+          std::cerr << "Adding landscape value (going down) for a point : " << i << " equal : " << landscape_value
+                    << std::endl;
+        }
+      }
+      landscape_value -= dx;
     }
-    else
-    {
-       p = read_persistence_intervals_in_one_dimension_from_file( filename , dimension );
+  }
+
+  if (number_of_levels != std::numeric_limits<unsigned>::max()) {
+    // in this case, vectors are used as heaps. And, since we want to have the smallest element at the top of
+    // each heap, we store minus distances. To get if right at the end, we need to multiply each value
+    // in the heap by -1 to get real vector of distances.
+    for (size_t pt = 0; pt != this->values_of_landscapes.size(); ++pt) {
+      for (size_t j = 0; j != this->values_of_landscapes[pt].size(); ++j) {
+        this->values_of_landscapes[pt][j] *= -1;
+      }
     }
-    this->set_up_values_of_landscapes( p , grid_min_ , grid_max_ , number_of_points_ , number_of_levels_of_landscape );
+  }
+
+  // and now we need to sort the values:
+  for (size_t pt = 0; pt != this->values_of_landscapes.size(); ++pt) {
+    std::sort(this->values_of_landscapes[pt].begin(), this->values_of_landscapes[pt].end(), std::greater<double>());
+  }
+}  // set_up_values_of_landscapes
+
+Persistence_landscape_on_grid::Persistence_landscape_on_grid(const std::vector<std::pair<double, double> >& p,
+                                                             double grid_min_, double grid_max_,
+                                                             size_t number_of_points_) {
+  this->set_up_values_of_landscapes(p, grid_min_, grid_max_, number_of_points_);
+}  // Persistence_landscape_on_grid
+
+Persistence_landscape_on_grid::Persistence_landscape_on_grid(const std::vector<std::pair<double, double> >& p,
+                                                             double grid_min_, double grid_max_,
+                                                             size_t number_of_points_,
+                                                             unsigned number_of_levels_of_landscape) {
+  this->set_up_values_of_landscapes(p, grid_min_, grid_max_, number_of_points_, number_of_levels_of_landscape);
 }
 
-Persistence_landscape_on_grid::Persistence_landscape_on_grid(const char* filename , size_t number_of_points_ , unsigned short dimension )
-{
-    std::vector< std::pair< double , double > > p;
-    if ( dimension == std::numeric_limits<unsigned short>::max() )
-    {
-       p = read_persistence_intervals_in_one_dimension_from_file( filename );
-    }
-    else
-    {
-       p = read_persistence_intervals_in_one_dimension_from_file( filename , dimension );
-    }
-    double grid_min_ = std::numeric_limits<double>::max();
-    double grid_max_ = -std::numeric_limits<double>::max();
-    for ( size_t i = 0 ; i != p.size() ; ++i )
-    {
-		if ( p[i].first < grid_min_ )grid_min_ = p[i].first;
-		if ( p[i].second > grid_max_ )grid_max_ = p[i].second;
-	}	
-	this->set_up_values_of_landscapes( p , grid_min_ , grid_max_ , number_of_points_ );
+Persistence_landscape_on_grid::Persistence_landscape_on_grid(const char* filename, double grid_min_, double grid_max_,
+                                                             size_t number_of_points_, unsigned short dimension) {
+  std::vector<std::pair<double, double> > p;
+  if (dimension == std::numeric_limits<unsigned short>::max()) {
+    p = read_persistence_intervals_in_one_dimension_from_file(filename);
+  } else {
+    p = read_persistence_intervals_in_one_dimension_from_file(filename, dimension);
+  }
+  this->set_up_values_of_landscapes(p, grid_min_, grid_max_, number_of_points_);
 }
 
-Persistence_landscape_on_grid::Persistence_landscape_on_grid(const char* filename , size_t number_of_points_ , unsigned number_of_levels_of_landscape , unsigned short dimension )
-{
-    std::vector< std::pair< double , double > > p;
-    if ( dimension == std::numeric_limits<unsigned short>::max() )
-    {
-       p = read_persistence_intervals_in_one_dimension_from_file( filename );
-    }
-    else
-    {
-       p = read_persistence_intervals_in_one_dimension_from_file( filename , dimension );
-    }
-    double grid_min_ = std::numeric_limits<double>::max();
-    double grid_max_ = -std::numeric_limits<double>::max();
-    for ( size_t i = 0 ; i != p.size() ; ++i )
-    {
-		if ( p[i].first < grid_min_ )grid_min_ = p[i].first;
-		if ( p[i].second > grid_max_ )grid_max_ = p[i].second;
-	}	
-	this->set_up_values_of_landscapes( p , grid_min_ , grid_max_ , number_of_points_ , number_of_levels_of_landscape );
+Persistence_landscape_on_grid::Persistence_landscape_on_grid(const char* filename, double grid_min_, double grid_max_,
+                                                             size_t number_of_points_,
+                                                             unsigned number_of_levels_of_landscape,
+                                                             unsigned short dimension) {
+  std::vector<std::pair<double, double> > p;
+  if (dimension == std::numeric_limits<unsigned short>::max()) {
+    p = read_persistence_intervals_in_one_dimension_from_file(filename);
+  } else {
+    p = read_persistence_intervals_in_one_dimension_from_file(filename, dimension);
+  }
+  this->set_up_values_of_landscapes(p, grid_min_, grid_max_, number_of_points_, number_of_levels_of_landscape);
 }
 
+Persistence_landscape_on_grid::Persistence_landscape_on_grid(const char* filename, size_t number_of_points_,
+                                                             unsigned short dimension) {
+  std::vector<std::pair<double, double> > p;
+  if (dimension == std::numeric_limits<unsigned short>::max()) {
+    p = read_persistence_intervals_in_one_dimension_from_file(filename);
+  } else {
+    p = read_persistence_intervals_in_one_dimension_from_file(filename, dimension);
+  }
+  double grid_min_ = std::numeric_limits<double>::max();
+  double grid_max_ = -std::numeric_limits<double>::max();
+  for (size_t i = 0; i != p.size(); ++i) {
+    if (p[i].first < grid_min_) grid_min_ = p[i].first;
+    if (p[i].second > grid_max_) grid_max_ = p[i].second;
+  }
+  this->set_up_values_of_landscapes(p, grid_min_, grid_max_, number_of_points_);
+}
 
-void Persistence_landscape_on_grid::load_landscape_from_file( const char* filename )
-{
-    std::ifstream in;
-	in.open( filename );
-	//check if the file exist.
-	if ( !in.good() )
-	{
-		std::cerr << "The file : " << filename << " do not exist. The program will now terminate \n";
-		throw "The file from which you are trying to read the persistence landscape do not exist. The program will now terminate \n";
-	}	
-	
-	size_t number_of_points_in_the_grid = 0;
-	in >> this->grid_min >> this->grid_max >> number_of_points_in_the_grid;
-	
-	std::vector< std::vector< double > > v(number_of_points_in_the_grid);
-	std::string line;
-	std::getline(in, line);
-	double number;
-	for ( size_t i = 0 ; i != number_of_points_in_the_grid ; ++i )
-	{
-		//read a line of a file and convert it to a vector.
-		std::vector< double > vv;		
-		std::getline(in, line);		
-		std::istringstream stream(line);
-		while (stream >> number)
-		{
-			vv.push_back(number);
-		}		
-		v[i] = vv;
-	}
-	this->values_of_landscapes = v;
-	in.close();
+Persistence_landscape_on_grid::Persistence_landscape_on_grid(const char* filename, size_t number_of_points_,
+                                                             unsigned number_of_levels_of_landscape,
+                                                             unsigned short dimension) {
+  std::vector<std::pair<double, double> > p;
+  if (dimension == std::numeric_limits<unsigned short>::max()) {
+    p = read_persistence_intervals_in_one_dimension_from_file(filename);
+  } else {
+    p = read_persistence_intervals_in_one_dimension_from_file(filename, dimension);
+  }
+  double grid_min_ = std::numeric_limits<double>::max();
+  double grid_max_ = -std::numeric_limits<double>::max();
+  for (size_t i = 0; i != p.size(); ++i) {
+    if (p[i].first < grid_min_) grid_min_ = p[i].first;
+    if (p[i].second > grid_max_) grid_max_ = p[i].second;
+  }
+  this->set_up_values_of_landscapes(p, grid_min_, grid_max_, number_of_points_, number_of_levels_of_landscape);
 }
 
-void Persistence_landscape_on_grid::print_to_file( const char* filename )const
-{
-	std::ofstream out;
-	out.open( filename );
-	
-	//first we store the parameters of the grid:
-	out << grid_min << std::endl << grid_max << std::endl << this->values_of_landscapes.size() << std::endl;
-	
-	//and now in the following lines, the values of this->values_of_landscapes for the following arguments:
-	for ( size_t i = 0 ; i != this->values_of_landscapes.size() ; ++i )
-	{
-		for ( size_t j = 0 ; j != this->values_of_landscapes[i].size() ; ++j )
-		{
-			out << this->values_of_landscapes[i][j] << " ";
-		}
-		out << std::endl;
-	}
-	
-	out.close();
+void Persistence_landscape_on_grid::load_landscape_from_file(const char* filename) {
+  std::ifstream in;
+  in.open(filename);
+  // check if the file exist.
+  if (!in.good()) {
+    std::cerr << "The file : " << filename << " do not exist. The program will now terminate \n";
+    throw "The file from which you are trying to read the persistence landscape do not exist. The program will now terminate \n";
+  }
+
+  size_t number_of_points_in_the_grid = 0;
+  in >> this->grid_min >> this->grid_max >> number_of_points_in_the_grid;
+
+  std::vector<std::vector<double> > v(number_of_points_in_the_grid);
+  std::string line;
+  std::getline(in, line);
+  double number;
+  for (size_t i = 0; i != number_of_points_in_the_grid; ++i) {
+    // read a line of a file and convert it to a vector.
+    std::vector<double> vv;
+    std::getline(in, line);
+    std::istringstream stream(line);
+    while (stream >> number) {
+      vv.push_back(number);
+    }
+    v[i] = vv;
+  }
+  this->values_of_landscapes = v;
+  in.close();
 }
 
-void Persistence_landscape_on_grid::plot( const char* filename, double min_x , double max_x , double min_y , double max_y, size_t from_ , size_t to_  )const
-{		
-    //this program create a gnuplot script file that allows to plot persistence diagram.
-    std::ofstream out;
-
-    std::ostringstream nameSS;
-    nameSS << filename << "_GnuplotScript";
-    std::string nameStr = nameSS.str();
-    out.open( nameStr );
-
-	if ( min_x == max_x )
-	{
-		std::pair<double,double> min_max = compute_minimum_maximum();
-		out << "set xrange [" << this->grid_min << " : " << this->grid_max << "]" << std::endl;
-		out << "set yrange [" << min_max.first << " : " << min_max.second << "]" << std::endl;
-	}
-	else
-	{
-		out << "set xrange [" << min_x << " : " << max_x << "]" << std::endl;
-		out << "set yrange [" << min_y << " : " << max_y << "]" << std::endl;
-	}
-    
-    size_t number_of_nonzero_levels = this->number_of_nonzero_levels();
-    double dx = ( this->grid_max - this->grid_min )/((double)this->values_of_landscapes.size()-1);
-    
-    
-    size_t from = 0;
-    if ( from_ != std::numeric_limits<size_t>::max() )
-    {
-		if ( from_ < number_of_nonzero_levels )
-		{
-			from = from_;
-		}
-		else
-		{
-			return;
-		}
-	}	
-	size_t to = number_of_nonzero_levels;
-	if ( to_ != std::numeric_limits<size_t>::max() )
-    {
-		if ( to_ < number_of_nonzero_levels )
-		{
-			to = to_;
-		}
-	}
-    
-    
-    out << "plot ";    
-    for ( size_t lambda= from ; lambda != to ; ++lambda )
-    {
-        //out << "     '-' using 1:2 title 'l" << lambda << "' with lp";
-        out << "     '-' using 1:2 notitle with lp";
-        if ( lambda+1 != to )
-        {
-            out << ", \\";
-        }
-        out << std::endl;
+void Persistence_landscape_on_grid::print_to_file(const char* filename) const {
+  std::ofstream out;
+  out.open(filename);
+
+  // first we store the parameters of the grid:
+  out << grid_min << std::endl << grid_max << std::endl << this->values_of_landscapes.size() << std::endl;
+
+  // and now in the following lines, the values of this->values_of_landscapes for the following arguments:
+  for (size_t i = 0; i != this->values_of_landscapes.size(); ++i) {
+    for (size_t j = 0; j != this->values_of_landscapes[i].size(); ++j) {
+      out << this->values_of_landscapes[i][j] << " ";
     }
-    
-    for ( size_t lambda = from ; lambda != to ; ++lambda )
-    {
-		double point = this->grid_min;
-        for ( size_t i = 0 ; i != this->values_of_landscapes.size() ; ++i )
-        {
-			double value = 0;
-			if ( this->values_of_landscapes[i].size() > lambda )			
-			{
-				value = this->values_of_landscapes[i][lambda];
-			}
-            out << point << " " << value << std::endl;
-            point += dx;
-        }
-        out << "EOF" << std::endl;
+    out << std::endl;
+  }
+
+  out.close();
+}
+
+void Persistence_landscape_on_grid::plot(const char* filename, double min_x, double max_x, double min_y, double max_y,
+                                         size_t from_, size_t to_) const {
+  // this program create a gnuplot script file that allows to plot persistence diagram.
+  std::ofstream out;
+
+  std::ostringstream nameSS;
+  nameSS << filename << "_GnuplotScript";
+  std::string nameStr = nameSS.str();
+  out.open(nameStr);
+
+  if (min_x == max_x) {
+    std::pair<double, double> min_max = compute_minimum_maximum();
+    out << "set xrange [" << this->grid_min << " : " << this->grid_max << "]" << std::endl;
+    out << "set yrange [" << min_max.first << " : " << min_max.second << "]" << std::endl;
+  } else {
+    out << "set xrange [" << min_x << " : " << max_x << "]" << std::endl;
+    out << "set yrange [" << min_y << " : " << max_y << "]" << std::endl;
+  }
+
+  size_t number_of_nonzero_levels = this->number_of_nonzero_levels();
+  double dx = (this->grid_max - this->grid_min) / ((double)this->values_of_landscapes.size() - 1);
+
+  size_t from = 0;
+  if (from_ != std::numeric_limits<size_t>::max()) {
+    if (from_ < number_of_nonzero_levels) {
+      from = from_;
+    } else {
+      return;
+    }
+  }
+  size_t to = number_of_nonzero_levels;
+  if (to_ != std::numeric_limits<size_t>::max()) {
+    if (to_ < number_of_nonzero_levels) {
+      to = to_;
+    }
+  }
+
+  out << "plot ";
+  for (size_t lambda = from; lambda != to; ++lambda) {
+    // out << "     '-' using 1:2 title 'l" << lambda << "' with lp";
+    out << "     '-' using 1:2 notitle with lp";
+    if (lambda + 1 != to) {
+      out << ", \\";
+    }
+    out << std::endl;
+  }
+
+  for (size_t lambda = from; lambda != to; ++lambda) {
+    double point = this->grid_min;
+    for (size_t i = 0; i != this->values_of_landscapes.size(); ++i) {
+      double value = 0;
+      if (this->values_of_landscapes[i].size() > lambda) {
+        value = this->values_of_landscapes[i][lambda];
+      }
+      out << point << " " << value << std::endl;
+      point += dx;
     }
-    std::cout << "Gnuplot script to visualize persistence diagram written to the file: " << nameStr << ". Type load '" << nameStr << "' in gnuplot to visualize." << std::endl;
+    out << "EOF" << std::endl;
+  }
+  std::cout << "Gnuplot script to visualize persistence diagram written to the file: " << nameStr << ". Type load '"
+            << nameStr << "' in gnuplot to visualize." << std::endl;
 }
 
-template < typename T > 
-Persistence_landscape_on_grid operation_on_pair_of_landscapes_on_grid ( const Persistence_landscape_on_grid& land1 ,  const Persistence_landscape_on_grid& land2 )
-{
-	//first we need to check if the domains are the same:
-	if ( !check_if_defined_on_the_same_domain(land1,land2) )throw "Two grids are not compatible"; 	
-	
-	T oper;
-	Persistence_landscape_on_grid result;
-	result.values_of_landscapes = std::vector< std::vector< double > >( land1.values_of_landscapes.size()  );
-	result.grid_min = land1.grid_min;
-	result.grid_max = land1.grid_max;
-	
-	//now we perform the operations:
-	for ( size_t grid_point = 0 ; grid_point != land1.values_of_landscapes.size() ; ++grid_point )
-	{
-		result.values_of_landscapes[grid_point] = std::vector< double >( std::max( land1.values_of_landscapes[grid_point].size() , land2.values_of_landscapes[grid_point].size() ) );
-		for ( size_t lambda = 0 ; lambda != std::max( land1.values_of_landscapes[grid_point].size() , land2.values_of_landscapes[grid_point].size() ) ; ++lambda )
-		{
-			double value1 = 0;
-			double value2 = 0;
-			if ( lambda < land1.values_of_landscapes[grid_point].size() )value1 = land1.values_of_landscapes[grid_point][lambda];
-			if ( lambda < land2.values_of_landscapes[grid_point].size() )value2 = land2.values_of_landscapes[grid_point][lambda];
-			result.values_of_landscapes[grid_point][lambda] = oper( value1 , value2 );
-		}
-	}
-	
-	return result;
+template <typename T>
+Persistence_landscape_on_grid operation_on_pair_of_landscapes_on_grid(const Persistence_landscape_on_grid& land1,
+                                                                      const Persistence_landscape_on_grid& land2) {
+  // first we need to check if the domains are the same:
+  if (!check_if_defined_on_the_same_domain(land1, land2)) throw "Two grids are not compatible";
+
+  T oper;
+  Persistence_landscape_on_grid result;
+  result.values_of_landscapes = std::vector<std::vector<double> >(land1.values_of_landscapes.size());
+  result.grid_min = land1.grid_min;
+  result.grid_max = land1.grid_max;
+
+  // now we perform the operations:
+  for (size_t grid_point = 0; grid_point != land1.values_of_landscapes.size(); ++grid_point) {
+    result.values_of_landscapes[grid_point] = std::vector<double>(
+        std::max(land1.values_of_landscapes[grid_point].size(), land2.values_of_landscapes[grid_point].size()));
+    for (size_t lambda = 0; lambda != std::max(land1.values_of_landscapes[grid_point].size(),
+                                               land2.values_of_landscapes[grid_point].size());
+         ++lambda) {
+      double value1 = 0;
+      double value2 = 0;
+      if (lambda < land1.values_of_landscapes[grid_point].size())
+        value1 = land1.values_of_landscapes[grid_point][lambda];
+      if (lambda < land2.values_of_landscapes[grid_point].size())
+        value2 = land2.values_of_landscapes[grid_point][lambda];
+      result.values_of_landscapes[grid_point][lambda] = oper(value1, value2);
+    }
+  }
+
+  return result;
 }
 
-Persistence_landscape_on_grid Persistence_landscape_on_grid::multiply_lanscape_by_real_number_not_overwrite( double x )const
-{
-	Persistence_landscape_on_grid result;
-	result.values_of_landscapes = std::vector< std::vector< double > >( this->values_of_landscapes.size()  );
-	result.grid_min = this->grid_min;
-	result.grid_max = this->grid_max;
-	
-	for ( size_t grid_point = 0 ; grid_point != this->values_of_landscapes.size() ; ++grid_point )
-	{
-		result.values_of_landscapes[grid_point] = std::vector< double >( this->values_of_landscapes[grid_point].size() );
-		for ( size_t i = 0 ; i != this->values_of_landscapes[grid_point].size() ; ++i )
-		{
-			result.values_of_landscapes[grid_point][i] = x*this->values_of_landscapes[grid_point][i];
-		}
-	}
-	
-	return result;
+Persistence_landscape_on_grid Persistence_landscape_on_grid::multiply_lanscape_by_real_number_not_overwrite(
+    double x) const {
+  Persistence_landscape_on_grid result;
+  result.values_of_landscapes = std::vector<std::vector<double> >(this->values_of_landscapes.size());
+  result.grid_min = this->grid_min;
+  result.grid_max = this->grid_max;
+
+  for (size_t grid_point = 0; grid_point != this->values_of_landscapes.size(); ++grid_point) {
+    result.values_of_landscapes[grid_point] = std::vector<double>(this->values_of_landscapes[grid_point].size());
+    for (size_t i = 0; i != this->values_of_landscapes[grid_point].size(); ++i) {
+      result.values_of_landscapes[grid_point][i] = x * this->values_of_landscapes[grid_point][i];
+    }
+  }
+
+  return result;
 }
 
-double compute_max_norm_distance_of_landscapes( const Persistence_landscape_on_grid& first, const Persistence_landscape_on_grid& second )
-{
-	double result = 0;
-	
-	//first we need to check if first and second is defined on the same domain"
-	if ( !check_if_defined_on_the_same_domain(first, second) )throw "Two grids are not compatible"; 
-	
-	for ( size_t i = 0 ; i != first.values_of_landscapes.size() ; ++i )
-	{
-		for ( size_t j = 0 ; j != std::min( first.values_of_landscapes[i].size() , second.values_of_landscapes[i].size() ) ; ++j )
-		{
-			if ( result < abs( first.values_of_landscapes[i][j] - second.values_of_landscapes[i][j] ) )
-			{
-				result = abs( first.values_of_landscapes[i][j] - second.values_of_landscapes[i][j] );
-			}
-		}
-		if ( first.values_of_landscapes[i].size() == std::min( first.values_of_landscapes[i].size() , second.values_of_landscapes[i].size() ) )
-		{
-			for ( size_t j = first.values_of_landscapes[i].size() ; j != second.values_of_landscapes[i].size() ; ++j )
-			{
-				if ( result < second.values_of_landscapes[i][j] )result = second.values_of_landscapes[i][j];
-			}
-		}
-		if ( second.values_of_landscapes[i].size() == std::min( first.values_of_landscapes[i].size() , second.values_of_landscapes[i].size() ) )
-		{
-			for ( size_t j = second.values_of_landscapes[i].size() ; j != first.values_of_landscapes[i].size() ; ++j )
-			{
-				if ( result < first.values_of_landscapes[i][j] )result = first.values_of_landscapes[i][j];
-			}
-		}
-	}  
-	return result;
+double compute_max_norm_distance_of_landscapes(const Persistence_landscape_on_grid& first,
+                                               const Persistence_landscape_on_grid& second) {
+  double result = 0;
+
+  // first we need to check if first and second is defined on the same domain"
+  if (!check_if_defined_on_the_same_domain(first, second)) throw "Two grids are not compatible";
+
+  for (size_t i = 0; i != first.values_of_landscapes.size(); ++i) {
+    for (size_t j = 0; j != std::min(first.values_of_landscapes[i].size(), second.values_of_landscapes[i].size());
+         ++j) {
+      if (result < abs(first.values_of_landscapes[i][j] - second.values_of_landscapes[i][j])) {
+        result = abs(first.values_of_landscapes[i][j] - second.values_of_landscapes[i][j]);
+      }
+    }
+    if (first.values_of_landscapes[i].size() ==
+        std::min(first.values_of_landscapes[i].size(), second.values_of_landscapes[i].size())) {
+      for (size_t j = first.values_of_landscapes[i].size(); j != second.values_of_landscapes[i].size(); ++j) {
+        if (result < second.values_of_landscapes[i][j]) result = second.values_of_landscapes[i][j];
+      }
+    }
+    if (second.values_of_landscapes[i].size() ==
+        std::min(first.values_of_landscapes[i].size(), second.values_of_landscapes[i].size())) {
+      for (size_t j = second.values_of_landscapes[i].size(); j != first.values_of_landscapes[i].size(); ++j) {
+        if (result < first.values_of_landscapes[i][j]) result = first.values_of_landscapes[i][j];
+      }
+    }
+  }
+  return result;
 }
 
-}//namespace Persistence_representations
-}//namespace Gudhi
+}  // namespace Persistence_representations
+}  // namespace Gudhi
 
 #endif  // PERSISTENCE_LANDSCAPE_ON_GRID_H_
diff --git a/src/Persistence_representations/include/gudhi/Persistence_vectors.h b/src/Persistence_representations/include/gudhi/Persistence_vectors.h
index 7cfb8e0b..587eb212 100644
--- a/src/Persistence_representations/include/gudhi/Persistence_vectors.h
+++ b/src/Persistence_representations/include/gudhi/Persistence_vectors.h
@@ -20,7 +20,6 @@
  *    along with this program.  If not, see <http://www.gnu.org/licenses/>.
  */
 
-
 #ifndef PERSISTENCE_VECTORS_H_
 #define PERSISTENCE_VECTORS_H_
 
@@ -31,28 +30,21 @@
 #include <limits>
 #include <functional>
 
-//gudhi include
+// gudhi include
 #include <gudhi/read_persistence_from_file.h>
 #include <gudhi/common_persistence_representations.h>
 #include <gudhi/distance_functions.h>
 
-
-namespace Gudhi 
-{
-namespace Persistence_representations 
-{
+namespace Gudhi {
+namespace Persistence_representations {
 
 template <typename T>
-struct Maximum_distance
-{
-    double operator() ( const std::pair< T,T >& f , const std::pair<T,T>& s )
-    {
-        return  std::max( fabs( f.first - s.first ) , fabs( f.second - s.second ) );
-    }
+struct Maximum_distance {
+  double operator()(const std::pair<T, T>& f, const std::pair<T, T>& s) {
+    return std::max(fabs(f.first - s.first), fabs(f.second - s.second));
+  }
 };
 
-
-
 /**
  * \class Vector_distances_in_diagram Persistence_vectors.h gudhi/Persistence_vectors.h
  * \brief A class implementing persistence vectors.
@@ -69,665 +61,579 @@ struct Maximum_distance
  * Real_valued_topological_data, Topological_data_with_averages, Topological_data_with_scalar_product
  **/
 template <typename F>
-class Vector_distances_in_diagram 
-{
-public:
-	/**
-	* The default constructor.  
-	**/
-    Vector_distances_in_diagram(){};
-        
-    /**
-	* The constructor that takes as an input a multiset of persistence intervals (given as vector of birth-death pairs). The second parameter is the desired length of the output vectors. 
-	**/
-    Vector_distances_in_diagram( const std::vector< std::pair< double , double > >& intervals , size_t where_to_cut );
-    
-    /**
-	* The constructor taking as an input a file with birth-death pairs. The second parameter is the desired length of the output vectors. 
-	**/
-    Vector_distances_in_diagram( const char* filename , size_t where_to_cut , unsigned dimension = std::numeric_limits<unsigned>::max() );
-
-	
-	/**
-	 *  Writing to a stream. 
-	**/
-	template <typename K>
-    friend std::ostream& operator << ( std::ostream& out , const Vector_distances_in_diagram<K>& d )
-    {
-        for ( size_t i = 0 ; i != std::min( d.sorted_vector_of_distances.size() , d.where_to_cut) ; ++i )
-        {
-            out << d.sorted_vector_of_distances[i] << " ";
-        }
-        return out;
+class Vector_distances_in_diagram {
+ public:
+  /**
+  * The default constructor.
+  **/
+  Vector_distances_in_diagram(){};
+
+  /**
+      * The constructor that takes as an input a multiset of persistence intervals (given as vector of birth-death
+    *pairs). The second parameter is the desired length of the output vectors.
+      **/
+  Vector_distances_in_diagram(const std::vector<std::pair<double, double> >& intervals, size_t where_to_cut);
+
+  /**
+      * The constructor taking as an input a file with birth-death pairs. The second parameter is the desired length of
+    *the output vectors.
+      **/
+  Vector_distances_in_diagram(const char* filename, size_t where_to_cut,
+                              unsigned dimension = std::numeric_limits<unsigned>::max());
+
+  /**
+   *  Writing to a stream.
+  **/
+  template <typename K>
+  friend std::ostream& operator<<(std::ostream& out, const Vector_distances_in_diagram<K>& d) {
+    for (size_t i = 0; i != std::min(d.sorted_vector_of_distances.size(), d.where_to_cut); ++i) {
+      out << d.sorted_vector_of_distances[i] << " ";
     }
-
-	/**
-	* This procedure gives the value of a vector on a given position.  
-	**/ 
-    inline double vector_in_position( size_t position )const
-    {
-        if ( position >= this->sorted_vector_of_distances.size() )throw("Wrong position in accessing Vector_distances_in_diagram::sorted_vector_of_distances\n");
-        return this->sorted_vector_of_distances[position];
+    return out;
+  }
+
+  /**
+  * This procedure gives the value of a vector on a given position.
+  **/
+  inline double vector_in_position(size_t position) const {
+    if (position >= this->sorted_vector_of_distances.size())
+      throw("Wrong position in accessing Vector_distances_in_diagram::sorted_vector_of_distances\n");
+    return this->sorted_vector_of_distances[position];
+  }
+
+  /**
+   * Return a size of a vector.
+  **/
+  inline size_t size() const { return this->sorted_vector_of_distances.size(); }
+
+  /**
+       * Write a vector to a file.
+      **/
+  void write_to_file(const char* filename) const;
+
+  /**
+      * Write a vector to a file.
+     **/
+  void print_to_file(const char* filename) const { this->write_to_file(filename); }
+
+  /**
+       * Loading a vector to a file.
+      **/
+  void load_from_file(const char* filename);
+
+  /**
+   * Comparison operators:
+  **/
+  bool operator==(const Vector_distances_in_diagram& second) const {
+    if (this->sorted_vector_of_distances.size() != second.sorted_vector_of_distances.size()) return false;
+    for (size_t i = 0; i != this->sorted_vector_of_distances.size(); ++i) {
+      if (!almost_equal(this->sorted_vector_of_distances[i], second.sorted_vector_of_distances[i])) return false;
     }
-
-	/**
-	 * Return a size of a vector. 
-	**/
-    inline size_t size()const{return this->sorted_vector_of_distances.size();}
-    
-    /**
-	 * Write a vector to a file.
-	**/
-    void write_to_file( const char* filename )const;
-    
-     /**
-	 * Write a vector to a file.
-	**/
-    void print_to_file( const char* filename )const
-    {
-		this->write_to_file( filename );
-	}  
-    
-    /**
-	 * Loading a vector to a file.
-	**/
-    void load_from_file( const char* filename );
-    
-    /**
-     * Comparison operators:
-    **/ 
-    bool operator == ( const Vector_distances_in_diagram& second )const
-    {
-		if ( this->sorted_vector_of_distances.size() != second.sorted_vector_of_distances.size() )return false;
-		for ( size_t i = 0 ; i != this->sorted_vector_of_distances.size() ; ++i )
-		{
-			if ( !almost_equal(this->sorted_vector_of_distances[i] , second.sorted_vector_of_distances[i]) )return false;
-		}
-		return true;
-	}
-	
-	bool operator != ( const Vector_distances_in_diagram& second )const
-    {
-		return !( *this == second );
-	}
-    
-   //Implementations of functions for various concepts.
-     /**
-     * Compute projection to real numbers of persistence vector. This function is required by the Real_valued_topological_data concept
-     * At the moment this function is not tested, since it is quite likely to be changed in the future. Given this, when using it, keep in mind that it
-     * will be most likely changed in the next versions.
-    **/
-    double project_to_R( int number_of_function )const;
-    /**
-	 * The function gives the number of possible projections to R. This function is required by the Real_valued_topological_data concept.
-	**/ 
-	size_t number_of_projections_to_R()const
-	{
-		return this->number_of_functions_for_projections_to_reals;
-	}
-    
-    /**
-     * Compute a vectorization of a persistent vectors. It is required in a concept Vectorized_topological_data.
-    **/
-    std::vector<double> vectorize( int number_of_function )const;
-     /**
-	 * This function return the number of functions that allows vectorization of a persistence vector. It is required in a concept Vectorized_topological_data.
-	 **/ 
-	size_t number_of_vectorize_functions()const
-	{
-		return this->number_of_functions_for_vectorization;	
-	}
-    
-    /**
-     * Compute a average of two persistent vectors. This function is required by Topological_data_with_averages concept.
-    **/
-    void compute_average( const std::vector< Vector_distances_in_diagram* >& to_average );
-    
-    /**
-     * Compute a distance of two persistent vectors. This function is required in Topological_data_with_distances concept.
-     * For max norm distance, set power to std::numeric_limits<double>::max()
-    **/
-    double distance( const Vector_distances_in_diagram& second , double power = 1)const;
-    
-    /**
-     * Compute a scalar product of two persistent vectors. This function is required in Topological_data_with_scalar_product concept.
-    **/ 
-    double compute_scalar_product( const Vector_distances_in_diagram& second )const;        
-    //end of implementation of functions needed for concepts.
-    
-    
-    /**
-    * For visualization use output from vectorize and build histograms. 
-    **/
-    std::vector< double > output_for_visualization()const
-    {
-		return this->sorted_vector_of_distances;
-	}
-	
-	
-	/**
-	 * Create a gnuplot script to visualize the data structure. 
-	 **/ 
-	void plot( const char* filename )const
-	{
-		std::stringstream gnuplot_script;
-		gnuplot_script << filename << "_GnuplotScript";
-		std::ofstream out;
-		out.open( gnuplot_script.str().c_str() );
-		out << "set style data histogram" << std::endl;
-		out << "set style histogram cluster gap 1" << std::endl;
-		out << "set style fill solid border -1" << std::endl;
-		out << "plot '-' notitle" << std::endl;    
-		for ( size_t i = 0 ; i != this->sorted_vector_of_distances.size() ; ++i )
-		{
-			out << this->sorted_vector_of_distances[i]  << std::endl;
-		}		
-		out <<std::endl;
-		out.close();
-		std::cout << "To visualize, open gnuplot and type: load \'" << gnuplot_script.str().c_str() << "\'" <<  std::endl;			
-	}
-	
-	/**
-	 * The x-range of the persistence vector. 
-	**/ 
-	std::pair< double , double > get_x_range()const
-	{
-		return std::make_pair( 0 , this->sorted_vector_of_distances.size() );
-	}
-	
-	/**
-	 * The y-range of the persistence vector. 
-	**/ 
-	std::pair< double , double > get_y_range()const
-	{
-		if ( this->sorted_vector_of_distances.size() == 0 )return std::make_pair(0,0);
-		return std::make_pair( this->sorted_vector_of_distances[0] , 0);
-	}
-	
-	//arithmetic operations:		
-	template < typename Operation_type > 
-	friend Vector_distances_in_diagram operation_on_pair_of_vectors( const Vector_distances_in_diagram& first ,  const Vector_distances_in_diagram& second , Operation_type opertion )
-    {
-		Vector_distances_in_diagram result;		
-		//Operation_type operation;		
-		result.sorted_vector_of_distances.reserve(std::max( first.sorted_vector_of_distances.size() , second.sorted_vector_of_distances.size() ) );
-        for ( size_t i = 0 ; i != std::min( first.sorted_vector_of_distances.size() , second.sorted_vector_of_distances.size() ) ; ++i )
-        {
-			result.sorted_vector_of_distances.push_back( opertion( first.sorted_vector_of_distances[i] , second.sorted_vector_of_distances[i]) );
-		}
-		if ( first.sorted_vector_of_distances.size() == std::min( first.sorted_vector_of_distances.size() , second.sorted_vector_of_distances.size() ) )
-		{
-			for ( size_t i = std::min( first.sorted_vector_of_distances.size() , second.sorted_vector_of_distances.size() ) ; 
-			i != std::max( first.sorted_vector_of_distances.size() , second.sorted_vector_of_distances.size() ) ; ++i )
-			{
-				result.sorted_vector_of_distances.push_back( opertion(0,second.sorted_vector_of_distances[i]) );
-			}
-		}
-		else
-		{
-			for ( size_t i = std::min( first.sorted_vector_of_distances.size() , second.sorted_vector_of_distances.size() ) ; 
-			i != std::max( first.sorted_vector_of_distances.size() , second.sorted_vector_of_distances.size() ) ; ++i )
-			{
-				result.sorted_vector_of_distances.push_back( opertion(first.sorted_vector_of_distances[i],0) );
-			}
-		}		
-		return result;
-    }//operation_on_pair_of_vectors
-    
-    /**
-     * This function implements an operation of multiplying Vector_distances_in_diagram by a scalar. 
-    **/ 
-    Vector_distances_in_diagram multiply_by_scalar( double scalar )const 
-    {
-		Vector_distances_in_diagram result;
-		result.sorted_vector_of_distances.reserve( this->sorted_vector_of_distances.size() );
-        for ( size_t i = 0 ; i != this->sorted_vector_of_distances.size() ; ++i )
-        {
-			result.sorted_vector_of_distances.push_back( scalar * this->sorted_vector_of_distances[i] );
-		}		
-		return result;
-    }//multiply_by_scalar
-    
-    
-    
-    /**
-     * This function computes a sum of two objects of a type Vector_distances_in_diagram.
-    **/    
-    friend Vector_distances_in_diagram operator+( const Vector_distances_in_diagram& first , const Vector_distances_in_diagram& second )
-    {
-		return operation_on_pair_of_vectors( first , second , std::plus<double>() );
-	}	
-	/**
-     * This function computes a difference of two objects of a type Vector_distances_in_diagram.
-    **/
-    friend Vector_distances_in_diagram operator-( const Vector_distances_in_diagram& first , const Vector_distances_in_diagram& second )
-    {
-		return operation_on_pair_of_vectors( first , second , std::minus<double>() );
-	}
-	/**
-     * This function computes a product of an object of a type Vector_distances_in_diagram with real number.
-    **/
-	friend Vector_distances_in_diagram operator*( double scalar , const Vector_distances_in_diagram& A )
-	{
-		return A.multiply_by_scalar( scalar );
-	}
-	/**
-     * This function computes a product of an object of a type Vector_distances_in_diagram with real number.
-    **/
-	friend Vector_distances_in_diagram operator*( const Vector_distances_in_diagram& A , double scalar )
-	{
-		return A.multiply_by_scalar( scalar );
-	}
-	/**
-     * This function computes a product of an object of a type Vector_distances_in_diagram with real number.
-    **/
-	Vector_distances_in_diagram operator*( double scalar )
-	{
-		return this->multiply_by_scalar( scalar );
-	}
-	/**
-	 * += operator for Vector_distances_in_diagram.
-	**/ 
-    Vector_distances_in_diagram operator += ( const Vector_distances_in_diagram& rhs )
-    {
-        *this = *this + rhs;
-        return *this;
-    }    
-    /**
-	 * -= operator for Vector_distances_in_diagram.
-	**/ 
-    Vector_distances_in_diagram operator -= ( const Vector_distances_in_diagram& rhs )
-    {
-        *this = *this - rhs;
-        return *this;
+    return true;
+  }
+
+  bool operator!=(const Vector_distances_in_diagram& second) const { return !(*this == second); }
+
+  // Implementations of functions for various concepts.
+  /**
+  * Compute projection to real numbers of persistence vector. This function is required by the
+  *Real_valued_topological_data concept
+  * At the moment this function is not tested, since it is quite likely to be changed in the future. Given this, when
+  *using it, keep in mind that it
+  * will be most likely changed in the next versions.
+ **/
+  double project_to_R(int number_of_function) const;
+  /**
+       * The function gives the number of possible projections to R. This function is required by the
+    *Real_valued_topological_data concept.
+      **/
+  size_t number_of_projections_to_R() const { return this->number_of_functions_for_projections_to_reals; }
+
+  /**
+   * Compute a vectorization of a persistent vectors. It is required in a concept Vectorized_topological_data.
+  **/
+  std::vector<double> vectorize(int number_of_function) const;
+  /**
+      * This function return the number of functions that allows vectorization of a persistence vector. It is required
+    *in a concept Vectorized_topological_data.
+      **/
+  size_t number_of_vectorize_functions() const { return this->number_of_functions_for_vectorization; }
+
+  /**
+   * Compute a average of two persistent vectors. This function is required by Topological_data_with_averages concept.
+  **/
+  void compute_average(const std::vector<Vector_distances_in_diagram*>& to_average);
+
+  /**
+   * Compute a distance of two persistent vectors. This function is required in Topological_data_with_distances concept.
+   * For max norm distance, set power to std::numeric_limits<double>::max()
+  **/
+  double distance(const Vector_distances_in_diagram& second, double power = 1) const;
+
+  /**
+   * Compute a scalar product of two persistent vectors. This function is required in
+   *Topological_data_with_scalar_product concept.
+  **/
+  double compute_scalar_product(const Vector_distances_in_diagram& second) const;
+  // end of implementation of functions needed for concepts.
+
+  /**
+  * For visualization use output from vectorize and build histograms.
+  **/
+  std::vector<double> output_for_visualization() const { return this->sorted_vector_of_distances; }
+
+  /**
+   * Create a gnuplot script to visualize the data structure.
+   **/
+  void plot(const char* filename) const {
+    std::stringstream gnuplot_script;
+    gnuplot_script << filename << "_GnuplotScript";
+    std::ofstream out;
+    out.open(gnuplot_script.str().c_str());
+    out << "set style data histogram" << std::endl;
+    out << "set style histogram cluster gap 1" << std::endl;
+    out << "set style fill solid border -1" << std::endl;
+    out << "plot '-' notitle" << std::endl;
+    for (size_t i = 0; i != this->sorted_vector_of_distances.size(); ++i) {
+      out << this->sorted_vector_of_distances[i] << std::endl;
     }
-    /**
-	 * *= operator for Vector_distances_in_diagram.
-	**/ 
-    Vector_distances_in_diagram operator *= ( double x )
-    {
-        *this = *this*x;
-        return *this;
+    out << std::endl;
+    out.close();
+    std::cout << "To visualize, open gnuplot and type: load \'" << gnuplot_script.str().c_str() << "\'" << std::endl;
+  }
+
+  /**
+   * The x-range of the persistence vector.
+  **/
+  std::pair<double, double> get_x_range() const { return std::make_pair(0, this->sorted_vector_of_distances.size()); }
+
+  /**
+   * The y-range of the persistence vector.
+  **/
+  std::pair<double, double> get_y_range() const {
+    if (this->sorted_vector_of_distances.size() == 0) return std::make_pair(0, 0);
+    return std::make_pair(this->sorted_vector_of_distances[0], 0);
+  }
+
+  // arithmetic operations:
+  template <typename Operation_type>
+  friend Vector_distances_in_diagram operation_on_pair_of_vectors(const Vector_distances_in_diagram& first,
+                                                                  const Vector_distances_in_diagram& second,
+                                                                  Operation_type opertion) {
+    Vector_distances_in_diagram result;
+    // Operation_type operation;
+    result.sorted_vector_of_distances.reserve(
+        std::max(first.sorted_vector_of_distances.size(), second.sorted_vector_of_distances.size()));
+    for (size_t i = 0; i != std::min(first.sorted_vector_of_distances.size(), second.sorted_vector_of_distances.size());
+         ++i) {
+      result.sorted_vector_of_distances.push_back(
+          opertion(first.sorted_vector_of_distances[i], second.sorted_vector_of_distances[i]));
     }
-    /**
-	 * /= operator for Vector_distances_in_diagram.
-	**/ 
-    Vector_distances_in_diagram operator /= ( double x )
-    {
-        if ( x == 0 )throw( "In operator /=, division by 0. Program terminated." );
-        *this = *this * (1/x);
-        return *this;
+    if (first.sorted_vector_of_distances.size() ==
+        std::min(first.sorted_vector_of_distances.size(), second.sorted_vector_of_distances.size())) {
+      for (size_t i = std::min(first.sorted_vector_of_distances.size(), second.sorted_vector_of_distances.size());
+           i != std::max(first.sorted_vector_of_distances.size(), second.sorted_vector_of_distances.size()); ++i) {
+        result.sorted_vector_of_distances.push_back(opertion(0, second.sorted_vector_of_distances[i]));
+      }
+    } else {
+      for (size_t i = std::min(first.sorted_vector_of_distances.size(), second.sorted_vector_of_distances.size());
+           i != std::max(first.sorted_vector_of_distances.size(), second.sorted_vector_of_distances.size()); ++i) {
+        result.sorted_vector_of_distances.push_back(opertion(first.sorted_vector_of_distances[i], 0));
+      }
     }
-    
-
-private:
-    std::vector< std::pair< double , double > > intervals;
-    std::vector< double > sorted_vector_of_distances;
-    size_t number_of_functions_for_vectorization;
-	size_t number_of_functions_for_projections_to_reals;
-	size_t where_to_cut;
-
-    void compute_sorted_vector_of_distances_via_heap( size_t where_to_cut );
-    void compute_sorted_vector_of_distances_via_vector_sorting( size_t where_to_cut );
-    
-    Vector_distances_in_diagram( const std::vector< double >& sorted_vector_of_distances_ ):sorted_vector_of_distances(sorted_vector_of_distances_)
-    {
-		this->set_up_numbers_of_functions_for_vectorization_and_projections_to_reals();
-	}
-    
-    void set_up_numbers_of_functions_for_vectorization_and_projections_to_reals()
-	{		
-		//warning, this function can be only called after filling in the intervals vector.
-		this->number_of_functions_for_vectorization = this->sorted_vector_of_distances.size();
-		this->number_of_functions_for_projections_to_reals = this->sorted_vector_of_distances.size();
-	}
-};
+    return result;
+  }  // operation_on_pair_of_vectors
+
+  /**
+   * This function implements an operation of multiplying Vector_distances_in_diagram by a scalar.
+  **/
+  Vector_distances_in_diagram multiply_by_scalar(double scalar) const {
+    Vector_distances_in_diagram result;
+    result.sorted_vector_of_distances.reserve(this->sorted_vector_of_distances.size());
+    for (size_t i = 0; i != this->sorted_vector_of_distances.size(); ++i) {
+      result.sorted_vector_of_distances.push_back(scalar * this->sorted_vector_of_distances[i]);
+    }
+    return result;
+  }  // multiply_by_scalar
+
+  /**
+   * This function computes a sum of two objects of a type Vector_distances_in_diagram.
+  **/
+  friend Vector_distances_in_diagram operator+(const Vector_distances_in_diagram& first,
+                                               const Vector_distances_in_diagram& second) {
+    return operation_on_pair_of_vectors(first, second, std::plus<double>());
+  }
+  /**
+* This function computes a difference of two objects of a type Vector_distances_in_diagram.
+**/
+  friend Vector_distances_in_diagram operator-(const Vector_distances_in_diagram& first,
+                                               const Vector_distances_in_diagram& second) {
+    return operation_on_pair_of_vectors(first, second, std::minus<double>());
+  }
+  /**
+* This function computes a product of an object of a type Vector_distances_in_diagram with real number.
+**/
+  friend Vector_distances_in_diagram operator*(double scalar, const Vector_distances_in_diagram& A) {
+    return A.multiply_by_scalar(scalar);
+  }
+  /**
+* This function computes a product of an object of a type Vector_distances_in_diagram with real number.
+**/
+  friend Vector_distances_in_diagram operator*(const Vector_distances_in_diagram& A, double scalar) {
+    return A.multiply_by_scalar(scalar);
+  }
+  /**
+* This function computes a product of an object of a type Vector_distances_in_diagram with real number.
+**/
+  Vector_distances_in_diagram operator*(double scalar) { return this->multiply_by_scalar(scalar); }
+  /**
+   * += operator for Vector_distances_in_diagram.
+  **/
+  Vector_distances_in_diagram operator+=(const Vector_distances_in_diagram& rhs) {
+    *this = *this + rhs;
+    return *this;
+  }
+  /**
+       * -= operator for Vector_distances_in_diagram.
+      **/
+  Vector_distances_in_diagram operator-=(const Vector_distances_in_diagram& rhs) {
+    *this = *this - rhs;
+    return *this;
+  }
+  /**
+       * *= operator for Vector_distances_in_diagram.
+      **/
+  Vector_distances_in_diagram operator*=(double x) {
+    *this = *this * x;
+    return *this;
+  }
+  /**
+       * /= operator for Vector_distances_in_diagram.
+      **/
+  Vector_distances_in_diagram operator/=(double x) {
+    if (x == 0) throw("In operator /=, division by 0. Program terminated.");
+    *this = *this * (1 / x);
+    return *this;
+  }
+
+ private:
+  std::vector<std::pair<double, double> > intervals;
+  std::vector<double> sorted_vector_of_distances;
+  size_t number_of_functions_for_vectorization;
+  size_t number_of_functions_for_projections_to_reals;
+  size_t where_to_cut;
+
+  void compute_sorted_vector_of_distances_via_heap(size_t where_to_cut);
+  void compute_sorted_vector_of_distances_via_vector_sorting(size_t where_to_cut);
+
+  Vector_distances_in_diagram(const std::vector<double>& sorted_vector_of_distances_)
+      : sorted_vector_of_distances(sorted_vector_of_distances_) {
+    this->set_up_numbers_of_functions_for_vectorization_and_projections_to_reals();
+  }
 
+  void set_up_numbers_of_functions_for_vectorization_and_projections_to_reals() {
+    // warning, this function can be only called after filling in the intervals vector.
+    this->number_of_functions_for_vectorization = this->sorted_vector_of_distances.size();
+    this->number_of_functions_for_projections_to_reals = this->sorted_vector_of_distances.size();
+  }
+};
 
 template <typename F>
-Vector_distances_in_diagram<F>::Vector_distances_in_diagram( const std::vector< std::pair< double,double > >& intervals_ , size_t where_to_cut_ ):where_to_cut(where_to_cut_)
-{    
-    std::vector< std::pair< double,double > > i( intervals_ );
-    this->intervals = i;
-    //this->compute_sorted_vector_of_distances_via_heap( where_to_cut );
-    this->compute_sorted_vector_of_distances_via_vector_sorting(where_to_cut);
-    this->set_up_numbers_of_functions_for_vectorization_and_projections_to_reals();
+Vector_distances_in_diagram<F>::Vector_distances_in_diagram(const std::vector<std::pair<double, double> >& intervals_,
+                                                            size_t where_to_cut_)
+    : where_to_cut(where_to_cut_) {
+  std::vector<std::pair<double, double> > i(intervals_);
+  this->intervals = i;
+  // this->compute_sorted_vector_of_distances_via_heap( where_to_cut );
+  this->compute_sorted_vector_of_distances_via_vector_sorting(where_to_cut);
+  this->set_up_numbers_of_functions_for_vectorization_and_projections_to_reals();
 }
 
 template <typename F>
-Vector_distances_in_diagram<F>::Vector_distances_in_diagram( const char* filename , size_t where_to_cut , unsigned dimension  ):where_to_cut(where_to_cut)
-{
-    std::vector< std::pair< double , double > > intervals;
-    if ( dimension == std::numeric_limits<unsigned>::max() )
-    {
-        intervals = read_persistence_intervals_in_one_dimension_from_file( filename );
-    }
-    else
-    {
-        intervals = read_persistence_intervals_in_one_dimension_from_file( filename , dimension );
-    }
-    this->intervals = intervals;
-    this->compute_sorted_vector_of_distances_via_heap( where_to_cut );
-    //this->compute_sorted_vector_of_distances_via_vector_sorting( where_to_cut );
-    set_up_numbers_of_functions_for_vectorization_and_projections_to_reals();  
+Vector_distances_in_diagram<F>::Vector_distances_in_diagram(const char* filename, size_t where_to_cut,
+                                                            unsigned dimension)
+    : where_to_cut(where_to_cut) {
+  std::vector<std::pair<double, double> > intervals;
+  if (dimension == std::numeric_limits<unsigned>::max()) {
+    intervals = read_persistence_intervals_in_one_dimension_from_file(filename);
+  } else {
+    intervals = read_persistence_intervals_in_one_dimension_from_file(filename, dimension);
+  }
+  this->intervals = intervals;
+  this->compute_sorted_vector_of_distances_via_heap(where_to_cut);
+  // this->compute_sorted_vector_of_distances_via_vector_sorting( where_to_cut );
+  set_up_numbers_of_functions_for_vectorization_and_projections_to_reals();
 }
 
-template < typename F>
-void Vector_distances_in_diagram<F>::compute_sorted_vector_of_distances_via_heap( size_t where_to_cut )
-{
-
-    bool dbg = false;
-    if ( dbg )
-    {
-        std::cerr << "Here are the intervals : \n";
-        for ( size_t i = 0 ; i != this->intervals.size() ; ++i )
-        {
-            std::cerr << this->intervals[i].first << " , " << this->intervals[i].second <<std::endl;
-        }
-    }       
-	where_to_cut = std::min(where_to_cut , (size_t)(0.5 * this->intervals.size() * ( this->intervals.size() - 1 ) + this->intervals.size()));
-
-    std::vector< double > heap( where_to_cut , std::numeric_limits<int>::max() );
-    std::make_heap (heap.begin(),heap.end());
-    F f;
-
-	//for every pair of points in the diagram, compute the minimum of their distance, and distance of those points from diagonal	
-    for ( size_t i = 0 ; i < this->intervals.size() ; ++i )
-    {
-        for ( size_t j = i+1 ; j < this->intervals.size() ; ++j )
-        {			
-            double value = std::min(
-                                f( this->intervals[i] , this->intervals[j] ),                               
-                                std::min(
-                                        f( this->intervals[i] , std::make_pair( 0.5*(this->intervals[i].first+this->intervals[i].second) , 0.5*(this->intervals[i].first+this->intervals[i].second) ) ),
-                                        f( this->intervals[j] , std::make_pair( 0.5*(this->intervals[j].first+this->intervals[j].second) , 0.5*(this->intervals[j].first+this->intervals[j].second) ) )                                
-                                        )    
-                                );
-
-							if ( dbg )
-							{
-								std::cerr << "Value : " << value <<std::endl;
-								std::cerr << "heap.front() : " << heap.front() <<std::endl;
-								getchar();
-							}
-
-            if ( -value < heap.front() )
-            {
-                if ( dbg ){std::cerr << "Replacing : " << heap.front() << " with : " << -value <<std::endl;getchar();}
-                //remove the first element from the heap
-                std::pop_heap (heap.begin(),heap.end());
-                //heap.pop_back();
-                //and put value there instead:
-                //heap.push_back(-value);
-                heap[ where_to_cut-1 ] = -value;
-                std::push_heap (heap.begin(),heap.end());
-            }
-        }
+template <typename F>
+void Vector_distances_in_diagram<F>::compute_sorted_vector_of_distances_via_heap(size_t where_to_cut) {
+  bool dbg = false;
+  if (dbg) {
+    std::cerr << "Here are the intervals : \n";
+    for (size_t i = 0; i != this->intervals.size(); ++i) {
+      std::cerr << this->intervals[i].first << " , " << this->intervals[i].second << std::endl;
     }
-    
-    //now add distances of all points from diagonal   
-    for ( size_t i = 0 ; i < this->intervals.size() ; ++i )
-    {
-		double value = f( this->intervals[i] , std::make_pair( 0.5*(this->intervals[i].first+this->intervals[i].second) , 0.5*(this->intervals[i].first+this->intervals[i].second) ) );
-		if ( -value < heap.front() )
-            {
-                //remove the first element from the heap
-                std::pop_heap (heap.begin(),heap.end());
-                //heap.pop_back();
-                //and put value there instead:
-                //heap.push_back(-value);
-                heap[ where_to_cut-1 ] = -value;
-                std::push_heap (heap.begin(),heap.end());
-            }
-	}
-	 
-    
-    std::sort_heap (heap.begin(),heap.end());
-    for ( size_t i = 0 ; i != heap.size() ; ++i )
-    {
-        if ( heap[i] == std::numeric_limits<int>::max() )
-        {
-            heap[i] = 0;
-        }
-        else
-        {
-            heap[i] *= -1;
+  }
+  where_to_cut = std::min(
+      where_to_cut, (size_t)(0.5 * this->intervals.size() * (this->intervals.size() - 1) + this->intervals.size()));
+
+  std::vector<double> heap(where_to_cut, std::numeric_limits<int>::max());
+  std::make_heap(heap.begin(), heap.end());
+  F f;
+
+  // for every pair of points in the diagram, compute the minimum of their distance, and distance of those points from
+  // diagonal
+  for (size_t i = 0; i < this->intervals.size(); ++i) {
+    for (size_t j = i + 1; j < this->intervals.size(); ++j) {
+      double value = std::min(
+          f(this->intervals[i], this->intervals[j]),
+          std::min(
+              f(this->intervals[i], std::make_pair(0.5 * (this->intervals[i].first + this->intervals[i].second),
+                                                   0.5 * (this->intervals[i].first + this->intervals[i].second))),
+              f(this->intervals[j], std::make_pair(0.5 * (this->intervals[j].first + this->intervals[j].second),
+                                                   0.5 * (this->intervals[j].first + this->intervals[j].second)))));
+
+      if (dbg) {
+        std::cerr << "Value : " << value << std::endl;
+        std::cerr << "heap.front() : " << heap.front() << std::endl;
+        getchar();
+      }
+
+      if (-value < heap.front()) {
+        if (dbg) {
+          std::cerr << "Replacing : " << heap.front() << " with : " << -value << std::endl;
+          getchar();
         }
+        // remove the first element from the heap
+        std::pop_heap(heap.begin(), heap.end());
+        // heap.pop_back();
+        // and put value there instead:
+        // heap.push_back(-value);
+        heap[where_to_cut - 1] = -value;
+        std::push_heap(heap.begin(), heap.end());
+      }
+    }
+  }
+
+  // now add distances of all points from diagonal
+  for (size_t i = 0; i < this->intervals.size(); ++i) {
+    double value = f(this->intervals[i], std::make_pair(0.5 * (this->intervals[i].first + this->intervals[i].second),
+                                                        0.5 * (this->intervals[i].first + this->intervals[i].second)));
+    if (-value < heap.front()) {
+      // remove the first element from the heap
+      std::pop_heap(heap.begin(), heap.end());
+      // heap.pop_back();
+      // and put value there instead:
+      // heap.push_back(-value);
+      heap[where_to_cut - 1] = -value;
+      std::push_heap(heap.begin(), heap.end());
+    }
+  }
+
+  std::sort_heap(heap.begin(), heap.end());
+  for (size_t i = 0; i != heap.size(); ++i) {
+    if (heap[i] == std::numeric_limits<int>::max()) {
+      heap[i] = 0;
+    } else {
+      heap[i] *= -1;
     }
-    
-    if ( dbg )
-    {
-		std::cerr << "This is the heap after all the operations :\n";
-		for ( size_t i = 0 ; i != heap.size() ; ++i )
-		{
-			std::cout << heap[i] << " ";
-		} 
-		std::cout <<std::endl;
-	} 
-
-    this->sorted_vector_of_distances = heap;
+  }
+
+  if (dbg) {
+    std::cerr << "This is the heap after all the operations :\n";
+    for (size_t i = 0; i != heap.size(); ++i) {
+      std::cout << heap[i] << " ";
+    }
+    std::cout << std::endl;
+  }
+
+  this->sorted_vector_of_distances = heap;
 }
 
+template <typename F>
+void Vector_distances_in_diagram<F>::compute_sorted_vector_of_distances_via_vector_sorting(size_t where_to_cut) {
+  std::vector<double> distances;
+  distances.reserve((size_t)(0.5 * this->intervals.size() * (this->intervals.size() - 1) + this->intervals.size()));
+  F f;
+
+  // for every pair of points in the diagram, compute the minimum of their distance, and distance of those points from
+  // diagonal
+  for (size_t i = 0; i < this->intervals.size(); ++i) {
+    // add distance of i-th point in the diagram from the diagonal to the distances vector
+    distances.push_back(
+        f(this->intervals[i], std::make_pair(0.5 * (this->intervals[i].first + this->intervals[i].second),
+                                             0.5 * (this->intervals[i].first + this->intervals[i].second))));
+    for (size_t j = i + 1; j < this->intervals.size(); ++j) {
+      double value = std::min(
+          f(this->intervals[i], this->intervals[j]),
+          std::min(
+              f(this->intervals[i], std::make_pair(0.5 * (this->intervals[i].first + this->intervals[i].second),
+                                                   0.5 * (this->intervals[i].first + this->intervals[i].second))),
+              f(this->intervals[j], std::make_pair(0.5 * (this->intervals[j].first + this->intervals[j].second),
+                                                   0.5 * (this->intervals[j].first + this->intervals[j].second)))));
+      distances.push_back(value);
+    }
+  }
+  std::sort(distances.begin(), distances.end(), std::greater<double>());
+  if (distances.size() > where_to_cut) distances.resize(where_to_cut);
 
+  this->sorted_vector_of_distances = distances;
+}
 
+// Implementations of functions for various concepts.
+template <typename F>
+double Vector_distances_in_diagram<F>::project_to_R(int number_of_function) const {
+  if ((size_t)number_of_function > this->number_of_functions_for_projections_to_reals)
+    throw "Wrong index of a function in a method Vector_distances_in_diagram<F>::project_to_R";
+  if (number_of_function < 0)
+    throw "Wrong index of a function in a method Vector_distances_in_diagram<F>::project_to_R";
+
+  double result = 0;
+  for (size_t i = 0; i != (size_t)number_of_function; ++i) {
+    result += sorted_vector_of_distances[i];
+  }
+  return result;
+}
 
-template < typename F>
-void Vector_distances_in_diagram<F>::compute_sorted_vector_of_distances_via_vector_sorting( size_t where_to_cut )
-{		
-	std::vector< double > distances;	
-	distances.reserve( (size_t)(0.5 * this->intervals.size() * ( this->intervals.size() - 1 ) + this->intervals.size()) );
-    F f;
-
-	//for every pair of points in the diagram, compute the minimum of their distance, and distance of those points from diagonal	
-    for ( size_t i = 0 ; i < this->intervals.size() ; ++i )
-    {
-		//add distance of i-th point in the diagram from the diagonal to the distances vector
-		distances.push_back( f( this->intervals[i] , std::make_pair( 0.5*(this->intervals[i].first+this->intervals[i].second) , 0.5*(this->intervals[i].first+this->intervals[i].second) ) )  );
-        for ( size_t j = i+1 ; j < this->intervals.size() ; ++j )
-        {
-            double value = std::min(
-                                f( this->intervals[i] , this->intervals[j] ),                               
-                                std::min(
-                                        f( this->intervals[i] , std::make_pair( 0.5*(this->intervals[i].first+this->intervals[i].second) , 0.5*(this->intervals[i].first+this->intervals[i].second) ) ),
-                                        f( this->intervals[j] , std::make_pair( 0.5*(this->intervals[j].first+this->intervals[j].second) , 0.5*(this->intervals[j].first+this->intervals[j].second) ) )                                
-                                        )    
-                                );
-            distances.push_back( value );
-            
-        }
+template <typename F>
+void Vector_distances_in_diagram<F>::compute_average(const std::vector<Vector_distances_in_diagram*>& to_average) {
+  if (to_average.size() == 0) {
+    (*this) = Vector_distances_in_diagram<F>();
+    return;
+  }
+
+  size_t maximal_length_of_vector = 0;
+  for (size_t i = 0; i != to_average.size(); ++i) {
+    if (to_average[i]->sorted_vector_of_distances.size() > maximal_length_of_vector) {
+      maximal_length_of_vector = to_average[i]->sorted_vector_of_distances.size();
     }
-    std::sort( distances.begin() , distances.end() , std::greater<double>() );    
-    if ( distances.size() > where_to_cut )distances.resize( where_to_cut );       
-    
-    this->sorted_vector_of_distances =  distances;
-}
+  }
 
+  std::vector<double> av(maximal_length_of_vector, 0);
+  for (size_t i = 0; i != to_average.size(); ++i) {
+    for (size_t j = 0; j != to_average[i]->sorted_vector_of_distances.size(); ++j) {
+      av[j] += to_average[i]->sorted_vector_of_distances[j];
+    }
+  }
 
+  for (size_t i = 0; i != maximal_length_of_vector; ++i) {
+    av[i] /= (double)to_average.size();
+  }
+  this->sorted_vector_of_distances = av;
+  this->where_to_cut = av.size();
+}
 
-//Implementations of functions for various concepts.  
 template <typename F>
-double Vector_distances_in_diagram<F>::project_to_R( int number_of_function )const
-{
-	if ( (size_t)number_of_function > this->number_of_functions_for_projections_to_reals )throw "Wrong index of a function in a method Vector_distances_in_diagram<F>::project_to_R";
-	if ( number_of_function < 0 )throw "Wrong index of a function in a method Vector_distances_in_diagram<F>::project_to_R";
-	
-	double result = 0;
-	for ( size_t i = 0 ; i != (size_t)number_of_function ; ++i )
-	{
-		result += sorted_vector_of_distances[i];
-	}
-	return result;
+double Vector_distances_in_diagram<F>::distance(const Vector_distances_in_diagram& second_, double power) const {
+  bool dbg = false;
+
+  if (dbg) {
+    std::cerr << "Entering double Vector_distances_in_diagram<F>::distance( const Abs_Topological_data_with_distances* "
+                 "second , double power ) procedure \n";
+    std::cerr << "Power : " << power << std::endl;
+    std::cerr << "This : " << *this << std::endl;
+    std::cerr << "second : " << second_ << std::endl;
+  }
+
+  double result = 0;
+  for (size_t i = 0; i != std::min(this->sorted_vector_of_distances.size(), second_.sorted_vector_of_distances.size());
+       ++i) {
+    if (power == 1) {
+      if (dbg) {
+        std::cerr << "|" << this->sorted_vector_of_distances[i] << " -  " << second_.sorted_vector_of_distances[i]
+                  << " |  : " << fabs(this->sorted_vector_of_distances[i] - second_.sorted_vector_of_distances[i])
+                  << std::endl;
+      }
+      result += fabs(this->sorted_vector_of_distances[i] - second_.sorted_vector_of_distances[i]);
+    } else {
+      if (power < std::numeric_limits<double>::max()) {
+        result += std::pow(fabs(this->sorted_vector_of_distances[i] - second_.sorted_vector_of_distances[i]), power);
+      } else {
+        // max norm
+        if (result < fabs(this->sorted_vector_of_distances[i] - second_.sorted_vector_of_distances[i]))
+          result = fabs(this->sorted_vector_of_distances[i] - second_.sorted_vector_of_distances[i]);
+      }
+      if (dbg) {
+        std::cerr << "| " << this->sorted_vector_of_distances[i] << " - " << second_.sorted_vector_of_distances[i]
+                  << " : " << fabs(this->sorted_vector_of_distances[i] - second_.sorted_vector_of_distances[i])
+                  << std::endl;
+      }
+    }
+  }
+  if (this->sorted_vector_of_distances.size() != second_.sorted_vector_of_distances.size()) {
+    if (this->sorted_vector_of_distances.size() > second_.sorted_vector_of_distances.size()) {
+      for (size_t i = second_.sorted_vector_of_distances.size(); i != this->sorted_vector_of_distances.size(); ++i) {
+        result += fabs(this->sorted_vector_of_distances[i]);
+      }
+    } else {
+      // this->sorted_vector_of_distances.size() < second_.sorted_vector_of_distances.size()
+      for (size_t i = this->sorted_vector_of_distances.size(); i != second_.sorted_vector_of_distances.size(); ++i) {
+        result += fabs(second_.sorted_vector_of_distances[i]);
+      }
+    }
+  }
+
+  if (power != 1) {
+    result = std::pow(result, (1.0 / power));
+  }
+  return result;
 }
 
 template <typename F>
-void Vector_distances_in_diagram<F>::compute_average( const std::vector< Vector_distances_in_diagram* >& to_average )
-{
-	
-	if ( to_average.size() == 0 )
-	{
-		(*this) = Vector_distances_in_diagram<F>();
-		return;
-	}
-	
-	size_t maximal_length_of_vector = 0;
-	for ( size_t i = 0 ; i != to_average.size() ; ++i )
-	{		
-		if ( to_average[i]->sorted_vector_of_distances.size() > maximal_length_of_vector )
-		{
-			maximal_length_of_vector = to_average[i]->sorted_vector_of_distances.size();
-		}
-	}	
-	
-	std::vector< double > av(  maximal_length_of_vector , 0 );
-	for ( size_t i = 0 ; i != to_average.size() ; ++i )
-	{		
-		for ( size_t j = 0  ; j != to_average[i]->sorted_vector_of_distances.size() ; ++j )
-		{
-			av[j] += to_average[i]->sorted_vector_of_distances[j];
-		}
-	}
-	
-	for ( size_t i = 0 ; i != maximal_length_of_vector ; ++i )
-	{
-		av[i] /= (double)to_average.size();
-	}
-	this->sorted_vector_of_distances = av;
-	this->where_to_cut = av.size();
+std::vector<double> Vector_distances_in_diagram<F>::vectorize(int number_of_function) const {
+  if ((size_t)number_of_function > this->number_of_functions_for_vectorization)
+    throw "Wrong index of a function in a method Vector_distances_in_diagram<F>::vectorize";
+  if (number_of_function < 0) throw "Wrong index of a function in a method Vector_distances_in_diagram<F>::vectorize";
+
+  std::vector<double> result(std::min((size_t)number_of_function, this->sorted_vector_of_distances.size()));
+  for (size_t i = 0; i != std::min((size_t)number_of_function, this->sorted_vector_of_distances.size()); ++i) {
+    result[i] = this->sorted_vector_of_distances[i];
+  }
+  return result;
 }
 
 template <typename F>
-double Vector_distances_in_diagram<F>::distance( const Vector_distances_in_diagram& second_ , double power )const
-{
-	bool dbg = false;
-	
-	if ( dbg )
-	{
-		std::cerr << "Entering double Vector_distances_in_diagram<F>::distance( const Abs_Topological_data_with_distances* second , double power ) procedure \n";
-		std::cerr << "Power : " << power << std::endl;
-		std::cerr << "This : " << *this << std::endl;
-		std::cerr << "second : " << second_ << std::endl;
-	}		
-	
-	
-	double result = 0;
-	for ( size_t i = 0 ; i != std::min(this->sorted_vector_of_distances.size(), second_.sorted_vector_of_distances.size())  ; ++i )
-	{
-		if ( power == 1 )
-		{
-			if ( dbg )
-			{
-				std::cerr << "|" << this->sorted_vector_of_distances[i] << " -  " << second_.sorted_vector_of_distances[i] << " |  : " << fabs( this->sorted_vector_of_distances[i] - second_.sorted_vector_of_distances[i] ) <<std::endl;
-			}
-			result += fabs( this->sorted_vector_of_distances[i] - second_.sorted_vector_of_distances[i] );
-		}
-		else
-		{
-			if ( power < std::numeric_limits<double>::max() )
-			{
-				result += std::pow( fabs( this->sorted_vector_of_distances[i] - second_.sorted_vector_of_distances[i] ) , power );
-			}
-			else
-			{
-				// max norm
-				if ( result < fabs( this->sorted_vector_of_distances[i] - second_.sorted_vector_of_distances[i] ) )result = fabs( this->sorted_vector_of_distances[i] - second_.sorted_vector_of_distances[i] );
-			}
-			if ( dbg )
-			{
-				std::cerr << "| " << this->sorted_vector_of_distances[i] << " - " << second_.sorted_vector_of_distances[i]  << " : " << fabs( this->sorted_vector_of_distances[i] - second_.sorted_vector_of_distances[i] ) <<std::endl;
-			}
-		}
-	}
-	if ( this->sorted_vector_of_distances.size() != second_.sorted_vector_of_distances.size() )
-	{
-		if ( this->sorted_vector_of_distances.size() > second_.sorted_vector_of_distances.size() )
-		{
-			for ( size_t i = second_.sorted_vector_of_distances.size() ; i != this->sorted_vector_of_distances.size() ; ++i )			
-			{
-				result += fabs( this->sorted_vector_of_distances[i] );
-			}
-		}
-		else
-		{
-			//this->sorted_vector_of_distances.size() < second_.sorted_vector_of_distances.size()
-			for ( size_t i = this->sorted_vector_of_distances.size() ; i != second_.sorted_vector_of_distances.size() ; ++i )			
-			{
-				result += fabs( second_.sorted_vector_of_distances[i] );
-			}			
-		}
-	}
-	
-	
-	if ( power != 1 )
-	{
-		result = std::pow( result , (1.0/power) );
-	}
-	return result;
-}
-    
-template < typename F>
-std::vector<double> Vector_distances_in_diagram<F>::vectorize( int number_of_function )const
-{
-	if ( (size_t)number_of_function > this->number_of_functions_for_vectorization )throw "Wrong index of a function in a method Vector_distances_in_diagram<F>::vectorize";
-	if ( number_of_function < 0 )throw "Wrong index of a function in a method Vector_distances_in_diagram<F>::vectorize";
-	
-    std::vector< double > result( std::min( (size_t)number_of_function , this->sorted_vector_of_distances.size() ) );
-    for ( size_t i = 0 ; i != std::min( (size_t)number_of_function , this->sorted_vector_of_distances.size() ) ; ++i )
-    {
-        result[i] = this->sorted_vector_of_distances[i];
-    }
-    return result;
-}
+void Vector_distances_in_diagram<F>::write_to_file(const char* filename) const {
+  std::ofstream out;
+  out.open(filename);
 
+  for (size_t i = 0; i != this->sorted_vector_of_distances.size(); ++i) {
+    out << this->sorted_vector_of_distances[i] << " ";
+  }
 
-template < typename F>
-void Vector_distances_in_diagram<F>::write_to_file( const char* filename )const
-{
-	std::ofstream out;
-	out.open( filename );
-	
-	for ( size_t i = 0 ; i != this->sorted_vector_of_distances.size() ; ++i )
-	{
-		out << this->sorted_vector_of_distances[i] << " ";
-	}
-	
-	out.close();
+  out.close();
 }
 
-template < typename F>
-void Vector_distances_in_diagram<F>::load_from_file( const char* filename )
-{
-	std::ifstream in;
-	in.open( filename );
-	//check if the file exist.
-	if ( !in.good() )
-	{
-		std::cerr << "The file : " << filename << " do not exist. The program will now terminate \n";
-		throw "The file from which you are trying to read the persistence landscape do not exist. The program will now terminate \n";
-	}	
-
-	double number;
-	while ( true )
-	{		
-		in >> number;
-		if ( in.eof() )break;
-		this->sorted_vector_of_distances.push_back(number);
-	}	
-	in.close();
+template <typename F>
+void Vector_distances_in_diagram<F>::load_from_file(const char* filename) {
+  std::ifstream in;
+  in.open(filename);
+  // check if the file exist.
+  if (!in.good()) {
+    std::cerr << "The file : " << filename << " do not exist. The program will now terminate \n";
+    throw "The file from which you are trying to read the persistence landscape do not exist. The program will now terminate \n";
+  }
+
+  double number;
+  while (true) {
+    in >> number;
+    if (in.eof()) break;
+    this->sorted_vector_of_distances.push_back(number);
+  }
+  in.close();
 }
 
-template < typename F>
-double Vector_distances_in_diagram<F>::compute_scalar_product( const Vector_distances_in_diagram& second_vector )const
-{
-	double result = 0;
-	for ( size_t i = 0 ; i != std::min(this->sorted_vector_of_distances.size(),second_vector.sorted_vector_of_distances.size()) ; ++i )
-	{
-		result += this->sorted_vector_of_distances[i] * second_vector.sorted_vector_of_distances[i];
-	}
-	return result;
+template <typename F>
+double Vector_distances_in_diagram<F>::compute_scalar_product(const Vector_distances_in_diagram& second_vector) const {
+  double result = 0;
+  for (size_t i = 0;
+       i != std::min(this->sorted_vector_of_distances.size(), second_vector.sorted_vector_of_distances.size()); ++i) {
+    result += this->sorted_vector_of_distances[i] * second_vector.sorted_vector_of_distances[i];
+  }
+  return result;
 }
 
-}//namespace Persistence_representations
-}//namespace Gudhi
-
+}  // namespace Persistence_representations
+}  // namespace Gudhi
 
 #endif  // PERSISTENCE_VECTORS_H_
diff --git a/src/Persistence_representations/include/gudhi/common_persistence_representations.h b/src/Persistence_representations/include/gudhi/common_persistence_representations.h
index f571ca4f..d5c9ece1 100644
--- a/src/Persistence_representations/include/gudhi/common_persistence_representations.h
+++ b/src/Persistence_representations/include/gudhi/common_persistence_representations.h
@@ -23,129 +23,100 @@
 #ifndef COMMON_PERSISTENCE_REPRESENTATIONS_H_
 #define COMMON_PERSISTENCE_REPRESENTATIONS_H_
 
+namespace Gudhi {
+namespace Persistence_representations {
+// this file contain an implementation of some common procedures used in Persistence_representations.
 
-namespace Gudhi
-{
-namespace Persistence_representations
-{
- //this file contain an implementation of some common procedures used in Persistence_representations.
-
- //double epsi = std::numeric_limits<double>::epsilon();
+// double epsi = std::numeric_limits<double>::epsilon();
 double epsi = 0.000005;
 
-
-
-
-
 /**
- *  A procedure used to compare doubles. Typically given two doubles A and B, comparing A == B is not good idea. In this case, we use the procedure almostEqual with the epsi defined at
+ *  A procedure used to compare doubles. Typically given two doubles A and B, comparing A == B is not good idea. In this
+ *case, we use the procedure almostEqual with the epsi defined at
  *  the top of the file. Setting up the epsi gives the user a tolerance on what should be consider equal.
 **/
-inline bool almost_equal( double a , double b )
-{
-    if ( fabs(a-b) < epsi )
-        return true;
-    return false;
+inline bool almost_equal(double a, double b) {
+  if (fabs(a - b) < epsi) return true;
+  return false;
 }
 
-
-
-
-//landscapes
+// landscapes
 /**
  * Extra functions needed in construction of barcodes.
 **/
-double minus_length( std::pair<double,double> a )
-{
-    return a.first-a.second;
-}
-double birth_plus_deaths( std::pair<double,double> a )
-{
-    return a.first+a.second;
-}
-
+double minus_length(std::pair<double, double> a) { return a.first - a.second; }
+double birth_plus_deaths(std::pair<double, double> a) { return a.first + a.second; }
 
-//landscapes
+// landscapes
 /**
- * Given two points in R^2, the procedure compute the parameters A and B of the line y = Ax + B that crosses those two points.
+ * Given two points in R^2, the procedure compute the parameters A and B of the line y = Ax + B that crosses those two
+ *points.
 **/
-std::pair<double,double> compute_parameters_of_a_line( std::pair<double,double> p1 , std::pair<double,double> p2 )
-{
-    double a = (p2.second-p1.second)/( p2.first - p1.first );
-    double b = p1.second - a*p1.first;
-    return std::make_pair(a,b);
+std::pair<double, double> compute_parameters_of_a_line(std::pair<double, double> p1, std::pair<double, double> p2) {
+  double a = (p2.second - p1.second) / (p2.first - p1.first);
+  double b = p1.second - a * p1.first;
+  return std::make_pair(a, b);
 }
 
-//landscapes
+// landscapes
 /**
- * This procedure given two points which lies on the opposite sides of x axis, compute x for which the line connecting those two points crosses x axis.
+ * This procedure given two points which lies on the opposite sides of x axis, compute x for which the line connecting
+ *those two points crosses x axis.
 **/
-double find_zero_of_a_line_segment_between_those_two_points ( std::pair<double,double> p1, std::pair<double,double> p2 )
-{
-    if ( p1.first == p2.first )return p1.first;
-    if ( p1.second*p2.second > 0 )
-    {
-        std::ostringstream errMessage;
-        errMessage <<"In function find_zero_of_a_line_segment_between_those_two_points the arguments are: (" << p1.first << "," << p1.second << ") and (" << p2.first << "," << p2.second << "). There is no zero in line between those two points. Program terminated.";
-        std::string errMessageStr = errMessage.str();
-        const char* err = errMessageStr.c_str();
-        throw(err);
-    }
-    //we assume here, that x \in [ p1.first, p2.first ] and p1 and p2 are points between which we will put the line segment
-    double a = (p2.second - p1.second)/(p2.first - p1.first);
-    double b = p1.second - a*p1.first;
-    return -b/a;
+double find_zero_of_a_line_segment_between_those_two_points(std::pair<double, double> p1,
+                                                            std::pair<double, double> p2) {
+  if (p1.first == p2.first) return p1.first;
+  if (p1.second * p2.second > 0) {
+    std::ostringstream errMessage;
+    errMessage << "In function find_zero_of_a_line_segment_between_those_two_points the arguments are: (" << p1.first
+               << "," << p1.second << ") and (" << p2.first << "," << p2.second
+               << "). There is no zero in line between those two points. Program terminated.";
+    std::string errMessageStr = errMessage.str();
+    const char* err = errMessageStr.c_str();
+    throw(err);
+  }
+  // we assume here, that x \in [ p1.first, p2.first ] and p1 and p2 are points between which we will put the line
+  // segment
+  double a = (p2.second - p1.second) / (p2.first - p1.first);
+  double b = p1.second - a * p1.first;
+  return -b / a;
 }
 
-
-
-//landscapes
+// landscapes
 /**
- * This method provides a comparison of points that is used in construction of persistence landscapes. The ordering is lexicographical for the first coordinate, and reverse-lexicographical for the 
- * second coordinate. 
+ * This method provides a comparison of points that is used in construction of persistence landscapes. The ordering is
+ *lexicographical for the first coordinate, and reverse-lexicographical for the
+ * second coordinate.
 **/
-bool compare_points_sorting( std::pair<double,double> f, std::pair<double,double> s )
-{
-    if ( f.first < s.first )
-    {
+bool compare_points_sorting(std::pair<double, double> f, std::pair<double, double> s) {
+  if (f.first < s.first) {
+    return true;
+  } else {  // f.first >= s.first
+    if (f.first > s.first) {
+      return false;
+    } else {  // f.first == s.first
+      if (f.second > s.second) {
         return true;
+      } else {
+        return false;
+      }
     }
-    else
-    {//f.first >= s.first
-        if ( f.first > s.first )
-        {
-            return false;
-        }
-        else
-        {//f.first == s.first
-            if ( f.second > s.second )
-            {
-                return true;
-            }
-            else
-            {
-                return false;
-            }
-        }
-    }
+  }
 }
 
-
-//landscapes
+// landscapes
 /**
- * This procedure takes two points in R^2 and a double value x. It computes the line parsing through those two points and return the value of that linear function at x.
+ * This procedure takes two points in R^2 and a double value x. It computes the line parsing through those two points
+ *and return the value of that linear function at x.
 **/
-double function_value ( std::pair<double,double> p1, std::pair<double,double> p2 , double x )
-{
-    //we assume here, that x \in [ p1.first, p2.first ] and p1 and p2 are points between which we will put the line segment
-    double a = (p2.second - p1.second)/(p2.first - p1.first);
-    double b = p1.second - a*p1.first;
-    return (a*x+b);
+double function_value(std::pair<double, double> p1, std::pair<double, double> p2, double x) {
+  // we assume here, that x \in [ p1.first, p2.first ] and p1 and p2 are points between which we will put the line
+  // segment
+  double a = (p2.second - p1.second) / (p2.first - p1.first);
+  double b = p1.second - a * p1.first;
+  return (a * x + b);
 }
 
-
-
-
 }  // namespace Persistence_representations
 }  // namespace Gudhi
 
diff --git a/src/Persistence_representations/include/gudhi/read_persistence_from_file.h b/src/Persistence_representations/include/gudhi/read_persistence_from_file.h
index a4884314..39d485a9 100644
--- a/src/Persistence_representations/include/gudhi/read_persistence_from_file.h
+++ b/src/Persistence_representations/include/gudhi/read_persistence_from_file.h
@@ -20,7 +20,6 @@
  *    along with this program.  If not, see <http://www.gnu.org/licenses/>.
  */
 
-
 #ifndef READ_PERSISTENCE_FROM_FILE_H_
 #define READ_PERSISTENCE_FROM_FILE_H_
 
@@ -30,184 +29,148 @@
 #include <vector>
 #include <algorithm>
 
+namespace Gudhi {
+namespace Persistence_representations {
 
+/**
+ * Universal procedure to read files with persistence. It ignores the lines starting from # (treat them as comments).
+ * It reads the fist line which is not a comment and assume that there are some numerical entries over there. The
+ *program assume
+ * that each other line in the file, which is not a comment, have the same number of numerical entries (2, 3 or 4).
+ * If there are two numerical entries per line, then the function assume that they are birth/death coordinates.
+ * If there are three numerical entries per line, then the function assume that they are: dimension and birth/death
+ *coordinates.
+ * If there are four numerical entries per line, then the function assume that they are: the characteristic of a filed
+ *over which
+ * persistence was computed, dimension and birth/death coordinates.
+ * The 'inf' string can appear only as a last element of a line.
+ * The procedure returns vector of persistence pairs.
+**/
+std::vector<std::pair<double, double> > read_persistence_intervals_in_one_dimension_from_file(
+    std::string const& filename, int dimension = -1, double what_to_substitute_for_infinite_bar = -1) {
+  bool dbg = false;
+  std::ifstream in;
+  in.open(filename);
+  // checking if the file exist:
+  if (!in.good()) {
+    std::cerr << "The file : " << filename << " do not exist. The program will now terminate \n";
+    throw "The file from which you are trying to read the persistence landscape do not exist. The program will now terminate \n";
+  }
 
-namespace Gudhi
-{
-namespace Persistence_representations
-{
+  std::string line;
+  std::vector<std::pair<double, double> > barcode;
 
-/**
- * Universal procedure to read files with persistence. It ignores the lines starting from # (treat them as comments). 
- * It reads the fist line which is not a comment and assume that there are some numerical entries over there. The program assume
- * that each other line in the file, which is not a comment, have the same number of numerical entries (2, 3 or 4). 
- * If there are two numerical entries per line, then the function assume that they are birth/death coordinates. 
- * If there are three numerical entries per line, then the function assume that they are: dimension and birth/death coordinates. 
- * If there are four numerical entries per line, then the function assume that they are: the characteristic of a filed over which 
- * persistence was computed, dimension and birth/death coordinates. 
- * The 'inf' string can appear only as a last element of a line. 
- * The procedure returns vector of persistence pairs. 
-**/ 
-std::vector<std::pair<double,double> > read_persistence_intervals_in_one_dimension_from_file(std::string const& filename, int dimension=-1 , double what_to_substitute_for_infinite_bar = -1 )
-{
-	bool dbg = false;
-	std::ifstream in;
-	in.open( filename );
-	//checking if the file exist:
-	if ( !in.good() )
-	{
-		std::cerr << "The file : " << filename << " do not exist. The program will now terminate \n";
-		throw "The file from which you are trying to read the persistence landscape do not exist. The program will now terminate \n";
-	}
-	
-	
-	
+  int number_of_entries_per_line = -1;
 
-	std::string line;
-	std::vector< std::pair<double,double> > barcode;
-	
-	int number_of_entries_per_line = -1;
+  while (!in.eof()) {
+    getline(in, line);
+    if (dbg) std::cerr << "Reading line : " << line << std::endl;
+    if (!(line.length() == 0 || line[0] == '#')) {
+      // If we do not know how many entries per line we have, we check it in below.
+      if (number_of_entries_per_line == -1) {
+        number_of_entries_per_line = 0;
+        std::string line_copy(line);
+        if (line_copy.find("inf") != std::string::npos) {
+          size_t np = line_copy.find("inf");
+          // replace symbols 'inf' in line_copy with white spaces:
+          line_copy[np] = ' ';
+          line_copy[np + 1] = ' ';
+          line_copy[np + 2] = ' ';
+          number_of_entries_per_line = 1;
+        }
+        // check how many entries we have in the line.
+        std::stringstream ss(line_copy);
+        double number;
+        std::vector<double> this_line;
+        while (ss >> number) {
+          this_line.push_back(number);
+        }
+        number_of_entries_per_line += (int)this_line.size();
+        if (dbg) {
+          std::cerr << "number_of_entries_per_line : " << number_of_entries_per_line
+                    << ". This number was obtained by analyzing this line : " << line << std::endl;
+        }
+        if ((number_of_entries_per_line < 2) || (number_of_entries_per_line > 4)) {
+          std::cerr << "The input file you have provided have wrong number of numerical entries per line. The program "
+                       "will now terminate. \n";
+          throw "The input file you have provided have wrong number of numerical entries per line. The program will now terminate. \n";
+        }
+      }
+      // In case there is an 'inf' string in this line, we are dealing with this situation in below.
+      if (line.find("inf") != std::string::npos) {
+        if (dbg) {
+          std::cerr << "This line: " << line << " contains infinite interval. \n";
+        }
+        // first we substitute inf by white spaces:
+        size_t np = line.find("inf");
+        line[np] = ' ';
+        line[np + 1] = ' ';
+        line[np + 2] = ' ';
+        if (what_to_substitute_for_infinite_bar != -1) {
+          double beginn, field, dim;
+          std::stringstream lineSS(line);
+          if (number_of_entries_per_line == 4) lineSS >> field;
+          if (number_of_entries_per_line >= 3) {
+            lineSS >> dim;
+          } else {
+            dim = dimension;
+          }
+          lineSS >> beginn;
+          if (dim == dimension) {
+            if (beginn > what_to_substitute_for_infinite_bar) {
+              barcode.push_back(std::make_pair(what_to_substitute_for_infinite_bar, beginn));
+            } else {
+              barcode.push_back(std::make_pair(beginn, what_to_substitute_for_infinite_bar));
+            }
+            if (dbg) {
+              std::cerr << "this is the line that is going to the output : " << beginn << " , "
+                        << what_to_substitute_for_infinite_bar << std::endl;
+            }
+          }
+        } else {
+          // this is a line with infinity. Since the variable what_to_substitute_for_infinite_bar have not been set up,
+          // it means that this line will be skipped.
+          if (dbg) {
+            std::cerr << "We will skip it \n";
+          }
+        }
+        continue;
+      } else {
+        // Then, we read the content of the line. We know that it do not contain 'inf' substring.
+        std::stringstream lineSS(line);
+        double beginn, endd, field, dim;
+        if (number_of_entries_per_line == 4) lineSS >> field;
+        if (number_of_entries_per_line >= 3) {
+          lineSS >> dim;
+        } else {
+          dim = dimension;
+        }
+        lineSS >> beginn;
+        lineSS >> endd;
+        if (beginn > endd) {
+          std::swap(beginn, endd);
+        }
+        if (dim == dimension) {
+          barcode.push_back(std::make_pair(beginn, endd));
+          if (dbg) {
+            std::cerr << "This is a line that is going to the output : " << beginn << " , " << endd << std::endl;
+          }
+        } else {
+          if ((number_of_entries_per_line == 3) && (dimension == -1)) {
+            barcode.push_back(std::make_pair(beginn, endd));
+          }
+        }
+      }
+    } else {
+      if (dbg) {
+        std::cerr << "This is a comment line \n";
+      }
+    }
+  }
+  in.close();
+  if (dbg) std::cerr << "End of reading \n";
 
-	while (!in.eof())
-	{
-		getline(in,line);
-		if ( dbg )std::cerr << "Reading line : " << line << std::endl;
-		if ( !(line.length() == 0 || line[0] == '#') )
-		{
-			//If we do not know how many entries per line we have, we check it in below.
-			if ( number_of_entries_per_line == -1 )
-			{	
-				number_of_entries_per_line = 0;
-				std::string line_copy(line);			
-				if ( line_copy.find("inf") != std::string::npos )
-				{					
-					size_t np = line_copy.find("inf");
-					//replace symbols 'inf' in line_copy with white spaces:					
-					line_copy[np] = ' ';
-					line_copy[np+1] = ' ';
-					line_copy[np+2] = ' ';		
-					number_of_entries_per_line = 1;			
-				}				
-				//check how many entries we have in the line.				
-				std::stringstream ss( line_copy );
-				double number;
-				std::vector<double> this_line;
-				while ( ss >> number )
-				{
-					this_line.push_back( number );
-				}
-				number_of_entries_per_line += (int)this_line.size();						
-				if ( dbg )
-				{
-					std::cerr << "number_of_entries_per_line : " << number_of_entries_per_line << ". This number was obtained by analyzing this line : " << line << std::endl;
-				}
-				if ( (number_of_entries_per_line < 2) || ( number_of_entries_per_line > 4 ) )
-				{
-					std::cerr << "The input file you have provided have wrong number of numerical entries per line. The program will now terminate. \n";
-					throw "The input file you have provided have wrong number of numerical entries per line. The program will now terminate. \n";
-				}
-			}
-			//In case there is an 'inf' string in this line, we are dealing with this situation in below.
-			if ( line.find("inf") != std::string::npos )
-			{
-				if ( dbg )
-				{
-					std::cerr << "This line: " << line << " contains infinite interval. \n";
-				}
-				//first we substitute inf by white spaces:
-				size_t np = line.find("inf");									
-				line[np] = ' ';
-				line[np+1] = ' ';
-				line[np+2] = ' ';	
-				if ( what_to_substitute_for_infinite_bar != -1 )
-				{
-					double beginn, field, dim;
-					std::stringstream lineSS(line);			
-					if ( number_of_entries_per_line == 4 )lineSS >> field;
-					if ( number_of_entries_per_line >= 3 )
-					{
-						 lineSS >> dim;
-					}
-					else
-					{
-						dim = dimension;
-					}
-					lineSS >> beginn;
-					if ( dim == dimension )
-					{
-						if ( beginn > what_to_substitute_for_infinite_bar )
-						{
-							barcode.push_back( std::make_pair( what_to_substitute_for_infinite_bar , beginn ) );
-						}
-						else
-						{
-							barcode.push_back( std::make_pair( beginn , what_to_substitute_for_infinite_bar ) );
-						}
-						if (dbg)
-						{
-							std::cerr << "this is the line that is going to the output : " << beginn << " , " << what_to_substitute_for_infinite_bar << std::endl;
-						}
-					} 
-				}
-				else
-				{
-					//this is a line with infinity. Since the variable what_to_substitute_for_infinite_bar have not been set up, it means that this line will be skipped. 
-					if ( dbg )
-					{
-						std::cerr << "We will skip it \n";
-					}
-				}
-				continue;
-			}
-			else
-			{
-				//Then, we read the content of the line. We know that it do not contain 'inf' substring.
-				std::stringstream lineSS(line);			
-				double beginn, endd, field, dim;
-				if ( number_of_entries_per_line == 4 )lineSS >> field;
-				if ( number_of_entries_per_line >= 3 )
-				{
-					 lineSS >> dim;
-				}
-				else
-				{
-					dim = dimension;
-				}
-				lineSS >> beginn;
-				lineSS >> endd;
-				if ( beginn > endd )
-				{
-					std::swap(beginn,endd);				
-				}
-				if ( dim == dimension )
-				{ 
-					barcode.push_back( std::make_pair( beginn , endd ) );
-					if (dbg)
-					{
-						std::cerr << "This is a line that is going to the output : " <<  beginn << " , " << endd << std::endl;
-					}
-				}
-				else
-				{
-					if ( (number_of_entries_per_line==3) && (dimension == -1) )
-					{
-						barcode.push_back( std::make_pair( beginn , endd ) );
-					}
-				}
-			}
-		}
-		else
-		{
-			if ( dbg )
-			{
-				std::cerr << "This is a comment line \n";
-			}
-		}
-	}
-	in.close();
-	if ( dbg )std::cerr << "End of reading \n";  
-	
-	return barcode;
+  return barcode;
 }  // read_persistence_intervals_in_one_dimension_from_file
 
 }  // namespace Persistence_representations
diff --git a/src/Persistence_representations/test/persistence_heat_maps_test.cpp b/src/Persistence_representations/test/persistence_heat_maps_test.cpp
index b997382e..48086ba8 100644
--- a/src/Persistence_representations/test/persistence_heat_maps_test.cpp
+++ b/src/Persistence_representations/test/persistence_heat_maps_test.cpp
@@ -20,8 +20,6 @@
  *    along with this program.  If not, see <http://www.gnu.org/licenses/>.
  */
 
-
-
 #define BOOST_TEST_DYN_LINK
 #define BOOST_TEST_MODULE "Persistence_representations"
 #include <boost/test/unit_test.hpp>
@@ -30,365 +28,333 @@
 
 #include <iostream>
 
-
-
 using namespace Gudhi;
 using namespace Gudhi::Persistence_representations;
 
+BOOST_AUTO_TEST_CASE(check_construction_of_heat_maps) {
+  std::vector<std::vector<double> > filter = create_Gaussian_filter(100, 1);
+  Persistence_heat_maps<constant_scaling_function> p("data/file_with_diagram", filter, false, 1000, 0, 1);
+  p.print_to_file("data/persistence_heat_map_from_file_with_diagram");
 
+  Persistence_heat_maps<constant_scaling_function> q;
+  q.load_from_file("data/persistence_heat_map_from_file_with_diagram");
 
-	
-
-BOOST_AUTO_TEST_CASE(check_construction_of_heat_maps) 
-{	
-	std::vector< std::vector<double> > filter = create_Gaussian_filter(100,1);		
-	Persistence_heat_maps<constant_scaling_function> p( "data/file_with_diagram" , filter , false , 1000 , 0 , 1 );
-	p.print_to_file( "data/persistence_heat_map_from_file_with_diagram" );
-	
-	Persistence_heat_maps<constant_scaling_function> q;
-	q.load_from_file( "data/persistence_heat_map_from_file_with_diagram" );	
-		
-	BOOST_CHECK( p == q );
+  BOOST_CHECK(p == q);
 }
 
+BOOST_AUTO_TEST_CASE(check_averages_of_heat_maps) {
+  std::vector<std::vector<double> > filter = create_Gaussian_filter(30, 1);
+  Persistence_heat_maps<constant_scaling_function> p("data/file_with_diagram", filter, false, 1000, 0, 10);
+  Persistence_heat_maps<constant_scaling_function> q("data/file_with_diagram_1", filter, false, 1000, 0, 10);
+  Persistence_heat_maps<constant_scaling_function> r("data/file_with_diagram_2", filter, false, 1000, 0, 10);
 
-BOOST_AUTO_TEST_CASE(check_averages_of_heat_maps) 
-{
-	std::vector< std::vector<double> > filter = create_Gaussian_filter(30,1);	
-	Persistence_heat_maps<constant_scaling_function> p( "data/file_with_diagram" , filter , false , 1000 , 0 , 10 );
-	Persistence_heat_maps<constant_scaling_function> q( "data/file_with_diagram_1" , filter , false , 1000 , 0 , 10 );
-	Persistence_heat_maps<constant_scaling_function> r( "data/file_with_diagram_2" , filter , false , 1000 , 0 , 10 );
-
-	Persistence_heat_maps<constant_scaling_function> av;	
-	av.compute_average( {&p,&q,&r} );
-	
-	Persistence_heat_maps<constant_scaling_function> template_average;
-	template_average.load_from_file( "data/template_average_of_heat_maps" );
-	
-	BOOST_CHECK( av == template_average );
+  Persistence_heat_maps<constant_scaling_function> av;
+  av.compute_average({&p, &q, &r});
+
+  Persistence_heat_maps<constant_scaling_function> template_average;
+  template_average.load_from_file("data/template_average_of_heat_maps");
+
+  BOOST_CHECK(av == template_average);
 }
 
+BOOST_AUTO_TEST_CASE(check_median_of_heat_maps) {
+  std::vector<std::vector<double> > filter = create_Gaussian_filter(30, 1);
+  Persistence_heat_maps<constant_scaling_function> p("data/file_with_diagram", filter, false, 1000, 0, 1);
+  Persistence_heat_maps<constant_scaling_function> q("data/file_with_diagram_1", filter, false, 1000, 0, 1);
+  Persistence_heat_maps<constant_scaling_function> r("data/file_with_diagram_2", filter, false, 1000, 0, 1);
+
+  std::vector<Persistence_heat_maps<constant_scaling_function>*> to_compute_median;
+  to_compute_median.push_back(&p);
+  to_compute_median.push_back(&q);
+  to_compute_median.push_back(&r);
+  Persistence_heat_maps<constant_scaling_function> median;
+  median.compute_median(to_compute_median);
+
+  Persistence_heat_maps<constant_scaling_function> template_median;
+  template_median.load_from_file("data/template_median_of_heat_maps");
 
-BOOST_AUTO_TEST_CASE(check_median_of_heat_maps) 
-{
-	std::vector< std::vector<double> > filter = create_Gaussian_filter(30,1);	
-	Persistence_heat_maps<constant_scaling_function> p( "data/file_with_diagram" , filter , false , 1000 , 0 , 1 );
-	Persistence_heat_maps<constant_scaling_function> q( "data/file_with_diagram_1" , filter , false , 1000 , 0 , 1 );
-	Persistence_heat_maps<constant_scaling_function> r( "data/file_with_diagram_2" , filter , false , 1000 , 0 , 1 );
-	
-	std::vector< Persistence_heat_maps<constant_scaling_function>* > to_compute_median;
-	to_compute_median.push_back( &p );
-	to_compute_median.push_back( &q );
-	to_compute_median.push_back( &r );
-	Persistence_heat_maps<constant_scaling_function> median;	
-	median.compute_median( to_compute_median );
-	
-	Persistence_heat_maps<constant_scaling_function> template_median;
-	template_median.load_from_file( "data/template_median_of_heat_maps" );
-	
-	BOOST_CHECK( median == template_median );	
+  BOOST_CHECK(median == template_median);
 }
 
+BOOST_AUTO_TEST_CASE(check_compute_percentage_of_active_of_heat_maps) {
+  std::vector<std::vector<double> > filter = create_Gaussian_filter(30, 1);
+  Persistence_heat_maps<constant_scaling_function> p("data/file_with_diagram", filter, false, 1000, 0, 1);
+  Persistence_heat_maps<constant_scaling_function> q("data/file_with_diagram_1", filter, false, 1000, 0, 1);
+  Persistence_heat_maps<constant_scaling_function> r("data/file_with_diagram_2", filter, false, 1000, 0, 1);
 
-BOOST_AUTO_TEST_CASE(check_compute_percentage_of_active_of_heat_maps) 
-{
-	std::vector< std::vector<double> > filter = create_Gaussian_filter(30,1);	
-	Persistence_heat_maps<constant_scaling_function> p( "data/file_with_diagram" , filter , false , 1000 , 0 , 1 );
-	Persistence_heat_maps<constant_scaling_function> q( "data/file_with_diagram_1" , filter , false , 1000 , 0 , 1 );
-	Persistence_heat_maps<constant_scaling_function> r( "data/file_with_diagram_2" , filter , false , 1000 , 0 , 1 );
-	
-	std::vector< Persistence_heat_maps<constant_scaling_function>* > to_compute_percentage_of_active;
-	to_compute_percentage_of_active.push_back( &p );
-	to_compute_percentage_of_active.push_back( &q );
-	to_compute_percentage_of_active.push_back( &r );
-	Persistence_heat_maps<constant_scaling_function> percentage_of_active;	
-	percentage_of_active.compute_percentage_of_active( to_compute_percentage_of_active , 0.1 );
-	
-	Persistence_heat_maps<constant_scaling_function> template_percentage_of_active;
-	template_percentage_of_active.load_from_file( "data/template_percentage_of_active_of_heat_maps" );
-	
-	BOOST_CHECK( percentage_of_active == template_percentage_of_active );	
+  std::vector<Persistence_heat_maps<constant_scaling_function>*> to_compute_percentage_of_active;
+  to_compute_percentage_of_active.push_back(&p);
+  to_compute_percentage_of_active.push_back(&q);
+  to_compute_percentage_of_active.push_back(&r);
+  Persistence_heat_maps<constant_scaling_function> percentage_of_active;
+  percentage_of_active.compute_percentage_of_active(to_compute_percentage_of_active, 0.1);
+
+  Persistence_heat_maps<constant_scaling_function> template_percentage_of_active;
+  template_percentage_of_active.load_from_file("data/template_percentage_of_active_of_heat_maps");
+
+  BOOST_CHECK(percentage_of_active == template_percentage_of_active);
+}
+
+BOOST_AUTO_TEST_CASE(check_vectorize_for_heat_maps) {
+  std::vector<std::vector<double> > filter = create_Gaussian_filter(30, 1);
+  Persistence_heat_maps<constant_scaling_function> p("data/file_with_diagram", filter, false, 5, 0, 1);
+
+  std::vector<double> p_vect_template;
+
+  p_vect_template.push_back(0.0606728);
+  p_vect_template.push_back(0.0610023);
+  p_vect_template.push_back(0.0607978);
+  p_vect_template.push_back(0.0600647);
+  p_vect_template.push_back(0.0588224);
+  p_vect_template.push_back(0.0619829);
+  p_vect_template.push_back(0.0623218);
+  p_vect_template.push_back(0.0621152);
+  p_vect_template.push_back(0.0613686);
+  p_vect_template.push_back(0.0601016);
+  p_vect_template.push_back(0.0627679);
+  p_vect_template.push_back(0.0631134);
+  p_vect_template.push_back(0.0629066);
+  p_vect_template.push_back(0.0621528);
+  p_vect_template.push_back(0.0608719);
+  p_vect_template.push_back(0.0630073);
+  p_vect_template.push_back(0.0633564);
+  p_vect_template.push_back(0.0631511);
+  p_vect_template.push_back(0.0623968);
+  p_vect_template.push_back(0.0611132);
+  p_vect_template.push_back(0.0626947);
+  p_vect_template.push_back(0.0630445);
+  p_vect_template.push_back(0.0628425);
+  p_vect_template.push_back(0.0620941);
+  p_vect_template.push_back(0.060819);
+
+  std::vector<double> p_vect = p.vectorize(0);
+  for (size_t i = 0; i != p_vect.size(); ++i) {
+    BOOST_CHECK(almost_equal(p_vect_template[i], p_vect[i]));
+  }
 }
 
-BOOST_AUTO_TEST_CASE(check_vectorize_for_heat_maps) 
-{
-	std::vector< std::vector<double> > filter = create_Gaussian_filter(30,1);	
-	Persistence_heat_maps<constant_scaling_function> p( "data/file_with_diagram" , filter , false , 5 , 0 , 1 );
-	
-	std::vector<double> p_vect_template;
-	
-	p_vect_template.push_back(0.0606728);
-	p_vect_template.push_back(0.0610023); 
-	p_vect_template.push_back(0.0607978 );
-	p_vect_template.push_back(0.0600647 );
-	p_vect_template.push_back(0.0588224 );
-	p_vect_template.push_back(0.0619829 );
-	p_vect_template.push_back(0.0623218 );
-	p_vect_template.push_back(0.0621152 );
-	p_vect_template.push_back(0.0613686 );
-	p_vect_template.push_back(0.0601016 );
-	p_vect_template.push_back(0.0627679 );
-	p_vect_template.push_back(0.0631134 );
-	p_vect_template.push_back(0.0629066 );
-	p_vect_template.push_back(0.0621528 );
-	p_vect_template.push_back(0.0608719 );
-	p_vect_template.push_back(0.0630073 );
-	p_vect_template.push_back(0.0633564 );
-	p_vect_template.push_back(0.0631511 );
-	p_vect_template.push_back(0.0623968 );
-	p_vect_template.push_back(0.0611132 );
-	p_vect_template.push_back(0.0626947 );
-	p_vect_template.push_back(0.0630445 );
-	p_vect_template.push_back(0.0628425 );
-	p_vect_template.push_back(0.0620941 );
-	p_vect_template.push_back(0.060819);
-	
-	std::vector<double> p_vect = p.vectorize(0);
-	for ( size_t i = 0 ; i != p_vect.size() ; ++i )
-	{
-		BOOST_CHECK( almost_equal( p_vect_template[i] , p_vect[i] ) );
-	}	
+BOOST_AUTO_TEST_CASE(check_distance_for_heat_maps) {
+  std::vector<std::vector<double> > filter = create_Gaussian_filter(30, 1);
+  Persistence_heat_maps<constant_scaling_function> p("data/file_with_diagram", filter, false, 1000, 0, 1);
+  Persistence_heat_maps<constant_scaling_function> q("data/file_with_diagram_1", filter, false, 1000, 0, 1);
+  Persistence_heat_maps<constant_scaling_function> r("data/file_with_diagram_2", filter, false, 1000, 0, 1);
+
+  // cerr << p.distance( p ) << endl;
+  // cerr << p.distance( q ) << endl;
+  // cerr << p.distance( r ) << endl;
+  // cerr << q.distance( p ) << endl;
+  // cerr << q.distance( q ) << endl;
+  // cerr << q.distance( r ) << endl;
+  // cerr << r.distance( p ) << endl;
+  // cerr << r.distance( q ) << endl;
+  // cerr << r.distance( r ) << endl;
+  // 0         624.183   415.815
+  // 624.183   0         528.06Z
+  // 415.815   528.066   0
+
+  BOOST_CHECK(fabs(p.distance(p) - 0) < 0.0005);
+  BOOST_CHECK(fabs(p.distance(q) - 624.183) < 0.0005);
+  BOOST_CHECK(fabs(p.distance(r) - 415.815) < 0.0005);
+  BOOST_CHECK(fabs(q.distance(p) - 624.183) < 0.0005);
+  BOOST_CHECK(fabs(q.distance(q) - 0) < 0.0005);
+  BOOST_CHECK(fabs(q.distance(r) - 528.066) < 0.0005);
+  BOOST_CHECK(fabs(r.distance(p) - 415.815) < 0.0005);
+  BOOST_CHECK(fabs(r.distance(q) - 528.066) < 0.0005);
+  BOOST_CHECK(fabs(r.distance(r) - 0) < 0.0005);
 }
 
+BOOST_AUTO_TEST_CASE(check_projections_to_R_for_heat_maps) {
+  std::vector<std::vector<double> > filter = create_Gaussian_filter(30, 1);
+  Persistence_heat_maps<constant_scaling_function> p("data/file_with_diagram", filter, false, 1000, 0, 1);
+  Persistence_heat_maps<constant_scaling_function> q("data/file_with_diagram_1", filter, false, 1000, 0, 1);
+  Persistence_heat_maps<constant_scaling_function> r("data/file_with_diagram_2", filter, false, 1000, 0, 1);
 
-BOOST_AUTO_TEST_CASE(check_distance_for_heat_maps) 
-{
-	std::vector< std::vector<double> > filter = create_Gaussian_filter(30,1);	
-	Persistence_heat_maps<constant_scaling_function> p( "data/file_with_diagram" , filter , false , 1000 , 0 , 1 );
-	Persistence_heat_maps<constant_scaling_function> q( "data/file_with_diagram_1" , filter , false , 1000 , 0 , 1 );
-	Persistence_heat_maps<constant_scaling_function> r( "data/file_with_diagram_2" , filter , false , 1000 , 0 , 1 );
-
-	//cerr << p.distance( p ) << endl;
-	//cerr << p.distance( q ) << endl;
-	//cerr << p.distance( r ) << endl;	
-	//cerr << q.distance( p ) << endl;
-	//cerr << q.distance( q ) << endl;
-	//cerr << q.distance( r ) << endl;	
-	//cerr << r.distance( p ) << endl;
-	//cerr << r.distance( q ) << endl;
-	//cerr << r.distance( r ) << endl;	
-	//0         624.183   415.815
-	//624.183   0         528.06Z
-	//415.815   528.066   0
-
-	BOOST_CHECK( fabs( p.distance( p ) - 0) < 0.0005);
-	BOOST_CHECK( fabs( p.distance( q ) - 624.183)< 0.0005);
-	BOOST_CHECK( fabs( p.distance( r ) - 415.815)< 0.0005);
-	BOOST_CHECK( fabs( q.distance( p ) - 624.183)< 0.0005);
-	BOOST_CHECK( fabs( q.distance( q ) - 0)< 0.0005);
-	BOOST_CHECK( fabs( q.distance( r ) - 528.066)< 0.0005);
-	BOOST_CHECK( fabs( r.distance( p ) - 415.815)< 0.0005);
-	BOOST_CHECK( fabs( r.distance( q ) - 528.066)< 0.0005);
-	BOOST_CHECK( fabs( r.distance( r ) - 0)< 0.0005);
+  // cerr << p.project_to_R(0) << endl;
+  // cerr << q.project_to_R(0) << endl;
+  // cerr << r.project_to_R(0) << endl;
+
+  BOOST_CHECK(fabs(p.project_to_R(0) - 44.3308) < 0.0005);
+  BOOST_CHECK(fabs(q.project_to_R(0) - 650.568) < 0.0005);
+  BOOST_CHECK(fabs(r.project_to_R(0) - 429.287) < 0.0005);
+}
+
+BOOST_AUTO_TEST_CASE(check_scalar_products_for_heat_maps) {
+  std::vector<std::vector<double> > filter = create_Gaussian_filter(30, 1);
+  Persistence_heat_maps<constant_scaling_function> p("data/file_with_diagram", filter, false, 1000, 0, 1);
+  Persistence_heat_maps<constant_scaling_function> q("data/file_with_diagram_1", filter, false, 1000, 0, 1);
+  Persistence_heat_maps<constant_scaling_function> r("data/file_with_diagram_2", filter, false, 1000, 0, 1);
+
+  // cerr << p.compute_scalar_product( p ) << endl;
+  // cerr << p.compute_scalar_product( q ) << endl;
+  // cerr << p.compute_scalar_product( r ) << endl;
+  // cerr << q.compute_scalar_product( p ) << endl;
+  // cerr << q.compute_scalar_product( q ) << endl;
+  // cerr << q.compute_scalar_product( r ) << endl;
+  // cerr << r.compute_scalar_product( p ) << endl;
+  // cerr << r.compute_scalar_product( q ) << endl;
+  // cerr << r.compute_scalar_product( r ) << endl;
+
+  BOOST_CHECK(fabs(p.compute_scalar_product(p) - 0.0345687) < 0.0005);
+  BOOST_CHECK(fabs(p.compute_scalar_product(q) - 0.0509357) < 0.0005);
+  BOOST_CHECK(fabs(p.compute_scalar_product(r) - 0.0375608) < 0.0005);
+  BOOST_CHECK(fabs(q.compute_scalar_product(p) - 0.0509357) < 0.0005);
+  BOOST_CHECK(fabs(q.compute_scalar_product(q) - 1.31293) < 0.0005);
+  BOOST_CHECK(fabs(q.compute_scalar_product(r) - 0.536799) < 0.0005);
+  BOOST_CHECK(fabs(r.compute_scalar_product(p) - 0.0375608) < 0.0005);
+  BOOST_CHECK(fabs(r.compute_scalar_product(q) - 0.536799) < 0.0005);
+  BOOST_CHECK(fabs(r.compute_scalar_product(r) - 0.672907) < 0.0005);
 }
 
+BOOST_AUTO_TEST_CASE(check_arythmetic_operations_for_heat_maps) {
+  std::vector<std::vector<double> > filter = create_Gaussian_filter(30, 1);
+  Persistence_heat_maps<constant_scaling_function> p("data/file_with_diagram", filter, false, 1000, 0, 1);
+  Persistence_heat_maps<constant_scaling_function> q("data/file_with_diagram_1", filter, false, 1000, 0, 1);
 
+  Persistence_heat_maps<constant_scaling_function> sum = p + q;
+  Persistence_heat_maps<constant_scaling_function> difference = p - q;
+  Persistence_heat_maps<constant_scaling_function> multiply_by_scalar = 2 * p;
 
-BOOST_AUTO_TEST_CASE(check_projections_to_R_for_heat_maps) 
-{
-	std::vector< std::vector<double> > filter = create_Gaussian_filter(30,1);	
-	Persistence_heat_maps<constant_scaling_function> p( "data/file_with_diagram" , filter , false , 1000 , 0 , 1 );
-	Persistence_heat_maps<constant_scaling_function> q( "data/file_with_diagram_1" , filter , false , 1000 , 0 , 1 );
-	Persistence_heat_maps<constant_scaling_function> r( "data/file_with_diagram_2" , filter , false , 1000 , 0 , 1 );
+  // sum.print_to_file( "sum" );
+  // difference.print_to_file( "difference" );
+  // multiply_by_scalar.print_to_file( "multiply_by_scalar" );
 
-	//cerr << p.project_to_R(0) << endl;
-	//cerr << q.project_to_R(0) << endl;
-	//cerr << r.project_to_R(0) << endl;
+  Persistence_heat_maps<constant_scaling_function> sum_template;
+  sum_template.load_from_file("data/heat_map_sum");
+  Persistence_heat_maps<constant_scaling_function> difference_template;
+  difference_template.load_from_file("data/heat_map_difference");
+  Persistence_heat_maps<constant_scaling_function> multiply_by_scalar_template;
+  multiply_by_scalar_template.load_from_file("data/heat_map_multiply_by_scalar");
 
-	BOOST_CHECK( fabs( p.project_to_R(0) - 44.3308 )< 0.0005);
-	BOOST_CHECK( fabs( q.project_to_R(0) - 650.568 )< 0.0005);
-	BOOST_CHECK( fabs( r.project_to_R(0) - 429.287 )< 0.0005);
+  BOOST_CHECK(sum == sum_template);
 }
 
+BOOST_AUTO_TEST_CASE(check_distance_of_heat_maps_infinite_power_parameters) {
+  std::vector<std::vector<double> > filter = create_Gaussian_filter(100, 1);
+  Persistence_heat_maps<constant_scaling_function> p("data/file_with_diagram", filter, false, 1000, 0, 1);
 
-BOOST_AUTO_TEST_CASE(check_scalar_products_for_heat_maps) 
-{
-	std::vector< std::vector<double> > filter = create_Gaussian_filter(30,1);	
-	Persistence_heat_maps<constant_scaling_function> p( "data/file_with_diagram" , filter , false , 1000 , 0 , 1 );
-	Persistence_heat_maps<constant_scaling_function> q( "data/file_with_diagram_1" , filter , false , 1000 , 0 , 1 );
-	Persistence_heat_maps<constant_scaling_function> r( "data/file_with_diagram_2" , filter , false , 1000 , 0 , 1 );
-
-	//cerr << p.compute_scalar_product( p ) << endl;
-	//cerr << p.compute_scalar_product( q ) << endl;
-	//cerr << p.compute_scalar_product( r ) << endl;
-	//cerr << q.compute_scalar_product( p ) << endl;
-	//cerr << q.compute_scalar_product( q ) << endl;
-	//cerr << q.compute_scalar_product( r ) << endl;	
-	//cerr << r.compute_scalar_product( p ) << endl;
-	//cerr << r.compute_scalar_product( q ) << endl;
-	//cerr << r.compute_scalar_product( r ) << endl;
-	
-
-	BOOST_CHECK( fabs( p.compute_scalar_product( p ) - 0.0345687 )< 0.0005);
-	BOOST_CHECK( fabs( p.compute_scalar_product( q ) - 0.0509357 )< 0.0005);
-	BOOST_CHECK( fabs( p.compute_scalar_product( r ) - 0.0375608 )< 0.0005);
-	BOOST_CHECK( fabs( q.compute_scalar_product( p ) - 0.0509357 )< 0.0005);
-	BOOST_CHECK( fabs( q.compute_scalar_product( q ) - 1.31293 )< 0.0005);
-	BOOST_CHECK( fabs( q.compute_scalar_product( r ) - 0.536799)< 0.0005);
-	BOOST_CHECK( fabs( r.compute_scalar_product( p ) - 0.0375608)< 0.0005);
-	BOOST_CHECK( fabs( r.compute_scalar_product( q ) - 0.536799)< 0.0005);
-	BOOST_CHECK( fabs( r.compute_scalar_product( r ) - 0.672907)< 0.0005);
-	
-}
+  std::vector<std::vector<double> > filter_2 = create_Gaussian_filter(150, 1);
+  Persistence_heat_maps<constant_scaling_function> q("data/file_with_diagram", filter_2, true, 1000, 0, 1);
 
+  double distance_max_double_parameter = p.distance(q, std::numeric_limits<double>::max());
+  double distance_inf_double_parameter = p.distance(q, std::numeric_limits<double>::infinity());
 
+  // std::cerr << "distance_max_double_parameter: " << distance_max_double_parameter << std::endl;
+  // std::cerr << "distance_inf_double_parameter: " << distance_inf_double_parameter << std::endl;
 
-BOOST_AUTO_TEST_CASE(check_arythmetic_operations_for_heat_maps) 
-{
-	std::vector< std::vector<double> > filter = create_Gaussian_filter(30,1);	
-	Persistence_heat_maps<constant_scaling_function> p( "data/file_with_diagram" , filter , false , 1000 , 0 , 1 );
-	Persistence_heat_maps<constant_scaling_function> q( "data/file_with_diagram_1" , filter , false , 1000 , 0 , 1 );
-	
-	Persistence_heat_maps<constant_scaling_function> sum = p + q;
-	Persistence_heat_maps<constant_scaling_function> difference = p - q;
-	Persistence_heat_maps<constant_scaling_function> multiply_by_scalar = 2*p;
-	
-	//sum.print_to_file( "sum" );
-	//difference.print_to_file( "difference" );
-	//multiply_by_scalar.print_to_file( "multiply_by_scalar" );		
-	
-	Persistence_heat_maps<constant_scaling_function> sum_template;
-	sum_template.load_from_file( "data/heat_map_sum" );
-	Persistence_heat_maps<constant_scaling_function> difference_template;
-	difference_template.load_from_file( "data/heat_map_difference" );
-	Persistence_heat_maps<constant_scaling_function> multiply_by_scalar_template;
-	multiply_by_scalar_template.load_from_file( "data/heat_map_multiply_by_scalar" );
-	
-	BOOST_CHECK( sum == sum_template );	
+  BOOST_CHECK(distance_max_double_parameter == distance_inf_double_parameter);
 }
 
-BOOST_AUTO_TEST_CASE(check_distance_of_heat_maps_infinite_power_parameters) 
-{	
-	std::vector< std::vector<double> > filter = create_Gaussian_filter(100,1);		
-	Persistence_heat_maps<constant_scaling_function> p( "data/file_with_diagram" , filter , false , 1000 , 0 , 1 );
-	
-	std::vector< std::vector<double> > filter_2 = create_Gaussian_filter(150,1);
-	Persistence_heat_maps<constant_scaling_function> q( "data/file_with_diagram" , filter_2 , true , 1000 , 0 , 1 );
-	
-	double distance_max_double_parameter = p.distance( q , std::numeric_limits<double>::max() );
-	double distance_inf_double_parameter = p.distance( q , std::numeric_limits<double>::infinity() );	
-		
-	//std::cerr << "distance_max_double_parameter: " << distance_max_double_parameter << std::endl;
-	//std::cerr << "distance_inf_double_parameter: " << distance_inf_double_parameter << std::endl;
-		
-	BOOST_CHECK( distance_max_double_parameter == distance_inf_double_parameter );
-}
+// Below I am storing the code used to generate tests for that functionality.
+/*
+        std::vector< std::pair< double,double > > intervals;
+        intervals.push_back( std::make_pair(0.5,0.5) );
+        std::vector< std::vector<double> > filter = create_Gaussian_filter(5,1);
+        Persistence_heat_maps p( intervals , filter ,  constant_function, false , 100 , 0 , 1 );
+        p.plot( "heat_map_1" );
 
 
+        std::vector< std::pair< double,double > > intervals2;
+        intervals2.push_back( std::make_pair(7,12) );
+        Persistence_heat_maps q( intervals2 , filter ,  constant_function, false , 100 , 0 , 10 );
+        q.plot( "heat_map_2" );
+*/
+/*
+        std::vector< std::pair< double,double > > intervals;
+        intervals.push_back( std::make_pair(0.5,0.5) );
+        std::vector< std::vector<double> > filter = create_Gaussian_filter(5,1);
+        Persistence_heat_maps p( intervals , filter ,  constant_function, false , 10 , 0 , 1 );
+        p.write_to_file( "aaa" );
+
+        Persistence_heat_maps q;
+        q.load_from_file( "aaa" );
 
+        cerr << ( p == q ) << endl;
+        */
 
-//Below I am storing the code used to generate tests for that functionality.
 /*
-	std::vector< std::pair< double,double > > intervals;
-	intervals.push_back( std::make_pair(0.5,0.5) );	
-	std::vector< std::vector<double> > filter = create_Gaussian_filter(5,1);		
-	Persistence_heat_maps p( intervals , filter ,  constant_function, false , 100 , 0 , 1 );
-	p.plot( "heat_map_1" );
-
-	
-	std::vector< std::pair< double,double > > intervals2;
-	intervals2.push_back( std::make_pair(7,12) );		
-	Persistence_heat_maps q( intervals2 , filter ,  constant_function, false , 100 , 0 , 10 );
-	q.plot( "heat_map_2" );
+        std::vector< std::vector<double> > filter = create_Gaussian_filter(30,1);
+        Persistence_heat_maps p( "file_with_diagram" , filter ,  constant_function, false , 100 , 0 , 1 );
+        p.plot( "heat_map_1" );
 */
-/*
-	std::vector< std::pair< double,double > > intervals;
-	intervals.push_back( std::make_pair(0.5,0.5) );	
-	std::vector< std::vector<double> > filter = create_Gaussian_filter(5,1);		
-	Persistence_heat_maps p( intervals , filter ,  constant_function, false , 10 , 0 , 1 );
-	p.write_to_file( "aaa" );
-	
-	Persistence_heat_maps q;
-	q.load_from_file( "aaa" );
-	
-	cerr << ( p == q ) << endl;
-	*/
 
 /*
-	std::vector< std::vector<double> > filter = create_Gaussian_filter(30,1);		
-	Persistence_heat_maps p( "file_with_diagram" , filter ,  constant_function, false , 100 , 0 , 1 );
-	p.plot( "heat_map_1" );
-*/ 
-	 
-/*   
    //test to construct persistence heat map:
-    std::vector< std::vector<double> > filter = create_Gaussian_filter(100,1);		
-	Persistence_heat_maps p( "file_with_diagram" , filter ,  constant_function, false , 1000 , 0 , 1 );
-	p.print_to_file( "persistence_heat_map_from_file_with_diagram" );
-	
-	Persistence_heat_maps q;
-	q.load_from_file( "persistence_heat_map_from_file_with_diagram" );	
-	
-	cerr << (p == q) << endl;
+    std::vector< std::vector<double> > filter = create_Gaussian_filter(100,1);
+        Persistence_heat_maps p( "file_with_diagram" , filter ,  constant_function, false , 1000 , 0 , 1 );
+        p.print_to_file( "persistence_heat_map_from_file_with_diagram" );
+
+        Persistence_heat_maps q;
+        q.load_from_file( "persistence_heat_map_from_file_with_diagram" );
+
+        cerr << (p == q) << endl;
 */
 /*
-	//test of computations of a mean:
-	std::vector< std::pair< double,double > > intervals;
-	intervals.push_back( std::make_pair(5,5) );	
-	std::vector< std::vector<double> > filter = create_Gaussian_filter(5,1);		
-	Persistence_heat_maps p( intervals , filter ,  constant_function, false , 100 , 0 , 10 );
-	p.plot( "heat_map_1" );
-
-	
-	std::vector< std::pair< double,double > > intervals2;
-	intervals2.push_back( std::make_pair(7,7) );		
-	Persistence_heat_maps q( intervals2 , filter ,  constant_function, false , 100 , 0 , 10 );
-	q.plot( "heat_map_2" );
-	
-	
-	Persistence_heat_maps av;	
-	av.compute_average( { &P , &q } );
-	av.plot( "average" );
+        //test of computations of a mean:
+        std::vector< std::pair< double,double > > intervals;
+        intervals.push_back( std::make_pair(5,5) );
+        std::vector< std::vector<double> > filter = create_Gaussian_filter(5,1);
+        Persistence_heat_maps p( intervals , filter ,  constant_function, false , 100 , 0 , 10 );
+        p.plot( "heat_map_1" );
+
+
+        std::vector< std::pair< double,double > > intervals2;
+        intervals2.push_back( std::make_pair(7,7) );
+        Persistence_heat_maps q( intervals2 , filter ,  constant_function, false , 100 , 0 , 10 );
+        q.plot( "heat_map_2" );
+
+
+        Persistence_heat_maps av;
+        av.compute_average( { &P , &q } );
+        av.plot( "average" );
 */
 
 /*
-	std::vector< std::vector<double> > filter = create_Gaussian_filter(30,1);	
-	Persistence_heat_maps p( "file_with_diagram" , filter ,  constant_function, false , 1000 , 0 , 10 );
-	Persistence_heat_maps q( "file_with_diagram_1" , filter ,  constant_function, false , 1000 , 0 , 10 );
-	Persistence_heat_maps r( "file_with_diagram_2" , filter ,  constant_function, false , 1000 , 0 , 10 );
-	Persistence_heat_maps av;	
-	av.compute_average( {&p,&q,&r} );
-	
-	av.print_to_file( "template_average_of_heat_maps" );
-*/	
+        std::vector< std::vector<double> > filter = create_Gaussian_filter(30,1);
+        Persistence_heat_maps p( "file_with_diagram" , filter ,  constant_function, false , 1000 , 0 , 10 );
+        Persistence_heat_maps q( "file_with_diagram_1" , filter ,  constant_function, false , 1000 , 0 , 10 );
+        Persistence_heat_maps r( "file_with_diagram_2" , filter ,  constant_function, false , 1000 , 0 , 10 );
+        Persistence_heat_maps av;
+        av.compute_average( {&p,&q,&r} );
+
+        av.print_to_file( "template_average_of_heat_maps" );
+*/
 
 /*
-	std::vector< std::pair< double,double > > intervals;
-	intervals.push_back( std::make_pair(5,5) );	
-	std::vector< std::vector<double> > filter = create_Gaussian_filter(5,1);		
-	Persistence_heat_maps p( intervals , filter ,  constant_function, false , 10 , 0 , 10 );
-	p.plot( "heat_map_1" );
-	
-	std::vector< std::pair< double,double > > intervals2;
-	intervals2.push_back( std::make_pair(7,7) );		
-	Persistence_heat_maps q( intervals2 , filter ,  constant_function, false , 10 , 0 , 10 );
-	q.plot( "heat_map_2" );
-	
-	Persistence_heat_maps median;	
-	median.compute_median( {&p,&q} );
-	median.plot( "median" );
+        std::vector< std::pair< double,double > > intervals;
+        intervals.push_back( std::make_pair(5,5) );
+        std::vector< std::vector<double> > filter = create_Gaussian_filter(5,1);
+        Persistence_heat_maps p( intervals , filter ,  constant_function, false , 10 , 0 , 10 );
+        p.plot( "heat_map_1" );
+
+        std::vector< std::pair< double,double > > intervals2;
+        intervals2.push_back( std::make_pair(7,7) );
+        Persistence_heat_maps q( intervals2 , filter ,  constant_function, false , 10 , 0 , 10 );
+        q.plot( "heat_map_2" );
+
+        Persistence_heat_maps median;
+        median.compute_median( {&p,&q} );
+        median.plot( "median" );
 */
 
 /*
-	std::vector< std::vector<double> > filter = create_Gaussian_filter(30,1);	
-	Persistence_heat_maps p( "file_with_diagram" , filter ,  constant_function, false , 1000 , 0 , 1 );
-	Persistence_heat_maps q( "file_with_diagram_1" , filter ,  constant_function, false , 1000 , 0 , 1 );
-	Persistence_heat_maps r( "file_with_diagram_2" , filter ,  constant_function, false , 1000 , 0 , 1 );
-	Persistence_heat_maps median;	
-	median.compute_median( {&p,&q,&r} );	
-	median.print_to_file( "template_median_of_heat_maps" );
+        std::vector< std::vector<double> > filter = create_Gaussian_filter(30,1);
+        Persistence_heat_maps p( "file_with_diagram" , filter ,  constant_function, false , 1000 , 0 , 1 );
+        Persistence_heat_maps q( "file_with_diagram_1" , filter ,  constant_function, false , 1000 , 0 , 1 );
+        Persistence_heat_maps r( "file_with_diagram_2" , filter ,  constant_function, false , 1000 , 0 , 1 );
+        Persistence_heat_maps median;
+        median.compute_median( {&p,&q,&r} );
+        median.print_to_file( "template_median_of_heat_maps" );
 */
 
-
 /*
-	std::vector< std::vector<double> > filter = create_Gaussian_filter(30,1);	
-	Persistence_heat_maps p( "file_with_diagram" , filter ,  constant_function, false , 1000 , 0 , 1 );
-	Persistence_heat_maps q( "file_with_diagram_1" , filter ,  constant_function, false , 1000 , 0 , 1 );
-	Persistence_heat_maps r( "file_with_diagram_2" , filter ,  constant_function, false , 1000 , 0 , 1 );
-	
-	Persistence_heat_maps percentage_of_active;	
-	percentage_of_active.compute_percentage_of_active( {&p,&q,&r} , 0.1 );
-	
-	percentage_of_active.print_to_file( "template_percentage_of_active_of_heat_maps" );
-	//percentage_of_active.plot( "template_percentage_of_active_of_heat_maps" );
+        std::vector< std::vector<double> > filter = create_Gaussian_filter(30,1);
+        Persistence_heat_maps p( "file_with_diagram" , filter ,  constant_function, false , 1000 , 0 , 1 );
+        Persistence_heat_maps q( "file_with_diagram_1" , filter ,  constant_function, false , 1000 , 0 , 1 );
+        Persistence_heat_maps r( "file_with_diagram_2" , filter ,  constant_function, false , 1000 , 0 , 1 );
+
+        Persistence_heat_maps percentage_of_active;
+        percentage_of_active.compute_percentage_of_active( {&p,&q,&r} , 0.1 );
+
+        percentage_of_active.print_to_file( "template_percentage_of_active_of_heat_maps" );
+        //percentage_of_active.plot( "template_percentage_of_active_of_heat_maps" );
 */
diff --git a/src/Persistence_representations/test/persistence_intervals_test.cpp b/src/Persistence_representations/test/persistence_intervals_test.cpp
index 8bad499a..a0580bb8 100644
--- a/src/Persistence_representations/test/persistence_intervals_test.cpp
+++ b/src/Persistence_representations/test/persistence_intervals_test.cpp
@@ -20,8 +20,6 @@
  *    along with this program.  If not, see <http://www.gnu.org/licenses/>.
  */
 
-
-
 #define BOOST_TEST_DYN_LINK
 #define BOOST_TEST_MODULE "Persistence_representations"
 #include <boost/test/unit_test.hpp>
@@ -30,314 +28,275 @@
 
 #include <iostream>
 
-
-
 using namespace Gudhi;
 using namespace Gudhi::Persistence_representations;
 
-
 double epsilon = 0.0000005;
 
+// cout << "Left most end of the interval : " << min_max_.first << std::endl;
+// cout << "Right most end of the interval : " << min_max_.second << std::endl;
+BOOST_AUTO_TEST_CASE(check_min_max_function) {
+  Persistence_intervals p("data/file_with_diagram");
+  std::pair<double, double> min_max_ = p.get_x_range();
 
-	
-
+  // cout << min_max_.first << " " << min_max_.second << std::endl;getchar();
 
-//cout << "Left most end of the interval : " << min_max_.first << std::endl;
-//cout << "Right most end of the interval : " << min_max_.second << std::endl;
-BOOST_AUTO_TEST_CASE(check_min_max_function) 
-{
-	Persistence_intervals p( "data/file_with_diagram" );
-	std::pair<double,double> min_max_ = p.get_x_range();
-	
-	//cout << min_max_.first << " " << min_max_.second << std::endl;getchar();
-	
-	BOOST_CHECK( fabs ( min_max_.first - 0.0290362 ) <= epsilon );
-	BOOST_CHECK( fabs ( min_max_.second - 0.994537 ) <= epsilon );
+  BOOST_CHECK(fabs(min_max_.first - 0.0290362) <= epsilon);
+  BOOST_CHECK(fabs(min_max_.second - 0.994537) <= epsilon);
 }
 
-
-
-
-
-BOOST_AUTO_TEST_CASE(check_length_of_dominant_intervals) 
-{
-	Persistence_intervals p( "data/file_with_diagram" );
-	std::vector<double> dominant_ten_intervals_length = p.length_of_dominant_intervals(10);
-	std::vector< double > dominant_intervals_length;
-	dominant_intervals_length.push_back(0.862625);
-	dominant_intervals_length.push_back(0.800893);
-	dominant_intervals_length.push_back(0.762061);
-	dominant_intervals_length.push_back(0.756501);
-	dominant_intervals_length.push_back(0.729367);
-	dominant_intervals_length.push_back(0.718177);
-	dominant_intervals_length.push_back(0.708395);
-	dominant_intervals_length.push_back(0.702844);
-	dominant_intervals_length.push_back(0.700468);
-	dominant_intervals_length.push_back(0.622177);
-	for ( size_t i = 0 ; i != dominant_ten_intervals_length.size() ; ++i )
-	{
-		BOOST_CHECK( fabs ( dominant_ten_intervals_length[i] - dominant_intervals_length[i] ) <= epsilon );
-	}
+BOOST_AUTO_TEST_CASE(check_length_of_dominant_intervals) {
+  Persistence_intervals p("data/file_with_diagram");
+  std::vector<double> dominant_ten_intervals_length = p.length_of_dominant_intervals(10);
+  std::vector<double> dominant_intervals_length;
+  dominant_intervals_length.push_back(0.862625);
+  dominant_intervals_length.push_back(0.800893);
+  dominant_intervals_length.push_back(0.762061);
+  dominant_intervals_length.push_back(0.756501);
+  dominant_intervals_length.push_back(0.729367);
+  dominant_intervals_length.push_back(0.718177);
+  dominant_intervals_length.push_back(0.708395);
+  dominant_intervals_length.push_back(0.702844);
+  dominant_intervals_length.push_back(0.700468);
+  dominant_intervals_length.push_back(0.622177);
+  for (size_t i = 0; i != dominant_ten_intervals_length.size(); ++i) {
+    BOOST_CHECK(fabs(dominant_ten_intervals_length[i] - dominant_intervals_length[i]) <= epsilon);
+  }
 }
-BOOST_AUTO_TEST_CASE(check_dominant_intervals) 
-{
-	Persistence_intervals p( "data/file_with_diagram" );
-	std::vector< std::pair<double,double> > ten_dominant_intervals = p.dominant_intervals( 10 );
-	
-	std::vector< std::pair<double,double> > templ;
-	templ.push_back( std::pair<double,double>( 0.114718,0.977343) );
-	templ.push_back( std::pair<double,double>( 0.133638,0.93453) );
-	templ.push_back( std::pair<double,double>( 0.104599,0.866659) );
-	templ.push_back( std::pair<double,double>( 0.149798,0.906299) );
-	templ.push_back( std::pair<double,double>( 0.247352,0.976719) );
-	templ.push_back( std::pair<double,double>( 0.192675,0.910852) );
-	templ.push_back( std::pair<double,double>( 0.191836,0.900231) );
-	templ.push_back( std::pair<double,double>( 0.284998,0.987842) );
-	templ.push_back( std::pair<double,double>( 0.294069,0.994537) );
-	templ.push_back( std::pair<double,double>( 0.267421,0.889597) );
-		
-	for ( size_t i = 0 ; i != ten_dominant_intervals.size() ; ++i )
-	{
-		BOOST_CHECK( fabs ( ten_dominant_intervals[i].first - templ[i].first ) <= epsilon );
-		BOOST_CHECK( fabs ( ten_dominant_intervals[i].second - templ[i].second ) <= epsilon );
-	}
+BOOST_AUTO_TEST_CASE(check_dominant_intervals) {
+  Persistence_intervals p("data/file_with_diagram");
+  std::vector<std::pair<double, double> > ten_dominant_intervals = p.dominant_intervals(10);
+
+  std::vector<std::pair<double, double> > templ;
+  templ.push_back(std::pair<double, double>(0.114718, 0.977343));
+  templ.push_back(std::pair<double, double>(0.133638, 0.93453));
+  templ.push_back(std::pair<double, double>(0.104599, 0.866659));
+  templ.push_back(std::pair<double, double>(0.149798, 0.906299));
+  templ.push_back(std::pair<double, double>(0.247352, 0.976719));
+  templ.push_back(std::pair<double, double>(0.192675, 0.910852));
+  templ.push_back(std::pair<double, double>(0.191836, 0.900231));
+  templ.push_back(std::pair<double, double>(0.284998, 0.987842));
+  templ.push_back(std::pair<double, double>(0.294069, 0.994537));
+  templ.push_back(std::pair<double, double>(0.267421, 0.889597));
+
+  for (size_t i = 0; i != ten_dominant_intervals.size(); ++i) {
+    BOOST_CHECK(fabs(ten_dominant_intervals[i].first - templ[i].first) <= epsilon);
+    BOOST_CHECK(fabs(ten_dominant_intervals[i].second - templ[i].second) <= epsilon);
+  }
 }
 
-BOOST_AUTO_TEST_CASE(check_histogram_of_lengths) 
-{
-	Persistence_intervals p( "data/file_with_diagram" );
-	std::vector< size_t > histogram = p.histogram_of_lengths( 10  );
-	std::vector< size_t > template_histogram;
-	template_histogram.push_back(10); 
-	template_histogram.push_back(5); 
-	template_histogram.push_back(3); 
-	template_histogram.push_back(4); 
-	template_histogram.push_back(4); 
-	template_histogram.push_back(3); 
-	template_histogram.push_back(6);
-	template_histogram.push_back(1); 
-	template_histogram.push_back(7);
-	template_histogram.push_back(1); 
-	template_histogram.push_back(1);		
-	for ( size_t i = 0 ; i != histogram.size() ; ++i )
-	{
-		BOOST_CHECK( fabs ( histogram[i] - template_histogram[i] ) <= epsilon );
-	}		
+BOOST_AUTO_TEST_CASE(check_histogram_of_lengths) {
+  Persistence_intervals p("data/file_with_diagram");
+  std::vector<size_t> histogram = p.histogram_of_lengths(10);
+  std::vector<size_t> template_histogram;
+  template_histogram.push_back(10);
+  template_histogram.push_back(5);
+  template_histogram.push_back(3);
+  template_histogram.push_back(4);
+  template_histogram.push_back(4);
+  template_histogram.push_back(3);
+  template_histogram.push_back(6);
+  template_histogram.push_back(1);
+  template_histogram.push_back(7);
+  template_histogram.push_back(1);
+  template_histogram.push_back(1);
+  for (size_t i = 0; i != histogram.size(); ++i) {
+    BOOST_CHECK(fabs(histogram[i] - template_histogram[i]) <= epsilon);
+  }
 }
 
-BOOST_AUTO_TEST_CASE(check_cumulative_histograms_of_lengths) 
-{
-	Persistence_intervals p( "data/file_with_diagram" );
-	std::vector< size_t > cumulative_histogram = p.cumulative_histogram_of_lengths( 10  );
-	std::vector< size_t > template_cumulative_histogram;
-	template_cumulative_histogram.push_back(10); 
-	template_cumulative_histogram.push_back(15); 
-	template_cumulative_histogram.push_back(18);
-	template_cumulative_histogram.push_back(22); 
-	template_cumulative_histogram.push_back(26); 
-	template_cumulative_histogram.push_back(29); 
-	template_cumulative_histogram.push_back(35); 
-	template_cumulative_histogram.push_back(36); 
-	template_cumulative_histogram.push_back(43); 
-	template_cumulative_histogram.push_back(44); 
-	template_cumulative_histogram.push_back(45);
-	
-	for ( size_t i = 0 ; i != cumulative_histogram.size() ; ++i )
-	{
-		BOOST_CHECK( fabs ( cumulative_histogram[i] - template_cumulative_histogram[i] ) <= epsilon );
-	}		
-}	
-BOOST_AUTO_TEST_CASE(check_characteristic_function_of_diagram) 
-{
-	Persistence_intervals p( "data/file_with_diagram" );
-	std::pair<double,double> min_max_ = p.get_x_range();
-	std::vector< double  > char_funct_diag = p.characteristic_function_of_diagram( min_max_.first , min_max_.second );	
-	std::vector< double > template_char_funct_diag;
-	template_char_funct_diag.push_back(	0.370665	);
-	template_char_funct_diag.push_back(	0.84058	);
-	template_char_funct_diag.push_back(	1.24649	);
-	template_char_funct_diag.push_back(	1.3664	);
-	template_char_funct_diag.push_back(	1.34032	);
-	template_char_funct_diag.push_back(	1.31904	);
-	template_char_funct_diag.push_back(	1.14076	);
-	template_char_funct_diag.push_back(	0.991259	);
-	template_char_funct_diag.push_back(	0.800714	);
-	template_char_funct_diag.push_back(	0.0676303	);
-
-	for ( size_t i = 0 ; i != char_funct_diag.size() ; ++i )
-	{
-		//cout << char_funct_diag[i] << std::endl;
-		if ( fabs ( char_funct_diag[i] - template_char_funct_diag[i] ) >= 0.0001  )
-		{
-			std::cout << "Boost test fail  check_characteristic_function_of_diagram : " << std::endl;
-			std::cerr << char_funct_diag[i] << " " << template_char_funct_diag[i] << std::endl;
-			std::cerr << fabs ( char_funct_diag[i] - template_char_funct_diag[i] ) << std::endl;
-			std::cerr << 0.0001 << std::endl;
-			getchar();
-		}
-		BOOST_CHECK( fabs ( char_funct_diag[i] - template_char_funct_diag[i] ) <= 0.0001 );
-	}		
-}	
-
-
-BOOST_AUTO_TEST_CASE(check_cumulative_characteristic_function_of_diagram) 
-{
-	Persistence_intervals p( "data/file_with_diagram" );
-	std::pair<double,double> min_max_ = p.get_x_range();
-	std::vector< double  > cumul_char_funct_diag = p.cumulative_characteristic_function_of_diagram( min_max_.first , min_max_.second );
-	std::vector< double > template_char_funct_diag_cumul;		
-	
-	template_char_funct_diag_cumul.push_back(0.370665);
-	template_char_funct_diag_cumul.push_back(1.21125);
-	template_char_funct_diag_cumul.push_back(2.45774);
-	template_char_funct_diag_cumul.push_back(3.82414);
-	template_char_funct_diag_cumul.push_back(5.16446);
-	template_char_funct_diag_cumul.push_back(6.4835);
-	template_char_funct_diag_cumul.push_back(7.62426);
-	template_char_funct_diag_cumul.push_back(8.61552);
-	template_char_funct_diag_cumul.push_back(9.41623);
-	template_char_funct_diag_cumul.push_back(9.48386);
-
-	for ( size_t i = 0 ; i != cumul_char_funct_diag.size() ; ++i )
-	{		
-		//cout << cumul_char_funct_diag[i] << std::endl;
-		BOOST_CHECK( fabs (cumul_char_funct_diag[i] - template_char_funct_diag_cumul[i] ) <= 0.0001 );
-	}	
+BOOST_AUTO_TEST_CASE(check_cumulative_histograms_of_lengths) {
+  Persistence_intervals p("data/file_with_diagram");
+  std::vector<size_t> cumulative_histogram = p.cumulative_histogram_of_lengths(10);
+  std::vector<size_t> template_cumulative_histogram;
+  template_cumulative_histogram.push_back(10);
+  template_cumulative_histogram.push_back(15);
+  template_cumulative_histogram.push_back(18);
+  template_cumulative_histogram.push_back(22);
+  template_cumulative_histogram.push_back(26);
+  template_cumulative_histogram.push_back(29);
+  template_cumulative_histogram.push_back(35);
+  template_cumulative_histogram.push_back(36);
+  template_cumulative_histogram.push_back(43);
+  template_cumulative_histogram.push_back(44);
+  template_cumulative_histogram.push_back(45);
+
+  for (size_t i = 0; i != cumulative_histogram.size(); ++i) {
+    BOOST_CHECK(fabs(cumulative_histogram[i] - template_cumulative_histogram[i]) <= epsilon);
+  }
 }
-
-
-BOOST_AUTO_TEST_CASE(check_compute_persistent_betti_numbers) 
-{
-	Persistence_intervals p( "data/file_with_diagram" );
-	std::vector< std::pair< double , double > > pbns;
-	pbns.push_back(std::pair<double,double>(	0.0290362,1	));
-	pbns.push_back(std::pair<double,double>(	0.0307676,2	));
-	pbns.push_back(std::pair<double,double>(	0.0366312,3	));
-	pbns.push_back(std::pair<double,double>(	0.0544614,4	));
-	pbns.push_back(std::pair<double,double>(	0.0920033,5	));
-	pbns.push_back(std::pair<double,double>(	0.104599,6	));
-	pbns.push_back(std::pair<double,double>(	0.114718,7	));
-	pbns.push_back(std::pair<double,double>(	0.117379,8	));
-	pbns.push_back(std::pair<double,double>(	0.123493,9	));
-	pbns.push_back(std::pair<double,double>(	0.133638,10	));
-	pbns.push_back(std::pair<double,double>(	0.137798,9	));
-	pbns.push_back(std::pair<double,double>(	0.149798,10	));
-	pbns.push_back(std::pair<double,double>(	0.155421,11	));
-	pbns.push_back(std::pair<double,double>(	0.158443,12	));
-	pbns.push_back(std::pair<double,double>(	0.176956,13	));
-	pbns.push_back(std::pair<double,double>(	0.183234,12	));
-	pbns.push_back(std::pair<double,double>(	0.191069,13	));
-	pbns.push_back(std::pair<double,double>(	0.191333,14	));
-	pbns.push_back(std::pair<double,double>(	0.191836,15	));
-	pbns.push_back(std::pair<double,double>(	0.192675,16	));
-	pbns.push_back(std::pair<double,double>(	0.208564,17	));
-	pbns.push_back(std::pair<double,double>(	0.218425,18	));
-	pbns.push_back(std::pair<double,double>(	0.219902,17	));
-	pbns.push_back(std::pair<double,double>(	0.23233,16	));
-	pbns.push_back(std::pair<double,double>(	0.234558,17	));
-	pbns.push_back(std::pair<double,double>(	0.237166,16	));
-	pbns.push_back(std::pair<double,double>(	0.247352,17	));
-	pbns.push_back(std::pair<double,double>(	0.267421,18	));
-	pbns.push_back(std::pair<double,double>(	0.268093,19	));
-	pbns.push_back(std::pair<double,double>(	0.278734,18	));
-	pbns.push_back(std::pair<double,double>(	0.284722,19	));
-	pbns.push_back(std::pair<double,double>(	0.284998,20	));
-	pbns.push_back(std::pair<double,double>(	0.294069,21	));
-	pbns.push_back(std::pair<double,double>(	0.306293,22	));
-	pbns.push_back(std::pair<double,double>(	0.322361,21	));
-	pbns.push_back(std::pair<double,double>(	0.323152,22	));
-	pbns.push_back(std::pair<double,double>(	0.371021,23	));
-	pbns.push_back(std::pair<double,double>(	0.372395,24	));
-	pbns.push_back(std::pair<double,double>(	0.387744,25	));
-	pbns.push_back(std::pair<double,double>(	0.435537,26	));
-	pbns.push_back(std::pair<double,double>(	0.462911,25	));
-	pbns.push_back(std::pair<double,double>(	0.483569,26	));
-	pbns.push_back(std::pair<double,double>(	0.489209,25	));
-	pbns.push_back(std::pair<double,double>(	0.517115,24	));
-	pbns.push_back(std::pair<double,double>(	0.522197,23	));
-	pbns.push_back(std::pair<double,double>(	0.532665,22	));
-	pbns.push_back(std::pair<double,double>(	0.545262,23	));
-	pbns.push_back(std::pair<double,double>(	0.587227,22	));
-	pbns.push_back(std::pair<double,double>(	0.593036,23	));
-	pbns.push_back(std::pair<double,double>(	0.602647,24	));
-	pbns.push_back(std::pair<double,double>(	0.605044,25	));
-	pbns.push_back(std::pair<double,double>(	0.621962,24	));
-	pbns.push_back(std::pair<double,double>(	0.629449,23	));
-	pbns.push_back(std::pair<double,double>(	0.636719,22	));
-	pbns.push_back(std::pair<double,double>(	0.64957,21	));
-	pbns.push_back(std::pair<double,double>(	0.650781,22	));
-	pbns.push_back(std::pair<double,double>(	0.654951,23	));
-	pbns.push_back(std::pair<double,double>(	0.683489,24	));
-	pbns.push_back(std::pair<double,double>(	0.687172,23	));
-	pbns.push_back(std::pair<double,double>(	0.69703,22	));
-	pbns.push_back(std::pair<double,double>(	0.701174,21	));
-	pbns.push_back(std::pair<double,double>(	0.717623,22	));
-	pbns.push_back(std::pair<double,double>(	0.722023,21	));
-	pbns.push_back(std::pair<double,double>(	0.722298,20	));
-	pbns.push_back(std::pair<double,double>(	0.725347,19	));
-	pbns.push_back(std::pair<double,double>(	0.73071,18	));
-	pbns.push_back(std::pair<double,double>(	0.758355,17	));
-	pbns.push_back(std::pair<double,double>(	0.770913,18	));
-	pbns.push_back(std::pair<double,double>(	0.790833,17	));
-	pbns.push_back(std::pair<double,double>(	0.821211,16	));
-	pbns.push_back(std::pair<double,double>(	0.849305,17	));
-	pbns.push_back(std::pair<double,double>(	0.853669,16	));
-	pbns.push_back(std::pair<double,double>(	0.866659,15	));
-	pbns.push_back(std::pair<double,double>(	0.872896,16	));
-	pbns.push_back(std::pair<double,double>(	0.889597,15	));
-	pbns.push_back(std::pair<double,double>(	0.900231,14	));
-	pbns.push_back(std::pair<double,double>(	0.903847,13	));
-	pbns.push_back(std::pair<double,double>(	0.906299,12	));
-	pbns.push_back(std::pair<double,double>(	0.910852,11	));
-	pbns.push_back(std::pair<double,double>(	0.93453,10	));
-	pbns.push_back(std::pair<double,double>(	0.944757,9	));
-	pbns.push_back(std::pair<double,double>(	0.947812,8	));
-	pbns.push_back(std::pair<double,double>(	0.959154,7	));
-	pbns.push_back(std::pair<double,double>(	0.975654,6	));
-	pbns.push_back(std::pair<double,double>(	0.976719,5	));
-	pbns.push_back(std::pair<double,double>(	0.977343,4	));
-	pbns.push_back(std::pair<double,double>(	0.980129,3	));
-	pbns.push_back(std::pair<double,double>(	0.987842,2	));
-	pbns.push_back(std::pair<double,double>(	0.990127,1	));
-	pbns.push_back(std::pair<double,double>(	0.994537,0	));
-
-
-
-
-	std::vector< std::pair< double , size_t > > pbns_new = p.compute_persistent_betti_numbers();	
-	for ( size_t i = 0 ; i != pbns.size() ; ++i )
-	{
-		//cout << pbns_new[i].first << "," << pbns_new[i].second << std::endl;
-		BOOST_CHECK( fabs ( pbns[i].first - pbns_new[i].first ) <= epsilon );		
-		BOOST_CHECK( fabs ( pbns[i].second - pbns_new[i].second ) <= epsilon );
-	}
+BOOST_AUTO_TEST_CASE(check_characteristic_function_of_diagram) {
+  Persistence_intervals p("data/file_with_diagram");
+  std::pair<double, double> min_max_ = p.get_x_range();
+  std::vector<double> char_funct_diag = p.characteristic_function_of_diagram(min_max_.first, min_max_.second);
+  std::vector<double> template_char_funct_diag;
+  template_char_funct_diag.push_back(0.370665);
+  template_char_funct_diag.push_back(0.84058);
+  template_char_funct_diag.push_back(1.24649);
+  template_char_funct_diag.push_back(1.3664);
+  template_char_funct_diag.push_back(1.34032);
+  template_char_funct_diag.push_back(1.31904);
+  template_char_funct_diag.push_back(1.14076);
+  template_char_funct_diag.push_back(0.991259);
+  template_char_funct_diag.push_back(0.800714);
+  template_char_funct_diag.push_back(0.0676303);
+
+  for (size_t i = 0; i != char_funct_diag.size(); ++i) {
+    // cout << char_funct_diag[i] << std::endl;
+    if (fabs(char_funct_diag[i] - template_char_funct_diag[i]) >= 0.0001) {
+      std::cout << "Boost test fail  check_characteristic_function_of_diagram : " << std::endl;
+      std::cerr << char_funct_diag[i] << " " << template_char_funct_diag[i] << std::endl;
+      std::cerr << fabs(char_funct_diag[i] - template_char_funct_diag[i]) << std::endl;
+      std::cerr << 0.0001 << std::endl;
+      getchar();
+    }
+    BOOST_CHECK(fabs(char_funct_diag[i] - template_char_funct_diag[i]) <= 0.0001);
+  }
 }
 
-
-
-BOOST_AUTO_TEST_CASE(check_k_n_n) 
-{
-	Persistence_intervals p( "data/file_with_diagram" );
-	std::vector< double > knn = p.k_n_n( 5 );	
-	std::vector< double > knn_template;
-	knn_template.push_back(	1.04208	);
-	knn_template.push_back(	1.00344	);
-	knn_template.push_back(	0.979395	);
-	knn_template.push_back(	0.890643	);
-	knn_template.push_back(	0.874769	);
-	knn_template.push_back(	0.845787	);
-	knn_template.push_back(	0.819713	);
-	knn_template.push_back(	0.803984	);
-	knn_template.push_back(	0.799864	);
-	knn_template.push_back(	0.786945	);
-		
-	for ( size_t i = 0 ; i != knn.size() ; ++i )
-	{
-		//cout << knn[i] << std::endl;
-		BOOST_CHECK( fabs ( knn[i] - knn_template[i] ) <= 0.000005 );
-	}
+BOOST_AUTO_TEST_CASE(check_cumulative_characteristic_function_of_diagram) {
+  Persistence_intervals p("data/file_with_diagram");
+  std::pair<double, double> min_max_ = p.get_x_range();
+  std::vector<double> cumul_char_funct_diag =
+      p.cumulative_characteristic_function_of_diagram(min_max_.first, min_max_.second);
+  std::vector<double> template_char_funct_diag_cumul;
+
+  template_char_funct_diag_cumul.push_back(0.370665);
+  template_char_funct_diag_cumul.push_back(1.21125);
+  template_char_funct_diag_cumul.push_back(2.45774);
+  template_char_funct_diag_cumul.push_back(3.82414);
+  template_char_funct_diag_cumul.push_back(5.16446);
+  template_char_funct_diag_cumul.push_back(6.4835);
+  template_char_funct_diag_cumul.push_back(7.62426);
+  template_char_funct_diag_cumul.push_back(8.61552);
+  template_char_funct_diag_cumul.push_back(9.41623);
+  template_char_funct_diag_cumul.push_back(9.48386);
+
+  for (size_t i = 0; i != cumul_char_funct_diag.size(); ++i) {
+    // cout << cumul_char_funct_diag[i] << std::endl;
+    BOOST_CHECK(fabs(cumul_char_funct_diag[i] - template_char_funct_diag_cumul[i]) <= 0.0001);
+  }
 }
 
+BOOST_AUTO_TEST_CASE(check_compute_persistent_betti_numbers) {
+  Persistence_intervals p("data/file_with_diagram");
+  std::vector<std::pair<double, double> > pbns;
+  pbns.push_back(std::pair<double, double>(0.0290362, 1));
+  pbns.push_back(std::pair<double, double>(0.0307676, 2));
+  pbns.push_back(std::pair<double, double>(0.0366312, 3));
+  pbns.push_back(std::pair<double, double>(0.0544614, 4));
+  pbns.push_back(std::pair<double, double>(0.0920033, 5));
+  pbns.push_back(std::pair<double, double>(0.104599, 6));
+  pbns.push_back(std::pair<double, double>(0.114718, 7));
+  pbns.push_back(std::pair<double, double>(0.117379, 8));
+  pbns.push_back(std::pair<double, double>(0.123493, 9));
+  pbns.push_back(std::pair<double, double>(0.133638, 10));
+  pbns.push_back(std::pair<double, double>(0.137798, 9));
+  pbns.push_back(std::pair<double, double>(0.149798, 10));
+  pbns.push_back(std::pair<double, double>(0.155421, 11));
+  pbns.push_back(std::pair<double, double>(0.158443, 12));
+  pbns.push_back(std::pair<double, double>(0.176956, 13));
+  pbns.push_back(std::pair<double, double>(0.183234, 12));
+  pbns.push_back(std::pair<double, double>(0.191069, 13));
+  pbns.push_back(std::pair<double, double>(0.191333, 14));
+  pbns.push_back(std::pair<double, double>(0.191836, 15));
+  pbns.push_back(std::pair<double, double>(0.192675, 16));
+  pbns.push_back(std::pair<double, double>(0.208564, 17));
+  pbns.push_back(std::pair<double, double>(0.218425, 18));
+  pbns.push_back(std::pair<double, double>(0.219902, 17));
+  pbns.push_back(std::pair<double, double>(0.23233, 16));
+  pbns.push_back(std::pair<double, double>(0.234558, 17));
+  pbns.push_back(std::pair<double, double>(0.237166, 16));
+  pbns.push_back(std::pair<double, double>(0.247352, 17));
+  pbns.push_back(std::pair<double, double>(0.267421, 18));
+  pbns.push_back(std::pair<double, double>(0.268093, 19));
+  pbns.push_back(std::pair<double, double>(0.278734, 18));
+  pbns.push_back(std::pair<double, double>(0.284722, 19));
+  pbns.push_back(std::pair<double, double>(0.284998, 20));
+  pbns.push_back(std::pair<double, double>(0.294069, 21));
+  pbns.push_back(std::pair<double, double>(0.306293, 22));
+  pbns.push_back(std::pair<double, double>(0.322361, 21));
+  pbns.push_back(std::pair<double, double>(0.323152, 22));
+  pbns.push_back(std::pair<double, double>(0.371021, 23));
+  pbns.push_back(std::pair<double, double>(0.372395, 24));
+  pbns.push_back(std::pair<double, double>(0.387744, 25));
+  pbns.push_back(std::pair<double, double>(0.435537, 26));
+  pbns.push_back(std::pair<double, double>(0.462911, 25));
+  pbns.push_back(std::pair<double, double>(0.483569, 26));
+  pbns.push_back(std::pair<double, double>(0.489209, 25));
+  pbns.push_back(std::pair<double, double>(0.517115, 24));
+  pbns.push_back(std::pair<double, double>(0.522197, 23));
+  pbns.push_back(std::pair<double, double>(0.532665, 22));
+  pbns.push_back(std::pair<double, double>(0.545262, 23));
+  pbns.push_back(std::pair<double, double>(0.587227, 22));
+  pbns.push_back(std::pair<double, double>(0.593036, 23));
+  pbns.push_back(std::pair<double, double>(0.602647, 24));
+  pbns.push_back(std::pair<double, double>(0.605044, 25));
+  pbns.push_back(std::pair<double, double>(0.621962, 24));
+  pbns.push_back(std::pair<double, double>(0.629449, 23));
+  pbns.push_back(std::pair<double, double>(0.636719, 22));
+  pbns.push_back(std::pair<double, double>(0.64957, 21));
+  pbns.push_back(std::pair<double, double>(0.650781, 22));
+  pbns.push_back(std::pair<double, double>(0.654951, 23));
+  pbns.push_back(std::pair<double, double>(0.683489, 24));
+  pbns.push_back(std::pair<double, double>(0.687172, 23));
+  pbns.push_back(std::pair<double, double>(0.69703, 22));
+  pbns.push_back(std::pair<double, double>(0.701174, 21));
+  pbns.push_back(std::pair<double, double>(0.717623, 22));
+  pbns.push_back(std::pair<double, double>(0.722023, 21));
+  pbns.push_back(std::pair<double, double>(0.722298, 20));
+  pbns.push_back(std::pair<double, double>(0.725347, 19));
+  pbns.push_back(std::pair<double, double>(0.73071, 18));
+  pbns.push_back(std::pair<double, double>(0.758355, 17));
+  pbns.push_back(std::pair<double, double>(0.770913, 18));
+  pbns.push_back(std::pair<double, double>(0.790833, 17));
+  pbns.push_back(std::pair<double, double>(0.821211, 16));
+  pbns.push_back(std::pair<double, double>(0.849305, 17));
+  pbns.push_back(std::pair<double, double>(0.853669, 16));
+  pbns.push_back(std::pair<double, double>(0.866659, 15));
+  pbns.push_back(std::pair<double, double>(0.872896, 16));
+  pbns.push_back(std::pair<double, double>(0.889597, 15));
+  pbns.push_back(std::pair<double, double>(0.900231, 14));
+  pbns.push_back(std::pair<double, double>(0.903847, 13));
+  pbns.push_back(std::pair<double, double>(0.906299, 12));
+  pbns.push_back(std::pair<double, double>(0.910852, 11));
+  pbns.push_back(std::pair<double, double>(0.93453, 10));
+  pbns.push_back(std::pair<double, double>(0.944757, 9));
+  pbns.push_back(std::pair<double, double>(0.947812, 8));
+  pbns.push_back(std::pair<double, double>(0.959154, 7));
+  pbns.push_back(std::pair<double, double>(0.975654, 6));
+  pbns.push_back(std::pair<double, double>(0.976719, 5));
+  pbns.push_back(std::pair<double, double>(0.977343, 4));
+  pbns.push_back(std::pair<double, double>(0.980129, 3));
+  pbns.push_back(std::pair<double, double>(0.987842, 2));
+  pbns.push_back(std::pair<double, double>(0.990127, 1));
+  pbns.push_back(std::pair<double, double>(0.994537, 0));
+
+  std::vector<std::pair<double, size_t> > pbns_new = p.compute_persistent_betti_numbers();
+  for (size_t i = 0; i != pbns.size(); ++i) {
+    // cout << pbns_new[i].first << "," << pbns_new[i].second << std::endl;
+    BOOST_CHECK(fabs(pbns[i].first - pbns_new[i].first) <= epsilon);
+    BOOST_CHECK(fabs(pbns[i].second - pbns_new[i].second) <= epsilon);
+  }
+}
 
-
-
+BOOST_AUTO_TEST_CASE(check_k_n_n) {
+  Persistence_intervals p("data/file_with_diagram");
+  std::vector<double> knn = p.k_n_n(5);
+  std::vector<double> knn_template;
+  knn_template.push_back(1.04208);
+  knn_template.push_back(1.00344);
+  knn_template.push_back(0.979395);
+  knn_template.push_back(0.890643);
+  knn_template.push_back(0.874769);
+  knn_template.push_back(0.845787);
+  knn_template.push_back(0.819713);
+  knn_template.push_back(0.803984);
+  knn_template.push_back(0.799864);
+  knn_template.push_back(0.786945);
+
+  for (size_t i = 0; i != knn.size(); ++i) {
+    // cout << knn[i] << std::endl;
+    BOOST_CHECK(fabs(knn[i] - knn_template[i]) <= 0.000005);
+  }
+}
diff --git a/src/Persistence_representations/test/persistence_intervals_with_distances_test.cpp b/src/Persistence_representations/test/persistence_intervals_with_distances_test.cpp
index 703b5011..b936c41d 100644
--- a/src/Persistence_representations/test/persistence_intervals_with_distances_test.cpp
+++ b/src/Persistence_representations/test/persistence_intervals_with_distances_test.cpp
@@ -29,42 +29,33 @@
 
 #include <iostream>
 
-
-
 using namespace Gudhi;
 using namespace Gudhi::Persistence_representations;
 
+BOOST_AUTO_TEST_CASE(check_bottleneck_distances_computation) {
+  Persistence_intervals_with_distances p("data/file_with_diagram");
+  Persistence_intervals_with_distances q("data/file_with_diagram_1");
 
-BOOST_AUTO_TEST_CASE(check_bottleneck_distances_computation) 
-{
-	Persistence_intervals_with_distances p( "data/file_with_diagram" );
-	Persistence_intervals_with_distances q( "data/file_with_diagram_1" );
-	
-	double dist = p.distance( q );
-	
-	//std::cout << "dist : " << dist << std::endl;
-	
-	BOOST_CHECK( almost_equal(dist,0.389043) );
-}
+  double dist = p.distance(q);
 
+  // std::cout << "dist : " << dist << std::endl;
 
-BOOST_AUTO_TEST_CASE(check_default_parameters_in_distance) 
-{
-	Persistence_intervals_with_distances p( "data/file_with_diagram" );
-	Persistence_intervals_with_distances q( "data/file_with_diagram_1" );
-	
-	double default_parameter_distance = p.distance( q );
-	double max_parameter_distance = p.distance( q , std::numeric_limits< double >::max() );
-	double inf_parameter_distance = p.distance( q , std::numeric_limits<double>::infinity() );
-	
-	//std::cout << "default_parameter_distance : " << default_parameter_distance << std::endl;
-	//std::cout << "max_parameter_distance : " << max_parameter_distance << std::endl;
-	//std::cout << "inf_parameter_distance : " << inf_parameter_distance << std::endl;
-	
-	BOOST_CHECK( default_parameter_distance == max_parameter_distance );
-	BOOST_CHECK( inf_parameter_distance == max_parameter_distance );
-	BOOST_CHECK( inf_parameter_distance == max_parameter_distance );
+  BOOST_CHECK(almost_equal(dist, 0.389043));
 }
 
+BOOST_AUTO_TEST_CASE(check_default_parameters_in_distance) {
+  Persistence_intervals_with_distances p("data/file_with_diagram");
+  Persistence_intervals_with_distances q("data/file_with_diagram_1");
 
+  double default_parameter_distance = p.distance(q);
+  double max_parameter_distance = p.distance(q, std::numeric_limits<double>::max());
+  double inf_parameter_distance = p.distance(q, std::numeric_limits<double>::infinity());
 
+  // std::cout << "default_parameter_distance : " << default_parameter_distance << std::endl;
+  // std::cout << "max_parameter_distance : " << max_parameter_distance << std::endl;
+  // std::cout << "inf_parameter_distance : " << inf_parameter_distance << std::endl;
+
+  BOOST_CHECK(default_parameter_distance == max_parameter_distance);
+  BOOST_CHECK(inf_parameter_distance == max_parameter_distance);
+  BOOST_CHECK(inf_parameter_distance == max_parameter_distance);
+}
diff --git a/src/Persistence_representations/test/persistence_lanscapes_on_grid_test.cpp b/src/Persistence_representations/test/persistence_lanscapes_on_grid_test.cpp
index 865a8280..40d52415 100644
--- a/src/Persistence_representations/test/persistence_lanscapes_on_grid_test.cpp
+++ b/src/Persistence_representations/test/persistence_lanscapes_on_grid_test.cpp
@@ -20,8 +20,6 @@
  *    along with this program.  If not, see <http://www.gnu.org/licenses/>.
  */
 
-
-
 #define BOOST_TEST_DYN_LINK
 #define BOOST_TEST_MODULE "Persistence_representations"
 #include <boost/test/unit_test.hpp>
@@ -30,359 +28,317 @@
 
 #include <iostream>
 
-
-
 using namespace Gudhi;
 using namespace Gudhi::Persistence_representations;
 
+BOOST_AUTO_TEST_CASE(check_construction_of_landscape) {
+  Persistence_landscape_on_grid l("data/file_with_diagram_1", 100, std::numeric_limits<unsigned short>::max());
+  l.print_to_file("landscape_from_file_with_diagram_1");
 
-	
+  Persistence_landscape_on_grid g;
+  g.load_landscape_from_file("landscape_from_file_with_diagram_1");
 
-BOOST_AUTO_TEST_CASE(check_construction_of_landscape) 
-{	
-	Persistence_landscape_on_grid l( "data/file_with_diagram_1" , 100 , std::numeric_limits<unsigned short>::max());
-	l.print_to_file( "landscape_from_file_with_diagram_1" );
-	
-	Persistence_landscape_on_grid g;
-	g.load_landscape_from_file( "landscape_from_file_with_diagram_1" );
-	
-	BOOST_CHECK( l == g );
+  BOOST_CHECK(l == g);
 }
 
-BOOST_AUTO_TEST_CASE(check_construction_of_landscape_using_only_ten_levels) 
-{	
-	//TODO
-	unsigned number = 10;
-	Persistence_landscape_on_grid l( "data/file_with_diagram_1" , 100  , number );		
-	Persistence_landscape_on_grid g( "data/file_with_diagram_1" , 100 , std::numeric_limits<unsigned short>::max());
-	//cut all the elements of order > 10 in g. 
-	
-	for ( size_t level = 0 ; level != number ; ++level )
-	{
-		std::vector<double> v1 = l.vectorize(level);
-		std::vector<double> v2 = g.vectorize(level);				
-		BOOST_CHECK( v1.size() == v2.size() );
-		for ( size_t i = 0 ; i != v1.size() ; ++i )
-		{
-			BOOST_CHECK( v1[i] == v2[i] );
-		}
-	}
-	}
-
-
-
-BOOST_AUTO_TEST_CASE(check_computations_of_integrals) 
-{
-	Persistence_landscape_on_grid p( "data/file_with_diagram_1" , 100 , std::numeric_limits<unsigned short>::max());	
-	double integral = p.compute_integral_of_landscape();
-	//cerr << "integral : " << integral << endl;getchar();
-	BOOST_CHECK( fabs( integral - 27.343 ) <= 0.00005 );
+BOOST_AUTO_TEST_CASE(check_construction_of_landscape_using_only_ten_levels) {
+  // TODO
+  unsigned number = 10;
+  Persistence_landscape_on_grid l("data/file_with_diagram_1", 100, number);
+  Persistence_landscape_on_grid g("data/file_with_diagram_1", 100, std::numeric_limits<unsigned short>::max());
+  // cut all the elements of order > 10 in g.
+
+  for (size_t level = 0; level != number; ++level) {
+    std::vector<double> v1 = l.vectorize(level);
+    std::vector<double> v2 = g.vectorize(level);
+    BOOST_CHECK(v1.size() == v2.size());
+    for (size_t i = 0; i != v1.size(); ++i) {
+      BOOST_CHECK(v1[i] == v2[i]);
+    }
+  }
 }
 
-
-BOOST_AUTO_TEST_CASE(check_computations_of_integrals_for_each_level_separatelly) 
-{
-	Persistence_landscape_on_grid p( "data/file_with_diagram_1" , 100, std::numeric_limits<unsigned short>::max() );	
-	
-	std::vector< double > integrals_fir_different_levels;	
-	//integrals_fir_different_levels.push_back();
-	integrals_fir_different_levels.push_back(0.241168);
-	integrals_fir_different_levels.push_back(0.239276);
-	integrals_fir_different_levels.push_back(0.237882);
-	integrals_fir_different_levels.push_back(0.235193);
-	integrals_fir_different_levels.push_back(0.230115);
-	integrals_fir_different_levels.push_back(0.227626);
-	integrals_fir_different_levels.push_back(0.226132);
-	integrals_fir_different_levels.push_back(0.223643);
-	integrals_fir_different_levels.push_back(0.221651);
-	integrals_fir_different_levels.push_back(0.220556);
-	integrals_fir_different_levels.push_back(0.21727);
-	integrals_fir_different_levels.push_back(0.215976);
-	integrals_fir_different_levels.push_back(0.213685);
-	integrals_fir_different_levels.push_back(0.211993);
-	integrals_fir_different_levels.push_back(0.2102);
-	integrals_fir_different_levels.push_back(0.208707);
-	integrals_fir_different_levels.push_back(0.207014);
-	integrals_fir_different_levels.push_back(0.205122);
-	integrals_fir_different_levels.push_back(0.204226);
-	integrals_fir_different_levels.push_back(0.202633);
-
-	
-	for ( size_t level = 0 ; level != integrals_fir_different_levels.size() ; ++level )
-	{
-		double integral = p.compute_integral_of_landscape( level );		
-		//cerr << integral << endl;
-		BOOST_CHECK( fabs( integral - integrals_fir_different_levels[level] ) <= 0.00005 );
-	}	
-	
+BOOST_AUTO_TEST_CASE(check_computations_of_integrals) {
+  Persistence_landscape_on_grid p("data/file_with_diagram_1", 100, std::numeric_limits<unsigned short>::max());
+  double integral = p.compute_integral_of_landscape();
+  // cerr << "integral : " << integral << endl;getchar();
+  BOOST_CHECK(fabs(integral - 27.343) <= 0.00005);
 }
 
+BOOST_AUTO_TEST_CASE(check_computations_of_integrals_for_each_level_separatelly) {
+  Persistence_landscape_on_grid p("data/file_with_diagram_1", 100, std::numeric_limits<unsigned short>::max());
+
+  std::vector<double> integrals_fir_different_levels;
+  // integrals_fir_different_levels.push_back();
+  integrals_fir_different_levels.push_back(0.241168);
+  integrals_fir_different_levels.push_back(0.239276);
+  integrals_fir_different_levels.push_back(0.237882);
+  integrals_fir_different_levels.push_back(0.235193);
+  integrals_fir_different_levels.push_back(0.230115);
+  integrals_fir_different_levels.push_back(0.227626);
+  integrals_fir_different_levels.push_back(0.226132);
+  integrals_fir_different_levels.push_back(0.223643);
+  integrals_fir_different_levels.push_back(0.221651);
+  integrals_fir_different_levels.push_back(0.220556);
+  integrals_fir_different_levels.push_back(0.21727);
+  integrals_fir_different_levels.push_back(0.215976);
+  integrals_fir_different_levels.push_back(0.213685);
+  integrals_fir_different_levels.push_back(0.211993);
+  integrals_fir_different_levels.push_back(0.2102);
+  integrals_fir_different_levels.push_back(0.208707);
+  integrals_fir_different_levels.push_back(0.207014);
+  integrals_fir_different_levels.push_back(0.205122);
+  integrals_fir_different_levels.push_back(0.204226);
+  integrals_fir_different_levels.push_back(0.202633);
+
+  for (size_t level = 0; level != integrals_fir_different_levels.size(); ++level) {
+    double integral = p.compute_integral_of_landscape(level);
+    // cerr << integral << endl;
+    BOOST_CHECK(fabs(integral - integrals_fir_different_levels[level]) <= 0.00005);
+  }
+}
 
+BOOST_AUTO_TEST_CASE(check_computations_of_integrals_of_powers_of_landscape) {
+  Persistence_landscape_on_grid p("data/file_with_diagram_1", 100, std::numeric_limits<unsigned short>::max());
+
+  std::vector<double> integrals_fir_different_powers;
+  integrals_fir_different_powers.push_back(0.241168);
+  integrals_fir_different_powers.push_back(0.239276);
+  integrals_fir_different_powers.push_back(0.237882);
+  integrals_fir_different_powers.push_back(0.235193);
+  integrals_fir_different_powers.push_back(0.23011);
+
+  for (size_t power = 0; power != 5; ++power) {
+    double integral = p.compute_integral_of_landscape(power);
+    // cerr << integral << endl;
+    BOOST_CHECK(fabs(integral - integrals_fir_different_powers[power]) <= 0.00001);
+  }
+}
 
-BOOST_AUTO_TEST_CASE(check_computations_of_integrals_of_powers_of_landscape) 
-{
-	Persistence_landscape_on_grid p( "data/file_with_diagram_1" , 100, std::numeric_limits<unsigned short>::max() );	
-	
-	std::vector<double> integrals_fir_different_powers;
-	integrals_fir_different_powers.push_back(	0.241168);
-	integrals_fir_different_powers.push_back(	0.239276);
-	integrals_fir_different_powers.push_back(	0.237882);
-	integrals_fir_different_powers.push_back(	0.235193);
-	integrals_fir_different_powers.push_back(	0.23011);
- 
-	for ( size_t power = 0 ; power != 5 ; ++power ) 
-	{
-		double integral = p.compute_integral_of_landscape( power );
-		//cerr << integral << endl;
-		BOOST_CHECK( fabs( integral - integrals_fir_different_powers[power] ) <= 0.00001 );
-	}
+BOOST_AUTO_TEST_CASE(check_computations_of_values_on_different_points) {
+  Persistence_landscape_on_grid p("data/file_with_diagram_1", 100, std::numeric_limits<unsigned short>::max());
+
+  std::vector<double> results_level_0;
+  results_level_0.push_back(0.00997867);
+  results_level_0.push_back(0.0521921);
+  results_level_0.push_back(0.104312);
+  results_level_0.push_back(0.156432);
+  results_level_0.push_back(0.208552);
+  results_level_0.push_back(0.260672);
+  results_level_0.push_back(0.312792);
+  results_level_0.push_back(0.364912);
+  results_level_0.push_back(0.417032);
+  results_level_0.push_back(0.429237);
+
+  std::vector<double> results_level_10;
+  results_level_10.push_back(7.21433e-05);
+  results_level_10.push_back(0.0422135);
+  results_level_10.push_back(0.0943335);
+  results_level_10.push_back(0.146453);
+  results_level_10.push_back(0.198573);
+  results_level_10.push_back(0.240715);
+  results_level_10.push_back(0.272877);
+  results_level_10.push_back(0.324997);
+  results_level_10.push_back(0.359232);
+  results_level_10.push_back(0.379344);
+
+  double x = 0.0012321;
+  double dx = 0.05212;
+  for (size_t i = 0; i != 10; ++i) {
+    BOOST_CHECK(almost_equal(p.compute_value_at_a_given_point(0, x), results_level_0[i]));
+    BOOST_CHECK(almost_equal(p.compute_value_at_a_given_point(10, x), results_level_10[i]));
+    x += dx;
+  }
 }
 
+BOOST_AUTO_TEST_CASE(check_computations_sum_differences_and_multiplications) {
+  Persistence_landscape_on_grid p("data/file_with_diagram_1", 100, std::numeric_limits<unsigned short>::max());
+  Persistence_landscape_on_grid second("data/file_with_diagram_1", 100, std::numeric_limits<unsigned short>::max());
 
-BOOST_AUTO_TEST_CASE(check_computations_of_values_on_different_points) 
-{
-	Persistence_landscape_on_grid p( "data/file_with_diagram_1" , 100, std::numeric_limits<unsigned short>::max() );	
-
-	std::vector< double > results_level_0;	
-	results_level_0.push_back(0.00997867);
-	results_level_0.push_back(0.0521921);
-	results_level_0.push_back(0.104312);
-	results_level_0.push_back(0.156432);
-	results_level_0.push_back(0.208552);
-	results_level_0.push_back(0.260672);
-	results_level_0.push_back(0.312792);
-	results_level_0.push_back(0.364912);
-	results_level_0.push_back(0.417032);
-	results_level_0.push_back(0.429237);
-	
-	std::vector< double > results_level_10;
-	results_level_10.push_back(7.21433e-05);
-	results_level_10.push_back(0.0422135);
-	results_level_10.push_back(0.0943335);
-	results_level_10.push_back(0.146453);
-	results_level_10.push_back(0.198573);
-	results_level_10.push_back(0.240715);
-	results_level_10.push_back(0.272877);
-	results_level_10.push_back(0.324997);
-	results_level_10.push_back(0.359232);
-	results_level_10.push_back(0.379344);
-	
-	double x = 0.0012321;
-	 double dx = 0.05212;
-	 for ( size_t i = 0 ; i != 10 ; ++i )
-	 {  		
-		BOOST_CHECK( almost_equal( p.compute_value_at_a_given_point(0,x) , results_level_0[i] ) );
-		BOOST_CHECK( almost_equal( p.compute_value_at_a_given_point(10,x) , results_level_10[i] ) );
-		x += dx;
-	 }
-}
+  Persistence_landscape_on_grid sum = p + second;
+  Persistence_landscape_on_grid difference = p - second;
+  Persistence_landscape_on_grid multiply_by_scalar = 10 * p;
+  ;
 
+  Persistence_landscape_on_grid template_sum;
+  template_sum.load_landscape_from_file("data/sum_on_grid_test");
 
-BOOST_AUTO_TEST_CASE(check_computations_sum_differences_and_multiplications) 
-{	
-	Persistence_landscape_on_grid p( "data/file_with_diagram_1" ,100 , std::numeric_limits<unsigned short>::max());	
-	Persistence_landscape_on_grid second("data/file_with_diagram_1" , 100, std::numeric_limits<unsigned short>::max() );	
-	
-	Persistence_landscape_on_grid sum = p + second;
-	Persistence_landscape_on_grid difference = p - second;
-	Persistence_landscape_on_grid multiply_by_scalar = 10*p;	;
-
-	
-	Persistence_landscape_on_grid template_sum;
-	template_sum.load_landscape_from_file( "data/sum_on_grid_test" );
-	
-	Persistence_landscape_on_grid template_difference;
-	template_difference.load_landscape_from_file( "data/difference_on_grid_test" );
-	
-	Persistence_landscape_on_grid template_multiply_by_scalar;
-	template_multiply_by_scalar.load_landscape_from_file( "data/multiply_by_scalar_on_grid_test" );
-	
-	BOOST_CHECK( sum == template_sum );
-	BOOST_CHECK( difference == template_difference );
-	BOOST_CHECK( multiply_by_scalar == template_multiply_by_scalar );		
-}
+  Persistence_landscape_on_grid template_difference;
+  template_difference.load_landscape_from_file("data/difference_on_grid_test");
 
+  Persistence_landscape_on_grid template_multiply_by_scalar;
+  template_multiply_by_scalar.load_landscape_from_file("data/multiply_by_scalar_on_grid_test");
 
+  BOOST_CHECK(sum == template_sum);
+  BOOST_CHECK(difference == template_difference);
+  BOOST_CHECK(multiply_by_scalar == template_multiply_by_scalar);
+}
 
-BOOST_AUTO_TEST_CASE(check_computations_of_maxima_and_norms) 
-{	
-	Persistence_landscape_on_grid p( "data/file_with_diagram_1" , 0. , 1. , 100 );	
-	Persistence_landscape_on_grid second("data/file_with_diagram_2" , 0. , 1. , 100 );	
-	Persistence_landscape_on_grid sum = p + second;
-	
-	//cerr << p.compute_maximum() << endl;
-	//cerr <<  p.compute_norm_of_landscape(1) << endl;
-	//cerr << p.compute_norm_of_landscape(2) << endl;
-	//cerr <<  p.compute_norm_of_landscape(3) << endl;
-	//cerr <<  compute_distance_of_landscapes_on_grid(p,sum,1) << endl;
-	//cerr <<  compute_distance_of_landscapes_on_grid(p,sum,2) << endl;
-	//cerr <<  compute_distance_of_landscapes_on_grid(p,sum,std::numeric_limits<double>::max())  << endl;
-	
-	BOOST_CHECK( fabs( p.compute_maximum() - 0.46 ) <= 0.00001 );
-	BOOST_CHECK( fabs( p.compute_norm_of_landscape(1) - 27.3373 ) <= 0.00001 );
-	BOOST_CHECK( fabs( p.compute_norm_of_landscape(2) - 1.84143 ) <= 0.00001 );
-	BOOST_CHECK( fabs( p.compute_norm_of_landscape(3) - 0.927067 ) <= 0.00001 );
-	BOOST_CHECK( fabs( compute_distance_of_landscapes_on_grid(p,sum,1) - 16.8519 ) <= 0.00005 );	
-	BOOST_CHECK( fabs( compute_distance_of_landscapes_on_grid(p,sum,2) - 1.44542 ) <= 0.00001 );	
-	BOOST_CHECK( fabs(compute_distance_of_landscapes_on_grid(p,sum,std::numeric_limits<double>::max()) - 0.45 ) <= 0.00001 );		
+BOOST_AUTO_TEST_CASE(check_computations_of_maxima_and_norms) {
+  Persistence_landscape_on_grid p("data/file_with_diagram_1", 0., 1., 100);
+  Persistence_landscape_on_grid second("data/file_with_diagram_2", 0., 1., 100);
+  Persistence_landscape_on_grid sum = p + second;
+
+  // cerr << p.compute_maximum() << endl;
+  // cerr <<  p.compute_norm_of_landscape(1) << endl;
+  // cerr << p.compute_norm_of_landscape(2) << endl;
+  // cerr <<  p.compute_norm_of_landscape(3) << endl;
+  // cerr <<  compute_distance_of_landscapes_on_grid(p,sum,1) << endl;
+  // cerr <<  compute_distance_of_landscapes_on_grid(p,sum,2) << endl;
+  // cerr <<  compute_distance_of_landscapes_on_grid(p,sum,std::numeric_limits<double>::max())  << endl;
+
+  BOOST_CHECK(fabs(p.compute_maximum() - 0.46) <= 0.00001);
+  BOOST_CHECK(fabs(p.compute_norm_of_landscape(1) - 27.3373) <= 0.00001);
+  BOOST_CHECK(fabs(p.compute_norm_of_landscape(2) - 1.84143) <= 0.00001);
+  BOOST_CHECK(fabs(p.compute_norm_of_landscape(3) - 0.927067) <= 0.00001);
+  BOOST_CHECK(fabs(compute_distance_of_landscapes_on_grid(p, sum, 1) - 16.8519) <= 0.00005);
+  BOOST_CHECK(fabs(compute_distance_of_landscapes_on_grid(p, sum, 2) - 1.44542) <= 0.00001);
+  BOOST_CHECK(fabs(compute_distance_of_landscapes_on_grid(p, sum, std::numeric_limits<double>::max()) - 0.45) <=
+              0.00001);
 }
 
-BOOST_AUTO_TEST_CASE(check_default_parameters_of_distances ) 
-{	
-	std::vector< std::pair< double , double > > diag = read_persistence_intervals_in_one_dimension_from_file( "data/file_with_diagram" );	
-	Persistence_landscape_on_grid p( diag , 0. , 1. , 100 );
-	
-	std::vector< std::pair< double , double > > diag1 = read_persistence_intervals_in_one_dimension_from_file( "data/file_with_diagram_1" );	
-	Persistence_landscape_on_grid q( diag1 , 0. , 1. , 100 );
-	
-	double dist_numeric_limit_max = p.distance( q,std::numeric_limits<double>::max()  );
-	double dist_infinity = p.distance( q,std::numeric_limits<double>::infinity() );
-	
-	BOOST_CHECK( dist_numeric_limit_max == dist_infinity );	
+BOOST_AUTO_TEST_CASE(check_default_parameters_of_distances) {
+  std::vector<std::pair<double, double> > diag =
+      read_persistence_intervals_in_one_dimension_from_file("data/file_with_diagram");
+  Persistence_landscape_on_grid p(diag, 0., 1., 100);
+
+  std::vector<std::pair<double, double> > diag1 =
+      read_persistence_intervals_in_one_dimension_from_file("data/file_with_diagram_1");
+  Persistence_landscape_on_grid q(diag1, 0., 1., 100);
+
+  double dist_numeric_limit_max = p.distance(q, std::numeric_limits<double>::max());
+  double dist_infinity = p.distance(q, std::numeric_limits<double>::infinity());
+
+  BOOST_CHECK(dist_numeric_limit_max == dist_infinity);
 }
 
+BOOST_AUTO_TEST_CASE(check_computations_of_averages) {
+  Persistence_landscape_on_grid p("data/file_with_diagram", 0., 1., 100);
+  Persistence_landscape_on_grid q("data/file_with_diagram_1", 0., 1., 100);
+  Persistence_landscape_on_grid av;
+  av.compute_average({&p, &q});
 
+  Persistence_landscape_on_grid template_average;
+  template_average.load_landscape_from_file("data/average_on_a_grid");
+  BOOST_CHECK(template_average == av);
+}
 
+BOOST_AUTO_TEST_CASE(check_computations_of_distances) {
+  Persistence_landscape_on_grid p("data/file_with_diagram", 0., 1., 10000);
+  Persistence_landscape_on_grid q("data/file_with_diagram_1", 0., 1., 10000);
+  BOOST_CHECK(fabs(p.distance(q) - 25.5779) <= 0.00005);
+  BOOST_CHECK(fabs(p.distance(q, 2) - 2.04891) <= 0.00001);
+  BOOST_CHECK(fabs(p.distance(q, std::numeric_limits<double>::max()) - 0.359) <= 0.00001);
+}
 
-BOOST_AUTO_TEST_CASE(check_computations_of_averages) 
-{
-	Persistence_landscape_on_grid p( "data/file_with_diagram", 0.,1.,100 );
-	Persistence_landscape_on_grid q( "data/file_with_diagram_1", 0.,1.,100 );
-	Persistence_landscape_on_grid av;	
-	av.compute_average( {&p,&q} );
-	
-	Persistence_landscape_on_grid template_average;
-	template_average.load_landscape_from_file( "data/average_on_a_grid" );
-	BOOST_CHECK ( template_average == av );
+BOOST_AUTO_TEST_CASE(check_computations_of_scalar_product) {
+  Persistence_landscape_on_grid p("data/file_with_diagram", 0., 1., 10000);
+  Persistence_landscape_on_grid q("data/file_with_diagram_1", 0., 1., 10000);
+  // std::cerr << p.compute_scalar_product( q ) << std::endl;
+  BOOST_CHECK(almost_equal(p.compute_scalar_product(q), 0.754367));
 }
 
+// Below I am storing the code used to generate tests for that functionality.
+/*
+        Persistence_landscape_on_grid l( "file_with_diagram_1" , 100 );
+        l.print_to_file( "landscape_from_file_with_diagram_1" );
 
+        Persistence_landscape_on_grid g;
+        g.load_landscape_from_file( "landscape_from_file_with_diagram_1" );
 
+        cerr << ( l == g );
+        */
 
-BOOST_AUTO_TEST_CASE(check_computations_of_distances)
+/*
+Persistence_landscape_on_grid l( "file_with_diagram_1" , 100 );
+cerr << l << endl;
+cerr << l.compute_integral_of_landscape() << endl;
+*/
+
+/*
+Persistence_landscape_on_grid p( "file_with_diagram_1" , 100 );
+for ( size_t level = 0 ; level != 30 ; ++level )
 {
-	Persistence_landscape_on_grid p( "data/file_with_diagram", 0.,1.,10000 );
-	Persistence_landscape_on_grid q( "data/file_with_diagram_1", 0.,1.,10000 );
-	BOOST_CHECK( fabs( p.distance( q )- 25.5779) <= 0.00005 );	
-	BOOST_CHECK( fabs( p.distance( q , 2) - 2.04891) <= 0.00001 );	
-	BOOST_CHECK( fabs( p.distance( q , std::numeric_limits<double>::max() )-0.359		 ) <= 0.00001 );
+        double integral = p.compute_integral_of_landscape( level );
+        cerr << integral << endl;
 }
-	
+*/
 
-BOOST_AUTO_TEST_CASE(check_computations_of_scalar_product)
+/*
+Persistence_landscape_on_grid p( "file_with_diagram_1" , 100 );
+for ( size_t power = 0 ; power != 5 ; ++power )
 {
-	Persistence_landscape_on_grid p( "data/file_with_diagram" , 0.,1.,10000);
-	Persistence_landscape_on_grid q( "data/file_with_diagram_1", 0.,1.,10000 );
-	//std::cerr << p.compute_scalar_product( q ) << std::endl;
-	BOOST_CHECK( almost_equal(  p.compute_scalar_product( q ) , 0.754367 ) );	
+        double integral = p.compute_integral_of_landscape( (double)power );
+        cerr << integral << endl;
 }
+*/
 
+/*
+Persistence_landscape_on_grid p( "file_with_diagram_1" , 100 );
+double x = 0.0012321;
+double dx = 0.05212;
+for ( size_t i = 0 ; i != 10 ; ++i )
+{
+       cerr << p.compute_value_at_a_given_point(10,x) << endl;
+       x += dx;
+}
+*/
 
+/*
+Persistence_landscape_on_grid p( "file_with_diagram_1",100 );
+Persistence_landscape_on_grid second("file_with_diagram_1",100 );
+Persistence_landscape_on_grid sum = p + second;
+Persistence_landscape_on_grid difference = p - second;
+Persistence_landscape_on_grid multiply_by_scalar = 10*p;
+sum.print_to_file( "sum_on_grid_test" );
+difference.print_to_file( "difference_on_grid_test" );
+multiply_by_scalar.print_to_file( "multiply_by_scalar_on_grid_test" );
+*/
 
+/*
+Persistence_landscape_on_grid p( "file_with_diagram_1" , 0 , 1 , 100 );
+Persistence_landscape_on_grid second("file_with_diagram_1", 0 , 1 , 100 );
+Persistence_landscape_on_grid sum = p + second;
+
+cerr << "max : " << p.compute_maximum() << endl;
+cerr << "1-norm : " << p.compute_norm_of_landscape(1) << endl;
+cerr << "2-norm : " << p.compute_norm_of_landscape(2) << endl;
+cerr << "3-norm : " << p.compute_norm_of_landscape(3) << endl;
+
+cerr <<  compute_distance_of_landscapes_on_grid(p,sum,1) << endl;
+cerr <<  compute_distance_of_landscapes_on_grid(p,sum,2) << endl;
+cerr <<  compute_distance_of_landscapes_on_grid(p,sum,-1)  << endl;
+*/
 
-//Below I am storing the code used to generate tests for that functionality.
 /*
-	Persistence_landscape_on_grid l( "file_with_diagram_1" , 100 );
-	l.print_to_file( "landscape_from_file_with_diagram_1" );
-	
-	Persistence_landscape_on_grid g;
-	g.load_landscape_from_file( "landscape_from_file_with_diagram_1" );
-	
-	cerr << ( l == g );
-	*/
-	
-	/*
-	Persistence_landscape_on_grid l( "file_with_diagram_1" , 100 );
-	cerr << l << endl;
-	cerr << l.compute_integral_of_landscape() << endl;
-	*/
-	 
-	 /*
-	 Persistence_landscape_on_grid p( "file_with_diagram_1" , 100 );	
-	 for ( size_t level = 0 ; level != 30 ; ++level )
-	 {
-		 double integral = p.compute_integral_of_landscape( level );
-		 cerr << integral << endl;
-	 }
-	 */
-	 
-	 /*
-	 Persistence_landscape_on_grid p( "file_with_diagram_1" , 100 );	
-	 for ( size_t power = 0 ; power != 5 ; ++power )
-	 {
-		 double integral = p.compute_integral_of_landscape( (double)power );
-		 cerr << integral << endl;
-	 }
-	 */
-	 
-	 /*
-	 Persistence_landscape_on_grid p( "file_with_diagram_1" , 100 );	
-	 double x = 0.0012321;
-	 double dx = 0.05212;
-	 for ( size_t i = 0 ; i != 10 ; ++i )
-	 {  		
-		cerr << p.compute_value_at_a_given_point(10,x) << endl;
-		x += dx;
-	 }
-	 */
-	 
-	 /*	
-	Persistence_landscape_on_grid p( "file_with_diagram_1",100 );	
-	Persistence_landscape_on_grid second("file_with_diagram_1",100 );		
-	Persistence_landscape_on_grid sum = p + second;
-	Persistence_landscape_on_grid difference = p - second;
-	Persistence_landscape_on_grid multiply_by_scalar = 10*p;
-	sum.print_to_file( "sum_on_grid_test" );
-	difference.print_to_file( "difference_on_grid_test" );
-	multiply_by_scalar.print_to_file( "multiply_by_scalar_on_grid_test" );
-	*/
-	
-	
-	/*	
-	Persistence_landscape_on_grid p( "file_with_diagram_1" , 0 , 1 , 100 );
-	Persistence_landscape_on_grid second("file_with_diagram_1", 0 , 1 , 100 );	
-	Persistence_landscape_on_grid sum = p + second;
-	
-	cerr << "max : " << p.compute_maximum() << endl;
-	cerr << "1-norm : " << p.compute_norm_of_landscape(1) << endl;
-	cerr << "2-norm : " << p.compute_norm_of_landscape(2) << endl;
-	cerr << "3-norm : " << p.compute_norm_of_landscape(3) << endl;
-	
-	cerr <<  compute_distance_of_landscapes_on_grid(p,sum,1) << endl;
-	cerr <<  compute_distance_of_landscapes_on_grid(p,sum,2) << endl;
-	cerr <<  compute_distance_of_landscapes_on_grid(p,sum,-1)  << endl;
-	*/
-	
-	/*
-	Persistence_landscape_on_grid p( "file_with_diagram", 0,1,100 );
-	Persistence_landscape_on_grid q( "file_with_diagram_1", 0,1,100 );		
-	Persistence_landscape_on_grid av;	
-	av.compute_average( {&p,&q} );
-	av.print_to_file("average_on_a_grid");
-
-	Persistence_landscape_on_grid template_average;
-	template_average.load_landscape_from_file( "average_on_a_grid" );
-	if ( template_average == av )
-	{
-		cerr << "OK OK \n";
-	}*/
-	
-	/*
-	Persistence_landscape_on_grid p( "file_with_diagram" , 0,1,10000);
-	Persistence_landscape_on_grid q( "file_with_diagram_1" , 0,1,10000);
-	cerr <<  p.distance( &q )<< endl;
-	cerr <<  p.distance( &q , 2 ) << endl;
-	cerr <<  p.distance( &q , std::numeric_limits<double>::max() ) << endl;
-	*/
-	
+Persistence_landscape_on_grid p( "file_with_diagram", 0,1,100 );
+Persistence_landscape_on_grid q( "file_with_diagram_1", 0,1,100 );
+Persistence_landscape_on_grid av;
+av.compute_average( {&p,&q} );
+av.print_to_file("average_on_a_grid");
+
+Persistence_landscape_on_grid template_average;
+template_average.load_landscape_from_file( "average_on_a_grid" );
+if ( template_average == av )
+{
+        cerr << "OK OK \n";
+}*/
+
 /*
-	Persistence_landscape_on_grid p( "file_with_diagram", 0,1,10000 );
-	Persistence_landscape_on_grid q( "file_with_diagram_1", 0,1,10000 );
-	
-	//std::vector< std::pair< double,double > > aa;
-	//aa.push_back( std::make_pair( 0,1 ) );
-	//Persistence_landscape_on_grid p( aa, 0,1,10 );
-	//Persistence_landscape_on_grid q( aa, 0,1,10 );
-	cerr <<  p.compute_scalar_product( &q ) << endl;
+Persistence_landscape_on_grid p( "file_with_diagram" , 0,1,10000);
+Persistence_landscape_on_grid q( "file_with_diagram_1" , 0,1,10000);
+cerr <<  p.distance( &q )<< endl;
+cerr <<  p.distance( &q , 2 ) << endl;
+cerr <<  p.distance( &q , std::numeric_limits<double>::max() ) << endl;
 */
 
+/*
+        Persistence_landscape_on_grid p( "file_with_diagram", 0,1,10000 );
+        Persistence_landscape_on_grid q( "file_with_diagram_1", 0,1,10000 );
+
+        //std::vector< std::pair< double,double > > aa;
+        //aa.push_back( std::make_pair( 0,1 ) );
+        //Persistence_landscape_on_grid p( aa, 0,1,10 );
+        //Persistence_landscape_on_grid q( aa, 0,1,10 );
+        cerr <<  p.compute_scalar_product( &q ) << endl;
+*/
diff --git a/src/Persistence_representations/test/persistence_lanscapes_test.cpp b/src/Persistence_representations/test/persistence_lanscapes_test.cpp
index c1e24b1c..2bdc6bdb 100644
--- a/src/Persistence_representations/test/persistence_lanscapes_test.cpp
+++ b/src/Persistence_representations/test/persistence_lanscapes_test.cpp
@@ -20,8 +20,6 @@
  *    along with this program.  If not, see <http://www.gnu.org/licenses/>.
  */
 
-
-
 #define BOOST_TEST_DYN_LINK
 #define BOOST_TEST_MODULE "Persistence_representations"
 #include <boost/test/unit_test.hpp>
@@ -31,354 +29,332 @@
 #include <iostream>
 #include <limits>
 
-
-
 using namespace Gudhi;
 using namespace Gudhi::Persistence_representations;
 
-
 double epsilon = 0.0000005;
 
-
-	
-
-BOOST_AUTO_TEST_CASE(check_construction_of_landscape) 
-{	
-	std::vector< std::pair< double , double > > diag = read_persistence_intervals_in_one_dimension_from_file( "data/file_with_diagram" );
-	Persistence_landscape p( diag );	
-	Persistence_landscape q;
-	q.load_landscape_from_file( "data/file_with_landscape_from_file_with_diagram" );		
-	BOOST_CHECK( p == q );
+BOOST_AUTO_TEST_CASE(check_construction_of_landscape) {
+  std::vector<std::pair<double, double> > diag =
+      read_persistence_intervals_in_one_dimension_from_file("data/file_with_diagram");
+  Persistence_landscape p(diag);
+  Persistence_landscape q;
+  q.load_landscape_from_file("data/file_with_landscape_from_file_with_diagram");
+  BOOST_CHECK(p == q);
 }
 
-
-BOOST_AUTO_TEST_CASE(check_construction_of_landscape_form_gudhi_style_file) 
-{		
-	Persistence_landscape p( "data/persistence_file_with_four_entries_per_line" , 1 );		
-	//p.print_to_file("persistence_file_with_four_entries_per_line_landscape");
-	Persistence_landscape q;
-	q.load_landscape_from_file( "data/persistence_file_with_four_entries_per_line_landscape" );		
-	BOOST_CHECK( p == q );
+BOOST_AUTO_TEST_CASE(check_construction_of_landscape_form_gudhi_style_file) {
+  Persistence_landscape p("data/persistence_file_with_four_entries_per_line", 1);
+  // p.print_to_file("persistence_file_with_four_entries_per_line_landscape");
+  Persistence_landscape q;
+  q.load_landscape_from_file("data/persistence_file_with_four_entries_per_line_landscape");
+  BOOST_CHECK(p == q);
 }
 
-
-BOOST_AUTO_TEST_CASE(check_computations_of_integrals) 
-{
-	std::vector< std::pair< double , double > > diag = read_persistence_intervals_in_one_dimension_from_file( "data/file_with_diagram" );
-	Persistence_landscape p( diag );
-	double integral = p.compute_integral_of_landscape();
-	//cerr << integral  << " " << 2.34992 << endl;
-	BOOST_CHECK( fabs( integral - 2.34992 ) <= 0.00001 );
+BOOST_AUTO_TEST_CASE(check_computations_of_integrals) {
+  std::vector<std::pair<double, double> > diag =
+      read_persistence_intervals_in_one_dimension_from_file("data/file_with_diagram");
+  Persistence_landscape p(diag);
+  double integral = p.compute_integral_of_landscape();
+  // cerr << integral  << " " << 2.34992 << endl;
+  BOOST_CHECK(fabs(integral - 2.34992) <= 0.00001);
 }
 
-
-BOOST_AUTO_TEST_CASE(check_computations_of_integrals_for_each_level_separatelly) 
-{
-	std::vector< std::pair< double , double > > diag = read_persistence_intervals_in_one_dimension_from_file( "data/file_with_diagram" );
-	Persistence_landscape p( diag );	
-	
-	std::vector< double > integrals_fir_different_levels;
-	integrals_fir_different_levels.push_back(	0.216432	);
-	integrals_fir_different_levels.push_back(	0.204763	);
-	integrals_fir_different_levels.push_back(	0.188793	);
-	integrals_fir_different_levels.push_back(	0.178856	);
-	integrals_fir_different_levels.push_back(	0.163142	);
-	integrals_fir_different_levels.push_back(	0.155015	);
-	integrals_fir_different_levels.push_back(	0.143046	);
-	integrals_fir_different_levels.push_back(	0.133765	);
-	integrals_fir_different_levels.push_back(	0.123531	);
-	integrals_fir_different_levels.push_back(	0.117393	);
-	integrals_fir_different_levels.push_back(	0.111269	);
-	integrals_fir_different_levels.push_back(	0.104283	);
-	integrals_fir_different_levels.push_back(	0.0941308	);
-	integrals_fir_different_levels.push_back(	0.0811208	);
-	integrals_fir_different_levels.push_back(	0.0679001	);
-	integrals_fir_different_levels.push_back(	0.0580801	);
-	integrals_fir_different_levels.push_back(	0.0489647	);
-	integrals_fir_different_levels.push_back(	0.0407936	);
-	integrals_fir_different_levels.push_back(	0.0342599	);
-	integrals_fir_different_levels.push_back(	0.02896	);
-	integrals_fir_different_levels.push_back(	0.0239881	);
-	integrals_fir_different_levels.push_back(	0.0171792	);
-	integrals_fir_different_levels.push_back(	0.0071511	);
-	integrals_fir_different_levels.push_back(	0.00462067	);
-	integrals_fir_different_levels.push_back(	0.00229033	);
-	integrals_fir_different_levels.push_back(	0.000195296	);
-
-
-	
-	
-	for ( size_t level = 0 ; level != p.size() ; ++level )
-	{
-		double integral = p.compute_integral_of_a_level_of_a_landscape( level );
-		BOOST_CHECK( fabs( integral - integrals_fir_different_levels[level] ) <= 0.00001 );
-	}
-	
+BOOST_AUTO_TEST_CASE(check_computations_of_integrals_for_each_level_separatelly) {
+  std::vector<std::pair<double, double> > diag =
+      read_persistence_intervals_in_one_dimension_from_file("data/file_with_diagram");
+  Persistence_landscape p(diag);
+
+  std::vector<double> integrals_fir_different_levels;
+  integrals_fir_different_levels.push_back(0.216432);
+  integrals_fir_different_levels.push_back(0.204763);
+  integrals_fir_different_levels.push_back(0.188793);
+  integrals_fir_different_levels.push_back(0.178856);
+  integrals_fir_different_levels.push_back(0.163142);
+  integrals_fir_different_levels.push_back(0.155015);
+  integrals_fir_different_levels.push_back(0.143046);
+  integrals_fir_different_levels.push_back(0.133765);
+  integrals_fir_different_levels.push_back(0.123531);
+  integrals_fir_different_levels.push_back(0.117393);
+  integrals_fir_different_levels.push_back(0.111269);
+  integrals_fir_different_levels.push_back(0.104283);
+  integrals_fir_different_levels.push_back(0.0941308);
+  integrals_fir_different_levels.push_back(0.0811208);
+  integrals_fir_different_levels.push_back(0.0679001);
+  integrals_fir_different_levels.push_back(0.0580801);
+  integrals_fir_different_levels.push_back(0.0489647);
+  integrals_fir_different_levels.push_back(0.0407936);
+  integrals_fir_different_levels.push_back(0.0342599);
+  integrals_fir_different_levels.push_back(0.02896);
+  integrals_fir_different_levels.push_back(0.0239881);
+  integrals_fir_different_levels.push_back(0.0171792);
+  integrals_fir_different_levels.push_back(0.0071511);
+  integrals_fir_different_levels.push_back(0.00462067);
+  integrals_fir_different_levels.push_back(0.00229033);
+  integrals_fir_different_levels.push_back(0.000195296);
+
+  for (size_t level = 0; level != p.size(); ++level) {
+    double integral = p.compute_integral_of_a_level_of_a_landscape(level);
+    BOOST_CHECK(fabs(integral - integrals_fir_different_levels[level]) <= 0.00001);
+  }
 }
 
-BOOST_AUTO_TEST_CASE(check_computations_of_integrals_of_powers_of_landscape) 
-{
-	std::vector< std::pair< double , double > > diag = read_persistence_intervals_in_one_dimension_from_file( "data/file_with_diagram" );
-	Persistence_landscape p( diag );	
-	
-	std::vector<double> integrals_fir_different_powers;
- 	integrals_fir_different_powers.push_back(	17.1692	);
-	integrals_fir_different_powers.push_back(	2.34992	);
-	integrals_fir_different_powers.push_back(	0.49857	);
-	integrals_fir_different_powers.push_back(	0.126405	);
-	integrals_fir_different_powers.push_back(	0.0355235	);
-	
-	for ( size_t power = 0 ; power != 5 ; ++power ) 
-	{
-		double integral = p.compute_integral_of_landscape( (double)power );		
-		BOOST_CHECK( fabs( integral - integrals_fir_different_powers[power] ) <= 0.00005 );
-	}
+BOOST_AUTO_TEST_CASE(check_computations_of_integrals_of_powers_of_landscape) {
+  std::vector<std::pair<double, double> > diag =
+      read_persistence_intervals_in_one_dimension_from_file("data/file_with_diagram");
+  Persistence_landscape p(diag);
+
+  std::vector<double> integrals_fir_different_powers;
+  integrals_fir_different_powers.push_back(17.1692);
+  integrals_fir_different_powers.push_back(2.34992);
+  integrals_fir_different_powers.push_back(0.49857);
+  integrals_fir_different_powers.push_back(0.126405);
+  integrals_fir_different_powers.push_back(0.0355235);
+
+  for (size_t power = 0; power != 5; ++power) {
+    double integral = p.compute_integral_of_landscape((double)power);
+    BOOST_CHECK(fabs(integral - integrals_fir_different_powers[power]) <= 0.00005);
+  }
 }
 
-BOOST_AUTO_TEST_CASE(check_computations_of_values_on_different_points) 
-{
-	std::vector< std::pair< double , double > > diag = read_persistence_intervals_in_one_dimension_from_file( "data/file_with_diagram" );
-	Persistence_landscape p( diag );	
-	
-	
-	BOOST_CHECK( fabs( p.compute_value_at_a_given_point(1,0.0)  ) <= 0.00001 );
-	BOOST_CHECK( fabs(  p.compute_value_at_a_given_point(1,0.1) - 0.0692324 ) <= 0.00001 );
-	BOOST_CHECK( fabs( p.compute_value_at_a_given_point(1,0.2) - 0.163369 ) <= 0.00001 );
-	BOOST_CHECK( fabs( p.compute_value_at_a_given_point(1,0.3) - 0.217115 ) <= 0.00001 );
-	BOOST_CHECK( fabs( p.compute_value_at_a_given_point(2,0.0) ) <= 0.00001 );
-	BOOST_CHECK( fabs( p.compute_value_at_a_given_point(2,0.1) - 0.0633688 ) <= 0.00001 );
-	BOOST_CHECK( fabs( p.compute_value_at_a_given_point(2,0.2) - 0.122361 ) <= 0.00001 );
-	BOOST_CHECK( fabs( p.compute_value_at_a_given_point(2,0.3) - 0.195401 ) <= 0.00001 );			
-	BOOST_CHECK( fabs( p.compute_value_at_a_given_point(3,0.0)  ) <= 0.00001 );
-	BOOST_CHECK( fabs( p.compute_value_at_a_given_point(3,0.1) - 0.0455386 ) <= 0.00001 );
-	BOOST_CHECK( fabs( p.compute_value_at_a_given_point(3,0.2) - 0.0954012 ) <= 0.00001 );
-	BOOST_CHECK( fabs( p.compute_value_at_a_given_point(3,0.3) - 0.185282 ) <= 0.00001 );
+BOOST_AUTO_TEST_CASE(check_computations_of_values_on_different_points) {
+  std::vector<std::pair<double, double> > diag =
+      read_persistence_intervals_in_one_dimension_from_file("data/file_with_diagram");
+  Persistence_landscape p(diag);
+
+  BOOST_CHECK(fabs(p.compute_value_at_a_given_point(1, 0.0)) <= 0.00001);
+  BOOST_CHECK(fabs(p.compute_value_at_a_given_point(1, 0.1) - 0.0692324) <= 0.00001);
+  BOOST_CHECK(fabs(p.compute_value_at_a_given_point(1, 0.2) - 0.163369) <= 0.00001);
+  BOOST_CHECK(fabs(p.compute_value_at_a_given_point(1, 0.3) - 0.217115) <= 0.00001);
+  BOOST_CHECK(fabs(p.compute_value_at_a_given_point(2, 0.0)) <= 0.00001);
+  BOOST_CHECK(fabs(p.compute_value_at_a_given_point(2, 0.1) - 0.0633688) <= 0.00001);
+  BOOST_CHECK(fabs(p.compute_value_at_a_given_point(2, 0.2) - 0.122361) <= 0.00001);
+  BOOST_CHECK(fabs(p.compute_value_at_a_given_point(2, 0.3) - 0.195401) <= 0.00001);
+  BOOST_CHECK(fabs(p.compute_value_at_a_given_point(3, 0.0)) <= 0.00001);
+  BOOST_CHECK(fabs(p.compute_value_at_a_given_point(3, 0.1) - 0.0455386) <= 0.00001);
+  BOOST_CHECK(fabs(p.compute_value_at_a_given_point(3, 0.2) - 0.0954012) <= 0.00001);
+  BOOST_CHECK(fabs(p.compute_value_at_a_given_point(3, 0.3) - 0.185282) <= 0.00001);
 }
 
+BOOST_AUTO_TEST_CASE(check_computations_sum_differences_and_multiplications) {
+  std::vector<std::pair<double, double> > diag =
+      read_persistence_intervals_in_one_dimension_from_file("data/file_with_diagram");
+  Persistence_landscape p(diag);
+  Persistence_landscape second;
+  second.load_landscape_from_file("data/file_with_landscape_from_file_with_diagram_1");
 
-BOOST_AUTO_TEST_CASE(check_computations_sum_differences_and_multiplications) 
-{	
-	std::vector< std::pair< double , double > > diag = read_persistence_intervals_in_one_dimension_from_file( "data/file_with_diagram" );
-	Persistence_landscape p( diag );
-	Persistence_landscape second;
-	second.load_landscape_from_file("data/file_with_landscape_from_file_with_diagram_1" );
-	
-	Persistence_landscape sum = p + second;
-	Persistence_landscape difference = p - second;
-	Persistence_landscape multiply_by_scalar = 10*p;
-
-	
-	Persistence_landscape template_sum;
-	template_sum.load_landscape_from_file( "data/sum" );
-	
-	Persistence_landscape template_difference;
-	template_difference.load_landscape_from_file( "data/difference" );
-	
-	Persistence_landscape template_multiply_by_scalar;
-	template_multiply_by_scalar.load_landscape_from_file( "data/multiply_by_scalar" );
-	
-	BOOST_CHECK( sum == template_sum );
-	BOOST_CHECK( difference == template_difference );
-	BOOST_CHECK( multiply_by_scalar == template_multiply_by_scalar );		
-}
-
+  Persistence_landscape sum = p + second;
+  Persistence_landscape difference = p - second;
+  Persistence_landscape multiply_by_scalar = 10 * p;
 
+  Persistence_landscape template_sum;
+  template_sum.load_landscape_from_file("data/sum");
 
-BOOST_AUTO_TEST_CASE(check_computations_of_maxima_and_norms) 
-{	
-	std::vector< std::pair< double , double > > diag = read_persistence_intervals_in_one_dimension_from_file( "data/file_with_diagram" );
-	Persistence_landscape p( diag );	
-	Persistence_landscape second;
-	second.load_landscape_from_file("data/file_with_landscape_from_file_with_diagram_1" );	
-	Persistence_landscape sum = p + second;
-	
-	BOOST_CHECK( fabs( p.compute_maximum() - 0.431313 ) <= 0.00001 );
-	BOOST_CHECK( fabs( p.compute_norm_of_landscape(1) - 2.34992 ) <= 0.00001 );
-	BOOST_CHECK( fabs( p.compute_norm_of_landscape(2) - 0.706095 ) <= 0.00001 );
-	BOOST_CHECK( fabs( p.compute_norm_of_landscape(3) - 0.501867 ) <= 0.00001 );
-	BOOST_CHECK( fabs( compute_distance_of_landscapes(p,sum,1) - 27.9323 ) <= 0.00005 );	
-	BOOST_CHECK( fabs( compute_distance_of_landscapes(p,sum,2) - 2.35199 ) <= 0.00001 );
-	BOOST_CHECK( fabs(compute_distance_of_landscapes( p , sum , std::numeric_limits<double>::max() ) - 0.464478 ) <= 0.00001 );		
-}
+  Persistence_landscape template_difference;
+  template_difference.load_landscape_from_file("data/difference");
 
+  Persistence_landscape template_multiply_by_scalar;
+  template_multiply_by_scalar.load_landscape_from_file("data/multiply_by_scalar");
 
-BOOST_AUTO_TEST_CASE(check_default_parameters_of_distances ) 
-{	
-	std::vector< std::pair< double , double > > diag = read_persistence_intervals_in_one_dimension_from_file( "data/file_with_diagram" );	
-	Persistence_landscape p( diag );
-	
-	std::vector< std::pair< double , double > > diag1 = read_persistence_intervals_in_one_dimension_from_file( "data/file_with_diagram_1" );	
-	Persistence_landscape q( diag1 );
-	
-	double dist_numeric_limit_max = p.distance( q,std::numeric_limits<double>::max()  );
-	double dist_infinity = p.distance( q,std::numeric_limits<double>::infinity() );
-	
-	BOOST_CHECK( dist_numeric_limit_max == dist_infinity );	
+  BOOST_CHECK(sum == template_sum);
+  BOOST_CHECK(difference == template_difference);
+  BOOST_CHECK(multiply_by_scalar == template_multiply_by_scalar);
 }
 
-BOOST_AUTO_TEST_CASE(check_computations_of_averages) 
-{
-	std::vector< std::pair< double , double > > diag = read_persistence_intervals_in_one_dimension_from_file( "data/file_with_diagram" );
-	Persistence_landscape p( diag );
-	std::vector< std::pair< double , double > > diag2 = read_persistence_intervals_in_one_dimension_from_file( "data/file_with_diagram_1" );
-	Persistence_landscape q( diag2 );	
-	Persistence_landscape av;
-	av.compute_average( {&p,&q} );
-
-	Persistence_landscape template_average;
-	template_average.load_landscape_from_file( "data/average" );
-	BOOST_CHECK ( template_average == av );
+BOOST_AUTO_TEST_CASE(check_computations_of_maxima_and_norms) {
+  std::vector<std::pair<double, double> > diag =
+      read_persistence_intervals_in_one_dimension_from_file("data/file_with_diagram");
+  Persistence_landscape p(diag);
+  Persistence_landscape second;
+  second.load_landscape_from_file("data/file_with_landscape_from_file_with_diagram_1");
+  Persistence_landscape sum = p + second;
+
+  BOOST_CHECK(fabs(p.compute_maximum() - 0.431313) <= 0.00001);
+  BOOST_CHECK(fabs(p.compute_norm_of_landscape(1) - 2.34992) <= 0.00001);
+  BOOST_CHECK(fabs(p.compute_norm_of_landscape(2) - 0.706095) <= 0.00001);
+  BOOST_CHECK(fabs(p.compute_norm_of_landscape(3) - 0.501867) <= 0.00001);
+  BOOST_CHECK(fabs(compute_distance_of_landscapes(p, sum, 1) - 27.9323) <= 0.00005);
+  BOOST_CHECK(fabs(compute_distance_of_landscapes(p, sum, 2) - 2.35199) <= 0.00001);
+  BOOST_CHECK(fabs(compute_distance_of_landscapes(p, sum, std::numeric_limits<double>::max()) - 0.464478) <= 0.00001);
 }
 
+BOOST_AUTO_TEST_CASE(check_default_parameters_of_distances) {
+  std::vector<std::pair<double, double> > diag =
+      read_persistence_intervals_in_one_dimension_from_file("data/file_with_diagram");
+  Persistence_landscape p(diag);
 
+  std::vector<std::pair<double, double> > diag1 =
+      read_persistence_intervals_in_one_dimension_from_file("data/file_with_diagram_1");
+  Persistence_landscape q(diag1);
 
+  double dist_numeric_limit_max = p.distance(q, std::numeric_limits<double>::max());
+  double dist_infinity = p.distance(q, std::numeric_limits<double>::infinity());
 
-BOOST_AUTO_TEST_CASE(check_computations_of_distances)
-{
-	std::vector< std::pair< double , double > > diag = read_persistence_intervals_in_one_dimension_from_file( "data/file_with_diagram" );
-	Persistence_landscape p( diag );
-	std::vector< std::pair< double , double > > diag2 = read_persistence_intervals_in_one_dimension_from_file( "data/file_with_diagram_1" );
-	Persistence_landscape q( diag2 );
-	BOOST_CHECK( fabs( p.distance( q )- 25.5824) <= 0.00005 );	
-	BOOST_CHECK( fabs( p.distance( q , 2) - 2.12636 ) <= 0.00001 );	
-	BOOST_CHECK( fabs( p.distance( q , std::numeric_limits<double>::max() )-0.359068 ) <= 0.00001 );	
-	std::cerr << "p.distance( q , std::numeric_limits<double>::max() ) : " << p.distance( q , std::numeric_limits<double>::max() ) << std::endl;
+  BOOST_CHECK(dist_numeric_limit_max == dist_infinity);
 }
-	
-
-BOOST_AUTO_TEST_CASE(check_computations_of_scalar_product)
-{
-	std::vector< std::pair< double , double > > diag = read_persistence_intervals_in_one_dimension_from_file( "data/file_with_diagram" );
-	Persistence_landscape p( diag );
-	std::vector< std::pair< double , double > > diag2 = read_persistence_intervals_in_one_dimension_from_file( "data/file_with_diagram_1" );
-	Persistence_landscape q( diag2 );
-	BOOST_CHECK( fabs(  p.compute_scalar_product( q ) - 0.754498 ) <= 0.00001 );	
+
+BOOST_AUTO_TEST_CASE(check_computations_of_averages) {
+  std::vector<std::pair<double, double> > diag =
+      read_persistence_intervals_in_one_dimension_from_file("data/file_with_diagram");
+  Persistence_landscape p(diag);
+  std::vector<std::pair<double, double> > diag2 =
+      read_persistence_intervals_in_one_dimension_from_file("data/file_with_diagram_1");
+  Persistence_landscape q(diag2);
+  Persistence_landscape av;
+  av.compute_average({&p, &q});
+
+  Persistence_landscape template_average;
+  template_average.load_landscape_from_file("data/average");
+  BOOST_CHECK(template_average == av);
 }
 
+BOOST_AUTO_TEST_CASE(check_computations_of_distances) {
+  std::vector<std::pair<double, double> > diag =
+      read_persistence_intervals_in_one_dimension_from_file("data/file_with_diagram");
+  Persistence_landscape p(diag);
+  std::vector<std::pair<double, double> > diag2 =
+      read_persistence_intervals_in_one_dimension_from_file("data/file_with_diagram_1");
+  Persistence_landscape q(diag2);
+  BOOST_CHECK(fabs(p.distance(q) - 25.5824) <= 0.00005);
+  BOOST_CHECK(fabs(p.distance(q, 2) - 2.12636) <= 0.00001);
+  BOOST_CHECK(fabs(p.distance(q, std::numeric_limits<double>::max()) - 0.359068) <= 0.00001);
+  std::cerr << "p.distance( q , std::numeric_limits<double>::max() ) : "
+            << p.distance(q, std::numeric_limits<double>::max()) << std::endl;
+}
 
+BOOST_AUTO_TEST_CASE(check_computations_of_scalar_product) {
+  std::vector<std::pair<double, double> > diag =
+      read_persistence_intervals_in_one_dimension_from_file("data/file_with_diagram");
+  Persistence_landscape p(diag);
+  std::vector<std::pair<double, double> > diag2 =
+      read_persistence_intervals_in_one_dimension_from_file("data/file_with_diagram_1");
+  Persistence_landscape q(diag2);
+  BOOST_CHECK(fabs(p.compute_scalar_product(q) - 0.754498) <= 0.00001);
+}
 
-//Below I am storing the code used to generate tests for that functionality.
+// Below I am storing the code used to generate tests for that functionality.
 /*
 if ( argc != 2 )
-	{
-		std::cerr << "To run this program, please provide a name of a file with persistence landscape \n";
-		//return 1;
-	}		
-	Persistence_landscape p("../test/data/file_with_diagram");
-	
-	Persistence_landscape q;
-	q.load_landscape_from_file( "file_with_landscape_from_file_with_diagram" );
-	
-	if ( p != q )
-	{
-		cout << "Not equal \n";
-	}
-	
-	double integral = p.compute_integral_of_landscape();
-	cout << "integral : " << integral <<endl;
-	
-	//compute integral for each level separatelly
-	for ( size_t level = 0 ; level != p.size() ; ++level )
-	{
-		cout << p.compute_integral_of_landscape( level ) << endl;
-	}
-	
-	//compute integral of p-th power of landscspe
-	for ( size_t power = 0 ; power != 5 ; ++power ) 
-	{
-		cout << p.compute_integral_of_landscape( power ) << endl;
-	}
-	
-	cout << "Value of level 1 at 0 : " <<  p.compute_value_at_a_given_point(1,0.0) << endl;
-	cout << "Value of level 1  at 1 : " <<  p.compute_value_at_a_given_point(1,0.1) << endl;
-	cout << "Value of level 1  at 2 : " <<  p.compute_value_at_a_given_point(1,0.2) << endl;
-	cout << "Value of level 1  at 3 : " <<  p.compute_value_at_a_given_point(1,0.3) << endl;
-	
-		
-	cout << "Value of level 2 at 0 : " <<  p.compute_value_at_a_given_point(2,0.0) << endl;
-	cout << "Value of level 2  at 1 : " <<  p.compute_value_at_a_given_point(2,0.1) << endl;
-	cout << "Value of level 2  at 2 : " <<  p.compute_value_at_a_given_point(2,0.2) << endl;
-	cout << "Value of level 2  at 3 : " <<  p.compute_value_at_a_given_point(2,0.3) << endl;
-	
-		
-	cout << "Value of level 3 at 0 : " <<  p.compute_value_at_a_given_point(3,0.0) << endl;
-	cout << "Value of level 3  at 1 : " <<  p.compute_value_at_a_given_point(3,0.1) << endl;
-	cout << "Value of level 3  at 2 : " <<  p.compute_value_at_a_given_point(3,0.2) << endl;
-	cout << "Value of level 3  at 3 : " <<  p.compute_value_at_a_given_point(3,0.3) << endl;
-	
-	
-	
-	Persistence_landscape second;
-	second.load_landscape_from_file("file_with_landscape_from_file_with_diagram_1" );
-	
-	Persistence_landscape sum = p + second;
-	Persistence_landscape difference = p - second;
-	Persistence_landscape multiply_by_scalar = 10*p;
-	
-	//sum.print_to_file("sum");
-	//difference.print_to_file("difference");
-	//multiply_by_scalar.print_to_file("multiply_by_scalar");
-	
-	Persistence_landscape template_sum;
-	template_sum.load_landscape_from_file( "sum" );
-	Persistence_landscape template_difference;
-	template_difference.load_landscape_from_file( "difference" );
-	Persistence_landscape template_multiply_by_scalar;
-	template_multiply_by_scalar.load_landscape_from_file( "multiply_by_scalar" );
-	
-	if ( sum != template_sum )
-	{
-		cerr << "Problem with sums \n";
-	}
-	if ( difference != template_difference )
-	{
-		cerr << "Problem with differences \n";
-	}
-	if ( multiply_by_scalar != template_multiply_by_scalar )
-	{
-		cerr << "Problem with multiplication by scalar \n";
-	}
-	
-	
-	
-	cout << "Maximum : " << p.compute_maximum() << endl;
-	
-	cout << "L^1 norm : " << p.compute_norm_of_landscape(1) << endl;
-	cout << "L^2 norm : " << p.compute_norm_of_landscape(2) << endl;
-	cout << "L^3 norm : " << p.compute_norm_of_landscape(3) << endl;	
-	
-	
-	cout << "L^1 distance : " << compute_distance_of_landscapes(p,sum,1) << endl;
-	cout << "L^2 distance : " << compute_distance_of_landscapes(p,sum,2) << endl;
-	cout << "L^infty distance : " << compute_distance_of_landscapes(p,sum,std::numeric_limits<double>::max() ) << endl;
-	
-	{
-		Persistence_landscape p( "../test/data/file_with_diagram" );
-		Persistence_landscape q( "../test/data/file_with_diagram_1" );
-		Persistence_landscape av;
-		av.compute_average( {&p,&q} );
-	
-		Persistence_landscape template_average;
-		template_average.load_landscape_from_file( "average" );
-		if ( template_average != av )
-		{
-			cerr << "We have a problem with average \n";
-		}
-	}
-	
-	
-	{
-		Persistence_landscape p( "../test/data/file_with_diagram" );
-		Persistence_landscape q( "../test/data/file_with_diagram_1" );
-		cout << "L^1 distance : " <<  p.distance( &q ) << endl;
-		cout << "L^2 distance : " <<  p.distance( &q , 2) << endl;
-		cout << "L^infty distance : " <<  p.distance( &q , std::numeric_limits<double>::max() ) << endl;
-	}
-	
-	
-	{
-		Persistence_landscape p( "../test/data/file_with_diagram" );
-		Persistence_landscape q( "../test/data/file_with_diagram_1" );
-		cout << "Scalar product : " <<  p.compute_scalar_product( &q ) << endl;		
-	}
-*/ 
+        {
+                std::cerr << "To run this program, please provide a name of a file with persistence landscape \n";
+                //return 1;
+        }
+        Persistence_landscape p("../test/data/file_with_diagram");
+
+        Persistence_landscape q;
+        q.load_landscape_from_file( "file_with_landscape_from_file_with_diagram" );
+
+        if ( p != q )
+        {
+                cout << "Not equal \n";
+        }
+
+        double integral = p.compute_integral_of_landscape();
+        cout << "integral : " << integral <<endl;
+
+        //compute integral for each level separatelly
+        for ( size_t level = 0 ; level != p.size() ; ++level )
+        {
+                cout << p.compute_integral_of_landscape( level ) << endl;
+        }
+
+        //compute integral of p-th power of landscspe
+        for ( size_t power = 0 ; power != 5 ; ++power )
+        {
+                cout << p.compute_integral_of_landscape( power ) << endl;
+        }
+
+        cout << "Value of level 1 at 0 : " <<  p.compute_value_at_a_given_point(1,0.0) << endl;
+        cout << "Value of level 1  at 1 : " <<  p.compute_value_at_a_given_point(1,0.1) << endl;
+        cout << "Value of level 1  at 2 : " <<  p.compute_value_at_a_given_point(1,0.2) << endl;
+        cout << "Value of level 1  at 3 : " <<  p.compute_value_at_a_given_point(1,0.3) << endl;
+
+
+        cout << "Value of level 2 at 0 : " <<  p.compute_value_at_a_given_point(2,0.0) << endl;
+        cout << "Value of level 2  at 1 : " <<  p.compute_value_at_a_given_point(2,0.1) << endl;
+        cout << "Value of level 2  at 2 : " <<  p.compute_value_at_a_given_point(2,0.2) << endl;
+        cout << "Value of level 2  at 3 : " <<  p.compute_value_at_a_given_point(2,0.3) << endl;
+
+
+        cout << "Value of level 3 at 0 : " <<  p.compute_value_at_a_given_point(3,0.0) << endl;
+        cout << "Value of level 3  at 1 : " <<  p.compute_value_at_a_given_point(3,0.1) << endl;
+        cout << "Value of level 3  at 2 : " <<  p.compute_value_at_a_given_point(3,0.2) << endl;
+        cout << "Value of level 3  at 3 : " <<  p.compute_value_at_a_given_point(3,0.3) << endl;
+
+
+
+        Persistence_landscape second;
+        second.load_landscape_from_file("file_with_landscape_from_file_with_diagram_1" );
+
+        Persistence_landscape sum = p + second;
+        Persistence_landscape difference = p - second;
+        Persistence_landscape multiply_by_scalar = 10*p;
+
+        //sum.print_to_file("sum");
+        //difference.print_to_file("difference");
+        //multiply_by_scalar.print_to_file("multiply_by_scalar");
+
+        Persistence_landscape template_sum;
+        template_sum.load_landscape_from_file( "sum" );
+        Persistence_landscape template_difference;
+        template_difference.load_landscape_from_file( "difference" );
+        Persistence_landscape template_multiply_by_scalar;
+        template_multiply_by_scalar.load_landscape_from_file( "multiply_by_scalar" );
+
+        if ( sum != template_sum )
+        {
+                cerr << "Problem with sums \n";
+        }
+        if ( difference != template_difference )
+        {
+                cerr << "Problem with differences \n";
+        }
+        if ( multiply_by_scalar != template_multiply_by_scalar )
+        {
+                cerr << "Problem with multiplication by scalar \n";
+        }
+
+
+
+        cout << "Maximum : " << p.compute_maximum() << endl;
+
+        cout << "L^1 norm : " << p.compute_norm_of_landscape(1) << endl;
+        cout << "L^2 norm : " << p.compute_norm_of_landscape(2) << endl;
+        cout << "L^3 norm : " << p.compute_norm_of_landscape(3) << endl;
+
+
+        cout << "L^1 distance : " << compute_distance_of_landscapes(p,sum,1) << endl;
+        cout << "L^2 distance : " << compute_distance_of_landscapes(p,sum,2) << endl;
+        cout << "L^infty distance : " << compute_distance_of_landscapes(p,sum,std::numeric_limits<double>::max() ) <<
+endl;
+
+        {
+                Persistence_landscape p( "../test/data/file_with_diagram" );
+                Persistence_landscape q( "../test/data/file_with_diagram_1" );
+                Persistence_landscape av;
+                av.compute_average( {&p,&q} );
+
+                Persistence_landscape template_average;
+                template_average.load_landscape_from_file( "average" );
+                if ( template_average != av )
+                {
+                        cerr << "We have a problem with average \n";
+                }
+        }
+
+
+        {
+                Persistence_landscape p( "../test/data/file_with_diagram" );
+                Persistence_landscape q( "../test/data/file_with_diagram_1" );
+                cout << "L^1 distance : " <<  p.distance( &q ) << endl;
+                cout << "L^2 distance : " <<  p.distance( &q , 2) << endl;
+                cout << "L^infty distance : " <<  p.distance( &q , std::numeric_limits<double>::max() ) << endl;
+        }
+
+
+        {
+                Persistence_landscape p( "../test/data/file_with_diagram" );
+                Persistence_landscape q( "../test/data/file_with_diagram_1" );
+                cout << "Scalar product : " <<  p.compute_scalar_product( &q ) << endl;
+        }
+*/
diff --git a/src/Persistence_representations/test/read_persistence_from_file_test.cpp b/src/Persistence_representations/test/read_persistence_from_file_test.cpp
index 69493efb..924a67a1 100644
--- a/src/Persistence_representations/test/read_persistence_from_file_test.cpp
+++ b/src/Persistence_representations/test/read_persistence_from_file_test.cpp
@@ -20,8 +20,6 @@
  *    along with this program.  If not, see <http://www.gnu.org/licenses/>.
  */
 
-
-
 #define BOOST_TEST_DYN_LINK
 #define BOOST_TEST_MODULE "Persistence_representations"
 #include <boost/test/unit_test.hpp>
@@ -30,86 +28,71 @@
 
 #include <iostream>
 
-
-
 using namespace Gudhi;
 using namespace Gudhi::Persistence_representations;
 
+BOOST_AUTO_TEST_CASE(test_read_file_with_four_elements_per_line) {
+  std::vector<std::pair<double, double> > what_we_should_get;
+  what_we_should_get.push_back(std::make_pair(0, 2));
+  what_we_should_get.push_back(std::make_pair(10, 1000));
+  what_we_should_get.push_back(std::make_pair(10, 90));
+  what_we_should_get.push_back(std::make_pair(4, 4));
+  std::vector<std::pair<double, double> > what_we_get = read_persistence_intervals_in_one_dimension_from_file(
+      "data/persistence_file_with_four_entries_per_line", 1, 1000);
+
+  // for ( size_t i = 0 ; i != what_we_get.size() ; ++i )
+  //{
+  //	std::cerr << what_we_get[i].first << " , " << what_we_get[i].second << std::endl;
+  //}
+
+  BOOST_CHECK(what_we_should_get.size() == what_we_get.size());
+
+  for (size_t i = 0; i != what_we_get.size(); ++i) {
+    BOOST_CHECK(what_we_should_get[i] == what_we_get[i]);
+  }
+}
 
+BOOST_AUTO_TEST_CASE(test_read_file_with_three_elements_per_line) {
+  std::vector<std::pair<double, double> > what_we_should_get;
+  what_we_should_get.push_back(std::make_pair(4, 9999));
+  what_we_should_get.push_back(std::make_pair(0, 1));
+  what_we_should_get.push_back(std::make_pair(1, 9999));
+  what_we_should_get.push_back(std::make_pair(10, 90));
+  what_we_should_get.push_back(std::make_pair(4, 4));
 
-	
-
-BOOST_AUTO_TEST_CASE(test_read_file_with_four_elements_per_line) 
-{	
-	std::vector< std::pair< double,double > > what_we_should_get;
-	what_we_should_get.push_back( std::make_pair( 0 , 2 ) );
-	what_we_should_get.push_back( std::make_pair( 10 , 1000 ) );
-	what_we_should_get.push_back( std::make_pair( 10 , 90 ) );
-	what_we_should_get.push_back( std::make_pair( 4 , 4 ) );		
-	std::vector<std::pair<double,double> > what_we_get = read_persistence_intervals_in_one_dimension_from_file("data/persistence_file_with_four_entries_per_line" , 1 , 1000 );
-	
-	
-	//for ( size_t i = 0 ; i != what_we_get.size() ; ++i )
-	//{
-	//	std::cerr << what_we_get[i].first << " , " << what_we_get[i].second << std::endl;
-	//}
-	
-	BOOST_CHECK( what_we_should_get.size() == what_we_get.size() );
-	
-	for ( size_t i = 0 ; i != what_we_get.size() ; ++i )
-	{
-		BOOST_CHECK( what_we_should_get[i] == what_we_get[i] );
-	}
-}
+  std::vector<std::pair<double, double> > what_we_get = read_persistence_intervals_in_one_dimension_from_file(
+      "data/persistence_file_with_three_entries_per_line", 1, 9999);
 
+  // for ( size_t i = 0 ; i != what_we_get.size() ; ++i )
+  //{
+  //	std::cerr << what_we_get[i].first << " , " << what_we_get[i].second << std::endl;
+  //}
 
-BOOST_AUTO_TEST_CASE(test_read_file_with_three_elements_per_line) 
-{	
-	std::vector< std::pair< double,double > > what_we_should_get;	
-	what_we_should_get.push_back( std::make_pair( 4 , 9999 ) );
-	what_we_should_get.push_back( std::make_pair( 0 , 1 ) );
-	what_we_should_get.push_back( std::make_pair( 1 , 9999 ) );
-	what_we_should_get.push_back( std::make_pair( 10 , 90 ) );
-	what_we_should_get.push_back( std::make_pair( 4 , 4 ) );
-	
-	std::vector<std::pair<double,double> > what_we_get = read_persistence_intervals_in_one_dimension_from_file("data/persistence_file_with_three_entries_per_line" , 1 , 9999 );
-	
-	
-	//for ( size_t i = 0 ; i != what_we_get.size() ; ++i )
-	//{
-	//	std::cerr << what_we_get[i].first << " , " << what_we_get[i].second << std::endl;
-	//}
-	
-	BOOST_CHECK( what_we_should_get.size() == what_we_get.size() );
-	
-	for ( size_t i = 0 ; i != what_we_get.size() ; ++i )
-	{
-		BOOST_CHECK( what_we_should_get[i] == what_we_get[i] );
-	}
+  BOOST_CHECK(what_we_should_get.size() == what_we_get.size());
+
+  for (size_t i = 0; i != what_we_get.size(); ++i) {
+    BOOST_CHECK(what_we_should_get[i] == what_we_get[i]);
+  }
 }
 
+BOOST_AUTO_TEST_CASE(test_read_file_with_two_elements_per_line) {
+  std::vector<std::pair<double, double> > what_we_should_get;
+  what_we_should_get.push_back(std::make_pair(4, 10));
+  what_we_should_get.push_back(std::make_pair(4, 9999));
+  what_we_should_get.push_back(std::make_pair(0, 1));
+  what_we_should_get.push_back(std::make_pair(1, 4));
 
-BOOST_AUTO_TEST_CASE(test_read_file_with_two_elements_per_line) 
-{	
-	std::vector< std::pair< double,double > > what_we_should_get;	
-	what_we_should_get.push_back( std::make_pair( 4 , 10 ) );
-	what_we_should_get.push_back( std::make_pair( 4 , 9999 ) );
-	what_we_should_get.push_back( std::make_pair( 0 , 1 ) );
-	what_we_should_get.push_back( std::make_pair( 1 , 4 ) );	
-	
-	std::vector<std::pair<double,double> > what_we_get = read_persistence_intervals_in_one_dimension_from_file("data/persistence_file_with_two_entries_per_line" , 1 , 9999 );
-	
-	
-	//for ( size_t i = 0 ; i != what_we_get.size() ; ++i )
-	//{
-	//	std::cerr << what_we_get[i].first << " , " << what_we_get[i].second << std::endl;
-	//}
-	
-	BOOST_CHECK( what_we_should_get.size() == what_we_get.size() );
-	
-	for ( size_t i = 0 ; i != what_we_get.size() ; ++i )
-	{
-		BOOST_CHECK( what_we_should_get[i] == what_we_get[i] );
-	}
-}
+  std::vector<std::pair<double, double> > what_we_get =
+      read_persistence_intervals_in_one_dimension_from_file("data/persistence_file_with_two_entries_per_line", 1, 9999);
+
+  // for ( size_t i = 0 ; i != what_we_get.size() ; ++i )
+  //{
+  //	std::cerr << what_we_get[i].first << " , " << what_we_get[i].second << std::endl;
+  //}
 
+  BOOST_CHECK(what_we_should_get.size() == what_we_get.size());
+
+  for (size_t i = 0; i != what_we_get.size(); ++i) {
+    BOOST_CHECK(what_we_should_get[i] == what_we_get[i]);
+  }
+}
diff --git a/src/Persistence_representations/test/vector_representation_test.cpp b/src/Persistence_representations/test/vector_representation_test.cpp
index 5e185445..d541d3e1 100644
--- a/src/Persistence_representations/test/vector_representation_test.cpp
+++ b/src/Persistence_representations/test/vector_representation_test.cpp
@@ -20,7 +20,6 @@
  *    along with this program.  If not, see <http://www.gnu.org/licenses/>.
  */
 
-
 #include <gudhi/Persistence_vectors.h>
 #include <gudhi/common_persistence_representations.h>
 #include <iostream>
@@ -33,381 +32,351 @@
 #include <cmath>
 #include <iomanip>
 
-
 using namespace Gudhi;
 using namespace Gudhi::Persistence_representations;
 
+BOOST_AUTO_TEST_CASE(check_read_write_to_files) {
+  std::vector<std::pair<double, double> > intervals;
+  intervals.push_back(std::make_pair(2, 3));
+  intervals.push_back(std::make_pair(4, 7));
+  intervals.push_back(std::make_pair(9, 10));
+  intervals.push_back(std::make_pair(3, 11));
+  Vector_distances_in_diagram<Euclidean_distance> p(intervals, -1);
+  p.write_to_file("test_vector_representation_write_read");
 
+  Vector_distances_in_diagram<Euclidean_distance> q;
+  q.load_from_file("test_vector_representation_write_read");
 
-
-
-
-
-BOOST_AUTO_TEST_CASE(check_read_write_to_files) 
-{
-	std::vector< std::pair<double,double> > intervals;
-	intervals.push_back( std::make_pair(2,3) );
-	intervals.push_back( std::make_pair(4,7) );
-	intervals.push_back( std::make_pair(9,10) );
-	intervals.push_back( std::make_pair(3,11) );
-	Vector_distances_in_diagram< Euclidean_distance > p( intervals , -1 );
-	p.write_to_file( "test_vector_representation_write_read" );
-	
-	Vector_distances_in_diagram< Euclidean_distance > q;
-	q.load_from_file( "test_vector_representation_write_read" );
-	
-	BOOST_CHECK( p == q );
-	
+  BOOST_CHECK(p == q);
 }
 
+BOOST_AUTO_TEST_CASE(check_sortev_vector_distances_template) {
+  Vector_distances_in_diagram<Euclidean_distance> p("data/file_with_diagram", 100);
+  std::vector<double> sortev_vector_distances_template;
+
+  sortev_vector_distances_template.push_back(0.609968);
+  sortev_vector_distances_template.push_back(0.566317);
+  sortev_vector_distances_template.push_back(0.538858);
+  sortev_vector_distances_template.push_back(0.534927);
+  sortev_vector_distances_template.push_back(0.515741);
+  sortev_vector_distances_template.push_back(0.507828);
+  sortev_vector_distances_template.push_back(0.500911);
+  sortev_vector_distances_template.push_back(0.496986);
+  sortev_vector_distances_template.push_back(0.495306);
+  sortev_vector_distances_template.push_back(0.439945);
+  sortev_vector_distances_template.push_back(0.424097);
+  sortev_vector_distances_template.push_back(0.413891);
+  sortev_vector_distances_template.push_back(0.413891);
+  sortev_vector_distances_template.push_back(0.413891);
+  sortev_vector_distances_template.push_back(0.412621);
+  sortev_vector_distances_template.push_back(0.410613);
+  sortev_vector_distances_template.push_back(0.407853);
+  sortev_vector_distances_template.push_back(0.407853);
+  sortev_vector_distances_template.push_back(0.402306);
+  sortev_vector_distances_template.push_back(0.401937);
+  sortev_vector_distances_template.push_back(0.377605);
+  sortev_vector_distances_template.push_back(0.363859);
+  sortev_vector_distances_template.push_back(0.357765);
+  sortev_vector_distances_template.push_back(0.357765);
+  sortev_vector_distances_template.push_back(0.357765);
+  sortev_vector_distances_template.push_back(0.357765);
+  sortev_vector_distances_template.push_back(0.357765);
+  sortev_vector_distances_template.push_back(0.353401);
+  sortev_vector_distances_template.push_back(0.348004);
+  sortev_vector_distances_template.push_back(0.345124);
+  sortev_vector_distances_template.push_back(0.345124);
+  sortev_vector_distances_template.push_back(0.345124);
+  sortev_vector_distances_template.push_back(0.345124);
+  sortev_vector_distances_template.push_back(0.345124);
+  sortev_vector_distances_template.push_back(0.345124);
+  sortev_vector_distances_template.push_back(0.345124);
+  sortev_vector_distances_template.push_back(0.345124);
+  sortev_vector_distances_template.push_back(0.345124);
+  sortev_vector_distances_template.push_back(0.345124);
+  sortev_vector_distances_template.push_back(0.345124);
+  sortev_vector_distances_template.push_back(0.345124);
+  sortev_vector_distances_template.push_back(0.345124);
+  sortev_vector_distances_template.push_back(0.345124);
+  sortev_vector_distances_template.push_back(0.34469);
+  sortev_vector_distances_template.push_back(0.339466);
+  sortev_vector_distances_template.push_back(0.33935);
+  sortev_vector_distances_template.push_back(0.32834);
+  sortev_vector_distances_template.push_back(0.327276);
+  sortev_vector_distances_template.push_back(0.318626);
+  sortev_vector_distances_template.push_back(0.318082);
+  sortev_vector_distances_template.push_back(0.30603);
+  sortev_vector_distances_template.push_back(0.30525);
+  sortev_vector_distances_template.push_back(0.297308);
+  sortev_vector_distances_template.push_back(0.296333);
+  sortev_vector_distances_template.push_back(0.296333);
+  sortev_vector_distances_template.push_back(0.296333);
+  sortev_vector_distances_template.push_back(0.296333);
+  sortev_vector_distances_template.push_back(0.293372);
+  sortev_vector_distances_template.push_back(0.292666);
+  sortev_vector_distances_template.push_back(0.292666);
+  sortev_vector_distances_template.push_back(0.292666);
+  sortev_vector_distances_template.push_back(0.292666);
+  sortev_vector_distances_template.push_back(0.292666);
+  sortev_vector_distances_template.push_back(0.292666);
+  sortev_vector_distances_template.push_back(0.292666);
+  sortev_vector_distances_template.push_back(0.292666);
+  sortev_vector_distances_template.push_back(0.292666);
+  sortev_vector_distances_template.push_back(0.292666);
+  sortev_vector_distances_template.push_back(0.292666);
+  sortev_vector_distances_template.push_back(0.292666);
+  sortev_vector_distances_template.push_back(0.292666);
+  sortev_vector_distances_template.push_back(0.292666);
+  sortev_vector_distances_template.push_back(0.292666);
+  sortev_vector_distances_template.push_back(0.29029);
+  sortev_vector_distances_template.push_back(0.290218);
+  sortev_vector_distances_template.push_back(0.289782);
+  sortev_vector_distances_template.push_back(0.288128);
+  sortev_vector_distances_template.push_back(0.286416);
+  sortev_vector_distances_template.push_back(0.285969);
+  sortev_vector_distances_template.push_back(0.282046);
+  sortev_vector_distances_template.push_back(0.28154);
+  sortev_vector_distances_template.push_back(0.281085);
+  sortev_vector_distances_template.push_back(0.280227);
+  sortev_vector_distances_template.push_back(0.279273);
+  sortev_vector_distances_template.push_back(0.278936);
+  sortev_vector_distances_template.push_back(0.278706);
+  sortev_vector_distances_template.push_back(0.278507);
+  sortev_vector_distances_template.push_back(0.278097);
+  sortev_vector_distances_template.push_back(0.276293);
+  sortev_vector_distances_template.push_back(0.276293);
+  sortev_vector_distances_template.push_back(0.276293);
+  sortev_vector_distances_template.push_back(0.276293);
+  sortev_vector_distances_template.push_back(0.276293);
+  sortev_vector_distances_template.push_back(0.276293);
+  sortev_vector_distances_template.push_back(0.276293);
+  sortev_vector_distances_template.push_back(0.276293);
+  sortev_vector_distances_template.push_back(0.276293);
+  sortev_vector_distances_template.push_back(0.276169);
+  sortev_vector_distances_template.push_back(0.270563);
+  sortev_vector_distances_template.push_back(0.264009);
+
+  size_t proj_no = p.number_of_vectorize_functions();
+  std::vector<double> aa = p.vectorize(proj_no);
+
+  for (size_t i = 0; i != aa.size(); ++i) {
+    BOOST_CHECK(almost_equal(sortev_vector_distances_template[i], aa[i]));
+  }
+}
 
-BOOST_AUTO_TEST_CASE(check_sortev_vector_distances_template) 
-{	
-	Vector_distances_in_diagram< Euclidean_distance > p( "data/file_with_diagram" , 100 );
-	std::vector< double > sortev_vector_distances_template;
-
-	sortev_vector_distances_template.push_back(	0.609968	);
-	sortev_vector_distances_template.push_back(	0.566317	);
-	sortev_vector_distances_template.push_back(	0.538858	);
-	sortev_vector_distances_template.push_back(	0.534927	);
-	sortev_vector_distances_template.push_back(	0.515741	);
-	sortev_vector_distances_template.push_back(	0.507828	);
-	sortev_vector_distances_template.push_back(	0.500911	);
-	sortev_vector_distances_template.push_back(	0.496986	);
-	sortev_vector_distances_template.push_back(	0.495306	);
-	sortev_vector_distances_template.push_back(	0.439945	);
-	sortev_vector_distances_template.push_back(	0.424097	);
-	sortev_vector_distances_template.push_back(	0.413891	);
-	sortev_vector_distances_template.push_back(	0.413891	);
-	sortev_vector_distances_template.push_back(	0.413891	);
-	sortev_vector_distances_template.push_back(	0.412621	);
-	sortev_vector_distances_template.push_back(	0.410613	);
-	sortev_vector_distances_template.push_back(	0.407853	);
-	sortev_vector_distances_template.push_back(	0.407853	);
-	sortev_vector_distances_template.push_back(	0.402306	);
-	sortev_vector_distances_template.push_back(	0.401937	);
-	sortev_vector_distances_template.push_back(	0.377605	);
-	sortev_vector_distances_template.push_back(	0.363859	);
-	sortev_vector_distances_template.push_back(	0.357765	);
-	sortev_vector_distances_template.push_back(	0.357765	);
-	sortev_vector_distances_template.push_back(	0.357765	);
-	sortev_vector_distances_template.push_back(	0.357765	);
-	sortev_vector_distances_template.push_back(	0.357765	);
-	sortev_vector_distances_template.push_back(	0.353401	);
-	sortev_vector_distances_template.push_back(	0.348004	);
-	sortev_vector_distances_template.push_back(	0.345124	);
-	sortev_vector_distances_template.push_back(	0.345124	);
-	sortev_vector_distances_template.push_back(	0.345124	);
-	sortev_vector_distances_template.push_back(	0.345124	);
-	sortev_vector_distances_template.push_back(	0.345124	);
-	sortev_vector_distances_template.push_back(	0.345124	);
-	sortev_vector_distances_template.push_back(	0.345124	);
-	sortev_vector_distances_template.push_back(	0.345124	);
-	sortev_vector_distances_template.push_back(	0.345124	);
-	sortev_vector_distances_template.push_back(	0.345124	);
-	sortev_vector_distances_template.push_back(	0.345124	);
-	sortev_vector_distances_template.push_back(	0.345124	);
-	sortev_vector_distances_template.push_back(	0.345124	);
-	sortev_vector_distances_template.push_back(	0.345124	);
-	sortev_vector_distances_template.push_back(	0.34469	);
-	sortev_vector_distances_template.push_back(	0.339466	);
-	sortev_vector_distances_template.push_back(	0.33935	);
-	sortev_vector_distances_template.push_back(	0.32834	);
-	sortev_vector_distances_template.push_back(	0.327276	);
-	sortev_vector_distances_template.push_back(	0.318626	);
-	sortev_vector_distances_template.push_back(	0.318082	);
-	sortev_vector_distances_template.push_back(	0.30603	);
-	sortev_vector_distances_template.push_back(	0.30525	);
-	sortev_vector_distances_template.push_back(	0.297308	);
-	sortev_vector_distances_template.push_back(	0.296333	);
-	sortev_vector_distances_template.push_back(	0.296333	);
-	sortev_vector_distances_template.push_back(	0.296333	);
-	sortev_vector_distances_template.push_back(	0.296333	);
-	sortev_vector_distances_template.push_back(	0.293372	);
-	sortev_vector_distances_template.push_back(	0.292666	);
-	sortev_vector_distances_template.push_back(	0.292666	);
-	sortev_vector_distances_template.push_back(	0.292666	);
-	sortev_vector_distances_template.push_back(	0.292666	);
-	sortev_vector_distances_template.push_back(	0.292666	);
-	sortev_vector_distances_template.push_back(	0.292666	);
-	sortev_vector_distances_template.push_back(	0.292666	);
-	sortev_vector_distances_template.push_back(	0.292666	);
-	sortev_vector_distances_template.push_back(	0.292666	);
-	sortev_vector_distances_template.push_back(	0.292666	);
-	sortev_vector_distances_template.push_back(	0.292666	);
-	sortev_vector_distances_template.push_back(	0.292666	);
-	sortev_vector_distances_template.push_back(	0.292666	);
-	sortev_vector_distances_template.push_back(	0.292666	);
-	sortev_vector_distances_template.push_back(	0.292666	);
-	sortev_vector_distances_template.push_back(	0.29029	);
-	sortev_vector_distances_template.push_back(	0.290218	);
-	sortev_vector_distances_template.push_back(	0.289782	);
-	sortev_vector_distances_template.push_back(	0.288128	);
-	sortev_vector_distances_template.push_back(	0.286416	);
-	sortev_vector_distances_template.push_back(	0.285969	);
-	sortev_vector_distances_template.push_back(	0.282046	);
-	sortev_vector_distances_template.push_back(	0.28154	);
-	sortev_vector_distances_template.push_back(	0.281085	);
-	sortev_vector_distances_template.push_back(	0.280227	);
-	sortev_vector_distances_template.push_back(	0.279273	);
-	sortev_vector_distances_template.push_back(	0.278936	);
-	sortev_vector_distances_template.push_back(	0.278706	);
-	sortev_vector_distances_template.push_back(	0.278507	);
-	sortev_vector_distances_template.push_back(	0.278097	);
-	sortev_vector_distances_template.push_back(	0.276293	);
-	sortev_vector_distances_template.push_back(	0.276293	);
-	sortev_vector_distances_template.push_back(	0.276293	);
-	sortev_vector_distances_template.push_back(	0.276293	);
-	sortev_vector_distances_template.push_back(	0.276293	);
-	sortev_vector_distances_template.push_back(	0.276293	);
-	sortev_vector_distances_template.push_back(	0.276293	);
-	sortev_vector_distances_template.push_back(	0.276293	);
-	sortev_vector_distances_template.push_back(	0.276293	);
-	sortev_vector_distances_template.push_back(	0.276169	);
-	sortev_vector_distances_template.push_back(	0.270563	);
-	sortev_vector_distances_template.push_back(	0.264009	);
-
-
- 
-	size_t proj_no = p.number_of_vectorize_functions();
-	std::vector< double > aa = p.vectorize(proj_no);
-	
-	for ( size_t i = 0 ; i != aa.size() ; ++i )	
-	{		
-		BOOST_CHECK( almost_equal( sortev_vector_distances_template[i] , aa[i] ) );
-	}
-}	
-
-
-
-
-BOOST_AUTO_TEST_CASE(check_projections_to_R) 
-{
-	Vector_distances_in_diagram< Euclidean_distance > p( "data/file_with_diagram" , 100 );
-	std::vector< double > proj;
-	proj.push_back(	0	);
-	proj.push_back(	0.6099679993	);
-	proj.push_back(	1.176284775	);
-	proj.push_back(	1.715142954	);
-	proj.push_back(	2.25006986	);
-	proj.push_back(	2.765810506	);
-	proj.push_back(	3.273638431	);
-	proj.push_back(	3.774549309	);
-	proj.push_back(	4.271535042	);
-	proj.push_back(	4.766840875	);
-	proj.push_back(	5.206786149	);
-	proj.push_back(	5.63088295	);
-	proj.push_back(	6.04477433	);
-	proj.push_back(	6.45866571	);
-	proj.push_back(	6.87255709	);
-	proj.push_back(	7.285177939	);
-	proj.push_back(	7.695791381	);
-	proj.push_back(	8.103643945	);
-	proj.push_back(	8.511496508	);
-	proj.push_back(	8.913802775	);
-	proj.push_back(	9.315740229	);
-	proj.push_back(	9.693344927	);
-	proj.push_back(	10.0572035	);
-	proj.push_back(	10.41496899	);
-	proj.push_back(	10.77273448	);
-	proj.push_back(	11.13049996	);
-	proj.push_back(	11.48826545	);
-	proj.push_back(	11.84603094	);
-	proj.push_back(	12.19943233	);
-	proj.push_back(	12.5474364	);
-	proj.push_back(	12.89256042	);
-	proj.push_back(	13.23768444	);
-	proj.push_back(	13.58280846	);
-	proj.push_back(	13.92793248	);
-	proj.push_back(	14.2730565	);
-	proj.push_back(	14.61818051	);
-	proj.push_back(	14.96330453	);
-	proj.push_back(	15.30842855	);
-	proj.push_back(	15.65355257	);
-	proj.push_back(	15.99867659	);
-	proj.push_back(	16.34380061	);
-	proj.push_back(	16.68892462	);
-	proj.push_back(	17.03404864	);
-	proj.push_back(	17.37917266	);
-	proj.push_back(	17.7238622	);
-	proj.push_back(	18.06332781	);
-	proj.push_back(	18.40267754	);
-	proj.push_back(	18.73101759	);
-	proj.push_back(	19.05829313	);
-	proj.push_back(	19.3769189	);
-	proj.push_back(	19.69500045	);
-	proj.push_back(	20.0010306	);
-	proj.push_back(	20.30628026	);
-	proj.push_back(	20.60358868	);
-	proj.push_back(	20.89992192	);
-	proj.push_back(	21.19625516	);
-	proj.push_back(	21.4925884	);
-	proj.push_back(	21.78892164	);
-	proj.push_back(	22.08229394	);
-	proj.push_back(	22.37495987	);
-	proj.push_back(	22.66762581	);
-	proj.push_back(	22.96029174	);
-	proj.push_back(	23.25295768	);
-	proj.push_back(	23.54562361	);
-	proj.push_back(	23.83828955	);
-	proj.push_back(	24.13095549	);
-	proj.push_back(	24.42362142	);
-	proj.push_back(	24.71628736	);
-	proj.push_back(	25.00895329	);
-	proj.push_back(	25.30161923	);
-	proj.push_back(	25.59428516	);
-	proj.push_back(	25.8869511	);
-	proj.push_back(	26.17961703	);
-	proj.push_back(	26.47228297	);
-	proj.push_back(	26.76257262	);
-	proj.push_back(	27.05279049	);
-	proj.push_back(	27.34257265	);
-	proj.push_back(	27.63070097	);
-	proj.push_back(	27.91711687	);
-	proj.push_back(	28.20308566	);
-	proj.push_back(	28.48513176	);
-	proj.push_back(	28.76667161	);
-	proj.push_back(	29.04775635	);
-	proj.push_back(	29.32798359	);
-	proj.push_back(	29.60725702	);
-	proj.push_back(	29.88619335	);
-	proj.push_back(	30.16489915	);
-	proj.push_back(	30.44340655	);
-	proj.push_back(	30.72150329	);
-	proj.push_back(	30.99779604	);
-	proj.push_back(	31.27408878	);
-	proj.push_back(	31.55038153	);
-	proj.push_back(	31.82667427	);
-	proj.push_back(	32.10296702	);
-	proj.push_back(	32.37925976	);
-	proj.push_back(	32.6555525	);
-	proj.push_back(	32.93184525	);
-	proj.push_back(	33.20813799	);
-	proj.push_back(	33.48430662	);
-	proj.push_back(	33.7548692	);
-
-	for ( size_t proj_no = 0 ; proj_no != p.number_of_projections_to_R() ; ++proj_no )	 
-	{		
-		//cout << std::setprecision(10)  << 	p.project_to_R(proj_no) << endl;
-		BOOST_CHECK( almost_equal( p.project_to_R(proj_no) , proj[proj_no] ) );
-	}
+BOOST_AUTO_TEST_CASE(check_projections_to_R) {
+  Vector_distances_in_diagram<Euclidean_distance> p("data/file_with_diagram", 100);
+  std::vector<double> proj;
+  proj.push_back(0);
+  proj.push_back(0.6099679993);
+  proj.push_back(1.176284775);
+  proj.push_back(1.715142954);
+  proj.push_back(2.25006986);
+  proj.push_back(2.765810506);
+  proj.push_back(3.273638431);
+  proj.push_back(3.774549309);
+  proj.push_back(4.271535042);
+  proj.push_back(4.766840875);
+  proj.push_back(5.206786149);
+  proj.push_back(5.63088295);
+  proj.push_back(6.04477433);
+  proj.push_back(6.45866571);
+  proj.push_back(6.87255709);
+  proj.push_back(7.285177939);
+  proj.push_back(7.695791381);
+  proj.push_back(8.103643945);
+  proj.push_back(8.511496508);
+  proj.push_back(8.913802775);
+  proj.push_back(9.315740229);
+  proj.push_back(9.693344927);
+  proj.push_back(10.0572035);
+  proj.push_back(10.41496899);
+  proj.push_back(10.77273448);
+  proj.push_back(11.13049996);
+  proj.push_back(11.48826545);
+  proj.push_back(11.84603094);
+  proj.push_back(12.19943233);
+  proj.push_back(12.5474364);
+  proj.push_back(12.89256042);
+  proj.push_back(13.23768444);
+  proj.push_back(13.58280846);
+  proj.push_back(13.92793248);
+  proj.push_back(14.2730565);
+  proj.push_back(14.61818051);
+  proj.push_back(14.96330453);
+  proj.push_back(15.30842855);
+  proj.push_back(15.65355257);
+  proj.push_back(15.99867659);
+  proj.push_back(16.34380061);
+  proj.push_back(16.68892462);
+  proj.push_back(17.03404864);
+  proj.push_back(17.37917266);
+  proj.push_back(17.7238622);
+  proj.push_back(18.06332781);
+  proj.push_back(18.40267754);
+  proj.push_back(18.73101759);
+  proj.push_back(19.05829313);
+  proj.push_back(19.3769189);
+  proj.push_back(19.69500045);
+  proj.push_back(20.0010306);
+  proj.push_back(20.30628026);
+  proj.push_back(20.60358868);
+  proj.push_back(20.89992192);
+  proj.push_back(21.19625516);
+  proj.push_back(21.4925884);
+  proj.push_back(21.78892164);
+  proj.push_back(22.08229394);
+  proj.push_back(22.37495987);
+  proj.push_back(22.66762581);
+  proj.push_back(22.96029174);
+  proj.push_back(23.25295768);
+  proj.push_back(23.54562361);
+  proj.push_back(23.83828955);
+  proj.push_back(24.13095549);
+  proj.push_back(24.42362142);
+  proj.push_back(24.71628736);
+  proj.push_back(25.00895329);
+  proj.push_back(25.30161923);
+  proj.push_back(25.59428516);
+  proj.push_back(25.8869511);
+  proj.push_back(26.17961703);
+  proj.push_back(26.47228297);
+  proj.push_back(26.76257262);
+  proj.push_back(27.05279049);
+  proj.push_back(27.34257265);
+  proj.push_back(27.63070097);
+  proj.push_back(27.91711687);
+  proj.push_back(28.20308566);
+  proj.push_back(28.48513176);
+  proj.push_back(28.76667161);
+  proj.push_back(29.04775635);
+  proj.push_back(29.32798359);
+  proj.push_back(29.60725702);
+  proj.push_back(29.88619335);
+  proj.push_back(30.16489915);
+  proj.push_back(30.44340655);
+  proj.push_back(30.72150329);
+  proj.push_back(30.99779604);
+  proj.push_back(31.27408878);
+  proj.push_back(31.55038153);
+  proj.push_back(31.82667427);
+  proj.push_back(32.10296702);
+  proj.push_back(32.37925976);
+  proj.push_back(32.6555525);
+  proj.push_back(32.93184525);
+  proj.push_back(33.20813799);
+  proj.push_back(33.48430662);
+  proj.push_back(33.7548692);
+
+  for (size_t proj_no = 0; proj_no != p.number_of_projections_to_R(); ++proj_no) {
+    // cout << std::setprecision(10)  << 	p.project_to_R(proj_no) << endl;
+    BOOST_CHECK(almost_equal(p.project_to_R(proj_no), proj[proj_no]));
+  }
 }
 
+BOOST_AUTO_TEST_CASE(check_distance_computations) {
+  Vector_distances_in_diagram<Euclidean_distance> p("data/file_with_diagram", 100);
+  Vector_distances_in_diagram<Euclidean_distance> p_prime("data/file_with_diagram", 10);
+  std::vector<std::pair<double, double> > intervals(10);
+  intervals[0] = std::pair<double, double>(1, 2);
+  intervals[1] = std::pair<double, double>(3, 4);
+  intervals[2] = std::pair<double, double>(5, 6);
+  intervals[3] = std::pair<double, double>(7, 8);
+  intervals[4] = std::pair<double, double>(9, 10);
+  intervals[5] = std::pair<double, double>(11, 12);
+  intervals[6] = std::pair<double, double>(13, 14);
+  intervals[7] = std::pair<double, double>(15, 16);
+  intervals[8] = std::pair<double, double>(17, 18);
+  intervals[9] = std::pair<double, double>(19, 20);
+  Vector_distances_in_diagram<Euclidean_distance> p_bis(intervals, 10);
+  // cerr << "p_prime.distance( (Abs_Topological_data_with_distances*)(&p_bis) , 1 ) : " << p_prime.distance(
+  // (Abs_Topological_data_with_distances*)(&p_bis) , 1 ) << endl;
+  BOOST_CHECK(almost_equal(p_prime.distance(p_bis, 1), 1.86428));
+}
 
+BOOST_AUTO_TEST_CASE(check_default_parameters_of_distances) {
+  std::vector<std::pair<double, double> > diag =
+      read_persistence_intervals_in_one_dimension_from_file("data/file_with_diagram");
+  Vector_distances_in_diagram<Euclidean_distance> p(diag, 100);
 
+  std::vector<std::pair<double, double> > diag1 =
+      read_persistence_intervals_in_one_dimension_from_file("data/file_with_diagram_1");
+  Vector_distances_in_diagram<Euclidean_distance> q(diag1, 100);
 
+  double dist_numeric_limit_max = p.distance(q, std::numeric_limits<double>::max());
+  double dist_infinity = p.distance(q, std::numeric_limits<double>::infinity());
 
-BOOST_AUTO_TEST_CASE(check_distance_computations) 
-{
-	Vector_distances_in_diagram< Euclidean_distance > p( "data/file_with_diagram" , 100 );
-	Vector_distances_in_diagram< Euclidean_distance > p_prime( "data/file_with_diagram" , 10 );	
-	std::vector< std::pair<double,double> > intervals(10);
-	intervals[0] = std::pair<double,double>( 1,2 );
-	intervals[1] = std::pair<double,double>( 3,4 );
-	intervals[2] = std::pair<double,double>( 5,6 );
-	intervals[3] = std::pair<double,double>( 7,8 );
-	intervals[4] = std::pair<double,double>( 9,10 );
-	intervals[5] = std::pair<double,double>( 11,12 );
-	intervals[6] = std::pair<double,double>( 13,14 );
-	intervals[7] = std::pair<double,double>( 15,16 );
-	intervals[8] = std::pair<double,double>( 17,18 );
-	intervals[9] = std::pair<double,double>( 19,20 );		
-	Vector_distances_in_diagram< Euclidean_distance > p_bis( intervals , 10 );	
-	//cerr << "p_prime.distance( (Abs_Topological_data_with_distances*)(&p_bis) , 1 ) : " << p_prime.distance( (Abs_Topological_data_with_distances*)(&p_bis) , 1 ) << endl;	
-	BOOST_CHECK( almost_equal ( p_prime.distance( p_bis , 1 ) , 1.86428 ) );		
+  BOOST_CHECK(dist_numeric_limit_max == dist_infinity);
 }
 
-BOOST_AUTO_TEST_CASE(check_default_parameters_of_distances ) 
-{	
-	std::vector< std::pair< double , double > > diag = read_persistence_intervals_in_one_dimension_from_file( "data/file_with_diagram" );	
-	Vector_distances_in_diagram< Euclidean_distance > p( diag , 100 );
-	
-	std::vector< std::pair< double , double > > diag1 = read_persistence_intervals_in_one_dimension_from_file( "data/file_with_diagram_1" );	
-	Vector_distances_in_diagram< Euclidean_distance > q( diag1 , 100 );
-	
-	double dist_numeric_limit_max = p.distance( q,std::numeric_limits<double>::max()  );
-	double dist_infinity = p.distance( q,std::numeric_limits<double>::infinity() );
-	
-	BOOST_CHECK( dist_numeric_limit_max == dist_infinity );	
-}
+BOOST_AUTO_TEST_CASE(check_compute_average) {
+  Vector_distances_in_diagram<Euclidean_distance> p("data/file_with_diagram", 100);
+  // compute average
+  std::vector<std::pair<double, double> > i1(3);
+  i1[0] = std::pair<double, double>(1, 2);
+  i1[1] = std::pair<double, double>(3, 8);
+  i1[2] = std::pair<double, double>(1, 6);
 
+  std::vector<std::pair<double, double> > i2(3);
+  i2[0] = std::pair<double, double>(2, 9);
+  i2[1] = std::pair<double, double>(2, 15);
+  i2[2] = std::pair<double, double>(6, 17);
 
+  Vector_distances_in_diagram<Euclidean_distance> A(i1, -1);
+  Vector_distances_in_diagram<Euclidean_distance> B(i1, -1);
 
-BOOST_AUTO_TEST_CASE(check_compute_average) 
-{
-	Vector_distances_in_diagram< Euclidean_distance > p( "data/file_with_diagram" , 100 );
-	//compute average 
-	std::vector< std::pair<double,double> > i1(3);
-	i1[0] = std::pair<double,double>( 1,2 );
-	i1[1] = std::pair<double,double>( 3,8 );
-	i1[2] = std::pair<double,double>( 1,6 );
-	
-	std::vector< std::pair<double,double> > i2(3);
-	i2[0] = std::pair<double,double>( 2,9 );
-	i2[1] = std::pair<double,double>( 2,15);
-	i2[2] = std::pair<double,double>( 6,17 );
-	
-	Vector_distances_in_diagram< Euclidean_distance > A( i1 , -1 );
-	Vector_distances_in_diagram< Euclidean_distance > B( i1 , -1 );
+  Vector_distances_in_diagram<Euclidean_distance> average;
+  average.compute_average({&A, &B});
 
-	Vector_distances_in_diagram< Euclidean_distance > average; 
-	average.compute_average( {&A,&B} );
-	
-	Vector_distances_in_diagram< Euclidean_distance > template_average; 
-	template_average.load_from_file( "data/average_of_persistence_vectors" );
-		
-	BOOST_CHECK( template_average == average );
-	
-}
+  Vector_distances_in_diagram<Euclidean_distance> template_average;
+  template_average.load_from_file("data/average_of_persistence_vectors");
 
+  BOOST_CHECK(template_average == average);
+}
 
-	
-BOOST_AUTO_TEST_CASE(check_arythmetic_operations) 
-{
-	std::vector< std::pair<double,double> > i1(3);
-	i1[0] = std::pair<double,double>( 1,2 );
-	i1[1] = std::pair<double,double>( 3,8 );
-	i1[2] = std::pair<double,double>( 1,6 );
-	
-	std::vector< std::pair<double,double> > i2(3);
-	i2[0] = std::pair<double,double>( 2,9 );
-	i2[1] = std::pair<double,double>( 2,15);
-	i2[2] = std::pair<double,double>( 6,17 );
-	
-	Vector_distances_in_diagram< Euclidean_distance > A( i1 , -1 );
-	Vector_distances_in_diagram< Euclidean_distance > B( i1 , -1 );
-	
-	Vector_distances_in_diagram< Euclidean_distance > sum = A+B;
-	Vector_distances_in_diagram< Euclidean_distance > difference = A-B;
-		
-	BOOST_CHECK( almost_equal( sum.vector_in_position(0) , 7.07107) );
-	BOOST_CHECK( almost_equal( sum.vector_in_position(1) , 7.07107) );
-	BOOST_CHECK( almost_equal( sum.vector_in_position(2) , 5.65685) );
-	BOOST_CHECK( almost_equal( sum.vector_in_position(3) , 1.41421) );
-	BOOST_CHECK( almost_equal( sum.vector_in_position(4) , 1.41421) );
-	BOOST_CHECK( almost_equal( sum.vector_in_position(5) , 1.41421) );
-	
-	BOOST_CHECK( almost_equal( difference.vector_in_position(0) , 0) );
-	BOOST_CHECK( almost_equal( difference.vector_in_position(1) , 0) );
-	BOOST_CHECK( almost_equal( difference.vector_in_position(2) , 0) );
-	BOOST_CHECK( almost_equal( difference.vector_in_position(3) , 0) );
-	BOOST_CHECK( almost_equal( difference.vector_in_position(4) , 0) );
-	BOOST_CHECK( almost_equal( difference.vector_in_position(5) , 0) );
-	
-	Vector_distances_in_diagram< Euclidean_distance > prod = 2.*A;
-	BOOST_CHECK( almost_equal( prod.vector_in_position(0) , 7.07107) );
-	BOOST_CHECK( almost_equal( prod.vector_in_position(1) , 7.07107) );
-	BOOST_CHECK( almost_equal( prod.vector_in_position(2) , 5.65685) );
-	BOOST_CHECK( almost_equal( prod.vector_in_position(3) , 1.41421) );
-	BOOST_CHECK( almost_equal( prod.vector_in_position(4) , 1.41421) );
-	BOOST_CHECK( almost_equal( prod.vector_in_position(5) , 1.41421) );
-	
-	Vector_distances_in_diagram< Euclidean_distance > prod1 = A*2;
-	BOOST_CHECK( almost_equal( prod1.vector_in_position(0) , 7.07107) );
-	BOOST_CHECK( almost_equal( prod1.vector_in_position(1) , 7.07107) );
-	BOOST_CHECK( almost_equal( prod1.vector_in_position(2) , 5.65685) );
-	BOOST_CHECK( almost_equal( prod1.vector_in_position(3) , 1.41421) );
-	BOOST_CHECK( almost_equal( prod1.vector_in_position(4) , 1.41421) );
-	BOOST_CHECK( almost_equal( prod1.vector_in_position(5) , 1.41421) );
-	
+BOOST_AUTO_TEST_CASE(check_arythmetic_operations) {
+  std::vector<std::pair<double, double> > i1(3);
+  i1[0] = std::pair<double, double>(1, 2);
+  i1[1] = std::pair<double, double>(3, 8);
+  i1[2] = std::pair<double, double>(1, 6);
+
+  std::vector<std::pair<double, double> > i2(3);
+  i2[0] = std::pair<double, double>(2, 9);
+  i2[1] = std::pair<double, double>(2, 15);
+  i2[2] = std::pair<double, double>(6, 17);
+
+  Vector_distances_in_diagram<Euclidean_distance> A(i1, -1);
+  Vector_distances_in_diagram<Euclidean_distance> B(i1, -1);
+
+  Vector_distances_in_diagram<Euclidean_distance> sum = A + B;
+  Vector_distances_in_diagram<Euclidean_distance> difference = A - B;
+
+  BOOST_CHECK(almost_equal(sum.vector_in_position(0), 7.07107));
+  BOOST_CHECK(almost_equal(sum.vector_in_position(1), 7.07107));
+  BOOST_CHECK(almost_equal(sum.vector_in_position(2), 5.65685));
+  BOOST_CHECK(almost_equal(sum.vector_in_position(3), 1.41421));
+  BOOST_CHECK(almost_equal(sum.vector_in_position(4), 1.41421));
+  BOOST_CHECK(almost_equal(sum.vector_in_position(5), 1.41421));
+
+  BOOST_CHECK(almost_equal(difference.vector_in_position(0), 0));
+  BOOST_CHECK(almost_equal(difference.vector_in_position(1), 0));
+  BOOST_CHECK(almost_equal(difference.vector_in_position(2), 0));
+  BOOST_CHECK(almost_equal(difference.vector_in_position(3), 0));
+  BOOST_CHECK(almost_equal(difference.vector_in_position(4), 0));
+  BOOST_CHECK(almost_equal(difference.vector_in_position(5), 0));
+
+  Vector_distances_in_diagram<Euclidean_distance> prod = 2. * A;
+  BOOST_CHECK(almost_equal(prod.vector_in_position(0), 7.07107));
+  BOOST_CHECK(almost_equal(prod.vector_in_position(1), 7.07107));
+  BOOST_CHECK(almost_equal(prod.vector_in_position(2), 5.65685));
+  BOOST_CHECK(almost_equal(prod.vector_in_position(3), 1.41421));
+  BOOST_CHECK(almost_equal(prod.vector_in_position(4), 1.41421));
+  BOOST_CHECK(almost_equal(prod.vector_in_position(5), 1.41421));
+
+  Vector_distances_in_diagram<Euclidean_distance> prod1 = A * 2;
+  BOOST_CHECK(almost_equal(prod1.vector_in_position(0), 7.07107));
+  BOOST_CHECK(almost_equal(prod1.vector_in_position(1), 7.07107));
+  BOOST_CHECK(almost_equal(prod1.vector_in_position(2), 5.65685));
+  BOOST_CHECK(almost_equal(prod1.vector_in_position(3), 1.41421));
+  BOOST_CHECK(almost_equal(prod1.vector_in_position(4), 1.41421));
+  BOOST_CHECK(almost_equal(prod1.vector_in_position(5), 1.41421));
 }
diff --git a/src/Persistence_representations/utilities/persistence_heat_maps/average_persistence_heat_maps.cpp b/src/Persistence_representations/utilities/persistence_heat_maps/average_persistence_heat_maps.cpp
index 2d221d27..34fdb1f8 100644
--- a/src/Persistence_representations/utilities/persistence_heat_maps/average_persistence_heat_maps.cpp
+++ b/src/Persistence_representations/utilities/persistence_heat_maps/average_persistence_heat_maps.cpp
@@ -20,53 +20,45 @@
  *    along with this program.  If not, see <http://www.gnu.org/licenses/>.
  */
 
-
-
 #include <gudhi/Persistence_heat_maps.h>
 
-
-
 using namespace Gudhi;
 using namespace Gudhi::Persistence_representations;
 
 #include <iostream>
 
+int main(int argc, char** argv) {
+  std::cout << "This program computes average persistence landscape of persistence landscapes created based on "
+               "persistence diagrams provided as an input. Please call this program with the names of files with "
+               "persistence diagrams \n";
+  std::vector<const char*> filenames;
+
+  if (argc == 1) {
+    std::cout << "No input files given, the program will now terminate \n";
+    return 1;
+  }
+
+  for (int i = 1; i < argc; ++i) {
+    filenames.push_back(argv[i]);
+  }
+
+  std::cout << "Creating persistence landscapes...\n";
+  std::vector<Persistence_heat_maps<constant_scaling_function>*> maps;
+  for (size_t i = 0; i != filenames.size(); ++i) {
+    Persistence_heat_maps<constant_scaling_function>* l = new Persistence_heat_maps<constant_scaling_function>;
+    l->load_from_file(filenames[i]);
+    maps.push_back(l);
+  }
+
+  Persistence_heat_maps<constant_scaling_function> av;
+  av.compute_average(maps);
+
+  av.print_to_file("average.mps");
+
+  for (size_t i = 0; i != filenames.size(); ++i) {
+    delete maps[i];
+  }
 
-int main( int argc , char** argv )
-{
-	std::cout << "This program computes average persistence landscape of persistence landscapes created based on persistence diagrams provided as an input. Please call this program with the names of files with persistence diagrams \n";
-	std::vector< const char* > filenames;
-	
-	if ( argc == 1 )
-	{
-		std::cout << "No input files given, the program will now terminate \n";
-		return 1;
-	}
-	
-	for ( int i = 1 ; i < argc ; ++i )
-	{
-		filenames.push_back( argv[i] );
-	}
-	
-	std::cout << "Creating persistence landscapes...\n";
-	std::vector< Persistence_heat_maps<constant_scaling_function>* > maps;
-	for ( size_t i = 0 ; i != filenames.size() ; ++i )
-	{
-		Persistence_heat_maps<constant_scaling_function>* l = new Persistence_heat_maps<constant_scaling_function>;
-		l->load_from_file( filenames[i] );
-		maps.push_back( l );
-	}
-	
-	Persistence_heat_maps<constant_scaling_function> av;
-	av.compute_average( maps );
-	
-	av.print_to_file( "average.mps" );
-	
-	for ( size_t i = 0 ; i != filenames.size() ; ++i )
-	{
-		delete maps[i];
-	}
-	
-	std::cout << "Done \n";
-	return 0;
+  std::cout << "Done \n";
+  return 0;
 }
diff --git a/src/Persistence_representations/utilities/persistence_heat_maps/compute_distance_of_persistence_heat_maps.cpp b/src/Persistence_representations/utilities/persistence_heat_maps/compute_distance_of_persistence_heat_maps.cpp
index 27a7836f..cfa209d1 100644
--- a/src/Persistence_representations/utilities/persistence_heat_maps/compute_distance_of_persistence_heat_maps.cpp
+++ b/src/Persistence_representations/utilities/persistence_heat_maps/compute_distance_of_persistence_heat_maps.cpp
@@ -20,89 +20,72 @@
  *    along with this program.  If not, see <http://www.gnu.org/licenses/>.
  */
 
-
 #include <gudhi/Persistence_heat_maps.h>
 
-
-
 using namespace Gudhi;
 using namespace Gudhi::Persistence_representations;
 
 #include <iostream>
 #include <sstream>
 
+int main(int argc, char** argv) {
+  std::cout << "This program compute distance of persistence heat maps stored in a file (the file needs to be created "
+               "beforehand). \n";
+  std::cout << "The first parameter of a program is an integer p. The program compute L^p distance of the two heat "
+               "maps. For L^infty distance choose p = -1. \n";
+  std::cout << "The remaining parameters of this programs are names of files with persistence heat maps.\n";
 
-int main( int argc , char** argv )
-{
-	std::cout << "This program compute distance of persistence heat maps stored in a file (the file needs to be created beforehand). \n";	
-	std::cout << "The first parameter of a program is an integer p. The program compute L^p distance of the two heat maps. For L^infty distance choose p = -1. \n";
-	std::cout << "The remaining parameters of this programs are names of files with persistence heat maps.\n";
-	
-	if ( argc < 3 )
-	{
-		std::cout << "Wrong number of parameters, the program will now terminate \n";
-		return 1;
-	}
-	
-	int pp = atoi( argv[1] );
-	double p = std::numeric_limits<double>::max();
-	if ( pp != -1 )
-	{
-		p = pp;
-	}
-	
+  if (argc < 3) {
+    std::cout << "Wrong number of parameters, the program will now terminate \n";
+    return 1;
+  }
 
-	std::vector< const char* > filenames;
-	for ( int i = 2 ; i < argc ; ++i )
-	{
-		filenames.push_back( argv[i] );
-	}
-	std::vector< Persistence_heat_maps<constant_scaling_function> > maps;
-	maps.reserve( filenames.size() );
-	for ( size_t file_no = 0 ; file_no != filenames.size() ; ++file_no )
-	{
-		Persistence_heat_maps<constant_scaling_function> l;
-		l.load_from_file( filenames[file_no] );
-		maps.push_back( l );
-	}
-		
-	//and now we will compute the scalar product of landscapes.
-	
-	//first we prepare an array:
-	std::vector< std::vector< double > > distance( filenames.size() );
-	for ( size_t i = 0 ; i != filenames.size() ; ++i )
-	{
-		std::vector< double > v( filenames.size() , 0 );
-		distance[i] = v;
-	}
-	
-	//and now we can compute the distances:
-	for ( size_t i = 0 ; i != filenames.size() ; ++i )
-	{
-		for ( size_t j = i ; j != filenames.size() ; ++j )
-		{
-			distance[i][j] = distance[j][i] = maps[i].distance( maps[j] , p ) ;
-		}
-	}
-	
-	//and now output the result to the screen and a file:
-	std::ofstream out;
-	out.open( "distance" );
-	for ( size_t i = 0 ; i != distance.size() ; ++i )
-	{
-		for ( size_t j = 0 ; j != distance.size() ; ++j )
-		{
-			std::cout << distance[i][j] << " ";
-			out << distance[i][j] << " ";
-		}
-		std::cout << std::endl;
-		out << std::endl;
-	}
-	out.close();
-		
-	return 0;
-}
+  int pp = atoi(argv[1]);
+  double p = std::numeric_limits<double>::max();
+  if (pp != -1) {
+    p = pp;
+  }
 
+  std::vector<const char*> filenames;
+  for (int i = 2; i < argc; ++i) {
+    filenames.push_back(argv[i]);
+  }
+  std::vector<Persistence_heat_maps<constant_scaling_function> > maps;
+  maps.reserve(filenames.size());
+  for (size_t file_no = 0; file_no != filenames.size(); ++file_no) {
+    Persistence_heat_maps<constant_scaling_function> l;
+    l.load_from_file(filenames[file_no]);
+    maps.push_back(l);
+  }
 
+  // and now we will compute the scalar product of landscapes.
 
+  // first we prepare an array:
+  std::vector<std::vector<double> > distance(filenames.size());
+  for (size_t i = 0; i != filenames.size(); ++i) {
+    std::vector<double> v(filenames.size(), 0);
+    distance[i] = v;
+  }
 
+  // and now we can compute the distances:
+  for (size_t i = 0; i != filenames.size(); ++i) {
+    for (size_t j = i; j != filenames.size(); ++j) {
+      distance[i][j] = distance[j][i] = maps[i].distance(maps[j], p);
+    }
+  }
+
+  // and now output the result to the screen and a file:
+  std::ofstream out;
+  out.open("distance");
+  for (size_t i = 0; i != distance.size(); ++i) {
+    for (size_t j = 0; j != distance.size(); ++j) {
+      std::cout << distance[i][j] << " ";
+      out << distance[i][j] << " ";
+    }
+    std::cout << std::endl;
+    out << std::endl;
+  }
+  out.close();
+
+  return 0;
+}
diff --git a/src/Persistence_representations/utilities/persistence_heat_maps/compute_scalar_product_of_persistence_heat_maps.cpp b/src/Persistence_representations/utilities/persistence_heat_maps/compute_scalar_product_of_persistence_heat_maps.cpp
index edbf16c1..22bb9e2e 100644
--- a/src/Persistence_representations/utilities/persistence_heat_maps/compute_scalar_product_of_persistence_heat_maps.cpp
+++ b/src/Persistence_representations/utilities/persistence_heat_maps/compute_scalar_product_of_persistence_heat_maps.cpp
@@ -20,70 +20,59 @@
  *    along with this program.  If not, see <http://www.gnu.org/licenses/>.
  */
 
-
 #include <gudhi/Persistence_heat_maps.h>
 
-
-
 using namespace Gudhi;
 using namespace Gudhi::Persistence_representations;
 
 #include <iostream>
 #include <sstream>
 
+int main(int argc, char** argv) {
+  std::cout << "This program compute scalar product of persistence landscapes stored in a file (the file needs to be "
+               "created beforehand). \n";
+  std::cout << "The parameters of this programs are names of files with persistence landscapes.\n";
+
+  std::vector<const char*> filenames;
+  for (int i = 1; i < argc; ++i) {
+    filenames.push_back(argv[i]);
+  }
+  std::vector<Persistence_heat_maps<constant_scaling_function> > maps;
+  maps.reserve(filenames.size());
+  for (size_t file_no = 0; file_no != filenames.size(); ++file_no) {
+    Persistence_heat_maps<constant_scaling_function> l;
+    l.load_from_file(filenames[file_no]);
+    maps.push_back(l);
+  }
+
+  // and now we will compute the scalar product of landscapes.
+
+  // first we prepare an array:
+  std::vector<std::vector<double> > scalar_product(filenames.size());
+  for (size_t i = 0; i != filenames.size(); ++i) {
+    std::vector<double> v(filenames.size(), 0);
+    scalar_product[i] = v;
+  }
+
+  // and now we can compute the scalar product:
+  for (size_t i = 0; i != maps.size(); ++i) {
+    for (size_t j = i; j != maps.size(); ++j) {
+      scalar_product[i][j] = scalar_product[j][i] = maps[i].compute_scalar_product(maps[j]);
+    }
+  }
 
-int main( int argc , char** argv )
-{
-	std::cout << "This program compute scalar product of persistence landscapes stored in a file (the file needs to be created beforehand). \n";	
-	std::cout << "The parameters of this programs are names of files with persistence landscapes.\n";
+  // and now output the result to the screen and a file:
+  std::ofstream out;
+  out.open("scalar_product");
+  for (size_t i = 0; i != scalar_product.size(); ++i) {
+    for (size_t j = 0; j != scalar_product.size(); ++j) {
+      std::cout << scalar_product[i][j] << " ";
+      out << scalar_product[i][j] << " ";
+    }
+    std::cout << std::endl;
+    out << std::endl;
+  }
+  out.close();
 
-	std::vector< const char* > filenames;
-	for ( int i = 1 ; i < argc ; ++i )
-	{
-		filenames.push_back( argv[i] );
-	}
-	std::vector< Persistence_heat_maps<constant_scaling_function> > maps;
-	maps.reserve( filenames.size() );
-	for ( size_t file_no = 0 ; file_no != filenames.size() ; ++file_no )
-	{
-		Persistence_heat_maps<constant_scaling_function> l;
-		l.load_from_file( filenames[file_no] );
-		maps.push_back( l );
-	}
-		
-	//and now we will compute the scalar product of landscapes.
-	
-	//first we prepare an array:
-	std::vector< std::vector< double > > scalar_product( filenames.size() );
-	for ( size_t i = 0 ; i != filenames.size() ; ++i )
-	{
-		std::vector< double > v( filenames.size() , 0 );
-		scalar_product[i] = v;
-	}
-	
-	//and now we can compute the scalar product:
-	for ( size_t i = 0 ; i != maps.size() ; ++i )
-	{
-		for ( size_t j = i ; j != maps.size() ; ++j )
-		{
-			scalar_product[i][j] = scalar_product[j][i] = maps[i].compute_scalar_product( maps[j] ) ;
-		}
-	}
-	
-	//and now output the result to the screen and a file:
-	std::ofstream out;
-	out.open( "scalar_product" );
-	for ( size_t i = 0 ; i != scalar_product.size() ; ++i )
-	{
-		for ( size_t j = 0 ; j != scalar_product.size() ; ++j )
-		{
-			std::cout << scalar_product[i][j] << " ";
-			out << scalar_product[i][j] << " ";
-		}
-		std::cout << std::endl;
-		out << std::endl;
-	}
-	out.close();
-		
-	return 0;
+  return 0;
 }
diff --git a/src/Persistence_representations/utilities/persistence_heat_maps/create_p_h_m_weighted_by_arctan_of_their_persistence.cpp b/src/Persistence_representations/utilities/persistence_heat_maps/create_p_h_m_weighted_by_arctan_of_their_persistence.cpp
index f755e9a6..942246a4 100644
--- a/src/Persistence_representations/utilities/persistence_heat_maps/create_p_h_m_weighted_by_arctan_of_their_persistence.cpp
+++ b/src/Persistence_representations/utilities/persistence_heat_maps/create_p_h_m_weighted_by_arctan_of_their_persistence.cpp
@@ -1,88 +1,82 @@
-	/*    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) 2015  INRIA (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/>.
- */
-
-
+/*    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) 2015  INRIA (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/>.
+*/
 
 #include <gudhi/Persistence_heat_maps.h>
 
-
-
 using namespace Gudhi;
 using namespace Gudhi::Persistence_representations;
 
 #include <iostream>
 #include <sstream>
 
+int main(int argc, char** argv) {
+  std::cout << "This program creates persistence heat map of diagrams provided as an input. The Gaussian kernels are "
+               "weighted by the arc tangential of their persistence.\n";
+  std::cout << "The first parameter of a program is an integer, a size of a grid.\n";
+  std::cout << "The second and third parameters are min and max of the grid. If you want those numbers to be computed "
+               "based on the data, set them both to -1 \n";
+  std::cerr << "The fourth parameter is an integer, the standard deviation of a Gaussian kernel expressed in a number "
+               "of pixels \n";
+  std::cout << "The fifth parameter of this program is a dimension of persistence that will be used in creation of the "
+               "persistence heat maps.";
+  std::cout << "If our input files contain persistence pairs of various dimension, as a fifth parameter of the "
+               "procedure please provide the dimension of persistence you want to use.";
+  std::cout << "If in your file there are only birth-death pairs of the same dimension, set the first parameter to -1."
+            << std::endl;
+  std::cout << "The remaining parameters are the names of files with persistence diagrams. \n";
+
+  if (argc < 5) {
+    std::cout << "Wrong parameter list, the program will now terminate \n";
+    return 1;
+  }
+
+  size_t size_of_grid = (size_t)atoi(argv[1]);
+  double min_ = atof(argv[2]);
+  double max_ = atof(argv[3]);
+  size_t stdiv = atof(argv[4]);
+
+  unsigned dimension = std::numeric_limits<unsigned>::max();
+  int dim = atoi(argv[5]);
+  if (dim >= 0) {
+    dimension = (unsigned)dim;
+  }
 
+  std::vector<const char*> filenames;
+  for (int i = 6; i < argc; ++i) {
+    filenames.push_back(argv[i]);
+  }
 
-int main( int argc , char** argv )
-{
-	std::cout << "This program creates persistence heat map of diagrams provided as an input. The Gaussian kernels are weighted by the arc tangential of their persistence.\n";
-	std::cout << "The first parameter of a program is an integer, a size of a grid.\n";
-	std::cout << "The second and third parameters are min and max of the grid. If you want those numbers to be computed based on the data, set them both to -1 \n";
-	std::cerr << "The fourth parameter is an integer, the standard deviation of a Gaussian kernel expressed in a number of pixels \n";
-	std::cout << "The fifth parameter of this program is a dimension of persistence that will be used in creation of the persistence heat maps.";
-	std::cout << "If our input files contain persistence pairs of various dimension, as a fifth parameter of the procedure please provide the dimension of persistence you want to use.";
-	std::cout << "If in your file there are only birth-death pairs of the same dimension, set the first parameter to -1." << std::endl;		
-	std::cout << "The remaining parameters are the names of files with persistence diagrams. \n";
+  std::cout << "Creating persistence heat maps...\n";
+  std::vector<std::vector<double> > filter = create_Gaussian_filter(stdiv, 1);
 
-	if ( argc < 5 )
-	{
-		std::cout << "Wrong parameter list, the program will now terminate \n";
-		return 1;
-	}
-	
-	size_t size_of_grid = (size_t)atoi( argv[1] );
-	double min_ = atof( argv[2] );
-	double max_ = atof( argv[3] );
-	size_t stdiv = atof( argv[4] );
-	
-	unsigned dimension = std::numeric_limits<unsigned>::max();
-	int dim = atoi( argv[5] );	 
-	if ( dim >= 0 )
-	{
-		dimension = (unsigned)dim;
-	}
-	
-	std::vector< const char* > filenames;
-	for ( int i = 6 ; i < argc ; ++i )
-	{
-		filenames.push_back( argv[i] );
-	}
+  for (size_t i = 0; i != filenames.size(); ++i) {
+    std::cout << "Creating a heat map based on a file : " << filenames[i] << std::endl;
+    Persistence_heat_maps<arc_tan_of_persistence_of_point> l(filenames[i], filter, false, size_of_grid, min_, max_,
+                                                             dimension);
 
-	
-	
-	std::cout << "Creating persistence heat maps...\n";	
-	std::vector< std::vector<double> > filter = create_Gaussian_filter(stdiv,1);
-	
-	for ( size_t i = 0 ; i != filenames.size() ; ++i )
-	{		
-		std::cout << "Creating a heat map based on a file : " << filenames[i] << std::endl;
-		Persistence_heat_maps<arc_tan_of_persistence_of_point> l( filenames[i] , filter, false , size_of_grid , min_ , max_ , dimension );		
-		
-		std::stringstream ss;
-		ss << filenames[i] << ".mps";
-		l.print_to_file( ss.str().c_str() );
-	}
-	std::cout << "Done \n";
-	return 0;
+    std::stringstream ss;
+    ss << filenames[i] << ".mps";
+    l.print_to_file(ss.str().c_str());
+  }
+  std::cout << "Done \n";
+  return 0;
 }
diff --git a/src/Persistence_representations/utilities/persistence_heat_maps/create_p_h_m_weighted_by_distance_from_diagonal.cpp b/src/Persistence_representations/utilities/persistence_heat_maps/create_p_h_m_weighted_by_distance_from_diagonal.cpp
index 732b3768..fce874bd 100644
--- a/src/Persistence_representations/utilities/persistence_heat_maps/create_p_h_m_weighted_by_distance_from_diagonal.cpp
+++ b/src/Persistence_representations/utilities/persistence_heat_maps/create_p_h_m_weighted_by_distance_from_diagonal.cpp
@@ -20,68 +20,63 @@
  *    along with this program.  If not, see <http://www.gnu.org/licenses/>.
  */
 
-
 #include <gudhi/Persistence_heat_maps.h>
 
-
-
 using namespace Gudhi;
 using namespace Gudhi::Persistence_representations;
 
 #include <iostream>
 #include <sstream>
 
+int main(int argc, char** argv) {
+  std::cout << "This program creates persistence heat map of diagrams provided as an input. The Gaussian kernels are "
+               "weighted by the distance of a center from the diagonal.\n";
+  std::cout << "The first parameter of a program is an integer, a size of a grid.\n";
+  std::cout << "The second and third parameters are min and max of the grid. If you want those numbers to be computed "
+               "based on the data, set them both to -1 \n";
+  std::cerr << "The fourth parameter is an integer, the standard deviation of a Gaussian kernel expressed in a number "
+               "of pixels \n";
+  std::cout << "The fifth parameter of this program is a dimension of persistence that will be used in creation of the "
+               "persistence heat maps.";
+  std::cout << "If our input files contain persistence pairs of various dimension, as a fifth parameter of the "
+               "procedure please provide the dimension of persistence you want to use.";
+  std::cout << "If in your file there are only birth-death pairs of the same dimension, set the first parameter to -1."
+            << std::endl;
+  std::cout << "The remaining parameters are the names of files with persistence diagrams. \n";
+
+  if (argc < 5) {
+    std::cout << "Wrong parameter list, the program will now terminate \n";
+    return 1;
+  }
+
+  size_t size_of_grid = (size_t)atoi(argv[1]);
+  double min_ = atof(argv[2]);
+  double max_ = atof(argv[3]);
+  size_t stdiv = atof(argv[4]);
+
+  unsigned dimension = std::numeric_limits<unsigned>::max();
+  int dim = atoi(argv[5]);
+  if (dim >= 0) {
+    dimension = (unsigned)dim;
+  }
+
+  std::vector<const char*> filenames;
+  for (int i = 6; i != argc; ++i) {
+    filenames.push_back(argv[i]);
+  }
 
+  std::cout << "Creating persistence heat maps...\n";
+  std::vector<std::vector<double> > filter = create_Gaussian_filter(stdiv, 1);
 
-int main( int argc , char** argv )
-{
-	std::cout << "This program creates persistence heat map of diagrams provided as an input. The Gaussian kernels are weighted by the distance of a center from the diagonal.\n";
-	std::cout << "The first parameter of a program is an integer, a size of a grid.\n";
-	std::cout << "The second and third parameters are min and max of the grid. If you want those numbers to be computed based on the data, set them both to -1 \n";
-	std::cerr << "The fourth parameter is an integer, the standard deviation of a Gaussian kernel expressed in a number of pixels \n";
-	std::cout << "The fifth parameter of this program is a dimension of persistence that will be used in creation of the persistence heat maps.";
-	std::cout << "If our input files contain persistence pairs of various dimension, as a fifth parameter of the procedure please provide the dimension of persistence you want to use.";
-	std::cout << "If in your file there are only birth-death pairs of the same dimension, set the first parameter to -1." << std::endl;			
-	std::cout << "The remaining parameters are the names of files with persistence diagrams. \n";
-	
-	if ( argc < 5 )
-	{
-		std::cout << "Wrong parameter list, the program will now terminate \n";
-		return 1;
-	}
-	
-	size_t size_of_grid = (size_t)atoi( argv[1] );
-	double min_ = atof( argv[2] );
-	double max_ = atof( argv[3] );
-	size_t stdiv = atof( argv[4] );
-	
-	unsigned dimension = std::numeric_limits<unsigned>::max();
-	int dim = atoi( argv[5] );	 
-	if ( dim >= 0 )
-	{
-		dimension = (unsigned)dim;
-	}
-	
-	std::vector< const char* > filenames;
-	for ( int i = 6 ; i != argc ; ++i )
-	{
-		filenames.push_back( argv[i] );
-	}
+  for (size_t i = 0; i != filenames.size(); ++i) {
+    std::cout << "Creating a heat map based on a file : " << filenames[i] << std::endl;
+    Persistence_heat_maps<distance_from_diagonal_scaling> l(filenames[i], filter, false, size_of_grid, min_, max_,
+                                                            dimension);
 
-	
-	
-	std::cout << "Creating persistence heat maps...\n";	
-	std::vector< std::vector<double> > filter = create_Gaussian_filter(stdiv,1);
-	
-	for ( size_t i = 0 ; i != filenames.size() ; ++i )
-	{		
-		std::cout << "Creating a heat map based on a file : " << filenames[i] << std::endl;
-		Persistence_heat_maps<distance_from_diagonal_scaling> l( filenames[i] , filter , false ,  size_of_grid , min_ , max_ , dimension );
-		
-		std::stringstream ss;
-		ss << filenames[i] << ".mps";
-		l.print_to_file( ss.str().c_str() );
-	}
-	std::cout << "Done \n";
-	return 0;
+    std::stringstream ss;
+    ss << filenames[i] << ".mps";
+    l.print_to_file(ss.str().c_str());
+  }
+  std::cout << "Done \n";
+  return 0;
 }
diff --git a/src/Persistence_representations/utilities/persistence_heat_maps/create_p_h_m_weighted_by_squared_diag_distance.cpp b/src/Persistence_representations/utilities/persistence_heat_maps/create_p_h_m_weighted_by_squared_diag_distance.cpp
index 58406d08..92375387 100644
--- a/src/Persistence_representations/utilities/persistence_heat_maps/create_p_h_m_weighted_by_squared_diag_distance.cpp
+++ b/src/Persistence_representations/utilities/persistence_heat_maps/create_p_h_m_weighted_by_squared_diag_distance.cpp
@@ -20,66 +20,63 @@
  *    along with this program.  If not, see <http://www.gnu.org/licenses/>.
  */
 
-
 #include <gudhi/Persistence_heat_maps.h>
 
-
-
 using namespace Gudhi;
 using namespace Gudhi::Persistence_representations;
 
 #include <iostream>
 #include <sstream>
 
+int main(int argc, char** argv) {
+  std::cout << "This program creates persistence heat map of diagrams provided as an input. The Gaussian kernels are "
+               "weighted by the square of distance of a center from the diagonal.\n";
+  std::cout << "The first parameter of a program is an integer, a size of a grid.\n";
+  std::cout << "The second and third parameters are min and max of the grid. If you want those numbers to be computed "
+               "based on the data, set them both to -1 \n";
+  std::cerr << "The fourth parameter is an integer, the standard deviation of a Gaussian kernel expressed in a number "
+               "of pixels \n";
+  std::cout << "The fifth parameter of this program is a dimension of persistence that will be used in creation of the "
+               "persistence heat maps.";
+  std::cout << "If our input files contain persistence pairs of various dimension, as a fifth parameter of the "
+               "procedure please provide the dimension of persistence you want to use.";
+  std::cout << "If in your file there are only birth-death pairs of the same dimension, set the first parameter to -1."
+            << std::endl;
+  std::cout << "The remaining parameters are the names of files with persistence diagrams. \n";
+
+  if (argc < 5) {
+    std::cout << "Wrong parameter list, the program will now terminate \n";
+    return 1;
+  }
+
+  size_t size_of_grid = (size_t)atoi(argv[1]);
+  double min_ = atof(argv[2]);
+  double max_ = atof(argv[3]);
+  size_t stdiv = atof(argv[4]);
+
+  unsigned dimension = std::numeric_limits<unsigned>::max();
+  int dim = atoi(argv[5]);
+  if (dim >= 0) {
+    dimension = (unsigned)dim;
+  }
 
+  std::vector<const char*> filenames;
+  for (int i = 6; i < argc; ++i) {
+    filenames.push_back(argv[i]);
+  }
 
-int main( int argc , char** argv )
-{
-	std::cout << "This program creates persistence heat map of diagrams provided as an input. The Gaussian kernels are weighted by the square of distance of a center from the diagonal.\n";
-	std::cout << "The first parameter of a program is an integer, a size of a grid.\n";
-	std::cout << "The second and third parameters are min and max of the grid. If you want those numbers to be computed based on the data, set them both to -1 \n";
-	std::cerr << "The fourth parameter is an integer, the standard deviation of a Gaussian kernel expressed in a number of pixels \n";
-	std::cout << "The fifth parameter of this program is a dimension of persistence that will be used in creation of the persistence heat maps.";
-	std::cout << "If our input files contain persistence pairs of various dimension, as a fifth parameter of the procedure please provide the dimension of persistence you want to use.";
-	std::cout << "If in your file there are only birth-death pairs of the same dimension, set the first parameter to -1." << std::endl;				
-	std::cout << "The remaining parameters are the names of files with persistence diagrams. \n";
+  std::cout << "Creating persistence heat maps...\n";
+  std::vector<std::vector<double> > filter = create_Gaussian_filter(stdiv, 1);
 
-	if ( argc < 5 )
-	{
-		std::cout << "Wrong parameter list, the program will now terminate \n";
-		return 1;
-	}
-	
-	size_t size_of_grid = (size_t)atoi( argv[1] );
-	double min_ = atof( argv[2] );
-	double max_ = atof( argv[3] );
-	size_t stdiv = atof( argv[4] );
+  for (size_t i = 0; i != filenames.size(); ++i) {
+    std::cout << "Creating a heat map based on a file : " << filenames[i] << std::endl;
+    Persistence_heat_maps<squared_distance_from_diagonal_scaling> l(filenames[i], filter, false, size_of_grid, min_,
+                                                                    max_, dimension);
 
-	unsigned dimension = std::numeric_limits<unsigned>::max();
-	int dim = atoi( argv[5] );	 
-	if ( dim >= 0 )
-	{
-		dimension = (unsigned)dim;
-	}
-	
-	std::vector< const char* > filenames;
-	for ( int i = 6 ; i < argc ; ++i )
-	{
-		filenames.push_back( argv[i] );
-	}
-	
-	std::cout << "Creating persistence heat maps...\n";	
-	std::vector< std::vector<double> > filter = create_Gaussian_filter(stdiv,1);
-	
-	for ( size_t i = 0 ; i != filenames.size() ; ++i )
-	{		
-		std::cout << "Creating a heat map based on a file : " << filenames[i] << std::endl;
-		Persistence_heat_maps<squared_distance_from_diagonal_scaling> l( filenames[i] , filter, false , size_of_grid , min_ , max_ , dimension );		
-		
-		std::stringstream ss;
-		ss << filenames[i] << ".mps";
-		l.print_to_file( ss.str().c_str() );
-	}
-	std::cout << "Done \n";
-	return 0;
+    std::stringstream ss;
+    ss << filenames[i] << ".mps";
+    l.print_to_file(ss.str().c_str());
+  }
+  std::cout << "Done \n";
+  return 0;
 }
diff --git a/src/Persistence_representations/utilities/persistence_heat_maps/create_persistence_heat_maps.cpp b/src/Persistence_representations/utilities/persistence_heat_maps/create_persistence_heat_maps.cpp
index 90b50b0b..3b0fd8ae 100644
--- a/src/Persistence_representations/utilities/persistence_heat_maps/create_persistence_heat_maps.cpp
+++ b/src/Persistence_representations/utilities/persistence_heat_maps/create_persistence_heat_maps.cpp
@@ -20,65 +20,60 @@
  *    along with this program.  If not, see <http://www.gnu.org/licenses/>.
  */
 
-
-
 #include <gudhi/Persistence_heat_maps.h>
 
-
-
 using namespace Gudhi;
 using namespace Gudhi::Persistence_representations;
 
 #include <iostream>
 #include <sstream>
 
+int main(int argc, char** argv) {
+  std::cout << "This program creates persistence heat map of diagrams provided as an input.\n";
+  std::cout << "The first parameter of a program is an integer, a size of a grid.\n";
+  std::cout << "The second and third parameters are min and max of the grid. If you want those numbers to be computed "
+               "based on the data, set them both to -1 \n";
+  std::cerr << "The fourth parameter is an integer, the standard deviation of a Gaussian kernel expressed in a number "
+               "of pixels \n";
+
+  std::cout << "The fifth parameter of this program is a dimension of persistence that will be used in creation of the "
+               "persistence heat maps.";
+  std::cout << "If our input files contain persistence pairs of various dimension, as a fifth parameter of the "
+               "procedure please provide the dimension of persistence you want to use.";
+  std::cout << "If in your file there are only birth-death pairs of the same dimension, set the first parameter to -1."
+            << std::endl;
+  std::cout << "The remaining parameters are the names of files with persistence diagrams. \n";
+  if (argc < 5) {
+    std::cout << "Wrong parameter list, the program will now terminate \n";
+    return 1;
+  }
+  size_t size_of_grid = (size_t)atoi(argv[1]);
+  double min_ = atof(argv[2]);
+  double max_ = atof(argv[3]);
+  size_t stdiv = atof(argv[4]);
+
+  unsigned dimension = std::numeric_limits<unsigned>::max();
+  int dim = atoi(argv[5]);
+  if (dim >= 0) {
+    dimension = (unsigned)dim;
+  }
+  std::vector<const char*> filenames;
+  for (int i = 6; i < argc; ++i) {
+    filenames.push_back(argv[i]);
+  }
+
+  std::cout << "Creating persistence heat maps...\n";
+  std::vector<std::vector<double> > filter = create_Gaussian_filter(stdiv, 1);
 
+  for (size_t i = 0; i != filenames.size(); ++i) {
+    std::cout << "Creating a heat map based on a file : " << filenames[i] << std::endl;
+    Persistence_heat_maps<constant_scaling_function> l(filenames[i], filter, false, size_of_grid, min_, max_,
+                                                       dimension);
 
-int main( int argc , char** argv )
-{
-	std::cout << "This program creates persistence heat map of diagrams provided as an input.\n";
-	std::cout << "The first parameter of a program is an integer, a size of a grid.\n";
-	std::cout << "The second and third parameters are min and max of the grid. If you want those numbers to be computed based on the data, set them both to -1 \n";
-	std::cerr << "The fourth parameter is an integer, the standard deviation of a Gaussian kernel expressed in a number of pixels \n";
-	
-	std::cout << "The fifth parameter of this program is a dimension of persistence that will be used in creation of the persistence heat maps.";
-	std::cout << "If our input files contain persistence pairs of various dimension, as a fifth parameter of the procedure please provide the dimension of persistence you want to use.";
-	std::cout << "If in your file there are only birth-death pairs of the same dimension, set the first parameter to -1." << std::endl;	
-	std::cout << "The remaining parameters are the names of files with persistence diagrams. \n";
-	if ( argc < 5 )
-	{
-		std::cout << "Wrong parameter list, the program will now terminate \n";
-		return 1;
-	}	
-	size_t size_of_grid = (size_t)atoi( argv[1] );
-	double min_ = atof( argv[2] );
-	double max_ = atof( argv[3] );
-	size_t stdiv = atof( argv[4] );
-	
-	unsigned dimension = std::numeric_limits<unsigned>::max();
-	int dim = atoi( argv[5] );	 
-	if ( dim >= 0 )
-	{
-		dimension = (unsigned)dim;
-	}
-	std::vector< const char* > filenames;
-	for ( int i = 6 ; i < argc ; ++i )
-	{
-		filenames.push_back( argv[i] );
-	}
-	
-	std::cout << "Creating persistence heat maps...\n";	
-	std::vector< std::vector<double> > filter = create_Gaussian_filter(stdiv,1);
-	
-	for ( size_t i = 0 ; i != filenames.size() ; ++i )
-	{		
-		std::cout << "Creating a heat map based on a file : " << filenames[i] << std::endl;
-		Persistence_heat_maps<constant_scaling_function> l( filenames[i] , filter, false , size_of_grid , min_ , max_ , dimension );		
-		
-		std::stringstream ss;
-		ss << filenames[i] << ".mps";
-		l.print_to_file( ss.str().c_str() );
-	}
-	std::cout << "Done \n";
-	return 0;
+    std::stringstream ss;
+    ss << filenames[i] << ".mps";
+    l.print_to_file(ss.str().c_str());
+  }
+  std::cout << "Done \n";
+  return 0;
 }
diff --git a/src/Persistence_representations/utilities/persistence_heat_maps/create_pssk.cpp b/src/Persistence_representations/utilities/persistence_heat_maps/create_pssk.cpp
index 6a07bf19..6b464378 100644
--- a/src/Persistence_representations/utilities/persistence_heat_maps/create_pssk.cpp
+++ b/src/Persistence_representations/utilities/persistence_heat_maps/create_pssk.cpp
@@ -22,63 +22,59 @@
 
 #include <gudhi/PSSK.h>
 
-
-
 using namespace Gudhi;
 using namespace Gudhi::Persistence_representations;
 
 #include <iostream>
 #include <sstream>
 
+int main(int argc, char** argv) {
+  std::cout << "This program creates PSSK of diagrams provided as an input.\n";
+  std::cout << "The first parameter of a program is an integer, a size of a grid.\n";
+  std::cout << "The second and third parameters are min and max of the grid. If you want those numbers to be computed "
+               "based on the data, set them both to -1 \n";
+  std::cerr << "The fourth parameter is an integer, the standard deviation of a Gaussian kernel expressed in a number "
+               "of pixels \n";
+  std::cout << "The fifth parameter of this program is a dimension of persistence that will be used in creation of the "
+               "persistence heat maps.";
+  std::cout << "If our input files contain persistence pairs of various dimension, as a fifth parameter of the "
+               "procedure please provide the dimension of persistence you want to use.";
+  std::cout << "If in your file there are only birth-death pairs of the same dimension, set the first parameter to -1."
+            << std::endl;
+  std::cout << "The remaining parameters are the names of files with persistence diagrams. \n";
+
+  if (argc < 5) {
+    std::cout << "Wrong parameter list, the program will now terminate \n";
+    return 1;
+  }
+
+  size_t size_of_grid = (size_t)atoi(argv[1]);
+  double min_ = atof(argv[2]);
+  double max_ = atof(argv[3]);
+  size_t stdiv = atof(argv[4]);
+
+  unsigned dimension = std::numeric_limits<unsigned>::max();
+  int dim = atoi(argv[5]);
+  if (dim >= 0) {
+    dimension = (unsigned)dim;
+  }
+
+  std::vector<const char*> filenames;
+  for (int i = 6; i < argc; ++i) {
+    filenames.push_back(argv[i]);
+  }
 
+  std::cout << "Creating persistence heat maps...\n";
+  std::vector<std::vector<double> > filter = create_Gaussian_filter(stdiv, 1);
 
-int main( int argc , char** argv )
-{
-	std::cout << "This program creates PSSK of diagrams provided as an input.\n";
-	std::cout << "The first parameter of a program is an integer, a size of a grid.\n";
-	std::cout << "The second and third parameters are min and max of the grid. If you want those numbers to be computed based on the data, set them both to -1 \n";
-	std::cerr << "The fourth parameter is an integer, the standard deviation of a Gaussian kernel expressed in a number of pixels \n";
-	std::cout << "The fifth parameter of this program is a dimension of persistence that will be used in creation of the persistence heat maps.";
-	std::cout << "If our input files contain persistence pairs of various dimension, as a fifth parameter of the procedure please provide the dimension of persistence you want to use.";
-	std::cout << "If in your file there are only birth-death pairs of the same dimension, set the first parameter to -1." << std::endl;					
-	std::cout << "The remaining parameters are the names of files with persistence diagrams. \n";
+  for (size_t i = 0; i != filenames.size(); ++i) {
+    std::cout << "Creating a heat map based on a file : " << filenames[i] << std::endl;
+    PSSK l(filenames[i], filter, size_of_grid, min_, max_, dimension);
 
-	if ( argc < 5 )
-	{
-		std::cout << "Wrong parameter list, the program will now terminate \n";
-		return 1;
-	}
-	
-	size_t size_of_grid = (size_t)atoi( argv[1] );
-	double min_ = atof( argv[2] );
-	double max_ = atof( argv[3] );
-	size_t stdiv = atof( argv[4] );
-	
-	unsigned dimension = std::numeric_limits<unsigned>::max();
-	int dim = atoi( argv[5] );	 
-	if ( dim >= 0 )
-	{
-		dimension = (unsigned)dim;
-	}
-	
-	std::vector< const char* > filenames;
-	for ( int i = 6 ; i < argc ; ++i )
-	{
-		filenames.push_back( argv[i] );
-	}	
-	
-	std::cout << "Creating persistence heat maps...\n";	
-	std::vector< std::vector<double> > filter = create_Gaussian_filter(stdiv,1);	
-	
-	for ( size_t i = 0 ; i != filenames.size() ; ++i )
-	{		
-		std::cout << "Creating a heat map based on a file : " << filenames[i] << std::endl;
-		PSSK l( filenames[i] , filter , size_of_grid , min_ , max_ , dimension );		
-		
-		std::stringstream ss;
-		ss << filenames[i] << ".pssk";
-		l.print_to_file( ss.str().c_str() );
-	}
-	std::cout << "Done \n";
-	return 0;
+    std::stringstream ss;
+    ss << filenames[i] << ".pssk";
+    l.print_to_file(ss.str().c_str());
+  }
+  std::cout << "Done \n";
+  return 0;
 }
diff --git a/src/Persistence_representations/utilities/persistence_heat_maps/plot_persistence_heat_map.cpp b/src/Persistence_representations/utilities/persistence_heat_maps/plot_persistence_heat_map.cpp
index 7aedfbb1..59f12a7d 100644
--- a/src/Persistence_representations/utilities/persistence_heat_maps/plot_persistence_heat_map.cpp
+++ b/src/Persistence_representations/utilities/persistence_heat_maps/plot_persistence_heat_map.cpp
@@ -20,23 +20,19 @@
  *    along with this program.  If not, see <http://www.gnu.org/licenses/>.
  */
 
-
 #include <gudhi/Persistence_heat_maps.h>
 
-
-
 using namespace Gudhi;
 using namespace Gudhi::Persistence_representations;
 
 #include <iostream>
 #include <sstream>
 
-
-int main( int argc , char** argv )
-{
-	std::cout << "This program plot persistence landscape stored in a file (the file needs to be created beforehand). Please call the code with the name of a landscape file \n";	
-	Persistence_heat_maps<constant_scaling_function> l;
-	l.load_from_file( argv[1] );		
-	l.plot( argv[1] );	
-	return 0;
+int main(int argc, char** argv) {
+  std::cout << "This program plot persistence landscape stored in a file (the file needs to be created beforehand). "
+               "Please call the code with the name of a landscape file \n";
+  Persistence_heat_maps<constant_scaling_function> l;
+  l.load_from_file(argv[1]);
+  l.plot(argv[1]);
+  return 0;
 }
diff --git a/src/Persistence_representations/utilities/persistence_intervals/compute_birth_death_range_in_persistence_diagram.cpp b/src/Persistence_representations/utilities/persistence_intervals/compute_birth_death_range_in_persistence_diagram.cpp
index 2e0d680f..750d0a55 100644
--- a/src/Persistence_representations/utilities/persistence_intervals/compute_birth_death_range_in_persistence_diagram.cpp
+++ b/src/Persistence_representations/utilities/persistence_intervals/compute_birth_death_range_in_persistence_diagram.cpp
@@ -20,8 +20,6 @@
  *    along with this program.  If not, see <http://www.gnu.org/licenses/>.
  */
 
-
-
 #include <gudhi/reader_utils.h>
 #include <gudhi/Persistence_intervals.h>
 
@@ -29,43 +27,38 @@
 #include <vector>
 #include <limits>
 
-
-
 using namespace Gudhi;
 using namespace Gudhi::Persistence_representations;
 
+int main(int argc, char** argv) {
+  std::cout << "This program compute the range of birth and death times of persistence pairs in diagrams provided as "
+               "an input. \n";
+  std::cout << "The first parameter of the program is the dimension of persistence to be used. If your file contains ";
+  std::cout << "the information about dimension of persistence pairs, please provide here the dimension of persistence "
+               "pairs you want to use. If your input files consist only ";
+  std::cout << "of birth-death pairs, please set this first parameter to -1 \n";
+  std::cout << "The remaining parameters of the program are the names of files with persistence diagrams. \n";
+
+  int dim = atoi(argv[1]);
+  unsigned dimension = std::numeric_limits<unsigned>::max();
+  if (dim >= 0) {
+    dimension = (unsigned)dim;
+  }
+  std::vector<const char*> filenames;
+  for (int i = 2; i < argc; ++i) {
+    filenames.push_back(argv[i]);
+  }
+
+  double min_ = std::numeric_limits<double>::max();
+  double max_ = -std::numeric_limits<double>::max();
 
-int main( int argc , char** argv )
-{
-	std::cout << "This program compute the range of birth and death times of persistence pairs in diagrams provided as an input. \n";
-	std::cout << "The first parameter of the program is the dimension of persistence to be used. If your file contains ";
-	std::cout << "the information about dimension of persistence pairs, please provide here the dimension of persistence pairs you want to use. If your input files consist only ";
-	std::cout << "of birth-death pairs, please set this first parameter to -1 \n";	
-	std::cout << "The remaining parameters of the program are the names of files with persistence diagrams. \n";
-	
-	int dim = atoi( argv[1] );
-	unsigned dimension = std::numeric_limits<unsigned>::max();
-	if ( dim >= 0 )
-	{
-		dimension = (unsigned)dim;
-	}
-	std::vector< const char* > filenames;
-	for ( int i = 2 ; i < argc ; ++i )
-	{
-		filenames.push_back( argv[i] );
-	}
-	
-	double min_ = std::numeric_limits<double>::max();
-	double max_ = -std::numeric_limits<double>::max();
-	
-	for ( size_t file_no = 0 ; file_no != filenames.size() ; ++file_no )
-	{
-		std::cout << "Creating diagram based on a file : " << filenames[file_no] << std::endl;
-		Persistence_intervals p( filenames[file_no] , dimension );
-		std::pair<double,double> min_max_ = p.get_x_range();
-		if ( min_max_.first < min_ )min_ = min_max_.first;
-		if ( min_max_.second > max_ )max_ = min_max_.second;
-	}
-	std::cout << "Birth-death range : min: " <<  min_ << ", max: " << max_ << std::endl;
-	return 0;
+  for (size_t file_no = 0; file_no != filenames.size(); ++file_no) {
+    std::cout << "Creating diagram based on a file : " << filenames[file_no] << std::endl;
+    Persistence_intervals p(filenames[file_no], dimension);
+    std::pair<double, double> min_max_ = p.get_x_range();
+    if (min_max_.first < min_) min_ = min_max_.first;
+    if (min_max_.second > max_) max_ = min_max_.second;
+  }
+  std::cout << "Birth-death range : min: " << min_ << ", max: " << max_ << std::endl;
+  return 0;
 }
diff --git a/src/Persistence_representations/utilities/persistence_intervals/compute_bottleneck_distance.cpp b/src/Persistence_representations/utilities/persistence_intervals/compute_bottleneck_distance.cpp
index fe4e709f..d5d166ce 100644
--- a/src/Persistence_representations/utilities/persistence_intervals/compute_bottleneck_distance.cpp
+++ b/src/Persistence_representations/utilities/persistence_intervals/compute_bottleneck_distance.cpp
@@ -23,91 +23,72 @@
 #include <gudhi/Persistence_intervals_with_distances.h>
 #include <gudhi/read_persistence_from_file.h>
 
-
-
 using namespace Gudhi;
 using namespace Gudhi::Persistence_representations;
 
 #include <iostream>
 #include <sstream>
 
-
-int main( int argc , char** argv )
-{
-	std::cout << "This program compute the bottleneck distance of persistence diagrams stored in a files. \n";
-	std::cout << "The first parameter of the program is the dimension of persistence to be used to construct persistence landscapes. If your file contains ";
-	std::cout << "the information about dimension of persistence pairs, please provide here the dimension of persistence pairs you want to use. If your input files consist only ";
-	std::cout << "of birth-death pairs, please set this first parameter to -1 \n";	
-	std::cout << "The remaining parameters of this programs are names of files with persistence diagrams.\n";
-
-	if ( argc < 3 )
-	{
-		std::cout << "Wrong number of parameters, the program will now terminate \n";
-		return 1;
-	}
-
-	int dim = atoi(argv[1]);
-	unsigned dimension = std::numeric_limits<unsigned>::max();
-	if ( dim >= 0 )
-	{
-		dimension = (unsigned)dim;
-	}
-
-
-	std::vector< const char* > filenames;
-	for ( int i = 2 ; i < argc ; ++i )
-	{
-		filenames.push_back( argv[i] );
-	}
-	
-	//reading the persistence intervals:
-	std::vector< Persistence_intervals_with_distances > persistence_intervals;
-	for ( size_t i = 0 ; i != filenames.size() ; ++i )
-	{
-		Persistence_intervals_with_distances pers(filenames[i] , dimension );	
-		persistence_intervals.push_back( pers );
-	}
-	
-	//and now we will compute the scalar product of landscapes.
-
-	//first we prepare an array:
-	std::vector< std::vector< double > > distance( filenames.size() );
-	for ( size_t i = 0 ; i != filenames.size() ; ++i )
-	{
-		std::vector< double > v( filenames.size() , 0 );
-		distance[i] = v;
-	}
-
-	//and now we can compute the distances:
-	for ( size_t i = 0 ; i != persistence_intervals.size() ; ++i )
-	{
-		for ( size_t j = i+1 ; j != persistence_intervals.size() ; ++j )
-		{
-			distance[i][j] = distance[j][i] = persistence_intervals[i].distance( persistence_intervals[j] );
-		}
-	}
-
-	//and now output the result to the screen and a file:
-	std::ofstream out;
-	out.open( "distance" );
-	for ( size_t i = 0 ; i != distance.size() ; ++i )
-	{
-		for ( size_t j = 0 ; j != distance.size() ; ++j )
-		{
-			std::cout << distance[i][j] << " ";
-			out << distance[i][j] << " ";
-		}
-		std::cout << std::endl;
-		out << std::endl;
-	}
-	out.close();
-
-	return 0;
+int main(int argc, char** argv) {
+  std::cout << "This program compute the bottleneck distance of persistence diagrams stored in a files. \n";
+  std::cout << "The first parameter of the program is the dimension of persistence to be used to construct persistence "
+               "landscapes. If your file contains ";
+  std::cout << "the information about dimension of persistence pairs, please provide here the dimension of persistence "
+               "pairs you want to use. If your input files consist only ";
+  std::cout << "of birth-death pairs, please set this first parameter to -1 \n";
+  std::cout << "The remaining parameters of this programs are names of files with persistence diagrams.\n";
+
+  if (argc < 3) {
+    std::cout << "Wrong number of parameters, the program will now terminate \n";
+    return 1;
+  }
+
+  int dim = atoi(argv[1]);
+  unsigned dimension = std::numeric_limits<unsigned>::max();
+  if (dim >= 0) {
+    dimension = (unsigned)dim;
+  }
+
+  std::vector<const char*> filenames;
+  for (int i = 2; i < argc; ++i) {
+    filenames.push_back(argv[i]);
+  }
+
+  // reading the persistence intervals:
+  std::vector<Persistence_intervals_with_distances> persistence_intervals;
+  for (size_t i = 0; i != filenames.size(); ++i) {
+    Persistence_intervals_with_distances pers(filenames[i], dimension);
+    persistence_intervals.push_back(pers);
+  }
+
+  // and now we will compute the scalar product of landscapes.
+
+  // first we prepare an array:
+  std::vector<std::vector<double> > distance(filenames.size());
+  for (size_t i = 0; i != filenames.size(); ++i) {
+    std::vector<double> v(filenames.size(), 0);
+    distance[i] = v;
+  }
+
+  // and now we can compute the distances:
+  for (size_t i = 0; i != persistence_intervals.size(); ++i) {
+    for (size_t j = i + 1; j != persistence_intervals.size(); ++j) {
+      distance[i][j] = distance[j][i] = persistence_intervals[i].distance(persistence_intervals[j]);
+    }
+  }
+
+  // and now output the result to the screen and a file:
+  std::ofstream out;
+  out.open("distance");
+  for (size_t i = 0; i != distance.size(); ++i) {
+    for (size_t j = 0; j != distance.size(); ++j) {
+      std::cout << distance[i][j] << " ";
+      out << distance[i][j] << " ";
+    }
+    std::cout << std::endl;
+    out << std::endl;
+  }
+  out.close();
+
+  return 0;
 }
-
-
-
-
-
-
-
diff --git a/src/Persistence_representations/utilities/persistence_intervals/compute_number_of_dominant_intervals.cpp b/src/Persistence_representations/utilities/persistence_intervals/compute_number_of_dominant_intervals.cpp
index c099befc..5308878e 100644
--- a/src/Persistence_representations/utilities/persistence_intervals/compute_number_of_dominant_intervals.cpp
+++ b/src/Persistence_representations/utilities/persistence_intervals/compute_number_of_dominant_intervals.cpp
@@ -20,40 +20,34 @@
  *    along with this program.  If not, see <http://www.gnu.org/licenses/>.
  */
 
-
-
 #include <gudhi/reader_utils.h>
 #include <gudhi/Persistence_intervals.h>
 
 #include <iostream>
 
-
-
 using namespace Gudhi;
 using namespace Gudhi::Persistence_representations;
 
-
-int main( int argc , char** argv )
-{
-	std::cout << "This program compute the dominant intervals. A number of intervals to be displayed is a parameter of this program. \n";
-	if ( argc != 4 )
-	{
-		std::cout << "To run this program, please provide the name of a file with persistence diagram, dimension of intervals that should be taken into account (if your file contains only persistence pairs in a single dimension, set it up to -1) and number of dominant intervals you would like to get \n";
-		return 1;
-	}
-	int dim = atoi( argv[2] );
-	unsigned dimension = std::numeric_limits<unsigned>::max();
-	if ( dim >= 0 )
-	{
-		dimension = (unsigned)dim;
-	}
-	Persistence_intervals p( argv[1] , dimension );
-	std::vector< std::pair<double,double> > dominant_intervals = p.dominant_intervals( atoi( argv[3] ) );
-	std::cout << "Here are the dominant intervals : " << std::endl;
-	for ( size_t i = 0 ; i != dominant_intervals.size() ; ++i )
-	{
-		std::cout << " " << dominant_intervals[i].first<< "," << dominant_intervals[i].second  << " "<< std::endl;
-	}
-	
-	return 0;
+int main(int argc, char** argv) {
+  std::cout << "This program compute the dominant intervals. A number of intervals to be displayed is a parameter of "
+               "this program. \n";
+  if (argc != 4) {
+    std::cout << "To run this program, please provide the name of a file with persistence diagram, dimension of "
+                 "intervals that should be taken into account (if your file contains only persistence pairs in a "
+                 "single dimension, set it up to -1) and number of dominant intervals you would like to get \n";
+    return 1;
+  }
+  int dim = atoi(argv[2]);
+  unsigned dimension = std::numeric_limits<unsigned>::max();
+  if (dim >= 0) {
+    dimension = (unsigned)dim;
+  }
+  Persistence_intervals p(argv[1], dimension);
+  std::vector<std::pair<double, double> > dominant_intervals = p.dominant_intervals(atoi(argv[3]));
+  std::cout << "Here are the dominant intervals : " << std::endl;
+  for (size_t i = 0; i != dominant_intervals.size(); ++i) {
+    std::cout << " " << dominant_intervals[i].first << "," << dominant_intervals[i].second << " " << std::endl;
+  }
+
+  return 0;
 }
diff --git a/src/Persistence_representations/utilities/persistence_intervals/plot_histogram_of_intervals_lengths.cpp b/src/Persistence_representations/utilities/persistence_intervals/plot_histogram_of_intervals_lengths.cpp
index 6e2598fa..dd81af88 100644
--- a/src/Persistence_representations/utilities/persistence_intervals/plot_histogram_of_intervals_lengths.cpp
+++ b/src/Persistence_representations/utilities/persistence_intervals/plot_histogram_of_intervals_lengths.cpp
@@ -20,58 +20,51 @@
  *    along with this program.  If not, see <http://www.gnu.org/licenses/>.
  */
 
-
-
 #include <gudhi/reader_utils.h>
 #include <gudhi/Persistence_intervals.h>
 
 #include <iostream>
 
-
-
 using namespace Gudhi;
 using namespace Gudhi::Persistence_representations;
 
+int main(int argc, char** argv) {
+  std::cout << "This program compute a histogram of barcode's length. A number of bins in the histogram is a parameter "
+               "of this program. \n";
+  if (argc != 3) {
+    std::cout << "To run this program, please provide the name of a file with persistence diagram and number of "
+                 "dominant intervals you would like to get \n";
+    std::cout << "The third parameter of a program is the dimension of the persistence that is to be used. If your "
+                 "file contains only birth-death pairs, you can skip this parameter\n";
+    return 1;
+  }
+  unsigned dimension = std::numeric_limits<unsigned>::max();
+  int dim = -1;
+  if (argc > 2) {
+    dim = atoi(argv[2]);
+  }
+  if (dim >= 0) {
+    dimension = (unsigned)dim;
+  }
+
+  Persistence_intervals p(argv[1], dimension);
+  std::vector<std::pair<double, double> > dominant_intervals = p.dominant_intervals(atoi(argv[2]));
+  std::vector<size_t> histogram = p.histogram_of_lengths(10);
 
-int main( int argc , char** argv )
-{
-	std::cout << "This program compute a histogram of barcode's length. A number of bins in the histogram is a parameter of this program. \n";
-	if ( argc != 3 )
-	{
-		std::cout << "To run this program, please provide the name of a file with persistence diagram and number of dominant intervals you would like to get \n";
-		std::cout << "The third parameter of a program is the dimension of the persistence that is to be used. If your file contains only birth-death pairs, you can skip this parameter\n";
-		return 1;
-	}
-	unsigned dimension = std::numeric_limits<unsigned>::max();
-	int dim = -1;
-	if ( argc > 2 )
-	{
-		dim = atoi( argv[2] );
-	} 
-	if ( dim >= 0 )
-	{
-		dimension = (unsigned)dim;
-	}
+  std::stringstream gnuplot_script;
+  gnuplot_script << argv[1] << "_Gnuplot_script";
+  std::ofstream out;
+  out.open(gnuplot_script.str().c_str());
 
-	Persistence_intervals p( argv[1] , dimension );
-	std::vector< std::pair<double,double> > dominant_intervals = p.dominant_intervals( atoi( argv[2] ) );
-	std::vector< size_t > histogram = p.histogram_of_lengths( 10  );
-	
-	std::stringstream gnuplot_script;
-	gnuplot_script << argv[1] << "_Gnuplot_script";
-	std::ofstream out;
-	out.open( gnuplot_script.str().c_str() );
-	
-	out << "set style data histogram" << std::endl;
-	out << "set style histogram cluster gap 1" << std::endl;
-	out << "set style fill solid border -1" << std::endl;
-	out << "plot '-' notitle" << std::endl;    
-	for ( size_t i = 0 ; i != histogram.size() ; ++i )
-	{
-		out << histogram[i]  << std::endl;
-	}		
-	out << std::endl;
-	std::cout << "To visualize, open gnuplot and type: load \'" << gnuplot_script.str().c_str() << "\'" <<  std::endl;	
-	out.close();	
-	return 0;
+  out << "set style data histogram" << std::endl;
+  out << "set style histogram cluster gap 1" << std::endl;
+  out << "set style fill solid border -1" << std::endl;
+  out << "plot '-' notitle" << std::endl;
+  for (size_t i = 0; i != histogram.size(); ++i) {
+    out << histogram[i] << std::endl;
+  }
+  out << std::endl;
+  std::cout << "To visualize, open gnuplot and type: load \'" << gnuplot_script.str().c_str() << "\'" << std::endl;
+  out.close();
+  return 0;
 }
diff --git a/src/Persistence_representations/utilities/persistence_intervals/plot_persistence_Betti_numbers.cpp b/src/Persistence_representations/utilities/persistence_intervals/plot_persistence_Betti_numbers.cpp
index 5b36e0ce..08d308aa 100644
--- a/src/Persistence_representations/utilities/persistence_intervals/plot_persistence_Betti_numbers.cpp
+++ b/src/Persistence_representations/utilities/persistence_intervals/plot_persistence_Betti_numbers.cpp
@@ -20,76 +20,66 @@
  *    along with this program.  If not, see <http://www.gnu.org/licenses/>.
  */
 
-
-
 #include <gudhi/reader_utils.h>
 #include <gudhi/Persistence_intervals.h>
 
 #include <iostream>
 
-
-
 using namespace Gudhi;
 using namespace Gudhi::Persistence_representations;
 
+int main(int argc, char** argv) {
+  std::cout << "This program compute a plot of persistence Betti numbers. The input parameter is a file with "
+               "persistence intervals. \n";
+  std::cout << "The second optional parameter of a program is the dimension of the persistence that is to be used. If "
+               "your file contains only birth-death pairs, you can skip this parameter\n";
+  if (argc < 2) {
+    std::cout << "To run this program, please provide the name of a file with persistence diagram and number of "
+                 "dominant intervals you would like to get \n";
+    return 1;
+  }
+  unsigned dimension = std::numeric_limits<unsigned>::max();
+  int dim = -1;
+  if (argc > 2) {
+    dim = atoi(argv[2]);
+  }
+  if (dim >= 0) {
+    dimension = (unsigned)dim;
+  }
+
+  std::stringstream gnuplot_script;
+  gnuplot_script << argv[1] << "_Gnuplot_script";
+  std::ofstream out;
+  out.open(gnuplot_script.str().c_str());
+
+  Persistence_intervals p(argv[1], dimension);
+  std::vector<std::pair<double, size_t> > pbns = p.compute_persistent_betti_numbers();
+
+  // set up the ranges so that we see the image well.
+  double xRangeBegin = pbns[0].first;
+  double xRangeEnd = pbns[pbns.size() - 1].first;
+  double yRangeBegin = 0;
+  double yRangeEnd = 0;
+  for (size_t i = 0; i != pbns.size(); ++i) {
+    if (pbns[i].second > yRangeEnd) yRangeEnd = pbns[i].second;
+  }
+  xRangeBegin -= (xRangeEnd - xRangeBegin) / 100.0;
+  xRangeEnd += (xRangeEnd - xRangeBegin) / 100.0;
+  yRangeEnd += yRangeEnd / 100;
+
+  out << "set xrange [" << xRangeBegin << " : " << xRangeEnd << "]" << std::endl;
+  out << "set yrange [" << yRangeBegin << " : " << yRangeEnd << "]" << std::endl;
+  out << "plot '-' using 1:2 notitle with lp " << std::endl;
+  double previous_y = 0;
+  for (size_t i = 0; i != pbns.size(); ++i) {
+    out << pbns[i].first << " " << previous_y << std::endl;
+    out << pbns[i].first << " " << pbns[i].second << std::endl;
+    previous_y = pbns[i].second;
+  }
+  out << std::endl;
+  out.close();
+
+  std::cout << "To visualize, open gnuplot and type: load \'" << gnuplot_script.str().c_str() << "\'" << std::endl;
 
-int main( int argc , char** argv )
-{
-	std::cout << "This program compute a plot of persistence Betti numbers. The input parameter is a file with persistence intervals. \n";
-	std::cout << "The second optional parameter of a program is the dimension of the persistence that is to be used. If your file contains only birth-death pairs, you can skip this parameter\n";
-	if ( argc < 2 )
-	{
-		std::cout << "To run this program, please provide the name of a file with persistence diagram and number of dominant intervals you would like to get \n";
-		return 1;
-	}
-	unsigned dimension = std::numeric_limits<unsigned>::max();
-	int dim = -1;
-	if ( argc > 2 )
-	{
-		dim = atoi( argv[2] );
-	} 
-	if ( dim >= 0 )
-	{
-		dimension = (unsigned)dim;
-	}
-	
-	
-	std::stringstream gnuplot_script;
-	gnuplot_script << argv[1] << "_Gnuplot_script";
-	std::ofstream out;
-	out.open( gnuplot_script.str().c_str() );
-	
-	Persistence_intervals p( argv[1] , dimension );
-	std::vector< std::pair< double , size_t > > pbns = p.compute_persistent_betti_numbers();	
-	
-	//set up the ranges so that we see the image well.
-	double xRangeBegin = pbns[0].first;
-	double xRangeEnd = pbns[ pbns.size()-1 ].first;
-	double yRangeBegin = 0;
-	double yRangeEnd = 0;
-	for ( size_t i = 0 ; i != pbns.size() ; ++i )
-	{
-		if ( pbns[i].second > yRangeEnd )yRangeEnd = pbns[i].second;
-	}
-	xRangeBegin -= (xRangeEnd -xRangeBegin)/100.0;
-	xRangeEnd += (xRangeEnd -xRangeBegin)/100.0;
-	yRangeEnd += yRangeEnd/100;
-	
-	
-	out << "set xrange [" << xRangeBegin << " : " << xRangeEnd << "]" << std::endl;
-    out << "set yrange [" << yRangeBegin << " : " << yRangeEnd << "]" << std::endl;	
-	out << "plot '-' using 1:2 notitle with lp " << std::endl;    
-	double previous_y = 0;
-	for ( size_t i = 0 ; i != pbns.size() ; ++i )
-	{
-		out << pbns[i].first << " " << previous_y << std::endl;
-		out << pbns[i].first << " " << pbns[i].second << std::endl;
-		previous_y = pbns[i].second;
-	}		
-	out << std::endl;
-	out.close();
-	
-	std::cout << "To visualize, open gnuplot and type: load \'" << gnuplot_script.str().c_str() << "\'" << std::endl;
-			
-	return 0;
+  return 0;
 }
diff --git a/src/Persistence_representations/utilities/persistence_intervals/plot_persistence_intervals.cpp b/src/Persistence_representations/utilities/persistence_intervals/plot_persistence_intervals.cpp
index ed03459b..32ca0fd9 100644
--- a/src/Persistence_representations/utilities/persistence_intervals/plot_persistence_intervals.cpp
+++ b/src/Persistence_representations/utilities/persistence_intervals/plot_persistence_intervals.cpp
@@ -20,50 +20,35 @@
  *    along with this program.  If not, see <http://www.gnu.org/licenses/>.
  */
 
-
-
 #include <gudhi/reader_utils.h>
 #include <gudhi/Persistence_intervals.h>
 #include <gudhi/read_persistence_from_file.h>
 
 #include <iostream>
 
-
-
 using namespace Gudhi;
 using namespace Gudhi::Persistence_representations;
 
-
 double epsilon = 0.0000005;
 
-	
-int main( int argc , char** argv )
-{
-	if ( argc < 2 )
-	{
-		std::cout << "To run this program, please provide the name of a file with persistence diagram \n";
-		std::cout << "The second optional parameter of a program is the dimension of the persistence that is to be used. If your file contains only birth-death pairs, you can skip this parameter\n";		
-		return 1;
-	}
-	unsigned dimension = std::numeric_limits<unsigned>::max();
-	int dim = -1;
-	if ( argc > 2 )
-	{
-		dim = atoi( argv[2] );
-	} 
-	if ( dim >= 0 )
-	{
-		dimension = (unsigned)dim;
-	}			
-	std::vector< std::pair< double , double > > intervals = read_persistence_intervals_in_one_dimension_from_file( argv[1] , dimension );
-	Persistence_intervals b( intervals );
-	b.plot( argv[1] );
-	return 0;
+int main(int argc, char** argv) {
+  if (argc < 2) {
+    std::cout << "To run this program, please provide the name of a file with persistence diagram \n";
+    std::cout << "The second optional parameter of a program is the dimension of the persistence that is to be used. "
+                 "If your file contains only birth-death pairs, you can skip this parameter\n";
+    return 1;
+  }
+  unsigned dimension = std::numeric_limits<unsigned>::max();
+  int dim = -1;
+  if (argc > 2) {
+    dim = atoi(argv[2]);
+  }
+  if (dim >= 0) {
+    dimension = (unsigned)dim;
+  }
+  std::vector<std::pair<double, double> > intervals =
+      read_persistence_intervals_in_one_dimension_from_file(argv[1], dimension);
+  Persistence_intervals b(intervals);
+  b.plot(argv[1]);
+  return 0;
 }
-
-
-
-
-
-
-
diff --git a/src/Persistence_representations/utilities/persistence_landscapes/average_landscapes.cpp b/src/Persistence_representations/utilities/persistence_landscapes/average_landscapes.cpp
index 1e0caa30..9816ff1d 100644
--- a/src/Persistence_representations/utilities/persistence_landscapes/average_landscapes.cpp
+++ b/src/Persistence_representations/utilities/persistence_landscapes/average_landscapes.cpp
@@ -20,55 +20,47 @@
  *    along with this program.  If not, see <http://www.gnu.org/licenses/>.
  */
 
-
-
 #include <gudhi/Persistence_landscape.h>
 
-
-
 using namespace Gudhi;
 using namespace Gudhi::Persistence_representations;
 
 #include <iostream>
 
+int main(int argc, char** argv) {
+  std::cout << "This program computes average persistence landscape of persistence landscapes created based on "
+               "persistence diagrams provided as an input (you must create them first).\n";
+  std::cout << "Please call this program with the names of files with persistence landscapes. The program will create "
+               "a persistence landscape which will be their average \n";
+  std::vector<const char*> filenames;
+
+  if (argc == 1) {
+    std::cout << "No input files given, the program will now terminate \n";
+    return 1;
+  }
+
+  for (int i = 1; i < argc; ++i) {
+    filenames.push_back(argv[i]);
+  }
+
+  std::cout << "Creating persistence landscapes...\n";
+  std::vector<Persistence_landscape*> lands;
+  for (size_t i = 0; i != filenames.size(); ++i) {
+    Persistence_landscape* l = new Persistence_landscape;
+    l->load_landscape_from_file(filenames[i]);
+    lands.push_back(l);
+  }
+
+  Persistence_landscape av;
+  av.compute_average(lands);
+
+  av.print_to_file("average.land");
+
+  for (size_t i = 0; i != filenames.size(); ++i) {
+    delete lands[i];
+  }
 
-int main( int argc , char** argv )
-{
-	std::cout << "This program computes average persistence landscape of persistence landscapes created based on persistence diagrams provided as an input (you must create them first).\n"; 
-	std::cout << "Please call this program with the names of files with persistence landscapes. The program will create a persistence landscape which will be their average \n";
-	std::vector< const char* > filenames;
-	
-	if ( argc == 1 )
-	{
-		std::cout << "No input files given, the program will now terminate \n";
-		return 1;
-	}
-	
-	for ( int i = 1 ; i < argc ; ++i )
-	{
-		filenames.push_back( argv[i] );
-	}
-	
-	std::cout << "Creating persistence landscapes...\n";
-	std::vector< Persistence_landscape* > lands;
-	for ( size_t i = 0 ; i != filenames.size() ; ++i )
-	{
-		Persistence_landscape* l = new Persistence_landscape;
-		l->load_landscape_from_file( filenames[i] );
-		lands.push_back( l );
-	}
-	
-	Persistence_landscape av;
-	av.compute_average( lands );
-	
-	av.print_to_file( "average.land" );
-	
-	for ( size_t i = 0 ; i != filenames.size() ; ++i )
-	{
-		delete lands[i];
-	}
-	
-	std::cout << "Done \n";
+  std::cout << "Done \n";
 
-	return 0;
+  return 0;
 }
diff --git a/src/Persistence_representations/utilities/persistence_landscapes/compute_distance_of_landscapes.cpp b/src/Persistence_representations/utilities/persistence_landscapes/compute_distance_of_landscapes.cpp
index ef969ed0..1c690c53 100644
--- a/src/Persistence_representations/utilities/persistence_landscapes/compute_distance_of_landscapes.cpp
+++ b/src/Persistence_representations/utilities/persistence_landscapes/compute_distance_of_landscapes.cpp
@@ -22,91 +22,71 @@
 
 #include <gudhi/Persistence_landscape.h>
 
-
-
 using namespace Gudhi;
 using namespace Gudhi::Persistence_representations;
 
 #include <iostream>
 #include <sstream>
 
+int main(int argc, char** argv) {
+  std::cout << "This program compute distance of persistence landscapes stored in a file (the file needs to be created "
+               "beforehand). \n";
+  std::cout << "The first parameter of a program is an integer p. The program compute L^p distance of the given "
+               "landscapes. For L^infty distance choose p = -1. \n";
+  std::cout << "The remaining parameters of this programs are names of files with persistence landscapes.";
 
-int main( int argc , char** argv )
-{
-	std::cout << "This program compute distance of persistence landscapes stored in a file (the file needs to be created beforehand). \n";	
-	std::cout << "The first parameter of a program is an integer p. The program compute L^p distance of the given landscapes. For L^infty distance choose p = -1. \n";
-	std::cout << "The remaining parameters of this programs are names of files with persistence landscapes.";
-	
-	if ( argc < 3 )
-	{
-		std::cout << "Wrong number of parameters, the program will now terminate \n";
-		return 1;
-	}
-	
-	int pp = atoi( argv[1] );
-	double p = std::numeric_limits<double>::max();
-	if ( pp != -1 )
-	{
-		p = pp;
-	}
-	
+  if (argc < 3) {
+    std::cout << "Wrong number of parameters, the program will now terminate \n";
+    return 1;
+  }
 
-	std::vector< const char* > filenames;
-	for ( int i = 2 ; i < argc ; ++i )
-	{
-		filenames.push_back( argv[i] );
-	}
-	std::vector< Persistence_landscape > landscaspes;
-	landscaspes.reserve( filenames.size() );
-	for ( size_t file_no = 0 ; file_no != filenames.size() ; ++file_no )
-	{
-		std::cout << "Loading persistence landscape from a file : " << filenames[file_no] << std::endl;
-		Persistence_landscape l;
-		l.load_landscape_from_file( filenames[file_no] );
-		landscaspes.push_back( l );
-	}
-		
-	//and now we will compute the scalar product of landscapes.
-	
-	//first we prepare an array:
-	std::vector< std::vector< double > > distance( filenames.size() );
-	for ( size_t i = 0 ; i != filenames.size() ; ++i )
-	{
-		std::vector< double > v( filenames.size() , 0 );
-		distance[i] = v;
-	}
-	
-	//and now we can compute the distances:
-	for ( size_t i = 0 ; i != landscaspes.size() ; ++i )
-	{
-		for ( size_t j = i ; j != landscaspes.size() ; ++j )
-		{			
-			distance[i][j] = distance[j][i] = compute_distance_of_landscapes( landscaspes[i], landscaspes[j] , p ) ;
-			
-		}
-	}
-	
-	//and now output the result to the screen and a file:
-	std::ofstream out;
-	out.open( "distance" );
-	for ( size_t i = 0 ; i != distance.size() ; ++i )
-	{
-		for ( size_t j = 0 ; j != distance.size() ; ++j )
-		{
-			std::cout << distance[i][j] << " ";
-			out << distance[i][j] << " ";
-		}
-		std::cout << std::endl;
-		out << std::endl;
-	}
-	out.close();
-		
-	return 0;
-}
+  int pp = atoi(argv[1]);
+  double p = std::numeric_limits<double>::max();
+  if (pp != -1) {
+    p = pp;
+  }
 
+  std::vector<const char*> filenames;
+  for (int i = 2; i < argc; ++i) {
+    filenames.push_back(argv[i]);
+  }
+  std::vector<Persistence_landscape> landscaspes;
+  landscaspes.reserve(filenames.size());
+  for (size_t file_no = 0; file_no != filenames.size(); ++file_no) {
+    std::cout << "Loading persistence landscape from a file : " << filenames[file_no] << std::endl;
+    Persistence_landscape l;
+    l.load_landscape_from_file(filenames[file_no]);
+    landscaspes.push_back(l);
+  }
 
+  // and now we will compute the scalar product of landscapes.
 
+  // first we prepare an array:
+  std::vector<std::vector<double> > distance(filenames.size());
+  for (size_t i = 0; i != filenames.size(); ++i) {
+    std::vector<double> v(filenames.size(), 0);
+    distance[i] = v;
+  }
 
+  // and now we can compute the distances:
+  for (size_t i = 0; i != landscaspes.size(); ++i) {
+    for (size_t j = i; j != landscaspes.size(); ++j) {
+      distance[i][j] = distance[j][i] = compute_distance_of_landscapes(landscaspes[i], landscaspes[j], p);
+    }
+  }
 
+  // and now output the result to the screen and a file:
+  std::ofstream out;
+  out.open("distance");
+  for (size_t i = 0; i != distance.size(); ++i) {
+    for (size_t j = 0; j != distance.size(); ++j) {
+      std::cout << distance[i][j] << " ";
+      out << distance[i][j] << " ";
+    }
+    std::cout << std::endl;
+    out << std::endl;
+  }
+  out.close();
 
-	
+  return 0;
+}
diff --git a/src/Persistence_representations/utilities/persistence_landscapes/compute_scalar_product_of_landscapes.cpp b/src/Persistence_representations/utilities/persistence_landscapes/compute_scalar_product_of_landscapes.cpp
index 02b729b2..83121a9c 100644
--- a/src/Persistence_representations/utilities/persistence_landscapes/compute_scalar_product_of_landscapes.cpp
+++ b/src/Persistence_representations/utilities/persistence_landscapes/compute_scalar_product_of_landscapes.cpp
@@ -22,68 +22,58 @@
 
 #include <gudhi/Persistence_landscape.h>
 
-
-
 using namespace Gudhi;
 using namespace Gudhi::Persistence_representations;
 
 #include <iostream>
 #include <sstream>
 
+int main(int argc, char** argv) {
+  std::cout << "This program compute scalar product of persistence landscapes stored in a file (the file needs to be "
+               "created beforehand). \n";
+  std::cout << "The parameters of this programs are names of files with persistence landscapes.\n";
+
+  std::vector<const char*> filenames;
+  for (int i = 1; i < argc; ++i) {
+    filenames.push_back(argv[i]);
+  }
+  std::vector<Persistence_landscape> landscaspes;
+  landscaspes.reserve(filenames.size());
+  for (size_t file_no = 0; file_no != filenames.size(); ++file_no) {
+    std::cout << "Reading persistence landscape from a file : " << filenames[file_no] << std::endl;
+    Persistence_landscape l;
+    l.load_landscape_from_file(filenames[file_no]);
+    landscaspes.push_back(l);
+  }
+
+  // and now we will compute the scalar product of landscapes.
+
+  // first we prepare an array:
+  std::vector<std::vector<double> > scalar_product(filenames.size());
+  for (size_t i = 0; i != filenames.size(); ++i) {
+    std::vector<double> v(filenames.size(), 0);
+    scalar_product[i] = v;
+  }
+
+  // and now we can compute the scalar product:
+  for (size_t i = 0; i != landscaspes.size(); ++i) {
+    for (size_t j = i; j != landscaspes.size(); ++j) {
+      scalar_product[i][j] = scalar_product[j][i] = compute_inner_product(landscaspes[i], landscaspes[j]);
+    }
+  }
 
-int main( int argc , char** argv )
-{
-	std::cout << "This program compute scalar product of persistence landscapes stored in a file (the file needs to be created beforehand). \n";	
-	std::cout << "The parameters of this programs are names of files with persistence landscapes.\n";
+  // and now output the result to the screen and a file:
+  std::ofstream out;
+  out.open("scalar_product");
+  for (size_t i = 0; i != scalar_product.size(); ++i) {
+    for (size_t j = 0; j != scalar_product.size(); ++j) {
+      std::cout << scalar_product[i][j] << " ";
+      out << scalar_product[i][j] << " ";
+    }
+    std::cout << std::endl;
+    out << std::endl;
+  }
+  out.close();
 
-	std::vector< const char* > filenames;
-	for ( int i = 1 ; i < argc ; ++i )
-	{
-		filenames.push_back( argv[i] );
-	}
-	std::vector< Persistence_landscape > landscaspes;
-	landscaspes.reserve( filenames.size() );
-	for ( size_t file_no = 0 ; file_no != filenames.size() ; ++file_no )
-	{
-		std::cout << "Reading persistence landscape from a file : " << filenames[file_no] << std::endl;
-		Persistence_landscape l;
-		l.load_landscape_from_file( filenames[file_no] );
-		landscaspes.push_back( l );
-	}
-		
-	//and now we will compute the scalar product of landscapes.
-	
-	//first we prepare an array:
-	std::vector< std::vector< double > > scalar_product( filenames.size() );
-	for ( size_t i = 0 ; i != filenames.size() ; ++i )
-	{
-		std::vector< double > v( filenames.size() , 0 );
-		scalar_product[i] = v;
-	}
-	
-	//and now we can compute the scalar product:
-	for ( size_t i = 0 ; i != landscaspes.size() ; ++i )
-	{
-		for ( size_t j = i ; j != landscaspes.size() ; ++j )
-		{
-			scalar_product[i][j] = scalar_product[j][i] = compute_inner_product( landscaspes[i], landscaspes[j] ) ;
-		}
-	}
-	
-	//and now output the result to the screen and a file:
-	std::ofstream out;
-	out.open( "scalar_product" );
-	for ( size_t i = 0 ; i != scalar_product.size() ; ++i )
-	{
-		for ( size_t j = 0 ; j != scalar_product.size() ; ++j )
-		{
-			std::cout << scalar_product[i][j] << " ";
-			out << scalar_product[i][j] << " ";
-		}
-		std::cout << std::endl;
-		out << std::endl;
-	}
-	out.close();
-		
-	return 0;
+  return 0;
 }
diff --git a/src/Persistence_representations/utilities/persistence_landscapes/create_landscapes.cpp b/src/Persistence_representations/utilities/persistence_landscapes/create_landscapes.cpp
index b85c8644..f98fe3ad 100644
--- a/src/Persistence_representations/utilities/persistence_landscapes/create_landscapes.cpp
+++ b/src/Persistence_representations/utilities/persistence_landscapes/create_landscapes.cpp
@@ -22,41 +22,37 @@
 
 #include <gudhi/Persistence_landscape.h>
 
-
 using namespace Gudhi;
 using namespace Gudhi::Persistence_representations;
 
 #include <iostream>
 #include <sstream>
 
+int main(int argc, char** argv) {
+  std::cout << "This program creates persistence landscapes of diagrams provided as an input. \n";
+  std::cout << "The first parameter of the program is the dimension of persistence to be used to construct persistence "
+               "landscapes. If your file contains ";
+  std::cout << "the information about dimension of persistence pairs, please provide here the dimension of persistence "
+               "pairs you want to use. If your input files consist only ";
+  std::cout << "of birth-death pairs, please set this first parameter to -1 \n";
+  std::cout << "The remaining parameters of the program are the names of files with persistence diagrams. \n";
+  std::vector<const char*> filenames;
+  int dim = atoi(argv[1]);
+  unsigned dimension = std::numeric_limits<unsigned>::max();
+  if (dim >= 0) {
+    dimension = (unsigned)dim;
+  }
+  for (int i = 2; i < argc; ++i) {
+    filenames.push_back(argv[i]);
+  }
 
-int main( int argc , char** argv )
-{
-	std::cout << "This program creates persistence landscapes of diagrams provided as an input. \n";
-	std::cout << "The first parameter of the program is the dimension of persistence to be used to construct persistence landscapes. If your file contains ";
-	std::cout << "the information about dimension of persistence pairs, please provide here the dimension of persistence pairs you want to use. If your input files consist only ";
-	std::cout << "of birth-death pairs, please set this first parameter to -1 \n";	
-	std::cout << "The remaining parameters of the program are the names of files with persistence diagrams. \n";
-	std::vector< const char* > filenames;
-	int dim = atoi(argv[1]);
-	unsigned dimension = std::numeric_limits<unsigned>::max();
-	if ( dim >= 0 )
-	{
-		dimension = (unsigned)dim;
-	}
-	for ( int i = 2 ; i < argc ; ++i )
-	{
-		filenames.push_back( argv[i] );
-	}
-	
-	std::cout << "Creating persistence landscapes...\n";	
-	for ( size_t i = 0 ; i != filenames.size() ; ++i )
-	{
-		Persistence_landscape l( filenames[i] , dimension );
-		std::stringstream ss;
-		ss << filenames[i] << ".land";
-		l.print_to_file( ss.str().c_str() );
-	}
-	std::cout << "Done \n";
-	return 0;
+  std::cout << "Creating persistence landscapes...\n";
+  for (size_t i = 0; i != filenames.size(); ++i) {
+    Persistence_landscape l(filenames[i], dimension);
+    std::stringstream ss;
+    ss << filenames[i] << ".land";
+    l.print_to_file(ss.str().c_str());
+  }
+  std::cout << "Done \n";
+  return 0;
 }
diff --git a/src/Persistence_representations/utilities/persistence_landscapes/plot_landscapes.cpp b/src/Persistence_representations/utilities/persistence_landscapes/plot_landscapes.cpp
index 670f0364..4761a095 100644
--- a/src/Persistence_representations/utilities/persistence_landscapes/plot_landscapes.cpp
+++ b/src/Persistence_representations/utilities/persistence_landscapes/plot_landscapes.cpp
@@ -22,26 +22,23 @@
 
 #include <gudhi/Persistence_landscape.h>
 
-
-
 using namespace Gudhi;
 using namespace Gudhi::Persistence_representations;
 
 #include <iostream>
 #include <sstream>
 
+int main(int argc, char** argv) {
+  std::cout << "This program plot persistence landscape stored in a file (the file needs to be created beforehand). "
+               "Please call the code with the name of a landscape file \n";
+  Persistence_landscape l;
+  l.load_landscape_from_file(argv[1]);
+
+  std::stringstream ss;
+  ss << argv[1] << "_gnuplot_script";
+  l.plot(ss.str().c_str());
+
+  std::cout << "Done \n";
 
-int main( int argc , char** argv )
-{
-	std::cout << "This program plot persistence landscape stored in a file (the file needs to be created beforehand). Please call the code with the name of a landscape file \n";	
-	Persistence_landscape l;
-	l.load_landscape_from_file( argv[1] );
-	
-	std::stringstream ss;
-	ss << argv[1] << "_gnuplot_script";
-	l.plot( ss.str().c_str() );
-	
-	std::cout << "Done \n";
-		
-	return 0;
+  return 0;
 }
diff --git a/src/Persistence_representations/utilities/persistence_landscapes_on_grid/average_landscapes_on_grid.cpp b/src/Persistence_representations/utilities/persistence_landscapes_on_grid/average_landscapes_on_grid.cpp
index 10d9e7ac..87512212 100644
--- a/src/Persistence_representations/utilities/persistence_landscapes_on_grid/average_landscapes_on_grid.cpp
+++ b/src/Persistence_representations/utilities/persistence_landscapes_on_grid/average_landscapes_on_grid.cpp
@@ -22,50 +22,44 @@
 
 #include <gudhi/Persistence_landscape_on_grid.h>
 
-
-
 using namespace Gudhi;
 using namespace Gudhi::Persistence_representations;
 
 #include <iostream>
 
+int main(int argc, char** argv) {
+  std::cout << "This program computes average persistence landscape on grid of persistence landscapes on grid created "
+               "based on persistence diagrams provided as an input. Please call this program with the names of files "
+               "with persistence diagrams \n";
+  std::vector<const char*> filenames;
+
+  if (argc == 1) {
+    std::cout << "No input files given, the program will now terminate \n";
+    return 1;
+  }
+
+  for (int i = 1; i < argc; ++i) {
+    filenames.push_back(argv[i]);
+  }
+
+  std::cout << "Creating persistence landscapes...\n";
+  std::vector<Persistence_landscape_on_grid*> lands;
+  for (size_t i = 0; i != filenames.size(); ++i) {
+    Persistence_landscape_on_grid* l = new Persistence_landscape_on_grid;
+    l->load_landscape_from_file(filenames[i]);
+    lands.push_back(l);
+  }
+
+  Persistence_landscape_on_grid av;
+  av.compute_average(lands);
+
+  av.print_to_file("average.g_land");
+
+  for (size_t i = 0; i != filenames.size(); ++i) {
+    delete lands[i];
+  }
 
-int main( int argc , char** argv )
-{
-	std::cout << "This program computes average persistence landscape on grid of persistence landscapes on grid created based on persistence diagrams provided as an input. Please call this program with the names of files with persistence diagrams \n";
-	std::vector< const char* > filenames;
-	
-	if ( argc == 1 )
-	{
-		std::cout << "No input files given, the program will now terminate \n";
-		return 1;
-	}
-	
-	for ( int i = 1 ; i < argc ; ++i )
-	{
-		filenames.push_back( argv[i] );
-	}
-	
-	std::cout << "Creating persistence landscapes...\n";
-	std::vector< Persistence_landscape_on_grid* > lands;
-	for ( size_t i = 0 ; i != filenames.size() ; ++i )
-	{
-		Persistence_landscape_on_grid* l = new Persistence_landscape_on_grid;
-		l->load_landscape_from_file( filenames[i] );
-		lands.push_back( l );
-	}
-	
-	Persistence_landscape_on_grid av;
-	av.compute_average( lands );
-	
-	av.print_to_file( "average.g_land" );
-	
-	for ( size_t i = 0 ; i != filenames.size() ; ++i )
-	{
-		delete lands[i];
-	}
-	
-	std::cout << "Done \n";
+  std::cout << "Done \n";
 
-	return 0;
+  return 0;
 }
diff --git a/src/Persistence_representations/utilities/persistence_landscapes_on_grid/compute_distance_of_landscapes_on_grid.cpp b/src/Persistence_representations/utilities/persistence_landscapes_on_grid/compute_distance_of_landscapes_on_grid.cpp
index 3065b52c..db920c82 100644
--- a/src/Persistence_representations/utilities/persistence_landscapes_on_grid/compute_distance_of_landscapes_on_grid.cpp
+++ b/src/Persistence_representations/utilities/persistence_landscapes_on_grid/compute_distance_of_landscapes_on_grid.cpp
@@ -22,87 +22,70 @@
 
 #include <gudhi/Persistence_landscape_on_grid.h>
 
-
-
 using namespace Gudhi;
 using namespace Gudhi::Persistence_representations;
 
 #include <iostream>
 #include <sstream>
 
+int main(int argc, char** argv) {
+  std::cout << "This program compute distance of persistence landscapes on grid stored in a file (the file needs to be "
+               "created beforehand). \n";
+  std::cout << "The first parameter of a program is an integer p. The program compute L^p distance of the landscapes "
+               "on grid. For L^infty distance choose p = -1. \n";
+  std::cout << "The remaining parameters of this programs are names of files with persistence landscapes on grid.\n";
 
-int main( int argc , char** argv )
-{
-	std::cout << "This program compute distance of persistence landscapes on grid stored in a file (the file needs to be created beforehand). \n";	
-	std::cout << "The first parameter of a program is an integer p. The program compute L^p distance of the landscapes on grid. For L^infty distance choose p = -1. \n";
-	std::cout << "The remaining parameters of this programs are names of files with persistence landscapes on grid.\n";
-	
-	if ( argc < 3 )
-	{
-		std::cout << "Wrong number of parameters, the program will now terminate \n";
-		return 1;
-	}
-	
-	int pp = atoi( argv[1] );
-	double p = std::numeric_limits<double>::max();
-	if ( pp != -1 )
-	{
-		p = pp;
-	}
-	
+  if (argc < 3) {
+    std::cout << "Wrong number of parameters, the program will now terminate \n";
+    return 1;
+  }
 
-	std::vector< const char* > filenames;
-	for ( int i = 2 ; i < argc ; ++i )
-	{
-		filenames.push_back( argv[i] );
-	}
-	std::vector< Persistence_landscape_on_grid > landscaspes;
-	landscaspes.reserve( filenames.size() );
-	for ( size_t file_no = 0 ; file_no != filenames.size() ; ++file_no )
-	{
-		Persistence_landscape_on_grid l;
-		l.load_landscape_from_file( filenames[file_no] );
-		landscaspes.push_back( l );
-	}
-		
-	//and now we will compute the scalar product of landscapes.
-	
-	//first we prepare an array:
-	std::vector< std::vector< double > > distance( filenames.size() );
-	for ( size_t i = 0 ; i != filenames.size() ; ++i )
-	{
-		std::vector< double > v( filenames.size() , 0 );
-		distance[i] = v;
-	}
-	
-	//and now we can compute the scalar product:
-	for ( size_t i = 0 ; i != landscaspes.size() ; ++i )
-	{
-		for ( size_t j = i ; j != landscaspes.size() ; ++j )
-		{
-			distance[i][j] = distance[j][i] = compute_distance_of_landscapes_on_grid( landscaspes[i], landscaspes[j] , p ) ;
-		}
-	}
-	
-	//and now output the result to the screen and a file:
-	std::ofstream out;
-	out.open( "distance" );
-	for ( size_t i = 0 ; i != distance.size() ; ++i )
-	{
-		for ( size_t j = 0 ; j != distance.size() ; ++j )
-		{
-			std::cout << distance[i][j] << " ";
-			out << distance[i][j] << " ";
-		}
-		std::cout << std::endl;
-		out << std::endl;
-	}
-	out.close();
-		
-	return 0;
-}
+  int pp = atoi(argv[1]);
+  double p = std::numeric_limits<double>::max();
+  if (pp != -1) {
+    p = pp;
+  }
 
+  std::vector<const char*> filenames;
+  for (int i = 2; i < argc; ++i) {
+    filenames.push_back(argv[i]);
+  }
+  std::vector<Persistence_landscape_on_grid> landscaspes;
+  landscaspes.reserve(filenames.size());
+  for (size_t file_no = 0; file_no != filenames.size(); ++file_no) {
+    Persistence_landscape_on_grid l;
+    l.load_landscape_from_file(filenames[file_no]);
+    landscaspes.push_back(l);
+  }
 
+  // and now we will compute the scalar product of landscapes.
 
+  // first we prepare an array:
+  std::vector<std::vector<double> > distance(filenames.size());
+  for (size_t i = 0; i != filenames.size(); ++i) {
+    std::vector<double> v(filenames.size(), 0);
+    distance[i] = v;
+  }
 
+  // and now we can compute the scalar product:
+  for (size_t i = 0; i != landscaspes.size(); ++i) {
+    for (size_t j = i; j != landscaspes.size(); ++j) {
+      distance[i][j] = distance[j][i] = compute_distance_of_landscapes_on_grid(landscaspes[i], landscaspes[j], p);
+    }
+  }
 
+  // and now output the result to the screen and a file:
+  std::ofstream out;
+  out.open("distance");
+  for (size_t i = 0; i != distance.size(); ++i) {
+    for (size_t j = 0; j != distance.size(); ++j) {
+      std::cout << distance[i][j] << " ";
+      out << distance[i][j] << " ";
+    }
+    std::cout << std::endl;
+    out << std::endl;
+  }
+  out.close();
+
+  return 0;
+}
diff --git a/src/Persistence_representations/utilities/persistence_landscapes_on_grid/compute_scalar_product_of_landscapes_on_grid.cpp b/src/Persistence_representations/utilities/persistence_landscapes_on_grid/compute_scalar_product_of_landscapes_on_grid.cpp
index 342613b4..9bbba7cf 100644
--- a/src/Persistence_representations/utilities/persistence_landscapes_on_grid/compute_scalar_product_of_landscapes_on_grid.cpp
+++ b/src/Persistence_representations/utilities/persistence_landscapes_on_grid/compute_scalar_product_of_landscapes_on_grid.cpp
@@ -20,70 +20,59 @@
  *    along with this program.  If not, see <http://www.gnu.org/licenses/>.
  */
 
-
 #include <gudhi/Persistence_landscape_on_grid.h>
 
-
-
 using namespace Gudhi;
 using namespace Gudhi::Persistence_representations;
 
 #include <iostream>
 #include <sstream>
 
+int main(int argc, char** argv) {
+  std::cout << "This program compute scalar product of persistence landscapes on grid stored in a file (the file needs "
+               "to be created beforehand). \n";
+  std::cout << "The parameters of this programs are names of files with persistence landscapes on grid.\n";
+
+  std::vector<const char*> filenames;
+  for (int i = 1; i < argc; ++i) {
+    filenames.push_back(argv[i]);
+  }
+  std::vector<Persistence_landscape_on_grid> landscaspes;
+  landscaspes.reserve(filenames.size());
+  for (size_t file_no = 0; file_no != filenames.size(); ++file_no) {
+    Persistence_landscape_on_grid l;
+    l.load_landscape_from_file(filenames[file_no]);
+    landscaspes.push_back(l);
+  }
+
+  // and now we will compute the scalar product of landscapes.
+
+  // first we prepare an array:
+  std::vector<std::vector<double> > scalar_product(filenames.size());
+  for (size_t i = 0; i != filenames.size(); ++i) {
+    std::vector<double> v(filenames.size(), 0);
+    scalar_product[i] = v;
+  }
+
+  // and now we can compute the scalar product:
+  for (size_t i = 0; i != landscaspes.size(); ++i) {
+    for (size_t j = i; j != landscaspes.size(); ++j) {
+      scalar_product[i][j] = scalar_product[j][i] = compute_inner_product(landscaspes[i], landscaspes[j]);
+    }
+  }
 
-int main( int argc , char** argv )
-{
-	std::cout << "This program compute scalar product of persistence landscapes on grid stored in a file (the file needs to be created beforehand). \n";	
-	std::cout << "The parameters of this programs are names of files with persistence landscapes on grid.\n";
+  // and now output the result to the screen and a file:
+  std::ofstream out;
+  out.open("scalar_product");
+  for (size_t i = 0; i != scalar_product.size(); ++i) {
+    for (size_t j = 0; j != scalar_product.size(); ++j) {
+      std::cout << scalar_product[i][j] << " ";
+      out << scalar_product[i][j] << " ";
+    }
+    std::cout << std::endl;
+    out << std::endl;
+  }
+  out.close();
 
-	std::vector< const char* > filenames;
-	for ( int i = 1 ; i < argc ; ++i )
-	{
-		filenames.push_back( argv[i] );
-	}
-	std::vector< Persistence_landscape_on_grid > landscaspes;
-	landscaspes.reserve( filenames.size() );
-	for ( size_t file_no = 0 ; file_no != filenames.size() ; ++file_no )
-	{
-		Persistence_landscape_on_grid l;
-		l.load_landscape_from_file( filenames[file_no] );
-		landscaspes.push_back( l );
-	}
-		
-	//and now we will compute the scalar product of landscapes.
-	
-	//first we prepare an array:
-	std::vector< std::vector< double > > scalar_product( filenames.size() );
-	for ( size_t i = 0 ; i != filenames.size() ; ++i )
-	{
-		std::vector< double > v( filenames.size() , 0 );
-		scalar_product[i] = v;
-	}
-	
-	//and now we can compute the scalar product:
-	for ( size_t i = 0 ; i != landscaspes.size() ; ++i )
-	{
-		for ( size_t j = i ; j != landscaspes.size() ; ++j )
-		{
-			scalar_product[i][j] = scalar_product[j][i] = compute_inner_product( landscaspes[i], landscaspes[j] ) ;
-		}
-	}
-	
-	//and now output the result to the screen and a file:
-	std::ofstream out;
-	out.open( "scalar_product" );
-	for ( size_t i = 0 ; i != scalar_product.size() ; ++i )
-	{
-		for ( size_t j = 0 ; j != scalar_product.size() ; ++j )
-		{
-			std::cout << scalar_product[i][j] << " ";
-			out << scalar_product[i][j] << " ";
-		}
-		std::cout << std::endl;
-		out << std::endl;
-	}
-	out.close();
-		
-	return 0;
+  return 0;
 }
diff --git a/src/Persistence_representations/utilities/persistence_landscapes_on_grid/create_landscapes_on_grid.cpp b/src/Persistence_representations/utilities/persistence_landscapes_on_grid/create_landscapes_on_grid.cpp
index a033362c..e135896c 100644
--- a/src/Persistence_representations/utilities/persistence_landscapes_on_grid/create_landscapes_on_grid.cpp
+++ b/src/Persistence_representations/utilities/persistence_landscapes_on_grid/create_landscapes_on_grid.cpp
@@ -22,65 +22,57 @@
 
 #include <gudhi/Persistence_landscape_on_grid.h>
 
-
-
 using namespace Gudhi;
 using namespace Gudhi::Persistence_representations;
 
 #include <iostream>
 #include <sstream>
 
+int main(int argc, char** argv) {
+  std::cout << "This program creates persistence landscape on grid of diagrams provided as an input.\n";
+  std::cout << "The first parameter of a program is an integer, a size of a grid.\n";
+  std::cout << "The second and third parameters are min and max of the grid. If you want those numbers to be computed "
+               "based on the data, set them both to -1 \n";
+  std::cout << "The fourth parameter of the program is the dimension of persistence to be used to construct "
+               "persistence landscape on a grid. If your file contains ";
+  std::cout << "the information about dimension of birth-death pairs, please provide here the dimension of intervals "
+               "you want to use. If your input files consist only ";
+  std::cout << "of birth-death pairs, please set the fourth parameter to -1 \n";
+  std::cout << "The remaining parameters are the names of files with persistence diagrams. \n";
+
+  if (argc < 5) {
+    std::cout << "Wrong parameter list, the program will now terminate \n";
+    return 1;
+  }
+
+  size_t size_of_grid = (size_t)atoi(argv[1]);
+  double min_ = atof(argv[2]);
+  double max_ = atof(argv[3]);
+  int dim = atoi(argv[4]);
+  unsigned dimension = std::numeric_limits<unsigned>::max();
+  if (dim >= 0) {
+    dimension = (unsigned)dim;
+  }
+
+  std::vector<const char*> filenames;
+  for (int i = 5; i < argc; ++i) {
+    filenames.push_back(argv[i]);
+  }
 
-int main( int argc , char** argv )
-{
-	std::cout << "This program creates persistence landscape on grid of diagrams provided as an input.\n";
-	std::cout << "The first parameter of a program is an integer, a size of a grid.\n";
-	std::cout << "The second and third parameters are min and max of the grid. If you want those numbers to be computed based on the data, set them both to -1 \n";
-	std::cout << "The fourth parameter of the program is the dimension of persistence to be used to construct persistence landscape on a grid. If your file contains ";
-	std::cout << "the information about dimension of birth-death pairs, please provide here the dimension of intervals you want to use. If your input files consist only ";
-	std::cout << "of birth-death pairs, please set the fourth parameter to -1 \n";
-	std::cout << "The remaining parameters are the names of files with persistence diagrams. \n";
-	
-	if ( argc < 5 )
-	{
-		std::cout << "Wrong parameter list, the program will now terminate \n";
-		return 1;
-	}
-	
-	size_t size_of_grid = (size_t)atoi( argv[1] );
-	double min_ = atof( argv[2] );
-	double max_ = atof( argv[3] );
-	int dim = atoi( argv[4] );
-	unsigned dimension = std::numeric_limits<unsigned>::max();
-	if ( dim >= 0 )
-	{
-		dimension = (unsigned)dim;
-	}
-	
-	std::vector< const char* > filenames;
-	for ( int i = 5 ; i < argc ; ++i )
-	{
-		filenames.push_back( argv[i] );
-	}
-	
-	std::cout << "Creating persistence landscapes...\n";	
-	for ( size_t i = 0 ; i != filenames.size() ; ++i )
-	{
-		std::cout << "Creating persistence landscape on a grid based on a file : " << filenames[i] << std::endl;
-		Persistence_landscape_on_grid l;
-		if ( (min_ != -1) || (max_ != -1) )
-		{
-			l = Persistence_landscape_on_grid( filenames[i] , min_ , max_ , size_of_grid , dimension );
-		}
-		else
-		{
-			//(min_ == -1) && (max_ == -1), in this case the program will find min_ and max_ based on the data.
-			l = Persistence_landscape_on_grid( filenames[i] , size_of_grid , dimension );
-		}		
-		std::stringstream ss;
-		ss << filenames[i] << ".g_land";
-		l.print_to_file( ss.str().c_str() );
-	}
-	std::cout << "Done \n";
-	return 0;
+  std::cout << "Creating persistence landscapes...\n";
+  for (size_t i = 0; i != filenames.size(); ++i) {
+    std::cout << "Creating persistence landscape on a grid based on a file : " << filenames[i] << std::endl;
+    Persistence_landscape_on_grid l;
+    if ((min_ != -1) || (max_ != -1)) {
+      l = Persistence_landscape_on_grid(filenames[i], min_, max_, size_of_grid, dimension);
+    } else {
+      //(min_ == -1) && (max_ == -1), in this case the program will find min_ and max_ based on the data.
+      l = Persistence_landscape_on_grid(filenames[i], size_of_grid, dimension);
+    }
+    std::stringstream ss;
+    ss << filenames[i] << ".g_land";
+    l.print_to_file(ss.str().c_str());
+  }
+  std::cout << "Done \n";
+  return 0;
 }
diff --git a/src/Persistence_representations/utilities/persistence_landscapes_on_grid/plot_landscapes_on_grid.cpp b/src/Persistence_representations/utilities/persistence_landscapes_on_grid/plot_landscapes_on_grid.cpp
index b4fa3046..d9d7d7af 100644
--- a/src/Persistence_representations/utilities/persistence_landscapes_on_grid/plot_landscapes_on_grid.cpp
+++ b/src/Persistence_representations/utilities/persistence_landscapes_on_grid/plot_landscapes_on_grid.cpp
@@ -22,31 +22,27 @@
 
 #include <gudhi/Persistence_landscape_on_grid.h>
 
-
-
 using namespace Gudhi;
 using namespace Gudhi::Persistence_representations;
 
 #include <iostream>
 #include <sstream>
 
+int main(int argc, char** argv) {
+  std::cout << "This program plot persistence landscape on grid stored in a file (the file needs to be created "
+               "beforehand). Please call the code with the name of a landscape on grid file \n";
+  if (argc == 1) {
+    std::cout << "Wrong parameters of a program call, the program will now terminate \n";
+    return 1;
+  }
+  Persistence_landscape_on_grid l;
+  l.load_landscape_from_file(argv[1]);
+
+  std::stringstream ss;
+  ss << argv[1] << "_gnuplot_script";
+  l.plot(ss.str().c_str());
+
+  std::cout << "Done \n";
 
-int main( int argc , char** argv )
-{
-	std::cout << "This program plot persistence landscape on grid stored in a file (the file needs to be created beforehand). Please call the code with the name of a landscape on grid file \n";	
-	if ( argc == 1 )
-	{
-		std::cout << "Wrong parameters of a program call, the program will now terminate \n";
-		return 1;
-	}
-	Persistence_landscape_on_grid l;
-	l.load_landscape_from_file( argv[1] );
-	
-	std::stringstream ss;
-	ss << argv[1] << "_gnuplot_script";
-	l.plot( ss.str().c_str() );
-	
-	std::cout << "Done \n";
-		
-	return 0;
+  return 0;
 }
diff --git a/src/Persistence_representations/utilities/persistence_vectors/average_persistence_vectors.cpp b/src/Persistence_representations/utilities/persistence_vectors/average_persistence_vectors.cpp
index 320d1f63..aa26ce2b 100644
--- a/src/Persistence_representations/utilities/persistence_vectors/average_persistence_vectors.cpp
+++ b/src/Persistence_representations/utilities/persistence_vectors/average_persistence_vectors.cpp
@@ -20,54 +20,46 @@
  *    along with this program.  If not, see <http://www.gnu.org/licenses/>.
  */
 
-
 #include <gudhi/Persistence_vectors.h>
 
-
-
 using namespace Gudhi;
 using namespace Gudhi::Persistence_representations;
 
 #include <iostream>
 
+int main(int argc, char** argv) {
+  std::cout << "This program computes average persistence vector of persistence vectors created based on persistence "
+               "diagrams provided as an input. \n";
+  std::cout << "Please call this program with the names of files with persistence diagrams \n";
+  std::vector<const char*> filenames;
+
+  if (argc == 1) {
+    std::cout << "No input files given, the program will now terminate \n";
+    return 1;
+  }
+
+  for (int i = 1; i < argc; ++i) {
+    filenames.push_back(argv[i]);
+  }
+
+  std::cout << "Reading persistence vectors...\n";
+  std::vector<Vector_distances_in_diagram<Euclidean_distance>*> lands;
+  for (size_t i = 0; i != filenames.size(); ++i) {
+    Vector_distances_in_diagram<Euclidean_distance>* l = new Vector_distances_in_diagram<Euclidean_distance>;
+    l->load_from_file(filenames[i]);
+    lands.push_back(l);
+  }
+
+  Vector_distances_in_diagram<Euclidean_distance> av;
+  av.compute_average(lands);
+
+  av.print_to_file("average.vect");
+
+  for (size_t i = 0; i != filenames.size(); ++i) {
+    delete lands[i];
+  }
 
-int main( int argc , char** argv )
-{
-	std::cout << "This program computes average persistence vector of persistence vectors created based on persistence diagrams provided as an input. \n";
-	std::cout << "Please call this program with the names of files with persistence diagrams \n";
-	std::vector< const char* > filenames;
-	
-	if ( argc == 1 )
-	{
-		std::cout << "No input files given, the program will now terminate \n";
-		return 1;
-	}
-	
-	for ( int i = 1 ; i < argc ; ++i )
-	{
-		filenames.push_back( argv[i] );
-	}
-	
-	std::cout << "Reading persistence vectors...\n";
-	std::vector< Vector_distances_in_diagram< Euclidean_distance >* > lands;
-	for ( size_t i = 0 ; i != filenames.size() ; ++i )
-	{		
-		Vector_distances_in_diagram< Euclidean_distance >* l = new Vector_distances_in_diagram< Euclidean_distance >;
-		l->load_from_file( filenames[i] );
-		lands.push_back(l );
-	}
-	
-	Vector_distances_in_diagram< Euclidean_distance > av;
-	av.compute_average( lands );
-	
-	av.print_to_file( "average.vect" );
-	
-	for ( size_t i = 0 ; i != filenames.size() ; ++i )
-	{
-		delete lands[i];
-	}
-	
-	std::cout << "Done \n";
+  std::cout << "Done \n";
 
-	return 0;
+  return 0;
 }
diff --git a/src/Persistence_representations/utilities/persistence_vectors/compute_distance_of_persistence_vectors.cpp b/src/Persistence_representations/utilities/persistence_vectors/compute_distance_of_persistence_vectors.cpp
index 5c0d3328..3ab8033c 100644
--- a/src/Persistence_representations/utilities/persistence_vectors/compute_distance_of_persistence_vectors.cpp
+++ b/src/Persistence_representations/utilities/persistence_vectors/compute_distance_of_persistence_vectors.cpp
@@ -22,89 +22,70 @@
 
 #include <gudhi/Persistence_vectors.h>
 
-
-
 using namespace Gudhi;
 using namespace Gudhi::Persistence_representations;
 
 #include <iostream>
 #include <sstream>
 
+int main(int argc, char** argv) {
+  std::cout << "This program compute distance of persistence vectors stored in a file (the file needs to be created "
+               "beforehand). \n";
+  std::cout << "The first parameter of a program is an integer p. The program compute l^p distance of the vectors. For "
+               "l^infty distance choose p = -1. \n";
+  std::cout << "The remaining parameters of this programs are names of files with persistence vectors.\n";
 
-int main( int argc , char** argv )
-{
-	std::cout << "This program compute distance of persistence vectors stored in a file (the file needs to be created beforehand). \n";	
-	std::cout << "The first parameter of a program is an integer p. The program compute l^p distance of the vectors. For l^infty distance choose p = -1. \n";
-	std::cout << "The remaining parameters of this programs are names of files with persistence vectors.\n";
-	
-	if ( argc < 3 )
-	{
-		std::cout << "Wrong number of parameters, the program will now terminate \n";
-		return 1;
-	}
-	
-	int pp = atoi( argv[1] );
-	double p = std::numeric_limits<double>::max();
-	if ( pp != -1 )
-	{
-		p = pp;
-	}
-	
+  if (argc < 3) {
+    std::cout << "Wrong number of parameters, the program will now terminate \n";
+    return 1;
+  }
 
-	std::vector< const char* > filenames;
-	for ( int i = 2 ; i < argc ; ++i )
-	{
-		filenames.push_back( argv[i] );
-	}
-	std::vector< Vector_distances_in_diagram< Euclidean_distance > > vectors;
-	vectors.reserve( filenames.size() );
-	for ( size_t file_no = 0 ; file_no != filenames.size() ; ++file_no )
-	{
-		Vector_distances_in_diagram< Euclidean_distance > l;
-		l.load_from_file( filenames[file_no] );
-		vectors.push_back( l );
-	}
-		
-	//and now we will compute the scalar product of landscapes.
-	
-	//first we prepare an array:
-	std::vector< std::vector< double > > distance( filenames.size() );
-	for ( size_t i = 0 ; i != filenames.size() ; ++i )
-	{
-		std::vector< double > v( filenames.size() , 0 );
-		distance[i] = v;
-	}
-		
-	//and now we can compute the distances:
-	for ( size_t i = 0 ; i != vectors.size() ; ++i )
-	{
-		for ( size_t j = i+1 ; j != vectors.size() ; ++j )
-		{
-			distance[i][j] = distance[j][i] = vectors[i].distance( vectors[j] , p ) ;
-		}
-	}
-	
-	//and now output the result to the screen and a file:
-	std::ofstream out;
-	out.open( "distance" );
-	for ( size_t i = 0 ; i != distance.size() ; ++i )
-	{
-		for ( size_t j = 0 ; j != distance.size() ; ++j )
-		{
-			std::cout << distance[i][j] << " ";
-			out << distance[i][j] << " ";
-		}
-		std::cout << std::endl;
-		out << std::endl;
-	}
-	out.close();
-		
-	return 0;
-}
+  int pp = atoi(argv[1]);
+  double p = std::numeric_limits<double>::max();
+  if (pp != -1) {
+    p = pp;
+  }
 
+  std::vector<const char*> filenames;
+  for (int i = 2; i < argc; ++i) {
+    filenames.push_back(argv[i]);
+  }
+  std::vector<Vector_distances_in_diagram<Euclidean_distance> > vectors;
+  vectors.reserve(filenames.size());
+  for (size_t file_no = 0; file_no != filenames.size(); ++file_no) {
+    Vector_distances_in_diagram<Euclidean_distance> l;
+    l.load_from_file(filenames[file_no]);
+    vectors.push_back(l);
+  }
 
+  // and now we will compute the scalar product of landscapes.
 
+  // first we prepare an array:
+  std::vector<std::vector<double> > distance(filenames.size());
+  for (size_t i = 0; i != filenames.size(); ++i) {
+    std::vector<double> v(filenames.size(), 0);
+    distance[i] = v;
+  }
 
+  // and now we can compute the distances:
+  for (size_t i = 0; i != vectors.size(); ++i) {
+    for (size_t j = i + 1; j != vectors.size(); ++j) {
+      distance[i][j] = distance[j][i] = vectors[i].distance(vectors[j], p);
+    }
+  }
 
+  // and now output the result to the screen and a file:
+  std::ofstream out;
+  out.open("distance");
+  for (size_t i = 0; i != distance.size(); ++i) {
+    for (size_t j = 0; j != distance.size(); ++j) {
+      std::cout << distance[i][j] << " ";
+      out << distance[i][j] << " ";
+    }
+    std::cout << std::endl;
+    out << std::endl;
+  }
+  out.close();
 
-	
+  return 0;
+}
diff --git a/src/Persistence_representations/utilities/persistence_vectors/compute_scalar_product_of_persistence_vectors.cpp b/src/Persistence_representations/utilities/persistence_vectors/compute_scalar_product_of_persistence_vectors.cpp
index 7a1bbaf0..2a79b1ea 100644
--- a/src/Persistence_representations/utilities/persistence_vectors/compute_scalar_product_of_persistence_vectors.cpp
+++ b/src/Persistence_representations/utilities/persistence_vectors/compute_scalar_product_of_persistence_vectors.cpp
@@ -22,66 +22,56 @@
 
 #include <gudhi/Persistence_vectors.h>
 
-
-
 using namespace Gudhi;
 using namespace Gudhi::Persistence_representations;
 
 #include <iostream>
 #include <sstream>
 
+int main(int argc, char** argv) {
+  std::cout << "This program compute scalar product of persistence vectors stored in a file (the file needs to be "
+               "created beforehand). \n";
+  std::cout << "The parameters of this programs are names of files with persistence vectors.\n";
+
+  std::vector<const char*> filenames;
+  for (int i = 1; i < argc; ++i) {
+    filenames.push_back(argv[i]);
+  }
+  std::vector<Vector_distances_in_diagram<Euclidean_distance> > vectors;
+  vectors.reserve(filenames.size());
+  for (size_t file_no = 0; file_no != filenames.size(); ++file_no) {
+    Vector_distances_in_diagram<Euclidean_distance> l;
+    l.load_from_file(filenames[file_no]);
+    vectors.push_back(l);
+  }
+
+  // and now we will compute the scalar product of landscapes.
+
+  // first we prepare an array:
+  std::vector<std::vector<double> > scalar_product(filenames.size());
+  for (size_t i = 0; i != filenames.size(); ++i) {
+    std::vector<double> v(filenames.size(), 0);
+    scalar_product[i] = v;
+  }
 
-int main( int argc , char** argv )
-{
-	std::cout << "This program compute scalar product of persistence vectors stored in a file (the file needs to be created beforehand). \n";	
-	std::cout << "The parameters of this programs are names of files with persistence vectors.\n";
+  // and now we can compute the scalar product:
+  for (size_t i = 0; i != vectors.size(); ++i) {
+    for (size_t j = i; j != vectors.size(); ++j) {
+      scalar_product[i][j] = scalar_product[j][i] = vectors[i].compute_scalar_product(vectors[j]);
+    }
+  }
 
-	std::vector< const char* > filenames;
-	for ( int i = 1 ; i < argc ; ++i )
-	{
-		filenames.push_back( argv[i] );
-	}
-	std::vector< Vector_distances_in_diagram< Euclidean_distance > > vectors;
-	vectors.reserve( filenames.size() );
-	for ( size_t file_no = 0 ; file_no != filenames.size() ; ++file_no )
-	{
-		Vector_distances_in_diagram< Euclidean_distance > l;
-		l.load_from_file( filenames[file_no] );
-		vectors.push_back( l );
-	}
-		
-	//and now we will compute the scalar product of landscapes.
-	
-	//first we prepare an array:
-	std::vector< std::vector< double > > scalar_product( filenames.size() );
-	for ( size_t i = 0 ; i != filenames.size() ; ++i )
-	{
-		std::vector< double > v( filenames.size() , 0 );
-		scalar_product[i] = v;
-	}
-	
-	//and now we can compute the scalar product:
-	for ( size_t i = 0 ; i != vectors.size() ; ++i )
-	{
-		for ( size_t j = i ; j != vectors.size() ; ++j )
-		{
-			scalar_product[i][j] = scalar_product[j][i] = vectors[i].compute_scalar_product( vectors[j] ) ;
-		}
-	}
-	
-	//and now output the result to the screen and a file:
-	std::ofstream out;
-	out.open( "scalar_product" );
-	for ( size_t i = 0 ; i != scalar_product.size() ; ++i )
-	{
-		for ( size_t j = 0 ; j != scalar_product.size() ; ++j )
-		{
-			std::cout << scalar_product[i][j] << " ";
-			out << scalar_product[i][j] << " ";
-		}
-		std::cout << std::endl;
-		out << std::endl;
-	}
-	out.close();	
-	return 0;
+  // and now output the result to the screen and a file:
+  std::ofstream out;
+  out.open("scalar_product");
+  for (size_t i = 0; i != scalar_product.size(); ++i) {
+    for (size_t j = 0; j != scalar_product.size(); ++j) {
+      std::cout << scalar_product[i][j] << " ";
+      out << scalar_product[i][j] << " ";
+    }
+    std::cout << std::endl;
+    out << std::endl;
+  }
+  out.close();
+  return 0;
 }
diff --git a/src/Persistence_representations/utilities/persistence_vectors/create_persistence_vectors.cpp b/src/Persistence_representations/utilities/persistence_vectors/create_persistence_vectors.cpp
index d7a22e58..3c4c7dad 100644
--- a/src/Persistence_representations/utilities/persistence_vectors/create_persistence_vectors.cpp
+++ b/src/Persistence_representations/utilities/persistence_vectors/create_persistence_vectors.cpp
@@ -22,43 +22,39 @@
 
 #include <gudhi/Persistence_vectors.h>
 
-
-
 using namespace Gudhi;
 using namespace Gudhi::Persistence_representations;
 
 #include <iostream>
 #include <sstream>
 
-
-int main( int argc , char** argv )
-{
-	std::cout << "This program creates persistence vectors of diagrams provided as an input. The first parameter of this program is a dimension of persistence ";
-	std::cout << " that will be used in creation of the persistence vectors. If our input files contain persistence pairs of various dimension, as a second parameter of the ";
-	std::cout << " procedure please provide the dimension of persistence you want to use. If in your file there are only birth-death pairs of the same dimension, set the first parameter to -1." << std::endl;
-	std::cout << "The remaining parameters are the names of files with persistence diagrams. \n";
-	int dim = atoi( argv[1] );
-	unsigned dimension = std::numeric_limits<unsigned>::max();
-	if ( dim >= 0 )
-	{
-		dimension = (unsigned)dim;
-	}
-	
-	std::vector< const char* > filenames;
-	for ( int i = 2 ; i < argc ; ++i )
-	{
-		filenames.push_back( argv[i] );
-	}
-	
-	for ( size_t i = 0 ; i != filenames.size() ; ++i )
-	{
-		std::cerr << "Creating persistence vectors based on a file : " << filenames[i] << std::endl;
-		Vector_distances_in_diagram< Euclidean_distance > l( filenames[i] , dimension );				
-		std::stringstream ss;
-		ss << filenames[i] << ".vect";
-		l.print_to_file( ss.str().c_str() );
-	}
-	std::cout << "Done \n";
-	return 0;
+int main(int argc, char** argv) {
+  std::cout << "This program creates persistence vectors of diagrams provided as an input. The first parameter of this "
+               "program is a dimension of persistence ";
+  std::cout << " that will be used in creation of the persistence vectors. If our input files contain persistence "
+               "pairs of various dimension, as a second parameter of the ";
+  std::cout << " procedure please provide the dimension of persistence you want to use. If in your file there are only "
+               "birth-death pairs of the same dimension, set the first parameter to -1."
+            << std::endl;
+  std::cout << "The remaining parameters are the names of files with persistence diagrams. \n";
+  int dim = atoi(argv[1]);
+  unsigned dimension = std::numeric_limits<unsigned>::max();
+  if (dim >= 0) {
+    dimension = (unsigned)dim;
+  }
+
+  std::vector<const char*> filenames;
+  for (int i = 2; i < argc; ++i) {
+    filenames.push_back(argv[i]);
+  }
+
+  for (size_t i = 0; i != filenames.size(); ++i) {
+    std::cerr << "Creating persistence vectors based on a file : " << filenames[i] << std::endl;
+    Vector_distances_in_diagram<Euclidean_distance> l(filenames[i], dimension);
+    std::stringstream ss;
+    ss << filenames[i] << ".vect";
+    l.print_to_file(ss.str().c_str());
+  }
+  std::cout << "Done \n";
+  return 0;
 }
-
diff --git a/src/Persistence_representations/utilities/persistence_vectors/plot_persistence_vectors.cpp b/src/Persistence_representations/utilities/persistence_vectors/plot_persistence_vectors.cpp
index c72fc1ee..48e0b258 100644
--- a/src/Persistence_representations/utilities/persistence_vectors/plot_persistence_vectors.cpp
+++ b/src/Persistence_representations/utilities/persistence_vectors/plot_persistence_vectors.cpp
@@ -22,27 +22,22 @@
 
 #include <gudhi/Persistence_vectors.h>
 
-
-
 using namespace Gudhi;
 using namespace Gudhi::Persistence_representations;
 
 #include <iostream>
 #include <sstream>
 
-
-int main( int argc , char** argv )
-{
-	std::cout << "This program create a Gnuplot script to plot persistence vector. Please call this program with the name of file with persistence vector. \n";
-	if ( argc != 2 )
-	{
-		std::cout << "Wrong number of parameters, the program will now terminate. \n";
-		return 1;
-	}
-	Vector_distances_in_diagram< Euclidean_distance > l;
-	l.load_from_file( argv[1] );
-	l.plot( argv[1] );
-	
-	return 0;
+int main(int argc, char** argv) {
+  std::cout << "This program create a Gnuplot script to plot persistence vector. Please call this program with the "
+               "name of file with persistence vector. \n";
+  if (argc != 2) {
+    std::cout << "Wrong number of parameters, the program will now terminate. \n";
+    return 1;
+  }
+  Vector_distances_in_diagram<Euclidean_distance> l;
+  l.load_from_file(argv[1]);
+  l.plot(argv[1]);
+
+  return 0;
 }
-
author	vrouvrea <vrouvrea@636b058d-ea47-450e-bf9e-a15bfbe3eedb>	2017-05-30 15:52:00 +0000
committer	vrouvrea <vrouvrea@636b058d-ea47-450e-bf9e-a15bfbe3eedb>	2017-05-30 15:52:00 +0000
commit	9d1a526de85694b5f075bb88dbd7097a40abf10a (patch)
tree	bbcd0cef32610d2f5e9c0209b48c58f73fbf379a
parent	2bcb3d7cb47ce71803f2464cc822346ed2e1b039 (diff)