removal of unused private members

3 files changed, 180 insertions, 176 deletions

diff --git a/src/Coxeter_triangulation/include/gudhi/Functions/Function_affine_plane_in_Rd.h b/src/Coxeter_triangulation/include/gudhi/Functions/Function_affine_plane_in_Rd.h
index dc6f5f90..58a9fc41 100644
--- a/src/Coxeter_triangulation/include/gudhi/Functions/Function_affine_plane_in_Rd.h
+++ b/src/Coxeter_triangulation/include/gudhi/Functions/Function_affine_plane_in_Rd.h
@@ -25,63 +25,62 @@ namespace coxeter_triangulation {
  * embedded in d-dimensional Euclidean space.
  */
 struct Function_affine_plane_in_Rd {
-  /**
-   * \brief Value of the function at a specified point.
-   * @param[in] p The input point. The dimension needs to coincide with the ambient dimension.
-   */
-  Eigen::VectorXd operator()(const Eigen::VectorXd& p) const {
-    Eigen::VectorXd result = normal_matrix_.transpose() * (p - off_);
-    return result;
-  }
+	/**
+	 * \brief Value of the function at a specified point.
+	 * @param[in] p The input point. The dimension needs to coincide with the ambient dimension.
+	 */
+	Eigen::VectorXd operator()(const Eigen::VectorXd& p) const {
+		Eigen::VectorXd result = normal_matrix_.transpose() * (p - off_);
+		return result;
+	}
 
-  /** \brief Returns the domain dimension. Same as the ambient dimension of the sphere. */
-  std::size_t amb_d() const { return d_; };
+	/** \brief Returns the domain dimension. Same as the ambient dimension of the sphere. */
+	std::size_t amb_d() const { return d_; };
 
-  /** \brief Returns the codomain dimension. Same as the codimension of the sphere. */
-  std::size_t cod_d() const { return k_; };
+	/** \brief Returns the codomain dimension. Same as the codimension of the sphere. */
+	std::size_t cod_d() const { return k_; };
 
-  /** \brief Returns a point on the affine plane. */
-  Eigen::VectorXd seed() const {
-    Eigen::VectorXd result = off_;
-    return result;
-  }
+	/** \brief Returns a point on the affine plane. */
+	Eigen::VectorXd seed() const {
+		Eigen::VectorXd result = off_;
+		return result;
+	}
 
-  /**
-   * \brief Constructor of the function that defines an m-dimensional implicit affine
-   * plane in the d-dimensional Euclidean space.
-   *
-   * @param[in] normal_matrix A normal matrix of the affine plane. The number of rows should
-   * correspond to the ambient dimension, the number of columns should correspond to
-   * the size of the normal basis (codimension).
-   * @param[in] offset The offset vector of the affine plane.
-   * The dimension of the vector should be the ambient dimension of the manifold.
-   */
-  Function_affine_plane_in_Rd(const Eigen::MatrixXd& normal_matrix, const Eigen::VectorXd& offset)
-      : normal_matrix_(normal_matrix), d_(normal_matrix.rows()), k_(normal_matrix.cols()), m_(d_ - k_), off_(offset) {
-    normal_matrix_.colwise().normalize();
-  }
+	/**
+	 * \brief Constructor of the function that defines an m-dimensional implicit affine
+	 * plane in the d-dimensional Euclidean space.
+	 *
+	 * @param[in] normal_matrix A normal matrix of the affine plane. The number of rows should
+	 * correspond to the ambient dimension, the number of columns should correspond to
+	 * the size of the normal basis (codimension).
+	 * @param[in] offset The offset vector of the affine plane.
+	 * The dimension of the vector should be the ambient dimension of the manifold.
+	 */
+	Function_affine_plane_in_Rd(const Eigen::MatrixXd& normal_matrix, const Eigen::VectorXd& offset)
+		: normal_matrix_(normal_matrix), d_(normal_matrix.rows()), k_(normal_matrix.cols()), off_(offset) {
+		normal_matrix_.colwise().normalize();
+	}
 
-  /**
-   * \brief Constructor of the function that defines an m-dimensional implicit affine
-   * plane in the d-dimensional Euclidean space that passes through origin.
-   *
-   * @param[in] normal_matrix A normal matrix of the affine plane. The number of rows should
-   * correspond to the ambient dimension, the number of columns should correspond to
-   * the size of the normal basis (codimension).
-   */
-  Function_affine_plane_in_Rd(const Eigen::MatrixXd& normal_matrix)
-      : normal_matrix_(normal_matrix),
-        d_(normal_matrix.rows()),
-        k_(normal_matrix.cols()),
-        m_(d_ - k_),
-        off_(Eigen::VectorXd::Zero(d_)) {
-    normal_matrix_.colwise().normalize();
-  }
+	/**
+	 * \brief Constructor of the function that defines an m-dimensional implicit affine
+	 * plane in the d-dimensional Euclidean space that passes through origin.
+	 *
+	 * @param[in] normal_matrix A normal matrix of the affine plane. The number of rows should
+	 * correspond to the ambient dimension, the number of columns should correspond to
+	 * the size of the normal basis (codimension).
+	 */
+	Function_affine_plane_in_Rd(const Eigen::MatrixXd& normal_matrix)
+		: normal_matrix_(normal_matrix),
+		  d_(normal_matrix.rows()),
+		  k_(normal_matrix.cols()),
+		  off_(Eigen::VectorXd::Zero(d_)) {
+		normal_matrix_.colwise().normalize();
+	}
 
- private:
-  Eigen::MatrixXd normal_matrix_;
-  std::size_t d_, k_, m_;
-  Eigen::VectorXd off_;
+private:
+	Eigen::MatrixXd normal_matrix_;
+	std::size_t d_, k_;
+	Eigen::VectorXd off_;
 };
 
 }  // namespace coxeter_triangulation
