}}
Note that the function
@@ -361,7 +361,7 @@ but will be specific to the \code{out} block.
For example,
-\if{html}{\out{
}}\preformatted{out = function() \{
+\if{html}{\out{
}}\preformatted{out = function() \{
V = V0 * wt # only needed if not included in sec block
y[1] = x[1]/V
#Vp and Vm must be defined in pri or sec blocks
diff --git a/man/PM_result.Rd b/man/PM_result.Rd
index c6a5e7e56..2648cc753 100755
--- a/man/PM_result.Rd
+++ b/man/PM_result.Rd
@@ -14,6 +14,31 @@ After a run completes, results are stored on your hard drive. They are loaded
back into R with \link{PM_load} to create the \link{PM_result} object, which contains both
the results and functions to analyze or plot the result.
}
+\examples{
+
+## ------------------------------------------------
+## Method `PM_result$bestdose`
+## ------------------------------------------------
+
+\dontrun{
+# Load NPAG result
+result <- PM_load(1)
+
+# Create target data
+target <- PM_data$new("target.csv")
+
+# Run BestDose optimization
+bd <- result$bestdose(
+ target = target,
+ dose_range = list(min = 50, max = 500),
+ bias_weight = 0.5
+)
+
+# View results
+print(bd)
+bd$get_doses()
+}
+}
\author{
Michael Neely, Julian Otalvaro
}
@@ -67,6 +92,7 @@ new optimal sampling results.}
\item \href{#method-PM_result-nca}{\code{PM_result$nca()}}
\item \href{#method-PM_result-report}{\code{PM_result$report()}}
\item \href{#method-PM_result-sim}{\code{PM_result$sim()}}
+\item \href{#method-PM_result-bestdose}{\code{PM_result$bestdose()}}
\item \href{#method-PM_result-save}{\code{PM_result$save()}}
\item \href{#method-PM_result-validate}{\code{PM_result$validate()}}
\item \href{#method-PM_result-step}{\code{PM_result$step()}}
@@ -247,6 +273,85 @@ arguments, e.g. \verb{$sim(include = 1:2, predInt = 1, limits = NA)}.}
}
\if{html}{\out{
}}
}
+}
+\if{html}{\out{
}}
+\if{html}{\out{
}}
+\if{latex}{\out{\hypertarget{method-PM_result-bestdose}{}}}
+\subsection{Method \code{bestdose()}}{
+Run BestDose optimization using this result as the prior
+\subsection{Usage}{
+\if{html}{\out{
}}\preformatted{PM_result$bestdose(
+ target,
+ past_data = NULL,
+ dose_range = list(min = 0, max = 1000),
+ bias_weight = 0.5,
+ target_type = "concentration",
+ time_offset = NULL,
+ ...
+)}\if{html}{\out{
}}
+}
+
+\subsection{Arguments}{
+\if{html}{\out{
}}
+\describe{
+\item{\code{target}}{PM_data object or path to CSV with target doses/observations.
+Required. This defines the dosing template and target values. Set dose amounts
+to 0 for doses to be optimized.}
+
+\item{\code{past_data}}{Optional: PM_data object or path to CSV with patient history.
+If NULL (default), uses the full dataset from this result.}
+
+\item{\code{dose_range}}{Named list with min and max allowable doses.
+Default: list(min = 0, max = 1000)}
+
+\item{\code{bias_weight}}{Numeric \link{0,1} controlling personalization level.
+0 = fully personalized, 1 = population-based. Default: 0.5 (balanced)}
+
+\item{\code{target_type}}{One of "concentration" (default), "auc_from_zero", or
+"auc_from_last_dose"}
+
+\item{\code{time_offset}}{Optional: time offset for past/future concatenation}
+
+\item{\code{...}}{Additional arguments passed to \link{PM_bestdose}}
+}
+\if{html}{\out{
}}
+}
+\subsection{Details}{
+BestDose finds optimal dosing regimens to achieve target drug concentrations
+or AUC values. The algorithm uses Bayesian posterior estimation combined with
+dual optimization to balance patient-specific adaptation and population-level
+robustness. By default, uses the \verb{$final}, \verb{$model}, and \verb{$data} objects from
+this result. Most commonly, you will supply a different \code{target} data object.
+}
+
+\subsection{Returns}{
+A \link{PM_bestdose} object containing optimal doses and predictions
+}
+\subsection{Examples}{
+\if{html}{\out{
}}
+\preformatted{\dontrun{
+# Load NPAG result
+result <- PM_load(1)
+
+# Create target data
+target <- PM_data$new("target.csv")
+
+# Run BestDose optimization
+bd <- result$bestdose(
+ target = target,
+ dose_range = list(min = 50, max = 500),
+ bias_weight = 0.5
+)
+
+# View results
+print(bd)
+bd$get_doses()
+}
+}
+\if{html}{\out{
}}
+
+}
+
}
\if{html}{\out{
}}
\if{html}{\out{
}}
diff --git a/man/compile_model.Rd b/man/compile_model.Rd
index bdd7b086f..943cc2811 100755
--- a/man/compile_model.Rd
+++ b/man/compile_model.Rd
@@ -4,7 +4,7 @@
\alias{compile_model}
\title{Compiles the text representation of a model into a binary file.}
\usage{
-compile_model(model_path, output_path, params, kind)
+compile_model(model_path, template_path, output_path, params, kind)
}
\description{
Compiles the text representation of a model into a binary file.
diff --git a/man/dummy_compile.Rd b/man/dummy_compile.Rd
index 6e7b34390..8af0daf60 100755
--- a/man/dummy_compile.Rd
+++ b/man/dummy_compile.Rd
@@ -4,7 +4,7 @@
\alias{dummy_compile}
\title{Dummy function to cache compilation artifacts.}
\usage{
-dummy_compile()
+dummy_compile(template_path)
}
\description{
Dummy function to cache compilation artifacts.
diff --git a/man/interp.Rd b/man/interp.Rd
index 8f9f5b295..6a75496a5 100755
--- a/man/interp.Rd
+++ b/man/interp.Rd
@@ -24,8 +24,8 @@ interpolation between values or not.
}
\examples{
\dontrun{
-cov = c(
- wt = interp() # same as interp("lm") or interp("linear")
+cov <- c(
+ wt = interp(), # same as interp("lm") or interp("linear")
visit = interp("none")
)
}
diff --git a/src/rust/Cargo.toml b/src/rust/Cargo.toml
index 8c556ce9c..d8fe6025a 100755
--- a/src/rust/Cargo.toml
+++ b/src/rust/Cargo.toml
@@ -9,8 +9,8 @@ name = 'pm_rs'
[dependencies]
extendr-api = '*'
-pmcore = {version ="=0.20.0", features = ["exa"]}
-# pmcore = { path = "/Users/jotalvaro/code/LAPKB/PMcore", features = ["exa"] }
+pmcore = { version = "=0.22.1", features = ["exa"] }
+libloading = "0.8"
rayon = "1.10.0"
anyhow = "1.0.97"
diff --git a/src/rust/src/bestdose_executor.rs b/src/rust/src/bestdose_executor.rs
new file mode 100644
index 000000000..2d83731f6
--- /dev/null
+++ b/src/rust/src/bestdose_executor.rs
@@ -0,0 +1,426 @@
+use crate::{logs::RFormatLayer, settings::settings};
+use extendr_api::prelude::*;
+use pmcore::bestdose::{BestDoseProblem, BestDoseResult, DoseRange, Target};
+use pmcore::prelude::{data, ODE};
+use pmcore::routines::initialization::parse_prior;
+use std::path::PathBuf;
+
+/// Helper to parse target type from string
+pub(crate) fn parse_target_type(target_str: &str) -> std::result::Result
{
+ match target_str.to_lowercase().as_str() {
+ "concentration" => Ok(Target::Concentration),
+ "auc_from_zero" | "auc" => Ok(Target::AUCFromZero),
+ "auc_from_last_dose" | "auc_interval" => Ok(Target::AUCFromLastDose),
+ _ => Err(format!(
+ "Invalid target type: {}. Must be 'concentration', 'auc_from_zero', or 'auc_from_last_dose'",
+ target_str
+ )),
+ }
+}
+
+/// R-compatible prediction row for BestDose output
+#[derive(Debug, IntoDataFrameRow)]
+pub struct BestDosePredictionRow {
+ id: String,
+ time: f64,
+ observed: f64,
+ pop_mean: f64,
+ pop_median: f64,
+ post_mean: f64,
+ post_median: f64,
+ outeq: usize,
+}
+
+impl BestDosePredictionRow {
+ pub fn from_np_prediction(
+ pred: &pmcore::routines::output::predictions::NPPredictionRow,
+ id: &str,
+ ) -> Self {
+ Self {
+ id: id.to_string(),
+ time: pred.time(),
+ observed: pred.obs().unwrap_or(0.0),
+ pop_mean: pred.pop_mean(),
+ pop_median: pred.pop_median(),
+ post_mean: pred.post_mean(),
+ post_median: pred.post_median(),
+ outeq: pred.outeq(),
+ }
+ }
+}
+
+/// R-compatible AUC prediction row
+#[derive(Debug, IntoDataFrameRow)]
+pub struct BestDoseAucRow {
+ time: f64,
+ auc: f64,
+}
+
+/// Convert BestDoseResult to R-compatible list structure
+pub(crate) fn convert_bestdose_result_to_r(
+ result: BestDoseResult,
+) -> std::result::Result {
+ // Extract doses
+ let doses: Vec = result.doses();
+
+ // Objective function
+ let objf = result.objf();
+
+ // Status
+ let status_str = format!("{:?}", result.status());
+
+ // Predictions as data frame
+ let pred_rows: Vec = result
+ .predictions()
+ .predictions()
+ .iter()
+ .map(|p| BestDosePredictionRow::from_np_prediction(p, "subject_1"))
+ .collect();
+ let pred_df = pred_rows
+ .into_dataframe()
+ .map_err(|e| format!("Failed to create predictions dataframe: {:?}", e))?;
+
+ // AUC predictions (if available)
+ let auc_val = if let Some(auc_preds) = result.auc_predictions() {
+ let auc_rows: Vec = auc_preds
+ .iter()
+ .map(|(time, auc)| BestDoseAucRow {
+ time: *time,
+ auc: *auc,
+ })
+ .collect();
+ let auc_df = auc_rows
+ .into_dataframe()
+ .map_err(|e| format!("Failed to create AUC dataframe: {:?}", e))?;
+ Robj::from(auc_df)
+ } else {
+ Robj::from(()) // NULL for no AUC
+ };
+
+ // Optimization method
+ let method_str = format!("{}", result.optimization_method());
+
+ // Build the list using list! macro
+ let output = list!(
+ doses = doses,
+ objf = objf,
+ status = status_str,
+ predictions = pred_df,
+ auc_predictions = auc_val,
+ method = method_str
+ );
+
+ Ok(output.into())
+}
+/// Opaque handle that keeps the dynamic model library alive while reusing the
+/// prepared `BestDoseProblem` for multiple optimization runs.
+pub struct BestDoseProblemHandle {
+ problem: BestDoseProblem,
+ #[allow(dead_code)]
+ library: libloading::Library,
+}
+
+impl BestDoseProblemHandle {
+ #[allow(clippy::too_many_arguments)]
+ pub fn new(
+ model_path: PathBuf,
+ prior_path: PathBuf,
+ past_data_path: Option,
+ target_data_path: PathBuf,
+ time_offset: Option,
+ dose_min: f64,
+ dose_max: f64,
+ bias_weight: f64,
+ target_type: &str,
+ params: List,
+ ) -> std::result::Result {
+ let (library, (eq, meta)) =
+ unsafe { pmcore::prelude::pharmsol::exa::load::load::(model_path) };
+
+ let settings = settings(params, meta.get_params(), "/tmp/bestdose")
+ .map_err(|e| format!("Failed to parse settings: {}", e))?;
+
+ let (population_theta, prior_weights) =
+ parse_prior(&prior_path.to_str().unwrap().to_string(), &settings)
+ .map_err(|e| format!("Failed to parse prior: {}", e))?;
+
+ let population_weights = prior_weights
+ .ok_or_else(|| "Prior file must contain a 'prob' column with weights".to_string())?;
+
+ let past_data = if let Some(path) = past_data_path {
+ let data = data::read_pmetrics(path.to_str().unwrap())
+ .map_err(|e| format!("Failed to read past data: {}", e))?;
+ let subjects = data.subjects();
+ if subjects.is_empty() {
+ return Err("Past data file contains no subjects".to_string());
+ }
+ Some(subjects[0].clone())
+ } else {
+ None
+ };
+
+ let target_data = {
+ let data = data::read_pmetrics(target_data_path.to_str().unwrap())
+ .map_err(|e| format!("Failed to read target data: {}", e))?;
+ let subjects = data.subjects();
+ if subjects.is_empty() {
+ return Err("Target data file contains no subjects".to_string());
+ }
+ subjects[0].clone()
+ };
+
+ let target_enum = parse_target_type(target_type)?;
+ let doserange = DoseRange::new(dose_min, dose_max);
+
+ let problem = BestDoseProblem::new(
+ &population_theta,
+ &population_weights,
+ past_data,
+ target_data,
+ time_offset,
+ eq,
+ doserange,
+ bias_weight,
+ settings,
+ target_enum,
+ )
+ .map_err(|e| format!("Failed to create BestDose problem: {}", e))?;
+
+ Ok(Self { problem, library })
+ }
+
+ pub fn optimize(
+ &self,
+ bias_weight: Option,
+ ) -> std::result::Result {
+ let configured_problem = match bias_weight {
+ Some(weight) => self.problem.clone().with_bias_weight(weight),
+ None => self.problem.clone(),
+ };
+
+ configured_problem
+ .optimize()
+ .map_err(|e| format!("Optimization failed: {}", e))
+ }
+
+ pub fn problem(&self) -> &BestDoseProblem {
+ &self.problem
+ }
+}
+
+pub(crate) fn bestdose_ode(
+ model_path: PathBuf,
+ prior_path: PathBuf,
+ past_data_path: Option,
+ target_data_path: PathBuf,
+ time_offset: Option,
+ dose_min: f64,
+ dose_max: f64,
+ bias_weight: f64,
+ target_type: &str,
+ params: List,
+) -> std::result::Result {
+ let handle = BestDoseProblemHandle::new(
+ model_path,
+ prior_path,
+ past_data_path,
+ target_data_path,
+ time_offset,
+ dose_min,
+ dose_max,
+ bias_weight,
+ target_type,
+ params,
+ )?;
+
+ handle.optimize(None)
+}
+
+/// Execute bestdose optimization for analytical models (placeholder - not yet supported)
+pub(crate) fn bestdose_analytical(
+ _model_path: PathBuf,
+ _prior_path: PathBuf,
+ _past_data_path: Option,
+ _target_data_path: PathBuf,
+ _time_offset: Option,
+ _dose_min: f64,
+ _dose_max: f64,
+ _bias_weight: f64,
+ _target_type: &str,
+ _params: List,
+) -> std::result::Result {
+ Err("BestDose for analytical models is not yet supported".to_string())
+}
+
+pub(crate) struct PosteriorSummary {
+ theta_values: Vec,
+ theta_dim: (i32, i32),
+ param_names: Vec,
+ posterior_weights: Vec,
+ population_weights: Vec,
+ bias_weight: f64,
+ target_type: Target,
+}
+
+fn summarize_problem(problem: &BestDoseProblem) -> PosteriorSummary {
+ let theta = problem.posterior_theta();
+ let matrix = theta.matrix();
+ let nrows = matrix.nrows() as i32;
+ let ncols = matrix.ncols() as i32;
+ let mut theta_values = vec![0.0; (nrows * ncols) as usize];
+
+ for col in 0..ncols as usize {
+ for row in 0..nrows as usize {
+ theta_values[row + col * nrows as usize] = *matrix.get(row, col);
+ }
+ }
+
+ PosteriorSummary {
+ theta_values,
+ theta_dim: (nrows, ncols),
+ param_names: theta.param_names(),
+ posterior_weights: problem.posterior_weights().to_vec(),
+ population_weights: problem.population_weights().to_vec(),
+ bias_weight: problem.bias_weight(),
+ target_type: problem.target_type(),
+ }
+}
+
+fn vec_to_doubles(values: Vec, label: &str) -> std::result::Result {
+ Doubles::try_from(values)
+ .map_err(|e| format!("Failed to convert {} to doubles: {:?}", label, e))
+}
+
+fn dims_to_integers(dim: (i32, i32)) -> std::result::Result {
+ Integers::try_from(vec![dim.0, dim.1])
+ .map_err(|e| format!("Failed to convert dims to integers: {:?}", e))
+}
+
+fn names_to_strings(names: &[String]) -> Strings {
+ Strings::from_values(names.iter().map(|s| s.as_str()))
+}
+
+pub(crate) fn prepare_bestdose_problem(
+ model_path: PathBuf,
+ prior_path: PathBuf,
+ past_data_path: Option,
+ target_data_path: PathBuf,
+ time_offset: Option,
+ dose_min: f64,
+ dose_max: f64,
+ bias_weight: f64,
+ target_type: &str,
+ params: List,
+) -> std::result::Result<(BestDoseProblemHandle, PosteriorSummary), String> {
+ let handle = BestDoseProblemHandle::new(
+ model_path,
+ prior_path,
+ past_data_path,
+ target_data_path,
+ time_offset,
+ dose_min,
+ dose_max,
+ bias_weight,
+ target_type,
+ params,
+ )?;
+
+ let summary = summarize_problem(handle.problem());
+ Ok((handle, summary))
+}
+
+pub(crate) fn bestdose_prepare_internal(
+ model_path: &str,
+ prior_path: &str,
+ past_data_path: Nullable,
+ target_data_path: &str,
+ time_offset: Nullable,
+ dose_min: f64,
+ dose_max: f64,
+ bias_weight: f64,
+ target_type: &str,
+ params: List,
+ kind: &str,
+) -> Robj {
+ RFormatLayer::reset_global_timer();
+ let _ = crate::setup_logs();
+
+ let past_path = past_data_path.into_option().map(PathBuf::from);
+ let time_offset = time_offset.into_option();
+
+ let preparation = match kind {
+ "ode" => prepare_bestdose_problem(
+ PathBuf::from(model_path),
+ PathBuf::from(prior_path),
+ past_path,
+ PathBuf::from(target_data_path),
+ time_offset,
+ dose_min,
+ dose_max,
+ bias_weight,
+ target_type,
+ params.clone(),
+ ),
+ "analytical" => Err("BestDose for analytical models is not yet supported".to_string()),
+ other => Err(format!("{} is not a supported model type", other)),
+ };
+
+ match preparation {
+ Ok((handle, summary)) => {
+ let theta_values = match vec_to_doubles(summary.theta_values, "theta_values") {
+ Ok(values) => values,
+ Err(e) => return Robj::from(e),
+ };
+ let theta_dim = match dims_to_integers(summary.theta_dim) {
+ Ok(dim) => dim,
+ Err(e) => return Robj::from(e),
+ };
+ let posterior_weights =
+ match vec_to_doubles(summary.posterior_weights, "posterior_weights") {
+ Ok(values) => values,
+ Err(e) => return Robj::from(e),
+ };
+ let population_weights =
+ match vec_to_doubles(summary.population_weights, "population_weights") {
+ Ok(values) => values,
+ Err(e) => return Robj::from(e),
+ };
+ let param_names = names_to_strings(&summary.param_names);
+ let handle_ptr = ExternalPtr::new(handle);
+
+ let output = list!(
+ handle = handle_ptr,
+ theta_values = theta_values,
+ theta_dim = theta_dim,
+ param_names = param_names,
+ posterior_weights = posterior_weights,
+ population_weights = population_weights,
+ bias_weight = summary.bias_weight,
+ target_type = format!("{:?}", summary.target_type),
+ nspp = summary.theta_dim.0,
+ n_parameters = summary.theta_dim.1
+ );
+
+ output.into()
+ }
+ Err(e) => Robj::from(format!("BestDose prepare failed: {}", e)),
+ }
+}
+
+pub(crate) fn bestdose_optimize_internal(
+ handle: ExternalPtr,
+ bias_weight: Nullable,
+) -> Robj {
+ let weight = bias_weight.into_option();
+
+ match handle.try_addr() {
+ Ok(inner) => match inner.optimize(weight) {
+ Ok(result) => match convert_bestdose_result_to_r(result) {
+ Ok(robj) => robj,
+ Err(e) => Robj::from(format!("Failed to convert result: {}", e)),
+ },
+ Err(e) => Robj::from(format!("BestDose optimization failed: {}", e)),
+ },
+ Err(e) => Robj::from(format!("Invalid BestDose handle: {}", e)),
+ }
+}
diff --git a/src/rust/src/executor.rs b/src/rust/src/executor.rs
index 69818461c..8cf5461f0 100755
--- a/src/rust/src/executor.rs
+++ b/src/rust/src/executor.rs
@@ -31,7 +31,7 @@ pub(crate) fn simulate(
))
}
-pub(crate) fn fit(
+pub(crate) fn fit(
model_path: PathBuf,
data: PathBuf,
params: List,
@@ -42,7 +42,7 @@ pub(crate) fn fit(
let data = data::read_pmetrics(data.to_str().unwrap()).expect("Failed to read data");
//dbg!(&data);
let mut algorithm = dispatch_algorithm(settings, eq, data)?;
- let result = algorithm.fit()?;
+ let mut result = algorithm.fit()?;
result.write_outputs()?;
Ok(())
}
diff --git a/src/rust/src/lib.rs b/src/rust/src/lib.rs
index 69d6e947a..ffa43b6fc 100755
--- a/src/rust/src/lib.rs
+++ b/src/rust/src/lib.rs
@@ -1,4 +1,5 @@
// mod build;
+mod bestdose_executor;
mod executor;
mod logs;
mod settings;
@@ -8,9 +9,11 @@ use anyhow::Result;
use extendr_api::prelude::*;
use pmcore::prelude::{data::read_pmetrics, pharmsol::exa::build, Analytical, ODE};
use simulation::SimulationRow;
+use std::path::PathBuf;
use std::process::Command;
use tracing_subscriber::layer::SubscriberExt;
+use crate::bestdose_executor::BestDoseProblemHandle;
use crate::logs::RFormatLayer;
fn validate_paths(data_path: &str, model_path: &str) {
@@ -164,7 +167,13 @@ fn parse_theta(matrix: RMatrix) -> Vec> {
/// Compiles the text representation of a model into a binary file.
///@export
#[extendr]
-fn compile_model(model_path: &str, output_path: &str, params: Strings, kind: &str) -> Result<()> {
+fn compile_model(
+ model_path: &str,
+ template_path: &str,
+ output_path: &str,
+ params: Strings,
+ kind: &str,
+) -> Result<()> {
let params: Vec = params.iter().map(|x| x.to_string()).collect();
let model_txt = std::fs::read_to_string(model_path).expect("Failed to read model file");
match kind {
@@ -172,6 +181,7 @@ fn compile_model(model_path: &str, output_path: &str, params: Strings, kind: &st
model_txt,
Some(output_path.into()),
params.to_vec(),
+ template_path.into(),
|_key, val| {
print!("{}", val);
},
@@ -180,6 +190,7 @@ fn compile_model(model_path: &str, output_path: &str, params: Strings, kind: &st
model_txt,
Some(output_path.into()),
params.to_vec(),
+ template_path.into(),
|_key, val| {
print!("{}", val);
},
@@ -193,8 +204,8 @@ fn compile_model(model_path: &str, output_path: &str, params: Strings, kind: &st
/// Dummy function to cache compilation artifacts.
///@export
#[extendr]
-fn dummy_compile() -> Result {
- let build_path = build::dummy_compile(|_key, val| {
+fn dummy_compile(template_path: &str) -> Result {
+ let build_path = build::dummy_compile(template_path.into(), |_key, val| {
print!("{}", val);
})?;
Ok(build_path)
@@ -218,18 +229,6 @@ fn model_parameters(model_path: &str, kind: &str) -> Result> {
}
}
-//@export
-#[extendr]
-fn template_path() -> String {
- build::template_path()
-}
-
-//@export
-#[extendr]
-fn clear_build() {
- build::clear_build();
-}
-
/// Initialize the tracing subscriber with the custom R formatter
/// @keywords internal
///@export
@@ -251,6 +250,110 @@ fn setup_logs() -> anyhow::Result<()> {
Ok(())
}
+/// Run BestDose optimization to find optimal doses
+///@export
+#[extendr]
+fn bestdose(
+ model_path: &str,
+ prior_path: &str,
+ past_data_path: Nullable,
+ target_data_path: &str,
+ time_offset: Nullable,
+ dose_min: f64,
+ dose_max: f64,
+ bias_weight: f64,
+ target_type: &str,
+ params: List,
+ kind: &str,
+) -> Robj {
+ RFormatLayer::reset_global_timer();
+ let _ = setup_logs();
+
+ println!("Starting BestDose optimization...");
+
+ let past_path = match past_data_path.into_option() {
+ Some(p) => Some(PathBuf::from(p)),
+ None => None,
+ };
+
+ let time_offset_opt = time_offset.into_option();
+
+ let result = match kind {
+ "ode" => bestdose_executor::bestdose_ode(
+ model_path.into(),
+ prior_path.into(),
+ past_path,
+ target_data_path.into(),
+ time_offset_opt,
+ dose_min,
+ dose_max,
+ bias_weight,
+ target_type,
+ params.clone(),
+ ),
+ "analytical" => bestdose_executor::bestdose_analytical(
+ model_path.into(),
+ prior_path.into(),
+ past_path,
+ target_data_path.into(),
+ time_offset_opt,
+ dose_min,
+ dose_max,
+ bias_weight,
+ target_type,
+ params.clone(),
+ ),
+ _ => {
+ return Robj::from(format!("{} is not a supported model type", kind));
+ }
+ };
+
+ match result {
+ Ok(bd_result) => match bestdose_executor::convert_bestdose_result_to_r(bd_result) {
+ Ok(r) => r,
+ Err(e) => Robj::from(format!("Failed to convert result: {}", e)),
+ },
+ Err(e) => Robj::from(format!("BestDose failed: {}", e)),
+ }
+}
+
+#[extendr]
+fn bestdose_prepare(
+ model_path: &str,
+ prior_path: &str,
+ past_data_path: Nullable,
+ target_data_path: &str,
+ time_offset: Nullable,
+ dose_min: f64,
+ dose_max: f64,
+ bias_weight: f64,
+ target_type: &str,
+ params: List,
+ kind: &str,
+) -> Robj {
+ bestdose_executor::bestdose_prepare_internal(
+ model_path,
+ prior_path,
+ past_data_path,
+ target_data_path,
+ time_offset,
+ dose_min,
+ dose_max,
+ bias_weight,
+ target_type,
+ params,
+ kind,
+ )
+}
+
+#[extendr]
+fn bestdose_optimize(
+ handle: ExternalPtr,
+ bias_weight: Nullable,
+) -> Robj {
+ bestdose_executor::bestdose_optimize_internal(handle, bias_weight)
+}
+
// Macro to generate exports.
// This ensures exported functions are registered with R.
// See corresponding C code in `entrypoint.c`.
@@ -263,9 +366,10 @@ extendr_module! {
fn is_cargo_installed;
fn fit;
fn model_parameters;
- fn template_path;
- fn clear_build;
fn setup_logs;
+ fn bestdose;
+ fn bestdose_prepare;
+ fn bestdose_optimize;
}
// To generate the exported function in R, run the following command: