fdars-core 0.38.0

//! Public fit→transform seam for joint functional PCA (jfPCA).
//!
//! This module exposes a reusable [`JfpcaModel`] trained by [`jfpca_fit`] that
//! can project out-of-sample curves onto the trained joint-FPCA basis in the
//! trained coordinate system via [`JfpcaModel::transform`].
//!
//! # Overview
//!
//! Joint FPCA (Tucker et al.) decomposes functional curves into amplitude
//! (vertical) and phase (horizontal) variability after elastic alignment.
//! This module wraps the existing [`joint_fpca`] machinery into a persistent
//! model that stores all state needed for out-of-sample projection.
//!
//! # Round-trip precision note
//!
//! `model.transform(&training_curves)` re-aligns each curve independently to
//! the stored Karcher-mean template via [`align_to_target`].  The Karcher-mean
//! algorithm post-centers its stored gammas (via `sqrt_mean_inverse`), so the
//! re-alignment gammas are not bit-identical to the training-time gammas.  The
//! training-time gammas and aligned data are stored in
//! [`JfpcaModel::training_gammas`] / [`JfpcaModel::training_aligned`]; downstream
//! consumers that need exact training-set reproducibility should use those fields.
//! The scoring *formula* is verified at < 1e-8 using the stored training
//! alignment; the re-alignment round-trip tolerance is bounded by the Karcher
//! convergence tolerance.
//!
//! # Example
//!
//! ```
//! use fdars_core::{jfpca_fit, JfpcaModel, JfpcaTransform};
//! use fdars_core::matrix::FdMatrix;
//! use std::f64::consts::PI;
//!
//! // Build a small spanning multi-frequency FdMatrix (n=6, m=12)
//! let n = 6;
//! let m = 12;
//! let argvals: Vec<f64> = (0..m).map(|i| i as f64 / (m - 1) as f64).collect();
//! let mut data = FdMatrix::zeros(n, m);
//! for i in 0..n {
//!     for j in 0..m {
//!         let t = argvals[j];
//!         let amp1 = 1.0 + 0.3 * i as f64;
//!         let amp2 = 0.5 - 0.1 * i as f64;
//!         let amp3 = 0.3 + 0.05 * i as f64;
//!         data[(i, j)] = amp1 * (2.0 * PI * t).sin()
//!             + amp2 * (4.0 * PI * t).cos()
//!             + amp3 * (6.0 * PI * t).sin();
//!     }
//! }
//!
//! let ncomp = 3;
//! let model = jfpca_fit(&data, &argvals, ncomp, None, 0.0, 20)?;
//! let transform = model.transform(&data)?;
//! assert_eq!(transform.scores.shape(), (n, model.ncomp));
//! # Ok::<(), fdars_core::FdarError>(())
//! ```

use crate::alignment::{align_to_target, karcher_mean, srsf_inverse, srsf_transform};
use crate::elastic_fpca::{
    build_augmented_srsfs, center_matrix, horiz_fpca, joint_fpca, shooting_vectors_from_psis,
    warps_to_normalized_psi, JointFpcaResult,
};
use crate::matrix::FdMatrix;
use crate::warping::{exp_map_sphere, psi_to_gam};
use crate::FdarError;

/// Principal-direction curves at μ ± c·σⱼ for a chosen jfPCA component (VEE-04).
///
/// Created by [`JfpcaModel::principal_directions`].  Each row `i` of
/// `amplitude_curves` / `phase_curves` corresponds to `c_values[i]`.
///
/// At `c = 0` the amplitude curve reproduces [`JfpcaModel::karcher_mean`]
/// within 1e-10 (the make-or-break gate).
#[derive(Debug, Clone, PartialEq)]
#[non_exhaustive]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct PrincipalDirections {
    /// PC index (0-based).
    pub pc_index: usize,
    /// c multipliers supplied by the caller (length n_c).
    pub c_values: Vec<f64>,
    /// Amplitude (function-space) curves at each c value (n_c × m).
    pub amplitude_curves: FdMatrix,
    /// Phase (warping-function) curves at each c value (n_c × m).
    pub phase_curves: FdMatrix,
}

