rmath 0.1.5

A rust math library
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

/// The DefaultSeed implement by the rdseed instruction in the x86/x86_64 platform

use crate::rand::{Seed, RandError, RandErrKind, Result, PrimitiveType};

#[cfg(target_arch = "x86_64")]
use std::arch::x86_64 as march;

#[cfg(target_arch = "x86")]
use std::arch::x86 as march;
use std::marker::PhantomData;

#[derive(Clone)]
pub struct DefaultSeed<T> {
    ph: PhantomData<T>,
}

impl<T: PrimitiveType> DefaultSeed<T> {
    pub fn new() -> Result<Self> {
        Ok(DefaultSeed {ph: PhantomData})
    }

    #[target_feature(enable = "rdseed")]
    unsafe fn rdseed_u32(&self) -> Result<u32> {
        let mut out = 0;
        if march::_rdseed32_step(&mut out) > 0 {
            Ok(out)
        } else {
            Err(RandError::new(RandErrKind::NoNewRandSeedGen, ""))
        }
    }
    
    #[cfg(target_arch = "x86")]
    #[target_feature(enable = "rdseed")]
    unsafe fn rdseed_u64(&self) -> Result<u64> {
        match self.rdseed_u32() {
            Ok(low) => {
                self.rdseed_u32().map(|high| {
                    Ok((low as u64) | ((high as u64) << 32))
                })
            },
            Err(e) => Err(e),
        }
    }

    #[cfg(target_arch = "x86_64")]
    #[target_feature(enable = "rdseed")]
    unsafe fn rdseed_u64(&self) -> Result<u64> {
        let mut out = 0;
        if march::_rdseed64_step(&mut out) > 0 {
            Ok(out)
        } else {
            Err(RandError::new(RandErrKind::NoNewRandSeedGen, ""))
        }
    }
    
    fn rdseed_usize(&self) -> Result<usize> {
        #[cfg(target_pointer_width = "32")]
            unsafe {self.rdseed_u32().map(|x| {x as usize}) }

        #[cfg(target_pointer_width = "64")]
            unsafe {self.rdseed_u64().map(|x| {x as usize})}
    }
}

impl Seed<u32> for DefaultSeed<u32> {
    fn seed(&self) -> Result<u32> {
        unsafe {
            self.rdseed_u32()
        }
    }
}

impl Seed<u64> for DefaultSeed<u64> {
    fn seed(&self) -> Result<u64> {
        unsafe {
            self.rdseed_u64()
        }
    }
}

impl Seed<usize> for DefaultSeed<usize> {
    fn seed(&self) -> Result<usize> {
        self.rdseed_usize()
    }
}