fix clippy error

implemented single linkage clustering
implemented multiclass for svc (#308 )
2025-07-03 11:59:18 +01:00 · 2025-07-01 14:21:22 -05:00 · 2025-06-16 11:00:11 +01:00 · 2025-06-02 11:01:46 +01:00 · 2025-04-24 23:24:29 -04:00 · 2025-02-04 14:26:53 +00:00
50 changed files with 2273 additions and 734 deletions
@@ -2,6 +2,5 @@
 # the repo. Unless a later match takes precedence,
 # Developers in this list will be requested for
 # review when someone opens a pull request.
-*       @VolodymyrOrlov
 *       @morenol
 *       @Mec-iS
@@ -50,9 +50,9 @@ $ rust-code-analysis-cli -p src/algorithm/neighbour/fastpair.rs --ls 22 --le 213

 1. After a PR is opened maintainers are notified
 2. Probably changes will be required to comply with the workflow, these commands are run automatically and all tests shall pass:
-    * **Coverage** (optional): `tarpaulin` is used with command `cargo tarpaulin --out Lcov --all-features -- --test-threads 1`
    * **Formatting**: run `rustfmt src/*.rs` to apply automatic formatting
    * **Linting**: `clippy` is used with command `cargo clippy --all-features -- -Drust-2018-idioms -Dwarnings`
+    * **Coverage** (optional): `tarpaulin` is used with command `cargo tarpaulin --out Lcov --all-features -- --test-threads 1`
    * **Testing**: multiple test pipelines are run for different targets
 3. When everything is OK, code is merged.

@@ -19,14 +19,13 @@ jobs:
            { os: "ubuntu", target: "i686-unknown-linux-gnu" },
            { os: "ubuntu", target: "wasm32-unknown-unknown" },
            { os: "macos", target: "aarch64-apple-darwin" },
-            { os: "ubuntu", target: "wasm32-wasi" },
          ]
    env:
      TZ: "/usr/share/zoneinfo/your/location"
    steps:
-      - uses: actions/checkout@v3
+      - uses: actions/checkout@v4
      - name: Cache .cargo and target
-        uses: actions/cache@v2
+        uses: actions/cache@v4
        with:
          path: |
            ~/.cargo
@@ -43,9 +42,6 @@ jobs:
      - name: Install test runner for wasm
        if: matrix.platform.target == 'wasm32-unknown-unknown'
        run: curl https://rustwasm.github.io/wasm-pack/installer/init.sh -sSf | sh
-      - name: Install test runner for wasi
-        if: matrix.platform.target == 'wasm32-wasi'
-        run: curl https://wasmtime.dev/install.sh -sSf | bash
      - name: Stable Build with all features
        uses: actions-rs/cargo@v1
        with:
@@ -65,12 +61,6 @@ jobs:
      - name: Tests in WASM
        if: matrix.platform.target == 'wasm32-unknown-unknown'
        run: wasm-pack test --node -- --all-features
-      - name: Tests in WASI
-        if: matrix.platform.target == 'wasm32-wasi'
-        run: |
-          export WASMTIME_HOME="$HOME/.wasmtime"
-          export PATH="$WASMTIME_HOME/bin:$PATH"
-          cargo install cargo-wasi && cargo wasi test
  
  check_features:
    runs-on: "${{ matrix.platform.os }}-latest"
@@ -81,9 +71,9 @@ jobs:
    env:
      TZ: "/usr/share/zoneinfo/your/location"
    steps:
-      - uses: actions/checkout@v3
+      - uses: actions/checkout@v4
      - name: Cache .cargo and target
-        uses: actions/cache@v2
+        uses: actions/cache@v4
        with:
          path: |
            ~/.cargo
@@ -12,9 +12,9 @@ jobs:
    env:
      TZ: "/usr/share/zoneinfo/your/location"
    steps:
-      - uses: actions/checkout@v2
+      - uses: actions/checkout@v4
      - name: Cache .cargo
-        uses: actions/cache@v2
+        uses: actions/cache@v4
        with:
          path: |
            ~/.cargo
@@ -14,7 +14,7 @@ jobs:
    steps:
      - uses: actions/checkout@v2
      - name: Cache .cargo and target
-        uses: actions/cache@v2
+        uses: actions/cache@v4
        with:
          path: |
            ~/.cargo
@@ -2,7 +2,7 @@
 name = "smartcore"
 description = "Machine Learning in Rust."
 homepage = "https://smartcorelib.org"
-version = "0.4.0"
+version = "0.4.2"
 authors = ["smartcore Developers"]
 edition = "2021"
 license = "Apache-2.0"
@@ -48,7 +48,7 @@ getrandom = { version = "0.2.8", optional = true }
 wasm-bindgen-test = "0.3"

 [dev-dependencies]
-itertools = "0.12.0"
+itertools = "0.13.0"
 serde_json = "1.0"
 bincode = "1.3.1"