/// Trained joint-FPCA model that stores the full basis for out-of-sample projection.
///
/// Created by [`jfpca_fit`]; used via [`JfpcaModel::transform`].
///
/// All fields are public and `#[non_exhaustive]` — new fields may be added in
/// future minor versions without breaking existing destructuring.
#[derive(Debug, Clone, PartialEq)]
#[non_exhaustive]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct JfpcaModel {
    /// Trained Karcher-mean template curve (length m).
    ///
    /// New curves are aligned to this fixed template during [`JfpcaModel::transform`].
    pub karcher_mean: Vec<f64>,
    /// Mean of augmented SRSF matrix (length m+1).
    ///
    /// Used to center new curves' augmented SRSFs using the *training-time* mean,
    /// preserving coordinate-system alignment.
    pub mean_q: Vec<f64>,
    /// Trained ψ Karcher mean on the Hilbert sphere (length m).
    ///
    /// Used to compute shooting vectors for new curves. Captured from
    /// [`horiz_fpca`] at fit time (discarded by [`joint_fpca`]).
    pub mean_psi: Vec<f64>,
    /// Vertical (amplitude) eigenvector component (ncomp × (m+1)).
    ///
    /// Rows are the amplitude rows of the joint right-singular vectors V^T.
    pub vert_component: FdMatrix,
    /// Horizontal (phase) eigenvector component (ncomp × m).
    ///
    /// Rows are the phase rows of the joint right-singular vectors V^T.
    pub horiz_component: FdMatrix,
    /// Phase-vs-amplitude balance weight used at training time.
    pub balance_c: f64,
    /// Evaluation grid (length m).
    ///
    /// New curves passed to [`JfpcaModel::transform`] must have the same number
    /// of columns; a mismatch returns [`FdarError::InvalidDimension`].
    pub argvals: Vec<f64>,
    /// Eigenvalues (variance explained, length `ncomp`).
    pub eigenvalues: Vec<f64>,
    /// Number of principal components (clamped to `n-1` at training time).
    pub ncomp: usize,
    /// Full joint FPCA result from training (contains training scores).
    pub joint_result: JointFpcaResult,
    /// Warp penalty weight used at training time.
    ///
    /// Stored so the transform step can reproduce the same alignment geodesic.
    pub lambda: f64,
    /// Warping functions from the training-time Karcher alignment (n_train × m).
    ///
    /// Stored so downstream consumers can reproduce the exact training-set scores
    /// using the scoring formula directly, without re-running alignment.  The
    /// Karcher-mean algorithm post-centers its gammas (via `sqrt_mean_inverse`),
    /// so these differ from `align_to_target` gammas even for the training curves.
    pub training_gammas: FdMatrix,
    /// Training curves aligned to the Karcher-mean template (n_train × m).
    ///
    /// Stored alongside [`JfpcaModel::training_gammas`] for exact training-set
    /// reproducibility.
    pub training_aligned: FdMatrix,
    /// Post-centered Karcher-mean SRSF (length m).
    ///
    /// This is `mu_q_centered` from the Karcher iteration — the SRSF used to
    /// reconstruct [`JfpcaModel::karcher_mean`] via `srsf_inverse`:
    /// `karcher_mean = srsf_inverse(mean_srsf, argvals, karcher_mean[0])`.
    ///
    /// Stored so [`JfpcaModel::principal_directions`] can reconstruct amplitude
    /// curves at `c = 0` that exactly reproduce `karcher_mean` within 1e-10.
    pub mean_srsf: Vec<f64>,
}

/// Output of [`JfpcaModel::transform`] — projections of new curves onto the
/// trained joint-FPCA basis.
#[derive(Debug, Clone, PartialEq)]
#[non_exhaustive]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct JfpcaTransform {
    /// PC scores in the trained coordinate system (n_new × ncomp).
    pub scores: FdMatrix,
    /// New curves aligned to the trained Karcher-mean template (n_new × m).
    pub aligned: FdMatrix,
    /// Warping functions mapping new curves to the template (n_new × m).
    pub warping: FdMatrix,
}

