prandom 0.1.0

Some PNRG algorithms implemented 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
90
91
92
93
94
95
96
97
98

// MIT License
//
// Copyright (c) 2023 Ferhat Geçdoğan All Rights Reserved.
// Distributed under the terms of the MIT License.
//
//

const N         : usize =  624      ;
const M         : usize =  397      ;
const MATRIX_A  : usize = 0x9908b0df;
const UPPER_MASK: usize = 0x80000000;
const LOWER_MASK: usize = 0x7fffffff;

pub struct MersenneTwister {
    pub _index        : usize,
    
    pub _btw_start_pos: usize,
    pub _btw_end_pos  : usize,
    pub _seed         : usize,

    pub _state        : Vec<usize>
}

impl Default for MersenneTwister {
    fn default() -> Self {
        MersenneTwister { 
            _index        : 0,
            _btw_start_pos: 0, 
            _btw_end_pos  : 0, 
            _seed         : 0, 
            _state        : vec![]
        }
    }
}

impl MersenneTwister {
    pub fn init_by_pos(&mut self, start: usize, end: usize) {
        self.init();
        self._btw_start_pos = start;
        self._btw_end_pos   = end;
        // you need to call init_state() when seed is applied.
    }

    pub fn init_by_seed(&mut self, seed: usize) {
        self.init();
        self._seed = seed;
        self.init_state();
    }

    pub fn init(&mut self) {
        self._state = vec![0; 625];
        // you need to call init_state() when seed is applied.
    }

    pub fn take(&mut self) -> usize {
        if self._index >= N {
            self._twist();
        }

        let mut y: usize = self._state[self._index];
        self._index += 1;

        y ^= (y >> 11) & 0xffffffff;
        y ^= (y << 7) & 0x9d2c5680;
        y ^= (y << 15) & 0xefc60000;
        y ^= y >> 18;

        y % (self._btw_end_pos - self._btw_start_pos + 1) + self._btw_start_pos
    } 

    pub fn init_state(&mut self) {
        self._state[0] = self._seed;

        for i in 1..N {
            self._state[i] = 1812433253usize
                                .wrapping_mul(self._state[i - 1] ^ (self._state[i - 1] >> 30))
                                .try_into()
                                .unwrap();
        }

        self._index = N;
    }

    fn _twist(&mut self) {
        for i in 0..N {
            let x     : usize = (self._state[i] & UPPER_MASK) + (self._state[(i + 1) % N] & LOWER_MASK);
            let mut xa: usize = x >> 1;
            
            if x % 2 != 0 {
                xa ^= MATRIX_A;
            }

            self._state[i] = self._state[(i + M) % N] ^ xa;
        }

        self._index = 0;
    } 
}