int_interval/

i8.rs

use crate::res::{OneTwo, ZeroOneTwo};

#[cfg(test)]
mod between_tests;
#[cfg(test)]
mod convex_hull_tests;
#[cfg(test)]
mod difference_tests;
#[cfg(test)]
mod intersection_tests;
#[cfg(test)]
mod minkowski_tests;
#[cfg(test)]
mod symmetric_difference_tests;
#[cfg(test)]
mod union_tests;

#[derive(Copy, Clone, Debug, Eq, PartialEq, Hash)]
pub struct I8CO {
    start: i8,
    end_excl: i8,
}

// ------------------------------------------------------------
// low-level api: construction / accessors / predicates
// ------------------------------------------------------------
mod construction_accessors_predicates {

    use super::*;

    impl I8CO {
        #[inline]
        pub const fn try_new(start: i8, end_excl: i8) -> Option<Self> {
            if start < end_excl {
                Some(Self { start, end_excl })
            } else {
                None
            }
        }

        #[inline]
        pub(super) const fn new_unchecked(start: i8, end_excl: i8) -> Self {
            debug_assert!(start < end_excl);
            Self { start, end_excl }
        }

        #[inline]
        pub const fn start(self) -> i8 {
            self.start
        }

        #[inline]
        pub const fn end_excl(self) -> i8 {
            self.end_excl
        }

        #[inline]
        pub const fn end_incl(self) -> i8 {
            // i8_low_bound =< start < end_excl
            self.end_excl - 1
        }

        #[inline]
        pub const fn len(self) -> u8 {
            (self.end_excl - self.start) as u8
        }

        #[inline]
        pub const fn contains(self, x: i8) -> bool {
            self.start <= x && x < self.end_excl
        }

        #[inline]
        pub const fn iter(self) -> core::ops::Range<i8> {
            self.start..self.end_excl
        }

        #[inline]
        pub const fn intersects(self, other: Self) -> bool {
            !(self.end_excl <= other.start || other.end_excl <= self.start)
        }

        #[inline]
        pub const fn is_adjacent(self, other: Self) -> bool {
            self.end_excl == other.start || other.end_excl == self.start
        }

        #[inline]
        pub const fn is_contiguous_with(self, other: Self) -> bool {
            self.intersects(other) || self.is_adjacent(other)
        }
    }
}
// ------------------------------------------------------------
// interval algebra api: intersection / convex_hull / between / union / difference / symmetric_difference
// ------------------------------------------------------------

mod interval_algebra {

    use super::*;

    impl I8CO {
        /// Returns the intersection of two intervals.
        ///
        /// If the intervals do not overlap, returns `None`.
        #[inline]
        pub const fn intersection(self, other: Self) -> Option<Self> {
            let start = if self.start >= other.start {
                self.start
            } else {
                other.start
            };

            let end_excl = if self.end_excl <= other.end_excl {
                self.end_excl
            } else {
                other.end_excl
            };

            Self::try_new(start, end_excl)
        }

        /// Returns the convex hull (smallest interval containing both) of two intervals.
        ///
        /// Always returns a valid `I8CO`.
        #[inline]
        pub const fn convex_hull(self, other: Self) -> Self {
            let start = if self.start <= other.start {
                self.start
            } else {
                other.start
            };

            let end_excl = if self.end_excl >= other.end_excl {
                self.end_excl
            } else {
                other.end_excl
            };

            Self { start, end_excl }
        }

        /// Returns the interval strictly between two intervals.
        ///
        /// If the intervals are contiguous or overlap, returns `None`.
        #[inline]
        pub const fn between(self, other: Self) -> Option<Self> {
            let (left, right) = if self.start <= other.start {
                (self, other)
            } else {
                (other, self)
            };

            Self::try_new(left.end_excl, right.start)
        }

        /// Returns the union of two intervals.
        ///
        /// - If intervals are contiguous or overlapping, returns `One` containing the merged interval.
        /// - Otherwise, returns `Two` containing both intervals in ascending order.
        #[inline]
        pub const fn union(self, other: Self) -> OneTwo<Self> {
            if self.is_contiguous_with(other) {
                OneTwo::One(self.convex_hull(other))
            } else if self.start <= other.start {
                OneTwo::Two(self, other)
            } else {
                OneTwo::Two(other, self)
            }
        }