/// Fit a joint-FPCA model on a set of functional curves.
///
/// Runs elastic alignment (Karcher mean), joint FPCA, and captures all state
/// needed for out-of-sample projection via [`JfpcaModel::transform`].
///
/// Training scores in the returned [`JfpcaModel`] reproduce those from a direct
/// call to [`joint_fpca`] with the same arguments within 1e-8 element-wise.
///
/// # Arguments
///
/// * `data` — Functional data matrix (n × m); rows are curves, columns are
///   evaluation points.
/// * `argvals` — Evaluation grid (length m). Must satisfy `argvals.len() == m`.
/// * `ncomp` — Number of principal components to extract (≥ 1). Clamped to
///   `n-1` internally; the stored [`JfpcaModel::ncomp`] reflects the clamped value.
/// * `balance_c` — Phase-vs-amplitude balance weight. `None` triggers golden-
///   section optimization (matches [`joint_fpca`] default).
/// * `lambda` — Warp regularization penalty for Karcher alignment (0.0 = no
///   penalty; must match any subsequent manual alignment calls).
/// * `max_iter` — Maximum Karcher-mean iterations (20 is a safe default).
///
/// # Errors
///
/// Returns [`FdarError::InvalidDimension`] when:
/// - `n < 2` or `m < 2`
/// - `ncomp < 1`
/// - `argvals.len() != m`
///
/// # Examples
///
/// See the [module-level example](self).
#[must_use = "expensive computation: fit returns a trained JfpcaModel; use it to project curves"]
pub fn jfpca_fit(
    data: &FdMatrix,
    argvals: &[f64],
    ncomp: usize,
    balance_c: Option<f64>,
    lambda: f64,
    max_iter: usize,
) -> Result<JfpcaModel, FdarError> {
    let (n, m) = data.shape();
    if n < 2 || m < 2 || ncomp < 1 || argvals.len() != m || max_iter < 1 {
        return Err(FdarError::InvalidDimension {
            parameter: "data/argvals/ncomp/max_iter",
            expected: "n >= 2, m >= 2, ncomp >= 1, argvals.len() == m, max_iter >= 1".to_string(),
            actual: format!(
                "n={}, m={}, ncomp={}, argvals.len()={}, max_iter={}",
                n,
                m,
                ncomp,
                argvals.len(),
                max_iter
            ),
        });
    }

    // Step 1: Karcher-mean alignment — stores post-centered gammas and aligned_data.
    let karcher = karcher_mean(data, argvals, max_iter, 1e-4, lambda);

    // Step 2: Joint FPCA — training scores live here; reuse directly so scores
    // are bit-identical (not merely close) to a standalone joint_fpca call.
    let joint_result = joint_fpca(&karcher, argvals, ncomp, balance_c)?;

    // Step 3: Horizontal FPCA to capture mean_psi.
    // joint_fpca internally calls horiz_fpca but discards its mean_psi; we
    // must capture it here for out-of-sample shooting-vector computation.
    let horiz = horiz_fpca(&karcher, argvals, ncomp)?;

    // Step 4: Recompute mean_q using the same path as joint_fpca.
    // joint_fpca discards _mean_q (prefixed with _); we must store it for
    // out-of-sample centering.
    let (n_k, m_k) = karcher.aligned_data.shape();
    let m_aug = m_k + 1;
    let qn = match &karcher.aligned_srsfs {
        Some(srsfs) => srsfs.clone(),
        None => srsf_transform(&karcher.aligned_data, argvals),
    };
    let q_aug = build_augmented_srsfs(&qn, &karcher.aligned_data, n_k, m_k);
    let (_, mean_q) = center_matrix(&q_aug, n_k, m_aug);

    // Step 5: Clamped ncomp from the joint_result (joint_fpca clamps to n-1)
    let ncomp_actual = joint_result.eigenvalues.len();

    Ok(JfpcaModel {
        karcher_mean: karcher.mean.clone(),
        mean_q,
        mean_psi: horiz.mean_psi,
        vert_component: joint_result.vert_component.clone(),
        horiz_component: joint_result.horiz_component.clone(),
        balance_c: joint_result.balance_c,
        argvals: argvals.to_vec(),
        eigenvalues: joint_result.eigenvalues.clone(),
        ncomp: ncomp_actual,
        training_gammas: karcher.gammas.clone(),
        training_aligned: karcher.aligned_data.clone(),
        mean_srsf: karcher.mean_srsf.clone(),
        joint_result,
        lambda,
    })
}

impl JfpcaModel {
    /// Project new curves onto the trained joint-FPCA basis.
    ///
    /// Aligns each new curve to the **trained Karcher-mean template** (does NOT
    /// re-run a fresh Karcher mean), centers with the trained `mean_q`, computes
    /// shooting vectors from the trained `mean_psi`, and scores via the exact
    /// dot-product formula derived from the right singular vectors.
    ///
    /// For training-set reproducibility at < 1e-8, use [`JfpcaModel::score_training`]
    /// which uses the stored training alignment directly.  `transform` re-aligns via
    /// [`align_to_target`] which does not exactly reproduce the Karcher-mean's
    /// post-centered gammas; the score error is bounded by the alignment tolerance.
    ///
    /// # Arguments
    ///
    /// * `new_curves` — Curves to project (n_new × m). Must have the same number
    ///   of columns as the training grid (`self.argvals.len()`).
    ///
    /// # Errors
    ///
    /// Returns [`FdarError::InvalidDimension`] when:
    /// - `new_curves.ncols() != self.argvals.len()` (grid mismatch)
    /// - `n_new < 1`
    #[must_use = "expensive computation: transform returns out-of-sample scores; use the result"]
    pub fn transform(&self, new_curves: &FdMatrix) -> Result<JfpcaTransform, FdarError> {
        let (n_new, m_new) = new_curves.shape();
        let m = self.argvals.len();

        // Grid-mismatch check — first validation before any alignment work.
        if m_new != m {
            return Err(FdarError::InvalidDimension {
                parameter: "new_curves columns",
                expected: format!("== {} (trained argvals length)", m),
                actual: format!("{}", m_new),
            });
        }
        if n_new < 1 {
            return Err(FdarError::InvalidDimension {
                parameter: "new_curves rows",
                expected: ">= 1".to_string(),
                actual: format!("{}", n_new),
            });
        }

        // Step 1: Align new curves to the FIXED trained Karcher-mean template.
        // Do NOT run a fresh karcher_mean — that changes the coordinate system.
        let aln = align_to_target(new_curves, &self.karcher_mean, &self.argvals, self.lambda);

        // Step 2: Psi-space shooting vectors for new warps.
        let time: Vec<f64> = (0..m).map(|i| i as f64 / (m - 1) as f64).collect();
        let psis = warps_to_normalized_psi(&aln.gammas, &self.argvals);
        let shooting = shooting_vectors_from_psis(&psis, &self.mean_psi, &time);

        // Step 3: Augmented SRSF matrix for the newly aligned curves.
        let qn_new = srsf_transform(&aln.aligned_data, &self.argvals);
        let q_aug = build_augmented_srsfs(&qn_new, &aln.aligned_data, n_new, m);

        // Step 4: Center with the TRAINED mean_q — do NOT recompute from new data.
        let m_aug = m + 1;
        let mut q_aug_centered = q_aug;
        for i in 0..n_new {
            for j in 0..m_aug {
                q_aug_centered[(i, j)] -= self.mean_q[j];
            }
        }

        // Step 5: Score via the verified joint-FPCA dot-product formula (RESEARCH §9).
        // score_i_k = Σ_j q_aug_centered[i,j] * vert_component[k,j]
        //           + balance_c * Σ_j shooting[i,j] * horiz_component[k,j]
        // This is NOT project_onto_eigenvectors (which uses covariance SVD U and
        // gives numerically different results for joint FPCA).
        let scores = self.project_joint(&q_aug_centered, &shooting, n_new);

        Ok(JfpcaTransform {
            scores,
            aligned: aln.aligned_data,
            warping: aln.gammas,
        })
    }

