Struct FpcaResult 

pub struct FpcaResult {
    pub singular_values: Vec<f64>,
    pub rotation: FdMatrix,
    pub scores: FdMatrix,
    pub mean: Vec<f64>,
    pub centered: FdMatrix,
}

Result of functional PCA.

Fields

singular_values: Vec<f64>

Singular values

rotation: FdMatrix

Rotation matrix (loadings), m x ncomp

scores: FdMatrix

Scores matrix, n x ncomp

mean: Vec<f64>

Mean function

centered: FdMatrix

Centered data, n x m

Implementations

impl FpcaResult

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

Project new functional data onto the FPC score space.

Centers the input data by subtracting the mean function estimated during FPCA, then multiplies by the rotation (loadings) matrix to obtain FPC scores for the new observations.

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 length of the mean vector (i.e. the number of evaluation points used during FPCA).

Examples

use fdars_core::matrix::FdMatrix;
use fdars_core::regression::fdata_to_pc_1d;

let data = FdMatrix::from_column_major(
    (0..50).map(|i| (i as f64 * 0.1).sin()).collect(),
    5, 10,
).unwrap();
let fpca = fdata_to_pc_1d(&data, 3).unwrap();

// Project the original data (scores should match)
let scores = fpca.project(&data).unwrap();
assert_eq!(scores.shape(), (5, 3));

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

pub fn reconstruct( &self, scores: &FdMatrix, ncomp: usize, ) -> Result<FdMatrix, FdarError>

Reconstruct functional data from FPC scores.

Computes the approximation of functional data using the first ncomp principal components: data[i, j] = mean[j] + sum_k scores[i, k] * rotation[j, k]

Arguments

• scores - Score matrix (n x p) where p >= ncomp
• ncomp - Number of components to use for reconstruction

Errors

Returns FdarError::InvalidParameter if ncomp is zero or exceeds the number of columns in scores or the number of available components in the rotation matrix.

Examples

use fdars_core::matrix::FdMatrix;
use fdars_core::regression::fdata_to_pc_1d;

let data = FdMatrix::from_column_major(
    (0..100).map(|i| (i as f64 * 0.1).sin()).collect(),
    10, 10,
).unwrap();
let fpca = fdata_to_pc_1d(&data, 5).unwrap();

// Reconstruct using all 5 components
let recon = fpca.reconstruct(&fpca.scores, 5).unwrap();
assert_eq!(recon.shape(), (10, 10));

// Reconstruct using fewer components
let recon2 = fpca.reconstruct(&fpca.scores, 2).unwrap();
assert_eq!(recon2.shape(), (10, 10));

Trait Implementations

impl Clone for FpcaResult

fn clone(&self) -> FpcaResult

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for FpcaResult

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

Formats the value using the given formatter.

impl PartialEq for FpcaResult

fn eq(&self, other: &FpcaResult) -> 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 FpcaResult