Struct FdMatrix 

pub struct FdMatrix { /* private fields */ }

Column-major matrix for functional data.

Stores data in a flat Vec<f64> with column-major (Fortran) layout: element (row, col) is at index row + col * nrows.

Conventions

For functional data, rows typically represent observations and columns represent evaluation points. For 2D surfaces with m1 x m2 grids, the surface is flattened into m1 * m2 columns.

Examples

use fdars_core::matrix::FdMatrix;

// 3 observations, 4 evaluation points
let data = vec![
    1.0, 2.0, 3.0,  // column 0 (all obs at point 0)
    4.0, 5.0, 6.0,  // column 1
    7.0, 8.0, 9.0,  // column 2
    10.0, 11.0, 12.0, // column 3
];
let mat = FdMatrix::from_column_major(data, 3, 4).unwrap();

assert_eq!(mat[(0, 0)], 1.0);  // obs 0 at point 0
assert_eq!(mat[(1, 2)], 8.0);  // obs 1 at point 2
assert_eq!(mat.column(0), &[1.0, 2.0, 3.0]);

Implementations

impl FdMatrix

pub fn from_column_major( data: Vec<f64>, nrows: usize, ncols: usize, ) -> Result<Self, FdarError>

Create from flat column-major data with dimension validation.

Returns Err if data.len() != nrows * ncols.

pub fn from_slice( data: &[f64], nrows: usize, ncols: usize, ) -> Result<Self, FdarError>

Create from a borrowed slice (copies the data).

Returns Err if data.len() != nrows * ncols.

pub fn zeros(nrows: usize, ncols: usize) -> Self

Create a zero-filled matrix.

pub fn nrows(&self) -> usize

Number of rows.

pub fn ncols(&self) -> usize

Number of columns.

pub fn shape(&self) -> (usize, usize)

Dimensions as (nrows, ncols).

pub fn len(&self) -> usize

Total number of elements.

pub fn is_empty(&self) -> bool

Whether the matrix is empty.

pub fn column(&self, col: usize) -> &[f64]

Get a contiguous column slice (zero-copy).

Panics

Panics if col >= ncols.

pub fn column_mut(&mut self, col: usize) -> &mut [f64]

Get a mutable contiguous column slice (zero-copy).

Panics

Panics if col >= ncols.

pub fn row(&self, row: usize) -> Vec<f64>

Extract a single row as a new Vec<f64>.

This is an O(ncols) operation because rows are not contiguous in column-major layout.

pub fn row_to_buf(&self, row: usize, buf: &mut [f64])

Copy a single row into a pre-allocated buffer (zero allocation).

Panics

Panics if buf.len() < ncols or row >= nrows.

pub fn row_dot(&self, row_a: usize, other: &FdMatrix, row_b: usize) -> f64

Compute the dot product of two rows without materializing either one.

The rows may come from different matrices (which must have the same ncols).

Panics

Panics (in debug) if row_a >= self.nrows, row_b >= other.nrows, or self.ncols != other.ncols.

pub fn row_l2_sq(&self, row_a: usize, other: &FdMatrix, row_b: usize) -> f64

Compute the squared L2 distance between two rows without allocation.

Equivalent to ||self.row(row_a) - other.row(row_b)||^2 but without materializing either row vector.

Panics

Panics (in debug) if row_a >= self.nrows, row_b >= other.nrows, or self.ncols != other.ncols.

pub fn rows(&self) -> Vec<Vec<f64>>

Extract all rows as Vec<Vec<f64>>.

Equivalent to the former extract_curves function.

pub fn to_row_major(&self) -> Vec<f64>

Produce a single contiguous flat buffer in row-major order.

Row i occupies buf[i * ncols..(i + 1) * ncols]. This is a single allocation versus nrows allocations from rows(), and gives better cache locality for row-oriented iteration.

pub fn as_slice(&self) -> &[f64]

Flat slice of the underlying column-major data (zero-copy).

pub fn as_mut_slice(&mut self) -> &mut [f64]

Mutable flat slice of the underlying column-major data.

pub fn into_vec(self) -> Vec<f64>

Consume and return the underlying Vec<f64>.

pub fn to_dmatrix(&self) -> DMatrix<f64>

Convert to a nalgebra DMatrix<f64>.

This copies the data into nalgebra’s storage. Both use column-major layout, so the copy is a simple memcpy.

pub fn from_dmatrix(mat: &DMatrix<f64>) -> Self

Create from a nalgebra DMatrix<f64>.

Both use column-major layout so this is a direct copy.

pub fn get(&self, row: usize, col: usize) -> Option<f64>

Get element at (row, col) with bounds checking.

pub fn set(&mut self, row: usize, col: usize, value: f64) -> bool

Set element at (row, col) with bounds checking.

Trait Implementations

impl Clone for FdMatrix

fn clone(&self) -> FdMatrix

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for FdMatrix

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

Formats the value using the given formatter.

impl Display for FdMatrix

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

Formats the value using the given formatter.

impl Index<(usize, usize)> for FdMatrix

type Output = f64

The returned type after indexing.

fn index(&self, (row, col): (usize, usize)) -> &f64

Performs the indexing (container[index]) operation.

impl IndexMut<(usize, usize)> for FdMatrix

fn index_mut(&mut self, (row, col): (usize, usize)) -> &mut f64

Performs the mutable indexing (container[index]) operation.

impl PartialEq for FdMatrix

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