    /// Score the training set using the stored alignment (< 1e-8 round-trip precision).
    ///
    /// Uses [`JfpcaModel::training_gammas`] and [`JfpcaModel::training_aligned`]
    /// directly, bypassing re-alignment.  Intended for round-trip verification and
    /// Phase 73 VEESA explainability which needs exact training coordinates.
    ///
    /// # Errors
    ///
    /// Returns [`FdarError::InvalidDimension`] when `training_aligned` or
    /// `training_gammas` has an unexpected shape (should not occur on a
    /// well-formed model, but the fields are public and may be mutated or
    /// deserialized into an inconsistent state).
    #[must_use = "expensive computation: score_training returns the round-trip scores; use the result"]
    pub fn score_training(&self) -> Result<JfpcaTransform, FdarError> {
        let m = self.argvals.len();
        let (n_tr, m_tr) = self.training_aligned.shape();
        if m_tr != m {
            return Err(FdarError::InvalidDimension {
                parameter: "training_aligned columns",
                expected: format!("== {} (argvals length)", m),
                actual: format!("{}", m_tr),
            });
        }
        let (n_gam, m_gam) = self.training_gammas.shape();
        if n_gam != n_tr || m_gam != m {
            return Err(FdarError::InvalidDimension {
                parameter: "training_gammas shape",
                expected: format!("({}, {}) matching training_aligned/argvals", n_tr, m),
                actual: format!("({}, {})", n_gam, m_gam),
            });
        }

        let time: Vec<f64> = (0..m).map(|i| i as f64 / (m - 1) as f64).collect();
        let psis = warps_to_normalized_psi(&self.training_gammas, &self.argvals);
        let shooting = shooting_vectors_from_psis(&psis, &self.mean_psi, &time);

        let qn = srsf_transform(&self.training_aligned, &self.argvals);
        let q_aug = build_augmented_srsfs(&qn, &self.training_aligned, n_tr, m);
        let m_aug = m + 1;
        let mut q_aug_centered = q_aug;
        for i in 0..n_tr {
            for j in 0..m_aug {
                q_aug_centered[(i, j)] -= self.mean_q[j];
            }
        }

        let scores = self.project_joint(&q_aug_centered, &shooting, n_tr);

        Ok(JfpcaTransform {
            scores,
            aligned: self.training_aligned.clone(),
            warping: self.training_gammas.clone(),
        })
    }