diff --git a/src/Coxeter_triangulation/include/gudhi/Functions/Function_moment_curve_in_Rd.h b/src/Coxeter_triangulation/include/gudhi/Functions/Function_moment_curve_in_Rd.h
index 11b379f3..d44cdf70 100644
--- a/src/Coxeter_triangulation/include/gudhi/Functions/Function_moment_curve_in_Rd.h
+++ b/src/Coxeter_triangulation/include/gudhi/Functions/Function_moment_curve_in_Rd.h
@@ -25,51 +25,57 @@ namespace coxeter_triangulation {
  * in the d-dimensional Euclidean space.
  */
 struct Function_moment_curve_in_Rd {
-  /** \brief Value of the function at a specified point.
-   * @param[in] p The input point. The dimension needs to coincide with the ambient dimension.
-   */
-  Eigen::VectorXd operator()(const Eigen::VectorXd& p) const {
-    Eigen::VectorXd result(k_);
-    for (std::size_t i = 1; i < d_; ++i) result(i - 1) = p(i) - p(0) * p(i - 1);
-    return result;
-  }
-
-  /** \brief Returns the domain (ambient) dimension.. */
-  std::size_t amb_d() const { return d_; };
-
-  /** \brief Returns the codomain dimension. */
-  std::size_t cod_d() const { return k_; };
-
-  /** \brief Returns a point on the moment curve. */
-  Eigen::VectorXd seed() const {
-    Eigen::VectorXd result = Eigen::VectorXd::Zero(d_);
-    return result;
-  }
-
-  /**
-   * \brief Constructor of the function that defines an implicit moment curve
-   * in the d-dimensional Euclidean space.
-   *
-   * @param[in] r Numerical parameter.
-   * @param[in] d The ambient dimension.
-   */
-  Function_moment_curve_in_Rd(double r, std::size_t d) : m_(1), k_(d - 1), d_(d), r_(r) {}
-
-  /**
-   * \brief Constructor of the function that defines an implicit moment curve
-   * in the d-dimensional Euclidean space.
-   *
-   * @param[in] r Numerical parameter.
-   * @param[in] d The ambient dimension.
-   * @param[in] offset The offset of the moment curve.
-   */
-  Function_moment_curve_in_Rd(double r, std::size_t d, Eigen::VectorXd& offset)
-      : m_(1), k_(d - 1), d_(d), r_(r), off_(offset) {}
-
- private:
-  std::size_t m_, k_, d_;
-  double r_;
-  Eigen::VectorXd off_;
+public:
+	/** \brief Value of the function at a specified point.
+	 * @param[in] p The input point. The dimension needs to coincide with the ambient dimension.
+	 */
+	Eigen::VectorXd operator()(const Eigen::VectorXd& p) const {
+		Eigen::VectorXd result(k_);
+		for (std::size_t i = 1; i < d_; ++i) result(i - 1) = p(i) - p(0) * p(i - 1);
+		return result;
+	}
+
+	/** \brief Returns the domain (ambient) dimension.. */
+	std::size_t amb_d() const { return d_; };
+
+	/** \brief Returns the codomain dimension. */
+	std::size_t cod_d() const { return k_; };
+
+	/** \brief Returns a point on the moment curve. */
+	Eigen::VectorXd seed() const {
+		Eigen::VectorXd result = Eigen::VectorXd::Zero(d_);
+		return result;
+	}
+
+	/** @brief Returns the radius of the moment curve. */
+	double get_radius() const{
+		return r_;
+	}
+
+	/**
+	 * \brief Constructor of the function that defines an implicit moment curve
+	 * in the d-dimensional Euclidean space.
+	 *
+	 * @param[in] r Numerical parameter.
+	 * @param[in] d The ambient dimension.
+	 */
+	Function_moment_curve_in_Rd(double r, std::size_t d) : k_(d - 1), d_(d), r_(r) {}
+
+	/**
+	 * \brief Constructor of the function that defines an implicit moment curve
+	 * in the d-dimensional Euclidean space.
+	 *
+	 * @param[in] r Numerical parameter.
+	 * @param[in] d The ambient dimension.
+	 * @param[in] offset The offset of the moment curve.
+	 */
+	Function_moment_curve_in_Rd(double r, std::size_t d, Eigen::VectorXd& offset)
+		: k_(d - 1), d_(d), r_(r), off_(offset) {}
+
+private:
+	std::size_t k_, d_;
+	double r_;
+	Eigen::VectorXd off_;
 };
 
 }  // namespace coxeter_triangulation
