Trait rug::rand::RandGen

pub trait RandGen: Send + Sync {
    fn gen(&mut self) -> u32;

    fn seed(&mut self, _seed: &Integer) { ... }
}

Custom random number generator to be used with RandState.

Examples

use rug::Integer;
use rug::rand::RandGen;
struct SimpleGenerator {
    seed: u64,
}
impl RandGen for SimpleGenerator {
    fn gen(&mut self) -> u32 {
        self.seed =
            self.seed.wrapping_mul(6364136223846793005).wrapping_add(1);
        (self.seed >> 32) as u32
    }
    fn seed(&mut self, seed: &Integer) {
        self.seed = seed.to_u64_wrapping();
    }
}
let mut rand = SimpleGenerator { seed: 1 };
assert_eq!(rand.gen(), 1481765933);
assert_eq!(rand.seed, 6364136223846793006);

Required Methods

fn gen(&mut self) -> u32

Gets a random 32-bit unsigned integer.

Examples

use rug::rand::RandGen;
struct SimpleGenerator {
    seed: u64,
}
impl RandGen for SimpleGenerator {
    fn gen(&mut self) -> u32 {
        self.seed =
            self.seed.wrapping_mul(6364136223846793005).wrapping_add(1);
        (self.seed >> 32) as u32
    }
}
let mut rand = SimpleGenerator { seed: 1 };
let first = rand.gen();
assert_eq!(rand.seed, 6364136223846793006);
assert_eq!(first, 1481765933);
let second = rand.gen();
assert_eq!(rand.seed, 13885033948157127959);
assert_eq!(second, 3232861391);

Provided Methods

fn seed(&mut self, _seed: &Integer)

Seeds the random number generator.

The default implementation of this function does nothing.

Note that the RandState::seed() method will pass its seed parameter exactly to this function without using it otherwise.

Examples

use rug::{Assign, Integer};
use rug::rand::{RandGen, RandState};
struct Seed { inner: Integer };
impl RandGen for Seed {
    fn gen(&mut self) -> u32 { self.inner.to_u32_wrapping() }
    fn seed(&mut self, seed: &Integer) {
        self.inner.assign(seed);
    }
}
let mut seed = Seed { inner: Integer::from(12) };
let i = Integer::from(12345);
{
    let mut rand = RandState::new_custom(&mut seed);
    rand.seed(&i);
}
assert_eq!(seed.inner, i);

If you use unsafe code, you can pass a reference to anything, or even an isize or usize, to the seeding function.

use rug::Integer;
use rug::rand::{RandGen, RandState};
struct Seed { num: isize };
impl RandGen for Seed {
    fn gen(&mut self) -> u32 { 0x8cef7310 }
    fn seed(&mut self, seed: &Integer) {
        // cast seed to pointer, then to isize
        self.num = seed as *const _ as isize;
    }
}
let mut seed = Seed { num: 15 };
let i = -12345_isize;
{
    let i_ptr = i as *const Integer;
    // unsafe code to cast i from isize to &Integer
    let ir = unsafe { &*i_ptr };
    let mut rand = RandState::new_custom(&mut seed);
    rand.seed(ir);
}
assert_eq!(seed.num, i);

Implementors