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

30 files changed, 1156 insertions, 1420 deletions

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;
 }
-