vortex-dtype 0.59.4

Vortex's core type system
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

// SPDX-License-Identifier: Apache-2.0
// SPDX-FileCopyrightText: Copyright the Vortex contributors

use std::ops::BitOr;
use std::ops::Rem;
use std::ops::Shl;
use std::ops::Shr;
use std::ops::Sub;

use arbitrary::unstructured::Int;
use num_traits::CheckedAdd;
use num_traits::WrappingAdd;
use num_traits::WrappingSub;
use primitive_types::U256;

use crate::i256;

/// Used only internally to implement `Int` for i256
#[derive(Debug, Copy, Clone, Ord, PartialOrd, Eq, PartialEq)]
pub struct U256Wrapper(U256);

impl Sub for U256Wrapper {
    type Output = Self;

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

impl Rem for U256Wrapper {
    type Output = Self;

    fn rem(self, rhs: Self) -> Self::Output {
        U256Wrapper(self.0 % rhs.0)
    }
}

impl Shr for U256Wrapper {
    type Output = Self;

    fn shr(self, rhs: Self) -> Self::Output {
        U256Wrapper(self.0 >> rhs.0)
    }
}

impl Shl<usize> for U256Wrapper {
    type Output = Self;

    fn shl(self, rhs: usize) -> Self::Output {
        U256Wrapper(self.0 << rhs)
    }
}

impl BitOr for U256Wrapper {
    type Output = Self;

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

impl Int for U256Wrapper {
    type Unsigned = Self;

    const ZERO: Self = U256Wrapper(U256::zero());
    const ONE: Self = U256Wrapper(U256::one());
    const MAX: Self = U256Wrapper(U256::max_value());

    fn from_u8(b: u8) -> Self {
        Self(U256::from(b))
    }

    fn from_usize(u: usize) -> Self {
        Self(U256::from(u))
    }

    fn checked_add(self, rhs: Self) -> Option<Self> {
        self.0.checked_add(rhs.0).map(U256Wrapper)
    }

    fn wrapping_add(self, rhs: Self) -> Self {
        let (v, _) = self.0.overflowing_add(rhs.0);
        U256Wrapper(v)
    }

    fn wrapping_sub(self, rhs: Self) -> Self {
        let (v, _) = self.0.overflowing_sub(rhs.0);
        U256Wrapper(v)
    }

    fn to_unsigned(self) -> Self::Unsigned {
        self
    }

    fn from_unsigned(unsigned: Self::Unsigned) -> Self {
        unsigned
    }
}

impl Int for i256 {
    type Unsigned = U256Wrapper;
    const ZERO: Self = i256::ZERO;
    const ONE: Self = i256::ONE;
    const MAX: Self = i256::MAX;

    fn from_u8(b: u8) -> Self {
        Self::from_i128(b as i128)
    }

    fn from_usize(u: usize) -> Self {
        Self::from_i128(u as i128)
    }

    fn checked_add(self, rhs: Self) -> Option<Self> {
        <Self as CheckedAdd>::checked_add(&self, &rhs)
    }

    fn wrapping_add(self, rhs: Self) -> Self {
        <Self as WrappingAdd>::wrapping_add(&self, &rhs)
    }

    fn wrapping_sub(self, rhs: Self) -> Self {
        <Self as WrappingSub>::wrapping_sub(&self, &rhs)
    }

    fn to_unsigned(self) -> Self::Unsigned {
        let bytes = self.to_le_bytes(); // or to_be_bytes(), depends on your impl
        U256Wrapper(U256::from_little_endian(&bytes))
    }

    fn from_unsigned(unsigned: Self::Unsigned) -> Self {
        let bytes = unsigned.0.to_little_endian();
        i256::from_le_bytes(bytes)
    }
}