Struct BestDosePosterior 

pub struct BestDosePosterior { /* private fields */ }

The computed Bayesian posterior for a patient

This is the main public entry point for the two-stage BestDose API:

1. Stage 1: Posterior computation (BestDosePosterior::compute())

   • NPAGFULL11: Bayesian filtering of prior support points
   • NPAGFULL: Local refinement of each filtered point

2. Stage 2: Dose optimization (BestDosePosterior::optimize())

   • Dual optimization (posterior vs uniform weights)
   • Final predictions with optimal doses

The posterior can be reused across multiple optimize() calls with different targets, dose ranges, or bias weights.

Example

use pmcore::bestdose::{BestDosePosterior, Target, DoseRange};

// Stage 1: Compute posterior (expensive, done once)
let posterior = BestDosePosterior::compute(
    &population_theta,
    &population_weights,
    Some(past),
    eq,
    settings,
)?;

// Stage 2: Optimize doses (can be called multiple times)
let result = posterior.optimize(
    target,
    None,                            // No time offset
    DoseRange::new(0.0, 1000.0),
    0.5,                             // bias_weight
    Target::Concentration,
)?;

Implementations

impl BestDosePosterior

pub fn theta(&self) -> &Theta

Get the refined posterior support points (Θ)

pub fn posterior_weights(&self) -> &Weights

Get the posterior probability weights

pub fn population_weights(&self) -> &Weights

Get the filtered population weights used for the bias term

pub fn n_support_points(&self) -> usize

Get the number of support points in the posterior

impl BestDosePosterior

pub fn compute( population_theta: &Theta, population_weights: &Weights, past_data: Option<Subject>, eq: ODE, settings: Settings, ) -> Result<Self>

Stage 1: Compute the Bayesian posterior density from population prior and patient data

This performs the expensive posterior calculation (NPAGFULL11 filtering + NPAGFULL refinement) and returns a reusable BestDosePosterior that can be optimized multiple times.

Algorithm

Prior (N support points)
    ↓
NPAGFULL11: Bayesian filtering
    P(θᵢ|data) ∝ P(data|θᵢ) × P(θᵢ)
    ↓
Filtered posterior (M points)
    ↓
NPAGFULL: Local refinement (max_cycles iterations)
    ↓
Refined posterior (M points with updated weights)

Arguments

• population_theta - Population support points from NPAG
• population_weights - Population probabilities
• past_data - Patient history (None = use prior directly)
• eq - Pharmacokinetic/pharmacodynamic model
• settings - NPAG settings (includes error models and posterior refinement config)

Example

let posterior = BestDosePosterior::compute(
    &theta, &weights,
    Some(past_subject),
    eq, settings,
)?;
println!("Posterior has {} support points", posterior.n_support_points());

pub fn optimize( &self, target: Subject, time_offset: Option<f64>, dose_range: DoseRange, bias_weight: f64, target_type: Target, ) -> Result<BestDoseResult>

Stage 2: Optimize doses for target outcomes using the computed posterior

This runs the dual optimization (posterior weights vs uniform weights) and returns the best dosing regimen. Can be called multiple times on the same posterior with different parameters.

Arguments

• target - Future dosing template with target observations
• time_offset - Optional gap (in hours) between the last past event and the start of the future target. 0 means the future starts immediately after the last past event. The effective absolute offset is max_past_time + time_offset.
• dose_range - Allowable dose constraints
• bias_weight - λ in [0,1]: 0=personalized, 1=population
• target_type - Concentration or AUC targets

Example

// Try different bias weights
for &bw in &[0.0, 0.25, 0.5, 0.75, 1.0] {
    let result = posterior.optimize(
        target.clone(),
        None,
        DoseRange::new(0.0, 300.0),
        bw,
        Target::Concentration,
    )?;
    println!("λ={}: dose={:.1}", bw, result.doses()[0]);
}

Trait Implementations

impl Clone for BestDosePosterior

fn clone(&self) -> BestDosePosterior

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for BestDosePosterior

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

Formats the value using the given formatter.