vyre_std/arith/
signed.rs

1#[must_use]
2#[inline]
3pub fn min_i8(a: i8, b: i8) -> i8 {
4    if a < b {
5        a
6    } else {
7        b
8    }
9}
10/// Minimum of two `i16` values.
11#[must_use]
12#[inline]
13pub fn min_i16(a: i16, b: i16) -> i16 {
14    if a < b {
15        a
16    } else {
17        b
18    }
19}
20/// Minimum of two `i32` values.
21#[must_use]
22#[inline]
23pub fn min_i32(a: i32, b: i32) -> i32 {
24    if a < b {
25        a
26    } else {
27        b
28    }
29}
30/// Minimum of two `i64` values.
31#[must_use]
32#[inline]
33pub fn min_i64(a: i64, b: i64) -> i64 {
34    if a < b {
35        a
36    } else {
37        b
38    }
39}
40
41/// Maximum of two `i8` values.
42#[must_use]
43#[inline]
44pub fn max_i8(a: i8, b: i8) -> i8 {
45    if a > b {
46        a
47    } else {
48        b
49    }
50}
51/// Maximum of two `i16` values.
52#[must_use]
53#[inline]
54pub fn max_i16(a: i16, b: i16) -> i16 {
55    if a > b {
56        a
57    } else {
58        b
59    }
60}
61/// Maximum of two `i32` values.
62#[must_use]
63#[inline]
64pub fn max_i32(a: i32, b: i32) -> i32 {
65    if a > b {
66        a
67    } else {
68        b
69    }
70}
71/// Maximum of two `i64` values.
72#[must_use]
73#[inline]
74pub fn max_i64(a: i64, b: i64) -> i64 {
75    if a > b {
76        a
77    } else {
78        b
79    }
80}
81
82/// Clamp `x` to the inclusive range `[lo, hi]` for `i8`.
83///
84/// # Panics
85/// Panics if `lo > hi`.
86#[must_use]
87#[inline]
88pub fn clamp_i8(x: i8, lo: i8, hi: i8) -> i8 {
89    assert!(lo <= hi, "Fix: clamp_i8 called with lo > hi");
90    min_i8(max_i8(x, lo), hi)
91}
92/// Clamp `x` to the inclusive range `[lo, hi]` for `i16`.
93///
94/// # Panics
95/// Panics if `lo > hi`.
96#[must_use]
97#[inline]
98pub fn clamp_i16(x: i16, lo: i16, hi: i16) -> i16 {
99    assert!(lo <= hi, "Fix: clamp_i16 called with lo > hi");
100    min_i16(max_i16(x, lo), hi)
101}
102/// Clamp `x` to the inclusive range `[lo, hi]` for `i32`.
103///
104/// # Panics
105/// Panics if `lo > hi`.
106#[must_use]
107#[inline]
108pub fn clamp_i32(x: i32, lo: i32, hi: i32) -> i32 {
109    assert!(lo <= hi, "Fix: clamp_i32 called with lo > hi");
110    min_i32(max_i32(x, lo), hi)
111}
112/// Clamp `x` to the inclusive range `[lo, hi]` for `i64`.
113///
114/// # Panics
115/// Panics if `lo > hi`.
116#[must_use]
117#[inline]
118pub fn clamp_i64(x: i64, lo: i64, hi: i64) -> i64 {
119    assert!(lo <= hi, "Fix: clamp_i64 called with lo > hi");
120    min_i64(max_i64(x, lo), hi)
121}
122
123/// Overflow-safe midpoint for `i8` (rounds toward negative infinity).
124///
125/// Uses `i16` widening so `a + b` cannot overflow even at `i8::MIN`.
126#[must_use]
127#[inline]
128pub fn midpoint_i8(a: i8, b: i8) -> i8 {
129    ((i16::from(a) + i16::from(b)).div_euclid(2)) as i8
130}
131/// Overflow-safe midpoint for `i16`.
132#[must_use]
133#[inline]
134pub fn midpoint_i16(a: i16, b: i16) -> i16 {
135    ((i32::from(a) + i32::from(b)).div_euclid(2)) as i16
136}
137/// Overflow-safe midpoint for `i32`.
138#[must_use]
139#[inline]
140pub fn midpoint_i32(a: i32, b: i32) -> i32 {
141    ((i64::from(a) + i64::from(b)).div_euclid(2)) as i32
142}
143/// Overflow-safe midpoint for `i64`.
144#[must_use]
145#[inline]
146pub fn midpoint_i64(a: i64, b: i64) -> i64 {
147    ((i128::from(a) + i128::from(b)).div_euclid(2)) as i64
148}
149
150/// Absolute difference between two `i8` values, returned as `u8`.
151///
152/// Widens through `i16` so `abs_diff_i8(i8::MIN, i8::MAX)` returns `255`
153/// without overflowing.
154#[must_use]
155#[inline]
156pub fn abs_diff_i8(a: i8, b: i8) -> u8 {
157    (i16::from(a) - i16::from(b)).unsigned_abs() as u8
158}
159/// Absolute difference between two `i16` values, returned as `u16`.
160#[must_use]
161#[inline]
162pub fn abs_diff_i16(a: i16, b: i16) -> u16 {
163    (i32::from(a) - i32::from(b)).unsigned_abs() as u16
164}
165/// Absolute difference between two `i32` values, returned as `u32`.
166#[must_use]
167#[inline]
168pub fn abs_diff_i32(a: i32, b: i32) -> u32 {
169    (i64::from(a) - i64::from(b)).unsigned_abs() as u32
170}
171/// Absolute difference between two `i64` values, returned as `u64`.
172#[must_use]
173#[inline]
174pub fn abs_diff_i64(a: i64, b: i64) -> u64 {
175    (i128::from(a) - i128::from(b)).unsigned_abs() as u64
176}
vyre_std/arith/signed.rs

vyre_std/arith/
signed.rs
