Smartcore

https://docs.rs/smartcore
Admin
Smartcore is a comprehensive machine learning library for Rust, offering a wide array of algorithms...
Tokens:1,354,407
Snippets:10,757
Trust Score:9.7
Update:3 months ago
Show doc for...
Tokens:
Raw
### Example Search: u32 to bool

Source: https://docs.rs/smartcore/latest/smartcore/api/trait.NoParameters.html?search=std%3A%3Avec

This is an example search query for common Rust patterns.

```rust
u32 -> bool
```

--------------------------------

### Example Search Queries

Source: https://docs.rs/smartcore/latest/src/smartcore/svm/search/mod.rs.html?search=

Illustrates various example search queries. These demonstrate how to search for different types of data structures and function signatures.

```rust
  * std::vec
```

```rust
  * u32 -> bool
```

```rust
  * Option<T>, (T -> U) -> Option<U>
```

--------------------------------

### FastPair Example Usage

Source: https://docs.rs/smartcore/latest/src/smartcore/algorithm/neighbour/fastpair.rs.html?search=u32+-%3E+bool

Example demonstrating how to create a FastPair instance and find the closest pair in a dataset.

```APIDOC
## Example Usage

### Description
This example shows how to use the `FastPair` struct to find the closest pair of points in a given dataset.

### Code
```rust
use smartcore::metrics::distance::PairwiseDistance;
use smartcore::linalg::basic::matrix::DenseMatrix;
use smartcore::algorithm::neighbour::fastpair::FastPair;

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],
]).unwrap();

let fastpair = FastPair::new(&x);

if let Ok(fp) = fastpair {
    let closest_pair: PairwiseDistance<f64> = fp.closest_pair();
    // Process the closest_pair
}
```
```

--------------------------------

### Example Search: Option<T>, (T to U) to Option<U>

Source: https://docs.rs/smartcore/latest/smartcore/api/trait.NoParameters.html?search=std%3A%3Avec

This is an example search query for common Rust patterns.

```rust
Option<T>, (T -> U) -> Option<U>
```

--------------------------------

### K-Means Clustering Example in Rust

Source: https://docs.rs/smartcore/latest/smartcore/cluster/kmeans/index.html

Demonstrates how to perform K-Means clustering on a dataset using the smartcore library. This example initializes a DenseMatrix, fits a KMeans model with a specified number of clusters, and then predicts cluster assignments for the data points.

```rust
use smartcore::linalg::basic::matrix::DenseMatrix;
use smartcore::cluster::kmeans::*;

// Iris data
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 kmeans = KMeans::fit(&x, KMeansParameters::default().with_k(2)).unwrap(); // Fit to data, 2 clusters
let y_hat: Vec<u8> = kmeans.predict(&x).unwrap(); // use the same points for prediction

```

--------------------------------

### Example Search: std::vec

Source: https://docs.rs/smartcore/latest/smartcore/api/trait.NoParameters.html?search=std%3A%3Avec

This is an example search query for common Rust patterns.

```rust
std::vec
```

--------------------------------

### Example Searches

Source: https://docs.rs/smartcore/latest/smartcore/numbers/basenum/trait.Number.html?search=

Illustrative examples of search queries that can be performed. These demonstrate common patterns for searching within the smartcore library, such as searching for vector operations, type conversions, or functional transformations on options.

```text
* std::vec
* u32 -> bool
* Option<T>, (T -> U) -> Option<U>
```

--------------------------------

### Example Searches

Source: https://docs.rs/smartcore/latest/smartcore/ensemble/random_forest_regressor/struct.RandomForestRegressor.html?search=

Provides examples of search queries that can be used to find relevant information within the documentation.

```APIDOC
Example searches:
  * std::vec
  * u32 -> bool
  * Option<T>, (T -> U) -> Option<U>
```

--------------------------------

### Eigen Decomposition Example

Source: https://docs.rs/smartcore/latest/src/smartcore/linalg/traits/evd.rs.html?search=

Example demonstrating how to compute the eigen decomposition of a dense matrix using the `evd` method.