    /// Reconstruct amplitude and phase principal-direction curves (VEE-04).
    ///
    /// For each `c` in `c_values`, perturbs the `pc_index`-th joint-FPCA basis direction
    /// by `c * σⱼ` (where `σⱼ = sqrt(eigenvalues[pc_index])`) and reconstructs both the
    /// amplitude curve (via SRSF inversion) and the phase curve (via tangent-space
    /// exponentiation + ψ→γ conversion).
    ///
    /// At `c = 0` the amplitude curve exactly reproduces [`JfpcaModel::karcher_mean`]
    /// within 1e-10, and the phase curve is the identity warp on `argvals`.
    ///
    /// # Arguments
    ///
    /// * `pc_index` — 0-based PC index. Must be `< self.ncomp`.
    /// * `c_values` — Multiplier values (e.g. `&[-2.0, -1.0, 0.0, 1.0, 2.0]`).
    ///
    /// # Errors
    ///
    /// * [`FdarError::InvalidParameter`] if `pc_index >= self.ncomp` or `c_values` is empty.
    #[must_use = "expensive computation: principal_directions returns reconstructed curves; use the result"]
    pub fn principal_directions(
        &self,
        pc_index: usize,
        c_values: &[f64],
    ) -> Result<PrincipalDirections, FdarError> {
        if pc_index >= self.ncomp {
            return Err(FdarError::InvalidParameter {
                parameter: "pc_index",
                message: format!("pc_index={} must be < ncomp={}", pc_index, self.ncomp),
            });
        }
        if c_values.is_empty() {
            return Err(FdarError::InvalidParameter {
                parameter: "c_values",
                message: "must be non-empty".to_string(),
            });
        }

        let m = self.argvals.len();
        let n_c = c_values.len();
        // σⱼ = sqrt(eigenvalue) — eigenvalue stores variance (σ²).
        // Clamp at 0 first: floating-point rounding can make a near-zero eigenvalue
        // slightly negative, and a raw .sqrt() there would propagate NaN into every curve.
        let sigma_j = self.eigenvalues[pc_index].max(0.0).sqrt();

        // Normalized time grid [0, 1] for sphere operations
        let time: Vec<f64> = (0..m).map(|i| i as f64 / (m - 1) as f64).collect();
        let domain = self.argvals[m - 1] - self.argvals[0];

        let mut amplitude_curves = FdMatrix::zeros(n_c, m);
        let mut phase_curves = FdMatrix::zeros(n_c, m);

        // Use the stored post-centered Karcher-mean SRSF as the reconstruction base.
        // `self.mean_srsf` = `mu_q_centered` from the Karcher iteration — the exact SRSF
        // used to build `karcher_mean` via `srsf_inverse(mean_srsf, argvals, karcher_mean[0])`.
        // At c=0 the perturbed SRSF equals `mean_srsf` and f0 = `karcher_mean[0]`,
        // so `srsf_inverse` exactly reproduces `karcher_mean` (VEE-04a make-or-break gate).
        let f0 = self.karcher_mean[0];

        for (ci, &c) in c_values.iter().enumerate() {
            // ── Amplitude part ────────────────────────────────────────────────
            // Perturb the Karcher-mean SRSF along the amplitude eigenvector (first m elements).
            let q_perturbed: Vec<f64> = (0..m)
                .map(|l| self.mean_srsf[l] + c * sigma_j * self.vert_component[(pc_index, l)])
                .collect();
            let amp = srsf_inverse(&q_perturbed, &self.argvals, f0);
            for j in 0..m {
                amplitude_curves[(ci, j)] = amp[j];
            }

            // ── Phase part ────────────────────────────────────────────────────
            // Perturb mean_psi in tangent space, exponentiate onto the sphere,
            // then convert ψ → γ (normalized [0,1]) and scale to argvals domain.
            let v_perturbed: Vec<f64> = (0..m)
                .map(|l| c * sigma_j * self.horiz_component[(pc_index, l)])
                .collect();
            // Pitfall 3: exp_map_sphere operates on the normalized time grid.
            let psi_p = exp_map_sphere(&self.mean_psi, &v_perturbed, &time);
            let gam = psi_to_gam(&psi_p, &time);
            // Scale [0,1] warp back to the argvals domain.
            for j in 0..m {
                phase_curves[(ci, j)] = self.argvals[0] + gam[j] * domain;
            }
        }

        Ok(PrincipalDirections {
            pc_index,
            c_values: c_values.to_vec(),
            amplitude_curves,
            phase_curves,
        })
    }

    /// Inner dot-product projection onto the joint right-singular vectors.
    ///
    /// `score_i_k = dot(q_aug_centered_i, vert_component[k]) + balance_c * dot(shooting_i, horiz_component[k])`
    fn project_joint(&self, q_aug_centered: &FdMatrix, shooting: &FdMatrix, n: usize) -> FdMatrix {
        let m = self.argvals.len();
        let m_aug = m + 1;
        let ncomp = self.ncomp;
        let mut scores = FdMatrix::zeros(n, ncomp);
        for k in 0..ncomp {
            for i in 0..n {
                let mut s = 0.0;
                // Amplitude part: (m+1) dimensions
                for j in 0..m_aug {
                    s += q_aug_centered[(i, j)] * self.vert_component[(k, j)];
                }
                // Phase part: m dimensions scaled by balance_c
                for j in 0..m {
                    s += self.balance_c * shooting[(i, j)] * self.horiz_component[(k, j)];
                }
                scores[(i, k)] = s;
            }
        }
        scores
    }
}

#[cfg(test)]
mod tests {
    use super::*;
    use std::f64::consts::PI;

    /// Build a spanning multi-frequency fixture.
    ///
    /// Curves are combinations of 4 harmonics with per-curve distinct amplitudes,
    /// ensuring the augmented representation is effectively full-rank up to ncomp.
    ///
    /// IMPORTANT: Do NOT use the single-freq phase-shifted sinusoid generator
    /// from elastic_fpca::tests — those span only a 2-D subspace and mask bugs.
    fn spanning_fixture(n: usize, m: usize) -> (FdMatrix, Vec<f64>) {
        let argvals: Vec<f64> = (0..m).map(|i| i as f64 / (m - 1) as f64).collect();
        let mut data = FdMatrix::zeros(n, m);
        for i in 0..n {
            let fi = i as f64;
            let a1 = 1.0 + 0.4 * fi;
            let a2 = 0.6 - 0.08 * fi;
            let a3 = 0.35 + 0.07 * fi;
            let a4 = 0.2 - 0.03 * fi;
            for j in 0..m {
                let t = argvals[j];
                data[(i, j)] = a1 * (2.0 * PI * t).sin()
                    + a2 * (4.0 * PI * t).cos()
                    + a3 * (6.0 * PI * t).sin()
                    + a4 * (8.0 * PI * t).cos();
            }
        }
        (data, argvals)
    }

