Answer to Marc's comments.

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

Former-commit-id: 564683f4a60572ac78f9c45c4cc589d97e7663ed

13 files changed, 276 insertions, 19 deletions

diff --git a/src/Gudhi_stat/include/gudhi/permutation_test.h b/src/Gudhi_stat/include/gudhi/permutation_test.h
index 1618d7ef..b4c1a8ba 100644
--- a/src/Gudhi_stat/include/gudhi/permutation_test.h
+++ b/src/Gudhi_stat/include/gudhi/permutation_test.h
@@ -29,7 +29,7 @@
 #include <iostream>
 #include <cstdlib>
 #include <algorithm>
-#include <gudhi/read_persitence_from_file.h>
+#include <gudhi/read_persistence_from_file.h>
 
 
 namespace Gudhi 
diff --git a/src/Gudhi_stat/include/gudhi/persistence_representations/Persistence_heat_maps.h b/src/Gudhi_stat/include/gudhi/persistence_representations/Persistence_heat_maps.h
index 219349cb..f82f3100 100644
--- a/src/Gudhi_stat/include/gudhi/persistence_representations/Persistence_heat_maps.h
+++ b/src/Gudhi_stat/include/gudhi/persistence_representations/Persistence_heat_maps.h
@@ -33,7 +33,7 @@
 #include <algorithm>
 
 //gudhi include
-#include <gudhi/read_persitence_from_file.h>
+#include <gudhi/read_persistence_from_file.h>
 #include <gudhi/common_gudhi_stat.h>
 
 
diff --git a/src/Gudhi_stat/include/gudhi/persistence_representations/Persistence_intervals.h b/src/Gudhi_stat/include/gudhi/persistence_representations/Persistence_intervals.h
index 43135b41..2c3e4803 100644
--- a/src/Gudhi_stat/include/gudhi/persistence_representations/Persistence_intervals.h
+++ b/src/Gudhi_stat/include/gudhi/persistence_representations/Persistence_intervals.h
@@ -24,7 +24,7 @@
 #define Persistence_intervals_H_
 
 //gudhi include
-#include <gudhi/read_persitence_from_file.h>
+#include <gudhi/read_persistence_from_file.h>
 //Bottleneck distance:
 //#include <gudhi/Bottleneck.h>
 
@@ -249,13 +249,14 @@ public:
 
     /**
      *Computations of distance from the current persistnce diagram to the persistence diagram given as a parameter of this function.
-     *The last parameter, power, is here in case we would like to compute p=th Wasserstein distance. At the moment, this method only implement Bottleneck distance,
+     *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& second , double power = std::numeric_limits< double >::max() , double tolerance = 0.00000001 ) const
+     double distance( const Persistence_intervals& second , double power = std::numeric_limits< double >::max() , double tolerance = 0) const
     {
-		if ( power == std::numeric_limits< double >::max() )
+		if ( power >= std::numeric_limits< double >::max() )
 		{
 			//return Gudhi::persistence_diagram::bottleneck_distance(this->intervals, second.intervals, tolerance); 		
 			return 1;
diff --git a/src/Gudhi_stat/include/gudhi/persistence_representations/Persistence_landscape.h b/src/Gudhi_stat/include/gudhi/persistence_representations/Persistence_landscape.h
index 9b968b01..0d8fe5fe 100644
--- a/src/Gudhi_stat/include/gudhi/persistence_representations/Persistence_landscape.h
+++ b/src/Gudhi_stat/include/gudhi/persistence_representations/Persistence_landscape.h
@@ -36,7 +36,7 @@
 
 
 //gudhi include
-#include <gudhi/read_persitence_from_file.h>
+#include <gudhi/read_persistence_from_file.h>
 #include <gudhi/common_gudhi_stat.h>
 
 
diff --git a/src/Gudhi_stat/include/gudhi/persistence_representations/Persistence_landscape_on_grid.h b/src/Gudhi_stat/include/gudhi/persistence_representations/Persistence_landscape_on_grid.h
index 51f432c6..a4d8dce6 100644
--- a/src/Gudhi_stat/include/gudhi/persistence_representations/Persistence_landscape_on_grid.h
+++ b/src/Gudhi_stat/include/gudhi/persistence_representations/Persistence_landscape_on_grid.h
@@ -37,7 +37,7 @@
 
 //gudhi include
 
-#include <gudhi/read_persitence_from_file.h>
+#include <gudhi/read_persistence_from_file.h>
 #include <gudhi/common_gudhi_stat.h>
 
 
@@ -47,6 +47,13 @@ namespace Gudhi
 namespace Gudhi_stat
 {
 
+/**
+ * A clas implementing persistence landascpes by approximating them on a collection of grid points.  * Persistence landscapes on grid allow vertorization, computations of distances, computations 
+ * of projections to Real, computations of averages and scalar products. Therefore they implement suitable interfaces.
+ * It implements the following concepts: Vectorized_topological_data, Topological_data_with_distances, Real_valued_topological_data, Topological_data_with_averages, Topological_data_with_scalar_product
+ * Note that at the moment, due to roundoff errors during the construction of persistence landscapes on a grid, elements which are different by 0.000005 are considered the same. If the scale in your persistence diagrams
+ * 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  
@@ -66,16 +73,37 @@ public:
 	**/
     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, resoltion 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 , size_t dimension_ = 0 );
