multitype 0.21.1

Arithmetic type traits.
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
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331

// Copyright 2025-2026 Gabriel Bjørnager Jensen.
//
// SPDX: MIT OR Apache-2.0

#![cfg(test)]

use multitype::Integral;

#[cfg(feature = "std")]
use std::panic::catch_unwind;

#[test]
fn test_highest_one() {
	assert_eq!(Integral::highest_one(0_u8), None);
	assert_eq!(Integral::highest_one(1_u8), Some(0));
	assert_eq!(Integral::highest_one(2_u8), Some(1));
	assert_eq!(Integral::highest_one(3_u8), Some(1));
	assert_eq!(Integral::highest_one(4_u8), Some(2));
	assert_eq!(Integral::highest_one(5_u8), Some(2));
	assert_eq!(Integral::highest_one(6_u8), Some(2));
	assert_eq!(Integral::highest_one(7_u8), Some(2));

	assert_eq!(Integral::highest_one(-0_i8), None);
	assert_eq!(Integral::highest_one(-1_i8), Some(7));
	assert_eq!(Integral::highest_one(-2_i8), Some(7));
	assert_eq!(Integral::highest_one(-3_i8), Some(7));
	assert_eq!(Integral::highest_one(-4_i8), Some(7));
	assert_eq!(Integral::highest_one(-5_i8), Some(7));
	assert_eq!(Integral::highest_one(-6_i8), Some(7));
	assert_eq!(Integral::highest_one(-7_i8), Some(7));
}

#[test]
fn test_isolate_highest_one() {
	assert_eq!(Integral::isolate_highest_one(0_u8), 0);
	assert_eq!(Integral::isolate_highest_one(1_u8), 1);
	assert_eq!(Integral::isolate_highest_one(2_u8), 2);
	assert_eq!(Integral::isolate_highest_one(3_u8), 2);
	assert_eq!(Integral::isolate_highest_one(4_u8), 4);
	assert_eq!(Integral::isolate_highest_one(5_u8), 4);
	assert_eq!(Integral::isolate_highest_one(6_u8), 4);
	assert_eq!(Integral::isolate_highest_one(7_u8), 4);

	assert_eq!(Integral::isolate_highest_one(-0_i8),    0);
	assert_eq!(Integral::isolate_highest_one(-1_i8), -128);
	assert_eq!(Integral::isolate_highest_one(-2_i8), -128);
	assert_eq!(Integral::isolate_highest_one(-3_i8), -128);
	assert_eq!(Integral::isolate_highest_one(-4_i8), -128);
	assert_eq!(Integral::isolate_highest_one(-5_i8), -128);
	assert_eq!(Integral::isolate_highest_one(-6_i8), -128);
	assert_eq!(Integral::isolate_highest_one(-7_i8), -128);
}

#[test]
fn test_isolate_lowest_one() {
	assert_eq!(Integral::isolate_lowest_one(0_u8), 0);
	assert_eq!(Integral::isolate_lowest_one(1_u8), 1);
	assert_eq!(Integral::isolate_lowest_one(2_u8), 2);
	assert_eq!(Integral::isolate_lowest_one(3_u8), 1);
	assert_eq!(Integral::isolate_lowest_one(4_u8), 4);
	assert_eq!(Integral::isolate_lowest_one(5_u8), 1);
	assert_eq!(Integral::isolate_lowest_one(6_u8), 2);
	assert_eq!(Integral::isolate_lowest_one(7_u8), 1);

	assert_eq!(Integral::isolate_lowest_one(-0_i8), 0);
	assert_eq!(Integral::isolate_lowest_one(-1_i8), 1);
	assert_eq!(Integral::isolate_lowest_one(-2_i8), 2);
	assert_eq!(Integral::isolate_lowest_one(-3_i8), 1);
	assert_eq!(Integral::isolate_lowest_one(-4_i8), 4);
	assert_eq!(Integral::isolate_lowest_one(-5_i8), 1);
	assert_eq!(Integral::isolate_lowest_one(-6_i8), 2);
	assert_eq!(Integral::isolate_lowest_one(-7_i8), 1);
}

