rust_qrng 0.1.2

Tsotchkes quantum random number generator library with cryptographic, financial, and gaming applications converted to Rust
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56

// This file implements Monte Carlo simulations using quantum RNG. 
use crate::QuantumRNG;

pub struct MonteCarloSimulator {
    quantum_rng: QuantumRNG,
}

impl MonteCarloSimulator {
    pub fn new() -> Self {
        MonteCarloSimulator {
            quantum_rng: QuantumRNG::new(),
        }
    }

    pub fn run_simulation<F>(&mut self, num_samples: usize, mut simulation_func: F) -> f64
    where
        F: FnMut(f64) -> f64,
    {
        let mut sum = 0.0;
        for _ in 0..num_samples {
            let sample = self.quantum_rng.generate_random_number();
            sum += simulation_func(sample);
        }
        sum / num_samples as f64
    }

    pub fn simulate_option_pricing(&mut self, strike: f64, spot: f64, rate: f64, volatility: f64, time: f64) -> f64 {
        let mut sum = 0.0;
        let num_samples = 10000;
        
        for _ in 0..num_samples {
            // Black-Scholes Monte Carlo simulation
            let drift = (rate - 0.5 * volatility * volatility) * time;
            let diffusion = volatility * (time.sqrt()) * self.normal_random();
            let final_price = spot * (drift + diffusion).exp();
            sum += (final_price - strike).max(0.0);
        }
        
        (sum / num_samples as f64) * (-rate * time).exp()
    }

    fn normal_random(&mut self) -> f64 {
        // Box-Muller transform for normal distribution
        let u1 = self.quantum_rng.generate_random_number();
        let u2 = self.quantum_rng.generate_random_number();
        (-2.0 * u1.ln()).sqrt() * (2.0 * std::f64::consts::PI * u2).cos()
    }
}

pub fn simulate(iterations: u32) -> f64 {
    let mut simulator = MonteCarloSimulator::new();
    simulator.run_simulation(iterations as usize, |x| x)
}

// Alias for backwards compatibility
pub type MonteCarloSimulation = MonteCarloSimulator;