Replace num_points with n_samples to be consistent with sphere

2 files changed, 17 insertions, 21 deletions

diff --git a/src/python/gudhi/datasets/generators/points/_torus.cc b/src/python/gudhi/datasets/generators/points/_torus.cc
index 21638bb8..f4b4f14e 100644
--- a/src/python/gudhi/datasets/generators/points/_torus.cc
+++ b/src/python/gudhi/datasets/generators/points/_torus.cc
@@ -22,22 +22,18 @@ namespace py = pybind11;
 typedef CGAL::Epick_d< CGAL::Dynamic_dimension_tag > Kern;
 
 
-py::array_t<double> generate_points_on_torus(size_t num_points, int dim, bool uniform) {
+py::array_t<double> generate_points_on_torus(size_t n_samples, int dim, bool uniform) {
 
     std::vector<typename Kern::Point_d> points_generated;
 
     {
         py::gil_scoped_release release;
-        points_generated = Gudhi::generate_points_on_torus_d<Kern>(num_points, dim, uniform);
+        points_generated = Gudhi::generate_points_on_torus_d<Kern>(n_samples, dim, uniform);
     }
 
     size_t npoints = points_generated.size();
 
-    py::print("points generated size: ");
-    py::print(points_generated.size());
-    py::print(points_generated[0].size());
-
-    GUDHI_CHECK(2*dim == points_generated[0].size(), "Py array second dimension not matching the double ambient space dimension");
+    GUDHI_CHECK(2*dim == points_generated[0].size(), "Py array second dimension not matching the double torus dimension");
 
     py::array_t<double> points({npoints, (size_t)2*dim});
 
@@ -54,15 +50,15 @@ py::array_t<double> generate_points_on_torus(size_t num_points, int dim, bool un
 PYBIND11_MODULE(_torus, m) {
       m.attr("__license__") = "LGPL v3";
       m.def("generate_random_points", &generate_points_on_torus,
-          py::arg("num_points"), py::arg("dim"), py::arg("uniform") = false,
+          py::arg("n_samples"), py::arg("dim"), py::arg("uniform") = false,
           R"pbdoc(
     Generate random i.i.d. points on a d-torus in R^2d
 
-    :param num_points: The number of points to be generated.
-    :type num_points: unsigned integer
+    :param n_samples: The number of points to be generated.
+    :type n_samples: integer
     :param dim: The dimension.
     :type dim: integer
-    :param uniform: A flag to define if the points generation is uniform (generated as a grid).
+    :param uniform: A flag to define if the points generation is uniform (i.e generated as a grid).
     :type uniform: bool
     :rtype: numpy array of float
     :returns: the generated points on a torus.
diff --git a/src/python/gudhi/datasets/generators/points/torus.py b/src/python/gudhi/datasets/generators/points/torus.py
index 5a2b9016..1df0a930 100644
--- a/src/python/gudhi/datasets/generators/points/torus.py
+++ b/src/python/gudhi/datasets/generators/points/torus.py
@@ -10,33 +10,33 @@
 import numpy as np
 import itertools
 
-def generate_random_points(num_points, dim):
+def generate_random_points(n_samples, dim):
 
-    # Generate random angles of size num_points*dim
-    alpha = 2*np.pi*np.random.rand(num_points*dim)
+    # Generate random angles of size n_samples*dim
+    alpha = 2*np.pi*np.random.rand(n_samples*dim)
 
-    # Based on angles, construct points of size num_points*dim on a circle and reshape the result in a num_points*2*dim array    
+    # Based on angles, construct points of size n_samples*dim on a circle and reshape the result in a n_samples*2*dim array
     array_points = np.column_stack([np.cos(alpha), np.sin(alpha)]).reshape(-1, 2*dim)
     
     return array_points
 
-def generate_grid_points(num_points, dim):
+def generate_grid_points(n_samples, dim):
     
-    num_points_grid = int(num_points**(1./dim))
-    alpha = np.linspace(0, 2*np.pi, num_points_grid, endpoint=False)
+    n_samples_grid = int(n_samples**(1./dim))
+    alpha = np.linspace(0, 2*np.pi, n_samples_grid, endpoint=False)
     
     array_points_inter = np.column_stack([np.cos(alpha), np.sin(alpha)])
     array_points = np.array(list(itertools.product(array_points_inter, repeat=dim))).reshape(-1, 2*dim)
     
     return array_points
 
-def generate_points(num_points, dim, sample='random'):
+def generate_points(n_samples, dim, sample='random'):
     if sample == 'random':
         print("Sample is random")
-        generate_random_points(num_points, dim)
+        generate_random_points(n_samples, dim)
     elif sample == 'grid':
         print("Sample is grid")
-        generate_grid_points(num_points, dim)
+        generate_grid_points(n_samples, dim)
     else:
         print("Sample type '{}' is not supported".format(sample))
         return