+    
+     /**
 	 * 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, resoltion 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_ , size_t dimension_ = 0 );
+
         
     /**
 	 * 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 resoution of a grid. The remaning parameters are 
+	 * 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 resoution of a grid and the number of landscape
+	 * functions to be created. The remaning parameters are calculated based on data. 
+	**/
+    Persistence_landscape_on_grid(const char* filename , 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 parameter is the resoution of a grid. The remaning paraameters are 
 	 * calculated based on data. 
 	**/
     Persistence_landscape_on_grid(const char* filename , size_t number_of_points );
@@ -856,7 +884,15 @@ public:
 		{
 			throw "Wrong number of function\n";
 		}
-		std::vector<double> v = this->values_of_landscapes[ number_of_function ];
+		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;
 	}
 	
@@ -1027,11 +1063,161 @@ protected:
 		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_ );	
+	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_ );
+	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 );	
 	Persistence_landscape_on_grid multiply_lanscape_by_real_number_not_overwrite( double x )const;
 };
 
 
+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;
+		}
+	}
+	
+	this->values_of_landscapes = std::vector< std::vector< double > >( number_of_points_+1 );//over here we will use those vectors as heaps.
+	
+	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 ( 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 heep. 
+					std::make_heap (this->values_of_landscapes[i].begin(),this->values_of_landscapes[i].end());
+				}
+			}						
+			landscape_value += dx;
+		}
+		for ( size_t i = grid_interval_midpoint ; i <= grid_interval_end ; ++i )
+		{						
+			if ( landscape_value > 0 ) 
+			{ 
+				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 heep. 
+						std::make_heap (this->values_of_landscapes[i].begin(),this->values_of_landscapes[i].end());
+					}
+				}		
+				
+				
+				if ( dbg )
+				{				
+					std::cerr << "AAdding landscape value (going down) for a point : " << i << " equal : " << landscape_value << std::endl;
+				}
+			}
+			landscape_value -= dx;				
+		}  
+	}
+	
+	//first reverse all the values (note that they are negatie, since we were using heap:
+	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
+
+
+
+
 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_ )
 {
 	bool dbg = false;
@@ -1046,9 +1232,25 @@ void Persistence_landscape_on_grid::set_up_values_of_landscapes( const std::vect
 		} 
 	}
 	
-	if ( (grid_min_ == std::numeric_limits<double>::max()) || (grid_min_ == std::numeric_limits<double>::max()) )
+	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 
+		//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;
+		}
 	}
 	
 	this->values_of_landscapes = std::vector< std::vector< double > >( number_of_points_+1 );
