From cf30dde33d2463172af32de208909f4638343bec Mon Sep 17 00:00:00 2001 From: ROUVREAU Vincent Date: Mon, 5 Oct 2020 22:07:26 +0200 Subject: Remove the Function inheritance and keep concept --- .../example/manifold_tracing_custom_function.cpp | 10 ++--- .../include/gudhi/Functions/Cartesian_product.h | 12 +++--- .../include/gudhi/Functions/Constant_function.h | 12 +++--- .../include/gudhi/Functions/Embed_in_Rd.h | 12 +++--- .../include/gudhi/Functions/Function.h | 50 ---------------------- .../include/gudhi/Functions/Function_Sm_in_Rd.h | 12 +++--- .../gudhi/Functions/Function_affine_plane_in_Rd.h | 12 +++--- .../include/gudhi/Functions/Function_chair_in_R3.h | 12 +++--- .../include/gudhi/Functions/Function_iron_in_R3.h | 12 +++--- .../Function_lemniscate_revolution_in_R3.h | 12 +++--- .../gudhi/Functions/Function_moment_curve_in_Rd.h | 12 +++--- .../include/gudhi/Functions/Function_torus_in_R3.h | 12 +++--- .../Functions/Function_whitney_umbrella_in_R3.h | 12 +++--- .../gudhi/Functions/Linear_transformation.h | 12 +++--- .../include/gudhi/Functions/Negation.h | 12 +++--- .../include/gudhi/Functions/PL_approximation.h | 14 +++--- .../include/gudhi/Functions/Translate.h | 12 +++--- 17 files changed, 81 insertions(+), 161 deletions(-) delete mode 100644 src/Coxeter_triangulation/include/gudhi/Functions/Function.h (limited to 'src') diff --git a/src/Coxeter_triangulation/example/manifold_tracing_custom_function.cpp b/src/Coxeter_triangulation/example/manifold_tracing_custom_function.cpp index 7e3d95a4..a15756c6 100644 --- a/src/Coxeter_triangulation/example/manifold_tracing_custom_function.cpp +++ b/src/Coxeter_triangulation/example/manifold_tracing_custom_function.cpp @@ -19,8 +19,8 @@ using namespace Gudhi::coxeter_triangulation; * the equation of the manifold is x^3*y + y^3*z + z^3*x = 0. * The embedding consists of restricting the manifold to the affine subspace z = 1. */ -struct Function_surface_on_CP2_in_R4 : public Function { - virtual Eigen::VectorXd operator()(const Eigen::VectorXd& p) const override { +struct Function_surface_on_CP2_in_R4 { + Eigen::VectorXd operator()(const Eigen::VectorXd& p) const { // The real and imaginary parts of the variables x and y double xr = p(0), xi = p(1), yr = p(2), yi = p(3); Eigen::VectorXd result(cod_d()); @@ -36,10 +36,10 @@ struct Function_surface_on_CP2_in_R4 : public Function { return result; } - virtual std::size_t amb_d() const override { return 4; }; - virtual std::size_t cod_d() const override { return 2; }; + std::size_t amb_d() const { return 4; }; + std::size_t cod_d() const { return 2; }; - virtual Eigen::VectorXd seed() const override { + Eigen::VectorXd seed() const { Eigen::VectorXd result = Eigen::VectorXd::Zero(4); return result; } diff --git a/src/Coxeter_triangulation/include/gudhi/Functions/Cartesian_product.h b/src/Coxeter_triangulation/include/gudhi/Functions/Cartesian_product.h index d1767eca..0533bb83 100644 --- a/src/Coxeter_triangulation/include/gudhi/Functions/Cartesian_product.h +++ b/src/Coxeter_triangulation/include/gudhi/Functions/Cartesian_product.h @@ -16,8 +16,6 @@ #include // for std::enable_if #include // for std::size_t -#include - #include namespace Gudhi { @@ -96,25 +94,25 @@ inline typename std::enable_if::type get_value(const st * the concept FunctionForImplicitManifold. */ template -struct Cartesian_product : public Function { +struct Cartesian_product { /** * \brief Value of the function at a specified point. * @param[in] p The input point. The dimension needs to coincide with the ambient dimension. */ - virtual Eigen::VectorXd operator()(const Eigen::VectorXd& p) const override { + Eigen::VectorXd operator()(const Eigen::VectorXd& p) const { Eigen::VectorXd result(cod_d_); get_value(function_tuple_, p, result, 0, 0); return result; } /** \brief Returns the domain (ambient) dimension. */ - virtual std::size_t amb_d() const override { return amb_d_; } + std::size_t amb_d() const { return amb_d_; } /** \brief Returns the codomain dimension. */ - virtual std::size_t cod_d() const override { return cod_d_; } + std::size_t cod_d() const { return cod_d_; } /** \brief Returns a point on the zero-set. */ - virtual Eigen::VectorXd seed() const override { + Eigen::VectorXd seed() const { Eigen::VectorXd result(amb_d_); get_seed(function_tuple_, result, 0); return result; diff --git a/src/Coxeter_triangulation/include/gudhi/Functions/Constant_function.h b/src/Coxeter_triangulation/include/gudhi/Functions/Constant_function.h index 86533f81..0603afd8 100644 --- a/src/Coxeter_triangulation/include/gudhi/Functions/Constant_function.h +++ b/src/Coxeter_triangulation/include/gudhi/Functions/Constant_function.h @@ -13,8 +13,6 @@ #include // for std::size_t -#include - #include namespace Gudhi { @@ -26,22 +24,22 @@ namespace coxeter_triangulation { * \brief A class that encodes a constant function from R^d to R^k. * This class does not have any implicit manifold in correspondence. */ -struct Constant_function : public Function { +struct Constant_function { /** \brief Value of the function at a specified point. The value is constant. * @param[in] p The input point. The dimension needs to coincide with the ambient dimension. */ - virtual Eigen::VectorXd operator()(const Eigen::VectorXd& p) const override { + Eigen::VectorXd operator()(const Eigen::VectorXd& p) const { return value_; } /** \brief Returns the domain dimension. Same as the ambient dimension of the sphere. */ - virtual std::size_t amb_d() const override { return d_; }; + std::size_t amb_d() const { return d_; }; /** \brief Returns the codomain dimension. Same as the codimension of the sphere. */ - virtual std::size_t cod_d() const override { return k_; }; + std::size_t cod_d() const { return k_; }; /** \brief No seed point is available. Throws an exception on evocation. */ - virtual Eigen::VectorXd seed() const override { throw "Seed invoked on a constant function.\n"; } + Eigen::VectorXd seed() const { throw "Seed invoked on a constant function.\n"; } Constant_function() {} diff --git a/src/Coxeter_triangulation/include/gudhi/Functions/Embed_in_Rd.h b/src/Coxeter_triangulation/include/gudhi/Functions/Embed_in_Rd.h index bfeda2c3..e1fe868f 100644 --- a/src/Coxeter_triangulation/include/gudhi/Functions/Embed_in_Rd.h +++ b/src/Coxeter_triangulation/include/gudhi/Functions/Embed_in_Rd.h @@ -13,8 +13,6 @@ #include // for std::size_t -#include - #include namespace Gudhi { @@ -29,12 +27,12 @@ namespace coxeter_triangulation { * the concept FunctionForImplicitManifold. */ template -struct Embed_in_Rd : public Function { +struct Embed_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. */ - virtual Eigen::VectorXd operator()(const Eigen::VectorXd& p) const override { + Eigen::VectorXd operator()(const Eigen::VectorXd& p) const { Eigen::VectorXd x = p; Eigen::VectorXd x_k(fun_.amb_d()), x_rest(d_ - fun_.amb_d()); for (std::size_t i = 0; i < fun_.amb_d(); ++i) x_k(i) = x(i); @@ -46,13 +44,13 @@ struct Embed_in_Rd : public Function { } /** \brief Returns the domain (ambient) dimension. */ - virtual std::size_t amb_d() const override { return d_; } + std::size_t amb_d() const { return d_; } /** \brief Returns the codomain dimension. */ - virtual std::size_t cod_d() const override { return d_ - (fun_.amb_d() - fun_.cod_d()); } + std::size_t cod_d() const { return d_ - (fun_.amb_d() - fun_.cod_d()); } /** \brief Returns a point on the zero-set of the embedded function. */ - virtual Eigen::VectorXd seed() const override { + Eigen::VectorXd seed() const { Eigen::VectorXd result = fun_.seed(); result.conservativeResize(d_); for (std::size_t l = fun_.amb_d(); l < d_; ++l) result(l) = 0; diff --git a/src/Coxeter_triangulation/include/gudhi/Functions/Function.h b/src/Coxeter_triangulation/include/gudhi/Functions/Function.h deleted file mode 100644 index eddfedf5..00000000 --- a/src/Coxeter_triangulation/include/gudhi/Functions/Function.h +++ /dev/null @@ -1,50 +0,0 @@ -/* This file is part of the Gudhi Library - https://gudhi.inria.fr/ - which is released under MIT. - * See file LICENSE or go to https://gudhi.inria.fr/licensing/ for full license details. - * Author(s): Siargey Kachanovich - * - * Copyright (C) 2019 Inria - * - * Modification(s): - * - YYYY/MM Author: Description of the modification - */ - -#ifndef FUNCTIONS_FUNCTION_H_ -#define FUNCTIONS_FUNCTION_H_ - -#include - -namespace Gudhi { - -namespace coxeter_triangulation { - -/** - * \class Function - * \brief The parent class for all functions implemented in the module. - * Contains virtual methods needed to be a model of the concept FunctionForImplicitManifold. - * - * \ingroup coxeter_triangulation - */ -struct Function { - /** \brief Virtual method for the value of the function at a specified point. - * @param[in] p The input point. - */ - virtual Eigen::VectorXd operator()(const Eigen::VectorXd& p) const = 0; - - /** \brief Virtual method for the domain dimension. */ - virtual std::size_t amb_d() const = 0; - - /** \brief Virtual method for the codomain dimension. */ - virtual std::size_t cod_d() const = 0; - - /** \brief Virtual method for the seed point. */ - virtual Eigen::VectorXd seed() const = 0; - - /** \brief Virtual destructor. */ - virtual ~Function() {} -}; - -} // namespace coxeter_triangulation - -} // namespace Gudhi - -#endif diff --git a/src/Coxeter_triangulation/include/gudhi/Functions/Function_Sm_in_Rd.h b/src/Coxeter_triangulation/include/gudhi/Functions/Function_Sm_in_Rd.h index d901e832..8911f990 100644 --- a/src/Coxeter_triangulation/include/gudhi/Functions/Function_Sm_in_Rd.h +++ b/src/Coxeter_triangulation/include/gudhi/Functions/Function_Sm_in_Rd.h @@ -13,8 +13,6 @@ #include // for std::size_t -#include - #include namespace Gudhi { @@ -26,11 +24,11 @@ namespace coxeter_triangulation { * \brief A class for the function that defines an m-dimensional implicit sphere embedded * in the d-dimensional Euclidean space. */ -struct Function_Sm_in_Rd : public Function { +struct Function_Sm_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. */ - virtual Eigen::VectorXd operator()(const Eigen::VectorXd& p) const override { + Eigen::VectorXd operator()(const Eigen::VectorXd& p) const { Eigen::VectorXd x = p; for (std::size_t i = 0; i < d_; ++i) x(i) -= center_[i]; Eigen::VectorXd result = Eigen::VectorXd::Zero(k_); @@ -41,13 +39,13 @@ struct Function_Sm_in_Rd : public Function { } /** \brief Returns the domain dimension. Same as the ambient dimension of the sphere. */ - virtual std::size_t amb_d() const override { return d_; }; + std::size_t amb_d() const { return d_; }; /** \brief Returns the codomain dimension. Same as the codimension of the sphere. */ - virtual std::size_t cod_d() const override { return k_; }; + std::size_t cod_d() const { return k_; }; /** \brief Returns a point on the sphere. */ - virtual Eigen::VectorXd seed() const override { + Eigen::VectorXd seed() const { Eigen::VectorXd result = Eigen::VectorXd::Zero(d_); result(0) += r_; for (std::size_t i = 0; i < d_; ++i) result(i) += center_[i]; 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 b7414cda..b29f0906 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 @@ -13,8 +13,6 @@ #include // for std::size_t -#include - #include namespace Gudhi { @@ -26,24 +24,24 @@ namespace coxeter_triangulation { * \brief A class for the function that defines an m-dimensional implicit affine plane * embedded in d-dimensional Euclidean space. */ -struct Function_affine_plane_in_Rd : public Function { +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. */ - virtual Eigen::VectorXd operator()(const Eigen::VectorXd& p) const override { + 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. */ - virtual std::size_t amb_d() const override { return d_; }; + std::size_t amb_d() const { return d_; }; /** \brief Returns the codomain dimension. Same as the codimension of the sphere. */ - virtual std::size_t cod_d() const override { return k_; }; + std::size_t cod_d() const { return k_; }; /** \brief Returns a point on the affine plane. */ - virtual Eigen::VectorXd seed() const override { + Eigen::VectorXd seed() const { Eigen::VectorXd result = off_; return result; } diff --git a/src/Coxeter_triangulation/include/gudhi/Functions/Function_chair_in_R3.h b/src/Coxeter_triangulation/include/gudhi/Functions/Function_chair_in_R3.h index b30f964f..620446da 100644 --- a/src/Coxeter_triangulation/include/gudhi/Functions/Function_chair_in_R3.h +++ b/src/Coxeter_triangulation/include/gudhi/Functions/Function_chair_in_R3.h @@ -14,8 +14,6 @@ #include // for std::size_t #include // for std::pow -#include - #include namespace Gudhi { @@ -27,12 +25,12 @@ namespace coxeter_triangulation { * \brief A class that encodes the function, the zero-set of which is a so-called * "chair" surface embedded in R^3. */ -struct Function_chair_in_R3 : public Function { +struct Function_chair_in_R3 { /** * \brief Value of the function at a specified point. * @param[in] p The input point. The dimension needs to coincide with the ambient dimension. */ - virtual Eigen::VectorXd operator()(const Eigen::VectorXd& p) const override { + Eigen::VectorXd operator()(const Eigen::VectorXd& p) const { double x = p(0) - off_[0], y = p(1) - off_[1], z = p(2) - off_[2]; Eigen::VectorXd result(cod_d()); result(0) = std::pow(x * x + y * y + z * z - a_ * k_ * k_, 2) - @@ -41,13 +39,13 @@ struct Function_chair_in_R3 : public Function { } /** \brief Returns the domain (ambient) dimension. */ - virtual std::size_t amb_d() const override { return 3; } + std::size_t amb_d() const { return 3; } /** \brief Returns the codomain dimension. */ - virtual std::size_t cod_d() const override { return 1; } + std::size_t cod_d() const { return 1; } /** \brief Returns a point on the surface. */ - virtual Eigen::VectorXd seed() const override { + Eigen::VectorXd seed() const { double t1 = a_ - b_; double discr = t1 * t1 - (1.0 - b_) * (a_ * a_ - b_); double z0 = k_ * std::sqrt((t1 + std::sqrt(discr)) / (1 - b_)); diff --git a/src/Coxeter_triangulation/include/gudhi/Functions/Function_iron_in_R3.h b/src/Coxeter_triangulation/include/gudhi/Functions/Function_iron_in_R3.h index def2a99c..f73c4280 100644 --- a/src/Coxeter_triangulation/include/gudhi/Functions/Function_iron_in_R3.h +++ b/src/Coxeter_triangulation/include/gudhi/Functions/Function_iron_in_R3.h @@ -14,8 +14,6 @@ #include // for std::size_t #include // for std::pow -#include - #include namespace Gudhi { @@ -27,12 +25,12 @@ namespace coxeter_triangulation { * \brief A class that encodes the function, the zero-set of which is a surface * embedded in R^3 that ressembles an iron. */ -struct Function_iron_in_R3 : public Function { +struct Function_iron_in_R3 { /** * \brief Value of the function at a specified point. * @param[in] p The input point. The dimension needs to coincide with the ambient dimension. */ - virtual Eigen::VectorXd operator()(const Eigen::VectorXd& p) const override { + Eigen::VectorXd operator()(const Eigen::VectorXd& p) const { double x = p(0), y = p(1), z = p(2); Eigen::VectorXd result(cod_d()); result(0) = -std::pow(x, 6) / 300. - std::pow(y, 6) / 300. - std::pow(z, 6) / 300. + x * y * y * z / 2.1 + y * y + @@ -41,13 +39,13 @@ struct Function_iron_in_R3 : public Function { } /** \brief Returns the domain (ambient) dimension. */ - virtual std::size_t amb_d() const override { return 3; }; + std::size_t amb_d() const { return 3; }; /** \brief Returns the codomain dimension. */ - virtual std::size_t cod_d() const override { return 1; }; + std::size_t cod_d() const { return 1; }; /** \brief Returns a point on the surface. */ - virtual Eigen::VectorXd seed() const override { + Eigen::VectorXd seed() const { Eigen::Vector3d result(std::pow(4500, 1. / 6), 0, 0); return result; } diff --git a/src/Coxeter_triangulation/include/gudhi/Functions/Function_lemniscate_revolution_in_R3.h b/src/Coxeter_triangulation/include/gudhi/Functions/Function_lemniscate_revolution_in_R3.h index f36ccd3c..beb41e00 100644 --- a/src/Coxeter_triangulation/include/gudhi/Functions/Function_lemniscate_revolution_in_R3.h +++ b/src/Coxeter_triangulation/include/gudhi/Functions/Function_lemniscate_revolution_in_R3.h @@ -14,8 +14,6 @@ #include // for std::size_t #include // for std::sqrt -#include - #include namespace Gudhi { @@ -27,12 +25,12 @@ namespace coxeter_triangulation { * \brief A class that encodes the function, the zero-set of which is a surface of revolution * around the x axis based on the lemniscate of Bernoulli embedded in R^3. */ -struct Function_lemniscate_revolution_in_R3 : public Function { +struct Function_lemniscate_revolution_in_R3 { /** * \brief Value of the function at a specified point. * @param[in] p The input point. The dimension needs to coincide with the ambient dimension. */ - virtual Eigen::VectorXd operator()(const Eigen::VectorXd& p) const override { + Eigen::VectorXd operator()(const Eigen::VectorXd& p) const { double x = p(0) - off_[0], y = p(1) - off_[1], z = p(2) - off_[2]; Eigen::VectorXd result(cod_d()); double x2 = x * x, y2 = y * y, z2 = z * z, a2 = a_ * a_; @@ -42,16 +40,16 @@ struct Function_lemniscate_revolution_in_R3 : public Function { } /** \brief Returns the (ambient) domain dimension.*/ - virtual std::size_t amb_d() const override { return 3; }; + std::size_t amb_d() const { return 3; }; /** \brief Returns the codomain dimension. */ - virtual std::size_t cod_d() const override { return 1; }; + std::size_t cod_d() const { return 1; }; /** \brief Returns a point on the surface. This seed point is only one of * two necessary seed points for the manifold tracing algorithm. * See the method seed2() for the other point. */ - virtual Eigen::VectorXd seed() const override { + Eigen::VectorXd seed() const { Eigen::Vector3d result(std::sqrt(2 * a_) + off_[0], off_[1], off_[2]); return result; } 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 0db8289b..11b379f3 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 @@ -13,8 +13,6 @@ #include // for std::size_t -#include - #include namespace Gudhi { @@ -26,24 +24,24 @@ namespace coxeter_triangulation { * \brief A class for the function that defines an implicit moment curve * in the d-dimensional Euclidean space. */ -struct Function_moment_curve_in_Rd : public Function { +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. */ - virtual Eigen::VectorXd operator()(const Eigen::VectorXd& p) const override { + 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.. */ - virtual std::size_t amb_d() const override { return d_; }; + std::size_t amb_d() const { return d_; }; /** \brief Returns the codomain dimension. */ - virtual std::size_t cod_d() const override { return k_; }; + std::size_t cod_d() const { return k_; }; /** \brief Returns a point on the moment curve. */ - virtual Eigen::VectorXd seed() const override { + Eigen::VectorXd seed() const { Eigen::VectorXd result = Eigen::VectorXd::Zero(d_); return result; } diff --git a/src/Coxeter_triangulation/include/gudhi/Functions/Function_torus_in_R3.h b/src/Coxeter_triangulation/include/gudhi/Functions/Function_torus_in_R3.h index 4aa50cfd..b54d3c74 100644 --- a/src/Coxeter_triangulation/include/gudhi/Functions/Function_torus_in_R3.h +++ b/src/Coxeter_triangulation/include/gudhi/Functions/Function_torus_in_R3.h @@ -14,8 +14,6 @@ #include // for std::size_t #include // for std::sqrt -#include - #include namespace Gudhi { @@ -27,12 +25,12 @@ namespace coxeter_triangulation { * \brief A class that encodes the function, the zero-set of which is a torus * surface embedded in R^3. */ -struct Function_torus_in_R3 : public Function { +struct Function_torus_in_R3 { /** * \brief Value of the function at a specified point. * @param[in] p The input point. The dimension needs to coincide with the ambient dimension. */ - virtual Eigen::VectorXd operator()(const Eigen::VectorXd& p) const override { + Eigen::VectorXd operator()(const Eigen::VectorXd& p) const { double x = p(0) - off_[0], y = p(1) - off_[1], z = p(2) - off_[2]; Eigen::VectorXd result(cod_d()); result(0) = (z * z + (std::sqrt(x * x + y * y) - r_) * (std::sqrt(x * x + y * y) - r_) - R_ * R_); @@ -40,13 +38,13 @@ struct Function_torus_in_R3 : public Function { } /** \brief Returns the domain (ambient) dimension. */ - virtual std::size_t amb_d() const override { return 3; }; + std::size_t amb_d() const { return 3; }; /** \brief Returns the codomain dimension. */ - virtual std::size_t cod_d() const override { return 1; }; + std::size_t cod_d() const { return 1; }; /** \brief Returns a point on the surface. */ - virtual Eigen::VectorXd seed() const override { + Eigen::VectorXd seed() const { Eigen::Vector3d result(R_ + r_ + off_[0], off_[1], off_[2]); return result; } diff --git a/src/Coxeter_triangulation/include/gudhi/Functions/Function_whitney_umbrella_in_R3.h b/src/Coxeter_triangulation/include/gudhi/Functions/Function_whitney_umbrella_in_R3.h index a37fec1c..df1f1eec 100644 --- a/src/Coxeter_triangulation/include/gudhi/Functions/Function_whitney_umbrella_in_R3.h +++ b/src/Coxeter_triangulation/include/gudhi/Functions/Function_whitney_umbrella_in_R3.h @@ -13,8 +13,6 @@ #include // for std::size_t -#include - #include namespace Gudhi { @@ -26,12 +24,12 @@ namespace coxeter_triangulation { * \brief A class that encodes the function, the zero-set of which is the Whitney umbrella * surface embedded in R^3. */ -struct Function_whitney_umbrella_in_R3 : public Function { +struct Function_whitney_umbrella_in_R3 { /** * \brief Value of the function at a specified point. * @param[in] p The input point. The dimension needs to coincide with the ambient dimension. */ - virtual Eigen::VectorXd operator()(const Eigen::VectorXd& p) const override { + Eigen::VectorXd operator()(const Eigen::VectorXd& p) const { double x = p(0) - off_[0], y = p(1) - off_[1], z = p(2) - off_[2]; Eigen::VectorXd result(cod_d()); result(0) = x * x - y * y * z; @@ -39,16 +37,16 @@ struct Function_whitney_umbrella_in_R3 : public Function { } /** \brief Returns the (ambient) domain dimension.*/ - virtual std::size_t amb_d() const override { return 3; }; + std::size_t amb_d() const { return 3; }; /** \brief Returns the codomain dimension. */ - virtual std::size_t cod_d() const override { return 1; }; + std::size_t cod_d() const { return 1; }; /** \brief Returns a point on the surface. This seed point is only one of * two necessary seed points for the manifold tracing algorithm. * See the method seed2() for the other point. */ - virtual Eigen::VectorXd seed() const override { + Eigen::VectorXd seed() const { Eigen::Vector3d result(1 + off_[0], 1 + off_[1], 1 + off_[2]); return result; } diff --git a/src/Coxeter_triangulation/include/gudhi/Functions/Linear_transformation.h b/src/Coxeter_triangulation/include/gudhi/Functions/Linear_transformation.h index 9228d487..82e25bb9 100644 --- a/src/Coxeter_triangulation/include/gudhi/Functions/Linear_transformation.h +++ b/src/Coxeter_triangulation/include/gudhi/Functions/Linear_transformation.h @@ -13,8 +13,6 @@ #include // for std::size_t -#include - #include namespace Gudhi { @@ -29,24 +27,24 @@ namespace coxeter_triangulation { * the concept FunctionForImplicitManifold. */ template -struct Linear_transformation : public Function { +struct Linear_transformation { /** * \brief Value of the function at a specified point. * @param[in] p The input point. The dimension needs to coincide with the ambient dimension. */ - virtual Eigen::VectorXd operator()(const Eigen::VectorXd& p) const override { + Eigen::VectorXd operator()(const Eigen::VectorXd& p) const { Eigen::VectorXd result = fun_(matrix_.householderQr().solve(p)); return result; } /** \brief Returns the domain (ambient) dimension. */ - virtual std::size_t amb_d() const override { return fun_.amb_d(); } + std::size_t amb_d() const { return fun_.amb_d(); } /** \brief Returns the codomain dimension. */ - virtual std::size_t cod_d() const override { return fun_.cod_d(); } + std::size_t cod_d() const { return fun_.cod_d(); } /** \brief Returns a point on the zero-set. */ - virtual Eigen::VectorXd seed() const override { + Eigen::VectorXd seed() const { Eigen::VectorXd result = fun_.seed(); result = matrix_ * result; return result; diff --git a/src/Coxeter_triangulation/include/gudhi/Functions/Negation.h b/src/Coxeter_triangulation/include/gudhi/Functions/Negation.h index 1c202cd5..fdf07f27 100644 --- a/src/Coxeter_triangulation/include/gudhi/Functions/Negation.h +++ b/src/Coxeter_triangulation/include/gudhi/Functions/Negation.h @@ -13,8 +13,6 @@ #include // for std::size_t -#include - #include namespace Gudhi { @@ -30,24 +28,24 @@ namespace coxeter_triangulation { * the concept FunctionForImplicitManifold. */ template -struct Negation : public Function { +struct Negation { /** * \brief Value of the function at a specified point. * @param[in] p The input point. The dimension needs to coincide with the ambient dimension. */ - virtual Eigen::VectorXd operator()(const Eigen::VectorXd& p) const override { + Eigen::VectorXd operator()(const Eigen::VectorXd& p) const { Eigen::VectorXd result = -fun_(p); return result; } /** \brief Returns the domain (ambient) dimension. */ - virtual std::size_t amb_d() const override { return fun_.amb_d(); } + std::size_t amb_d() const { return fun_.amb_d(); } /** \brief Returns the codomain dimension. */ - virtual std::size_t cod_d() const override { return fun_.cod_d(); } + std::size_t cod_d() const { return fun_.cod_d(); } /** \brief Returns a point on the zero-set. */ - virtual Eigen::VectorXd seed() const override { + Eigen::VectorXd seed() const { Eigen::VectorXd result = fun_.seed(); return result; } diff --git a/src/Coxeter_triangulation/include/gudhi/Functions/PL_approximation.h b/src/Coxeter_triangulation/include/gudhi/Functions/PL_approximation.h index 20d4e6a8..22071d6d 100644 --- a/src/Coxeter_triangulation/include/gudhi/Functions/PL_approximation.h +++ b/src/Coxeter_triangulation/include/gudhi/Functions/PL_approximation.h @@ -13,8 +13,6 @@ #include // for std::size_t -#include - #include namespace Gudhi { @@ -26,18 +24,18 @@ namespace coxeter_triangulation { * \brief Constructs a piecewise-linear approximation of a function induced by * an ambient triangulation. * - * \tparam Function The function template parameter. Should be a model of + * \tparam Function_ The function template parameter. Should be a model of * the concept FunctionForImplicitManifold. * \tparam Triangulation The triangulation template parameter. Should be a model of * the concept TriangulationForManifoldTracing. */ template -struct PL_approximation : public Function { +struct PL_approximation { /** * \brief Value of the function at a specified point. * @param[in] p The input point. The dimension needs to coincide with the ambient dimension. */ - virtual Eigen::VectorXd operator()(const Eigen::VectorXd& p) const override { + Eigen::VectorXd operator()(const Eigen::VectorXd& p) const { std::size_t cod_d = this->cod_d(); std::size_t amb_d = this->amb_d(); auto s = tr_.locate_point(p); @@ -62,13 +60,13 @@ struct PL_approximation : public Function { } /** \brief Returns the domain (ambient) dimension. */ - virtual std::size_t amb_d() const override { return fun_.amb_d(); } + std::size_t amb_d() const { return fun_.amb_d(); } /** \brief Returns the codomain dimension. */ - virtual std::size_t cod_d() const override { return fun_.cod_d(); } + std::size_t cod_d() const { return fun_.cod_d(); } /** \brief Returns a point on the zero-set. */ - virtual Eigen::VectorXd seed() const override { + Eigen::VectorXd seed() const { // TODO: not finished. Should use an oracle. return Eigen::VectorXd(amb_d()); } diff --git a/src/Coxeter_triangulation/include/gudhi/Functions/Translate.h b/src/Coxeter_triangulation/include/gudhi/Functions/Translate.h index fc91a118..cbe65abe 100644 --- a/src/Coxeter_triangulation/include/gudhi/Functions/Translate.h +++ b/src/Coxeter_triangulation/include/gudhi/Functions/Translate.h @@ -13,8 +13,6 @@ #include // for std::size_t -#include - #include namespace Gudhi { @@ -30,24 +28,24 @@ namespace coxeter_triangulation { * the concept FunctionForImplicitManifold. */ template -struct Translate : public Function { +struct Translate { /** * \brief Value of the function at a specified point. * @param[in] p The input point. The dimension needs to coincide with the ambient dimension. */ - virtual Eigen::VectorXd operator()(const Eigen::VectorXd& p) const override { + Eigen::VectorXd operator()(const Eigen::VectorXd& p) const { Eigen::VectorXd result = fun_(p - off_); return result; } /** \brief Returns the domain (ambient) dimension. */ - virtual std::size_t amb_d() const override { return fun_.amb_d(); } + std::size_t amb_d() const { return fun_.amb_d(); } /** \brief Returns the codomain dimension. */ - virtual std::size_t cod_d() const override { return fun_.cod_d(); } + std::size_t cod_d() const { return fun_.cod_d(); } /** \brief Returns a point on the zero-set. */ - virtual Eigen::VectorXd seed() const override { + Eigen::VectorXd seed() const { Eigen::VectorXd result = fun_.seed(); result += off_; return result; -- cgit v1.2.3