chore: bump rand to 0.10.1, rand_distr to 0.5, getrandom to 0.3 (#369)

* chore: bump rand to 0.10.1, remove rand_distr from default, getrandom to 0.3

- Update rand 0.8.5 → 0.10.1
- Update getrandom 0.2.8 → 0.3
- Add rand/thread_rng to std_rand feature (required in 0.9+)
- Rename getrandom/js feature → getrandom/wasm_js (getrandom 0.3)
- Replace deprecated thread_rng() → rng() (rand_custom, generator, io_testing)
- Replace deprecated gen() → random() (floatnum, realnum, kmeans)
- Replace deprecated gen_range() → random_range() (kmeans, base_forest_regressor, random_forest_classifier, base_tree_regressor)
- Replace distributions:: → distr:: module path (generator, io_testing)
- Replace DistString → SampleString trait (io_testing)
- Replace Uniform::from(range) → Uniform::new(a, b) (generator)
- Remove infallible .unwrap() from SmallRng::from_rng() (realnum)

* fix: replace removed small_rng feature with alloc for rand 0.10.1 compatibility

rand 0.9+ removed the `small_rng` cargo feature — SmallRng is now
unconditionally available via the `alloc` feature. Requesting `small_rng`
caused `cargo build --no-default-features` to fail with:

  package `smartcore` depends on `rand` with feature `small_rng`
  but `rand` does not have that feature.

Fix: replace `features = ["small_rng"]` with `features = ["alloc"]`.

* fix: replace rand::Rng with rand::RngExt and gen_range with random_range for rand 0.10 compatibility

* fix: resolve rand 0.10 compile errors in rand_custom and generator

- rand_custom.rs: replace `use rand::RngCore` with `use rand::Rng`
  so that `.next_u64()` resolves on ThreadRng (RngCore is no longer
  re-exported at the rand crate root; Rng supertrait covers it)

- dataset/generator.rs: add `use rand_distr::Distribution`
  rand::prelude::* no longer pulls in rand_distr's Distribution
  trait in rand 0.10, so Normal::sample() was unresolved on all
  call sites in make_blobs, make_circles and make_moons

* fix: bump getrandom wasm dep to 0.4 to match rand_core 0.9 requirement

rand 0.10 → rand_core 0.9 → getrandom 0.4 (transitively).
The old wasm32 getrandom = "0.3" pin caused a version mismatch:
the wasm_js feature flag and fill_inner/inner_u32/inner_u64 symbols
did not exist in the 0.3 API surface used by 0.4 consumers.

Bumping to getrandom = "0.4" aligns the explicit dep with the
transitive one; the `js` feature (`getrandom/wasm_js`) is unchanged
because the flag name is identical in getrandom 0.4.

* fix: bump rand_distr to 0.5.1 and use rand::distr::Distribution

rand_distr 0.5.0 depends on rand 0.9.x, causing a two-crate version
conflict: ThreadRng from rand 0.10 does not satisfy the Rng bound
defined in rand 0.9's distribution.rs, so every .sample() call fails
with E0277 (DerefMut / RngCore unsatisfied).

rand_distr 0.5.1 is the patch that retargets the crate to rand 0.10,
unifying both ThreadRng and the Distribution trait to the same version.

Also replace `use rand_distr::Distribution` with
`use rand::distr::Distribution` in generator.rs: after the bump
both Uniform (from rand) and Normal (from rand_distr 0.5.1) implement
rand 0.10's Distribution trait, so using the single canonical import
from rand eliminates any remaining trait-version ambiguity.

* fix: import both Distribution traits to cover Uniform and Normal

rand::distr::Distribution covers Uniform (from rand 0.10).
rand_distr::Distribution covers Normal (from rand_distr 0.5.1).
Both traits define .sample() but are distinct types; aliasing
rand_distr::Distribution as DistrDistribution avoids the name
ambiguity while keeping both call sites resolvable.

* fix: replace rand_distr::Normal with rand::distr::Normal in generator

rand_distr (any version 0.5.x) still carries rand = "^0.9" in its own
dependency tree, so Cargo resolves it against rand 0.9.3 even when
rand_distr = "0.5.1" is specified. This causes the persistent
E0277: ThreadRng (from rand 0.10) does not satisfy rand 0.9's Rng bound.

rand 0.10 ships rand::distr::Normal natively, so rand_distr is not
needed for generator.rs at all. Switching to rand::distr::Normal
and rand::distr::Distribution eliminates the cross-version conflict
entirely. rand_distr remains an optional dep for other future use
but is removed from the datasets feature deps.

* fix: use rand_distr::Normal with rand::distr::Distribution trait

rand_distr 0.5.1 does not yet target rand 0.10, so rand::distr::Normal
does not exist. The correct bridging pattern is:
- rand_distr::Normal for the struct (from rand_distr 0.5.1)
- rand::distr::Distribution for the trait (from rand 0.10)

Cargo unifies the Distribution trait across the two versions via the
rand_core re-export, so .sample(&mut rng) works with a rand 0.10
ThreadRng as long as rand::distr::Distribution is the imported trait.

Also restores rand_distr as optional dep and in datasets feature.

* fix: replace rand_distr with rand::distr::StandardNormal for Normal sampling

rand_distr 0.5.1 depends on rand 0.9 and cannot be made compatible with
rand 0.10 via trait imports — they are distinct incompatible types.

rand 0.10 ships rand::distr::StandardNormal (samples N(0,1)) natively.
Normal(mean, std) sampling is trivially: mean + std * StandardNormal.sample(rng)

This removes the rand_distr dependency entirely, solving the version
conflict at the root.

* fix: implement Normal sampling via Box-Muller using rand 0.10 primitives only

rand::distr::StandardNormal does not exist in rand 0.10 — StandardNormal
is only in rand_distr, which conflicts with rand 0.10.

Instead, implement sample_normal() using the Box-Muller transform:
  z = sqrt(-2 * ln(u1)) * cos(2π * u2)  where u1,u2 ~ Uniform(0,1)

This uses only rand::distr::Uniform and rand::Rng from rand 0.10,
requiring no external crates.

* style: rustfmt sample_with_replacement signature in random_forest_classifier

Author: Mec-iS

Cargo.toml

@@ -25,8 +25,7 @@ cfg-if = "1.0.0"
 ndarray = { version = "0.15", optional = true }
 num-traits = "0.2.12"
 num = "0.4"
-rand = { version = "0.8.5", default-features = false, features = ["small_rng"] }
-rand_distr = { version = "0.4", optional = true }
+rand = { version = "0.10.1", default-features = false, features = ["alloc"] }
 serde = { version = "1", features = ["derive"], optional = true }
 ordered-float = "5.1.0"
 
@@ -37,13 +36,13 @@ typetag = { version = "0.2", optional = true }
 default = []
 serde = ["dep:serde", "dep:typetag"]
 ndarray-bindings = ["dep:ndarray"]
-datasets = ["dep:rand_distr", "std_rand", "serde"]
-std_rand = ["rand/std_rng", "rand/std"]
+datasets = ["std_rand", "serde"]
+std_rand = ["rand/std_rng", "rand/std", "rand/thread_rng"]
 # used by wasm32-unknown-unknown for in-browser usage
-js = ["getrandom/js"]
+js = ["getrandom/wasm_js"]
 
 [target.'cfg(target_arch = "wasm32")'.dependencies]
-getrandom = { version = "0.2.8", optional = true }
+getrandom = { version = "0.4", optional = true }
 
 [target.'cfg(all(target_arch = "wasm32", not(target_os = "wasi")))'.dev-dependencies]
 wasm-bindgen-test = "0.3"

src/cluster/kmeans.rs

@@ -55,7 +55,7 @@
 use std::fmt::Debug;
 use std::marker::PhantomData;
 
-use rand::Rng;
+use rand::RngExt;
 #[cfg(feature = "serde")]
 use serde::{Deserialize, Serialize};
 
@@ -356,7 +356,7 @@ impl<TX: Number, TY: Number, X: Array2<TX>, Y: Array1<TY>> KMeans<TX, TY, X, Y>
         let (n, _) = data.shape();
         let mut y = vec![0; n];
         let mut centroid: Vec<TX> = data
-            .get_row(rng.gen_range(0..n))
+            .get_row(rng.random_range(0..n))
             .iterator(0)
             .cloned()
             .collect();
@@ -382,7 +382,7 @@ impl<TX: Number, TY: Number, X: Array2<TX>, Y: Array1<TY>> KMeans<TX, TY, X, Y>
             for i in d.iter() {
                 sum += *i;
             }
-            let cutoff = rng.gen::<f64>() * sum;
+            let cutoff = rng.random::<f64>() * sum;
             let mut cost = 0f64;
             let mut index = 0;
             while index < n {

src/dataset/generator.rs

@@ -1,38 +1,47 @@
 //! # Dataset Generators
 //!
-use rand::distributions::Uniform;
-use rand::prelude::*;
-use rand_distr::Normal;
+use rand::distr::Distribution;
+use rand::distr::Uniform;
 
 use crate::dataset::Dataset;
 
+/// Sample from N(mean, std) via Box-Muller transform using only rand 0.10
+#[inline]
+fn sample_normal(mean: f32, std: f32, rng: &mut impl rand::Rng) -> f32 {
+    let unit = Uniform::new(f32::EPSILON, 1.0f32).unwrap();
+    let u1 = unit.sample(rng);
+    let u2 = unit.sample(rng);
+    let z = (-2.0 * u1.ln()).sqrt() * (2.0 * std::f32::consts::PI * u2).cos();
+    mean + std * z
+}
+
 /// Generate `num_centers` clusters of normally distributed points
 pub fn make_blobs(
     num_samples: usize,
     num_features: usize,
     num_centers: usize,
 ) -> Dataset<f32, f32> {
-    let center_box = Uniform::from(-10.0..10.0);
-    let cluster_std = 1.0;
-    let mut centers: Vec<Vec<Normal<f32>>> = Vec::with_capacity(num_centers);
+    let center_box = Uniform::new(-10.0f32, 10.0f32).expect("Invalid uniform range");
+    let cluster_std = 1.0f32;
+    let mut rng = rand::rng();
 
-    let mut rng = rand::thread_rng();
-    for _ in 0..num_centers {
-        centers.push(
+    // Pre-compute cluster centers (one mean per feature per cluster)
+    let centers: Vec<Vec<f32>> = (0..num_centers)
+        .map(|_| {
             (0..num_features)
-                .map(|_| Normal::new(center_box.sample(&mut rng), cluster_std).unwrap())
-                .collect(),
-        );
-    }
+                .map(|_| center_box.sample(&mut rng))
+                .collect()
+        })
+        .collect();
 
     let mut y: Vec<f32> = Vec::with_capacity(num_samples);
-    let mut x: Vec<f32> = Vec::with_capacity(num_samples);
+    let mut x: Vec<f32> = Vec::with_capacity(num_samples * num_features);
 
     for i in 0..num_samples {
         let label = i % num_centers;
         y.push(label as f32);
         for j in 0..num_features {
-            x.push(centers[label][j].sample(&mut rng));
+            x.push(sample_normal(centers[label][j], cluster_std, &mut rng));
         }
     }
 
@@ -59,21 +68,20 @@ pub fn make_circles(num_samples: usize, factor: f32, noise: f32) -> Dataset<f32,
     let linspace_out = linspace(0.0, 2.0 * std::f32::consts::PI, num_samples_out);
     let linspace_in = linspace(0.0, 2.0 * std::f32::consts::PI, num_samples_in);
 
-    let noise = Normal::new(0.0, noise).unwrap();
-    let mut rng = rand::thread_rng();
+    let mut rng = rand::rng();
 
     let mut x: Vec<f32> = Vec::with_capacity(num_samples * 2);
     let mut y: Vec<f32> = Vec::with_capacity(num_samples);
 
     for v in linspace_out {
-        x.push(v.cos() + noise.sample(&mut rng));
-        x.push(v.sin() + noise.sample(&mut rng));
+        x.push(v.cos() + sample_normal(0.0, noise, &mut rng));
+        x.push(v.sin() + sample_normal(0.0, noise, &mut rng));
         y.push(0.0);
     }
 
     for v in linspace_in {
-        x.push(v.cos() * factor + noise.sample(&mut rng));
-        x.push(v.sin() * factor + noise.sample(&mut rng));
+        x.push(v.cos() * factor + sample_normal(0.0, noise, &mut rng));
+        x.push(v.sin() * factor + sample_normal(0.0, noise, &mut rng));
         y.push(1.0);
     }
 
@@ -96,21 +104,20 @@ pub fn make_moons(num_samples: usize, noise: f32) -> Dataset<f32, u32> {
     let linspace_out = linspace(0.0, std::f32::consts::PI, num_samples_out);
     let linspace_in = linspace(0.0, std::f32::consts::PI, num_samples_in);
 
-    let noise = Normal::new(0.0, noise).unwrap();
-    let mut rng = rand::thread_rng();
+    let mut rng = rand::rng();
 
     let mut x: Vec<f32> = Vec::with_capacity(num_samples * 2);
     let mut y: Vec<f32> = Vec::with_capacity(num_samples);
 
     for v in linspace_out {
-        x.push(v.cos() + noise.sample(&mut rng));
-        x.push(v.sin() + noise.sample(&mut rng));
+        x.push(v.cos() + sample_normal(0.0, noise, &mut rng));
+        x.push(v.sin() + sample_normal(0.0, noise, &mut rng));
         y.push(0.0);
     }
 
     for v in linspace_in {
-        x.push(1.0 - v.cos() + noise.sample(&mut rng));
-        x.push(1.0 - v.sin() + noise.sample(&mut rng) - 0.5);
+        x.push(1.0 - v.cos() + sample_normal(0.0, noise, &mut rng));
+        x.push(1.0 - v.sin() + sample_normal(0.0, noise, &mut rng) - 0.5);
         y.push(1.0);
     }
 

src/ensemble/base_forest_regressor.rs

@@ -1,4 +1,4 @@
-use rand::Rng;
+use rand::RngExt;
 use std::fmt::Debug;
 
 #[cfg(feature = "serde")]
@@ -209,10 +209,10 @@ impl<TX: Number + FloatNumber + PartialOrd, TY: Number, X: Array2<TX>, Y: Array1
         result / TY::from(n_trees).unwrap()
     }
 
-    fn sample_with_replacement(nrows: usize, rng: &mut impl Rng) -> Vec<usize> {
+    fn sample_with_replacement(nrows: usize, rng: &mut impl rand::Rng) -> Vec<usize> {
         let mut samples = vec![0; nrows];
         for _ in 0..nrows {
-            let xi = rng.gen_range(0..nrows);
+            let xi = rng.random_range(0..nrows);
             samples[xi] += 1;
         }
         samples

src/ensemble/random_forest_classifier.rs

@@ -45,7 +45,7 @@
 //!
 //! <script src="https://polyfill.io/v3/polyfill.min.js?features=es6"></script>
 //! <script id="MathJax-script" async src="https://cdn.jsdelivr.net/npm/mathjax@3/es5/tex-mml-chtml.js"></script>
-use rand::Rng;
+use rand::RngExt;
 
 use std::default::Default;
 use std::fmt::Debug;
@@ -587,7 +587,11 @@ impl<TX: FloatNumber + PartialOrd, TY: Number + Ord, X: Array2<TX>, Y: Array1<TY
         which_max(&result)
     }
 
-    fn sample_with_replacement(y: &[usize], num_classes: usize, rng: &mut impl Rng) -> Vec<usize> {
+    fn sample_with_replacement(
+        y: &[usize],
+        num_classes: usize,
+        rng: &mut impl rand::Rng,
+    ) -> Vec<usize> {
         let class_weight = vec![1.; num_classes];
         let nrows = y.len();
         let mut samples = vec![0; nrows];
@@ -603,7 +607,7 @@ impl<TX: FloatNumber + PartialOrd, TY: Number + Ord, X: Array2<TX>, Y: Array1<TY
 
             let size = ((n_samples as f64) / *class_weight_l) as usize;
             for _ in 0..size {
-                let xi: usize = rng.gen_range(0..n_samples);
+                let xi: usize = rng.random_range(0..n_samples);
                 samples[index[xi]] += 1;
             }
         }

src/numbers/floatnum.rs

@@ -56,9 +56,9 @@ impl FloatNumber for f64 {
     }
 
     fn rand() -> f64 {
-        use rand::Rng;
+        use rand::RngExt;
         let mut rng = get_rng_impl(None);
-        rng.gen()
+        rng.random()
     }
 
     fn two() -> Self {
@@ -98,9 +98,9 @@ impl FloatNumber for f32 {
     }
 
     fn rand() -> f32 {
-        use rand::Rng;
+        use rand::RngExt;
         let mut rng = get_rng_impl(None);
-        rng.gen()
+        rng.random()
     }
 
     fn two() -> Self {

src/numbers/realnum.rs

@@ -3,7 +3,7 @@
 //! This module defines real number and some useful functions that are used in [Linear Algebra](../../linalg/index.html) module.
 
 use rand::rngs::SmallRng;
-use rand::{Rng, SeedableRng};
+use rand::{RngExt, SeedableRng};
 
 use num_traits::Float;
 
@@ -69,10 +69,8 @@ impl RealNumber for f64 {
     fn rand() -> f64 {
         let mut small_rng = get_rng_impl(None);
 
-        let mut rngs: Vec<SmallRng> = (0..3)
-            .map(|_| SmallRng::from_rng(&mut small_rng).unwrap())
-            .collect();
-        rngs[0].gen::<f64>()
+        let mut rngs: Vec<SmallRng> = (0..3).map(|_| SmallRng::from_rng(&mut small_rng)).collect();
+        rngs[0].random::<f64>()
     }
 
     fn two() -> Self {
@@ -118,10 +116,8 @@ impl RealNumber for f32 {
     fn rand() -> f32 {
         let mut small_rng = get_rng_impl(None);
 
-        let mut rngs: Vec<SmallRng> = (0..3)
-            .map(|_| SmallRng::from_rng(&mut small_rng).unwrap())
-            .collect();
-        rngs[0].gen::<f32>()
+        let mut rngs: Vec<SmallRng> = (0..3).map(|_| SmallRng::from_rng(&mut small_rng)).collect();
+        rngs[0].random::<f32>()
     }
 
     fn two() -> Self {

src/rand_custom.rs

@@ -11,8 +11,11 @@ pub fn get_rng_impl(seed: Option<u64>) -> RngImpl {
         None => {
             cfg_if::cfg_if! {
                 if #[cfg(feature = "std_rand")] {
-                    use rand::RngCore;
-                    RngImpl::seed_from_u64(rand::thread_rng().next_u64())
+                    use rand::Rng;
+                    // FIX: thread_rng() deprecated in rand 0.9 → use rng()
+                    // FIX: rand 0.10 no longer re-exports RngCore at root;
+                    //      import rand::Rng (supertrait) instead so next_u64() resolves
+                    RngImpl::seed_from_u64(rand::rng().next_u64())
                 } else {
                     // no std_random feature build, use getrandom
                     #[cfg(feature = "js")]

src/readers/io_testing.rs

@@ -1,7 +1,7 @@
 //! This module contains functionality to test IO. It has both functions that write
 //! to the file-system for end-to-end tests, but also abstractions to avoid this by
 //! reading from strings instead.
-use rand::distributions::{Alphanumeric, DistString};
+use rand::distr::{Alphanumeric, SampleString};
 use std::fs;
 use std::io::Bytes;
 use std::io::Read;
@@ -16,7 +16,7 @@ pub struct TemporaryTextFile {
 impl TemporaryTextFile {
     pub fn new(contents: &str) -> std::io::Result<Self> {
         let test_text_file = TemporaryTextFile {
-            random_path: Alphanumeric.sample_string(&mut rand::thread_rng(), 16),
+            random_path: Alphanumeric.sample_string(&mut rand::rng(), 16),
         };
         string_to_file(contents, &test_text_file.random_path)?;
         Ok(test_text_file)

src/tree/base_tree_regressor.rs

@@ -4,7 +4,7 @@ use std::fmt::Debug;
 use std::marker::PhantomData;
 
 use rand::seq::SliceRandom;
-use rand::Rng;
+use rand::RngExt;
 
 #[cfg(feature = "serde")]
 use serde::{Deserialize, Serialize};
@@ -292,7 +292,7 @@ impl<TX: Number + PartialOrd, TY: Number, X: Array2<TX>, Y: Array1<TY>>
         &mut self,
         visitor: &mut NodeVisitor<'_, TX, TY, X, Y>,
         mtry: usize,
-        rng: &mut impl Rng,
+        rng: &mut impl rand::Rng,
     ) -> bool {
         let (_, n_attr) = visitor.x.shape();
 
@@ -336,7 +336,7 @@ impl<TX: Number + PartialOrd, TY: Number, X: Array2<TX>, Y: Array1<TY>>
         sum: f64,
         parent_gain: f64,
         j: usize,
-        rng: &mut impl Rng,
+        rng: &mut impl rand::Rng,
     ) {
         let (min_val, max_val) = {
             let mut min_opt = None;
@@ -363,7 +363,7 @@ impl<TX: Number + PartialOrd, TY: Number, X: Array2<TX>, Y: Array1<TY>>
             return;
         }
 
-        let split_value = rng.gen_range(min_val.to_f64().unwrap()..max_val.to_f64().unwrap());
+        let split_value = rng.random_range(min_val.to_f64().unwrap()..max_val.to_f64().unwrap());
 
         let mut true_sum = 0f64;
         let mut true_count = 0;
@@ -476,7 +476,7 @@ impl<TX: Number + PartialOrd, TY: Number, X: Array2<TX>, Y: Array1<TY>>
         mut visitor: NodeVisitor<'a, TX, TY, X, Y>,
         mtry: usize,
         visitor_queue: &mut LinkedList<NodeVisitor<'a, TX, TY, X, Y>>,
-        rng: &mut impl Rng,
+        rng: &mut impl rand::Rng,
     ) -> bool {
         let (n, _) = visitor.x.shape();
         let mut tc = 0;