Enum AssayErrorModel 

pub enum AssayErrorModel {
    Additive {
        lambda: Factor,
        poly: ErrorPoly,
    },
    Proportional {
        gamma: Factor,
        poly: ErrorPoly,
    },
    None,
}

Model for calculating observation errors in pharmacometric analyses

An AssayErrorModel defines how the standard deviation of observations is calculated based on the type of error model used and its parameters.

Variants

Additive

Additive error model, where error is independent of concentration

Contains:

• lambda - Lambda parameter for scaling errors (can be fixed or variable)
• poly - Error polynomial coefficients (c0, c1, c2, c3)

Fields

lambda: Factor

Lambda parameter for scaling errors (can be fixed or variable)

poly: ErrorPoly

Error polynomial coefficients (c0, c1, c2, c3)

Proportional

Proportional error model, where error scales with concentration

Contains:

• gamma - Gamma parameter for scaling errors (can be fixed or variable)
• poly - Error polynomial coefficients (c0, c1, c2, c3)

Fields

gamma: Factor

Gamma parameter for scaling errors (can be fixed or variable)

poly: ErrorPoly

Error polynomial coefficients (c0, c1, c2, c3)

None

Implementations

impl AssayErrorModel

pub fn additive(poly: ErrorPoly, lambda: f64) -> AssayErrorModel

Create a new additive error model with a variable lambda parameter

Arguments

• poly - Error polynomial coefficients (c0, c1, c2, c3)
• lambda - Lambda parameter for scaling errors (will be variable)

Returns

A new additive error model

pub fn additive_fixed(poly: ErrorPoly, lambda: f64) -> AssayErrorModel

Create a new additive error model with a fixed lambda parameter

Arguments

• poly - Error polynomial coefficients (c0, c1, c2, c3)
• lambda - Lambda parameter for scaling errors (will be fixed)

Returns

A new additive error model with fixed lambda

pub fn additive_with_param(poly: ErrorPoly, lambda: Factor) -> AssayErrorModel

Create a new additive error model with a specified Factor for lambda

Arguments

• poly - Error polynomial coefficients (c0, c1, c2, c3)
• lambda - Lambda parameter (can be Variable or Fixed) using Factor

Returns

A new additive error model

pub fn proportional(poly: ErrorPoly, gamma: f64) -> AssayErrorModel

Create a new proportional error model with a variable gamma parameter

Arguments

• poly - Error polynomial coefficients (c0, c1, c2, c3)
• gamma - Gamma parameter for scaling errors (will be variable)

Returns

A new proportional error model

pub fn proportional_fixed(poly: ErrorPoly, gamma: f64) -> AssayErrorModel

Create a new proportional error model with a fixed gamma parameter

Arguments

• poly - Error polynomial coefficients (c0, c1, c2, c3)
• gamma - Gamma parameter for scaling errors (will be fixed)

Returns

A new proportional error model with fixed gamma

pub fn proportional_with_param( poly: ErrorPoly, gamma: Factor, ) -> AssayErrorModel

Create a new proportional error model with a specified Factor for gamma

Arguments

• poly - Error polynomial coefficients (c0, c1, c2, c3)
• gamma - Gamma parameter (can be Variable or Fixed) using Factor

Returns

A new proportional error model

pub fn errorpoly(&self) -> Result<ErrorPoly, ErrorModelError>

Get the error polynomial coefficients

Returns

The error polynomial coefficients (c0, c1, c2, c3)

pub fn set_errorpoly(&mut self, poly: ErrorPoly)

Set the error polynomial coefficients

Arguments

• poly - New error polynomial coefficients (c0, c1, c2, c3)

Returns

The updated error model with the new polynomial coefficients

pub fn factor(&self) -> Result<f64, ErrorModelError>

Get the scaling parameter value

pub fn set_factor(&mut self, factor: f64)

Set the scaling parameter value (preserves fixed/variable state)

pub fn factor_param(&self) -> Result<Factor, ErrorModelError>

Get the scaling parameter (including its fixed/variable state)

pub fn set_factor_param(&mut self, param: Factor)

Set the scaling parameter (including its fixed/variable state)

pub fn is_factor_fixed(&self) -> Result<bool, ErrorModelError>

Check if the scaling parameter is fixed

pub fn fix_factor(&mut self)

Make the scaling parameter fixed at its current value

pub fn unfix_factor(&mut self)

Make the scaling parameter variable at its current value

pub fn is_proportional(&self) -> bool

Check if this is a proportional error model

Returns

true if this is a Proportional variant, false otherwise

pub fn is_additive(&self) -> bool

Check if this is an additive error model

Returns

true if this is an Additive variant, false otherwise

pub fn sigma(&self, prediction: &Prediction) -> Result<f64, ErrorModelError>

Estimate the standard deviation for a prediction

Calculates the standard deviation based on the error model type, using either observation-specific error polynomial coefficients or the model’s default coefficients.

Arguments

• prediction - The prediction for which to estimate the standard deviation

Returns

The estimated standard deviation of the prediction

pub fn variance(&self, prediction: &Prediction) -> Result<f64, ErrorModelError>

Estimate the variance of the observation

This is a convenience function which calls AssayErrorModel::sigma, and squares the result.

pub fn sigma_from_value(&self, value: f64) -> Result<f64, ErrorModelError>

Estimate the standard deviation for a raw observation value

Calculates the standard deviation based on the error model type, using the model’s default coefficients and a provided observation value.

Arguments

• value - The observation value for which to estimate the standard deviation

Returns

The estimated standard deviation for the given value

pub fn variance_from_value(&self, value: f64) -> Result<f64, ErrorModelError>

Estimate the variance for a raw observation value

This is a convenience function which calls AssayErrorModel::sigma_from_value, and squares the result.

pub fn optimize(&self) -> bool

Get a boolean indicating if the error model should be optimized

In other words, if the error model is not None, and the Factor is variable, it should be optimized.

Trait Implementations

impl Clone for AssayErrorModel

fn clone(&self) -> AssayErrorModel

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for AssayErrorModel

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

Formats the value using the given formatter.

impl Default for AssayErrorModel

fn default() -> AssayErrorModel

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for AssayErrorModel

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for AssayErrorModel

fn eq(&self, other: &AssayErrorModel) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Serialize for AssayErrorModel

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 StructuralPartialEq for AssayErrorModel