@@ -18,4 +18,4 @@
 -----
 [![CI](https://github.com/smartcorelib/smartcore/actions/workflows/ci.yml/badge.svg)](https://github.com/smartcorelib/smartcore/actions/workflows/ci.yml)

-To start getting familiar with the new smartcore v0.3 API, there is now available a [**Jupyter Notebook environment repository**](https://github.com/smartcorelib/smartcore-jupyter). Please see instructions there, contributions welcome see [CONTRIBUTING](.github/CONTRIBUTING.md).
+To start getting familiar with the new smartcore v0.4 API, there is now available a [**Jupyter Notebook environment repository**](https://github.com/smartcorelib/smartcore-jupyter). Please see instructions there, contributions welcome see [CONTRIBUTING](.github/CONTRIBUTING.md).
@@ -124,7 +124,7 @@ impl<T: Debug + PartialEq, D: Distance<T>> CoverTree<T, D> {
        current_cover_set.push((d, &self.root));

        let mut heap = HeapSelection::with_capacity(k);
-        heap.add(std::f64::MAX);
+        heap.add(f64::MAX);

        let mut empty_heap = true;
        if !self.identical_excluded || self.get_data_value(self.root.idx) != p {
@@ -145,7 +145,7 @@ impl<T: Debug + PartialEq, D: Distance<T>> CoverTree<T, D> {
                    }

                    let upper_bound = if empty_heap {
-                        std::f64::INFINITY
+                        f64::INFINITY
                    } else {
                        *heap.peek()
                    };
@@ -291,7 +291,7 @@ impl<T: Debug + PartialEq, D: Distance<T>> CoverTree<T, D> {
        } else {
            let max_dist = self.max(point_set);
            let next_scale = (max_scale - 1).min(self.get_scale(max_dist));
-            if next_scale == std::i64::MIN {
+            if next_scale == i64::MIN {
                let mut children: Vec<Node> = Vec::new();
                let mut leaf = self.new_leaf(p);
                children.push(leaf);
@@ -435,7 +435,7 @@ impl<T: Debug + PartialEq, D: Distance<T>> CoverTree<T, D> {

    fn get_scale(&self, d: f64) -> i64 {
        if d == 0f64 {
-            std::i64::MIN
+            i64::MIN
        } else {
            (self.inv_log_base * d.ln()).ceil() as i64
        }
@@ -52,10 +52,8 @@ pub struct FastPair<'a, T: RealNumber + FloatNumber, M: Array2<T>> {
 }

 impl<'a, T: RealNumber + FloatNumber, M: Array2<T>> FastPair<'a, T, M> {
-    ///
    /// Constructor
-    /// Instantiate and inizialise the algorithm
-    ///
+    /// Instantiate and initialize the algorithm
    pub fn new(m: &'a M) -> Result<Self, Failed> {
        if m.shape().0 < 3 {
            return Err(Failed::because(
@@ -74,10 +72,8 @@ impl<'a, T: RealNumber + FloatNumber, M: Array2<T>> FastPair<'a, T, M> {
        Ok(init)
    }

-    ///
    /// Initialise `FastPair` by passing a `Array2`.
    /// Build a FastPairs data-structure from a set of (new) points.
-    ///
    fn init(&mut self) {
        // basic measures
        let len = self.samples.shape().0;
@@ -158,9 +154,7 @@ impl<'a, T: RealNumber + FloatNumber, M: Array2<T>> FastPair<'a, T, M> {
        self.neighbours = neighbours;
    }

-    ///
    /// Find closest pair by scanning list of nearest neighbors.
-    ///
    #[allow(dead_code)]
    pub fn closest_pair(&self) -> PairwiseDistance<T> {
        let mut a = self.neighbours[0]; // Start with first point
@@ -179,6 +173,21 @@ impl<'a, T: RealNumber + FloatNumber, M: Array2<T>> FastPair<'a, T, M> {
        }
    }

+    ///
+    /// Return order dissimilarities from closest to furthest
+    ///
+    #[allow(dead_code)]
+    pub fn ordered_pairs(&self) -> std::vec::IntoIter<&PairwiseDistance<T>> {
+        // improvement: implement this to return `impl Iterator<Item = &PairwiseDistance<T>>`
+        // need to implement trait `Iterator` for `Vec<&PairwiseDistance<T>>`
+        let mut distances = self
+            .distances
+            .values()
+            .collect::<Vec<&PairwiseDistance<T>>>();
+        distances.sort_by(|a, b| a.partial_cmp(b).unwrap());
+        distances.into_iter()
+    }
+
    //
    // Compute distances from input to all other points in data-structure.
    // input is the row index of the sample matrix
@@ -217,10 +226,10 @@ mod tests_fastpair {
    use super::*;
    use crate::linalg::basic::{arrays::Array, matrix::DenseMatrix};

-    ///
    /// Brute force algorithm, used only for comparison and testing
-    ///
-    pub fn closest_pair_brute(fastpair: &FastPair<f64, DenseMatrix<f64>>) -> PairwiseDistance<f64> {
+    pub fn closest_pair_brute(
+        fastpair: &FastPair<'_, f64, DenseMatrix<f64>>,
+    ) -> PairwiseDistance<f64> {
        use itertools::Itertools;
        let m = fastpair.samples.shape().0;

@@ -594,4 +603,103 @@ mod tests_fastpair {

        assert_eq!(closest, min_dissimilarity);
    }
+
+    #[test]
+    fn fastpair_ordered_pairs() {
+        let x = DenseMatrix::<f64>::from_2d_array(&[
+            &[5.1, 3.5, 1.4, 0.2],
+            &[4.9, 3.0, 1.4, 0.2],
+            &[4.7, 3.2, 1.3, 0.2],
+            &[4.6, 3.1, 1.5, 0.2],
+            &[5.0, 3.6, 1.4, 0.2],
+            &[5.4, 3.9, 1.7, 0.4],
+            &[4.9, 3.1, 1.5, 0.1],
+            &[7.0, 3.2, 4.7, 1.4],
+            &[6.4, 3.2, 4.5, 1.5],
+            &[6.9, 3.1, 4.9, 1.5],
+            &[5.5, 2.3, 4.0, 1.3],
+            &[6.5, 2.8, 4.6, 1.5],
+            &[4.6, 3.4, 1.4, 0.3],
+            &[5.0, 3.4, 1.5, 0.2],
+            &[4.4, 2.9, 1.4, 0.2],
+        ])
+        .unwrap();
+        let fastpair = FastPair::new(&x).unwrap();
+
+        let ordered = fastpair.ordered_pairs();
+
+        let mut previous: f64 = -1.0;
+        for p in ordered {
+            if previous == -1.0 {
+                previous = p.distance.unwrap();
+            } else {
+                let current = p.distance.unwrap();
+                assert!(current >= previous);
+                previous = current;
+            }
+        }
+    }
+
+    #[test]
+    fn test_empty_set() {
+        let empty_matrix = DenseMatrix::<f64>::zeros(0, 0);
+        let result = FastPair::new(&empty_matrix);
+        assert!(result.is_err());
+        if let Err(e) = result {
+            assert_eq!(
+                e,
+                Failed::because(FailedError::FindFailed, "min number of rows should be 3")
+            );
+        }
+    }
+
+    #[test]
+    fn test_single_point() {
+        let single_point = DenseMatrix::from_2d_array(&[&[1.0, 2.0, 3.0]]).unwrap();
+        let result = FastPair::new(&single_point);
+        assert!(result.is_err());
+        if let Err(e) = result {
+            assert_eq!(
+                e,
+                Failed::because(FailedError::FindFailed, "min number of rows should be 3")
+            );
+        }
+    }
+
+    #[test]
+    fn test_two_points() {
+        let two_points = DenseMatrix::from_2d_array(&[&[1.0, 2.0], &[3.0, 4.0]]).unwrap();
+        let result = FastPair::new(&two_points);
+        assert!(result.is_err());
+        if let Err(e) = result {
+            assert_eq!(
+                e,
+                Failed::because(FailedError::FindFailed, "min number of rows should be 3")
+            );
+        }
+    }
+
+    #[test]
+    fn test_three_identical_points() {
+        let identical_points =
+            DenseMatrix::from_2d_array(&[&[1.0, 1.0], &[1.0, 1.0], &[1.0, 1.0]]).unwrap();
+        let result = FastPair::new(&identical_points);
+        assert!(result.is_ok());
+        let fastpair = result.unwrap();
+        let closest_pair = fastpair.closest_pair();
+        assert_eq!(closest_pair.distance, Some(0.0));
+    }
+
+    #[test]
+    fn test_result_unwrapping() {
+        let valid_matrix =
+            DenseMatrix::from_2d_array(&[&[1.0, 2.0], &[3.0, 4.0], &[5.0, 6.0], &[7.0, 8.0]])
+                .unwrap();
+
+        let result = FastPair::new(&valid_matrix);
+        assert!(result.is_ok());
+
+        // This should not panic
+        let _fastpair = result.unwrap();
+    }
 }
@@ -61,7 +61,7 @@ impl<T, D: Distance<T>> LinearKNNSearch<T, D> {

        for _ in 0..k {
            heap.add(KNNPoint {
-                distance: std::f64::INFINITY,
+                distance: f64::INFINITY,
                index: None,
            });
        }
@@ -215,7 +215,7 @@ mod tests {
        };

        let point_inf = KNNPoint {
-            distance: std::f64::INFINITY,
+            distance: f64::INFINITY,
            index: Some(3),
        };

@@ -133,7 +133,7 @@ mod tests {
    #[test]
    fn test_add1() {
        let mut heap = HeapSelection::with_capacity(3);
-        heap.add(std::f64::INFINITY);
+        heap.add(f64::INFINITY);
        heap.add(-5f64);
        heap.add(4f64);
        heap.add(-1f64);
@@ -151,7 +151,7 @@ mod tests {
    #[test]
    fn test_add2() {
        let mut heap = HeapSelection::with_capacity(3);
-        heap.add(std::f64::INFINITY);
+        heap.add(f64::INFINITY);
        heap.add(0.0);
        heap.add(8.4852);
        heap.add(5.6568);
@@ -3,6 +3,7 @@ use num_traits::Num;
 pub trait QuickArgSort {
    fn quick_argsort_mut(&mut self) -> Vec<usize>;

+    #[allow(dead_code)]
    fn quick_argsort(&self) -> Vec<usize>;
 }

@@ -0,0 +1,315 @@
+//! # Agglomerative Hierarchical Clustering
+//!
+//! Agglomerative clustering is a "bottom-up" hierarchical clustering method. It works by placing each data point in its own cluster and then successively merging the two most similar clusters until a stopping criterion is met. This process creates a tree-based hierarchy of clusters known as a dendrogram.
+//!
+//! The similarity of two clusters is determined by a **linkage criterion**. This implementation uses **single-linkage**, where the distance between two clusters is defined as the minimum distance between any single point in the first cluster and any single point in the second cluster. The distance between points is the standard Euclidean distance.
+//!
+//! The algorithm first builds the full hierarchy of `N-1` merges. To obtain a specific number of clusters, `n_clusters`, the algorithm then effectively "cuts" the dendrogram at the point where `n_clusters` remain.
+//!
+//! ## Example:
+//!
+//! ```
+//! use smartcore::linalg::basic::matrix::DenseMatrix;
+//! use smartcore::cluster::agglomerative::{AgglomerativeClustering, AgglomerativeClusteringParameters};
+//!
+//! // A dataset with 2 distinct groups of points.
+//! let x = DenseMatrix::from_2d_array(&[
+//!         &[0.0, 0.0], &[1.0, 1.0], &[0.5, 0.5], // Cluster A
+//!         &[10.0, 10.0], &[11.0, 11.0], &[10.5, 10.5], // Cluster B
+//!     ]).unwrap();
+//!
+//! // Set parameters to find 2 clusters.
+//! let parameters = AgglomerativeClusteringParameters::default().with_n_clusters(2);
+//!
+//! // Fit the model to the data.
+//! let clustering = AgglomerativeClustering::<f64, usize, DenseMatrix<f64>, Vec<usize>>::fit(&x, parameters).unwrap();
+//!
+//! // Get the cluster assignments.
+//! let labels = clustering.labels; // e.g., [0, 0, 0, 1, 1, 1]
+//! ```
+//!
+//! ## References:
+//!
+//! * ["An Introduction to Statistical Learning", James G., Witten D., Hastie T., Tibshirani R., 10.3.2 Hierarchical Clustering](http://faculty.marshall.usc.edu/gareth-james/ISL/)
+//! * ["The Elements of Statistical Learning", Hastie T., Tibshirani R., Friedman J., 14.3.12 Hierarchical Clustering](https://hastie.su.domains/ElemStatLearn/)
+
+use std::collections::HashMap;
+use std::marker::PhantomData;
+
+use crate::api::UnsupervisedEstimator;
+use crate::error::{Failed, FailedError};
+use crate::linalg::basic::arrays::{Array1, Array2};
+use crate::numbers::basenum::Number;
+
+/// Parameters for the Agglomerative Clustering algorithm.
+#[derive(Debug, Clone, Copy)]
+pub struct AgglomerativeClusteringParameters {
+    /// The number of clusters to find.
+    pub n_clusters: usize,
+}
+
+impl AgglomerativeClusteringParameters {
+    /// Sets the number of clusters.
+    ///
+    /// # Arguments
+    /// * `n_clusters` - The desired number of clusters.
+    pub fn with_n_clusters(mut self, n_clusters: usize) -> Self {
+        self.n_clusters = n_clusters;
+        self
+    }
+}
+
+impl Default for AgglomerativeClusteringParameters {
+    fn default() -> Self {
+        AgglomerativeClusteringParameters { n_clusters: 2 }
+    }
+}
+
+/// Agglomerative Clustering model.
+///
+/// This implementation uses single-linkage clustering, which is mathematically
+/// equivalent to finding the Minimum Spanning Tree (MST) of the data points.
+/// The core logic is an efficient implementation of Kruskal's algorithm, which
+/// processes all pairwise distances in increasing order and uses a Disjoint
+/// Set Union (DSU) data structure to track cluster membership.
+#[derive(Debug)]
+pub struct AgglomerativeClustering<TX: Number, TY: Number, X: Array2<TX>, Y: Array1<TY>> {
+    /// The cluster label assigned to each sample.
+    pub labels: Vec<usize>,
+    _phantom_tx: PhantomData<TX>,
+    _phantom_ty: PhantomData<TY>,
+    _phantom_x: PhantomData<X>,
+    _phantom_y: PhantomData<Y>,
+}
+
+impl<TX: Number, TY: Number, X: Array2<TX>, Y: Array1<TY>> AgglomerativeClustering<TX, TY, X, Y> {
+    /// Fits the agglomerative clustering model to the data.
+    ///
+    /// # Arguments
+    /// * `data` - A reference to the input data matrix.
+    /// * `parameters` - The parameters for the clustering algorithm, including `n_clusters`.
+    ///
+    /// # Returns
+    /// A `Result` containing the fitted model with cluster labels, or an error if
+    pub fn fit(data: &X, parameters: AgglomerativeClusteringParameters) -> Result<Self, Failed> {
+        let (num_samples, _) = data.shape();
+        let n_clusters = parameters.n_clusters;
+        if n_clusters > num_samples {
+            return Err(Failed::because(
+                FailedError::ParametersError,
+                &format!("n_clusters: {n_clusters} cannot be greater than n_samples: {num_samples}"),
+            ));
+        }
+
+        let mut distance_pairs = Vec::new();
+        for i in 0..num_samples {
+            for j in (i + 1)..num_samples {
+                let distance: f64 = data
+                    .get_row(i)
+                    .iterator(0)
+                    .zip(data.get_row(j).iterator(0))
+                    .map(|(&a, &b)| (a.to_f64().unwrap() - b.to_f64().unwrap()).powi(2))
+                    .sum::<f64>();
+
+                distance_pairs.push((distance, i, j));
+            }
+        }
+        distance_pairs.sort_unstable_by(|a, b| b.0.partial_cmp(&a.0).unwrap());
+        let mut parent = HashMap::new();
+        let mut children = HashMap::new();
+        for i in 0..num_samples {
+            parent.insert(i, i);
+            children.insert(i, vec![i]);
+        }
+
+        let mut merge_history = Vec::new();
+        let num_merges_needed = num_samples - 1;
+
+        while merge_history.len() < num_merges_needed {
+            let (_, p1, p2) = distance_pairs.pop().unwrap();
+
+            let root1 = parent[&p1];
+            let root2 = parent[&p2];
+
+            if root1 != root2 {
+                let root2_children = children.remove(&root2).unwrap();
+                for child in root2_children.iter() {
+                    parent.insert(*child, root1);
+                }
+                let root1_children = children.get_mut(&root1).unwrap();
+                root1_children.extend(root2_children);
+                merge_history.push((root1, root2));
+            }
+        }
+
+        let mut clusters = HashMap::new();
+        let mut assignments = HashMap::new();
+
+        for i in 0..num_samples {
+            clusters.insert(i, vec![i]);
+            assignments.insert(i, i);
+        }
+
+        let merges_to_apply = num_samples - n_clusters;
+
+        for (root1, root2) in merge_history[0..merges_to_apply].iter() {
+            let root1_cluster = assignments[root1];
+            let root2_cluster = assignments[root2];
+
+            let root2_assignments = clusters.remove(&root2_cluster).unwrap();
+            for assignment in root2_assignments.iter() {
+                assignments.insert(*assignment, root1_cluster);
+            }
+            let root1_assignments = clusters.get_mut(&root1_cluster).unwrap();
+            root1_assignments.extend(root2_assignments);
+        }
+
+        let mut labels: Vec<usize> = (0..num_samples).map(|_| 0).collect();
+        let mut cluster_keys: Vec<&usize> = clusters.keys().collect();
+        cluster_keys.sort();
+        for (i, key) in cluster_keys.into_iter().enumerate() {
+            for index in clusters[key].iter() {
+                labels[*index] = i;
+            }
+        }
+        Ok(AgglomerativeClustering {
+            labels,
+            _phantom_tx: PhantomData,
+            _phantom_ty: PhantomData,
+            _phantom_x: PhantomData,
+            _phantom_y: PhantomData,
+        })
+    }
+}
+
+impl<TX: Number, TY: Number, X: Array2<TX>, Y: Array1<TY>>
+    UnsupervisedEstimator<X, AgglomerativeClusteringParameters>
+    for AgglomerativeClustering<TX, TY, X, Y>
+{
+    fn fit(x: &X, parameters: AgglomerativeClusteringParameters) -> Result<Self, Failed> {
+        AgglomerativeClustering::fit(x, parameters)
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use crate::linalg::basic::matrix::DenseMatrix;
+    use std::collections::HashSet;
+
+    use super::*;
+
+    #[test]
+    fn test_simple_clustering() {
+        // Two distinct clusters, far apart.
+        let data = vec![
+            0.0, 0.0, 1.0, 1.0, 0.5, 0.5, // Cluster A
+            10.0, 10.0, 11.0, 11.0, 10.5, 10.5, // Cluster B
+        ];
+        let matrix = DenseMatrix::new(6, 2, data, false).unwrap();
+        let parameters = AgglomerativeClusteringParameters::default().with_n_clusters(2);
+        // Using f64 for TY as usize doesn't satisfy the Number trait bound.
+        let clustering = AgglomerativeClustering::<f64, f64, DenseMatrix<f64>, Vec<f64>>::fit(
+            &matrix, parameters,
+        )
+        .unwrap();
+
+        let labels = clustering.labels;
+
+        // Check that all points in the first group have the same label.
+        let first_group_label = labels[0];
+        assert!(labels[0..3].iter().all(|&l| l == first_group_label));
+
+        // Check that all points in the second group have the same label.
+        let second_group_label = labels[3];
+        assert!(labels[3..6].iter().all(|&l| l == second_group_label));
+
+        // Check that the two groups have different labels.
+        assert_ne!(first_group_label, second_group_label);
+    }
+
+    #[test]
+    fn test_four_clusters() {
+        // Four distinct clusters in the corners of a square.
+        let data = vec![
+            0.0, 0.0, 1.0, 1.0, // Cluster A
+            100.0, 100.0, 101.0, 101.0, // Cluster B
+            0.0, 100.0, 1.0, 101.0, // Cluster C
+            100.0, 0.0, 101.0, 1.0, // Cluster D
+        ];
+        let matrix = DenseMatrix::new(8, 2, data, false).unwrap();
+        let parameters = AgglomerativeClusteringParameters::default().with_n_clusters(4);
+        let clustering = AgglomerativeClustering::<f64, f64, DenseMatrix<f64>, Vec<f64>>::fit(
+            &matrix, parameters,
+        )
+        .unwrap();
+
+        let labels = clustering.labels;
+
+        // Verify that there are exactly 4 unique labels produced.
+        let unique_labels: HashSet<usize> = labels.iter().cloned().collect();
+        assert_eq!(unique_labels.len(), 4);
+
+        // Verify that points within each original group were assigned the same cluster label.
+        let label_a = labels[0];
+        assert_eq!(label_a, labels[1]);
+
+        let label_b = labels[2];
+        assert_eq!(label_b, labels[3]);
+
+        let label_c = labels[4];
+        assert_eq!(label_c, labels[5]);
+
+        let label_d = labels[6];
+        assert_eq!(label_d, labels[7]);
+
+        // Verify that all four groups received different labels.
+        assert_ne!(label_a, label_b);
+        assert_ne!(label_a, label_c);
+        assert_ne!(label_a, label_d);
+        assert_ne!(label_b, label_c);
+        assert_ne!(label_b, label_d);
+        assert_ne!(label_c, label_d);
+    }
+
+    #[test]
+    fn test_n_clusters_equal_to_samples() {
+        let data = vec![0.0, 0.0, 5.0, 5.0, 10.0, 10.0];
+        let matrix = DenseMatrix::new(3, 2, data, false).unwrap();
+        let parameters = AgglomerativeClusteringParameters::default().with_n_clusters(3);
+        let clustering = AgglomerativeClustering::<f64, f64, DenseMatrix<f64>, Vec<f64>>::fit(
+            &matrix, parameters,
+        )
+        .unwrap();
+
+        // Each point should be its own cluster. Sorting makes the test deterministic.
+        let mut labels = clustering.labels;
+        labels.sort();
+        assert_eq!(labels, vec![0, 1, 2]);
+    }
+
+    #[test]
+    fn test_one_cluster() {
+        let data = vec![0.0, 0.0, 5.0, 5.0, 10.0, 10.0];
+        let matrix = DenseMatrix::new(3, 2, data, false).unwrap();
+        let parameters = AgglomerativeClusteringParameters::default().with_n_clusters(1);
+        let clustering = AgglomerativeClustering::<f64, f64, DenseMatrix<f64>, Vec<f64>>::fit(
+            &matrix, parameters,
+        )
+        .unwrap();
+
+        // All points should be in the same cluster.
+        assert_eq!(clustering.labels, vec![0, 0, 0]);
+    }
+
+    #[test]
+    fn test_error_on_too_many_clusters() {
+        let data = vec![0.0, 0.0, 5.0, 5.0];
+        let matrix = DenseMatrix::new(2, 2, data, false).unwrap();
+        let parameters = AgglomerativeClusteringParameters::default().with_n_clusters(3);
+        let result = AgglomerativeClustering::<f64, f64, DenseMatrix<f64>, Vec<f64>>::fit(
+            &matrix, parameters,
+        );
+
+        assert!(result.is_err());
+    }
+}
@@ -96,7 +96,7 @@ impl<TX: Number, TY: Number, X: Array2<TX>, Y: Array1<TY>> PartialEq for KMeans<
                    return false;
                }
                for j in 0..self.centroids[i].len() {
-                    if (self.centroids[i][j] - other.centroids[i][j]).abs() > std::f64::EPSILON {
+                    if (self.centroids[i][j] - other.centroids[i][j]).abs() > f64::EPSILON {
                        return false;
                    }
                }
@@ -270,7 +270,7 @@ impl<TX: Number, TY: Number, X: Array2<TX>, Y: Array1<TY>> KMeans<TX, TY, X, Y>

        let (n, d) = data.shape();

-        let mut distortion = std::f64::MAX;
+        let mut distortion = f64::MAX;
        let mut y = KMeans::<TX, TY, X, Y>::kmeans_plus_plus(data, parameters.k, parameters.seed);
        let mut size = vec![0; parameters.k];
        let mut centroids = vec![vec![0f64; d]; parameters.k];
@@ -331,7 +331,7 @@ impl<TX: Number, TY: Number, X: Array2<TX>, Y: Array1<TY>> KMeans<TX, TY, X, Y>
        let mut row = vec![0f64; x.shape().1];

        for i in 0..n {
-            let mut min_dist = std::f64::MAX;
+            let mut min_dist = f64::MAX;
            let mut best_cluster = 0;

            for j in 0..self.k {
@@ -361,7 +361,7 @@ impl<TX: Number, TY: Number, X: Array2<TX>, Y: Array1<TY>> KMeans<TX, TY, X, Y>
            .cloned()
            .collect();

-        let mut d = vec![std::f64::MAX; n];
+        let mut d = vec![f64::MAX; n];
        let mut row = vec![TX::zero(); data.shape().1];

        for j in 1..k {
@@ -3,6 +3,7 @@
 //! Clustering is the type of unsupervised learning where you divide the population or data points into a number of groups such that data points in the same groups
 //! are more similar to other data points in the same group than those in other groups. In simple words, the aim is to segregate groups with similar traits and assign them into clusters.

+pub mod agglomerative;
 pub mod dbscan;
 /// An iterative clustering algorithm that aims to find local maxima in each iteration.
 pub mod kmeans;
@@ -7,7 +7,6 @@
    clippy::approx_constant
 )]
 #![warn(missing_docs)]
-#![warn(rustdoc::missing_doc_code_examples)]

 //! # smartcore
 //!
@@ -265,11 +265,11 @@ pub trait ArrayView1<T: Debug + Display + Copy + Sized>: Array<T, usize> {
        if p.is_infinite() && p.is_sign_positive() {
            self.iterator(0)
                .map(|x| x.to_f64().unwrap().abs())
-                .fold(std::f64::NEG_INFINITY, |a, b| a.max(b))
+                .fold(f64::NEG_INFINITY, |a, b| a.max(b))
        } else if p.is_infinite() && p.is_sign_negative() {
            self.iterator(0)
                .map(|x| x.to_f64().unwrap().abs())
-                .fold(std::f64::INFINITY, |a, b| a.min(b))
+                .fold(f64::INFINITY, |a, b| a.min(b))
        } else {
            let mut norm = 0f64;

@@ -558,11 +558,11 @@ pub trait ArrayView2<T: Debug + Display + Copy + Sized>: Array<T, (usize, usize)
        if p.is_infinite() && p.is_sign_positive() {
            self.iterator(0)
                .map(|x| x.to_f64().unwrap().abs())
-                .fold(std::f64::NEG_INFINITY, |a, b| a.max(b))
+                .fold(f64::NEG_INFINITY, |a, b| a.max(b))
        } else if p.is_infinite() && p.is_sign_negative() {
            self.iterator(0)
                .map(|x| x.to_f64().unwrap().abs())
-                .fold(std::f64::INFINITY, |a, b| a.min(b))
+                .fold(f64::INFINITY, |a, b| a.min(b))
        } else {
            let mut norm = 0f64;

@@ -619,7 +619,7 @@ pub trait MutArrayView1<T: Debug + Display + Copy + Sized>:
        T: Number + PartialOrd,
    {
        let stack_size = 64;
-        let mut jstack = -1;
+        let mut jstack: i32 = -1;
        let mut l = 0;
        let mut istack = vec![0; stack_size];
        let mut ir = self.shape() - 1;
@@ -731,34 +731,34 @@ pub trait MutArrayView1<T: Debug + Display + Copy + Sized>:
 pub trait MutArrayView2<T: Debug + Display + Copy + Sized>:
    MutArray<T, (usize, usize)> + ArrayView2<T>
 {
-    ///
+    /// copy values from another array
    fn copy_from(&mut self, other: &dyn Array<T, (usize, usize)>) {
        self.iterator_mut(0)
            .zip(other.iterator(0))
            .for_each(|(s, o)| *s = *o);
    }
-    ///
+    /// update view with absolute values
    fn abs_mut(&mut self)
    where
        T: Number + Signed,
    {
        self.iterator_mut(0).for_each(|v| *v = v.abs());
    }
-    ///
+    /// update view values with opposite sign
    fn neg_mut(&mut self)
    where
        T: Number + Neg<Output = T>,
    {
        self.iterator_mut(0).for_each(|v| *v = -*v);
    }
-    ///
+    /// update view values at power `p`
    fn pow_mut(&mut self, p: T)
    where
        T: RealNumber,
    {
        self.iterator_mut(0).for_each(|v| *v = v.powf(p));
    }
-    ///
+    /// scale view values
    fn scale_mut(&mut self, mean: &[T], std: &[T], axis: u8)
    where
        T: Number,
@@ -784,27 +784,27 @@ pub trait MutArrayView2<T: Debug + Display + Copy + Sized>:

 /// Trait for mutable 1D-array view
 pub trait Array1<T: Debug + Display + Copy + Sized>: MutArrayView1<T> + Sized + Clone {
-    ///
+    /// return a view of the array
    fn slice<'a>(&'a self, range: Range<usize>) -> Box<dyn ArrayView1<T> + 'a>;
-    ///
+    /// return a mutable view of the array
    fn slice_mut<'a>(&'a mut self, range: Range<usize>) -> Box<dyn MutArrayView1<T> + 'a>;
-    ///
+    /// fill array with a given value
    fn fill(len: usize, value: T) -> Self
    where
        Self: Sized;
-    ///
+    /// create array from iterator
    fn from_iterator<I: Iterator<Item = T>>(iter: I, len: usize) -> Self
    where
        Self: Sized;
-    ///
+    /// create array from vector
    fn from_vec_slice(slice: &[T]) -> Self
    where
        Self: Sized;
-    ///
+    /// create array from slice
    fn from_slice(slice: &'_ dyn ArrayView1<T>) -> Self
    where
        Self: Sized;
-    ///
+    /// create a zero array
    fn zeros(len: usize) -> Self
    where
        T: Number,
@@ -812,7 +812,7 @@ pub trait Array1<T: Debug + Display + Copy + Sized>: MutArrayView1<T> + Sized +
    {
        Self::fill(len, T::zero())
    }
-    ///
+    /// create an array of ones
    fn ones(len: usize) -> Self
    where
        T: Number,
@@ -820,7 +820,7 @@ pub trait Array1<T: Debug + Display + Copy + Sized>: MutArrayView1<T> + Sized +
    {
        Self::fill(len, T::one())
    }
-    ///
+    /// create an array of random values
    fn rand(len: usize) -> Self
    where
        T: RealNumber,
@@ -828,7 +828,7 @@ pub trait Array1<T: Debug + Display + Copy + Sized>: MutArrayView1<T> + Sized +
    {
        Self::from_iterator((0..len).map(|_| T::rand()), len)
    }
-    ///
+    /// add a scalar to the array
    fn add_scalar(&self, x: T) -> Self
    where
        T: Number,
@@ -838,7 +838,7 @@ pub trait Array1<T: Debug + Display + Copy + Sized>: MutArrayView1<T> + Sized +
        result.add_scalar_mut(x);
        result
    }
-    ///
+    /// subtract a scalar from the array
    fn sub_scalar(&self, x: T) -> Self
    where
        T: Number,
@@ -848,7 +848,7 @@ pub trait Array1<T: Debug + Display + Copy + Sized>: MutArrayView1<T> + Sized +
        result.sub_scalar_mut(x);
        result
    }
-    ///
+    /// divide a scalar from the array
    fn div_scalar(&self, x: T) -> Self
    where
        T: Number,
@@ -858,7 +858,7 @@ pub trait Array1<T: Debug + Display + Copy + Sized>: MutArrayView1<T> + Sized +
        result.div_scalar_mut(x);
        result
    }
-    ///
+    /// multiply a scalar to the array
    fn mul_scalar(&self, x: T) -> Self
    where
        T: Number,
@@ -868,7 +868,7 @@ pub trait Array1<T: Debug + Display + Copy + Sized>: MutArrayView1<T> + Sized +
        result.mul_scalar_mut(x);
        result
    }
-    ///
+    /// sum of two arrays
    fn add(&self, other: &dyn Array<T, usize>) -> Self
    where
        T: Number,
@@ -878,7 +878,7 @@ pub trait Array1<T: Debug + Display + Copy + Sized>: MutArrayView1<T> + Sized +
        result.add_mut(other);
        result
    }
-    ///
+    /// subtract two arrays
    fn sub(&self, other: &impl Array1<T>) -> Self
    where
        T: Number,
@@ -888,7 +888,7 @@ pub trait Array1<T: Debug + Display + Copy + Sized>: MutArrayView1<T> + Sized +
        result.sub_mut(other);
        result
    }
-    ///
+    /// multiply two arrays
    fn mul(&self, other: &dyn Array<T, usize>) -> Self
    where
        T: Number,
@@ -898,7 +898,7 @@ pub trait Array1<T: Debug + Display + Copy + Sized>: MutArrayView1<T> + Sized +
        result.mul_mut(other);
        result
    }
-    ///
+    /// divide two arrays
    fn div(&self, other: &dyn Array<T, usize>) -> Self
    where
        T: Number,
@@ -908,7 +908,7 @@ pub trait Array1<T: Debug + Display + Copy + Sized>: MutArrayView1<T> + Sized +
        result.div_mut(other);
        result
    }
-    ///
+    /// replace values with another array
    fn take(&self, index: &[usize]) -> Self
    where
        Self: Sized,
@@ -920,7 +920,7 @@ pub trait Array1<T: Debug + Display + Copy + Sized>: MutArrayView1<T> + Sized +
        );
        Self::from_iterator(index.iter().map(move |&i| *self.get(i)), index.len())
    }
-    ///
+    /// create a view of the array with absolute values
    fn abs(&self) -> Self
    where
        T: Number + Signed,
@@ -930,7 +930,7 @@ pub trait Array1<T: Debug + Display + Copy + Sized>: MutArrayView1<T> + Sized +
        result.abs_mut();
        result
    }
-    ///
+    /// create a view of the array with opposite sign
    fn neg(&self) -> Self
    where
        T: Number + Neg<Output = T>,
@@ -940,7 +940,7 @@ pub trait Array1<T: Debug + Display + Copy + Sized>: MutArrayView1<T> + Sized +
        result.neg_mut();
        result
    }
-    ///
+    /// create a view of the array with values at power `p`
    fn pow(&self, p: T) -> Self
    where
        T: RealNumber,
@@ -950,7 +950,7 @@ pub trait Array1<T: Debug + Display + Copy + Sized>: MutArrayView1<T> + Sized +
        result.pow_mut(p);
        result
    }
-    ///
+    /// apply argsort to the array
    fn argsort(&self) -> Vec<usize>
    where
        T: Number + PartialOrd,
@@ -958,12 +958,12 @@ pub trait Array1<T: Debug + Display + Copy + Sized>: MutArrayView1<T> + Sized +
        let mut v = self.clone();
        v.argsort_mut()
    }
-    ///
+    /// map values of the array
    fn map<O: Debug + Display + Copy + Sized, A: Array1<O>, F: FnMut(&T) -> O>(self, f: F) -> A {
        let len = self.shape();
        A::from_iterator(self.iterator(0).map(f), len)
    }
-    ///
+    /// apply softmax to the array
    fn softmax(&self) -> Self
    where
        T: RealNumber,
@@ -973,7 +973,7 @@ pub trait Array1<T: Debug + Display + Copy + Sized>: MutArrayView1<T> + Sized +
        result.softmax_mut();
        result
    }
-    ///
+    /// multiply array by matrix
    fn xa(&self, a_transpose: bool, a: &dyn ArrayView2<T>) -> Self
    where
        T: Number,
@@ -1003,7 +1003,7 @@ pub trait Array1<T: Debug + Display + Copy + Sized>: MutArrayView1<T> + Sized +
        result
    }

-    ///
+    /// check if two arrays are approximately equal
    fn approximate_eq(&self, other: &Self, error: T) -> bool
    where
        T: Number + RealNumber,
@@ -1015,13 +1015,13 @@ pub trait Array1<T: Debug + Display + Copy + Sized>: MutArrayView1<T> + Sized +

 /// Trait for mutable 2D-array view
 pub trait Array2<T: Debug + Display + Copy + Sized>: MutArrayView2<T> + Sized + Clone {
-    ///
+    /// fill 2d array with a given value
    fn fill(nrows: usize, ncols: usize, value: T) -> Self;
-    ///
+    /// get a view of the 2d array
    fn slice<'a>(&'a self, rows: Range<usize>, cols: Range<usize>) -> Box<dyn ArrayView2<T> + 'a>
    where
        Self: Sized;
-    ///
+    /// get a mutable view of the 2d array
    fn slice_mut<'a>(
        &'a mut self,
        rows: Range<usize>,
@@ -1029,31 +1029,31 @@ pub trait Array2<T: Debug + Display + Copy + Sized>: MutArrayView2<T> + Sized +
    ) -> Box<dyn MutArrayView2<T> + 'a>
    where
        Self: Sized;
-    ///
+    /// create 2d array from iterator
    fn from_iterator<I: Iterator<Item = T>>(iter: I, nrows: usize, ncols: usize, axis: u8) -> Self;
-    ///
+    /// get row from 2d array
    fn get_row<'a>(&'a self, row: usize) -> Box<dyn ArrayView1<T> + 'a>
    where
        Self: Sized;
-    ///
+    /// get column from 2d array
    fn get_col<'a>(&'a self, col: usize) -> Box<dyn ArrayView1<T> + 'a>
    where
        Self: Sized;
-    ///
+    /// create a zero 2d array
    fn zeros(nrows: usize, ncols: usize) -> Self
    where
        T: Number,
    {
        Self::fill(nrows, ncols, T::zero())
    }
-    ///
+    /// create a 2d array of ones
    fn ones(nrows: usize, ncols: usize) -> Self
    where
        T: Number,
    {
        Self::fill(nrows, ncols, T::one())
    }
-    ///
+    /// create an identity matrix
    fn eye(size: usize) -> Self
    where
        T: Number,
@@ -1066,29 +1066,29 @@ pub trait Array2<T: Debug + Display + Copy + Sized>: MutArrayView2<T> + Sized +

        matrix
    }
-    ///
+    /// create a 2d array of random values
    fn rand(nrows: usize, ncols: usize) -> Self
    where
        T: RealNumber,
    {
        Self::from_iterator((0..nrows * ncols).map(|_| T::rand()), nrows, ncols, 0)
    }
-    ///
+    /// crate from 2d slice
    fn from_slice(slice: &dyn ArrayView2<T>) -> Self {
        let (nrows, ncols) = slice.shape();
        Self::from_iterator(slice.iterator(0).cloned(), nrows, ncols, 0)
    }
-    ///
+    /// create from row
    fn from_row(slice: &dyn ArrayView1<T>) -> Self {
        let ncols = slice.shape();
        Self::from_iterator(slice.iterator(0).cloned(), 1, ncols, 0)
    }
-    ///
+    /// create from column
    fn from_column(slice: &dyn ArrayView1<T>) -> Self {
        let nrows = slice.shape();
        Self::from_iterator(slice.iterator(0).cloned(), nrows, 1, 0)
    }
-    ///
+    /// transpose 2d array
    fn transpose(&self) -> Self {
        let (nrows, ncols) = self.shape();
        let mut m = Self::fill(ncols, nrows, *self.get((0, 0)));
@@ -1099,7 +1099,7 @@ pub trait Array2<T: Debug + Display + Copy + Sized>: MutArrayView2<T> + Sized +
        }
        m
    }
-    ///
+    /// change shape of 2d array
    fn reshape(&self, nrows: usize, ncols: usize, axis: u8) -> Self {
        let (onrows, oncols) = self.shape();

@@ -1110,7 +1110,7 @@ pub trait Array2<T: Debug + Display + Copy + Sized>: MutArrayView2<T> + Sized +

        Self::from_iterator(self.iterator(0).cloned(), nrows, ncols, axis)
    }
-    ///
+    /// multiply two 2d arrays
    fn matmul(&self, other: &dyn ArrayView2<T>) -> Self
    where
        T: Number,
@@ -1136,7 +1136,7 @@ pub trait Array2<T: Debug + Display + Copy + Sized>: MutArrayView2<T> + Sized +

        result
    }
-    ///
+    /// matrix multiplication
    fn ab(&self, a_transpose: bool, b: &dyn ArrayView2<T>, b_transpose: bool) -> Self
    where
        T: Number,
@@ -1171,7 +1171,7 @@ pub trait Array2<T: Debug + Display + Copy + Sized>: MutArrayView2<T> + Sized +
            result
        }
    }
-    ///
+    /// matrix vector multiplication
    fn ax(&self, a_transpose: bool, x: &dyn ArrayView1<T>) -> Self
    where
        T: Number,
@@ -1199,7 +1199,7 @@ pub trait Array2<T: Debug + Display + Copy + Sized>: MutArrayView2<T> + Sized +
        }
        result
    }
-    ///
+    /// concatenate 1d array
    fn concatenate_1d<'a>(arrays: &'a [&'a dyn ArrayView1<T>], axis: u8) -> Self {
        assert!(
            axis == 1 || axis == 0,
@@ -1237,7 +1237,7 @@ pub trait Array2<T: Debug + Display + Copy + Sized>: MutArrayView2<T> + Sized +
            ),
        }
    }
-    ///
+    /// concatenate 2d array
    fn concatenate_2d<'a>(arrays: &'a [&'a dyn ArrayView2<T>], axis: u8) -> Self {
        assert!(
            axis == 1 || axis == 0,
@@ -1294,7 +1294,7 @@ pub trait Array2<T: Debug + Display + Copy + Sized>: MutArrayView2<T> + Sized +
            }
        }
    }
-    ///
+    /// merge 1d arrays
    fn merge_1d<'a>(&'a self, arrays: &'a [&'a dyn ArrayView1<T>], axis: u8, append: bool) -> Self {
        assert!(
            axis == 1 || axis == 0,
@@ -1362,7 +1362,7 @@ pub trait Array2<T: Debug + Display + Copy + Sized>: MutArrayView2<T> + Sized +
            }
        }
    }
-    ///
+    /// Stack arrays in sequence vertically
    fn v_stack(&self, other: &dyn ArrayView2<T>) -> Self {
        let (nrows, ncols) = self.shape();
        let (other_nrows, other_ncols) = other.shape();
@@ -1378,7 +1378,7 @@ pub trait Array2<T: Debug + Display + Copy + Sized>: MutArrayView2<T> + Sized +
            0,
        )
    }
-    ///
+    /// Stack arrays in sequence horizontally
    fn h_stack(&self, other: &dyn ArrayView2<T>) -> Self {
        let (nrows, ncols) = self.shape();
        let (other_nrows, other_ncols) = other.shape();
@@ -1394,20 +1394,20 @@ pub trait Array2<T: Debug + Display + Copy + Sized>: MutArrayView2<T> + Sized +
            1,
        )
    }
-    ///
+    /// map  array values
    fn map<O: Debug + Display + Copy + Sized, A: Array2<O>, F: FnMut(&T) -> O>(self, f: F) -> A {
        let (nrows, ncols) = self.shape();
        A::from_iterator(self.iterator(0).map(f), nrows, ncols, 0)
    }
-    ///
+    /// iter rows
    fn row_iter<'a>(&'a self) -> Box<dyn Iterator<Item = Box<dyn ArrayView1<T> + 'a>> + 'a> {
        Box::new((0..self.shape().0).map(move |r| self.get_row(r)))
    }
-    ///
+    /// iter cols
    fn col_iter<'a>(&'a self) -> Box<dyn Iterator<Item = Box<dyn ArrayView1<T> + 'a>> + 'a> {
        Box::new((0..self.shape().1).map(move |r| self.get_col(r)))
    }
-    ///
+    /// take elements from 2d array
    fn take(&self, index: &[usize], axis: u8) -> Self {
        let (nrows, ncols) = self.shape();

@@ -1447,7 +1447,7 @@ pub trait Array2<T: Debug + Display + Copy + Sized>: MutArrayView2<T> + Sized +
    fn take_column(&self, column_index: usize) -> Self {
        self.take(&[column_index], 1)
    }
-    ///
+    /// add a scalar to the array
    fn add_scalar(&self, x: T) -> Self
    where
        T: Number,
@@ -1456,7 +1456,7 @@ pub trait Array2<T: Debug + Display + Copy + Sized>: MutArrayView2<T> + Sized +
        result.add_scalar_mut(x);
        result
    }
-    ///
+    /// subtract a scalar from the array
    fn sub_scalar(&self, x: T) -> Self
    where
        T: Number,
@@ -1465,7 +1465,7 @@ pub trait Array2<T: Debug + Display + Copy + Sized>: MutArrayView2<T> + Sized +
        result.sub_scalar_mut(x);
        result
    }
-    ///
+    /// divide a scalar from the array
    fn div_scalar(&self, x: T) -> Self
    where
        T: Number,
@@ -1474,7 +1474,7 @@ pub trait Array2<T: Debug + Display + Copy + Sized>: MutArrayView2<T> + Sized +
        result.div_scalar_mut(x);
        result
    }