diff --git a/src/Coxeter_triangulation/include/gudhi/Permutahedral_representation/Integer_combination_iterator.h b/src/Coxeter_triangulation/include/gudhi/Permutahedral_representation/Integer_combination_iterator.h
index 3ee73754..155995f5 100644
--- a/src/Coxeter_triangulation/include/gudhi/Permutahedral_representation/Integer_combination_iterator.h
+++ b/src/Coxeter_triangulation/include/gudhi/Permutahedral_representation/Integer_combination_iterator.h
@@ -25,86 +25,85 @@ typedef unsigned uint;
  *  Based on the algorithm by Mifsud.
  */
 class Integer_combination_iterator
-    : public boost::iterator_facade<Integer_combination_iterator, std::vector<uint> const,
-                                    boost::forward_traversal_tag> {
-  using value_t = std::vector<uint>;
-
- private:
-  friend class boost::iterator_core_access;
-
-  bool equal(Integer_combination_iterator const& other) const { return (is_end_ && other.is_end_); }
-
-  value_t const& dereference() const { return value_; }
-
-  void increment() {
-    uint j1 = 0;
-    uint s = 0;
-    while (value_[j1] == 0 && j1 < k_) j1++;
-    uint j2 = j1 + 1;
-    while (value_[j2] == bounds_[j2]) {
-      if (bounds_[j2] != 0) {
-        s += value_[j1];
-        value_[j1] = 0;
-        j1 = j2;
-      }
-      j2++;
-    }
-    if (j2 >= k_) {
-      is_end_ = true;
-      return;
-    }
-    s += value_[j1] - 1;
-    value_[j1] = 0;
-    value_[j2]++;
-    uint i = 0;
-    while (s >= bounds_[i]) {
-      value_[i] = bounds_[i];
-      s -= bounds_[i];
-      i++;
-    }
-    value_[i++] = s;
-  }
-
- public:
-  template <class Bound_range>
-  Integer_combination_iterator(const uint& n, const uint& k, const Bound_range& bounds)
-      : value_(k + 2), is_end_(n == 0 || k == 0), n_(n), k_(k) {
-    bounds_.reserve(k + 2);
-    uint sum_radices = 0;
-    for (auto b : bounds) {
-      bounds_.push_back(b);
-      sum_radices += b;
-    }
-    bounds_.push_back(2);
-    bounds_.push_back(1);
-    if (n > sum_radices) {
-      is_end_ = true;
-      return;
-    }
-    uint i = 0;
-    uint s = n;
-    while (s >= bounds_[i]) {
-      value_[i] = bounds_[i];
-      s -= bounds_[i];
-      i++;
-    }
-    value_[i++] = s;
-
-    while (i < k_) value_[i++] = 0;
-    value_[k] = 1;
-    value_[k + 1] = 0;
-  }
-
-  // Used for the creating an end iterator
-  Integer_combination_iterator() : is_end_(true), n_(0), k_(0) {}
-
- private:
-  value_t value_;  // the dereference value
-  bool is_end_;    // is true when the current integer combination is the final one
-
-  uint n_;
-  uint k_;
-  std::vector<uint> bounds_;
+		: public boost::iterator_facade<Integer_combination_iterator, std::vector<uint> const,
+		boost::forward_traversal_tag> {
+	using value_t = std::vector<uint>;
+
+private:
+	friend class boost::iterator_core_access;
+
+	bool equal(Integer_combination_iterator const& other) const { return (is_end_ && other.is_end_); }
+
+	value_t const& dereference() const { return value_; }
+
+	void increment() {
+		uint j1 = 0;
+		uint s = 0;
+		while (value_[j1] == 0 && j1 < k_) j1++;
+		uint j2 = j1 + 1;
+		while (value_[j2] == bounds_[j2]) {
+			if (bounds_[j2] != 0) {
+				s += value_[j1];
+				value_[j1] = 0;
+				j1 = j2;
+			}
+			j2++;
+		}
+		if (j2 >= k_) {
+			is_end_ = true;
+			return;
+		}
+		s += value_[j1] - 1;
+		value_[j1] = 0;
+		value_[j2]++;
+		uint i = 0;
+		while (s >= bounds_[i]) {
+			value_[i] = bounds_[i];
+			s -= bounds_[i];
+			i++;
+		}
+		value_[i++] = s;
+	}
+
+public:
+	template <class Bound_range>
+	Integer_combination_iterator(const uint& n, const uint& k, const Bound_range& bounds)
+		: value_(k + 2), is_end_(n == 0 || k == 0), k_(k) {
+		bounds_.reserve(k + 2);
+		uint sum_radices = 0;
+		for (auto b : bounds) {
+			bounds_.push_back(b);
+			sum_radices += b;
+		}
+		bounds_.push_back(2);
+		bounds_.push_back(1);
+		if (n > sum_radices) {
+			is_end_ = true;
+			return;
+		}
+		uint i = 0;
+		uint s = n;
+		while (s >= bounds_[i]) {
+			value_[i] = bounds_[i];
+			s -= bounds_[i];
+			i++;
+		}
+		value_[i++] = s;
+
+		while (i < k_) value_[i++] = 0;
+		value_[k] = 1;
+		value_[k + 1] = 0;
+	}
+
+	// Used for the creating an end iterator
+	Integer_combination_iterator() : is_end_(true), k_(0) {}
+
+private:
+	value_t value_;  // the dereference value
+	bool is_end_;    // is true when the current integer combination is the final one
+
+	uint k_;
+	std::vector<uint> bounds_;
 };
 
 }  // namespace coxeter_triangulation