refactor(python/random): refactor random (wip)

Author: hakula139

binding/random_binding.cpp

@@ -33,33 +33,32 @@ void BindRandom(py::module &m) {
   py::class_<RandomGenerator>(m, "RandomGenerator")
       .def(py::init<>())
       .def(py::init<std::uint32_t>())
-      .def("generate_int", &RandomGenerator::GenerateInt<std::int64_t>)
-      .def("generate_real", &RandomGenerator::GenerateReal<double>)
-      .def("generate_int_list", &RandomGenerator::GenerateIntVector<int>)
-      .def("generate_real_list", &RandomGenerator::GenerateRealVector<double>)
-      .def("generate_bool", &RandomGenerator::GenerateBool)
-      .def("generate_normal", &RandomGenerator::GenerateNormal<double>)
-      .def("generate_normal_float", &RandomGenerator::GenerateNormal<float>)
+      .def("rand_int", &RandomGenerator::GenerateInt<std::int64_t>)
+      .def("rand_float", &RandomGenerator::GenerateReal<double>)
+      .def("rand_ints", &RandomGenerator::GenerateIntVector<int>)
+      .def("rand_floats", &RandomGenerator::GenerateRealVector<double>)
+      .def("rand_bool", &RandomGenerator::GenerateBool)
+      .def("normal", &RandomGenerator::GenerateNormal<double>)
       .def("seed", &RandomGenerator::Seed)
       .def("seed_with_time", &RandomGenerator::SeedWithTime)
       .def("__repr__", [](const RandomGenerator &self) {
         return std::format("<RandomGenerator at {}>", static_cast<const void *>(&self));
       });
 
   // Bind utility functions
-  m.def("shuffle_container", &ShuffleContainer<Container<int>>);
-  m.def("shuffle_container", &ShuffleContainer<Container<double>>);
-  m.def("shuffle_container", &ShuffleContainer<Container<std::string>>);
-  m.def("shuffle_container", &ShuffleContainer<std::vector<int>>);
-  m.def("shuffle_container", &ShuffleContainer<std::vector<double>>);
-  m.def("shuffle_container", &ShuffleContainer<std::vector<std::string>>);
-  m.def("shuffle_container", &ShuffleContainer<std::string>);
+  m.def("shuffle", &ShuffleContainer<Container<int>>);
+  m.def("shuffle", &ShuffleContainer<Container<double>>);
+  m.def("shuffle", &ShuffleContainer<Container<std::string>>);
+  m.def("shuffle", &ShuffleContainer<std::vector<int>>);
+  m.def("shuffle", &ShuffleContainer<std::vector<double>>);
+  m.def("shuffle", &ShuffleContainer<std::vector<std::string>>);
+  m.def("shuffle", &ShuffleContainer<std::string>);
 
-  m.def("sample_from_range", &SampleFromRangeWrapper<Container<int>>);
-  m.def("sample_from_range", &SampleFromRangeWrapper<Container<double>>);
-  m.def("sample_from_range", &SampleFromRangeWrapper<Container<std::string>>);
-  m.def("sample_from_range", &SampleFromRangeWrapper<std::vector<int>>);
-  m.def("sample_from_range", &SampleFromRangeWrapper<std::vector<double>>);
-  m.def("sample_from_range", &SampleFromRangeWrapper<std::vector<std::string>>);
-  m.def("sample_from_range", &SampleFromRangeWrapper<std::string>);
+  m.def("sample", &SampleFromRangeWrapper<Container<int>>);
+  m.def("sample", &SampleFromRangeWrapper<Container<double>>);
+  m.def("sample", &SampleFromRangeWrapper<Container<std::string>>);
+  m.def("sample", &SampleFromRangeWrapper<std::vector<int>>);
+  m.def("sample", &SampleFromRangeWrapper<std::vector<double>>);
+  m.def("sample", &SampleFromRangeWrapper<std::vector<std::string>>);
+  m.def("sample", &SampleFromRangeWrapper<std::string>);
 }

include/random/random_gen.hpp