```APIDOC
## Example Usage

```rust
use smartcore::linalg::basic::matrix::DenseMatrix;
use smartcore::linalg::traits::evd::*;

let A = DenseMatrix::from_2d_array(&[
         &[0.9000, 0.4000, 0.7000],
         &[0.4000, 0.5000, 0.3000],
         &[0.7000, 0.3000, 0.8000],
]).unwrap();

let evd = A.evd(true).unwrap();
let eigenvectors: DenseMatrix<f64> = evd.V;
let eigenvalues: Vec<f64> = evd.d;
```
```

--------------------------------

### Linear Regression Usage Example

Source: https://docs.rs/smartcore/latest/src/smartcore/linear/linear_regression.rs.html?search=

This example demonstrates how to perform linear regression using the smartcore library. It includes data preparation, model fitting with a specified solver (QR decomposition), and prediction.

```APIDOC
## Linear Regression Example

### Description
This example demonstrates how to perform linear regression using the smartcore library. It includes data preparation, model fitting with a specified solver (QR decomposition), and prediction.

### Method
`LinearRegression::fit` and `LinearRegression::predict`

### Parameters for `fit`
- `x`: A `DenseMatrix` representing the explanatory variables.
- `y`: A `Vec<f64>` representing the quantitative response variable.
- `parameters`: `LinearRegressionParameters` to configure the solver.

### Parameters for `predict`
- `x`: A `DenseMatrix` representing the explanatory variables for which to predict the response.

### Request Example
```rust
use smartcore::linalg::basic::matrix::DenseMatrix;
use smartcore::linear::linear_regression::*

// Longley dataset (https://www.statsmodels.org/stable/datasets/generated/longley.html)
let x = DenseMatrix::from_2d_array(&[
              &[234.289, 235.6, 159.0, 107.608, 1947., 60.323],
              &[259.426, 232.5, 145.6, 108.632, 1948., 61.122],
              &[258.054, 368.2, 161.6, 109.773, 1949., 60.171],
              &[284.599, 335.1, 165.0, 110.929, 1950., 61.187],
              &[328.975, 209.9, 309.9, 112.075, 1951., 63.221],
              &[346.999, 193.2, 359.4, 113.270, 1952., 63.639],
              &[365.385, 187.0, 354.7, 115.094, 1953., 64.989],
              &[363.112, 357.8, 335.0, 116.219, 1954., 63.761],
              &[397.469, 290.4, 304.8, 117.388, 1955., 66.019],
              &[419.180, 282.2, 285.7, 118.734, 1956., 67.857],
              &[442.769, 293.6, 279.8, 120.445, 1957., 68.169],
              &[444.546, 468.1, 263.7, 121.950, 1958., 66.513],
              &[482.704, 381.3, 255.2, 123.366, 1959., 68.655],
              &[502.601, 393.1, 251.4, 125.368, 1960., 69.564],
              &[518.173, 480.6, 257.2, 127.852, 1961., 69.331],
              &[554.894, 400.7, 282.7, 130.081, 1962., 70.551],
         ]).unwrap();

let y: Vec<f64> = vec![83.0, 88.5, 88.2, 89.5, 96.2, 98.1, 99.0,
          100.0, 101.2, 104.6, 108.4, 110.8, 112.6, 114.2, 115.7, 116.9];

let lr = LinearRegression::fit(&x, &y,
            LinearRegressionParameters::default().
            with_solver(LinearRegressionSolverName::QR)).unwrap();

let y_hat = lr.predict(&x).unwrap();
```

### Response Example (Success)
`y_hat` will contain the predicted values.
```

--------------------------------

### Initialize FastPair with a Dataset

Source: https://docs.rs/smartcore/latest/src/smartcore/algorithm/neighbour/fastpair.rs.html?search=u32+-%3E+bool

Demonstrates how to initialize the FastPair algorithm with a dense matrix of f64 data. Asserts that the initialization is successful.