#[test]
fn test_lowest_one() {
	assert_eq!(Integral::lowest_one(0_u8), None);
	assert_eq!(Integral::lowest_one(1_u8), Some(0));
	assert_eq!(Integral::lowest_one(2_u8), Some(1));
	assert_eq!(Integral::lowest_one(3_u8), Some(0));
	assert_eq!(Integral::lowest_one(4_u8), Some(2));
	assert_eq!(Integral::lowest_one(5_u8), Some(0));
	assert_eq!(Integral::lowest_one(6_u8), Some(1));
	assert_eq!(Integral::lowest_one(7_u8), Some(0));

	assert_eq!(Integral::lowest_one(-0_i8), None);
	assert_eq!(Integral::lowest_one(-1_i8), Some(0));
	assert_eq!(Integral::lowest_one(-2_i8), Some(1));
	assert_eq!(Integral::lowest_one(-3_i8), Some(0));
	assert_eq!(Integral::lowest_one(-4_i8), Some(2));
	assert_eq!(Integral::lowest_one(-5_i8), Some(0));
	assert_eq!(Integral::lowest_one(-6_i8), Some(1));
	assert_eq!(Integral::lowest_one(-7_i8), Some(0));
}

#[test]
fn test_midpoint() {
	assert_eq!(Integral::midpoint(0_u128,        0_u128),    0_u128);
	assert_eq!(Integral::midpoint(0_u128,        u128::MAX), u128::MAX / 2);
	assert_eq!(Integral::midpoint(u128::MAX,     u128::MAX), u128::MAX);
	assert_eq!(Integral::midpoint(u128::MAX - 2, u128::MAX), u128::MAX - 1);
	assert_eq!(Integral::midpoint(i128::MIN,     i128::MAX), 0);
}

#[cfg(feature = "std")]
#[test]
fn test_strict_add() {
	catch_unwind(|| Integral::strict_add(u8::MIN, 1)).unwrap();
	catch_unwind(|| Integral::strict_add(u16::MIN, 1)).unwrap();
	catch_unwind(|| Integral::strict_add(u32::MIN, 1)).unwrap();
	catch_unwind(|| Integral::strict_add(u64::MIN, 1)).unwrap();
	catch_unwind(|| Integral::strict_add(u128::MIN, 1)).unwrap();
	catch_unwind(|| Integral::strict_add(usize::MIN, 1)).unwrap();

	catch_unwind(|| Integral::strict_add(i8::MIN, 1)).unwrap();
	catch_unwind(|| Integral::strict_add(i16::MIN, 1)).unwrap();
	catch_unwind(|| Integral::strict_add(i32::MIN, 1)).unwrap();
	catch_unwind(|| Integral::strict_add(i64::MIN, 1)).unwrap();
	catch_unwind(|| Integral::strict_add(i128::MIN, 1)).unwrap();
	catch_unwind(|| Integral::strict_add(isize::MIN, 1)).unwrap();

	catch_unwind(|| Integral::strict_add(u8::MAX, 1)).unwrap_err();
	catch_unwind(|| Integral::strict_add(u16::MAX, 1)).unwrap_err();
	catch_unwind(|| Integral::strict_add(u32::MAX, 1)).unwrap_err();
	catch_unwind(|| Integral::strict_add(u64::MAX, 1)).unwrap_err();
	catch_unwind(|| Integral::strict_add(u128::MAX, 1)).unwrap_err();
	catch_unwind(|| Integral::strict_add(usize::MAX, 1)).unwrap_err();

	catch_unwind(|| Integral::strict_add(i8::MAX, 1)).unwrap_err();
	catch_unwind(|| Integral::strict_add(i16::MAX, 1)).unwrap_err();
	catch_unwind(|| Integral::strict_add(i32::MAX, 1)).unwrap_err();
	catch_unwind(|| Integral::strict_add(i64::MAX, 1)).unwrap_err();
	catch_unwind(|| Integral::strict_add(i128::MAX, 1)).unwrap_err();
	catch_unwind(|| Integral::strict_add(isize::MAX, 1)).unwrap_err();
}

#[cfg(feature = "std")]
#[test]
fn test_strict_div() {
	catch_unwind(|| Integral::strict_div(u8::MIN, 1)).unwrap();
	catch_unwind(|| Integral::strict_div(u16::MIN, 1)).unwrap();
	catch_unwind(|| Integral::strict_div(u32::MIN, 1)).unwrap();
	catch_unwind(|| Integral::strict_div(u64::MIN, 1)).unwrap();
	catch_unwind(|| Integral::strict_div(u128::MIN, 1)).unwrap();
	catch_unwind(|| Integral::strict_div(usize::MIN, 1)).unwrap();

	catch_unwind(|| Integral::strict_div(i8::MIN, 1)).unwrap();
	catch_unwind(|| Integral::strict_div(i16::MIN, 1)).unwrap();
	catch_unwind(|| Integral::strict_div(i32::MIN, 1)).unwrap();
	catch_unwind(|| Integral::strict_div(i64::MIN, 1)).unwrap();
	catch_unwind(|| Integral::strict_div(i128::MIN, 1)).unwrap();
	catch_unwind(|| Integral::strict_div(isize::MIN, 1)).unwrap();

	catch_unwind(|| Integral::strict_div(u8::MIN, 0)).unwrap_err();
	catch_unwind(|| Integral::strict_div(u16::MIN, 0)).unwrap_err();
	catch_unwind(|| Integral::strict_div(u32::MIN, 0)).unwrap_err();
	catch_unwind(|| Integral::strict_div(u64::MIN, 0)).unwrap_err();
	catch_unwind(|| Integral::strict_div(u128::MIN, 0)).unwrap_err();
	catch_unwind(|| Integral::strict_div(usize::MIN, 0)).unwrap_err();

	catch_unwind(|| Integral::strict_div(i8::MIN, -1)).unwrap_err();
	catch_unwind(|| Integral::strict_div(i16::MIN, -1)).unwrap_err();
	catch_unwind(|| Integral::strict_div(i32::MIN, -1)).unwrap_err();
	catch_unwind(|| Integral::strict_div(i64::MIN, -1)).unwrap_err();
	catch_unwind(|| Integral::strict_div(i128::MIN, -1)).unwrap_err();
	catch_unwind(|| Integral::strict_div(isize::MIN, -1)).unwrap_err();
}

