sfmt-sys 0.1.0

Rust wrapper of SFMT
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
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148

/// 128-bit data structure
#[repr(C)]
#[derive(Clone, Copy)]
pub union w128 {
    pub u: [u32; 4usize],
    pub u64: [u64; 2usize],
}

/// SFMT internal state
#[repr(C)]
#[derive(Clone)]
pub struct SFMT {
    /// the 128-bit internal state array
    pub state: [w128; 156usize],
    /// index counter to the 32-bit internal state array
    pub idx: i32,
}

extern "C" {
    pub fn sfmt_fill_array32(sfmt: *mut SFMT, array: *mut u32, size: i32);
    pub fn sfmt_fill_array64(sfmt: *mut SFMT, array: *mut u64, size: i32);
    pub fn sfmt_gen_rand_all(sfmt: *mut SFMT);
    pub fn sfmt_get_idstring(sfmt: *mut SFMT) -> *const u8;
    pub fn sfmt_get_min_array_size32(sfmt: *mut SFMT) -> i32;
    pub fn sfmt_get_min_array_size64(sfmt: *mut SFMT) -> i32;
    pub fn sfmt_init_by_array(sfmt: *mut SFMT, init_key: *mut u32, key_length: i32);
    pub fn sfmt_init_gen_rand(sfmt: *mut SFMT, seed: u32);
}

/// the 128-bit internal state array
#[repr(C)]
pub struct DSFMT {
    pub status: [w128; 192usize],
    pub idx: i32,
}

extern "C" {
    #[link_name = "\u{1}dsfmt_global_data"]
    pub static mut dsfmt_global_data: DSFMT;
    #[link_name = "\u{1}dsfmt_global_mexp"]
    pub static mut dsfmt_global_mexp: i32;
    pub fn dsfmt_gen_rand_all(dsfmt: *mut DSFMT);
    pub fn dsfmt_fill_array_open_close(dsfmt: *mut DSFMT, array: *mut f64, size: i32);
    pub fn dsfmt_fill_array_close_open(dsfmt: *mut DSFMT, array: *mut f64, size: i32);
    pub fn dsfmt_fill_array_open_open(dsfmt: *mut DSFMT, array: *mut f64, size: i32);
    pub fn dsfmt_fill_array_close1_open2(dsfmt: *mut DSFMT, array: *mut f64, size: i32);
    pub fn dsfmt_chk_init_gen_rand(dsfmt: *mut DSFMT, seed: u32, mexp: i32);
    pub fn dsfmt_chk_init_by_array(
        dsfmt: *mut DSFMT,
        init_key: *mut u32,
        key_length: i32,
        mexp: i32,
    );
    pub fn dsfmt_get_idstring() -> *const i8;
    pub fn dsfmt_get_min_array_size() -> i32;
}

#[cfg(test)]
mod test {
    use super::*;

    #[test]
    fn bindgen_test_layout_w128() {
        assert_eq!(
            ::std::mem::size_of::<w128>(),
            16usize,
            concat!("Size of: ", stringify!(w128))
        );
        assert_eq!(
            ::std::mem::align_of::<w128>(),
            8usize,
            concat!("Alignment of ", stringify!(w128))
        );
        assert_eq!(
            unsafe { &(*(::std::ptr::null::<w128>())).u as *const _ as usize },
            0usize,
            concat!("Offset of field: ", stringify!(w128), "::", stringify!(u))
        );
        assert_eq!(
            unsafe { &(*(::std::ptr::null::<w128>())).u64 as *const _ as usize },
            0usize,
            concat!("Offset of field: ", stringify!(w128), "::", stringify!(u64))
        );
    }

    #[test]
    fn bindgen_test_layout_sfmt() {
        assert_eq!(
            ::std::mem::size_of::<SFMT>(),
            2504usize,
            concat!("Size of: ", stringify!(SFMT))
        );
        assert_eq!(
            ::std::mem::align_of::<SFMT>(),
            8usize,
            concat!("Alignment of ", stringify!(SFMT))
        );
        assert_eq!(
            unsafe { &(*(::std::ptr::null::<SFMT>())).state as *const _ as usize },
            0usize,
            concat!(
                "Offset of field: ",
                stringify!(SFMT),
                "::",
                stringify!(state)
            )
        );
        assert_eq!(
            unsafe { &(*(::std::ptr::null::<SFMT>())).idx as *const _ as usize },
            2496usize,
            concat!("Offset of field: ", stringify!(SFMT), "::", stringify!(idx))
        );
    }

    #[test]
    fn bindgen_test_layout_dsfmt() {
        assert_eq!(
            ::std::mem::size_of::<DSFMT>(),
            3080usize,
            concat!("Size of: ", stringify!(DSFMT))
        );
        assert_eq!(
            ::std::mem::align_of::<DSFMT>(),
            8usize,
            concat!("Alignment of ", stringify!(DSFMT))
        );
        assert_eq!(
            unsafe { &(*(::std::ptr::null::<DSFMT>())).status as *const _ as usize },
            0usize,
            concat!(
                "Offset of field: ",
                stringify!(DSFMT),
                "::",
                stringify!(status)
            )
        );
        assert_eq!(
            unsafe { &(*(::std::ptr::null::<DSFMT>())).idx as *const _ as usize },
            3072usize,
            concat!(
                "Offset of field: ",
                stringify!(DSFMT),
                "::",
                stringify!(idx)
            )
        );
    }
}