diff --git a/CHANGELOG.md b/CHANGELOG.md
index b47f9dc5..5cf71f94 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -11,7 +11,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ### Other
 
-- *(Exa)* when installing Vial on MacOs, the environment varaibles are not completly shared to the sandbox in which Vial is running, this changes are meant to provide vial a better way to approach finding the rust binary ([#181](https://github.com/LAPKB/pharmsol/pull/181))
+- _(Exa)_ when installing Papir on MacOs, the environment varaibles are not completly shared to the sandbox in which Papir is running, this changes are meant to provide papir a better way to approach finding the rust binary ([#181](https://github.com/LAPKB/pharmsol/pull/181))
 - Update diffsol requirement from =0.7.0 to =0.8.0 ([#176](https://github.com/LAPKB/pharmsol/pull/176))
 - Update criterion requirement from 0.7.0 to 0.8.0 ([#177](https://github.com/LAPKB/pharmsol/pull/177))
 - Update libloading requirement from 0.8.6 to 0.9.0 ([#162](https://github.com/LAPKB/pharmsol/pull/162))
@@ -218,7 +218,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 - Add events to occasions
 - Expose functions for number of states and outeqs
-- Add support for multiple error models  ([#65](https://github.com/LAPKB/pharmsol/pull/65))
+- Add support for multiple error models ([#65](https://github.com/LAPKB/pharmsol/pull/65))
 
 ## [0.9.1](https://github.com/LAPKB/pharmsol/compare/v0.9.0...v0.9.1) - 2025-05-22
 
diff --git a/README.md b/README.md
index be588c9c..cfb6acd0 100644
--- a/README.md
+++ b/README.md
@@ -87,7 +87,44 @@ let ode = equation::ODE::new(
 
 Analytical solutions provide 20-33× speedups compared to equivalent ODE formulations. See [benchmarks](benches/) for details.
 
-## Documentation
+## Non-Compartmental Analysis (NCA)
+
+pharmsol includes a complete NCA module for calculating standard pharmacokinetic parameters.
+
+```rust
+use pharmsol::prelude::*;
+use pharmsol::nca::NCAOptions;
+
+let subject = Subject::builder("patient_001")
+    .bolus(0.0, 100.0, 0)  // 100 mg oral dose
+    .observation(0.5, 5.0, 0)
+    .observation(1.0, 10.0, 0)
+    .observation(2.0, 8.0, 0)
+    .observation(4.0, 4.0, 0)
+    .observation(8.0, 2.0, 0)
+    .build();
+
+let results = subject.nca(&NCAOptions::default(), 0);
+let result = results[0].as_ref().expect("NCA failed");
+
+println!("Cmax: {:.2}", result.exposure.cmax);
+println!("Tmax: {:.2} h", result.exposure.tmax);
+println!("AUClast: {:.2}", result.exposure.auc_last);
+
+if let Some(ref term) = result.terminal {
+    println!("Half-life: {:.2} h", term.half_life);
+}
+```
+
+**Supported NCA Parameters:**
+
+- Exposure: Cmax, Tmax, Clast, Tlast, AUClast, AUCinf, tlag
+- Terminal: λz, t½, MRT
+- Clearance: CL/F, Vz/F, Vss
+- IV-specific: C0 (back-extrapolation), Vd
+- Steady-state: AUCtau, Cmin, Cavg, fluctuation, swing
+
+# Links
 
 - [API Documentation](https://lapkb.github.io/pharmsol/pharmsol/)
 - [Examples](examples/)
diff --git a/examples/nca.rs b/examples/nca.rs
new file mode 100644
index 00000000..56a02e2b
--- /dev/null
+++ b/examples/nca.rs
@@ -0,0 +1,239 @@
+//! NCA (Non-Compartmental Analysis) Example
+//!
+//! This example demonstrates the NCA capabilities of pharmsol.
+//!
+//! Run with: `cargo run --example nca`
+
+use pharmsol::nca::{BLQRule, NCAOptions};
+use pharmsol::prelude::*;
+use pharmsol::Censor;
+
+fn main() {
+    println!("=== pharmsol NCA Example ===\n");
+
+    // Example 1: Basic oral PK analysis
+    basic_oral_example();
+
+    // Example 2: IV Bolus analysis
+    iv_bolus_example();
+
+    // Example 3: IV Infusion analysis
+    iv_infusion_example();
+
+    // Example 4: Steady-state analysis
+    steady_state_example();
+
+    // Example 5: BLQ handling
+    blq_handling_example();
+}
+
+/// Basic oral PK NCA analysis
+fn basic_oral_example() {
+    println!("--- Basic Oral PK Example ---\n");
+
+    // Build subject with oral dose and observations
+    let subject = Subject::builder("patient_001")
+        .bolus(0.0, 100.0, 0) // 100 mg oral dose (input 0 = depot)
+        .observation(0.0, 0.0, 0)
+        .observation(0.5, 5.0, 0)
+        .observation(1.0, 10.0, 0)
+        .observation(2.0, 8.0, 0)
+        .observation(4.0, 4.0, 0)
+        .observation(8.0, 2.0, 0)
+        .observation(12.0, 1.0, 0)
+        .observation(24.0, 0.25, 0)
+        .build();
+
+    let options = NCAOptions::default();
+    let results = subject.nca(&options, 0);
+    let result = results[0].as_ref().expect("NCA analysis failed");
+
+    println!("Exposure Parameters:");
+    println!("  Cmax:     {:.2}", result.exposure.cmax);
+    println!("  Tmax:     {:.2} h", result.exposure.tmax);
+    println!("  Clast:    {:.3}", result.exposure.clast);
+    println!("  Tlast:    {:.1} h", result.exposure.tlast);
+    println!("  AUClast:  {:.2}", result.exposure.auc_last);
+
+    if let Some(ref term) = result.terminal {
+        println!("\nTerminal Phase:");
+        println!("  Lambda-z: {:.4} h⁻¹", term.lambda_z);
+        println!("  Half-life: {:.2} h", term.half_life);
+        if let Some(mrt) = term.mrt {
+            println!("  MRT:      {:.2} h", mrt);
+        }
+    }
+
+    if let Some(ref cl) = result.clearance {
+        println!("\nClearance Parameters:");
+        println!("  CL/F:    {:.2} L/h", cl.cl_f);
+        println!("  Vz/F:    {:.2} L", cl.vz_f);
+    }
+
+    println!("\nQuality: {:?}\n", result.quality.warnings);
+}
+
+/// IV Bolus analysis with C0 back-extrapolation
+fn iv_bolus_example() {
+    println!("--- IV Bolus Example ---\n");
+
+    // Build subject with IV bolus (input 1 = central compartment)
+    let subject = Subject::builder("iv_patient")
+        .bolus(0.0, 500.0, 1) // 500 mg IV bolus
+        .observation(0.25, 95.0, 0)
+        .observation(0.5, 82.0, 0)
+        .observation(1.0, 61.0, 0)
+        .observation(2.0, 34.0, 0)
+        .observation(4.0, 10.0, 0)
+        .observation(8.0, 3.0, 0)
+        .observation(12.0, 0.9, 0)
+        .build();
+
+    let options = NCAOptions::default();
+    let results = subject.nca(&options, 0);
+    let result = results[0].as_ref().expect("NCA analysis failed");
+
+    println!("Exposure:");
+    println!("  Cmax:     {:.1}", result.exposure.cmax);
+    println!("  AUClast:  {:.1}", result.exposure.auc_last);
+
+    if let Some(ref bolus) = result.iv_bolus {
+        println!("\nIV Bolus Parameters:");
+        println!("  C0 (back-extrap): {:.1}", bolus.c0);
+        println!("  Vd:               {:.1} L", bolus.vd);
+        if let Some(vss) = bolus.vss {
+            println!("  Vss:              {:.1} L", vss);
+        }
+    }
+
+    println!();
+}
+
+/// IV Infusion analysis
+fn iv_infusion_example() {
+    println!("--- IV Infusion Example ---\n");
+
+    // Build subject with IV infusion
+    let subject = Subject::builder("infusion_patient")
+        .infusion(0.0, 100.0, 1, 0.5) // 100 mg over 0.5h to central
+        .observation(0.0, 0.0, 0)
+        .observation(0.5, 15.0, 0)
+        .observation(1.0, 12.0, 0)
+        .observation(2.0, 8.0, 0)
+        .observation(4.0, 4.0, 0)
+        .observation(8.0, 1.5, 0)
+        .observation(12.0, 0.5, 0)
+        .build();
+
+    let options = NCAOptions::default();
+    let results = subject.nca(&options, 0);
+    let result = results[0].as_ref().expect("NCA analysis failed");
+
+    println!("Exposure:");
+    println!("  Cmax:     {:.1}", result.exposure.cmax);
+    println!("  Tmax:     {:.2} h", result.exposure.tmax);
+    println!("  AUClast:  {:.1}", result.exposure.auc_last);
+
+    if let Some(ref infusion) = result.iv_infusion {
+        println!("\nIV Infusion Parameters:");
+        println!("  Infusion duration: {:.2} h", infusion.infusion_duration);
+        if let Some(mrt_iv) = infusion.mrt_iv {
+            println!("  MRT (corrected):   {:.2} h", mrt_iv);
+        }
+    }
+
+    println!();
+}
+
+/// Steady-state analysis
+fn steady_state_example() {
+    println!("--- Steady-State Example ---\n");
+
+    // Build subject at steady-state (Q12H dosing)
+    let subject = Subject::builder("ss_patient")
+        .bolus(0.0, 100.0, 0) // 100 mg oral
+        .observation(0.0, 5.0, 0)
+        .observation(1.0, 15.0, 0)
+        .observation(2.0, 12.0, 0)
+        .observation(4.0, 8.0, 0)
+        .observation(6.0, 6.0, 0)
+        .observation(8.0, 5.5, 0)
+        .observation(12.0, 5.0, 0)
+        .build();
+
+    let options = NCAOptions::default().with_tau(12.0); // 12-hour dosing interval
+    let results = subject.nca(&options, 0);
+    let result = results[0].as_ref().expect("NCA analysis failed");
+
+    println!("Exposure:");
+    println!("  Cmax:     {:.1}", result.exposure.cmax);
+    println!("  AUClast:  {:.1}", result.exposure.auc_last);
+
+    if let Some(ref ss) = result.steady_state {
+        println!("\nSteady-State Parameters (tau = {} h):", ss.tau);
+        println!("  AUCtau:       {:.1}", ss.auc_tau);
+        println!("  Cmin:         {:.1}", ss.cmin);
+        println!("  Cmax,ss:      {:.1}", ss.cmax_ss);
+        println!("  Cavg:         {:.2}", ss.cavg);
+        println!("  Fluctuation:  {:.1}%", ss.fluctuation);
+        println!("  Swing:        {:.2}", ss.swing);
+    }
+
+    println!();
+}
+
+/// BLQ handling demonstration
+fn blq_handling_example() {
+    println!("--- BLQ Handling Example ---\n");
+
+    // Build subject with BLQ observations marked using Censor::BLOQ
+    // This is the proper way to indicate BLQ samples - the censoring
+    // information is stored with each observation, not determined
+    // retroactively by a numeric threshold.
+    let subject = Subject::builder("blq_patient")
+        .bolus(0.0, 100.0, 0)
+        .observation(0.0, 0.0, 0)
+        .observation(1.0, 10.0, 0)
+        .observation(2.0, 8.0, 0)
+        .observation(4.0, 4.0, 0)
+        .observation(8.0, 2.0, 0)
+        .observation(12.0, 0.5, 0)
+        // The last observation is BLQ - mark it with Censor::BLOQ
+        // The value (0.02) represents the LOQ threshold
+        .censored_observation(24.0, 0.02, 0, Censor::BLOQ)
+        .build();
+
+    // With BLQ exclusion - BLOQ-marked samples are excluded
+    let options_exclude = NCAOptions::default().with_blq_rule(BLQRule::Exclude);
+    let results_exclude = subject.nca(&options_exclude, 0);
+    let result_exclude = results_exclude[0].as_ref().unwrap();
+
+    // With BLQ = 0 - BLOQ-marked samples are set to zero
+    let options_zero = NCAOptions::default().with_blq_rule(BLQRule::Zero);
+    let results_zero = subject.nca(&options_zero, 0);
+    let result_zero = results_zero[0].as_ref().unwrap();
+
+    // With LOQ/2 - BLOQ-marked samples are set to LOQ/2 (0.02/2 = 0.01)
+    let options_loq2 = NCAOptions::default().with_blq_rule(BLQRule::LoqOver2);
+    let results_loq2 = subject.nca(&options_loq2, 0);
+    let result_loq2 = results_loq2[0].as_ref().unwrap();
+
+    println!("BLQ Handling Comparison (using Censor::BLOQ marking):");
+    println!("\n  Exclude BLQ:");
+    println!("    Tlast:   {:.1} h", result_exclude.exposure.tlast);
+    println!("    AUClast: {:.2}", result_exclude.exposure.auc_last);
+
+    println!("\n  BLQ = 0:");
+    println!("    Tlast:   {:.1} h", result_zero.exposure.tlast);
+    println!("    AUClast: {:.2}", result_zero.exposure.auc_last);
+
+    println!("\n  BLQ = LOQ/2:");
+    println!("    Tlast:   {:.1} h", result_loq2.exposure.tlast);
+    println!("    AUClast: {:.2}", result_loq2.exposure.auc_last);
+
+    println!();
+
+    // Full result display
+    println!("--- Full Result Display ---\n");
+    println!("{}", result_exclude);
+}
diff --git a/examples/one_compartment.rs b/examples/one_compartment.rs
index ee27295b..d6397605 100644
--- a/examples/one_compartment.rs
+++ b/examples/one_compartment.rs
@@ -56,11 +56,11 @@ fn main() -> Result<(), pharmsol::PharmsolError> {
     );
 
     // Define the error models for the observations
-    let ems = ErrorModels::new().
+    let ems = AssayErrorModels::new().
     // For this example, we use a simple additive error model with 5% error
     add(
         0,
-        ErrorModel::additive(ErrorPoly::new(0.0, 0.05, 0.0, 0.0), 0.0),
+        AssayErrorModel::additive(ErrorPoly::new(0.0, 0.05, 0.0, 0.0), 0.0),
     )?;
 
     // Define the parameter values for the simulations
diff --git a/src/data/error_model.rs b/src/data/error_model.rs
index d2989789..54a10bf4 100644
--- a/src/data/error_model.rs
+++ b/src/data/error_model.rs
@@ -118,33 +118,51 @@ impl ErrorPoly {
     }
 }
 
-impl From<Vec<ErrorModel>> for ErrorModels {
-    fn from(models: Vec<ErrorModel>) -> Self {
+impl From<Vec<AssayErrorModel>> for AssayErrorModels {
+    fn from(models: Vec<AssayErrorModel>) -> Self {
         Self { models }
     }
 }
 
-/// Collection of error models for all possible outputs in the model/dataset
-/// This struct holds a vector of error models, each corresponding to a specific output
-/// in the pharmacometric analysis.
+/// Collection of assay/measurement error models for all outputs.
 ///
-/// This is a wrapper around a vector of [ErrorModel]s, its size is determined by the number of outputs in the model/dataset.
+/// This struct represents **measurement/assay noise** - the error associated with
+/// quantification of drug concentration in biological samples. Sigma is computed
+/// from the **observation** value.
+///
+/// Used by non-parametric algorithms (NPAG, NPOD, etc.).
+///
+/// For parametric algorithms (SAEM, FOCE), use [`crate::ResidualErrorModels`] instead,
+/// which computes sigma from the **prediction**.
+///
+/// This is a wrapper around a vector of [AssayErrorModel]s, its size is determined by
+/// the number of outputs in the model/dataset.
 #[derive(Serialize, Debug, Clone, Deserialize)]
-pub struct ErrorModels {
-    models: Vec<ErrorModel>,
+pub struct AssayErrorModels {
+    models: Vec<AssayErrorModel>,
 }
 
-impl Default for ErrorModels {
+/// Deprecated alias for [`AssayErrorModels`].
+///
+/// This type alias is provided for backward compatibility.
+/// New code should use [`AssayErrorModels`] directly.
+#[deprecated(
+    since = "0.23.0",
+    note = "Use AssayErrorModels instead. ErrorModels has been renamed to better reflect its purpose (assay/measurement error)."
+)]
+pub type ErrorModels = AssayErrorModels;
+
+impl Default for AssayErrorModels {
     fn default() -> Self {
         Self::new()
     }
 }
 
-impl ErrorModels {
-    /// Create a new instance of [ErrorModels]
+impl AssayErrorModels {
+    /// Create a new instance of [`AssayErrorModels`]
     ///
     /// # Returns
-    /// A new instance of [ErrorModels].
+    /// A new instance of [AssayErrorModels].
     pub fn new() -> Self {
         Self { models: vec![] }
     }
@@ -154,10 +172,10 @@ impl ErrorModels {
     /// # Arguments
     /// * `outeq` - The index of the output equation for which to retrieve the error model.
     /// # Returns
-    /// A reference to the [ErrorModel] for the specified output equation.
+    /// A reference to the [AssayErrorModel] for the specified output equation.
     /// # Errors
     /// If the output equation index is invalid, an [ErrorModelError::InvalidOutputEquation] is returned.
-    pub fn error_model(&self, outeq: usize) -> Result<&ErrorModel, ErrorModelError> {
+    pub fn error_model(&self, outeq: usize) -> Result<&AssayErrorModel, ErrorModelError> {
         if outeq >= self.models.len() {
             return Err(ErrorModelError::InvalidOutputEquation(outeq));
         }
@@ -167,16 +185,16 @@ impl ErrorModels {
     /// Add a new error model for a specific output equation
     /// # Arguments
     /// * `outeq` - The index of the output equation for which to add the error model.
-    /// * `model` - The [ErrorModel] to add for the specified output equation.
+    /// * `model` - The [AssayErrorModel] to add for the specified output equation.
     /// # Returns
-    /// A new instance of ErrorModels with the added model.
+    /// A new instance of AssayErrorModels with the added model.
     /// # Errors
     /// If the output equation index is invalid or if a model already exists for that output equation, an [ErrorModelError::ExistingOutputEquation] is returned.
-    pub fn add(mut self, outeq: usize, model: ErrorModel) -> Result<Self, ErrorModelError> {
+    pub fn add(mut self, outeq: usize, model: AssayErrorModel) -> Result<Self, ErrorModelError> {
         if outeq >= self.models.len() {
-            self.models.resize(outeq + 1, ErrorModel::None);
+            self.models.resize(outeq + 1, AssayErrorModel::None);
         }
-        if self.models[outeq] != ErrorModel::None {
+        if self.models[outeq] != AssayErrorModel::None {
             return Err(ErrorModelError::ExistingOutputEquation(outeq));
         }
         self.models[outeq] = model;
@@ -185,22 +203,22 @@ impl ErrorModels {
     /// Returns an iterator over the error models in the collection.
     ///
     /// # Returns
-    /// An iterator that yields tuples containing the index and a reference to each [ErrorModel].
-    pub fn iter(&self) -> impl Iterator<Item = (usize, &ErrorModel)> {
+    /// An iterator that yields tuples containing the index and a reference to each [AssayErrorModel].
+    pub fn iter(&self) -> impl Iterator<Item = (usize, &AssayErrorModel)> {
         self.models.iter().enumerate()
     }
 
     /// Returns an iterator that yields mutable references to the error models in the collection.
     /// # Returns
-    /// An iterator that yields tuples containing the index and a mutable reference to each [ErrorModel].
-    pub fn into_iter(self) -> impl Iterator<Item = (usize, ErrorModel)> {
+    /// An iterator that yields tuples containing the index and a mutable reference to each [AssayErrorModel].
+    pub fn into_iter(self) -> impl Iterator<Item = (usize, AssayErrorModel)> {
         self.models.into_iter().enumerate()
     }
 
     /// Returns a mutable iterator that yields mutable references to the error models in the collection.
     /// # Returns
-    /// An iterator that yields tuples containing the index and a mutable reference to each [ErrorModel].
-    pub fn iter_mut(&mut self) -> impl Iterator<Item = (usize, &mut ErrorModel)> {
+    /// An iterator that yields tuples containing the index and a mutable reference to each [AssayErrorModel].
+    pub fn iter_mut(&mut self) -> impl Iterator<Item = (usize, &mut AssayErrorModel)> {
         self.models.iter_mut().enumerate()
     }
 
@@ -218,17 +236,17 @@ impl ErrorModels {
             outeq.hash(&mut hasher);
 
             match model {
-                ErrorModel::Additive { lambda, poly: _ } => {
+                AssayErrorModel::Additive { lambda, poly: _ } => {
                     0u8.hash(&mut hasher); // Use 0 for additive model
                     lambda.value().to_bits().hash(&mut hasher);
                     lambda.is_fixed().hash(&mut hasher); // Include fixed/variable state in hash
                 }
-                ErrorModel::Proportional { gamma, poly: _ } => {
+                AssayErrorModel::Proportional { gamma, poly: _ } => {
                     1u8.hash(&mut hasher); // Use 1 for proportional model
                     gamma.value().to_bits().hash(&mut hasher);
                     gamma.is_fixed().hash(&mut hasher); // Include fixed/variable state in hash
                 }
-                ErrorModel::None => {
+                AssayErrorModel::None => {
                     2u8.hash(&mut hasher); // Use 2 for no model
                 }
             }
@@ -254,7 +272,7 @@ impl ErrorModels {
         if outeq >= self.models.len() {
             return Err(ErrorModelError::InvalidOutputEquation(outeq));
         }
-        if self.models[outeq] == ErrorModel::None {
+        if self.models[outeq] == AssayErrorModel::None {
             return Err(ErrorModelError::NoneErrorModel(outeq));
         }
         self.models[outeq].errorpoly()
@@ -273,7 +291,7 @@ impl ErrorModels {
         if outeq >= self.models.len() {
             return Err(ErrorModelError::InvalidOutputEquation(outeq));
         }
-        if self.models[outeq] == ErrorModel::None {
+        if self.models[outeq] == AssayErrorModel::None {
             return Err(ErrorModelError::NoneErrorModel(outeq));
         }
         Ok(self.models[outeq].factor()?)
@@ -289,7 +307,7 @@ impl ErrorModels {
         if outeq >= self.models.len() {
             return Err(ErrorModelError::InvalidOutputEquation(outeq));
         }
-        if self.models[outeq] == ErrorModel::None {
+        if self.models[outeq] == AssayErrorModel::None {
             return Err(ErrorModelError::NoneErrorModel(outeq));
         }
         self.models[outeq].set_errorpoly(poly);
@@ -306,7 +324,7 @@ impl ErrorModels {
         if outeq >= self.models.len() {
             return Err(ErrorModelError::InvalidOutputEquation(outeq));
         }
-        if self.models[outeq] == ErrorModel::None {
+        if self.models[outeq] == AssayErrorModel::None {
             return Err(ErrorModelError::NoneErrorModel(outeq));
         }
         self.models[outeq].set_factor(factor);
@@ -326,7 +344,7 @@ impl ErrorModels {
         if outeq >= self.models.len() {
             return Err(ErrorModelError::InvalidOutputEquation(outeq));
         }
-        if self.models[outeq] == ErrorModel::None {
+        if self.models[outeq] == AssayErrorModel::None {
             return Err(ErrorModelError::NoneErrorModel(outeq));
         }
         self.models[outeq].factor_param()
@@ -342,7 +360,7 @@ impl ErrorModels {
         if outeq >= self.models.len() {
             return Err(ErrorModelError::InvalidOutputEquation(outeq));
         }
-        if self.models[outeq] == ErrorModel::None {
+        if self.models[outeq] == AssayErrorModel::None {
             return Err(ErrorModelError::NoneErrorModel(outeq));
         }
         self.models[outeq].set_factor_param(param);
@@ -362,7 +380,7 @@ impl ErrorModels {
         if outeq >= self.models.len() {
             return Err(ErrorModelError::InvalidOutputEquation(outeq));
         }
-        if self.models[outeq] == ErrorModel::None {
+        if self.models[outeq] == AssayErrorModel::None {
             return Err(ErrorModelError::NoneErrorModel(outeq));
         }
         self.models[outeq].is_factor_fixed()
@@ -377,7 +395,7 @@ impl ErrorModels {
         if outeq >= self.models.len() {
             return Err(ErrorModelError::InvalidOutputEquation(outeq));
         }
-        if self.models[outeq] == ErrorModel::None {
+        if self.models[outeq] == AssayErrorModel::None {
             return Err(ErrorModelError::NoneErrorModel(outeq));
         }
         self.models[outeq].fix_factor();
@@ -393,18 +411,53 @@ impl ErrorModels {
         if outeq >= self.models.len() {
             return Err(ErrorModelError::InvalidOutputEquation(outeq));
         }
-        if self.models[outeq] == ErrorModel::None {
+        if self.models[outeq] == AssayErrorModel::None {
             return Err(ErrorModelError::NoneErrorModel(outeq));
         }
         self.models[outeq].unfix_factor();
         Ok(())
     }
 
+    /// Check if the error model for a specific output equation is proportional
+    ///
+    /// # Arguments
+    ///
+    /// * `outeq` - The index of the output equation
+    ///
+    /// # Returns
+    ///
+    /// `true` if the error model for `outeq` is proportional, `false` otherwise
+    pub fn is_proportional(&self, outeq: usize) -> bool {
+        if outeq >= self.models.len() {
+            return false;
+        }
+        self.models[outeq].is_proportional()
+    }
+
+    /// Check if the error model for a specific output equation is additive
+    ///
+    /// # Arguments
+    ///
+    /// * `outeq` - The index of the output equation
+    ///
+    /// # Returns
+    ///
+    /// `true` if the error model for `outeq` is additive, `false` otherwise
+    pub fn is_additive(&self, outeq: usize) -> bool {
+        if outeq >= self.models.len() {
+            return false;
+        }
+        self.models[outeq].is_additive()
+    }
+
     /// Computes the standard deviation (sigma) for the specified output equation and prediction.
     ///
+    /// This always uses the **observation** value to compute sigma, which is appropriate
+    /// for non-parametric algorithms (NPAG, NPOD). For parametric algorithms (SAEM, FOCE),
+    /// use [`crate::ResidualErrorModels`] instead, which computes sigma from the prediction.
+    ///
     /// # Arguments
     ///
-    /// * `outeq` - The index of the output equation.
     /// * `prediction` - The [`Prediction`] to use for the calculation.
     ///
     /// # Returns
@@ -415,7 +468,7 @@ impl ErrorModels {
         if outeq >= self.models.len() {
             return Err(ErrorModelError::InvalidOutputEquation(outeq));
         }
-        if self.models[outeq] == ErrorModel::None {
+        if self.models[outeq] == AssayErrorModel::None {
             return Err(ErrorModelError::NoneErrorModel(outeq));
         }
         self.models[prediction.outeq].sigma(prediction)
@@ -436,7 +489,7 @@ impl ErrorModels {
         if outeq >= self.models.len() {
             return Err(ErrorModelError::InvalidOutputEquation(outeq));
         }
-        if self.models[outeq] == ErrorModel::None {
+        if self.models[outeq] == AssayErrorModel::None {
             return Err(ErrorModelError::NoneErrorModel(outeq));
         }
         self.models[prediction.outeq].variance(prediction)
@@ -456,7 +509,7 @@ impl ErrorModels {
         if outeq >= self.models.len() {
             return Err(ErrorModelError::InvalidOutputEquation(outeq));
         }
-        if self.models[outeq] == ErrorModel::None {
+        if self.models[outeq] == AssayErrorModel::None {
             return Err(ErrorModelError::NoneErrorModel(outeq));
         }
         self.models[outeq].sigma_from_value(value)
@@ -476,15 +529,15 @@ impl ErrorModels {
         if outeq >= self.models.len() {
             return Err(ErrorModelError::InvalidOutputEquation(outeq));
         }
-        if self.models[outeq] == ErrorModel::None {
+        if self.models[outeq] == AssayErrorModel::None {
             return Err(ErrorModelError::NoneErrorModel(outeq));
         }
         self.models[outeq].variance_from_value(value)
     }
 }
 
-impl IntoIterator for ErrorModels {
-    type Item = (usize, ErrorModel);
+impl IntoIterator for AssayErrorModels {
+    type Item = (usize, AssayErrorModel);
     type IntoIter = std::vec::IntoIter<Self::Item>;
 
     fn into_iter(self) -> Self::IntoIter {
@@ -496,18 +549,18 @@ impl IntoIterator for ErrorModels {
     }
 }
 
-impl<'a> IntoIterator for &'a ErrorModels {
-    type Item = (usize, &'a ErrorModel);
-    type IntoIter = std::iter::Enumerate<std::slice::Iter<'a, ErrorModel>>;
+impl<'a> IntoIterator for &'a AssayErrorModels {
+    type Item = (usize, &'a AssayErrorModel);
+    type IntoIter = std::iter::Enumerate<std::slice::Iter<'a, AssayErrorModel>>;
 
     fn into_iter(self) -> Self::IntoIter {
         self.models.iter().enumerate()
     }
 }
 
-impl<'a> IntoIterator for &'a mut ErrorModels {
-    type Item = (usize, &'a mut ErrorModel);
-    type IntoIter = std::iter::Enumerate<std::slice::IterMut<'a, ErrorModel>>;
+impl<'a> IntoIterator for &'a mut AssayErrorModels {
+    type Item = (usize, &'a mut AssayErrorModel);
+    type IntoIter = std::iter::Enumerate<std::slice::IterMut<'a, AssayErrorModel>>;
 
     fn into_iter(self) -> Self::IntoIter {
         self.models.iter_mut().enumerate()
@@ -516,10 +569,10 @@ impl<'a> IntoIterator for &'a mut ErrorModels {
 
 /// Model for calculating observation errors in pharmacometric analyses
 ///
-/// An [ErrorModel] defines how the standard deviation of observations is calculated
+/// An [AssayErrorModel] defines how the standard deviation of observations is calculated
 /// based on the type of error model used and its parameters.
 #[derive(Debug, Clone, Serialize, Deserialize, Default, PartialEq)]
-pub enum ErrorModel {
+pub enum AssayErrorModel {
     /// Additive error model, where error is independent of concentration
     ///
     /// Contains:
@@ -547,14 +600,23 @@ pub enum ErrorModel {
     None,
 }
 
-impl ErrorModel {
+/// Deprecated alias for [`AssayErrorModel`].
+///
+/// This type alias is provided for backward compatibility.
+/// New code should use [`AssayErrorModel`] directly.
+#[deprecated(
+    since = "0.23.0",
+    note = "Use AssayErrorModel instead. ErrorModel has been renamed to better reflect its purpose (assay/measurement error)."
+)]
+pub type ErrorModel = AssayErrorModel;
+
+impl AssayErrorModel {
     /// Create a new additive error model with a variable lambda parameter
     ///
     /// # Arguments
     ///
     /// * `poly` - Error polynomial coefficients (c0, c1, c2, c3)
     /// * `lambda` - Lambda parameter for scaling errors (will be variable)
-    /// * `lloq` - Optional lower limit of quantification
     ///
     /// # Returns
     ///
@@ -572,7 +634,6 @@ impl ErrorModel {
     ///
     /// * `poly` - Error polynomial coefficients (c0, c1, c2, c3)
     /// * `lambda` - Lambda parameter for scaling errors (will be fixed)
-    /// * `lloq` - Optional lower limit of quantification
     ///
     /// # Returns
     ///
@@ -590,7 +651,6 @@ impl ErrorModel {
     ///
     /// * `poly` - Error polynomial coefficients (c0, c1, c2, c3)
     /// * `lambda` - Lambda parameter (can be Variable or Fixed) using [Factor]
-    /// * `lloq` - Optional lower limit of quantification
     ///
     /// # Returns
     ///
@@ -605,7 +665,6 @@ impl ErrorModel {
     ///
     /// * `poly` - Error polynomial coefficients (c0, c1, c2, c3)
     /// * `gamma` - Gamma parameter for scaling errors (will be variable)
-    /// * `lloq` - Optional lower limit of quantification
     ///
     /// # Returns
     ///
@@ -623,7 +682,6 @@ impl ErrorModel {
     ///
     /// * `poly` - Error polynomial coefficients (c0, c1, c2, c3)
     /// * `gamma` - Gamma parameter for scaling errors (will be fixed)
-    /// * `lloq` - Optional lower limit of quantification
     ///
     /// # Returns
     ///
@@ -641,7 +699,6 @@ impl ErrorModel {
     ///
     /// * `poly` - Error polynomial coefficients (c0, c1, c2, c3)
     /// * `gamma` - Gamma parameter (can be Variable or Fixed) using [Factor]
-    /// * `lloq` - Optional lower limit of quantification
     ///
     /// # Returns
     ///
@@ -743,6 +800,24 @@ impl ErrorModel {
         }
     }
 
+    /// Check if this is a proportional error model
+    ///
+    /// # Returns
+    ///
+    /// `true` if this is a `Proportional` variant, `false` otherwise
+    pub fn is_proportional(&self) -> bool {
+        matches!(self, Self::Proportional { .. })
+    }
+
+    /// Check if this is an additive error model
+    ///
+    /// # Returns
+    ///
+    /// `true` if this is an `Additive` variant, `false` otherwise
+    pub fn is_additive(&self) -> bool {
+        matches!(self, Self::Additive { .. })
+    }
+
     /// Estimate the standard deviation for a prediction
     ///
     /// Calculates the standard deviation based on the error model type,
@@ -795,7 +870,7 @@ impl ErrorModel {
 
     /// Estimate the variance of the observation
     ///
-    /// This is a conveniecen function which calls [ErrorModel::sigma], and squares the result.
+    /// This is a convenience function which calls [AssayErrorModel::sigma], and squares the result.
     pub fn variance(&self, prediction: &Prediction) -> Result<f64, ErrorModelError> {
         let sigma = self.sigma(prediction)?;
         Ok(sigma.powi(2))
@@ -842,7 +917,7 @@ impl ErrorModel {
 
     /// Estimate the variance for a raw observation value
     ///
-    /// This is a conveniecen function which calls [ErrorModel::sigma_from_value], and squares the result.
+    /// This is a convenience function which calls [AssayErrorModel::sigma_from_value], and squares the result.
     pub fn variance_from_value(&self, value: f64) -> Result<f64, ErrorModelError> {
         let sigma = self.sigma_from_value(value)?;
         Ok(sigma.powi(2))
@@ -889,7 +964,7 @@ mod tests {
     fn test_additive_error_model() {
         let observation = Observation::new(0.0, Some(20.0), 0, None, 0, Censor::None);
         let prediction = observation.to_prediction(10.0, vec![]);
-        let model = ErrorModel::additive(ErrorPoly::new(1.0, 0.0, 0.0, 0.0), 5.0);
+        let model = AssayErrorModel::additive(ErrorPoly::new(1.0, 0.0, 0.0, 0.0), 5.0);
         assert_eq!(model.sigma(&prediction).unwrap(), (26.0_f64).sqrt());
     }
 
@@ -897,13 +972,13 @@ mod tests {
     fn test_proportional_error_model() {
         let observation = Observation::new(0.0, Some(20.0), 0, None, 0, Censor::None);
         let prediction = observation.to_prediction(10.0, vec![]);
-        let model = ErrorModel::proportional(ErrorPoly::new(1.0, 0.0, 0.0, 0.0), 2.0);
+        let model = AssayErrorModel::proportional(ErrorPoly::new(1.0, 0.0, 0.0, 0.0), 2.0);
         assert_eq!(model.sigma(&prediction).unwrap(), 2.0);
     }
 
     #[test]
     fn test_polynomial() {
-        let model = ErrorModel::additive(ErrorPoly::new(1.0, 2.0, 3.0, 4.0), 5.0);
+        let model = AssayErrorModel::additive(ErrorPoly::new(1.0, 2.0, 3.0, 4.0), 5.0);
         assert_eq!(
             model.errorpoly().unwrap().coefficients(),
             (1.0, 2.0, 3.0, 4.0)
@@ -912,7 +987,7 @@ mod tests {
 
     #[test]
     fn test_set_errorpoly() {
-        let mut model = ErrorModel::additive(ErrorPoly::new(1.0, 2.0, 3.0, 4.0), 5.0);
+        let mut model = AssayErrorModel::additive(ErrorPoly::new(1.0, 2.0, 3.0, 4.0), 5.0);
         assert_eq!(
             model.errorpoly().unwrap().coefficients(),
             (1.0, 2.0, 3.0, 4.0)
@@ -926,7 +1001,7 @@ mod tests {
 
     #[test]
     fn test_set_factor() {
-        let mut model = ErrorModel::additive(ErrorPoly::new(1.0, 2.0, 3.0, 4.0), 5.0);
+        let mut model = AssayErrorModel::additive(ErrorPoly::new(1.0, 2.0, 3.0, 4.0), 5.0);
         assert_eq!(model.factor().unwrap(), 5.0);
         model.set_factor(10.0);
         assert_eq!(model.factor().unwrap(), 10.0);
@@ -934,38 +1009,38 @@ mod tests {
 
     #[test]
     fn test_sigma_from_value() {
-        let model = ErrorModel::additive(ErrorPoly::new(1.0, 0.0, 0.0, 0.0), 5.0);
+        let model = AssayErrorModel::additive(ErrorPoly::new(1.0, 0.0, 0.0, 0.0), 5.0);
         assert_eq!(model.sigma_from_value(20.0).unwrap(), (26.0_f64).sqrt());
 
-        let model = ErrorModel::proportional(ErrorPoly::new(1.0, 0.0, 0.0, 0.0), 2.0);
+        let model = AssayErrorModel::proportional(ErrorPoly::new(1.0, 0.0, 0.0, 0.0), 2.0);
         assert_eq!(model.sigma_from_value(20.0).unwrap(), 2.0);
     }
 
     #[test]
     fn test_error_models_new() {
-        let models = ErrorModels::new();
+        let models = AssayErrorModels::new();
         assert_eq!(models.len(), 0);
     }
 
     #[test]
     fn test_error_models_default() {
-        let models = ErrorModels::default();
+        let models = AssayErrorModels::default();
         assert_eq!(models.len(), 0);
     }
 
     #[test]
     fn test_error_models_add_single() {
-        let model = ErrorModel::additive(ErrorPoly::new(1.0, 0.0, 0.0, 0.0), 5.0);
-        let models = ErrorModels::new().add(0, model).unwrap();
+        let model = AssayErrorModel::additive(ErrorPoly::new(1.0, 0.0, 0.0, 0.0), 5.0);
+        let models = AssayErrorModels::new().add(0, model).unwrap();
         assert_eq!(models.len(), 1);
     }
 
     #[test]
     fn test_error_models_add_multiple() {
-        let model1 = ErrorModel::additive(ErrorPoly::new(1.0, 0.0, 0.0, 0.0), 5.0);
-        let model2 = ErrorModel::proportional(ErrorPoly::new(2.0, 0.0, 0.0, 0.0), 3.0);
+        let model1 = AssayErrorModel::additive(ErrorPoly::new(1.0, 0.0, 0.0, 0.0), 5.0);
+        let model2 = AssayErrorModel::proportional(ErrorPoly::new(2.0, 0.0, 0.0, 0.0), 3.0);
 
-        let models = ErrorModels::new()
+        let models = AssayErrorModels::new()
             .add(0, model1)
             .unwrap()
             .add(1, model2)
@@ -976,10 +1051,13 @@ mod tests {
 
     #[test]
     fn test_error_models_add_duplicate_outeq_fails() {
-        let model1 = ErrorModel::additive(ErrorPoly::new(1.0, 0.0, 0.0, 0.0), 5.0);
-        let model2 = ErrorModel::proportional(ErrorPoly::new(2.0, 0.0, 0.0, 0.0), 3.0);
+        let model1 = AssayErrorModel::additive(ErrorPoly::new(1.0, 0.0, 0.0, 0.0), 5.0);
+        let model2 = AssayErrorModel::proportional(ErrorPoly::new(2.0, 0.0, 0.0, 0.0), 3.0);
 
-        let result = ErrorModels::new().add(0, model1).unwrap().add(0, model2); // Same outeq should fail
+        let result = AssayErrorModels::new()
+            .add(0, model1)
+            .unwrap()
+            .add(0, model2); // Same outeq should fail
 
         assert!(result.is_err());
         match result {
@@ -990,16 +1068,16 @@ mod tests {
 
     #[test]
     fn test_error_models_factor() {
-        let model = ErrorModel::additive(ErrorPoly::new(1.0, 0.0, 0.0, 0.0), 5.0);
-        let models = ErrorModels::new().add(0, model).unwrap();
+        let model = AssayErrorModel::additive(ErrorPoly::new(1.0, 0.0, 0.0, 0.0), 5.0);
+        let models = AssayErrorModels::new().add(0, model).unwrap();
 
         assert_eq!(models.factor(0).unwrap(), 5.0);
     }
 
     #[test]
     fn test_error_models_factor_invalid_outeq() {
-        let model = ErrorModel::additive(ErrorPoly::new(1.0, 0.0, 0.0, 0.0), 5.0);
-        let models = ErrorModels::new().add(0, model).unwrap();
+        let model = AssayErrorModel::additive(ErrorPoly::new(1.0, 0.0, 0.0, 0.0), 5.0);
+        let models = AssayErrorModels::new().add(0, model).unwrap();
 
         let result = models.factor(1);
         assert!(result.is_err());
@@ -1011,8 +1089,8 @@ mod tests {
 
     #[test]
     fn test_error_models_set_factor() {
-        let model = ErrorModel::additive(ErrorPoly::new(1.0, 0.0, 0.0, 0.0), 5.0);
-        let mut models = ErrorModels::new().add(0, model).unwrap();
+        let model = AssayErrorModel::additive(ErrorPoly::new(1.0, 0.0, 0.0, 0.0), 5.0);
+        let mut models = AssayErrorModels::new().add(0, model).unwrap();
 
         assert_eq!(models.factor(0).unwrap(), 5.0);
         models.set_factor(0, 10.0).unwrap();
@@ -1021,8 +1099,8 @@ mod tests {
 
     #[test]
     fn test_error_models_set_factor_invalid_outeq() {
-        let model = ErrorModel::additive(ErrorPoly::new(1.0, 0.0, 0.0, 0.0), 5.0);
-        let mut models = ErrorModels::new().add(0, model).unwrap();
+        let model = AssayErrorModel::additive(ErrorPoly::new(1.0, 0.0, 0.0, 0.0), 5.0);
+        let mut models = AssayErrorModels::new().add(0, model).unwrap();
 
         let result = models.set_factor(1, 10.0);
         assert!(result.is_err());
@@ -1035,8 +1113,8 @@ mod tests {
     #[test]
     fn test_error_models_errorpoly() {
         let poly = ErrorPoly::new(1.0, 2.0, 3.0, 4.0);
-        let model = ErrorModel::additive(poly, 5.0);
-        let models = ErrorModels::new().add(0, model).unwrap();
+        let model = AssayErrorModel::additive(poly, 5.0);
+        let models = AssayErrorModels::new().add(0, model).unwrap();
 
         let retrieved_poly = models.errorpoly(0).unwrap();
         assert_eq!(retrieved_poly.coefficients(), (1.0, 2.0, 3.0, 4.0));
@@ -1044,8 +1122,8 @@ mod tests {
 
     #[test]
     fn test_error_models_errorpoly_invalid_outeq() {
-        let model = ErrorModel::additive(ErrorPoly::new(1.0, 0.0, 0.0, 0.0), 5.0);
-        let models = ErrorModels::new().add(0, model).unwrap();
+        let model = AssayErrorModel::additive(ErrorPoly::new(1.0, 0.0, 0.0, 0.0), 5.0);
+        let models = AssayErrorModels::new().add(0, model).unwrap();
 
         let result = models.errorpoly(1);
         assert!(result.is_err());
@@ -1059,8 +1137,8 @@ mod tests {
     fn test_error_models_set_errorpoly() {
         let poly1 = ErrorPoly::new(1.0, 2.0, 3.0, 4.0);
         let poly2 = ErrorPoly::new(5.0, 6.0, 7.0, 8.0);
-        let model = ErrorModel::additive(poly1, 5.0);
-        let mut models = ErrorModels::new().add(0, model).unwrap();
+        let model = AssayErrorModel::additive(poly1, 5.0);
+        let mut models = AssayErrorModels::new().add(0, model).unwrap();
 
         assert_eq!(
             models.errorpoly(0).unwrap().coefficients(),
@@ -1075,8 +1153,8 @@ mod tests {
 
     #[test]
     fn test_error_models_set_errorpoly_invalid_outeq() {
-        let model = ErrorModel::additive(ErrorPoly::new(1.0, 0.0, 0.0, 0.0), 5.0);
-        let mut models = ErrorModels::new().add(0, model).unwrap();
+        let model = AssayErrorModel::additive(ErrorPoly::new(1.0, 0.0, 0.0, 0.0), 5.0);
+        let mut models = AssayErrorModels::new().add(0, model).unwrap();
 
         let result = models.set_errorpoly(1, ErrorPoly::new(5.0, 6.0, 7.0, 8.0));
         assert!(result.is_err());
@@ -1088,20 +1166,21 @@ mod tests {
 
     #[test]
     fn test_error_models_sigma() {
-        let model = ErrorModel::additive(ErrorPoly::new(1.0, 0.0, 0.0, 0.0), 5.0);
-        let models = ErrorModels::new().add(0, model).unwrap();
+        let model = AssayErrorModel::additive(ErrorPoly::new(1.0, 0.0, 0.0, 0.0), 5.0);
+        let models = AssayErrorModels::new().add(0, model).unwrap();
 
         let observation = Observation::new(0.0, Some(20.0), 0, None, 0, Censor::None);
         let prediction = observation.to_prediction(10.0, vec![]);
 
+        // Non-parametric: sigma from observation
         let sigma = models.sigma(&prediction).unwrap();
         assert_eq!(sigma, (26.0_f64).sqrt());
     }
 
     #[test]
     fn test_error_models_sigma_invalid_outeq() {
-        let model = ErrorModel::additive(ErrorPoly::new(1.0, 0.0, 0.0, 0.0), 5.0);
-        let models = ErrorModels::new().add(0, model).unwrap();
+        let model = AssayErrorModel::additive(ErrorPoly::new(1.0, 0.0, 0.0, 0.0), 5.0);
+        let models = AssayErrorModels::new().add(0, model).unwrap();
 
         let observation = Observation::new(0.0, Some(20.0), 1, None, 0, Censor::None); // outeq=1 not in models
         let prediction = observation.to_prediction(10.0, vec![]);
@@ -1116,8 +1195,8 @@ mod tests {
 
     #[test]
     fn test_error_models_variance() {
-        let model = ErrorModel::additive(ErrorPoly::new(1.0, 0.0, 0.0, 0.0), 5.0);
-        let models = ErrorModels::new().add(0, model).unwrap();
+        let model = AssayErrorModel::additive(ErrorPoly::new(1.0, 0.0, 0.0, 0.0), 5.0);
+        let models = AssayErrorModels::new().add(0, model).unwrap();
 
         let observation = Observation::new(0.0, Some(20.0), 0, None, 0, Censor::None);
         let prediction = observation.to_prediction(10.0, vec![]);
@@ -1129,8 +1208,8 @@ mod tests {
 
     #[test]
     fn test_error_models_variance_invalid_outeq() {
-        let model = ErrorModel::additive(ErrorPoly::new(1.0, 0.0, 0.0, 0.0), 5.0);
-        let models = ErrorModels::new().add(0, model).unwrap();
+        let model = AssayErrorModel::additive(ErrorPoly::new(1.0, 0.0, 0.0, 0.0), 5.0);
+        let models = AssayErrorModels::new().add(0, model).unwrap();
 
         let observation = Observation::new(0.0, Some(20.0), 1, None, 0, Censor::None); // outeq=1 not in models
         let prediction = observation.to_prediction(10.0, vec![]);
@@ -1145,8 +1224,8 @@ mod tests {
 
     #[test]
     fn test_error_models_sigma_from_value() {
-        let model = ErrorModel::additive(ErrorPoly::new(1.0, 0.0, 0.0, 0.0), 5.0);
-        let models = ErrorModels::new().add(0, model).unwrap();
+        let model = AssayErrorModel::additive(ErrorPoly::new(1.0, 0.0, 0.0, 0.0), 5.0);
+        let models = AssayErrorModels::new().add(0, model).unwrap();
 
         let sigma = models.sigma_from_value(0, 20.0).unwrap();
         assert_eq!(sigma, (26.0_f64).sqrt());
@@ -1154,8 +1233,8 @@ mod tests {
 
     #[test]
     fn test_error_models_sigma_from_value_invalid_outeq() {
-        let model = ErrorModel::additive(ErrorPoly::new(1.0, 0.0, 0.0, 0.0), 5.0);
-        let models = ErrorModels::new().add(0, model).unwrap();
+        let model = AssayErrorModel::additive(ErrorPoly::new(1.0, 0.0, 0.0, 0.0), 5.0);
+        let models = AssayErrorModels::new().add(0, model).unwrap();
 
         let result = models.sigma_from_value(1, 20.0);
         assert!(result.is_err());
@@ -1167,8 +1246,8 @@ mod tests {
 
     #[test]
     fn test_error_models_variance_from_value() {
-        let model = ErrorModel::additive(ErrorPoly::new(1.0, 0.0, 0.0, 0.0), 5.0);
-        let models = ErrorModels::new().add(0, model).unwrap();
+        let model = AssayErrorModel::additive(ErrorPoly::new(1.0, 0.0, 0.0, 0.0), 5.0);
+        let models = AssayErrorModels::new().add(0, model).unwrap();
 
         let variance = models.variance_from_value(0, 20.0).unwrap();
         let expected_sigma = (26.0_f64).sqrt();
@@ -1177,8 +1256,8 @@ mod tests {
 
     #[test]
     fn test_error_models_variance_from_value_invalid_outeq() {
-        let model = ErrorModel::additive(ErrorPoly::new(1.0, 0.0, 0.0, 0.0), 5.0);
-        let models = ErrorModels::new().add(0, model).unwrap();
+        let model = AssayErrorModel::additive(ErrorPoly::new(1.0, 0.0, 0.0, 0.0), 5.0);
+        let models = AssayErrorModels::new().add(0, model).unwrap();
 
         let result = models.variance_from_value(1, 20.0);
         assert!(result.is_err());
@@ -1190,16 +1269,16 @@ mod tests {
 
     #[test]
     fn test_error_models_hash_consistency() {
-        let model1 = ErrorModel::additive(ErrorPoly::new(1.0, 0.0, 0.0, 0.0), 5.0);
-        let model2 = ErrorModel::proportional(ErrorPoly::new(2.0, 0.0, 0.0, 0.0), 3.0);
+        let model1 = AssayErrorModel::additive(ErrorPoly::new(1.0, 0.0, 0.0, 0.0), 5.0);
+        let model2 = AssayErrorModel::proportional(ErrorPoly::new(2.0, 0.0, 0.0, 0.0), 3.0);
 
-        let models1 = ErrorModels::new()
+        let models1 = AssayErrorModels::new()
             .add(0, model1.clone())
             .unwrap()
             .add(1, model2.clone())
             .unwrap();
 
-        let models2 = ErrorModels::new()
+        let models2 = AssayErrorModels::new()
             .add(0, model1)
             .unwrap()
             .add(1, model2)
@@ -1211,17 +1290,17 @@ mod tests {
 
     #[test]
     fn test_error_models_hash_order_independence() {
-        let model1 = ErrorModel::additive(ErrorPoly::new(1.0, 0.0, 0.0, 0.0), 5.0);
-        let model2 = ErrorModel::proportional(ErrorPoly::new(2.0, 0.0, 0.0, 0.0), 3.0);
+        let model1 = AssayErrorModel::additive(ErrorPoly::new(1.0, 0.0, 0.0, 0.0), 5.0);
+        let model2 = AssayErrorModel::proportional(ErrorPoly::new(2.0, 0.0, 0.0, 0.0), 3.0);
 
         // Add in different orders
-        let models1 = ErrorModels::new()
+        let models1 = AssayErrorModels::new()
             .add(0, model1.clone())
             .unwrap()
             .add(1, model2.clone())
             .unwrap();
 
-        let models2 = ErrorModels::new()
+        let models2 = AssayErrorModels::new()
             .add(1, model2)
             .unwrap()
             .add(0, model1)
@@ -1233,10 +1312,11 @@ mod tests {
 
     #[test]
     fn test_error_models_multiple_outeqs() {
-        let additive_model = ErrorModel::additive(ErrorPoly::new(1.0, 0.1, 0.0, 0.0), 0.5);
-        let proportional_model = ErrorModel::proportional(ErrorPoly::new(0.0, 0.05, 0.0, 0.0), 0.1);
+        let additive_model = AssayErrorModel::additive(ErrorPoly::new(1.0, 0.1, 0.0, 0.0), 0.5);
+        let proportional_model =
+            AssayErrorModel::proportional(ErrorPoly::new(0.0, 0.05, 0.0, 0.0), 0.1);
 
-        let models = ErrorModels::new()
+        let models = AssayErrorModels::new()
             .add(0, additive_model)
             .unwrap()
             .add(1, proportional_model)
@@ -1261,10 +1341,11 @@ mod tests {
 
     #[test]
     fn test_error_models_with_predictions_different_outeqs() {
-        let additive_model = ErrorModel::additive(ErrorPoly::new(1.0, 0.0, 0.0, 0.0), 5.0);
-        let proportional_model = ErrorModel::proportional(ErrorPoly::new(1.0, 0.0, 0.0, 0.0), 2.0);
+        let additive_model = AssayErrorModel::additive(ErrorPoly::new(1.0, 0.0, 0.0, 0.0), 5.0);
+        let proportional_model =
+            AssayErrorModel::proportional(ErrorPoly::new(1.0, 0.0, 0.0, 0.0), 2.0);
 
-        let models = ErrorModels::new()
+        let models = AssayErrorModels::new()
             .add(0, additive_model)
             .unwrap()
             .add(1, proportional_model)
@@ -1286,31 +1367,34 @@ mod tests {
     #[test]
     fn test_factor_param_new_constructors() {
         // Test variable constructors (default behavior)
-        let additive = ErrorModel::additive(ErrorPoly::new(1.0, 0.0, 0.0, 0.0), 5.0);
+        let additive = AssayErrorModel::additive(ErrorPoly::new(1.0, 0.0, 0.0, 0.0), 5.0);
         assert_eq!(additive.factor().unwrap(), 5.0);
         assert!(!additive.is_factor_fixed().unwrap());
 
-        let proportional = ErrorModel::proportional(ErrorPoly::new(1.0, 0.0, 0.0, 0.0), 2.0);
+        let proportional = AssayErrorModel::proportional(ErrorPoly::new(1.0, 0.0, 0.0, 0.0), 2.0);
         assert_eq!(proportional.factor().unwrap(), 2.0);
         assert!(!proportional.is_factor_fixed().unwrap());
 
         // Test fixed constructors
-        let additive_fixed = ErrorModel::additive_fixed(ErrorPoly::new(1.0, 0.0, 0.0, 0.0), 5.0);
+        let additive_fixed =
+            AssayErrorModel::additive_fixed(ErrorPoly::new(1.0, 0.0, 0.0, 0.0), 5.0);
         assert_eq!(additive_fixed.factor().unwrap(), 5.0);
         assert!(additive_fixed.is_factor_fixed().unwrap());
 
         let proportional_fixed =
-            ErrorModel::proportional_fixed(ErrorPoly::new(1.0, 0.0, 0.0, 0.0), 2.0);
+            AssayErrorModel::proportional_fixed(ErrorPoly::new(1.0, 0.0, 0.0, 0.0), 2.0);
         assert_eq!(proportional_fixed.factor().unwrap(), 2.0);
         assert!(proportional_fixed.is_factor_fixed().unwrap());
 
         // Test Factor constructors
-        let additive_with_param =
-            ErrorModel::additive_with_param(ErrorPoly::new(1.0, 0.0, 0.0, 0.0), Factor::Fixed(5.0));
+        let additive_with_param = AssayErrorModel::additive_with_param(
+            ErrorPoly::new(1.0, 0.0, 0.0, 0.0),
+            Factor::Fixed(5.0),
+        );
         assert_eq!(additive_with_param.factor().unwrap(), 5.0);
         assert!(additive_with_param.is_factor_fixed().unwrap());
 
-        let proportional_with_param = ErrorModel::proportional_with_param(
+        let proportional_with_param = AssayErrorModel::proportional_with_param(
             ErrorPoly::new(1.0, 0.0, 0.0, 0.0),
             Factor::Variable(2.0),
         );
@@ -1320,7 +1404,7 @@ mod tests {
 
     #[test]
     fn test_factor_param_methods() {
-        let mut model = ErrorModel::additive(ErrorPoly::new(1.0, 0.0, 0.0, 0.0), 5.0);
+        let mut model = AssayErrorModel::additive(ErrorPoly::new(1.0, 0.0, 0.0, 0.0), 5.0);
 
         // Test initial state
         assert_eq!(model.factor().unwrap(), 5.0);
@@ -1376,10 +1460,12 @@ mod tests {
 
     #[test]
     fn test_error_models_factor_param_methods() {
-        let additive_model = ErrorModel::additive_fixed(ErrorPoly::new(1.0, 0.0, 0.0, 0.0), 5.0);
-        let proportional_model = ErrorModel::proportional(ErrorPoly::new(1.0, 0.0, 0.0, 0.0), 2.0);
+        let additive_model =
+            AssayErrorModel::additive_fixed(ErrorPoly::new(1.0, 0.0, 0.0, 0.0), 5.0);
+        let proportional_model =
+            AssayErrorModel::proportional(ErrorPoly::new(1.0, 0.0, 0.0, 0.0), 2.0);
 
-        let mut models = ErrorModels::new()
+        let mut models = AssayErrorModels::new()
             .add(0, additive_model)
             .unwrap()
             .add(1, proportional_model)
@@ -1417,8 +1503,8 @@ mod tests {
         let observation = Observation::new(0.0, Some(20.0), 0, None, 0, Censor::None);
         let prediction = observation.to_prediction(10.0, vec![]);
 
-        let model_variable = ErrorModel::additive(ErrorPoly::new(1.0, 0.0, 0.0, 0.0), 5.0);
-        let model_fixed = ErrorModel::additive_fixed(ErrorPoly::new(1.0, 0.0, 0.0, 0.0), 5.0);
+        let model_variable = AssayErrorModel::additive(ErrorPoly::new(1.0, 0.0, 0.0, 0.0), 5.0);
+        let model_fixed = AssayErrorModel::additive_fixed(ErrorPoly::new(1.0, 0.0, 0.0, 0.0), 5.0);
 
         let sigma_variable = model_variable.sigma(&prediction).unwrap();
         let sigma_fixed = model_fixed.sigma(&prediction).unwrap();
@@ -1436,11 +1522,11 @@ mod tests {
 
     #[test]
     fn test_hash_includes_fixed_state() {
-        let model1_variable = ErrorModel::additive(ErrorPoly::new(1.0, 0.0, 0.0, 0.0), 5.0);
-        let model1_fixed = ErrorModel::additive_fixed(ErrorPoly::new(1.0, 0.0, 0.0, 0.0), 5.0);
+        let model1_variable = AssayErrorModel::additive(ErrorPoly::new(1.0, 0.0, 0.0, 0.0), 5.0);
+        let model1_fixed = AssayErrorModel::additive_fixed(ErrorPoly::new(1.0, 0.0, 0.0, 0.0), 5.0);
 
-        let models1 = ErrorModels::new().add(0, model1_variable).unwrap();
-        let models2 = ErrorModels::new().add(0, model1_fixed).unwrap();
+        let models1 = AssayErrorModels::new().add(0, model1_variable).unwrap();
+        let models2 = AssayErrorModels::new().add(0, model1_fixed).unwrap();
 
         // Different fixed/variable states should produce different hashes
         assert_ne!(models1.hash(), models2.hash());
@@ -1448,10 +1534,11 @@ mod tests {
 
     #[test]
     fn test_error_models_into_iter_functionality() {
-        let additive_model = ErrorModel::additive(ErrorPoly::new(1.0, 0.0, 0.0, 0.0), 5.0);
-        let proportional_model = ErrorModel::proportional(ErrorPoly::new(1.0, 0.0, 0.0, 0.0), 2.0);
+        let additive_model = AssayErrorModel::additive(ErrorPoly::new(1.0, 0.0, 0.0, 0.0), 5.0);
+        let proportional_model =
+            AssayErrorModel::proportional(ErrorPoly::new(1.0, 0.0, 0.0, 0.0), 2.0);
 
-        let mut models = ErrorModels::new()
+        let mut models = AssayErrorModels::new()
             .add(0, additive_model)
             .unwrap()
             .add(1, proportional_model)
@@ -1508,7 +1595,7 @@ mod tests {
         assert_eq!(count, 2);
 
         // Test consuming iteration with into_iter()
-        let collected_models: Vec<(usize, ErrorModel)> = models.into_iter().collect();
+        let collected_models: Vec<(usize, AssayErrorModel)> = models.into_iter().collect();
         assert_eq!(collected_models.len(), 2);
 
         // Verify the collected models retain their state
diff --git a/src/data/mod.rs b/src/data/mod.rs
index f5e31586..813c13fd 100644
--- a/src/data/mod.rs
+++ b/src/data/mod.rs
@@ -10,6 +10,9 @@
 //! - **Covariates**: Time-varying subject characteristics
 //! - **Subjects**: Collections of events and covariates for a single individual
 //! - **Data**: Collections of subjects, representing a complete dataset
+//! - **Error Models**: Two types for different algorithm families:
+//!   - [`ErrorModel`]: Observation-based (assay error) for non-parametric algorithms
+//!   - [`ResidualErrorModel`]: Prediction-based (residual error) for parametric algorithms
 //!
 //! # Examples
 //!
@@ -31,8 +34,10 @@ pub mod covariate;
 pub mod error_model;
 pub mod event;
 pub mod parser;
+pub mod residual_error;
 pub mod structs;
 pub use covariate::*;
 pub use error_model::*;
 pub use event::*;
+pub use residual_error::*;
 pub use structs::{Data, Occasion, Subject};
diff --git a/src/data/parser/mod.rs b/src/data/parser/mod.rs
index 8af9b41e..613edc69 100644
--- a/src/data/parser/mod.rs
+++ b/src/data/parser/mod.rs
@@ -1,2 +1,5 @@
+pub mod normalized;
 pub mod pmetrics;
+
+pub use normalized::{build_data, NormalizedRow, NormalizedRowBuilder};
 pub use pmetrics::*;
diff --git a/src/data/parser/normalized.rs b/src/data/parser/normalized.rs
new file mode 100644
index 00000000..72ba1a16
--- /dev/null
+++ b/src/data/parser/normalized.rs
@@ -0,0 +1,858 @@
+//! Normalized row representation for flexible data parsing
+//!
+//! This module provides a format-agnostic intermediate representation that decouples
+//! column naming/mapping from event creation logic. Any data source (CSV with custom
+//! columns, Excel, DataFrames) can construct [`NormalizedRow`] instances, then use
+//! [`NormalizedRow::into_events()`] to get properly parsed pharmsol Events.
+//!
+//! # Design Philosophy
+//!
+//! The key insight is separating two concerns:
+//! 1. **Row Normalization** - Transform arbitrary input formats into a standard representation
+//! 2. **Event Creation** - Convert normalized rows into pharmsol Events (with ADDL expansion, etc.)
+//!
+//! This allows any consumer (GUI applications, scripts, other tools) to bring their own
+//! "column mapping" while reusing parsing logic.
+//!
+//! # Example
+//!
+//! ```rust
+//! use pharmsol::data::parser::NormalizedRow;
+//!
+//! // Create a dosing row with ADDL expansion
+//! let row = NormalizedRow::builder("subject_1", 0.0)
+//!     .evid(1)
+//!     .dose(100.0)
+//!     .input(1)
+//!     .addl(3)   // 3 additional doses
+//!     .ii(12.0)  // 12 hours apart
+//!     .build();
+//!
+//! let events = row.into_events().unwrap();
+//! assert_eq!(events.len(), 4); // Original + 3 additional doses
+//! ```
+//!
+
+use super::PmetricsError;
+use crate::data::*;
+use std::collections::HashMap;
+
+/// A format-agnostic representation of a single data row
+///
+/// This struct represents the canonical fields needed to create pharmsol Events.
+/// Consumers construct this from their source data (regardless of column names),
+/// then call [`into_events()`](NormalizedRow::into_events) to get properly parsed
+/// Events with full ADDL expansion, EVID handling, censoring, etc.
+///
+/// # Fields
+///
+/// All fields use Pmetrics conventions:
+/// - `input` and `outeq` are **1-indexed** (will be converted to 0-indexed internally)
+/// - `evid`: 0=observation, 1=dose, 4=reset/new occasion
+/// - `addl`: positive=forward in time, negative=backward in time
+///
+/// # Example
+///
+/// ```rust
+/// use pharmsol::data::parser::NormalizedRow;
+///
+/// // Observation row
+/// let obs = NormalizedRow::builder("pt1", 1.0)
+///     .evid(0)
+///     .out(25.5)
+///     .outeq(1)
+///     .build();
+///
+/// // Dosing row with negative ADDL (doses before time 0)
+/// let dose = NormalizedRow::builder("pt1", 0.0)
+///     .evid(1)
+///     .dose(100.0)
+///     .input(1)
+///     .addl(-10)  // 10 doses BEFORE time 0
+///     .ii(12.0)
+///     .build();
+///
+/// let events = dose.into_events().unwrap();
+/// // Events at times: -120, -108, -96, ..., -12, 0
+/// assert_eq!(events.len(), 11);
+/// ```
+#[derive(Debug, Clone, Default)]
+pub struct NormalizedRow {
+    /// Subject identifier (required)
+    pub id: String,
+    /// Event time (required)
+    pub time: f64,
+    /// Event type: 0=observation, 1=dose, 4=reset/new occasion
+    pub evid: i32,
+    /// Dose amount (for EVID=1)
+    pub dose: Option<f64>,
+    /// Infusion duration (if > 0, dose is infusion; otherwise bolus)
+    pub dur: Option<f64>,
+    /// Additional doses count (positive=forward, negative=backward in time)
+    pub addl: Option<i64>,
+    /// Interdose interval for ADDL
+    pub ii: Option<f64>,
+    /// Input compartment (1-indexed in Pmetrics convention)
+    pub input: Option<usize>,
+    /// Observed value (for EVID=0)
+    pub out: Option<f64>,
+    /// Output equation number (1-indexed)
+    pub outeq: Option<usize>,
+    /// Censoring indicator
+    pub cens: Option<Censor>,
+    /// Error polynomial coefficients
+    pub c0: Option<f64>,
+    /// Error polynomial coefficients
+    pub c1: Option<f64>,
+    /// Error polynomial coefficients
+    pub c2: Option<f64>,
+    /// Error polynomial coefficients
+    pub c3: Option<f64>,
+    /// Covariate values at this time point
+    pub covariates: HashMap<String, f64>,
+}
+
+impl NormalizedRow {
+    /// Create a new builder for constructing a NormalizedRow
+    ///
+    /// # Arguments
+    ///
+    /// * `id` - Subject identifier
+    /// * `time` - Event time
+    ///
+    /// # Example
+    ///
+    /// ```rust
+    /// use pharmsol::data::parser::NormalizedRow;
+    ///
+    /// let row = NormalizedRow::builder("patient_001", 0.0)
+    ///     .evid(1)
+    ///     .dose(100.0)
+    ///     .input(1)
+    ///     .build();
+    /// ```
+    pub fn builder(id: impl Into<String>, time: f64) -> NormalizedRowBuilder {
+        NormalizedRowBuilder::new(id, time)
+    }
+
+    /// Get error polynomial if all coefficients are present
+    fn get_errorpoly(&self) -> Option<ErrorPoly> {
+        match (self.c0, self.c1, self.c2, self.c3) {
+            (Some(c0), Some(c1), Some(c2), Some(c3)) => Some(ErrorPoly::new(c0, c1, c2, c3)),
+            _ => None,
+        }
+    }
+
+    /// Convert this normalized row into pharmsol Events
+    ///
+    /// This method contains all the complex parsing logic:
+    /// - EVID interpretation (0=observation, 1=dose, 4=reset)
+    /// - ADDL/II expansion (both positive and negative directions)
+    /// - Infusion vs bolus detection based on DUR
+    /// - Censoring and error polynomial handling
+    ///
+    /// # ADDL Expansion
+    ///
+    /// When `addl` and `ii` are both specified:
+    /// - **Positive ADDL**: Additional doses are placed *after* the base time
+    ///   - Example: time=0, addl=3, ii=12 → doses at 12, 24, 36, then 0
+    /// - **Negative ADDL**: Additional doses are placed *before* the base time
+    ///   - Example: time=0, addl=-3, ii=12 → doses at -36, -24, -12, then 0
+    ///
+    /// # Returns
+    ///
+    /// A vector of Events. A single row may produce multiple events when ADDL is used.
+    ///
+    /// # Errors
+    ///
+    /// Returns [`PmetricsError`] if required fields are missing for the given EVID:
+    /// - EVID=0: Requires `outeq`
+    /// - EVID=1: Requires `dose` and `input`; if `dur > 0`, it's an infusion
+    ///
+    /// # Example
+    ///
+    /// ```rust
+    /// use pharmsol::data::parser::NormalizedRow;
+    ///
+    /// let row = NormalizedRow::builder("pt1", 0.0)
+    ///     .evid(1)
+    ///     .dose(100.0)
+    ///     .input(1)
+    ///     .addl(2)
+    ///     .ii(24.0)
+    ///     .build();
+    ///
+    /// let events = row.into_events().unwrap();
+    /// assert_eq!(events.len(), 3); // doses at 24, 48, and 0
+    ///
+    /// let times: Vec<f64> = events.iter().map(|e| e.time()).collect();
+    /// assert_eq!(times, vec![24.0, 48.0, 0.0]);
+    /// ```
+    pub fn into_events(self) -> Result<Vec<Event>, PmetricsError> {
+        let mut events: Vec<Event> = Vec::new();
+
+        match self.evid {
+            0 => {
+                // Observation event
+                events.push(Event::Observation(Observation::new(
+                    self.time,
+                    self.out,
+                    self.outeq
+                        .ok_or_else(|| PmetricsError::MissingObservationOuteq {
+                            id: self.id.clone(),
+                            time: self.time,
+                        })?
+                        .saturating_sub(1), // Convert 1-indexed to 0-indexed
+                    self.get_errorpoly(),
+                    0, // occasion set later
+                    self.cens.unwrap_or(Censor::None),
+                )));
+            }
+            1 | 4 => {
+                // Dosing event (1) or reset with dose (4)
+                let input_0indexed = self
+                    .input
+                    .ok_or_else(|| PmetricsError::MissingBolusInput {
+                        id: self.id.clone(),
+                        time: self.time,
+                    })?
+                    .saturating_sub(1); // Convert 1-indexed to 0-indexed
+
+                let event = if self.dur.unwrap_or(0.0) > 0.0 {
+                    // Infusion
+                    Event::Infusion(Infusion::new(
+                        self.time,
+                        self.dose
+                            .ok_or_else(|| PmetricsError::MissingInfusionDose {
+                                id: self.id.clone(),
+                                time: self.time,
+                            })?,
+                        input_0indexed,
+                        self.dur.ok_or_else(|| PmetricsError::MissingInfusionDur {
+                            id: self.id.clone(),
+                            time: self.time,
+                        })?,
+                        0,
+                    ))
+                } else {
+                    // Bolus
+                    Event::Bolus(Bolus::new(
+                        self.time,
+                        self.dose.ok_or_else(|| PmetricsError::MissingBolusDose {
+                            id: self.id.clone(),
+                            time: self.time,
+                        })?,
+                        input_0indexed,
+                        0,
+                    ))
+                };
+
+                // Handle ADDL/II expansion
+                if let (Some(addl), Some(ii)) = (self.addl, self.ii) {
+                    if addl != 0 && ii > 0.0 {
+                        let mut ev = event.clone();
+                        let interval = ii.abs();
+                        let repetitions = addl.abs();
+                        let direction = addl.signum() as f64;
+
+                        for _ in 0..repetitions {
+                            ev.inc_time(direction * interval);
+                            events.push(ev.clone());
+                        }
+                    }
+                }
+
+                events.push(event);
+            }
+            _ => {
+                return Err(PmetricsError::UnknownEvid {
+                    evid: self.evid as isize,
+                    id: self.id.clone(),
+                    time: self.time,
+                });
+            }
+        }
+
+        Ok(events)
+    }
+
+    /// Get the covariate values for this row
+    ///
+    /// Returns a reference to the HashMap of covariate name → value pairs.
+    pub fn covariates(&self) -> &HashMap<String, f64> {
+        &self.covariates
+    }
+
+    /// Check if this row represents a new occasion (EVID=4)
+    pub fn is_occasion_reset(&self) -> bool {
+        self.evid == 4
+    }
+
+    /// Get the subject ID
+    pub fn id(&self) -> &str {
+        &self.id
+    }
+
+    /// Get the event time
+    pub fn time(&self) -> f64 {
+        self.time
+    }
+}
+
+/// Builder for constructing NormalizedRow with a fluent API
+///
+/// # Example
+///
+/// ```rust
+/// use pharmsol::data::parser::NormalizedRow;
+/// use pharmsol::data::Censor;
+///
+/// let row = NormalizedRow::builder("patient_001", 1.5)
+///     .evid(0)
+///     .out(25.5)
+///     .outeq(1)
+///     .cens(Censor::None)
+///     .covariate("weight", 70.0)
+///     .covariate("age", 45.0)
+///     .build();
+/// ```
+#[derive(Debug, Clone)]
+pub struct NormalizedRowBuilder {
+    row: NormalizedRow,
+}
+
+impl NormalizedRowBuilder {
+    /// Create a new builder with required fields
+    ///
+    /// # Arguments
+    ///
+    /// * `id` - Subject identifier
+    /// * `time` - Event time
+    pub fn new(id: impl Into<String>, time: f64) -> Self {
+        Self {
+            row: NormalizedRow {
+                id: id.into(),
+                time,
+                evid: 0, // Default to observation
+                ..Default::default()
+            },
+        }
+    }
+
+    /// Set the event type
+    ///
+    /// # Arguments
+    ///
+    /// * `evid` - Event ID: 0=observation, 1=dose, 4=reset/new occasion
+    pub fn evid(mut self, evid: i32) -> Self {
+        self.row.evid = evid;
+        self
+    }
+
+    /// Set the dose amount
+    ///
+    /// Required for EVID=1 (dosing events).
+    pub fn dose(mut self, dose: f64) -> Self {
+        self.row.dose = Some(dose);
+        self
+    }
+
+    /// Set the infusion duration
+    ///
+    /// If > 0, the dose is treated as an infusion rather than a bolus.
+    pub fn dur(mut self, dur: f64) -> Self {
+        self.row.dur = Some(dur);
+        self
+    }
+
+    /// Set the additional doses count
+    ///
+    /// # Arguments
+    ///
+    /// * `addl` - Number of additional doses
+    ///   - Positive: doses placed after the base time
+    ///   - Negative: doses placed before the base time
+    pub fn addl(mut self, addl: i64) -> Self {
+        self.row.addl = Some(addl);
+        self
+    }
+
+    /// Set the interdose interval
+    ///
+    /// Used with ADDL to specify time between additional doses.
+    pub fn ii(mut self, ii: f64) -> Self {
+        self.row.ii = Some(ii);
+        self
+    }
+
+    /// Set the input compartment (1-indexed)
+    ///
+    /// Required for EVID=1 (dosing events).
+    /// Will be converted to 0-indexed internally.
+    pub fn input(mut self, input: usize) -> Self {
+        self.row.input = Some(input);
+        self
+    }
+
+    /// Set the observed value
+    ///
+    /// Used for EVID=0 (observation events).
+    pub fn out(mut self, out: f64) -> Self {
+        self.row.out = Some(out);
+        self
+    }
+
+    /// Set the output equation (1-indexed)
+    ///
+    /// Required for EVID=0 (observation events).
+    /// Will be converted to 0-indexed internally.
+    pub fn outeq(mut self, outeq: usize) -> Self {
+        self.row.outeq = Some(outeq);
+        self
+    }
+
+    /// Set the censoring type
+    pub fn cens(mut self, cens: Censor) -> Self {
+        self.row.cens = Some(cens);
+        self
+    }
+
+    /// Set error polynomial coefficients
+    ///
+    /// The error polynomial models observation error as:
+    /// SD = c0 + c1*Y + c2*Y² + c3*Y³
+    pub fn error_poly(mut self, c0: f64, c1: f64, c2: f64, c3: f64) -> Self {
+        self.row.c0 = Some(c0);
+        self.row.c1 = Some(c1);
+        self.row.c2 = Some(c2);
+        self.row.c3 = Some(c3);
+        self
+    }
+
+    /// Add a covariate value
+    ///
+    /// Can be called multiple times to add multiple covariates.
+    ///
+    /// # Arguments
+    ///
+    /// * `name` - Covariate name
+    /// * `value` - Covariate value at this time point
+    pub fn covariate(mut self, name: impl Into<String>, value: f64) -> Self {
+        self.row.covariates.insert(name.into(), value);
+        self
+    }
+
+    /// Build the NormalizedRow
+    pub fn build(self) -> NormalizedRow {
+        self.row
+    }
+}
+
+/// Build a [Data] object from an iterator of [NormalizedRow]s
+///
+/// This function handles all the complex assembly logic:
+/// - Groups rows by subject ID
+/// - Splits into occasions at EVID=4 boundaries
+/// - Converts rows to events via [`NormalizedRow::into_events()`]
+/// - Builds covariates from row covariate data
+///
+/// # Example
+///
+/// ```rust
+/// use pharmsol::data::parser::{NormalizedRow, build_data};
+///
+/// let rows = vec![
+///     // Subject 1, Occasion 0
+///     NormalizedRow::builder("pt1", 0.0)
+///         .evid(1).dose(100.0).input(1).build(),
+///     NormalizedRow::builder("pt1", 1.0)
+///         .evid(0).out(50.0).outeq(1).build(),
+///     // Subject 1, Occasion 1 (EVID=4 starts new occasion)
+///     NormalizedRow::builder("pt1", 24.0)
+///         .evid(4).dose(100.0).input(1).build(),
+///     NormalizedRow::builder("pt1", 25.0)
+///         .evid(0).out(48.0).outeq(1).build(),
+///     // Subject 2
+///     NormalizedRow::builder("pt2", 0.0)
+///         .evid(1).dose(50.0).input(1).build(),
+/// ];
+///
+/// let data = build_data(rows).unwrap();
+/// assert_eq!(data.subjects().len(), 2);
+/// ```
+pub fn build_data(rows: impl IntoIterator<Item = NormalizedRow>) -> Result<Data, PmetricsError> {
+    // Group rows by subject ID
+    let mut rows_map: std::collections::HashMap<String, Vec<NormalizedRow>> =
+        std::collections::HashMap::new();
+    for row in rows {
+        rows_map.entry(row.id.clone()).or_default().push(row);
+    }
+
+    let mut subjects: Vec<Subject> = Vec::new();
+
+    for (id, rows) in rows_map {
+        // Split rows into occasion blocks at EVID=4 boundaries
+        let split_indices: Vec<usize> = rows
+            .iter()
+            .enumerate()
+            .filter_map(|(i, row)| if row.evid == 4 { Some(i) } else { None })
+            .collect();
+
+        let mut block_rows_vec: Vec<&[NormalizedRow]> = Vec::new();
+        let mut start = 0;
+        for &split_index in &split_indices {
+            if start < split_index {
+                block_rows_vec.push(&rows[start..split_index]);
+            }
+            start = split_index;
+        }
+        if start < rows.len() {
+            block_rows_vec.push(&rows[start..]);
+        }
+
+        // Build occasions
+        let mut occasions: Vec<Occasion> = Vec::new();
+        for (block_index, block) in block_rows_vec.iter().enumerate() {
+            let mut events: Vec<Event> = Vec::new();
+
+            // Collect covariate observations for this block
+            let mut observed_covariates: std::collections::HashMap<
+                String,
+                Vec<(f64, Option<f64>)>,
+            > = std::collections::HashMap::new();
+
+            for row in *block {
+                // Parse events
+                let row_events = row.clone().into_events()?;
+                events.extend(row_events);
+
+                // Collect covariates
+                for (name, value) in &row.covariates {
+                    observed_covariates
+                        .entry(name.clone())
+                        .or_default()
+                        .push((row.time, Some(*value)));
+                }
+            }
+
+            // Set occasion index on all events
+            events.iter_mut().for_each(|e| e.set_occasion(block_index));
+
+            // Build covariates
+            let covariates = Covariates::from_pmetrics_observations(&observed_covariates);
+
+            // Create occasion
+            let mut occasion = Occasion::new(block_index);
+            occasion.events = events;
+            occasion.covariates = covariates;
+            occasion.sort();
+            occasions.push(occasion);
+        }
+
+        subjects.push(Subject::new(id, occasions));
+    }
+
+    // Sort subjects alphabetically by ID for consistent ordering
+    subjects.sort_by(|a, b| a.id().cmp(b.id()));
+
+    Ok(Data::new(subjects))
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_observation_row() {
+        let row = NormalizedRow::builder("pt1", 1.0)
+            .evid(0)
+            .out(25.5)
+            .outeq(1)
+            .build();
+
+        let events = row.into_events().unwrap();
+        assert_eq!(events.len(), 1);
+
+        match &events[0] {
+            Event::Observation(obs) => {
+                assert_eq!(obs.time(), 1.0);
+                assert_eq!(obs.value(), Some(25.5));
+                assert_eq!(obs.outeq(), 0); // Converted to 0-indexed
+            }
+            _ => panic!("Expected observation event"),
+        }
+    }
+
+    #[test]
+    fn test_bolus_row() {
+        let row = NormalizedRow::builder("pt1", 0.0)
+            .evid(1)
+            .dose(100.0)
+            .input(1)
+            .build();
+
+        let events = row.into_events().unwrap();
+        assert_eq!(events.len(), 1);
+
+        match &events[0] {
+            Event::Bolus(bolus) => {
+                assert_eq!(bolus.time(), 0.0);
+                assert_eq!(bolus.amount(), 100.0);
+                assert_eq!(bolus.input(), 0); // Converted to 0-indexed
+            }
+            _ => panic!("Expected bolus event"),
+        }
+    }
+
+    #[test]
+    fn test_infusion_row() {
+        let row = NormalizedRow::builder("pt1", 0.0)
+            .evid(1)
+            .dose(100.0)
+            .dur(2.0)
+            .input(1)
+            .build();
+
+        let events = row.into_events().unwrap();
+        assert_eq!(events.len(), 1);
+
+        match &events[0] {
+            Event::Infusion(inf) => {
+                assert_eq!(inf.time(), 0.0);
+                assert_eq!(inf.amount(), 100.0);
+                assert_eq!(inf.duration(), 2.0);
+                assert_eq!(inf.input(), 0);
+            }
+            _ => panic!("Expected infusion event"),
+        }
+    }
+
+    #[test]
+    fn test_positive_addl() {
+        let row = NormalizedRow::builder("pt1", 0.0)
+            .evid(1)
+            .dose(100.0)
+            .input(1)
+            .addl(3)
+            .ii(12.0)
+            .build();
+
+        let events = row.into_events().unwrap();
+        assert_eq!(events.len(), 4); // Original + 3 additional
+
+        let times: Vec<f64> = events.iter().map(|e| e.time()).collect();
+        // Additional doses come first, then original
+        assert_eq!(times, vec![12.0, 24.0, 36.0, 0.0]);
+    }
+
+    #[test]
+    fn test_negative_addl() {
+        let row = NormalizedRow::builder("pt1", 0.0)
+            .evid(1)
+            .dose(100.0)
+            .input(1)
+            .addl(-3)
+            .ii(12.0)
+            .build();
+
+        let events = row.into_events().unwrap();
+        assert_eq!(events.len(), 4); // Original + 3 additional
+
+        let times: Vec<f64> = events.iter().map(|e| e.time()).collect();
+        // Negative ADDL: doses go backward in time
+        assert_eq!(times, vec![-12.0, -24.0, -36.0, 0.0]);
+    }
+
+    #[test]
+    fn test_large_negative_addl() {
+        // Match the pharmsol pmetrics test case
+        let row = NormalizedRow::builder("pt1", 0.0)
+            .evid(1)
+            .dose(100.0)
+            .input(1)
+            .addl(-10)
+            .ii(12.0)
+            .build();
+
+        let events = row.into_events().unwrap();
+        assert_eq!(events.len(), 11); // Original + 10 additional
+
+        let times: Vec<f64> = events.iter().map(|e| e.time()).collect();
+        assert_eq!(
+            times,
+            vec![-12.0, -24.0, -36.0, -48.0, -60.0, -72.0, -84.0, -96.0, -108.0, -120.0, 0.0]
+        );
+    }
+
+    #[test]
+    fn test_infusion_with_addl() {
+        let row = NormalizedRow::builder("pt1", 0.0)
+            .evid(1)
+            .dose(100.0)
+            .dur(1.0)
+            .input(1)
+            .addl(2)
+            .ii(24.0)
+            .build();
+
+        let events = row.into_events().unwrap();
+        assert_eq!(events.len(), 3);
+
+        // All events should be infusions
+        for event in &events {
+            match event {
+                Event::Infusion(inf) => {
+                    assert_eq!(inf.amount(), 100.0);
+                    assert_eq!(inf.duration(), 1.0);
+                }
+                _ => panic!("Expected infusion event"),
+            }
+        }
+    }
+
+    #[test]
+    fn test_covariates() {
+        let row = NormalizedRow::builder("pt1", 0.0)
+            .evid(0)
+            .out(25.0)
+            .outeq(1)
+            .covariate("weight", 70.0)
+            .covariate("age", 45.0)
+            .build();
+
+        assert_eq!(row.covariates().len(), 2);
+        assert_eq!(row.covariates().get("weight"), Some(&70.0));
+        assert_eq!(row.covariates().get("age"), Some(&45.0));
+    }
+
+    #[test]
+    fn test_error_poly() {
+        let row = NormalizedRow::builder("pt1", 1.0)
+            .evid(0)
+            .out(25.0)
+            .outeq(1)
+            .error_poly(0.1, 0.2, 0.0, 0.0)
+            .build();
+
+        let events = row.into_events().unwrap();
+        match &events[0] {
+            Event::Observation(obs) => {
+                let ep = obs.errorpoly().unwrap();
+                assert_eq!(ep.coefficients(), (0.1, 0.2, 0.0, 0.0));
+            }
+            _ => panic!("Expected observation"),
+        }
+    }
+
+    #[test]
+    fn test_censoring() {
+        let row = NormalizedRow::builder("pt1", 1.0)
+            .evid(0)
+            .out(0.5)
+            .outeq(1)
+            .cens(Censor::BLOQ)
+            .build();
+
+        let events = row.into_events().unwrap();
+        match &events[0] {
+            Event::Observation(obs) => {
+                assert!(obs.censored());
+                assert_eq!(obs.censoring(), Censor::BLOQ);
+            }
+            _ => panic!("Expected observation"),
+        }
+    }
+
+    #[test]
+    fn test_missing_outeq_error() {
+        let row = NormalizedRow::builder("pt1", 1.0)
+            .evid(0)
+            .out(25.0)
+            // Missing outeq
+            .build();
+
+        let result = row.into_events();
+        assert!(result.is_err());
+        assert!(matches!(
+            result.unwrap_err(),
+            PmetricsError::MissingObservationOuteq { .. }
+        ));
+    }
+
+    #[test]
+    fn test_missing_dose_error() {
+        let row = NormalizedRow::builder("pt1", 0.0)
+            .evid(1)
+            .input(1)
+            // Missing dose
+            .build();
+
+        let result = row.into_events();
+        assert!(result.is_err());
+    }
+
+    #[test]
+    fn test_missing_input_error() {
+        let row = NormalizedRow::builder("pt1", 0.0)
+            .evid(1)
+            .dose(100.0)
+            // Missing input
+            .build();
+
+        let result = row.into_events();
+        assert!(result.is_err());
+    }
+
+    #[test]
+    fn test_unknown_evid_error() {
+        let row = NormalizedRow::builder("pt1", 0.0).evid(99).build();
+
+        let result = row.into_events();
+        assert!(result.is_err());
+        assert!(matches!(
+            result.unwrap_err(),
+            PmetricsError::UnknownEvid { evid: 99, .. }
+        ));
+    }
+
+    #[test]
+    fn test_addl_zero_has_no_effect() {
+        let row = NormalizedRow::builder("pt1", 0.0)
+            .evid(1)
+            .dose(100.0)
+            .input(1)
+            .addl(0)
+            .ii(12.0)
+            .build();
+
+        let events = row.into_events().unwrap();
+        assert_eq!(events.len(), 1); // Only original dose
+    }
+
+    #[test]
+    fn test_addl_without_ii_has_no_effect() {
+        let row = NormalizedRow::builder("pt1", 0.0)
+            .evid(1)
+            .dose(100.0)
+            .input(1)
+            .addl(5)
+            // Missing ii
+            .build();
+
+        let events = row.into_events().unwrap();
+        assert_eq!(events.len(), 1); // Only original dose
+    }
+
+    #[test]
+    fn test_evid_4_reset() {
+        let row = NormalizedRow::builder("pt1", 24.0)
+            .evid(4)
+            .dose(100.0)
+            .input(1)
+            .build();
+
+        assert!(row.is_occasion_reset());
+        let events = row.into_events().unwrap();
+        assert_eq!(events.len(), 1);
+    }
+}
diff --git a/src/data/parser/pmetrics.rs b/src/data/parser/pmetrics.rs
index 69857aa3..8886561e 100644
--- a/src/data/parser/pmetrics.rs
+++ b/src/data/parser/pmetrics.rs
@@ -76,7 +76,7 @@ pub enum PmetricsError {
 /// - Parse covariates and create appropriate interpolations
 /// - Handle additional doses via ADDL and II fields
 ///
-/// For specific column definitions, see the [Row] struct.
+/// For specific column definitions, see the `Row` struct.
 #[allow(dead_code)]
 pub fn read_pmetrics(path: impl Into<String>) -> Result<Data, PmetricsError> {
     let path = path.into();
@@ -95,95 +95,15 @@ pub fn read_pmetrics(path: impl Into<String>) -> Result<Data, PmetricsError> {
         .collect::<Vec<_>>();
     reader.set_headers(csv::StringRecord::from(headers));
 
-    // This is the object we are building, which can be converted to [Data]
-    // Read the datafile into a hashmap of rows by ID
-    let mut rows_map: HashMap<String, Vec<Row>> = HashMap::new();
-    let mut subjects: Vec<Subject> = Vec::new();
+    // Parse CSV rows and convert to NormalizedRows
+    let mut normalized_rows: Vec<super::normalized::NormalizedRow> = Vec::new();
     for row_result in reader.deserialize() {
         let row: Row = row_result.map_err(|e| PmetricsError::CSVError(e.to_string()))?;
-
-        rows_map.entry(row.id.clone()).or_default().push(row);
+        normalized_rows.push(row.to_normalized());
     }
 
-    // For each ID, we ultimately create a [Subject] object
-    for (id, rows) in rows_map {
-        // Split rows into vectors of rows, creating the occasions
-        let split_indices: Vec<usize> = rows
-            .iter()
-            .enumerate()
-            .filter_map(|(i, row)| if row.evid == 4 { Some(i) } else { None })
-            .collect();
-
-        let mut block_rows_vec = Vec::new();
-        let mut start = 0;
-        for &split_index in &split_indices {
-            let end = split_index;
-            if start < rows.len() {
-                block_rows_vec.push(&rows[start..end]);
-            }
-            start = end;
-        }
-
-        if start < rows.len() {
-            block_rows_vec.push(&rows[start..]);
-        }
-
-        let block_rows: Vec<Vec<Row>> = block_rows_vec.iter().map(|block| block.to_vec()).collect();
-        let mut occasions: Vec<Occasion> = Vec::new();
-        for (block_index, rows) in block_rows.clone().iter().enumerate() {
-            // Collector for all events
-            let mut events: Vec<Event> = Vec::new();
-
-            // Parse events
-            for row in rows.clone() {
-                match row.parse_events() {
-                    Ok(ev) => events.extend(ev),
-                    Err(e) => {
-                        // dbg!(&row);
-                        // dbg!(&e);
-                        return Err(e);
-                    }
-                }
-            }
-
-            // Parse covariates - collect raw observations
-            let mut cloned_rows = rows.clone();
-            cloned_rows.retain(|row| !row.covs.is_empty());
-
-            // Collect all covariates by name
-            let mut observed_covariates: HashMap<String, Vec<(f64, Option<f64>)>> = HashMap::new();
-            for row in &cloned_rows {
-                for (key, value) in &row.covs {
-                    if let Some(val) = value {
-                        observed_covariates
-                            .entry(key.clone())
-                            .or_default()
-                            .push((row.time, Some(*val)));
-                    }
-                }
-            }
-
-            // Parse the raw covariate observations and build covariates
-            let covariates = Covariates::from_pmetrics_observations(&observed_covariates);
-
-            // Create the occasion
-            let mut occasion = Occasion::new(block_index);
-            events.iter_mut().for_each(|e| e.set_occasion(block_index));
-            occasion.events = events;
-            occasion.covariates = covariates;
-            occasion.sort();
-            occasions.push(occasion);
-        }
-
-        let subject = Subject::new(id, occasions);
-        subjects.push(subject);
-    }
-
-    // Sort subjects alphabetically by ID to get consistent ordering
-    subjects.sort_by(|a, b| a.id().cmp(b.id()));
-    let data = Data::new(subjects);
-
-    Ok(data)
+    // Use the shared build_data logic
+    super::normalized::build_data(normalized_rows)
 }
 
 /// A [Row] represents a row in the Pmetrics data format
@@ -238,96 +158,34 @@ struct Row {
 }
 
 impl Row {
-    /// Get the error polynomial coefficients
-    fn get_errorpoly(&self) -> Option<ErrorPoly> {
-        match (self.c0, self.c1, self.c2, self.c3) {
-            (Some(c0), Some(c1), Some(c2), Some(c3)) => Some(ErrorPoly::new(c0, c1, c2, c3)),
-            _ => None,
+    /// Convert this Row to a NormalizedRow for parsing
+    fn to_normalized(&self) -> super::normalized::NormalizedRow {
+        super::normalized::NormalizedRow {
+            id: self.id.clone(),
+            time: self.time,
+            evid: self.evid as i32,
+            dose: self.dose,
+            dur: self.dur,
+            addl: self.addl.map(|a| a as i64),
+            ii: self.ii,
+            input: self.input,
+            // Treat -99 as missing value (Pmetrics convention)
+            out: self
+                .out
+                .and_then(|v| if v == -99.0 { None } else { Some(v) }),
+            outeq: self.outeq,
+            cens: self.cens,
+            c0: self.c0,
+            c1: self.c1,
+            c2: self.c2,
+            c3: self.c3,
+            covariates: self
+                .covs
+                .iter()
+                .filter_map(|(k, v)| v.map(|val| (k.clone(), val)))
+                .collect(),
         }
     }
-    fn parse_events(self) -> Result<Vec<Event>, PmetricsError> {
-        let mut events: Vec<Event> = Vec::new();
-
-        match self.evid {
-            0 => events.push(Event::Observation(Observation::new(
-                self.time,
-                if self.out == Some(-99.0) {
-                    None
-                } else {
-                    self.out
-                },
-                self.outeq
-                    .ok_or_else(|| PmetricsError::MissingObservationOuteq {
-                        id: self.id.clone(),
-                        time: self.time,
-                    })?
-                    - 1,
-                self.get_errorpoly(),
-                0,
-                self.cens.unwrap_or(Censor::None),
-            ))),
-            1 | 4 => {
-                let event = if self.dur.unwrap_or(0.0) > 0.0 {
-                    Event::Infusion(Infusion::new(
-                        self.time,
-                        self.dose
-                            .ok_or_else(|| PmetricsError::MissingInfusionDose {
-                                id: self.id.clone(),
-                                time: self.time,
-                            })?,
-                        self.input
-                            .ok_or_else(|| PmetricsError::MissingInfusionInput {
-                                id: self.id.clone(),
-                                time: self.time,
-                            })?
-                            - 1,
-                        self.dur.ok_or_else(|| PmetricsError::MissingInfusionDur {
-                            id: self.id.clone(),
-                            time: self.time,
-                        })?,
-                        0,
-                    ))
-                } else {
-                    Event::Bolus(Bolus::new(
-                        self.time,
-                        self.dose.ok_or_else(|| PmetricsError::MissingBolusDose {
-                            id: self.id.clone(),
-                            time: self.time,
-                        })?,
-                        self.input.ok_or(PmetricsError::MissingBolusInput {
-                            id: self.id,
-                            time: self.time,
-                        })? - 1,
-                        0,
-                    ))
-                };
-                if self.addl.is_some()
-                    && self.ii.is_some()
-                    && self.addl.unwrap_or(0) != 0
-                    && self.ii.unwrap_or(0.0) > 0.0
-                {
-                    let mut ev = event.clone();
-                    let interval = &self.ii.unwrap().abs();
-                    let repetitions = &self.addl.unwrap().abs();
-                    let direction = &self.addl.unwrap().signum();
-
-                    for _ in 0..*repetitions {
-                        ev.inc_time((*direction as f64) * interval);
-                        events.push(ev.clone());
-                    }
-                }
-                events.push(event);
-            }
-            _ => {
-                return Err(PmetricsError::UnknownEvid {
-                    evid: self.evid,
-                    id: self.id.clone(),
-                    time: self.time,
-                });
-            }
-        };
-        Ok(events)
-    }
 }
 
 /// Deserialize Option<T> from a string
diff --git a/src/data/residual_error.rs b/src/data/residual_error.rs
new file mode 100644
index 00000000..51dd9763
--- /dev/null
+++ b/src/data/residual_error.rs
@@ -0,0 +1,519 @@
+//! Residual error models for parametric algorithms (SAEM, FOCE, etc.)
+//!
+//! This module provides error model implementations that use the **prediction**
+//! (model output) rather than the **observation** for computing residual error.
+//!
+//! # Conceptual Difference from [`crate::ErrorModel`]
+//!
+//! - [`crate::ErrorModel`] (in `error_model.rs`): Represents **measurement/assay noise**.
+//!   Sigma is computed from the **observation** using polynomial characterization.
+//!   Used by non-parametric algorithms (NPAG, NPOD, etc.).
+//!
+//! - [`ResidualErrorModel`] (this module): Represents **residual unexplained variability**
+//!   in population models. Sigma is computed from the **prediction**.
+//!   Used by parametric algorithms (SAEM, FOCE, etc.).
+//!
+//! # R saemix Correspondence
+//!
+//! The error model in saemix (func_aux.R):
+//! ```R
+//! error.typ <- function(f, ab) {
+//!     g <- cutoff(sqrt(ab[1]^2 + ab[2]^2 * f^2))
+//!     return(g)
+//! }
+//! ```
+//!
+//! | saemix parameter | This implementation |
+//! |------------------|---------------------|
+//! | `ab[1]` (a)      | `Constant::a` or `Combined::a` |
+//! | `ab[2]` (b)      | `Proportional::b` or `Combined::b` |
+//!
+//! # Error Model Types
+//!
+//! - **Constant**: σ = a (independent of prediction)
+//! - **Proportional**: σ = b * |f| (scales with prediction)
+//! - **Combined**: σ = sqrt(a² + b²*f²) (most flexible, default in saemix)
+//! - **Exponential**: σ for log-transformed data
+
+use serde::{Deserialize, Serialize};
+
+/// Residual error model for parametric estimation algorithms.
+///
+/// Unlike [`crate::ErrorModel`] which uses observations, this uses
+/// the model **prediction** to compute the standard deviation.
+///
+/// # Usage in SAEM
+///
+/// The error model affects:
+/// 1. **Likelihood computation** in E-step: L(y|f) = N(y; f, σ²)
+/// 2. **Residual weighting** in M-step: weighted_res² = (y-f)²/σ²
+///
+/// # Examples
+///
+/// ```rust
+/// use pharmsol::ResidualErrorModel;
+///
+/// // Constant (additive) error: σ = 0.5
+/// let constant = ResidualErrorModel::Constant { a: 0.5 };
+/// assert!((constant.sigma(100.0) - 0.5).abs() < 1e-10);
+///
+/// // Proportional error: σ = 0.1 * |f|
+/// let proportional = ResidualErrorModel::Proportional { b: 0.1 };
+/// assert!((proportional.sigma(100.0) - 10.0).abs() < 1e-10);
+///
+/// // Combined error: σ = sqrt(0.5² + 0.1² * f²)
+/// let combined = ResidualErrorModel::Combined { a: 0.5, b: 0.1 };
+/// // For f=100: σ = sqrt(0.25 + 100) = sqrt(100.25) ≈ 10.01
+/// ```
+#[derive(Debug, Clone, Copy, Serialize, Deserialize, PartialEq)]
+pub enum ResidualErrorModel {
+    /// Constant (additive) error model
+    ///
+    /// σ = a
+    ///
+    /// Error is independent of the predicted value.
+    /// Appropriate when measurement error is constant regardless of concentration.
+    Constant {
+        /// Additive error standard deviation
+        a: f64,
+    },
+
+    /// Proportional error model
+    ///
+    /// σ = b * |f|
+    ///
+    /// Error scales linearly with the prediction.
+    /// Appropriate when measurement error is a constant percentage of the value.
+    ///
+    /// Note: Uses |f| to handle negative predictions gracefully.
+    Proportional {
+        /// Proportional coefficient (e.g., 0.1 = 10% CV)
+        b: f64,
+    },
+
+    /// Combined (additive + proportional) error model
+    ///
+    /// σ = sqrt(a² + b² * f²)
+    ///
+    /// This is the standard saemix error model from func_aux.R:
+    /// ```R
+    /// g <- cutoff(sqrt(ab[1]^2 + ab[2]^2 * f^2))
+    /// ```
+    ///
+    /// The combined model:
+    /// - Dominates at low concentrations (a term)
+    /// - Scales proportionally at high concentrations (b term)
+    Combined {
+        /// Additive component (a)
+        a: f64,
+        /// Proportional component (b)
+        b: f64,
+    },
+
+    /// Exponential error model (for log-transformed data)
+    ///
+    /// σ = σ_exp (constant on log scale)
+    ///
+    /// When data is analyzed on the log scale:
+    /// ```text
+    /// log(Y) = log(f) + ε, where ε ~ N(0, σ²)
+    /// ```
+    ///
+    /// This corresponds to multiplicative error on the original scale.
+    Exponential {
+        /// Error standard deviation on log scale
+        sigma: f64,
+    },
+}
+
+impl Default for ResidualErrorModel {
+    fn default() -> Self {
+        // Default to constant error with σ = 1.0
+        ResidualErrorModel::Constant { a: 1.0 }
+    }
+}
+
+impl ResidualErrorModel {
+    /// Create a constant (additive) error model
+    ///
+    /// # Arguments
+    /// * `a` - Standard deviation (must be positive)
+    pub fn constant(a: f64) -> Self {
+        ResidualErrorModel::Constant { a }
+    }
+
+    /// Create a proportional error model
+    ///
+    /// # Arguments
+    /// * `b` - Proportional coefficient (e.g., 0.1 for 10% CV)
+    pub fn proportional(b: f64) -> Self {
+        ResidualErrorModel::Proportional { b }
+    }
+
+    /// Create a combined (additive + proportional) error model
+    ///
+    /// # Arguments
+    /// * `a` - Additive component
+    /// * `b` - Proportional component
+    pub fn combined(a: f64, b: f64) -> Self {
+        ResidualErrorModel::Combined { a, b }
+    }
+
+    /// Create an exponential error model
+    ///
+    /// # Arguments
+    /// * `sigma` - Standard deviation on log scale
+    pub fn exponential(sigma: f64) -> Self {
+        ResidualErrorModel::Exponential { sigma }
+    }
+
+    /// Compute sigma (standard deviation) for a given prediction
+    ///
+    /// # Arguments
+    /// * `prediction` - The model prediction (f)
+    ///
+    /// # Returns
+    /// The standard deviation σ at this prediction value.
+    /// Returns a cutoff minimum to avoid numerical issues with very small σ.
+    pub fn sigma(&self, prediction: f64) -> f64 {
+        let raw_sigma = match self {
+            ResidualErrorModel::Constant { a } => *a,
+            ResidualErrorModel::Proportional { b } => b * prediction.abs(),
+            ResidualErrorModel::Combined { a, b } => {
+                (a.powi(2) + b.powi(2) * prediction.powi(2)).sqrt()
+            }
+            ResidualErrorModel::Exponential { sigma } => *sigma,
+        };
+
+        // Apply cutoff to prevent division by zero in likelihood
+        // R saemix uses cutoff function with default .Machine$double.eps
+        raw_sigma.max(f64::EPSILON.sqrt())
+    }
+
+    /// Compute variance for a given prediction
+    ///
+    /// # Arguments
+    /// * `prediction` - The model prediction (f)
+    ///
+    /// # Returns
+    /// The variance σ² at this prediction value.
+    pub fn variance(&self, prediction: f64) -> f64 {
+        let sigma = self.sigma(prediction);
+        sigma.powi(2)
+    }
+
+    /// Compute the weighted residual for M-step sigma updates
+    ///
+    /// For the M-step in SAEM, we compute the normalized residual:
+    /// - For constant/additive: (y - f)² (unweighted)
+    /// - For proportional: (y - f)² / f² (weighted by prediction)
+    /// - For combined: (y - f)² / (a² + b²*f²) (using current sigma params)
+    ///
+    /// This matches R saemix's approach in main_mstep.R where for proportional
+    /// error: `resk <- sum((yobs - fk)**2 / cutoff(fk**2, .Machine$double.eps))`
+    ///
+    /// # Arguments
+    /// * `observation` - The observed value (y)
+    /// * `prediction` - The model prediction (f)
+    ///
+    /// # Returns
+    /// The weighted squared residual for sigma estimation.
+    pub fn weighted_squared_residual(&self, observation: f64, prediction: f64) -> f64 {
+        let residual = observation - prediction;
+        let residual_sq = residual * residual;
+
+        match self {
+            ResidualErrorModel::Constant { .. } => {
+                // Constant error: unweighted residuals
+                // new_sigma² = Σ(y - f)² / n
+                residual_sq
+            }
+            ResidualErrorModel::Proportional { .. } => {
+                // Proportional error: weight by 1/f²
+                // new_sigma² = Σ(y - f)²/f² / n = b² (the proportional coefficient)
+                // This matches R saemix: resk <- sum((yobs - fk)**2 / cutoff(fk**2, ...))
+                let pred_sq = prediction.powi(2).max(f64::EPSILON);
+                residual_sq / pred_sq
+            }
+            ResidualErrorModel::Combined { a, b } => {
+                // Combined error: weight by current variance estimate
+                // This is more complex - use current sigma² = a² + b²*f²
+                let variance = (a.powi(2) + b.powi(2) * prediction.powi(2)).max(f64::EPSILON);
+                residual_sq / variance
+            }
+            ResidualErrorModel::Exponential { .. } => {
+                // Exponential: residuals on log scale
+                // This should be computed differently for log-transformed data
+                residual_sq
+            }
+        }
+    }
+
+    /// Compute log-likelihood contribution for a single observation
+    ///
+    /// Assuming normal distribution:
+    /// ```text
+    /// log L(y|f,σ) = -0.5 * [log(2π) + log(σ²) + (y-f)²/σ²]
+    /// ```
+    ///
+    /// # Arguments
+    /// * `observation` - The observed value (y)
+    /// * `prediction` - The model prediction (f)
+    ///
+    /// # Returns
+    /// The log-likelihood contribution.
+    pub fn log_likelihood(&self, observation: f64, prediction: f64) -> f64 {
+        let sigma = self.sigma(prediction);
+        let residual = observation - prediction;
+        let normalized_residual = residual / sigma;
+
+        -0.5 * (std::f64::consts::TAU.ln() + 2.0 * sigma.ln() + normalized_residual.powi(2))
+    }
+
+    /// Update the error model parameters based on M-step sufficient statistics
+    ///
+    /// In SAEM, the residual error is estimated in the M-step. This method
+    /// updates the appropriate parameter based on the new estimate.
+    ///
+    /// # Arguments
+    /// * `new_sigma` - The new sigma estimate from M-step
+    ///
+    /// # Returns
+    /// A new error model with updated parameters.
+    pub fn with_updated_sigma(self, new_sigma: f64) -> Self {
+        match self {
+            ResidualErrorModel::Constant { .. } => ResidualErrorModel::Constant { a: new_sigma },
+            ResidualErrorModel::Proportional { .. } => {
+                ResidualErrorModel::Proportional { b: new_sigma }
+            }
+            ResidualErrorModel::Combined { a: _, b } => {
+                // For combined model, we update the additive component
+                // and keep the proportional component fixed
+                // This is a simplification - full estimation would estimate both
+                ResidualErrorModel::Combined { a: new_sigma, b }
+            }
+            ResidualErrorModel::Exponential { .. } => {
+                ResidualErrorModel::Exponential { sigma: new_sigma }
+            }
+        }
+    }
+
+    /// Get the primary sigma parameter value
+    ///
+    /// For Constant: returns a
+    /// For Proportional: returns b
+    /// For Combined: returns a (additive component)
+    /// For Exponential: returns sigma
+    pub fn primary_parameter(&self) -> f64 {
+        match self {
+            ResidualErrorModel::Constant { a } => *a,
+            ResidualErrorModel::Proportional { b } => *b,
+            ResidualErrorModel::Combined { a, .. } => *a,
+            ResidualErrorModel::Exponential { sigma } => *sigma,
+        }
+    }
+
+    /// Check if this is a proportional error model
+    pub fn is_proportional(&self) -> bool {
+        matches!(self, ResidualErrorModel::Proportional { .. })
+    }
+
+    /// Check if this is a constant (additive) error model
+    pub fn is_constant(&self) -> bool {
+        matches!(self, ResidualErrorModel::Constant { .. })
+    }
+
+    /// Check if this is a combined error model
+    pub fn is_combined(&self) -> bool {
+        matches!(self, ResidualErrorModel::Combined { .. })
+    }
+
+    /// Check if this is an exponential error model
+    pub fn is_exponential(&self) -> bool {
+        matches!(self, ResidualErrorModel::Exponential { .. })
+    }
+}
+
+/// Collection of residual error models for multiple output equations
+///
+/// This mirrors [`crate::ErrorModels`] but for parametric algorithms.
+#[derive(Debug, Clone, Serialize, Deserialize, Default)]
+pub struct ResidualErrorModels {
+    models: Vec<ResidualErrorModel>,
+}
+
+impl ResidualErrorModels {
+    /// Create an empty collection
+    pub fn new() -> Self {
+        Self { models: vec![] }
+    }
+
+    /// Add an error model for a specific output equation
+    pub fn add(mut self, outeq: usize, model: ResidualErrorModel) -> Self {
+        if outeq >= self.models.len() {
+            self.models.resize(outeq + 1, ResidualErrorModel::default());
+        }
+        self.models[outeq] = model;
+        self
+    }
+
+    /// Get the error model for a specific output equation
+    pub fn get(&self, outeq: usize) -> Option<&ResidualErrorModel> {
+        self.models.get(outeq)
+    }
+
+    /// Get a mutable reference to the error model for a specific output equation
+    pub fn get_mut(&mut self, outeq: usize) -> Option<&mut ResidualErrorModel> {
+        self.models.get_mut(outeq)
+    }
+
+    /// Compute sigma for a specific output equation and prediction
+    pub fn sigma(&self, outeq: usize, prediction: f64) -> Option<f64> {
+        self.models.get(outeq).map(|m| m.sigma(prediction))
+    }
+
+    /// Number of error models
+    pub fn len(&self) -> usize {
+        self.models.len()
+    }
+
+    /// Check if collection is empty
+    pub fn is_empty(&self) -> bool {
+        self.models.is_empty()
+    }
+
+    /// Iterate over (outeq, model) pairs
+    pub fn iter(&self) -> impl Iterator<Item = (usize, &ResidualErrorModel)> {
+        self.models.iter().enumerate()
+    }
+
+    /// Compute log-likelihood for a single observation given its prediction
+    ///
+    /// # Arguments
+    /// * `outeq` - Output equation index
+    /// * `observation` - The observed value (y)
+    /// * `prediction` - The model prediction (f)
+    ///
+    /// # Returns
+    /// The log-likelihood contribution, or None if outeq is invalid.
+    pub fn log_likelihood(&self, outeq: usize, observation: f64, prediction: f64) -> Option<f64> {
+        self.models
+            .get(outeq)
+            .map(|m| m.log_likelihood(observation, prediction))
+    }
+
+    /// Compute total log-likelihood for multiple observation-prediction pairs
+    ///
+    /// # Arguments
+    /// * `obs_pred_pairs` - Iterator of (outeq, observation, prediction) tuples
+    ///
+    /// # Returns
+    /// The sum of log-likelihood contributions. Returns `f64::NEG_INFINITY` if any
+    /// outeq is invalid.
+    pub fn total_log_likelihood<I>(&self, obs_pred_pairs: I) -> f64
+    where
+        I: IntoIterator<Item = (usize, f64, f64)>,
+    {
+        let mut total = 0.0;
+        for (outeq, obs, pred) in obs_pred_pairs {
+            match self.log_likelihood(outeq, obs, pred) {
+                Some(ll) => total += ll,
+                None => return f64::NEG_INFINITY,
+            }
+        }
+        total
+    }
+
+    /// Update all models with a new sigma estimate
+    pub fn update_sigma(&mut self, new_sigma: f64) {
+        for model in &mut self.models {
+            *model = model.with_updated_sigma(new_sigma);
+        }
+    }
+}
+
+/// Convert from [`ErrorModels`] to [`ResidualErrorModels`]
+///
+/// This allows backward compatibility when users have existing `ErrorModels`
+/// configurations that need to be used with parametric algorithms.
+///
+/// # Conversion Mapping
+///
+/// | pharmsol ErrorModel | ResidualErrorModel |
+/// |---------------------|-------------------|
+/// | `Additive { lambda, .. }` | `Constant { a: lambda }` |
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_constant_error() {
+        let model = ResidualErrorModel::constant(0.5);
+        assert!((model.sigma(0.0) - 0.5).abs() < 1e-10);
+        assert!((model.sigma(100.0) - 0.5).abs() < 1e-10);
+        assert!((model.sigma(-50.0) - 0.5).abs() < 1e-10);
+    }
+
+    #[test]
+    fn test_proportional_error() {
+        let model = ResidualErrorModel::proportional(0.1);
+        assert!((model.sigma(100.0) - 10.0).abs() < 1e-10);
+        assert!((model.sigma(50.0) - 5.0).abs() < 1e-10);
+        // Uses absolute value, so negative predictions work
+        assert!((model.sigma(-100.0) - 10.0).abs() < 1e-10);
+    }
+
+    #[test]
+    fn test_combined_error() {
+        let model = ResidualErrorModel::combined(0.5, 0.1);
+        // At f=0: sigma = sqrt(0.25 + 0) = 0.5
+        assert!((model.sigma(0.0) - 0.5).abs() < 1e-10);
+        // At f=100: sigma = sqrt(0.25 + 100) = sqrt(100.25)
+        assert!((model.sigma(100.0) - 100.25_f64.sqrt()).abs() < 1e-10);
+    }
+
+    #[test]
+    fn test_weighted_residual() {
+        let model = ResidualErrorModel::constant(1.0);
+        // Constant error: unweighted residual = (obs - pred)²
+        let wr = model.weighted_squared_residual(5.0, 3.0);
+        assert!((wr - 4.0).abs() < 1e-10); // (5-3)² = 4
+
+        let prop_model = ResidualErrorModel::proportional(0.1);
+        // Proportional: weighted by 1/pred², NOT 1/sigma²
+        // At pred=10, residual = 12-10 = 2, weighted = (2)²/(10)² = 4/100 = 0.04
+        let wr2 = prop_model.weighted_squared_residual(12.0, 10.0);
+        assert!((wr2 - 0.04).abs() < 1e-10);
+    }
+
+    #[test]
+    fn test_sigma_cutoff() {
+        let model = ResidualErrorModel::proportional(0.1);
+        // At prediction = 0, raw sigma would be 0, but cutoff prevents this
+        let sigma = model.sigma(0.0);
+        assert!(sigma > 0.0);
+        assert!(sigma >= f64::EPSILON.sqrt());
+    }
+
+    #[test]
+    fn test_log_likelihood() {
+        let model = ResidualErrorModel::constant(1.0);
+        // Standard normal: log L = -0.5 * (log(2π) + 0 + z²)
+        let ll = model.log_likelihood(1.0, 0.0);
+        let expected = -0.5 * (std::f64::consts::TAU.ln() + 1.0);
+        assert!((ll - expected).abs() < 1e-10);
+    }
+
+    #[test]
+    fn test_residual_error_models_collection() {
+        let models = ResidualErrorModels::new()
+            .add(0, ResidualErrorModel::constant(0.5))
+            .add(1, ResidualErrorModel::proportional(0.1));
+
+        assert_eq!(models.len(), 2);
+        assert!(models.get(0).unwrap().is_constant());
+        assert!(models.get(1).unwrap().is_proportional());
+        assert!((models.sigma(0, 100.0).unwrap() - 0.5).abs() < 1e-10);
+        assert!((models.sigma(1, 100.0).unwrap() - 10.0).abs() < 1e-10);
+    }
+}
diff --git a/src/data/structs.rs b/src/data/structs.rs
index c5978386..87d4f213 100644
--- a/src/data/structs.rs
+++ b/src/data/structs.rs
@@ -41,7 +41,7 @@ pub struct Data {
 impl Data {
     /// Constructs a new [Data] object from a vector of [Subject]s
     ///
-    /// It is recommended to construct subjects using the [SubjectBuilder] to ensure proper data formatting.
+    /// It is recommended to construct subjects using the [`crate::data::builder::SubjectBuilder`] to ensure proper data formatting.
     ///
     /// # Arguments
     ///
@@ -285,6 +285,30 @@ impl Data {
         outeq_values.dedup();
         outeq_values
     }
+
+    /// Perform Non-Compartmental Analysis (NCA) on all subjects in the dataset
+    ///
+    /// This method iterates through all subjects and performs NCA analysis
+    /// for each subject's data, returning a collection of results.
+    ///
+    /// # Arguments
+    ///
+    /// * `options` - NCA calculation options
+    /// * `outeq` - Output equation index to analyze (0-indexed)
+    ///
+    /// # Returns
+    ///
+    /// Vector of `Result<NCAResult, NCAError>` for each subject-occasion combination
+    pub fn nca(
+        &self,
+        options: &crate::nca::NCAOptions,
+        outeq: usize,
+    ) -> Vec<Result<crate::nca::NCAResult, crate::nca::NCAError>> {
+        self.subjects
+            .iter()
+            .flat_map(|subject| subject.nca(options, outeq))
+            .collect()
+    }
 }
 
 impl IntoIterator for Data {
@@ -469,6 +493,114 @@ impl Subject {
         self.id.hash(&mut hasher);
         hasher.finish()
     }
+
+    /// Perform Non-Compartmental Analysis (NCA) on this subject's data
+    ///
+    /// Calculates standard NCA parameters (Cmax, Tmax, AUC, half-life, etc.)
+    /// from the subject's observed concentration-time data.
+    ///
+    /// # Arguments
+    ///
+    /// * `options` - NCA calculation options
+    /// * `outeq` - Output equation index to analyze (default: 0)
+    ///
+    /// # Returns
+    ///
+    /// Vector of `NCAResult`, one per occasion
+    ///
+    /// # Examples
+    ///
+    /// ```rust,ignore
+    /// use pharmsol::prelude::*;
+    /// use pharmsol::nca::NCAOptions;
+    ///
+    /// let subject = Subject::builder("patient_001")
+    ///     .bolus(0.0, 100.0, 0)
+    ///     .observation(1.0, 10.0, 0)
+    ///     .observation(2.0, 8.0, 0)
+    ///     .observation(4.0, 4.0, 0)
+    ///     .build();
+    ///
+    /// let results = subject.nca(&NCAOptions::default(), 0);
+    /// if let Ok(res) = &results[0] {
+    ///     println!("Cmax: {:.2}", res.exposure.cmax);
+    /// }
+    /// ```
+    pub fn nca(
+        &self,
+        options: &crate::nca::NCAOptions,
+        outeq: usize,
+    ) -> Vec<Result<crate::nca::NCAResult, crate::nca::NCAError>> {
+        self.occasions
+            .iter()
+            .map(|occasion| occasion.nca(options, outeq, Some(self.id.clone())))
+            .collect()
+    }
+
+    /// Extract time-concentration data for a specific output equation
+    ///
+    /// Returns vectors of (times, concentrations, censoring) for the specified outeq.
+    /// This is useful for NCA calculations or other analysis.
+    ///
+    /// # Arguments
+    ///
+    /// * `outeq` - Output equation index to extract
+    ///
+    /// # Returns
+    ///
+    /// Tuple of (times, concentrations, censoring) vectors
+    pub fn get_observations(&self, outeq: usize) -> (Vec<f64>, Vec<f64>, Vec<Censor>) {
+        let mut times = Vec::new();
+        let mut concs = Vec::new();
+        let mut censoring = Vec::new();
+
+        for occasion in &self.occasions {
+            for event in occasion.events() {
+                if let Event::Observation(obs) = event {
+                    if obs.outeq() == outeq {
+                        if let Some(value) = obs.value() {
+                            times.push(obs.time());
+                            concs.push(value);
+                            censoring.push(obs.censoring());
+                        }
+                    }
+                }
+            }
+        }
+
+        (times, concs, censoring)
+    }
+
+    /// Get total dose administered to a specific input compartment
+    ///
+    /// Sums all bolus and infusion doses to the specified compartment.
+    ///
+    /// # Arguments
+    ///
+    /// * `input` - Input compartment index
+    ///
+    /// # Returns
+    ///
+    /// Total dose amount
+    pub fn get_total_dose(&self, input: usize) -> f64 {
+        let mut total = 0.0;
+
+        for occasion in &self.occasions {
+            for event in occasion.events() {
+                match event {
+                    Event::Bolus(bolus) if bolus.input() == input => {
+                        total += bolus.amount();
+                    }
+                    Event::Infusion(infusion) if infusion.input() == input => {
+                        total += infusion.amount();
+                    }
+                    _ => {}
+                }
+            }
+        }
+
+        total
+    }
 }
 
 impl IntoIterator for Subject {
@@ -793,6 +925,157 @@ impl Occasion {
     pub fn is_empty(&self) -> bool {
         self.events.is_empty()
     }
+
+    /// Perform Non-Compartmental Analysis (NCA) on this occasion's data
+    ///
+    /// Automatically extracts dose information and route from events in this occasion.
+    ///
+    /// # Arguments
+    ///
+    /// * `options` - NCA calculation options
+    /// * `outeq` - Output equation index to analyze (0-indexed)
+    /// * `subject_id` - Optional subject ID for result identification
+    ///
+    /// # Returns
+    ///
+    /// `Result<NCAResult, NCAError>` containing calculated parameters or an error
+    ///
+    /// # Example
+    ///
+    /// ```ignore
+    /// use pharmsol::prelude::*;
+    /// use pharmsol::nca::NCAOptions;
+    ///
+    /// let subject = Subject::builder("patient_001")
+    ///     .bolus(0.0, 100.0, 0)
+    ///     .observation(1.0, 10.0, 0)
+    ///     .observation(2.0, 8.0, 0)
+    ///     .build();
+    ///
+    /// let occasion = &subject.occasions()[0];
+    /// let result = occasion.nca(&NCAOptions::default(), 0, Some("patient_001".into()))?;
+    /// println!("Cmax: {:.2}", result.exposure.cmax);
+    /// ```
+    pub fn nca(
+        &self,
+        options: &crate::nca::NCAOptions,
+        outeq: usize,
+        subject_id: Option<String>,
+    ) -> Result<crate::nca::NCAResult, crate::nca::NCAError> {
+        // Extract observations for this outeq (including censoring info)
+        let (times, concs, censoring) = self.get_observations(outeq);
+
+        // Auto-detect dose and route from events
+        let dose_context = self.detect_dose_context();
+
+        // Calculate NCA using the analyze module
+        let mut result =
+            crate::nca::analyze_arrays(&times, &concs, &censoring, dose_context.as_ref(), options)?;
+        result.subject_id = subject_id;
+        result.occasion = Some(self.index);
+
+        Ok(result)
+    }
+
+    /// Detect dose information from dose events in this occasion
+    fn detect_dose_context(&self) -> Option<crate::nca::DoseContext> {
+        let mut total_dose = 0.0;
+        let mut infusion_duration: Option<f64> = None;
+        let mut is_extravascular = false;
+
+        for event in &self.events {
+            match event {
+                Event::Bolus(bolus) => {
+                    total_dose += bolus.amount();
+                    // Input 0 = depot (extravascular), Input >= 1 = central (IV)
+                    if bolus.input() == 0 {
+                        is_extravascular = true;
+                    }
+                }
+                Event::Infusion(infusion) => {
+                    total_dose += infusion.amount();
+                    infusion_duration = Some(infusion.duration());
+                    // Infusions are IV
+                }
+                _ => {}
+            }
+        }
+
+        if total_dose == 0.0 {
+            return None;
+        }
+
+        // Determine route
+        let route = if infusion_duration.is_some() {
+            crate::nca::Route::IVInfusion
+        } else if is_extravascular {
+            crate::nca::Route::Extravascular
+        } else {
+            crate::nca::Route::IVBolus
+        };
+
+        Some(crate::nca::DoseContext::new(
+            total_dose,
+            infusion_duration,
+            route,
+        ))
+    }
+
+    /// Extract time-concentration data for a specific output equation
+    ///
+    /// # Arguments
+    ///
+    /// * `outeq` - Output equation index to extract
+    ///
+    /// # Returns
+    ///
+    /// Tuple of (times, concentrations, censoring) vectors
+    pub fn get_observations(&self, outeq: usize) -> (Vec<f64>, Vec<f64>, Vec<Censor>) {
+        let mut times = Vec::new();
+        let mut concs = Vec::new();
+        let mut censoring = Vec::new();
+
+        for event in &self.events {
+            if let Event::Observation(obs) = event {
+                if obs.outeq() == outeq {
+                    if let Some(value) = obs.value() {
+                        times.push(obs.time());
+                        concs.push(value);
+                        censoring.push(obs.censoring());
+                    }
+                }
+            }
+        }
+
+        (times, concs, censoring)
+    }
+
+    /// Get total dose administered to a specific input compartment
+    ///
+    /// # Arguments
+    ///
+    /// * `input` - Input compartment index
+    ///
+    /// # Returns
+    ///
+    /// Total dose amount
+    pub fn get_total_dose(&self, input: usize) -> f64 {
+        let mut total = 0.0;
+
+        for event in &self.events {
+            match event {
+                Event::Bolus(bolus) if bolus.input() == input => {
+                    total += bolus.amount();
+                }
+                Event::Infusion(infusion) if infusion.input() == input => {
+                    total += infusion.amount();
+                }
+                _ => {}
+            }
+        }
+
+        total
+    }
 }
 
 impl IntoIterator for Occasion {
diff --git a/src/lib.rs b/src/lib.rs
index 29fa56b0..36c5e6d1 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -2,6 +2,7 @@ pub mod data;
 pub mod error;
 #[cfg(feature = "exa")]
 pub mod exa;
+pub mod nca;
 pub mod optimize;
 pub mod simulator;
 
@@ -40,17 +41,17 @@ pub mod prelude {
     // Data submodule for organized access and backward compatibility
     pub mod data {
         pub use crate::data::{
-            builder::SubjectBuilderExt,
-            error_model::{ErrorModel, ErrorModels, ErrorPoly},
-            parser::read_pmetrics,
-            Covariates, Data, Event, Interpolation, Occasion, Subject,
+            error_model::{AssayErrorModel, AssayErrorModels},
+            parser::{read_pmetrics, NormalizedRow, NormalizedRowBuilder},
+            residual_error::{ResidualErrorModel, ResidualErrorModels},
+            Covariates, Data, Event, Occasion, Subject,
         };
     }
 
     // Direct data re-exports for convenience
     pub use crate::data::{
         builder::SubjectBuilderExt,
-        error_model::{ErrorModel, ErrorModels, ErrorPoly},
+        error_model::{AssayErrorModel, AssayErrorModels, ErrorPoly},
         Covariates, Data, Event, Interpolation, Occasion, Subject,
     };
 
@@ -59,8 +60,15 @@ pub mod prelude {
         pub use crate::simulator::{
             equation,
             equation::Equation,
-            likelihood::{psi, PopulationPredictions, Prediction, SubjectPredictions},
+            likelihood::{
+                log_likelihood_batch, log_likelihood_matrix, log_likelihood_subject,
+                LikelihoodMatrixOptions, PopulationPredictions, Prediction, SubjectPredictions,
+            },
         };
+
+        // Deprecated re-exports for backward compatibility
+        #[allow(deprecated)]
+        pub use crate::simulator::likelihood::{log_psi, psi};
     }
 
     // Direct simulator re-exports for convenience
diff --git a/src/nca/analyze.rs b/src/nca/analyze.rs
new file mode 100644
index 00000000..866e96b6
--- /dev/null
+++ b/src/nca/analyze.rs
@@ -0,0 +1,517 @@
+//! Main NCA analysis orchestrator
+//!
+//! This module contains the core analysis function that computes all NCA parameters
+//! from a validated profile and options.
+
+use super::calc;
+use super::error::NCAError;
+use super::profile::Profile;
+use super::types::*;
+
+// ============================================================================
+// Dose Context (internal - auto-detected from data structures)
+// ============================================================================
+
+/// Dose and route information detected from data
+///
+/// This is constructed internally by `Occasion::nca()` from the dose events in the data.
+#[derive(Debug, Clone)]
+pub(crate) struct DoseContext {
+    /// Total dose amount
+    pub amount: f64,
+    /// Infusion duration (None for bolus)
+    pub duration: Option<f64>,
+    /// Administration route
+    pub route: Route,
+}
+
+impl DoseContext {
+    /// Create a new dose context
+    pub fn new(amount: f64, duration: Option<f64>, route: Route) -> Self {
+        Self {
+            amount,
+            duration,
+            route,
+        }
+    }
+}
+
+// ============================================================================
+// Main Analysis Function
+// ============================================================================
+
+/// Perform complete NCA analysis on a profile
+///
+/// This is an internal function. External users should use `analyze_arrays`
+/// or the `.nca()` method on data structures.
+///
+/// # Arguments
+/// * `profile` - Validated concentration-time profile
+/// * `dose` - Dose context (detected from data, None if no dosing info)
+/// * `options` - Analysis configuration
+#[allow(dead_code)] // Used only in tests; main entry point is analyze_arrays
+pub(crate) fn analyze(
+    profile: &Profile,
+    dose: Option<&DoseContext>,
+    options: &NCAOptions,
+) -> Result<NCAResult, NCAError> {
+    // When called without raw data, calculate tlag from the (filtered) profile
+    #[allow(deprecated)]
+    let raw_tlag = calc::tlag(profile);
+    analyze_with_raw_tlag(profile, dose, options, raw_tlag)
+}
+
+/// Internal analysis with pre-computed raw tlag
+fn analyze_with_raw_tlag(
+    profile: &Profile,
+    dose: Option<&DoseContext>,
+    options: &NCAOptions,
+    raw_tlag: Option<f64>,
+) -> Result<NCAResult, NCAError> {
+    if profile.times.is_empty() {
+        return Err(NCAError::InsufficientData { n: 0, required: 2 });
+    }
+
+    // Core exposure parameters (always calculated)
+    let mut exposure = compute_exposure(profile, options, raw_tlag)?;
+
+    // Terminal phase parameters (if lambda-z can be estimated)
+    let (terminal, lambda_z_result) = compute_terminal(profile, options);
+
+    // Update exposure with AUCinf if we have terminal phase
+    if let Some(ref lz) = lambda_z_result {
+        update_exposure_with_terminal(&mut exposure, profile, lz, options);
+    }
+
+    // Clearance parameters (if we have dose and terminal phase)
+    let clearance = dose
+        .and_then(|d| lambda_z_result.as_ref().map(|lz| (d, lz)))
+        .map(|(d, lz)| compute_clearance(d.amount, exposure.auc_inf, lz.lambda_z));
+
+    // Route-specific parameters
+    let (iv_bolus, iv_infusion) =
+        compute_route_specific(profile, dose, lambda_z_result.as_ref(), options);
+
+    // Steady-state parameters (if tau specified)
+    let steady_state = options
+        .tau
+        .map(|tau| compute_steady_state(profile, tau, options));
+
+    // Build quality summary
+    let quality = build_quality(
+        &exposure,
+        terminal.as_ref(),
+        lambda_z_result.as_ref(),
+        options,
+    );
+
+    Ok(NCAResult {
+        subject_id: None,
+        occasion: None,
+        exposure,
+        terminal,
+        clearance,
+        iv_bolus,
+        iv_infusion,
+        steady_state,
+        quality,
+    })
+}
+
+/// Compute core exposure parameters
+fn compute_exposure(
+    profile: &Profile,
+    options: &NCAOptions,
+    raw_tlag: Option<f64>,
+) -> Result<ExposureParams, NCAError> {
+    let cmax = profile.cmax();
+    let tmax = profile.tmax();
+    let clast = profile.clast();
+    let tlast = profile.tlast();
+
+    let auc_last = calc::auc_last(profile, options.auc_method);
+    let aumc_last = calc::aumc_last(profile, options.auc_method);
+
+    // Calculate partial AUC if interval specified
+    let auc_partial = options
+        .auc_interval
+        .map(|(start, end)| calc::auc_interval(profile, start, end, options.auc_method));
+
+    // AUCinf will be computed in terminal phase if lambda-z is available
+    Ok(ExposureParams {
+        cmax,
+        tmax,
+        clast,
+        tlast,
+        auc_last,
+        auc_inf: None, // Will be filled in if terminal phase estimated
+        auc_pct_extrap: None,
+        auc_partial,
+        aumc_last: Some(aumc_last),
+        aumc_inf: None,
+        tlag: raw_tlag,
+    })
+}
+
+/// Compute terminal phase parameters
+fn compute_terminal(
+    profile: &Profile,
+    options: &NCAOptions,
+) -> (Option<TerminalParams>, Option<calc::LambdaZResult>) {
+    use crate::nca::types::ClastType;
+
+    let lz_result = calc::lambda_z(profile, &options.lambda_z);
+
+    let terminal = lz_result.as_ref().map(|lz| {
+        let half_life = calc::half_life(lz.lambda_z);
+
+        // Choose Clast based on ClastType option
+        let clast = match options.clast_type {
+            ClastType::Observed => profile.clast(),
+            ClastType::Predicted => lz.clast_pred,
+        };
+
+        // Compute AUC infinity
+        let auc_last_val = calc::auc_last(profile, options.auc_method);
+        let auc_inf = calc::auc_inf(auc_last_val, clast, lz.lambda_z);
+
+        // MRT - use aumc with same method as auc for consistency
+        let aumc_last_val = calc::aumc_last(profile, options.auc_method);
+        let aumc_inf = calc::aumc_inf(aumc_last_val, clast, profile.tlast(), lz.lambda_z);
+        let mrt = calc::mrt(aumc_inf, auc_inf);
+
+        TerminalParams {
+            lambda_z: lz.lambda_z,
+            half_life,
+            mrt: Some(mrt),
+            regression: Some(lz.clone().into()),
+        }
+    });
+
+    (terminal, lz_result)
+}
+
+/// Compute clearance parameters
+fn compute_clearance(dose: f64, auc_inf: Option<f64>, lambda_z: f64) -> ClearanceParams {
+    let auc = auc_inf.unwrap_or(f64::NAN);
+    let cl = calc::clearance(dose, auc);
+    let vz = calc::vz(dose, lambda_z, auc);
+
+    ClearanceParams {
+        cl_f: cl,
+        vz_f: vz,
+        vss: None, // Computed for IV routes
+    }
+}
+
+/// Pre-computed base values to avoid redundant calculations
+struct BaseValues {
+    auc_last: f64,
+    aumc_last: f64,
+    clast: f64,
+    tlast: f64,
+}
+
+impl BaseValues {
+    fn from_profile(profile: &Profile, method: AUCMethod) -> Self {
+        Self {
+            auc_last: calc::auc_last(profile, method),
+            aumc_last: calc::aumc_last(profile, method),
+            clast: profile.clast(),
+            tlast: profile.tlast(),
+        }
+    }
+
+    /// Create with predicted clast from lambda-z regression
+    fn with_clast_pred(mut self, clast_pred: f64) -> Self {
+        self.clast = clast_pred;
+        self
+    }
+
+    fn auc_inf(&self, lambda_z: f64) -> f64 {
+        calc::auc_inf(self.auc_last, self.clast, lambda_z)
+    }
+
+    fn aumc_inf(&self, lambda_z: f64) -> f64 {
+        calc::aumc_inf(self.aumc_last, self.clast, self.tlast, lambda_z)
+    }
+}
+
+/// Compute route-specific parameters (IV only - extravascular tlag is in exposure)
+fn compute_route_specific(
+    profile: &Profile,
+    dose: Option<&DoseContext>,
+    lz_result: Option<&calc::LambdaZResult>,
+    options: &NCAOptions,
+) -> (Option<IVBolusParams>, Option<IVInfusionParams>) {
+    let route = dose.map(|d| d.route).unwrap_or(Route::Extravascular);
+
+    // Pre-compute base values once to avoid redundant calculations
+    let mut base = BaseValues::from_profile(profile, options.auc_method);
+
+    // Apply predicted clast if requested and lambda-z is available
+    if matches!(options.clast_type, ClastType::Predicted) {
+        if let Some(lz) = lz_result {
+            base = base.with_clast_pred(lz.clast_pred);
+        }
+    }
+
+    match route {
+        Route::IVBolus => {
+            let lambda_z = lz_result.map(|lz| lz.lambda_z).unwrap_or(f64::NAN);
+            let c0 = calc::c0(profile, &options.c0_methods, lambda_z);
+
+            let vd = dose
+                .map(|d| calc::vd_bolus(d.amount, c0))
+                .unwrap_or(f64::NAN);
+
+            // VSS for IV
+            let vss = lz_result.and_then(|lz| {
+                dose.map(|d| {
+                    let auc_inf = base.auc_inf(lz.lambda_z);
+                    let aumc_inf = base.aumc_inf(lz.lambda_z);
+                    calc::vss(d.amount, aumc_inf, auc_inf)
+                })
+            });
+
+            (Some(IVBolusParams { c0, vd, vss }), None)
+        }
+        Route::IVInfusion => {
+            let duration = dose.and_then(|d| d.duration).unwrap_or(0.0);
+
+            // MRT adjusted for infusion
+            let mrt_iv = lz_result.map(|lz| {
+                let auc_inf = base.auc_inf(lz.lambda_z);
+                let aumc_inf = base.aumc_inf(lz.lambda_z);
+                let mrt_uncorrected = calc::mrt(aumc_inf, auc_inf);
+                calc::mrt_infusion(mrt_uncorrected, duration)
+            });
+
+            // VSS for IV infusion
+            let vss = lz_result.and_then(|lz| {
+                dose.map(|d| {
+                    let auc_inf = base.auc_inf(lz.lambda_z);
+                    let aumc_inf = base.aumc_inf(lz.lambda_z);
+                    calc::vss(d.amount, aumc_inf, auc_inf)
+                })
+            });
+
+            (
+                None,
+                Some(IVInfusionParams {
+                    infusion_duration: duration,
+                    mrt_iv,
+                    vss,
+                }),
+            )
+        }
+        Route::Extravascular => {
+            // Tlag is computed in exposure params
+            (None, None)
+        }
+    }
+}
+
+/// Compute steady-state parameters
+fn compute_steady_state(profile: &Profile, tau: f64, options: &NCAOptions) -> SteadyStateParams {
+    let cmax = profile.cmax();
+    let cmin = calc::cmin(profile);
+    let auc_tau = calc::auc_interval(profile, 0.0, tau, options.auc_method);
+    let cavg = calc::cavg(auc_tau, tau);
+    let fluctuation = calc::fluctuation(cmax, cmin, cavg);
+    let swing = calc::swing(cmax, cmin);
+
+    SteadyStateParams {
+        tau,
+        auc_tau,
+        cmin,
+        cmax_ss: cmax,
+        cavg,
+        fluctuation,
+        swing,
+        accumulation: None, // Would need single-dose reference
+    }
+}
+
+/// Build quality assessment
+fn build_quality(
+    exposure: &ExposureParams,
+    terminal: Option<&TerminalParams>,
+    lz_result: Option<&calc::LambdaZResult>,
+    options: &NCAOptions,
+) -> Quality {
+    let mut warnings = Vec::new();
+
+    // Check for issues
+    if exposure.cmax <= 0.0 {
+        warnings.push(Warning::LowCmax);
+    }
+
+    // Check extrapolation percentage
+    if let (Some(auc_inf), Some(lz)) = (exposure.auc_inf, lz_result) {
+        let pct_extrap = calc::auc_extrap_pct(exposure.auc_last, auc_inf);
+        if pct_extrap > options.max_auc_extrap_pct {
+            warnings.push(Warning::HighExtrapolation);
+        }
+
+        // Check span ratio
+        if let Some(stats) = terminal.and_then(|t| t.regression.as_ref()) {
+            if stats.span_ratio < options.lambda_z.min_span_ratio {
+                warnings.push(Warning::ShortTerminalPhase);
+            }
+        }
+
+        // Check R²
+        if lz.r_squared < options.lambda_z.min_r_squared {
+            warnings.push(Warning::PoorFit);
+        }
+    } else {
+        warnings.push(Warning::LambdaZNotEstimable);
+    }
+
+    Quality { warnings }
+}
+
+/// Update exposure parameters with terminal phase info
+fn update_exposure_with_terminal(
+    exposure: &mut ExposureParams,
+    profile: &Profile,
+    lz_result: &calc::LambdaZResult,
+    options: &NCAOptions,
+) {
+    // Choose Clast based on ClastType option
+    let clast = match options.clast_type {
+        ClastType::Observed => profile.clast(),
+        ClastType::Predicted => lz_result.clast_pred,
+    };
+    let tlast = profile.tlast();
+
+    // AUC infinity
+    let auc_inf = calc::auc_inf(exposure.auc_last, clast, lz_result.lambda_z);
+    exposure.auc_inf = Some(auc_inf);
+    exposure.auc_pct_extrap = Some(calc::auc_extrap_pct(exposure.auc_last, auc_inf));
+
+    // AUMC infinity
+    if let Some(aumc_last) = exposure.aumc_last {
+        exposure.aumc_inf = Some(calc::aumc_inf(aumc_last, clast, tlast, lz_result.lambda_z));
+    }
+}
+
+// ============================================================================
+// Helper for Data integration
+// ============================================================================
+
+/// Analyze from raw arrays with censoring information
+///
+/// Censoring status is determined by the `Censor` marking:
+/// - `Censor::BLOQ`: Below limit of quantification - value is the lower limit
+/// - `Censor::ALOQ`: Above limit of quantification - value is the upper limit  
+/// - `Censor::None`: Quantifiable observation - value is the measured concentration
+///
+/// For uncensored data, pass `Censor::None` for all observations.
+pub(crate) fn analyze_arrays(
+    times: &[f64],
+    concentrations: &[f64],
+    censoring: &[crate::Censor],
+    dose: Option<&DoseContext>,
+    options: &NCAOptions,
+) -> Result<NCAResult, NCAError> {
+    // Calculate tlag from raw data (before BLQ filtering) to match PKNCA
+    let raw_tlag = calc::tlag_from_raw(times, concentrations, censoring);
+
+    let profile = Profile::from_arrays(times, concentrations, censoring, options.blq_rule.clone())?;
+    analyze_with_raw_tlag(&profile, dose, options, raw_tlag)
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::Censor;
+
+    fn test_profile() -> Profile {
+        let censoring = vec![Censor::None; 8];
+        Profile::from_arrays(
+            &[0.0, 0.5, 1.0, 2.0, 4.0, 8.0, 12.0, 24.0],
+            &[0.0, 5.0, 10.0, 8.0, 4.0, 2.0, 1.0, 0.25],
+            &censoring,
+            BLQRule::Exclude,
+        )
+        .unwrap()
+    }
+
+    #[test]
+    fn test_analyze_basic() {
+        let profile = test_profile();
+        let options = NCAOptions::default();
+
+        let result = analyze(&profile, None, &options).unwrap();
+
+        assert_eq!(result.exposure.cmax, 10.0);
+        assert_eq!(result.exposure.tmax, 1.0);
+        assert!(result.exposure.auc_last > 0.0);
+        // No clearance without dose
+        assert!(result.clearance.is_none());
+    }
+
+    #[test]
+    fn test_analyze_with_dose() {
+        let profile = test_profile();
+        let options = NCAOptions::default();
+        let dose = DoseContext::new(100.0, None, Route::Extravascular);
+
+        let result = analyze(&profile, Some(&dose), &options).unwrap();
+
+        // Should have clearance if terminal phase estimated
+        if result.terminal.is_some() {
+            assert!(result.clearance.is_some());
+        }
+        // Tlag is now in exposure, not a separate struct
+        // Exposure params are always present
+        assert!(result.exposure.auc_last > 0.0);
+    }
+
+    #[test]
+    fn test_analyze_iv_bolus() {
+        let profile = test_profile();
+        let options = NCAOptions::default();
+        let dose = DoseContext::new(100.0, None, Route::IVBolus);
+
+        let result = analyze(&profile, Some(&dose), &options).unwrap();
+
+        assert!(result.iv_bolus.is_some());
+        assert!(result.iv_infusion.is_none());
+    }
+
+    #[test]
+    fn test_analyze_iv_infusion() {
+        let profile = test_profile();
+        let options = NCAOptions::default();
+        let dose = DoseContext::new(100.0, Some(1.0), Route::IVInfusion);
+
+        let result = analyze(&profile, Some(&dose), &options).unwrap();
+
+        assert!(result.iv_bolus.is_none());
+        assert!(result.iv_infusion.is_some());
+        assert_eq!(result.iv_infusion.as_ref().unwrap().infusion_duration, 1.0);
+    }
+
+    #[test]
+    fn test_analyze_steady_state() {
+        let profile = test_profile();
+        let options = NCAOptions::default().with_tau(12.0);
+        let dose = DoseContext::new(100.0, None, Route::Extravascular);
+
+        let result = analyze(&profile, Some(&dose), &options).unwrap();
+
+        assert!(result.steady_state.is_some());
+        let ss = result.steady_state.unwrap();
+        assert_eq!(ss.tau, 12.0);
+        assert!(ss.auc_tau > 0.0);
+    }
+
+    #[test]
+    fn test_empty_profile() {
+        let profile = Profile::from_arrays(&[], &[], &[], BLQRule::Exclude);
+        assert!(profile.is_err());
+    }
+}
diff --git a/src/nca/calc.rs b/src/nca/calc.rs
new file mode 100644
index 00000000..6834f47f
--- /dev/null
+++ b/src/nca/calc.rs
@@ -0,0 +1,838 @@
+//! Pure calculation functions for NCA parameters
+//!
+//! This module contains stateless functions that compute individual NCA parameters.
+//! All functions take validated inputs and return calculated values.
+
+use super::profile::Profile;
+use super::types::{AUCMethod, LambdaZMethod, LambdaZOptions, RegressionStats};
+
+// ============================================================================
+// AUC Calculations
+// ============================================================================
+
+/// Check if log-linear method should be used for this segment
+#[inline]
+fn use_log_linear(c1: f64, c2: f64) -> bool {
+    c2 < c1 && c1 > 0.0 && c2 > 0.0 && ((c1 / c2) - 1.0).abs() >= 1e-10
+}
+
+/// Linear trapezoidal AUC for a segment
+#[inline]
+fn auc_linear(c1: f64, c2: f64, dt: f64) -> f64 {
+    (c1 + c2) / 2.0 * dt
+}
+
+/// Log-linear AUC for a segment (assumes c1 > c2 > 0)
+#[inline]
+fn auc_log(c1: f64, c2: f64, dt: f64) -> f64 {
+    (c1 - c2) * dt / (c1 / c2).ln()
+}
+
+/// Linear trapezoidal AUMC for a segment
+#[inline]
+fn aumc_linear(t1: f64, c1: f64, t2: f64, c2: f64, dt: f64) -> f64 {
+    (t1 * c1 + t2 * c2) / 2.0 * dt
+}
+
+/// Log-linear AUMC for a segment (PKNCA formula)
+#[inline]
+fn aumc_log(t1: f64, c1: f64, t2: f64, c2: f64, dt: f64) -> f64 {
+    let k = (c1 / c2).ln() / dt;
+    (t1 * c1 - t2 * c2) / k + (c1 - c2) / (k * k)
+}
+
+/// Calculate AUC for a single segment between two time points
+///
+/// For [`AUCMethod::LinLog`], this uses linear trapezoidal since segment-level
+/// calculation cannot know Tmax context. Use [`auc_last`] for proper LinLog handling.
+#[inline]
+pub fn auc_segment(t1: f64, c1: f64, t2: f64, c2: f64, method: AUCMethod) -> f64 {
+    let dt = t2 - t1;
+    if dt <= 0.0 {
+        return 0.0;
+    }
+
+    match method {
+        AUCMethod::Linear | AUCMethod::LinLog => auc_linear(c1, c2, dt),
+        AUCMethod::LinUpLogDown => {
+            if use_log_linear(c1, c2) {
+                auc_log(c1, c2, dt)
+            } else {
+                auc_linear(c1, c2, dt)
+            }
+        }
+    }
+}
+
+/// Calculate AUC for a segment with Tmax context (for LinLog method)
+#[inline]
+fn auc_segment_with_tmax(t1: f64, c1: f64, t2: f64, c2: f64, tmax: f64, method: AUCMethod) -> f64 {
+    let dt = t2 - t1;
+    if dt <= 0.0 {
+        return 0.0;
+    }
+
+    match method {
+        AUCMethod::Linear => auc_linear(c1, c2, dt),
+        AUCMethod::LinUpLogDown => {
+            if use_log_linear(c1, c2) {
+                auc_log(c1, c2, dt)
+            } else {
+                auc_linear(c1, c2, dt)
+            }
+        }
+        AUCMethod::LinLog => {
+            // Linear before/at Tmax, log-linear after Tmax (for descending)
+            if t2 <= tmax || !use_log_linear(c1, c2) {
+                auc_linear(c1, c2, dt)
+            } else {
+                auc_log(c1, c2, dt)
+            }
+        }
+    }
+}
+
+/// Calculate AUC from time 0 to Tlast
+pub fn auc_last(profile: &Profile, method: AUCMethod) -> f64 {
+    let mut auc = 0.0;
+    let tmax = profile.tmax(); // Get Tmax for LinLog method
+
+    for i in 1..=profile.tlast_idx {
+        auc += auc_segment_with_tmax(
+            profile.times[i - 1],
+            profile.concentrations[i - 1],
+            profile.times[i],
+            profile.concentrations[i],
+            tmax,
+            method,
+        );
+    }
+
+    auc
+}
+
+/// Calculate AUMC for a segment with Tmax context (for LinLog method)
+#[inline]
+fn aumc_segment_with_tmax(t1: f64, c1: f64, t2: f64, c2: f64, tmax: f64, method: AUCMethod) -> f64 {
+    let dt = t2 - t1;
+    if dt <= 0.0 {
+        return 0.0;
+    }
+
+    match method {
+        AUCMethod::Linear => aumc_linear(t1, c1, t2, c2, dt),
+        AUCMethod::LinUpLogDown => {
+            if use_log_linear(c1, c2) {
+                aumc_log(t1, c1, t2, c2, dt)
+            } else {
+                aumc_linear(t1, c1, t2, c2, dt)
+            }
+        }
+        AUCMethod::LinLog => {
+            // Linear before/at Tmax, log-linear after Tmax (for descending)
+            if t2 <= tmax || !use_log_linear(c1, c2) {
+                aumc_linear(t1, c1, t2, c2, dt)
+            } else {
+                aumc_log(t1, c1, t2, c2, dt)
+            }
+        }
+    }
+}
+
+/// Calculate AUMC from time 0 to Tlast
+pub fn aumc_last(profile: &Profile, method: AUCMethod) -> f64 {
+    let mut aumc = 0.0;
+    let tmax_val = profile.tmax();
+
+    for i in 1..=profile.tlast_idx {
+        aumc += aumc_segment_with_tmax(
+            profile.times[i - 1],
+            profile.concentrations[i - 1],
+            profile.times[i],
+            profile.concentrations[i],
+            tmax_val,
+            method,
+        );
+    }
+
+    aumc
+}
+
+/// Calculate AUC over a specific interval (for steady-state AUCτ)
+pub fn auc_interval(profile: &Profile, start: f64, end: f64, method: AUCMethod) -> f64 {
+    if end <= start {
+        return 0.0;
+    }
+
+    let mut auc = 0.0;
+
+    for i in 1..profile.times.len() {
+        let t1 = profile.times[i - 1];
+        let t2 = profile.times[i];
+
+        // Skip segments entirely outside the interval
+        if t2 <= start || t1 >= end {
+            continue;
+        }
+
+        // Clamp to interval boundaries
+        let seg_start = t1.max(start);
+        let seg_end = t2.min(end);
+
+        // Interpolate concentrations at boundaries if needed
+        let c1 = if t1 < start {
+            interpolate_concentration(profile, start)
+        } else {
+            profile.concentrations[i - 1]
+        };
+
+        let c2 = if t2 > end {
+            interpolate_concentration(profile, end)
+        } else {
+            profile.concentrations[i]
+        };
+
+        auc += auc_segment(seg_start, c1, seg_end, c2, method);
+    }
+
+    auc
+}
+
+/// Linear interpolation of concentration at a given time
+fn interpolate_concentration(profile: &Profile, time: f64) -> f64 {
+    if time <= profile.times[0] {
+        return profile.concentrations[0];
+    }
+    if time >= profile.times[profile.times.len() - 1] {
+        return profile.concentrations[profile.times.len() - 1];
+    }
+
+    // Find bracketing indices
+    let upper_idx = profile
+        .times
+        .iter()
+        .position(|&t| t >= time)
+        .unwrap_or(profile.times.len() - 1);
+    let lower_idx = upper_idx.saturating_sub(1);
+
+    let t1 = profile.times[lower_idx];
+    let t2 = profile.times[upper_idx];
+    let c1 = profile.concentrations[lower_idx];
+    let c2 = profile.concentrations[upper_idx];
+
+    if (t2 - t1).abs() < 1e-10 {
+        c1
+    } else {
+        c1 + (c2 - c1) * (time - t1) / (t2 - t1)
+    }
+}
+
+// ============================================================================
+// Lambda-z Calculations
+// ============================================================================
+
+/// Result of lambda-z estimation
+#[derive(Debug, Clone)]
+pub struct LambdaZResult {
+    pub lambda_z: f64,
+    pub intercept: f64,
+    pub r_squared: f64,
+    pub adj_r_squared: f64,
+    pub n_points: usize,
+    pub time_first: f64,
+    pub time_last: f64,
+    pub clast_pred: f64,
+}
+
+impl From<LambdaZResult> for RegressionStats {
+    fn from(lz: LambdaZResult) -> Self {
+        let half_life = std::f64::consts::LN_2 / lz.lambda_z;
+        let span = lz.time_last - lz.time_first;
+        RegressionStats {
+            r_squared: lz.r_squared,
+            adj_r_squared: lz.adj_r_squared,
+            n_points: lz.n_points,
+            time_first: lz.time_first,
+            time_last: lz.time_last,
+            span_ratio: span / half_life,
+        }
+    }
+}
+
+/// Estimate lambda-z using log-linear regression
+pub fn lambda_z(profile: &Profile, options: &LambdaZOptions) -> Option<LambdaZResult> {
+    // Determine start index (exclude or include Tmax)
+    let start_idx = if options.include_tmax {
+        0
+    } else {
+        profile.cmax_idx + 1
+    };
+
+    // Need at least min_points between start and tlast
+    if profile.tlast_idx < start_idx + options.min_points - 1 {
+        return None;
+    }
+
+    match options.method {
+        LambdaZMethod::Manual(n) => lambda_z_with_n_points(profile, start_idx, n, options),
+        LambdaZMethod::R2 | LambdaZMethod::AdjR2 => lambda_z_best_fit(profile, start_idx, options),
+    }
+}
+
+/// Lambda-z with specified number of terminal points
+fn lambda_z_with_n_points(
+    profile: &Profile,
+    start_idx: usize,
+    n_points: usize,
+    options: &LambdaZOptions,
+) -> Option<LambdaZResult> {
+    if n_points < options.min_points {
+        return None;
+    }
+
+    let first_idx = profile.tlast_idx.saturating_sub(n_points - 1);
+    if first_idx < start_idx {
+        return None;
+    }
+
+    fit_lambda_z(profile, first_idx, profile.tlast_idx, options)
+}
+
+/// Lambda-z with best fit selection
+fn lambda_z_best_fit(
+    profile: &Profile,
+    start_idx: usize,
+    options: &LambdaZOptions,
+) -> Option<LambdaZResult> {
+    let mut best_result: Option<LambdaZResult> = None;
+
+    // Determine max points to try
+    let max_n = if let Some(max) = options.max_points {
+        (profile.tlast_idx - start_idx + 1).min(max)
+    } else {
+        profile.tlast_idx - start_idx + 1
+    };
+
+    // Try all valid point counts
+    for n_points in options.min_points..=max_n {
+        let first_idx = profile.tlast_idx - n_points + 1;
+
+        if first_idx < start_idx {
+            continue;
+        }
+
+        if let Some(result) = fit_lambda_z(profile, first_idx, profile.tlast_idx, options) {
+            // Check quality criteria
+            if result.r_squared < options.min_r_squared {
+                continue;
+            }
+
+            let half_life = std::f64::consts::LN_2 / result.lambda_z;
+            let span = result.time_last - result.time_first;
+            let span_ratio = span / half_life;
+
+            if span_ratio < options.min_span_ratio {
+                continue;
+            }
+
+            // Select best based on method, using adj_r_squared_factor to prefer more points
+            let is_better = match &best_result {
+                None => true,
+                Some(best) => {
+                    // PKNCA formula: adj_r_squared + factor * n_points
+                    // This allows preferring regressions with more points when R² is similar
+                    let factor = options.adj_r_squared_factor;
+                    let current_score = match options.method {
+                        LambdaZMethod::AdjR2 => {
+                            result.adj_r_squared + factor * result.n_points as f64
+                        }
+                        _ => result.r_squared,
+                    };
+                    let best_score = match options.method {
+                        LambdaZMethod::AdjR2 => best.adj_r_squared + factor * best.n_points as f64,
+                        _ => best.r_squared,
+                    };
+
+                    current_score > best_score
+                }
+            };
+
+            if is_better {
+                best_result = Some(result);
+            }
+        }
+    }
+
+    best_result
+}
+
+/// Fit log-linear regression for lambda-z
+fn fit_lambda_z(
+    profile: &Profile,
+    first_idx: usize,
+    last_idx: usize,
+    _options: &LambdaZOptions,
+) -> Option<LambdaZResult> {
+    // Extract points with positive concentrations
+    let mut times = Vec::new();
+    let mut log_concs = Vec::new();
+
+    for i in first_idx..=last_idx {
+        if profile.concentrations[i] > 0.0 {
+            times.push(profile.times[i]);
+            log_concs.push(profile.concentrations[i].ln());
+        }
+    }
+
+    if times.len() < 2 {
+        return None;
+    }
+
+    // Simple linear regression: ln(C) = intercept + slope * t
+    let (slope, intercept, r_squared) = linear_regression(&times, &log_concs)?;
+
+    let lambda_z = -slope;
+
+    // Lambda-z must be positive
+    if lambda_z <= 0.0 {
+        return None;
+    }
+
+    let n = times.len() as f64;
+    let adj_r_squared = 1.0 - (1.0 - r_squared) * (n - 1.0) / (n - 2.0);
+
+    // Predicted concentration at Tlast
+    let clast_pred = (intercept + slope * profile.times[last_idx]).exp();
+
+    Some(LambdaZResult {
+        lambda_z,
+        intercept,
+        r_squared,
+        adj_r_squared,
+        n_points: times.len(),
+        time_first: times[0],
+        time_last: times[times.len() - 1],
+        clast_pred,
+    })
+}
+
+/// Simple linear regression: y = a + b*x
+/// Returns (slope, intercept, r_squared)
+fn linear_regression(x: &[f64], y: &[f64]) -> Option<(f64, f64, f64)> {
+    let n = x.len() as f64;
+    if n < 2.0 {
+        return None;
+    }
+
+    let sum_x: f64 = x.iter().sum();
+    let sum_y: f64 = y.iter().sum();
+    let sum_xy: f64 = x.iter().zip(y.iter()).map(|(xi, yi)| xi * yi).sum();
+    let sum_x2: f64 = x.iter().map(|xi| xi * xi).sum();
+    let sum_y2: f64 = y.iter().map(|yi| yi * yi).sum();
+
+    let denom = n * sum_x2 - sum_x * sum_x;
+    if denom.abs() < 1e-15 {
+        return None;
+    }
+
+    let slope = (n * sum_xy - sum_x * sum_y) / denom;
+    let intercept = (sum_y - slope * sum_x) / n;
+
+    // Calculate R²
+    let ss_tot = sum_y2 - sum_y * sum_y / n;
+    let ss_res: f64 = x
+        .iter()
+        .zip(y.iter())
+        .map(|(xi, yi)| {
+            let pred = intercept + slope * xi;
+            (yi - pred).powi(2)
+        })
+        .sum();
+
+    let r_squared = if ss_tot.abs() < 1e-15 {
+        1.0
+    } else {
+        1.0 - ss_res / ss_tot
+    };
+
+    Some((slope, intercept, r_squared))
+}
+
+// ============================================================================
+// Derived Parameters
+// ============================================================================
+
+/// Calculate terminal half-life
+#[inline]
+pub fn half_life(lambda_z: f64) -> f64 {
+    std::f64::consts::LN_2 / lambda_z
+}
+
+/// Calculate AUC extrapolated to infinity
+#[inline]
+pub fn auc_inf(auc_last: f64, clast: f64, lambda_z: f64) -> f64 {
+    if lambda_z <= 0.0 {
+        return f64::NAN;
+    }
+    auc_last + clast / lambda_z
+}
+
+/// Calculate percentage of AUC extrapolated
+#[inline]
+pub fn auc_extrap_pct(auc_last: f64, auc_inf: f64) -> f64 {
+    if auc_inf <= 0.0 || !auc_inf.is_finite() {
+        return f64::NAN;
+    }
+    (auc_inf - auc_last) / auc_inf * 100.0
+}
+
+/// Calculate AUMC extrapolated to infinity
+pub fn aumc_inf(aumc_last: f64, clast: f64, tlast: f64, lambda_z: f64) -> f64 {
+    if lambda_z <= 0.0 {
+        return f64::NAN;
+    }
+    aumc_last + clast * tlast / lambda_z + clast / (lambda_z * lambda_z)
+}
+
+/// Calculate mean residence time
+#[inline]
+pub fn mrt(aumc_inf: f64, auc_inf: f64) -> f64 {
+    if auc_inf <= 0.0 || !auc_inf.is_finite() {
+        return f64::NAN;
+    }
+    aumc_inf / auc_inf
+}
+
+/// Calculate clearance
+#[inline]
+pub fn clearance(dose: f64, auc_inf: f64) -> f64 {
+    if auc_inf <= 0.0 || !auc_inf.is_finite() {
+        return f64::NAN;
+    }
+    dose / auc_inf
+}
+
+/// Calculate volume of distribution
+#[inline]
+pub fn vz(dose: f64, lambda_z: f64, auc_inf: f64) -> f64 {
+    if lambda_z <= 0.0 || auc_inf <= 0.0 || !auc_inf.is_finite() {
+        return f64::NAN;
+    }
+    dose / (lambda_z * auc_inf)
+}
+
+// ============================================================================
+// Route-Specific Parameters
+// ============================================================================
+
+use super::types::C0Method;
+
+/// Estimate C0 using a cascade of methods (first success wins)
+///
+/// Methods are tried in order. Default cascade: `[Observed, LogSlope, FirstConc]`
+pub fn c0(profile: &Profile, methods: &[C0Method], lambda_z: f64) -> f64 {
+    methods
+        .iter()
+        .filter_map(|m| try_c0_method(profile, *m, lambda_z))
+        .next()
+        .unwrap_or(f64::NAN)
+}
+
+/// Try a single C0 estimation method
+fn try_c0_method(profile: &Profile, method: C0Method, _lambda_z: f64) -> Option<f64> {
+    match method {
+        C0Method::Observed => {
+            // Use concentration at t=0 if present and positive
+            if !profile.times.is_empty() && profile.times[0].abs() < 1e-10 {
+                let c = profile.concentrations[0];
+                if c > 0.0 {
+                    return Some(c);
+                }
+            }
+            None
+        }
+        C0Method::LogSlope => c0_logslope(profile),
+        C0Method::FirstConc => {
+            // Use first positive concentration
+            profile.concentrations.iter().find(|&&c| c > 0.0).copied()
+        }
+        C0Method::Cmin => {
+            // Use minimum positive concentration
+            profile
+                .concentrations
+                .iter()
+                .filter(|&&c| c > 0.0)
+                .min_by(|a, b| a.partial_cmp(b).unwrap())
+                .copied()
+        }
+        C0Method::Zero => Some(0.0),
+    }
+}
+
+/// Semilog back-extrapolation from first two positive points (PKNCA logslope method)
+fn c0_logslope(profile: &Profile) -> Option<f64> {
+    if profile.concentrations.is_empty() {
+        return None;
+    }
+
+    // Find first two positive concentrations
+    let positive_points: Vec<(f64, f64)> = profile
+        .times
+        .iter()
+        .zip(profile.concentrations.iter())
+        .filter(|(_, &c)| c > 0.0)
+        .map(|(&t, &c)| (t, c))
+        .take(2)
+        .collect();
+
+    if positive_points.len() < 2 {
+        return None;
+    }
+
+    let (t1, c1) = positive_points[0];
+    let (t2, c2) = positive_points[1];
+
+    // PKNCA requires c2 < c1 (declining) for logslope
+    if c2 >= c1 || (t2 - t1).abs() < 1e-10 {
+        return None;
+    }
+
+    // Semilog extrapolation: C0 = exp(ln(c1) - slope * t1)
+    let slope = (c2.ln() - c1.ln()) / (t2 - t1);
+    Some((c1.ln() - slope * t1).exp())
+}
+
+/// Legacy C0 back-extrapolation (kept for compatibility)
+#[deprecated(note = "Use c0() with C0Method cascade instead")]
+#[allow(dead_code)]
+pub fn c0_backextrap(profile: &Profile, _lambda_z: f64) -> f64 {
+    c0(
+        profile,
+        &[C0Method::Observed, C0Method::LogSlope, C0Method::FirstConc],
+        _lambda_z,
+    )
+}
+
+/// Calculate Vd for IV bolus
+#[inline]
+pub fn vd_bolus(dose: f64, c0: f64) -> f64 {
+    if c0 <= 0.0 || !c0.is_finite() {
+        return f64::NAN;
+    }
+    dose / c0
+}
+
+/// Calculate Vss for IV administration
+pub fn vss(dose: f64, aumc_inf: f64, auc_inf: f64) -> f64 {
+    if auc_inf <= 0.0 || !auc_inf.is_finite() {
+        return f64::NAN;
+    }
+    dose * aumc_inf / (auc_inf * auc_inf)
+}
+
+/// Calculate MRT corrected for infusion duration
+#[inline]
+pub fn mrt_infusion(mrt: f64, duration: f64) -> f64 {
+    mrt - duration / 2.0
+}
+
+/// Detect lag time for extravascular administration from raw concentration data
+///
+/// This matches PKNCA's approach: tlag is calculated on raw data with BLQ treated as 0,
+/// BEFORE any BLQ filtering is applied to the profile.
+///
+/// Returns the time at which concentration first increases (PKNCA method).
+/// For profiles starting at t=0 with C=0 (or BLQ), this returns 0 if there's
+/// an increase to the next point.
+pub fn tlag_from_raw(
+    times: &[f64],
+    concentrations: &[f64],
+    censoring: &[crate::Censor],
+) -> Option<f64> {
+    if times.len() < 2 || concentrations.len() < 2 {
+        return None;
+    }
+
+    // Convert BLQ to 0, keep other values as-is (matching PKNCA)
+    let concs: Vec<f64> = concentrations
+        .iter()
+        .zip(censoring.iter())
+        .map(|(&c, censor)| {
+            if matches!(censor, crate::Censor::BLOQ) {
+                0.0
+            } else {
+                c
+            }
+        })
+        .collect();
+
+    // Find first time when concentration increases (PKNCA method)
+    for i in 0..concs.len().saturating_sub(1) {
+        if concs[i + 1] > concs[i] {
+            return Some(times[i]);
+        }
+    }
+    // No increase found - either flat or all decreasing
+    None
+}
+
+/// Detect lag time for extravascular administration from processed profile
+///
+/// Returns the time at which concentration first increases (PKNCA method).
+/// This is more appropriate than finding "time before first positive" because
+/// it captures when absorption actually begins, not just when drug is detectable.
+///
+/// For profiles starting at t=0 with C=0, this returns the time point where
+/// C[i+1] > C[i] for the first time.
+#[deprecated(note = "Use tlag_from_raw for PKNCA-compatible tlag calculation")]
+pub fn tlag(profile: &Profile) -> Option<f64> {
+    // Find first time when concentration increases
+    for i in 0..profile.concentrations.len().saturating_sub(1) {
+        if profile.concentrations[i + 1] > profile.concentrations[i] {
+            return Some(profile.times[i]);
+        }
+    }
+    // No increase found - either flat or all decreasing
+    None
+}
+
+// ============================================================================
+// Steady-State Parameters
+// ============================================================================
+
+/// Calculate Cmin from profile
+pub fn cmin(profile: &Profile) -> f64 {
+    profile
+        .concentrations
+        .iter()
+        .copied()
+        .filter(|&c| c > 0.0)
+        .min_by(|a, b| a.partial_cmp(b).unwrap_or(std::cmp::Ordering::Equal))
+        .unwrap_or(0.0)
+}
+
+/// Calculate average concentration
+#[inline]
+pub fn cavg(auc_tau: f64, tau: f64) -> f64 {
+    if tau <= 0.0 {
+        return f64::NAN;
+    }
+    auc_tau / tau
+}
+
+/// Calculate fluctuation percentage
+pub fn fluctuation(cmax: f64, cmin: f64, cavg: f64) -> f64 {
+    if cavg <= 0.0 {
+        return f64::NAN;
+    }
+    (cmax - cmin) / cavg * 100.0
+}
+
+/// Calculate swing
+pub fn swing(cmax: f64, cmin: f64) -> f64 {
+    if cmin <= 0.0 {
+        return f64::NAN;
+    }
+    (cmax - cmin) / cmin
+}
+
+/// Calculate accumulation ratio
+#[inline]
+#[allow(dead_code)] // Reserved for future steady-state analysis
+pub fn accumulation(auc_tau: f64, auc_inf_single: f64) -> f64 {
+    if auc_inf_single <= 0.0 || !auc_inf_single.is_finite() {
+        return f64::NAN;
+    }
+    auc_tau / auc_inf_single
+}
+
+// ============================================================================
+// Tests
+// ============================================================================
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::Censor;
+
+    fn make_test_profile() -> Profile {
+        let censoring = vec![Censor::None; 6];
+        Profile::from_arrays(
+            &[0.0, 1.0, 2.0, 4.0, 8.0, 12.0],
+            &[0.0, 10.0, 8.0, 4.0, 2.0, 1.0],
+            &censoring,
+            super::super::types::BLQRule::Exclude,
+        )
+        .unwrap()
+    }
+
+    #[test]
+    fn test_auc_segment_linear() {
+        let auc = auc_segment(0.0, 10.0, 1.0, 8.0, AUCMethod::Linear);
+        assert!((auc - 9.0).abs() < 1e-10); // (10 + 8) / 2 * 1
+    }
+
+    #[test]
+    fn test_auc_segment_log_down() {
+        // Descending - should use log-linear
+        let auc = auc_segment(0.0, 10.0, 1.0, 5.0, AUCMethod::LinUpLogDown);
+        let expected = 5.0 / (10.0_f64 / 5.0).ln(); // (C1-C2) * dt / ln(C1/C2)
+        assert!((auc - expected).abs() < 1e-10);
+    }
+
+    #[test]
+    fn test_auc_last() {
+        let profile = make_test_profile();
+        let auc = auc_last(&profile, AUCMethod::Linear);
+
+        // Manual calculation:
+        // 0-1: (0 + 10) / 2 * 1 = 5
+        // 1-2: (10 + 8) / 2 * 1 = 9
+        // 2-4: (8 + 4) / 2 * 2 = 12
+        // 4-8: (4 + 2) / 2 * 4 = 12
+        // 8-12: (2 + 1) / 2 * 4 = 6
+        // Total = 44
+        assert!((auc - 44.0).abs() < 1e-10);
+    }
+
+    #[test]
+    fn test_half_life() {
+        let hl = half_life(0.1);
+        assert!((hl - 6.931).abs() < 0.01); // ln(2) / 0.1 ≈ 6.931
+    }
+
+    #[test]
+    fn test_clearance() {
+        let cl = clearance(100.0, 50.0);
+        assert!((cl - 2.0).abs() < 1e-10);
+    }
+
+    #[test]
+    fn test_vz() {
+        let v = vz(100.0, 0.1, 50.0);
+        assert!((v - 20.0).abs() < 1e-10); // 100 / (0.1 * 50) = 20
+    }
+
+    #[test]
+    fn test_linear_regression() {
+        let x = vec![1.0, 2.0, 3.0, 4.0, 5.0];
+        let y = vec![2.0, 4.0, 6.0, 8.0, 10.0]; // Perfect line: y = 2x
+
+        let (slope, intercept, r_squared) = linear_regression(&x, &y).unwrap();
+        assert!((slope - 2.0).abs() < 1e-10);
+        assert!(intercept.abs() < 1e-10);
+        assert!((r_squared - 1.0).abs() < 1e-10);
+    }
+
+    #[test]
+    fn test_fluctuation() {
+        let fluct = fluctuation(10.0, 2.0, 5.0);
+        assert!((fluct - 160.0).abs() < 1e-10); // (10-2)/5 * 100 = 160%
+    }
+
+    #[test]
+    fn test_swing() {
+        let s = swing(10.0, 2.0);
+        assert!((s - 4.0).abs() < 1e-10); // (10-2)/2 = 4
+    }
+}
diff --git a/src/nca/error.rs b/src/nca/error.rs
new file mode 100644
index 00000000..52a8b081
--- /dev/null
+++ b/src/nca/error.rs
@@ -0,0 +1,39 @@
+//! NCA error types
+
+use thiserror::Error;
+
+/// Errors that can occur during NCA analysis
+#[derive(Error, Debug, Clone)]
+pub enum NCAError {
+    /// No observations found for the specified output equation
+    #[error("No observations found for outeq {outeq}")]
+    NoObservations { outeq: usize },
+
+    /// Insufficient data points for analysis
+    #[error("Insufficient data: {n} points, need at least {required}")]
+    InsufficientData { n: usize, required: usize },
+
+    /// Occasion not found
+    #[error("Occasion {index} not found")]
+    OccasionNotFound { index: usize },
+
+    /// Subject not found
+    #[error("Subject '{id}' not found")]
+    SubjectNotFound { id: String },
+
+    /// All concentrations are zero or BLQ
+    #[error("All concentrations are zero or below LOQ")]
+    AllBLQ,
+
+    /// Lambda-z estimation failed
+    #[error("Lambda-z estimation failed: {reason}")]
+    LambdaZFailed { reason: String },
+
+    /// Invalid time sequence
+    #[error("Invalid time sequence: times must be monotonically increasing")]
+    InvalidTimeSequence,
+
+    /// Invalid parameter value
+    #[error("Invalid parameter: {param} = {value}")]
+    InvalidParameter { param: String, value: String },
+}
diff --git a/src/nca/mod.rs b/src/nca/mod.rs
new file mode 100644
index 00000000..d2ee32fa
--- /dev/null
+++ b/src/nca/mod.rs
@@ -0,0 +1,89 @@
+//! Non-Compartmental Analysis (NCA) for pharmacokinetic data
+//!
+//! This module provides a clean, powerful API for calculating standard NCA parameters
+//! from concentration-time data. It integrates seamlessly with pharmsol's data structures
+//! ([`crate::Subject`], [`crate::Occasion`]).
+//!
+//! # Design Philosophy
+//!
+//! - **Simple**: Single entry point via `.nca()` method on data structures
+//! - **Powerful**: Full support for all standard NCA parameters
+//! - **Data-aware**: Doses and routes are auto-detected from the data
+//! - **Configurable**: Analysis options via [`NCAOptions`]
+//!
+//! # Key Parameters
+//!
+//! | Parameter | Description |
+//! |-----------|-------------|
+//! | Cmax | Maximum observed concentration |
+//! | Tmax | Time of maximum concentration |
+//! | Clast | Last measurable concentration (> 0) |
+//! | Tlast | Time of last measurable concentration |
+//! | AUClast | Area under curve from 0 to Tlast |
+//! | AUCinf | AUC extrapolated to infinity |
+//! | λz | Terminal elimination rate constant |
+//! | t½ | Terminal half-life (ln(2)/λz) |
+//! | CL/F | Apparent clearance |
+//! | Vz/F | Apparent volume of distribution |
+//! | MRT | Mean residence time |
+//!
+//! # Usage
+//!
+//! NCA is performed by calling `.nca()` on a `Subject`. Dose and route
+//! information are automatically detected from the dose events in the data.
+//!
+//! ```rust,ignore
+//! use pharmsol::prelude::*;
+//! use pharmsol::nca::NCAOptions;
+//!
+//! // Build subject with dose and observation events
+//! let subject = Subject::builder("patient_001")
+//!     .bolus(0.0, 100.0, 0)  // 100 mg oral dose
+//!     .observation(1.0, 10.0, 0)
+//!     .observation(2.0, 8.0, 0)
+//!     .observation(4.0, 4.0, 0)
+//!     .build();
+//!
+//! // Perform NCA with default options
+//! let results = subject.nca(&NCAOptions::default(), 0);
+//! let result = results[0].as_ref().expect("NCA failed");
+//!
+//! println!("Cmax: {:.2}", result.exposure.cmax);
+//! println!("AUClast: {:.2}", result.exposure.auc_last);
+//! ```
+//!
+//! # Steady-State Analysis
+//!
+//! ```rust,ignore
+//! use pharmsol::nca::NCAOptions;
+//!
+//! // Configure for steady-state with 12h dosing interval
+//! let options = NCAOptions::default().with_tau(12.0);
+//! let results = subject.nca(&options, 0);
+//!
+//! if let Some(ref ss) = results[0].as_ref().unwrap().steady_state {
+//!     println!("Cavg: {:.2}", ss.cavg);
+//!     println!("Fluctuation: {:.1}%", ss.fluctuation);
+//! }
+//! ```
+
+// Internal modules
+mod analyze;
+mod calc;
+mod error;
+mod profile;
+mod types;
+
+#[cfg(test)]
+mod tests;
+
+// Crate-internal re-exports (for data/structs.rs)
+pub(crate) use analyze::{analyze_arrays, DoseContext};
+
+// Public API
+pub use error::NCAError;
+pub use types::{
+    AUCMethod, BLQRule, C0Method, ClastType, ClearanceParams, ExposureParams, IVBolusParams,
+    IVInfusionParams, LambdaZMethod, LambdaZOptions, NCAOptions, NCAResult, Quality,
+    RegressionStats, Route, SteadyStateParams, TerminalParams, Warning,
+};
diff --git a/src/nca/profile.rs b/src/nca/profile.rs
new file mode 100644
index 00000000..161f8969
--- /dev/null
+++ b/src/nca/profile.rs
@@ -0,0 +1,389 @@
+//! Internal profile representation for NCA analysis
+//!
+//! The Profile struct is a validated, analysis-ready concentration-time dataset.
+//! It handles BLQ processing and caches key indices for efficiency.
+
+use super::error::NCAError;
+use super::types::BLQRule;
+use crate::Censor;
+
+/// A validated concentration-time profile ready for NCA analysis
+///
+/// This is an internal structure that normalizes data from various sources
+/// (raw arrays, Occasion) into a consistent format with BLQ handling applied.
+#[derive(Debug, Clone)]
+pub(crate) struct Profile {
+    /// Time points (sorted, ascending)
+    pub times: Vec<f64>,
+    /// Concentration values (parallel to times)
+    pub concentrations: Vec<f64>,
+    /// Index of Cmax in the arrays
+    pub cmax_idx: usize,
+    /// Index of Clast (last positive concentration)
+    pub tlast_idx: usize,
+}
+
+impl Profile {
+    /// Create a profile from time/concentration/censoring arrays
+    ///
+    /// BLQ/ALQ status is determined by the `Censor` marking:
+    /// - `Censor::BLOQ`: Below limit of quantification - value is the lower limit
+    /// - `Censor::ALOQ`: Above limit of quantification - value is the upper limit
+    /// - `Censor::None`: Quantifiable observation - value is the measured concentration
+    ///
+    /// # Arguments
+    /// * `times` - Time points
+    /// * `concentrations` - Concentration values (for censored samples, this is the LOQ/ULQ)
+    /// * `censoring` - Censoring status for each observation
+    /// * `blq_rule` - How to handle BLQ values
+    ///
+    /// # Errors
+    /// Returns error if data is insufficient or invalid
+    pub fn from_arrays(
+        times: &[f64],
+        concentrations: &[f64],
+        censoring: &[Censor],
+        blq_rule: BLQRule,
+    ) -> Result<Self, NCAError> {
+        if times.len() != concentrations.len() || times.len() != censoring.len() {
+            return Err(NCAError::InvalidParameter {
+                param: "arrays".to_string(),
+                value: format!(
+                    "array lengths mismatch: times={}, concentrations={}, censoring={}",
+                    times.len(),
+                    concentrations.len(),
+                    censoring.len()
+                ),
+            });
+        }
+
+        if times.is_empty() {
+            return Err(NCAError::InsufficientData { n: 0, required: 2 });
+        }
+
+        // Check time sequence is valid
+        for i in 1..times.len() {
+            if times[i] < times[i - 1] {
+                return Err(NCAError::InvalidTimeSequence);
+            }
+        }
+
+        // For Positional rule, we need tfirst and tlast first
+        // For TmaxRelative, we need tmax
+        // Do a preliminary pass to find these indices
+        let (tfirst_idx, tlast_idx) = if matches!(blq_rule, BLQRule::Positional) {
+            Self::find_tfirst_tlast(concentrations, censoring)
+        } else {
+            (None, None)
+        };
+
+        let tmax_idx = if matches!(blq_rule, BLQRule::TmaxRelative { .. }) {
+            Self::find_tmax_idx(concentrations, censoring)
+        } else {
+            None
+        };
+
+        let mut proc_times = Vec::with_capacity(times.len());
+        let mut proc_concs = Vec::with_capacity(concentrations.len());
+
+        for i in 0..times.len() {
+            let time = times[i];
+            let conc = concentrations[i];
+            let censor = censoring[i];
+
+            // BLQ is determined by the Censor marking
+            // Note: ALOQ values are kept unchanged (follows PKNCA behavior)
+            let is_blq = matches!(censor, Censor::BLOQ);
+
+            if is_blq {
+                // When censored, `conc` is the LOQ threshold
+                match blq_rule {
+                    BLQRule::Zero => {
+                        proc_times.push(time);
+                        proc_concs.push(0.0);
+                    }
+                    BLQRule::LoqOver2 => {
+                        proc_times.push(time);
+                        proc_concs.push(conc / 2.0); // conc IS the LOQ
+                    }
+                    BLQRule::Exclude => {
+                        // Skip this point
+                    }
+                    BLQRule::Positional => {
+                        // Position-aware handling: first=keep, middle=drop, last=keep
+                        // PKNCA "keep" means keep as 0, not as LOQ
+                        let action = Self::get_positional_action(i, tfirst_idx, tlast_idx);
+                        match action {
+                            super::types::BlqAction::Keep => {
+                                // Keep as 0 (PKNCA "keep" behavior preserves the zero)
+                                proc_times.push(time);
+                                proc_concs.push(0.0);
+                            }
+                            super::types::BlqAction::Drop => {
+                                // Skip middle BLQ points
+                            }
+                        }
+                    }
+                    BLQRule::TmaxRelative {
+                        before_tmax_keep,
+                        after_tmax_keep,
+                    } => {
+                        // Tmax-relative handling
+                        let is_before_tmax = tmax_idx.map(|t| i < t).unwrap_or(true);
+                        let keep = if is_before_tmax {
+                            before_tmax_keep
+                        } else {
+                            after_tmax_keep
+                        };
+                        if keep {
+                            proc_times.push(time);
+                            proc_concs.push(0.0);
+                        }
+                        // else: drop the point
+                    }
+                }
+            } else {
+                proc_times.push(time);
+                proc_concs.push(conc);
+            }
+        }
+
+        Self::finalize(proc_times, proc_concs)
+    }
+
+    /// Find tfirst and tlast indices for positional BLQ handling
+    ///
+    /// tfirst = index of first positive (non-BLQ) concentration
+    /// tlast = index of last positive (non-BLQ) concentration
+    fn find_tfirst_tlast(
+        concentrations: &[f64],
+        censoring: &[Censor],
+    ) -> (Option<usize>, Option<usize>) {
+        let mut tfirst_idx = None;
+        let mut tlast_idx = None;
+
+        for i in 0..concentrations.len() {
+            let is_blq = matches!(censoring[i], Censor::BLOQ);
+            if !is_blq && concentrations[i] > 0.0 {
+                if tfirst_idx.is_none() {
+                    tfirst_idx = Some(i);
+                }
+                tlast_idx = Some(i);
+            }
+        }
+
+        (tfirst_idx, tlast_idx)
+    }
+
+    /// Find index of Tmax (first maximum concentration) among non-BLQ points
+    fn find_tmax_idx(concentrations: &[f64], censoring: &[Censor]) -> Option<usize> {
+        let mut max_conc = f64::NEG_INFINITY;
+        let mut tmax_idx = None;
+
+        for i in 0..concentrations.len() {
+            let is_blq = matches!(censoring[i], Censor::BLOQ);
+            if !is_blq && concentrations[i] > max_conc {
+                max_conc = concentrations[i];
+                tmax_idx = Some(i);
+            }
+        }
+
+        tmax_idx
+    }
+
+    /// Determine action for a BLQ observation based on its position
+    ///
+    /// PKNCA default: first=keep, middle=drop, last=keep
+    fn get_positional_action(
+        idx: usize,
+        tfirst_idx: Option<usize>,
+        tlast_idx: Option<usize>,
+    ) -> super::types::BlqAction {
+        match (tfirst_idx, tlast_idx) {
+            (Some(tfirst), Some(tlast)) => {
+                if idx <= tfirst {
+                    // First position (at or before tfirst): keep
+                    super::types::BlqAction::Keep
+                } else if idx >= tlast {
+                    // Last position (at or after tlast): keep
+                    super::types::BlqAction::Keep
+                } else {
+                    // Middle position: drop
+                    super::types::BlqAction::Drop
+                }
+            }
+            _ => {
+                // No positive concentrations found - keep everything
+                super::types::BlqAction::Keep
+            }
+        }
+    }
+
+    /// Finalize profile construction by finding Cmax/Tlast indices
+    fn finalize(proc_times: Vec<f64>, proc_concs: Vec<f64>) -> Result<Self, NCAError> {
+        if proc_times.len() < 2 {
+            return Err(NCAError::InsufficientData {
+                n: proc_times.len(),
+                required: 2,
+            });
+        }
+
+        // Find Cmax index (first occurrence in case of ties, matching PKNCA)
+        let cmax_idx = proc_concs
+            .iter()
+            .enumerate()
+            .fold((0, f64::NEG_INFINITY), |(max_i, max_c), (i, &c)| {
+                if c > max_c {
+                    (i, c)
+                } else {
+                    (max_i, max_c)
+                }
+            })
+            .0;
+
+        // Find Tlast index (last positive concentration)
+        let tlast_idx = proc_concs
+            .iter()
+            .rposition(|&c| c > 0.0)
+            .unwrap_or(proc_concs.len() - 1);
+
+        // Check if all values are zero
+        if proc_concs.iter().all(|&c| c <= 0.0) {
+            return Err(NCAError::AllBLQ);
+        }
+
+        Ok(Self {
+            times: proc_times,
+            concentrations: proc_concs,
+            cmax_idx,
+            tlast_idx,
+        })
+    }
+
+    /// Get Cmax value
+    #[inline]
+    pub fn cmax(&self) -> f64 {
+        self.concentrations[self.cmax_idx]
+    }
+
+    /// Get Tmax value
+    #[inline]
+    pub fn tmax(&self) -> f64 {
+        self.times[self.cmax_idx]
+    }
+
+    /// Get Clast value
+    #[inline]
+    pub fn clast(&self) -> f64 {
+        self.concentrations[self.tlast_idx]
+    }
+
+    /// Get Tlast value
+    #[inline]
+    pub fn tlast(&self) -> f64 {
+        self.times[self.tlast_idx]
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_profile_from_arrays() {
+        let times = vec![0.0, 1.0, 2.0, 4.0, 8.0];
+        let concs = vec![0.0, 10.0, 8.0, 4.0, 2.0];
+        let censoring = vec![Censor::None; 5];
+
+        let profile = Profile::from_arrays(&times, &concs, &censoring, BLQRule::Exclude).unwrap();
+
+        assert_eq!(profile.times.len(), 5);
+        assert_eq!(profile.cmax(), 10.0);
+        assert_eq!(profile.tmax(), 1.0);
+        assert_eq!(profile.clast(), 2.0);
+        assert_eq!(profile.tlast(), 8.0);
+    }
+
+    #[test]
+    fn test_profile_blq_handling() {
+        let times = vec![0.0, 1.0, 2.0, 4.0, 8.0];
+        // First and last are BLOQ with LOQ = 0.1
+        let concs = vec![0.1, 10.0, 8.0, 4.0, 0.1];
+        let censoring = vec![
+            Censor::BLOQ,
+            Censor::None,
+            Censor::None,
+            Censor::None,
+            Censor::BLOQ,
+        ];
+
+        // Exclude BLQ
+        let profile = Profile::from_arrays(&times, &concs, &censoring, BLQRule::Exclude).unwrap();
+        assert_eq!(profile.times.len(), 3); // Only 3 points not BLQ
+
+        // Zero substitution
+        let profile = Profile::from_arrays(&times, &concs, &censoring, BLQRule::Zero).unwrap();
+        assert_eq!(profile.times.len(), 5);
+        assert_eq!(profile.concentrations[0], 0.0);
+        assert_eq!(profile.concentrations[4], 0.0);
+
+        // LOQ/2 substitution (conc value IS the LOQ when censored)
+        let profile = Profile::from_arrays(&times, &concs, &censoring, BLQRule::LoqOver2).unwrap();
+        assert_eq!(profile.times.len(), 5);
+        assert_eq!(profile.concentrations[0], 0.05); // 0.1 / 2
+        assert_eq!(profile.concentrations[4], 0.05);
+    }
+
+    #[test]
+    fn test_profile_insufficient_data() {
+        let times = vec![0.0];
+        let concs = vec![10.0];
+        let censoring = vec![Censor::None];
+
+        let result = Profile::from_arrays(&times, &concs, &censoring, BLQRule::Exclude);
+        assert!(result.is_err());
+    }
+
+    #[test]
+    fn test_profile_all_blq() {
+        let times = vec![0.0, 1.0, 2.0];
+        let concs = vec![0.1, 0.1, 0.1]; // All are LOQ values
+        let censoring = vec![Censor::BLOQ, Censor::BLOQ, Censor::BLOQ];
+
+        let result = Profile::from_arrays(&times, &concs, &censoring, BLQRule::Exclude);
+        assert!(matches!(result, Err(NCAError::InsufficientData { .. })));
+    }
+
+    #[test]
+    fn test_profile_positional_blq() {
+        // Profile with BLQ at first, middle, and last positions
+        let times = vec![0.0, 1.0, 2.0, 4.0, 8.0, 12.0];
+        let concs = vec![0.1, 10.0, 0.1, 4.0, 2.0, 0.1]; // LOQ = 0.1
+        let censoring = vec![
+            Censor::BLOQ, // first - should keep
+            Censor::None, // quantifiable
+            Censor::BLOQ, // middle - should drop
+            Censor::None, // quantifiable
+            Censor::None, // quantifiable (tlast)
+            Censor::BLOQ, // last - should keep
+        ];
+
+        // Positional BLQ handling: first=keep(0), middle=drop, last=keep(0)
+        let profile =
+            Profile::from_arrays(&times, &concs, &censoring, BLQRule::Positional).unwrap();
+
+        // Should have 5 points: first BLQ (kept as 0), 3 quantifiable, last BLQ (kept as 0)
+        // Middle BLQ at t=2 should be dropped
+        assert_eq!(profile.times.len(), 5);
+        assert_eq!(profile.times[0], 0.0); // First BLQ kept
+        assert_eq!(profile.times[1], 1.0); // Quantifiable
+        assert_eq!(profile.times[2], 4.0); // Middle BLQ dropped, this is the next
+        assert_eq!(profile.times[3], 8.0); // Quantifiable
+        assert_eq!(profile.times[4], 12.0); // Last BLQ kept
+
+        // First BLQ should be kept as 0 (PKNCA behavior, not LOQ)
+        assert_eq!(profile.concentrations[0], 0.0);
+        // Last BLQ should be kept as 0 (PKNCA behavior, not LOQ)
+        assert_eq!(profile.concentrations[4], 0.0);
+    }
+}
diff --git a/src/nca/tests.rs b/src/nca/tests.rs
new file mode 100644
index 00000000..68fcc173
--- /dev/null
+++ b/src/nca/tests.rs
@@ -0,0 +1,578 @@
+//! Comprehensive tests for NCA module
+//!
+//! Tests cover all major NCA parameters and edge cases.
+//! All tests use Subject::builder() as the single entry point.
+
+use crate::data::Subject;
+use crate::nca::*;
+use crate::SubjectBuilderExt;
+
+// ============================================================================
+// Test subject builders
+// ============================================================================
+
+/// Create a typical single-dose oral PK subject
+fn single_dose_oral() -> Subject {
+    Subject::builder("test")
+        .bolus(0.0, 100.0, 0) // 100 mg to depot (extravascular)
+        .observation(0.0, 0.0, 0)
+        .observation(0.5, 5.0, 0)
+        .observation(1.0, 10.0, 0)
+        .observation(2.0, 8.0, 0)
+        .observation(4.0, 4.0, 0)
+        .observation(8.0, 2.0, 0)
+        .observation(12.0, 1.0, 0)
+        .observation(24.0, 0.25, 0)
+        .build()
+}
+
+/// Create an IV bolus subject (high C0, dose to central)
+fn iv_bolus_subject() -> Subject {
+    Subject::builder("test")
+        .bolus(0.0, 500.0, 1) // 500 mg to central (IV)
+        .observation(0.0, 100.0, 0)
+        .observation(0.25, 75.0, 0)
+        .observation(0.5, 56.0, 0)
+        .observation(1.0, 32.0, 0)
+        .observation(2.0, 10.0, 0)
+        .observation(4.0, 3.0, 0)
+        .observation(8.0, 0.9, 0)
+        .observation(12.0, 0.3, 0)
+        .build()
+}
+
+/// Create an IV infusion subject
+fn iv_infusion_subject() -> Subject {
+    Subject::builder("test")
+        .infusion(0.0, 100.0, 1, 0.5) // 100 mg over 0.5h to central
+        .observation(0.0, 0.0, 0)
+        .observation(0.5, 5.0, 0)
+        .observation(1.0, 10.0, 0)
+        .observation(2.0, 8.0, 0)
+        .observation(4.0, 4.0, 0)
+        .observation(8.0, 2.0, 0)
+        .observation(12.0, 1.0, 0)
+        .observation(24.0, 0.25, 0)
+        .build()
+}
+
+/// Create a steady-state profile subject
+fn steady_state_subject() -> Subject {
+    Subject::builder("test")
+        .bolus(0.0, 100.0, 0) // 100 mg oral
+        .observation(0.0, 5.0, 0)
+        .observation(1.0, 15.0, 0)
+        .observation(2.0, 12.0, 0)
+        .observation(4.0, 8.0, 0)
+        .observation(6.0, 6.0, 0)
+        .observation(8.0, 5.5, 0)
+        .observation(12.0, 5.0, 0)
+        .build()
+}
+
+/// Create a subject with BLQ values
+fn blq_subject() -> Subject {
+    use crate::Censor;
+
+    Subject::builder("test")
+        .bolus(0.0, 100.0, 0)
+        .observation(0.0, 0.0, 0)
+        .observation(1.0, 10.0, 0)
+        .observation(2.0, 8.0, 0)
+        .observation(4.0, 4.0, 0)
+        .observation(8.0, 2.0, 0)
+        .observation(12.0, 0.5, 0)
+        .censored_observation(24.0, 0.1, 0, Censor::BLOQ) // BLQ with LOQ=0.1
+        .build()
+}
+
+/// Create a minimal subject (no dose)
+fn no_dose_subject() -> Subject {
+    Subject::builder("test")
+        .observation(0.0, 0.0, 0)
+        .observation(1.0, 10.0, 0)
+        .observation(2.0, 8.0, 0)
+        .observation(4.0, 4.0, 0)
+        .build()
+}
+
+// ============================================================================
+// Basic NCA parameter tests
+// ============================================================================
+
+#[test]
+fn test_nca_basic_exposure() {
+    let subject = single_dose_oral();
+    let options = NCAOptions::default();
+    let results = subject.nca(&options, 0);
+    let result = results[0].as_ref().unwrap();
+
+    // Check Cmax/Tmax
+    assert_eq!(result.exposure.cmax, 10.0, "Cmax should be 10.0");
+    assert_eq!(result.exposure.tmax, 1.0, "Tmax should be 1.0");
+
+    // Check Clast/Tlast
+    assert_eq!(result.exposure.clast, 0.25, "Clast should be 0.25");
+    assert_eq!(result.exposure.tlast, 24.0, "Tlast should be 24.0");
+
+    // AUClast should be positive
+    assert!(result.exposure.auc_last > 0.0, "AUClast should be positive");
+}
+
+#[test]
+fn test_nca_with_dose() {
+    let subject = single_dose_oral();
+    let options = NCAOptions::default();
+    let results = subject.nca(&options, 0);
+    let result = results[0].as_ref().unwrap();
+
+    // Should have clearance parameters if lambda-z was estimated
+    if let Some(ref cl) = result.clearance {
+        assert!(cl.cl_f > 0.0, "CL/F should be positive");
+        assert!(cl.vz_f > 0.0, "Vz/F should be positive");
+    }
+}
+
+#[test]
+fn test_nca_without_dose() {
+    let subject = no_dose_subject();
+    let options = NCAOptions::default();
+    let results = subject.nca(&options, 0);
+    let result = results[0].as_ref().unwrap();
+
+    // Exposure should still be computed
+    assert!(result.exposure.cmax > 0.0);
+    // But clearance should be None (no dose)
+    assert!(result.clearance.is_none());
+}
+
+#[test]
+fn test_nca_terminal_phase() {
+    let subject = single_dose_oral();
+    let options = NCAOptions::default();
+    let results = subject.nca(&options, 0);
+    let result = results[0].as_ref().unwrap();
+
+    // Check terminal phase was estimated
+    assert!(
+        result.terminal.is_some(),
+        "Terminal phase should be estimated"
+    );
+
+    if let Some(ref term) = result.terminal {
+        assert!(term.lambda_z > 0.0, "Lambda-z should be positive");
+        assert!(term.half_life > 0.0, "Half-life should be positive");
+
+        // Half-life relationship
+        let expected_hl = std::f64::consts::LN_2 / term.lambda_z;
+        assert!(
+            (term.half_life - expected_hl).abs() < 1e-10,
+            "Half-life = ln(2)/lambda_z"
+        );
+    }
+}
+
+// ============================================================================
+// AUC calculation tests
+// ============================================================================
+
+#[test]
+fn test_auc_linear_method() {
+    let subject = single_dose_oral();
+    let options = NCAOptions::default().with_auc_method(AUCMethod::Linear);
+    let results = subject.nca(&options, 0);
+    let result = results[0].as_ref().unwrap();
+
+    assert!(result.exposure.auc_last > 0.0);
+}
+
+#[test]
+fn test_auc_linuplogdown_method() {
+    let subject = single_dose_oral();
+    let options = NCAOptions::default().with_auc_method(AUCMethod::LinUpLogDown);
+    let results = subject.nca(&options, 0);
+    let result = results[0].as_ref().unwrap();
+
+    assert!(result.exposure.auc_last > 0.0);
+}
+
+#[test]
+fn test_auc_methods_differ() {
+    let subject = single_dose_oral();
+
+    let linear = NCAOptions::default().with_auc_method(AUCMethod::Linear);
+    let logdown = NCAOptions::default().with_auc_method(AUCMethod::LinUpLogDown);
+
+    let result_linear = subject.nca(&linear, 0)[0]
+        .as_ref()
+        .unwrap()
+        .exposure
+        .auc_last;
+    let result_logdown = subject.nca(&logdown, 0)[0]
+        .as_ref()
+        .unwrap()
+        .exposure
+        .auc_last;
+
+    // Methods should give slightly different results
+    assert!(
+        result_linear != result_logdown,
+        "Different AUC methods should give different results"
+    );
+}
+
+// ============================================================================
+// Route-specific tests
+// ============================================================================
+
+#[test]
+fn test_iv_bolus_route() {
+    let subject = iv_bolus_subject();
+    let options = NCAOptions::default();
+    let results = subject.nca(&options, 0);
+    let result = results[0].as_ref().unwrap();
+
+    // Should have IV bolus parameters
+    assert!(
+        result.iv_bolus.is_some(),
+        "IV bolus parameters should be present"
+    );
+
+    if let Some(ref bolus) = result.iv_bolus {
+        assert!(bolus.c0 > 0.0, "C0 should be positive");
+        assert!(bolus.vd > 0.0, "Vd should be positive");
+    }
+
+    // Should not have infusion params
+    assert!(result.iv_infusion.is_none());
+}
+
+#[test]
+fn test_iv_infusion_route() {
+    let subject = iv_infusion_subject();
+    let options = NCAOptions::default();
+    let results = subject.nca(&options, 0);
+    let result = results[0].as_ref().unwrap();
+
+    // Should have IV infusion parameters
+    assert!(
+        result.iv_infusion.is_some(),
+        "IV infusion parameters should be present"
+    );
+
+    if let Some(ref infusion) = result.iv_infusion {
+        assert_eq!(
+            infusion.infusion_duration, 0.5,
+            "Infusion duration should be 0.5"
+        );
+    }
+}
+
+#[test]
+fn test_extravascular_route() {
+    let subject = single_dose_oral();
+    let options = NCAOptions::default();
+    let results = subject.nca(&options, 0);
+    let result = results[0].as_ref().unwrap();
+
+    // Tlag should be in exposure params (may be None if no lag detected)
+    // For extravascular, should not have IV-specific params
+    assert!(result.iv_bolus.is_none());
+    assert!(result.iv_infusion.is_none());
+}
+
+// ============================================================================
+// Steady-state tests
+// ============================================================================
+
+#[test]
+fn test_steady_state_parameters() {
+    let subject = steady_state_subject();
+    let options = NCAOptions::default().with_tau(12.0);
+    let results = subject.nca(&options, 0);
+    let result = results[0].as_ref().unwrap();
+
+    // Should have steady-state parameters
+    assert!(
+        result.steady_state.is_some(),
+        "Steady-state parameters should be present"
+    );
+
+    if let Some(ref ss) = result.steady_state {
+        assert_eq!(ss.tau, 12.0, "Tau should be 12.0");
+        assert!(ss.auc_tau > 0.0, "AUCtau should be positive");
+        assert!(ss.cmin > 0.0, "Cmin should be positive");
+        assert!(ss.cavg > 0.0, "Cavg should be positive");
+        assert!(ss.fluctuation > 0.0, "Fluctuation should be positive");
+    }
+}
+
+// ============================================================================
+// BLQ handling tests
+// ============================================================================
+
+#[test]
+fn test_blq_exclude() {
+    let subject = blq_subject();
+    let options = NCAOptions::default().with_blq_rule(BLQRule::Exclude);
+    let results = subject.nca(&options, 0);
+    let result = results[0].as_ref().unwrap();
+
+    // Tlast should be at t=12 (last non-BLQ point)
+    assert_eq!(result.exposure.tlast, 12.0, "Tlast should exclude BLQ");
+}
+
+#[test]
+fn test_blq_zero() {
+    let subject = blq_subject();
+    let options = NCAOptions::default().with_blq_rule(BLQRule::Zero);
+    let results = subject.nca(&options, 0);
+    let result = results[0].as_ref().unwrap();
+
+    // Should include the BLQ points as zeros
+    assert!(result.exposure.auc_last > 0.0);
+}
+
+#[test]
+fn test_blq_loq_over_2() {
+    let subject = blq_subject();
+    let options = NCAOptions::default().with_blq_rule(BLQRule::LoqOver2);
+    let results = subject.nca(&options, 0);
+    let result = results[0].as_ref().unwrap();
+
+    // Should include the BLQ points as LOQ/2 (0.1 / 2 = 0.05)
+    assert!(result.exposure.auc_last > 0.0);
+}
+
+// ============================================================================
+// Lambda-z estimation tests
+// ============================================================================
+
+#[test]
+fn test_lambda_z_auto_selection() {
+    let subject = single_dose_oral();
+    let options = NCAOptions::default().with_lambda_z(LambdaZOptions {
+        method: LambdaZMethod::AdjR2,
+        ..Default::default()
+    });
+    let results = subject.nca(&options, 0);
+    let result = results[0].as_ref().unwrap();
+
+    // Should have terminal phase
+    assert!(result.terminal.is_some());
+
+    if let Some(ref term) = result.terminal {
+        assert!(term.regression.is_some());
+        if let Some(ref reg) = term.regression {
+            assert!(reg.r_squared > 0.9, "R² should be high for good fit");
+            assert!(reg.n_points >= 3, "Should use at least 3 points");
+        }
+    }
+}
+
+#[test]
+fn test_lambda_z_manual_points() {
+    let subject = single_dose_oral();
+    let options = NCAOptions::default().with_lambda_z(LambdaZOptions {
+        method: LambdaZMethod::Manual(4),
+        ..Default::default()
+    });
+    let results = subject.nca(&options, 0);
+    let result = results[0].as_ref().unwrap();
+
+    if let Some(ref term) = result.terminal {
+        if let Some(ref reg) = term.regression {
+            assert_eq!(reg.n_points, 4, "Should use exactly 4 points");
+        }
+    }
+}
+
+// ============================================================================
+// Edge case tests
+// ============================================================================
+
+#[test]
+fn test_insufficient_observations() {
+    let subject = Subject::builder("test")
+        .bolus(0.0, 100.0, 0)
+        .observation(1.0, 10.0, 0)
+        .build();
+
+    let results = subject.nca(&NCAOptions::default(), 0);
+    // Should fail with insufficient data
+    assert!(
+        results[0].is_err(),
+        "Single observation should return error"
+    );
+}
+
+#[test]
+fn test_all_zero_concentrations() {
+    let subject = Subject::builder("test")
+        .bolus(0.0, 100.0, 0)
+        .observation(0.0, 0.0, 0)
+        .observation(1.0, 0.0, 0)
+        .observation(2.0, 0.0, 0)
+        .observation(4.0, 0.0, 0)
+        .build();
+
+    let results = subject.nca(&NCAOptions::default(), 0);
+    assert!(results[0].is_err(), "All zero concentrations should fail");
+}
+
+// ============================================================================
+// Quality/Warning tests
+// ============================================================================
+
+#[test]
+fn test_quality_warnings_lambda_z() {
+    // Profile with too few points for lambda-z
+    let subject = Subject::builder("test")
+        .bolus(0.0, 100.0, 0)
+        .observation(0.0, 0.0, 0)
+        .observation(1.0, 10.0, 0)
+        .observation(2.0, 8.0, 0)
+        .build();
+
+    let results = subject.nca(&NCAOptions::default(), 0);
+    let result = results[0].as_ref().unwrap();
+
+    // Should have lambda-z warning
+    assert!(
+        result
+            .quality
+            .warnings
+            .iter()
+            .any(|w| matches!(w, Warning::LambdaZNotEstimable)),
+        "Should warn about lambda-z"
+    );
+}
+
+// ============================================================================
+// Result conversion tests
+// ============================================================================
+
+#[test]
+fn test_result_to_params() {
+    let subject = single_dose_oral();
+    let results = subject.nca(&NCAOptions::default(), 0);
+    let result = results[0].as_ref().unwrap();
+
+    let params = result.to_params();
+
+    // Check key parameters are present
+    assert!(params.contains_key("cmax"));
+    assert!(params.contains_key("tmax"));
+    assert!(params.contains_key("auc_last"));
+}
+
+#[test]
+fn test_result_display() {
+    let subject = single_dose_oral();
+    let results = subject.nca(&NCAOptions::default(), 0);
+    let result = results[0].as_ref().unwrap();
+
+    let display = format!("{}", result);
+    assert!(display.contains("Cmax"), "Display should contain Cmax");
+    assert!(display.contains("AUC"), "Display should contain AUC");
+}
+
+// ============================================================================
+// Subject/Occasion identification tests
+// ============================================================================
+
+#[test]
+fn test_result_subject_id() {
+    let subject = Subject::builder("patient_001")
+        .bolus(0.0, 100.0, 0)
+        .observation(1.0, 10.0, 0)
+        .observation(2.0, 8.0, 0)
+        .observation(4.0, 4.0, 0)
+        .observation(8.0, 2.0, 0)
+        .build();
+
+    let results = subject.nca(&NCAOptions::default(), 0);
+    let result = results[0].as_ref().unwrap();
+
+    assert_eq!(result.subject_id.as_deref(), Some("patient_001"));
+    assert_eq!(result.occasion, Some(0));
+}
+
+// ============================================================================
+// Presets tests
+// ============================================================================
+
+#[test]
+fn test_bioequivalence_preset() {
+    let options = NCAOptions::bioequivalence();
+    assert_eq!(options.lambda_z.min_r_squared, 0.90);
+    assert_eq!(options.max_auc_extrap_pct, 20.0);
+}
+
+#[test]
+fn test_sparse_preset() {
+    let options = NCAOptions::sparse();
+    assert_eq!(options.lambda_z.min_r_squared, 0.80);
+    assert_eq!(options.max_auc_extrap_pct, 30.0);
+}
+
+// ============================================================================
+// Partial AUC tests
+// ============================================================================
+
+#[test]
+fn test_partial_auc_interval() {
+    let subject = single_dose_oral();
+    let options = NCAOptions::default().with_auc_interval(0.0, 4.0);
+    let results = subject.nca(&options, 0);
+    let result = results[0].as_ref().unwrap();
+
+    // Partial AUC should be calculated
+    assert!(
+        result.exposure.auc_partial.is_some(),
+        "Partial AUC should be computed when interval specified"
+    );
+
+    let auc_partial = result.exposure.auc_partial.unwrap();
+    assert!(auc_partial > 0.0, "Partial AUC should be positive");
+
+    // Partial AUC (0-4h) should be less than AUClast (0-24h)
+    assert!(
+        auc_partial < result.exposure.auc_last,
+        "Partial AUC should be less than AUClast"
+    );
+}
+
+#[test]
+fn test_positional_blq_rule() {
+    use crate::Censor;
+
+    // Create subject with BLQ at start, middle, and end
+    let subject = Subject::builder("test")
+        .bolus(0.0, 100.0, 0)
+        .censored_observation(0.0, 0.1, 0, Censor::BLOQ) // First - keep as 0
+        .observation(1.0, 10.0, 0)
+        .censored_observation(2.0, 0.1, 0, Censor::BLOQ) // Middle - drop
+        .observation(4.0, 4.0, 0)
+        .observation(8.0, 2.0, 0)
+        .censored_observation(12.0, 0.1, 0, Censor::BLOQ) // Last - keep as 0
+        .build();
+
+    // With positional BLQ handling
+    let options = NCAOptions::default().with_blq_rule(BLQRule::Positional);
+    let results = subject.nca(&options, 0);
+    let result = results[0].as_ref().unwrap();
+
+    // Middle BLQ at t=2 should be dropped, but first and last kept as 0 (PKNCA behavior)
+    // With last BLQ kept as 0 (not LOQ), tlast remains at 8.0 (last positive conc)
+    assert_eq!(result.exposure.cmax, 10.0, "Cmax should be 10.0");
+    // tlast is the last time with positive concentration (8.0), the BLQ at 12 is 0
+    assert_eq!(
+        result.exposure.tlast, 8.0,
+        "Tlast should be 8.0 (last positive concentration)"
+    );
+    assert_eq!(
+        result.exposure.clast, 2.0,
+        "Clast should be 2.0 (last positive value)"
+    );
+}
diff --git a/src/nca/types.rs b/src/nca/types.rs
new file mode 100644
index 00000000..4f7eb410
--- /dev/null
+++ b/src/nca/types.rs
@@ -0,0 +1,592 @@
+//! NCA types: results, options, and configuration structures
+//!
+//! This module defines all public types for NCA analysis including:
+//! - [`NCAResult`]: Complete structured results
+//! - [`NCAOptions`]: Configuration options
+//! - [`Route`]: Administration route
+//! - Parameter group structs
+
+use serde::{Deserialize, Serialize};
+use std::{collections::HashMap, fmt};
+
+// ============================================================================
+// Configuration Types
+// ============================================================================
+
+/// Complete NCA configuration
+///
+/// Dose and route information are automatically detected from the data.
+/// Use these options to control calculation methods and quality thresholds.
+#[derive(Debug, Clone)]
+pub struct NCAOptions {
+    /// AUC calculation method (default: LinUpLogDown)
+    pub auc_method: AUCMethod,
+
+    /// BLQ handling rule (default: Exclude)
+    ///
+    /// When an observation is censored (`Censor::BLOQ` or `Censor::ALOQ`),
+    /// its value represents the quantification limit (lower or upper).
+    /// This rule determines how such observations are handled in the analysis.
+    ///
+    /// Note: ALOQ (Above LOQ) values are currently kept unchanged in the analysis.
+    /// This follows PKNCA behavior which also does not explicitly handle ALOQ.
+    pub blq_rule: BLQRule,
+
+    /// Terminal phase (λz) estimation options
+    pub lambda_z: LambdaZOptions,
+
+    /// Dosing interval for steady-state analysis (None = single-dose)
+    pub tau: Option<f64>,
+
+    /// Time interval for partial AUC calculation (start, end)
+    ///
+    /// If specified, `auc_partial` in the result will contain the AUC
+    /// over this interval. Useful for regulatory submissions requiring
+    /// AUC over specific time windows (e.g., AUC0-4h).
+    pub auc_interval: Option<(f64, f64)>,
+
+    /// C0 estimation methods for IV bolus (tried in order)
+    ///
+    /// Default: `[Observed, LogSlope, FirstConc]`
+    pub c0_methods: Vec<C0Method>,
+
+    /// Which Clast to use for extrapolation to infinity
+    pub clast_type: ClastType,
+
+    /// Maximum acceptable AUC extrapolation percentage (default: 20.0)
+    pub max_auc_extrap_pct: f64,
+}
+
+impl Default for NCAOptions {
+    fn default() -> Self {
+        Self {
+            auc_method: AUCMethod::LinUpLogDown,
+            blq_rule: BLQRule::Exclude,
+            lambda_z: LambdaZOptions::default(),
+            tau: None,
+            auc_interval: None,
+            c0_methods: vec![C0Method::Observed, C0Method::LogSlope, C0Method::FirstConc],
+            clast_type: ClastType::Observed,
+            max_auc_extrap_pct: 20.0,
+        }
+    }
+}
+
+impl NCAOptions {
+    /// FDA Bioequivalence study defaults
+    pub fn bioequivalence() -> Self {
+        Self {
+            lambda_z: LambdaZOptions {
+                min_r_squared: 0.90,
+                min_points: 3,
+                ..Default::default()
+            },
+            max_auc_extrap_pct: 20.0,
+            ..Default::default()
+        }
+    }
+
+    /// Lenient settings for sparse/exploratory data
+    pub fn sparse() -> Self {
+        Self {
+            lambda_z: LambdaZOptions {
+                min_r_squared: 0.80,
+                min_points: 3,
+                ..Default::default()
+            },
+            max_auc_extrap_pct: 30.0,
+            ..Default::default()
+        }
+    }
+
+    /// Set AUC calculation method
+    pub fn with_auc_method(mut self, method: AUCMethod) -> Self {
+        self.auc_method = method;
+        self
+    }
+
+    /// Set BLQ handling rule
+    ///
+    /// Censoring is determined by `Censor` markings on observations (`BLOQ`/`ALOQ`),
+    /// not by a numeric threshold. This method sets how censored observations
+    /// are handled in the analysis.
+    pub fn with_blq_rule(mut self, rule: BLQRule) -> Self {
+        self.blq_rule = rule;
+        self
+    }
+
+    /// Set dosing interval for steady-state analysis
+    pub fn with_tau(mut self, tau: f64) -> Self {
+        self.tau = Some(tau);
+        self
+    }
+
+    /// Set time interval for partial AUC calculation
+    pub fn with_auc_interval(mut self, start: f64, end: f64) -> Self {
+        self.auc_interval = Some((start, end));
+        self
+    }
+
+    /// Set lambda-z options
+    pub fn with_lambda_z(mut self, options: LambdaZOptions) -> Self {
+        self.lambda_z = options;
+        self
+    }
+
+    /// Set minimum R² for lambda-z
+    pub fn with_min_r_squared(mut self, min_r_squared: f64) -> Self {
+        self.lambda_z.min_r_squared = min_r_squared;
+        self
+    }
+
+    /// Set C0 estimation methods (tried in order)
+    pub fn with_c0_methods(mut self, methods: Vec<C0Method>) -> Self {
+        self.c0_methods = methods;
+        self
+    }
+
+    /// Set which Clast to use for AUCinf extrapolation
+    pub fn with_clast_type(mut self, clast_type: ClastType) -> Self {
+        self.clast_type = clast_type;
+        self
+    }
+}
+
+/// Lambda-z estimation options
+#[derive(Debug, Clone)]
+pub struct LambdaZOptions {
+    /// Point selection method
+    pub method: LambdaZMethod,
+    /// Minimum number of points for regression (default: 3)
+    pub min_points: usize,
+    /// Maximum number of points (None = no limit)
+    pub max_points: Option<usize>,
+    /// Minimum R² to accept (default: 0.90)
+    pub min_r_squared: f64,
+    /// Minimum span ratio (default: 2.0)
+    pub min_span_ratio: f64,
+    /// Whether to include Tmax in regression (default: false)
+    pub include_tmax: bool,
+    /// Factor added to adjusted R² to prefer more points (default: 0.0001, PKNCA default)
+    ///
+    /// The scoring formula becomes: adj_r_squared + adj_r_squared_factor * n_points
+    /// This allows preferring regressions with more points when R² values are similar.
+    pub adj_r_squared_factor: f64,
+}
+
+impl Default for LambdaZOptions {
+    fn default() -> Self {
+        Self {
+            method: LambdaZMethod::AdjR2,
+            min_points: 3,
+            max_points: None,
+            min_r_squared: 0.90,
+            min_span_ratio: 2.0,
+            include_tmax: false,
+            adj_r_squared_factor: 0.0001, // PKNCA default
+        }
+    }
+}
+
+/// Lambda-z point selection method
+#[derive(Debug, Clone, Copy, Default, PartialEq, Eq, Serialize, Deserialize)]
+pub enum LambdaZMethod {
+    /// Best adjusted R² (recommended)
+    #[default]
+    AdjR2,
+    /// Best raw R²
+    R2,
+    /// Use specific number of terminal points
+    Manual(usize),
+}
+
+/// AUC calculation method
+#[derive(Debug, Clone, Copy, Default, PartialEq, Eq, Serialize, Deserialize)]
+pub enum AUCMethod {
+    /// Linear trapezoidal rule
+    Linear,
+    /// Linear up / log down (industry standard)
+    #[default]
+    LinUpLogDown,
+    /// Linear before Tmax, log-linear after Tmax (PKNCA "lin-log")
+    ///
+    /// Uses linear trapezoidal before and at Tmax, then log-linear for
+    /// descending portions after Tmax. Falls back to linear if either
+    /// concentration is zero or non-positive.
+    LinLog,
+}
+
+/// BLQ (Below Limit of Quantification) handling rule
+#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
+pub enum BLQRule {
+    /// Replace BLQ with zero
+    Zero,
+    /// Replace BLQ with LOQ/2
+    LoqOver2,
+    /// Exclude BLQ values from analysis
+    #[default]
+    Exclude,
+    /// Position-aware handling (PKNCA default): first=keep(0), middle=drop, last=keep(0)
+    ///
+    /// This is the FDA-recommended approach that:
+    /// - Keeps first BLQ (before tfirst) as 0 to anchor the profile start
+    /// - Drops middle BLQ (between tfirst and tlast) to avoid deflating AUC
+    /// - Keeps last BLQ (at/after tlast) as 0 to define profile end
+    Positional,
+    /// Tmax-relative handling: different rules before vs after Tmax
+    ///
+    /// Contains (before_tmax_rule, after_tmax_rule) where each rule can be:
+    /// - "keep" = keep as 0
+    /// - "drop" = exclude from analysis
+    /// Default PKNCA: before.tmax=drop, after.tmax=keep
+    TmaxRelative {
+        /// Rule for BLQ before Tmax: true=keep as 0, false=drop
+        before_tmax_keep: bool,
+        /// Rule for BLQ at or after Tmax: true=keep as 0, false=drop
+        after_tmax_keep: bool,
+    },
+}
+
+/// Action to take for a BLQ observation based on position
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub(crate) enum BlqAction {
+    Keep,
+    Drop,
+}
+
+/// Administration route
+#[derive(Debug, Clone, Copy, Default, PartialEq, Eq, Serialize, Deserialize)]
+pub enum Route {
+    /// Intravenous bolus
+    IVBolus,
+    /// Intravenous infusion
+    IVInfusion,
+    /// Extravascular (oral, SC, IM, etc.)
+    #[default]
+    Extravascular,
+}
+
+/// C0 (initial concentration) estimation method for IV bolus
+///
+/// Methods are tried in order until one succeeds. Default cascade:
+/// `[Observed, LogSlope, FirstConc]`
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
+pub enum C0Method {
+    /// Use observed concentration at dose time if present and non-zero
+    Observed,
+    /// Semilog back-extrapolation from first two positive concentrations
+    LogSlope,
+    /// Use first positive concentration after dose time
+    FirstConc,
+    /// Use minimum positive concentration (for IV infusion steady-state)
+    Cmin,
+    /// Set C0 = 0 (for extravascular where C0 doesn't exist)
+    Zero,
+}
+
+/// Which Clast value to use for extrapolation to infinity
+#[derive(Debug, Clone, Copy, Default, PartialEq, Eq, Serialize, Deserialize)]
+pub enum ClastType {
+    /// Use observed Clast (AUCinf,obs)
+    #[default]
+    Observed,
+    /// Use predicted Clast from λz regression (AUCinf,pred)
+    Predicted,
+}
+
+// ============================================================================
+// Result Types
+// ============================================================================
+
+/// Complete NCA result with logical parameter grouping
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct NCAResult {
+    /// Subject identifier
+    pub subject_id: Option<String>,
+    /// Occasion index
+    pub occasion: Option<usize>,
+
+    /// Core exposure parameters (always computed)
+    pub exposure: ExposureParams,
+
+    /// Terminal phase parameters (if λz succeeds)
+    pub terminal: Option<TerminalParams>,
+
+    /// Clearance parameters (if dose + λz available)
+    pub clearance: Option<ClearanceParams>,
+
+    /// IV Bolus-specific parameters
+    pub iv_bolus: Option<IVBolusParams>,
+
+    /// IV Infusion-specific parameters
+    pub iv_infusion: Option<IVInfusionParams>,
+
+    /// Steady-state parameters (if tau specified)
+    pub steady_state: Option<SteadyStateParams>,
+
+    /// Quality metrics and warnings
+    pub quality: Quality,
+}
+
+impl NCAResult {
+    /// Get half-life if available
+    pub fn half_life(&self) -> Option<f64> {
+        self.terminal.as_ref().map(|t| t.half_life)
+    }
+
+    /// Flatten result to parameter name-value pairs for export
+    pub fn to_params(&self) -> HashMap<&'static str, f64> {
+        let mut p = HashMap::new();
+
+        p.insert("cmax", self.exposure.cmax);
+        p.insert("tmax", self.exposure.tmax);
+        p.insert("clast", self.exposure.clast);
+        p.insert("tlast", self.exposure.tlast);
+        p.insert("auc_last", self.exposure.auc_last);
+
+        if let Some(ref t) = self.terminal {
+            p.insert("lambda_z", t.lambda_z);
+            p.insert("half_life", t.half_life);
+        }
+
+        if let Some(ref c) = self.clearance {
+            p.insert("cl_f", c.cl_f);
+            p.insert("vz_f", c.vz_f);
+        }
+
+        p
+    }
+}
+
+impl fmt::Display for NCAResult {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        writeln!(f, "╔══════════════════════════════════════╗")?;
+        writeln!(f, "║           NCA Results                ║")?;
+        writeln!(f, "╠══════════════════════════════════════╣")?;
+
+        if let Some(ref id) = self.subject_id {
+            writeln!(f, "║ Subject: {:<27} ║", id)?;
+        }
+        if let Some(occ) = self.occasion {
+            writeln!(f, "║ Occasion: {:<26} ║", occ)?;
+        }
+
+        writeln!(f, "╠══════════════════════════════════════╣")?;
+        writeln!(f, "║ EXPOSURE                             ║")?;
+        writeln!(
+            f,
+            "║   Cmax:    {:>10.4} at Tmax={:<6.2} ║",
+            self.exposure.cmax, self.exposure.tmax
+        )?;
+        writeln!(
+            f,
+            "║   AUClast: {:>10.4}               ║",
+            self.exposure.auc_last
+        )?;
+        writeln!(
+            f,
+            "║   Clast:   {:>10.4} at Tlast={:<5.2}║",
+            self.exposure.clast, self.exposure.tlast
+        )?;
+
+        if let Some(ref t) = self.terminal {
+            writeln!(f, "╠══════════════════════════════════════╣")?;
+            writeln!(f, "║ TERMINAL                             ║")?;
+            writeln!(f, "║   λz:      {:>10.5}               ║", t.lambda_z)?;
+            writeln!(f, "║   t½:      {:>10.2}               ║", t.half_life)?;
+            if let Some(ref reg) = t.regression {
+                writeln!(f, "║   R²:      {:>10.4}               ║", reg.r_squared)?;
+            }
+        }
+
+        if let Some(ref c) = self.clearance {
+            writeln!(f, "╠══════════════════════════════════════╣")?;
+            writeln!(f, "║ CLEARANCE                            ║")?;
+            writeln!(f, "║   CL/F:    {:>10.4}               ║", c.cl_f)?;
+            writeln!(f, "║   Vz/F:    {:>10.4}               ║", c.vz_f)?;
+        }
+
+        if !self.quality.warnings.is_empty() {
+            writeln!(f, "╠══════════════════════════════════════╣")?;
+            writeln!(f, "║ WARNINGS                             ║")?;
+            for w in &self.quality.warnings {
+                writeln!(f, "║   • {:<32} ║", format!("{:?}", w))?;
+            }
+        }
+
+        writeln!(f, "╚══════════════════════════════════════╝")?;
+        Ok(())
+    }
+}
+
+/// Core exposure parameters
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct ExposureParams {
+    /// Maximum observed concentration
+    pub cmax: f64,
+    /// Time of maximum concentration
+    pub tmax: f64,
+    /// Last quantifiable concentration
+    pub clast: f64,
+    /// Time of last quantifiable concentration
+    pub tlast: f64,
+    /// AUC from time 0 to Tlast
+    pub auc_last: f64,
+    /// AUC extrapolated to infinity
+    pub auc_inf: Option<f64>,
+    /// Percentage of AUC extrapolated
+    pub auc_pct_extrap: Option<f64>,
+    /// Partial AUC (if requested)
+    pub auc_partial: Option<f64>,
+    /// AUMC from time 0 to Tlast
+    pub aumc_last: Option<f64>,
+    /// AUMC extrapolated to infinity
+    pub aumc_inf: Option<f64>,
+    /// Lag time (extravascular only)
+    pub tlag: Option<f64>,
+}
+
+/// Terminal phase parameters
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct TerminalParams {
+    /// Terminal elimination rate constant
+    pub lambda_z: f64,
+    /// Terminal half-life
+    pub half_life: f64,
+    /// Mean residence time
+    pub mrt: Option<f64>,
+    /// Regression statistics
+    pub regression: Option<RegressionStats>,
+}
+
+/// Regression statistics for λz estimation
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct RegressionStats {
+    /// Coefficient of determination
+    pub r_squared: f64,
+    /// Adjusted R²
+    pub adj_r_squared: f64,
+    /// Number of points used
+    pub n_points: usize,
+    /// First time point in regression
+    pub time_first: f64,
+    /// Last time point in regression
+    pub time_last: f64,
+    /// Span ratio
+    pub span_ratio: f64,
+}
+
+/// Clearance parameters
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct ClearanceParams {
+    /// Apparent clearance (CL/F)
+    pub cl_f: f64,
+    /// Apparent volume of distribution (Vz/F)
+    pub vz_f: f64,
+    /// Volume at steady state (for IV)
+    pub vss: Option<f64>,
+}
+
+/// IV Bolus-specific parameters
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct IVBolusParams {
+    /// Back-extrapolated initial concentration
+    pub c0: f64,
+    /// Volume of distribution
+    pub vd: f64,
+    /// Volume at steady state
+    pub vss: Option<f64>,
+}
+
+/// IV Infusion-specific parameters
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct IVInfusionParams {
+    /// Infusion duration
+    pub infusion_duration: f64,
+    /// MRT corrected for infusion
+    pub mrt_iv: Option<f64>,
+    /// Volume at steady state
+    pub vss: Option<f64>,
+}
+
+/// Steady-state parameters
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct SteadyStateParams {
+    /// Dosing interval
+    pub tau: f64,
+    /// AUC over dosing interval
+    pub auc_tau: f64,
+    /// Minimum concentration
+    pub cmin: f64,
+    /// Maximum concentration at steady state
+    pub cmax_ss: f64,
+    /// Average concentration
+    pub cavg: f64,
+    /// Percent fluctuation
+    pub fluctuation: f64,
+    /// Swing
+    pub swing: f64,
+    /// Accumulation ratio
+    pub accumulation: Option<f64>,
+}
+
+/// Quality metrics and warnings
+#[derive(Debug, Clone, Default, Serialize, Deserialize)]
+pub struct Quality {
+    /// List of warnings
+    pub warnings: Vec<Warning>,
+}
+
+/// NCA analysis warnings
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub enum Warning {
+    /// High AUC extrapolation
+    HighExtrapolation,
+    /// Poor lambda-z fit
+    PoorFit,
+    /// Lambda-z could not be estimated
+    LambdaZNotEstimable,
+    /// Short terminal phase
+    ShortTerminalPhase,
+    /// Low Cmax
+    LowCmax,
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_nca_options_default() {
+        let opts = NCAOptions::default();
+        assert_eq!(opts.auc_method, AUCMethod::LinUpLogDown);
+        assert_eq!(opts.blq_rule, BLQRule::Exclude);
+        assert!(opts.tau.is_none());
+        assert_eq!(opts.max_auc_extrap_pct, 20.0);
+    }
+
+    #[test]
+    fn test_nca_options_builder() {
+        let opts = NCAOptions::default()
+            .with_auc_method(AUCMethod::Linear)
+            .with_blq_rule(BLQRule::LoqOver2)
+            .with_tau(24.0)
+            .with_min_r_squared(0.95);
+
+        assert_eq!(opts.auc_method, AUCMethod::Linear);
+        assert_eq!(opts.blq_rule, BLQRule::LoqOver2);
+        assert_eq!(opts.tau, Some(24.0));
+        assert_eq!(opts.lambda_z.min_r_squared, 0.95);
+    }
+
+    #[test]
+    fn test_nca_options_presets() {
+        let be = NCAOptions::bioequivalence();
+        assert_eq!(be.lambda_z.min_r_squared, 0.90);
+        assert_eq!(be.max_auc_extrap_pct, 20.0);
+
+        let sparse = NCAOptions::sparse();
+        assert_eq!(sparse.lambda_z.min_r_squared, 0.80);
+        assert_eq!(sparse.max_auc_extrap_pct, 30.0);
+    }
+}
diff --git a/src/optimize/effect.rs b/src/optimize/effect.rs
index f132393d..92542a8d 100644
--- a/src/optimize/effect.rs
+++ b/src/optimize/effect.rs
@@ -150,6 +150,61 @@ fn find_m0(afinal: f64, b: f64, alpha: f64, h1: f64, h2: f64) -> f64 {
     xm
 }
 
+/// Computes the effect metric for a dual-site pharmacodynamic model.
+///
+/// This function calculates the maximum effect for a model where two binding sites
+/// contribute to the overall effect. The effect is computed as `xm / (xm + 1)` where `xm`
+/// is the optimal concentration that maximizes the combined effect from both sites.
+///
+/// # Model Description
+///
+/// The underlying model assumes the total effect is:
+/// ```text
+/// Effect = a / xm^h1 + b / xm^h2 + w / xm^((h1+h2)/2)
+/// ```
+/// where:
+/// - `a` and `b` are the coefficients for the two binding sites
+/// - `h1` and `h2` are the Hill coefficients for each site
+/// - `w` is a cross-interaction term
+/// - `xm` is the concentration
+///
+/// The function finds the optimal `xm` that makes this sum equal to 1, then returns
+/// the corresponding effect value `xm / (xm + 1)`.
+///
+/// # Arguments
+///
+/// * `a` - Coefficient for the first binding site (typically positive)
+/// * `b` - Coefficient for the second binding site (typically positive)
+/// * `w` - Cross-interaction term between the two sites
+/// * `h1` - Hill coefficient for the first binding site
+/// * `h2` - Hill coefficient for the second binding site
+/// * `alpha_s` - Scaling factor used in the fallback numerical estimator
+///
+/// # Returns
+///
+/// The E2 effect value in the range [0, 1), representing the maximum achievable effect.
+/// Returns 0.0 if both `a` and `b` are essentially zero.
+///
+/// # Algorithm
+///
+/// 1. If both coefficients are near zero, returns 0.0
+/// 2. If only one coefficient is positive, uses a closed-form solution
+/// 3. Otherwise, uses Nelder-Mead optimization in log-space to find the optimal `xm`
+/// 4. Falls back to an iterative numerical estimator if optimization fails to converge
+///
+/// # Example
+///
+/// ```
+/// use pharmsol::get_e2;
+///
+/// // Single-site model (b = 0)
+/// let e2 = get_e2(1.0, 0.0, 0.0, 1.0, 1.0, 0.5);
+/// assert!((e2 - 0.5).abs() < 1e-6); // xm = 1, so E2 = 1/(1+1) = 0.5
+///
+/// // Dual-site model
+/// let e2 = get_e2(1.0, 1.0, 0.0, 1.0, 2.0, 0.5);
+/// assert!(e2 > 0.0 && e2 < 1.0);
+/// ```
 pub fn get_e2(a: f64, b: f64, w: f64, h1: f64, h2: f64, alpha_s: f64) -> f64 {
     // trivial cases
     if a.abs() < 1.0e-12 && b.abs() < 1.0e-12 {
diff --git a/src/optimize/spp.rs b/src/optimize/spp.rs
index ac19bd3b..cb569b94 100644
--- a/src/optimize/spp.rs
+++ b/src/optimize/spp.rs
@@ -5,12 +5,15 @@ use argmin::{
 
 use ndarray::{Array1, Axis};
 
-use crate::{prelude::simulator::psi, Data, Equation, ErrorModels};
+use crate::{
+    prelude::simulator::{log_likelihood_matrix, LikelihoodMatrixOptions},
+    AssayErrorModels, Data, Equation,
+};
 
 pub struct SppOptimizer<'a, E: Equation> {
     equation: &'a E,
     data: &'a Data,
-    sig: &'a ErrorModels,
+    sig: &'a AssayErrorModels,
     pyl: &'a Array1<f64>,
 }
 
@@ -20,7 +23,14 @@ impl<E: Equation> CostFunction for SppOptimizer<'_, E> {
     fn cost(&self, spp: &Self::Param) -> Result<Self::Output, Error> {
         let theta = Array1::from(spp.clone()).insert_axis(Axis(0));
 
-        let psi = psi(self.equation, self.data, &theta, self.sig, false, false)?;
+        let log_psi = log_likelihood_matrix(
+            self.equation,
+            self.data,
+            &theta,
+            self.sig,
+            LikelihoodMatrixOptions::default(),
+        )?;
+        let psi = log_psi.mapv(f64::exp);
 
         if psi.ncols() > 1 {
             tracing::error!("Psi in SppOptimizer has more than one column");
@@ -45,7 +55,7 @@ impl<'a, E: Equation> SppOptimizer<'a, E> {
     pub fn new(
         equation: &'a E,
         data: &'a Data,
-        sig: &'a ErrorModels,
+        sig: &'a AssayErrorModels,
         pyl: &'a Array1<f64>,
     ) -> Self {
         Self {
diff --git a/src/simulator/equation/analytical/mod.rs b/src/simulator/equation/analytical/mod.rs
index 5db77979..f41d5b49 100644
--- a/src/simulator/equation/analytical/mod.rs
+++ b/src/simulator/equation/analytical/mod.rs
@@ -7,6 +7,7 @@ pub use one_compartment_models::*;
 pub use three_compartment_models::*;
 pub use two_compartment_models::*;
 
+use crate::data::error_model::AssayErrorModels;
 use crate::PharmsolError;
 use crate::{
     data::Covariates, simulator::*, Equation, EquationPriv, EquationTypes, Observation, Subject,
@@ -172,7 +173,7 @@ impl EquationPriv for Analytical {
         &self,
         support_point: &Vec<f64>,
         observation: &Observation,
-        error_models: Option<&ErrorModels>,
+        error_models: Option<&AssayErrorModels>,
         _time: f64,
         covariates: &Covariates,
         x: &mut Self::S,
@@ -191,7 +192,7 @@ impl EquationPriv for Analytical {
         let pred = y[observation.outeq()];
         let pred = observation.to_prediction(pred, x.as_slice().to_vec());
         if let Some(error_models) = error_models {
-            likelihood.push(pred.likelihood(error_models)?);
+            likelihood.push(pred.log_likelihood(error_models)?.exp());
         }
         output.add_prediction(pred);
         Ok(())
@@ -287,7 +288,7 @@ impl Equation for Analytical {
         &self,
         subject: &Subject,
         support_point: &Vec<f64>,
-        error_models: &ErrorModels,
+        error_models: &AssayErrorModels,
         cache: bool,
     ) -> Result<f64, PharmsolError> {
         _estimate_likelihood(self, subject, support_point, error_models, cache)
@@ -297,7 +298,7 @@ impl Equation for Analytical {
         &self,
         subject: &Subject,
         support_point: &Vec<f64>,
-        error_models: &ErrorModels,
+        error_models: &AssayErrorModels,
         cache: bool,
     ) -> Result<f64, PharmsolError> {
         let ypred = if cache {
@@ -346,7 +347,7 @@ fn _estimate_likelihood(
     ode: &Analytical,
     subject: &Subject,
     support_point: &Vec<f64>,
-    error_models: &ErrorModels,
+    error_models: &AssayErrorModels,
     cache: bool,
 ) -> Result<f64, PharmsolError> {
     let ypred = if cache {
@@ -354,5 +355,5 @@ fn _estimate_likelihood(
     } else {
         _subject_predictions_no_cache(ode, subject, support_point)
     }?;
-    ypred.likelihood(error_models)
+    Ok(ypred.log_likelihood(error_models)?.exp())
 }
diff --git a/src/simulator/equation/mod.rs b/src/simulator/equation/mod.rs
index 70219080..2e7db989 100644
--- a/src/simulator/equation/mod.rs
+++ b/src/simulator/equation/mod.rs
@@ -9,7 +9,7 @@ pub use ode::*;
 pub use sde::*;
 
 use crate::{
-    error_model::ErrorModels,
+    error_model::AssayErrorModels,
     simulator::{Fa, Lag},
     Covariates, Event, Infusion, Observation, PharmsolError, Subject,
 };
@@ -61,7 +61,7 @@ pub trait Predictions: Default {
     ///
     /// # Returns
     /// The sum of log-likelihoods for all predictions
-    fn log_likelihood(&self, error_models: &ErrorModels) -> Result<f64, PharmsolError>;
+    fn log_likelihood(&self, error_models: &AssayErrorModels) -> Result<f64, PharmsolError>;
 }
 
 /// Trait defining the associated types for equations.
@@ -101,7 +101,7 @@ pub(crate) trait EquationPriv: EquationTypes {
         &self,
         support_point: &Vec<f64>,
         observation: &Observation,
-        error_models: Option<&ErrorModels>,
+        error_models: Option<&AssayErrorModels>,
         time: f64,
         covariates: &Covariates,
         x: &mut Self::S,
@@ -122,7 +122,7 @@ pub(crate) trait EquationPriv: EquationTypes {
         support_point: &Vec<f64>,
         event: &Event,
         next_event: Option<&Event>,
-        error_models: Option<&ErrorModels>,
+        error_models: Option<&AssayErrorModels>,
         covariates: &Covariates,
         x: &mut Self::S,
         infusions: &mut Vec<Infusion>,
@@ -169,10 +169,19 @@ pub(crate) trait EquationPriv: EquationTypes {
 /// This trait defines the interface for different types of model equations
 /// (ODE, SDE, analytical) that can be simulated to generate predictions
 /// and estimate parameters.
+///
+/// # Likelihood Calculation
+///
+/// Use [`estimate_log_likelihood`](Self::estimate_log_likelihood) for numerically stable
+/// likelihood computation. The deprecated [`estimate_likelihood`](Self::estimate_likelihood)
+/// is provided for backward compatibility.
 #[allow(private_bounds)]
 pub trait Equation: EquationPriv + 'static + Clone + Sync {
     /// Estimate the likelihood of the subject given the support point and error model.
     ///
+    /// **Deprecated**: Use [`estimate_log_likelihood`](Self::estimate_log_likelihood) instead
+    /// for better numerical stability, especially with many observations or extreme parameter values.
+    ///
     /// This function calculates how likely the observed data is given the model
     /// parameters and error model. It may use caching for performance.
     ///
@@ -184,11 +193,15 @@ pub trait Equation: EquationPriv + 'static + Clone + Sync {
     ///
     /// # Returns
     /// The likelihood value (product of individual observation likelihoods)
+    #[deprecated(
+        since = "0.23.0",
+        note = "Use estimate_log_likelihood() instead for better numerical stability"
+    )]
     fn estimate_likelihood(
         &self,
         subject: &Subject,
         support_point: &Vec<f64>,
-        error_models: &ErrorModels,
+        error_models: &AssayErrorModels,
         cache: bool,
     ) -> Result<f64, PharmsolError>;
 
@@ -198,10 +211,13 @@ pub trait Equation: EquationPriv + 'static + Clone + Sync {
     /// parameters and error model. It is numerically more stable than `estimate_likelihood`
     /// for extreme values or many observations.
     ///
+    /// Uses observation-based sigma, appropriate for non-parametric algorithms.
+    /// For parametric algorithms (SAEM, FOCE), use [`crate::ResidualErrorModels`] directly.
+    ///
     /// # Parameters
     /// - `subject`: The subject data
     /// - `support_point`: The parameter values
-    /// - `error_model`: The error model
+    /// - `error_models`: The error model
     /// - `cache`: Whether to use caching
     ///
     /// # Returns
@@ -210,7 +226,7 @@ pub trait Equation: EquationPriv + 'static + Clone + Sync {
         &self,
         subject: &Subject,
         support_point: &Vec<f64>,
-        error_models: &ErrorModels,
+        error_models: &AssayErrorModels,
         cache: bool,
     ) -> Result<f64, PharmsolError>;
 
@@ -255,7 +271,7 @@ pub trait Equation: EquationPriv + 'static + Clone + Sync {
         &self,
         subject: &Subject,
         support_point: &Vec<f64>,
-        error_models: Option<&ErrorModels>,
+        error_models: Option<&AssayErrorModels>,
     ) -> Result<(Self::P, Option<f64>), PharmsolError> {
         let mut output = Self::P::new(self.nparticles());
         let mut likelihood = Vec::new();
diff --git a/src/simulator/equation/ode/mod.rs b/src/simulator/equation/ode/mod.rs
index 4c005ee7..23746c8d 100644
--- a/src/simulator/equation/ode/mod.rs
+++ b/src/simulator/equation/ode/mod.rs
@@ -2,11 +2,12 @@ mod closure;
 
 use crate::{
     data::{Covariates, Infusion},
-    error_model::ErrorModels,
+    error_model::AssayErrorModels,
     prelude::simulator::SubjectPredictions,
     simulator::{DiffEq, Fa, Init, Lag, Neqs, Out, M, V},
     Event, Observation, PharmsolError, Subject,
 };
+
 use cached::proc_macro::cached;
 use cached::UnboundCache;
 
@@ -73,7 +74,7 @@ fn _estimate_likelihood(
     ode: &ODE,
     subject: &Subject,
     support_point: &Vec<f64>,
-    error_models: &ErrorModels,
+    error_models: &AssayErrorModels,
     cache: bool,
 ) -> Result<f64, PharmsolError> {
     let ypred = if cache {
@@ -81,7 +82,7 @@ fn _estimate_likelihood(
     } else {
         _subject_predictions_no_cache(ode, subject, support_point)
     }?;
-    ypred.likelihood(error_models)
+    Ok(ypred.log_likelihood(error_models)?.exp())
 }
 
 #[inline(always)]
@@ -151,7 +152,7 @@ impl EquationPriv for ODE {
         &self,
         _support_point: &Vec<f64>,
         _observation: &Observation,
-        _error_models: Option<&ErrorModels>,
+        _error_models: Option<&AssayErrorModels>,
         _time: f64,
         _covariates: &Covariates,
         _x: &mut Self::S,
@@ -178,7 +179,7 @@ impl Equation for ODE {
         &self,
         subject: &Subject,
         support_point: &Vec<f64>,
-        error_models: &ErrorModels,
+        error_models: &AssayErrorModels,
         cache: bool,
     ) -> Result<f64, PharmsolError> {
         _estimate_likelihood(self, subject, support_point, error_models, cache)
@@ -188,7 +189,7 @@ impl Equation for ODE {
         &self,
         subject: &Subject,
         support_point: &Vec<f64>,
-        error_models: &ErrorModels,
+        error_models: &AssayErrorModels,
         cache: bool,
     ) -> Result<f64, PharmsolError> {
         let ypred = if cache {
@@ -207,7 +208,7 @@ impl Equation for ODE {
         &self,
         subject: &Subject,
         support_point: &Vec<f64>,
-        error_models: Option<&ErrorModels>,
+        error_models: Option<&AssayErrorModels>,
     ) -> Result<(Self::P, Option<f64>), PharmsolError> {
         let mut output = Self::P::new(self.nparticles());
 
@@ -324,7 +325,7 @@ impl Equation for ODE {
                         let pred =
                             observation.to_prediction(pred, solver.state().y.as_slice().to_vec());
                         if let Some(error_models) = error_models {
-                            likelihood.push(pred.likelihood(error_models)?);
+                            likelihood.push(pred.log_likelihood(error_models)?.exp());
                         }
                         output.add_prediction(pred);
                     }
diff --git a/src/simulator/equation/sde/mod.rs b/src/simulator/equation/sde/mod.rs
index 63d2cf82..e7b7f243 100644
--- a/src/simulator/equation/sde/mod.rs
+++ b/src/simulator/equation/sde/mod.rs
@@ -11,7 +11,7 @@ use cached::UnboundCache;
 
 use crate::{
     data::{Covariates, Infusion},
-    error_model::ErrorModels,
+    error_model::AssayErrorModels,
     prelude::simulator::Prediction,
     simulator::{Diffusion, Drift, Fa, Init, Lag, Neqs, Out, V},
     Subject,
@@ -182,7 +182,7 @@ impl Predictions for Array2<Prediction> {
 
         result
     }
-    fn log_likelihood(&self, error_models: &ErrorModels) -> Result<f64, crate::PharmsolError> {
+    fn log_likelihood(&self, error_models: &AssayErrorModels) -> Result<f64, crate::PharmsolError> {
         // For SDE, compute log-likelihood using mean predictions across particles
         let predictions = self.get_predictions();
         if predictions.is_empty() {
@@ -282,7 +282,7 @@ impl EquationPriv for SDE {
         &self,
         support_point: &Vec<f64>,
         observation: &crate::Observation,
-        error_models: Option<&ErrorModels>,
+        error_models: Option<&AssayErrorModels>,
         _time: f64,
         covariates: &Covariates,
         x: &mut Self::S,
@@ -309,7 +309,7 @@ impl EquationPriv for SDE {
             let mut q: Vec<f64> = Vec::with_capacity(self.nparticles);
 
             pred.iter().for_each(|p| {
-                let lik = p.likelihood(em);
+                let lik = p.log_likelihood(em).map(f64::exp);
                 match lik {
                     Ok(l) => q.push(l),
                     Err(e) => panic!("Error in likelihood calculation: {:?}", e),
@@ -367,13 +367,15 @@ impl Equation for SDE {
         &self,
         subject: &Subject,
         support_point: &Vec<f64>,
-        error_models: &ErrorModels,
+        error_models: &AssayErrorModels,
         cache: bool,
     ) -> Result<f64, PharmsolError> {
         if cache {
             _estimate_likelihood(self, subject, support_point, error_models)
         } else {
-            _estimate_likelihood_no_cache(self, subject, support_point, error_models)
+            // No cache version: directly simulate
+            let ypred = self.simulate_subject(subject, support_point, Some(error_models))?;
+            Ok(ypred.1.unwrap())
         }
     }
 
@@ -381,13 +383,19 @@ impl Equation for SDE {
         &self,
         subject: &Subject,
         support_point: &Vec<f64>,
-        error_models: &ErrorModels,
+        error_models: &AssayErrorModels,
         cache: bool,
     ) -> Result<f64, PharmsolError> {
         // For SDE, the particle filter computes likelihood in regular space.
-        // We take the log of the cached/computed likelihood.
-        // Note: For extreme underflow cases, this may return -inf.
-        let lik = self.estimate_likelihood(subject, support_point, error_models, cache)?;
+        // We compute it directly and then take the log.
+        let lik = if cache {
+            _estimate_likelihood(self, subject, support_point, error_models)?
+        } else {
+            // No cache version: directly simulate
+            let ypred = self.simulate_subject(subject, support_point, Some(error_models))?;
+            ypred.1.unwrap()
+        };
+
         if lik > 0.0 {
             Ok(lik.ln())
         } else {
@@ -427,7 +435,7 @@ fn _estimate_likelihood(
     sde: &SDE,
     subject: &Subject,
     support_point: &Vec<f64>,
-    error_models: &ErrorModels,
+    error_models: &AssayErrorModels,
 ) -> Result<f64, PharmsolError> {
     let ypred = sde.simulate_subject(subject, support_point, Some(error_models))?;
     Ok(ypred.1.unwrap())
diff --git a/src/simulator/likelihood/distributions.rs b/src/simulator/likelihood/distributions.rs
new file mode 100644
index 00000000..95ec9570
--- /dev/null
+++ b/src/simulator/likelihood/distributions.rs
@@ -0,0 +1,183 @@
+//! Statistical distribution functions for likelihood calculations.
+//!
+//! This module provides numerically stable implementations of probability
+//! distribution functions used in pharmacometric likelihood calculations.
+//!
+//! All functions operate in log-space for numerical stability.
+
+use crate::ErrorModelError;
+use statrs::distribution::{ContinuousCDF, Normal};
+
+// ln(2π) = ln(2) + ln(π) ≈ 1.8378770664093453
+pub(crate) const LOG_2PI: f64 = 1.8378770664093453_f64;
+
+/// Log of the probability density function of the normal distribution.
+///
+/// This is numerically stable and avoids underflow for extreme values.
+///
+/// # Formula
+/// ```text
+/// log(φ(x; μ, σ)) = -0.5 * ln(2π) - ln(σ) - (x - μ)² / (2σ²)
+/// ```
+///
+/// # Parameters
+/// - `obs`: Observed value
+/// - `pred`: Predicted value (mean)
+/// - `sigma`: Standard deviation
+///
+/// # Returns
+/// The log probability density
+#[inline(always)]
+pub fn lognormpdf(obs: f64, pred: f64, sigma: f64) -> f64 {
+    let diff = obs - pred;
+    -0.5 * LOG_2PI - sigma.ln() - (diff * diff) / (2.0 * sigma * sigma)
+}
+
+/// Log of the cumulative distribution function of the normal distribution.
+///
+/// Used for BLOQ (below limit of quantification) observations where the
+/// likelihood is the probability of observing a value ≤ LOQ.
+///
+/// # Parameters
+/// - `obs`: Observed value (typically the LOQ)
+/// - `pred`: Predicted value (mean)
+/// - `sigma`: Standard deviation
+///
+/// # Returns
+/// The log of the CDF value, or an error if numerical issues occur
+///
+/// # Numerical Stability
+/// For extremely small CDF values (z < -37), uses an asymptotic approximation
+/// to avoid underflow to zero.
+#[inline(always)]
+pub fn lognormcdf(obs: f64, pred: f64, sigma: f64) -> Result<f64, ErrorModelError> {
+    let norm = Normal::new(pred, sigma).map_err(|_| ErrorModelError::NegativeSigma)?;
+    let cdf = norm.cdf(obs);
+    if cdf <= 0.0 {
+        // For extremely small CDF values, use an approximation
+        // log(Φ(x)) ≈ log(φ(x)) - log(-x) for large negative x
+        // where x = (obs - pred) / sigma
+        let z = (obs - pred) / sigma;
+        if z < -37.0 {
+            // Below this, cdf is essentially 0, use asymptotic approximation
+            Ok(lognormpdf(obs, pred, sigma) - z.abs().ln())
+        } else {
+            Err(ErrorModelError::NegativeSigma) // Indicates numerical issue
+        }
+    } else {
+        Ok(cdf.ln())
+    }
+}
+
+/// Log of the survival function (1 - CDF) of the normal distribution.
+///
+/// Used for ALOQ (above limit of quantification) observations where the
+/// likelihood is the probability of observing a value > LOQ.
+///
+/// # Parameters
+/// - `obs`: Observed value (typically the LOQ)
+/// - `pred`: Predicted value (mean)
+/// - `sigma`: Standard deviation
+///
+/// # Returns
+/// The log of the survival function value, or an error if numerical issues occur
+///
+/// # Numerical Stability
+/// For extremely small survival function values (z > 37), uses an asymptotic
+/// approximation to avoid underflow to zero.
+#[inline(always)]
+pub fn lognormccdf(obs: f64, pred: f64, sigma: f64) -> Result<f64, ErrorModelError> {
+    let norm = Normal::new(pred, sigma).map_err(|_| ErrorModelError::NegativeSigma)?;
+    let sf = 1.0 - norm.cdf(obs);
+    if sf <= 0.0 {
+        let z = (obs - pred) / sigma;
+        if z > 37.0 {
+            // Use asymptotic approximation for upper tail
+            Ok(lognormpdf(obs, pred, sigma) - z.ln())
+        } else {
+            Err(ErrorModelError::NegativeSigma)
+        }
+    } else {
+        Ok(sf.ln())
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_lognormpdf_standard_normal() {
+        // At mean, log PDF should be -0.5 * ln(2π) - ln(σ)
+        let log_pdf = lognormpdf(0.0, 0.0, 1.0);
+        let expected = -0.5 * LOG_2PI;
+        assert!(
+            (log_pdf - expected).abs() < 1e-10,
+            "lognormpdf at mean should be -0.5*ln(2π)"
+        );
+    }
+
+    #[test]
+    fn test_lognormpdf_matches_exp_pdf() {
+        let obs = 1.5;
+        let pred = 1.0;
+        let sigma = 0.5;
+
+        let log_pdf = lognormpdf(obs, pred, sigma);
+        let pdf = log_pdf.exp();
+
+        // Manual calculation
+        let diff = obs - pred;
+        let expected_pdf = (1.0 / (sigma * (2.0 * std::f64::consts::PI).sqrt()))
+            * (-diff * diff / (2.0 * sigma * sigma)).exp();
+
+        assert!(
+            (pdf - expected_pdf).abs() < 1e-10,
+            "exp(lognormpdf) should match manual PDF calculation"
+        );
+    }
+
+    #[test]
+    fn test_lognormcdf_basic() {
+        // CDF at mean should be 0.5, so log should be ln(0.5)
+        let log_cdf = lognormcdf(0.0, 0.0, 1.0).unwrap();
+        let expected = 0.5_f64.ln();
+        assert!(
+            (log_cdf - expected).abs() < 1e-10,
+            "lognormcdf at mean should be ln(0.5)"
+        );
+    }
+
+    #[test]
+    fn test_lognormccdf_basic() {
+        // SF at mean should be 0.5, so log should be ln(0.5)
+        let log_sf = lognormccdf(0.0, 0.0, 1.0).unwrap();
+        let expected = 0.5_f64.ln();
+        assert!(
+            (log_sf - expected).abs() < 1e-10,
+            "lognormccdf at mean should be ln(0.5)"
+        );
+    }
+
+    #[test]
+    fn test_lognormcdf_extreme() {
+        // Very far in the tail - should still return finite value
+        let result = lognormcdf(-40.0, 0.0, 1.0);
+        assert!(result.is_ok(), "lognormcdf should handle extreme values");
+        assert!(
+            result.unwrap().is_finite(),
+            "lognormcdf should return finite value"
+        );
+    }
+
+    #[test]
+    fn test_lognormccdf_extreme() {
+        // Very far in the upper tail
+        let result = lognormccdf(40.0, 0.0, 1.0);
+        assert!(result.is_ok(), "lognormccdf should handle extreme values");
+        assert!(
+            result.unwrap().is_finite(),
+            "lognormccdf should return finite value"
+        );
+    }
+}
diff --git a/src/simulator/likelihood/matrix.rs b/src/simulator/likelihood/matrix.rs
new file mode 100644
index 00000000..1f45f936
--- /dev/null
+++ b/src/simulator/likelihood/matrix.rs
@@ -0,0 +1,233 @@
+//! Population-level log-likelihood matrix computation.
+//!
+//! This module provides functions for computing log-likelihood matrices
+//! across populations of subjects and parameter support points.
+
+use ndarray::{Array2, Axis, ShapeBuilder};
+use rayon::prelude::*;
+
+use crate::data::error_model::AssayErrorModels;
+use crate::{Data, Equation, PharmsolError};
+
+use super::progress::ProgressTracker;
+
+/// Options for log-likelihood matrix computation.
+///
+/// This struct replaces the boolean flags in the old `psi` function signature
+/// for better API clarity.
+#[derive(Debug, Clone)]
+pub struct LikelihoodMatrixOptions {
+    /// Show a progress bar during computation
+    pub show_progress: bool,
+    /// Use caching for repeated simulations
+    pub use_cache: bool,
+}
+
+impl Default for LikelihoodMatrixOptions {
+    fn default() -> Self {
+        Self {
+            show_progress: false,
+            use_cache: true,
+        }
+    }
+}
+
+impl LikelihoodMatrixOptions {
+    /// Create new options with default values
+    pub fn new() -> Self {
+        Self::default()
+    }
+
+    /// Enable progress bar display
+    pub fn with_progress(mut self) -> Self {
+        self.show_progress = true;
+        self
+    }
+
+    /// Disable progress bar display
+    pub fn without_progress(mut self) -> Self {
+        self.show_progress = false;
+        self
+    }
+
+    /// Enable simulation caching
+    pub fn with_cache(mut self) -> Self {
+        self.use_cache = true;
+        self
+    }
+
+    /// Disable simulation caching
+    pub fn without_cache(mut self) -> Self {
+        self.use_cache = false;
+        self
+    }
+}
+
+/// Calculate the log-likelihood matrix for all subjects and support points.
+///
+/// This function computes log-likelihoods directly in log-space, which is numerically
+/// more stable than computing likelihoods and then taking logarithms. This is especially
+/// important when dealing with many observations or extreme parameter values that could
+/// cause the regular likelihood to underflow to zero.
+///
+/// # Parameters
+/// - `equation`: The equation to use for simulation
+/// - `subjects`: The subject data
+/// - `support_points`: The support points to evaluate (rows = support points, cols = parameters)
+/// - `error_models`: The error models to use (observation-based sigma)
+/// - `options`: Computation options (progress bar, caching)
+///
+/// # Returns
+/// A 2D array of log-likelihoods with shape (n_subjects, n_support_points)
+///
+/// # Example
+/// ```ignore
+/// use pharmsol::prelude::simulator::{log_likelihood_matrix, LikelihoodMatrixOptions};
+///
+/// let log_liks = log_likelihood_matrix(
+///     &equation,
+///     &data,
+///     &support_points,
+///     &error_models,
+///     LikelihoodMatrixOptions::new().with_progress(),
+/// )?;
+/// ```
+pub fn log_likelihood_matrix(
+    equation: &impl Equation,
+    subjects: &Data,
+    support_points: &Array2<f64>,
+    error_models: &AssayErrorModels,
+    options: LikelihoodMatrixOptions,
+) -> Result<Array2<f64>, PharmsolError> {
+    let mut log_psi: Array2<f64> = Array2::default((subjects.len(), support_points.nrows()).f());
+
+    let subjects_vec = subjects.subjects();
+
+    let progress_tracker = if options.show_progress {
+        let total = subjects_vec.len() * support_points.nrows();
+        println!(
+            "Computing log-likelihood matrix: {} subjects × {} support points...",
+            subjects_vec.len(),
+            support_points.nrows()
+        );
+        Some(ProgressTracker::new(total))
+    } else {
+        None
+    };
+
+    let result: Result<(), PharmsolError> = log_psi
+        .axis_iter_mut(Axis(0))
+        .into_par_iter()
+        .enumerate()
+        .try_for_each(|(i, mut row)| {
+            row.axis_iter_mut(Axis(0))
+                .into_par_iter()
+                .enumerate()
+                .try_for_each(|(j, mut element)| {
+                    let subject = subjects_vec.get(i).unwrap();
+                    match equation.estimate_log_likelihood(
+                        subject,
+                        &support_points.row(j).to_vec(),
+                        error_models,
+                        options.use_cache,
+                    ) {
+                        Ok(log_likelihood) => {
+                            element.fill(log_likelihood);
+                            if let Some(ref tracker) = progress_tracker {
+                                tracker.inc();
+                            }
+                        }
+                        Err(e) => return Err(e),
+                    };
+                    Ok(())
+                })
+        });
+
+    if let Some(tracker) = progress_tracker {
+        tracker.finish();
+    }
+
+    result?;
+    Ok(log_psi)
+}
+
+/// Calculate the log-likelihood matrix (deprecated signature with boolean flags).
+///
+/// **Deprecated**: Use [`log_likelihood_matrix`] with [`LikelihoodMatrixOptions`] instead.
+///
+/// This function is provided for backward compatibility with the old `log_psi` API.
+#[deprecated(
+    since = "0.23.0",
+    note = "Use log_likelihood_matrix() with LikelihoodMatrixOptions instead"
+)]
+pub fn log_psi(
+    equation: &impl Equation,
+    subjects: &Data,
+    support_points: &Array2<f64>,
+    error_models: &AssayErrorModels,
+    progress: bool,
+    cache: bool,
+) -> Result<Array2<f64>, PharmsolError> {
+    let options = LikelihoodMatrixOptions {
+        show_progress: progress,
+        use_cache: cache,
+    };
+    log_likelihood_matrix(equation, subjects, support_points, error_models, options)
+}
+
+/// Calculate the likelihood matrix (deprecated).
+///
+/// **Deprecated**: Use [`log_likelihood_matrix`] instead. This function exponentiates
+/// the log-likelihood matrix, which can cause numerical underflow for many observations
+/// or extreme parameter values.
+///
+/// This function is provided for backward compatibility with the old `psi` API.
+#[deprecated(
+    since = "0.23.0",
+    note = "Use log_likelihood_matrix() instead and exponentiate if needed"
+)]
+pub fn psi(
+    equation: &impl Equation,
+    subjects: &Data,
+    support_points: &Array2<f64>,
+    error_models: &AssayErrorModels,
+    progress: bool,
+    cache: bool,
+) -> Result<Array2<f64>, PharmsolError> {
+    let options = LikelihoodMatrixOptions {
+        show_progress: progress,
+        use_cache: cache,
+    };
+    let log_psi_matrix =
+        log_likelihood_matrix(equation, subjects, support_points, error_models, options)?;
+
+    // Exponentiate to get likelihoods (may underflow to 0 for extreme values)
+    Ok(log_psi_matrix.mapv(f64::exp))
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_likelihood_matrix_options_builder() {
+        let opts = LikelihoodMatrixOptions::new().with_progress().with_cache();
+
+        assert!(opts.show_progress);
+        assert!(opts.use_cache);
+
+        let opts2 = LikelihoodMatrixOptions::new()
+            .without_progress()
+            .without_cache();
+
+        assert!(!opts2.show_progress);
+        assert!(!opts2.use_cache);
+    }
+
+    #[test]
+    fn test_default_options() {
+        let opts = LikelihoodMatrixOptions::default();
+        assert!(!opts.show_progress);
+        assert!(opts.use_cache);
+    }
+}
diff --git a/src/simulator/likelihood/mod.rs b/src/simulator/likelihood/mod.rs
index d629ffac..92750aab 100644
--- a/src/simulator/likelihood/mod.rs
+++ b/src/simulator/likelihood/mod.rs
@@ -1,593 +1,213 @@
-use crate::simulator::likelihood::progress::ProgressTracker;
-use crate::Censor;
-use crate::ErrorModelError;
-use crate::{
-    data::error_model::ErrorModels, Data, Equation, ErrorPoly, Observation, PharmsolError,
-    Predictions,
-};
-use ndarray::{Array2, Axis, ShapeBuilder};
-use rayon::prelude::*;
-use statrs::distribution::ContinuousCDF;
-use statrs::distribution::Normal;
-
+//! Likelihood calculation module for pharmacometric analyses.
+//!
+//! This module provides functions and types for computing log-likelihoods
+//! in pharmacometric population modeling. It supports both:
+//!
+//! - **Non-parametric algorithms** (NPAG, NPOD): Use [`ErrorModels`] with observation-based sigma
+//! - **Parametric algorithms** (SAEM, FOCE): Use [`ResidualErrorModels`] with prediction-based sigma
+//!
+//! # Module Organization
+//!
+//! - [`distributions`]: Statistical distribution functions (log-normal PDF, CDF)
+//! - [`prediction`]: Single observation-prediction pairs
+//! - [`subject`]: Subject-level prediction collections
+//! - [`matrix`]: Population-level log-likelihood matrix computation
+//!
+//! # Key Functions
+//!
+//! ## For Non-Parametric Algorithms
+//!
+//! Use [`log_likelihood_matrix`] to compute a matrix of log-likelihoods across
+//! all subjects and support points:
+//!
+//! ```ignore
+//! use pharmsol::prelude::simulator::{log_likelihood_matrix, LikelihoodMatrixOptions};
+//!
+//! let log_liks = log_likelihood_matrix(
+//!     &equation,
+//!     &data,
+//!     &support_points,
+//!     &error_models,
+//!     LikelihoodMatrixOptions::new().with_progress(),
+//! )?;
+//! ```
+//!
+//! ## For Parametric Algorithms
+//!
+//! Use [`log_likelihood_batch`] when each subject has individual parameters:
+//!
+//! ```ignore
+//! use pharmsol::prelude::simulator::log_likelihood_batch;
+//!
+//! let log_liks = log_likelihood_batch(
+//!     &equation,
+//!     &data,
+//!     &parameters,
+//!     &residual_error_models,
+//! )?;
+//! ```
+//!
+//! # Numerical Stability
+//!
+//! All likelihood functions operate in log-space for numerical stability.
+//! The deprecated `likelihood()` and `psi()` functions are provided for
+//! backward compatibility but should be avoided in new code.
+
+mod distributions;
+mod matrix;
+mod prediction;
 mod progress;
+mod subject;
 
-const FRAC_1_SQRT_2PI: f64 =
-    std::f64::consts::FRAC_2_SQRT_PI * std::f64::consts::FRAC_1_SQRT_2 / 2.0;
-
-// ln(2π) = ln(2) + ln(π) ≈ 1.8378770664093453
-const LOG_2PI: f64 = 1.8378770664093453_f64;
-
-/// Container for predictions associated with a single subject.
-///
-/// This struct holds all predictions for a subject along with the corresponding
-/// observations and time points.
-#[derive(Debug, Clone, Default)]
-pub struct SubjectPredictions {
-    predictions: Vec<Prediction>,
-}
-
-impl Predictions for SubjectPredictions {
-    fn squared_error(&self) -> f64 {
-        self.predictions
-            .iter()
-            .filter_map(|p| p.observation.map(|obs| (obs - p.prediction).powi(2)))
-            .sum()
-    }
-    fn get_predictions(&self) -> Vec<Prediction> {
-        self.predictions.clone()
-    }
-    fn log_likelihood(&self, error_models: &ErrorModels) -> Result<f64, PharmsolError> {
-        SubjectPredictions::log_likelihood(self, error_models)
-    }
-}
-
-impl SubjectPredictions {
-    /// Calculate the likelihood of the predictions given an error model.
-    ///
-    /// This multiplies the likelihood of each prediction to get the joint likelihood.
-    ///
-    /// # Parameters
-    /// - `error_model`: The error model to use for calculating the likelihood
-    ///
-    /// # Returns
-    /// The product of all individual prediction likelihoods
-    pub fn likelihood(&self, error_models: &ErrorModels) -> Result<f64, PharmsolError> {
-        match self.predictions.is_empty() {
-            true => Ok(1.0),
-            false => self
-                .predictions
-                .iter()
-                .filter(|p| p.observation.is_some())
-                .map(|p| p.likelihood(error_models))
-                .collect::<Result<Vec<f64>, _>>()
-                .map(|likelihoods| likelihoods.iter().product())
-                .map_err(PharmsolError::from),
-        }
-    }
-
-    /// Calculate the log-likelihood of the predictions given an error model.
-    ///
-    /// This sums the log-likelihood of each prediction to get the joint log-likelihood.
-    /// This is numerically more stable than computing the product of likelihoods,
-    /// especially for many observations or extreme values.
-    ///
-    /// # Parameters
-    /// - `error_models`: The error models to use for calculating the likelihood
-    ///
-    /// # Returns
-    /// The sum of all individual prediction log-likelihoods
-    pub fn log_likelihood(&self, error_models: &ErrorModels) -> Result<f64, PharmsolError> {
-        if self.predictions.is_empty() {
-            return Ok(0.0); // log(0) for empty predictions
-        }
-
-        let log_liks: Result<Vec<f64>, _> = self
-            .predictions
-            .iter()
-            .filter(|p| p.observation.is_some())
-            .map(|p| p.log_likelihood(error_models))
-            .collect();
-
-        log_liks.map(|lls| lls.iter().sum())
-    }
-
-    /// Add a new prediction to the collection.
-    ///
-    /// This updates both the main predictions vector and the flat vectors.
-    ///
-    /// # Parameters
-    /// - `prediction`: The prediction to add
-    pub fn add_prediction(&mut self, prediction: Prediction) {
-        self.predictions.push(prediction.clone());
-    }
-
-    /// Get a reference to a vector of predictions.
-    ///
-    /// # Returns
-    /// Vector of observation values
-    pub fn predictions(&self) -> &Vec<Prediction> {
-        &self.predictions
-    }
-
-    /// Return a flat vector of predictions.
-    pub fn flat_predictions(&self) -> Vec<f64> {
-        self.predictions
-            .iter()
-            .map(|p| p.prediction)
-            .collect::<Vec<f64>>()
-    }
-
-    /// Return a flat vector of predictions.
-    pub fn flat_times(&self) -> Vec<f64> {
-        self.predictions
-            .iter()
-            .map(|p| p.time)
-            .collect::<Vec<f64>>()
-    }
-
-    /// Return a flat vector of observations.
-    pub fn flat_observations(&self) -> Vec<Option<f64>> {
-        self.predictions
-            .iter()
-            .map(|p| p.observation)
-            .collect::<Vec<Option<f64>>>()
-    }
-}
-
-/// Probability density function of the normal distribution
-#[inline(always)]
-fn normpdf(obs: f64, pred: f64, sigma: f64) -> f64 {
-    (FRAC_1_SQRT_2PI / sigma) * (-((obs - pred) * (obs - pred)) / (2.0 * sigma * sigma)).exp()
-}
-
-/// Log of the probability density function of the normal distribution.
-///
-/// This is numerically stable and avoids underflow for extreme values.
-/// Returns: -0.5 * ln(2π) - ln(σ) - (obs - pred)² / (2σ²)
-#[inline(always)]
-fn lognormpdf(obs: f64, pred: f64, sigma: f64) -> f64 {
-    let diff = obs - pred;
-    -0.5 * LOG_2PI - sigma.ln() - (diff * diff) / (2.0 * sigma * sigma)
-}
-
-/// Log of the cumulative distribution function of the normal distribution.
-///
-/// Uses the error function for numerical stability.
-#[inline(always)]
-fn lognormcdf(obs: f64, pred: f64, sigma: f64) -> Result<f64, ErrorModelError> {
-    let norm = Normal::new(pred, sigma).map_err(|_| ErrorModelError::NegativeSigma)?;
-    let cdf = norm.cdf(obs);
-    if cdf <= 0.0 {
-        // For extremely small CDF values, use an approximation
-        // log(Φ(x)) ≈ log(φ(x)) - log(-x) for large negative x
-        // where x = (obs - pred) / sigma
-        let z = (obs - pred) / sigma;
-        if z < -37.0 {
-            // Below this, cdf is essentially 0, use asymptotic approximation
-            Ok(lognormpdf(obs, pred, sigma) - z.abs().ln())
-        } else {
-            Err(ErrorModelError::NegativeSigma) // Indicates numerical issue
-        }
-    } else {
-        Ok(cdf.ln())
-    }
-}
+// Re-export main types
+pub use matrix::{log_likelihood_matrix, LikelihoodMatrixOptions};
+pub use prediction::Prediction;
+pub use subject::{PopulationPredictions, SubjectPredictions};
 
-/// Log of the survival function (1 - CDF) of the normal distribution.
-#[inline(always)]
-fn lognormccdf(obs: f64, pred: f64, sigma: f64) -> Result<f64, ErrorModelError> {
-    let norm = Normal::new(pred, sigma).map_err(|_| ErrorModelError::NegativeSigma)?;
-    let sf = 1.0 - norm.cdf(obs);
-    if sf <= 0.0 {
-        let z = (obs - pred) / sigma;
-        if z > 37.0 {
-            // Use asymptotic approximation for upper tail
-            Ok(lognormpdf(obs, pred, sigma) - z.ln())
-        } else {
-            Err(ErrorModelError::NegativeSigma)
-        }
-    } else {
-        Ok(sf.ln())
-    }
-}
+// Deprecated re-exports for backward compatibility
+#[allow(deprecated)]
+pub use matrix::{log_psi, psi};
 
-#[inline(always)]
-fn normcdf(obs: f64, pred: f64, sigma: f64) -> Result<f64, ErrorModelError> {
-    let norm = Normal::new(pred, sigma).map_err(|_| ErrorModelError::NegativeSigma)?;
-    Ok(norm.cdf(obs))
-}
+use ndarray::Array2;
+use rayon::prelude::*;
 
-impl From<Vec<Prediction>> for SubjectPredictions {
-    fn from(predictions: Vec<Prediction>) -> Self {
-        Self {
-            predictions: predictions.to_vec(),
-        }
-    }
-}
+use crate::{Data, Equation, PharmsolError, Predictions, Subject};
 
-/// Container for predictions across a population of subjects.
+/// Compute log-likelihoods for all subjects in parallel, where each subject
+/// has its own parameter vector.
 ///
-/// This struct holds predictions for multiple subjects organized in a 2D array.
-pub struct PopulationPredictions {
-    /// 2D array of subject predictions
-    pub subject_predictions: Array2<SubjectPredictions>,
-}
-
-impl Default for PopulationPredictions {
-    fn default() -> Self {
-        Self {
-            subject_predictions: Array2::default((0, 0)),
-        }
-    }
-}
-
-impl From<Array2<SubjectPredictions>> for PopulationPredictions {
-    fn from(subject_predictions: Array2<SubjectPredictions>) -> Self {
-        Self {
-            subject_predictions,
-        }
-    }
-}
-
-/// Calculate the psi matrix for maximum likelihood estimation.
+/// This function simulates each subject with their individual parameters and
+/// computes log-likelihood using prediction-based sigma (appropriate for
+/// parametric algorithms like SAEM, FOCE).
 ///
 /// # Parameters
 /// - `equation`: The equation to use for simulation
-/// - `subjects`: The subject data
-/// - `support_points`: The support points to evaluate
-/// - `error_model`: The error model to use
-/// - `progress`: Whether to show a progress bar
-/// - `cache`: Whether to use caching
+/// - `subjects`: The subject data (N subjects)
+/// - `parameters`: Parameter vectors for each subject (N × P matrix, row i = params for subject i)
+/// - `residual_error_models`: The residual error models (prediction-based sigma)
 ///
 /// # Returns
-/// A 2D array of likelihoods
-pub fn psi(
+/// A vector of N log-likelihoods, one per subject. Returns `f64::NEG_INFINITY`
+/// for subjects where simulation fails.
+///
+/// # Example
+/// ```ignore
+/// use pharmsol::prelude::simulator::log_likelihood_batch;
+/// use pharmsol::{ResidualErrorModel, ResidualErrorModels};
+///
+/// let residual_error = ResidualAssayErrorModels::new()
+///     .add(0, ResidualErrorModel::constant(0.5));
+///
+/// let log_liks = log_likelihood_batch(
+///     &equation,
+///     &data,
+///     &parameters,
+///     &residual_error,
+/// )?;
+/// ```
+pub fn log_likelihood_batch(
     equation: &impl Equation,
     subjects: &Data,
-    support_points: &Array2<f64>,
-    error_models: &ErrorModels,
-    progress: bool,
-    cache: bool,
-) -> Result<Array2<f64>, PharmsolError> {
-    let mut psi: Array2<f64> = Array2::default((subjects.len(), support_points.nrows()).f());
-
-    let subjects = subjects.subjects();
-
-    let progress_tracker = if progress {
-        let total = subjects.len() * support_points.nrows();
-        println!(
-            "Simulating {} subjects with {} support points each...",
-            subjects.len(),
-            support_points.nrows()
-        );
-        Some(ProgressTracker::new(total))
-    } else {
-        None
-    };
-
-    let result: Result<(), PharmsolError> = psi
-        .axis_iter_mut(Axis(0))
+    parameters: &Array2<f64>,
+    residual_error_models: &crate::ResidualErrorModels,
+) -> Result<Vec<f64>, PharmsolError> {
+    let subjects_vec = subjects.subjects();
+    let n_subjects = subjects_vec.len();
+
+    if parameters.nrows() != n_subjects {
+        return Err(PharmsolError::OtherError(format!(
+            "parameters has {} rows but there are {} subjects",
+            parameters.nrows(),
+            n_subjects
+        )));
+    }
+
+    // Parallel computation across subjects
+    let results: Vec<f64> = (0..n_subjects)
         .into_par_iter()
-        .enumerate()
-        .try_for_each(|(i, mut row)| {
-            row.axis_iter_mut(Axis(0))
-                .into_par_iter()
-                .enumerate()
-                .try_for_each(|(j, mut element)| {
-                    let subject = subjects.get(i).unwrap();
-                    match equation.estimate_likelihood(
-                        subject,
-                        support_points.row(j).to_vec().as_ref(),
-                        error_models,
-                        cache,
-                    ) {
-                        Ok(likelihood) => {
-                            element.fill(likelihood);
-                            if let Some(ref tracker) = progress_tracker {
-                                tracker.inc();
-                            }
-                        }
-                        Err(e) => return Err(e),
-                    };
-                    Ok(())
-                })
-        });
-
-    if let Some(tracker) = progress_tracker {
-        tracker.finish();
-    }
-
-    result?;
-    Ok(psi)
+        .map(|i| {
+            let subject = &subjects_vec[i];
+            let params = parameters.row(i).to_vec();
+
+            // Simulate to get predictions
+            let predictions = match equation.estimate_predictions(subject, &params) {
+                Ok(preds) => preds,
+                Err(_) => return f64::NEG_INFINITY,
+            };
+
+            // Extract (outeq, observation, prediction) tuples and compute log-likelihood
+            let obs_pred_pairs = predictions
+                .get_predictions()
+                .into_iter()
+                .filter_map(|pred| {
+                    pred.observation()
+                        .map(|obs| (pred.outeq(), obs, pred.prediction()))
+                });
+
+            residual_error_models.total_log_likelihood(obs_pred_pairs)
+        })
+        .collect();
+
+    Ok(results)
 }
 
-/// Calculate the log-likelihood matrix for all subjects and support points.
+/// Compute log-likelihood for a single subject using prediction-based sigma.
 ///
-/// This function computes log-likelihoods directly in log-space, which is numerically
-/// more stable than computing likelihoods and then taking logarithms. This is especially
-/// important when dealing with many observations or extreme parameter values that could
-/// cause the regular likelihood to underflow to zero.
+/// This is the single-subject equivalent of [`log_likelihood_batch`].
+/// It simulates the model, extracts observation-prediction pairs, and computes
+/// the log-likelihood using [`crate::ResidualErrorModels`].
 ///
 /// # Parameters
 /// - `equation`: The equation to use for simulation
-/// - `subjects`: The subject data
-/// - `support_points`: The support points to evaluate
-/// - `error_model`: The error model to use
-/// - `progress`: Whether to show a progress bar
-/// - `cache`: Whether to use caching
+/// - `subject`: The subject data
+/// - `params`: Parameter vector for this subject
+/// - `residual_error_models`: The residual error models (prediction-based sigma)
 ///
 /// # Returns
-/// A 2D array of log-likelihoods with shape (n_subjects, n_support_points)
-#[allow(dead_code)]
-pub fn log_psi(
+/// The log-likelihood for this subject. Returns `f64::NEG_INFINITY` on simulation error.
+///
+/// # Example
+/// ```ignore
+/// use pharmsol::prelude::simulator::log_likelihood_subject;
+///
+/// let log_lik = log_likelihood_subject(
+///     &equation,
+///     &subject,
+///     &params,
+///     &residual_error_models,
+/// );
+/// ```
+pub fn log_likelihood_subject(
     equation: &impl Equation,
-    subjects: &Data,
-    support_points: &Array2<f64>,
-    error_models: &ErrorModels,
-    progress: bool,
-    cache: bool,
-) -> Result<Array2<f64>, PharmsolError> {
-    let mut log_psi: Array2<f64> = Array2::default((subjects.len(), support_points.nrows()).f());
-
-    let subjects = subjects.subjects();
-
-    let progress_tracker = if progress {
-        let total = subjects.len() * support_points.nrows();
-        println!(
-            "Simulating {} subjects with {} support points each...",
-            subjects.len(),
-            support_points.nrows()
-        );
-        Some(ProgressTracker::new(total))
-    } else {
-        None
+    subject: &Subject,
+    params: &[f64],
+    residual_error_models: &crate::ResidualErrorModels,
+) -> f64 {
+    // Simulate to get predictions
+    let predictions = match equation.estimate_predictions(subject, &params.to_vec()) {
+        Ok(preds) => preds,
+        Err(_) => return f64::NEG_INFINITY,
     };
 
-    let result: Result<(), PharmsolError> = log_psi
-        .axis_iter_mut(Axis(0))
-        .into_par_iter()
-        .enumerate()
-        .try_for_each(|(i, mut row)| {
-            row.axis_iter_mut(Axis(0))
-                .into_par_iter()
-                .enumerate()
-                .try_for_each(|(j, mut element)| {
-                    let subject = subjects.get(i).unwrap();
-                    match equation.estimate_log_likelihood(
-                        subject,
-                        support_points.row(j).to_vec().as_ref(),
-                        error_models,
-                        cache,
-                    ) {
-                        Ok(log_likelihood) => {
-                            element.fill(log_likelihood);
-                            if let Some(ref tracker) = progress_tracker {
-                                tracker.inc();
-                            }
-                        }
-                        Err(e) => return Err(e),
-                    };
-                    Ok(())
-                })
+    // Extract (outeq, observation, prediction) tuples and compute log-likelihood
+    let obs_pred_pairs = predictions
+        .get_predictions()
+        .into_iter()
+        .filter_map(|pred| {
+            pred.observation()
+                .map(|obs| (pred.outeq(), obs, pred.prediction()))
         });
 
-    if let Some(tracker) = progress_tracker {
-        tracker.finish();
-    }
-
-    result?;
-    Ok(log_psi)
-}
-
-/// Prediction holds an observation and its prediction
-#[derive(Debug, Clone)]
-pub struct Prediction {
-    pub(crate) time: f64,
-    pub(crate) observation: Option<f64>,
-    pub(crate) prediction: f64,
-    pub(crate) outeq: usize,
-    pub(crate) errorpoly: Option<ErrorPoly>,
-    pub(crate) state: Vec<f64>,
-    pub(crate) occasion: usize,
-    pub(crate) censoring: Censor,
-}
-
-impl Prediction {
-    /// Get the time point of this prediction.
-    pub fn time(&self) -> f64 {
-        self.time
-    }
-
-    /// Get the observed value.
-    pub fn observation(&self) -> Option<f64> {
-        self.observation
-    }
-
-    /// Get the predicted value.
-    pub fn prediction(&self) -> f64 {
-        self.prediction
-    }
-
-    /// Set the predicted value
-    pub(crate) fn set_prediction(&mut self, prediction: f64) {
-        self.prediction = prediction;
-    }
-
-    /// Get the output equation index.
-    pub fn outeq(&self) -> usize {
-        self.outeq
-    }
-
-    /// Get the error polynomial coefficients, if available.
-    pub fn errorpoly(&self) -> Option<ErrorPoly> {
-        self.errorpoly
-    }
-
-    /// Calculate the raw prediction error (prediction - observation).
-    pub fn prediction_error(&self) -> Option<f64> {
-        self.observation.map(|obs| self.prediction - obs)
-    }
-
-    /// Calculate the percentage error as (prediction - observation)/observation * 100.
-    pub fn percentage_error(&self) -> Option<f64> {
-        self.observation
-            .map(|obs| ((self.prediction - obs) / obs) * 100.0)
-    }
-
-    /// Calculate the absolute error |prediction - observation|.
-    pub fn absolute_error(&self) -> Option<f64> {
-        self.observation.map(|obs| (self.prediction - obs).abs())
-    }
-
-    /// Calculate the squared error (prediction - observation)².
-    pub fn squared_error(&self) -> Option<f64> {
-        self.observation.map(|obs| (self.prediction - obs).powi(2))
-    }
-
-    /// Calculate the likelihood of this prediction given an error model.
-    ///
-    /// Returns an error if the observation is missing or if the likelihood is either zero or non-finite.
-    pub fn likelihood(&self, error_models: &ErrorModels) -> Result<f64, PharmsolError> {
-        if self.observation.is_none() {
-            return Err(PharmsolError::MissingObservation);
-        }
-
-        let sigma = error_models.sigma(self)?;
-
-        //TODO: For the BLOQ and ALOQ cases, we should be using the LOQ values, not the observation values.
-        let likelihood = match self.censoring {
-            Censor::None => normpdf(self.observation.unwrap(), self.prediction, sigma),
-            Censor::BLOQ => normcdf(self.observation.unwrap(), self.prediction, sigma)?,
-            Censor::ALOQ => 1.0 - normcdf(self.observation.unwrap(), self.prediction, sigma)?,
-        };
-
-        if likelihood.is_finite() {
-            Ok(likelihood)
-        } else if likelihood == 0.0 {
-            Err(PharmsolError::ZeroLikelihood)
-        } else {
-            Err(PharmsolError::NonFiniteLikelihood(likelihood))
-        }
-    }
-
-    /// Calculate the log-likelihood of this prediction given an error model.
-    ///
-    /// This method is numerically stable and avoids underflow issues that can occur
-    /// with the standard likelihood calculation for extreme values.
-    ///
-    /// Returns an error if the observation is missing or if the log-likelihood is non-finite.
-    #[inline]
-    pub fn log_likelihood(&self, error_models: &ErrorModels) -> Result<f64, PharmsolError> {
-        if self.observation.is_none() {
-            return Err(PharmsolError::MissingObservation);
-        }
-
-        let sigma = error_models.sigma(self)?;
-        let obs = self.observation.unwrap();
-
-        let log_lik = match self.censoring {
-            Censor::None => lognormpdf(obs, self.prediction, sigma),
-            Censor::BLOQ => lognormcdf(obs, self.prediction, sigma)?,
-            Censor::ALOQ => lognormccdf(obs, self.prediction, sigma)?,
-        };
-
-        if log_lik.is_finite() {
-            Ok(log_lik)
-        } else {
-            Err(PharmsolError::NonFiniteLikelihood(log_lik))
-        }
-    }
-
-    /// Get the state vector at this prediction point
-    pub fn state(&self) -> &Vec<f64> {
-        &self.state
-    }
-
-    /// Get the occasion index
-    pub fn occasion(&self) -> usize {
-        self.occasion
-    }
-
-    /// Get a mutable reference to the occasion index
-    pub fn mut_occasion(&mut self) -> &mut usize {
-        &mut self.occasion
-    }
-
-    /// Get the censoring status
-    pub fn censoring(&self) -> Censor {
-        self.censoring
-    }
-
-    /// Create an [Observation] from this prediction
-    pub fn to_observation(&self) -> Observation {
-        Observation::new(
-            self.time,
-            self.observation,
-            self.outeq,
-            self.errorpoly,
-            self.occasion,
-            self.censoring,
-        )
-    }
-}
-
-impl Default for Prediction {
-    fn default() -> Self {
-        Self {
-            time: 0.0,
-            observation: None,
-            prediction: 0.0,
-            outeq: 0,
-            errorpoly: None,
-            state: vec![],
-            occasion: 0,
-            censoring: Censor::None,
-        }
-    }
-}
-
-// Implement display for Prediction
-impl std::fmt::Display for Prediction {
-    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
-        let obs_str = match self.observation {
-            Some(obs) => format!("{:.4}", obs),
-            None => "NA".to_string(),
-        };
-        write!(
-            f,
-            "Time: {:.2}\tObs: {:.4}\tPred: {:.4}\tOuteq: {:.2}",
-            self.time, obs_str, self.prediction, self.outeq
-        )
-    }
+    residual_error_models.total_log_likelihood(obs_pred_pairs)
 }
 
 #[cfg(test)]
 mod tests {
     use super::*;
-    use crate::data::error_model::{ErrorModel, ErrorPoly};
+    use crate::data::error_model::{AssayErrorModel, ErrorPoly};
     use crate::data::event::Observation;
     use crate::Censor;
 
-    #[test]
-    fn empty_predictions_have_neutral_likelihood() {
-        let preds = SubjectPredictions::default();
-        let errors = ErrorModels::new();
-        assert_eq!(preds.likelihood(&errors).unwrap(), 1.0);
-    }
-
-    #[test]
-    fn likelihood_combines_observations() {
-        let mut preds = SubjectPredictions::default();
-        let obs = Observation::new(0.0, Some(1.0), 0, None, 0, Censor::None);
-        preds.add_prediction(obs.to_prediction(1.0, vec![]));
-
-        let error_model = ErrorModel::additive(ErrorPoly::new(1.0, 0.0, 0.0, 0.0), 0.0);
-        let errors = ErrorModels::new().add(0, error_model).unwrap();
-
-        assert!(preds.likelihood(&errors).unwrap() > 0.0);
-    }
-
     #[test]
     fn test_log_likelihood_equals_log_of_likelihood() {
         // Create a prediction with an observation
@@ -603,13 +223,14 @@ mod tests {
         };
 
         // Create error model with additive error
-        let error_models = ErrorModels::new()
+        let error_models = crate::AssayErrorModels::new()
             .add(
                 0,
-                ErrorModel::additive(ErrorPoly::new(0.0, 1.0, 0.0, 0.0), 0.0),
+                AssayErrorModel::additive(ErrorPoly::new(0.0, 1.0, 0.0, 0.0), 0.0),
             )
             .unwrap();
 
+        #[allow(deprecated)]
         let lik = prediction.likelihood(&error_models).unwrap();
         let log_lik = prediction.log_likelihood(&error_models).unwrap();
 
@@ -623,95 +244,6 @@ mod tests {
         );
     }
 
-    #[test]
-    fn test_log_likelihood_numerical_stability() {
-        // Test with values that would cause very small likelihood
-        let prediction = Prediction {
-            time: 1.0,
-            observation: Some(10.0),
-            prediction: 30.0, // Far from observation (20 sigma away with sigma=1)
-            outeq: 0,
-            errorpoly: None,
-            state: vec![30.0],
-            occasion: 0,
-            censoring: Censor::None,
-        };
-
-        // Using c0=1.0 (constant error term) to ensure sigma=1 regardless of observation
-        let error_models = ErrorModels::new()
-            .add(
-                0,
-                ErrorModel::additive(ErrorPoly::new(1.0, 0.0, 0.0, 0.0), 0.0),
-            )
-            .unwrap();
-
-        // Regular likelihood will be extremely small but non-zero
-        let lik = prediction.likelihood(&error_models).unwrap();
-
-        // log_likelihood should give a finite (very negative) value
-        let log_lik = prediction.log_likelihood(&error_models).unwrap();
-
-        assert!(log_lik.is_finite(), "log_likelihood should be finite");
-        assert!(
-            log_lik < -100.0,
-            "log_likelihood should be very negative for large mismatch"
-        );
-
-        // They should match: log_lik ≈ ln(lik)
-        if lik > 0.0 && lik.ln().is_finite() {
-            let diff = (log_lik - lik.ln()).abs();
-            assert!(
-                diff < 1e-6,
-                "log_likelihood ({}) should equal ln(likelihood) ({}) for non-extreme cases, diff={}",
-                log_lik,
-                lik.ln(),
-                diff
-            );
-        }
-    }
-
-    #[test]
-    fn test_log_likelihood_extreme_underflow() {
-        // Test with truly extreme values where regular likelihood underflows to 0
-        let prediction = Prediction {
-            time: 1.0,
-            observation: Some(10.0),
-            prediction: 50.0, // 40 sigma away - regular pdf ≈ 10^{-350}
-            outeq: 0,
-            errorpoly: None,
-            state: vec![50.0],
-            occasion: 0,
-            censoring: Censor::None,
-        };
-
-        // Using c0=1.0 (constant error term) to ensure sigma=1 regardless of observation
-        let error_models = ErrorModels::new()
-            .add(
-                0,
-                ErrorModel::additive(ErrorPoly::new(1.0, 0.0, 0.0, 0.0), 0.0),
-            )
-            .unwrap();
-
-        // Regular likelihood may underflow to 0
-        let _lik_result = prediction.likelihood(&error_models);
-
-        // log_likelihood should still work
-        let log_lik = prediction.log_likelihood(&error_models).unwrap();
-
-        assert!(
-            log_lik.is_finite(),
-            "log_likelihood should be finite even for extreme values"
-        );
-        assert!(log_lik < -100.0, "log_likelihood should be very negative");
-
-        // For 40 sigma away: log_lik ≈ -0.5*ln(2π) - ln(1) - (40)^2/2 ≈ -800
-        assert!(
-            log_lik < -700.0 && log_lik > -900.0,
-            "log_likelihood ({}) should be approximately -800 for 40 sigma away",
-            log_lik
-        );
-    }
-
     #[test]
     fn test_subject_predictions_log_likelihood() {
         let predictions = vec![
@@ -738,13 +270,14 @@ mod tests {
         ];
 
         let subject_predictions = SubjectPredictions::from(predictions);
-        let error_models = ErrorModels::new()
+        let error_models = crate::AssayErrorModels::new()
             .add(
                 0,
-                ErrorModel::additive(ErrorPoly::new(0.0, 1.0, 0.0, 0.0), 0.0),
+                AssayErrorModel::additive(ErrorPoly::new(0.0, 1.0, 0.0, 0.0), 0.0),
             )
             .unwrap();
 
+        #[allow(deprecated)]
         let lik = subject_predictions.likelihood(&error_models).unwrap();
         let log_lik = subject_predictions.log_likelihood(&error_models).unwrap();
 
@@ -758,19 +291,43 @@ mod tests {
         );
     }
 
+    #[test]
+    fn test_empty_predictions_have_neutral_log_likelihood() {
+        let preds = SubjectPredictions::default();
+        let errors = crate::AssayErrorModels::new();
+        assert_eq!(preds.log_likelihood(&errors).unwrap(), 0.0); // log(1) = 0
+    }
+
+    #[test]
+    fn test_log_likelihood_combines_observations() {
+        let mut preds = SubjectPredictions::default();
+        let obs = Observation::new(0.0, Some(1.0), 0, None, 0, Censor::None);
+        preds.add_prediction(obs.to_prediction(1.0, vec![]));
+
+        let error_model = AssayErrorModel::additive(ErrorPoly::new(1.0, 0.0, 0.0, 0.0), 0.0);
+        let errors = crate::AssayErrorModels::new().add(0, error_model).unwrap();
+
+        let log_lik = preds.log_likelihood(&errors).unwrap();
+        assert!(log_lik.is_finite());
+        assert!(log_lik <= 0.0); // Log likelihood is always <= 0
+    }
+
     #[test]
     fn test_lognormpdf_direct() {
+        use super::distributions::lognormpdf;
+
         // Test the helper function directly
         let obs = 0.0;
         let pred = 0.0;
         let sigma = 1.0;
 
-        let pdf = normpdf(obs, pred, sigma);
         let log_pdf = lognormpdf(obs, pred, sigma);
 
+        // At mean of standard normal, log PDF = -0.5 * ln(2π)
+        let expected = -0.5 * distributions::LOG_2PI;
         assert!(
-            (log_pdf - pdf.ln()).abs() < 1e-12,
-            "lognormpdf should equal ln(normpdf)"
+            (log_pdf - expected).abs() < 1e-12,
+            "lognormpdf at mean should be -0.5*ln(2π)"
         );
     }
 }
diff --git a/src/simulator/likelihood/prediction.rs b/src/simulator/likelihood/prediction.rs
new file mode 100644
index 00000000..a9dc95b5
--- /dev/null
+++ b/src/simulator/likelihood/prediction.rs
@@ -0,0 +1,303 @@
+//! Single-point prediction and likelihood calculation.
+//!
+//! This module contains the [`Prediction`] struct which holds a single
+//! observation-prediction pair along with metadata needed for likelihood
+//! calculation.
+
+use crate::data::error_model::AssayErrorModels;
+use crate::data::event::Observation;
+use crate::{Censor, ErrorPoly, PharmsolError};
+
+use super::distributions::{lognormccdf, lognormcdf, lognormpdf};
+
+/// Prediction holds an observation and its prediction at a single time point.
+///
+/// This struct contains all information needed to calculate the likelihood
+/// contribution of a single observation.
+#[derive(Debug, Clone)]
+pub struct Prediction {
+    pub(crate) time: f64,
+    pub(crate) observation: Option<f64>,
+    pub(crate) prediction: f64,
+    pub(crate) outeq: usize,
+    pub(crate) errorpoly: Option<ErrorPoly>,
+    pub(crate) state: Vec<f64>,
+    pub(crate) occasion: usize,
+    pub(crate) censoring: Censor,
+}
+
+impl Prediction {
+    /// Get the time point of this prediction.
+    pub fn time(&self) -> f64 {
+        self.time
+    }
+
+    /// Get the observed value.
+    pub fn observation(&self) -> Option<f64> {
+        self.observation
+    }
+
+    /// Get the predicted value.
+    pub fn prediction(&self) -> f64 {
+        self.prediction
+    }
+
+    /// Set the predicted value
+    pub(crate) fn set_prediction(&mut self, prediction: f64) {
+        self.prediction = prediction;
+    }
+
+    /// Get the output equation index.
+    pub fn outeq(&self) -> usize {
+        self.outeq
+    }
+
+    /// Get the error polynomial coefficients, if available.
+    pub fn errorpoly(&self) -> Option<ErrorPoly> {
+        self.errorpoly
+    }
+
+    /// Calculate the raw prediction error (prediction - observation).
+    pub fn prediction_error(&self) -> Option<f64> {
+        self.observation.map(|obs| self.prediction - obs)
+    }
+
+    /// Calculate the percentage error as (prediction - observation)/observation * 100.
+    pub fn percentage_error(&self) -> Option<f64> {
+        self.observation
+            .map(|obs| ((self.prediction - obs) / obs) * 100.0)
+    }
+
+    /// Calculate the absolute error |prediction - observation|.
+    pub fn absolute_error(&self) -> Option<f64> {
+        self.observation.map(|obs| (self.prediction - obs).abs())
+    }
+
+    /// Calculate the squared error (prediction - observation)².
+    pub fn squared_error(&self) -> Option<f64> {
+        self.observation.map(|obs| (self.prediction - obs).powi(2))
+    }
+
+    /// Calculate the log-likelihood of this prediction given an error model.
+    ///
+    /// This method is numerically stable and handles:
+    /// - Regular observations: uses log-normal PDF
+    /// - BLOQ (below limit of quantification): uses log-CDF
+    /// - ALOQ (above limit of quantification): uses log-survival function
+    ///
+    /// # Error Model
+    /// Uses observation-based sigma from [`AssayErrorModels`], which is appropriate
+    /// for non-parametric algorithms (NPAG, NPOD). For parametric algorithms
+    /// (SAEM, FOCE), use [`crate::ResidualErrorModels`] directly.
+    ///
+    /// # Parameters
+    /// - `error_models`: The error models to use for sigma calculation
+    ///
+    /// # Returns
+    /// The log-likelihood value, or an error if:
+    /// - The observation is missing
+    /// - The log-likelihood is non-finite
+    ///
+    /// # Example
+    /// ```ignore
+    /// let log_lik = prediction.log_likelihood(&error_models)?;
+    /// ```
+    #[inline]
+    pub fn log_likelihood(&self, error_models: &AssayErrorModels) -> Result<f64, PharmsolError> {
+        if self.observation.is_none() {
+            return Err(PharmsolError::MissingObservation);
+        }
+
+        let sigma = error_models.sigma(self)?;
+        let obs = self.observation.unwrap();
+
+        let log_lik = match self.censoring {
+            Censor::None => lognormpdf(obs, self.prediction, sigma),
+            Censor::BLOQ => lognormcdf(obs, self.prediction, sigma)?,
+            Censor::ALOQ => lognormccdf(obs, self.prediction, sigma)?,
+        };
+
+        if log_lik.is_finite() {
+            Ok(log_lik)
+        } else {
+            Err(PharmsolError::NonFiniteLikelihood(log_lik))
+        }
+    }
+
+    /// Calculate the likelihood of this prediction.
+    ///
+    /// **Deprecated**: Use [`log_likelihood`](Self::log_likelihood) instead for
+    /// better numerical stability. This method is provided for backward
+    /// compatibility and simply exponentiates the log-likelihood.
+    ///
+    /// # Parameters
+    /// - `error_models`: The error models to use for sigma calculation
+    ///
+    /// # Returns
+    /// The likelihood value (exp of log-likelihood)
+    #[deprecated(
+        since = "0.23.0",
+        note = "Use log_likelihood() instead for better numerical stability"
+    )]
+    pub fn likelihood(&self, error_models: &AssayErrorModels) -> Result<f64, PharmsolError> {
+        let log_lik = self.log_likelihood(error_models)?;
+        let lik = log_lik.exp();
+
+        if lik.is_finite() {
+            Ok(lik)
+        } else if lik == 0.0 {
+            Err(PharmsolError::ZeroLikelihood)
+        } else {
+            Err(PharmsolError::NonFiniteLikelihood(lik))
+        }
+    }
+
+    /// Get the state vector at this prediction point
+    pub fn state(&self) -> &Vec<f64> {
+        &self.state
+    }
+
+    /// Get the occasion index
+    pub fn occasion(&self) -> usize {
+        self.occasion
+    }
+
+    /// Get a mutable reference to the occasion index
+    pub fn mut_occasion(&mut self) -> &mut usize {
+        &mut self.occasion
+    }
+
+    /// Get the censoring status
+    pub fn censoring(&self) -> Censor {
+        self.censoring
+    }
+
+    /// Create an [Observation] from this prediction
+    pub fn to_observation(&self) -> Observation {
+        Observation::new(
+            self.time,
+            self.observation,
+            self.outeq,
+            self.errorpoly,
+            self.occasion,
+            self.censoring,
+        )
+    }
+}
+
+impl Default for Prediction {
+    fn default() -> Self {
+        Self {
+            time: 0.0,
+            observation: None,
+            prediction: 0.0,
+            outeq: 0,
+            errorpoly: None,
+            state: vec![],
+            occasion: 0,
+            censoring: Censor::None,
+        }
+    }
+}
+
+impl std::fmt::Display for Prediction {
+    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
+        let obs_str = match self.observation {
+            Some(obs) => format!("{:.4}", obs),
+            None => "NA".to_string(),
+        };
+        write!(
+            f,
+            "Time: {:.2}\tObs: {:.4}\tPred: {:.4}\tOuteq: {:.2}",
+            self.time, obs_str, self.prediction, self.outeq
+        )
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::data::error_model::{AssayErrorModel, ErrorPoly};
+
+    fn create_test_prediction(obs: f64, pred: f64) -> Prediction {
+        Prediction {
+            time: 1.0,
+            observation: Some(obs),
+            prediction: pred,
+            outeq: 0,
+            errorpoly: None,
+            state: vec![pred],
+            occasion: 0,
+            censoring: Censor::None,
+        }
+    }
+
+    fn create_error_models() -> AssayErrorModels {
+        AssayErrorModels::new()
+            .add(
+                0,
+                AssayErrorModel::additive(ErrorPoly::new(1.0, 0.0, 0.0, 0.0), 0.0),
+            )
+            .unwrap()
+    }
+
+    #[test]
+    fn test_log_likelihood_basic() {
+        let prediction = create_test_prediction(10.0, 10.5);
+        let error_models = create_error_models();
+
+        let log_lik = prediction.log_likelihood(&error_models).unwrap();
+        assert!(log_lik.is_finite());
+        assert!(log_lik < 0.0); // Log likelihood should be negative
+    }
+
+    #[test]
+    fn test_log_likelihood_numerical_stability() {
+        // Test with values that would cause very small likelihood
+        let prediction = create_test_prediction(10.0, 30.0); // 20 sigma away
+        let error_models = create_error_models();
+
+        let log_lik = prediction.log_likelihood(&error_models).unwrap();
+        assert!(log_lik.is_finite());
+        assert!(log_lik < -100.0); // Should be very negative
+    }
+
+    #[test]
+    fn test_log_likelihood_extreme() {
+        // Test with truly extreme values
+        let prediction = create_test_prediction(10.0, 50.0); // 40 sigma away
+        let error_models = create_error_models();
+
+        let log_lik = prediction.log_likelihood(&error_models).unwrap();
+        assert!(log_lik.is_finite());
+        assert!(
+            log_lik < -700.0 && log_lik > -900.0,
+            "log_lik ({}) should be approximately -800",
+            log_lik
+        );
+    }
+
+    #[test]
+    fn test_missing_observation() {
+        let prediction = Prediction {
+            time: 1.0,
+            observation: None,
+            prediction: 10.0,
+            ..Default::default()
+        };
+        let error_models = create_error_models();
+
+        let result = prediction.log_likelihood(&error_models);
+        assert!(matches!(result, Err(PharmsolError::MissingObservation)));
+    }
+
+    #[test]
+    fn test_error_metrics() {
+        let prediction = create_test_prediction(10.0, 12.0);
+
+        assert_eq!(prediction.prediction_error(), Some(2.0));
+        assert_eq!(prediction.absolute_error(), Some(2.0));
+        assert_eq!(prediction.squared_error(), Some(4.0));
+        assert_eq!(prediction.percentage_error(), Some(20.0));
+    }
+}
diff --git a/src/simulator/likelihood/subject.rs b/src/simulator/likelihood/subject.rs
new file mode 100644
index 00000000..77d8963b
--- /dev/null
+++ b/src/simulator/likelihood/subject.rs
@@ -0,0 +1,270 @@
+//! Subject-level predictions and likelihood calculations.
+//!
+//! This module contains [`SubjectPredictions`] for holding all predictions
+//! for a single subject, and [`PopulationPredictions`] for population-level
+//! predictions.
+
+use ndarray::{Array2, ShapeBuilder};
+
+use crate::data::error_model::AssayErrorModels;
+use crate::{PharmsolError, Predictions};
+
+use super::prediction::Prediction;
+
+/// Container for predictions associated with a single subject.
+///
+/// This struct holds all predictions for a subject along with methods
+/// for calculating aggregate likelihood and error metrics.
+#[derive(Debug, Clone, Default)]
+pub struct SubjectPredictions {
+    predictions: Vec<Prediction>,
+}
+
+impl Predictions for SubjectPredictions {
+    fn squared_error(&self) -> f64 {
+        self.predictions
+            .iter()
+            .filter_map(|p| p.observation().map(|obs| (obs - p.prediction()).powi(2)))
+            .sum()
+    }
+
+    fn get_predictions(&self) -> Vec<Prediction> {
+        self.predictions.clone()
+    }
+
+    fn log_likelihood(&self, error_models: &AssayErrorModels) -> Result<f64, PharmsolError> {
+        SubjectPredictions::log_likelihood(self, error_models)
+    }
+}
+
+impl SubjectPredictions {
+    /// Calculate the log-likelihood of all predictions given an error model.
+    ///
+    /// This sums the log-likelihood of each prediction to get the joint log-likelihood.
+    /// This is numerically stable and avoids underflow issues that can occur
+    /// when computing products of small probabilities.
+    ///
+    /// # Error Model
+    /// Uses observation-based sigma from [`AssayErrorModels`], which is appropriate
+    /// for non-parametric algorithms (NPAG, NPOD). For parametric algorithms
+    /// (SAEM, FOCE), use [`crate::ResidualErrorModels`] directly.
+    ///
+    /// # Parameters
+    /// - `error_models`: The error models to use for calculating the likelihood
+    ///
+    /// # Returns
+    /// The sum of all individual prediction log-likelihoods.
+    /// Returns 0.0 for empty prediction sets (log of 1.0).
+    ///
+    /// # Example
+    /// ```ignore
+    /// let log_lik = subject_predictions.log_likelihood(&error_models)?;
+    /// ```
+    pub fn log_likelihood(&self, error_models: &AssayErrorModels) -> Result<f64, PharmsolError> {
+        if self.predictions.is_empty() {
+            return Ok(0.0);
+        }
+
+        let log_liks: Result<Vec<f64>, _> = self
+            .predictions
+            .iter()
+            .filter(|p| p.observation().is_some())
+            .map(|p| p.log_likelihood(error_models))
+            .collect();
+
+        log_liks.map(|lls| lls.iter().sum())
+    }
+
+    /// Calculate the likelihood of all predictions.
+    ///
+    /// **Deprecated**: Use [`log_likelihood`](Self::log_likelihood) instead for
+    /// better numerical stability. This method exponentiates the log-likelihood.
+    ///
+    /// # Parameters
+    /// - `error_models`: The error models to use for calculating the likelihood
+    ///
+    /// # Returns
+    /// The product of all individual prediction likelihoods.
+    /// Returns 1.0 for empty prediction sets.
+    #[deprecated(
+        since = "0.23.0",
+        note = "Use log_likelihood() instead for better numerical stability"
+    )]
+    pub fn likelihood(&self, error_models: &AssayErrorModels) -> Result<f64, PharmsolError> {
+        match self.predictions.is_empty() {
+            true => Ok(1.0),
+            false => {
+                let log_lik = self.log_likelihood(error_models)?;
+                Ok(log_lik.exp())
+            }
+        }
+    }
+
+    /// Add a new prediction to the collection.
+    ///
+    /// # Parameters
+    /// - `prediction`: The prediction to add
+    pub fn add_prediction(&mut self, prediction: Prediction) {
+        self.predictions.push(prediction);
+    }
+
+    /// Get a reference to the vector of predictions.
+    pub fn predictions(&self) -> &Vec<Prediction> {
+        &self.predictions
+    }
+
+    /// Return a flat vector of prediction values.
+    pub fn flat_predictions(&self) -> Vec<f64> {
+        self.predictions.iter().map(|p| p.prediction()).collect()
+    }
+
+    /// Return a flat vector of time points.
+    pub fn flat_times(&self) -> Vec<f64> {
+        self.predictions.iter().map(|p| p.time()).collect()
+    }
+
+    /// Return a flat vector of observations.
+    pub fn flat_observations(&self) -> Vec<Option<f64>> {
+        self.predictions.iter().map(|p| p.observation()).collect()
+    }
+}
+
+impl From<Vec<Prediction>> for SubjectPredictions {
+    fn from(predictions: Vec<Prediction>) -> Self {
+        Self { predictions }
+    }
+}
+
+/// Container for predictions across a population of subjects.
+///
+/// This struct holds predictions for multiple subjects organized in a 2D array
+/// where rows represent subjects and columns represent support points (or
+/// other groupings).
+pub struct PopulationPredictions {
+    /// 2D array of subject predictions
+    pub subject_predictions: Array2<SubjectPredictions>,
+}
+
+impl Default for PopulationPredictions {
+    fn default() -> Self {
+        Self {
+            subject_predictions: Array2::default((0, 0).f()),
+        }
+    }
+}
+
+impl From<Array2<SubjectPredictions>> for PopulationPredictions {
+    fn from(subject_predictions: Array2<SubjectPredictions>) -> Self {
+        Self {
+            subject_predictions,
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::data::error_model::{AssayErrorModel, ErrorPoly};
+    use crate::data::event::Observation;
+    use crate::Censor;
+
+    fn create_error_models() -> AssayErrorModels {
+        AssayErrorModels::new()
+            .add(
+                0,
+                AssayErrorModel::additive(ErrorPoly::new(0.0, 1.0, 0.0, 0.0), 0.0),
+            )
+            .unwrap()
+    }
+
+    #[test]
+    fn test_empty_predictions_log_likelihood() {
+        let preds = SubjectPredictions::default();
+        let errors = create_error_models();
+        assert_eq!(preds.log_likelihood(&errors).unwrap(), 0.0);
+    }
+
+    #[test]
+    #[allow(deprecated)]
+    fn test_empty_predictions_likelihood() {
+        let preds = SubjectPredictions::default();
+        let errors = create_error_models();
+        assert_eq!(preds.likelihood(&errors).unwrap(), 1.0);
+    }
+
+    #[test]
+    fn test_log_likelihood_with_observations() {
+        let mut preds = SubjectPredictions::default();
+        let obs = Observation::new(0.0, Some(1.0), 0, None, 0, Censor::None);
+        preds.add_prediction(obs.to_prediction(1.0, vec![]));
+
+        let error_model = AssayErrorModel::additive(ErrorPoly::new(1.0, 0.0, 0.0, 0.0), 0.0);
+        let errors = AssayErrorModels::new().add(0, error_model).unwrap();
+
+        let log_lik = preds.log_likelihood(&errors).unwrap();
+        assert!(log_lik.is_finite());
+        assert!(log_lik <= 0.0); // Log likelihood should be <= 0
+    }
+
+    #[test]
+    fn test_multiple_observations() {
+        let predictions = vec![
+            Prediction {
+                time: 1.0,
+                observation: Some(10.0),
+                prediction: 10.1,
+                outeq: 0,
+                errorpoly: None,
+                state: vec![10.1],
+                occasion: 0,
+                censoring: Censor::None,
+            },
+            Prediction {
+                time: 2.0,
+                observation: Some(8.0),
+                prediction: 8.2,
+                outeq: 0,
+                errorpoly: None,
+                state: vec![8.2],
+                occasion: 0,
+                censoring: Censor::None,
+            },
+        ];
+
+        let subject_predictions = SubjectPredictions::from(predictions);
+        let error_models = create_error_models();
+
+        let log_lik = subject_predictions.log_likelihood(&error_models).unwrap();
+        assert!(log_lik.is_finite());
+
+        // Log-likelihood of multiple observations should be sum of individual log-likelihoods
+        // (more negative than single observation)
+    }
+
+    #[test]
+    fn test_flat_vectors() {
+        let predictions = vec![
+            Prediction {
+                time: 1.0,
+                observation: Some(10.0),
+                prediction: 11.0,
+                ..Default::default()
+            },
+            Prediction {
+                time: 2.0,
+                observation: Some(8.0),
+                prediction: 9.0,
+                ..Default::default()
+            },
+        ];
+
+        let subject_predictions = SubjectPredictions::from(predictions);
+
+        assert_eq!(subject_predictions.flat_times(), vec![1.0, 2.0]);
+        assert_eq!(subject_predictions.flat_predictions(), vec![11.0, 9.0]);
+        assert_eq!(
+            subject_predictions.flat_observations(),
+            vec![Some(10.0), Some(8.0)]
+        );
+    }
+}
diff --git a/src/simulator/mod.rs b/src/simulator/mod.rs
index 39d2baab..b7feaa75 100644
--- a/src/simulator/mod.rs
+++ b/src/simulator/mod.rs
@@ -4,7 +4,6 @@ use diffsol::{NalgebraMat, NalgebraVec};
 
 use crate::{
     data::{Covariates, Infusion},
-    error_model::ErrorModels,
     simulator::likelihood::SubjectPredictions,
 };
 
@@ -21,12 +20,12 @@ pub type M = NalgebraMat<T>;
 ///
 /// # Parameters
 /// - `x`: The state vector at time t
-/// - `p`: The parameters of the model; Use the [fetch_params!] macro to extract the parameters
+/// - `p`: The parameters of the model; Use the `fetch_params!` macro to extract the parameters
 /// - `t`: The time at which the differential equation is evaluated
 /// - `dx`: A mutable reference to the derivative of the state vector at time t
 /// - `bolus`: A vector of bolus amounts at time t
 /// - `rateiv`: A vector of infusion rates at time t
-/// - `cov`: A reference to the covariates at time t; Use the [fetch_cov!] macro to extract the covariates
+/// - `cov`: A reference to the covariates at time t; Use the `fetch_cov!` macro to extract the covariates
 ///
 /// # Example
 /// ```ignore
@@ -41,14 +40,14 @@ pub type M = NalgebraMat<T>;
 pub type DiffEq = fn(&V, &V, T, &mut V, &V, &V, &Covariates);
 
 /// This closure represents an Analytical solution of the model.
-/// See [analytical] module for examples.
+/// See [`equation::analytical`] module for examples.
 ///
 /// # Parameters
 /// - `x`: The state vector at time t
-/// - `p`: The parameters of the model; Use the [fetch_params!] macro to extract the parameters
+/// - `p`: The parameters of the model; Use the `fetch_params!` macro to extract the parameters
 /// - `t`: The time at which the output equation is evaluated
 /// - `rateiv`: A vector of infusion rates at time t
-/// - `cov`: A reference to the covariates at time t; Use the [fetch_cov!] macro to extract the covariates
+/// - `cov`: A reference to the covariates at time t; Use the `fetch_cov!` macro to extract the covariates
 ///
 /// TODO: Remove covariates. They are not used in the analytical solution
 pub type AnalyticalEq = fn(&V, &V, T, V, &Covariates) -> V;
@@ -57,11 +56,11 @@ pub type AnalyticalEq = fn(&V, &V, T, V, &Covariates) -> V;
 ///
 /// # Parameters
 /// - `x`: The state vector at time t
-/// - `p`: The parameters of the model; Use the [fetch_params!] macro to extract the parameters
+/// - `p`: The parameters of the model; Use the `fetch_params!` macro to extract the parameters
 /// - `t`: The time at which the drift term is evaluated
 /// - `dx`: A mutable reference to the derivative of the state vector at time t
 /// - `rateiv`: A vector of infusion rates at time t
-/// - `cov`: A reference to the covariates at time t; Use the [fetch_cov!] macro to extract the covariates
+/// - `cov`: A reference to the covariates at time t; Use the `fetch_cov!` macro to extract the covariates
 ///
 /// # Example
 /// ```ignore
@@ -83,7 +82,7 @@ pub type Drift = fn(&V, &V, T, &mut V, V, &Covariates);
 /// This closure represents the diffusion term of a stochastic differential equation model.
 ///
 /// # Parameters
-/// - `p`: The parameters of the model; Use the [fetch_params!] macro to extract the parameters
+/// - `p`: The parameters of the model; Use the `fetch_params!` macro to extract the parameters
 /// - `d`: A mutable reference to the diffusion term for each state variable
 ///   (This vector should have the same length as the x, and dx vectors on the drift closure)
 pub type Diffusion = fn(&V, &mut V);
@@ -91,9 +90,9 @@ pub type Diffusion = fn(&V, &mut V);
 /// This closure represents the initial state of the system.
 ///
 /// # Parameters
-/// - `p`: The parameters of the model; Use the [fetch_params!] macro to extract the parameters
+/// - `p`: The parameters of the model; Use the `fetch_params!` macro to extract the parameters
 /// - `t`: The time at which the initial state is evaluated; Hardcoded to 0.0
-/// - `cov`: A reference to the covariates at time t; Use the [fetch_cov!] macro to extract the covariates
+/// - `cov`: A reference to the covariates at time t; Use the `fetch_cov!` macro to extract the covariates
 /// - `x`: A mutable reference to the state vector at time t
 ///
 /// # Example
@@ -112,9 +111,9 @@ pub type Init = fn(&V, T, &Covariates, &mut V);
 ///
 /// # Parameters
 /// - `x`: The state vector at time t
-/// - `p`: The parameters of the model; Use the [fetch_params!] macro to extract the parameters
+/// - `p`: The parameters of the model; Use the `fetch_params!` macro to extract the parameters
 /// - `t`: The time at which the output equation is evaluated
-/// - `cov`: A reference to the covariates at time t; Use the [fetch_cov!] macro to extract the covariates
+/// - `cov`: A reference to the covariates at time t; Use the `fetch_cov!` macro to extract the covariates
 /// - `y`: A mutable reference to the output vector at time t
 ///
 /// # Example
@@ -132,9 +131,9 @@ pub type Out = fn(&V, &V, T, &Covariates, &mut V);
 /// Secondary equations are used to update the parameter values based on the covariates.
 ///
 /// # Parameters
-/// - `p`: The parameters of the model; Use the [fetch_params!] macro to extract the parameters
+/// - `p`: The parameters of the model; Use the `fetch_params!` macro to extract the parameters
 /// - `t`: The time at which the secondary equation is evaluated
-/// - `cov`: A reference to the covariates at time t; Use the [fetch_cov!] macro to extract the covariates
+/// - `cov`: A reference to the covariates at time t; Use the `fetch_cov!` macro to extract the covariates
 ///
 /// # Example
 /// ```ignore
@@ -152,12 +151,12 @@ pub type SecEq = fn(&mut V, T, &Covariates);
 /// The lag term delays only the boluses going into a specific compartment.
 ///
 /// # Parameters
-/// - `p`: The parameters of the model; Use the [fetch_params!] macro to extract the parameters
+/// - `p`: The parameters of the model; Use the `fetch_params!` macro to extract the parameters
 ///
 /// # Returns
 /// - A hashmap with the lag times for each compartment. If not present, lag is assumed to be 0.
 ///
-/// There is a convenience macro [lag!] to create the hashmap
+/// There is a convenience macro `lag!` to create the hashmap
 ///
 /// # Example
 /// ```ignore
@@ -177,12 +176,12 @@ pub type Lag = fn(&V, T, &Covariates) -> HashMap<usize, T>;
 /// The fa term is used to adjust the amount of drug that is absorbed into the system.
 ///
 /// # Parameters
-/// - `p`: The parameters of the model; Use the [fetch_params!] macro to extract the parameters
+/// - `p`: The parameters of the model; Use the `fetch_params!` macro to extract the parameters
 ///
 /// # Returns
 /// - A hashmap with the fraction absorbed for each compartment. If not present, it is assumed to be 1.
 ///
-/// There is a convenience macro [fa!] to create the hashmap
+/// There is a convenience macro `fa!` to create the hashmap
 ///
 /// # Example
 /// ```ignore
diff --git a/tests/nca.rs b/tests/nca.rs
new file mode 100644
index 00000000..05792544
--- /dev/null
+++ b/tests/nca.rs
@@ -0,0 +1,16 @@
+//! NCA Integration Tests
+//!
+//! Tests for the public NCA API using Subject::builder().nca()
+
+// Include test modules from nca/ directory
+#[path = "nca/test_auc.rs"]
+mod test_auc;
+
+#[path = "nca/test_params.rs"]
+mod test_params;
+
+#[path = "nca/test_quality.rs"]
+mod test_quality;
+
+#[path = "nca/test_terminal.rs"]
+mod test_terminal;
diff --git a/tests/nca/mod.rs b/tests/nca/mod.rs
new file mode 100644
index 00000000..4ad3c7eb
--- /dev/null
+++ b/tests/nca/mod.rs
@@ -0,0 +1,10 @@
+// NCA Integration Tests Module
+// Tests using the public NCA API via Subject::builder().nca()
+//
+// Note: Most NCA tests are in src/nca/tests.rs (internal unit tests).
+// These integration tests verify the public API works correctly.
+
+pub mod test_auc;
+pub mod test_params;
+pub mod test_quality;
+pub mod test_terminal;
diff --git a/tests/nca/test_auc.rs b/tests/nca/test_auc.rs
new file mode 100644
index 00000000..7578ac2f
--- /dev/null
+++ b/tests/nca/test_auc.rs
@@ -0,0 +1,242 @@
+//! Comprehensive tests for AUC calculation algorithms
+//!
+//! Tests cover:
+//! - Linear trapezoidal rule
+//! - Linear up / log down
+//! - Edge cases (zeros, single points, etc.)
+//! - Partial AUC intervals
+//!
+//! Note: These tests use the public NCA API via Subject::builder().nca()
+
+use approx::assert_relative_eq;
+use pharmsol::data::Subject;
+use pharmsol::nca::{AUCMethod, NCAOptions};
+use pharmsol::SubjectBuilderExt;
+
+/// Helper to create a subject from time/concentration arrays
+fn build_subject(times: &[f64], concs: &[f64]) -> Subject {
+    let mut builder = Subject::builder("test").bolus(0.0, 100.0, 0);
+    for (&t, &c) in times.iter().zip(concs.iter()) {
+        builder = builder.observation(t, c, 0);
+    }
+    builder.build()
+}
+
+#[test]
+fn test_linear_trapezoidal_simple_decreasing() {
+    let times = vec![0.0, 1.0, 2.0, 4.0, 8.0];
+    let concs = vec![10.0, 8.0, 6.0, 4.0, 2.0];
+
+    let subject = build_subject(&times, &concs);
+    let options = NCAOptions::default().with_auc_method(AUCMethod::Linear);
+
+    let results = subject.nca(&options, 0);
+    let result = results
+        .first()
+        .unwrap()
+        .as_ref()
+        .expect("NCA should succeed");
+
+    // Manual calculation: (10+8)/2*1 + (8+6)/2*1 + (6+4)/2*2 + (4+2)/2*4 = 38.0
+    assert_relative_eq!(result.exposure.auc_last, 38.0, epsilon = 1e-6);
+}
+
+#[test]
+fn test_linear_trapezoidal_exponential_decay() {
+    let times = vec![0.0, 1.0, 2.0, 4.0, 8.0, 12.0, 24.0];
+    let concs = vec![100.0, 90.48, 81.87, 67.03, 44.93, 30.12, 9.07];
+
+    let subject = build_subject(&times, &concs);
+    let options = NCAOptions::default().with_auc_method(AUCMethod::Linear);
+
+    let results = subject.nca(&options, 0);
+    let result = results
+        .first()
+        .unwrap()
+        .as_ref()
+        .expect("NCA should succeed");
+
+    // For exponential decay with lambda = 0.1, true AUC to 24h is around 909
+    assert!(
+        result.exposure.auc_last > 900.0 && result.exposure.auc_last < 950.0,
+        "AUClast = {} not in expected range",
+        result.exposure.auc_last
+    );
+}
+
+#[test]
+fn test_linear_up_log_down() {
+    let times = vec![0.0, 0.5, 1.0, 2.0, 4.0, 8.0];
+    let concs = vec![0.0, 5.0, 8.0, 6.0, 3.0, 1.0];
+
+    let subject = build_subject(&times, &concs);
+    let options = NCAOptions::default().with_auc_method(AUCMethod::LinUpLogDown);
+
+    let results = subject.nca(&options, 0);
+    let result = results
+        .first()
+        .unwrap()
+        .as_ref()
+        .expect("NCA should succeed");
+
+    assert!(result.exposure.auc_last > 0.0);
+    assert!(result.exposure.auc_last < 50.0);
+}
+
+#[test]
+fn test_auc_with_zero_concentration() {
+    let times = vec![0.0, 1.0, 2.0, 3.0, 4.0];
+    let concs = vec![10.0, 5.0, 0.0, 0.0, 0.0];
+
+    let subject = build_subject(&times, &concs);
+    let options = NCAOptions::default().with_auc_method(AUCMethod::Linear);
+
+    let results = subject.nca(&options, 0);
+    let result = results
+        .first()
+        .unwrap()
+        .as_ref()
+        .expect("NCA should succeed");
+
+    // NCA calculates AUC to Tlast (last positive concentration)
+    // Tlast = 1.0 (concentration 5.0), so AUC is only segment 1: (10+5)/2*1 = 7.5
+    assert_relative_eq!(result.exposure.auc_last, 7.5, epsilon = 1e-6);
+    assert!(result.exposure.auc_last.is_finite());
+}
+
+#[test]
+fn test_auc_two_points() {
+    let times = vec![0.0, 4.0];
+    let concs = vec![10.0, 6.0];
+
+    let subject = build_subject(&times, &concs);
+    let options = NCAOptions::default().with_auc_method(AUCMethod::Linear);
+
+    let results = subject.nca(&options, 0);
+    let result = results
+        .first()
+        .unwrap()
+        .as_ref()
+        .expect("NCA should succeed");
+
+    // (10+6)/2 * 4 = 32.0
+    assert_relative_eq!(result.exposure.auc_last, 32.0, epsilon = 1e-6);
+}
+
+#[test]
+fn test_auc_plateau() {
+    let times = vec![0.0, 1.0, 2.0, 3.0, 4.0];
+    let concs = vec![5.0, 5.0, 5.0, 5.0, 5.0];
+
+    let subject = build_subject(&times, &concs);
+    let options = NCAOptions::default().with_auc_method(AUCMethod::Linear);
+
+    let results = subject.nca(&options, 0);
+    let result = results
+        .first()
+        .unwrap()
+        .as_ref()
+        .expect("NCA should succeed");
+
+    // 5.0 * 4.0 = 20.0
+    assert_relative_eq!(result.exposure.auc_last, 20.0, epsilon = 1e-6);
+}
+
+#[test]
+fn test_auc_unequal_spacing() {
+    let times = vec![0.0, 0.25, 1.0, 2.5, 8.0];
+    let concs = vec![100.0, 95.0, 80.0, 55.0, 20.0];
+
+    let subject = build_subject(&times, &concs);
+    let options = NCAOptions::default().with_auc_method(AUCMethod::Linear);
+
+    let results = subject.nca(&options, 0);
+    let result = results
+        .first()
+        .unwrap()
+        .as_ref()
+        .expect("NCA should succeed");
+
+    // Total: 397.5
+    assert_relative_eq!(result.exposure.auc_last, 397.5, epsilon = 1e-6);
+}
+
+#[test]
+fn test_auc_methods_comparison() {
+    let times = vec![0.0, 1.0, 2.0, 4.0, 8.0, 12.0];
+    let concs = vec![100.0, 86.07, 74.08, 54.88, 30.12, 16.53];
+
+    let subject = build_subject(&times, &concs);
+
+    let options_linear = NCAOptions::default().with_auc_method(AUCMethod::Linear);
+    let options_linlog = NCAOptions::default().with_auc_method(AUCMethod::LinUpLogDown);
+
+    let results_linear = subject.nca(&options_linear, 0);
+    let results_linlog = subject.nca(&options_linlog, 0);
+
+    let auc_linear = results_linear
+        .first()
+        .unwrap()
+        .as_ref()
+        .unwrap()
+        .exposure
+        .auc_last;
+    let auc_linlog = results_linlog
+        .first()
+        .unwrap()
+        .as_ref()
+        .unwrap()
+        .exposure
+        .auc_last;
+
+    // Both should be reasonably close (within 5%)
+    let true_auc = 555.6;
+    assert!((auc_linear - true_auc).abs() / true_auc < 0.05);
+    assert!((auc_linlog - true_auc).abs() / true_auc < 0.05);
+}
+
+#[test]
+fn test_partial_auc() {
+    let times = vec![0.0, 1.0, 2.0, 4.0, 8.0, 12.0];
+    let concs = vec![100.0, 90.0, 80.0, 60.0, 35.0, 20.0];
+
+    let subject = build_subject(&times, &concs);
+    let options = NCAOptions::default()
+        .with_auc_method(AUCMethod::Linear)
+        .with_auc_interval(2.0, 8.0);
+
+    let results = subject.nca(&options, 0);
+    let result = results
+        .first()
+        .unwrap()
+        .as_ref()
+        .expect("NCA should succeed");
+
+    if let Some(auc_partial) = result.exposure.auc_partial {
+        // (80+60)/2*2 + (60+35)/2*4 = 330
+        assert_relative_eq!(auc_partial, 330.0, epsilon = 1.0);
+    }
+}
+
+#[test]
+fn test_auc_inf_calculation() {
+    let times = vec![0.0, 1.0, 2.0, 4.0, 8.0, 12.0, 24.0];
+    let lambda: f64 = 0.1;
+    let concs: Vec<f64> = times.iter().map(|&t| 100.0 * (-lambda * t).exp()).collect();
+
+    let subject = build_subject(&times, &concs);
+    let options = NCAOptions::default();
+
+    let results = subject.nca(&options, 0);
+    let result = results
+        .first()
+        .unwrap()
+        .as_ref()
+        .expect("NCA should succeed");
+
+    if let Some(auc_inf) = result.exposure.auc_inf {
+        assert!(auc_inf > result.exposure.auc_last);
+        // True AUCinf = C0/lambda = 100/0.1 = 1000
+        assert_relative_eq!(auc_inf, 1000.0, epsilon = 50.0);
+    }
+}
diff --git a/tests/nca/test_params.rs b/tests/nca/test_params.rs
new file mode 100644
index 00000000..290c1e24
--- /dev/null
+++ b/tests/nca/test_params.rs
@@ -0,0 +1,256 @@
+//! Tests for NCA parameter calculations
+//!
+//! Tests all derived parameters via the public API:
+//! - Clearance
+//! - Volume of distribution
+//! - Half-life
+//! - Mean residence time
+//! - Steady-state parameters
+//!
+//! Note: These tests use the public NCA API via Subject::builder().nca()
+
+use approx::assert_relative_eq;
+use pharmsol::data::Subject;
+use pharmsol::nca::{LambdaZOptions, NCAOptions};
+use pharmsol::SubjectBuilderExt;
+
+/// Helper to create a subject from time/concentration arrays with a specific dose
+fn build_subject_with_dose(times: &[f64], concs: &[f64], dose: f64) -> Subject {
+    let mut builder = Subject::builder("test").bolus(0.0, dose, 0);
+    for (&t, &c) in times.iter().zip(concs.iter()) {
+        builder = builder.observation(t, c, 0);
+    }
+    builder.build()
+}
+
+#[test]
+fn test_clearance_calculation() {
+    // IV-like profile with known parameters
+    let times = vec![0.0, 1.0, 2.0, 4.0, 8.0, 12.0, 24.0];
+    let lambda: f64 = 0.1;
+    let concs: Vec<f64> = times.iter().map(|&t| 100.0 * (-lambda * t).exp()).collect();
+    let dose = 1000.0;
+
+    let subject = build_subject_with_dose(&times, &concs, dose);
+    let options = NCAOptions::default();
+
+    let results = subject.nca(&options, 0);
+    let result = results
+        .first()
+        .unwrap()
+        .as_ref()
+        .expect("NCA should succeed");
+
+    // If we have clearance, verify it's reasonable
+    // CL = Dose / AUCinf, for this profile AUCinf should be around 1000
+    if let Some(ref clearance) = result.clearance {
+        // CL = 1000 / 1000 = 1.0 L/h (approximately)
+        assert!(clearance.cl_f > 0.5 && clearance.cl_f < 2.0);
+    }
+}
+
+#[test]
+fn test_volume_distribution() {
+    let times = vec![0.0, 1.0, 2.0, 4.0, 8.0, 12.0, 24.0];
+    let lambda: f64 = 0.1;
+    let concs: Vec<f64> = times.iter().map(|&t| 100.0 * (-lambda * t).exp()).collect();
+    let dose = 1000.0;
+
+    let subject = build_subject_with_dose(&times, &concs, dose);
+    let options = NCAOptions::default();
+
+    let results = subject.nca(&options, 0);
+    let result = results
+        .first()
+        .unwrap()
+        .as_ref()
+        .expect("NCA should succeed");
+
+    // Vz = CL / lambda_z
+    // If CL ~ 1.0 and lambda ~ 0.1, then Vz ~ 10 L
+    if let Some(ref clearance) = result.clearance {
+        assert!(clearance.vz_f > 5.0 && clearance.vz_f < 20.0);
+    }
+}
+
+#[test]
+fn test_half_life() {
+    let times = vec![0.0, 1.0, 2.0, 4.0, 8.0, 12.0, 24.0];
+    let lambda: f64 = 0.0693; // ln(2)/10 = half-life of 10h
+    let concs: Vec<f64> = times.iter().map(|&t| 100.0 * (-lambda * t).exp()).collect();
+
+    let subject = build_subject_with_dose(&times, &concs, 100.0);
+    let options = NCAOptions::default().with_lambda_z(LambdaZOptions {
+        min_r_squared: 0.90,
+        min_span_ratio: 1.0,
+        ..Default::default()
+    });
+
+    let results = subject.nca(&options, 0);
+    let result = results
+        .first()
+        .unwrap()
+        .as_ref()
+        .expect("NCA should succeed");
+
+    if let Some(ref terminal) = result.terminal {
+        // Half-life should be close to 10 hours
+        assert_relative_eq!(terminal.half_life, 10.0, epsilon = 1.0);
+    }
+}
+
+#[test]
+fn test_cmax_tmax() {
+    // Typical oral PK profile
+    let times = vec![0.0, 0.5, 1.0, 2.0, 4.0, 8.0];
+    let concs = vec![0.0, 50.0, 80.0, 90.0, 60.0, 30.0];
+
+    let subject = build_subject_with_dose(&times, &concs, 100.0);
+    let options = NCAOptions::default();
+
+    let results = subject.nca(&options, 0);
+    let result = results
+        .first()
+        .unwrap()
+        .as_ref()
+        .expect("NCA should succeed");
+
+    assert_relative_eq!(result.exposure.cmax, 90.0, epsilon = 0.001);
+    assert_relative_eq!(result.exposure.tmax, 2.0, epsilon = 0.001);
+}
+
+#[test]
+fn test_iv_bolus_cmax_at_first_point() {
+    // IV bolus - Cmax at t=0
+    let times = vec![0.0, 1.0, 2.0, 4.0];
+    let concs = vec![100.0, 80.0, 60.0, 40.0];
+
+    let subject = build_subject_with_dose(&times, &concs, 100.0);
+    let options = NCAOptions::default();
+
+    let results = subject.nca(&options, 0);
+    let result = results
+        .first()
+        .unwrap()
+        .as_ref()
+        .expect("NCA should succeed");
+
+    assert_relative_eq!(result.exposure.cmax, 100.0, epsilon = 0.001);
+    assert_relative_eq!(result.exposure.tmax, 0.0, epsilon = 0.001);
+}
+
+#[test]
+fn test_clast_tlast() {
+    let times = vec![0.0, 1.0, 2.0, 4.0, 8.0];
+    let concs = vec![100.0, 80.0, 60.0, 30.0, 10.0];
+
+    let subject = build_subject_with_dose(&times, &concs, 100.0);
+    let options = NCAOptions::default();
+
+    let results = subject.nca(&options, 0);
+    let result = results
+        .first()
+        .unwrap()
+        .as_ref()
+        .expect("NCA should succeed");
+
+    // Last positive concentration
+    assert_relative_eq!(result.exposure.clast, 10.0, epsilon = 0.001);
+    assert_relative_eq!(result.exposure.tlast, 8.0, epsilon = 0.001);
+}
+
+#[test]
+fn test_steady_state_parameters() {
+    // Steady-state profile with dosing interval
+    let times = vec![0.0, 1.0, 2.0, 4.0, 6.0, 8.0, 12.0];
+    let concs = vec![50.0, 80.0, 70.0, 55.0, 48.0, 45.0, 50.0];
+    let tau = 12.0;
+
+    let subject = build_subject_with_dose(&times, &concs, 100.0);
+    let options = NCAOptions::default().with_tau(tau);
+
+    let results = subject.nca(&options, 0);
+    let result = results
+        .first()
+        .unwrap()
+        .as_ref()
+        .expect("NCA should succeed");
+
+    if let Some(ref ss) = result.steady_state {
+        // Cmin should be around 45-50
+        assert!(ss.cmin > 40.0 && ss.cmin < 55.0);
+        // Cavg = AUC_tau / tau
+        assert!(ss.cavg > 50.0 && ss.cavg < 70.0);
+        // Fluctuation should be moderate
+        assert!(ss.fluctuation > 0.0);
+    }
+}
+
+#[test]
+fn test_extrapolation_percent() {
+    let times = vec![0.0, 1.0, 2.0, 4.0, 8.0, 12.0];
+    let concs = vec![100.0, 80.0, 65.0, 45.0, 25.0, 15.0];
+
+    let subject = build_subject_with_dose(&times, &concs, 100.0);
+    let options = NCAOptions::default();
+
+    let results = subject.nca(&options, 0);
+    let result = results
+        .first()
+        .unwrap()
+        .as_ref()
+        .expect("NCA should succeed");
+
+    // Extrapolation percent should be reasonable for good data
+    if let Some(extrap_pct) = result.exposure.auc_pct_extrap {
+        // For well-sampled data, extrapolation should be under 30%
+        assert!(extrap_pct < 50.0, "Extrapolation too high: {}", extrap_pct);
+    }
+}
+
+#[test]
+fn test_complete_parameter_workflow() {
+    // Complete workflow: all parameters from raw data
+    let times = vec![0.0, 0.5, 1.0, 2.0, 4.0, 8.0, 12.0, 24.0];
+    let concs = vec![100.0, 91.0, 83.0, 70.0, 49.0, 24.0, 12.0, 1.5];
+    let dose = 1000.0;
+
+    let subject = build_subject_with_dose(&times, &concs, dose);
+    let options = NCAOptions::default();
+
+    let results = subject.nca(&options, 0);
+    let result = results
+        .first()
+        .unwrap()
+        .as_ref()
+        .expect("NCA should succeed");
+
+    // Verify basic parameters exist
+    assert_eq!(result.exposure.cmax, 100.0);
+    assert_eq!(result.exposure.tmax, 0.0);
+    assert!(result.exposure.auc_last > 400.0 && result.exposure.auc_last < 600.0);
+
+    // If terminal phase estimated
+    if let Some(ref terminal) = result.terminal {
+        assert!(terminal.lambda_z > 0.05 && terminal.lambda_z < 0.20);
+        assert!(terminal.half_life > 3.0 && terminal.half_life < 15.0);
+    }
+
+    // If clearance calculated
+    if let Some(ref clearance) = result.clearance {
+        assert!(clearance.cl_f > 0.0);
+        assert!(clearance.vz_f > 0.0);
+    }
+
+    println!("Complete parameter set:");
+    println!("  Cmax: {:.2}", result.exposure.cmax);
+    println!("  Tmax: {:.2}", result.exposure.tmax);
+    println!("  AUClast: {:.2}", result.exposure.auc_last);
+    if let Some(auc_inf) = result.exposure.auc_inf {
+        println!("  AUCinf: {:.2}", auc_inf);
+    }
+    if let Some(ref terminal) = result.terminal {
+        println!("  Lambda_z: {:.4}", terminal.lambda_z);
+        println!("  Half-life: {:.2}", terminal.half_life);
+    }
+}
diff --git a/tests/nca/test_quality.rs b/tests/nca/test_quality.rs
new file mode 100644
index 00000000..c7b12abe
--- /dev/null
+++ b/tests/nca/test_quality.rs
@@ -0,0 +1,247 @@
+//! Tests for quality assessment and acceptance criteria
+//!
+//! Tests verify that the NCA module properly flags quality issues like:
+//! - Poor R-squared for lambda_z regression
+//! - High AUC extrapolation percentage
+//! - Insufficient span ratio
+//!
+//! Note: These tests use the public NCA API via Subject::builder().nca()
+
+use pharmsol::data::Subject;
+use pharmsol::nca::{LambdaZOptions, NCAOptions, Warning};
+use pharmsol::SubjectBuilderExt;
+
+/// Helper to create a subject from time/concentration arrays
+fn build_subject(times: &[f64], concs: &[f64]) -> Subject {
+    let mut builder = Subject::builder("test").bolus(0.0, 100.0, 0);
+    for (&t, &c) in times.iter().zip(concs.iter()) {
+        builder = builder.observation(t, c, 0);
+    }
+    builder.build()
+}
+
+#[test]
+fn test_quality_good_data_no_warnings() {
+    // Well-behaved exponential decay
+    let times = vec![0.0, 1.0, 2.0, 4.0, 8.0, 12.0, 24.0];
+    let lambda: f64 = 0.1;
+    let concs: Vec<f64> = times.iter().map(|&t| 100.0 * (-lambda * t).exp()).collect();
+
+    let subject = build_subject(&times, &concs);
+    let options = NCAOptions::default();
+
+    let results = subject.nca(&options, 0);
+    let result = results
+        .first()
+        .unwrap()
+        .as_ref()
+        .expect("NCA should succeed");
+
+    // Good data should have few or no warnings
+    // (may have some due to extrapolation)
+    println!("Warnings for good data: {:?}", result.quality.warnings);
+}
+
+#[test]
+fn test_quality_high_extrapolation_warning() {
+    // Short sampling - will have high extrapolation
+    let times = vec![0.0, 1.0, 2.0, 4.0];
+    let concs = vec![100.0, 80.0, 60.0, 40.0];
+
+    let subject = build_subject(&times, &concs);
+    let options = NCAOptions::default().with_lambda_z(LambdaZOptions {
+        min_r_squared: 0.80,
+        min_span_ratio: 1.0,
+        ..Default::default()
+    });
+
+    let results = subject.nca(&options, 0);
+    let result = results
+        .first()
+        .unwrap()
+        .as_ref()
+        .expect("NCA should succeed");
+
+    // May have high extrapolation warning
+    let has_high_extrap = result
+        .quality
+        .warnings
+        .iter()
+        .any(|w| matches!(w, Warning::HighExtrapolation));
+    println!(
+        "Has high extrapolation warning: {}, warnings: {:?}",
+        has_high_extrap, result.quality.warnings
+    );
+}
+
+#[test]
+fn test_quality_lambda_z_not_estimable() {
+    // Too few points for lambda_z
+    let times = vec![0.0, 1.0];
+    let concs = vec![100.0, 50.0];
+
+    let subject = build_subject(&times, &concs);
+    let options = NCAOptions::default();
+
+    let results = subject.nca(&options, 0);
+    let result = results
+        .first()
+        .unwrap()
+        .as_ref()
+        .expect("NCA should succeed");
+
+    // Should not have terminal phase
+    assert!(result.terminal.is_none());
+
+    // Should have warning about lambda_z not estimable
+    let has_lz_warning = result
+        .quality
+        .warnings
+        .iter()
+        .any(|w| matches!(w, Warning::LambdaZNotEstimable));
+    assert!(has_lz_warning, "Expected LambdaZNotEstimable warning");
+}
+
+#[test]
+fn test_quality_poor_fit_warning() {
+    // Noisy data that should give poor fit
+    let times = vec![0.0, 2.0, 4.0, 6.0, 8.0, 10.0];
+    let concs = vec![100.0, 60.0, 80.0, 40.0, 50.0, 30.0]; // Very noisy
+
+    let subject = build_subject(&times, &concs);
+    let options = NCAOptions::default().with_lambda_z(LambdaZOptions {
+        min_r_squared: 0.70, // Very lenient
+        min_span_ratio: 0.5,
+        ..Default::default()
+    });
+
+    let results = subject.nca(&options, 0);
+    let result = results
+        .first()
+        .unwrap()
+        .as_ref()
+        .expect("NCA should succeed");
+
+    println!(
+        "Terminal phase: {:?}, Warnings: {:?}",
+        result.terminal, result.quality.warnings
+    );
+}
+
+#[test]
+fn test_quality_short_terminal_phase() {
+    // Very short terminal phase span
+    let times = vec![0.0, 0.5, 1.0, 1.5, 2.0];
+    let concs = vec![100.0, 90.0, 80.0, 70.0, 60.0];
+
+    let subject = build_subject(&times, &concs);
+    let options = NCAOptions::default().with_lambda_z(LambdaZOptions {
+        min_r_squared: 0.80,
+        min_span_ratio: 0.5, // Very lenient
+        ..Default::default()
+    });
+
+    let results = subject.nca(&options, 0);
+    let result = results
+        .first()
+        .unwrap()
+        .as_ref()
+        .expect("NCA should succeed");
+
+    // Check for short terminal phase warning
+    let has_short_warning = result
+        .quality
+        .warnings
+        .iter()
+        .any(|w| matches!(w, Warning::ShortTerminalPhase));
+    println!(
+        "Has short terminal phase warning: {}, warnings: {:?}",
+        has_short_warning, result.quality.warnings
+    );
+}
+
+#[test]
+fn test_regression_stats_available() {
+    // Good data should have regression statistics
+    let times = vec![0.0, 1.0, 2.0, 4.0, 8.0, 12.0, 24.0];
+    let lambda: f64 = 0.1;
+    let concs: Vec<f64> = times.iter().map(|&t| 100.0 * (-lambda * t).exp()).collect();
+
+    let subject = build_subject(&times, &concs);
+    let options = NCAOptions::default();
+
+    let results = subject.nca(&options, 0);
+    let result = results
+        .first()
+        .unwrap()
+        .as_ref()
+        .expect("NCA should succeed");
+
+    if let Some(ref terminal) = result.terminal {
+        if let Some(ref stats) = terminal.regression {
+            // Good fit should have high R-squared
+            assert!(
+                stats.r_squared > 0.95,
+                "R-squared too low: {}",
+                stats.r_squared
+            );
+            assert!(stats.adj_r_squared > 0.95);
+            assert!(stats.n_points >= 3);
+            assert!(stats.span_ratio > 2.0);
+        }
+    }
+}
+
+#[test]
+fn test_bioequivalence_preset_quality() {
+    // Test BE preset quality thresholds
+    let times = vec![0.0, 1.0, 2.0, 4.0, 8.0, 12.0, 24.0];
+    let lambda: f64 = 0.1;
+    let concs: Vec<f64> = times.iter().map(|&t| 100.0 * (-lambda * t).exp()).collect();
+
+    let subject = build_subject(&times, &concs);
+    let options = NCAOptions::bioequivalence();
+
+    let results = subject.nca(&options, 0);
+    let result = results
+        .first()
+        .unwrap()
+        .as_ref()
+        .expect("NCA should succeed");
+
+    // BE preset should have stricter quality requirements
+    // Good data should still pass
+    if let Some(ref terminal) = result.terminal {
+        if let Some(ref stats) = terminal.regression {
+            assert!(
+                stats.r_squared >= 0.90,
+                "BE threshold requires R-squared >= 0.90"
+            );
+        }
+    }
+}
+
+#[test]
+fn test_sparse_preset_quality() {
+    // Sparse preset should be more lenient
+    let times = vec![0.0, 2.0, 8.0, 24.0];
+    let concs = vec![100.0, 70.0, 35.0, 10.0];
+
+    let subject = build_subject(&times, &concs);
+    let options = NCAOptions::sparse();
+
+    let results = subject.nca(&options, 0);
+    let result = results
+        .first()
+        .unwrap()
+        .as_ref()
+        .expect("NCA should succeed");
+
+    // Sparse preset should still be able to estimate terminal phase
+    // with fewer points
+    println!(
+        "Sparse data - Terminal: {:?}, Warnings: {:?}",
+        result.terminal.is_some(),
+        result.quality.warnings
+    );
+}
diff --git a/tests/nca/test_terminal.rs b/tests/nca/test_terminal.rs
new file mode 100644
index 00000000..a3223b1d
--- /dev/null
+++ b/tests/nca/test_terminal.rs
@@ -0,0 +1,316 @@
+//! Tests for terminal phase (lambda_z) calculations
+//!
+//! Tests various methods using the public NCA API:
+//! - Adjusted R²
+//! - R²
+//! - Manual point selection
+//!
+//! Note: Tests use Subject::builder() with .nca() as the entry point,
+//! which internally computes lambda_z via regression on the terminal phase.
+
+use approx::assert_relative_eq;
+use pharmsol::data::Subject;
+use pharmsol::nca::{LambdaZMethod, LambdaZOptions, NCAOptions};
+use pharmsol::SubjectBuilderExt;
+
+/// Helper to create a subject from time/concentration arrays
+fn build_subject(times: &[f64], concs: &[f64]) -> Subject {
+    let mut builder = Subject::builder("test").bolus(0.0, 100.0, 0); // Dose at depot
+    for (&t, &c) in times.iter().zip(concs.iter()) {
+        builder = builder.observation(t, c, 0);
+    }
+    builder.build()
+}
+
+#[test]
+fn test_lambda_z_simple_exponential() {
+    // Perfect exponential decay: C = 100 * e^(-0.1*t)
+    // lambda_z should be exactly 0.1
+    let times = vec![0.0, 4.0, 8.0, 12.0, 16.0, 24.0];
+    let concs = vec![
+        100.0, 67.03, // 100 * e^(-0.1*4)
+        44.93, // 100 * e^(-0.1*8)
+        30.12, // 100 * e^(-0.1*12)
+        20.19, // 100 * e^(-0.1*16)
+        9.07,  // 100 * e^(-0.1*24)
+    ];
+
+    let subject = build_subject(&times, &concs);
+    let options = NCAOptions::default().with_lambda_z(LambdaZOptions {
+        min_r_squared: 0.90,
+        ..Default::default()
+    });
+
+    let results = subject.nca(&options, 0);
+    let result = results
+        .first()
+        .unwrap()
+        .as_ref()
+        .expect("NCA should succeed");
+
+    // Terminal params should exist
+    let terminal = result
+        .terminal
+        .as_ref()
+        .expect("Terminal phase should be estimated");
+
+    // Lambda_z should be very close to 0.1
+    assert_relative_eq!(terminal.lambda_z, 0.1, epsilon = 0.01);
+
+    // R² should be high (check regression stats in terminal params)
+    if let Some(ref stats) = terminal.regression {
+        assert!(stats.r_squared > 0.99);
+        assert!(stats.adj_r_squared > 0.99);
+    }
+}
+
+#[test]
+fn test_lambda_z_with_noise() {
+    // Exponential decay with some realistic noise
+    let times = vec![0.0, 4.0, 6.0, 8.0, 12.0, 24.0];
+    let concs = vec![100.0, 65.0, 52.0, 43.0, 29.5, 9.5];
+
+    let subject = build_subject(&times, &concs);
+    let options = NCAOptions::default().with_lambda_z(LambdaZOptions {
+        min_r_squared: 0.90,
+        ..Default::default()
+    });
+
+    let results = subject.nca(&options, 0);
+    let result = results
+        .first()
+        .unwrap()
+        .as_ref()
+        .expect("NCA should succeed");
+
+    let terminal = result
+        .terminal
+        .as_ref()
+        .expect("Terminal phase should be estimated");
+
+    // Lambda should be around 0.09-0.11
+    assert!(
+        terminal.lambda_z > 0.08 && terminal.lambda_z < 0.12,
+        "lambda_z = {} not in expected range",
+        terminal.lambda_z
+    );
+
+    // R² should still be reasonable
+    if let Some(ref stats) = terminal.regression {
+        assert!(stats.r_squared > 0.95);
+    }
+}
+
+#[test]
+fn test_lambda_z_manual_points() {
+    // Test using manual N points method
+    let times = vec![0.0, 1.0, 2.0, 4.0, 8.0, 12.0, 24.0];
+    let concs = vec![0.0, 80.0, 100.0, 80.0, 50.0, 30.0, 10.0];
+
+    let subject = build_subject(&times, &concs);
+
+    // Use manual 3 points
+    let options = NCAOptions::default().with_lambda_z(LambdaZOptions {
+        method: LambdaZMethod::Manual(3),
+        min_r_squared: 0.80,
+        min_span_ratio: 1.0,
+        ..Default::default()
+    });
+
+    let results = subject.nca(&options, 0);
+    let result = results
+        .first()
+        .unwrap()
+        .as_ref()
+        .expect("NCA should succeed");
+
+    if let Some(ref terminal) = result.terminal {
+        if let Some(ref stats) = terminal.regression {
+            // Should use exactly 3 points
+            assert_eq!(stats.n_points, 3);
+            // Should use terminal points
+            assert_eq!(stats.time_last, 24.0);
+        }
+    }
+}
+
+#[test]
+fn test_lambda_z_insufficient_points() {
+    // Only 2 points - insufficient for terminal phase
+    let times = vec![0.0, 2.0];
+    let concs = vec![100.0, 50.0];
+
+    let subject = build_subject(&times, &concs);
+    let options = NCAOptions::default();
+
+    let results = subject.nca(&options, 0);
+    let result = results
+        .first()
+        .unwrap()
+        .as_ref()
+        .expect("NCA should succeed");
+
+    // Terminal params should be None due to insufficient data
+    assert!(
+        result.terminal.is_none(),
+        "Terminal phase should not be estimated with only 2 points"
+    );
+}
+
+#[test]
+fn test_adjusted_r2_vs_r2_method() {
+    let times = vec![0.0, 4.0, 6.0, 8.0, 12.0, 16.0, 24.0];
+    let concs = vec![100.0, 70.0, 55.0, 45.0, 30.0, 22.0, 10.0];
+
+    let subject = build_subject(&times, &concs);
+
+    // Test with AdjR2 method (default)
+    let options_adj = NCAOptions::default().with_lambda_z(LambdaZOptions {
+        method: LambdaZMethod::AdjR2,
+        min_r_squared: 0.90,
+        ..Default::default()
+    });
+
+    let results_adj = subject.nca(&options_adj, 0);
+    let result_adj = results_adj
+        .first()
+        .unwrap()
+        .as_ref()
+        .expect("NCA should succeed");
+
+    if let Some(ref terminal) = result_adj.terminal {
+        if let Some(ref stats) = terminal.regression {
+            // Adjusted R² should be ≤ R²
+            assert!(stats.adj_r_squared <= stats.r_squared);
+            // For good fit, they should be close
+            assert!((stats.r_squared - stats.adj_r_squared) < 0.05);
+        }
+    }
+}
+
+#[test]
+fn test_half_life_from_lambda_z() {
+    // Build a subject with known lambda_z ≈ 0.0693 (half-life = 10h)
+    let lambda: f64 = 0.0693;
+    let times = vec![0.0, 5.0, 10.0, 15.0, 20.0];
+    let concs: Vec<f64> = times.iter().map(|&t| 100.0 * (-lambda * t).exp()).collect();
+
+    let subject = build_subject(&times, &concs);
+    let options = NCAOptions::default().with_lambda_z(LambdaZOptions {
+        min_r_squared: 0.90,
+        min_span_ratio: 1.0,
+        ..Default::default()
+    });
+
+    let results = subject.nca(&options, 0);
+    let result = results
+        .first()
+        .unwrap()
+        .as_ref()
+        .expect("NCA should succeed");
+
+    let terminal = result
+        .terminal
+        .as_ref()
+        .expect("Terminal phase should be estimated");
+
+    // Half-life should be close to 10.0 hours
+    assert_relative_eq!(terminal.half_life, 10.0, epsilon = 0.5);
+}
+
+#[test]
+fn test_lambda_z_quality_metrics() {
+    let times = vec![0.0, 4.0, 8.0, 12.0, 16.0, 24.0];
+    let concs = vec![100.0, 80.0, 60.0, 45.0, 30.0, 12.0];
+
+    let subject = build_subject(&times, &concs);
+    let options = NCAOptions::default();
+
+    let results = subject.nca(&options, 0);
+    let result = results
+        .first()
+        .unwrap()
+        .as_ref()
+        .expect("NCA should succeed");
+
+    // Check quality metrics in terminal.regression
+    if let Some(ref terminal) = result.terminal {
+        if let Some(ref stats) = terminal.regression {
+            assert!(stats.r_squared > 0.95, "R² too low: {}", stats.r_squared);
+            assert!(
+                stats.adj_r_squared > 0.95,
+                "Adjusted R² too low: {}",
+                stats.adj_r_squared
+            );
+            assert!(
+                stats.span_ratio > 2.0,
+                "Span ratio too small: {}",
+                stats.span_ratio
+            );
+            assert!(stats.n_points >= 3, "Too few points: {}", stats.n_points);
+        }
+    }
+}
+
+#[test]
+fn test_auc_inf_extrapolation() {
+    // Test that AUCinf is properly calculated
+    let times = vec![0.0, 1.0, 2.0, 4.0, 8.0, 12.0];
+    let concs = vec![100.0, 90.0, 80.0, 65.0, 40.0, 25.0];
+
+    let subject = build_subject(&times, &concs);
+    let options = NCAOptions::default().with_lambda_z(LambdaZOptions {
+        min_r_squared: 0.80,
+        min_span_ratio: 1.0,
+        ..Default::default()
+    });
+
+    let results = subject.nca(&options, 0);
+    let result = results
+        .first()
+        .unwrap()
+        .as_ref()
+        .expect("NCA should succeed");
+
+    // AUClast should exist
+    assert!(result.exposure.auc_last > 0.0);
+
+    // If terminal phase estimated, AUCinf should be > AUClast
+    if result.terminal.is_some() {
+        if let Some(auc_inf) = result.exposure.auc_inf {
+            assert!(
+                auc_inf > result.exposure.auc_last,
+                "AUCinf should be > AUClast"
+            );
+        }
+    }
+}
+
+#[test]
+fn test_terminal_phase_with_absorption() {
+    // Typical oral PK profile: absorption then elimination
+    let times = vec![0.0, 0.5, 1.0, 2.0, 4.0, 8.0, 12.0, 24.0];
+    let concs = vec![0.0, 5.0, 10.0, 8.0, 4.0, 2.0, 1.0, 0.25];
+
+    let subject = build_subject(&times, &concs);
+    let options = NCAOptions::default();
+
+    let results = subject.nca(&options, 0);
+    let result = results
+        .first()
+        .unwrap()
+        .as_ref()
+        .expect("NCA should succeed");
+
+    // Cmax should be at 1.0h
+    assert_eq!(result.exposure.cmax, 10.0);
+    assert_eq!(result.exposure.tmax, 1.0);
+
+    // Terminal phase should be estimated from post-Tmax points
+    if let Some(ref terminal) = result.terminal {
+        if let Some(ref stats) = terminal.regression {
+            // Should not include Tmax by default
+            assert!(stats.time_first > 1.0);
+        }
+    }
+}
diff --git a/tests/ode_optimizations.rs b/tests/ode_optimizations.rs
index 024405fb..2ecb36d8 100644
--- a/tests/ode_optimizations.rs
+++ b/tests/ode_optimizations.rs
@@ -871,22 +871,24 @@ fn likelihood_calculation_matches_analytical() {
         (1, 1),
     );
 
-    let error_models = ErrorModels::new()
+    let error_models = AssayErrorModels::new()
         .add(
             0,
-            ErrorModel::additive(ErrorPoly::new(0.0, 0.1, 0.0, 0.0), 0.0),
+            AssayErrorModel::additive(ErrorPoly::new(0.0, 0.1, 0.0, 0.0), 0.0),
         )
         .unwrap();
 
     let params = vec![0.1, 50.0];
 
     let ll_analytical = analytical
-        .estimate_likelihood(&subject, &params, &error_models, false)
-        .expect("analytical likelihood");
+        .estimate_log_likelihood(&subject, &params, &error_models, false)
+        .expect("analytical likelihood")
+        .exp();
 
     let ll_ode = ode
-        .estimate_likelihood(&subject, &params, &error_models, false)
-        .expect("ode likelihood");
+        .estimate_log_likelihood(&subject, &params, &error_models, false)
+        .expect("ode likelihood")
+        .exp();
 
     let ll_diff = (ll_analytical - ll_ode).abs();
     let ll_rel_diff = ll_diff / ll_analytical.abs().max(1e-10);
diff --git a/tests/pknca_validation.rs b/tests/pknca_validation.rs
new file mode 100644
index 00000000..d72c5ef5
--- /dev/null
+++ b/tests/pknca_validation.rs
@@ -0,0 +1,519 @@
+//! PKNCA Cross-Validation Tests
+//!
+//! This module validates pharmsol's NCA implementation against expected values
+//! generated by PKNCA (the gold-standard R package for NCA).
+//!
+//! The validation uses a clean-room approach:
+//! 1. Test scenarios are independently designed based on PK principles
+//! 2. PKNCA computes expected values (run `Rscript generate_expected.R`)
+//! 3. This module compares pharmsol's results against those expected values
+//!
+//! Run with: `cargo test pknca_validation`
+
+use pharmsol::nca::{AUCMethod, BLQRule, NCAOptions, Route};
+use pharmsol::{prelude::*, Censor};
+use serde::Deserialize;
+use std::collections::HashMap;
+use std::fs;
+use std::path::Path;
+
+/// Tolerance for floating-point comparisons
+/// NCA calculations should match within 0.1% for most parameters
+const RELATIVE_TOLERANCE: f64 = 0.001;
+
+/// Absolute tolerance for very small values (near zero)
+const ABSOLUTE_TOLERANCE: f64 = 1e-10;
+
+// =============================================================================
+// JSON Structures for Test Data
+// =============================================================================
+
+#[derive(Debug, Deserialize)]
+struct TestScenarios {
+    scenarios: Vec<Scenario>,
+}
+
+#[derive(Debug, Deserialize)]
+#[allow(dead_code)]
+struct Scenario {
+    id: String,
+    name: String,
+    route: String,
+    dose: DoseInfo,
+    times: Vec<f64>,
+    concentrations: Vec<f64>,
+    #[serde(default)]
+    auc_method: Option<String>,
+    #[serde(default)]
+    blq_rule: Option<String>,
+    #[serde(default)]
+    blq_indices: Option<Vec<usize>>,
+    #[serde(default)]
+    loq: Option<f64>,
+    #[serde(default)]
+    partial_auc_interval: Option<Vec<f64>>,
+    #[serde(default)]
+    tau: Option<f64>,
+    test_params: Vec<String>,
+}
+
+#[derive(Debug, Deserialize)]
+struct DoseInfo {
+    amount: f64,
+    time: f64,
+    #[serde(default)]
+    duration: Option<f64>,
+}
+
+#[derive(Debug, Deserialize)]
+struct ExpectedValues {
+    generated_at: String,
+    pknca_version: String,
+    results: HashMap<String, ScenarioResult>,
+}
+
+#[derive(Debug, Deserialize)]
+#[allow(dead_code)]
+struct ScenarioResult {
+    id: String,
+    name: String,
+    #[serde(default)]
+    parameters: HashMap<String, f64>,
+    #[serde(default)]
+    error: Option<String>,
+}
+
+// =============================================================================
+// Test Utilities
+// =============================================================================
+
+/// Check if two floating-point values are approximately equal
+fn approx_eq(a: f64, b: f64, rel_tol: f64, abs_tol: f64) -> bool {
+    if a.is_nan() && b.is_nan() {
+        return true; // Both NaN is considered equal for our purposes
+    }
+    if a.is_nan() || b.is_nan() {
+        return false;
+    }
+    if a.is_infinite() && b.is_infinite() {
+        return a.signum() == b.signum();
+    }
+    if a.is_infinite() || b.is_infinite() {
+        return false;
+    }
+
+    let diff = (a - b).abs();
+    let max_val = a.abs().max(b.abs());
+
+    diff <= abs_tol || diff <= rel_tol * max_val
+}
+
+/// Map PKNCA parameter names to pharmsol field names
+fn map_param_name(pknca_name: &str) -> &str {
+    match pknca_name {
+        "cmax" => "cmax",
+        "tmax" => "tmax",
+        "tlast" => "tlast",
+        "clast.obs" => "clast",
+        "auclast" => "auc_last",
+        "aucall" => "auc_all",
+        "aumclast" => "aumc_last",
+        "aucinf.obs" => "auc_inf",
+        "aucinf.pred" => "auc_inf_pred",
+        "aumcinf.obs" => "aumc_inf",
+        "lambda.z" => "lambda_z",
+        "half.life" => "half_life",
+        "r.squared" => "r_squared",
+        "adj.r.squared" => "adj_r_squared",
+        "lambda.z.n.points" => "n_points",
+        "span.ratio" => "span_ratio",
+        "clast.pred" => "clast_pred",
+        "mrt.obs" => "mrt",
+        "mrt.iv.obs" => "mrt_iv",
+        "tlag" => "tlag",
+        "c0" => "c0",
+        "cl.obs" => "cl",
+        "vd.obs" => "vd",
+        "vz.obs" => "vz",
+        "vss.obs" => "vss",
+        "auc_extrap_pct" => "auc_pct_extrap",
+        "cmin" => "cmin",
+        "cav" => "cavg",
+        "auc_tau" => "auc_tau",
+        "fluctuation" => "fluctuation",
+        "swing" => "swing",
+        _ => pknca_name,
+    }
+}
+
+/// Convert scenario route string to pharmsol Route
+#[allow(dead_code)]
+fn parse_route(route: &str) -> Route {
+    match route {
+        "iv_bolus" => Route::IVBolus,
+        "iv_infusion" => Route::IVInfusion,
+        _ => Route::Extravascular,
+    }
+}
+
+/// Convert AUC method string to pharmsol AUCMethod
+fn parse_auc_method(method: Option<&str>) -> AUCMethod {
+    match method {
+        Some("linear") => AUCMethod::Linear,
+        Some("lin-log") => AUCMethod::LinLog,
+        _ => AUCMethod::LinUpLogDown,
+    }
+}
+
+/// Convert BLQ rule string to pharmsol BLQRule
+fn parse_blq_rule(rule: Option<&str>) -> BLQRule {
+    match rule {
+        Some("zero") => BLQRule::Zero,
+        Some("loq_over_2") => BLQRule::LoqOver2,
+        Some("positional") => BLQRule::Positional,
+        _ => BLQRule::Exclude,
+    }
+}
+
+// =============================================================================
+// Main Validation Function
+// =============================================================================
+
+/// Run validation for a single scenario
+fn validate_scenario(
+    scenario: &Scenario,
+    expected: &ScenarioResult,
+) -> Result<Vec<(String, f64, f64, bool)>, String> {
+    // Skip if PKNCA had an error
+    if let Some(err) = &expected.error {
+        return Err(format!("PKNCA error: {}", err));
+    }
+
+    // Build pharmsol Subject
+    let mut builder = Subject::builder(&scenario.id);
+
+    // Add dose based on route
+    match scenario.route.as_str() {
+        "iv_bolus" => {
+            builder = builder.bolus(scenario.dose.time, scenario.dose.amount, 0);
+        }
+        "iv_infusion" => {
+            let duration = scenario.dose.duration.unwrap_or(1.0);
+            builder = builder.infusion(scenario.dose.time, scenario.dose.amount, 0, duration);
+        }
+        _ => {
+            builder = builder.bolus(scenario.dose.time, scenario.dose.amount, 0);
+        }
+    }
+
+    // Add observations
+    let loq = scenario.loq.unwrap_or(0.1);
+    let blq_indices: Vec<usize> = scenario.blq_indices.clone().unwrap_or_default();
+
+    for (i, (&time, &conc)) in scenario
+        .times
+        .iter()
+        .zip(&scenario.concentrations)
+        .enumerate()
+    {
+        if blq_indices.contains(&i) {
+            builder = builder.censored_observation(time, loq, 0, Censor::BLOQ);
+        } else {
+            builder = builder.observation(time, conc, 0);
+        }
+    }
+
+    let subject = builder.build();
+
+    // Configure NCA options
+    let mut options = NCAOptions::default()
+        .with_auc_method(parse_auc_method(scenario.auc_method.as_deref()))
+        .with_blq_rule(parse_blq_rule(scenario.blq_rule.as_deref()));
+
+    if let Some(interval) = &scenario.partial_auc_interval {
+        if interval.len() == 2 {
+            options = options.with_auc_interval(interval[0], interval[1]);
+        }
+    }
+
+    // Add tau for steady-state analysis
+    if let Some(tau) = scenario.tau {
+        options = options.with_tau(tau);
+    }
+
+    // Run NCA
+    let results = subject.nca(&options, 0);
+    let result = results
+        .first()
+        .and_then(|r| r.as_ref().ok())
+        .ok_or("NCA failed to produce results")?;
+
+    // Compare parameters
+    let mut comparisons = Vec::new();
+
+    for (pknca_name, &expected_val) in &expected.parameters {
+        let pharmsol_name = map_param_name(pknca_name);
+
+        // Extract pharmsol value based on parameter name
+        let pharmsol_val = match pharmsol_name {
+            "cmax" => Some(result.exposure.cmax),
+            "tmax" => Some(result.exposure.tmax),
+            "tlast" => Some(result.exposure.tlast),
+            "clast" => Some(result.exposure.clast),
+            "auc_last" => Some(result.exposure.auc_last),
+            "aumc_last" => result.exposure.aumc_last,
+            "auc_inf" => result.exposure.auc_inf,
+            "aumc_inf" => result.exposure.aumc_inf,
+            "auc_pct_extrap" => result.exposure.auc_pct_extrap,
+            "lambda_z" => result.terminal.as_ref().map(|t| t.lambda_z),
+            "half_life" => result.terminal.as_ref().map(|t| t.half_life),
+            "mrt" => result.terminal.as_ref().and_then(|t| t.mrt),
+            "mrt_iv" => result.iv_infusion.as_ref().and_then(|iv| iv.mrt_iv),
+            "r_squared" => result
+                .terminal
+                .as_ref()
+                .and_then(|t| t.regression.as_ref())
+                .map(|r| r.r_squared),
+            "adj_r_squared" => result
+                .terminal
+                .as_ref()
+                .and_then(|t| t.regression.as_ref())
+                .map(|r| r.adj_r_squared),
+            "n_points" => result
+                .terminal
+                .as_ref()
+                .and_then(|t| t.regression.as_ref())
+                .map(|r| r.n_points as f64),
+            "span_ratio" => result
+                .terminal
+                .as_ref()
+                .and_then(|t| t.regression.as_ref())
+                .map(|r| r.span_ratio),
+            "tlag" => result.exposure.tlag,
+            "c0" => result.iv_bolus.as_ref().map(|iv| iv.c0),
+            "vd" => result.iv_bolus.as_ref().map(|iv| iv.vd),
+            "vss" => result
+                .iv_bolus
+                .as_ref()
+                .and_then(|iv| iv.vss)
+                .or_else(|| result.iv_infusion.as_ref().and_then(|iv| iv.vss)),
+            "cl" | "cl_f" => result.clearance.as_ref().map(|c| c.cl_f),
+            "vz" | "vz_f" => result.clearance.as_ref().map(|c| c.vz_f),
+            // Steady-state parameters
+            "cmin" => result.steady_state.as_ref().map(|ss| ss.cmin),
+            "cavg" => result.steady_state.as_ref().map(|ss| ss.cavg),
+            "auc_tau" => result.steady_state.as_ref().map(|ss| ss.auc_tau),
+            "fluctuation" => result.steady_state.as_ref().map(|ss| ss.fluctuation),
+            "swing" => result.steady_state.as_ref().map(|ss| ss.swing),
+            _ => None,
+        };
+
+        if let Some(pv) = pharmsol_val {
+            let matches = approx_eq(pv, expected_val, RELATIVE_TOLERANCE, ABSOLUTE_TOLERANCE);
+            comparisons.push((pknca_name.clone(), expected_val, pv, matches));
+        }
+    }
+
+    Ok(comparisons)
+}
+
+// =============================================================================
+// Test Entry Point
+// =============================================================================
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    /// Load test scenarios and expected values, run validation
+    #[test]
+    fn validate_against_pknca() {
+        let base_path = Path::new(env!("CARGO_MANIFEST_DIR")).join("tests/pknca_validation");
+
+        // Load scenarios
+        let scenarios_path = base_path.join("test_scenarios.json");
+        let scenarios_json = fs::read_to_string(&scenarios_path).expect(&format!(
+            "Failed to read test_scenarios.json from {:?}",
+            scenarios_path
+        ));
+        let scenarios: TestScenarios =
+            serde_json::from_str(&scenarios_json).expect("Failed to parse test_scenarios.json");
+
+        // Try to load expected values (may not exist if R script hasn't been run)
+        let expected_path = base_path.join("expected_values.json");
+        let expected_values: Option<ExpectedValues> = fs::read_to_string(&expected_path)
+            .ok()
+            .and_then(|json| serde_json::from_str(&json).ok());
+
+        if expected_values.is_none() {
+            println!("\n⚠️  Expected values not found!");
+            println!("   Run: cd tests/pknca_validation && Rscript generate_expected.R");
+            println!("   Skipping cross-validation tests.\n");
+            return;
+        }
+
+        let expected = expected_values.unwrap();
+        println!("\n═══════════════════════════════════════════════════════════════");
+        println!("PKNCA Cross-Validation Results");
+        println!("Generated: {}", expected.generated_at);
+        println!("PKNCA Version: {}", expected.pknca_version);
+        println!("═══════════════════════════════════════════════════════════════\n");
+
+        // Known differences: currently empty - all differences have been resolved!
+        // Keeping this infrastructure in case future differences are discovered.
+        let known_differences: Vec<(&str, &str, &str)> = vec![];
+
+        let mut total_params = 0;
+        let mut passed_params = 0;
+        let mut known_diff_params = 0;
+        let mut failed_scenarios = Vec::new();
+
+        for scenario in &scenarios.scenarios {
+            print!("Testing: {} ... ", scenario.name);
+
+            if let Some(expected_result) = expected.results.get(&scenario.id) {
+                match validate_scenario(scenario, expected_result) {
+                    Ok(comparisons) => {
+                        let mut scenario_passed = 0;
+                        let mut scenario_known_diff = 0;
+                        let scenario_total = comparisons.len();
+                        total_params += scenario_total;
+
+                        let mut failures = Vec::new();
+                        let mut known_diffs = Vec::new();
+
+                        for (name, expected_val, actual_val, matched) in &comparisons {
+                            if *matched {
+                                scenario_passed += 1;
+                            } else {
+                                // Check if this is a known difference
+                                let is_known = known_differences.iter().any(|(sid, pname, _)| {
+                                    *sid == scenario.id && *pname == name.as_str()
+                                });
+                                if is_known {
+                                    scenario_known_diff += 1;
+                                    let reason = known_differences
+                                        .iter()
+                                        .find(|(sid, pname, _)| {
+                                            *sid == scenario.id && *pname == name.as_str()
+                                        })
+                                        .map(|(_, _, r)| *r)
+                                        .unwrap_or("convention difference");
+                                    known_diffs.push((
+                                        name.clone(),
+                                        *expected_val,
+                                        *actual_val,
+                                        reason,
+                                    ));
+                                } else {
+                                    failures.push((name.clone(), *expected_val, *actual_val));
+                                }
+                            }
+                        }
+
+                        passed_params += scenario_passed;
+                        known_diff_params += scenario_known_diff;
+
+                        if failures.is_empty() {
+                            if known_diffs.is_empty() {
+                                println!("✓ ({}/{} params)", scenario_passed, scenario_total);
+                            } else {
+                                println!(
+                                    "✓ ({}/{} params, {} known diffs)",
+                                    scenario_passed,
+                                    scenario_total,
+                                    known_diffs.len()
+                                );
+                                for (name, expected_val, actual_val, reason) in &known_diffs {
+                                    println!(
+                                        "    [known] {} - expected: {:.6}, got: {:.6} ({})",
+                                        name, expected_val, actual_val, reason
+                                    );
+                                }
+                            }
+                        } else {
+                            println!(
+                                "✗ ({}/{} params, {} failures)",
+                                scenario_passed,
+                                scenario_total,
+                                failures.len()
+                            );
+                            for (name, expected_val, actual_val) in &failures {
+                                println!(
+                                    "    {} - expected: {:.6}, got: {:.6}",
+                                    name, expected_val, actual_val
+                                );
+                            }
+                            if !known_diffs.is_empty() {
+                                for (name, expected_val, actual_val, reason) in &known_diffs {
+                                    println!(
+                                        "    [known] {} - expected: {:.6}, got: {:.6} ({})",
+                                        name, expected_val, actual_val, reason
+                                    );
+                                }
+                            }
+                            failed_scenarios.push(scenario.id.clone());
+                        }
+                    }
+                    Err(e) => {
+                        println!("⚠ {}", e);
+                    }
+                }
+            } else {
+                println!("⚠ No expected values");
+            }
+        }
+
+        println!("\n═══════════════════════════════════════════════════════════════");
+        println!(
+            "Summary: {}/{} parameters matched ({:.1}%)",
+            passed_params,
+            total_params,
+            (passed_params as f64 / total_params as f64) * 100.0
+        );
+        if known_diff_params > 0 {
+            println!(
+                "Known differences: {} (documented convention differences)",
+                known_diff_params
+            );
+        }
+        if !failed_scenarios.is_empty() {
+            println!("Failed scenarios: {:?}", failed_scenarios);
+        }
+        println!("═══════════════════════════════════════════════════════════════\n");
+
+        // Fail test only for unexpected failures (not known differences)
+        assert!(
+            failed_scenarios.is_empty(),
+            "Some scenarios failed validation with unexpected differences"
+        );
+    }
+
+    /// Quick sanity test that runs without PKNCA expected values
+    #[test]
+    fn basic_nca_sanity_check() {
+        // Simple IV bolus test
+        let subject = Subject::builder("sanity")
+            .bolus(0.0, 100.0, 0)
+            .observation(0.0, 10.0, 0)
+            .observation(1.0, 6.0, 0)
+            .observation(2.0, 3.6, 0)
+            .observation(4.0, 1.3, 0)
+            .observation(8.0, 0.17, 0)
+            .build();
+
+        let options = NCAOptions::default();
+        let results = subject.nca(&options, 0);
+        let result = results[0].as_ref().expect("NCA should succeed");
+
+        // Basic sanity checks
+        assert_eq!(result.exposure.cmax, 10.0);
+        assert_eq!(result.exposure.tmax, 0.0);
+        assert!(result.exposure.auc_last > 0.0);
+        assert!(result.terminal.is_some());
+
+        let terminal = result.terminal.as_ref().unwrap();
+        assert!(terminal.lambda_z > 0.0);
+        assert!(terminal.half_life > 0.0);
+    }
+}
diff --git a/tests/pknca_validation/README.md b/tests/pknca_validation/README.md
new file mode 100644
index 00000000..0ea5ca07
--- /dev/null
+++ b/tests/pknca_validation/README.md
@@ -0,0 +1,66 @@
+# PKNCA Cross-Validation Framework
+
+This framework validates pharmsol's NCA implementation against PKNCA (the gold-standard R package) using a **clean-room approach**:
+
+1. **Test cases are independently designed** based on pharmacokinetic principles
+2. **PKNCA serves as an oracle** - we run it to get expected values
+3. **pharmsol results are compared** against these expected values
+
+## Directory Structure
+
+```
+tests/pknca_validation/
+├── README.md                    # This file
+├── generate_expected.R          # R script to run PKNCA and save expected values
+├── expected_values.json         # Generated expected outputs from PKNCA
+├── test_scenarios.json          # Test case definitions (inputs)
+└── validation_tests.rs          # Rust tests that compare pharmsol vs expected
+```
+
+## Usage
+
+### Step 1: Generate Expected Values (requires R + PKNCA)
+
+```bash
+cd tests/pknca_validation
+Rscript generate_expected.R
+```
+
+This creates `expected_values.json` with PKNCA's outputs.
+
+### Step 2: Run Validation Tests
+
+```bash
+cargo test pknca_validation
+```
+
+## Test Scenarios
+
+Test cases are designed to cover:
+
+| Category         | Scenarios                                             |
+| ---------------- | ----------------------------------------------------- |
+| **Basic PK**     | Single-dose oral, IV bolus, IV infusion               |
+| **AUC Methods**  | Linear, lin-up/log-down, lin-log                      |
+| **Lambda-z**     | Various terminal phase slopes, different point counts |
+| **BLQ Handling** | Zero, LOQ/2, exclude, positional                      |
+| **C0 Methods**   | Back-extrapolation, observed, first conc              |
+| **Edge Cases**   | Sparse data, flat profiles, noisy data                |
+
+## Validation Results
+
+**Current Status: 100% match (194/194 parameters)**
+
+| Metric                       | Value          |
+| ---------------------------- | -------------- |
+| Exact matches                | 194/194 (100%) |
+| Known convention differences | 0              |
+| Unexpected failures          | 0              |
+
+All NCA parameters computed by pharmsol match PKNCA v0.12.1 exactly.
+
+## Legal Note
+
+This framework does NOT copy PKNCA code or tests. Test scenarios are independently
+designed based on pharmacokinetic theory. PKNCA is used only as a reference
+implementation to validate numerical accuracy.
diff --git a/tests/pknca_validation/expected_values.json b/tests/pknca_validation/expected_values.json
new file mode 100644
index 00000000..316aceb5
--- /dev/null
+++ b/tests/pknca_validation/expected_values.json
@@ -0,0 +1,619 @@
+{
+  "generated_at": "2026-01-11T19:51:40",
+  "r_version": "R version 4.5.1 (2025-06-13)",
+  "pknca_version": "0.12.1",
+  "scenario_count": 25,
+  "results": {
+    "basic_oral_01": {
+      "id": "basic_oral_01",
+      "name": "Basic single-dose oral absorption",
+      "pknca_version": "0.12.1",
+      "auc_method": "lin up/log down",
+      "blq_rule": {},
+      "parameters": {
+        "cmax": 12,
+        "tmax": 2,
+        "tlast": 24,
+        "clast.obs": 0.05,
+        "tlag": 0,
+        "lambda.z": 0.2526,
+        "r.squared": 0.9941,
+        "adj.r.squared": 0.9926,
+        "lambda.z.time.first": 3,
+        "lambda.z.time.last": 24,
+        "lambda.z.n.points": 6,
+        "clast.pred": 0.044,
+        "half.life": 2.7445,
+        "span.ratio": 7.6516
+      }
+    },
+    "basic_oral_02": {
+      "id": "basic_oral_02",
+      "name": "Oral with delayed Tmax",
+      "pknca_version": "0.12.1",
+      "auc_method": "lin up/log down",
+      "blq_rule": {},
+      "parameters": {
+        "cmax": 10,
+        "tmax": 4,
+        "tlast": 48,
+        "clast.obs": 0.05,
+        "tlag": 0,
+        "lambda.z": 0.1148,
+        "r.squared": 1,
+        "adj.r.squared": 0.9999,
+        "lambda.z.time.first": 12,
+        "lambda.z.time.last": 48,
+        "lambda.z.n.points": 3,
+        "clast.pred": 0.0502,
+        "half.life": 6.0395,
+        "span.ratio": 5.9607
+      }
+    },
+    "iv_bolus_01": {
+      "id": "iv_bolus_01",
+      "name": "IV bolus single compartment",
+      "pknca_version": "0.12.1",
+      "auc_method": "lin up/log down",
+      "blq_rule": {},
+      "parameters": {
+        "auclast": 20.172,
+        "aucall": 20.172,
+        "aumclast": 40.3646,
+        "c0": 10,
+        "cmax": 10,
+        "tmax": 0,
+        "tlast": 12,
+        "clast.obs": 0.03,
+        "lambda.z": 0.4854,
+        "r.squared": 0.9998,
+        "adj.r.squared": 0.9998,
+        "lambda.z.time.first": 0.25,
+        "lambda.z.time.last": 12,
+        "lambda.z.n.points": 8,
+        "clast.pred": 0.0289,
+        "half.life": 1.4279,
+        "span.ratio": 8.2287,
+        "aucinf.obs": 20.2338,
+        "aucinf.pred": 20.2316,
+        "aumcinf.obs": 41.2336,
+        "aumcinf.pred": 41.2024,
+        "cl.obs": 4.9422,
+        "mrt.obs": 2.0379,
+        "vz.obs": 10.1814,
+        "vss.obs": 10.0716
+      }
+    },
+    "iv_bolus_02": {
+      "id": "iv_bolus_02",
+      "name": "IV bolus two-compartment",
+      "pknca_version": "0.12.1",
+      "auc_method": "lin up/log down",
+      "blq_rule": {},
+      "parameters": {
+        "auclast": 51.7981,
+        "aucall": 51.7981,
+        "aumclast": 166.7329,
+        "c0": 50,
+        "cmax": 50,
+        "tmax": 0,
+        "tlast": 24,
+        "clast.obs": 0.05,
+        "lambda.z": 0.1989,
+        "r.squared": 0.9932,
+        "adj.r.squared": 0.9865,
+        "lambda.z.time.first": 8,
+        "lambda.z.time.last": 24,
+        "lambda.z.n.points": 3,
+        "clast.pred": 0.0481,
+        "half.life": 3.485,
+        "span.ratio": 4.5911,
+        "aucinf.obs": 52.0494,
+        "aucinf.pred": 52.0401,
+        "aumcinf.obs": 174.0302,
+        "aumcinf.pred": 173.7588,
+        "cl.obs": 9.6063,
+        "mrt.obs": 3.3436,
+        "vz.obs": 48.2984,
+        "vss.obs": 32.119
+      }
+    },
+    "iv_infusion_01": {
+      "id": "iv_infusion_01",
+      "name": "1-hour IV infusion",
+      "pknca_version": "0.12.1",
+      "auc_method": "lin up/log down",
+      "blq_rule": {},
+      "parameters": {
+        "cmax": 15,
+        "tmax": 1,
+        "tlast": 12,
+        "clast.obs": 0.3,
+        "tlag": 0,
+        "lambda.z": 0.3525,
+        "r.squared": 0.9999,
+        "adj.r.squared": 0.9998,
+        "lambda.z.time.first": 1.5,
+        "lambda.z.time.last": 12,
+        "lambda.z.n.points": 6,
+        "clast.pred": 0.3014,
+        "half.life": 1.9666,
+        "span.ratio": 5.339
+      }
+    },
+    "auc_method_linear": {
+      "id": "auc_method_linear",
+      "name": "AUC comparison - Linear method",
+      "pknca_version": "0.12.1",
+      "auc_method": "linear",
+      "blq_rule": {},
+      "parameters": {
+        "cmax": 10,
+        "tmax": 2,
+        "tlast": 12,
+        "clast.obs": 0.4,
+        "tlag": 0,
+        "lambda.z": 0.3356,
+        "r.squared": 0.9997,
+        "adj.r.squared": 0.9997,
+        "lambda.z.time.first": 3,
+        "lambda.z.time.last": 12,
+        "lambda.z.n.points": 5,
+        "clast.pred": 0.3983,
+        "half.life": 2.0652,
+        "span.ratio": 4.3579
+      }
+    },
+    "auc_method_linuplogdown": {
+      "id": "auc_method_linuplogdown",
+      "name": "AUC comparison - Lin up/log down",
+      "pknca_version": "0.12.1",
+      "auc_method": "lin up/log down",
+      "blq_rule": {},
+      "parameters": {
+        "cmax": 10,
+        "tmax": 2,
+        "tlast": 12,
+        "clast.obs": 0.4,
+        "tlag": 0,
+        "lambda.z": 0.3356,
+        "r.squared": 0.9997,
+        "adj.r.squared": 0.9997,
+        "lambda.z.time.first": 3,
+        "lambda.z.time.last": 12,
+        "lambda.z.n.points": 5,
+        "clast.pred": 0.3983,
+        "half.life": 2.0652,
+        "span.ratio": 4.3579
+      }
+    },
+    "auc_method_linlog": {
+      "id": "auc_method_linlog",
+      "name": "AUC comparison - Lin-log method",
+      "pknca_version": "0.12.1",
+      "auc_method": "lin-log",
+      "blq_rule": {},
+      "parameters": {
+        "cmax": 10,
+        "tmax": 2,
+        "tlast": 12,
+        "clast.obs": 0.4,
+        "tlag": 0,
+        "lambda.z": 0.3356,
+        "r.squared": 0.9997,
+        "adj.r.squared": 0.9997,
+        "lambda.z.time.first": 3,
+        "lambda.z.time.last": 12,
+        "lambda.z.n.points": 5,
+        "clast.pred": 0.3983,
+        "half.life": 2.0652,
+        "span.ratio": 4.3579
+      }
+    },
+    "lambda_z_short": {
+      "id": "lambda_z_short",
+      "name": "Lambda-z with minimum points",
+      "pknca_version": "0.12.1",
+      "auc_method": "lin up/log down",
+      "blq_rule": {},
+      "parameters": {
+        "cmax": 10,
+        "tmax": 1,
+        "tlast": 8,
+        "clast.obs": 1,
+        "tlag": 0,
+        "lambda.z": 0.3466,
+        "r.squared": 1,
+        "adj.r.squared": 1,
+        "lambda.z.time.first": 2,
+        "lambda.z.time.last": 8,
+        "lambda.z.n.points": 4,
+        "clast.pred": 1,
+        "half.life": 2,
+        "span.ratio": 3
+      }
+    },
+    "lambda_z_long": {
+      "id": "lambda_z_long",
+      "name": "Lambda-z with many points",
+      "pknca_version": "0.12.1",
+      "auc_method": "lin up/log down",
+      "blq_rule": {},
+      "parameters": {
+        "cmax": 12,
+        "tmax": 2,
+        "tlast": 48,
+        "clast.obs": 0.002,
+        "tlag": 0,
+        "lambda.z": 0.1882,
+        "r.squared": 1,
+        "adj.r.squared": 1,
+        "lambda.z.time.first": 4,
+        "lambda.z.time.last": 48,
+        "lambda.z.n.points": 8,
+        "clast.pred": 0.002,
+        "half.life": 3.6828,
+        "span.ratio": 11.9474
+      }
+    },
+    "blq_middle": {
+      "id": "blq_middle",
+      "name": "BLQ in middle of profile",
+      "pknca_version": "0.12.1",
+      "auc_method": "lin up/log down",
+      "blq_rule": "exclude",
+      "parameters": {
+        "cmax": 10,
+        "tmax": 2,
+        "tlast": 12,
+        "clast.obs": 0.4,
+        "tlag": 0,
+        "lambda.z": 0.3383,
+        "r.squared": 0.9998,
+        "adj.r.squared": 0.9997,
+        "lambda.z.time.first": 4,
+        "lambda.z.time.last": 12,
+        "lambda.z.n.points": 4,
+        "clast.pred": 0.3956,
+        "half.life": 2.0491,
+        "span.ratio": 3.9042
+      }
+    },
+    "blq_positional": {
+      "id": "blq_positional",
+      "name": "BLQ with positional handling",
+      "pknca_version": "0.12.1",
+      "auc_method": "lin up/log down",
+      "blq_rule": "positional",
+      "parameters": {
+        "auclast": 36.186,
+        "aucall": 40.186,
+        "aumclast": 116.2766,
+        "cmax": 10,
+        "tmax": 1,
+        "tlast": 8,
+        "clast.obs": 2,
+        "tlag": 0
+      }
+    },
+    "sparse_profile": {
+      "id": "sparse_profile",
+      "name": "Sparse sampling profile",
+      "pknca_version": "0.12.1",
+      "auc_method": "lin up/log down",
+      "blq_rule": {},
+      "parameters": {
+        "cmax": 12,
+        "tmax": 2,
+        "tlast": 24,
+        "clast.obs": 0.2,
+        "tlag": 0
+      }
+    },
+    "flat_cmax": {
+      "id": "flat_cmax",
+      "name": "Multiple Tmax candidates",
+      "pknca_version": "0.12.1",
+      "auc_method": "lin up/log down",
+      "blq_rule": {},
+      "parameters": {
+        "cmax": 10,
+        "tmax": 2,
+        "tlast": 8,
+        "clast.obs": 3,
+        "tlag": 0,
+        "lambda.z": 0.301,
+        "r.squared": 0.9924,
+        "adj.r.squared": 0.9848,
+        "lambda.z.time.first": 4,
+        "lambda.z.time.last": 8,
+        "lambda.z.n.points": 3,
+        "clast.pred": 3.0926,
+        "half.life": 2.3029,
+        "span.ratio": 1.737
+      }
+    },
+    "high_extrapolation": {
+      "id": "high_extrapolation",
+      "name": "High AUC extrapolation percentage",
+      "pknca_version": "0.12.1",
+      "auc_method": "lin up/log down",
+      "blq_rule": {},
+      "parameters": {
+        "cmax": 10,
+        "tmax": 1,
+        "tlast": 6,
+        "clast.obs": 3,
+        "tlag": 0,
+        "lambda.z": 0.2452,
+        "r.squared": 0.9994,
+        "adj.r.squared": 0.9988,
+        "lambda.z.time.first": 2,
+        "lambda.z.time.last": 6,
+        "lambda.z.n.points": 3,
+        "clast.pred": 3.0205,
+        "half.life": 2.8268,
+        "span.ratio": 1.415
+      }
+    },
+    "clast_pred_comparison": {
+      "id": "clast_pred_comparison",
+      "name": "Clast observed vs predicted",
+      "pknca_version": "0.12.1",
+      "auc_method": "lin up/log down",
+      "blq_rule": {},
+      "parameters": {
+        "cmax": 12,
+        "tmax": 2,
+        "tlast": 12,
+        "clast.obs": 0.8,
+        "tlag": 0,
+        "lambda.z": 0.2708,
+        "r.squared": 0.9998,
+        "adj.r.squared": 0.9997,
+        "lambda.z.time.first": 4,
+        "lambda.z.time.last": 12,
+        "lambda.z.n.points": 4,
+        "clast.pred": 0.7921,
+        "half.life": 2.5597,
+        "span.ratio": 3.1254
+      }
+    },
+    "partial_auc": {
+      "id": "partial_auc",
+      "name": "Partial AUC calculation",
+      "pknca_version": "0.12.1",
+      "auc_method": "lin up/log down",
+      "blq_rule": {},
+      "parameters": {
+        "cmax": 10,
+        "tmax": 2,
+        "tlast": 24,
+        "clast.obs": 0.3,
+        "tlag": 0,
+        "lambda.z": 0.1631,
+        "r.squared": 0.9862,
+        "adj.r.squared": 0.9816,
+        "lambda.z.time.first": 4,
+        "lambda.z.time.last": 24,
+        "lambda.z.n.points": 5,
+        "clast.pred": 0.271,
+        "half.life": 4.2493,
+        "span.ratio": 4.7066,
+        "partial_auc": 40.1198,
+        "partial_auc_start": 2,
+        "partial_auc_end": 8
+      }
+    },
+    "mrt_calculation": {
+      "id": "mrt_calculation",
+      "name": "MRT and related parameters",
+      "pknca_version": "0.12.1",
+      "auc_method": "lin up/log down",
+      "blq_rule": {},
+      "parameters": {
+        "cmax": 10,
+        "tmax": 2,
+        "tlast": 24,
+        "clast.obs": 0.15,
+        "tlag": 0,
+        "lambda.z": 0.1792,
+        "r.squared": 0.9913,
+        "adj.r.squared": 0.987,
+        "lambda.z.time.first": 6,
+        "lambda.z.time.last": 24,
+        "lambda.z.n.points": 4,
+        "clast.pred": 0.1409,
+        "half.life": 3.8672,
+        "span.ratio": 4.6545
+      }
+    },
+    "tlag_detection": {
+      "id": "tlag_detection",
+      "name": "Lag time detection",
+      "pknca_version": "0.12.1",
+      "auc_method": "lin up/log down",
+      "blq_rule": {},
+      "parameters": {
+        "cmax": 10,
+        "tmax": 2,
+        "tlast": 8,
+        "clast.obs": 1.5,
+        "tlag": 0.5,
+        "lambda.z": 0.3466,
+        "r.squared": 1,
+        "adj.r.squared": 1,
+        "lambda.z.time.first": 4,
+        "lambda.z.time.last": 8,
+        "lambda.z.n.points": 3,
+        "clast.pred": 1.5,
+        "half.life": 2,
+        "span.ratio": 2
+      }
+    },
+    "numerical_precision": {
+      "id": "numerical_precision",
+      "name": "Numerical precision test",
+      "pknca_version": "0.12.1",
+      "auc_method": "lin up/log down",
+      "blq_rule": {},
+      "parameters": {
+        "cmax": 67.891,
+        "tmax": 2,
+        "tlast": 96,
+        "clast.obs": 0.002,
+        "tlag": 0,
+        "lambda.z": 0.1059,
+        "r.squared": 0.9998,
+        "adj.r.squared": 0.9997,
+        "lambda.z.time.first": 12,
+        "lambda.z.time.last": 96,
+        "lambda.z.n.points": 5,
+        "clast.pred": 0.0021,
+        "half.life": 6.5456,
+        "span.ratio": 12.8331
+      }
+    },
+    "steady_state_oral": {
+      "id": "steady_state_oral",
+      "name": "Steady-state oral dosing",
+      "pknca_version": "0.12.1",
+      "auc_method": "lin up/log down",
+      "blq_rule": {},
+      "parameters": {
+        "auclast": 67.5547,
+        "aucall": 67.5547,
+        "aumclast": 295.7289,
+        "cmax": 12,
+        "cmin": 1.5,
+        "tmax": 2,
+        "tlast": 12,
+        "clast.obs": 1.5,
+        "cav": 5.6296,
+        "tlag": 0,
+        "lambda.z": 0.2132,
+        "r.squared": 0.9986,
+        "adj.r.squared": 0.9981,
+        "lambda.z.time.first": 4,
+        "lambda.z.time.last": 12,
+        "lambda.z.n.points": 5,
+        "clast.pred": 1.4819,
+        "half.life": 3.251,
+        "span.ratio": 2.4608,
+        "aucinf.obs": 74.59,
+        "aucinf.pred": 74.5051,
+        "aumcinf.obs": 413.1483,
+        "aumcinf.pred": 411.7316,
+        "cl.obs": 1.3407,
+        "mrt.obs": 5.5389,
+        "vz.obs": 6.2879
+      }
+    },
+    "steady_state_iv": {
+      "id": "steady_state_iv",
+      "name": "Steady-state IV infusion",
+      "pknca_version": "0.12.1",
+      "auc_method": "lin up/log down",
+      "blq_rule": {},
+      "parameters": {
+        "auclast": 139.0232,
+        "aucall": 139.0232,
+        "aumclast": 920.3314,
+        "cmax": 18,
+        "cmin": 0.5,
+        "tmax": 2,
+        "tlast": 24,
+        "clast.obs": 0.5,
+        "cav": 5.7926,
+        "tlag": 0,
+        "lambda.z": 0.1661,
+        "r.squared": 0.999,
+        "adj.r.squared": 0.9988,
+        "lambda.z.time.first": 4,
+        "lambda.z.time.last": 24,
+        "lambda.z.n.points": 6,
+        "clast.pred": 0.526,
+        "half.life": 4.1731,
+        "span.ratio": 4.7926,
+        "aucinf.obs": 142.0334,
+        "aucinf.pred": 142.1897,
+        "aumcinf.obs": 1010.7007,
+        "aumcinf.pred": 1015.3927,
+        "cl.obs": 3.5203,
+        "mrt.obs": 7.1159,
+        "mrt.iv.obs": 6.1159,
+        "vss.obs": 25.0502
+      }
+    },
+    "c0_logslope": {
+      "id": "c0_logslope",
+      "name": "C0 back-extrapolation test",
+      "pknca_version": "0.12.1",
+      "auc_method": "lin up/log down",
+      "blq_rule": {},
+      "parameters": {
+        "c0": 9.8462,
+        "cmax": 8,
+        "tmax": 0.5,
+        "tlast": 8,
+        "clast.obs": 0.35,
+        "tlag": 0,
+        "lambda.z": 0.4182,
+        "r.squared": 0.9999,
+        "adj.r.squared": 0.9999,
+        "lambda.z.time.first": 1,
+        "lambda.z.time.last": 8,
+        "lambda.z.n.points": 5,
+        "clast.pred": 0.3501,
+        "half.life": 1.6573,
+        "span.ratio": 4.2237
+      }
+    },
+    "span_ratio_test": {
+      "id": "span_ratio_test",
+      "name": "Span ratio quality metric",
+      "pknca_version": "0.12.1",
+      "auc_method": "lin up/log down",
+      "blq_rule": {},
+      "parameters": {
+        "cmax": 12,
+        "tmax": 2,
+        "tlast": 48,
+        "clast.obs": 0.1,
+        "tlag": 0,
+        "lambda.z": 0.0924,
+        "r.squared": 0.9999,
+        "adj.r.squared": 0.9999,
+        "lambda.z.time.first": 12,
+        "lambda.z.time.last": 48,
+        "lambda.z.n.points": 3,
+        "clast.pred": 0.0995,
+        "half.life": 7.5002,
+        "span.ratio": 4.7999
+      }
+    },
+    "auc_all_terminal_blq": {
+      "id": "auc_all_terminal_blq",
+      "name": "AUCall with terminal BLQ",
+      "pknca_version": "0.12.1",
+      "auc_method": "lin up/log down",
+      "blq_rule": "exclude",
+      "parameters": {
+        "cmax": 10,
+        "tmax": 2,
+        "tlast": 8,
+        "clast.obs": 1.5,
+        "tlag": 0,
+        "lambda.z": 0.3466,
+        "r.squared": 1,
+        "adj.r.squared": 1,
+        "lambda.z.time.first": 4,
+        "lambda.z.time.last": 8,
+        "lambda.z.n.points": 3,
+        "clast.pred": 1.5,
+        "half.life": 2,
+        "span.ratio": 2
+      }
+    }
+  }
+}
diff --git a/tests/pknca_validation/generate_expected.R b/tests/pknca_validation/generate_expected.R
new file mode 100644
index 00000000..dc2f1491
--- /dev/null
+++ b/tests/pknca_validation/generate_expected.R
@@ -0,0 +1,250 @@
+#!/usr/bin/env Rscript
+# =============================================================================
+# PKNCA Cross-Validation: Generate Expected Values
+# =============================================================================
+#
+# This script reads test scenarios from test_scenarios.json, runs PKNCA to
+# compute NCA parameters, and saves the expected values to expected_values.json.
+#
+# Usage: Rscript generate_expected.R
+#
+# Requirements: R with PKNCA, jsonlite packages installed
+# =============================================================================
+
+library(PKNCA)
+library(jsonlite)
+
+cat("PKNCA Cross-Validation - Generating Expected Values\n")
+cat("====================================================\n\n")
+
+# Read test scenarios
+scenarios_raw <- fromJSON("test_scenarios.json", simplifyVector = FALSE)
+scenarios <- scenarios_raw$scenarios
+cat(sprintf("Loaded %d test scenarios\n\n", length(scenarios)))
+
+# Helper function to map our route names to PKNCA expectations
+get_route_for_pknca <- function(route) {
+    switch(route,
+        "extravascular" = "extravascular",
+        "iv_bolus" = "intravascular",
+        "iv_infusion" = "intravascular",
+        route
+    )
+}
+
+# Helper function to get AUC method name for PKNCA
+get_auc_method <- function(method) {
+    if (is.null(method)) {
+        return("lin up/log down")
+    }
+    method
+}
+
+# Process each scenario
+results <- list()
+
+for (scenario in scenarios) {
+    cat(sprintf("Processing: %s (%s)\n", scenario$name, scenario$id))
+
+    tryCatch(
+        {
+            # Build concentration data frame - unlist JSON arrays
+            times <- unlist(scenario$times)
+            concs <- unlist(scenario$concentrations)
+
+            conc_data <- data.frame(
+                ID = 1,
+                time = times,
+                conc = concs
+            )
+
+            # Handle BLQ if specified
+            if (!is.null(scenario$blq_indices)) {
+                # Mark BLQ as 0 (PKNCA convention)
+                # Note: blq_indices are 0-based from JSON
+                blq_idx <- unlist(scenario$blq_indices)
+                for (idx in blq_idx) {
+                    conc_data$conc[idx + 1] <- 0
+                }
+            }
+
+            # Build dose data frame
+            dose_data <- data.frame(
+                ID = 1,
+                time = scenario$dose$time,
+                dose = scenario$dose$amount
+            )
+
+            # Add duration for infusions
+            if (scenario$route == "iv_infusion" && !is.null(scenario$dose$duration)) {
+                dose_data$duration <- scenario$dose$duration
+            }
+
+            # Create PKNCA objects
+            conc_obj <- PKNCAconc(conc_data, conc ~ time | ID)
+
+            if (scenario$route == "iv_infusion" && !is.null(scenario$dose$duration)) {
+                dose_obj <- PKNCAdose(dose_data, dose ~ time | ID,
+                    route = "intravascular",
+                    duration = "duration"
+                )
+            } else {
+                dose_obj <- PKNCAdose(dose_data, dose ~ time | ID,
+                    route = get_route_for_pknca(scenario$route)
+                )
+            }
+
+            # Set up intervals - request all parameters up to infinity
+            intervals <- data.frame(
+                start = 0,
+                end = Inf,
+                cmax = TRUE,
+                tmax = TRUE,
+                tlast = TRUE,
+                clast.obs = TRUE,
+                auclast = TRUE,
+                aucall = TRUE,
+                aumclast = TRUE,
+                half.life = TRUE,
+                lambda.z = TRUE,
+                r.squared = TRUE,
+                adj.r.squared = TRUE,
+                lambda.z.n.points = TRUE,
+                clast.pred = TRUE,
+                aucinf.obs = TRUE,
+                aucinf.pred = TRUE,
+                aumcinf.obs = TRUE,
+                aumcinf.pred = TRUE,
+                mrt.obs = TRUE,
+                tlag = TRUE,
+                span.ratio = TRUE
+            )
+
+            # Add steady-state parameters if tau is specified
+            if (!is.null(scenario$tau)) {
+                tau_val <- scenario$tau
+                intervals$end <- tau_val # Use tau as the interval end
+                intervals$cmin <- TRUE
+                intervals$cav <- TRUE
+            }
+
+            # Add route-specific parameters
+            if (scenario$route == "iv_bolus") {
+                intervals$c0 <- TRUE
+                intervals$vz.obs <- TRUE
+                intervals$cl.obs <- TRUE
+                intervals$vss.obs <- TRUE
+            } else if (scenario$route == "iv_infusion") {
+                intervals$cl.obs <- TRUE
+                intervals$vss.obs <- TRUE
+                intervals$mrt.iv.obs <- TRUE
+            } else {
+                intervals$vz.obs <- TRUE
+                intervals$cl.obs <- TRUE
+            }
+
+            # Add partial AUC if specified
+            if (!is.null(scenario$partial_auc_interval)) {
+                partial_int <- unlist(scenario$partial_auc_interval)
+                partial_interval <- data.frame(
+                    start = partial_int[1],
+                    end = partial_int[2],
+                    auclast = TRUE
+                )
+            }
+
+            # Set PKNCA options
+            auc_method <- get_auc_method(scenario$auc_method)
+
+            # Determine BLQ handling
+            blq_handling <- if (!is.null(scenario$blq_rule)) {
+                switch(scenario$blq_rule,
+                    "exclude" = "drop",
+                    "zero" = "keep",
+                    "positional" = list(first = "keep", middle = "drop", last = "keep"),
+                    "drop"
+                )
+            } else {
+                "drop"
+            }
+
+            # Create PKNCAdata with options
+            data_obj <- PKNCAdata(
+                conc_obj, dose_obj,
+                intervals = intervals,
+                options = list(
+                    auc.method = auc_method,
+                    conc.blq = blq_handling
+                )
+            )
+
+            # Run NCA
+            nca_result <- pk.nca(data_obj)
+
+            # Extract results
+            result_df <- as.data.frame(nca_result)
+
+            # Convert to named list
+            param_values <- list()
+            for (i in 1:nrow(result_df)) {
+                param_name <- result_df$PPTESTCD[i]
+                param_value <- result_df$PPORRES[i]
+                if (!is.na(param_value)) {
+                    param_values[[param_name]] <- param_value
+                }
+            }
+
+            # Calculate partial AUC if requested
+            if (!is.null(scenario$partial_auc_interval)) {
+                partial_int <- unlist(scenario$partial_auc_interval)
+                start_t <- partial_int[1]
+                end_t <- partial_int[2]
+                partial_auc <- pk.calc.auc(
+                    conc_data$conc, conc_data$time,
+                    interval = c(start_t, end_t),
+                    method = auc_method,
+                    auc.type = "AUClast"
+                )
+                param_values[["partial_auc"]] <- partial_auc
+                param_values[["partial_auc_start"]] <- start_t
+                param_values[["partial_auc_end"]] <- end_t
+            }
+
+            # Store results
+            results[[scenario$id]] <- list(
+                id = scenario$id,
+                name = scenario$name,
+                pknca_version = as.character(packageVersion("PKNCA")),
+                auc_method = auc_method,
+                blq_rule = scenario$blq_rule,
+                parameters = param_values
+            )
+
+            cat(sprintf("  -> Computed %d parameters\n", length(param_values)))
+        },
+        error = function(e) {
+            cat(sprintf("  -> ERROR: %s\n", e$message))
+            results[[scenario$id]] <<- list(
+                id = scenario$id,
+                name = scenario$name,
+                error = e$message
+            )
+        }
+    )
+}
+
+# Create output structure
+output <- list(
+    generated_at = format(Sys.time(), "%Y-%m-%dT%H:%M:%S"),
+    r_version = R.version.string,
+    pknca_version = as.character(packageVersion("PKNCA")),
+    scenario_count = length(results),
+    results = results
+)
+
+# Write to JSON
+output_file <- "expected_values.json"
+write_json(output, output_file, pretty = TRUE, auto_unbox = TRUE)
+
+cat(sprintf("\n✓ Generated expected values for %d scenarios\n", length(results)))
+cat(sprintf("✓ Saved to: %s\n", output_file))
diff --git a/tests/pknca_validation/test_scenarios.json b/tests/pknca_validation/test_scenarios.json
new file mode 100644
index 00000000..8523abd8
--- /dev/null
+++ b/tests/pknca_validation/test_scenarios.json
@@ -0,0 +1,333 @@
+{
+  "version": "1.0",
+  "description": "Independent test scenarios for NCA cross-validation",
+  "scenarios": [
+    {
+      "id": "basic_oral_01",
+      "name": "Basic single-dose oral absorption",
+      "description": "Standard oral PK profile with clear absorption and elimination phases",
+      "route": "extravascular",
+      "dose": { "amount": 100, "time": 0 },
+      "times": [0, 0.5, 1, 2, 3, 4, 6, 8, 12, 24],
+      "concentrations": [0, 2.5, 8.0, 12.0, 10.0, 7.5, 4.2, 2.3, 0.7, 0.05],
+      "test_params": [
+        "cmax",
+        "tmax",
+        "auc_last",
+        "auc_inf",
+        "lambda_z",
+        "half_life",
+        "cl_f",
+        "vz_f"
+      ]
+    },
+    {
+      "id": "basic_oral_02",
+      "name": "Oral with delayed Tmax",
+      "description": "Slower absorption with Tmax at 4 hours",
+      "route": "extravascular",
+      "dose": { "amount": 250, "time": 0 },
+      "times": [0, 0.5, 1, 2, 4, 6, 8, 12, 24, 48],
+      "concentrations": [0, 0.5, 2.0, 5.5, 10.0, 8.5, 6.2, 3.1, 0.8, 0.05],
+      "test_params": [
+        "cmax",
+        "tmax",
+        "auc_last",
+        "auc_inf",
+        "lambda_z",
+        "half_life",
+        "tlag"
+      ]
+    },
+    {
+      "id": "iv_bolus_01",
+      "name": "IV bolus single compartment",
+      "description": "Monoexponential decline after IV bolus",
+      "route": "iv_bolus",
+      "dose": { "amount": 100, "time": 0 },
+      "times": [0, 0.25, 0.5, 1, 2, 4, 6, 8, 12],
+      "concentrations": [10.0, 8.8, 7.8, 6.1, 3.7, 1.4, 0.5, 0.2, 0.03],
+      "test_params": [
+        "c0",
+        "cmax",
+        "auc_last",
+        "auc_inf",
+        "lambda_z",
+        "half_life",
+        "cl",
+        "vd",
+        "vss"
+      ]
+    },
+    {
+      "id": "iv_bolus_02",
+      "name": "IV bolus two-compartment",
+      "description": "Biexponential decline showing distribution phase",
+      "route": "iv_bolus",
+      "dose": { "amount": 500, "time": 0 },
+      "times": [0, 0.083, 0.25, 0.5, 1, 2, 4, 8, 12, 24],
+      "concentrations": [
+        50.0, 35.0, 22.0, 15.0, 10.0, 6.5, 3.8, 1.3, 0.45, 0.05
+      ],
+      "test_params": [
+        "c0",
+        "cmax",
+        "auc_last",
+        "auc_inf",
+        "lambda_z",
+        "half_life"
+      ]
+    },
+    {
+      "id": "iv_infusion_01",
+      "name": "1-hour IV infusion",
+      "description": "IV infusion over 1 hour",
+      "route": "iv_infusion",
+      "dose": { "amount": 200, "time": 0, "duration": 1.0 },
+      "times": [0, 0.5, 1, 1.5, 2, 4, 6, 8, 12],
+      "concentrations": [0, 8.0, 15.0, 12.5, 10.0, 5.0, 2.5, 1.25, 0.3],
+      "test_params": [
+        "cmax",
+        "tmax",
+        "auc_last",
+        "auc_inf",
+        "lambda_z",
+        "half_life",
+        "cl",
+        "vss"
+      ]
+    },
+    {
+      "id": "auc_method_linear",
+      "name": "AUC comparison - Linear method",
+      "description": "Profile for comparing AUC calculation methods",
+      "route": "extravascular",
+      "dose": { "amount": 100, "time": 0 },
+      "times": [0, 1, 2, 3, 4, 6, 8, 12],
+      "concentrations": [0, 5.0, 10.0, 8.0, 6.0, 3.0, 1.5, 0.4],
+      "auc_method": "linear",
+      "test_params": ["auc_last", "aumc_last"]
+    },
+    {
+      "id": "auc_method_linuplogdown",
+      "name": "AUC comparison - Lin up/log down",
+      "description": "Same profile with lin-up/log-down method",
+      "route": "extravascular",
+      "dose": { "amount": 100, "time": 0 },
+      "times": [0, 1, 2, 3, 4, 6, 8, 12],
+      "concentrations": [0, 5.0, 10.0, 8.0, 6.0, 3.0, 1.5, 0.4],
+      "auc_method": "lin up/log down",
+      "test_params": ["auc_last", "aumc_last"]
+    },
+    {
+      "id": "auc_method_linlog",
+      "name": "AUC comparison - Lin-log method",
+      "description": "Same profile with lin-log method (linear pre-Tmax, log post-Tmax)",
+      "route": "extravascular",
+      "dose": { "amount": 100, "time": 0 },
+      "times": [0, 1, 2, 3, 4, 6, 8, 12],
+      "concentrations": [0, 5.0, 10.0, 8.0, 6.0, 3.0, 1.5, 0.4],
+      "auc_method": "lin-log",
+      "test_params": ["auc_last", "aumc_last"]
+    },
+    {
+      "id": "lambda_z_short",
+      "name": "Lambda-z with minimum points",
+      "description": "Short terminal phase with 3 points",
+      "route": "extravascular",
+      "dose": { "amount": 100, "time": 0 },
+      "times": [0, 1, 2, 4, 6, 8],
+      "concentrations": [0, 10.0, 8.0, 4.0, 2.0, 1.0],
+      "test_params": ["lambda_z", "half_life", "r_squared", "n_points_lambda_z"]
+    },
+    {
+      "id": "lambda_z_long",
+      "name": "Lambda-z with many points",
+      "description": "Extended terminal phase with 8 points",
+      "route": "extravascular",
+      "dose": { "amount": 100, "time": 0 },
+      "times": [0, 1, 2, 4, 6, 8, 12, 16, 24, 36, 48],
+      "concentrations": [
+        0, 10.0, 12.0, 8.0, 5.5, 3.8, 1.8, 0.85, 0.19, 0.02, 0.002
+      ],
+      "test_params": [
+        "lambda_z",
+        "half_life",
+        "r_squared",
+        "adj_r_squared",
+        "n_points_lambda_z"
+      ]
+    },
+    {
+      "id": "blq_middle",
+      "name": "BLQ in middle of profile",
+      "description": "Profile with BLQ values between positive concentrations",
+      "route": "extravascular",
+      "dose": { "amount": 100, "time": 0 },
+      "times": [0, 1, 2, 3, 4, 6, 8, 12],
+      "concentrations": [0, 5.0, 10.0, 0, 6.0, 3.0, 1.5, 0.4],
+      "blq_indices": [0, 3],
+      "loq": 0.1,
+      "blq_rule": "exclude",
+      "test_params": ["cmax", "tmax", "auc_last", "tlast"]
+    },
+    {
+      "id": "blq_positional",
+      "name": "BLQ with positional handling",
+      "description": "BLQ at start, middle, and end with positional rule",
+      "route": "extravascular",
+      "dose": { "amount": 100, "time": 0 },
+      "times": [0, 1, 2, 4, 8, 12],
+      "concentrations": [0, 10.0, 0, 4.0, 2.0, 0],
+      "blq_indices": [0, 2, 5],
+      "loq": 0.1,
+      "blq_rule": "positional",
+      "test_params": ["cmax", "tmax", "auc_last", "tlast", "clast"]
+    },
+    {
+      "id": "sparse_profile",
+      "name": "Sparse sampling profile",
+      "description": "Only 4 concentration time points",
+      "route": "extravascular",
+      "dose": { "amount": 100, "time": 0 },
+      "times": [0, 2, 8, 24],
+      "concentrations": [0, 12.0, 3.0, 0.2],
+      "test_params": ["cmax", "tmax", "auc_last"]
+    },
+    {
+      "id": "flat_cmax",
+      "name": "Multiple Tmax candidates",
+      "description": "Profile where Cmax is reached at multiple time points",
+      "route": "extravascular",
+      "dose": { "amount": 100, "time": 0 },
+      "times": [0, 1, 2, 3, 4, 6, 8],
+      "concentrations": [0, 5.0, 10.0, 10.0, 10.0, 6.0, 3.0],
+      "test_params": ["cmax", "tmax"]
+    },
+    {
+      "id": "high_extrapolation",
+      "name": "High AUC extrapolation percentage",
+      "description": "Profile where extrapolated portion is significant",
+      "route": "extravascular",
+      "dose": { "amount": 100, "time": 0 },
+      "times": [0, 1, 2, 4, 6],
+      "concentrations": [0, 10.0, 8.0, 5.0, 3.0],
+      "test_params": ["auc_last", "auc_inf", "auc_extrap_pct"]
+    },
+    {
+      "id": "clast_pred_comparison",
+      "name": "Clast observed vs predicted",
+      "description": "Compare AUCinf,obs vs AUCinf,pred",
+      "route": "extravascular",
+      "dose": { "amount": 100, "time": 0 },
+      "times": [0, 1, 2, 4, 6, 8, 12],
+      "concentrations": [0, 8.0, 12.0, 7.0, 4.0, 2.3, 0.8],
+      "test_params": ["clast_obs", "clast_pred", "auc_inf_obs", "auc_inf_pred"]
+    },
+    {
+      "id": "partial_auc",
+      "name": "Partial AUC calculation",
+      "description": "AUC over specific time interval",
+      "route": "extravascular",
+      "dose": { "amount": 100, "time": 0 },
+      "times": [0, 1, 2, 4, 6, 8, 12, 24],
+      "concentrations": [0, 5.0, 10.0, 8.0, 5.5, 3.5, 1.5, 0.3],
+      "partial_auc_interval": [2, 8],
+      "test_params": ["auc_last", "partial_auc"]
+    },
+    {
+      "id": "mrt_calculation",
+      "name": "MRT and related parameters",
+      "description": "Mean residence time calculation",
+      "route": "extravascular",
+      "dose": { "amount": 100, "time": 0 },
+      "times": [0, 0.5, 1, 2, 4, 6, 8, 12, 24],
+      "concentrations": [0, 3.0, 8.0, 10.0, 6.5, 4.0, 2.5, 1.0, 0.15],
+      "test_params": ["auc_inf", "aumc_inf", "mrt"]
+    },
+    {
+      "id": "tlag_detection",
+      "name": "Lag time detection",
+      "description": "Profile with absorption lag",
+      "route": "extravascular",
+      "dose": { "amount": 100, "time": 0 },
+      "times": [0, 0.25, 0.5, 1, 2, 4, 6, 8],
+      "concentrations": [0, 0, 0, 5.0, 10.0, 6.0, 3.0, 1.5],
+      "test_params": ["tlag", "cmax", "tmax"]
+    },
+    {
+      "id": "numerical_precision",
+      "name": "Numerical precision test",
+      "description": "Values requiring high precision",
+      "route": "extravascular",
+      "dose": { "amount": 1000, "time": 0 },
+      "times": [0, 0.5, 1, 2, 4, 8, 12, 24, 48, 72, 96],
+      "concentrations": [
+        0, 15.234, 45.678, 67.891, 52.345, 28.123, 15.067, 4.321, 0.354, 0.029,
+        0.002
+      ],
+      "test_params": ["auc_last", "auc_inf", "lambda_z", "half_life"]
+    },
+    {
+      "id": "steady_state_oral",
+      "name": "Steady-state oral dosing",
+      "description": "Profile at steady state with tau=12h for cmin, cavg, fluctuation, swing",
+      "route": "extravascular",
+      "dose": { "amount": 100, "time": 0 },
+      "tau": 12,
+      "times": [0, 0.5, 1, 2, 4, 6, 8, 10, 12],
+      "concentrations": [1.5, 5.0, 10.0, 12.0, 8.0, 5.5, 3.5, 2.2, 1.5],
+      "test_params": ["cmax", "cmin", "cavg", "auc_tau", "fluctuation", "swing"]
+    },
+    {
+      "id": "steady_state_iv",
+      "name": "Steady-state IV infusion",
+      "description": "IV infusion at steady state with tau=24h",
+      "route": "iv_infusion",
+      "dose": { "amount": 500, "time": 0, "duration": 2.0 },
+      "tau": 24,
+      "times": [0, 1, 2, 4, 6, 8, 12, 18, 24],
+      "concentrations": [2.0, 12.0, 18.0, 14.0, 10.5, 7.5, 4.0, 1.5, 0.5],
+      "test_params": ["cmax", "cmin", "cavg", "auc_tau", "mrt_iv"]
+    },
+    {
+      "id": "c0_logslope",
+      "name": "C0 back-extrapolation test",
+      "description": "IV bolus with C0 estimated via log-linear back-extrapolation",
+      "route": "iv_bolus",
+      "dose": { "amount": 100, "time": 0 },
+      "times": [0, 0.5, 1, 2, 4, 6, 8],
+      "concentrations": [0, 8.0, 6.5, 4.3, 1.9, 0.8, 0.35],
+      "test_params": ["c0", "auc_last", "auc_inf", "vd", "vss"]
+    },
+    {
+      "id": "span_ratio_test",
+      "name": "Span ratio quality metric",
+      "description": "Test span ratio calculation for lambda-z regression",
+      "route": "extravascular",
+      "dose": { "amount": 100, "time": 0 },
+      "times": [0, 1, 2, 4, 8, 12, 24, 48],
+      "concentrations": [0, 8.0, 12.0, 9.0, 5.0, 2.8, 0.9, 0.1],
+      "test_params": [
+        "lambda_z",
+        "half_life",
+        "span_ratio",
+        "r_squared",
+        "n_points_lambda_z"
+      ]
+    },
+    {
+      "id": "auc_all_terminal_blq",
+      "name": "AUCall with terminal BLQ",
+      "description": "Profile with BLQ values at end to test AUCall vs AUClast",
+      "route": "extravascular",
+      "dose": { "amount": 100, "time": 0 },
+      "times": [0, 1, 2, 4, 6, 8, 10, 12],
+      "concentrations": [0, 5.0, 10.0, 6.0, 3.0, 1.5, 0, 0],
+      "blq_indices": [0, 6, 7],
+      "loq": 0.5,
+      "blq_rule": "exclude",
+      "test_params": ["auc_last", "auc_all", "tlast", "clast"]
+    }
+  ]
+}
diff --git a/tests/test_pf.rs b/tests/test_pf.rs
index 03b77ea3..79e0a336 100644
--- a/tests/test_pf.rs
+++ b/tests/test_pf.rs
@@ -1,4 +1,4 @@
-use pharmsol::data::error_model::ErrorModel;
+use pharmsol::data::error_model::AssayErrorModel;
 use pharmsol::*;
 
 /// Test the particle filter (SDE) likelihood estimation
@@ -33,10 +33,10 @@ fn test_particle_filter_likelihood() {
         10000,
     );
 
-    let ems = ErrorModels::new()
+    let ems = AssayErrorModels::new()
         .add(
             0,
-            ErrorModel::additive(ErrorPoly::new(0.5, 0.0, 0.0, 0.0), 0.0),
+            AssayErrorModel::additive(ErrorPoly::new(0.5, 0.0, 0.0, 0.0), 0.0),
         )
         .unwrap();
 
@@ -46,8 +46,9 @@ fn test_particle_filter_likelihood() {
 
     for i in 0..NUM_RUNS {
         let ll = sde
-            .estimate_likelihood(&subject, &vec![1.0], &ems, false)
-            .unwrap();
+            .estimate_log_likelihood(&subject, &vec![1.0], &ems, false)
+            .unwrap()
+            .exp();
         println!("Run {}: likelihood = {}", i + 1, ll);
         likelihoods.push(ll);
     }