Struct Occasion 

pub struct Occasion { /* private fields */ }

An occasion within a subject’s dataset

An Occasion represents a distinct period of data collection for a subject, such as a hospital visit or dosing regimen. It contains events (doses, observations) and time-varying covariates.

Implementations

impl Occasion

pub fn events(&self) -> &[Event]

Get a vector of references to all events in this occasion

Returns

A slice of all events in this occasion

pub fn index(&self) -> usize

Get the index of the occasion

Returns

The occasion index (0-based)

pub fn add_covariate(&mut self, name: String, covariate: Covariate)

Add a covariate to this occasion

Arguments

• name - Name of the covariate
• covariate - The covariate to add

pub fn covariates(&self) -> &Covariates

Get a reference to the covariates for this occasion

Returns

Reference to the occasion’s covariates, if any

pub fn covariates_mut(&mut self) -> &mut Covariates

Get a mutable refernce to the covariates for this occasion

Returns

Reference to the occasion’s covariates, if any

pub fn add_observation( &mut self, time: f64, value: f64, outeq: usize, errorpoly: Option<ErrorPoly>, censored: Censor, )

Add an Observation event to the Occasion

pub fn add_missing_observation(&mut self, time: f64, outeq: usize)

Add a missing Observation event to the Occasion

pub fn add_observation_with_error( &mut self, time: f64, value: f64, outeq: usize, errorpoly: ErrorPoly, censored: Censor, )

Add a missing Observation with a custom ErrorPoly to the Occasion

This is useful if you want a different weight for the observation

pub fn add_bolus(&mut self, time: f64, amount: f64, input: usize)

Add a Bolus event to the Occasion

pub fn add_infusion( &mut self, time: f64, amount: f64, input: usize, duration: f64, )

Add an Infusion event to the Occasion

pub fn events_mut(&mut self) -> &mut Vec<Event>

Get a mutable reference to the events

pub fn events_iter_mut(&mut self) -> IterMut<'_, Event>

Get a mutable iterator to the events

pub fn iter(&self) -> Iter<'_, Event>

Get an iterator over all events

Returns

An iterator yielding references to events

pub fn iter_mut(&mut self) -> IterMut<'_, Event>

Get a mutable iterator over all events

Returns

A mutable iterator yielding references to events

pub fn len(&self) -> usize

Get the number of events in this occasion

Returns

The number of events

pub fn is_empty(&self) -> bool

Check if the occasion has any events

Returns

true if there are no events, false otherwise

impl Occasion

pub fn nca_with_dose( &self, dose_amount: f64, route: Route, infusion_duration: Option<f64>, options: &NCAOptions, ) -> Result<NCAResult, NCAError>

Run NCA with an explicit dose, overriding what is embedded in the occasion.

Use this when you want to supply or override dose amount, route, or infusion duration without modifying the underlying data.

Trait Implementations

impl Clone for Occasion

fn clone(&self) -> Occasion

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Occasion

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Occasion

fn deserialize<__D>( __deserializer: __D, ) -> Result<Occasion, <__D as Deserializer<'de>>::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Display for Occasion

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

Formats the value using the given formatter.

impl<'a> IntoIterator for &'a Occasion

fn into_iter(self) -> <&'a Occasion as IntoIterator>::IntoIter

Iterate immutably over all events in the occasion

type Item = &'a Event

The type of the elements being iterated over.

type IntoIter = Iter<'a, Event>

Which kind of iterator are we turning this into?

impl<'a> IntoIterator for &'a mut Occasion

fn into_iter(self) -> <&'a mut Occasion as IntoIterator>::IntoIter

Iterate mutably over all events in the occasion

type Item = &'a mut Event

The type of the elements being iterated over.

type IntoIter = IterMut<'a, Event>

Which kind of iterator are we turning this into?

impl IntoIterator for Occasion

fn into_iter(self) -> <Occasion as IntoIterator>::IntoIter

Consumes the occasion and yields owned events

type Item = Event

The type of the elements being iterated over.

type IntoIter = IntoIter<Event>

Which kind of iterator are we turning this into?

impl NCA for Occasion

fn nca(&self, options: &NCAOptions) -> Result<NCAResult, NCAError>

NCA on the first occasion (the common case). Returns a single result.

fn nca_all(&self, options: &NCAOptions) -> Vec<Result<NCAResult, NCAError>>

NCA on all occasions. Returns a Vec of results.

