#[repr(transparent)]
pub struct RandState<'a> { /* fields omitted */ }
The state of a random number generator.
use rug::rand::RandState;
let mut rand = RandState::new();
let u = rand.bits(32);
println!("32 random bits: {:032b}", u);
Creates a new random generator with a compromise between speed
and randomness.
use rug::rand::RandState;
let mut rand = RandState::new();
let u = rand.bits(32);
println!("32 random bits: {:032b}", u);
Creates a random generator with a Mersenne Twister algorithm.
use rug::rand::RandState;
let mut rand = RandState::new_mersenne_twister();
let u = rand.bits(32);
println!("32 random bits: {:032b}", u);
Creates a new random generator with a linear congruential
algorithm X = (a × X + c) mod 2bits.
use rug::rand::RandState;
use rug::Integer;
let a = match Integer::from_str_radix("292787ebd3329ad7e7575e2fd", 16) {
Ok(i) => i,
Err(_) => unreachable!(),
};
let c = 1;
let bits = 100;
let mut rand = RandState::new_linear_congruential(&a, c, bits);
let u = rand.bits(32);
println!("32 random bits: {:032b}", u);
Creates a new random generator with a linear congruential
algorithm like the new_linear_congruential
method.
For the linear congrentail algorithm X = (a × X + c)
mod 2bits, a, c and bits are selected from
a table such that at least size bits of each X will be
used, that is bits ≥ size. The table only has values for a
size of up to 256 bits; None
will be returned if the
requested size is larger.
use rug::rand::RandState;
let mut rand = match RandState::new_linear_congruential_size(100) {
Some(r) => r,
None => unreachable!(),
};
let u = rand.bits(32);
println!("32 random bits: {:032b}", u);
Creates a new custom random generator.
If the custom random generator is cloned, the implemented
trait method RandGen::boxed_clone
is called; this leads to
panic if the method returns None
.
use rug::rand::{RandGen, RandState};
use rug::Integer;
struct Seed;
impl RandGen for Seed {
fn gen(&mut self) -> u32 {
0x8cef7310
}
}
let mut seed = Seed;
let mut rand = RandState::new_custom(&mut seed);
let mut i = Integer::from(15);
i.random_below_mut(&mut rand);
println!("0 ≤ {} < 15", i);
assert!(i < 15);
Creates a new custom random generator.
If the custom random generator is cloned, the implemented
trait method RandGen::boxed_clone
is called;
this leads to panic if the method returns None
.
use rug::rand::{RandGen, RandState};
use rug::Integer;
struct Seed;
impl RandGen for Seed {
fn gen(&mut self) -> u32 {
0x8cef7310
}
}
let seed = Box::new(Seed);
let mut rand = RandState::new_custom_boxed(seed);
let mut i = Integer::from(15);
i.random_below_mut(&mut rand);
println!("0 ≤ {} < 15", i);
assert!(i < 15);
Creates a random generator from an initialized
GMP random generator.
- The value must be initialized. Note that the GMP functions
do not initialize all fields of the
gmp_mpfr_sys::gmp::randstate_t
object,
which can eventually lead to reading uninitialized memory,
and that is undefined behaviour in Rust even if no
decision is made using the read value. One way to ensure
that there is no uninitialized memory inside raw
is to
use mem::zeroed
to initialize raw
before
initializing with a function such as
gmp_mpfr_sys::gmp::randinit_default
,
like in the example below.
- The
gmp_mpfr_sys::gmp::randstate_t
type
can be considered as a kind of pointer, so there can be
multiple copies of it. Since this function takes over
ownership, no other copies of the passed value should
exist.
use gmp_mpfr_sys::gmp;
use rug::rand::RandState;
use std::mem;
let mut rand = unsafe {
let mut raw = mem::zeroed();
gmp::randinit_default(&mut raw);
RandState::from_raw(raw)
};
let u = rand.bits(32);
println!("32 random bits: {:032b}", u);
Converts a random generator into a
GMP random generator.
The returned object should be freed to avoid memory leaks.
use gmp_mpfr_sys::gmp;
use rug::rand::RandState;
let rand = RandState::new();
let mut raw = rand.into_raw();
unsafe {
let u = gmp::urandomb_ui(&mut raw, 32) as u32;
println!("32 random bits: {:032b}", u);
gmp::randclear(&mut raw);
}
Returns a pointer to the inner
GMP random generator.
The returned pointer will be valid for as long as self
is
valid.
use rug::rand::RandState;
let mut rand = RandState::new();
let raw_ptr = rand.as_raw();
println!("pointer: {:p}", raw_ptr);
let u = rand.bits(32);
println!("32 random bits: {:032b}", u);
Returns an unsafe mutable pointer to the inner
GMP random generator.
The returned pointer will be valid for as long as self
is
valid.
use gmp_mpfr_sys::gmp;
use rug::rand::RandState;
let mut rand = RandState::new();
let raw_ptr = rand.as_raw_mut();
unsafe {
let u1 = gmp::urandomb_ui(raw_ptr, 32) as u32;
println!("32 random bits: {:032b}", u1);
}
let u2 = rand.bits(32);
println!("another 32 random bits: {:032b}", u2);
Seeds the random generator.
use rug::rand::RandState;
use rug::Integer;
let seed = Integer::from(123456);
let mut rand = RandState::new();
rand.seed(&seed);
let u1a = rand.bits(32);
let u1b = rand.bits(32);
rand.seed(&seed);
let u2a = rand.bits(32);
let u2b = rand.bits(32);
assert_eq!(u1a, u2a);
assert_eq!(u1b, u2b);
Generates a random number with the specified number of bits.
Panics if bits
is greater than 32.
use rug::rand::RandState;
let mut rand = RandState::new();
let u = rand.bits(16);
assert!(u < (1 << 16));
println!("16 random bits: {:016b}", u);
Generates a random number below the given boundary value.
This function can never return the maximum 32-bit value; in
order to generate a 32-bit random value that covers the whole
range, use the bits
method with bits
set to 32.
Panics if the boundary value is zero.
use rug::rand::RandState;
let mut rand = RandState::new();
let u = rand.below(10000);
assert!(u < 10000);
println!("0 ≤ {} < 10000", u);
Executes the destructor for this type. Read more
Returns the "default value" for a type. Read more
Performs copy-assignment from source
. Read more
Creates owned data from borrowed data, usually by cloning. Read more
🔬 This is a nightly-only experimental API. (toowned_clone_into
)
recently added
Uses borrowed data to replace owned data, usually by cloning. Read more
🔬 This is a nightly-only experimental API. (try_from
)
The type returned in the event of a conversion error.
🔬 This is a nightly-only experimental API. (try_from
)
Immutably borrows from an owned value. Read more
Mutably borrows from an owned value. Read more
🔬 This is a nightly-only experimental API. (try_from
)
The type returned in the event of a conversion error.
🔬 This is a nightly-only experimental API. (try_from
)
🔬 This is a nightly-only experimental API. (get_type_id
)
this method will likely be replaced by an associated static