#[cfg(feature = "std")]
#[test]
fn test_strict_mul() {
	catch_unwind(|| Integral::strict_mul(u8::MAX, 1)).unwrap();
	catch_unwind(|| Integral::strict_mul(u16::MAX, 1)).unwrap();
	catch_unwind(|| Integral::strict_mul(u32::MAX, 1)).unwrap();
	catch_unwind(|| Integral::strict_mul(u64::MAX, 1)).unwrap();
	catch_unwind(|| Integral::strict_mul(u128::MAX, 1)).unwrap();
	catch_unwind(|| Integral::strict_mul(usize::MAX, 1)).unwrap();

	catch_unwind(|| Integral::strict_mul(i8::MAX, 1)).unwrap();
	catch_unwind(|| Integral::strict_mul(i16::MAX, 1)).unwrap();
	catch_unwind(|| Integral::strict_mul(i32::MAX, 1)).unwrap();
	catch_unwind(|| Integral::strict_mul(i64::MAX, 1)).unwrap();
	catch_unwind(|| Integral::strict_mul(i128::MAX, 1)).unwrap();
	catch_unwind(|| Integral::strict_mul(isize::MAX, 1)).unwrap();

	catch_unwind(|| Integral::strict_mul(u8::MAX, 2)).unwrap_err();
	catch_unwind(|| Integral::strict_mul(u16::MAX, 2)).unwrap_err();
	catch_unwind(|| Integral::strict_mul(u32::MAX, 2)).unwrap_err();
	catch_unwind(|| Integral::strict_mul(u64::MAX, 2)).unwrap_err();
	catch_unwind(|| Integral::strict_mul(u128::MAX, 2)).unwrap_err();
	catch_unwind(|| Integral::strict_mul(usize::MAX, 2)).unwrap_err();

	catch_unwind(|| Integral::strict_mul(i8::MAX, 2)).unwrap_err();
	catch_unwind(|| Integral::strict_mul(i16::MAX, 2)).unwrap_err();
	catch_unwind(|| Integral::strict_mul(i32::MAX, 2)).unwrap_err();
	catch_unwind(|| Integral::strict_mul(i64::MAX, 2)).unwrap_err();
	catch_unwind(|| Integral::strict_mul(i128::MAX, 2)).unwrap_err();
	catch_unwind(|| Integral::strict_mul(isize::MAX, 2)).unwrap_err();
}

#[cfg(feature = "std")]
#[test]
fn test_strict_pow() {
	catch_unwind(|| Integral::strict_pow(2_u8, 7)).unwrap();
	catch_unwind(|| Integral::strict_pow(2_u16, 15)).unwrap();
	catch_unwind(|| Integral::strict_pow(2_u32, 31)).unwrap();
	catch_unwind(|| Integral::strict_pow(2_u64, 63)).unwrap();
	catch_unwind(|| Integral::strict_pow(2_u128, 127)).unwrap();
	catch_unwind(|| Integral::strict_pow(2_usize, usize::MAX.ilog2())).unwrap();

	catch_unwind(|| Integral::strict_pow(2_i8, 6)).unwrap();
	catch_unwind(|| Integral::strict_pow(2_i16, 14)).unwrap();
	catch_unwind(|| Integral::strict_pow(2_i32, 30)).unwrap();
	catch_unwind(|| Integral::strict_pow(2_i64, 62)).unwrap();
	catch_unwind(|| Integral::strict_pow(2_i128, 126)).unwrap();
	catch_unwind(|| Integral::strict_pow(2_isize, isize::MAX.ilog2())).unwrap();

	catch_unwind(|| Integral::strict_pow(2_u8, 8)).unwrap_err();
	catch_unwind(|| Integral::strict_pow(2_u16, 16)).unwrap_err();
	catch_unwind(|| Integral::strict_pow(2_u32, 32)).unwrap_err();
	catch_unwind(|| Integral::strict_pow(2_u64, 64)).unwrap_err();
	catch_unwind(|| Integral::strict_pow(2_u128, 128)).unwrap_err();
	catch_unwind(|| Integral::strict_pow(2_usize, usize::MAX.ilog2() + 1)).unwrap_err();

	catch_unwind(|| Integral::strict_pow(2_i8, 7)).unwrap_err();
	catch_unwind(|| Integral::strict_pow(2_i16, 15)).unwrap_err();
	catch_unwind(|| Integral::strict_pow(2_i32, 31)).unwrap_err();
	catch_unwind(|| Integral::strict_pow(2_i64, 63)).unwrap_err();
	catch_unwind(|| Integral::strict_pow(2_i128, 127)).unwrap_err();
	catch_unwind(|| Integral::strict_pow(2_isize, isize::MAX.ilog2() + 1)).unwrap_err();
}

