Struct Gaussian 

pub struct Gaussian<T: FloatingPoint> {
    pub std: T,
    pub mean: T,
}

A distribution type representing random sampling of floating point numbers, following a gaussian distribution.

Fields

std: T

The standard deviation of the distribution.

mean: T

The mean of the distribution.

Implementations

impl Gaussian<f64>

pub const fn from_standard_dev(std: StandardDev, mean: f64) -> Self

pub fn from_dispersion_parameter( dispersion: impl DispersionParameter, mean: f64, ) -> Self

pub const fn standard_dev(&self) -> StandardDev

Trait Implementations

impl<T: Clone + FloatingPoint> Clone for Gaussian<T>

fn clone(&self) -> Gaussian<T>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T: Debug + FloatingPoint> Debug for Gaussian<T>

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

Formats the value using the given formatter.

impl<'de, T> Deserialize<'de> for Gaussian<T>

where T: Deserialize<'de> + FloatingPoint,

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<T: PartialEq + FloatingPoint> PartialEq for Gaussian<T>

fn eq(&self, other: &Gaussian<T>) -> 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 RandomGenerable<Gaussian<f32>> for (f32, f32)

type CustomModulus = f32

fn generate_one<G: ByteRandomGenerator>( generator: &mut RandomGenerator<G>, _: Gaussian<f32>, ) -> Self

Generate a value from distribution.

fn single_sample_success_probability( _distribution: Gaussian<f32>, _modulus: Option<Self::CustomModulus>, ) -> f64

Return the probability to successfully generate a sample from the given distribution for the type the trait is implemented on.

fn single_sample_required_random_byte_count( _distribution: Gaussian<f32>, _modulus: Option<Self::CustomModulus>, ) -> usize

Return how many bytes coming from a CSPRNG are required to generate one sample even if that generation can fail.

fn generate_one_custom_modulus<G: ByteRandomGenerator>( generator: &mut RandomGenerator<G>, distribution: D, custom_modulus: Self::CustomModulus, ) -> Self

Generate a value from distribution modulo the given custom_modulus.

fn fill_slice<G: ByteRandomGenerator>( generator: &mut RandomGenerator<G>, distribution: D, slice: &mut [Self], )

fn fill_slice_custom_mod<G: ByteRandomGenerator>( generator: &mut RandomGenerator<G>, distribution: D, slice: &mut [Self], custom_modulus: Self::CustomModulus, )

impl<Torus> RandomGenerable<Gaussian<f64>> for (Torus, Torus)

where Torus: FromTorus<f64>,

type CustomModulus = Torus

fn generate_one<G: ByteRandomGenerator>( generator: &mut RandomGenerator<G>, distribution: Gaussian<f64>, ) -> Self

Generate a value from distribution.

fn generate_one_custom_modulus<G: ByteRandomGenerator>( generator: &mut RandomGenerator<G>, distribution: Gaussian<f64>, custom_modulus: Self::CustomModulus, ) -> Self

Generate a value from distribution modulo the given custom_modulus.

fn single_sample_success_probability( distribution: Gaussian<f64>, _modulus: Option<Self::CustomModulus>, ) -> f64

Return the probability to successfully generate a sample from the given distribution for the type the trait is implemented on.

fn single_sample_required_random_byte_count( distribution: Gaussian<f64>, _modulus: Option<Self::CustomModulus>, ) -> usize

Return how many bytes coming from a CSPRNG are required to generate one sample even if that generation can fail.

fn fill_slice<G: ByteRandomGenerator>( generator: &mut RandomGenerator<G>, distribution: D, slice: &mut [Self], )

fn fill_slice_custom_mod<G: ByteRandomGenerator>( generator: &mut RandomGenerator<G>, distribution: D, slice: &mut [Self], custom_modulus: Self::CustomModulus, )

impl RandomGenerable<Gaussian<f64>> for (f64, f64)

type CustomModulus = f64

fn generate_one<G: ByteRandomGenerator>( generator: &mut RandomGenerator<G>, _: Gaussian<f64>, ) -> Self

Generate a value from distribution.

fn single_sample_success_probability( _distribution: Gaussian<f64>, _modulus: Option<Self::CustomModulus>, ) -> f64

Return the probability to successfully generate a sample from the given distribution for the type the trait is implemented on.

fn single_sample_required_random_byte_count( _distribution: Gaussian<f64>, _modulus: Option<Self::CustomModulus>, ) -> usize

Return how many bytes coming from a CSPRNG are required to generate one sample even if that generation can fail.

fn generate_one_custom_modulus<G: ByteRandomGenerator>( generator: &mut RandomGenerator<G>, distribution: D, custom_modulus: Self::CustomModulus, ) -> Self

Generate a value from distribution modulo the given custom_modulus.

