Struct Generator

pub struct Generator;

Generator

This is the most commonly used struct. It is used to generate:

• Large Unsigned Integers
• Composite Numbers
• Prime Numbers
• Safe Primes

 
use num_primes::{Generator,Verification};
 
fn main(){
    let prime = Generator::new_prime(512);
    let _uint = Generator::new_uint(1024);
 
    // p = 2q + 1 || where p is safe prime
    let _safe_prime = Generator::safe_prime(64);
 
    let _ver: bool = Verification::is_prime(&prime);
}

Implementations

impl Generator

pub fn new_composite(n: usize) -> BigUint

Generate Large Composite Numbers

This function guarantees the returned value is a composite number and is not prime.

use num_primes::Generator;
 
fn main(){
    // Generate Composite Number of 1024 bits
    let composite = Generator::new_composite(1024);
 
    // Print Out Composite Number
    println!("Composite Number: {}",composite);
}

Examples found in repository

examples/new_composite.rs (line 5)

fn main(){
    // Generate Composite Number of 1024 bits
    let composite = Generator::new_composite(1024);

    // Print Out Composite Number
    println!("Composite Number: {}",composite);
}

pub fn new_uint(n: usize) -> BigUint

Generate Large Unsigned Integer

This function takes an input (n) for the number of bits the unsigned integer should be

use num_primes::Generator;

fn main() {
    // Generate Large Random Unsigned Integer of 1024 bits
    let x = Generator::new_uint(1024);
 
    // Print Integer
    println!("Large Unsigned Integer: {}",x);
}

Examples found in repository

examples/new_unsigned_int.rs (line 5)

fn main() {
    // Generate Large Random Unsigned Integer of 1024 bits
    let x = Generator::new_uint(1024);

    // Print Integer
    println!("Large Unsigned Integer: {}",x);
}

examples/factorization.rs (line 5)

fn main() {
    // Generates New Unsighed Integer of 32 bits
    let uint = Generator::new_uint(32);
    
    // Prime Factorization    
    let factor = Factorization::prime_factor(uint);

    match factor {
        Some(factor) => println!("Largest Prime Factor: {}",factor),
        None => println!("No Prime Factors Found"),
    }
}

pub fn new_prime(n: usize) -> BigUint

Generate Prime Number

This function generates a prime number of n-bits using three primality tests.

use num_primes::Generator;
 
fn main(){
    // Generate Two Primes (p,q) of 512 bits
    let p = Generator::new_prime(512);
    let q = Generator::new_prime(512);
 
    // Multiply p and q and return n
    let n = p * q;
 
    // Print n
    println!("n: {}",n);
}

Examples found in repository

examples/new_prime.rs (line 5)

fn main(){
    // Generate Two Primes (p,q) of 512 bits
    let p = Generator::new_prime(512);
    let q = Generator::new_prime(512);

    // Multiply p and q and return n
    let _n = p * q;
}

examples/verification.rs (line 4)

fn main(){
    let prime = Generator::new_prime(1024);
    let safe = Generator::safe_prime(128);

    let is_prime: bool = Verification::is_prime(&prime);
    let is_safe_prime: bool = Verification::is_safe_prime(&safe);

    assert_eq!(is_prime, true);
    assert_eq!(is_safe_prime, true);
}

pub fn safe_prime(n: usize) -> BigUint

Generate Safe Primes

This function will generate safe prime numbers, or numbers of the form p = 2q + 1 where p is the safe prime.

use num_primes::Generator;
 
fn main(){
    // p = 2q + 1 where p is the safe prime. This generates a number of 64 bits.
    let safe_prime = Generator::safe_prime(64);
}

Examples found in repository

examples/safe_prime.rs (line 5)

fn main(){
    // p = 2q + 1 where p is the safe prime and q is a prime that fits the equation
    let safe_prime = Generator::safe_prime(128);

    // Prints safe prime and prime number
    println!("safe prime: {}",safe_prime);
}

examples/verification.rs (line 5)

fn main(){
    let prime = Generator::new_prime(1024);
    let safe = Generator::safe_prime(128);

    let is_prime: bool = Verification::is_prime(&prime);
    let is_safe_prime: bool = Verification::is_safe_prime(&safe);

    assert_eq!(is_prime, true);
    assert_eq!(is_safe_prime, true);
}