briny_ai 0.4.1

A tiny & efficient AI inference engine
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
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

//! Utilities to approximate equality of floating point values.

// likely will be replaced VERY soon

/// The max epsilon accepted on `f32`s.
pub const F32_MAX_ERROR: f32 = 1e-3;

/// The expected minimum epsilon accepted on `f32`s.
pub const F32_AVG_ERROR: f32 = 1e-4;

/// The best expected epsilon accepted on `f32`s.
pub const F32_MIN_ERROR: f32 = 1e-6;

/// The max epsilon accepted on `f64`s.
pub const F64_MAX_ERROR: f64 = 1e-3;

/// The expected minimum epsilon accepted on `f64`s.
pub const F64_AVG_ERROR: f64 = 1e-6;

/// The best expected epsilon accepted on `f64`s.
pub const F64_MIN_ERROR: f64 = 1e-13;

/// Checks the relative distance based off epsilon.
pub trait RelativeEq<Rhs: ?Sized> {
    /// Enumerates the equality of `self`
    fn approx_eq(&self, rhs: &Rhs) -> ApproxEquality;
}

impl RelativeEq<Self> for f32 {
    fn approx_eq(&self, rhs: &Self) -> ApproxEquality
    where
        Self: Sized,
    {
        let dif = (self - rhs).abs();

        if dif < F32_MIN_ERROR {
            ApproxEquality::Precise
        } else if dif < F32_AVG_ERROR {
            ApproxEquality::Partial
        } else if dif < F32_MAX_ERROR {
            ApproxEquality::Relative
        } else {
            ApproxEquality::Scarce
        }
    }
}

impl RelativeEq<Self> for f64 {
    fn approx_eq(&self, rhs: &Self) -> ApproxEquality
    where
        Self: Sized,
    {
        let dif = (self - rhs).abs();

        if dif < F64_MIN_ERROR {
            ApproxEquality::Precise
        } else if dif < F64_AVG_ERROR {
            ApproxEquality::Partial
        } else if dif < F64_MAX_ERROR {
            ApproxEquality::Relative
        } else {
            ApproxEquality::Scarce
        }
    }
}

impl<const N: usize, T: RelativeEq<U>, U> RelativeEq<[U; N]> for [T; N] {
    fn approx_eq(&self, rhs: &[U; N]) -> ApproxEquality {
        let mut eq = ApproxEquality::Precise;
        for (t_val, u_val) in self.iter().zip(rhs.iter()) {
            let eq_rating = t_val.approx_eq(u_val);
            match eq_rating {
                ApproxEquality::Precise => {
                    // already the best, can't change equality for the worse; leave it as-is
                }
                ApproxEquality::Partial => {
                    if eq != ApproxEquality::Relative {
                        eq = eq_rating;
                    }
                }
                ApproxEquality::Relative => {
                    eq = eq_rating;
                }
                ApproxEquality::Scarce => {
                    break; // can't improve from here; not equal
                }
            }
        }
        eq
    }
}

impl<T: RelativeEq<U> + Copy, U: Copy> RelativeEq<[U]> for [T] {
    fn approx_eq(&self, rhs: &[U]) -> ApproxEquality {
        let mut eq = ApproxEquality::Precise;
        for (t_val, u_val) in self.iter().zip(rhs.iter()) {
            let eq_rating = t_val.approx_eq(u_val);
            match eq_rating {
                ApproxEquality::Precise => {
                    // already the best, can't change equality for the worse; leave it as-is
                }
                ApproxEquality::Partial => {
                    if eq != ApproxEquality::Relative {
                        eq = eq_rating;
                    }
                }
                ApproxEquality::Relative => {
                    eq = eq_rating;
                }
                ApproxEquality::Scarce => {
                    break; // can't improve from here; not equal
                }
            }
        }
        eq
    }
}

/// The approximated equality enumerated.
#[repr(u8)]
#[derive(Debug, PartialEq, Eq)]
pub enum ApproxEquality {
    /// Very strong epsilon.
    Precise = 0,

    /// Good epsilon.
    Partial = 1,

    /// Acceptable epsilon
    Relative = 2,

    /// No relative equality.
    Scarce = 3,
}

/// Approximates equality based off the relative difference.
pub fn approx_eq<A: RelativeEq<B> + ?Sized, B: ?Sized>(a: &A, b: &B) -> bool {
    let eq = a.approx_eq(b);
    eq == ApproxEquality::Precise
}