```rust
let x: DenseMatrix<f64> = DenseMatrix::rand(10, 4);
let _fastpair = FastPair::new(&x);
assert!(_fastpair.is_ok());
```

--------------------------------

### Instantiate SVRSearchParameters

Source: https://docs.rs/smartcore/latest/smartcore/svm/search/svr_params/struct.SVRSearchParameters.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Example of instantiating SVRSearchParameters with specific values for epsilon, C, tolerance, and kernel types. This setup is used to define the hyperparameter grid for SVR model selection.

```rust
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,
};
```

--------------------------------

### Example Matrix for Categorical Transformation Test

Source: https://docs.rs/smartcore/latest/src/smartcore/preprocessing/categorical.rs.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

This setup function creates a sample `DenseMatrix` with `f64` values, representing original data. This matrix is used in tests to verify the behavior of categorical transformations, particularly when categories appear in the first and last columns.

```rust
let orig = DenseMatrix::from_2d_array(&[
    &[1.0, 1.5, 3.0],
    &[2.0, 1.5, 4.0],
    &[1.0, 1.5, 5.0],
    &[2.0, 1.5, 6.0],
])
.unwrap();
```

--------------------------------

### Kernel Construction Examples

Source: https://docs.rs/smartcore/latest/smartcore/svm/enum.Kernels.html

Illustrates how to construct different kernel types using their respective variants and builder-style methods, including setting specific parameters like gamma, degree, and coef0.

```APIDOC
## §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);
```
```

--------------------------------

### FastPair Usage Example

Source: https://docs.rs/smartcore/latest/src/smartcore/algorithm/neighbour/fastpair.rs.html

Demonstrates how to initialize and use the FastPair algorithm to find the closest pair of points in a dataset. Requires importing necessary traits and types.

```rust
use smartcore::metrics::distance::PairwiseDistance;
use smartcore::linalg::basic::matrix::DenseMatrix;
use smartcore::algorithm::neighbour::fastpair::FastPair;
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],
]).unwrap();
let fastpair = FastPair::new(&x);
let closest_pair: PairwiseDistance<f64> = fastpair.unwrap().closest_pair();
```

--------------------------------

### Cover Tree Construction and Search Example

Source: https://docs.rs/smartcore/latest/src/smartcore/algorithm/neighbour/cover_tree.rs.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Demonstrates how to construct a CoverTree with custom distance metric and perform a k-nearest neighbor search.

```rust
use smartcore::algorithm::neighbour::cover_tree::*
use smartcore::metrics::distance::Distance;

#[derive(Clone)]
struct SimpleDistance {}

impl Distance<i32> for SimpleDistance {
  fn distance(&self, a: &i32, b: &i32) -> f64 {
    (a - b).abs() as f64
  }
}

let data = vec![1, 2, 3, 4, 5, 6, 7, 8, 9];

let mut tree = CoverTree::new(data, SimpleDistance {}).unwrap();

tree.find(&5, 3);

```

--------------------------------

### DBSCAN Parameters Search Examples

Source: https://docs.rs/smartcore/latest/smartcore/cluster/dbscan/struct.DBSCANParameters.html?search=

Examples of how to search for DBSCAN parameters and related type conversions.

```APIDOC
## Example Searches

### Searching for a specific type
```rust
std::vec
```

### Searching for type conversions
```rust
u32 -> bool
```

### Searching for generic type conversions with transformations
```rust
Option<T>, (T -> U) -> Option<U>
```
```

--------------------------------

### FastPair Initialization with Sample Data

Source: https://docs.rs/smartcore/latest/src/smartcore/algorithm/neighbour/fastpair.rs.html?search=u32+-%3E+bool

Initializes the FastPair algorithm with a predefined dataset of 15 points, each with 4 dimensions. It asserts that the initialization is successful and then unwraps the result.

```rust
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.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],
])
.unwrap();
let fastpair = FastPair::new(&x);
assert!(fastpair.is_ok());

