Struct Random 

pub struct Random { /* private fields */ }

Random number generator subsystem.

Provides access to the hardware Quantum Random Number Generator (QRNG) for generating cryptographically secure random data.

Example

use quantacore::{initialize, open_first_device};

initialize().unwrap();
let device = open_first_device().unwrap();
let random = device.random();

// Generate random bytes
let bytes = random.bytes(32).unwrap();
println!("Random: {}", hex::encode(&bytes));

// Generate random integer
let value = random.next_u64().unwrap();

// Generate random float in [0, 1)
let f = random.next_f64().unwrap();

// Check entropy status
let status = random.get_entropy_status().unwrap();
println!("Entropy level: {}%", status.level);

Implementations

impl Random

pub fn get_entropy_status(&self) -> Result<EntropyStatus>

Get the current entropy status.

pub fn bytes(&self, length: usize) -> Result<Vec<u8>>

Generate random bytes.

Arguments

• length - Number of bytes to generate

Returns

A vector of random bytes.

pub fn fill(&self, buffer: &mut [u8]) -> Result<()>

Fill a buffer with random bytes.

Arguments

• buffer - The buffer to fill

pub fn next_u8(&self) -> Result<u8>

Generate a random u8.

pub fn next_u16(&self) -> Result<u16>

Generate a random u16.

pub fn next_u32(&self) -> Result<u32>

Generate a random u32.

pub fn next_u64(&self) -> Result<u64>

Generate a random u64.

pub fn next_i32(&self) -> Result<i32>

Generate a random i32.

pub fn next_i64(&self) -> Result<i64>

Generate a random i64.

pub fn next_u32_bound(&self, bound: u32) -> Result<u32>

Generate a random u32 in range [0, bound).

Uses rejection sampling to ensure uniform distribution.

pub fn next_u64_bound(&self, bound: u64) -> Result<u64>

Generate a random u64 in range [0, bound).

pub fn randint(&self, min: i64, max: i64) -> Result<i64>

Generate a random integer in range [min, max].

pub fn next_f32(&self) -> Result<f32>

Generate a random f32 in range [0.0, 1.0).

pub fn next_f64(&self) -> Result<f64>

Generate a random f64 in range [0.0, 1.0).

pub fn uniform(&self, min: f64, max: f64) -> Result<f64>

Generate a random f64 in range [min, max).

pub fn next_bool(&self) -> Result<bool>

Generate a random boolean.

pub fn next_bool_with_probability(&self, p: f64) -> Result<bool>

Generate a random boolean with given probability of being true.

pub fn uuid(&self) -> Result<String>

Generate a UUID v4 string.

Returns a string in the format xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx where x is any hexadecimal digit and y is one of 8, 9, a, or b.

pub fn choice<'a, T>(&self, items: &'a [T]) -> Result<Option<&'a T>>

Select a random element from a slice.

pub fn sample<T: Clone>(&self, items: &[T], n: usize) -> Result<Vec<T>>

Sample n unique elements from a slice without replacement.

pub fn shuffle<T>(&self, items: &mut [T]) -> Result<()>

Shuffle a slice in place using Fisher-Yates algorithm.

pub fn shuffled<T: Clone>(&self, items: &[T]) -> Result<Vec<T>>

Return a shuffled copy of a slice.

Trait Implementations

impl Clone for Random

fn clone(&self) -> Random

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Random

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

Formats the value using the given formatter.