Functional Data Analysis (FDA)

High-performance Functional Data Analysis tools implemented in Rust, with Python and R bindings.

Packages

Package	Language	Registry	Folder	Status
fdars-core	Rust	crates.io	fdars-core/
pyfda	Python	GitHub	sipemu/pyfda	Python bindings
fdars	R	CRAN	sipemu/fdars-r	⚠️ outdated

Features

Installation

Rust (fdars-core)

[dependencies]
fdars-core = "0.40"

Or install from the repository:

[dependencies]
fdars-core = { git = "https://github.com/sipemu/fdars" }

Python (pyfda)

Python bindings are available via sipemu/pyfda:

pip install git+https://github.com/sipemu/pyfda

R (fdars)

⚠️ Note: The R package currently lags behind the Rust core and is outdated at the moment. For the latest capabilities, use fdars-core (Rust) or pyfda (Python).

install.packages("fdars")

# Development version from GitHub (requires Rust toolchain)
devtools::install_github("sipemu/fdars-r")

Feature Flags

• parallel (default): Enable rayon-based parallel processing
• linalg: Enable linear algebra features (faer, ridge regression) — requires Rust 1.84+
• serde: Add Serialize/Deserialize to core types and enable JSON support
• js: Enable WASM support with JS random number generation

For WASM builds, disable default features:

[dependencies]
fdars-core = { version = "0.40", default-features = false }

Data Layout

Functional data is represented using the FdMatrix type, a column-major matrix wrapping a flat Vec<f64> with safe (i, j) indexing and dimension tracking:

• For n observations with m evaluation points: data[(i, j)] gives observation i at point j
• Zero-copy column access via data.column(j), row gather via data.row(i)
• nalgebra interop via to_dmatrix() / from_dmatrix() for SVD operations
• 2D surfaces (n observations, m1 x m2 grid): stored as n x (m1*m2) matrices

Quick Start

use fdars_core::{FdMatrix, fdata, depth};

// Create sample functional data (3 observations, 10 points each)
let n = 3;
let m = 10;
let data: Vec<f64> = (0..(n * m)).map(|i| (i as f64).sin()).collect();
let mat = FdMatrix::from_column_major(data, n, m).unwrap();
let argvals: Vec<f64> = (0..m).map(|i| i as f64 / (m - 1) as f64).collect();

// Compute mean function
let mean = fdata::mean_1d(&mat);

// Compute Fraiman-Muniz depth
let depths = depth::fraiman_muniz_1d(&mat, &mat, true);

Examples

28 runnable examples in fdars-core/examples/:

* requires --features linalg

Run with cargo run -p fdars-core --example <name> (add --features linalg where marked).

Performance

With the parallel feature (enabled by default), computationally intensive operations use rayon for multi-core performance. The library also supports WASM targets with sequential execution.

Documentation

• Rust Crate: https://docs.rs/fdars-core
• Python Package: https://github.com/sipemu/pyfda
• R Package: https://sipemu.github.io/fdars/ (⚠️ outdated — lags the Rust core)

Guides (documentation/)

• Getting Started — install, first program, running the examples
• Architecture — FdMatrix layout, module map, error model, parallelism
• Configuration — Cargo feature flags, MSRV, build targets
• Development — conventions, adding modules, local gates, CI
• Testing — test layout, run commands, benchmarks, coverage

License

MIT