let result = fastpair.unwrap();
```

--------------------------------

### QR Decomposition Example

Source: https://docs.rs/smartcore/latest/src/smartcore/linalg/traits/qr.rs.html

Demonstrates how to perform QR decomposition on a DenseMatrix and access the resulting Q and R matrices.

```APIDOC
## QR Decomposition Usage

### Description
This example shows how to compute the QR decomposition of a matrix and extract the orthogonal matrix Q and the upper triangular matrix R.

### Method
`qr()`

### Endpoint
N/A (SDK method)

### Parameters
None

### Request Example
```rust
use smartcore::linalg::basic::matrix::DenseMatrix;
use smartcore::linalg::traits::qr::QRDecomposable;

let A = DenseMatrix::from_2d_array(&[
        &[0.9, 0.4, 0.7],
        &[0.4, 0.5, 0.3],
        &[0.7, 0.3, 0.8]
]).unwrap();

let qr_result = A.qr().unwrap();
let orthogonal_q: DenseMatrix<f64> = qr_result.Q();
let triangular_r: DenseMatrix<f64> = qr_result.R();
```

### Response
- **Q**: An orthogonal matrix.
- **R**: An upper triangular matrix.

### Response Example
(The actual matrices Q and R would be printed here if the example were executed and the matrices displayed.)
```

--------------------------------

### Construct Kernels with Builder Methods

Source: https://docs.rs/smartcore/latest/smartcore/svm/enum.Kernels.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Demonstrates how to construct different kernel types using their respective builder-style methods. This example shows the creation of Linear, RBF, Polynomial, and Sigmoid kernels with specified parameters.

```rust
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);
```

--------------------------------

### SVD Decomposition Example

Source: https://docs.rs/smartcore/latest/src/smartcore/decomposition/svd.rs.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Performs Singular Value Decomposition on a dataset and extracts the principal components. This example uses the `USArrests` dataset for demonstration.

```rust
let x = DenseMatrix::from_2d_array(&[
            &[13.2, 236.0, 58.0, 21.2],
            &[10.0, 263.0, 48.0, 44.5],
            &[8.1, 294.0, 80.0, 31.0],
            &[8.8, 190.0, 50.0, 19.5],
            &[9.0, 276.0, 91.0, 40.6],
            &[7.9, 204.0, 78.0, 38.7],
            &[3.3, 110.0, 77.0, 11.1],
            &[5.9, 238.0, 72.0, 15.8],
            &[15.4, 335.0, 80.0, 31.9],
            &[17.4, 211.0, 60.0, 25.8],
            &[5.3, 46.0, 83.0, 20.2],
            &[2.6, 120.0, 54.0, 14.2],
            &[10.4, 249.0, 83.0, 24.0],
            &[7.2, 113.0, 65.0, 21.0],
            &[2.2, 56.0, 57.0, 11.3],
            &[6.0, 115.0, 66.0, 18.0],
            &[9.7, 109.0, 52.0, 16.3],
            &[15.4, 249.0, 66.0, 22.2],
            &[2.1, 83.0, 51.0, 7.8],
            &[11.3, 300.0, 67.0, 27.8],
            &[4.4, 149.0, 85.0, 16.3],
            &[12.1, 255.0, 74.0, 35.1],
            &[2.7, 72.0, 66.0, 14.9],
            &[16.1, 259.0, 44.0, 17.1],
            &[9.0, 178.0, 70.0, 28.2],
            &[6.0, 109.0, 53.0, 16.4],
            &[4.3, 102.0, 62.0, 16.5],
            &[12.2, 252.0, 81.0, 46.0],
            &[2.1, 57.0, 56.0, 9.5],
            &[7.4, 159.0, 89.0, 18.8],
            &[11.4, 285.0, 70.0, 32.1],
        ]);

        let svd = SVD::fit(&x, SVDParameters::default()).unwrap();
        let components = svd.components();

        let expected_components = DenseMatrix::from_2d_array(&[
            &[-0.023, -0.431, -0.715, -0.541],
            &[-0.035, -0.415, -0.685, -0.571],
            &[-0.048, -0.477, -0.659, -0.571],
            &[-0.047, -0.477, -0.659, -0.571],
        ]);

        for i in 0..components.shape().1 {
            assert!(relative_eq!(components.column(i), expected_components.column(i), epsilon = 1e-3));
        }