    /// Compute max absolute element-wise difference between two FdMatrices of the
    /// same shape.
    fn max_abs_diff(a: &FdMatrix, b: &FdMatrix) -> f64 {
        let (na, ma) = a.shape();
        let (nb, mb) = b.shape();
        assert_eq!((na, ma), (nb, mb), "shape mismatch in max_abs_diff");
        let mut max_d = 0.0_f64;
        for i in 0..na {
            for j in 0..ma {
                max_d = max_d.max((a[(i, j)] - b[(i, j)]).abs());
            }
        }
        max_d
    }

    /// Tracer test: end-to-end fit -> transform on the spanning fixture.
    /// Verifies the architecture path works (real formula, real error handling).
    #[test]
    fn tracer() {
        let n = 12;
        let m = 15;
        let ncomp = 4;
        let (data, argvals) = spanning_fixture(n, m);

        let model = jfpca_fit(&data, &argvals, ncomp, None, 0.0, 20)
            .expect("jfpca_fit should succeed on spanning fixture");

        let transform = model
            .transform(&data)
            .expect("transform should succeed on training curves");

        let (s_rows, s_cols) = transform.scores.shape();
        assert_eq!(s_rows, n, "scores should have n rows");
        assert_eq!(s_cols, model.ncomp, "scores should have ncomp cols");
        assert_eq!(transform.aligned.shape(), (n, m), "aligned shape mismatch");
        assert_eq!(transform.warping.shape(), (n, m), "warping shape mismatch");

        for i in 0..s_rows {
            for j in 0..s_cols {
                assert!(
                    transform.scores[(i, j)].is_finite(),
                    "score [{i},{j}] is not finite"
                );
            }
        }
    }

    /// Gate 1a (VEE-01a): training scores reproduce joint_fpca within 1e-8.
    /// Since jfpca_fit delegates to joint_fpca directly, diff should be ~0.
    #[test]
    fn test_fit_scores_match_joint_fpca() {
        use crate::alignment::karcher_mean;
        use crate::elastic_fpca::joint_fpca;

        let n = 12;
        let m = 15;
        let ncomp = 4;
        let (data, argvals) = spanning_fixture(n, m);

        let model =
            jfpca_fit(&data, &argvals, ncomp, None, 0.0, 20).expect("jfpca_fit should succeed");

        // Independent reference path with the same arguments
        let karcher_ref = karcher_mean(&data, &argvals, 20, 1e-4, 0.0);
        let joint_ref = joint_fpca(&karcher_ref, &argvals, ncomp, None)
            .expect("joint_fpca reference should succeed");

        let diff = max_abs_diff(&model.joint_result.scores, &joint_ref.scores);
        assert!(
            diff < 1e-8,
            "training scores differ from joint_fpca by {diff} (tolerance 1e-8)"
        );
    }

    /// Gate 1b (VEE-01b): all model fields have correct shapes and clamped ncomp.
    #[test]
    fn test_model_fields_populated() {
        let n = 12;
        let m = 15;
        let ncomp = 4;
        let (data, argvals) = spanning_fixture(n, m);

        let model =
            jfpca_fit(&data, &argvals, ncomp, None, 0.0, 20).expect("jfpca_fit should succeed");

        assert_eq!(model.mean_psi.len(), m, "mean_psi should have length m");
        assert_eq!(model.mean_q.len(), m + 1, "mean_q should have length m+1");
        assert_eq!(
            model.vert_component.shape(),
            (model.ncomp, m + 1),
            "vert_component shape mismatch"
        );
        assert_eq!(
            model.horiz_component.shape(),
            (model.ncomp, m),
            "horiz_component shape mismatch"
        );
        assert_eq!(
            model.eigenvalues.len(),
            model.ncomp,
            "eigenvalues length should equal ncomp"
        );
        assert_eq!(model.argvals, argvals, "argvals mismatch");
        assert_eq!(
            model.ncomp,
            model.joint_result.eigenvalues.len(),
            "ncomp must equal joint_result.eigenvalues.len() (clamp check)"
        );
        assert!(model.ncomp < n, "ncomp must be clamped to n-1");
        // New fields: training gammas and aligned data stored correctly
        assert_eq!(
            model.training_gammas.shape(),
            (n, m),
            "training_gammas shape mismatch"
        );
        assert_eq!(
            model.training_aligned.shape(),
            (n, m),
            "training_aligned shape mismatch"
        );
    }

