Struct nyx_space::mc::Generator

pub struct Generator<S: State, Distr: Distribution<f64> + Copy>where
    DefaultAllocator: Allocator<f64, S::Size> + Allocator<f64, S::Size, S::Size> + Allocator<usize, S::Size, S::Size> + Allocator<f64, S::VecLength>,{
    pub template: S,
    pub dispersions: Vec<Dispersion<Distr>>,
}

A state generator for Monte Carlo analyses.

Fields

template: S

The template state

dispersions: Vec<Dispersion<Distr>>

The list of dispersions to be added to the template state Note that we can’t use a HashMap here because StateParameter has a SlantAngle option comprised of f64s, and those neither have Hash nor Eq

Implementations

impl<S: State, D: Distribution<f64> + Copy> Generator<S, D>where DefaultAllocator: Allocator<f64, S::Size> + Allocator<f64, S::Size, S::Size> + Allocator<usize, S::Size, S::Size> + Allocator<f64, S::VecLength>,

pub fn add_dispersion( &mut self, dispersion: Dispersion<D> ) -> Result<(), NyxError>

Add a parameter dispersion to this Monte Carlo state generator.

pub fn from_dispersions( template: S, dispersions: &[Dispersion<D>] ) -> Result<Self, NyxError>

Create a new Monte Carlo state generator given a template state, the parameters to disperse, and their respective dispersion probability density functions.

pub fn from_dispersion( template: S, dispersion: Dispersion<D> ) -> Result<Self, NyxError>

Create a new Monte Carlo state generator given a template state, the parameters to disperse, and their respective dispersion probability density functions.

impl<S: State> Generator<S, Normal<f64>>where DefaultAllocator: Allocator<f64, S::Size> + Allocator<f64, S::Size, S::Size> + Allocator<usize, S::Size, S::Size> + Allocator<f64, S::VecLength>,

pub fn add_3std_dev( &mut self, param: StateParameter, three_sigma: f64 ) -> Result<(), NyxError>

Add a state dispersion from the provided 3-sigma value, zero mean

pub fn add_std_dev( &mut self, param: StateParameter, std_dev: f64 ) -> Result<(), NyxError>

Add a state dispersion from the provided 1-sigma value, zero mean

pub fn from_3std_devs( template: S, three_sigmas: &[(StateParameter, f64)] ) -> Result<Self, NyxError>

Create a new Monte Carlo state generator given a template state, the parameters to disperse, and their respective 3-σ standard deviations, zero mean.

pub fn from_3std_dev( template: S, param: StateParameter, three_sigma: f64 ) -> Result<Self, NyxError>

Create a new Monte Carlo state generator given a template state, the parameter to disperse, and its 3-σ standard deviation, zero mean.

pub fn from_3std_dev_prct( template: S, param: StateParameter, prct: f64 ) -> Result<Self, NyxError>

Create a new Monte Carlo state generator given a template state, the parameter to disperse, and its 3-σ standard deviation in percentage of the template’s value, zero mean.

pub fn from_3std_dev_prcts( template: S, prcts: &[(StateParameter, f64)] ) -> Result<Self, NyxError>

Create a new Monte Carlo state generator given a template state, the parameter to disperse, and its 3-σ standard deviation in percentage of the template’s value, zero mean.

pub fn from_std_devs( template: S, std_devs: &[(StateParameter, f64)] ) -> Result<Self, NyxError>

Create a new Monte Carlo state generator given a template state, the parameters to disperse, and their respective 1-σ standard deviations, zero mean.

pub fn from_std_dev_prcts( template: S, prcts: &[(StateParameter, f64)] ) -> Result<Self, NyxError>

Create a new Monte Carlo state generator given a template state, the parameter to disperse, and its 1-σ standard deviation in percentage of the template’s value, zero mean.

pub fn from_std_dev( template: S, param: StateParameter, std_dev: f64 ) -> Result<Self, NyxError>

Create a new Monte Carlo state generator given a template state, the parameter to disperse, and its 1-σ standard deviation, zero mean.

pub fn from_std_dev_prct( template: S, param: StateParameter, prct: f64 ) -> Result<Self, NyxError>

Create a new Monte Carlo state generator given a template state, the parameter to disperse, and its 1-σ standard deviation in percentage of the template’s value, zero mean.

Trait Implementations

impl<S: State, D: Distribution<f64> + Copy> Distribution<DispersedState<S>> for Generator<S, D>where DefaultAllocator: Allocator<f64, S::Size> + Allocator<f64, S::Size, S::Size> + Allocator<usize, S::Size, S::Size> + Allocator<f64, S::VecLength>,

fn sample<R: Rng + ?Sized>(&self, rng: &mut R) -> DispersedState<S>

Generate a random value of T, using rng as the source of randomness.

fn sample_iter<R>(self, rng: R) -> DistIter<Self, R, T>where R: Rng, Self: Sized,

Create an iterator that generates random values of T, using rng as the source of randomness.

fn map<F, S>(self, func: F) -> DistMap<Self, F, T, S>where F: Fn(T) -> S, Self: Sized,

Create a distribution of values of ‘S’ by mapping the output of Self through the closure F

impl<S: State, D: Distribution<f64> + Copy> From<S> for Generator<S, D>where DefaultAllocator: Allocator<f64, S::Size> + Allocator<f64, S::Size, S::Size> + Allocator<usize, S::Size, S::Size> + Allocator<f64, S::VecLength>,

fn from(template: S) -> Self

Converts to this type from the input type.