```

--------------------------------

### make_one_hot Function Signature and Example

Source: https://docs.rs/smartcore/latest/smartcore/preprocessing/series_encoder/fn.make_one_hot.html?search=

This snippet shows the function signature for `make_one_hot` and provides an example of its usage to create a one-hot encoded vector.

```APIDOC
## Function make_one_hot

### Description
Make a one-hot encoded vector from a categorical variable.

### Signature
```rust
pub fn make_one_hot<T, V>(category_idx: usize, num_categories: usize) -> V
where
    T: RealNumber,
    V: Array1<T>,
```

### Example
```rust
use smartcore::preprocessing::series_encoder::make_one_hot;
let one_hot: Vec<f64> = make_one_hot(2, 3);
assert_eq!(one_hot, vec![0.0, 0.0, 1.0]);
```
```

--------------------------------

### QR Decomposition Example

Source: https://docs.rs/smartcore/latest/src/smartcore/linalg/traits/qr.rs.html?search=

Demonstrates how to perform QR decomposition on a DenseMatrix and access the resulting orthogonal (Q) and upper triangular (R) matrices.

```APIDOC
## QR Decomposition Example

### Description
This example shows how to use the `qr()` method to decompose a matrix into its orthogonal (Q) and upper triangular (R) components.

### Method
`qr()`

### Endpoint
N/A (SDK method)

### Parameters
None

### Request Example
```rust
use smartcore::linalg::basic::matrix::DenseMatrix;
use smartcore::linalg::traits::qr::*;

let A = DenseMatrix::from_2d_array(&[
        &[0.9, 0.4, 0.7],
        &[0.4, 0.5, 0.3],
        &[0.7, 0.3, 0.8]
]).unwrap();

let qr = A.qr().unwrap();
let orthogonal: DenseMatrix<f64> = qr.Q();
let triangular: DenseMatrix<f64> = qr.R();
```

### Response
#### Success Response
The `qr()` method returns a `QR` struct containing the decomposed matrices.

- `Q()`: Returns the orthogonal matrix (Q).
- `R()`: Returns the upper triangular matrix (R).

