Struct Data 

pub struct Data { /* private fields */ }

The main data container for pharmacokinetic/pharmacodynamic data

Data is a collection of Subject instances, which themselves contain Occasion instances with Events. This structure represents the complete dataset for pharmacometric analysis.

Examples

use pharmsol::*;

// Create subjects
let subject1 = Subject::builder("patient_001")
    .bolus(0.0, 100.0, 0)
    .observation(1.0, 5.0, 0)
    .build();
     
let subject2 = Subject::builder("patient_002")
    .bolus(0.0, 120.0, 0)
    .observation(1.0, 6.0, 0)
    .build();
     
// Create dataset with multiple subjects
let mut data = Data::new(vec![subject1]);
data.add_subject(subject2);

// Filter data
let filtered = data.filter_include(&["patient_001".to_string()]);

Implementations

impl Data

pub fn write_pmetrics(&self, file: &File) -> Result<(), PharmsolError>

Write the dataset to a file in Pmetrics format

Arguments

• file - The file to write to

impl Data

pub fn new(subjects: Vec<Subject>) -> Data

Constructs a new Data object from a vector of Subjects

It is recommended to construct subjects using the crate::data::builder::SubjectBuilder to ensure proper data formatting.

Arguments

• subjects - Vector of Subjects to include in the dataset

pub fn subjects(&self) -> Vec<&Subject>

Get a vector of references to all subjects in the dataset

Returns

Vector of references to all subjects

pub fn add_subject(&mut self, subject: Subject)

Add a subject to the dataset

Arguments

• subject - Subject to add to the dataset

pub fn get_subject(&self, id: &str) -> Option<&Subject>

Get a specific subject by ID

Arguments

• id - The ID of the subject to retrieve

Returns

An Option containing a reference to the subject if found, or None if not found

pub fn get_subject_mut(&mut self, id: &str) -> Option<&mut Subject>

Get a mutable reference to a specific subject by ID

Arguments

• id - The ID of the subject to retrieve

Returns

An Option containing a reference to the subject if found, or None if not found

pub fn filter_include(&self, include: &[String]) -> Data

Filter the dataset to include only subjects with specific IDs

Arguments

• include - Vector of subject IDs to include

Returns

A new Data object containing only the specified subjects

pub fn filter_exclude(&self, exclude: Vec<String>) -> Data

Filter the dataset to exclude subjects with specific IDs

Arguments

• exclude - Vector of subject IDs to exclude

Returns

A new Data object with the specified subjects excluded

pub fn expand(&self, idelta: f64, tad: f64) -> Data

Expand the dataset by adding observations at regular time intervals

This is useful for creating a dense grid of time points for simulations. Observations are only added if they don’t already exist at that time/outeq combination.

Arguments

• idelta - Time interval between added observations
• tad - Additional time to add after the last observation

Returns

A new Data object with expanded observations

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

Get an iterator over all subjects

Returns

An iterator yielding references to subjects

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

Get a mutable iterator over all subjects

Returns

A mutable iterator yielding references to subjects

pub fn len(&self) -> usize

Get the number of subjects in the dataset

Returns

The number of subjects

pub fn is_empty(&self) -> bool

Check if the dataset is empty

Returns

true if there are no subjects, false otherwise

pub fn get_output_equations(&self) -> Vec<usize>

Get a vector of all unique output equations (outeq) across all subjects

Trait Implementations

impl Clone for Data

fn clone(&self) -> Data

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Data

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

Formats the value using the given formatter.

impl Default for Data

fn default() -> Data

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for Data

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Display for Data

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

Formats the value using the given formatter.

impl Into<Data> for Subject

fn into(self) -> Data

Convert a subject into a Data object

impl Into<Data> for Vec<Subject>

fn into(self) -> Data

Convert a vector of subjects into a Data object

impl<'a> IntoIterator for &'a Data

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

Iterate immutably over all subjects in the dataset

type Item = &'a Subject

The type of the elements being iterated over.

type IntoIter = Iter<'a, Subject>

Which kind of iterator are we turning this into?

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

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

Iterate mutably over all subjects in the dataset

type Item = &'a mut Subject

The type of the elements being iterated over.

type IntoIter = IterMut<'a, Subject>

Which kind of iterator are we turning this into?

impl IntoIterator for Data

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

Consumes the data and yields owned subjects

type Item = Subject

The type of the elements being iterated over.

type IntoIter = IntoIter<Subject>

Which kind of iterator are we turning this into?

impl NCA for Data

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 NCAPopulation for Data

fn nca_grouped(&self, options: &NCAOptions) -> Vec<SubjectNCAResult>

Perform NCA and return results grouped by subject

impl ObservationMetrics for Data

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 Data

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.