Replace 'uniform' flag of torus generation with 'sample' taking two possible values: 'grid'(i.e uniform==True) or 'random' (i.e uniform==False)

5 files changed, 16 insertions, 16 deletions

diff --git a/src/Tangential_complex/benchmark/benchmark_tc.cpp b/src/Tangential_complex/benchmark/benchmark_tc.cpp
index e3b2a04f..6da1425f 100644
--- a/src/Tangential_complex/benchmark/benchmark_tc.cpp
+++ b/src/Tangential_complex/benchmark/benchmark_tc.cpp
@@ -704,7 +704,7 @@ int main() {
               points = Gudhi::generate_points_on_torus_d<Kernel>(
                                                                  num_points,
                                                                  intrinsic_dim,
-                                                                 param1 == "Y",  // uniform
+                                                                 (param1 == "Y") ? "grid" : "random",  // grid or random sample type
                                                                  std::atof(param2.c_str()));  // radius_noise_percentage
             } else if (input == "generate_klein_bottle_3D") {
               points = Gudhi::generate_points_on_klein_bottle_3D<Kernel>(
diff --git a/src/common/include/gudhi/random_point_generators.h b/src/common/include/gudhi/random_point_generators.h
index 33fb182d..07e4f3da 100644
--- a/src/common/include/gudhi/random_point_generators.h
+++ b/src/common/include/gudhi/random_point_generators.h
@@ -185,7 +185,7 @@ std::vector<typename Kernel::Point_d> generate_points_on_torus_3D(std::size_t nu
 
 // "Private" function used by generate_points_on_torus_d
 template <typename Kernel, typename OutputIterator>
-static void generate_uniform_points_on_torus_d(const Kernel &k, int dim, std::size_t num_slices,
+static void generate_grid_points_on_torus_d(const Kernel &k, int dim, std::size_t num_slices,
                                                OutputIterator out,
                                                double radius_noise_percentage = 0.,
                                                std::vector<typename Kernel::FT> current_point =
@@ -208,14 +208,14 @@ static void generate_uniform_points_on_torus_d(const Kernel &k, int dim, std::si
       double alpha = two_pi * slice_idx / num_slices;
       cp2.push_back(radius_noise_ratio * std::cos(alpha));
       cp2.push_back(radius_noise_ratio * std::sin(alpha));
-      generate_uniform_points_on_torus_d(
+      generate_grid_points_on_torus_d(
                                          k, dim, num_slices, out, radius_noise_percentage, cp2);
     }
   }
 }
 
 template <typename Kernel>
-std::vector<typename Kernel::Point_d> generate_points_on_torus_d(std::size_t num_points, int dim, bool uniform = false,
+std::vector<typename Kernel::Point_d> generate_points_on_torus_d(std::size_t num_points, int dim, std::string sample = "random",
                                                                  double radius_noise_percentage = 0.) {
   using namespace boost::math::double_constants;
 
@@ -226,9 +226,9 @@ std::vector<typename Kernel::Point_d> generate_points_on_torus_d(std::size_t num
 
   std::vector<Point> points;
   points.reserve(num_points);
-  if (uniform) {
+  if (sample == "grid") {
     std::size_t num_slices = (std::size_t)std::pow(num_points, 1. / dim);
-    generate_uniform_points_on_torus_d(
+    generate_grid_points_on_torus_d(
                                        k, dim, num_slices, std::back_inserter(points), radius_noise_percentage);
   } else {
     for (std::size_t i = 0; i < num_points;) {
diff --git a/src/common/utilities/off_file_from_shape_generator.cpp b/src/common/utilities/off_file_from_shape_generator.cpp
index 6efef4fc..71ede434 100644
--- a/src/common/utilities/off_file_from_shape_generator.cpp
+++ b/src/common/utilities/off_file_from_shape_generator.cpp
@@ -135,7 +135,7 @@ int main(int argc, char **argv) {
           if (dimension == 3)
             points = Gudhi::generate_points_on_torus_3D<K>(points_number, dimension, radius, radius/2.);
           else
-            points = Gudhi::generate_points_on_torus_d<K>(points_number, dimension, true);
+            points = Gudhi::generate_points_on_torus_d<K>(points_number, dimension, "grid");
         break;
         case Data_shape::klein:
           switch (dimension) {
diff --git a/src/python/doc/datasets_generators.rst b/src/python/doc/datasets_generators.rst
index ef21c9d2..2802eccd 100644
--- a/src/python/doc/datasets_generators.rst
+++ b/src/python/doc/datasets_generators.rst
@@ -52,9 +52,9 @@ First module : **_points**
 """"""""""""""""""""""""""
 
 The user should provide the number of points to be generated on the torus :code:`n_samples`, and the dimension :code:`dim` of the torus on which points would be generated in :math:`R^{2dim}`.
-The flag :code:`uniform` is optional and is set to **False** by default, meaning that the points will be generated randomly.
+The :code:`sample` argument is optional and is set to **'random'** by default.
 In this case, the returned generated points would be an array of shape :math:`(n\_samples, 2*dim)`.
-Otherwise, if set to **True**, the points are generated as a grid and would be given as an array of shape :
+Otherwise, if set to **'grid'**, the points are generated on a grid and would be given as an array of shape :
 
 .. math::
 
@@ -70,7 +70,7 @@ Example
    gen_points = _points.torus(n_samples = 50, dim = 3)
    
    # Generate 27 points on a torus as a grid in R^6
-   gen_points = _points.torus(n_samples = 50, dim = 3, uniform = True)
+   gen_points = _points.torus(n_samples = 50, dim = 3, sample = 'grid')
 
 .. autofunction:: gudhi.datasets.generators._points.torus
 
@@ -79,7 +79,7 @@ Second module : **points**
 
 The user should provide the number of points to be generated on the torus :code:`n_samples` and the dimension :code:`dim` of the torus on which points would be generated in :math:`R^{2dim}`.
 The :code:`sample` argument is optional and is set to **'random'** by default.
-The other allowed value of sample type is **'grid'** and is equivalent to :code:`uniform = True` in the first module.
+The other allowed value of sample type is **'grid'**.
 
 Example
 """""""
diff --git a/src/python/gudhi/datasets/generators/_points.cc b/src/python/gudhi/datasets/generators/_points.cc
index 55b21b2b..6bbdf284 100644
--- a/src/python/gudhi/datasets/generators/_points.cc
+++ b/src/python/gudhi/datasets/generators/_points.cc
@@ -46,13 +46,13 @@ py::array_t<double> generate_points_on_sphere(size_t n_samples, int ambient_dim,
     return points;
 }
 
-py::array_t<double> generate_points_on_torus(size_t n_samples, int dim, bool uniform) {
+py::array_t<double> generate_points_on_torus(size_t n_samples, int dim, std::string sample) {
 
     std::vector<typename Kern::Point_d> points_generated;
 
     {
         py::gil_scoped_release release;
-        points_generated = Gudhi::generate_points_on_torus_d<Kern>(n_samples, dim, uniform);
+        points_generated = Gudhi::generate_points_on_torus_d<Kern>(n_samples, dim, sample);
     }
 
     size_t npoints = points_generated.size();
@@ -93,7 +93,7 @@ PYBIND11_MODULE(_points, m) {
           )pbdoc");
 
     m.def("torus", &generate_points_on_torus,
-          py::arg("n_samples"), py::arg("dim"), py::arg("uniform") = false,
+          py::arg("n_samples"), py::arg("dim"), py::arg("sample") = "random",
           R"pbdoc(
           Generate random i.i.d. points on a d-torus in R^2d
 
@@ -101,8 +101,8 @@ PYBIND11_MODULE(_points, m) {
           :type n_samples: integer
           :param dim: The dimension of the torus on which points would be generated in R^2*dim.
           :type dim: integer
-          :param uniform: A flag to define if the points generation is uniform (i.e generated as a grid).
-          :type uniform: bool
+          :param sample: The sample type. Available values are: `"random"` and `"grid"`. Default value is `"random"`.
+          :type sample: string
           :rtype: numpy array of float
           :returns: the generated points on a torus.
           )pbdoc");