@@ -85,7 +85,7 @@ class RandomGenerator {
    * @tparam T Integral type that satisfies std::integral concept
    * @param min Minimum value (inclusive)
    * @param max Maximum value (inclusive)
-   * @return Random value of type T in the range [min, max]
+   * @return A random value of type T in the range [min, max]
    *
    * Generates a uniformly distributed random integral value within the specified range.
    * Both bounds are inclusive. The type T must be an integral type (int, long, etc.).
@@ -107,7 +107,7 @@ class RandomGenerator {
    * @tparam T Floating-point type that satisfies std::floating_point concept
    * @param min Minimum value (inclusive)
    * @param max Maximum value (exclusive)
-   * @return Random value of type T in the range [min, max)
+   * @return A random value of type T in the range [min, max)
    *
    * Generates a uniformly distributed random floating-point value within the specified range.
    * The minimum bound is inclusive, the maximum bound is exclusive. The type T must be a
@@ -131,7 +131,7 @@ class RandomGenerator {
    * @param min Minimum value for each element (inclusive)
    * @param max Maximum value for each element (inclusive)
    * @param count Number of random values to generate
-   * @return Vector containing count random values of type T
+   * @return A vector of random integral values
    *
    * Efficiently generates a vector of uniformly distributed random integral values.
    * Each value is independently generated within the specified range.
@@ -160,7 +160,7 @@ class RandomGenerator {
    * @param min Minimum value for each element (inclusive)
    * @param max Maximum value for each element (exclusive)
    * @param count Number of random values to generate
-   * @return Vector containing count random values of type T
+   * @return A vector of random floating-point values
    *
    * Efficiently generates a vector of uniformly distributed random floating-point values.
    * Each value is independently generated within the specified range.
@@ -186,7 +186,7 @@ class RandomGenerator {
    * @brief Generate a random boolean value with specified probability
    *
    * @param probability Probability of returning true (default: 0.5)
-   * @return Random boolean value
+   * @return A random boolean value
    *
    * Generates a random boolean value using a Bernoulli distribution with the specified probability.
    * A probability of 0.5 creates a fair coin flip, while other values bias the outcome accordingly.
@@ -208,7 +208,7 @@ class RandomGenerator {
    * @tparam T Floating-point type that satisfies std::floating_point concept
    * @param mean Mean (center) of the distribution
    * @param stddev Standard deviation of the distribution
-   * @return Random value from the normal distribution
+   * @return A random value from the normal distribution
    *
    * Generates a random value from a normal (Gaussian) distribution with the specified mean and
    * standard deviation. This is useful for generating naturally distributed data, noise, or
@@ -293,7 +293,7 @@ void ShuffleContainer(Range &range) {
  * @tparam Range Type that satisfies std::ranges::input_range concept
  * @param range The source range to sample from
  * @param count Number of elements to sample
- * @return Vector containing randomly selected elements from the range
+ * @return A vector of randomly selected elements from the range
  *
  * Selects a random subset of elements from the input range without replacement.
  * If count exceeds the range size, all elements are returned. The relative order of sampled

python/examples/algorithms_example.py

@@ -1,24 +1,18 @@
 """Example demonstrating the usage of the algorithms module."""
 
-from demo.algorithms import (
-    count_if,
-    find_min_max,
-    pipeline,
-    sort_inplace,
-    transform_to_list,
-)
+from demo.algorithms import *
 from demo.containers import Container
 
 
 def main() -> None:
     """Run all algorithm examples."""
     print('=== Algorithms Module Example ===')
 
-    # Demonstrate sort_inplace with integers
+    # Demonstrate sort with integers
     numbers = Container(int, [42, 17, 89, 3, 56, 23, 78, 12, 95, 34])
     print(f'Original numbers: {numbers}')
 
-    sort_inplace(numbers)
+    sort(numbers)
     print(f'Sorted numbers: {numbers}')
 
     # Demonstrate count_if
@@ -40,7 +34,7 @@ def main() -> None:
     words = Container(str, ['cherry', 'banana', 'elderberry', 'date', 'apple'])
     print(f'Original words: {words}')
 
-    sort_inplace(words)
+    sort(words)
     print(f'Sorted words: {words}')
 
     long_words = count_if(words, lambda word: len(word) > 5)

python/src/demo/algorithms.py

@@ -16,7 +16,7 @@
 U = TypeVar('U')
 
 
-def sort_inplace(data: list[T] | Container[T]) -> None:
+def sort(data: list[T] | Container[T]) -> None:
     """Sort a container in-place.
 
     Sorts the elements in the container in ascending order.
@@ -28,9 +28,9 @@ def sort_inplace(data: list[T] | Container[T]) -> None:
 
     Examples
     --------
-    >>> sort_inplace([3, 1, 4, 1, 5, 9, 2, 6, 5, 3])
+    >>> sort([3, 1, 4, 1, 5, 9, 2, 6, 5, 3])
     [1, 1, 2, 3, 3, 4, 5, 5, 6, 9]
-    >>> sort_inplace(Container(str, ['cherry', 'banana', 'elderberry', 'date', 'apple']))
+    >>> sort(Container(str, ['cherry', 'banana', 'elderberry', 'date', 'apple']))
     ['apple', 'banana', 'cherry', 'date', 'elderberry']
     """
     match data:
@@ -168,7 +168,7 @@ def composed(data: Any) -> Any:
 
 
 __all__ = [
-    'sort_inplace',
+    'sort',
     'count_if',
     'transform_to_list',
     'find_min_max',

python/src/demo/exceptions.py

@@ -1,7 +1,4 @@
-"""Modern Python wrapper for the exceptions module.
-
-Enhanced error handling with Result types and custom exceptions.
-"""
+"""Python wrapper for the exceptions module."""
 
 from enum import Enum