rumba-core 0.1.0

Core library for MBA (Mixed Boolean-Arithmetic) expression simplification
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

use std::{
    fmt::Display,
    ops::{Add, BitAnd, BitOr, BitXor, Deref, Mul, Neg, Not, Sub},
};

pub const fn make_mask(n: u8) -> u64 {
    if n >= 64 { u64::MAX } else { (1u64 << n) - 1 }
}

#[derive(Copy, Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Hash)]
pub struct VarInt(u64);

impl VarInt {
    pub const MAX: Self = Self(u64::MAX);

    pub const ZERO: Self = Self(0);

    pub const ONE: Self = Self(1);

    pub const fn get(self, mask: u64) -> u64 {
        self.0 & mask
    }

    pub const fn mask(self, mask: u64) -> Self {
        Self(self.get(mask))
    }

    pub const fn get_signed(self, n: u8, mask: u64) -> i64 {
        let value = self.get(mask);
        let shift = 64 - n;
        ((value << shift) as i64) >> shift
    }

    /// Displays a varint properly (with the best sign)
    pub fn repr(self, n: u8, mask: u64, hex: bool, latex: bool) -> String {
        let val = self.get(mask);
        let sign_bit = 1u64 << (n - 1);

        if val & sign_bit != 0 {
            let signed = self.get_signed(n, mask);

            match (hex, latex) {
                (true, true) => format!("(-\\mathrm{{{:#x}}})", -signed),
                (true, false) => format!("(-{:#x})", -signed),
                _ => format!("(-{})", -signed),
            }
        } else {
            match (hex, latex) {
                (true, true) => format!("\\mathrm{{{:#x}}}", val),
                (true, false) => format!("{:#x}", val),
                _ => format!("{}", val),
            }
        }
    }
}

impl From<u64> for VarInt {
    fn from(value: u64) -> Self {
        VarInt(value)
    }
}

impl Deref for VarInt {
    type Target = u64;

    fn deref(&self) -> &Self::Target {
        &self.0
    }
}

impl Display for VarInt {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.write_str(&self.repr(64, u64::MAX, false, false))
    }
}

impl Not for VarInt {
    type Output = VarInt;

    fn not(self) -> Self::Output {
        (!self.0).into()
    }
}

impl Neg for VarInt {
    type Output = VarInt;

    fn neg(self) -> Self::Output {
        self.0.wrapping_neg().into()
    }
}

impl BitXor for VarInt {
    type Output = VarInt;

    fn bitxor(self, rhs: Self) -> Self::Output {
        (self.0 ^ rhs.0).into()
    }
}

impl BitOr for VarInt {
    type Output = VarInt;

    fn bitor(self, rhs: Self) -> Self::Output {
        (self.0 | rhs.0).into()
    }
}

impl BitAnd for VarInt {
    type Output = VarInt;

    fn bitand(self, rhs: Self) -> Self::Output {
        (self.0 & rhs.0).into()
    }
}

impl Add for VarInt {
    type Output = VarInt;

    fn add(self, rhs: Self) -> Self::Output {
        self.0.wrapping_add(rhs.0).into()
    }
}

impl Sub for VarInt {
    type Output = VarInt;

    fn sub(self, rhs: Self) -> Self::Output {
        self.0.wrapping_sub(rhs.0).into()
    }
}

impl Mul for VarInt {
    type Output = VarInt;

    fn mul(self, rhs: Self) -> Self::Output {
        self.0.wrapping_mul(rhs.0).into()
    }
}