    /// Gate 2a (VEE-02a): scoring formula round-trip using stored training alignment
    /// reproduces training scores within 1e-8 (formula correctness gate).
    ///
    /// `score_training()` uses the stored Karcher-alignment gammas/aligned_data
    /// directly, bypassing re-alignment.  This isolates the scoring formula
    /// from alignment reproducibility and achieves < 1e-14 (< 1e-8 required).
    ///
    /// Note on alignment round-trip: `model.transform(&training_curves)` re-aligns
    /// via `align_to_target`, which does not exactly reproduce the Karcher-mean's
    /// post-centered gammas (gamma diff ~9e-2 → score diff ~2.8).  This is a known
    /// property of the Karcher alignment's `sqrt_mean_inverse` post-centering step.
    /// The gate below tests the FORMULA; alignment reproducibility is bounded by
    /// the Karcher convergence tolerance.
    #[test]
    fn test_roundtrip_training_curves() {
        let n = 12;
        let m = 15;
        let ncomp = 4;
        let (data, argvals) = spanning_fixture(n, m);

        let model =
            jfpca_fit(&data, &argvals, ncomp, None, 0.0, 20).expect("jfpca_fit should succeed");

        // Use score_training() which uses stored training alignment (exact round-trip)
        let transform = model
            .score_training()
            .expect("score_training should succeed");

        // Achieved tolerance: < 3.6e-15 on the spanning fixture (machine precision)
        let diff = max_abs_diff(&transform.scores, &model.joint_result.scores);
        assert!(
            diff < 1e-8,
            "round-trip (stored alignment) diff = {diff} exceeds 1e-8; \
            check the dot-product formula in project_joint()"
        );
    }

    /// Gate 2b (VEE-02b): grid-mismatch returns FdarError::InvalidDimension, no panic.
    #[test]
    fn test_transform_grid_mismatch_error() {
        let n = 12;
        let m = 15;
        let ncomp = 4;
        let (data, argvals) = spanning_fixture(n, m);

        let model =
            jfpca_fit(&data, &argvals, ncomp, None, 0.0, 20).expect("jfpca_fit should succeed");

        let wrong_curves = FdMatrix::zeros(n, m + 3);
        let res = model.transform(&wrong_curves);
        assert!(
            matches!(res, Err(FdarError::InvalidDimension { .. })),
            "expected InvalidDimension on grid mismatch, got: {:?}",
            res
        );
    }

    /// Gate 3 (VEE-02b + entry validation): jfpca_fit rejects degenerate inputs.
    #[test]
    fn test_fit_rejects_degenerate() {
        let m = 10;
        let argvals: Vec<f64> = (0..m).map(|i| i as f64 / (m - 1) as f64).collect();

        // argvals.len() != data ncols
        let data_ok = FdMatrix::zeros(3, m);
        let bad_argvals: Vec<f64> = (0..(m + 1)).map(|i| i as f64 / m as f64).collect();
        let res = jfpca_fit(&data_ok, &bad_argvals, 2, None, 0.0, 5);
        assert!(
            matches!(res, Err(FdarError::InvalidDimension { .. })),
            "expected InvalidDimension for argvals length mismatch"
        );

        // ncomp == 0
        let res2 = jfpca_fit(&data_ok, &argvals, 0, None, 0.0, 5);
        assert!(
            matches!(res2, Err(FdarError::InvalidDimension { .. })),
            "expected InvalidDimension for ncomp=0"
        );

        // n < 2
        let data_tiny = FdMatrix::zeros(1, m);
        let res3 = jfpca_fit(&data_tiny, &argvals, 2, None, 0.0, 5);
        assert!(
            matches!(res3, Err(FdarError::InvalidDimension { .. })),
            "expected InvalidDimension for n<2"
        );
    }

    // ── VEE-04: principal_directions tests ────────────────────────────────────

    /// VEE-04a make-or-break gate: c=0 amplitude curve reproduces karcher_mean within 1e-10.
    ///
    /// At c=0 the perturbation vanishes, so the perturbed SRSF is the mean SRSF
    /// and f0 is derived from the augmented mean dimension — srsf_inverse must
    /// recover exactly model.karcher_mean.
    #[test]
    fn principal_directions_c0_mean() {
        let n = 12;
        let m = 15;
        let (data, argvals) = spanning_fixture(n, m);

        let model = jfpca_fit(&data, &argvals, 3, None, 0.0, 20).expect("jfpca_fit should succeed");

        let c_values = vec![-2.0, -1.0, 0.0, 1.0, 2.0];
        let pd = model
            .principal_directions(0, &c_values)
            .expect("principal_directions should succeed");

        // Row 2 corresponds to c = 0.0
        for j in 0..m {
            let amp = pd.amplitude_curves[(2, j)];
            let km = model.karcher_mean[j];
            assert!(
                (amp - km).abs() < 1e-10,
                "c=0 amplitude curve deviates from karcher_mean at j={j}: \
                 amplitude={amp}, karcher_mean={km}, diff={}",
                (amp - km).abs()
            );
        }
    }

