sobol 1.0.2

A Sobol sequence generator for 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
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104

extern crate libflate;

use crate::{SobolParams, ParamDimension};

use std::io::{BufRead, BufReader, Cursor};
use libflate::gzip::Decoder;


pub struct JoeKuoD6 {
    pub dim_params: Vec<JoeKuoD6Dim>,
    pub max_dims: usize
}

impl JoeKuoD6 {

    /**
     * Load parameter values supporting up to 1000 dimensions
     */
    pub fn standard() -> Self {
        JoeKuoD6::load_gz_bytes(include_bytes!("data/new-joe-kuo-6.1000.gz"))
    }

    /**
     * Load parameter values supporting up to 100 dimensions
     */
    pub fn minimal() -> Self {
        JoeKuoD6::load_gz_bytes(include_bytes!("data/new-joe-kuo-6.100.gz"))
    }

    /**
     * Load parameter values supporting up to 21,201 dimensions
     */
    pub fn extended() -> Self {
        JoeKuoD6::load_gz_bytes(include_bytes!("data/new-joe-kuo-6.21201.gz"))
    }

    /** Instantiates parameter struct from gz sequence of bytes */
    fn load_gz_bytes(bytes: &[u8]) -> JoeKuoD6 {
        let mut byte_cursor = Cursor::new(bytes);
        let gz_decoder = Decoder::new(&mut byte_cursor).unwrap();
        let dim_params: Vec<JoeKuoD6Dim> = BufReader::new(gz_decoder)
            .lines()
            .skip(1)
            .map(|l| JoeKuoD6Dim::parse(&l.unwrap()))
            .collect();
        let max_dims = dim_params.len() + 1;
        JoeKuoD6 { dim_params, max_dims }
    }
}

impl SobolParams<u32> for JoeKuoD6 {
    #[inline]
    fn get_dim(&self, dim: usize) -> &dyn ParamDimension<u32> {
        &self.dim_params[dim - 2]
    }

    #[inline]
    fn max_dims(&self) -> usize {
        self.max_dims
    }
}

/** Parameters for a single dimension */
pub struct JoeKuoD6Dim {
    pub d: u16,
    pub a: u32,
    pub m: Vec<u32>
}

impl JoeKuoD6Dim {

    /** Parses the dimensional parameters from string according to the format provided by Joe/Kuo */
    pub fn parse(s: &str) -> Self {
        let mut tokens = s.split_whitespace();
        let d = tokens.next().unwrap().parse::<u16>().unwrap();
        tokens.next();
        let a = tokens.next().unwrap().parse::<u32>().unwrap();
        let m = tokens.map(|t| t.parse::<u32>().unwrap()).collect();
        JoeKuoD6Dim { d, a, m }
    }
}

impl ParamDimension<u32> for JoeKuoD6Dim {

    #[inline]
    fn d(&self) -> u16 {
        self.d
    }

    #[inline]
    fn s(&self) -> usize {
        self.m.len()
    }
    
    #[inline]
    fn coefficient(&self, i: usize) -> u32 {
        (self.a >> i) & 1
    }
    
    #[inline]
    fn m(&self, i: usize) -> u32 {
        self.m[i]
    }
}