vyre-std 0.1.0

/// Minimum of two `u8` values.
#[must_use]
#[inline]
pub fn min_u8(a: u8, b: u8) -> u8 {
    if a < b {
        a
    } else {
        b
    }
}
/// Minimum of two `u16` values.
#[must_use]
#[inline]
pub fn min_u16(a: u16, b: u16) -> u16 {
    if a < b {
        a
    } else {
        b
    }
}
/// Minimum of two `u32` values.
#[must_use]
#[inline]
pub fn min_u32(a: u32, b: u32) -> u32 {
    if a < b {
        a
    } else {
        b
    }
}
/// Minimum of two `u64` values.
#[must_use]
#[inline]
pub fn min_u64(a: u64, b: u64) -> u64 {
    if a < b {
        a
    } else {
        b
    }
}

/// Maximum of two `u8` values.
#[must_use]
#[inline]
pub fn max_u8(a: u8, b: u8) -> u8 {
    if a > b {
        a
    } else {
        b
    }
}
/// Maximum of two `u16` values.
#[must_use]
#[inline]
pub fn max_u16(a: u16, b: u16) -> u16 {
    if a > b {
        a
    } else {
        b
    }
}
/// Maximum of two `u32` values.
#[must_use]
#[inline]
pub fn max_u32(a: u32, b: u32) -> u32 {
    if a > b {
        a
    } else {
        b
    }
}
/// Maximum of two `u64` values.
#[must_use]
#[inline]
pub fn max_u64(a: u64, b: u64) -> u64 {
    if a > b {
        a
    } else {
        b
    }
}

/// Clamp `x` to the inclusive range `[lo, hi]` for `u32`.
///
/// # Panics
/// Panics (in debug **and** release) if `lo > hi`. Matches stdlib
/// `u32::clamp` semantics — a silently-returned wrong answer on inverted
/// bounds is a latent bug at internet scale.
#[must_use]
#[inline]
pub fn clamp_u32(x: u32, lo: u32, hi: u32) -> u32 {
    assert!(lo <= hi, "Fix: clamp_u32 called with lo > hi");
    min_u32(max_u32(x, lo), hi)
}
/// Clamp `x` to the inclusive range `[lo, hi]` for `u64`.
///
/// # Panics
/// Panics if `lo > hi`.
#[must_use]
#[inline]
pub fn clamp_u64(x: u64, lo: u64, hi: u64) -> u64 {
    assert!(lo <= hi, "Fix: clamp_u64 called with lo > hi");
    min_u64(max_u64(x, lo), hi)
}
/// Clamp `x` to the inclusive range `[lo, hi]` for `u16`.
///
/// # Panics
/// Panics if `lo > hi`.
#[must_use]
#[inline]
pub fn clamp_u16(x: u16, lo: u16, hi: u16) -> u16 {
    assert!(lo <= hi, "Fix: clamp_u16 called with lo > hi");
    min_u16(max_u16(x, lo), hi)
}
/// Clamp `x` to the inclusive range `[lo, hi]` for `u8`.
///
/// # Panics
/// Panics if `lo > hi`.
#[must_use]
#[inline]
pub fn clamp_u8(x: u8, lo: u8, hi: u8) -> u8 {
    assert!(lo <= hi, "Fix: clamp_u8 called with lo > hi");
    min_u8(max_u8(x, lo), hi)
}

/// Overflow-safe midpoint for `u32`: `a/2 + b/2 + (a & b & 1)`.
#[must_use]
#[inline]
pub fn midpoint_u32(a: u32, b: u32) -> u32 {
    (a & b).wrapping_add((a ^ b) >> 1)
}
/// Overflow-safe midpoint for `u64`.
#[must_use]
#[inline]
pub fn midpoint_u64(a: u64, b: u64) -> u64 {
    (a & b).wrapping_add((a ^ b) >> 1)
}
/// Overflow-safe midpoint for `u16`.
#[must_use]
#[inline]
pub fn midpoint_u16(a: u16, b: u16) -> u16 {
    (a & b).wrapping_add((a ^ b) >> 1)
}
/// Overflow-safe midpoint for `u8`.
#[must_use]
#[inline]
pub fn midpoint_u8(a: u8, b: u8) -> u8 {
    (a & b).wrapping_add((a ^ b) >> 1)
}