#[cfg(feature = "std")]
#[test]
fn test_strict_rem() {
	catch_unwind(|| Integral::strict_rem(u8::MIN, 1)).unwrap();
	catch_unwind(|| Integral::strict_rem(u16::MIN, 1)).unwrap();
	catch_unwind(|| Integral::strict_rem(u32::MIN, 1)).unwrap();
	catch_unwind(|| Integral::strict_rem(u64::MIN, 1)).unwrap();
	catch_unwind(|| Integral::strict_rem(u128::MIN, 1)).unwrap();
	catch_unwind(|| Integral::strict_rem(usize::MIN, 1)).unwrap();

	catch_unwind(|| Integral::strict_rem(i8::MIN, 1)).unwrap();
	catch_unwind(|| Integral::strict_rem(i16::MIN, 1)).unwrap();
	catch_unwind(|| Integral::strict_rem(i32::MIN, 1)).unwrap();
	catch_unwind(|| Integral::strict_rem(i64::MIN, 1)).unwrap();
	catch_unwind(|| Integral::strict_rem(i128::MIN, 1)).unwrap();
	catch_unwind(|| Integral::strict_rem(isize::MIN, 1)).unwrap();

	catch_unwind(|| Integral::strict_rem(u8::MIN, 0)).unwrap_err();
	catch_unwind(|| Integral::strict_rem(u16::MIN, 0)).unwrap_err();
	catch_unwind(|| Integral::strict_rem(u32::MIN, 0)).unwrap_err();
	catch_unwind(|| Integral::strict_rem(u64::MIN, 0)).unwrap_err();
	catch_unwind(|| Integral::strict_rem(u128::MIN, 0)).unwrap_err();
	catch_unwind(|| Integral::strict_rem(usize::MIN, 0)).unwrap_err();

	catch_unwind(|| Integral::strict_rem(i8::MIN, -1)).unwrap_err();
	catch_unwind(|| Integral::strict_rem(i16::MIN, -1)).unwrap_err();
	catch_unwind(|| Integral::strict_rem(i32::MIN, -1)).unwrap_err();
	catch_unwind(|| Integral::strict_rem(i64::MIN, -1)).unwrap_err();
	catch_unwind(|| Integral::strict_rem(i128::MIN, -1)).unwrap_err();
	catch_unwind(|| Integral::strict_rem(isize::MIN, -1)).unwrap_err();
}

#[cfg(feature = "std")]
#[test]
fn test_strict_sub() {
	catch_unwind(|| Integral::strict_sub(u8::MAX, 1)).unwrap();
	catch_unwind(|| Integral::strict_sub(u16::MAX, 1)).unwrap();
	catch_unwind(|| Integral::strict_sub(u32::MAX, 1)).unwrap();
	catch_unwind(|| Integral::strict_sub(u64::MAX, 1)).unwrap();
	catch_unwind(|| Integral::strict_sub(u128::MAX, 1)).unwrap();
	catch_unwind(|| Integral::strict_sub(usize::MAX, 1)).unwrap();

	catch_unwind(|| Integral::strict_sub(i8::MAX, 1)).unwrap();
	catch_unwind(|| Integral::strict_sub(i16::MAX, 1)).unwrap();
	catch_unwind(|| Integral::strict_sub(i32::MAX, 1)).unwrap();
	catch_unwind(|| Integral::strict_sub(i64::MAX, 1)).unwrap();
	catch_unwind(|| Integral::strict_sub(i128::MAX, 1)).unwrap();
	catch_unwind(|| Integral::strict_sub(isize::MAX, 1)).unwrap();

	catch_unwind(|| Integral::strict_sub(u8::MIN, 1)).unwrap_err();
	catch_unwind(|| Integral::strict_sub(u16::MIN, 1)).unwrap_err();
	catch_unwind(|| Integral::strict_sub(u32::MIN, 1)).unwrap_err();
	catch_unwind(|| Integral::strict_sub(u64::MIN, 1)).unwrap_err();
	catch_unwind(|| Integral::strict_sub(u128::MIN, 1)).unwrap_err();
	catch_unwind(|| Integral::strict_sub(usize::MIN, 1)).unwrap_err();

	catch_unwind(|| Integral::strict_sub(i8::MIN, 1)).unwrap_err();
	catch_unwind(|| Integral::strict_sub(i16::MIN, 1)).unwrap_err();
	catch_unwind(|| Integral::strict_sub(i32::MIN, 1)).unwrap_err();
	catch_unwind(|| Integral::strict_sub(i64::MIN, 1)).unwrap_err();
	catch_unwind(|| Integral::strict_sub(i128::MIN, 1)).unwrap_err();
	catch_unwind(|| Integral::strict_sub(isize::MIN, 1)).unwrap_err();
}