        /// Returns the difference of two intervals (self - other).
        ///
        /// - If no overlap, returns `One(self)`.
        /// - If partial overlap, returns `One` or `Two` depending on remaining segments.
        /// - If fully contained, returns `Zero`.
        #[inline]
        pub const fn difference(self, other: Self) -> ZeroOneTwo<Self> {
            match self.intersection(other) {
                None => ZeroOneTwo::One(self),
                Some(inter) => {
                    let left = Self::try_new(self.start, inter.start);
                    let right = Self::try_new(inter.end_excl, self.end_excl);

                    match (left, right) {
                        (None, None) => ZeroOneTwo::Zero,
                        (Some(x), None) | (None, Some(x)) => ZeroOneTwo::One(x),
                        (Some(x), Some(y)) => ZeroOneTwo::Two(x, y),
                    }
                }
            }
        }

        /// Returns the symmetric difference of two intervals.
        ///
        /// Equivalent to `(self - other) ∪ (other - self)`.
        /// - If intervals do not overlap, returns `Two(self, other)` in order.
        /// - If intervals partially overlap, returns remaining non-overlapping segments as `One` or `Two`.
        #[inline]
        pub const fn symmetric_difference(self, other: Self) -> ZeroOneTwo<Self> {
            match self.intersection(other) {
                None => {
                    if self.start <= other.start {
                        ZeroOneTwo::Two(self, other)
                    } else {
                        ZeroOneTwo::Two(other, self)
                    }
                }
                Some(inter) => {
                    let hull = self.convex_hull(other);
                    let left = Self::try_new(hull.start, inter.start);
                    let right = Self::try_new(inter.end_excl, hull.end_excl);

                    match (left, right) {
                        (None, None) => ZeroOneTwo::Zero,
                        (Some(x), None) | (None, Some(x)) => ZeroOneTwo::One(x),
                        (Some(x), Some(y)) => ZeroOneTwo::Two(x, y),
                    }
                }
            }
        }
    }
}

// ------------------------------------------------------------
// Module: Minkowski arithmetic for I8CO
// Provides checked Minkowski operations for intervals
// ------------------------------------------------------------

pub mod minkowski {
    use super::I8CO;

    // --------------------------------------------------------
    // Interval-to-interval Minkowski operations
    // --------------------------------------------------------
    impl I8CO {
        /// Minkowski addition: [a_start, a_end) + [b_start, b_end)
        #[inline]
        pub const fn minkowski_add(self, other: Self) -> Option<Self> {
            match self.start.checked_add(other.start) {
                Some(start) => match self.end_incl().checked_add(other.end_incl()) {
                    Some(end_incl) => match end_incl.checked_add(1) {
                        Some(end_excl) => Some(Self::new_unchecked(start, end_excl)),
                        None => None,
                    },
                    None => None,
                },
                None => None,
            }
        }

        /// Minkowski subtraction: [a_start, a_end) - [b_start, b_end)
        #[inline]
        pub const fn minkowski_sub(self, other: Self) -> Option<Self> {
            match self.start.checked_sub(other.end_incl()) {
                Some(start) => match self.end_incl().checked_sub(other.start) {
                    Some(end_incl) => match end_incl.checked_add(1) {
                        Some(end_excl) => Some(Self::new_unchecked(start, end_excl)),
                        None => None,
                    },
                    None => None,
                },
                None => None,
            }
        }

