range_set_blaze/
integer.rs

1#[cfg(feature = "from_slice")]
2use crate::{from_slice::FromSliceIter, RangeSetBlaze};
3use core::ops::RangeInclusive;
4
5#[cfg(feature = "from_slice")]
6const LANES: usize = 16;
7
8use crate::Integer;
9
10impl Integer for i8 {
11    #[cfg(target_pointer_width = "32")]
12    type SafeLen = usize;
13    #[cfg(target_pointer_width = "64")]
14    type SafeLen = usize;
15
16    #[cfg(feature = "from_slice")]
17    #[inline]
18    fn from_slice(slice: impl AsRef<[Self]>) -> RangeSetBlaze<Self> {
19        FromSliceIter::<Self, LANES>::new(slice.as_ref()).collect()
20    }
21
22    fn safe_len(r: &RangeInclusive<Self>) -> <Self as Integer>::SafeLen {
23        r.end().overflowing_sub(*r.start()).0 as u8 as <Self as Integer>::SafeLen + 1
24    }
25    fn safe_len_to_f64(len: Self::SafeLen) -> f64 {
26        len as f64
27    }
28    fn f64_to_safe_len(f: f64) -> Self::SafeLen {
29        f as Self::SafeLen
30    }
31    fn add_len_less_one(a: Self, b: Self::SafeLen) -> Self {
32        a + (b - 1) as Self
33    }
34    fn sub_len_less_one(a: Self, b: Self::SafeLen) -> Self {
35        a - (b - 1) as Self
36    }
37}
38
39impl Integer for u8 {
40    #[cfg(target_pointer_width = "32")]
41    type SafeLen = usize;
42    #[cfg(target_pointer_width = "64")]
43    type SafeLen = usize;
44
45    #[cfg(feature = "from_slice")]
46    #[inline]
47    fn from_slice(slice: impl AsRef<[Self]>) -> RangeSetBlaze<Self> {
48        FromSliceIter::<Self, LANES>::new(slice.as_ref()).collect()
49    }
50
51    fn safe_len(r: &RangeInclusive<Self>) -> <Self as Integer>::SafeLen {
52        r.end().overflowing_sub(*r.start()).0 as <Self as Integer>::SafeLen + 1
53    }
54
55    fn safe_len_to_f64(len: Self::SafeLen) -> f64 {
56        len as f64
57    }
58    fn f64_to_safe_len(f: f64) -> Self::SafeLen {
59        f as Self::SafeLen
60    }
61    fn add_len_less_one(a: Self, b: Self::SafeLen) -> Self {
62        a + (b - 1) as Self
63    }
64    fn sub_len_less_one(a: Self, b: Self::SafeLen) -> Self {
65        a - (b - 1) as Self
66    }
67}
68
69impl Integer for i32 {
70    #[cfg(target_pointer_width = "32")]
71    type SafeLen = u64;
72    #[cfg(target_pointer_width = "64")]
73    type SafeLen = usize;
74
75    fn safe_len(r: &RangeInclusive<Self>) -> <Self as Integer>::SafeLen {
76        r.end().overflowing_sub(*r.start()).0 as u32 as <Self as Integer>::SafeLen + 1
77    }
78
79    fn safe_len_to_f64(len: Self::SafeLen) -> f64 {
80        len as f64
81    }
82    fn f64_to_safe_len(f: f64) -> Self::SafeLen {
83        f as Self::SafeLen
84    }
85    fn add_len_less_one(a: Self, b: Self::SafeLen) -> Self {
86        a + (b - 1) as Self
87    }
88    fn sub_len_less_one(a: Self, b: Self::SafeLen) -> Self {
89        a - (b - 1) as Self
90    }
91
92    #[cfg(feature = "from_slice")]
93    #[inline]
94    fn from_slice(slice: impl AsRef<[Self]>) -> RangeSetBlaze<Self> {
95        FromSliceIter::<Self, LANES>::new(slice.as_ref()).collect()
96    }
97}
98
99impl Integer for u32 {
100    #[cfg(target_pointer_width = "32")]
101    type SafeLen = u64;
102    #[cfg(target_pointer_width = "64")]
103    type SafeLen = usize;
104
105    #[cfg(feature = "from_slice")]
106    #[inline]
107    fn from_slice(slice: impl AsRef<[Self]>) -> RangeSetBlaze<Self> {
108        FromSliceIter::<Self, LANES>::new(slice.as_ref()).collect()
109    }
110
111    fn safe_len(r: &RangeInclusive<Self>) -> <Self as Integer>::SafeLen {
112        r.end().overflowing_sub(*r.start()).0 as <Self as Integer>::SafeLen + 1
113    }
114
115    fn safe_len_to_f64(len: Self::SafeLen) -> f64 {
116        len as f64
117    }
118    fn f64_to_safe_len(f: f64) -> Self::SafeLen {
119        f as Self::SafeLen
120    }
121    fn add_len_less_one(a: Self, b: Self::SafeLen) -> Self {
122        a + (b - 1) as Self
123    }
124    fn sub_len_less_one(a: Self, b: Self::SafeLen) -> Self {
125        a - (b - 1) as Self
126    }
127}
128
129impl Integer for i64 {
130    #[cfg(target_pointer_width = "32")]
131    type SafeLen = u128;
132    #[cfg(target_pointer_width = "64")]
133    type SafeLen = u128;
134
135    #[cfg(feature = "from_slice")]
136    #[inline]
137    fn from_slice(slice: impl AsRef<[Self]>) -> RangeSetBlaze<Self> {
138        FromSliceIter::<Self, LANES>::new(slice.as_ref()).collect()
139    }
140
141    fn safe_len(r: &RangeInclusive<Self>) -> <Self as Integer>::SafeLen {
142        r.end().overflowing_sub(*r.start()).0 as u64 as <Self as Integer>::SafeLen + 1
143    }
144    fn safe_len_to_f64(len: Self::SafeLen) -> f64 {
145        len as f64
146    }
147    fn f64_to_safe_len(f: f64) -> Self::SafeLen {
148        f as Self::SafeLen
149    }
150    fn add_len_less_one(a: Self, b: Self::SafeLen) -> Self {
151        a + (b - 1) as Self
152    }
153    fn sub_len_less_one(a: Self, b: Self::SafeLen) -> Self {
154        a - (b - 1) as Self
155    }
156}
157
158impl Integer for u64 {
159    #[cfg(target_pointer_width = "32")]
160    type SafeLen = u128;
161    #[cfg(target_pointer_width = "64")]
162    type SafeLen = u128;
163
164    #[cfg(feature = "from_slice")]
165    #[inline]
166    fn from_slice(slice: impl AsRef<[Self]>) -> RangeSetBlaze<Self> {
167        FromSliceIter::<Self, LANES>::new(slice.as_ref()).collect()
168    }
169
170    fn safe_len(r: &RangeInclusive<Self>) -> <Self as Integer>::SafeLen {
171        r.end().overflowing_sub(*r.start()).0 as <Self as Integer>::SafeLen + 1
172    }
173    fn safe_len_to_f64(len: Self::SafeLen) -> f64 {
174        len as f64
175    }
176    fn f64_to_safe_len(f: f64) -> Self::SafeLen {
177        f as Self::SafeLen
178    }
179    fn add_len_less_one(a: Self, b: Self::SafeLen) -> Self {
180        a + (b - 1) as Self
181    }
182    fn sub_len_less_one(a: Self, b: Self::SafeLen) -> Self {
183        a - (b - 1) as Self
184    }
185}
186
187impl Integer for i128 {
188    #[cfg(target_pointer_width = "32")]
189    type SafeLen = u128;
190    #[cfg(target_pointer_width = "64")]
191    type SafeLen = u128;
192
193    #[cfg(feature = "from_slice")]
194    #[inline]
195    fn from_slice(slice: impl AsRef<[Self]>) -> crate::RangeSetBlaze<Self> {
196        return slice.as_ref().iter().collect();
197    }
198
199    fn safe_len(r: &RangeInclusive<Self>) -> <Self as Integer>::SafeLen {
200        r.end().overflowing_sub(*r.start()).0 as u128 as <Self as Integer>::SafeLen + 1
201    }
202    fn safe_max_value() -> Self {
203        Self::max_value() - 1
204    }
205
206    fn safe_len_to_f64(len: Self::SafeLen) -> f64 {
207        len as f64
208    }
209    fn f64_to_safe_len(f: f64) -> Self::SafeLen {
210        f as Self::SafeLen
211    }
212    fn add_len_less_one(a: Self, b: Self::SafeLen) -> Self {
213        a + (b - 1) as Self
214    }
215    fn sub_len_less_one(a: Self, b: Self::SafeLen) -> Self {
216        a - (b - 1) as Self
217    }
218}
219
220impl Integer for u128 {
221    #[cfg(target_pointer_width = "32")]
222    type SafeLen = u128;
223    #[cfg(target_pointer_width = "64")]
224    type SafeLen = u128;
225
226    #[cfg(feature = "from_slice")]
227    #[inline]
228    fn from_slice(slice: impl AsRef<[Self]>) -> crate::RangeSetBlaze<Self> {
229        return slice.as_ref().iter().collect();
230    }
231
232    fn safe_len(r: &RangeInclusive<Self>) -> <Self as Integer>::SafeLen {
233        r.end().overflowing_sub(*r.start()).0 as <Self as Integer>::SafeLen + 1
234    }
235    fn safe_max_value() -> Self {
236        Self::max_value() - 1
237    }
238    fn safe_len_to_f64(len: Self::SafeLen) -> f64 {
239        len as f64
240    }
241    fn f64_to_safe_len(f: f64) -> Self::SafeLen {
242        f as Self::SafeLen
243    }
244    fn add_len_less_one(a: Self, b: Self::SafeLen) -> Self {
245        a + (b - 1) as Self
246    }
247    fn sub_len_less_one(a: Self, b: Self::SafeLen) -> Self {
248        a - (b - 1) as Self
249    }
250}
251
252impl Integer for isize {
253    #[cfg(target_pointer_width = "32")]
254    type SafeLen = u64;
255    #[cfg(target_pointer_width = "64")]
256    type SafeLen = u128;
257
258    #[cfg(feature = "from_slice")]
259    #[inline]
260    fn from_slice(slice: impl AsRef<[Self]>) -> RangeSetBlaze<Self> {
261        FromSliceIter::<Self, LANES>::new(slice.as_ref()).collect()
262    }
263
264    fn safe_len(r: &RangeInclusive<Self>) -> <Self as Integer>::SafeLen {
265        r.end().overflowing_sub(*r.start()).0 as usize as <Self as Integer>::SafeLen + 1
266    }
267
268    fn safe_len_to_f64(len: Self::SafeLen) -> f64 {
269        len as f64
270    }
271    fn f64_to_safe_len(f: f64) -> Self::SafeLen {
272        f as Self::SafeLen
273    }
274    fn add_len_less_one(a: Self, b: Self::SafeLen) -> Self {
275        a + (b - 1) as Self
276    }
277    fn sub_len_less_one(a: Self, b: Self::SafeLen) -> Self {
278        a - (b - 1) as Self
279    }
280}
281
282impl Integer for usize {
283    #[cfg(target_pointer_width = "32")]
284    type SafeLen = u64;
285    #[cfg(target_pointer_width = "64")]
286    type SafeLen = u128;
287
288    #[cfg(feature = "from_slice")]
289    #[inline]
290    fn from_slice(slice: impl AsRef<[Self]>) -> RangeSetBlaze<Self> {
291        FromSliceIter::<Self, LANES>::new(slice.as_ref()).collect()
292    }
293
294    fn safe_len(r: &RangeInclusive<Self>) -> <Self as Integer>::SafeLen {
295        r.end().overflowing_sub(*r.start()).0 as <Self as Integer>::SafeLen + 1
296    }
297
298    fn safe_len_to_f64(len: Self::SafeLen) -> f64 {
299        len as f64
300    }
301    fn f64_to_safe_len(f: f64) -> Self::SafeLen {
302        f as Self::SafeLen
303    }
304    fn add_len_less_one(a: Self, b: Self::SafeLen) -> Self {
305        a + (b - 1) as Self
306    }
307    fn sub_len_less_one(a: Self, b: Self::SafeLen) -> Self {
308        a - (b - 1) as Self
309    }
310}
311
312impl Integer for i16 {
313    #[cfg(target_pointer_width = "32")]
314    type SafeLen = usize;
315    #[cfg(target_pointer_width = "64")]
316    type SafeLen = usize;
317
318    #[cfg(feature = "from_slice")]
319    #[inline]
320    fn from_slice(slice: impl AsRef<[Self]>) -> RangeSetBlaze<Self> {
321        FromSliceIter::<Self, LANES>::new(slice.as_ref()).collect()
322    }
323
324    fn safe_len(r: &RangeInclusive<Self>) -> <Self as Integer>::SafeLen {
325        r.end().overflowing_sub(*r.start()).0 as u16 as <Self as Integer>::SafeLen + 1
326    }
327
328    fn safe_len_to_f64(len: Self::SafeLen) -> f64 {
329        len as f64
330    }
331    fn f64_to_safe_len(f: f64) -> Self::SafeLen {
332        f as Self::SafeLen
333    }
334    fn add_len_less_one(a: Self, b: Self::SafeLen) -> Self {
335        a + (b - 1) as Self
336    }
337    fn sub_len_less_one(a: Self, b: Self::SafeLen) -> Self {
338        a - (b - 1) as Self
339    }
340}
341
342impl Integer for u16 {
343    #[cfg(target_pointer_width = "32")]
344    type SafeLen = usize;
345    #[cfg(target_pointer_width = "64")]
346    type SafeLen = usize;
347
348    #[cfg(feature = "from_slice")]
349    #[inline]
350    fn from_slice(slice: impl AsRef<[Self]>) -> RangeSetBlaze<Self> {
351        FromSliceIter::<Self, LANES>::new(slice.as_ref()).collect()
352    }
353
354    fn safe_len(r: &RangeInclusive<Self>) -> <Self as Integer>::SafeLen {
355        r.end().overflowing_sub(*r.start()).0 as <Self as Integer>::SafeLen + 1
356    }
357
358    fn safe_len_to_f64(len: Self::SafeLen) -> f64 {
359        len as f64
360    }
361    fn f64_to_safe_len(f: f64) -> Self::SafeLen {
362        f as Self::SafeLen
363    }
364    fn add_len_less_one(a: Self, b: Self::SafeLen) -> Self {
365        a + (b - 1) as Self
366    }
367    fn sub_len_less_one(a: Self, b: Self::SafeLen) -> Self {
368        a - (b - 1) as Self
369    }
370}
range_set_blaze/integer.rs

range_set_blaze/
integer.rs