-    ///
+    /// multiply a scalar to the array
    fn mul_scalar(&self, x: T) -> Self
    where
        T: Number,
@@ -1483,7 +1483,7 @@ pub trait Array2<T: Debug + Display + Copy + Sized>: MutArrayView2<T> + Sized +
        result.mul_scalar_mut(x);
        result
    }
-    ///
+    /// sum of two arrays
    fn add(&self, other: &dyn Array<T, (usize, usize)>) -> Self
    where
        T: Number,
@@ -1492,7 +1492,7 @@ pub trait Array2<T: Debug + Display + Copy + Sized>: MutArrayView2<T> + Sized +
        result.add_mut(other);
        result
    }
-    ///
+    /// subtract two arrays
    fn sub(&self, other: &dyn Array<T, (usize, usize)>) -> Self
    where
        T: Number,
@@ -1501,7 +1501,7 @@ pub trait Array2<T: Debug + Display + Copy + Sized>: MutArrayView2<T> + Sized +
        result.sub_mut(other);
        result
    }
-    ///
+    /// multiply two arrays
    fn mul(&self, other: &dyn Array<T, (usize, usize)>) -> Self
    where
        T: Number,
@@ -1510,7 +1510,7 @@ pub trait Array2<T: Debug + Display + Copy + Sized>: MutArrayView2<T> + Sized +
        result.mul_mut(other);
        result
    }
-    ///
+    /// divide two arrays
    fn div(&self, other: &dyn Array<T, (usize, usize)>) -> Self
    where
        T: Number,
@@ -1519,7 +1519,7 @@ pub trait Array2<T: Debug + Display + Copy + Sized>: MutArrayView2<T> + Sized +
        result.div_mut(other);
        result
    }
-    ///
+    /// absolute values of the array
    fn abs(&self) -> Self
    where
        T: Number + Signed,
@@ -1528,7 +1528,7 @@ pub trait Array2<T: Debug + Display + Copy + Sized>: MutArrayView2<T> + Sized +
        result.abs_mut();
        result
    }
-    ///
+    /// negation of the array
    fn neg(&self) -> Self
    where
        T: Number + Neg<Output = T>,
@@ -1537,7 +1537,7 @@ pub trait Array2<T: Debug + Display + Copy + Sized>: MutArrayView2<T> + Sized +
        result.neg_mut();
        result
    }
-    ///
+    /// values at power `p`
    fn pow(&self, p: T) -> Self
    where
        T: RealNumber,
@@ -1575,7 +1575,7 @@ pub trait Array2<T: Debug + Display + Copy + Sized>: MutArrayView2<T> + Sized +
        }
    }

-    /// appriximate equality of the elements of a matrix according to a given error
+    /// approximate equality of the elements of a matrix according to a given error
    fn approximate_eq(&self, other: &Self, error: T) -> bool
    where
        T: Number + RealNumber,
@@ -1631,8 +1631,8 @@ mod tests {
        let v = vec![3., -2., 6.];
        assert_eq!(v.norm(1.), 11.);
        assert_eq!(v.norm(2.), 7.);
-        assert_eq!(v.norm(std::f64::INFINITY), 6.);
-        assert_eq!(v.norm(std::f64::NEG_INFINITY), 2.);
+        assert_eq!(v.norm(f64::INFINITY), 6.);
+        assert_eq!(v.norm(f64::NEG_INFINITY), 2.);
    }

    #[test]
@@ -2190,4 +2190,29 @@ mod tests {

        assert_eq!(result, [65, 581, 30])
    }
+
+    #[test]
+    fn test_argsort_mut_exact_boundary() {
+        // Test index == length - 1 case
+        let boundary =
+            DenseMatrix::from_2d_array(&[&[1.0, 2.0, 3.0, f64::MAX], &[3.0, f64::MAX, 0.0, 2.0]])
+                .unwrap();
+        let mut view0: Vec<f64> = boundary.get_col(0).iterator(0).copied().collect();
+        let indices = view0.argsort_mut();
+        assert_eq!(indices.last(), Some(&1));
+        assert_eq!(indices.first(), Some(&0));
+
+        let mut view1: Vec<f64> = boundary.get_col(3).iterator(0).copied().collect();
+        let indices = view1.argsort_mut();
+        assert_eq!(indices.last(), Some(&0));
+        assert_eq!(indices.first(), Some(&1));
+    }
+
+    #[test]
+    fn test_argsort_mut_filled_array() {
+        let matrix = DenseMatrix::<f64>::rand(1000, 1000);
+        let mut view: Vec<f64> = matrix.get_col(0).iterator(0).copied().collect();
+        let sorted = view.argsort_mut();
+        assert_eq!(sorted.len(), 1000);
+    }
 }
@@ -91,7 +91,7 @@ impl<'a, T: Debug + Display + Copy + Sized> DenseMatrixView<'a, T> {
    }
 }

-impl<'a, T: Debug + Display + Copy + Sized> fmt::Display for DenseMatrixView<'a, T> {
+impl<T: Debug + Display + Copy + Sized> fmt::Display for DenseMatrixView<'_, T> {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        writeln!(
            f,
@@ -142,7 +142,7 @@ impl<'a, T: Debug + Display + Copy + Sized> DenseMatrixMutView<'a, T> {
        }
    }

-    fn iter_mut<'b>(&'b mut self, axis: u8) -> Box<dyn Iterator<Item = &mut T> + 'b> {
+    fn iter_mut<'b>(&'b mut self, axis: u8) -> Box<dyn Iterator<Item = &'b mut T> + 'b> {
        let column_major = self.column_major;
        let stride = self.stride;
        let ptr = self.values.as_mut_ptr();
@@ -169,7 +169,7 @@ impl<'a, T: Debug + Display + Copy + Sized> DenseMatrixMutView<'a, T> {
    }
 }

-impl<'a, T: Debug + Display + Copy + Sized> fmt::Display for DenseMatrixMutView<'a, T> {
+impl<T: Debug + Display + Copy + Sized> fmt::Display for DenseMatrixMutView<'_, T> {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        writeln!(
            f,
@@ -493,7 +493,7 @@ impl<T: Number + RealNumber> EVDDecomposable<T> for DenseMatrix<T> {}
 impl<T: Number + RealNumber> LUDecomposable<T> for DenseMatrix<T> {}
 impl<T: Number + RealNumber> SVDDecomposable<T> for DenseMatrix<T> {}

-impl<'a, T: Debug + Display + Copy + Sized> Array<T, (usize, usize)> for DenseMatrixView<'a, T> {
+impl<T: Debug + Display + Copy + Sized> Array<T, (usize, usize)> for DenseMatrixView<'_, T> {
    fn get(&self, pos: (usize, usize)) -> &T {
        if self.column_major {
            &self.values[pos.0 + pos.1 * self.stride]
@@ -515,7 +515,7 @@ impl<'a, T: Debug + Display + Copy + Sized> Array<T, (usize, usize)> for DenseMa
    }
 }

-impl<'a, T: Debug + Display + Copy + Sized> Array<T, usize> for DenseMatrixView<'a, T> {
+impl<T: Debug + Display + Copy + Sized> Array<T, usize> for DenseMatrixView<'_, T> {
    fn get(&self, i: usize) -> &T {
        if self.nrows == 1 {
            if self.column_major {
@@ -553,11 +553,11 @@ impl<'a, T: Debug + Display + Copy + Sized> Array<T, usize> for DenseMatrixView<
    }
 }

-impl<'a, T: Debug + Display + Copy + Sized> ArrayView2<T> for DenseMatrixView<'a, T> {}
+impl<T: Debug + Display + Copy + Sized> ArrayView2<T> for DenseMatrixView<'_, T> {}

-impl<'a, T: Debug + Display + Copy + Sized> ArrayView1<T> for DenseMatrixView<'a, T> {}
+impl<T: Debug + Display + Copy + Sized> ArrayView1<T> for DenseMatrixView<'_, T> {}

-impl<'a, T: Debug + Display + Copy + Sized> Array<T, (usize, usize)> for DenseMatrixMutView<'a, T> {
+impl<T: Debug + Display + Copy + Sized> Array<T, (usize, usize)> for DenseMatrixMutView<'_, T> {
    fn get(&self, pos: (usize, usize)) -> &T {
        if self.column_major {
            &self.values[pos.0 + pos.1 * self.stride]
@@ -579,9 +579,7 @@ impl<'a, T: Debug + Display + Copy + Sized> Array<T, (usize, usize)> for DenseMa
    }
 }

-impl<'a, T: Debug + Display + Copy + Sized> MutArray<T, (usize, usize)>
-    for DenseMatrixMutView<'a, T>
-{
+impl<T: Debug + Display + Copy + Sized> MutArray<T, (usize, usize)> for DenseMatrixMutView<'_, T> {
    fn set(&mut self, pos: (usize, usize), x: T) {
        if self.column_major {
            self.values[pos.0 + pos.1 * self.stride] = x;
@@ -595,15 +593,16 @@ impl<'a, T: Debug + Display + Copy + Sized> MutArray<T, (usize, usize)>
    }
 }

-impl<'a, T: Debug + Display + Copy + Sized> MutArrayView2<T> for DenseMatrixMutView<'a, T> {}
+impl<T: Debug + Display + Copy + Sized> MutArrayView2<T> for DenseMatrixMutView<'_, T> {}

-impl<'a, T: Debug + Display + Copy + Sized> ArrayView2<T> for DenseMatrixMutView<'a, T> {}
+impl<T: Debug + Display + Copy + Sized> ArrayView2<T> for DenseMatrixMutView<'_, T> {}

 impl<T: RealNumber> MatrixStats<T> for DenseMatrix<T> {}

 impl<T: RealNumber> MatrixPreprocessing<T> for DenseMatrix<T> {}

 #[cfg(test)]
+#[warn(clippy::reversed_empty_ranges)]
 mod tests {
    use super::*;
    use approx::relative_eq;
@@ -664,6 +663,7 @@ mod tests {
    #[test]
    fn test_instantiate_err_view3() {
        let x = DenseMatrix::from_2d_array(&[&[1., 2., 3.], &[4., 5., 6.], &[7., 8., 9.]]).unwrap();
+        #[allow(clippy::reversed_empty_ranges)]
        let v = DenseMatrixView::new(&x, 0..3, 4..3);
        assert!(v.is_err());
    }
@@ -119,7 +119,7 @@ impl<T: Debug + Display + Copy + Sized> Array1<T> for Vec<T> {
    }
 }

-impl<'a, T: Debug + Display + Copy + Sized> Array<T, usize> for VecMutView<'a, T> {
+impl<T: Debug + Display + Copy + Sized> Array<T, usize> for VecMutView<'_, T> {
    fn get(&self, i: usize) -> &T {
        &self.ptr[i]
    }
@@ -138,7 +138,7 @@ impl<'a, T: Debug + Display + Copy + Sized> Array<T, usize> for VecMutView<'a, T
    }
 }

-impl<'a, T: Debug + Display + Copy + Sized> MutArray<T, usize> for VecMutView<'a, T> {
+impl<T: Debug + Display + Copy + Sized> MutArray<T, usize> for VecMutView<'_, T> {
    fn set(&mut self, i: usize, x: T) {
        self.ptr[i] = x;
    }
@@ -149,10 +149,10 @@ impl<'a, T: Debug + Display + Copy + Sized> MutArray<T, usize> for VecMutView<'a
    }
 }

-impl<'a, T: Debug + Display + Copy + Sized> ArrayView1<T> for VecMutView<'a, T> {}
-impl<'a, T: Debug + Display + Copy + Sized> MutArrayView1<T> for VecMutView<'a, T> {}
+impl<T: Debug + Display + Copy + Sized> ArrayView1<T> for VecMutView<'_, T> {}
+impl<T: Debug + Display + Copy + Sized> MutArrayView1<T> for VecMutView<'_, T> {}

-impl<'a, T: Debug + Display + Copy + Sized> Array<T, usize> for VecView<'a, T> {
+impl<T: Debug + Display + Copy + Sized> Array<T, usize> for VecView<'_, T> {
    fn get(&self, i: usize) -> &T {
        &self.ptr[i]
    }
@@ -171,7 +171,7 @@ impl<'a, T: Debug + Display + Copy + Sized> Array<T, usize> for VecView<'a, T> {
    }
 }

-impl<'a, T: Debug + Display + Copy + Sized> ArrayView1<T> for VecView<'a, T> {}
+impl<T: Debug + Display + Copy + Sized> ArrayView1<T> for VecView<'_, T> {}

 #[cfg(test)]
 mod tests {
@@ -68,7 +68,7 @@ impl<T: Debug + Display + Copy + Sized> ArrayView2<T> for ArrayBase<OwnedRepr<T>

 impl<T: Debug + Display + Copy + Sized> MutArrayView2<T> for ArrayBase<OwnedRepr<T>, Ix2> {}

-impl<'a, T: Debug + Display + Copy + Sized> BaseArray<T, (usize, usize)> for ArrayView<'a, T, Ix2> {
+impl<T: Debug + Display + Copy + Sized> BaseArray<T, (usize, usize)> for ArrayView<'_, T, Ix2> {
    fn get(&self, pos: (usize, usize)) -> &T {
        &self[[pos.0, pos.1]]
    }
@@ -144,11 +144,9 @@ impl<T: Number + RealNumber> EVDDecomposable<T> for ArrayBase<OwnedRepr<T>, Ix2>
 impl<T: Number + RealNumber> LUDecomposable<T> for ArrayBase<OwnedRepr<T>, Ix2> {}
 impl<T: Number + RealNumber> SVDDecomposable<T> for ArrayBase<OwnedRepr<T>, Ix2> {}

-impl<'a, T: Debug + Display + Copy + Sized> ArrayView2<T> for ArrayView<'a, T, Ix2> {}
+impl<T: Debug + Display + Copy + Sized> ArrayView2<T> for ArrayView<'_, T, Ix2> {}

-impl<'a, T: Debug + Display + Copy + Sized> BaseArray<T, (usize, usize)>
-    for ArrayViewMut<'a, T, Ix2>
-{
+impl<T: Debug + Display + Copy + Sized> BaseArray<T, (usize, usize)> for ArrayViewMut<'_, T, Ix2> {
    fn get(&self, pos: (usize, usize)) -> &T {
        &self[[pos.0, pos.1]]
    }
@@ -175,9 +173,7 @@ impl<'a, T: Debug + Display + Copy + Sized> BaseArray<T, (usize, usize)>
    }
 }

-impl<'a, T: Debug + Display + Copy + Sized> MutArray<T, (usize, usize)>
-    for ArrayViewMut<'a, T, Ix2>
-{
+impl<T: Debug + Display + Copy + Sized> MutArray<T, (usize, usize)> for ArrayViewMut<'_, T, Ix2> {
    fn set(&mut self, pos: (usize, usize), x: T) {
        self[[pos.0, pos.1]] = x
    }
@@ -195,9 +191,9 @@ impl<'a, T: Debug + Display + Copy + Sized> MutArray<T, (usize, usize)>
    }
 }

-impl<'a, T: Debug + Display + Copy + Sized> MutArrayView2<T> for ArrayViewMut<'a, T, Ix2> {}
+impl<T: Debug + Display + Copy + Sized> MutArrayView2<T> for ArrayViewMut<'_, T, Ix2> {}

-impl<'a, T: Debug + Display + Copy + Sized> ArrayView2<T> for ArrayViewMut<'a, T, Ix2> {}
+impl<T: Debug + Display + Copy + Sized> ArrayView2<T> for ArrayViewMut<'_, T, Ix2> {}

 #[cfg(test)]
 mod tests {
@@ -41,7 +41,7 @@ impl<T: Debug + Display + Copy + Sized> ArrayView1<T> for ArrayBase<OwnedRepr<T>

 impl<T: Debug + Display + Copy + Sized> MutArrayView1<T> for ArrayBase<OwnedRepr<T>, Ix1> {}

-impl<'a, T: Debug + Display + Copy + Sized> BaseArray<T, usize> for ArrayView<'a, T, Ix1> {
+impl<T: Debug + Display + Copy + Sized> BaseArray<T, usize> for ArrayView<'_, T, Ix1> {
    fn get(&self, i: usize) -> &T {
        &self[i]
    }
@@ -60,9 +60,9 @@ impl<'a, T: Debug + Display + Copy + Sized> BaseArray<T, usize> for ArrayView<'a
    }
 }

-impl<'a, T: Debug + Display + Copy + Sized> ArrayView1<T> for ArrayView<'a, T, Ix1> {}
+impl<T: Debug + Display + Copy + Sized> ArrayView1<T> for ArrayView<'_, T, Ix1> {}

-impl<'a, T: Debug + Display + Copy + Sized> BaseArray<T, usize> for ArrayViewMut<'a, T, Ix1> {
+impl<T: Debug + Display + Copy + Sized> BaseArray<T, usize> for ArrayViewMut<'_, T, Ix1> {
    fn get(&self, i: usize) -> &T {
        &self[i]
    }
@@ -81,7 +81,7 @@ impl<'a, T: Debug + Display + Copy + Sized> BaseArray<T, usize> for ArrayViewMut
    }
 }

-impl<'a, T: Debug + Display + Copy + Sized> MutArray<T, usize> for ArrayViewMut<'a, T, Ix1> {
+impl<T: Debug + Display + Copy + Sized> MutArray<T, usize> for ArrayViewMut<'_, T, Ix1> {
    fn set(&mut self, i: usize, x: T) {
        self[i] = x;
    }
@@ -92,8 +92,8 @@ impl<'a, T: Debug + Display + Copy + Sized> MutArray<T, usize> for ArrayViewMut<
    }
 }

-impl<'a, T: Debug + Display + Copy + Sized> ArrayView1<T> for ArrayViewMut<'a, T, Ix1> {}
-impl<'a, T: Debug + Display + Copy + Sized> MutArrayView1<T> for ArrayViewMut<'a, T, Ix1> {}
+impl<T: Debug + Display + Copy + Sized> ArrayView1<T> for ArrayViewMut<'_, T, Ix1> {}
+impl<T: Debug + Display + Copy + Sized> MutArrayView1<T> for ArrayViewMut<'_, T, Ix1> {}

 impl<T: Debug + Display + Copy + Sized> Array1<T> for ArrayBase<OwnedRepr<T>, Ix1> {
    fn slice<'a>(&'a self, range: Range<usize>) -> Box<dyn ArrayView1<T> + 'a> {
@@ -841,7 +841,7 @@ mod tests {
        ));
        for (i, eigen_values_i) in eigen_values.iter().enumerate() {
            assert!((eigen_values_i - evd.d[i]).abs() < 1e-4);
-            assert!((0f64 - evd.e[i]).abs() < std::f64::EPSILON);
+            assert!((0f64 - evd.e[i]).abs() < f64::EPSILON);
        }
    }
    #[cfg_attr(
@@ -875,7 +875,7 @@ mod tests {
        ));
        for (i, eigen_values_i) in eigen_values.iter().enumerate() {
            assert!((eigen_values_i - evd.d[i]).abs() < 1e-4);
-            assert!((0f64 - evd.e[i]).abs() < std::f64::EPSILON);
+            assert!((0f64 - evd.e[i]).abs() < f64::EPSILON);
        }
    }
    #[cfg_attr(
@@ -142,7 +142,6 @@ pub trait MatrixPreprocessing<T: RealNumber>: MutArrayView2<T> + Clone {
    ///
    /// assert_eq!(a, expected);
    /// ```
-
    fn binarize_mut(&mut self, threshold: T) {
        let (nrows, ncols) = self.shape();
        for row in 0..nrows {
@@ -217,8 +216,8 @@ mod tests {
        let expected_0 = vec![0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0];
        let expected_1 = vec![1.25, 1.25];

-        assert!(m.var(0).approximate_eq(&expected_0, std::f64::EPSILON));
-        assert!(m.var(1).approximate_eq(&expected_1, std::f64::EPSILON));
+        assert!(m.var(0).approximate_eq(&expected_0, f64::EPSILON));
+        assert!(m.var(1).approximate_eq(&expected_1, f64::EPSILON));
        assert_eq!(
            m.mean(0),
            vec![0.0, 0.25, 0.25, 1.25, 1.5, 1.75, 2.75, 3.25]
@@ -48,11 +48,9 @@ pub struct SVD<T: Number + RealNumber, M: SVDDecomposable<T>> {
    pub V: M,
    /// Singular values of the original matrix
    pub s: Vec<T>,
-    ///
    m: usize,
-    ///
    n: usize,
-    ///
+    /// Tolerance
    tol: T,
 }

@@ -27,9 +27,9 @@ use crate::error::Failed;
 use crate::linalg::basic::arrays::{Array, Array1, Array2, ArrayView1, MutArrayView1};
 use crate::numbers::floatnum::FloatNumber;

-///
+/// Trait for Biconjugate Gradient Solver
 pub trait BiconjugateGradientSolver<'a, T: FloatNumber, X: Array2<T>> {
-    ///
+    /// Solve Ax = b
    fn solve_mut(
        &self,
        a: &'a X,
@@ -109,7 +109,7 @@ pub trait BiconjugateGradientSolver<'a, T: FloatNumber, X: Array2<T>> {
        Ok(err)
    }

-    ///
+    /// solve preconditioner
    fn solve_preconditioner(&self, a: &'a X, b: &[T], x: &mut [T]) {
        let diag = Self::diag(a);
        let n = diag.len();
@@ -133,7 +133,7 @@ pub trait BiconjugateGradientSolver<'a, T: FloatNumber, X: Array2<T>> {
        y.copy_from(&x.xa(true, a));
    }

-    ///
+    /// Extract the diagonal from a matrix
    fn diag(a: &X) -> Vec<T> {
        let (nrows, ncols) = a.shape();
        let n = nrows.min(ncols);
@@ -16,7 +16,7 @@ use crate::linalg::basic::arrays::{Array1, Array2, ArrayView1, MutArray, MutArra
 use crate::linear::bg_solver::BiconjugateGradientSolver;
 use crate::numbers::floatnum::FloatNumber;

-///
+/// Interior Point Optimizer
 pub struct InteriorPointOptimizer<T: FloatNumber, X: Array2<T>> {
    ata: X,
    d1: Vec<T>,
@@ -25,9 +25,8 @@ pub struct InteriorPointOptimizer<T: FloatNumber, X: Array2<T>> {
    prs: Vec<T>,
 }

-///
 impl<T: FloatNumber, X: Array2<T>> InteriorPointOptimizer<T, X> {
-    ///
+    /// Initialize a new Interior Point Optimizer
    pub fn new(a: &X, n: usize) -> InteriorPointOptimizer<T, X> {
        InteriorPointOptimizer {
            ata: a.ab(true, a, false),
@@ -38,7 +37,7 @@ impl<T: FloatNumber, X: Array2<T>> InteriorPointOptimizer<T, X> {
        }
    }

-    ///
+    /// Run the optimization
    pub fn optimize(
        &mut self,
        x: &X,
@@ -101,7 +100,7 @@ impl<T: FloatNumber, X: Array2<T>> InteriorPointOptimizer<T, X> {

            // CALCULATE DUALITY GAP
            let xnu = nu.xa(false, x);
-            let max_xnu = xnu.norm(std::f64::INFINITY);
+            let max_xnu = xnu.norm(f64::INFINITY);
            if max_xnu > lambda_f64 {
                let lnu = T::from_f64(lambda_f64 / max_xnu).unwrap();
                nu.mul_scalar_mut(lnu);
@@ -208,7 +207,6 @@ impl<T: FloatNumber, X: Array2<T>> InteriorPointOptimizer<T, X> {
        Ok(w)
    }

-    ///
    fn sumlogneg(f: &X) -> T {
        let (n, _) = f.shape();
        let mut sum = T::zero();
@@ -220,11 +218,9 @@ impl<T: FloatNumber, X: Array2<T>> InteriorPointOptimizer<T, X> {
    }
 }

-///
 impl<'a, T: FloatNumber, X: Array2<T>> BiconjugateGradientSolver<'a, T, X>
    for InteriorPointOptimizer<T, X>
 {
-    ///
    fn solve_preconditioner(&self, a: &'a X, b: &[T], x: &mut [T]) {
        let (_, p) = a.shape();

@@ -234,7 +230,6 @@ impl<'a, T: FloatNumber, X: Array2<T>> BiconjugateGradientSolver<'a, T, X>
        }
    }

-    ///
    fn mat_vec_mul(&self, _: &X, x: &Vec<T>, y: &mut Vec<T>) {
        let (_, p) = self.ata.shape();
        let x_slice = Vec::from_slice(x.slice(0..p).as_ref());
@@ -246,7 +241,6 @@ impl<'a, T: FloatNumber, X: Array2<T>> BiconjugateGradientSolver<'a, T, X>
        }
    }

-    ///
    fn mat_t_vec_mul(&self, a: &X, x: &Vec<T>, y: &mut Vec<T>) {
        self.mat_vec_mul(a, x, y);
    }
@@ -183,14 +183,11 @@ pub struct LogisticRegression<
 }

 trait ObjectiveFunction<T: Number + FloatNumber, X: Array2<T>> {
-    ///
    fn f(&self, w_bias: &[T]) -> T;

-    ///
    #[allow(clippy::ptr_arg)]
    fn df(&self, g: &mut Vec<T>, w_bias: &Vec<T>);

-    ///
    #[allow(clippy::ptr_arg)]
    fn partial_dot(w: &[T], x: &X, v_col: usize, m_row: usize) -> T {
        let mut sum = T::zero();
@@ -261,8 +258,8 @@ impl<TX: Number + FloatNumber + RealNumber, TY: Number + Ord, X: Array2<TX>, Y:
    }
 }

-impl<'a, T: Number + FloatNumber, X: Array2<T>> ObjectiveFunction<T, X>
-    for BinaryObjectiveFunction<'a, T, X>
+impl<T: Number + FloatNumber, X: Array2<T>> ObjectiveFunction<T, X>
+    for BinaryObjectiveFunction<'_, T, X>
 {
    fn f(&self, w_bias: &[T]) -> T {
        let mut f = T::zero();
@@ -316,8 +313,8 @@ struct MultiClassObjectiveFunction<'a, T: Number + FloatNumber, X: Array2<T>> {
    _phantom_t: PhantomData<T>,
 }

-impl<'a, T: Number + FloatNumber + RealNumber, X: Array2<T>> ObjectiveFunction<T, X>
-    for MultiClassObjectiveFunction<'a, T, X>
+impl<T: Number + FloatNumber + RealNumber, X: Array2<T>> ObjectiveFunction<T, X>
+    for MultiClassObjectiveFunction<'_, T, X>
 {
    fn f(&self, w_bias: &[T]) -> T {
        let mut f = T::zero();
@@ -629,11 +626,11 @@ mod tests {
        objective.df(&mut g, &vec![1., 2., 3., 4., 5., 6., 7., 8., 9.]);
        objective.df(&mut g, &vec![1., 2., 3., 4., 5., 6., 7., 8., 9.]);

-        assert!((g[0] + 33.000068218163484).abs() < std::f64::EPSILON);
+        assert!((g[0] + 33.000068218163484).abs() < f64::EPSILON);

        let f = objective.f(&[1., 2., 3., 4., 5., 6., 7., 8., 9.]);

-        assert!((f - 408.0052230582765).abs() < std::f64::EPSILON);
+        assert!((f - 408.0052230582765).abs() < f64::EPSILON);

        let objective_reg = MultiClassObjectiveFunction {
            x: &x,
@@ -689,13 +686,13 @@ mod tests {
        objective.df(&mut g, &vec![1., 2., 3.]);
        objective.df(&mut g, &vec![1., 2., 3.]);

-        assert!((g[0] - 26.051064349381285).abs() < std::f64::EPSILON);
-        assert!((g[1] - 10.239000702928523).abs() < std::f64::EPSILON);
-        assert!((g[2] - 3.869294270156324).abs() < std::f64::EPSILON);
+        assert!((g[0] - 26.051064349381285).abs() < f64::EPSILON);
+        assert!((g[1] - 10.239000702928523).abs() < f64::EPSILON);
+        assert!((g[2] - 3.869294270156324).abs() < f64::EPSILON);

        let f = objective.f(&[1., 2., 3.]);

-        assert!((f - 59.76994756647412).abs() < std::f64::EPSILON);
+        assert!((f - 59.76994756647412).abs() < f64::EPSILON);

        let objective_reg = BinaryObjectiveFunction {
            x: &x,
@@ -916,7 +913,7 @@ mod tests {
        let x: DenseMatrix<f32> = DenseMatrix::rand(52181, 94);
        let y1: Vec<i32> = vec![1; 2181];
        let y2: Vec<i32> = vec![0; 50000];
-        let y: Vec<i32> = y1.into_iter().chain(y2.into_iter()).collect();
+        let y: Vec<i32> = y1.into_iter().chain(y2).collect();

        let lr = LogisticRegression::fit(&x, &y, Default::default()).unwrap();
        let lr_reg = LogisticRegression::fit(
@@ -938,12 +935,12 @@ mod tests {
        let x: &DenseMatrix<f64> = &DenseMatrix::rand(52181, 94);
        let y1: Vec<u32> = vec![1; 2181];
        let y2: Vec<u32> = vec![0; 50000];
-        let y: &Vec<u32> = &(y1.into_iter().chain(y2.into_iter()).collect());
+        let y: &Vec<u32> = &(y1.into_iter().chain(y2).collect());
        println!("y vec height: {:?}", y.len());
        println!("x matrix shape: {:?}", x.shape());

        let lr = LogisticRegression::fit(x, y, Default::default()).unwrap();
-        let y_hat = lr.predict(&x).unwrap();
+        let y_hat = lr.predict(x).unwrap();

        println!("y_hat shape: {:?}", y_hat.shape());

@@ -257,8 +257,7 @@ impl<TY: Number + Ord + Unsigned> BernoulliNBDistribution<TY> {
    /// Fits the distribution to a NxM matrix where N is number of samples and M is number of features.
    /// * `x` - training data.
    /// * `y` - vector with target values (classes) of length N.
-    /// * `priors` - Optional vector with prior probabilities of the classes. If not defined,
-    /// priors are adjusted according to the data.
+    /// * `priors` - Optional vector with prior probabilities of the classes. If not defined, priors are adjusted according to the data.
    /// * `alpha` - Additive (Laplace/Lidstone) smoothing parameter.
    /// * `binarize` - Threshold for binarizing.
    fn fit<TX: Number + PartialOrd, X: Array2<TX>, Y: Array1<TY>>(
@@ -427,6 +426,7 @@ impl<TX: Number + PartialOrd, TY: Number + Ord + Unsigned, X: Array2<TX>, Y: Arr

    /// Estimates the class labels for the provided data.
    /// * `x` - data of shape NxM where N is number of data points to estimate and M is number of features.
+    ///
    /// Returns a vector of size N with class estimates.
    pub fn predict(&self, x: &X) -> Result<Y, Failed> {
        if let Some(threshold) = self.binarize {
@@ -95,7 +95,7 @@ impl<T: Number + Unsigned> PartialEq for CategoricalNBDistribution<T> {
                        return false;
                    }
                    for (a_i_j, b_i_j) in a_i.iter().zip(b_i.iter()) {
-                        if (*a_i_j - *b_i_j).abs() > std::f64::EPSILON {
+                        if (*a_i_j - *b_i_j).abs() > f64::EPSILON {
                            return false;
                        }
                    }
@@ -375,6 +375,7 @@ impl<T: Number + Unsigned, X: Array2<T>, Y: Array1<T>> CategoricalNB<T, X, Y> {

    /// Estimates the class labels for the provided data.
    /// * `x` - data of shape NxM where N is number of data points to estimate and M is number of features.
+    ///
    /// Returns a vector of size N with class estimates.
    pub fn predict(&self, x: &X) -> Result<Y, Failed> {
        self.inner.as_ref().unwrap().predict(x)
@@ -174,8 +174,7 @@ impl<TY: Number + Ord + Unsigned> GaussianNBDistribution<TY> {
    /// Fits the distribution to a NxM matrix where N is number of samples and M is number of features.
    /// * `x` - training data.
    /// * `y` - vector with target values (classes) of length N.
-    /// * `priors` - Optional vector with prior probabilities of the classes. If not defined,
-    /// priors are adjusted according to the data.
+    /// * `priors` - Optional vector with prior probabilities of the classes. If not defined, priors are adjusted according to the data.
    pub fn fit<TX: Number + RealNumber, X: Array2<TX>, Y: Array1<TY>>(
        x: &X,
        y: &Y,
@@ -328,6 +327,7 @@ impl<TX: Number + RealNumber, TY: Number + Ord + Unsigned, X: Array2<TX>, Y: Arr

    /// Estimates the class labels for the provided data.
    /// * `x` - data of shape NxM where N is number of data points to estimate and M is number of features.
+    ///
    /// Returns a vector of size N with class estimates.
    pub fn predict(&self, x: &X) -> Result<Y, Failed> {
        self.inner.as_ref().unwrap().predict(x)
@@ -40,7 +40,7 @@ use crate::linalg::basic::arrays::{Array1, Array2, ArrayView1};
 use crate::numbers::basenum::Number;
 #[cfg(feature = "serde")]
 use serde::{Deserialize, Serialize};
-use std::{cmp::Ordering, marker::PhantomData};
+use std::marker::PhantomData;

 /// Distribution used in the Naive Bayes classifier.
 pub(crate) trait NBDistribution<X: Number, Y: Number>: Clone {
@@ -89,45 +89,46 @@ impl<TX: Number, TY: Number, X: Array2<TX>, Y: Array1<TY>, D: NBDistribution<TX,

    /// Estimates the class labels for the provided data.
    /// * `x` - data of shape NxM where N is number of data points to estimate and M is number of features.
+    ///
    /// Returns a vector of size N with class estimates.
    pub fn predict(&self, x: &X) -> Result<Y, Failed> {
        let y_classes = self.distribution.classes();
-        let predictions = x
-            .row_iter()
-            .map(|row| {
-                y_classes
-                    .iter()
-                    .enumerate()
-                    .map(|(class_index, class)| {
-                        (
-                            class,
-                            self.distribution.log_likelihood(class_index, &row)
-                                + self.distribution.prior(class_index).ln(),
-                        )
-                    })
-                    // For some reason, the max_by method cannot use NaNs for finding the maximum value, it panics.
-                    // NaN must be considered as minimum values,
-                    // therefore it's like NaNs would not be considered for choosing the maximum value.
-                    // So we need to handle this case for avoiding panicking by using `Option::unwrap`.
-                    .max_by(|(_, p1), (_, p2)| match p1.partial_cmp(p2) {
-                        Some(ordering) => ordering,
-                        None => {
-                            if p1.is_nan() {
-                                Ordering::Less
-                            } else if p2.is_nan() {
-                                Ordering::Greater
+
+        if y_classes.is_empty() {
+            return Err(Failed::predict("Failed to predict, no classes available"));
+        }
+
+        let (rows, _) = x.shape();
+        let mut predictions = Vec::with_capacity(rows);
+        let mut all_probs_nan = true;
+
+        for row_index in 0..rows {
+            let row = x.get_row(row_index);
+            let mut max_log_prob = f64::NEG_INFINITY;
+            let mut max_class = None;
+
+            for (class_index, class) in y_classes.iter().enumerate() {
+                let log_likelihood = self.distribution.log_likelihood(class_index, &row);
+                let log_prob = log_likelihood + self.distribution.prior(class_index).ln();
+
+                if !log_prob.is_nan() && log_prob > max_log_prob {
+                    max_log_prob = log_prob;
+                    max_class = Some(*class);
+                    all_probs_nan = false;
+                }
+            }
+
+            predictions.push(max_class.unwrap_or(y_classes[0]));
+        }
+
+        if all_probs_nan {
+            Err(Failed::predict(
+                "Failed to predict, all probabilities were NaN",
+            ))
        } else {
-                                Ordering::Equal
+            Ok(Y::from_vec_slice(&predictions))
        }
    }
-                    })
-                    .map(|(prediction, _probability)| *prediction)
-                    .ok_or_else(|| Failed::predict("Failed to predict, there is no result"))
-            })
-            .collect::<Result<Vec<TY>, Failed>>()?;
-        let y_hat = Y::from_vec_slice(&predictions);
-        Ok(y_hat)
-    }
 }
 pub mod bernoulli;
 pub mod categorical;
@@ -146,7 +147,7 @@ mod tests {
    #[derive(Debug, PartialEq, Clone)]
    struct TestDistribution<'d>(&'d Vec<i32>);

-    impl<'d> NBDistribution<i32, i32> for TestDistribution<'d> {
+    impl NBDistribution<i32, i32> for TestDistribution<'_> {
        fn prior(&self, _class_index: usize) -> f64 {
            1.
        }
@@ -163,7 +164,7 @@ mod tests {
        }

        fn classes(&self) -> &Vec<i32> {
-            &self.0
+            self.0
        }
    }

@@ -176,7 +177,7 @@ mod tests {
            Ok(_) => panic!("Should return error in case of empty classes"),
            Err(err) => assert_eq!(
                err.to_string(),
-                "Predict failed: Failed to predict, there is no result"
+                "Predict failed: Failed to predict, no classes available"
            ),
        }

@@ -192,4 +193,441 @@ mod tests {
            Err(_) => panic!("Should success in normal case without NaNs"),
        }
    }
+
+    // A simple test distribution using float
+    #[derive(Debug, PartialEq, Clone)]
+    struct TestDistributionAgain {
+        classes: Vec<u32>,
+        probs: Vec<f64>,
+    }
+
+    impl NBDistribution<f64, u32> for TestDistributionAgain {
+        fn classes(&self) -> &Vec<u32> {
+            &self.classes
+        }
+        fn prior(&self, class_index: usize) -> f64 {
+            self.probs[class_index]
+        }
+        fn log_likelihood<'a>(
+            &'a self,
+            class_index: usize,
+            _j: &'a Box<dyn ArrayView1<f64> + 'a>,
+        ) -> f64 {
+            self.probs[class_index].ln()
+        }
+    }
+
+    type TestNB = BaseNaiveBayes<f64, u32, DenseMatrix<f64>, Vec<u32>, TestDistributionAgain>;
+
+    #[test]
+    fn test_predict_empty_classes() {
+        let dist = TestDistributionAgain {
+            classes: vec![],
+            probs: vec![],
+        };
+        let nb = TestNB::fit(dist).unwrap();
+        let x = DenseMatrix::from_2d_array(&[&[1.0, 2.0], &[3.0, 4.0]]).unwrap();
+        assert!(nb.predict(&x).is_err());
+    }
+
+    #[test]
+    fn test_predict_single_class() {
+        let dist = TestDistributionAgain {
+            classes: vec![1],
+            probs: vec![1.0],
+        };
+        let nb = TestNB::fit(dist).unwrap();
+        let x = DenseMatrix::from_2d_array(&[&[1.0, 2.0], &[3.0, 4.0]]).unwrap();
+        let result = nb.predict(&x).unwrap();
+        assert_eq!(result, vec![1, 1]);
+    }
+
+    #[test]
+    fn test_predict_multiple_classes() {
+        let dist = TestDistributionAgain {
+            classes: vec![1, 2, 3],
+            probs: vec![0.2, 0.5, 0.3],
+        };
+        let nb = TestNB::fit(dist).unwrap();
+        let x = DenseMatrix::from_2d_array(&[&[1.0, 2.0], &[3.0, 4.0], &[5.0, 6.0]]).unwrap();
+        let result = nb.predict(&x).unwrap();
+        assert_eq!(result, vec![2, 2, 2]);
+    }
+
+    #[test]
+    fn test_predict_with_nans() {
+        let dist = TestDistributionAgain {
+            classes: vec![1, 2],
+            probs: vec![f64::NAN, 0.5],
+        };
+        let nb = TestNB::fit(dist).unwrap();
+        let x = DenseMatrix::from_2d_array(&[&[1.0, 2.0], &[3.0, 4.0]]).unwrap();
+        let result = nb.predict(&x).unwrap();
+        assert_eq!(result, vec![2, 2]);
+    }
+
+    #[test]
+    fn test_predict_all_nans() {
+        let dist = TestDistributionAgain {
+            classes: vec![1, 2],
+            probs: vec![f64::NAN, f64::NAN],
+        };
+        let nb = TestNB::fit(dist).unwrap();
+        let x = DenseMatrix::from_2d_array(&[&[1.0, 2.0], &[3.0, 4.0]]).unwrap();
+        assert!(nb.predict(&x).is_err());
+    }
+
+    #[test]
+    fn test_predict_extreme_probabilities() {
+        let dist = TestDistributionAgain {
+            classes: vec![1, 2],
+            probs: vec![1e-300, 1e-301],
+        };
+        let nb = TestNB::fit(dist).unwrap();
+        let x = DenseMatrix::from_2d_array(&[&[1.0, 2.0], &[3.0, 4.0]]).unwrap();
+        let result = nb.predict(&x).unwrap();
+        assert_eq!(result, vec![1, 1]);
+    }
+
+    #[test]
+    fn test_predict_with_infinity() {
+        let dist = TestDistributionAgain {
+            classes: vec![1, 2, 3],
+            probs: vec![f64::INFINITY, 1.0, 2.0],
+        };
+        let nb = TestNB::fit(dist).unwrap();
+        let x = DenseMatrix::from_2d_array(&[&[1.0, 2.0], &[3.0, 4.0]]).unwrap();
+        let result = nb.predict(&x).unwrap();
+        assert_eq!(result, vec![1, 1]);
+    }
+
+    #[test]
+    fn test_predict_with_negative_infinity() {
+        let dist = TestDistributionAgain {
+            classes: vec![1, 2, 3],
+            probs: vec![f64::NEG_INFINITY, 1.0, 2.0],
+        };
+        let nb = TestNB::fit(dist).unwrap();
+        let x = DenseMatrix::from_2d_array(&[&[1.0, 2.0], &[3.0, 4.0]]).unwrap();
+        let result = nb.predict(&x).unwrap();
+        assert_eq!(result, vec![3, 3]);
+    }
+
+    #[test]
+    fn test_gaussian_naive_bayes_numerical_stability() {
+        #[derive(Debug, PartialEq, Clone)]
+        struct GaussianTestDistribution {
+            classes: Vec<u32>,
+            means: Vec<Vec<f64>>,
+            variances: Vec<Vec<f64>>,
+            priors: Vec<f64>,
+        }
+
+        impl NBDistribution<f64, u32> for GaussianTestDistribution {
+            fn classes(&self) -> &Vec<u32> {
+                &self.classes
+            }
+
+            fn prior(&self, class_index: usize) -> f64 {
+                self.priors[class_index]
+            }
+
+            fn log_likelihood<'a>(
+                &'a self,
+                class_index: usize,
+                j: &'a Box<dyn ArrayView1<f64> + 'a>,
+            ) -> f64 {
+                let means = &self.means[class_index];
+                let variances = &self.variances[class_index];
+                j.iterator(0)
+                    .enumerate()
+                    .map(|(i, &xi)| {
+                        let mean = means[i];
+                        let var = variances[i] + 1e-9; // Small smoothing for numerical stability
+                        let coeff = -0.5 * (2.0 * std::f64::consts::PI * var).ln();
+                        let exponent = -(xi - mean).powi(2) / (2.0 * var);
+                        coeff + exponent
+                    })
+                    .sum()
+            }
+        }
+
+        fn train_distribution(x: &DenseMatrix<f64>, y: &[u32]) -> GaussianTestDistribution {
+            let mut classes: Vec<u32> = y
+                .iter()
+                .cloned()
+                .collect::<std::collections::HashSet<u32>>()
+                .into_iter()
+                .collect();
+            classes.sort();
+            let n_classes = classes.len();
+            let n_features = x.shape().1;
+
+            let mut means = vec![vec![0.0; n_features]; n_classes];
+            let mut variances = vec![vec![0.0; n_features]; n_classes];
+            let mut class_counts = vec![0; n_classes];
+
+            // Calculate means and count samples per class
+            for (sample, &class) in x.row_iter().zip(y.iter()) {
+                let class_idx = classes.iter().position(|&c| c == class).unwrap();
+                class_counts[class_idx] += 1;
+                for (i, &value) in sample.iterator(0).enumerate() {
+                    means[class_idx][i] += value;
+                }
+            }
+
+            // Normalize means
+            for (class_idx, mean) in means.iter_mut().enumerate() {
+                for value in mean.iter_mut() {
+                    *value /= class_counts[class_idx] as f64;
+                }
+            }
+
+            // Calculate variances
+            for (sample, &class) in x.row_iter().zip(y.iter()) {
+                let class_idx = classes.iter().position(|&c| c == class).unwrap();
+                for (i, &value) in sample.iterator(0).enumerate() {
+                    let diff = value - means[class_idx][i];
+                    variances[class_idx][i] += diff * diff;
+                }
+            }
+
+            // Normalize variances and add small epsilon to avoid zero variance
+            let epsilon = 1e-9;
+            for (class_idx, variance) in variances.iter_mut().enumerate() {
+                for value in variance.iter_mut() {
+                    *value = *value / class_counts[class_idx] as f64 + epsilon;
+                }
+            }
+
+            // Calculate priors
+            let total_samples = y.len() as f64;
+            let priors: Vec<f64> = class_counts
+                .iter()
+                .map(|&count| count as f64 / total_samples)
+                .collect();
+
+            GaussianTestDistribution {
+                classes,
+                means,
+                variances,
+                priors,
+            }
+        }
+
+        type TestNBGaussian =
+            BaseNaiveBayes<f64, u32, DenseMatrix<f64>, Vec<u32>, GaussianTestDistribution>;
+
+        // Create a constant training dataset
+        let n_samples = 1000;
+        let n_features = 5;
+        let n_classes = 4;
+
+        let mut x_data = Vec::with_capacity(n_samples * n_features);
+        let mut y_data = Vec::with_capacity(n_samples);
+
+        for i in 0..n_samples {
+            for j in 0..n_features {
+                x_data.push((i * j) as f64 % 10.0);
+            }
+            y_data.push((i % n_classes) as u32);
+        }
+
+        let x = DenseMatrix::new(n_samples, n_features, x_data, true).unwrap();
+        let y = y_data;
+
+        // Train the model
+        let dist = train_distribution(&x, &y);
+        let nb = TestNBGaussian::fit(dist).unwrap();
+
+        // Create constant test data
+        let n_test_samples = 100;
+        let mut test_x_data = Vec::with_capacity(n_test_samples * n_features);
+        for i in 0..n_test_samples {
+            for j in 0..n_features {
+                test_x_data.push((i * j * 2) as f64 % 15.0);
+            }
+        }
+        let test_x = DenseMatrix::new(n_test_samples, n_features, test_x_data, true).unwrap();
+
+        // Make predictions
+        let predictions = nb
+            .predict(&test_x)
+            .map_err(|e| format!("Prediction failed: {}", e))
+            .unwrap();
+
+        // Check numerical stability
+        assert_eq!(
+            predictions.len(),
+            n_test_samples,
+            "Number of predictions should match number of test samples"
+        );
+
+        // Check that all predictions are valid class labels
+        for &pred in predictions.iter() {
+            assert!(pred < n_classes as u32, "Predicted class should be valid");
+        }
+
+        // Check consistency of predictions
+        let repeated_predictions = nb
+            .predict(&test_x)
+            .map_err(|e| format!("Repeated prediction failed: {}", e))
+            .unwrap();
+        assert_eq!(
+            predictions, repeated_predictions,
+            "Predictions should be consistent when repeated"
+        );
+
+        // Check extreme values
+        let extreme_x =
+            DenseMatrix::new(2, n_features, vec![f64::MAX; n_features * 2], true).unwrap();
+        let extreme_predictions = nb.predict(&extreme_x);
+        assert!(
+            extreme_predictions.is_err(),
+            "Extreme value input should result in an error"
+        );
+        assert_eq!(
+            extreme_predictions.unwrap_err().to_string(),
+            "Predict failed: Failed to predict, all probabilities were NaN",
+            "Incorrect error message for extreme values"
+        );
+
+        // Check for NaN handling
+        let nan_x = DenseMatrix::new(2, n_features, vec![f64::NAN; n_features * 2], true).unwrap();
+        let nan_predictions = nb.predict(&nan_x);
+        assert!(
+            nan_predictions.is_err(),
+            "NaN input should result in an error"
+        );
+
+        // Check for very small values
+        let small_x =
+            DenseMatrix::new(2, n_features, vec![f64::MIN_POSITIVE; n_features * 2], true).unwrap();
+        let small_predictions = nb
+            .predict(&small_x)
+            .map_err(|e| format!("Small value prediction failed: {}", e))
+            .unwrap();
+        for &pred in small_predictions.iter() {
+            assert!(
+                pred < n_classes as u32,
+                "Predictions for very small values should be valid"
+            );
+        }
+
+        // Check for values close to zero
+        let near_zero_x =
+            DenseMatrix::new(2, n_features, vec![1e-300; n_features * 2], true).unwrap();
+        let near_zero_predictions = nb
+            .predict(&near_zero_x)
+            .map_err(|e| format!("Near-zero value prediction failed: {}", e))
+            .unwrap();
+        for &pred in near_zero_predictions.iter() {
+            assert!(
+                pred < n_classes as u32,
+                "Predictions for near-zero values should be valid"
+            );
+        }
+
+        println!("All numerical stability checks passed!");
+    }
+
+    #[test]
+    fn test_gaussian_naive_bayes_numerical_stability_random_data() {
+        #[derive(Debug)]
+        struct MySimpleRng {
+            state: u64,
+        }
+
+        impl MySimpleRng {
+            fn new(seed: u64) -> Self {
+                MySimpleRng { state: seed }
+            }
+
+            /// Get the next u64 in the sequence.
+            fn next_u64(&mut self) -> u64 {
+                // LCG parameters; these are somewhat arbitrary but commonly used.
+                // Feel free to tweak the multiplier/adder etc.
+                self.state = self.state.wrapping_mul(6364136223846793005).wrapping_add(1);
+                self.state
+            }
+
+            /// Get an f64 in the range [min, max).
+            fn next_f64(&mut self, min: f64, max: f64) -> f64 {
+                let fraction = (self.next_u64() as f64) / (u64::MAX as f64);
+                min + fraction * (max - min)
+            }
+
+            /// Get a usize in the range [min, max). This floors the floating result.
+            fn gen_range_usize(&mut self, min: usize, max: usize) -> usize {
+                let v = self.next_f64(min as f64, max as f64);
+                // Truncate into the integer range. Because of floating inexactness,
+                // ensure we also clamp.
+                let int_v = v.floor() as isize;
+                // simple clamp to avoid any float rounding out of range
+                let clamped = int_v.max(min as isize).min((max - 1) as isize);
+                clamped as usize
+            }
+        }
+        use crate::naive_bayes::gaussian::GaussianNB;
+        // We will generate random data in a reproducible way (using a fixed seed).
+        // We will generate random data in a reproducible way:
+        let mut rng = MySimpleRng::new(42);
+
+        let n_samples = 1000;
+        let n_features = 5;
+        let n_classes = 4;
+
+        // Our feature matrix and label vector
+        let mut x_data = Vec::with_capacity(n_samples * n_features);
+        let mut y_data = Vec::with_capacity(n_samples);
+
+        // Fill x_data with random values and y_data with random class labels.
+        for _i in 0..n_samples {
+            for _j in 0..n_features {
+                // We’ll pick random values in [-10, 10).
+                x_data.push(rng.next_f64(-10.0, 10.0));
+            }
+            let class = rng.gen_range_usize(0, n_classes) as u32;
+            y_data.push(class);
+        }
+
+        // Create DenseMatrix from x_data
+        let x = DenseMatrix::new(n_samples, n_features, x_data, true).unwrap();
+
+        // Train GaussianNB
+        let gnb = GaussianNB::fit(&x, &y_data, Default::default())
+            .expect("Fitting GaussianNB with random data failed.");
+
+        // Predict on the same training data to verify no numerical instability
+        let predictions = gnb.predict(&x).expect("Prediction on random data failed.");
+
+        // Basic sanity checks
+        assert_eq!(
+            predictions.len(),
+            n_samples,
+            "Prediction size must match n_samples"
+        );
+        for &pred_class in &predictions {
+            assert!(
+                (pred_class as usize) < n_classes,
+                "Predicted class {} is out of range [0..n_classes).",
+                pred_class
+            );
+        }
+
+        // If you want to compare with scikit-learn, you can do something like:
+        // println!("X = {:?}", &x);
+        // println!("Y = {:?}", &y_data);
+        // println!("predictions = {:?}", &predictions);
+        // and then in Python:
+        //    import numpy as np
+        //    from sklearn.naive_bayes import GaussianNB
+        //    X = np.reshape(np.array(x), (1000, 5), order='F')
+        //    Y = np.array(y)
+        //    gnb = GaussianNB().fit(X, Y)
+        //    preds = gnb.predict(X)
+        //    expected = np.array(predictions)
+        //    assert expected == preds
+        // They should match closely (or exactly) depending on floating rounding.
+    }
 }
@@ -207,8 +207,7 @@ impl<TY: Number + Ord + Unsigned> MultinomialNBDistribution<TY> {
    /// Fits the distribution to a NxM matrix where N is number of samples and M is number of features.
    /// * `x` - training data.
    /// * `y` - vector with target values (classes) of length N.
-    /// * `priors` - Optional vector with prior probabilities of the classes. If not defined,
-    /// priors are adjusted according to the data.
+    /// * `priors` - Optional vector with prior probabilities of the classes. If not defined, priors are adjusted according to the data.
    /// * `alpha` - Additive (Laplace/Lidstone) smoothing parameter.
    pub fn fit<TX: Number + Unsigned, X: Array2<TX>, Y: Array1<TY>>(
        x: &X,
@@ -358,6 +357,7 @@ impl<TX: Number + Unsigned, TY: Number + Ord + Unsigned, X: Array2<TX>, Y: Array

    /// Estimates the class labels for the provided data.
    /// * `x` - data of shape NxM where N is number of data points to estimate and M is number of features.
+    ///
    /// Returns a vector of size N with class estimates.
    pub fn predict(&self, x: &X) -> Result<Y, Failed> {
        self.inner.as_ref().unwrap().predict(x)
@@ -261,6 +261,7 @@ impl<TX: Number, TY: Number + Ord, X: Array2<TX>, Y: Array1<TY>, D: Distance<Vec

    /// Estimates the class labels for the provided data.
    /// * `x` - data of shape NxM where N is number of data points to estimate and M is number of features.
+    ///
    /// Returns a vector of size N with class estimates.
    pub fn predict(&self, x: &X) -> Result<Y, Failed> {
        let mut result = Y::zeros(x.shape().0);
@@ -88,25 +88,21 @@ pub struct KNNRegressor<TX: Number, TY: Number, X: Array2<TX>, Y: Array1<TY>, D:
 impl<TX: Number, TY: Number, X: Array2<TX>, Y: Array1<TY>, D: Distance<Vec<TX>>>
    KNNRegressor<TX, TY, X, Y, D>
 {
-    ///
    fn y(&self) -> &Y {
        self.y.as_ref().unwrap()
    }

-    ///
    fn knn_algorithm(&self) -> &KNNAlgorithm<TX, D> {
        self.knn_algorithm
            .as_ref()
            .expect("Missing parameter: KNNAlgorithm")
    }

-    ///
    fn weight(&self) -> &KNNWeightFunction {
        self.weight.as_ref().expect("Missing parameter: weight")
    }

    #[allow(dead_code)]
-    ///
    fn k(&self) -> usize {
        self.k.unwrap()
    }
@@ -250,6 +246,7 @@ impl<TX: Number, TY: Number, X: Array2<TX>, Y: Array1<TY>, D: Distance<Vec<TX>>>

    /// Predict the target for the provided data.
    /// * `x` - data of shape NxM where N is number of data points to estimate and M is number of features.
+    ///
    /// Returns a vector of size N with estimates.
    pub fn predict(&self, x: &X) -> Result<Y, Failed> {
        let mut result = Y::zeros(x.shape().0);
@@ -312,7 +309,7 @@ mod tests {
        let y_hat = knn.predict(&x).unwrap();
        assert_eq!(5, Vec::len(&y_hat));
        for i in 0..y_hat.len() {
-            assert!((y_hat[i] - y_exp[i]).abs() < std::f64::EPSILON);
+            assert!((y_hat[i] - y_exp[i]).abs() < f64::EPSILON);
        }
    }

@@ -64,7 +64,7 @@ impl KNNWeightFunction {
            KNNWeightFunction::Distance => {
                // if there are any points that has zero distance from one or more training points,
                // those training points are weighted as 1.0 and the other points as 0.0
-                if distances.iter().any(|&e| e == 0f64) {
+                if distances.contains(&0f64) {
                    distances
                        .iter()
                        .map(|e| if *e == 0f64 { 1f64 } else { 0f64 })
@@ -1,5 +1,3 @@
-// TODO: missing documentation
-
 use std::default::Default;

 use crate::linalg::basic::arrays::Array1;
@@ -8,30 +6,27 @@ use crate::optimization::first_order::{FirstOrderOptimizer, OptimizerResult};
 use crate::optimization::line_search::LineSearchMethod;
 use crate::optimization::{DF, F};

-///
+/// Gradient Descent optimization algorithm
 pub struct GradientDescent {
-    ///
+    /// Maximum number of iterations
    pub max_iter: usize,
-    ///
+    /// Relative tolerance for the gradient norm
    pub g_rtol: f64,
-    ///
+    /// Absolute tolerance for the gradient norm
    pub g_atol: f64,
 }

-///
 impl Default for GradientDescent {
    fn default() -> Self {
        GradientDescent {
            max_iter: 10000,
-            g_rtol: std::f64::EPSILON.sqrt(),
-            g_atol: std::f64::EPSILON,
+            g_rtol: f64::EPSILON.sqrt(),
+            g_atol: f64::EPSILON,
        }
    }
 }

-///
 impl<T: FloatNumber> FirstOrderOptimizer<T> for GradientDescent {
-    ///
    fn optimize<'a, X: Array1<T>, LS: LineSearchMethod<T>>(
        &self,
        f: &'a F<'_, T, X>,
@@ -11,31 +11,29 @@ use crate::optimization::first_order::{FirstOrderOptimizer, OptimizerResult};
 use crate::optimization::line_search::LineSearchMethod;
 use crate::optimization::{DF, F};

-///
+/// Limited-memory BFGS optimization algorithm
 pub struct LBFGS {
-    ///
+    /// Maximum number of iterations
    pub max_iter: usize,
-    ///
+    /// TODO: Add documentation
    pub g_rtol: f64,
-    ///
+    /// TODO: Add documentation
    pub g_atol: f64,
-    ///
+    /// TODO: Add documentation
    pub x_atol: f64,
-    ///
+    /// TODO: Add documentation
    pub x_rtol: f64,
-    ///
+    /// TODO: Add documentation
    pub f_abstol: f64,
-    ///
+    /// TODO: Add documentation
    pub f_reltol: f64,
-    ///
+    /// TODO: Add documentation
    pub successive_f_tol: usize,
-    ///
+    /// TODO: Add documentation
    pub m: usize,
 }

-///
 impl Default for LBFGS {
-    ///
    fn default() -> Self {
        LBFGS {
            max_iter: 1000,
@@ -51,9 +49,7 @@ impl Default for LBFGS {
    }
 }

-///
 impl LBFGS {
-    ///
    fn two_loops<T: FloatNumber + RealNumber, X: Array1<T>>(&self, state: &mut LBFGSState<T, X>) {
        let lower = state.iteration.max(self.m) - self.m;
        let upper = state.iteration;
@@ -95,7 +91,6 @@ impl LBFGS {
        state.s.mul_scalar_mut(-T::one());
    }

-    ///
    fn init_state<T: FloatNumber + RealNumber, X: Array1<T>>(&self, x: &X) -> LBFGSState<T, X> {
        LBFGSState {
            x: x.clone(),
@@ -119,7 +114,6 @@ impl LBFGS {
        }
    }

-    ///
    fn update_state<'a, T: FloatNumber + RealNumber, X: Array1<T>, LS: LineSearchMethod<T>>(
        &self,
        f: &'a F<'_, T, X>,
@@ -161,7 +155,6 @@ impl LBFGS {
        df(&mut state.x_df, &state.x);
    }

-    ///
    fn assess_convergence<T: FloatNumber, X: Array1<T>>(
        &self,
        state: &mut LBFGSState<T, X>,
@@ -173,7 +166,7 @@ impl LBFGS {
        }

        if state.x.max_diff(&state.x_prev)
-            <= T::from_f64(self.x_rtol * state.x.norm(std::f64::INFINITY)).unwrap()
+            <= T::from_f64(self.x_rtol * state.x.norm(f64::INFINITY)).unwrap()
        {
            x_converged = true;
        }
@@ -188,14 +181,13 @@ impl LBFGS {
            state.counter_f_tol += 1;
        }

-        if state.x_df.norm(std::f64::INFINITY) <= self.g_atol {
+        if state.x_df.norm(f64::INFINITY) <= self.g_atol {
            g_converged = true;
        }

        g_converged || x_converged || state.counter_f_tol > self.successive_f_tol
    }

-    ///
    fn update_hessian<T: FloatNumber, X: Array1<T>>(
        &self,
        _: &DF<'_, X>,
@@ -212,7 +204,6 @@ impl LBFGS {
    }
 }

-///
 #[derive(Debug)]
 struct LBFGSState<T: FloatNumber, X: Array1<T>> {
    x: X,
@@ -234,9 +225,7 @@ struct LBFGSState<T: FloatNumber, X: Array1<T>> {
    alpha: T,
 }

-///
 impl<T: FloatNumber + RealNumber> FirstOrderOptimizer<T> for LBFGS {
-    ///
    fn optimize<'a, X: Array1<T>, LS: LineSearchMethod<T>>(
        &self,
        f: &F<'_, T, X>,
@@ -248,7 +237,7 @@ impl<T: FloatNumber + RealNumber> FirstOrderOptimizer<T> for LBFGS {

        df(&mut state.x_df, x0);

-        let g_converged = state.x_df.norm(std::f64::INFINITY) < self.g_atol;
+        let g_converged = state.x_df.norm(f64::INFINITY) < self.g_atol;
        let mut converged = g_converged;
        let stopped = false;

@@ -299,7 +288,7 @@ mod tests {

        let result = optimizer.optimize(&f, &df, &x0, &ls);

-        assert!((result.f_x - 0.0).abs() < std::f64::EPSILON);
+        assert!((result.f_x - 0.0).abs() < f64::EPSILON);
        assert!((result.x[0] - 1.0).abs() < 1e-8);
        assert!((result.x[1] - 1.0).abs() < 1e-8);
        assert!(result.iterations <= 24);
@@ -1,6 +1,6 @@
-///
+/// Gradient descent optimization algorithm
 pub mod gradient_descent;
-///
+/// Limited-memory BFGS optimization algorithm
 pub mod lbfgs;

 use std::clone::Clone;
@@ -11,9 +11,9 @@ use crate::numbers::floatnum::FloatNumber;
 use crate::optimization::line_search::LineSearchMethod;
 use crate::optimization::{DF, F};

-///
+/// First-order optimization is a class of algorithms that use the first derivative of a function to find optimal solutions.
 pub trait FirstOrderOptimizer<T: FloatNumber> {
-    ///
+    /// run first order optimization
    fn optimize<'a, X: Array1<T>, LS: LineSearchMethod<T>>(
        &self,
        f: &F<'_, T, X>,
@@ -23,13 +23,13 @@ pub trait FirstOrderOptimizer<T: FloatNumber> {
    ) -> OptimizerResult<T, X>;
 }

-///
+/// Result of optimization
 #[derive(Debug, Clone)]
 pub struct OptimizerResult<T: FloatNumber, X: Array1<T>> {
-    ///
+    /// Solution
    pub x: X,
-    ///
+    /// f(x) value
    pub f_x: T,
-    ///
+    /// number of iterations
    pub iterations: usize,
 }
@@ -1,11 +1,9 @@
-// TODO: missing documentation
-
 use crate::optimization::FunctionOrder;
 use num_traits::Float;

-///
+/// Line search optimization.
 pub trait LineSearchMethod<T: Float> {
-    ///
+    /// Find alpha that satisfies strong Wolfe conditions.
    fn search(
        &self,
        f: &(dyn Fn(T) -> T),
@@ -16,32 +14,31 @@ pub trait LineSearchMethod<T: Float> {
    ) -> LineSearchResult<T>;
 }

-///
+/// Line search result
 #[derive(Debug, Clone)]
 pub struct LineSearchResult<T: Float> {
-    ///
+    /// Alpha value
    pub alpha: T,
-    ///
+    /// f(alpha) value
    pub f_x: T,
 }

-///
+/// Backtracking line search method.
 pub struct Backtracking<T: Float> {
-    ///
+    /// TODO: Add documentation
    pub c1: T,
-    ///
+    /// Maximum number of iterations for Backtracking single run
    pub max_iterations: usize,
-    ///
+    /// TODO: Add documentation
    pub max_infinity_iterations: usize,
-    ///
+    /// TODO: Add documentation
    pub phi: T,
-    ///
+    /// TODO: Add documentation
    pub plo: T,
-    ///
+    /// function order
    pub order: FunctionOrder,
 }

-///
 impl<T: Float> Default for Backtracking<T> {
    fn default() -> Self {
        Backtracking {
@@ -55,9 +52,7 @@ impl<T: Float> Default for Backtracking<T> {
    }
 }

-///
 impl<T: Float> LineSearchMethod<T> for Backtracking<T> {
-    ///
    fn search(
        &self,
        f: &(dyn Fn(T) -> T),
@@ -1,21 +1,19 @@
-// TODO: missing documentation
-
-///
+/// first order optimization algorithms
 pub mod first_order;
-///
+/// line search algorithms
 pub mod line_search;

-///
+/// Function f(x) = y
 pub type F<'a, T, X> = dyn for<'b> Fn(&'b X) -> T + 'a;
-///
+/// Function df(x)
 pub type DF<'a, X> = dyn for<'b> Fn(&'b mut X, &'b X) + 'a;

-///
+/// Function order
 #[allow(clippy::upper_case_acronyms)]
 #[derive(Debug, PartialEq, Eq)]
 pub enum FunctionOrder {
-    ///
+    /// Second order
    SECOND,
-    ///
+    /// Third order
    THIRD,
 }
@@ -24,7 +24,7 @@
 //! //    &[1.5, 1.0, 0.0, 1.5, 0.0, 0.0, 1.0, 0.0]
 //! //    &[1.5, 0.0, 1.0, 1.5, 0.0, 0.0, 0.0, 1.0]
 //! ```
-use std::iter;
+use std::iter::repeat_n;

 use crate::error::Failed;
 use crate::linalg::basic::arrays::Array2;
@@ -75,11 +75,7 @@ fn find_new_idxs(num_params: usize, cat_sizes: &[usize], cat_idxs: &[usize]) ->
    let offset = (0..1).chain(offset_);

    let new_param_idxs: Vec<usize> = (0..num_params)
-        .zip(
-            repeats
-                .zip(offset)
-                .flat_map(|(r, o)| iter::repeat(o).take(r)),
-        )
+        .zip(repeats.zip(offset).flat_map(|(r, o)| repeat_n(o, r)))
        .map(|(idx, ofst)| idx + ofst)
        .collect();
    new_param_idxs
@@ -124,7 +120,7 @@ impl OneHotEncoder {
                let (nrows, _) = data.shape();

                // col buffer to avoid allocations
-                let mut col_buf: Vec<T> = iter::repeat(T::zero()).take(nrows).collect();
+                let mut col_buf: Vec<T> = repeat_n(T::zero(), nrows).collect();

                let mut res: Vec<CategoryMapper<CategoricalFloat>> = Vec::with_capacity(idxs.len());

@@ -172,18 +172,14 @@ where
    T: Number + RealNumber,
    M: Array2<T>,
 {
-    if let Some(output_matrix) = columns.first().cloned() {
-        return Some(
+    columns.first().cloned().map(|output_matrix| {
        columns
            .iter()
            .skip(1)
            .fold(output_matrix, |current_matrix, new_colum| {
                current_matrix.h_stack(new_colum)
-                }),
-        );
-    } else {
-        None
-    }
+            })
+    })
 }

 #[cfg(test)]
@@ -30,7 +30,7 @@ pub struct CSVDefinition<'a> {
    /// What seperates the fields in your csv-file?
    field_seperator: &'a str,
 }
-impl<'a> Default for CSVDefinition<'a> {
+impl Default for CSVDefinition<'_> {
    fn default() -> Self {
        Self {
            n_rows_header: 1,
@@ -25,14 +25,18 @@
 /// search parameters
 pub mod svc;
 pub mod svr;
-// /// search parameters space
-// pub mod search;
+// search parameters space
+pub mod search;

 use core::fmt::Debug;

 #[cfg(feature = "serde")]
 use serde::{Deserialize, Serialize};

+// Only import typetag if not compiling for wasm32 and serde is enabled
+#[cfg(all(feature = "serde", not(target_arch = "wasm32")))]
+use typetag;
+
 use crate::error::{Failed, FailedError};
 use crate::linalg::basic::arrays::{Array1, ArrayView1};

@@ -48,197 +52,281 @@ pub trait Kernel: Debug {
    fn apply(&self, x_i: &Vec<f64>, x_j: &Vec<f64>) -> Result<f64, Failed>;
 }

-/// Pre-defined kernel functions
+/// A enumerator for all the kernels type to support.
+/// This allows kernel selection and parameterization ergonomic, type-safe, and ready for use in parameter structs like SVRParameters.
+/// You can construct kernels using the provided variants and builder-style methods.
+///
+/// # Examples
+///
+/// ```
+/// use smartcore::svm::Kernels;
+///
+/// let linear = Kernels::linear();
+/// let rbf = Kernels::rbf().with_gamma(0.5);
+/// let poly = Kernels::polynomial().with_degree(3.0).with_gamma(0.5).with_coef0(1.0);
+/// let sigmoid = Kernels::sigmoid().with_gamma(0.2).with_coef0(0.0);
+/// ```
 #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
-#[derive(Debug, Clone)]
-pub struct Kernels;
+#[derive(Debug, Clone, PartialEq)]
+pub enum Kernels {
+    /// Linear kernel (default).
+    ///
+    /// Computes the standard dot product between vectors.
+    Linear,
+
+    /// Radial Basis Function (RBF) kernel.
+    ///
+    /// Formula: K(x, y) = exp(-gamma * ||x-y||²)
+    RBF {
+        /// Controls the width of the Gaussian RBF kernel.
+        ///
+        /// Larger values of gamma lead to higher bias and lower variance.
+        /// This parameter is inversely proportional to the radius of influence
+        /// of samples selected by the model as support vectors.
+        gamma: Option<f64>,
+    },
+
+    /// Polynomial kernel.
+    ///
+    /// Formula: K(x, y) = (gamma * <x, y> + coef0)^degree
+    Polynomial {
+        /// The degree of the polynomial kernel.
+        ///
+        /// Integer values are typical (2 = quadratic, 3 = cubic), but any positive real value is valid.
+        /// Higher degree values create decision boundaries with higher complexity.
+        degree: Option<f64>,
+
+        /// Kernel coefficient for the dot product.
+        ///
+        /// Controls the influence of higher-degree versus lower-degree terms in the polynomial.
+        /// If None, a default value will be used.
+        gamma: Option<f64>,
+
+        /// Independent term in the polynomial kernel.
+        ///
+        /// Controls the influence of higher-degree versus lower-degree terms.
+        /// If None, a default value of 1.0 will be used.
+        coef0: Option<f64>,
+    },
+
+    /// Sigmoid kernel.
+    ///
+    /// Formula: K(x, y) = tanh(gamma * <x, y> + coef0)
+    Sigmoid {
+        /// Kernel coefficient for the dot product.
+        ///
+        /// Controls the scaling of the dot product in the sigmoid function.
+        /// If None, a default value will be used.
+        gamma: Option<f64>,
+
+        /// Independent term in the sigmoid kernel.
+        ///
+        /// Acts as a threshold/bias term in the sigmoid function.
+        /// If None, a default value of 1.0 will be used.
+        coef0: Option<f64>,
+    },
+}

 impl Kernels {
-    /// Return a default linear
-    pub fn linear() -> LinearKernel {
-        LinearKernel
+    /// Create a linear kernel.
+    ///
+    /// The linear kernel computes the dot product between two vectors:
+    /// K(x, y) = <x, y>
+    pub fn linear() -> Self {
+        Kernels::Linear
    }
-    /// Return a default RBF
-    pub fn rbf() -> RBFKernel {
-        RBFKernel::default()
+
+    /// Create an RBF kernel with unspecified gamma.
+    ///
+    /// The RBF kernel is defined as:
+    /// K(x, y) = exp(-gamma * ||x-y||²)
+    ///
+    /// You should specify gamma using `with_gamma()` before using this kernel.
+    pub fn rbf() -> Self {
+        Kernels::RBF { gamma: None }
    }
-    /// Return a default polynomial
-    pub fn polynomial() -> PolynomialKernel {
-        PolynomialKernel::default()
-    }
-    /// Return a default sigmoid
-    pub fn sigmoid() -> SigmoidKernel {
-        SigmoidKernel::default()
+
+    /// Create a polynomial kernel with default parameters.
+    ///
+    /// The polynomial kernel is defined as:
+    /// K(x, y) = (gamma * <x, y> + coef0)^degree
+    ///
+    /// Default values:
+    /// - gamma: None (must be specified)
+    /// - degree: None (must be specified)
+    /// - coef0: 1.0
+    pub fn polynomial() -> Self {
+        Kernels::Polynomial {
+            gamma: None,
+            degree: None,
+            coef0: Some(1.0),
        }
    }

-/// Linear Kernel
-#[allow(clippy::derive_partial_eq_without_eq)]
-#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
-#[derive(Debug, Clone, PartialEq, Eq, Default)]
-pub struct LinearKernel;
-
-/// Radial basis function (Gaussian) kernel
-#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
-#[derive(Debug, Default, Clone, PartialEq)]
-pub struct RBFKernel {
-    /// kernel coefficient
-    pub gamma: Option<f64>,
+    /// Create a sigmoid kernel with default parameters.
+    ///
+    /// The sigmoid kernel is defined as:
+    /// K(x, y) = tanh(gamma * <x, y> + coef0)
+    ///
+    /// Default values:
+    /// - gamma: None (must be specified)
+    /// - coef0: 1.0
+    ///
+    pub fn sigmoid() -> Self {
+        Kernels::Sigmoid {
+            gamma: None,
+            coef0: Some(1.0),
+        }
    }

-#[allow(dead_code)]
-impl RBFKernel {
-    /// assign gamma parameter to kernel (required)
-    /// ```rust
-    /// use smartcore::svm::RBFKernel;
-    /// let knl = RBFKernel::default().with_gamma(0.7);
+    /// Set the `gamma` parameter for RBF, polynomial, or sigmoid kernels.
+    ///
+    /// The gamma parameter has different interpretations depending on the kernel:
+    /// - For RBF: Controls the width of the Gaussian. Larger values mean tighter fit.
+    /// - For Polynomial: Scaling factor for the dot product.
+    /// - For Sigmoid: Scaling factor for the dot product.
+    ///
+    pub fn with_gamma(self, gamma: f64) -> Self {
+        match self {
+            Kernels::RBF { .. } => Kernels::RBF { gamma: Some(gamma) },
+            Kernels::Polynomial { degree, coef0, .. } => Kernels::Polynomial {
+                gamma: Some(gamma),
+                degree,
+                coef0,
+            },
+            Kernels::Sigmoid { coef0, .. } => Kernels::Sigmoid {
+                gamma: Some(gamma),
+                coef0,
+            },
+            other => other,
+        }
+    }
+
+    /// Set the `degree` parameter for the polynomial kernel.
+    ///
+    /// The degree parameter controls the flexibility of the decision boundary.
+    /// Higher degrees create more complex boundaries but may lead to overfitting.
+    ///
+    pub fn with_degree(self, degree: f64) -> Self {
+        match self {
+            Kernels::Polynomial { gamma, coef0, .. } => Kernels::Polynomial {
+                degree: Some(degree),
+                gamma,
+                coef0,
+            },
+            other => other,
+        }
+    }
+
+    /// Set the `coef0` parameter for polynomial or sigmoid kernels.
+    ///
+    /// The coef0 parameter is the independent term in the kernel function:
+    /// - For Polynomial: Controls the influence of higher-degree vs. lower-degree terms.
+    /// - For Sigmoid: Acts as a threshold/bias term.
+    ///
+    pub fn with_coef0(self, coef0: f64) -> Self {
+        match self {
+            Kernels::Polynomial { degree, gamma, .. } => Kernels::Polynomial {
+                degree,
+                gamma,
+                coef0: Some(coef0),
+            },
+            Kernels::Sigmoid { gamma, .. } => Kernels::Sigmoid {
+                gamma,
+                coef0: Some(coef0),
+            },
+            other => other,
+        }
+    }
+}
+
+/// Implementation of the [`Kernel`] trait for the [`Kernels`] enum in smartcore.
+///
+/// This method computes the value of the kernel function between two feature vectors `x_i` and `x_j`,
+/// according to the variant and parameters of the [`Kernels`] enum. This enables flexible and type-safe
+/// selection of kernel functions for SVM and SVR models in smartcore.
+///
+/// # Supported Kernels
+///
+/// - [`Kernels::Linear`]: Computes the standard dot product between `x_i` and `x_j`.
+/// - [`Kernels::RBF`]: Computes the Radial Basis Function (Gaussian) kernel. Requires `gamma`.
+/// - [`Kernels::Polynomial`]: Computes the polynomial kernel. Requires `degree`, `gamma`, and `coef0`.
+/// - [`Kernels::Sigmoid`]: Computes the sigmoid kernel. Requires `gamma` and `coef0`.
+///
+/// # Parameters
+///
+/// - `x_i`: First input vector (feature vector).
+/// - `x_j`: Second input vector (feature vector).
+///
+/// # Returns
+///
+/// - `Ok(f64)`: The computed kernel value.
+/// - `Err(Failed)`: If any required kernel parameter is missing.
+///
+/// # Errors
+///
+/// Returns `Err(Failed)` if a required parameter (such as `gamma`, `degree`, or `coef0`)
+/// is `None` for the selected kernel variant.
+///
+/// # Example
+///
 /// ```
-    pub fn with_gamma(mut self, gamma: f64) -> Self {
-        self.gamma = Some(gamma);
-        self
-    }
-}
-
-/// Polynomial kernel
-#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
-#[derive(Debug, Clone, PartialEq)]
-pub struct PolynomialKernel {
-    /// degree of the polynomial
-    pub degree: Option<f64>,
-    /// kernel coefficient
-    pub gamma: Option<f64>,
-    /// independent term in kernel function
-    pub coef0: Option<f64>,
-}
-
-impl Default for PolynomialKernel {
-    fn default() -> Self {
-        Self {
-            gamma: Option::None,
-            degree: Option::None,
-            coef0: Some(1f64),
-        }
-    }
-}
-
-impl PolynomialKernel {
-    /// set parameters for kernel
-    /// ```rust
-    /// use smartcore::svm::PolynomialKernel;
-    /// let knl = PolynomialKernel::default().with_params(3.0, 0.7, 1.0);
+/// use smartcore::svm::Kernels;
+/// use smartcore::svm::Kernel;
+///
+/// let x = vec![1.0, 2.0, 3.0];
+/// let y = vec![4.0, 5.0, 6.0];
+/// let kernel = Kernels::rbf().with_gamma(0.5);
+/// let value = kernel.apply(&x, &y).unwrap();
 /// ```
-    pub fn with_params(mut self, degree: f64, gamma: f64, coef0: f64) -> Self {
-        self.degree = Some(degree);
-        self.gamma = Some(gamma);
-        self.coef0 = Some(coef0);
-        self
-    }
-    /// set gamma parameter for kernel
-    /// ```rust
-    /// use smartcore::svm::PolynomialKernel;
-    /// let knl = PolynomialKernel::default().with_gamma(0.7);
-    /// ```
-    pub fn with_gamma(mut self, gamma: f64) -> Self {
-        self.gamma = Some(gamma);
-        self
-    }
-    /// set degree parameter for kernel
-    /// ```rust
-    /// use smartcore::svm::PolynomialKernel;
-    /// let knl = PolynomialKernel::default().with_degree(3.0, 100);
-    /// ```
-    pub fn with_degree(self, degree: f64, n_features: usize) -> Self {
-        self.with_params(degree, 1f64, 1f64 / n_features as f64)
-    }
-}
-
-/// Sigmoid (hyperbolic tangent) kernel
-#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
-#[derive(Debug, Clone, PartialEq)]
-pub struct SigmoidKernel {
-    /// kernel coefficient
-    pub gamma: Option<f64>,
-    /// independent term in kernel function
-    pub coef0: Option<f64>,
-}
-
-impl Default for SigmoidKernel {
-    fn default() -> Self {
-        Self {
-            gamma: Option::None,
-            coef0: Some(1f64),
-        }
-    }
-}
-
-impl SigmoidKernel {
-    /// set parameters for kernel
-    /// ```rust
-    /// use smartcore::svm::SigmoidKernel;
-    /// let knl = SigmoidKernel::default().with_params(0.7, 1.0);
-    /// ```
-    pub fn with_params(mut self, gamma: f64, coef0: f64) -> Self {
-        self.gamma = Some(gamma);
-        self.coef0 = Some(coef0);
-        self
-    }
-    /// set gamma parameter for kernel
-    /// ```rust
-    /// use smartcore::svm::SigmoidKernel;
-    /// let knl = SigmoidKernel::default().with_gamma(0.7);
-    /// ```
-    pub fn with_gamma(mut self, gamma: f64) -> Self {
-        self.gamma = Some(gamma);
-        self
-    }
-}
-
+///
+/// # Notes
+///
+/// - This implementation follows smartcore's philosophy: pure Rust, no macros, no unsafe code,
+///   and an accessible, pythonic API surface for both ML practitioners and Rust beginners.
+/// - All kernel parameters must be set before calling `apply`; missing parameters will result in an error.
+///
+/// See the [`Kernels`] enum documentation for more details on each kernel type and its parameters.
 #[cfg_attr(all(feature = "serde", not(target_arch = "wasm32")), typetag::serde)]
-impl Kernel for LinearKernel {
+impl Kernel for Kernels {
    fn apply(&self, x_i: &Vec<f64>, x_j: &Vec<f64>) -> Result<f64, Failed> {
-        Ok(x_i.dot(x_j))
-    }
-}
-
-#[cfg_attr(all(feature = "serde", not(target_arch = "wasm32")), typetag::serde)]
-impl Kernel for RBFKernel {
-    fn apply(&self, x_i: &Vec<f64>, x_j: &Vec<f64>) -> Result<f64, Failed> {
-        if self.gamma.is_none() {
-            return Err(Failed::because(
-                FailedError::ParametersError,
-                "gamma should be set, use {Kernel}::default().with_gamma(..)",
-            ));
-        }
+        match self {
+            Kernels::Linear => Ok(x_i.dot(x_j)),
+            Kernels::RBF { gamma } => {
+                let gamma = gamma.ok_or_else(|| {
+                    Failed::because(FailedError::ParametersError, "gamma not set")
+                })?;
                let v_diff = x_i.sub(x_j);
-        Ok((-self.gamma.unwrap() * v_diff.mul(&v_diff).sum()).exp())
-    }
-}
-
-#[cfg_attr(all(feature = "serde", not(target_arch = "wasm32")), typetag::serde)]
-impl Kernel for PolynomialKernel {
-    fn apply(&self, x_i: &Vec<f64>, x_j: &Vec<f64>) -> Result<f64, Failed> {
-        if self.gamma.is_none() || self.coef0.is_none() || self.degree.is_none() {
-            return Err(Failed::because(
-                FailedError::ParametersError, "gamma, coef0, degree should be set, 
-                                                        use {Kernel}::default().with_{parameter}(..)")
-            );
+                Ok((-gamma * v_diff.mul(&v_diff).sum()).exp())
            }
+            Kernels::Polynomial {
+                degree,
+                gamma,
+                coef0,
+            } => {
+                let degree = degree.ok_or_else(|| {
+                    Failed::because(FailedError::ParametersError, "degree not set")
+                })?;
+                let gamma = gamma.ok_or_else(|| {
+                    Failed::because(FailedError::ParametersError, "gamma not set")
+                })?;
+                let coef0 = coef0.ok_or_else(|| {
+                    Failed::because(FailedError::ParametersError, "coef0 not set")
+                })?;
                let dot = x_i.dot(x_j);
-        Ok((self.gamma.unwrap() * dot + self.coef0.unwrap()).powf(self.degree.unwrap()))
-    }
-}
-
-#[cfg_attr(all(feature = "serde", not(target_arch = "wasm32")), typetag::serde)]
-impl Kernel for SigmoidKernel {
-    fn apply(&self, x_i: &Vec<f64>, x_j: &Vec<f64>) -> Result<f64, Failed> {
-        if self.gamma.is_none() || self.coef0.is_none() {
-            return Err(Failed::because(
-                FailedError::ParametersError, "gamma, coef0, degree should be set, 
-                                                        use {Kernel}::default().with_{parameter}(..)")
-            );
+                Ok((gamma * dot + coef0).powf(degree))
            }
+            Kernels::Sigmoid { gamma, coef0 } => {
+                let gamma = gamma.ok_or_else(|| {
+                    Failed::because(FailedError::ParametersError, "gamma not set")
+                })?;
+                let coef0 = coef0.ok_or_else(|| {
+                    Failed::because(FailedError::ParametersError, "coef0 not set")
+                })?;
                let dot = x_i.dot(x_j);
-        Ok(self.gamma.unwrap() * dot + self.coef0.unwrap().tanh())
+                Ok((gamma * dot + coef0).tanh())
+            }
+        }
    }
 }

@@ -247,6 +335,18 @@ mod tests {
    use super::*;
    use crate::svm::Kernels;

+    #[test]
+    fn rbf_kernel() {
+        let v1 = vec![1., 2., 3.];
+        let v2 = vec![4., 5., 6.];
+        let result = Kernels::rbf()
+            .with_gamma(0.055)
+            .apply(&v1, &v2)
+            .unwrap()
+            .abs();
+        assert!((0.2265f64 - result) < 1e-4);
+    }
+
    #[cfg_attr(
        all(target_arch = "wasm32", not(target_os = "wasi")),
        wasm_bindgen_test::wasm_bindgen_test
@@ -264,7 +364,7 @@ mod tests {
        wasm_bindgen_test::wasm_bindgen_test
    )]
    #[test]
-    fn rbf_kernel() {
+    fn test_rbf_kernel() {
        let v1 = vec![1., 2., 3.];
        let v2 = vec![4., 5., 6.];

@@ -287,12 +387,15 @@ mod tests {
        let v2 = vec![4., 5., 6.];

        let result = Kernels::polynomial()
-            .with_params(3.0, 0.5, 1.0)
+            .with_gamma(0.5)
+            .with_degree(3.0)
+            .with_coef0(1.0)
+            //.with_params(3.0, 0.5, 1.0)
            .apply(&v1, &v2)
            .unwrap()
            .abs();

-        assert!((4913f64 - result) < std::f64::EPSILON);
+        assert!((4913f64 - result).abs() < f64::EPSILON);
    }

    #[cfg_attr(
@@ -305,7 +408,8 @@ mod tests {
        let v2 = vec![4., 5., 6.];

        let result = Kernels::sigmoid()
-            .with_params(0.01, 0.1)
+            .with_gamma(0.01)
+            .with_coef0(0.1)
            .apply(&v1, &v2)
            .unwrap()
            .abs();
@@ -1,3 +1,5 @@
+//! SVC and Grid Search
+
 /// SVC search parameters
 pub mod svc_params;
 /// SVC search parameters
@@ -1,112 +1,293 @@
-// /// SVR grid search parameters
-// #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
-// #[derive(Debug, Clone)]
-// pub struct SVRSearchParameters<T: Number + RealNumber, M: Matrix<T>, K: Kernel<T, M::RowVector>> {
-//     /// Epsilon in the epsilon-SVR model.
-//     pub eps: Vec<T>,
-//     /// Regularization parameter.
-//     pub c: Vec<T>,
-//     /// Tolerance for stopping eps.
-//     pub tol: Vec<T>,
-//     /// The kernel function.
-//     pub kernel: Vec<K>,
-//     /// Unused parameter.
-//     m: PhantomData<M>,
-// }
+//! # SVR Grid Search Parameters
+//!
+//! This module provides utilities for defining and iterating over grid search parameter spaces
+//! for Support Vector Regression (SVR) models in [smartcore](https://github.com/smartcorelib/smartcore).
+//!
+//! The main struct, [`SVRSearchParameters`], allows users to specify multiple values for each
+//! SVR hyperparameter (epsilon, regularization parameter C, tolerance, and kernel function).
+//! The provided iterator yields all possible combinations (the Cartesian product) of these parameters,
+//! enabling exhaustive grid search for hyperparameter tuning.
+//!
+//!
+//! ## Example
+//! ```
+//! use smartcore::svm::Kernels;
+//! use smartcore::svm::search::svr_params::SVRSearchParameters;
+//! use smartcore::linalg::basic::matrix::DenseMatrix;
+//!
+//! let params = SVRSearchParameters::<f64, DenseMatrix<f64>> {
+//!     eps: vec![0.1, 0.2],
+//!     c: vec![1.0, 10.0],
+//!     tol: vec![1e-3],
+//!     kernel: vec![Kernels::linear(), Kernels::rbf().with_gamma(0.5)],
+//!     m: std::marker::PhantomData,
+//! };
+//!
+//! // for param_set in params.into_iter() {
+//!     // Use param_set (of type svr::SVRParameters) to fit and evaluate your SVR model.
+//! // }
+//! ```
+//!
+//!
+//! ## Note
+//! This module is intended for use with smartcore version 0.4 or later. The API is not compatible with older versions[1].
+#[cfg(feature = "serde")]
+use serde::{Deserialize, Serialize};

-// /// SVR grid search iterator
-// pub struct SVRSearchParametersIterator<T: Number + RealNumber, M: Matrix<T>, K: Kernel<T, M::RowVector>> {
-//     svr_search_parameters: SVRSearchParameters<T, M, K>,
-//     current_eps: usize,
-//     current_c: usize,
-//     current_tol: usize,
-//     current_kernel: usize,
-// }
+use crate::linalg::basic::arrays::Array2;
+use crate::numbers::basenum::Number;
+use crate::numbers::floatnum::FloatNumber;
+use crate::numbers::realnum::RealNumber;
+use crate::svm::{svr, Kernels};
+use std::marker::PhantomData;

-// impl<T: Number + RealNumber, M: Matrix<T>, K: Kernel<T, M::RowVector>> IntoIterator
-//     for SVRSearchParameters<T, M, K>
-// {
-//     type Item = SVRParameters<T, M, K>;
-//     type IntoIter = SVRSearchParametersIterator<T, M, K>;
+/// ## SVR grid search parameters
+/// A struct representing a grid of hyperparameters for SVR grid search in smartcore.
+///
+/// Each field is a vector of possible values for the corresponding SVR hyperparameter.
+/// The [`IntoIterator`] implementation yields every possible combination of these parameters
+/// as an `svr::SVRParameters` struct, suitable for use in model selection routines.
+///
+/// # Type Parameters
+/// - `T`: Numeric type for parameters (e.g., `f64`)
+/// - `M`: Matrix type implementing [`Array2<T>`]
+///
+/// # Fields
+/// - `eps`: Vector of epsilon values for the epsilon-insensitive loss in SVR.
+/// - `c`: Vector of regularization parameters (C) for SVR.
+/// - `tol`: Vector of tolerance values for the stopping criterion.
+/// - `kernel`: Vector of kernel function variants (see [`Kernels`]).
+/// - `m`: Phantom data for the matrix type parameter.
+///
+/// # Example
+/// ```
+/// use smartcore::svm::Kernels;
+/// use smartcore::svm::search::svr_params::SVRSearchParameters;
+/// use smartcore::linalg::basic::matrix::DenseMatrix;
+///
+/// let params = SVRSearchParameters::<f64, DenseMatrix<f64>> {
+///     eps: vec![0.1, 0.2],
+///     c: vec![1.0, 10.0],
+///     tol: vec![1e-3],
+///     kernel: vec![Kernels::linear(), Kernels::rbf().with_gamma(0.5)],
+///     m: std::marker::PhantomData,
+/// };
+/// ```
+#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
+#[derive(Debug, Clone)]
+pub struct SVRSearchParameters<T: Number + RealNumber, M: Array2<T>> {
+    /// Epsilon in the epsilon-SVR model.
+    pub eps: Vec<T>,
+    /// Regularization parameter.
+    pub c: Vec<T>,
+    /// Tolerance for stopping eps.
+    pub tol: Vec<T>,
+    /// The kernel function.
+    pub kernel: Vec<Kernels>,
+    /// Unused parameter.
+    pub m: PhantomData<M>,
+}

-//     fn into_iter(self) -> Self::IntoIter {
-//         SVRSearchParametersIterator {
-//             svr_search_parameters: self,
-//             current_eps: 0,
-//             current_c: 0,
-//             current_tol: 0,
-//             current_kernel: 0,
-//         }
-//     }
-// }
+/// SVR grid search iterator
+pub struct SVRSearchParametersIterator<T: Number + RealNumber, M: Array2<T>> {
+    svr_search_parameters: SVRSearchParameters<T, M>,
+    current_eps: usize,
+    current_c: usize,
+    current_tol: usize,
+    current_kernel: usize,
+}

-// impl<T: Number + RealNumber, M: Matrix<T>, K: Kernel<T, M::RowVector>> Iterator
-//     for SVRSearchParametersIterator<T, M, K>
-// {
-//     type Item = SVRParameters<T, M, K>;
+impl<T: Number + FloatNumber + RealNumber, M: Array2<T>> IntoIterator
+    for SVRSearchParameters<T, M>
+{
+    type Item = svr::SVRParameters<T>;
+    type IntoIter = SVRSearchParametersIterator<T, M>;

-//     fn next(&mut self) -> Option<Self::Item> {
-//         if self.current_eps == self.svr_search_parameters.eps.len()
-//             && self.current_c == self.svr_search_parameters.c.len()
-//             && self.current_tol == self.svr_search_parameters.tol.len()
-//             && self.current_kernel == self.svr_search_parameters.kernel.len()
-//         {
-//             return None;
-//         }
+    fn into_iter(self) -> Self::IntoIter {
+        SVRSearchParametersIterator {
+            svr_search_parameters: self,
+            current_eps: 0,
+            current_c: 0,
+            current_tol: 0,
+            current_kernel: 0,
+        }
+    }
+}

-//         let next = SVRParameters::<T, M, K> {
-//             eps: self.svr_search_parameters.eps[self.current_eps],
-//             c: self.svr_search_parameters.c[self.current_c],
-//             tol: self.svr_search_parameters.tol[self.current_tol],
-//             kernel: self.svr_search_parameters.kernel[self.current_kernel].clone(),
-//             m: PhantomData,
-//         };
+impl<T: Number + FloatNumber + RealNumber, M: Array2<T>> Iterator
+    for SVRSearchParametersIterator<T, M>
+{
+    type Item = svr::SVRParameters<T>;

-//         if self.current_eps + 1 < self.svr_search_parameters.eps.len() {
-//             self.current_eps += 1;
-//         } else if self.current_c + 1 < self.svr_search_parameters.c.len() {
-//             self.current_eps = 0;
-//             self.current_c += 1;
-//         } else if self.current_tol + 1 < self.svr_search_parameters.tol.len() {
-//             self.current_eps = 0;
-//             self.current_c = 0;
-//             self.current_tol += 1;
-//         } else if self.current_kernel + 1 < self.svr_search_parameters.kernel.len() {
-//             self.current_eps = 0;
-//             self.current_c = 0;
-//             self.current_tol = 0;
-//             self.current_kernel += 1;
-//         } else {
-//             self.current_eps += 1;
-//             self.current_c += 1;
-//             self.current_tol += 1;
-//             self.current_kernel += 1;
-//         }
+    fn next(&mut self) -> Option<Self::Item> {
+        if self.current_eps == self.svr_search_parameters.eps.len()
+            && self.current_c == self.svr_search_parameters.c.len()
+            && self.current_tol == self.svr_search_parameters.tol.len()
+            && self.current_kernel == self.svr_search_parameters.kernel.len()
+        {
+            return None;
+        }

-//         Some(next)
-//     }
-// }
+        let next = svr::SVRParameters::<T> {
+            eps: self.svr_search_parameters.eps[self.current_eps],
+            c: self.svr_search_parameters.c[self.current_c],
+            tol: self.svr_search_parameters.tol[self.current_tol],
+            kernel: Some(self.svr_search_parameters.kernel[self.current_kernel].clone()),
+        };

-// impl<T: Number + RealNumber, M: Matrix<T>> Default for SVRSearchParameters<T, M, LinearKernel> {
-//     fn default() -> Self {
-//         let default_params: SVRParameters<T, M, LinearKernel> = SVRParameters::default();
+        if self.current_eps + 1 < self.svr_search_parameters.eps.len() {
+            self.current_eps += 1;
+        } else if self.current_c + 1 < self.svr_search_parameters.c.len() {
+            self.current_eps = 0;
+            self.current_c += 1;
+        } else if self.current_tol + 1 < self.svr_search_parameters.tol.len() {
+            self.current_eps = 0;
+            self.current_c = 0;
+            self.current_tol += 1;
+        } else if self.current_kernel + 1 < self.svr_search_parameters.kernel.len() {
+            self.current_eps = 0;
+            self.current_c = 0;
+            self.current_tol = 0;
+            self.current_kernel += 1;
+        } else {
+            self.current_eps += 1;
+            self.current_c += 1;
+            self.current_tol += 1;
+            self.current_kernel += 1;
+        }

-//         SVRSearchParameters {
-//             eps: vec![default_params.eps],
-//             c: vec![default_params.c],
-//             tol: vec![default_params.tol],
-//             kernel: vec![default_params.kernel],
-//             m: PhantomData,
-//         }
-//     }
-// }
+        Some(next)
+    }
+}

-// #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
-// #[derive(Debug)]
-// #[cfg_attr(
-//     feature = "serde",
-//     serde(bound(
-//         serialize = "M::RowVector: Serialize, K: Serialize, T: Serialize",
-//         deserialize = "M::RowVector: Deserialize<'de>, K: Deserialize<'de>, T: Deserialize<'de>",
-//     ))
-// )]
+impl<T: Number + FloatNumber + RealNumber, M: Array2<T>> Default for SVRSearchParameters<T, M> {
+    fn default() -> Self {
+        let default_params: svr::SVRParameters<T> = svr::SVRParameters::default();
+
+        SVRSearchParameters {
+            eps: vec![default_params.eps],
+            c: vec![default_params.c],
+            tol: vec![default_params.tol],
+            kernel: vec![default_params.kernel.unwrap_or_else(Kernels::linear)],
+            m: PhantomData,
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::linalg::basic::matrix::DenseMatrix;
+    use crate::svm::Kernels;
+
+    type T = f64;
+    type M = DenseMatrix<T>;
+
+    #[test]
+    fn test_default_parameters() {
+        let params = SVRSearchParameters::<T, M>::default();
+        assert_eq!(params.eps.len(), 1);
+        assert_eq!(params.c.len(), 1);
+        assert_eq!(params.tol.len(), 1);
+        assert_eq!(params.kernel.len(), 1);
+        // Check that the default kernel is linear
+        assert_eq!(params.kernel[0], Kernels::linear());
+    }
+
+    #[test]
+    fn test_single_grid_iteration() {
+        let params = SVRSearchParameters::<T, M> {
+            eps: vec![0.1],
+            c: vec![1.0],
+            tol: vec![1e-3],
+            kernel: vec![Kernels::rbf().with_gamma(0.5)],
+            m: PhantomData,
+        };
+        let mut iter = params.into_iter();
+        let param = iter.next().unwrap();
+        assert_eq!(param.eps, 0.1);
+        assert_eq!(param.c, 1.0);
+        assert_eq!(param.tol, 1e-3);
+        assert_eq!(param.kernel, Some(Kernels::rbf().with_gamma(0.5)));
+        assert!(iter.next().is_none());
+    }
+
+    #[test]
+    fn test_cartesian_grid_iteration() {
+        let params = SVRSearchParameters::<T, M> {
+            eps: vec![0.1, 0.2],
+            c: vec![1.0, 2.0],
+            tol: vec![1e-3],
+            kernel: vec![Kernels::linear(), Kernels::rbf().with_gamma(0.5)],
+            m: PhantomData,
+        };
+        let expected_count =
+            params.eps.len() * params.c.len() * params.tol.len() * params.kernel.len();
+        let results: Vec<_> = params.into_iter().collect();
+        assert_eq!(results.len(), expected_count);
+
+        // Check that all parameter combinations are present
+        let mut seen = vec![];
+        for p in &results {
+            seen.push((p.eps, p.c, p.tol, p.kernel.clone().unwrap()));
+        }
+        for &eps in &[0.1, 0.2] {
+            for &c in &[1.0, 2.0] {
+                for &tol in &[1e-3] {
+                    for kernel in &[Kernels::linear(), Kernels::rbf().with_gamma(0.5)] {
+                        assert!(seen.contains(&(eps, c, tol, kernel.clone())));
+                    }
+                }
+            }
+        }
+    }
+
+    #[test]
+    fn test_empty_grid() {
+        let params = SVRSearchParameters::<T, M> {
+            eps: vec![],
+            c: vec![],
+            tol: vec![],
+            kernel: vec![],
+            m: PhantomData,
+        };
+        let mut iter = params.into_iter();
+        assert!(iter.next().is_none());
+    }
+
+    #[test]
+    fn test_kernel_enum_variants() {
+        let lin = Kernels::linear();
+        let rbf = Kernels::rbf().with_gamma(0.2);
+        let poly = Kernels::polynomial()
+            .with_degree(2.0)
+            .with_gamma(1.0)
+            .with_coef0(0.5);
+        let sig = Kernels::sigmoid().with_gamma(0.3).with_coef0(0.1);
+
+        assert_eq!(lin, Kernels::Linear);
+        match rbf {
+            Kernels::RBF { gamma } => assert_eq!(gamma, Some(0.2)),
+            _ => panic!("Not RBF"),
+        }
+        match poly {
+            Kernels::Polynomial {
+                degree,
+                gamma,
+                coef0,
+            } => {
+                assert_eq!(degree, Some(2.0));
+                assert_eq!(gamma, Some(1.0));
+                assert_eq!(coef0, Some(0.5));
+            }
+            _ => panic!("Not Polynomial"),
+        }
+        match sig {
+            Kernels::Sigmoid { gamma, coef0 } => {
+                assert_eq!(gamma, Some(0.3));
+                assert_eq!(coef0, Some(0.1));
+            }
+            _ => panic!("Not Sigmoid"),
+        }
+    }
+}
@@ -58,10 +58,11 @@
 //!            1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1];
 //!
 //! let knl = Kernels::linear();
-//! let params = &SVCParameters::default().with_c(200.0).with_kernel(knl);
-//! let svc = SVC::fit(&x, &y, params).unwrap();
+//! let parameters = &SVCParameters::default().with_c(200.0).with_kernel(knl);
+//! let svc = SVC::fit(&x, &y, parameters).unwrap();
 //!
 //! let y_hat = svc.predict(&x).unwrap();
+//!
 //! ```
 //!
 //! ## References:
@@ -84,12 +85,194 @@ use serde::{Deserialize, Serialize};

 use crate::api::{PredictorBorrow, SupervisedEstimatorBorrow};
 use crate::error::{Failed, FailedError};
-use crate::linalg::basic::arrays::{Array1, Array2, MutArray};
+use crate::linalg::basic::arrays::{Array, Array1, Array2, MutArray};
 use crate::numbers::basenum::Number;
 use crate::numbers::realnum::RealNumber;
 use crate::rand_custom::get_rng_impl;
 use crate::svm::Kernel;

+#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
+#[derive(Debug)]
+/// Configuration for a multi-class Support Vector Machine (SVM) classifier.
+/// This struct holds the indices of the data points relevant to a specific binary
+/// classification problem within a multi-class context, and the two classes
+/// being discriminated.
+struct MultiClassConfig<TY: Number + Ord> {
+    /// The indices of the data points from the original dataset that belong to the two `classes`.
+    indices: Vec<usize>,
+    /// A tuple representing the two classes that this configuration is designed to distinguish.
+    classes: (TY, TY),
+}
+
+impl<'a, TX: Number + RealNumber, TY: Number + Ord, X: Array2<TX>, Y: Array1<TY>>
+    SupervisedEstimatorBorrow<'a, X, Y, SVCParameters<TX, TY, X, Y>>
+    for MultiClassSVC<'a, TX, TY, X, Y>
+{
+    /// Creates a new, empty `MultiClassSVC` instance.
+    fn new() -> Self {
+        Self {
+            classifiers: Option::None,
+        }
+    }
+
+    /// Fits the `MultiClassSVC` model to the provided data and parameters.
+    ///
+    /// This method delegates the fitting process to the inherent `MultiClassSVC::fit` method.
+    ///
+    /// # Arguments
+    /// * `x` - A reference to the input features (2D array).
+    /// * `y` - A reference to the target labels (1D array).
+    /// * `parameters` - A reference to the `SVCParameters` controlling the SVM training.
+    ///
+    /// # Returns
+    /// A `Result` indicating success (`Self`) or failure (`Failed`).
+    fn fit(
+        x: &'a X,
+        y: &'a Y,
+        parameters: &'a SVCParameters<TX, TY, X, Y>,
+    ) -> Result<Self, Failed> {
+        MultiClassSVC::fit(x, y, parameters)
+    }
+}
+
+impl<'a, TX: Number + RealNumber, TY: Number + Ord, X: Array2<TX>, Y: Array1<TY>>
+    PredictorBorrow<'a, X, TX> for MultiClassSVC<'a, TX, TY, X, Y>
+{
+    /// Predicts the class labels for new data points.
+    ///
+    /// This method delegates the prediction process to the inherent `MultiClassSVC::predict` method.
+    ///
+    /// # Arguments
+    /// * `x` - A reference to the input features (2D array) for which to make predictions.
+    ///
+    /// # Returns
+    /// A `Result` containing a `Vec` of predicted class labels (`TX`) or a `Failed` error.
+    fn predict(&self, x: &'a X) -> Result<Vec<TX>, Failed> {
+        Ok(self.predict(x).unwrap())
+    }
+}
+
+/// A multi-class Support Vector Machine (SVM) classifier.
+///
+/// This struct implements a multi-class SVM using the "one-vs-one" strategy,
+/// where a separate binary SVC classifier is trained for every pair of classes.
+///
+/// # Type Parameters
+/// * `'a` - Lifetime parameter for borrowed data.
+/// * `TX` - The numeric type of the input features (must implement `Number` and `RealNumber`).
+/// * `TY` - The numeric type of the target labels (must implement `Number` and `Ord`).
+/// * `X` - The type representing the 2D array of input features (e.g., a matrix).
+/// * `Y` - The type representing the 1D array of target labels (e.g., a vector).
+pub struct MultiClassSVC<
+    'a,
+    TX: Number + RealNumber,
+    TY: Number + Ord,
+    X: Array2<TX>,
+    Y: Array1<TY>,
+> {
+    /// An optional vector of binary `SVC` classifiers.
+    classifiers: Option<Vec<SVC<'a, TX, TY, X, Y>>>,
+}
+
+impl<'a, TX: Number + RealNumber, TY: Number + Ord, X: Array2<TX>, Y: Array1<TY>>
+    MultiClassSVC<'a, TX, TY, X, Y>
+{
+    /// Fits the `MultiClassSVC` model to the provided data using a one-vs-one strategy.
+    ///
+    /// This method identifies all unique classes in the target labels `y` and then
+    /// trains a binary `SVC` for every unique pair of classes. For each pair, it
+    /// extracts the relevant data points and their labels, and then trains a
+    /// specialized `SVC` for that binary classification task.
+    ///
+    /// # Arguments
+    /// * `x` - A reference to the input features (2D array).
+    /// * `y` - A reference to the target labels (1D array).
+    /// * `parameters` - A reference to the `SVCParameters` controlling the SVM training for each individual binary classifier.
+    ///  
+    ///
+    /// # Returns
+    /// A `Result` indicating success (`MultiClassSVC`) or failure (`Failed`).
+    pub fn fit(
+        x: &'a X,
+        y: &'a Y,
+        parameters: &'a SVCParameters<TX, TY, X, Y>,
+    ) -> Result<MultiClassSVC<'a, TX, TY, X, Y>, Failed> {
+        let unique_classes = y.unique();
+        let mut classifiers = Vec::new();
+        // Iterate through all unique pairs of classes (one-vs-one strategy)
+        for i in 0..unique_classes.len() {
+            for j in i..unique_classes.len() {
+                if i == j {
+                    continue;
+                }
+                let class0 = unique_classes[j];
+                let class1 = unique_classes[i];
+
+                let mut indices = Vec::new();
+                // Collect indices of data points belonging to the current pair of classes
+                for (index, v) in y.iterator(0).enumerate() {
+                    if *v == class0 || *v == class1 {
+                        indices.push(index)
+                    }
+                }
+                let classes = (class0, class1);
+                let multiclass_config = MultiClassConfig { classes, indices };
+                // Fit a binary SVC for the current pair of classes
+                let svc = SVC::multiclass_fit(x, y, parameters, multiclass_config).unwrap();
+                classifiers.push(svc);
+            }
+        }
+        Ok(Self {
+            classifiers: Some(classifiers),
+        })
+    }
+
+    /// Predicts the class labels for new data points using the trained multi-class SVM.
+    ///
+    /// This method uses a "voting" scheme (majority vote) among all the binary
+    /// classifiers to determine the final prediction for each data point.
+    ///
+    /// # Arguments
+    /// * `x` - A reference to the input features (2D array) for which to make predictions.
+    ///
+    /// # Returns
+    /// A `Result` containing a `Vec` of predicted class labels (`TX`) or a `Failed` error.
+    ///
+    pub fn predict(&self, x: &X) -> Result<Vec<TX>, Failed> {
+        // Initialize a HashMap for each data point to store votes for each class
+        let mut polls = vec![HashMap::new(); x.shape().0];
+        // Retrieve the trained binary classifiers
+        let classifiers = self.classifiers.as_ref().unwrap();
+
+        // Iterate through each binary classifier
+        for i in 0..classifiers.len() {
+            let svc = classifiers.get(i).unwrap();
+            let predictions = svc.predict(x).unwrap(); // call SVC::predict for each binary classifier
+
+            // For each prediction from the current binary classifier
+            for (j, prediction) in predictions.iter().enumerate() {
+                let prediction = prediction.to_i32().unwrap();
+                let poll = polls.get_mut(j).unwrap(); // Get the poll for the current data point
+                                                      // Increment the vote for the predicted class
+                if let Some(count) = poll.get_mut(&prediction) {
+                    *count += 1
+                } else {
+                    poll.insert(prediction, 1);
+                }
+            }
+        }
+
+        // Determine the final prediction for each data point based on majority vote
+        Ok(polls
+            .iter()
+            .map(|v| {
+                // Find the class with the maximum votes for each data point
+                TX::from(*v.iter().max_by_key(|(_, class)| *class).unwrap().0).unwrap()
+            })
+            .collect())
+    }
+}
+
 #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
 #[derive(Debug)]
 /// SVC Parameters
@@ -123,7 +306,7 @@ pub struct SVCParameters<TX: Number + RealNumber, TY: Number + Ord, X: Array2<TX
 )]
 /// Support Vector Classifier
 pub struct SVC<'a, TX: Number + RealNumber, TY: Number + Ord, X: Array2<TX>, Y: Array1<TY>> {
-    classes: Option<Vec<TY>>,
+    classes: Option<(TY, TY)>,
    instances: Option<Vec<Vec<TX>>>,
    #[cfg_attr(feature = "serde", serde(skip))]
    parameters: Option<&'a SVCParameters<TX, TY, X, Y>>,
@@ -152,7 +335,9 @@ struct Cache<TX: Number + RealNumber, TY: Number + Ord, X: Array2<TX>, Y: Array1
 struct Optimizer<'a, TX: Number + RealNumber, TY: Number + Ord, X: Array2<TX>, Y: Array1<TY>> {
    x: &'a X,
    y: &'a Y,
+    indices: Option<Vec<usize>>,
    parameters: &'a SVCParameters<TX, TY, X, Y>,
+    classes: &'a (TY, TY),
    svmin: usize,
    svmax: usize,
    gmin: TX,
@@ -180,12 +365,12 @@ impl<TX: Number + RealNumber, TY: Number + Ord, X: Array2<TX>, Y: Array1<TY>>
        self.tol = tol;
        self
    }
+
    /// The kernel function.
    pub fn with_kernel<K: Kernel + 'static>(mut self, kernel: K) -> Self {
        self.kernel = Some(Box::new(kernel));
        self
    }
-
    /// Seed for the pseudo random number generator.
    pub fn with_seed(mut self, seed: Option<u64>) -> Self {
        self.seed = seed;
@@ -241,17 +426,98 @@ impl<'a, TX: Number + RealNumber, TY: Number + Ord, X: Array2<TX>, Y: Array1<TY>
 impl<'a, TX: Number + RealNumber, TY: Number + Ord, X: Array2<TX> + 'a, Y: Array1<TY> + 'a>
    SVC<'a, TX, TY, X, Y>
 {
-    /// Fits SVC to your data.
-    /// * `x` - _NxM_ matrix with _N_ observations and _M_ features in each observation.
-    /// * `y` - class labels
-    /// * `parameters` - optional parameters, use `Default::default()` to set parameters to default values.
+    /// Fits a binary Support Vector Classifier (SVC) to the provided data.
+    ///
+    /// This is the primary `fit` method for a standalone binary SVC. It expects
+    /// the target labels `y` to contain exactly two unique classes. If more or
+    /// fewer than two classes are found, it returns an error. It then extracts
+    /// these two classes and proceeds to optimize and fit the SVC model.
+    ///
+    /// # Arguments
+    /// * `x` - A reference to the input features (2D array) of the training data.
+    /// * `y` - A reference to the target labels (1D array) of the training data. `y` must contain exactly two unique class labels.
+    /// * `parameters` - A reference to the `SVCParameters` controlling the training process.
+    ///
+    /// # Returns
+    /// A `Result` which is:
+    /// - `Ok(SVC<'a, TX, TY, X, Y>)`: A new, fitted binary SVC instance.
+    /// - `Err(Failed)`: If the number of unique classes in `y` is not exactly two, or if the underlying optimization fails.
    pub fn fit(
        x: &'a X,
        y: &'a Y,
        parameters: &'a SVCParameters<TX, TY, X, Y>,
    ) -> Result<SVC<'a, TX, TY, X, Y>, Failed> {
-        let (n, _) = x.shape();
+        let classes = y.unique();
+        // Validate that there are exactly two unique classes in the target labels.
+        if classes.len() != 2 {
+            return Err(Failed::fit(&format!(
+                "Incorrect number of classes: {}. A binary SVC requires exactly two classes.",
+                classes.len()
+            )));
+        }
+        let classes = (classes[0], classes[1]);
+        let svc = Self::optimize_and_fit(x, y, parameters, classes, None);
+        svc
+    }

+    /// Fits a binary Support Vector Classifier (SVC) specifically for multi-class scenarios.
+    ///
+    /// This function is intended to be called by a multi-class strategy (e.g., one-vs-one)
+    /// to train individual binary SVCs. It takes a `MultiClassConfig` which specifies
+    /// the two classes this SVC should discriminate and the subset of data indices
+    /// relevant to these classes. It then delegates the actual optimization and fitting
+    /// to `optimize_and_fit`.
+    ///
+    /// # Arguments
+    /// * `x` - A reference to the input features (2D array) of the training data.
+    /// * `y` - A reference to the target labels (1D array) of the training data.
+    /// * `parameters` - A reference to the `SVCParameters` controlling the training process (e.g., kernel, C-value, tolerance).
+    /// * `multiclass_config` - A `MultiClassConfig` struct containing:
+    ///     - `classes`: A tuple `(class0, class1)` specifying the two classes this SVC should distinguish.
+    ///     - `indices`: A `Vec<usize>` containing the indices of the data points in `x` and `y that belong to either `class0` or `class1`.`
+    ///
+    /// # Returns
+    /// A `Result` which is:
+    /// - `Ok(SVC<'a, TX, TY, X, Y>)`: A new, fitted binary SVC instance.
+    /// - `Err(Failed)`: If the fitting process encounters an error (e.g., invalid parameters).
+    fn multiclass_fit(
+        x: &'a X,
+        y: &'a Y,
+        parameters: &'a SVCParameters<TX, TY, X, Y>,
+        multiclass_config: MultiClassConfig<TY>,
+    ) -> Result<SVC<'a, TX, TY, X, Y>, Failed> {
+        let classes = multiclass_config.classes;
+        let indices = multiclass_config.indices;
+        let svc = Self::optimize_and_fit(x, y, parameters, classes, Some(indices));
+        svc
+    }
+
+    /// Internal function to optimize and fit the Support Vector Classifier.
+    ///
+    /// This is the core logic for training a binary SVC. It performs several checks
+    /// (e.g., kernel presence, data shape consistency) and then initializes an
+    /// `Optimizer` to find the support vectors, weights (`w`), and bias (`b`).
+    ///
+    /// # Arguments
+    /// * `x` - A reference to the input features (2D array) of the training data.
+    /// * `y` - A reference to the target labels (1D array) of the training data.
+    /// * `parameters` - A reference to the `SVCParameters` defining the SVM model's configuration.
+    /// * `classes` - A tuple `(class0, class1)` representing the two distinct class labels that the SVC will learn to separate.
+    /// * `indices` - An `Option<Vec<usize>>`. If `Some`, it contains the specific indices of data points from `x` and `y` that should be used for training this binary classifier. If `None`, all data points in `x` and `y` are considered.
+    /// # Returns
+    /// A `Result` which is:
+    /// - `Ok(SVC<'a, TX, TY, X, Y>)`: A new `SVC` instance populated with the learned model components (support vectors, weights, bias).
+    /// - `Err(Failed)`: If any of the validation checks fail (e.g., missing kernel, mismatched data shapes), or if the optimization process fails.
+    fn optimize_and_fit(
+        x: &'a X,
+        y: &'a Y,
+        parameters: &'a SVCParameters<TX, TY, X, Y>,
+        classes: (TY, TY),
+        indices: Option<Vec<usize>>,
+    ) -> Result<SVC<'a, TX, TY, X, Y>, Failed> {
+        let (n_samples, _) = x.shape();
+
+        // Validate that a kernel has been defined in the parameters.
        if parameters.kernel.is_none() {
            return Err(Failed::because(
                FailedError::ParametersError,
@@ -259,55 +525,39 @@ impl<'a, TX: Number + RealNumber, TY: Number + Ord, X: Array2<TX> + 'a, Y: Array
            ));
        }

-        if n != y.shape() {
+        // Validate that the number of samples in X matches the number of labels in Y.
+        if n_samples != y.shape() {
            return Err(Failed::fit(
-                "Number of rows of X doesn\'t match number of rows of Y",
+                "Number of rows of X doesn't match number of rows of Y",
            ));
        }

-        let classes = y.unique();
-
-        if classes.len() != 2 {
-            return Err(Failed::fit(&format!(
-                "Incorrect number of classes: {}",
-                classes.len()
-            )));
-        }
-
-        // Make sure class labels are either 1 or -1
-        for e in y.iterator(0) {
-            let y_v = e.to_i32().unwrap();
-            if y_v != -1 && y_v != 1 {
-                return Err(Failed::because(
-                    FailedError::ParametersError,
-                    "Class labels must be 1 or -1",
-                ));
-            }
-        }
-
-        let optimizer: Optimizer<'_, TX, TY, X, Y> = Optimizer::new(x, y, parameters);
+        let optimizer: Optimizer<'_, TX, TY, X, Y> =
+            Optimizer::new(x, y, indices, parameters, &classes);

+        // Perform the optimization to find the support vectors, weight vector, and bias.
+        // This is where the core SVM algorithm (e.g., SMO) would run.
        let (support_vectors, weight, b) = optimizer.optimize();

+        // Construct and return the fitted SVC model.
        Ok(SVC::<'a> {
-            classes: Some(classes),
-            instances: Some(support_vectors),
-            parameters: Some(parameters),
-            w: Some(weight),
-            b: Some(b),
-            phantomdata: PhantomData,
+            classes: Some(classes), // Store the two classes the SVC was trained on.
+            instances: Some(support_vectors), // Store the data points that are support vectors.
+            parameters: Some(parameters), // Reference to the parameters used for fitting.
+            w: Some(weight),        // The learned weight vector (for linear kernels).
+            b: Some(b),             // The learned bias term.
+            phantomdata: PhantomData, // Placeholder for type parameters not directly stored.
        })
    }
-
    /// Predicts estimated class labels from `x`
    /// * `x` - _KxM_ data where _K_ is number of observations and _M_ is number of features.
    pub fn predict(&self, x: &'a X) -> Result<Vec<TX>, Failed> {
        let mut y_hat: Vec<TX> = self.decision_function(x)?;

        for i in 0..y_hat.len() {
-            let cls_idx = match *y_hat.get(i).unwrap() > TX::zero() {
-                false => TX::from(self.classes.as_ref().unwrap()[0]).unwrap(),
-                true => TX::from(self.classes.as_ref().unwrap()[1]).unwrap(),
+            let cls_idx = match *y_hat.get(i) > TX::zero() {
+                false => TX::from(self.classes.as_ref().unwrap().0).unwrap(),
+                true => TX::from(self.classes.as_ref().unwrap().1).unwrap(),
            };

            y_hat.set(i, cls_idx);
@@ -360,8 +610,8 @@ impl<'a, TX: Number + RealNumber, TY: Number + Ord, X: Array2<TX> + 'a, Y: Array
    }
 }

-impl<'a, TX: Number + RealNumber, TY: Number + Ord, X: Array2<TX>, Y: Array1<TY>> PartialEq
-    for SVC<'a, TX, TY, X, Y>
+impl<TX: Number + RealNumber, TY: Number + Ord, X: Array2<TX>, Y: Array1<TY>> PartialEq
+    for SVC<'_, TX, TY, X, Y>
 {
    fn eq(&self, other: &Self) -> bool {
        if (self.b.unwrap().sub(other.b.unwrap())).abs() > TX::epsilon() * TX::two()
@@ -445,14 +695,18 @@ impl<'a, TX: Number + RealNumber, TY: Number + Ord, X: Array2<TX>, Y: Array1<TY>
    fn new(
        x: &'a X,
        y: &'a Y,
+        indices: Option<Vec<usize>>,
        parameters: &'a SVCParameters<TX, TY, X, Y>,
+        classes: &'a (TY, TY),
    ) -> Optimizer<'a, TX, TY, X, Y> {
        let (n, _) = x.shape();

        Optimizer {
            x,
            y,
+            indices,
            parameters,
+            classes,
            svmin: 0,
            svmax: 0,
            gmin: <TX as Bounded>::max_value(),
@@ -478,7 +732,12 @@ impl<'a, TX: Number + RealNumber, TY: Number + Ord, X: Array2<TX>, Y: Array1<TY>
            for i in self.permutate(n) {
                x.clear();
                x.extend(self.x.get_row(i).iterator(0).take(n).copied());
-                self.process(i, &x, *self.y.get(i), &mut cache);
+                let y = if *self.y.get(i) == self.classes.1 {
+                    1
+                } else {
+                    -1
+                } as f64;
+                self.process(i, &x, y, &mut cache);
                loop {
                    self.reprocess(tol, &mut cache);
                    self.find_min_max_gradient();
@@ -514,14 +773,16 @@ impl<'a, TX: Number + RealNumber, TY: Number + Ord, X: Array2<TX>, Y: Array1<TY>
        for i in self.permutate(n) {
            x.clear();
            x.extend(self.x.get_row(i).iterator(0).take(n).copied());
-            if *self.y.get(i) == TY::one() && cp < few {
-                if self.process(i, &x, *self.y.get(i), cache) {
+            let y = if *self.y.get(i) == self.classes.1 {
+                1
+            } else {
+                -1
+            } as f64;
+            if y == 1.0 && cp < few {
+                if self.process(i, &x, y, cache) {
                    cp += 1;
                }
-            } else if *self.y.get(i) == TY::from(-1).unwrap()
-                && cn < few
-                && self.process(i, &x, *self.y.get(i), cache)
-            {
+            } else if y == -1.0 && cn < few && self.process(i, &x, y, cache) {
                cn += 1;
            }

@@ -531,14 +792,14 @@ impl<'a, TX: Number + RealNumber, TY: Number + Ord, X: Array2<TX>, Y: Array1<TY>
        }
    }

-    fn process(&mut self, i: usize, x: &[TX], y: TY, cache: &mut Cache<TX, TY, X, Y>) -> bool {
+    fn process(&mut self, i: usize, x: &[TX], y: f64, cache: &mut Cache<TX, TY, X, Y>) -> bool {
        for j in 0..self.sv.len() {
            if self.sv[j].index == i {
                return true;
            }
        }

-        let mut g: f64 = y.to_f64().unwrap();
+        let mut g = y;

        let mut cache_values: Vec<((usize, usize), TX)> = Vec::new();

@@ -559,8 +820,8 @@ impl<'a, TX: Number + RealNumber, TY: Number + Ord, X: Array2<TX>, Y: Array1<TY>
        self.find_min_max_gradient();

        if self.gmin < self.gmax
-            && ((y > TY::zero() && g < self.gmin.to_f64().unwrap())
-                || (y < TY::zero() && g > self.gmax.to_f64().unwrap()))
+            && ((y > 0.0 && g < self.gmin.to_f64().unwrap())
+                || (y < 0.0 && g > self.gmax.to_f64().unwrap()))
        {
            return false;
        }
@@ -590,7 +851,7 @@ impl<'a, TX: Number + RealNumber, TY: Number + Ord, X: Array2<TX>, Y: Array1<TY>
            ),
        );

-        if y > TY::zero() {
+        if y > 0.0 {
            self.smo(None, Some(0), TX::zero(), cache);
        } else {
            self.smo(Some(0), None, TX::zero(), cache);
@@ -647,7 +908,6 @@ impl<'a, TX: Number + RealNumber, TY: Number + Ord, X: Array2<TX>, Y: Array1<TY>
        let gmin = self.gmin;

        let mut idxs_to_drop: HashSet<usize> = HashSet::new();
-
        self.sv.retain(|v| {
            if v.alpha == 0f64
                && ((TX::from(v.grad).unwrap() >= gmax && TX::zero() >= TX::from(v.cmax).unwrap())
@@ -666,7 +926,11 @@ impl<'a, TX: Number + RealNumber, TY: Number + Ord, X: Array2<TX>, Y: Array1<TY>

    fn permutate(&self, n: usize) -> Vec<usize> {
        let mut rng = get_rng_impl(self.parameters.seed);
-        let mut range: Vec<usize> = (0..n).collect();
+        let mut range = if let Some(indices) = self.indices.clone() {
+            indices
+        } else {
+            (0..n).collect::<Vec<usize>>()
+        };
        range.shuffle(&mut rng);
        range
    }
@@ -965,12 +1229,12 @@ mod tests {
        ];

        let knl = Kernels::linear();
-        let params = SVCParameters::default()
+        let parameters = SVCParameters::default()
            .with_c(200.0)
            .with_kernel(knl)
            .with_seed(Some(100));

-        let y_hat = SVC::fit(&x, &y, &params)
+        let y_hat = SVC::fit(&x, &y, &parameters)
            .and_then(|lr| lr.predict(&x))
            .unwrap();
        let acc = accuracy(&y, &(y_hat.iter().map(|e| e.to_i32().unwrap()).collect()));
@@ -1070,6 +1334,56 @@ mod tests {
        assert!(acc >= 0.9, "accuracy ({acc}) is not larger or equal to 0.9");
    }

+    #[cfg_attr(
+        all(target_arch = "wasm32", not(target_os = "wasi")),
+        wasm_bindgen_test::wasm_bindgen_test
+    )]
+    #[test]
+    fn svc_multiclass_fit_predict() {
+        let x = DenseMatrix::from_2d_array(&[
+            &[5.1, 3.5, 1.4, 0.2],
+            &[4.9, 3.0, 1.4, 0.2],
+            &[4.7, 3.2, 1.3, 0.2],
+            &[4.6, 3.1, 1.5, 0.2],
+            &[5.0, 3.6, 1.4, 0.2],
+            &[5.4, 3.9, 1.7, 0.4],
+            &[4.6, 3.4, 1.4, 0.3],
+            &[5.0, 3.4, 1.5, 0.2],
+            &[4.4, 2.9, 1.4, 0.2],
+            &[4.9, 3.1, 1.5, 0.1],
+            &[7.0, 3.2, 4.7, 1.4],
+            &[6.4, 3.2, 4.5, 1.5],
+            &[6.9, 3.1, 4.9, 1.5],
+            &[5.5, 2.3, 4.0, 1.3],
+            &[6.5, 2.8, 4.6, 1.5],
+            &[5.7, 2.8, 4.5, 1.3],
+            &[6.3, 3.3, 4.7, 1.6],
+            &[4.9, 2.4, 3.3, 1.0],
+            &[6.6, 2.9, 4.6, 1.3],
+            &[5.2, 2.7, 3.9, 1.4],
+        ])
+        .unwrap();
+
+        let y: Vec<i32> = vec![0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 2, 2];
+
+        let knl = Kernels::linear();
+        let parameters = SVCParameters::default()
+            .with_c(200.0)
+            .with_kernel(knl)
+            .with_seed(Some(100));
+
+        let y_hat = MultiClassSVC::fit(&x, &y, &parameters)
+            .and_then(|lr| lr.predict(&x))
+            .unwrap();
+
+        let acc = accuracy(&y, &(y_hat.iter().map(|e| e.to_i32().unwrap()).collect()));
+
+        assert!(
+            acc >= 0.9,
+            "Multiclass accuracy ({acc}) is not larger or equal to 0.9"
+        );
+    }
+
    #[cfg_attr(
        all(target_arch = "wasm32", not(target_os = "wasi")),
        wasm_bindgen_test::wasm_bindgen_test
@@ -1106,11 +1420,11 @@ mod tests {
        ];

        let knl = Kernels::linear();
-        let params = SVCParameters::default().with_kernel(knl);
-        let svc = SVC::fit(&x, &y, &params).unwrap();
+        let parameters = SVCParameters::default().with_kernel(knl);
+        let svc = SVC::fit(&x, &y, &parameters).unwrap();

        // serialization
-        let deserialized_svc: SVC<f64, i32, _, _> =
+        let deserialized_svc: SVC<'_, f64, i32, _, _> =
            serde_json::from_str(&serde_json::to_string(&svc).unwrap()).unwrap();

        assert_eq!(svc, deserialized_svc);
@@ -51,9 +51,9 @@
 //!
 //! let knl = Kernels::linear();
 //! let params = &SVRParameters::default().with_eps(2.0).with_c(10.0).with_kernel(knl);
-//! // let svr = SVR::fit(&x, &y, params).unwrap();
+//! let svr = SVR::fit(&x, &y, params).unwrap();
 //!
-//! // let y_hat = svr.predict(&x).unwrap();
+//! let y_hat = svr.predict(&x).unwrap();
 //! ```
 //!
 //! ## References:
@@ -80,11 +80,12 @@ use crate::error::{Failed, FailedError};
 use crate::linalg::basic::arrays::{Array1, Array2, MutArray};
 use crate::numbers::basenum::Number;
 use crate::numbers::floatnum::FloatNumber;
-use crate::svm::Kernel;

+use crate::svm::{Kernel, Kernels};
+
+/// SVR Parameters
 #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
 #[derive(Debug)]
-/// SVR Parameters
 pub struct SVRParameters<T: Number + FloatNumber + PartialOrd> {
    /// Epsilon in the epsilon-SVR model.
    pub eps: T,
@@ -97,7 +98,7 @@ pub struct SVRParameters<T: Number + FloatNumber + PartialOrd> {
        all(feature = "serde", target_arch = "wasm32"),
        serde(skip_serializing, skip_deserializing)
    )]
-    pub kernel: Option<Box<dyn Kernel>>,
+    pub kernel: Option<Kernels>,
 }

 #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
@@ -160,8 +161,8 @@ impl<T: Number + FloatNumber + PartialOrd> SVRParameters<T> {
        self
    }
    /// The kernel function.
-    pub fn with_kernel<K: Kernel + 'static>(mut self, kernel: K) -> Self {
-        self.kernel = Some(Box::new(kernel));
+    pub fn with_kernel(mut self, kernel: Kernels) -> Self {
+        self.kernel = Some(kernel);
        self
    }
 }
@@ -281,8 +282,8 @@ impl<'a, T: Number + FloatNumber + PartialOrd, X: Array2<T>, Y: Array1<T>> SVR<'
    }
 }

-impl<'a, T: Number + FloatNumber + PartialOrd, X: Array2<T>, Y: Array1<T>> PartialEq
-    for SVR<'a, T, X, Y>
+impl<T: Number + FloatNumber + PartialOrd, X: Array2<T>, Y: Array1<T>> PartialEq
+    for SVR<'_, T, X, Y>
 {
    fn eq(&self, other: &Self) -> bool {
        if (self.b - other.b).abs() > T::epsilon() * T::two()
@@ -597,25 +598,25 @@ mod tests {
    use super::*;
    use crate::linalg::basic::matrix::DenseMatrix;
    use crate::metrics::mean_squared_error;
+    use crate::svm::search::svr_params::SVRSearchParameters;
    use crate::svm::Kernels;

-    // #[test]
-    // fn search_parameters() {
-    //     let parameters: SVRSearchParameters<f64, DenseMatrix<f64>, LinearKernel> =
-    //         SVRSearchParameters {
-    //             eps: vec![0., 1.],
-    //             kernel: vec![LinearKernel {}],
-    //             ..Default::default()
-    //         };
-    //     let mut iter = parameters.into_iter();
-    //     let next = iter.next().unwrap();
-    //     assert_eq!(next.eps, 0.);
+    #[test]
+    fn search_parameters() {
+        let parameters: SVRSearchParameters<f64, DenseMatrix<f64>> = SVRSearchParameters {
+            eps: vec![0., 1.],
+            kernel: vec![Kernels::linear()],
+            ..Default::default()
+        };
+        let mut iter = parameters.into_iter();
+        let next = iter.next().unwrap();
+        assert_eq!(next.eps, 0.);
        // assert_eq!(next.kernel, LinearKernel {});
        // let next = iter.next().unwrap();
        // assert_eq!(next.eps, 1.);
        // assert_eq!(next.kernel, LinearKernel {});
        // assert!(iter.next().is_none());
-    // }
+    }

    #[cfg_attr(
        all(target_arch = "wasm32", not(target_os = "wasi")),
@@ -648,7 +649,7 @@ mod tests {
            114.2, 115.7, 116.9,
        ];

-        let knl = Kernels::linear();
+        let knl: Kernels = Kernels::linear();
        let y_hat = SVR::fit(
            &x,
            &y,
@@ -702,7 +703,7 @@ mod tests {

        let svr = SVR::fit(&x, &y, &params).unwrap();

-        let deserialized_svr: SVR<f64, DenseMatrix<f64>, _> =
+        let deserialized_svr: SVR<'_, f64, DenseMatrix<f64>, _> =
            serde_json::from_str(&serde_json::to_string(&svr).unwrap()).unwrap();

        assert_eq!(svr, deserialized_svr);
@@ -77,7 +77,9 @@ use serde::{Deserialize, Serialize};

 use crate::api::{Predictor, SupervisedEstimator};
 use crate::error::Failed;
+use crate::linalg::basic::arrays::MutArray;
 use crate::linalg::basic::arrays::{Array1, Array2, MutArrayView1};
+use crate::linalg::basic::matrix::DenseMatrix;
 use crate::numbers::basenum::Number;
 use crate::rand_custom::get_rng_impl;

@@ -197,12 +199,12 @@ impl PartialEq for Node {
        self.output == other.output
            && self.split_feature == other.split_feature
            && match (self.split_value, other.split_value) {
-                (Some(a), Some(b)) => (a - b).abs() < std::f64::EPSILON,
+                (Some(a), Some(b)) => (a - b).abs() < f64::EPSILON,
                (None, None) => true,
                _ => false,
            }
            && match (self.split_score, other.split_score) {
-                (Some(a), Some(b)) => (a - b).abs() < std::f64::EPSILON,
+                (Some(a), Some(b)) => (a - b).abs() < f64::EPSILON,
                (None, None) => true,
                _ => false,
            }
@@ -613,7 +615,7 @@ impl<TX: Number + PartialOrd, TY: Number + Ord, X: Array2<TX>, Y: Array1<TY>>
            visitor_queue.push_back(visitor);
        }

-        while tree.depth() < tree.parameters().max_depth.unwrap_or(std::u16::MAX) {
+        while tree.depth() < tree.parameters().max_depth.unwrap_or(u16::MAX) {
            match visitor_queue.pop_front() {
                Some(node) => tree.split(node, mtry, &mut visitor_queue, &mut rng),
                None => break,
@@ -650,7 +652,7 @@ impl<TX: Number + PartialOrd, TY: Number + Ord, X: Array2<TX>, Y: Array1<TY>>
                    if node.true_child.is_none() && node.false_child.is_none() {
                        result = node.output;
                    } else if x.get((row, node.split_feature)).to_f64().unwrap()
-                        <= node.split_value.unwrap_or(std::f64::NAN)
+                        <= node.split_value.unwrap_or(f64::NAN)
                    {
                        queue.push_back(node.true_child.unwrap());
                    } else {
@@ -803,9 +805,7 @@ impl<TX: Number + PartialOrd, TY: Number + Ord, X: Array2<TX>, Y: Array1<TY>>
                    .get((i, self.nodes()[visitor.node].split_feature))
                    .to_f64()
                    .unwrap()
-                    <= self.nodes()[visitor.node]
-                        .split_value
-                        .unwrap_or(std::f64::NAN)
+                    <= self.nodes()[visitor.node].split_value.unwrap_or(f64::NAN)
                {
                    *true_sample = visitor.samples[i];
                    tc += *true_sample;
@@ -889,11 +889,77 @@ impl<TX: Number + PartialOrd, TY: Number + Ord, X: Array2<TX>, Y: Array1<TY>>
        }
        importances
    }
+
+    /// Predict class probabilities for the input samples.
+    ///
+    /// # Arguments
+    ///
+    /// * `x` - The input samples as a matrix where each row is a sample and each column is a feature.
+    ///
+    /// # Returns
+    ///
+    /// A `Result` containing a `DenseMatrix<f64>` where each row corresponds to a sample and each column
+    /// corresponds to a class. The values represent the probability of the sample belonging to each class.
+    ///
+    /// # Errors
+    ///
+    /// Returns an error if at least one row prediction process fails.
+    pub fn predict_proba(&self, x: &X) -> Result<DenseMatrix<f64>, Failed> {
+        let (n_samples, _) = x.shape();
+        let n_classes = self.classes().len();
+        let mut result = DenseMatrix::<f64>::zeros(n_samples, n_classes);
+
+        for i in 0..n_samples {
+            let probs = self.predict_proba_for_row(x, i)?;
+            for (j, &prob) in probs.iter().enumerate() {
+                result.set((i, j), prob);
+            }
+        }
+
+        Ok(result)
+    }
+
+    /// Predict class probabilities for a single input sample.
+    ///
+    /// # Arguments
+    ///
+    /// * `x` - The input matrix containing all samples.
+    /// * `row` - The index of the row in `x` for which to predict probabilities.
+    ///
+    /// # Returns
+    ///
+    /// A vector of probabilities, one for each class, representing the probability
+    /// of the input sample belonging to each class.
+    fn predict_proba_for_row(&self, x: &X, row: usize) -> Result<Vec<f64>, Failed> {
+        let mut node = 0;
+
+        while let Some(current_node) = self.nodes().get(node) {
+            if current_node.true_child.is_none() && current_node.false_child.is_none() {
+                // Leaf node reached
+                let mut probs = vec![0.0; self.classes().len()];
+                probs[current_node.output] = 1.0;
+                return Ok(probs);
+            }
+
+            let split_feature = current_node.split_feature;
+            let split_value = current_node.split_value.unwrap_or(f64::NAN);
+
+            if x.get((row, split_feature)).to_f64().unwrap() <= split_value {
+                node = current_node.true_child.unwrap();
+            } else {
+                node = current_node.false_child.unwrap();
+            }
+        }
+
+        // This should never happen if the tree is properly constructed
+        Err(Failed::predict("Nodes iteration did not reach leaf"))
+    }
 }

 #[cfg(test)]
 mod tests {
    use super::*;
+    use crate::linalg::basic::arrays::Array;
    use crate::linalg::basic::matrix::DenseMatrix;

    #[test]
@@ -925,17 +991,62 @@ mod tests {
    )]
    #[test]
    fn gini_impurity() {
-        assert!((impurity(&SplitCriterion::Gini, &[7, 3], 10) - 0.42).abs() < std::f64::EPSILON);
+        assert!((impurity(&SplitCriterion::Gini, &[7, 3], 10) - 0.42).abs() < f64::EPSILON);
        assert!(
            (impurity(&SplitCriterion::Entropy, &[7, 3], 10) - 0.8812908992306927).abs()
-                < std::f64::EPSILON
+                < f64::EPSILON
        );
        assert!(
            (impurity(&SplitCriterion::ClassificationError, &[7, 3], 10) - 0.3).abs()
-                < std::f64::EPSILON
+                < f64::EPSILON
        );
    }

+    #[cfg_attr(
+        all(target_arch = "wasm32", not(target_os = "wasi")),
+        wasm_bindgen_test::wasm_bindgen_test
+    )]
+    #[test]
+    fn test_predict_proba() {
+        let x: DenseMatrix<f64> = DenseMatrix::from_2d_array(&[
+            &[5.1, 3.5, 1.4, 0.2],
+            &[4.9, 3.0, 1.4, 0.2],
+            &[4.7, 3.2, 1.3, 0.2],
+            &[4.6, 3.1, 1.5, 0.2],
+            &[5.0, 3.6, 1.4, 0.2],
+            &[7.0, 3.2, 4.7, 1.4],
+            &[6.4, 3.2, 4.5, 1.5],
+            &[6.9, 3.1, 4.9, 1.5],
+            &[5.5, 2.3, 4.0, 1.3],
+            &[6.5, 2.8, 4.6, 1.5],
+        ])
+        .unwrap();
+        let y: Vec<usize> = vec![0, 0, 0, 0, 0, 1, 1, 1, 1, 1];
+
+        let tree = DecisionTreeClassifier::fit(&x, &y, Default::default()).unwrap();
+        let probabilities = tree.predict_proba(&x).unwrap();
+
+        assert_eq!(probabilities.shape(), (10, 2));
+
+        for row in 0..10 {
+            let row_sum: f64 = probabilities.get_row(row).sum();
+            assert!(
+                (row_sum - 1.0).abs() < 1e-6,
+                "Row probabilities should sum to 1"
+            );
+        }
+
+        // Check if the first 5 samples have higher probability for class 0
+        for i in 0..5 {
+            assert!(probabilities.get((i, 0)) > probabilities.get((i, 1)));
+        }
+
+        // Check if the last 5 samples have higher probability for class 1
+        for i in 5..10 {
+            assert!(probabilities.get((i, 1)) > probabilities.get((i, 0)));
+        }
+    }
+
    #[cfg_attr(
        all(target_arch = "wasm32", not(target_os = "wasi")),
        wasm_bindgen_test::wasm_bindgen_test
@@ -311,15 +311,15 @@ impl Node {

 impl PartialEq for Node {
    fn eq(&self, other: &Self) -> bool {
-        (self.output - other.output).abs() < std::f64::EPSILON
+        (self.output - other.output).abs() < f64::EPSILON
            && self.split_feature == other.split_feature
            && match (self.split_value, other.split_value) {
-                (Some(a), Some(b)) => (a - b).abs() < std::f64::EPSILON,
+                (Some(a), Some(b)) => (a - b).abs() < f64::EPSILON,
                (None, None) => true,
                _ => false,
            }
            && match (self.split_score, other.split_score) {
-                (Some(a), Some(b)) => (a - b).abs() < std::f64::EPSILON,
+                (Some(a), Some(b)) => (a - b).abs() < f64::EPSILON,
                (None, None) => true,
                _ => false,
            }
@@ -478,7 +478,7 @@ impl<TX: Number + PartialOrd, TY: Number, X: Array2<TX>, Y: Array1<TY>>
            visitor_queue.push_back(visitor);
        }

-        while tree.depth() < tree.parameters().max_depth.unwrap_or(std::u16::MAX) {
+        while tree.depth() < tree.parameters().max_depth.unwrap_or(u16::MAX) {
            match visitor_queue.pop_front() {
                Some(node) => tree.split(node, mtry, &mut visitor_queue, &mut rng),
                None => break,
@@ -515,7 +515,7 @@ impl<TX: Number + PartialOrd, TY: Number, X: Array2<TX>, Y: Array1<TY>>
                    if node.true_child.is_none() && node.false_child.is_none() {
                        result = node.output;
                    } else if x.get((row, node.split_feature)).to_f64().unwrap()
-                        <= node.split_value.unwrap_or(std::f64::NAN)
+                        <= node.split_value.unwrap_or(f64::NAN)
                    {
                        queue.push_back(node.true_child.unwrap());
                    } else {
@@ -640,9 +640,7 @@ impl<TX: Number + PartialOrd, TY: Number, X: Array2<TX>, Y: Array1<TY>>
                    .get((i, self.nodes()[visitor.node].split_feature))
                    .to_f64()
                    .unwrap()
-                    <= self.nodes()[visitor.node]
-                        .split_value
-                        .unwrap_or(std::f64::NAN)
+                    <= self.nodes()[visitor.node].split_value.unwrap_or(f64::NAN)
                {
                    *true_sample = visitor.samples[i];
                    tc += *true_sample;
Author	SHA1	Message	Date
Lorenzo Mec-iS	681fea6cbe	fix clippy error	2025-07-03 11:59:18 +01:00
bendeez	038108b1c3	implemented single linkage clustering	2025-07-01 14:21:22 -05:00
Daniel Lacina	730c0d64df	implemented multiclass for svc (#308 ) * implemented multiclass for svc * modified the multiclass svc so it doesnt modify the current api	2025-06-16 11:00:11 +01:00
Lorenzo	44424807a0	Implement SVR and SVR kernels with Enum. Add tests for argsort_mut (#303 ) * Add tests for argsort_mut * Add formatting and cleaning up .github directory * fix clippy error. suggestion to use .contains() * define type explicitly for variable jstack * Implement kernel as enumerator * basic svr and svr_params implementation * Complete enum implementation for Kernels. Implement search grid for SVR. Add documentation. * Fix serde configuration in cargo clippy * Implement search parameters (#304) * Implement SVR kernels as enumerator * basic svr and svr_params implementation * Implement search grid for SVR. Add documentation. * Fix serde configuration in cargo clippy * Fix wasm32 typetag * fix typetag * Bump to version 0.4.2	2025-06-02 11:01:46 +01:00
morenol	76d1ef610d	Update Cargo.toml (#299 ) * Update Cargo.toml * chore: fix clippy * chore: bump actions * chore: fix clippy * chore: update target name --------- Co-authored-by: Luis Moreno <morenol@users.noreply.github.com>	2025-04-24 23:24:29 -04:00
Lorenzo	4092e24c2a	Update README.md	2025-02-04 14:26:53 +00:00
Lorenzo	17dc9f3bbf	Add ordered pairs for FastPair (#252 ) * Add ordered_pairs method to FastPair * add tests to fastpair	2025-01-28 00:48:08 +00:00
Lorenzo	c8ec8fec00	Fix #245 : return error for NaN in naive bayes (#246 ) * Fix #245: return error for NaN in naive bayes * Implement error handling for NaN values in NBayes predict: * general behaviour has been kept unchanged according to original tests in `mod.rs` * aka: error is returned only if all the predicted probabilities are NaN * Add tests * Add test with static values * Add test for numerical stability with numpy	2025-01-27 23:17:55 +00:00
Lorenzo	3da433f757	Implement predict_proba for DecisionTreeClassifier (#287 ) * Implement predict_proba for DecisionTreeClassifier * Some automated fixes suggested by cargo clippy --fix	2025-01-20 18:50:00 +00:00
dependabot[bot]	4523ac73ff	Update itertools requirement from 0.12.0 to 0.13.0 (#280 ) Updates the requirements on [itertools](https://github.com/rust-itertools/itertools) to permit the latest version. - [Changelog](https://github.com/rust-itertools/itertools/blob/master/CHANGELOG.md) - [Commits](https://github.com/rust-itertools/itertools/compare/v0.12.0...v0.13.0) --- updated-dependencies: - dependency-name: itertools dependency-type: direct:production ... Signed-off-by: dependabot[bot] <support@github.com> Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>	2024-11-25 11:47:23 -04:00
morenol	ba75f9ffad	chore: fix clippy (#283 ) * chore: fix clippy Co-authored-by: Luis Moreno <morenol@users.noreply.github.com>	2024-11-25 11:34:29 -04:00