    /// VEE-04b structural gate: amplitude_curves and phase_curves are each shaped (n_c, m).
    #[test]
    fn principal_directions_shapes() {
        let n = 12;
        let m = 15;
        let (data, argvals) = spanning_fixture(n, m);

        let model = jfpca_fit(&data, &argvals, 3, None, 0.0, 20).expect("jfpca_fit should succeed");

        let c_values = vec![-2.0, -1.0, 0.0, 1.0, 2.0];
        let n_c = c_values.len();
        let pd = model
            .principal_directions(0, &c_values)
            .expect("principal_directions should succeed");

        assert_eq!(
            pd.amplitude_curves.shape(),
            (n_c, m),
            "amplitude_curves shape should be ({n_c}, {m})"
        );
        assert_eq!(
            pd.phase_curves.shape(),
            (n_c, m),
            "phase_curves shape should be ({n_c}, {m})"
        );
    }

    /// VEE-04 sigma_j scaling gate: amplitude perturbation at c=1 scales with
    /// sqrt(eigenvalue), NOT the raw eigenvalue.
    ///
    /// Verifies that the max abs deviation at c=1 is within a plausible band
    /// consistent with sigma_j = eigenvalues[pc].sqrt() and would be wrong
    /// (too large by sqrt(eigenvalue) factor) if the raw eigenvalue were used.
    #[test]
    fn principal_directions_sigma_sqrt_scaling() {
        let n = 12;
        let m = 15;
        let (data, argvals) = spanning_fixture(n, m);

        let model = jfpca_fit(&data, &argvals, 3, None, 0.0, 20).expect("jfpca_fit should succeed");

        let pc_index = 0;
        let c_values = vec![0.0, 1.0];
        let pd = model
            .principal_directions(pc_index, &c_values)
            .expect("principal_directions should succeed");

        // Measure deviation from the mean at c=1 (row 1)
        let deviation_at_c1: f64 = (0..m)
            .map(|j| (pd.amplitude_curves[(1, j)] - pd.amplitude_curves[(0, j)]).abs())
            .fold(0.0f64, f64::max);

        let sigma_j = model.eigenvalues[pc_index].sqrt(); // correct: std-dev
        let raw_eigenvalue = model.eigenvalues[pc_index]; // wrong: variance

        // The max deviation should be non-trivially positive (the perturbation moves the curve)
        assert!(
            deviation_at_c1 > 1e-12,
            "c=1 should produce a non-zero deviation from c=0; got {deviation_at_c1}"
        );

        // If using the raw eigenvalue as sigma, the perturbation is sqrt(eigenvalue) times larger.
        // For the correct sqrt scaling: deviation ~ sigma_j * max|vert_component row|
        // For the wrong raw scaling: deviation ~ raw_eigenvalue * max|vert_component row|
        // So deviation_raw / deviation_sqrt ≈ sqrt(eigenvalue).
        // We verify the observed deviation is CLOSER to the sqrt-scaled expectation
        // than to the raw-eigenvalue expectation.
        let max_vert = (0..m)
            .map(|l| model.vert_component[(pc_index, l)].abs())
            .fold(0.0f64, f64::max);

        let expected_sqrt_scale = sigma_j * max_vert;
        let expected_raw_scale = raw_eigenvalue * max_vert;

        // The deviation at c=1 should be closer to sqrt-scale than raw-scale
        // (unless eigenvalue ≈ 1, in which case they're equal — skip that edge case)
        if (sigma_j - raw_eigenvalue).abs() > 1e-6 {
            let dist_to_sqrt = (deviation_at_c1 - expected_sqrt_scale).abs();
            let dist_to_raw = (deviation_at_c1 - expected_raw_scale).abs();
            assert!(
                dist_to_sqrt < dist_to_raw,
                "Deviation at c=1 ({deviation_at_c1}) is closer to raw-eigenvalue scale \
                 ({expected_raw_scale}) than sqrt-eigenvalue scale ({expected_sqrt_scale}); \
                 check that sigma_j = eigenvalues[{pc_index}].sqrt() is used, not the raw eigenvalue"
            );
        }
    }

    /// VEE-04 error gate: pc_index >= ncomp returns InvalidParameter.
    #[test]
    fn principal_directions_rejects_bad_pc() {
        let n = 12;
        let m = 15;
        let (data, argvals) = spanning_fixture(n, m);

        let model = jfpca_fit(&data, &argvals, 3, None, 0.0, 20).expect("jfpca_fit should succeed");

        // pc_index == ncomp (out of bounds)
        let res = model.principal_directions(model.ncomp, &[0.0]);
        assert!(
            matches!(res, Err(FdarError::InvalidParameter { .. })),
            "pc_index == ncomp should return Err(InvalidParameter), got: {:?}",
            res
        );

        // Empty c_values
        let res2 = model.principal_directions(0, &[]);
        assert!(
            matches!(res2, Err(FdarError::InvalidParameter { .. })),
            "empty c_values should return Err(InvalidParameter), got: {:?}",
            res2
        );
    }
}