Struct BestDoseResult 

pub struct BestDoseResult { /* private fields */ }

Result from BestDose optimization

Contains the optimal doses and associated predictions from running BestDoseProblem::optimize().

Fields

• dose: Optimal dose amount(s) in the same order as doses in target subject
• objf: Final cost function value at optimal doses
• status: Optimization status message (e.g., “converged”, “max iterations”)
• preds: Concentration-time predictions using optimal doses
• auc_predictions: AUC values at observation times (only for [Target::AUC])
• optimization_method: Which method won: "posterior" or "uniform"

Interpretation

Optimization Method

• “posterior”: Patient-specific optimization won (uses posterior weights)

  • Indicates patient differs from population or has sufficient history
  • Doses are highly personalized

• “uniform”: Population-based optimization won (uses uniform weights)

  • Indicates patient is population-typical or has limited history
  • Doses are more conservative/robust

Cost Function (objf)

Lower is better. The cost combines variance and bias:

Cost = (1-λ) × Variance + λ × Bias²

Examples

Extracting Results

let result = problem.optimize()?;

// Single dose
println!("Optimal dose: {} mg", result.dose[0]);

// Multiple doses
for (i, &dose) in result.dose.iter().enumerate() {
    println!("Dose {}: {} mg", i + 1, dose);
}

// Check which method was used
match result.optimization_method.as_str() {
    "posterior" => println!("Patient-specific optimization"),
    "uniform" => println!("Population-based optimization"),
    _ => {}
}

// Access predictions
for pred in result.preds.iter() {
    println!("t={:.1}h: {:.2} mg/L", pred.time(), pred.prediction());
}

// For AUC targets
if let Some(auc_values) = result.auc_predictions {
    for (time, auc) in auc_values {
        println!("AUC at t={:.1}h: {:.1} mg·h/L", time, auc);
    }
}

Implementations

impl BestDoseResult

pub fn optimal_subject(&self) -> &Subject

Get the optimized subject

pub fn doses(&self) -> Vec<f64>

Get the dose amounts of the optimized subject

This includes all doses (bolus and infusion) in the order they appear in the optimal subject, and returns their amounts as a vector of f64.

pub fn objf(&self) -> f64

Get the objective cost function value

pub fn status(&self) -> &BestDoseStatus

Get the optimization status

pub fn predictions(&self) -> &NPPredictions

Get the concentration-time predictions

pub fn auc_predictions(&self) -> Option<Vec<(f64, f64)>>

Get the AUC predictions, if available

pub fn optimization_method(&self) -> OptimalMethod

Get the optimization method used

Trait Implementations

impl Clone for BestDoseResult

fn clone(&self) -> BestDoseResult

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for BestDoseResult

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for BestDoseResult

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Serialize for BestDoseResult

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.