impl ObservationMetrics for Occasion

fn auc_blq( &self, outeq: usize, method: &AUCMethod, blq_rule: &BLQRule, ) -> Vec<Result<f64, MetricsError>>

Calculate AUC from time 0 to Tlast with explicit BLQ handling

fn auc_interval_blq( &self, outeq: usize, start: f64, end: f64, method: &AUCMethod, blq_rule: &BLQRule, ) -> Vec<Result<f64, MetricsError>>

Calculate partial AUC over a time interval with explicit BLQ handling

fn cmax_blq( &self, outeq: usize, blq_rule: &BLQRule, ) -> Vec<Result<f64, MetricsError>>

Get Cmax with explicit BLQ handling

fn tmax_blq( &self, outeq: usize, blq_rule: &BLQRule, ) -> Vec<Result<f64, MetricsError>>

Get Tmax with explicit BLQ handling

fn clast_blq( &self, outeq: usize, blq_rule: &BLQRule, ) -> Vec<Result<f64, MetricsError>>

Get Clast with explicit BLQ handling

fn tlast_blq( &self, outeq: usize, blq_rule: &BLQRule, ) -> Vec<Result<f64, MetricsError>>

Get Tlast with explicit BLQ handling

fn aumc_blq( &self, outeq: usize, method: &AUCMethod, blq_rule: &BLQRule, ) -> Vec<Result<f64, MetricsError>>

Calculate AUMC with explicit BLQ handling

fn auc( &self, outeq: usize, method: &AUCMethod, ) -> Vec<Result<f64, MetricsError>>

Calculate AUC from time 0 to Tlast

fn auc_interval( &self, outeq: usize, start: f64, end: f64, method: &AUCMethod, ) -> Vec<Result<f64, MetricsError>>

Calculate partial AUC over a time interval

fn cmax(&self, outeq: usize) -> Vec<Result<f64, MetricsError>>

Get Cmax

fn tmax(&self, outeq: usize) -> Vec<Result<f64, MetricsError>>

Get Tmax

fn clast(&self, outeq: usize) -> Vec<Result<f64, MetricsError>>

Get Clast

fn tlast(&self, outeq: usize) -> Vec<Result<f64, MetricsError>>

Get Tlast

fn aumc( &self, outeq: usize, method: &AUCMethod, ) -> Vec<Result<f64, MetricsError>>

Calculate AUMC

fn auc_first( &self, outeq: usize, method: &AUCMethod, ) -> Result<f64, MetricsError>

Calculate AUC for the first occasion

fn cmax_first(&self, outeq: usize) -> Result<f64, MetricsError>

Get Cmax for the first occasion

fn tmax_first(&self, outeq: usize) -> Result<f64, MetricsError>

Get Tmax for the first occasion

fn clast_first(&self, outeq: usize) -> Result<f64, MetricsError>

Get Clast for the first occasion

fn tlast_first(&self, outeq: usize) -> Result<f64, MetricsError>

Get Tlast for the first occasion

fn aumc_first( &self, outeq: usize, method: &AUCMethod, ) -> Result<f64, MetricsError>

Calculate AUMC for the first occasion

fn auc_interval_first( &self, outeq: usize, start: f64, end: f64, method: &AUCMethod, ) -> Result<f64, MetricsError>

Calculate partial AUC for the first occasion

fn auc_blq_first( &self, outeq: usize, method: &AUCMethod, blq_rule: &BLQRule, ) -> Result<f64, MetricsError>

Calculate AUC for the first occasion with explicit BLQ handling

fn cmax_blq_first( &self, outeq: usize, blq_rule: &BLQRule, ) -> Result<f64, MetricsError>

Get Cmax for the first occasion with explicit BLQ handling

fn auc_interval_blq_first( &self, outeq: usize, start: f64, end: f64, method: &AUCMethod, blq_rule: &BLQRule, ) -> Result<f64, MetricsError>

Calculate partial AUC for the first occasion with explicit BLQ handling

impl Serialize for Occasion

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl Superposition for Occasion

fn superposition( &self, tau: f64, options: &NCAOptions, n_eval_points: Option<usize>, ) -> Result<SuperpositionResult, NCAError>

Predict steady-state profile via superposition

fn superposition_from_nca( &self, nca_result: &NCAResult, tau: f64, n_eval_points: Option<usize>, ) -> Result<SuperpositionResult, NCAError>

Predict steady-state profile using a pre-computed [NCAResult]