native_neural_network 0.3.1

Lib no_std Rust for native neural network (.rnn)
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

#[inline]
pub(crate) fn floord(x: f64) -> f64 {
    if x.is_nan() {
        return x;
    }
    let t = x as i64 as f64;
    if t > x {
        t - 1.0
    } else {
        t
    }
}

#[inline]
pub(crate) fn floorf(x: f32) -> f32 {
    if x.is_nan() {
        return x;
    }
    let t = x as i32 as f32;
    if t > x {
        t - 1.0
    } else {
        t
    }
}

#[inline]
pub(crate) fn ldexpf(x: f32, exp: i32) -> f32 {
    if x == 0.0 {
        return 0.0;
    }
    let bits = x.to_bits();
    let sign = bits & 0x8000_0000;
    let mant = bits & 0x007f_ffff;
    let mut e = ((bits >> 23) & 0xff) as i32 - 127;
    e += exp;
    if e <= -127 {
        return 0.0;
    }
    if e >= 128 {
        return f32::INFINITY;
    }
    let new_bits = sign | (((e + 127) as u32) << 23) | mant;
    f32::from_bits(new_bits)
}

#[inline]
pub(crate) fn ldexpd(x: f64, exp: i32) -> f64 {
    if x == 0.0 {
        return 0.0;
    }
    let bits = x.to_bits();
    let sign = bits & 0x8000_0000_0000_0000u64;
    let mant = bits & 0x000f_ffff_ffff_ffffu64;
    let mut e = ((bits >> 52) & 0x7ff) as i32 - 1023;
    e += exp;
    if e <= -1023 {
        return 0.0;
    }
    if e >= 1024 {
        return f64::INFINITY;
    }
    let new_bits = sign | (((e + 1023) as u64) << 52) | mant;
    f64::from_bits(new_bits)
}