/// Absolute difference between two `u8` values.
#[must_use]
#[inline]
pub fn abs_diff_u8(a: u8, b: u8) -> u8 {
    a.abs_diff(b)
}
/// Absolute difference between two `u16` values.
#[must_use]
#[inline]
pub fn abs_diff_u16(a: u16, b: u16) -> u16 {
    a.abs_diff(b)
}
/// Absolute difference between two `u32` values.
#[must_use]
#[inline]
pub fn abs_diff_u32(a: u32, b: u32) -> u32 {
    a.abs_diff(b)
}
/// Absolute difference between two `u64` values.
#[must_use]
#[inline]
pub fn abs_diff_u64(a: u64, b: u64) -> u64 {
    a.abs_diff(b)
}

// --- division helpers (unsigned) ----------------------------------------

/// Ceiling division for unsigned `u32`.
///
/// # Panics
/// Panics if `denom == 0`.
#[must_use]
#[inline]
pub fn div_ceil_u32(numer: u32, denom: u32) -> u32 {
    assert!(denom != 0, "Fix: div_ceil called with zero denominator");
    numer.div_ceil(denom)
}
/// Ceiling division for unsigned `u64`.
#[must_use]
#[inline]
pub fn div_ceil_u64(numer: u64, denom: u64) -> u64 {
    assert!(denom != 0, "Fix: div_ceil called with zero denominator");
    numer.div_ceil(denom)
}
/// Floor division for unsigned `u32`.
#[must_use]
#[inline]
pub fn div_floor_u32(numer: u32, denom: u32) -> u32 {
    assert!(denom != 0, "Fix: div_floor called with zero denominator");
    numer / denom
}
/// Floor division for unsigned `u64`.
#[must_use]
#[inline]
pub fn div_floor_u64(numer: u64, denom: u64) -> u64 {
    assert!(denom != 0, "Fix: div_floor called with zero denominator");
    numer / denom
}
/// Round-to-nearest-half-up division for `u8`.
///
/// Uses a `u16` intermediate so `(numer + denom/2)` cannot overflow even
/// at `numer == u8::MAX`.
///
/// # Panics
/// Panics if `denom == 0`.
#[must_use]
#[inline]
pub fn div_round_u8(numer: u8, denom: u8) -> u8 {
    assert!(denom != 0, "Fix: div_round_u8 called with zero denominator");
    let n = numer as u16;
    let d = denom as u16;
    ((n + d / 2) / d) as u8
}
/// Round-to-nearest-half-up division for `u16`.
///
/// # Panics
/// Panics if `denom == 0`.
#[must_use]
#[inline]
pub fn div_round_u16(numer: u16, denom: u16) -> u16 {
    assert!(
        denom != 0,
        "Fix: div_round_u16 called with zero denominator"
    );
    let n = numer as u32;
    let d = denom as u32;
    ((n + d / 2) / d) as u16
}
/// Round-to-nearest-half-up division for `u32`.
///
/// Uses a `u64` intermediate to avoid the overflow `(numer + denom/2)`
/// suffered when `numer` is near `u32::MAX` — a silent wrong result that
/// becomes a correctness bug at any scale.
///
/// # Panics
/// Panics if `denom == 0`.
#[must_use]
#[inline]
pub fn div_round_u32(numer: u32, denom: u32) -> u32 {
    assert!(
        denom != 0,
        "Fix: div_round_u32 called with zero denominator"
    );
    let n = u64::from(numer);
    let d = u64::from(denom);
    ((n + d / 2) / d) as u32
}
/// Round-to-nearest-half-up division for `u64`.
///
/// Uses a `u128` intermediate to avoid `(numer + denom/2)` overflow near
/// `u64::MAX`.
///
/// # Panics
/// Panics if `denom == 0`.
#[must_use]
#[inline]
pub fn div_round_u64(numer: u64, denom: u64) -> u64 {
    assert!(
        denom != 0,
        "Fix: div_round_u64 called with zero denominator"
    );
    let n = u128::from(numer);
    let d = u128::from(denom);
    ((n + d / 2) / d) as u64
}

// --- min / max / clamp / abs_diff / midpoint (signed) -------------------