#[test]
fn test_unbounded_shl() {
	assert_eq!(Integral::unbounded_shl(1_u128,   0),                           1);
	assert_eq!(Integral::unbounded_shl(1_u128,   1),                           2);
	assert_eq!(Integral::unbounded_shl(1_u128,   2),                           4);
	assert_eq!(Integral::unbounded_shl(1_u128,   4),                          16);
	assert_eq!(Integral::unbounded_shl(1_u128,   8),                         256);
	assert_eq!(Integral::unbounded_shl(1_u128,  16),                      65_536);
	assert_eq!(Integral::unbounded_shl(1_u128,  32),               4_294_967_296);
	assert_eq!(Integral::unbounded_shl(1_u128,  64),  18_446_744_073_709_551_616);
	assert_eq!(Integral::unbounded_shl(1_u128, 128),                           0);
}

#[test]
fn test_unbounded_shr() {
	assert_eq!(Integral::unbounded_shr(u128::MAX,   0), 340_282_366_920_938_463_463_374_607_431_768_211_455);
	assert_eq!(Integral::unbounded_shr(u128::MAX,   1), 170_141_183_460_469_231_731_687_303_715_884_105_727);
	assert_eq!(Integral::unbounded_shr(u128::MAX,   2),  85_070_591_730_234_615_865_843_651_857_942_052_863);
	assert_eq!(Integral::unbounded_shr(u128::MAX,   4),  21_267_647_932_558_653_966_460_912_964_485_513_215);
	assert_eq!(Integral::unbounded_shr(u128::MAX,   8),   1_329_227_995_784_915_872_903_807_060_280_344_575);
	assert_eq!(Integral::unbounded_shr(u128::MAX,  16),       5_192_296_858_534_827_628_530_496_329_220_095);
	assert_eq!(Integral::unbounded_shr(u128::MAX,  32),              79_228_162_514_264_337_593_543_950_335);
	assert_eq!(Integral::unbounded_shr(u128::MAX,  64),                          18_446_744_073_709_551_615);
	assert_eq!(Integral::unbounded_shr(u128::MAX, 128),                                                   0);

	assert_eq!(Integral::unbounded_shr(i128::MAX,   0), 170_141_183_460_469_231_731_687_303_715_884_105_727);
	assert_eq!(Integral::unbounded_shr(i128::MAX,   1),  85_070_591_730_234_615_865_843_651_857_942_052_863);
	assert_eq!(Integral::unbounded_shr(i128::MAX,   2),  42_535_295_865_117_307_932_921_825_928_971_026_431);
	assert_eq!(Integral::unbounded_shr(i128::MAX,   4),  10_633_823_966_279_326_983_230_456_482_242_756_607);
	assert_eq!(Integral::unbounded_shr(i128::MAX,   8),     664_613_997_892_457_936_451_903_530_140_172_287);
	assert_eq!(Integral::unbounded_shr(i128::MAX,  16),       2_596_148_429_267_413_814_265_248_164_610_047);
	assert_eq!(Integral::unbounded_shr(i128::MAX,  32),              39_614_081_257_132_168_796_771_975_167);
	assert_eq!(Integral::unbounded_shr(i128::MAX,  64),                           9_223_372_036_854_775_807);
	assert_eq!(Integral::unbounded_shr(i128::MAX, 128),                                                   0);
}