Struct PlsResult 

pub struct PlsResult {
    pub weights: FdMatrix,
    pub scores: FdMatrix,
    pub loadings: FdMatrix,
    pub x_means: Vec<f64>,
}

Result of PLS regression.

Fields

weights: FdMatrix

Weight vectors, m x ncomp

scores: FdMatrix

Score vectors, n x ncomp

loadings: FdMatrix

Loading vectors, m x ncomp

x_means: Vec<f64>

Column means of the training data, length m

Implementations

impl PlsResult

pub fn project(&self, data: &FdMatrix) -> Result<FdMatrix, FdarError>

Project new functional data onto the PLS score space.

Centers the input data by subtracting the column means estimated during PLS fitting, then iteratively projects and deflates through each PLS component using the stored weight and loading vectors.

Arguments

• data - Matrix (n_new x m) of new observations

Errors

Returns FdarError::InvalidDimension if the number of columns in data does not match the number of predictor variables used during PLS fitting.

Examples

use fdars_core::matrix::FdMatrix;
use fdars_core::regression::fdata_to_pls_1d;

let x = FdMatrix::from_column_major(
    (0..100).map(|i| (i as f64 * 0.1).sin()).collect(),
    10, 10,
).unwrap();
let y: Vec<f64> = (0..10).map(|i| i as f64 * 0.5).collect();
let pls = fdata_to_pls_1d(&x, &y, 3).unwrap();

// Project the original data
let scores = pls.project(&x).unwrap();
assert_eq!(scores.shape(), (10, 3));

// Project new data
let new_x = FdMatrix::from_column_major(
    (0..20).map(|i| (i as f64 * 0.2).cos()).collect(),
    2, 10,
).unwrap();
let new_scores = pls.project(&new_x).unwrap();
assert_eq!(new_scores.shape(), (2, 3));

Trait Implementations

impl Clone for PlsResult

fn clone(&self) -> PlsResult

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for PlsResult

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl PartialEq for PlsResult

fn eq(&self, other: &PlsResult) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl StructuralPartialEq for PlsResult