Enum sim::input_modeling::random_variable::Continuous

pub enum Continuous {
    Beta {
        alpha: f64,
        beta: f64,
    },
    Exp {
        lambda: f64,
    },
    Gamma {
        shape: f64,
        scale: f64,
    },
    LogNormal {
        mu: f64,
        sigma: f64,
    },
    Normal {
        mean: f64,
        std_dev: f64,
    },
    Triangular {
        min: f64,
        max: f64,
        mode: f64,
    },
    Uniform {
        min: f64,
        max: f64,
    },
    Weibull {
        shape: f64,
        scale: f64,
    },
}

Variants

Beta

Fields of Beta

alpha: f64beta: f64

Exp

Fields of Exp

lambda: f64

Gamma

Fields of Gamma

shape: f64scale: f64

LogNormal

Fields of LogNormal

mu: f64sigma: f64

Normal

Fields of Normal

mean: f64std_dev: f64

Triangular

Fields of Triangular

min: f64max: f64mode: f64

Uniform

Fields of Uniform

min: f64max: f64

Weibull

Fields of Weibull

shape: f64scale: f64

Implementations

impl Continuous

pub fn random_variate(
    &mut self,
    uniform_rng: &mut UniformRNG
) -> Result<f64, SimulationError>

The generation of random variates drives stochastic behaviors during simulation execution. This function requires the random number generator of the simulation, and produces a f64 random variate.

Trait Implementations

impl Clone for Continuous

fn clone(&self) -> Continuous

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Continuous

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Continuous

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

Deserialize this value from the given Serde deserializer.

impl Serialize for Continuous

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

Serialize this value into the given Serde serializer.