Struct `Bernoulli`

struct Bernoulli { ... }

The Bernoulli distribution Bernoulli(p).

This distribution describes a single boolean random variable, which is true with probability p and false with probability 1 - p. It is a special case of the Binomial distribution with n = 1.

Plot

The following plot shows the Bernoulli distribution with p = 0.1, p = 0.5, and p = 0.9.

Bernoulli distribution

Example

use rand::distr::{Bernoulli, Distribution};

let d = Bernoulli::new(0.3).unwrap();
let v = d.sample(&mut rand::rng());
println!("{} is from a Bernoulli distribution", v);

Precision

This Bernoulli distribution uses 64 bits from the RNG (a u64), so only probabilities that are multiples of 2^-64 can be represented.

Implementations

`impl Bernoulli`

fn new(p: f64) -> Result<Bernoulli, BernoulliError>

Construct a new Bernoulli with the given probability of success p.

Precision

For p = 1.0, the resulting distribution will always generate true. For p = 0.0, the resulting distribution will always generate false.

This method is accurate for any input p in the range [0, 1] which is a multiple of 2^-64. (Note that not all multiples of 2^-64 in [0, 1] can be represented as a f64.)

fn from_ratio(numerator: u32, denominator: u32) -> Result<Bernoulli, BernoulliError>

Construct a new Bernoulli with the probability of success of numerator-in-denominator. I.e. new_ratio(2, 3) will return a Bernoulli with a 2-in-3 chance, or about 67%, of returning true.

return true. If numerator == 0 it will always return false. For numerator > denominator and denominator == 0, this returns an error. Otherwise, for numerator == denominator, samples are always true; for numerator == 0 samples are always false.

fn p(self: &Self) -> f64

Returns the probability (p) of the distribution.

This value may differ slightly from the input due to loss of precision.

`impl Clone for Bernoulli`

fn clone(self: &Self) -> Bernoulli

`impl Copy for Bernoulli`

`impl Debug for Bernoulli`

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

`impl Distribution for Bernoulli`

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

`impl Freeze for Bernoulli`

`impl PartialEq for Bernoulli`

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

`impl RefUnwindSafe for Bernoulli`

`impl Send for Bernoulli`

`impl Serialize for Bernoulli`

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

`impl StructuralPartialEq for Bernoulli`

`impl Sync for Bernoulli`

`impl Unpin for Bernoulli`

`impl UnsafeUnpin for Bernoulli`

`impl UnwindSafe for Bernoulli`

`impl<'de> Deserialize for Bernoulli`

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

`impl<T> Any for Bernoulli`

fn type_id(self: &Self) -> TypeId

`impl<T> Borrow for Bernoulli`

fn borrow(self: &Self) -> &T

`impl<T> BorrowMut for Bernoulli`

fn borrow_mut(self: &mut Self) -> &mut T

`impl<T> CloneToUninit for Bernoulli`

unsafe fn clone_to_uninit(self: &Self, dest: *mut u8)

`impl<T> DeserializeOwned for Bernoulli`

`impl<T> From for Bernoulli`

fn from(t: T) -> T: Returns the argument unchanged.

`impl<T> ToOwned for Bernoulli`

fn to_owned(self: &Self) -> T
fn clone_into(self: &Self, target: &mut T)

`impl<T, U> Into for Bernoulli`

fn into(self: Self) -> U

Calls U::from(self).

That is, this conversion is whatever the implementation of [From]<T> for U chooses to do.

`impl<T, U> TryFrom for Bernoulli`

fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

`impl<T, U> TryInto for Bernoulli`

fn try_into(self: Self) -> Result<U, <U as TryFrom<T>>::Error>

`impl<V, T> VZip for Bernoulli`

fn vzip(self: Self) -> V