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.47"

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.47", 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

A single-threaded head-to-head of fdars-core against scikit-fda 0.10.1 and the R FDA ecosystem, on identical seeded inputs, at the largest grid cell (N=500, M=200):

Generated by benchmarks/render_report.py from comparison.csv — do not edit by hand.

† fdars measurement failed the noise gate (RSD >= 5% or CI-width >= 5%) — not headlined as significant.

fdars leads scikit-fda and R on every op that passed the noise gate at this cell — none were comparable or slower. The one committed optimization win, face_covariance, is headlined at a pinned, noise-clean 1.19× faster (not the larger but unpinned/noisy 3.45× figure from an earlier phase); elastic alignment and the SVD path were already near-optimal and are reported as such, not as speedups.

See the full performance report for the complete N×M grid, before/after tables, scaling analysis, full methodology, and step-by-step reproduction instructions.

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
• Performance — head-to-head vs scikit-fda and R, before/after optimization, N×M scaling, reproduction steps

License

MIT