#### Response Example
```rust
// Accessing Q and R matrices after decomposition:
let orthogonal: DenseMatrix<f64> = qr.Q();
let triangular: DenseMatrix<f64> = qr.R();
```
```

--------------------------------

### FastPair Initialization with Sample Data

Source: https://docs.rs/smartcore/latest/src/smartcore/algorithm/neighbour/fastpair.rs.html?search=std%3A%3Avec

Tests the FastPair initialization with a specific dataset and asserts that the operation is successful. It then checks the computed dissimilarities for specific pairs.

```rust
    #[test]
    fn fastpair_new() {
        // compute
        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.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],
        ])
        .unwrap();
        let fastpair = FastPair::new(&x);
        assert!(fastpair.is_ok());

        // unwrap results
        let result = fastpair.unwrap();

        // list of minimal pairwise dissimilarities
        let dissimilarities = vec![
            (
                1,
                PairwiseDistance {
                    node: 1,
                    neighbour: Some(9),
                    distance: Some(0.030000000000000037),
                },
            ),
            (
                10,
                PairwiseDistance {
                    node: 10,
                    neighbour: Some(12),
                    distance: Some(0.07000000000000003),
                },
            ),
            (
                11,
                PairwiseDistance {
                    node: 11,
                    neighbour: Some(14),
                    distance: Some(0.18000000000000013),
                },
            ),
            (
                12,
                PairwiseDistance {
                    node: 12,
                    
```

--------------------------------

### Vector Element Access and Modification

Source: https://docs.rs/smartcore/latest/src/smartcore/linalg/basic/vector.rs.html?search=

Shows how to get and set elements within a vector using `get` and `set` methods. Panics if the index is out of bounds.

```rust
let mut x = vec![1, 2, 3];
assert_eq!(3, *x.get(2));
x.set(1, 1);
assert_eq!(1, *x.get(1));
```

--------------------------------

### Classification Metrics Example

Source: https://docs.rs/smartcore/latest/src/smartcore/metrics/mod.rs.html

Demonstrates how to use Logistic Regression and calculate accuracy using ClassificationMetricsOrd. This example requires training a model and then predicting values to evaluate performance.

```rust
use smartcore::linalg::basic::matrix::DenseMatrix;
use smartcore::linear::logistic_regression::LogisticRegression;
use smartcore::metrics::*;

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<i8> = vec![
            0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
  ];

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

let y_hat = lr.predict(&x).unwrap();

let acc = ClassificationMetricsOrd::accuracy().get_score(&y, &y_hat);
// or
let acc = accuracy(&y, &y_hat);

```

--------------------------------

### LinearKNNSearch Example

Source: https://docs.rs/smartcore/latest/src/smartcore/algorithm/neighbour/linear_search.rs.html

Demonstrates how to initialize and use the LinearKNNSearch with a custom distance metric. Ensure your data points and distance metric are compatible.

```rust
use smartcore::algorithm::neighbour::linear_search::*
use smartcore::metrics::distance::Distance;

#[derive(Clone)]
struct SimpleDistance {}

impl Distance<i32> for SimpleDistance {
  fn distance(&self, a: &i32, b: &i32) -> f64 { // simple simmetrical scalar distance
    (a - b).abs() as f64
  }
}

let data = vec![1, 2, 3, 4, 5, 6, 7, 8, 9]; // data points

let knn = LinearKNNSearch::new(data, SimpleDistance {}).unwrap();

knn.find(&5, 3); // find 3 knn points from 5
```

--------------------------------

### Cover Tree Initialization and Search

Source: https://docs.rs/smartcore/latest/smartcore/algorithm/neighbour/cover_tree/index.html?search=

Demonstrates how to initialize a Cover Tree with custom distance metric and perform a nearest neighbor search. Requires importing necessary traits and types.

```rust
use smartcore::algorithm::neighbour::cover_tree::*;
use smartcore::metrics::distance::Distance;

#[derive(Clone)]
struct SimpleDistance {}

impl Distance<i32> for SimpleDistance {
  fn distance(&self, a: &i32, b: &i32) -> f64 {
    (a - b).abs() as f64
  }
}

let data = vec![1, 2, 3, 4, 5, 6, 7, 8, 9];

let mut tree = CoverTree::new(data, SimpleDistance {}).unwrap();

tree.find(&5, 3);
```

--------------------------------

### FastPair Example: Finding Closest Pair

Source: https://docs.rs/smartcore/latest/src/smartcore/algorithm/neighbour/fastpair.rs.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Demonstrates how to use the FastPair data structure to find the closest pair of points in a given matrix. Requires importing necessary traits and types.

```rust
use smartcore::metrics::distance::PairwiseDistance;
use smartcore::linalg::basic::matrix::DenseMatrix;
use smartcore::algorithm::neighbour::fastpair::FastPair;
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],
]).unwrap();
let fastpair = FastPair::new(&x);
let closest_pair: PairwiseDistance<f64> = fastpair.unwrap().closest_pair();