        /// Minkowski multiplication: [a_start, a_end) * [b_start, b_end)
        #[inline]
        pub const fn minkowski_mul(self, other: Self) -> Option<Self> {
            let a = self.start;
            let b = self.end_incl();
            let c = other.start;
            let d = other.end_incl();

            match a.checked_mul(c) {
                Some(p1) => match a.checked_mul(d) {
                    Some(p2) => match b.checked_mul(c) {
                        Some(p3) => match b.checked_mul(d) {
                            Some(p4) => {
                                let (min1, max1) = if p1 < p2 { (p1, p2) } else { (p2, p1) };
                                let (min2, max2) = if p3 < p4 { (p3, p4) } else { (p4, p3) };
                                let min = if min1 < min2 { min1 } else { min2 };
                                let max = if max1 > max2 { max1 } else { max2 };
                                match max.checked_add(1) {
                                    Some(end_excl) => Some(Self::new_unchecked(min, end_excl)),
                                    None => None,
                                }
                            }
                            None => None,
                        },
                        None => None,
                    },
                    None => None,
                },
                None => None,
            }
        }

        /// Minkowski division: [a_start, a_end) / [b_start, b_end)
        #[inline]
        pub const fn minkowski_div(self, other: Self) -> Option<Self> {
            if other.start <= 0 && other.end_incl() >= 0 {
                return None; // 避免除零
            }

            let a = self.start;
            let b = self.end_incl();
            let c = other.start;
            let d = other.end_incl();

            match a.checked_div(c) {
                Some(p1) => match a.checked_div(d) {
                    Some(p2) => match b.checked_div(c) {
                        Some(p3) => match b.checked_div(d) {
                            Some(p4) => {
                                let (min1, max1) = if p1 < p2 { (p1, p2) } else { (p2, p1) };
                                let (min2, max2) = if p3 < p4 { (p3, p4) } else { (p4, p3) };
                                let min = if min1 < min2 { min1 } else { min2 };
                                let max = if max1 > max2 { max1 } else { max2 };
                                match max.checked_add(1) {
                                    Some(end_excl) => Some(Self::new_unchecked(min, end_excl)),
                                    None => None,
                                }
                            }
                            None => None,
                        },
                        None => None,
                    },
                    None => None,
                },
                None => None,
            }
        }
    }

    // --------------------------------------------------------
    // Interval-to-scalar Minkowski operations
    // --------------------------------------------------------
    impl I8CO {
        /// Add a scalar to an interval: [start, end) + n
        #[inline]
        pub const fn minkowski_add_n(self, n: i8) -> Option<Self> {
            match self.start.checked_add(n) {
                Some(start) => match self.end_excl.checked_add(n) {
                    Some(end_excl) => Some(Self::new_unchecked(start, end_excl)),
                    None => None,
                },
                None => None,
            }
        }

        /// Subtract a scalar from an interval: [start, end) - n
        #[inline]
        pub const fn minkowski_sub_n(self, n: i8) -> Option<Self> {
            match self.start.checked_sub(n) {
                Some(start) => match self.end_excl.checked_sub(n) {
                    Some(end_excl) => Some(Self::new_unchecked(start, end_excl)),
                    None => None,
                },
                None => None,
            }
        }

        /// Multiply an interval by a scalar: [start, end) * n
        #[inline]
        pub const fn minkowski_mul_n(self, n: i8) -> Option<Self> {
            match self.start.checked_mul(n) {
                Some(a) => match self.end_incl().checked_mul(n) {
                    Some(b) => {
                        let (min, max) = match a < b {
                            true => (a, b),
                            false => (b, a),
                        };
                        match max.checked_add(1) {
                            Some(end_excl) => Some(Self::new_unchecked(min, end_excl)),
                            None => None,
                        }
                    }
                    None => None,
                },
                None => None,
            }
        }

        /// Divide an interval by a scalar: [start, end) / n
        #[inline]
        pub const fn minkowski_div_n(self, n: i8) -> Option<Self> {
            match n {
                0 => None, // 避免除零
                _ => match self.start.checked_div(n) {
                    Some(a) => match self.end_incl().checked_div(n) {
                        Some(b) => {
                            let (min, max) = match a < b {
                                true => (a, b),
                                false => (b, a),
                            };
                            match max.checked_add(1) {
                                Some(end_excl) => Some(Self::new_unchecked(min, end_excl)),
                                None => None,
                            }
                        }
                        None => None,
                    },
                    None => None,
                },
            }
        }
    }
}