fn fill_slice<G: ByteRandomGenerator>( generator: &mut RandomGenerator<G>, distribution: D, slice: &mut [Self], )

fn fill_slice_custom_mod<G: ByteRandomGenerator>( generator: &mut RandomGenerator<G>, distribution: D, slice: &mut [Self], custom_modulus: Self::CustomModulus, )

impl<Torus> RandomGenerable<Gaussian<f64>> for Torus

where Torus: FromTorus<f64>,

type CustomModulus = Torus

fn generate_one<G: ByteRandomGenerator>( generator: &mut RandomGenerator<G>, distribution: Gaussian<f64>, ) -> Self

Generate a value from distribution.

fn generate_one_custom_modulus<G: ByteRandomGenerator>( generator: &mut RandomGenerator<G>, distribution: Gaussian<f64>, custom_modulus: Self::CustomModulus, ) -> Self

Generate a value from distribution modulo the given custom_modulus.

fn single_sample_success_probability( distribution: Gaussian<f64>, _modulus: Option<Self::CustomModulus>, ) -> f64

Return the probability to successfully generate a sample from the given distribution for the type the trait is implemented on.

fn single_sample_required_random_byte_count( distribution: Gaussian<f64>, _modulus: Option<Self::CustomModulus>, ) -> usize

Return how many bytes coming from a CSPRNG are required to generate one sample even if that generation can fail.

fn fill_slice<G: ByteRandomGenerator>( generator: &mut RandomGenerator<G>, distribution: D, slice: &mut [Self], )

fn fill_slice_custom_mod<G: ByteRandomGenerator>( generator: &mut RandomGenerator<G>, distribution: D, slice: &mut [Self], custom_modulus: Self::CustomModulus, )

impl<T> Serialize for Gaussian<T>

where T: Serialize + FloatingPoint,

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl<T: FloatingPoint> Unversionize for Gaussian<T>

where GaussianVersions<T>: VersionsDispatch<Self>,

fn unversionize( versioned: Self::VersionedOwned, ) -> Result<Self, UnversionizeError>

Creates an object from a versioned enum, and eventually upgrades from previous variants.

impl<T: FloatingPoint> UnversionizeVec for Gaussian<T>

where GaussianVersions<T>: VersionsDispatch<Self>,

fn unversionize_vec( versioned: Self::VersionedVec, ) -> Result<Vec<Self>, UnversionizeError>

impl<T> Version for Gaussian<T>

where T: VersionizeOwned + Unversionize + Versionize + FloatingPoint,

type Ref<'vers> = GaussianVersion<'vers, T> where T: 'vers

type Owned = GaussianVersionOwned<T>

impl<T: FloatingPoint> Versionize for Gaussian<T>

where GaussianVersions<T>: VersionsDispatch<Self>,

type Versioned<'vers> = <GaussianVersions<T> as VersionsDispatch<Gaussian<T>>>::Ref<'vers> where T: 'vers

The equivalent versioned type. It should have a variant for each version. It may own the underlying data or only hold a read-only reference to it.

fn versionize(&self) -> Self::Versioned<'_>

Wraps the object into a versioned enum with a variant for each version. This will use references on the underlying types if possible.

impl<T: FloatingPoint> VersionizeOwned for Gaussian<T>

where GaussianVersions<T>: VersionsDispatch<Self>,

type VersionedOwned = <GaussianVersions<T> as VersionsDispatch<Gaussian<T>>>::Owned

fn versionize_owned(self) -> Self::VersionedOwned

Wraps the object into a versioned enum with a variant for each version. This will clone the underlying types.

impl<T: FloatingPoint> VersionizeSlice for Gaussian<T>

where GaussianVersions<T>: VersionsDispatch<Self>,

type VersionedSlice<'vers> = Vec<<Gaussian<T> as Versionize>::Versioned<'vers>> where T: 'vers

fn versionize_slice(slice: &[Self]) -> Self::VersionedSlice<'_>

impl<T: FloatingPoint> VersionizeVec for Gaussian<T>

where GaussianVersions<T>: VersionsDispatch<Self>,

type VersionedVec = Vec<<Gaussian<T> as VersionizeOwned>::VersionedOwned>

fn versionize_vec(vec: Vec<Self>) -> Self::VersionedVec

impl<T: FloatingPoint> VersionsDispatch<Gaussian<T>> for GaussianVersions<T>

where Gaussian<T>: Version,

type Ref<'vers> = GaussianVersionsDispatch<'vers, T> where T: 'vers

type Owned = GaussianVersionsDispatchOwned<T>

impl<T: Copy + FloatingPoint> Copy for Gaussian<T>

impl<T: FloatingPoint> Distribution for Gaussian<T>

impl<T: FloatingPoint> StructuralPartialEq for Gaussian<T>