lds-rs 0.1.10

Low-Discrepancy Sequence (LDS) Generator in 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
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89

//! Basic examples of using the lds-gen library

use lds_rs::{Circle, Disk, Halton, HaltonN, PRIME_TABLE, Sphere, VdCorput};

fn main() {
    println!("=== Basic Low-Discrepancy Sequence Examples ===\n");

    // Example 1: van der Corput sequence
    println!("1. van der Corput sequence (base 2):");
    let mut vgen = VdCorput::new(2);
    vgen.reseed(0);
    for i in 0..5 {
        println!("  Value {}: {}", i + 1, vgen.pop());
    }
    println!();

    // Example 2: Halton sequence
    println!("2. Halton sequence (bases [2, 3]):");
    let mut hgen = Halton::new([2, 3]);
    hgen.reseed(0);
    for i in 0..3 {
        let point = hgen.pop();
        println!("  Point {}: [{:.6}, {:.6}]", i + 1, point[0], point[1]);
    }
    println!();

    // Example 3: Circle sequence
    println!("3. Points on unit circle (base 2):");
    let mut cgen = Circle::new(2);
    cgen.reseed(0);
    for i in 0..3 {
        let point = cgen.pop();
        println!("  Point {}: [{:.6}, {:.6}]", i + 1, point[0], point[1]);
    }
    println!();

    // Example 4: Disk sequence
    println!("4. Points in unit disk (bases [2, 3]):");
    let mut dgen = Disk::new([2, 3]);
    dgen.reseed(0);
    for i in 0..3 {
        let point = dgen.pop();
        let radius = (point[0] * point[0] + point[1] * point[1]).sqrt();
        println!(
            "  Point {}: [{:.6}, {:.6}] (radius: {:.6})",
            i + 1,
            point[0],
            point[1],
            radius
        );
    }
    println!();

    // Example 5: Sphere sequence
    println!("5. Points on unit sphere (bases [2, 3]):");
    let mut sgen = Sphere::new([2, 3]);
    sgen.reseed(0);
    for i in 0..3 {
        let point = sgen.pop();
        let radius = (point[0] * point[0] + point[1] * point[1] + point[2] * point[2]).sqrt();
        println!(
            "  Point {}: [{:.6}, {:.6}, {:.6}] (radius: {:.6})",
            i + 1,
            point[0],
            point[1],
            point[2],
            radius
        );
    }
    println!();

    // Example 6: N-dimensional Halton sequence
    println!("6. 4D Halton sequence (first 4 primes):");
    let bases = &PRIME_TABLE[0..4];
    let mut hgen_n = HaltonN::new(bases);
    hgen_n.reseed(0);
    for i in 0..2 {
        let point = hgen_n.pop();
        println!("  Point {}: {:?}", i + 1, point);
    }
    println!();

    // Example 7: Using prime table
    println!("7. First 10 primes from PRIME_TABLE:");
    for &prime in PRIME_TABLE.iter().take(10) {
        print!("{} ", prime);
    }
    println!("\n");
}