```

--------------------------------

### Initialize Data and Create BBDTree

Source: https://docs.rs/smartcore/latest/src/smartcore/algorithm/neighbour/bbd_tree.rs.html?search=

Initializes a dataset with sample data points and constructs a BBDTree from it. This is the first step before performing any clustering operations.

```rust
let data = BBDTree::new(&[
            &[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 tree = BBDTree::new(&data);
```

--------------------------------

### type_id

Source: https://docs.rs/smartcore/latest/smartcore/tree/decision_tree_classifier/struct.DecisionTreeClassifierSearchParametersIterator.html

Gets the TypeId of the object.

```APIDOC
## fn type_id(&self) -> TypeId

### Description
Gets the `TypeId` of `self`.

### Returns
- `TypeId`: The unique type identifier of the object.
```

--------------------------------

### PCA Correlation Decomposition Example

Source: https://docs.rs/smartcore/latest/src/smartcore/decomposition/pca.rs.html?search=

Performs PCA decomposition using the correlation matrix of the dataset. This example verifies the computed eigenvectors and the projected data against expected values, suitable for datasets where variables have different scales.

```rust
let us_arrests = us_arrests_data();

        let expected_eigenvectors = DenseMatrix::from_2d_array(&[
            &[
                0.124288601688222,
                -0.0969866877028367,
                0.0791404742697482,
                -0.150572299008293,
            ],
            &[
                0.00706888610512014,
                -0.00227861130898090,
                0.00325028101296307,
                0.00901099154845273,
            ],
            &[
                0.0194141494466002,
                0.060910660326921,
                0.0263806464184195,
                -0.0093429458365566,
            ],
            &[
                0.0586084532558777,
                0.0180450999787168,
                -0.0881962972508558,
                -0.0096011588898465,
            ],
        ])
        .unwrap();

        let expected_projection = DenseMatrix::from_2d_array(&[
            &[0.9856, -1.1334, 0.4443, -0.1563],
            &[1.9501, -1.0732, -2.04, 0.4386],
            &[1.7632, 0.746, -0.0548, 0.8347],
            &[-0.1414, -1.1198, -0.1146, 0.1828],
            &[2.524, 1.5429, -0.5986, 0.342],
            &[1.5146, 0.9876, -1.095, -0.0015],
            &[-1.3586, 1.0889, 0.6433, 0.1185],
            &[0.0477, 0.3254, 0.7186, 0.882],
            &[3.013, -0.0392, 0.5768, 0.0963],
            &[1.6393, -1.2789, 0.3425, -1.0768],
            &[-0.9127, 1.5705, -0.0508, -0.9028],
            &[-1.6398, -0.211, -0.2598, 0.4991],
            &[1.3789, 0.6818, 0.6775, 0.122],
            &[-0.5055, 0.1516, -0.2281, -0.4247],
            &[-2.2536, 0.1041, -0.1646, -0.0176],
            &[-0.7969, 0.2702, -0.0256, -0.2065],
            &[-0.7509, -0.9584, 0.0284, -0.6706],
            &[1.5648, -0.8711, 0.7835, -0.4547],
            &[-2.3968, -0.3764, 0.0657, 0.3305],
            &[1.7634, -0.4277, 0.1573, 0.5591],
            &[-0.4862, 1.4745, 0.6095, 0.1796],
            &[2.1084, 0.1554, -0.3849, -0.1024],
            &[-1.6927, 0.6323, -0.1531, -0.0673],
            &[0.9965, -2.3938, 0.7408, -0.2155],
            &[0.6968, 0.2634, -0.3774, -0.2258],
            &[-1.1855, -0.5369, -0.2469, -0.1237],
            &[-1.2656, 0.194, -0.1756, -0.0159],
            &[2.8744, 0.7756, -1.1634, -0.3145]
        ])
        .unwrap();

        let pca = PCA::fit_with_correlation(&us_arrests, PCAParameters::default().with_n_components(4)).unwrap();

        assert!(relative_eq!(pca.eigenvectors.abs(), expected_eigenvectors.abs(), epsilon = 1e-4));

        let us_arrests_t = pca.transform(&us_arrests).unwrap();

        assert!(relative_eq!(us_arrests_t.abs(), expected_projection.abs(), epsilon = 1e-4));
```

--------------------------------

### Polynomial Kernel Example

Source: https://docs.rs/smartcore/latest/src/smartcore/svm/mod.rs.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Demonstrates how to configure and apply a polynomial kernel with specified gamma, degree, and coef0 parameters. Asserts the result against an expected value.

```rust
let v1 = vec![1., 2., 3.];
let v2 = vec![4., 5., 6.];

let result = Kernels::polynomial()
    .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).abs() < f64::EPSILON);
```
Tokens:
Raw