Struct randomorg::Random

pub struct Random { /* fields omitted */ }

A random.org api client.

Methods

impl Random

fn new<S: Into<String>>(api_key: S) -> Result<Random>

Creates new random.org client.

Usage

extern crate randomorg;
 
fn main() {
    use randomorg::Random;
    let r = Random::new("API KEY HERE").unwrap();
}

fn request_integers(&self) -> RequestIntegers

Create a request object for generating random integers

Usage

extern crate randomorg;
 
fn main() {
    use randomorg::Random;
    let r = Random::new("API KEY HERE").unwrap();
    let random_data = r.request_integers().min(0).max(100).limit(5).collect::<Vec<i32>>();
    println!("Random integers: {:?}", random_data);
}

fn request_decimal_fractions(&self) -> RequestDecimalFractions

Create a request object for generating random decimal fractions

Usage

extern crate randomorg;
 
fn main() {
    use randomorg::Random;
    let r = Random::new("API KEY HERE").unwrap();
    let random_data = r.request_decimal_fractions().limit(5)
                                                   .decimal_places(4)
                                                   .collect::<Vec<f32>>();
    println!("Random decimal fractions: {:?}", random_data);
}

fn request_gaussians(&self) -> RequestGaussians

Create a request object for generating random gaussians

Usage

extern crate randomorg;
 
fn main() {
    use randomorg::Random;
    let r = Random::new("API KEY HERE").unwrap();
    let random_data = r.request_gaussians().limit(5)
                                           .collect::<Vec<f32>>();
    println!("Random gaussians: {:?}", random_data);
}

fn request_strings(&self) -> RequestStrings

Create a request object for generating random strings

Usage

extern crate randomorg;
 
fn main() {
    use randomorg::Random;
    let r = Random::new("API KEY HERE").unwrap();
    let random_data = r.request_strings().limit(5)
                                         .collect::<Vec<String>>();
    println!("Random strings: {:?}", random_data);
}

fn request_uuids(&self) -> RequestUUIDs

Create a request object for generating random UUIDs

Usage

extern crate randomorg;
 
fn main() {
    use randomorg::Random;
    let r = Random::new("API KEY HERE").unwrap();
    let random_data = r.request_uuids().limit(5)
                                       .collect::<Vec<String>>();
    println!("Random strings: {:?}", random_data);
}

fn request_blobs(&self) -> RequestBlobs

Create a request object for generating random blobs

Usage

extern crate randomorg;
 
fn main() {
    use randomorg::Random;
    let r = Random::new("API KEY HERE").unwrap();
    let random_data = r.request_blobs().limit(5)
                                       .collect::<Vec<String>>();
    println!("Random strings: {:?}", random_data);
}

fn generate_integers(
    &self,
    min: i32,
    max: i32,
    limit: u16,
    replacement: bool
) -> Result<Response<GenerateIntegersResult>>

This method generates true random integers within a user-defined range.

• Official documentation

Usage

extern crate randomorg;
 
fn main() {
    use randomorg::Random;
    let r = Random::new("API KEY HERE").unwrap();
    println!("Result: {:?}", r.generate_integers(-100, 100, 15, true));
}

Constraints

• min must be within [-1e9; 1e9] range
• max must be within [-1e9; 1e9] range
• limit must be within [1; 1e4] range

fn generate_decimal_fractions(
    &self,
    limit: u16,
    decimal_places: u8
) -> Result<Response<GenerateDecimalFractionsResult>>

This method generates true random decimal fractions from a uniform distribution across the [0,1] interval with a user-defined number of decimal places.

• Official documentation

Usage

extern crate randomorg;
 
fn main() {
    use randomorg::Random;
    let r = Random::new("API KEY HERE").unwrap();
    println!("Result: {:?}", r.generate_decimal_fractions(10, 8));
}

Constraints

• limit must be within [1; 1e4] range
• decimal_places must be within [1; 20] range

fn generate_gaussians(
    &self,
    limit: u16,
    mean: i32,
    standard_deviation: i32,
    significant_digits: u8
) -> Result<Response<GenerateGaussiansResult>>

This method generates true random numbers from a Gaussian distribution (also known as a normal distribution). The form uses a Box-Muller Transform to generate the Gaussian distribution from uniformly distributed numbers.

• Official documentation

Usage

extern crate randomorg;
 
fn main() {
    use randomorg::Random;
    let r = Random::new("API KEY HERE").unwrap();
    println!("Result: {:?}", r.generate_gaussians(2000, 1100, 100, 4));
}

Constraints

• limit must be within [1; 1e4] range
• mean must be within [-1e6; 1e6] range
• standard_deviation must be within [-1e6; 1e6] range
• significant_digits must be within [2; 20] range

fn generate_strings(
    &self,
    limit: u16,
    length: u8,
    characters: AllowedCharacters
) -> Result<Response<GenerateStringsResult>>

This method generates true random strings.

• Official documentation

Usage

extern crate randomorg;
 
fn main() {
    use randomorg::{ Random, AllowedCharacters };
    use std::collections::BTreeSet;
    let chars = "abcde".chars().collect::<BTreeSet<char>>();
    let r = Random::new("API KEY HERE").unwrap();
    println!("Result: {:?}", r.generate_strings(5, 10, AllowedCharacters(chars)));
}

Constraints

• limit must be within [1; 1e4] range
• length must be within [1; 20] range
• characters must contain maximum 80 characters.

fn generate_uuids(&self, limit: u16) -> Result<Response<GenerateUUIDsResult>>

This method generates version 4 true random Universally Unique IDentifiers (UUIDs) in accordance with section 4.4 of RFC 4122.

• Official documentation

Usage

extern crate randomorg;
 
fn main() {
    use randomorg::Random;
    let r = Random::new("API KEY HERE").unwrap();
    println!("Result: {:?}", r.generate_uuids(5));
}

Constraints

• limit must be within [1; 1e3] range

fn generate_blobs(
    &self,
    limit: u16,
    size: u32
) -> Result<Response<GenerateBlobsResult>>

This method generates Binary Large OBjects (BLOBs) containing true random data.

• Official documentation

Usage

extern crate randomorg;
 
fn main() {
    use randomorg::Random;
    let r = Random::new("API KEY HERE").unwrap();
    println!("Result: {:?}", r.generate_blobs(5, 16));
}

Constraints

• limit must be within [1; 100] range
• size must be within [1, 1048576] range

fn get_usage(&self) -> Result<Response<GetUsageResult>>

Returns information related to the usage of a given API key.

• Official documentation

Usage

extern crate randomorg;
 
fn main() {
    use randomorg::Random;
    let r = Random::new("API KEY HERE").unwrap();
    println!("Result: {:?}", r.get_usage());
}