@@ -1114,6 +1316,12 @@ Persistence_landscape_on_grid::Persistence_landscape_on_grid( const std::vector<
 }//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 , double grid_min_, double grid_max_ , size_t number_of_points_ , size_t dimension )
 {
 	//standard file with barcode
@@ -1124,6 +1332,16 @@ Persistence_landscape_on_grid::Persistence_landscape_on_grid(const char* filenam
 	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 number_of_levels_of_landscape, size_t dimension )
+{
+	//standard file with barcode
+    std::vector< std::pair< double , double > > p = read_standard_persistence_file( filename );    
+    //gudhi file with barcode
+    //std::vector< std::pair< double , double > > p = read_gudhi_persistence_file_in_one_dimension( 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_ )
 {
 	//standard file with barcode
@@ -1141,6 +1359,23 @@ Persistence_landscape_on_grid::Persistence_landscape_on_grid(const char* filenam
 	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 )
+{
+	//standard file with barcode
+    std::vector< std::pair< double , double > > p = read_standard_persistence_file( filename );    
+    //gudhi file with barcode
+    //std::vector< std::pair< double , double > > p = read_gudhi_persistence_file_in_one_dimension( 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::load_landscape_from_file( const char* filename )
 {
 	//check if the file exist.
diff --git a/src/Gudhi_stat/include/gudhi/persistence_representations/persistence_vectors.h b/src/Gudhi_stat/include/gudhi/persistence_representations/persistence_vectors.h
index 83402d0f..b1a3e4fd 100644
--- a/src/Gudhi_stat/include/gudhi/persistence_representations/persistence_vectors.h
+++ b/src/Gudhi_stat/include/gudhi/persistence_representations/persistence_vectors.h
@@ -31,7 +31,7 @@
 #include <limits>
 
 //gudhi include
-#include <gudhi/read_persitence_from_file.h>
+#include <gudhi/read_persistence_from_file.h>
 #include <gudhi/common_gudhi_stat.h>
 #include <gudhi/distance_functions.h>
 
diff --git a/src/Gudhi_stat/include/gudhi/read_persitence_from_file.h b/src/Gudhi_stat/include/gudhi/read_persistence_from_file.h
index a340b40c..a340b40c 100644
--- a/src/Gudhi_stat/include/gudhi/read_persitence_from_file.h
+++ b/src/Gudhi_stat/include/gudhi/read_persistence_from_file.h
diff --git a/src/Gudhi_stat/test/persistence_lanscapes_on_grid_test.cpp b/src/Gudhi_stat/test/persistence_lanscapes_on_grid_test.cpp
index 2e4ba8d9..b67c061f 100644
--- a/src/Gudhi_stat/test/persistence_lanscapes_on_grid_test.cpp
+++ b/src/Gudhi_stat/test/persistence_lanscapes_on_grid_test.cpp
@@ -53,6 +53,27 @@ BOOST_AUTO_TEST_CASE(check_construction_of_landscape)
 	BOOST_CHECK( l == g );
 }
 
+BOOST_AUTO_TEST_CASE(check_construction_of_landscape_using_only_ten_levels) 
+{	
+	//TODO
+	size_t 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 );
+	//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) 
 {
diff --git a/src/Gudhi_stat/test/read_persistence_from_file_test.cpp b/src/Gudhi_stat/test/read_persistence_from_file_test.cpp
index ed26ba28..c0e988bf 100644
--- a/src/Gudhi_stat/test/read_persistence_from_file_test.cpp
+++ b/src/Gudhi_stat/test/read_persistence_from_file_test.cpp
@@ -26,7 +26,7 @@
 #define BOOST_TEST_MODULE "gudhi_stat"
 #include <boost/test/unit_test.hpp>
 #include <gudhi/reader_utils.h>
-#include <gudhi/read_persitence_from_file.h>
+#include <gudhi/read_persistence_from_file.h>
 
 #include <iostream>
 
diff --git a/src/Gudhi_stat/utilities/Hausdorff_subsampling.cpp b/src/Gudhi_stat/utilities/Hausdorff_subsampling.cpp
index e80caaec..d716b3b8 100644
--- a/src/Gudhi_stat/utilities/Hausdorff_subsampling.cpp
+++ b/src/Gudhi_stat/utilities/Hausdorff_subsampling.cpp
@@ -23,7 +23,7 @@
 
 #include <gudhi/Hausdorff_distances.h>
 #include <gudhi/bootstrap.h>
-#include <gudhi/read_persitence_from_file.h>
+#include <gudhi/read_persistence_from_file.h>
 #include <gudhi/persistence_representations/persistence_vectors.h>
 
 
diff --git a/src/Gudhi_stat/utilities/Landscape_bootstrap.cpp b/src/Gudhi_stat/utilities/Landscape_bootstrap.cpp
index 53552184..d67bb820 100644
--- a/src/Gudhi_stat/utilities/Landscape_bootstrap.cpp
+++ b/src/Gudhi_stat/utilities/Landscape_bootstrap.cpp
@@ -24,7 +24,7 @@
 #include <gudhi/Hausdorff_distances.h>
 #include <gudhi/bootstrap.h>
 #include <gudhi/persistence_representations/Persistence_landscape.h>
-#include <gudhi/read_persitence_from_file.h>
+#include <gudhi/read_persistence_from_file.h>
 #include <gudhi/persistence_representations/persistence_vectors.h>
 //persistence part:
 #include <gudhi/reader_utils.h>
diff --git a/src/Gudhi_stat/utilities/Multiplicative_bootstrap.cpp b/src/Gudhi_stat/utilities/Multiplicative_bootstrap.cpp
index 5a0a7b23..42534752 100644
--- a/src/Gudhi_stat/utilities/Multiplicative_bootstrap.cpp
+++ b/src/Gudhi_stat/utilities/Multiplicative_bootstrap.cpp
@@ -23,7 +23,7 @@
 
 #include <gudhi/Hausdorff_distances.h>
 #include <gudhi/multiplicative_bootstrap.h>
-#include <gudhi/read_persitence_from_file.h>
+#include <gudhi/read_persistence_from_file.h>
 #include <gudhi/persistence_representations/persistence_vectors.h>
 
 using namespace Gudhi;
diff --git a/src/Gudhi_stat/utilities/persistence_intervals/plot_persistence_intervals.cpp b/src/Gudhi_stat/utilities/persistence_intervals/plot_persistence_intervals.cpp
index 6df31a6f..bc466bd3 100644
--- a/src/Gudhi_stat/utilities/persistence_intervals/plot_persistence_intervals.cpp
+++ b/src/Gudhi_stat/utilities/persistence_intervals/plot_persistence_intervals.cpp
@@ -24,7 +24,7 @@
 
 #include <gudhi/reader_utils.h>
 #include <gudhi/persistence_representations/Persistence_intervals.h>
-#include <gudhi/read_persitence_from_file.h>
+#include <gudhi/read_persistence_from_file.h>
 
 #include <iostream>