grid1d 0.5.1

#![deny(rustdoc::broken_intra_doc_links)]

//! Mathematical bounds for 1D grid construction and interval arithmetic.
//!
//! This module provides strongly-typed boundary representations that encode inclusion/exclusion
//! semantics at the type level. These bounds are fundamental building blocks for constructing
//! mathematically correct intervals and grids where boundary behavior matters.
//!
//! ## Core Design Philosophy
//!
//! ### Type-Safe Boundary Semantics
//!
//! Rather than using raw scalar values with separate boolean flags, this module encodes
//! boundary behavior directly in the type system:
//!
//! ```rust
//! use grid1d::bounds::*;
//! use try_create::New;
//!
//! // These are different types that cannot be confused:
//! let inclusive_lower = LowerBoundClosed::new(0.0);  // [0
//! let exclusive_lower = LowerBoundOpen::new(0.0);    // (0
//! let inclusive_upper = UpperBoundClosed::new(1.0);  // 1]
//! let exclusive_upper = UpperBoundOpen::new(1.0);    // 1)
//!
//! // Compile-time prevention of boundary confusion:
//! // assert_eq!(inclusive_lower, exclusive_lower); // ← Compilation error!
//! ```
//!
//! ## Module Organization
//!
//! The bounds system is split across four files to aid navigation:
//!
//! | Module | Contents |
//! |--------|----------|
//! | [`bounds`](crate::bounds) *(this file)* | [`IntervalBound<T, Side, Type>`] and ready-made type aliases (`LowerBoundClosed`, `UpperBoundOpen`, …) |
//! | [`bounds::markers`](crate::bounds::markers) | Zero-sized marker types: [`Lower`], [`Upper`], [`Open`], [`Closed`] |
//! | [`bounds::runtime`](crate::bounds::runtime) | [`IntervalBoundRuntime`], [`LowerBoundRuntime`], [`UpperBoundRuntime`] |
//! | [`bounds::traits`](crate::bounds::traits) | All trait definitions: [`BoundSide`], [`BoundType`], [`BoundTypeChecks`], [`BoundSideChecks`], [`BoundChecks`], [`ValueWithinBound`], [`BoundTypeConversion`], [`BoundSideConversion`] |
//!
//! All public items from the submodules are re-exported at this level, so
//! `use grid1d::bounds::*;` is sufficient for day-to-day use.
//!
//! ## Architecture Summary
//!
//! The bounds system consists of four key components (see also [Module Organization](#module-organization) below):
//!
//! ### 1. Marker Traits and Types ([`bounds::markers`](crate::bounds::markers), [`bounds::traits`](crate::bounds::traits))
//! - [`BoundSide`]: [`Lower`] vs [`Upper`] marker trait and types
//! - [`BoundType`]: [`Open`] vs [`Closed`] marker trait and types
//! - Enables compile-time distinction between boundary semantics
//!
//! ### 2. Core Bound Type (this module)
//! - [`IntervalBound<RealType, Side, Type>`]: Generic bound representation
//! - Phantom types encode boundary semantics in the type system
//! - Zero-cost abstraction over scalar values
//!
//! ### 3. Type Aliases
//! - [`LowerBoundOpen`], [`LowerBoundClosed`]: Lower boundary types
//! - [`UpperBoundOpen`], [`UpperBoundClosed`]: Upper boundary types
//! - Provide convenient, intention-revealing names
//!
//! ### 4. Conversion Traits
//! - [`BoundTypeConversion`]: Convert between open/closed bounds
//! - [`BoundSideConversion`]: Convert between lower/upper bounds
//! - Enable flexible bound manipulation while maintaining type safety
//!
//! ## Mathematical Foundation
//!
//! The bound types maintain strict mathematical ordering that reflects their semantic meaning:
//!
//! | Comparison | Mathematical Meaning | Code Example |
//! |------------|---------------------|--------------|
//! | `[a < (a` | Closed bound is "tighter" than open | `LowerBoundClosed::new(5.0) < LowerBoundOpen::new(5.0)` |
//! | `b) < b]` | Open bound is "smaller" than closed | `UpperBoundOpen::new(5.0) < UpperBoundClosed::new(5.0)` |
//!
//! This ordering ensures that interval intersections, unions, and containment checks
//! produce mathematically correct results.
//!
//! ## Generic Over Any [`num_valid::RealScalar`] Type
//!
//! All bound types work seamlessly with any scalar type implementing [`num_valid::RealScalar`]:
//!
//! | Scalar Type | Performance | Validation | Best For |
//! |-------------|-------------|------------|----------|
//! | [`f64`] | ⚡⚡⚡ Maximum | ❌ None | Trusted input, maximum speed |
//! | [`RealNative64StrictFiniteInDebug`](num_valid::RealNative64StrictFiniteInDebug) | ⚡⚡⚡ **Same as f64** | ✅ **Debug only** | **Recommended for most uses** |
//! | [`RealNative64StrictFinite`](num_valid::RealNative64StrictFinite) | ⚡⚡ Small overhead | ✅ Always | Safety-critical applications |
//! | `RealRugStrictFinite<N>` | ⚡ Precision-dependent | ✅ Always | Arbitrary precision needs (available from the [num-valid](https://crates.io/crates/num-valid) crate when compiled with `--features=rug`)|
//!
//! ## Performance Characteristics
//!
//! ### Zero-Cost Abstractions
//! - **Memory**: Each bound is a single scalar value (8 bytes for f64)
//! - **Operations**: All bound operations compile to direct scalar operations
//! - **Validation**: Debug-only by default, zero overhead in release builds
//!
//! ### Operation Complexity
//! | Operation | Time | Space | Notes |
//! |-----------|------|-------|-------|
//! | Construction | O(1) | O(1) | Debug validation only |
//! | Comparison | O(1) | O(1) | Direct scalar comparison |
//! | Value access | O(1) | O(1) | Zero-cost via `AsRef` |
//!
//! ## Use Cases and Applications
//!
//! ### Grid Construction
//! ```rust
//! use grid1d::{bounds::*, intervals::*};
//! use try_create::New;
//!
//! // Define grid boundaries with precise semantics using actual interval types
//! struct GridRange {
//!     start: LowerBoundClosed<f64>,  // Include the starting point
//!     end: UpperBoundOpen<f64>,      // Exclude the ending point
//! }
//!
//! impl GridRange {
//!     fn new(start: f64, end: f64) -> Self {
//!         Self {
//!             start: LowerBoundClosed::new(start),
//!             end: UpperBoundOpen::new(end),
//!         }
//!     }
//!     
//!     fn to_interval(&self) -> IntervalLowerClosedUpperOpen<f64> {
//!         IntervalLowerClosedUpperOpen::new(*self.start.as_ref(), *self.end.as_ref())
//!     }
//!     
//!     fn contains(&self, point: f64) -> bool {
//!         self.to_interval().contains_point(&point)
//!     }
//! }
//!
//! let range = GridRange::new(0.0, 10.0);  // [0, 10)
//! assert!(range.contains(0.0));   // Start included
//! assert!(!range.contains(10.0)); // End excluded
//! ```
//!
//! ### Advanced Usage Patterns
//!
//! #### Constraint Composition
//! ```rust
//! use grid1d::bounds::*;
//! use try_create::New;
//!
//! // Combine multiple constraints
//! struct ConstraintSystem {
//!     lower_limit: LowerBoundClosed<f64>,
//!     upper_limit: UpperBoundOpen<f64>,
//! }
//!
//! impl ConstraintSystem {
//!     fn new(min_value: f64, max_value: f64) -> Self {
//!         Self {
//!             lower_limit: LowerBoundClosed::new(min_value),
//!             upper_limit: UpperBoundOpen::new(max_value),
//!         }
//!     }
//!     
//!     fn is_feasible(&self, value: f64) -> bool {
//!         self.lower_limit.value_within_bound(&value) && self.upper_limit.value_within_bound(&value)
//!     }
//! }
//! ```
//!
//! #### Generic Bound Processing
//! ```rust
//! use grid1d::bounds::*;
//! use num_valid::RealScalar;
//!
//! fn process_bound<T, S, B>(bound: &IntervalBound<T, S, B>) -> String
//! where
//!     T: RealScalar + std::fmt::Display,
//!     S: BoundSide,
//!     B: BoundType,
//! {
//!     format!(
//!         "{} bound: {} ({})",
//!         if bound.is_lower_bound() { "Lower" } else { "Upper" },
//!         bound.as_ref(),
//!         if bound.is_closed() { "inclusive" } else { "exclusive" }
//!     )
//! }
//! ```
//!
//! ## Error Handling and Validation
//!
//! ### Debug-Mode Validation
//! ```rust,ignore
//! use grid1d::bounds::*;
//! use try_create::New;
//!
//! // Valid construction
//! let bound = LowerBoundClosed::new(42.0);
//! assert_eq!(bound.as_ref(), &42.0);
//!
//! // Invalid values panic in debug mode only
//! #[cfg(debug_assertions)]
//! {
//!     std::panic::catch_unwind(|| {
//!         LowerBoundClosed::new(f64::NAN); // Panics in debug
//!     }).expect_err("Should panic on NaN");
//! }
//!
//! // In release mode, validation is skipped for performance
//! #[cfg(not(debug_assertions))]
//! {
//!     let _invalid = LowerBoundClosed::new(f64::NAN); // No panic in release
//! }
//! ```
//!
//! ## Best Practices
//!
//! ### Type Selection Guidelines
//! - **[`LowerBoundClosed`]**: Use for `x ≥ a` constraints → [`IntervalLowerClosedUpperUnbounded`](crate::intervals::IntervalLowerClosedUpperUnbounded), [`IntervalClosed`](crate::intervals::IntervalClosed)
//! - **[`LowerBoundOpen`]**: Use for `x > a` constraints → [`IntervalLowerOpenUpperUnbounded`](crate::intervals::IntervalLowerOpenUpperUnbounded), [`IntervalOpen`](crate::intervals::IntervalOpen)
//! - **[`UpperBoundClosed`]**: Use for `x ≤ b` constraints → [`IntervalLowerUnboundedUpperClosed`](crate::intervals::IntervalLowerUnboundedUpperClosed), [`IntervalClosed`](crate::intervals::IntervalClosed)
//! - **[`UpperBoundOpen`]**: Use for `x < b` constraints → [`IntervalLowerUnboundedUpperOpen`](crate::intervals::IntervalLowerUnboundedUpperOpen), [`IntervalOpen`](crate::intervals::IntervalOpen)
//!
//! ### Recommended Patterns
//! ```rust
//! use grid1d::{bounds::*, intervals::*};
//! use num_valid::RealNative64StrictFiniteInDebug;
//! use try_create::{IntoInner, New, TryNew};
//!
//! // Define type aliases for your application
//! type Real = RealNative64StrictFiniteInDebug;
//! type SafeLowerBound = LowerBoundClosed<Real>;
//! type StrictUpperBound = UpperBoundOpen<Real>;
//!
//! // Pattern: Safe construction with validation
//! fn create_safe_bounds(start: f64, end: f64) ->
//!     Result<(SafeLowerBound, StrictUpperBound), <Real as TryNew>::Error> {
//!     let start_val = Real::try_new(start)?;
//!     let end_val = Real::try_new(end)?;
//!     Ok((SafeLowerBound::new(start_val), StrictUpperBound::new(end_val)))
//! }
//!
//! // Pattern: Convert bounds to intervals
//! fn bounds_to_interval(
//!     lower: SafeLowerBound,
//!     upper: StrictUpperBound
//! ) -> IntervalLowerClosedUpperOpen<Real> {
//!     IntervalLowerClosedUpperOpen::new(
//!         lower.into_inner(),
//!         upper.into_inner()
//!     )
//! }
//! ```
//!
//! ## Performance Guarantees
//!
//! ### Zero-Cost Abstractions
//! - **Memory Layout**: Each bound is exactly one scalar value (e.g., 8 bytes for `f64`)
//! - **Runtime Cost**: All operations compile to direct scalar operations
//! - **Validation**: Debug assertions only, zero overhead in release builds
//! - **Monomorphization**: Generic code specializes to concrete scalar types

pub mod markers;
pub use markers::{Closed, Lower, Open, Upper};

pub mod runtime;
pub use runtime::{IntervalBoundRuntime, LowerBoundRuntime, UpperBoundRuntime};

pub mod traits;
pub use traits::{
    BoundChecks, BoundSide, BoundSideChecks, BoundSideConversion, BoundType, BoundTypeChecks,
    BoundTypeConversion, ValueWithinBound,
};

use derive_more::AsRef;
use duplicate::duplicate_item;
use num_valid::RealScalar;
use serde::{Deserialize, Serialize};
use std::{cmp::Ordering, fmt::Debug};
use try_create::{IntoInner, New};

//------------------------------------------------------------------------------------------------
impl<RealType: RealScalar, Type: BoundType> BoundSideConversion<RealType, Type>
    for IntervalBound<RealType, Lower, Type>
{
    #[inline(always)]
    fn into_lower(self) -> IntervalBound<RealType, Lower, Type> {
        self
    }

    #[inline(always)]
    fn into_upper(self) -> IntervalBound<RealType, Upper, Type> {
        // Implemented in terms of flip_bound_side() to avoid code duplication
        self.flip_bound_side()
    }
}

impl<RealType: RealScalar, Type: BoundType> BoundSideConversion<RealType, Type>
    for IntervalBound<RealType, Upper, Type>
{
    #[inline(always)]
    fn into_lower(self) -> IntervalBound<RealType, Lower, Type> {
        // Implemented in terms of flip_bound_side() to avoid code duplication
        self.flip_bound_side()
    }

    #[inline(always)]
    fn into_upper(self) -> IntervalBound<RealType, Upper, Type> {
        self
    }
}
//------------------------------------------------------------------------------------------------

//------------------------------------------------------------------------------------------------
/// Core interval boundary representation with compile-time semantics encoding.
///
/// [`IntervalBound<RealType, Side, Type>`] is the fundamental building block for all interval
/// boundaries in the grid1d library. It combines a scalar value with compile-time type
/// information that encodes both the boundary side (lower/upper) and inclusion semantics
/// (open/closed), providing mathematical correctness and zero-cost abstractions.
///
/// ## Design Philosophy
///
/// ### Type-Safe Boundary Semantics
///
/// Unlike traditional approaches that use boolean flags or runtime enums to indicate
/// boundary properties, [`IntervalBound`] encodes all semantic information in the type system:
///
/// ```rust
/// use grid1d::bounds::*;
/// use try_create::New;
///
/// // Type system prevents mixing incompatible boundaries
/// let lower_closed: LowerBoundClosed<f64> = IntervalBound::new(0.0);
/// let upper_open: UpperBoundOpen<f64> = IntervalBound::new(1.0);
///
/// // This would be a compile error:
/// // assert_eq!(lower_closed, upper_open); // Cannot compare different boundary types
/// ```
///
/// ### Zero-Cost Abstractions
///
/// The phantom types `Side` and `Type` have no runtime representation, allowing
/// the compiler to optimize boundary operations to direct scalar comparisons:
///
/// ```rust
/// use grid1d::bounds::*;
/// use try_create::New;
///
/// let bound = LowerBoundClosed::new(5.0);
/// // This compiles to a single comparison instruction:
/// let satisfies = bound.value_within_bound(&6.0); // 6.0 >= 5.0
/// ```
///
/// ## Type Parameters
///
/// ### `RealType: RealScalar`
///
/// The scalar type representing the boundary value. Must implement [`num_valid::RealScalar`]
/// for mathematical operations and validation:
///
/// ```rust
/// use grid1d::bounds::*;
/// use try_create::{New, TryNew};
/// use num_valid::{RealNative64StrictFiniteInDebug};
///
/// // Different scalar types supported
/// let f64_bound: LowerBoundClosed<f64> = IntervalBound::new(1.0);
/// let validated_bound: LowerBoundClosed<RealNative64StrictFiniteInDebug> =
///     IntervalBound::new(RealNative64StrictFiniteInDebug::try_new(1.0).unwrap());
/// ```
///
/// ### `Side: BoundSide`
///
/// Compile-time marker indicating whether this is a lower or upper boundary:
/// - [`Lower`]: Defines minimum constraints (`x ≥ value` or `x > value`)
/// - [`Upper`]: Defines maximum constraints (`x ≤ value` or `x < value`)
///
/// ### `Type: BoundType`
///
/// Compile-time marker indicating boundary inclusion semantics:
/// - [`Closed`]: Includes the boundary value in the constraint
/// - [`Open`]: Excludes the boundary value from the constraint
///
/// ## Mathematical Semantics
///
/// The combination of `Side` and `Type` parameters defines the mathematical constraint:
///
/// | Side | Type | Mathematical Constraint | Notation | Example |
/// |------|------|------------------------|----------|---------|
/// | [`Lower`] | [`Closed`] | `x ≥ bound_value` | `[a` | `x ≥ 5` |
/// | [`Lower`] | [`Open`] | `x > bound_value` | `(a` | `x > 5` |
/// | [`Upper`] | [`Closed`] | `x ≤ bound_value` | `b]` | `x ≤ 10` |
/// | [`Upper`] | [`Open`] | `x < bound_value` | `b)` | `x < 10` |
///
/// ## Core Operations
///
/// ### Construction and Value Access
///
/// ```rust
/// use grid1d::bounds::*;
/// use try_create::{New, IntoInner};
///
/// // Create a boundary
/// let bound = LowerBoundClosed::new(3.14);
///
/// // Access the value by reference
/// let value_ref: &f64 = bound.as_ref();
/// assert_eq!(*value_ref, 3.14);
///
/// // Extract the value (consuming the bound)
/// let value: f64 = bound.into_inner();
/// assert_eq!(value, 3.14);
/// ```
///
/// ### Constraint Testing
///
/// ```rust
/// use grid1d::bounds::*;
/// use try_create::New;
///
/// let lower_closed = LowerBoundClosed::new(5.0);  // x ≥ 5
/// let lower_open = LowerBoundOpen::new(5.0);      // x > 5
/// let upper_closed = UpperBoundClosed::new(10.0); // x ≤ 10
/// let upper_open = UpperBoundOpen::new(10.0);     // x < 10
///
/// // Test boundary values
/// assert!(lower_closed.value_within_bound(&5.0));   // 5 ≥ 5 → true
/// assert!(!lower_open.value_within_bound(&5.0));    // 5 > 5 → false
/// assert!(upper_closed.value_within_bound(&10.0));  // 10 ≤ 10 → true
/// assert!(!upper_open.value_within_bound(&10.0));   // 10 < 10 → false
///
/// // Test interior values
/// assert!(lower_closed.value_within_bound(&7.0));   // 7 ≥ 5 → true
/// assert!(lower_open.value_within_bound(&7.0));     // 7 > 5 → true
/// assert!(upper_closed.value_within_bound(&8.0));   // 8 ≤ 10 → true
/// assert!(upper_open.value_within_bound(&8.0));     // 8 < 10 → true
/// ```
///
/// ### Type Information Queries
///
/// ```rust
/// use grid1d::bounds::*;
/// use try_create::New;
///
/// let bound = LowerBoundClosed::new(0.0);
///
/// // Boundary inclusion semantics
/// assert!(bound.is_closed());
/// assert!(!bound.is_open());
/// assert!(bound.includes_boundary());
///
/// // Boundary side semantics
/// assert!(bound.is_lower_bound());
/// assert!(!bound.is_upper_bound());
/// ```
///
/// ## Transformation Operations
///
/// ### Type Conversion
///
/// ```rust
/// use grid1d::bounds::*;
/// use try_create::New;
///
/// let closed_bound = LowerBoundClosed::new(5.0);
///
/// // Convert to different boundary type (same side, different inclusion)
/// let open_bound: LowerBoundOpen<f64> = closed_bound.clone().with_bound_type();
/// assert_eq!(open_bound.as_ref(), closed_bound.as_ref()); // Same value
/// assert!(open_bound.is_open());  // Different inclusion semantics
///
/// // Create new bound with different value (same types)
/// let new_bound = closed_bound.with_value(10.0);
/// assert_eq!(new_bound.as_ref(), &10.0);
/// assert!(new_bound.is_closed()); // Same inclusion semantics
/// ```
///
/// ## Mathematical Ordering
///
/// Bounds are ordered by their values, providing intuitive mathematical ordering:
///
/// ```rust
/// use grid1d::bounds::*;
/// use try_create::New;
///
/// let bound_1 = LowerBoundClosed::new(1.0);
/// let bound_2 = LowerBoundClosed::new(2.0);
/// let bound_3 = LowerBoundClosed::new(3.0);
///
/// assert!(bound_1 < bound_2);
/// assert!(bound_2 < bound_3);
/// assert!(bound_1 < bound_3);
///
/// // Ordering respects mathematical semantics
/// use std::cmp::Ordering;
/// let ordering = bound_1.partial_cmp(&bound_2);
/// assert_eq!(ordering, Some(Ordering::Less));
/// ```
///
/// ## Generic Programming Support
///
/// ### Type-Parameterized Functions
///
/// ```rust
/// use grid1d::bounds::*;
/// use try_create::New;
///
/// fn create_symmetric_bounds<T, S, U>(center: T, radius: T) -> (IntervalBound<T, S, U>, IntervalBound<T, S, U>)
/// where
///     T: num_valid::RealScalar + std::ops::Sub<Output = T> + std::ops::Add<Output = T>,
///     S: BoundSide,
///     U: BoundType,
/// {
///     (
///         IntervalBound::new(center.clone() - radius.clone()),
///         IntervalBound::new(center + radius),
///     )
/// }
///
/// let (lower, upper) = create_symmetric_bounds::<_, Lower, Closed>(5.0, 2.0);
/// assert_eq!(*lower.as_ref(), 3.0);
/// assert_eq!(*upper.as_ref(), 7.0);
/// ```
///
/// ### Constraint Analysis
///
/// ```rust
/// use grid1d::bounds::*;
/// use try_create::New;
///
/// fn analyze_bounds<B: BoundChecks + AsRef<f64>>(bounds: &[B]) -> (f64, f64, usize, usize) {
///     let values: Vec<f64> = bounds.iter().map(|b| *b.as_ref()).collect();
///     let min_value = values.iter().fold(f64::INFINITY, |a, &b| a.min(b));
///     let max_value = values.iter().fold(f64::NEG_INFINITY, |a, &b| a.max(b));
///     
///     let (open_count, closed_count) = bounds.iter()
///         .fold((0, 0), |(open, closed), bound| {
///             if bound.is_open() { (open + 1, closed) } else { (open, closed + 1) }
///         });
///     
///     (min_value, max_value, open_count, closed_count)
/// }
///
/// let bounds = vec![
///     LowerBoundClosed::new(1.0),
///     LowerBoundClosed::new(2.0),
///     LowerBoundClosed::new(3.0),
/// ];
///
/// let (min, max, open, closed) = analyze_bounds(&bounds);
/// assert_eq!(min, 1.0);
/// assert_eq!(max, 3.0);
/// assert_eq!(open, 0);
/// assert_eq!(closed, 3);
/// ```
///
/// ## Integration with Grid1D
///
/// ### Interval Construction
///
/// ```rust
/// use grid1d::{bounds::*, intervals::*};
/// use try_create::{IntoInner, New};
///
/// let lower = LowerBoundClosed::new(0.0);
/// let upper = UpperBoundOpen::new(1.0);
///
/// // Convert bounds to interval
/// let interval = IntervalLowerClosedUpperOpen::new(
///     lower.into_inner(),
///     upper.into_inner()
/// );
///
/// // Test interval properties
/// assert!(interval.contains_point(&0.0));  // Includes lower (closed)
/// assert!(!interval.contains_point(&1.0)); // Excludes upper (open)
/// assert!(interval.contains_point(&0.5));  // Interior point
/// ```
///
/// ### Domain Specification
///
/// ```rust
/// use grid1d::{bounds::*, Grid1D, intervals::*, scalars::NumIntervals, Grid1DTrait, HasIntervalIdRange};
/// use try_create::{New, IntoInner, TryNew};
///
/// // Define domain using bounds
/// let domain_start = LowerBoundClosed::new(0.0);
/// let domain_end = UpperBoundClosed::new(10.0);
///
/// // Create interval from bounds
/// let domain = IntervalClosed::new(
///     domain_start.into_inner(),
///     domain_end.into_inner()
/// );
///
/// // Use in grid construction
/// let grid = Grid1D::uniform(domain, NumIntervals::try_new(100).unwrap());
/// assert_eq!(grid.num_intervals().as_ref(), &100);
/// ```
///
/// ## Performance Characteristics
///
/// ### Memory Layout
/// - **Size**: Same as `RealType` (phantom types have zero size)
/// - **Alignment**: Same as `RealType`
/// - **Padding**: No additional padding beyond the scalar value
///
/// ### Runtime Performance
/// | Operation | Complexity | Notes |
/// |-----------|------------|-------|
/// | Construction | O(1) | Debug assertion only |
/// | Value access | O(1) | Direct field access |
/// | Constraint testing | O(1) | Single comparison operation |
/// | Type queries | O(1) | Compile-time constants |
/// | Conversion | O(1) | Pure type manipulation |
///
/// ## Error Handling and Validation
///
/// ### Debug-Mode Validation
///
/// ```rust
/// use grid1d::bounds::*;
/// use try_create::New;
///
/// // In debug builds, construction validates finite values
/// #[cfg(debug_assertions)]
/// {
///     // This would panic in debug mode:
///     // let invalid = LowerBoundClosed::new(f64::NAN);
/// }
///
/// // In release builds, validation is skipped for performance
/// #[cfg(not(debug_assertions))]
/// {
///     let bound = LowerBoundClosed::new(f64::INFINITY); // Allowed in release
/// }
/// ```
///
/// ### Safe Construction Patterns
///
/// ```rust
/// use grid1d::bounds::*;
/// use try_create::{New, TryNew};
/// use num_valid::RealNative64StrictFiniteInDebug;
///
/// // Use validated scalar types for automatic validation
/// type SafeScalar = RealNative64StrictFiniteInDebug;
///
/// fn create_safe_bound(value: f64) -> Result<LowerBoundClosed<SafeScalar>, <SafeScalar as TryNew>::Error> {
///     let validated_value = SafeScalar::try_new(value)?;
///     Ok(LowerBoundClosed::new(validated_value))
/// }
///
/// // Safe construction with validation
/// let safe_bound = create_safe_bound(5.0).unwrap();
/// assert_eq!(safe_bound.as_ref().as_ref(), &5.0);
/// ```
///
/// ## Advanced Usage Patterns
///
/// ### Custom Bound Types
///
/// ```rust
/// use grid1d::bounds::*;
/// use try_create::New;
///
/// // Specialized bounds for specific domains
/// type PositiveLowerBound<T> = LowerBoundOpen<T>;  // x > 0
/// type UnitUpperBound<T> = UpperBoundClosed<T>;    // x ≤ 1
/// type ProbabilityBound<T> = LowerBoundClosed<T>;  // p ≥ 0
///
/// fn create_probability_domain() -> (ProbabilityBound<f64>, UnitUpperBound<f64>) {
///     (ProbabilityBound::new(0.0), UnitUpperBound::new(1.0))
/// }
///
/// let (prob_lower, prob_upper) = create_probability_domain();
/// assert!(prob_lower.value_within_bound(&0.0));  // Probability can be 0
/// assert!(prob_upper.value_within_bound(&1.0));  // Probability can be 1
/// ```
///
/// ### Bound Collections and Analysis
///
/// ```rust
/// use grid1d::bounds::*;
/// use try_create::New;
///
/// // Heterogeneous bound collection (same side and type)
/// let lower_bounds = vec![
///     LowerBoundClosed::new(0.0),
///     LowerBoundClosed::new(1.0),
///     LowerBoundClosed::new(2.0),
/// ];
///
/// // Find the most restrictive (maximum) lower bound
/// let max_lower = lower_bounds.iter().max_by(|a, b| a.partial_cmp(b).unwrap()).unwrap();
/// assert_eq!(max_lower.as_ref(), &2.0);
///
/// // Test which bounds a value satisfies
/// let test_value = 1.5;
/// let satisfied: Vec<_> = lower_bounds.iter()
///     .enumerate()
///     .filter(|(_, bound)| bound.value_within_bound(&test_value))
///     .map(|(i, _)| i)
///     .collect();
///
/// assert_eq!(satisfied, vec![0, 1]); // Satisfies bounds 0 and 1, not 2
/// ```
///
/// ## Best Practices
///
/// ### 1. **Choose Appropriate Scalar Types**
/// ```rust
/// use grid1d::bounds::*;
/// use try_create::New;
/// use num_valid::RealNative64StrictFiniteInDebug;
///
/// // ✅ GOOD: Use validated types for safety-critical code
/// type SafeBound = LowerBoundClosed<RealNative64StrictFiniteInDebug>;
///
/// // ✅ GOOD: Use f64 for performance-critical code with known valid input
/// type FastBound = LowerBoundClosed<f64>;
/// ```
///
/// ### 2. **Leverage Compile-Time Type Safety**
/// ```rust
/// use grid1d::bounds::*;
/// use try_create::New;
///
/// // ✅ GOOD: Use specific types when semantics are known
/// fn create_unit_interval() -> (LowerBoundClosed<f64>, UpperBoundClosed<f64>) {
///     (LowerBoundClosed::new(0.0), UpperBoundClosed::new(1.0))
/// }
///
/// // ❌ AVOID: Using runtime types when compile-time types suffice
/// fn create_runtime_unit_interval() -> (LowerBoundRuntime<f64>, UpperBoundRuntime<f64>) {
///     (
///         IntervalBoundRuntime::Closed(LowerBoundClosed::new(0.0)),
///         IntervalBoundRuntime::Closed(UpperBoundClosed::new(1.0))
///     )
/// }
/// ```
///
/// ### 3. **Use Type Aliases for Domain-Specific Bounds**
/// ```rust
/// use grid1d::bounds::*;
///
/// // ✅ GOOD: Clear semantic meaning
/// type TemperatureLowerBound = LowerBoundClosed<f64>;  // T ≥ 0 (Kelvin)
/// type ProbabilityUpperBound = UpperBoundClosed<f64>;  // p ≤ 1
/// type StrictPositiveBound = LowerBoundOpen<f64>;      // x > 0
/// ```
///
/// ## Mathematical Guarantees
///
/// The [`IntervalBound`] struct maintains mathematical correctness by:
///
/// - **Type Safety**: Prevents mixing incompatible boundary types at compile time
/// - **Semantic Consistency**: Boundary inclusion/exclusion semantics are enforced by types
/// - **Value Integrity**: Debug assertions ensure finite values (configurable via scalar types)
/// - **Zero-Cost Abstractions**: Full type safety with no runtime overhead
/// - **Mathematical Ordering**: Proper ordering semantics for boundary comparisons
///
/// [`IntervalBound`] forms the foundation of the grid1d boundary system, providing
/// type-safe, mathematically correct, and performant boundary representations for
/// interval arithmetic and domain specification.
#[derive(Debug, Clone, AsRef, PartialEq, Eq, Serialize, Deserialize)]
#[serde(bound(deserialize = "RealType: for<'a> Deserialize<'a>"))]
pub struct IntervalBound<RealType: RealScalar, Side: BoundSide, Type: BoundType> {
    #[as_ref]
    pub(crate) value: RealType,

    _phantom: std::marker::PhantomData<(Side, Type)>,
}

impl<RealType: RealScalar, Side: BoundSide, Type: BoundType> PartialOrd
    for IntervalBound<RealType, Side, Type>
{
    fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
        self.value.partial_cmp(&other.value)
    }
}

impl<RealType: RealScalar, Side: BoundSide, Type: BoundType> New
    for IntervalBound<RealType, Side, Type>
{
    #[inline(always)]
    fn new(value: RealType) -> Self {
        debug_assert!(
            value.is_finite(),
            "Bound value must be finite, got: {:?}",
            value
        );

        Self {
            value,
            _phantom: std::marker::PhantomData,
        }
    }
}

impl<RealType: RealScalar, Side: BoundSide, Type: BoundType> BoundTypeChecks
    for IntervalBound<RealType, Side, Type>
{
    /// Returns whether the boundary value is included in the interval
    #[inline(always)]
    fn includes_boundary(&self) -> bool {
        Type::includes_boundary()
    }
}

impl<RealType: RealScalar, Side: BoundSide, Type: BoundType> BoundSideChecks
    for IntervalBound<RealType, Side, Type>
{
    /// Returns whether this is an upper bound
    #[inline(always)]
    fn is_upper_bound(&self) -> bool {
        Side::is_upper()
    }
}

impl<RealType: RealScalar, Side: BoundSide, Type: BoundType> BoundChecks
    for IntervalBound<RealType, Side, Type>
{
}

impl<RealType: RealScalar, Side: BoundSide, Type: BoundType> IntervalBound<RealType, Side, Type> {
    /// Convert this bound to a (possibly) different [`BoundType`] while keeping the same value
    #[inline(always)]
    pub fn with_bound_type<NewType: BoundType>(self) -> IntervalBound<RealType, Side, NewType> {
        IntervalBound {
            value: self.value,
            _phantom: std::marker::PhantomData,
        }
    }

    /// Create a new bound with the same type but different value
    #[inline(always)]
    pub fn with_value(&self, new_value: RealType) -> Self {
        Self::new(new_value)
    }

    /// Converts a bound to the opposite type (Open ↔ Closed) while preserving value and side.
    ///
    /// This function transforms an `IntervalBound<RealType, Side, Type>` to
    /// `IntervalBound<RealType, Side, Type::Opposite>`, changing `Open` ↔ `Closed`
    /// at compile-time while keeping the side (`Lower` or `Upper`) unchanged.
    ///
    /// The return type is automatically inferred from the [`BoundType::Opposite`] associated
    /// type, so no turbofish syntax is needed.
    ///
    /// # Type Transformations
    ///
    /// | Input Type | Output Type |
    /// |------------|-------------|
    /// | `IntervalBound<T, Side, Open>` | `IntervalBound<T, Side, Closed>` |
    /// | `IntervalBound<T, Side, Closed>` | `IntervalBound<T, Side, Open>` |
    ///
    /// # Use Cases
    ///
    /// - Adjusting interval boundaries in set operations
    /// - Converting between boundary inclusion/exclusion semantics
    /// - Implementing boundary transformations in computational geometry
    /// - Handling boundary conditions in numerical algorithms
    ///
    /// # Examples
    ///
    /// ## Basic Transformation
    ///
    /// ```rust
    /// use grid1d::bounds::*;
    /// use try_create::New;
    ///
    /// // Open to Closed
    /// let open: LowerBound<f64, Open> = IntervalBound::new(5.0);
    /// let closed: LowerBound<f64, Closed> = open.flip_bound_type();
    ///
    /// assert_eq!(*closed.as_ref(), 5.0);
    /// assert!(closed.includes_boundary());
    ///
    /// // Closed to Open
    /// let closed: UpperBound<f64, Closed> = IntervalBound::new(10.0);
    /// let open: UpperBound<f64, Open> = closed.flip_bound_type();
    ///
    /// assert_eq!(*open.as_ref(), 10.0);
    /// assert!(!open.includes_boundary());
    /// ```
    ///
    /// ## Round-Trip Property
    ///
    /// ```rust
    /// use grid1d::bounds::*;
    /// use try_create::New;
    ///
    /// let original: LowerBound<f64, Closed> = IntervalBound::new(2.5);
    /// let flipped: LowerBound<f64, Open> = original.flip_bound_type();
    /// let restored: LowerBound<f64, Closed> = flipped.flip_bound_type();
    ///
    /// assert_eq!(*restored.as_ref(), 2.5);
    /// assert!(restored.includes_boundary());
    /// ```
    ///
    /// ## Interval Boundary Adjustment
    ///
    /// ```rust
    /// use grid1d::bounds::*;
    /// use try_create::New;
    ///
    /// // When computing interval difference A \ B, we often need to flip boundaries
    /// let b_lower: LowerBound<f64, Closed> = IntervalBound::new(3.0);  // [3
    /// let left_upper: LowerBound<f64, Open> = b_lower.flip_bound_type(); // (3
    ///
    /// assert!(!left_upper.includes_boundary());
    /// assert_eq!(*left_upper.as_ref(), 3.0);
    /// ```
    ///
    /// # Performance
    ///
    /// - **Time Complexity**: O(1) - compile-time type transformation
    /// - **Memory**: Zero-cost abstraction - no runtime overhead
    /// - **Inlining**: Marked `#[inline(always)]` for optimal performance
    ///
    /// # See Also
    ///
    /// - [`flip_bound_side`](Self::flip_bound_side) - Change Lower ↔ Upper
    /// - [`flip_bound_side_and_type`](Self::flip_bound_side_and_type) - Both transformations
    /// - [`with_bound_type`](Self::with_bound_type) - Convert to arbitrary bound type
    #[inline(always)]
    pub fn flip_bound_type(self) -> IntervalBound<RealType, Side, Type::Opposite> {
        IntervalBound {
            value: self.value,
            _phantom: std::marker::PhantomData,
        }
    }

    /// Converts a bound to the opposite side while preserving the open/closed type.
    ///
    /// This function transforms an `IntervalBound<RealType, Side, Type>` to
    /// `IntervalBound<RealType, Side::Opposite, Type>`, changing `Lower` ↔ `Upper`
    /// at compile-time while keeping the open/closed type unchanged.
    ///
    /// The return type is automatically inferred from the [`BoundSide::Opposite`] associated
    /// type, so no turbofish syntax is needed.
    ///
    /// # Type Transformations
    ///
    /// | Input Type | Output Type |
    /// |------------|-------------|
    /// | `LowerBound<T, Type>` | `UpperBound<T, Type>` |
    /// | `UpperBound<T, Type>` | `LowerBound<T, Type>` |
    ///
    /// More specifically:
    ///
    /// | Input Type | Output Type |
    /// |------------|-------------|
    /// | `LowerBound<T, Open>` | `UpperBound<T, Open>` |
    /// | `LowerBound<T, Closed>` | `UpperBound<T, Closed>` |
    /// | `UpperBound<T, Open>` | `LowerBound<T, Open>` |
    /// | `UpperBound<T, Closed>` | `LowerBound<T, Closed>` |
    ///
    /// # Use Cases
    ///
    /// - Converting bounds between interval endpoints
    /// - Implementing interval set operations (difference, complement)
    /// - Transforming boundary constraints in optimization problems
    /// - Handling bound conversions in computational geometry
    ///
    /// # Examples
    ///
    /// ## Converting Lower to Upper Bounds
    ///
    /// ```rust
    /// use grid1d::bounds::*;
    /// use try_create::New;
    ///
    /// // Open: Lower to Upper
    /// let lower_open: LowerBound<f64, Open> = IntervalBound::new(5.0);
    /// let upper_open: UpperBound<f64, Open> = lower_open.flip_bound_side();
    /// assert_eq!(*upper_open.as_ref(), 5.0);
    /// assert!(!upper_open.includes_boundary());
    ///
    /// // Closed: Lower to Upper
    /// let lower_closed: LowerBound<f64, Closed> = IntervalBound::new(10.0);
    /// let upper_closed: UpperBound<f64, Closed> = lower_closed.flip_bound_side();
    /// assert_eq!(*upper_closed.as_ref(), 10.0);
    /// assert!(upper_closed.includes_boundary());
    /// ```
    ///
    /// ## Converting Upper to Lower Bounds
    ///
    /// ```rust
    /// use grid1d::bounds::*;
    /// use try_create::New;
    ///
    /// // Open: Upper to Lower
    /// let upper_open: UpperBound<f64, Open> = IntervalBound::new(20.0);
    /// let lower_open: LowerBound<f64, Open> = upper_open.flip_bound_side();
    /// assert_eq!(*lower_open.as_ref(), 20.0);
    /// assert!(!lower_open.includes_boundary());
    ///
    /// // Closed: Upper to Lower
    /// let upper_closed: UpperBound<f64, Closed> = IntervalBound::new(15.0);
    /// let lower_closed: LowerBound<f64, Closed> = upper_closed.flip_bound_side();
    /// assert_eq!(*lower_closed.as_ref(), 15.0);
    /// assert!(lower_closed.includes_boundary());
    /// ```
    ///
    /// ## Combining with Type Flipping
    ///
    /// ```rust
    /// use grid1d::bounds::*;
    /// use try_create::New;
    ///
    /// // Start with a closed lower bound
    /// let lower_closed: LowerBound<f64, Closed> = IntervalBound::new(3.0);
    ///
    /// // Convert to open upper bound (both transformations)
    /// let upper_open: UpperBound<f64, Open> = lower_closed
    ///     .flip_bound_side()  // Lower Closed -> Upper Closed
    ///     .flip_bound_type(); // Upper Closed -> Upper Open
    ///
    /// assert_eq!(*upper_open.as_ref(), 3.0);
    /// assert!(!upper_open.includes_boundary());
    /// ```
    ///
    /// ## Use in Interval Operations
    ///
    /// ```rust
    /// use grid1d::bounds::*;
    /// use try_create::New;
    ///
    /// // When computing A \ B, if B has lower bound [5, we need to use it as upper bound
    /// let b_lower: LowerBound<f64, Closed> = IntervalBound::new(5.0);
    ///
    /// // Convert to upper bound for the left remainder
    /// let result_upper: UpperBound<f64, Closed> = b_lower.flip_bound_side();
    ///
    /// assert!(result_upper.includes_boundary());
    /// assert_eq!(*result_upper.as_ref(), 5.0);
    /// ```
    ///
    /// # Performance
    ///
    /// - **Time Complexity**: O(1) - compile-time type transformation
    /// - **Memory**: Zero-cost abstraction - no runtime overhead
    /// - **Inlining**: Marked `#[inline(always)]` for optimal performance
    ///
    /// # See Also
    ///
    /// - [`flip_bound_type`](Self::flip_bound_type) - Change Open ↔ Closed
    /// - [`flip_bound_side_and_type`](Self::flip_bound_side_and_type) - Both transformations
    #[inline(always)]
    pub fn flip_bound_side(self) -> IntervalBound<RealType, Side::Opposite, Type> {
        IntervalBound {
            value: self.value,
            _phantom: std::marker::PhantomData,
        }
    }

    /// Converts a bound to the opposite side AND flips the open/closed type.
    ///
    /// This is a convenience function that combines [`flip_bound_side`](Self::flip_bound_side)
    /// and [`flip_bound_type`](Self::flip_bound_type) in a single operation, performing
    /// both transformations at compile-time:
    /// - Changes `Lower` ↔ `Upper` (side transformation)
    /// - Changes `Open` ↔ `Closed` (type transformation)
    ///
    /// This is equivalent to calling `self.flip_bound_side().flip_bound_type()` but
    /// more concise and expresses the intent clearly.
    ///
    /// # Type Transformations
    ///
    /// | Input Type | Output Type |
    /// |------------|-------------|
    /// | `LowerBound<T, Open>` | `UpperBound<T, Closed>` |
    /// | `LowerBound<T, Closed>` | `UpperBound<T, Open>` |
    /// | `UpperBound<T, Open>` | `LowerBound<T, Closed>` |
    /// | `UpperBound<T, Closed>` | `LowerBound<T, Open>` |
    ///
    /// # Mathematical Motivation
    ///
    /// In interval arithmetic, particularly in set difference operations, when you
    /// exclude a portion of an interval, the complementary bound needs both transformations:
    ///
    /// - If the excluded interval has a **closed** lower bound `[a`, the remaining part
    ///   needs an **open** upper bound `)a` to avoid including the boundary
    /// - If the excluded interval has an **open** lower bound `(a`, the remaining part
    ///   needs a **closed** upper bound `]a` to include what was excluded
    ///
    /// This is precisely the transformation this function performs.
    ///
    /// # Use Cases
    ///
    /// - Essential for interval difference operations (`A \ B`)
    /// - Computing interval complements
    /// - Boundary adjustment in set operations
    /// - Transforming constraints in optimization problems
    ///
    /// # Examples
    ///
    /// ## Basic Transformations
    ///
    /// ```rust
    /// use grid1d::bounds::*;
    /// use try_create::New;
    ///
    /// // Lower Closed -> Upper Open
    /// let lower_closed: LowerBound<f64, Closed> = IntervalBound::new(5.0);
    /// let upper_open: UpperBound<f64, Open> = lower_closed.flip_bound_side_and_type();
    /// assert_eq!(*upper_open.as_ref(), 5.0);
    /// assert!(!upper_open.includes_boundary());
    ///
    /// // Lower Open -> Upper Closed
    /// let lower_open: LowerBound<f64, Open> = IntervalBound::new(10.0);
    /// let upper_closed: UpperBound<f64, Closed> = lower_open.flip_bound_side_and_type();
    /// assert_eq!(*upper_closed.as_ref(), 10.0);
    /// assert!(upper_closed.includes_boundary());
    ///
    /// // Upper Closed -> Lower Open
    /// let upper_closed: UpperBound<f64, Closed> = IntervalBound::new(15.0);
    /// let lower_open: LowerBound<f64, Open> = upper_closed.flip_bound_side_and_type();
    /// assert_eq!(*lower_open.as_ref(), 15.0);
    /// assert!(!lower_open.includes_boundary());
    ///
    /// // Upper Open -> Lower Closed
    /// let upper_open: UpperBound<f64, Open> = IntervalBound::new(20.0);
    /// let lower_closed: LowerBound<f64, Closed> = upper_open.flip_bound_side_and_type();
    /// assert_eq!(*lower_closed.as_ref(), 20.0);
    /// assert!(lower_closed.includes_boundary());
    /// ```
    ///
    /// ## Interval Difference: Complete Example
    ///
    /// ```rust
    /// use grid1d::bounds::*;
    /// use try_create::New;
    ///
    /// // Computing A \ B where:
    /// // A = [0, 10]
    /// // B = [5, 7]
    /// // Result should be [0, 5) ∪ (7, 10]
    ///
    /// // B's lower bound is [5 (closed), so left remainder needs )5 (open upper)
    /// let b_lower: LowerBound<f64, Closed> = IntervalBound::new(5.0);
    /// let left_upper: UpperBound<f64, Open> = b_lower.flip_bound_side_and_type();
    /// assert_eq!(*left_upper.as_ref(), 5.0);
    /// assert!(!left_upper.includes_boundary());
    /// // This creates [0, 5) - the left part of A \ B
    ///
    /// // B's upper bound is ]7 (closed), so right remainder needs (7 (open lower)
    /// let b_upper: UpperBound<f64, Closed> = IntervalBound::new(7.0);
    /// let right_lower: LowerBound<f64, Open> = b_upper.flip_bound_side_and_type();
    /// assert_eq!(*right_lower.as_ref(), 7.0);
    /// assert!(!right_lower.includes_boundary());
    /// // This creates (7, 10] - the right part of A \ B
    /// ```
    ///
    /// ## Comparison with Sequential Operations
    ///
    /// ```rust
    /// use grid1d::bounds::*;
    /// use try_create::New;
    ///
    /// let bound: LowerBound<f64, Closed> = IntervalBound::new(3.0);
    ///
    /// // These are equivalent:
    /// let result1: UpperBound<f64, Open> = bound.clone().flip_bound_side_and_type();
    /// let result2: UpperBound<f64, Open> = bound.flip_bound_side().flip_bound_type();
    ///
    /// assert_eq!(*result1.as_ref(), *result2.as_ref());
    /// assert_eq!(result1.includes_boundary(), result2.includes_boundary());
    /// ```
    ///
    /// ## Involutive Property
    ///
    /// Applying this transformation twice returns to the original state:
    ///
    /// ```rust
    /// use grid1d::bounds::*;
    /// use try_create::New;
    ///
    /// let original: LowerBound<f64, Closed> = IntervalBound::new(7.5);
    /// let original_value = *original.as_ref();
    /// let includes = original.includes_boundary();
    ///
    /// // Apply transformation twice
    /// let transformed: UpperBound<f64, Open> = original.flip_bound_side_and_type();
    /// let back: LowerBound<f64, Closed> = transformed.flip_bound_side_and_type();
    ///
    /// // Returns to original type and value
    /// assert_eq!(*back.as_ref(), original_value);
    /// assert_eq!(back.includes_boundary(), includes);
    /// ```
    ///
    /// # Performance
    ///
    /// - **Time Complexity**: O(1) - compile-time type transformation
    /// - **Memory**: Zero-cost abstraction - no runtime overhead
    /// - **Inlining**: Marked `#[inline(always)]` for optimal performance
    /// - **Optimization**: Compiler optimizes to a simple value move
    ///
    /// # See Also
    ///
    /// - [`flip_bound_side`](Self::flip_bound_side) - Change only the side (Lower ↔ Upper)
    /// - [`flip_bound_type`](Self::flip_bound_type) - Change only the type (Open ↔ Closed)
    #[inline(always)]
    pub fn flip_bound_side_and_type(
        self,
    ) -> IntervalBound<RealType, Side::Opposite, Type::Opposite> {
        IntervalBound {
            value: self.value,
            _phantom: std::marker::PhantomData,
        }
    }
}

impl<RealType: RealScalar, Side: BoundSide, Type: BoundType> IntoInner
    for IntervalBound<RealType, Side, Type>
{
    type InnerType = RealType;

    #[inline(always)]
    fn into_inner(self) -> Self::InnerType {
        self.value
    }
}

#[duplicate_item(
    BoundSide BoundType ordering_func;
    [Lower]   [Open]    [gt]; // x > value
    [Lower]   [Closed]  [ge]; // x >= value
    [Upper]   [Open]    [lt]; // x < value
    [Upper]   [Closed]  [le]; // x <= value
)]
impl<RealType: RealScalar> ValueWithinBound for IntervalBound<RealType, BoundSide, BoundType> {
    type RealType = RealType;

    #[inline(always)]
    fn value_within_bound(&self, x: &Self::RealType) -> bool {
        PartialOrd::ordering_func(x, &self.value)
    }
}
//------------------------------------------------------------------------------------------------

//------------------------------------------------------------------------------------------------
/// Generic lower bound type alias that parameterizes over boundary inclusion semantics.
///
/// [`LowerBound<RealType, BoundType>`] is a convenience type alias for [`IntervalBound<RealType, Lower, BoundType>`]
/// that simplifies the specification of lower boundaries while maintaining full type safety.
/// This alias enables more concise generic programming over different lower boundary types.
///
/// ## Type Parameters
///
/// - **`RealType`**: Any scalar type implementing [`num_valid::RealScalar`]
/// - **`BoundType`**: Either [`Open`] (exclusive) or [`Closed`] (inclusive) boundary semantics
///
/// ## Mathematical Properties
///
/// Lower bounds define the minimum constraint for intervals and domains:
///
/// | BoundType | Mathematical Constraint | Notation | Semantics |
/// |-----------|------------------------|----------|-----------|
/// | [`Open`]  | `x > lower_value`      | `(a`     | Excludes boundary value |
/// | [`Closed`]| `x ≥ lower_value`      | `[a`     | Includes boundary value |
///
/// ## Generic Programming Benefits
///
/// This type alias enables writing generic functions that work with any lower bound type:
///
/// ```rust
/// use grid1d::bounds::*;
/// use num_valid::RealScalar;
/// use try_create::New;
///
/// fn analyze_lower_bound<T, B>(bound: &LowerBound<T, B>) -> String
/// where
///     T: RealScalar + std::fmt::Display,
///     B: BoundType,
/// {
///     format!(
///         "Lower bound: {} ({})",
///         bound.as_ref(),
///         if bound.is_closed() { "inclusive" } else { "exclusive" }
///     )
/// }
///
/// // Works with both open and closed lower bounds
/// let closed_bound = LowerBoundClosed::new(5.0);
/// let open_bound = LowerBoundOpen::new(5.0);
///
/// println!("{}", analyze_lower_bound(&closed_bound)); // "Lower bound: 5 (inclusive)"
/// println!("{}", analyze_lower_bound(&open_bound));   // "Lower bound: 5 (exclusive)"
/// ```
///
/// ## Concrete Type Instantiations
///
/// The most commonly used concrete types are:
///
/// ```rust
/// use grid1d::bounds::*;
///
/// // These are equivalent type specifications:
/// type LowerBoundClosedF64 = LowerBound<f64, Closed>;  // Using alias
/// type LowerBoundClosedF64Alt = LowerBoundClosed<f64>;  // Direct alias
///
/// type LowerBoundOpenF64 = LowerBound<f64, Open>;      // Using alias
/// type LowerBoundOpenF64Alt = LowerBoundOpen<f64>;     // Direct alias
/// ```
///
/// ## Usage in Generic Interval Construction
///
/// This type alias is particularly useful when building generic interval types:
///
/// ```rust
/// use grid1d::bounds::*;
/// use num_valid::RealScalar;
///
/// // Generic interval with parameterized lower bound type
/// struct GenericInterval<T, LowerType, UpperType>
/// where
///     T: RealScalar,
///     LowerType: BoundType,
///     UpperType: BoundType,
/// {
///     lower: LowerBound<T, LowerType>,
///     upper: UpperBound<T, UpperType>,
/// }
///
/// // This enables flexible interval construction while maintaining type safety
/// type ClosedInterval<T> = GenericInterval<T, Closed, Closed>;     // [a, b]
/// type OpenInterval<T> = GenericInterval<T, Open, Open>;           // (a, b)
/// type HalfOpenInterval<T> = GenericInterval<T, Closed, Open>;     // [a, b)
/// ```
///
/// ## Trait Implementations
///
/// All [`IntervalBound`] functionality is available through this alias:
///
/// - **[`ValueWithinBound`]**: Test if values satisfy the bound constraint
/// - **[`BoundTypeConversion`]**: Convert between open and closed semantics
/// - **[`BoundSideConversion`]**: Convert to upper bounds (maintaining boundary type)
/// - **[`AsRef<RealType>`]**: Zero-cost access to the underlying scalar value
/// - **[`IntoInner`]**: Extract the underlying scalar value
///
/// ## Performance Characteristics
///
/// - **Zero Runtime Cost**: Type alias disappears completely at compile time
/// - **Memory Layout**: Identical to the underlying scalar type (e.g., 8 bytes for `f64`)
/// - **Generic Specialization**: Compiler generates optimized code for each concrete instantiation
/// - **Inline Optimization**: All operations inline to direct scalar operations
pub type LowerBound<RealType, BoundType> = IntervalBound<RealType, Lower, BoundType>;

/// Generic upper bound type alias that parameterizes over boundary inclusion semantics.
///
/// [`UpperBound<RealType, BoundType>`] is a convenience type alias for [`IntervalBound<RealType, Upper, BoundType>`]
/// that simplifies the specification of upper boundaries while maintaining full type safety.
/// This alias enables more concise generic programming over different upper boundary types.
///
/// ## Type Parameters
///
/// - **`RealType`**: Any scalar type implementing [`num_valid::RealScalar`]
/// - **`BoundType`**: Either [`Open`] (exclusive) or [`Closed`] (inclusive) boundary semantics
///
/// ## Mathematical Properties
///
/// Upper bounds define the maximum constraint for intervals and domains:
///
/// | BoundType | Mathematical Constraint | Notation | Semantics |
/// |-----------|------------------------|----------|-----------|
/// | [`Open`]  | `x < upper_value`      | `b)`     | Excludes boundary value |
/// | [`Closed`]| `x ≤ upper_value`      | `b]`     | Includes boundary value |
///
/// ## Generic Programming Benefits
///
/// This type alias enables writing generic functions that work with any upper bound type:
///
/// ```rust
/// use grid1d::bounds::*;
/// use num_valid::RealScalar;
/// use try_create::New;
///
/// fn analyze_upper_bound<T, B>(bound: &UpperBound<T, B>) -> String
/// where
///     T: RealScalar + std::fmt::Display,
///     B: BoundType,
/// {
///     format!(
///         "Upper bound: {} ({})",
///         bound.as_ref(),
///         if bound.is_closed() { "inclusive" } else { "exclusive" }
///     )
/// }
///
/// // Works with both open and closed upper bounds
/// let closed_bound = UpperBoundClosed::new(10.0);
/// let open_bound = UpperBoundOpen::new(10.0);
///
/// println!("{}", analyze_upper_bound(&closed_bound)); // "Upper bound: 10 (inclusive)"
/// println!("{}", analyze_upper_bound(&open_bound));   // "Upper bound: 10 (exclusive)"
/// ```
///
/// ## Concrete Type Instantiations
///
/// The most commonly used concrete types are:
///
/// ```rust
/// use grid1d::bounds::*;
///
/// // These are equivalent type specifications:
/// type UpperBoundClosedF64 = UpperBound<f64, Closed>;  // Using alias
/// type UpperBoundClosedF64Alt = UpperBoundClosed<f64>; // Direct alias
///
/// type UpperBoundOpenF64 = UpperBound<f64, Open>;      // Using alias
/// type UpperBoundOpenF64Alt = UpperBoundOpen<f64>;     // Direct alias
/// ```
///
/// ## Mathematical Ordering Semantics
///
/// Upper bounds follow mathematically correct ordering where "tighter" bounds are considered smaller:
///
/// ```rust
/// use grid1d::bounds::*;
/// use try_create::New;
///
/// let open_upper = UpperBoundOpen::new(5.0);    // 5)
/// let closed_upper = UpperBoundClosed::new(5.0); // 5]
///
/// // Open bound is "tighter" (excludes more) than closed bound
/// assert!(open_upper < closed_upper);  // 5) < 5] → true
///
/// // This ordering ensures correct interval intersection behavior:
/// // intersection([0, 5)) ∩ [0, 5]) = [0, 5) (the tighter constraint wins)
/// ```
///
/// ## Constraint Validation
///
/// Upper bounds provide constraint checking through the [`ValueWithinBound`] trait:
///
/// ```rust
/// use grid1d::bounds::*;
/// use try_create::New;
///
/// let open_upper = UpperBoundOpen::new(10.0);
/// let closed_upper = UpperBoundClosed::new(10.0);
///
/// // Test boundary value behavior
/// assert!(!open_upper.value_within_bound(&10.0));   // 10 < 10 → false
/// assert!(closed_upper.value_within_bound(&10.0));  // 10 ≤ 10 → true
///
/// // Test interior values
/// assert!(open_upper.value_within_bound(&9.5));     // 9.5 < 10 → true
/// assert!(closed_upper.value_within_bound(&9.5));   // 9.5 ≤ 10 → true
/// ```
///
/// ## Trait Implementations
///
/// All [`IntervalBound`] functionality is available through this alias:
///
/// - **[`ValueWithinBound`]**: Test if values satisfy the bound constraint
/// - **[`BoundTypeConversion`]**: Convert between open and closed semantics
/// - **[`BoundSideConversion`]**: Convert to lower bounds (maintaining boundary type)
/// - **[`AsRef<RealType>`]**: Zero-cost access to the underlying scalar value
/// - **[`IntoInner`]**: Extract the underlying scalar value
///
/// ## Performance Characteristics
///
/// - **Zero Runtime Cost**: Type alias disappears completely at compile time
/// - **Memory Layout**: Identical to the underlying scalar type (e.g., 8 bytes for `f64`)
/// - **Generic Specialization**: Compiler generates optimized code for each concrete instantiation
/// - **Inline Optimization**: All operations inline to direct scalar operations
pub type UpperBound<RealType, BoundType> = IntervalBound<RealType, Upper, BoundType>;
//------------------------------------------------------------------------------------------------

//------------------------------------------------------------------------------------------------
/// An open lower bound where the boundary value is excluded from the interval.
///
/// Represents the lower boundary of mathematical objects like intervals `(a, b)` and grids
/// where the starting point `a` is approached but not included. This enforces the strict
/// inequality `x > a` for any point `x` within the bounded region.
///
/// ## Mathematical Properties
///
/// - **Notation**: `(a` in interval notation
/// - **Semantics**: Excludes the boundary value
/// - **Containment**: Point `x` satisfies `x > a`
/// - **Ordering**: `LowerBoundClosed::new(a) < LowerBoundOpen::new(a)` (closed is "tighter")
///
/// ## When to Use
///
/// - **Strict constraints**: Modeling `x > threshold` relationships
/// - **Asymptotic domains**: Functions with singularities at the boundary
/// - **Grid partitioning**: Half-open ranges like `(0, 1]`, `(1, 2]`, etc.
/// - **Limit approaches**: Domains where the boundary is approached but never reached
///
/// ## Compatible Interval Types
///
/// This bound type is used in constructing:
/// - [`IntervalOpen`](crate::intervals::IntervalOpen): `(a, b)` - both bounds open
/// - [`IntervalLowerOpenUpperClosed`](crate::intervals::IntervalLowerOpenUpperClosed): `(a, b]` - lower open, upper closed
/// - [`IntervalLowerOpenUpperUnbounded`](crate::intervals::IntervalLowerOpenUpperUnbounded): `(a, +∞)` - extends infinitely upward
///
/// ## Examples
///
/// ```rust
/// use grid1d::{bounds::*, intervals::*};
/// use try_create::New;
///
/// let bound = LowerBoundOpen::new(0.0);  // (0
///
/// // Used in strict inequality contexts
/// let test_point = 0.0;
/// let is_inside = test_point > *bound.as_ref(); // false (0 > 0 → false)
///
/// // Construct intervals using this bound type
/// let open_interval = IntervalOpen::new(0.0, 1.0);              // (0, 1)
/// let half_open = IntervalLowerOpenUpperClosed::new(0.0, 1.0);  // (0, 1]
/// let unbounded = IntervalLowerOpenUpperUnbounded::new(0.0);    // (0, +∞)
///
/// // All exclude the lower bound value
/// assert!(!open_interval.contains_point(&0.0));
/// assert!(!half_open.contains_point(&0.0));
/// assert!(!unbounded.contains_point(&0.0));
/// ```
pub type LowerBoundOpen<RealType> = LowerBound<RealType, Open>;

/// A closed lower bound where the boundary value is included in the interval.
///
/// Represents the lower boundary of mathematical objects like intervals `[a, b]` and grids
/// where the starting point `a` is part of the bounded region. This enforces the inclusive
/// inequality `x ≥ a` for any point `x` within the bounded region.
///
/// ## Mathematical Properties
///
/// - **Notation**: `[a` in interval notation
/// - **Semantics**: Includes the boundary value
/// - **Containment**: Point `x` satisfies `x ≥ a`
/// - **Ordering**: `LowerBoundClosed::new(a) < LowerBoundOpen::new(a)` (closed is "tighter")
///
/// ## When to Use
///
/// - **Inclusive constraints**: Modeling `x ≥ minimum` relationships
/// - **Physical boundaries**: Achievable minimum values (e.g., temperature ≥ 0K)
/// - **Standard intervals**: Closed intervals `[a, b]` for integration, optimization
/// - **Array-like indexing**: When the starting index should be included
///
/// ## Compatible Interval Types
///
/// This bound type is used in constructing:
/// - [`IntervalClosed`](crate::intervals::IntervalClosed): `[a, b]` - both bounds closed
/// - [`IntervalLowerClosedUpperOpen`](crate::intervals::IntervalLowerClosedUpperOpen): `[a, b)` - lower closed, upper open
/// - [`IntervalLowerClosedUpperUnbounded`](crate::intervals::IntervalLowerClosedUpperUnbounded): `[a, +∞)` - extends infinitely upward
///
/// ## Examples
///
/// ```rust
/// use grid1d::{bounds::*, intervals::*};
/// use try_create::New;
///
/// let bound = LowerBoundClosed::new(0.0);  // [0
///
/// // Used in inclusive constraint contexts
/// let test_point = 0.0;
/// let is_inside = test_point >= *bound.as_ref(); // true (0 ≥ 0 → true)
///
/// // Construct intervals using this bound type
/// let closed_interval = IntervalClosed::new(0.0, 1.0);                    // [0, 1]
/// let half_open = IntervalLowerClosedUpperOpen::new(0.0, 1.0);            // [0, 1)
/// let unbounded = IntervalLowerClosedUpperUnbounded::new(0.0);            // [0, +∞)
///
/// // All include the lower bound value
/// assert!(closed_interval.contains_point(&0.0));
/// assert!(half_open.contains_point(&0.0));
/// assert!(unbounded.contains_point(&0.0));
/// ```
pub type LowerBoundClosed<RealType> = LowerBound<RealType, Closed>;

/// An open upper bound where the boundary value is excluded from the interval.
///
/// Represents the upper boundary of mathematical objects like intervals `[a, b)` and grids
/// where the ending point `b` is approached but not included. This enforces the strict
/// inequality `x < b` for any point `x` within the bounded region.
///
/// ## Mathematical Properties
///
/// - **Notation**: `b)` in interval notation
/// - **Semantics**: Excludes the boundary value  
/// - **Containment**: Point `x` satisfies `x < b`
/// - **Ordering**: `UpperBoundOpen::new(b) < UpperBoundClosed::new(b)` (open is "smaller")
///
/// ## When to Use
///
/// - **Strict constraints**: Modeling `x < threshold` relationships
/// - **Grid partitioning**: Half-open ranges like `[0, 1)`, `[1, 2)`, etc.
/// - **Asymptotic limits**: Functions approaching a limit from below
/// - **Array-like indexing**: When the ending index should be excluded (like Rust ranges)
///
/// ## Compatible Interval Types
///
/// This bound type is used in constructing:
/// - [`IntervalOpen`](crate::intervals::IntervalOpen): `(a, b)` - both bounds open
/// - [`IntervalLowerClosedUpperOpen`](crate::intervals::IntervalLowerClosedUpperOpen): `[a, b)` - lower closed, upper open
/// - [`IntervalLowerUnboundedUpperOpen`](crate::intervals::IntervalLowerUnboundedUpperOpen): `(-∞, b)` - extends infinitely downward
///
/// ## Examples
///
/// ```rust
/// use grid1d::{bounds::*, intervals::*};
/// use try_create::New;
///
/// let bound = UpperBoundOpen::new(1.0);  // 1)
///
/// // Used in strict constraint contexts
/// let test_point = 1.0;
/// let is_inside = test_point < *bound.as_ref(); // false (1 < 1 → false)
///
/// // Construct intervals using this bound type - perfect for Rust-style ranges
/// let open_interval = IntervalOpen::new(0.0, 1.0);                      // (0, 1)
/// let half_open = IntervalLowerClosedUpperOpen::new(0.0, 1.0);          // [0, 1)
/// let unbounded = IntervalLowerUnboundedUpperOpen::new(1.0);            // (-∞, 1)
///
/// // All exclude the upper bound value
/// assert!(!open_interval.contains_point(&1.0));
/// assert!(!half_open.contains_point(&1.0));
/// assert!(!unbounded.contains_point(&1.0));
/// ```
pub type UpperBoundOpen<RealType> = UpperBound<RealType, Open>;

/// A closed upper bound where the boundary value is included in the interval.
///
/// Represents the upper boundary of mathematical objects like intervals `[a, b]` and grids
/// where the ending point `b` is part of the bounded region. This enforces the inclusive
/// inequality `x ≤ b` for any point `x` within the bounded region.
///
/// ## Mathematical Properties
///
/// - **Notation**: `b]` in interval notation
/// - **Semantics**: Includes the boundary value
/// - **Containment**: Point `x` satisfies `x ≤ b`
/// - **Ordering**: `UpperBoundOpen::new(b) < UpperBoundClosed::new(b)` (open is "smaller")
///
/// ## When to Use
///
/// - **Inclusive constraints**: Modeling `x ≤ maximum` relationships
/// - **Physical boundaries**: Achievable maximum values (e.g., temperature ≤ 100°C)
/// - **Standard intervals**: Closed intervals `[a, b]` for integration, analysis
/// - **Complete coverage**: When the ending boundary should be part of the domain
///
/// ## Compatible Interval Types
///
/// This bound type is used in constructing:
/// - [`IntervalClosed`](crate::intervals::IntervalClosed): `[a, b]` - both bounds closed
/// - [`IntervalLowerOpenUpperClosed`](crate::intervals::IntervalLowerOpenUpperClosed): `(a, b]` - lower open, upper closed
/// - [`IntervalLowerUnboundedUpperClosed`](crate::intervals::IntervalLowerUnboundedUpperClosed): `(-∞, b]` - extends infinitely downward
///
/// ## Examples
///
/// ```rust
/// use grid1d::{bounds::*, intervals::*};
/// use try_create::New;
///
/// let bound = UpperBoundClosed::new(1.0);  // 1]
///
/// // Used in inclusive constraint contexts
/// let test_point = 1.0;
/// let is_inside = test_point <= *bound.as_ref(); // true (1 ≤ 1 → true)
///
/// // Construct intervals using this bound type
/// let closed_interval = IntervalClosed::new(0.0, 1.0);                   // [0, 1]
/// let half_open = IntervalLowerOpenUpperClosed::new(0.0, 1.0);           // (0, 1]
/// let unbounded = IntervalLowerUnboundedUpperClosed::new(1.0);           // (-∞, 1]
///
/// // All include the upper bound value
/// assert!(closed_interval.contains_point(&1.0));
/// assert!(half_open.contains_point(&1.0));
/// assert!(unbounded.contains_point(&1.0));
/// ```
pub type UpperBoundClosed<RealType> = UpperBound<RealType, Closed>;

//------------------------------------------------------------------------------------------------

impl<RealType: RealScalar, Side: BoundSide> BoundTypeConversion<RealType, Side>
    for IntervalBound<RealType, Side, Open>
{
    #[inline(always)]
    fn into_open(self) -> IntervalBound<RealType, Side, Open> {
        self
    }

    #[inline(always)]
    fn into_closed(self) -> IntervalBound<RealType, Side, Closed> {
        // Implemented in terms of flip_bound_type() to avoid code duplication
        self.flip_bound_type()
    }
}

impl<RealType: RealScalar, Side: BoundSide> BoundTypeConversion<RealType, Side>
    for IntervalBound<RealType, Side, Closed>
{
    #[inline(always)]
    fn into_open(self) -> IntervalBound<RealType, Side, Open> {
        // Implemented in terms of flip_bound_type() to avoid code duplication
        self.flip_bound_type()
    }

    #[inline(always)]
    fn into_closed(self) -> IntervalBound<RealType, Side, Closed> {
        self
    }
}

#[duplicate_item(
    bound_lhs                    bound_rhs;
    [LowerBoundOpen<RealType>]   [LowerBoundClosed<RealType>];
    [LowerBoundClosed<RealType>] [LowerBoundOpen<RealType>] ;
    [UpperBoundOpen<RealType>]   [UpperBoundClosed<RealType>];
    [UpperBoundClosed<RealType>] [UpperBoundOpen<RealType>];
)]
impl<RealType: RealScalar> PartialEq<bound_rhs> for bound_lhs {
    #[inline(always)]
    fn eq(&self, _other: &bound_rhs) -> bool {
        false // Different bound types are never equal
    }
}

#[duplicate_item(
    bound_lhs                    bound_rhs;
    [LowerBoundClosed<RealType>] [LowerBoundOpen<RealType>];
    [UpperBoundOpen<RealType>]   [UpperBoundClosed<RealType>];
)]
impl<RealType: RealScalar> PartialOrd<bound_rhs> for bound_lhs {
    #[inline(always)]
    fn partial_cmp(&self, other: &bound_rhs) -> Option<Ordering> {
        match self.value.partial_cmp(&other.value) {
            Some(Ordering::Equal) => {
                // When values are equal, the "tighter" bound is considered smaller.
                // For lower bounds: [a is tighter than (a, so [a < (a.
                // For upper bounds: b) is tighter than b], so b) < b].
                Some(Ordering::Less)
            }
            other_ordering => other_ordering,
        }
    }
}

#[duplicate_item(
    bound_lhs                    bound_rhs;
    [UpperBoundClosed<RealType>] [UpperBoundOpen<RealType>];
    [LowerBoundOpen<RealType>]   [LowerBoundClosed<RealType>];
)]
impl<RealType: RealScalar> PartialOrd<bound_rhs> for bound_lhs {
    #[inline(always)]
    fn partial_cmp(&self, other: &bound_rhs) -> Option<Ordering> {
        match self.value.partial_cmp(&other.value) {
            Some(Ordering::Equal) => {
                // When values are equal, the "looser" bound is considered greater.
                // For lower bounds: (a is looser than [a, so (a > [a.
                // For upper bounds: b] is looser than b), so b] > b).
                Some(Ordering::Greater)
            }
            other_ordering => other_ordering,
        }
    }
}
//------------------------------------------------------------------------------------------------

//------------------------------------------------------------------------------------------------
#[duplicate_item(
        func_name bound_type;
        [min_lower_bound] [LowerBoundRuntime];
        [min_upper_bound] [UpperBoundRuntime];
    )]
#[allow(dead_code)]
#[inline(always)]
pub(crate) fn func_name<RealType: RealScalar>(
    a: bound_type<RealType>,
    b: bound_type<RealType>,
) -> bound_type<RealType> {
    if a < b { a } else { b }
}

#[duplicate_item(
        func_name bound_type;
        [max_lower_bound] [LowerBoundRuntime];
        [max_upper_bound] [UpperBoundRuntime];
    )]
#[inline(always)]
pub(crate) fn func_name<RealType: RealScalar>(
    a: bound_type<RealType>,
    b: bound_type<RealType>,
) -> bound_type<RealType> {
    if a > b { a } else { b }
}

pub(crate) fn min_lower_bound_maybe_unbounded<RealType: RealScalar>(
    a: Option<LowerBoundRuntime<RealType>>,
    b: Option<LowerBoundRuntime<RealType>>,
) -> Option<LowerBoundRuntime<RealType>> {
    match (a, b) {
        (None, _) | (_, None) => None,
        (Some(a), Some(b)) => {
            if a < b {
                Some(a)
            } else {
                Some(b)
            }
        }
    }
}

pub(crate) fn max_upper_bound_maybe_unbounded<RealType: RealScalar>(
    a: Option<UpperBoundRuntime<RealType>>,
    b: Option<UpperBoundRuntime<RealType>>,
) -> Option<UpperBoundRuntime<RealType>> {
    match (a, b) {
        (None, _) | (_, None) => None,
        (Some(a), Some(b)) => {
            if a > b {
                Some(a)
            } else {
                Some(b)
            }
        }
    }
}

/*
#[duplicate_item(
        func_name bound_type;
        [min_lower_bound_ref] [LowerBoundRuntime];
        [min_upper_bound_ref] [UpperBoundRuntime];
    )]
#[allow(dead_code)]
#[inline(always)]
pub(crate) fn func_name<'a, RealType: RealScalar>(
    a: &'a bound_type<RealType>,
    b: &'a bound_type<RealType>,
) -> &'a bound_type<RealType> {
    if a < b { a } else { b }
}

#[duplicate_item(
        func_name bound_type;
        [max_lower_bound_ref] [LowerBoundRuntime];
        [max_upper_bound_ref] [UpperBoundRuntime];
    )]
#[inline(always)]
pub(crate) fn func_name<'a, RealType: RealScalar>(
    a: &'a bound_type<RealType>,
    b: &'a bound_type<RealType>,
) -> &'a bound_type<RealType> {
    if a > b { a } else { b }
}
*/
//------------------------------------------------------------------------------------------------

//------------------------------------------------------------------------------------------------
#[cfg(test)]
mod tests {
    use super::*;
    use crate::intervals::bounded::IntervalFromBounds;

    #[test]
    fn bound_constraint_satisfaction() {
        let lower_closed = LowerBoundClosed::new(5.0);
        let lower_open = LowerBoundOpen::new(5.0);
        let upper_closed = UpperBoundClosed::new(10.0);
        let upper_open = UpperBoundOpen::new(10.0);

        // Test constraint satisfaction
        assert!(lower_closed.value_within_bound(&5.0)); // x >= 5
        assert!(!lower_open.value_within_bound(&5.0)); // x > 5
        assert!(upper_closed.value_within_bound(&10.0)); // x <= 10
        assert!(!upper_open.value_within_bound(&10.0)); // x < 10

        assert!(lower_closed.value_within_bound(&6.0));
        assert!(lower_open.value_within_bound(&6.0));
        assert!(upper_closed.value_within_bound(&9.0));
        assert!(upper_open.value_within_bound(&9.0));
    }

    #[test]
    fn bound_type_queries() {
        let lower_closed = LowerBoundClosed::new(1.0);
        let upper_open = UpperBoundOpen::new(1.0);

        assert!(lower_closed.is_lower_bound());
        assert!(!lower_closed.is_upper_bound());
        assert!(lower_closed.is_closed());
        assert!(!lower_closed.is_open());

        assert!(!upper_open.is_lower_bound());
        assert!(upper_open.is_upper_bound());
        assert!(!upper_open.is_closed());
        assert!(upper_open.is_open());
    }

    #[test]
    fn bound_conversions() {
        let lower_open_bound = LowerBoundOpen::new(5.0);
        let lower_closed_bound = LowerBoundClosed::new(5.0);
        let upper_open_bound = UpperBoundOpen::new(5.0);
        let upper_closed_bound = UpperBoundClosed::new(5.0);

        assert_eq!(lower_open_bound.clone().into_open(), lower_open_bound);
        assert_eq!(lower_open_bound.clone().into_closed(), lower_closed_bound);
        assert_eq!(lower_open_bound.clone().into_lower(), lower_open_bound);
        assert_eq!(lower_open_bound.clone().into_upper(), upper_open_bound);

        assert_eq!(lower_closed_bound.clone().into_open(), lower_open_bound);
        assert_eq!(lower_closed_bound.clone().into_closed(), lower_closed_bound);
        assert_eq!(lower_closed_bound.clone().into_lower(), lower_closed_bound);
        assert_eq!(lower_closed_bound.clone().into_upper(), upper_closed_bound);

        assert_eq!(upper_open_bound.clone().into_open(), upper_open_bound);
        assert_eq!(upper_open_bound.clone().into_closed(), upper_closed_bound);
        assert_eq!(upper_open_bound.clone().into_lower(), lower_open_bound);
        assert_eq!(upper_open_bound.clone().into_upper(), upper_open_bound);

        assert_eq!(upper_closed_bound.clone().into_open(), upper_open_bound);
        assert_eq!(upper_closed_bound.clone().into_closed(), upper_closed_bound);
        assert_eq!(upper_closed_bound.clone().into_lower(), lower_closed_bound);
        assert_eq!(upper_closed_bound.clone().into_upper(), upper_closed_bound);
    }

    #[test]
    fn lower_bound_open_closed_partial_eq_and_ord() {
        let open = LowerBoundOpen::new(1.0);
        let closed = LowerBoundClosed::new(1.0);
        assert_ne!(open, closed);
        assert!(open > closed);
        assert!(closed < open);
    }

    #[test]
    fn upper_bound_open_closed_partial_eq_and_ord() {
        let open = UpperBoundOpen::new(2.0);
        let closed = UpperBoundClosed::new(2.0);
        assert_ne!(open, closed);
        assert!(open < closed);
        assert!(closed > open);
    }

    #[test]
    fn bounds_into_inner() {
        let open = LowerBoundOpen::new(1.0);
        let closed = LowerBoundClosed::new(2.0);
        let up_open = UpperBoundOpen::new(3.0);
        let up_closed = UpperBoundClosed::new(4.0);
        assert_eq!(open.into_inner(), 1.0);
        assert_eq!(closed.into_inner(), 2.0);
        assert_eq!(up_open.into_inner(), 3.0);
        assert_eq!(up_closed.into_inner(), 4.0);
    }

    #[test]
    fn bounds_new_and_try_new() {
        let open = LowerBoundOpen::new(1.0);
        let closed = LowerBoundClosed::new(2.0);
        let up_open = UpperBoundOpen::new(3.0);
        let up_closed = UpperBoundClosed::new(4.0);
        assert_eq!(open.as_ref(), &1.0);
        assert_eq!(closed.as_ref(), &2.0);
        assert_eq!(up_open.as_ref(), &3.0);
        assert_eq!(up_closed.as_ref(), &4.0);
    }

    #[test]
    fn bounds_ordering_01() {
        let lower_closed_0 = LowerBoundClosed::new(0.0);
        assert_eq!(lower_closed_0.clone(), lower_closed_0);
        assert!(lower_closed_0 == lower_closed_0);
        assert!(!(lower_closed_0 != lower_closed_0));
        more_asserts::assert_ge!(lower_closed_0, lower_closed_0);
        assert!(lower_closed_0 <= lower_closed_0);
        more_asserts::assert_le!(lower_closed_0, lower_closed_0);
        assert!(lower_closed_0 >= lower_closed_0);
        more_asserts::assert_le!(lower_closed_0, lower_closed_0);
        more_asserts::assert_ge!(lower_closed_0, lower_closed_0);

        let lower_closed_1 = LowerBoundClosed::new(1.0);
        assert_ne!(lower_closed_0, lower_closed_1);
        more_asserts::assert_lt!(lower_closed_0, lower_closed_1);
        more_asserts::assert_le!(lower_closed_0, lower_closed_1);
        more_asserts::assert_gt!(lower_closed_1, lower_closed_0);
        more_asserts::assert_ge!(lower_closed_1, lower_closed_0);

        let lower_open_0 = LowerBoundOpen::new(0.0);
        assert_eq!(lower_open_0.clone(), lower_open_0);
        assert!(lower_open_0 == lower_open_0);
        assert!(!(lower_open_0 != lower_open_0));
        more_asserts::assert_ge!(lower_open_0, lower_open_0);
        assert!(lower_open_0 <= lower_open_0);
        more_asserts::assert_le!(lower_open_0, lower_open_0);
        assert!(lower_open_0 >= lower_open_0);
        more_asserts::assert_le!(lower_open_0, lower_open_0);
        more_asserts::assert_ge!(lower_open_0, lower_open_0);

        let lower_open_1 = LowerBoundOpen::new(1.0);
        assert_ne!(lower_open_0, lower_open_1);
        more_asserts::assert_lt!(lower_open_0, lower_open_1);
        more_asserts::assert_le!(lower_open_0, lower_open_1);
        more_asserts::assert_gt!(lower_open_1, lower_open_0);
        more_asserts::assert_ge!(lower_open_1, lower_open_0);

        let upper_closed_0 = UpperBoundClosed::new(0.0);
        assert_eq!(upper_closed_0.clone(), upper_closed_0);
        assert!(upper_closed_0 == upper_closed_0);
        assert!(!(upper_closed_0 != upper_closed_0));
        more_asserts::assert_ge!(upper_closed_0, upper_closed_0);
        assert!(upper_closed_0 <= upper_closed_0);
        more_asserts::assert_le!(upper_closed_0, upper_closed_0);
        assert!(upper_closed_0 >= upper_closed_0);
        more_asserts::assert_le!(upper_closed_0, upper_closed_0);
        more_asserts::assert_ge!(upper_closed_0, upper_closed_0);

        let upper_closed_1 = UpperBoundClosed::new(1.0);
        assert_ne!(upper_closed_0, upper_closed_1);
        more_asserts::assert_lt!(upper_closed_0, upper_closed_1);
        more_asserts::assert_le!(upper_closed_0, upper_closed_1);
        more_asserts::assert_gt!(upper_closed_1, upper_closed_0);
        more_asserts::assert_ge!(upper_closed_1, upper_closed_0);

        let upper_open_0 = UpperBoundOpen::new(0.0);
        assert_eq!(upper_open_0.clone(), upper_open_0);
        assert!(upper_open_0 == upper_open_0);
        assert!(!(upper_open_0 != upper_open_0));
        more_asserts::assert_ge!(upper_open_0, upper_open_0);
        assert!(upper_open_0 <= upper_open_0);
        more_asserts::assert_le!(upper_open_0, upper_open_0);
        assert!(upper_open_0 >= upper_open_0);
        more_asserts::assert_le!(upper_open_0, upper_open_0);
        more_asserts::assert_ge!(upper_open_0, upper_open_0);

        let upper_open_1 = UpperBoundOpen::new(1.0);
        assert_ne!(upper_open_0, upper_open_1);
        more_asserts::assert_lt!(upper_open_0, upper_open_1);
        more_asserts::assert_le!(upper_open_0, upper_open_1);
        more_asserts::assert_gt!(upper_open_1, upper_open_0);
        more_asserts::assert_ge!(upper_open_1, upper_open_0);
    }

    #[test]
    fn bounds_ordering_02() {
        let lower_closed = LowerBoundClosed::new(0.0);
        let lower_open = LowerBoundOpen::new(0.0);
        let upper_closed = UpperBoundClosed::new(0.0);
        let upper_open = UpperBoundOpen::new(0.0);

        {
            // lower closed - lower open
            assert_ne!(lower_closed, lower_open);
            more_asserts::assert_lt!(lower_closed, lower_open);
            more_asserts::assert_le!(lower_closed, lower_open);
        }

        {
            // lower open - lower closed
            assert_ne!(lower_open, lower_closed);
            more_asserts::assert_ge!(lower_open, lower_closed);
            more_asserts::assert_gt!(lower_open, lower_closed);
        }

        {
            // upper closed - upper open
            assert_ne!(upper_closed, upper_open);
            more_asserts::assert_gt!(upper_closed, upper_open);
            more_asserts::assert_ge!(upper_closed, upper_open);
        }

        {
            // upper open - upper closed
            assert_ne!(upper_open, upper_closed);
            more_asserts::assert_lt!(upper_open, upper_closed);
            more_asserts::assert_le!(upper_open, upper_closed);
        }
    }

    #[test]
    fn bound_utility_methods() {
        let lower_closed = LowerBoundClosed::new(5.0);

        // Test with_value method
        let new_lower = lower_closed.with_value(7.0);
        assert_eq!(new_lower.as_ref(), &7.0);
        assert!(new_lower.is_closed());
        assert!(new_lower.is_lower_bound());

        // Test with_bound_type method
        let open_version = lower_closed.clone().with_bound_type::<Open>();
        assert_eq!(open_version.as_ref(), lower_closed.as_ref());
        assert!(open_version.is_open());
        assert!(open_version.is_lower_bound());
    }

    mod interval_lower_bound {
        use super::*;
        use crate::bounds::{LowerBoundClosed, LowerBoundOpen};
        use std::cmp::Ordering;

        #[test]
        fn test_interval_lower_bound_equality() {
            let closed_1 = LowerBoundRuntime::Closed(LowerBoundClosed::new(1.0));
            let closed_2 = LowerBoundRuntime::Closed(LowerBoundClosed::new(1.0));
            let closed_3 = LowerBoundRuntime::Closed(LowerBoundClosed::new(2.0));

            let open_1 = LowerBoundRuntime::Open(LowerBoundOpen::new(1.0));
            let open_2 = LowerBoundRuntime::Open(LowerBoundOpen::new(1.0));

            // Test equality for same variant and value
            assert_eq!(closed_1, closed_2);
            assert_eq!(open_1, open_2);

            // Test inequality for different values
            assert_ne!(closed_1, closed_3);

            // Test inequality for different variants, same value
            assert_ne!(closed_1, open_1);
        }

        mod interval_upper_bound {
            use super::*;
            use crate::bounds::{UpperBoundClosed, UpperBoundOpen};
            use std::cmp::Ordering;

            #[test]
            fn test_interval_upper_bound_equality() {
                let closed_1 = UpperBoundRuntime::Closed(UpperBoundClosed::new(1.0));
                let closed_2 = UpperBoundRuntime::Closed(UpperBoundClosed::new(1.0));
                let closed_3 = UpperBoundRuntime::Closed(UpperBoundClosed::new(2.0));

                let open_1 = UpperBoundRuntime::Open(UpperBoundOpen::new(1.0));
                let open_2 = UpperBoundRuntime::Open(UpperBoundOpen::new(1.0));

                // Test equality for same variant and value
                assert_eq!(closed_1, closed_2);
                assert_eq!(open_1, open_2);

                // Test inequality for different values
                assert_ne!(closed_1, closed_3);

                // Test inequality for different variants, same value
                assert_ne!(closed_1, open_1);
            }

            #[test]
            fn test_interval_upper_bound_partial_ord() {
                let closed_1 = UpperBoundRuntime::Closed(UpperBoundClosed::new(1.0));
                let closed_2 = UpperBoundRuntime::Closed(UpperBoundClosed::new(2.0));
                let open_1 = UpperBoundRuntime::Open(UpperBoundOpen::new(1.0));
                let open_2 = UpperBoundRuntime::Open(UpperBoundOpen::new(2.0));

                // Test closed vs closed
                assert_eq!(closed_1.partial_cmp(&closed_1), Some(Ordering::Equal));
                assert_eq!(closed_1.partial_cmp(&closed_2), Some(Ordering::Less));
                assert_eq!(closed_2.partial_cmp(&closed_1), Some(Ordering::Greater));

                // Test open vs open
                assert_eq!(open_1.partial_cmp(&open_1), Some(Ordering::Equal));
                assert_eq!(open_1.partial_cmp(&open_2), Some(Ordering::Less));
                assert_eq!(open_2.partial_cmp(&open_1), Some(Ordering::Greater));

                // Test open vs closed with same value (open < closed for upper bounds)
                assert_eq!(open_1.partial_cmp(&closed_1), Some(Ordering::Less));
                assert_eq!(closed_1.partial_cmp(&open_1), Some(Ordering::Greater));

                // Test open vs closed with different values
                assert_eq!(open_1.partial_cmp(&closed_2), Some(Ordering::Less));
                assert_eq!(closed_1.partial_cmp(&open_2), Some(Ordering::Less));
            }

            #[test]
            fn test_interval_upper_bound_ordering_consistency() {
                let closed_1 = UpperBoundRuntime::Closed(UpperBoundClosed::new(1.0));
                let open_1 = UpperBoundRuntime::Open(UpperBoundOpen::new(1.0));
                let closed_2 = UpperBoundRuntime::Closed(UpperBoundClosed::new(2.0));
                let open_2 = UpperBoundRuntime::Open(UpperBoundOpen::new(2.0));

                // Create sorted list based on expected ordering
                // For upper bounds: smaller values < larger values, and open < closed for same value
                let bounds = vec![
                    open_1.clone(),
                    closed_1.clone(),
                    open_2.clone(),
                    closed_2.clone(),
                ];

                // Test that the ordering is consistent
                for i in 0..bounds.len() {
                    for j in i + 1..bounds.len() {
                        assert!(bounds[i] < bounds[j],);
                        assert!(bounds[j] > bounds[i],);
                    }
                }

                // Test sorting
                let mut shuffled = bounds.clone();
                shuffled.reverse();
                shuffled.sort_by(|a, b| a.partial_cmp(b).unwrap());
                assert_eq!(shuffled, bounds);
            }

            #[test]
            fn test_interval_upper_bound_edge_cases() {
                // Test with special floating point values
                let closed_zero = UpperBoundRuntime::Closed(UpperBoundClosed::new(0.0));
                let closed_neg_zero = UpperBoundRuntime::Closed(UpperBoundClosed::new(-0.0));
                let open_zero = UpperBoundRuntime::Open(UpperBoundOpen::new(0.0));

                // 0.0 and -0.0 should be equal
                assert_eq!(closed_zero, closed_neg_zero);

                // But closed and open should be different even with same value
                assert_ne!(closed_zero, open_zero);
                assert!(open_zero < closed_zero); // open < closed for upper bounds

                // Test with very small differences
                let closed_small = UpperBoundRuntime::Closed(UpperBoundClosed::new(1e-15));
                let open_small = UpperBoundRuntime::Open(UpperBoundOpen::new(1e-15));
                assert!(open_small < closed_small);
            }

            #[test]
            fn test_interval_upper_bound_transitivity() {
                let open_1 = UpperBoundRuntime::Open(UpperBoundOpen::new(1.0));
                let closed_1 = UpperBoundRuntime::Closed(UpperBoundClosed::new(1.0));
                let closed_2 = UpperBoundRuntime::Closed(UpperBoundClosed::new(2.0));

                // Test transitivity: if a < b and b < c, then a < c
                assert!(open_1 < closed_1);
                assert!(closed_1 < closed_2);
                assert!(open_1 < closed_2); // transitivity
            }

            #[test]
            fn test_interval_upper_bound_reflexivity() {
                let closed = UpperBoundRuntime::Closed(UpperBoundClosed::new(1.0));
                let open = UpperBoundRuntime::Open(UpperBoundOpen::new(1.0));

                // Test reflexivity: a == a
                assert_eq!(closed.partial_cmp(&closed), Some(Ordering::Equal));
                assert_eq!(open.partial_cmp(&open), Some(Ordering::Equal));
            }

            #[test]
            fn test_interval_upper_bound_antisymmetry() {
                let closed_1 = UpperBoundRuntime::Closed(UpperBoundClosed::new(1.0));
                let closed_2 = UpperBoundRuntime::Closed(UpperBoundClosed::new(2.0));
                let open_1 = UpperBoundRuntime::Open(UpperBoundOpen::new(1.0));

                // Test antisymmetry: if a <= b and b <= a, then a == b
                // (This should only happen when a == b)
                assert_eq!(closed_1.partial_cmp(&closed_1), Some(Ordering::Equal));

                // When a < b, then b > a (not equal)
                assert_eq!(closed_1.partial_cmp(&closed_2), Some(Ordering::Less));
                assert_eq!(closed_2.partial_cmp(&closed_1), Some(Ordering::Greater));

                assert_eq!(open_1.partial_cmp(&closed_1), Some(Ordering::Less));
                assert_eq!(closed_1.partial_cmp(&open_1), Some(Ordering::Greater));
            }

            #[test]
            fn test_min_upper_bound() {
                let closed_1 = UpperBoundRuntime::Closed(UpperBoundClosed::new(1.0));
                let open_1 = UpperBoundRuntime::Open(UpperBoundOpen::new(1.0));
                let closed_2 = UpperBoundRuntime::Closed(UpperBoundClosed::new(2.0));

                // min with same value, different types should be open (smaller for upper bounds)
                assert_eq!(min_upper_bound(closed_1.clone(), open_1.clone()), open_1);
                assert_eq!(min_upper_bound(open_1.clone(), closed_1.clone()), open_1);

                // min with different values
                assert_eq!(
                    min_upper_bound(closed_1.clone(), closed_2.clone()),
                    closed_1
                );
                assert_eq!(
                    min_upper_bound(closed_2.clone(), closed_1.clone()),
                    closed_1
                );

                // min with same bound should return that bound
                assert_eq!(
                    min_upper_bound(closed_1.clone(), closed_1.clone()),
                    closed_1
                );
            }

            #[test]
            fn test_max_upper_bound() {
                let closed_1 = UpperBoundRuntime::Closed(UpperBoundClosed::new(1.0));
                let open_1 = UpperBoundRuntime::Open(UpperBoundOpen::new(1.0));
                let closed_2 = UpperBoundRuntime::Closed(UpperBoundClosed::new(2.0));

                // max with same value, different types should be closed (larger for upper bounds)
                assert_eq!(max_upper_bound(closed_1.clone(), open_1.clone()), closed_1);
                assert_eq!(max_upper_bound(open_1.clone(), closed_1.clone()), closed_1);

                // max with different values
                assert_eq!(
                    max_upper_bound(closed_1.clone(), closed_2.clone()),
                    closed_2
                );
                assert_eq!(
                    max_upper_bound(closed_2.clone(), closed_1.clone()),
                    closed_2
                );

                // max with same bound should return that bound
                assert_eq!(
                    max_upper_bound(closed_1.clone(), closed_1.clone()),
                    closed_1
                );
            }

            #[test]
            fn test_interval_upper_bound_with_negative_values() {
                let closed_neg = UpperBoundRuntime::Closed(UpperBoundClosed::new(-5.0));
                let open_neg = UpperBoundRuntime::Open(UpperBoundOpen::new(-5.0));
                let closed_pos = UpperBoundRuntime::Closed(UpperBoundClosed::new(5.0));

                // Negative values should still follow the ordering rules
                assert!(open_neg < closed_neg);
                assert!(closed_neg < closed_pos);

                // More negative values should be smaller
                let closed_more_neg = UpperBoundRuntime::Closed(UpperBoundClosed::new(-10.0));
                assert!(closed_more_neg < closed_neg);
            }

            #[test]
            fn test_interval_upper_bound_with_large_values() {
                let closed_large = UpperBoundRuntime::Closed(UpperBoundClosed::new(1e6));
                let open_large = UpperBoundRuntime::Open(UpperBoundOpen::new(1e6));
                let closed_larger = UpperBoundRuntime::Closed(UpperBoundClosed::new(1e9));

                // Large values should still follow ordering
                assert!(open_large < closed_large);
                assert!(closed_large < closed_larger);

                // Should be consistent with regular values
                let closed_small = UpperBoundRuntime::Closed(UpperBoundClosed::new(1.0));
                assert!(closed_small < closed_large);
            }

            #[test]
            fn test_interval_upper_bound_boundary_semantics() {
                // Test the key difference between upper and lower bounds:
                // For upper bounds, open < closed (opposite of lower bounds)

                let open_5 = UpperBoundRuntime::Open(UpperBoundOpen::new(5.0));
                let closed_5 = UpperBoundRuntime::Closed(UpperBoundClosed::new(5.0));

                // For upper bounds: open is more restrictive (smaller) than closed
                assert!(open_5 < closed_5);
                assert!(closed_5 > open_5);

                // This reflects the fact that (-∞, 5) ⊂ (-∞, 5]
                // The open upper bound excludes the endpoint, making it "smaller"
            }
        }

        #[test]
        fn test_interval_lower_bound_partial_ord() {
            let closed_1 = LowerBoundRuntime::Closed(LowerBoundClosed::new(1.0));
            let closed_2 = LowerBoundRuntime::Closed(LowerBoundClosed::new(2.0));
            let open_1 = LowerBoundRuntime::Open(LowerBoundOpen::new(1.0));
            let open_2 = LowerBoundRuntime::Open(LowerBoundOpen::new(2.0));

            // Test closed vs closed
            assert_eq!(closed_1.partial_cmp(&closed_1), Some(Ordering::Equal));
            assert_eq!(closed_1.partial_cmp(&closed_2), Some(Ordering::Less));
            assert_eq!(closed_2.partial_cmp(&closed_1), Some(Ordering::Greater));

            // Test open vs open
            assert_eq!(open_1.partial_cmp(&open_1), Some(Ordering::Equal));
            assert_eq!(open_1.partial_cmp(&open_2), Some(Ordering::Less));
            assert_eq!(open_2.partial_cmp(&open_1), Some(Ordering::Greater));

            // Test closed vs open with same value (closed < open)
            assert_eq!(closed_1.partial_cmp(&open_1), Some(Ordering::Less));
            assert_eq!(open_1.partial_cmp(&closed_1), Some(Ordering::Greater));

            // Test closed vs open with different values
            assert_eq!(closed_1.partial_cmp(&open_2), Some(Ordering::Less));
            assert_eq!(open_1.partial_cmp(&closed_2), Some(Ordering::Less));
        }

        #[test]
        fn test_interval_lower_bound_ordering_consistency() {
            let closed_0 = LowerBoundRuntime::Closed(LowerBoundClosed::new(0.0));
            let closed_1 = LowerBoundRuntime::Closed(LowerBoundClosed::new(1.0));
            let open_0 = LowerBoundRuntime::Open(LowerBoundOpen::new(0.0));
            let open_1 = LowerBoundRuntime::Open(LowerBoundOpen::new(1.0));

            // Create sorted list based on expected ordering
            let bounds = vec![
                closed_0.clone(),
                open_0.clone(),
                closed_1.clone(),
                open_1.clone(),
            ];

            // Test that the ordering is consistent
            for i in 0..bounds.len() {
                for j in i + 1..bounds.len() {
                    assert!(bounds[i] < bounds[j],);
                    assert!(bounds[j] > bounds[i],);
                }
            }

            // Test sorting
            let mut shuffled = bounds.clone();
            shuffled.reverse();
            shuffled.sort_by(|a, b| a.partial_cmp(b).unwrap());
            assert_eq!(shuffled, bounds);
        }

        #[test]
        fn test_interval_lower_bound_edge_cases() {
            // Test with special floating point values
            let closed_zero = LowerBoundRuntime::Closed(LowerBoundClosed::new(0.0));
            let closed_neg_zero = LowerBoundRuntime::Closed(LowerBoundClosed::new(-0.0));
            let open_zero = LowerBoundRuntime::Open(LowerBoundOpen::new(0.0));

            // 0.0 and -0.0 should be equal
            assert_eq!(closed_zero, closed_neg_zero);

            // But closed and open should be different even with same value
            assert_ne!(closed_zero, open_zero);
            assert!(closed_zero < open_zero);

            // Test with very small differences
            let closed_small = LowerBoundRuntime::Closed(LowerBoundClosed::new(1e-15));
            let open_small = LowerBoundRuntime::Open(LowerBoundOpen::new(1e-15));
            assert!(closed_small < open_small);
        }

        #[test]
        fn test_interval_lower_bound_transitivity() {
            let closed_1 = LowerBoundRuntime::Closed(LowerBoundClosed::new(1.0));
            let open_1 = LowerBoundRuntime::Open(LowerBoundOpen::new(1.0));
            let closed_2 = LowerBoundRuntime::Closed(LowerBoundClosed::new(2.0));

            // Test transitivity: if a < b and b < c, then a < c
            assert!(closed_1 < open_1);

            assert!(open_1 < closed_2);
            assert!(closed_1 < closed_2); // transitivity
        }

        #[test]
        fn test_interval_lower_bound_reflexivity() {
            let closed = LowerBoundRuntime::Closed(LowerBoundClosed::new(1.0));
            let open = LowerBoundRuntime::Open(LowerBoundOpen::new(1.0));

            // Test reflexivity: a == a
            assert_eq!(closed.partial_cmp(&closed), Some(Ordering::Equal));
            assert_eq!(open.partial_cmp(&open), Some(Ordering::Equal));
        }

        #[test]
        fn test_interval_lower_bound_antisymmetry() {
            let closed_1 = LowerBoundRuntime::Closed(LowerBoundClosed::new(1.0));
            let closed_2 = LowerBoundRuntime::Closed(LowerBoundClosed::new(2.0));
            let open_1 = LowerBoundRuntime::Open(LowerBoundOpen::new(1.0));

            // Test antisymmetry: if a <= b and b <= a, then a == b
            // (This should only happen when a == b)
            assert_eq!(closed_1.partial_cmp(&closed_1), Some(Ordering::Equal));

            // When a < b, then b > a (not equal)
            assert_eq!(closed_1.partial_cmp(&closed_2), Some(Ordering::Less));
            assert_eq!(closed_2.partial_cmp(&closed_1), Some(Ordering::Greater));

            assert_eq!(closed_1.partial_cmp(&open_1), Some(Ordering::Less));
            assert_eq!(open_1.partial_cmp(&closed_1), Some(Ordering::Greater));
        }

        #[test]
        fn test_min_lower_bound() {
            let closed_1 = LowerBoundRuntime::Closed(LowerBoundClosed::new(1.0));
            let open_1 = LowerBoundRuntime::Open(LowerBoundOpen::new(1.0));
            let closed_2 = LowerBoundRuntime::Closed(LowerBoundClosed::new(2.0));

            // min with same value, different types should be closed (smaller)
            assert_eq!(min_lower_bound(closed_1.clone(), open_1.clone()), closed_1);
            assert_eq!(min_lower_bound(open_1.clone(), closed_1.clone()), closed_1);

            // min with different values
            assert_eq!(
                min_lower_bound(closed_1.clone(), closed_2.clone()),
                closed_1
            );
            assert_eq!(
                min_lower_bound(closed_2.clone(), closed_1.clone()),
                closed_1
            );

            // min with same bound should return that bound
            assert_eq!(
                min_lower_bound(closed_1.clone(), closed_1.clone()),
                closed_1
            );
        }

        #[test]
        fn test_max_lower_bound() {
            let closed_1 = LowerBoundRuntime::Closed(LowerBoundClosed::new(1.0));
            let open_1 = LowerBoundRuntime::Open(LowerBoundOpen::new(1.0));
            let closed_2 = LowerBoundRuntime::Closed(LowerBoundClosed::new(2.0));

            // max with same value, different types should be open (larger)
            assert_eq!(max_lower_bound(closed_1.clone(), open_1.clone()), open_1);
            assert_eq!(max_lower_bound(open_1.clone(), closed_1.clone()), open_1);

            // max with different values
            assert_eq!(
                max_lower_bound(closed_1.clone(), closed_2.clone()),
                closed_2
            );
            assert_eq!(
                max_lower_bound(closed_2.clone(), closed_1.clone()),
                closed_2
            );

            // max with same bound should return that bound
            assert_eq!(
                max_lower_bound(closed_1.clone(), closed_1.clone()),
                closed_1
            );
        }

        #[test]
        fn test_interval_lower_bound_with_negative_values() {
            let closed_neg = LowerBoundRuntime::Closed(LowerBoundClosed::new(-5.0));
            let open_neg = LowerBoundRuntime::Open(LowerBoundOpen::new(-5.0));
            let closed_pos = LowerBoundRuntime::Closed(LowerBoundClosed::new(5.0));

            // Negative values should still follow the ordering rules
            assert!(closed_neg < open_neg);
            assert!(open_neg < closed_pos);

            // More negative values should be smaller
            let closed_more_neg = LowerBoundRuntime::Closed(LowerBoundClosed::new(-10.0));
            assert!(closed_more_neg < closed_neg);
        }

        #[test]
        fn test_interval_lower_bound_with_large_values() {
            let closed_large = LowerBoundRuntime::Closed(LowerBoundClosed::new(1e6));
            let open_large = LowerBoundRuntime::Open(LowerBoundOpen::new(1e6));
            let closed_larger = LowerBoundRuntime::Closed(LowerBoundClosed::new(1e9));

            // Large values should still follow ordering
            assert!(closed_large < open_large);
            assert!(open_large < closed_larger);

            // Should be consistent with regular values
            let closed_small = LowerBoundRuntime::Closed(LowerBoundClosed::new(1.0));
            assert!(closed_small < closed_large);
        }
    }

    mod get_interval_bound_trait {
        use super::*;
        use crate::intervals::*;

        #[test]
        fn get_interval_bound_closed() {
            let interval = IntervalClosed::new(1.0, 2.0);

            let lower = interval.lower_bound_runtime().unwrap();
            assert_eq!(lower, LowerBoundRuntime::Closed(LowerBoundClosed::new(1.0)));

            let upper = interval.upper_bound_runtime().unwrap();
            assert_eq!(upper, UpperBoundRuntime::Closed(UpperBoundClosed::new(2.0)));
        }

        #[test]
        fn get_interval_bound_open() {
            let interval = IntervalOpen::new(1.0, 2.0);

            let lower = interval.lower_bound_runtime().unwrap();
            assert_eq!(lower, LowerBoundRuntime::Open(LowerBoundOpen::new(1.0)));

            let upper = interval.upper_bound_runtime().unwrap();
            assert_eq!(upper, UpperBoundRuntime::Open(UpperBoundOpen::new(2.0)));
        }

        #[test]
        fn get_interval_bound_left_open_upper_closed() {
            let interval = IntervalLowerOpenUpperClosed::new(1.0, 2.0);

            let lower = interval.lower_bound_runtime().unwrap();
            assert_eq!(lower, LowerBoundRuntime::Open(LowerBoundOpen::new(1.0)));

            let upper = interval.upper_bound_runtime().unwrap();
            assert_eq!(upper, UpperBoundRuntime::Closed(UpperBoundClosed::new(2.0)));
        }

        #[test]
        fn get_interval_bound_left_closed_upper_open() {
            let interval = IntervalLowerClosedUpperOpen::new(1.0, 2.0);

            let lower = interval.lower_bound_runtime().unwrap();
            assert_eq!(lower, LowerBoundRuntime::Closed(LowerBoundClosed::new(1.0)));

            let upper = interval.upper_bound_runtime().unwrap();
            assert_eq!(upper, UpperBoundRuntime::Open(UpperBoundOpen::new(2.0)));
        }

        #[test]
        fn get_interval_bound_lower_closed_upper_unbounded() {
            let interval = IntervalLowerClosedUpperUnbounded::new(1.0);

            let lower = interval.lower_bound_runtime().unwrap();
            assert_eq!(lower, LowerBoundRuntime::Closed(LowerBoundClosed::new(1.0)));

            let upper = interval.upper_bound_runtime();
            assert_eq!(upper, None);
        }

        #[test]
        fn get_interval_bound_lower_open_upper_unbounded() {
            let interval = IntervalLowerOpenUpperUnbounded::new(1.0);

            let lower = interval.lower_bound_runtime().unwrap();
            assert_eq!(lower, LowerBoundRuntime::Open(LowerBoundOpen::new(1.0)));

            let upper = interval.upper_bound_runtime();
            assert_eq!(upper, None);
        }

        #[test]
        fn get_interval_bound_lower_unbounded_upper_closed() {
            let interval = IntervalLowerUnboundedUpperClosed::new(2.0);

            let lower = interval.lower_bound_runtime();
            assert_eq!(lower, None);

            let upper = interval.upper_bound_runtime().unwrap();
            assert_eq!(upper, UpperBoundRuntime::Closed(UpperBoundClosed::new(2.0)));
        }

        #[test]
        fn get_interval_bound_lower_unbounded_upper_open() {
            let interval = IntervalLowerUnboundedUpperOpen::new(2.0);

            let lower = interval.lower_bound_runtime();
            assert_eq!(lower, None);

            let upper = interval.upper_bound_runtime().unwrap();
            assert_eq!(upper, UpperBoundRuntime::Open(UpperBoundOpen::new(2.0)));
        }

        #[test]
        fn get_interval_bound_singleton() {
            let interval = IntervalSingleton::new(1.5);

            let lower = interval.lower_bound_runtime().unwrap();
            assert_eq!(lower, LowerBoundRuntime::Closed(LowerBoundClosed::new(1.5)));

            let upper = interval.upper_bound_runtime().unwrap();
            assert_eq!(upper, UpperBoundRuntime::Closed(UpperBoundClosed::new(1.5)));
        }

        #[test]
        fn get_interval_bound_finite_length() {
            let closed = IntervalClosed::new(1.0, 2.0);
            let singleton = IntervalSingleton::new(1.5);
            let finite =
                IntervalFiniteLength::PositiveLength(IntervalFinitePositiveLength::Closed(closed));
            let zero = IntervalFiniteLength::ZeroLength(singleton);

            let lower = finite.lower_bound_runtime().unwrap();
            let upper = finite.upper_bound_runtime().unwrap();
            assert_eq!(lower, LowerBoundRuntime::Closed(LowerBoundClosed::new(1.0)));
            assert_eq!(upper, UpperBoundRuntime::Closed(UpperBoundClosed::new(2.0)));

            let lower = zero.lower_bound_runtime().unwrap();
            let upper = zero.upper_bound_runtime().unwrap();
            assert_eq!(lower, LowerBoundRuntime::Closed(LowerBoundClosed::new(1.5)));
            assert_eq!(upper, UpperBoundRuntime::Closed(UpperBoundClosed::new(1.5)));
        }

        #[test]
        fn get_interval_bound_finite_positive_length() {
            use crate::intervals::IntervalFinitePositiveLengthTrait;

            let closed = IntervalClosed::new(1.0, 2.0);
            let open = IntervalOpen::new(1.0, 2.0);
            let left = IntervalLowerOpenUpperClosed::new(1.0, 2.0);
            let right = IntervalLowerClosedUpperOpen::new(1.0, 2.0);

            let c = IntervalFinitePositiveLength::Closed(closed);
            let o = IntervalFinitePositiveLength::Open(open);
            let l = IntervalFinitePositiveLength::LowerOpenUpperClosed(left);
            let r = IntervalFinitePositiveLength::LowerClosedUpperOpen(right);

            let (lower, upper) = (c.lower_bound_runtime(), c.upper_bound_runtime());
            assert_eq!(
                lower.unwrap(),
                LowerBoundRuntime::Closed(LowerBoundClosed::new(1.0))
            );
            assert_eq!(
                upper.unwrap(),
                UpperBoundRuntime::Closed(UpperBoundClosed::new(2.0))
            );
            assert_eq!(c.clone().into_bounds_pair(), (1., 2.));

            let (lower, upper) = (o.lower_bound_runtime(), o.upper_bound_runtime());
            assert_eq!(
                lower.unwrap(),
                LowerBoundRuntime::Open(LowerBoundOpen::new(1.0))
            );
            assert_eq!(
                upper.unwrap(),
                UpperBoundRuntime::Open(UpperBoundOpen::new(2.0))
            );
            assert_eq!(o.clone().into_bounds_pair(), (1., 2.));

            let (lower, upper) = (l.lower_bound_runtime(), l.upper_bound_runtime());
            assert_eq!(
                lower.unwrap(),
                LowerBoundRuntime::Open(LowerBoundOpen::new(1.0))
            );
            assert_eq!(
                upper.unwrap(),
                UpperBoundRuntime::Closed(UpperBoundClosed::new(2.0))
            );
            assert_eq!(l.clone().into_bounds_pair(), (1., 2.));

            let (lower, upper) = (r.lower_bound_runtime(), r.upper_bound_runtime());
            assert_eq!(
                lower.unwrap(),
                LowerBoundRuntime::Closed(LowerBoundClosed::new(1.0))
            );
            assert_eq!(
                upper.unwrap(),
                UpperBoundRuntime::Open(UpperBoundOpen::new(2.0))
            );
            assert_eq!(r.clone().into_bounds_pair(), (1., 2.));
        }

        #[test]
        fn get_interval_bound_infinite_length() {
            let closed = IntervalLowerClosedUpperUnbounded::new(1.0);
            let open = IntervalLowerOpenUpperUnbounded::new(2.0);
            let right_closed = IntervalLowerUnboundedUpperClosed::new(3.0);
            let right_open = IntervalLowerUnboundedUpperOpen::new(4.0);
            let unbounded = IntervalLowerUnboundedUpperUnbounded::<f64>::new();

            let c = IntervalInfiniteLength::LowerClosedUpperUnbounded(closed);
            let o = IntervalInfiniteLength::LowerOpenUpperUnbounded(open);
            let rc = IntervalInfiniteLength::LowerUnboundedUpperClosed(right_closed);
            let ro = IntervalInfiniteLength::LowerUnboundedUpperOpen(right_open);
            let u = IntervalInfiniteLength::LowerUnboundedUpperUnbounded(unbounded);

            let (lower, upper) = (c.lower_bound_runtime(), c.upper_bound_runtime());
            assert_eq!(
                lower.unwrap(),
                LowerBoundRuntime::Closed(LowerBoundClosed::new(1.0))
            );
            assert_eq!(upper, None);

            let (lower, upper) = (o.lower_bound_runtime(), o.upper_bound_runtime());
            assert_eq!(
                lower.unwrap(),
                LowerBoundRuntime::Open(LowerBoundOpen::new(2.0))
            );
            assert_eq!(upper, None);

            let (lower, upper) = (rc.lower_bound_runtime(), rc.upper_bound_runtime());
            assert_eq!(lower, None);
            assert_eq!(
                upper.unwrap(),
                UpperBoundRuntime::Closed(UpperBoundClosed::new(3.0))
            );

            let (lower, upper) = (ro.lower_bound_runtime(), ro.upper_bound_runtime());
            assert_eq!(lower, None);
            assert_eq!(
                upper.unwrap(),
                UpperBoundRuntime::Open(UpperBoundOpen::new(4.0))
            );

            let (lower, upper) = (u.lower_bound_runtime(), u.upper_bound_runtime());
            assert_eq!(lower, None);
            assert_eq!(upper, None);
        }

        #[test]
        fn get_interval_bound_enum_wrappers() {
            let closed = IntervalClosed::new(1.0, 2.0);
            let finite =
                IntervalFiniteLength::PositiveLength(IntervalFinitePositiveLength::Closed(closed));
            let inf = IntervalInfiniteLength::LowerUnboundedUpperUnbounded(
                IntervalLowerUnboundedUpperUnbounded::<f64>::new(),
            );
            let interval = Interval::FiniteLength(finite.clone());
            let interval_inf = Interval::InfiniteLength(inf.clone());

            let (lower, upper) = (
                interval.lower_bound_runtime(),
                interval.upper_bound_runtime(),
            );
            assert_eq!(
                lower.unwrap(),
                LowerBoundRuntime::Closed(LowerBoundClosed::new(1.0))
            );
            assert_eq!(
                upper.unwrap(),
                UpperBoundRuntime::Closed(UpperBoundClosed::new(2.0))
            );

            let (lower, upper) = (
                interval_inf.lower_bound_runtime(),
                interval_inf.upper_bound_runtime(),
            );
            assert_eq!(lower, None);
            assert_eq!(upper, None);
        }

        #[test]
        fn get_interval_bound_subinterval_in_partition() {
            type S = SubIntervalInPartition<IntervalClosed<f64>>;
            let first = IntervalLowerClosedUpperOpen::new(1.0, 2.0);
            let last = IntervalClosed::new(2.0, 3.0);
            let s1 = S::First(first);
            let s2 = S::Last(last);

            let (lower, upper) = (s1.lower_bound_runtime(), s1.upper_bound_runtime());
            assert_eq!(
                lower,
                Some(LowerBoundRuntime::Closed(LowerBoundClosed::new(1.0)))
            );
            assert_eq!(
                upper,
                Some(UpperBoundRuntime::Open(UpperBoundOpen::new(2.0)))
            );

            let (lower, upper) = (s2.lower_bound_runtime(), s2.upper_bound_runtime());
            assert_eq!(
                lower,
                Some(LowerBoundRuntime::Closed(LowerBoundClosed::new(2.0)))
            );
            assert_eq!(
                upper,
                Some(UpperBoundRuntime::Closed(UpperBoundClosed::new(3.0)))
            );
        }
    }

    mod partial_ord {
        use super::*;

        #[test]
        fn partial_ord_lower_bound_structs() {
            let closed1 = LowerBoundClosed::new(1.0);
            let closed2 = LowerBoundClosed::new(2.0);
            let open1 = LowerBoundOpen::new(1.0);
            let open2 = LowerBoundOpen::new(2.0);

            assert!(closed1 < closed2);
            assert!(open1 < open2);
            assert!(closed1 < open2);
            assert!(open1 < closed2);
            assert!(closed1 < open1); // closed < open if same value
            assert!(open2 > closed1);
            assert!(closed1 <= closed1);
            assert!(open2 >= open2);
            assert!(!(closed1 == open1));
        }

        #[test]
        fn partial_ord_upper_bound_structs() {
            let closed1 = UpperBoundClosed::new(1.0);
            let closed2 = UpperBoundClosed::new(2.0);
            let open1 = UpperBoundOpen::new(1.0);
            let open2 = UpperBoundOpen::new(2.0);

            assert!(closed1 < closed2);
            assert!(open1 < open2);
            assert!(closed1 < open2);
            assert!(open1 < closed2);
            assert!(open1 < closed1); // open < closed if same value
            assert!(closed2 > open1);
            assert!(closed1 <= closed1);
            assert!(open2 >= open2);
            assert!(!(closed1 == open1));
        }

        #[test]
        fn partial_ord_interval_lower_bound_enum() {
            let closed = LowerBoundRuntime::Closed(LowerBoundClosed::new(1.0));
            let open = LowerBoundRuntime::Open(LowerBoundOpen::new(2.0));

            assert_eq!(closed.partial_cmp(&open), Some(std::cmp::Ordering::Less));
            assert_eq!(open.partial_cmp(&closed), Some(std::cmp::Ordering::Greater));
            assert_eq!(closed.partial_cmp(&closed), Some(std::cmp::Ordering::Equal));
            assert_eq!(open.partial_cmp(&open), Some(std::cmp::Ordering::Equal));
        }

        #[test]
        fn partial_ord_interval_upper_bound_enum() {
            let closed = UpperBoundRuntime::Closed(UpperBoundClosed::new(1.0));
            let open = UpperBoundRuntime::Open(UpperBoundOpen::new(2.0));

            assert_eq!(closed.partial_cmp(&open), Some(std::cmp::Ordering::Less));
            assert_eq!(open.partial_cmp(&closed), Some(std::cmp::Ordering::Greater));
            assert_eq!(closed.partial_cmp(&closed), Some(std::cmp::Ordering::Equal));
            assert_eq!(open.partial_cmp(&open), Some(std::cmp::Ordering::Equal));
        }

        #[test]
        fn partial_ord_interval_lower_bound_enum_same_value() {
            let closed = LowerBoundRuntime::Closed(LowerBoundClosed::new(1.0));
            let open = LowerBoundRuntime::Open(LowerBoundOpen::new(1.0));
            assert_eq!(closed.partial_cmp(&open), Some(std::cmp::Ordering::Less));
            assert_eq!(open.partial_cmp(&closed), Some(std::cmp::Ordering::Greater));
        }

        #[test]
        fn partial_ord_interval_upper_bound_enum_same_value() {
            let closed = UpperBoundRuntime::Closed(UpperBoundClosed::new(1.0));
            let open = UpperBoundRuntime::Open(UpperBoundOpen::new(1.0));
            assert_eq!(open.partial_cmp(&closed), Some(std::cmp::Ordering::Less));
            assert_eq!(closed.partial_cmp(&open), Some(std::cmp::Ordering::Greater));
        }
    }

    mod test_interval_bound_comparisons {
        use super::*;
        use try_create::TryNew;

        type Real = f64;

        /// Test PartialOrd implementation for LowerBoundRuntime
        #[test]
        fn test_interval_lower_bound_comparison() {
            // Create test bounds
            let lower_bound_closed_5 =
                LowerBoundRuntime::Closed(LowerBoundClosed::new(Real::try_new(5.0).unwrap()));
            let lower_bound_open_5 =
                LowerBoundRuntime::Open(LowerBoundOpen::new(Real::try_new(5.0).unwrap()));
            let lower_bound_closed_3 =
                LowerBoundRuntime::Closed(LowerBoundClosed::new(Real::try_new(3.0).unwrap()));
            let lower_bound_open_3 =
                LowerBoundRuntime::Open(LowerBoundOpen::new(Real::try_new(3.0).unwrap()));
            let lower_bound_closed_7 =
                LowerBoundRuntime::Closed(LowerBoundClosed::new(Real::try_new(7.0).unwrap()));

            // Test basic ordering by value
            assert_eq!(
                lower_bound_closed_3.partial_cmp(&lower_bound_closed_5),
                Some(Ordering::Less)
            );
            assert_eq!(
                lower_bound_closed_5.partial_cmp(&lower_bound_closed_3),
                Some(Ordering::Greater)
            );
            assert_eq!(
                lower_bound_closed_5.partial_cmp(&lower_bound_closed_5),
                Some(Ordering::Equal)
            );

            // Test ordering between closed and open bounds with same value
            // For lower bounds: closed < open at same value (closed is more restrictive for lower)
            assert_eq!(
                lower_bound_closed_5.partial_cmp(&lower_bound_open_5),
                Some(Ordering::Less)
            );
            assert_eq!(
                lower_bound_open_5.partial_cmp(&lower_bound_closed_5),
                Some(Ordering::Greater)
            );

            // Test mixed value and boundary type comparisons
            assert_eq!(
                lower_bound_closed_3.partial_cmp(&lower_bound_open_5),
                Some(Ordering::Less)
            );
            assert_eq!(
                lower_bound_open_3.partial_cmp(&lower_bound_closed_5),
                Some(Ordering::Less)
            );
            assert_eq!(
                lower_bound_closed_5.partial_cmp(&lower_bound_open_3),
                Some(Ordering::Greater)
            );

            // Test transitivity
            assert_eq!(
                lower_bound_closed_3.partial_cmp(&lower_bound_closed_7),
                Some(Ordering::Less)
            );
            assert_eq!(
                lower_bound_open_3.partial_cmp(&lower_bound_closed_7),
                Some(Ordering::Less)
            );
        }

        /// Test PartialOrd implementation for UpperBoundRuntime
        #[test]
        fn test_interval_upper_bound_comparison() {
            // Create test bounds
            let upper_bound_closed_5 =
                UpperBoundRuntime::Closed(UpperBoundClosed::new(Real::try_new(5.0).unwrap()));
            let upper_bound_open_5 =
                UpperBoundRuntime::Open(UpperBoundOpen::new(Real::try_new(5.0).unwrap()));
            let upper_bound_closed_3 =
                UpperBoundRuntime::Closed(UpperBoundClosed::new(Real::try_new(3.0).unwrap()));
            let upper_bound_open_3 =
                UpperBoundRuntime::Open(UpperBoundOpen::new(Real::try_new(3.0).unwrap()));
            let upper_bound_closed_7 =
                UpperBoundRuntime::Closed(UpperBoundClosed::new(Real::try_new(7.0).unwrap()));

            // Test basic ordering by value
            assert_eq!(
                upper_bound_closed_3.partial_cmp(&upper_bound_closed_5),
                Some(Ordering::Less)
            );
            assert_eq!(
                upper_bound_closed_5.partial_cmp(&upper_bound_closed_3),
                Some(Ordering::Greater)
            );
            assert_eq!(
                upper_bound_closed_5.partial_cmp(&upper_bound_closed_5),
                Some(Ordering::Equal)
            );

            // Test ordering between closed and open bounds with same value
            // For upper bounds: open < closed at same value (open is more restrictive for upper)
            assert_eq!(
                upper_bound_open_5.partial_cmp(&upper_bound_closed_5),
                Some(Ordering::Less)
            );
            assert_eq!(
                upper_bound_closed_5.partial_cmp(&upper_bound_open_5),
                Some(Ordering::Greater)
            );

            // Test mixed value and boundary type comparisons
            assert_eq!(
                upper_bound_closed_3.partial_cmp(&upper_bound_open_5),
                Some(Ordering::Less)
            );
            assert_eq!(
                upper_bound_open_3.partial_cmp(&upper_bound_closed_5),
                Some(Ordering::Less)
            );
            assert_eq!(
                upper_bound_closed_5.partial_cmp(&upper_bound_open_3),
                Some(Ordering::Greater)
            );

            // Test transitivity
            assert_eq!(
                upper_bound_closed_3.partial_cmp(&upper_bound_closed_7),
                Some(Ordering::Less)
            );
            assert_eq!(
                upper_bound_open_3.partial_cmp(&upper_bound_closed_7),
                Some(Ordering::Less)
            );
        }

        /// Test boundary type semantics for lower bounds
        #[test]
        fn test_lower_bound_semantics() {
            let closed_5 =
                LowerBoundRuntime::Closed(LowerBoundClosed::new(Real::try_new(5.0).unwrap()));
            let open_5 = LowerBoundRuntime::Open(LowerBoundOpen::new(Real::try_new(5.0).unwrap()));

            // For lower bounds, closed is more restrictive (smaller) than open at same value
            // This is because [5,b) contains 5, while (5,b) does not
            more_asserts::assert_lt!(closed_5, open_5);
            more_asserts::assert_ge!(open_5, closed_5);
            assert_ne!(closed_5, open_5);
        }

        /// Test boundary type semantics for upper bounds
        #[test]
        fn test_upper_bound_semantics() {
            let closed_5 =
                UpperBoundRuntime::Closed(UpperBoundClosed::new(Real::try_new(5.0).unwrap()));
            let open_5 = UpperBoundRuntime::Open(UpperBoundOpen::new(Real::try_new(5.0).unwrap()));

            // For upper bounds, open is more restrictive (smaller) than closed at same value
            // This is because [a,5) excludes 5, while [a,5] includes 5
            more_asserts::assert_lt!(open_5, closed_5);
            more_asserts::assert_ge!(closed_5, open_5);
            assert_ne!(open_5, closed_5);
        }

        /// Test consistency with mathematical interval ordering
        #[test]
        fn test_mathematical_consistency() {
            // Create bounds that would represent valid intervals
            let lower_closed_1 =
                LowerBoundRuntime::Closed(LowerBoundClosed::new(Real::try_new(1.0).unwrap()));
            let lower_open_1 =
                LowerBoundRuntime::Open(LowerBoundOpen::new(Real::try_new(1.0).unwrap()));
            let upper_open_2 =
                UpperBoundRuntime::Open(UpperBoundOpen::new(Real::try_new(2.0).unwrap()));
            let upper_closed_2 =
                UpperBoundRuntime::Closed(UpperBoundClosed::new(Real::try_new(2.0).unwrap()));

            // Mathematical consistency checks:
            // [1,2) should have closed lower bound and open upper bound
            // (1,2] should have open lower bound and closed upper bound
            // [1,2] should have closed bounds
            // (1,2) should have open bounds

            // Verify ordering is consistent with interval containment
            // [1,x] contains more points than (1,x] at the same x
            assert!(lower_closed_1 < lower_open_1);

            // [x,2) contains fewer points than [x,2] at the same x
            assert!(upper_open_2 < upper_closed_2);
        }

        /// Test reflexivity property
        #[test]
        fn test_reflexivity() {
            let lower_closed =
                LowerBoundRuntime::Closed(LowerBoundClosed::new(Real::try_new(5.0).unwrap()));
            let lower_open =
                LowerBoundRuntime::Open(LowerBoundOpen::new(Real::try_new(5.0).unwrap()));
            let upper_closed =
                UpperBoundRuntime::Closed(UpperBoundClosed::new(Real::try_new(5.0).unwrap()));
            let upper_open =
                UpperBoundRuntime::Open(UpperBoundOpen::new(Real::try_new(5.0).unwrap()));

            // Reflexivity: x.partial_cmp(&x) == Some(Ordering::Equal)
            assert_eq!(
                lower_closed.partial_cmp(&lower_closed),
                Some(Ordering::Equal)
            );
            assert_eq!(lower_open.partial_cmp(&lower_open), Some(Ordering::Equal));
            assert_eq!(
                upper_closed.partial_cmp(&upper_closed),
                Some(Ordering::Equal)
            );
            assert_eq!(upper_open.partial_cmp(&upper_open), Some(Ordering::Equal));
        }

        /// Test antisymmetry property
        #[test]
        fn test_antisymmetry() {
            let lower_closed_3 =
                LowerBoundRuntime::Closed(LowerBoundClosed::new(Real::try_new(3.0).unwrap()));
            let lower_closed_5 =
                LowerBoundRuntime::Closed(LowerBoundClosed::new(Real::try_new(5.0).unwrap()));

            // Antisymmetry: if x <= y and y <= x, then x == y
            if lower_closed_3.partial_cmp(&lower_closed_5) == Some(Ordering::Less) {
                assert_eq!(
                    lower_closed_5.partial_cmp(&lower_closed_3),
                    Some(Ordering::Greater)
                );
            }
        }

        /// Test transitivity property
        #[test]
        fn test_transitivity() {
            let lower_closed_1 =
                LowerBoundRuntime::Closed(LowerBoundClosed::new(Real::try_new(1.0).unwrap()));
            let lower_open_3 =
                LowerBoundRuntime::Open(LowerBoundOpen::new(Real::try_new(3.0).unwrap()));
            let lower_closed_5 =
                LowerBoundRuntime::Closed(LowerBoundClosed::new(Real::try_new(5.0).unwrap()));

            // Transitivity: if x <= y and y <= z, then x <= z
            let ord_1_3 = lower_closed_1.partial_cmp(&lower_open_3);
            let ord_3_5 = lower_open_3.partial_cmp(&lower_closed_5);
            let ord_1_5 = lower_closed_1.partial_cmp(&lower_closed_5);

            if ord_1_3 == Some(Ordering::Less) && ord_3_5 == Some(Ordering::Less) {
                assert_eq!(ord_1_5, Some(Ordering::Less));
            }
        }

        /// Test edge cases with same values but different boundary types
        #[test]
        fn test_edge_cases_same_values() {
            let value = Real::try_new(42.0).unwrap();

            let lower_closed = LowerBoundRuntime::Closed(LowerBoundClosed::new(value));
            let lower_open = LowerBoundRuntime::Open(LowerBoundOpen::new(value));
            let upper_closed = UpperBoundRuntime::Closed(UpperBoundClosed::new(value));
            let upper_open = UpperBoundRuntime::Open(UpperBoundOpen::new(value));

            // Test that boundary type matters even with same value
            assert_ne!(lower_closed.partial_cmp(&lower_open), Some(Ordering::Equal));
            assert_ne!(upper_closed.partial_cmp(&upper_open), Some(Ordering::Equal));

            // Verify specific ordering relationships
            assert_eq!(lower_closed.partial_cmp(&lower_open), Some(Ordering::Less));
            assert_eq!(upper_open.partial_cmp(&upper_closed), Some(Ordering::Less));
        }

        /// Test with extreme values
        #[test]
        fn test_extreme_values() {
            let min_val = Real::try_new(f64::MIN).unwrap();
            let max_val = Real::try_new(f64::MAX).unwrap();

            let lower_min_closed = LowerBoundRuntime::Closed(LowerBoundClosed::new(min_val));
            let lower_max_open = LowerBoundRuntime::Open(LowerBoundOpen::new(max_val));
            let upper_min_open = UpperBoundRuntime::Open(UpperBoundOpen::new(min_val));
            let upper_max_closed = UpperBoundRuntime::Closed(UpperBoundClosed::new(max_val));

            // Test that extreme values still follow ordering rules
            assert_eq!(
                lower_min_closed.partial_cmp(&lower_max_open),
                Some(Ordering::Less)
            );
            assert_eq!(
                upper_min_open.partial_cmp(&upper_max_closed),
                Some(Ordering::Less)
            );
        }

        /// Test helper functions min_lower_bound and max_lower_bound
        #[test]
        fn test_min_max_lower_bound() {
            let lower_closed_3 =
                LowerBoundRuntime::Closed(LowerBoundClosed::new(Real::try_new(3.0).unwrap()));
            let lower_open_5 =
                LowerBoundRuntime::Open(LowerBoundOpen::new(Real::try_new(5.0).unwrap()));

            // Test min_lower_bound
            let min_result = min_lower_bound(lower_closed_3.clone(), lower_open_5.clone());
            assert_eq!(min_result, lower_closed_3);

            // Test max_lower_bound
            let max_result = max_lower_bound(lower_closed_3.clone(), lower_open_5.clone());
            assert_eq!(max_result, lower_open_5);
        }

        /// Test helper functions min_upper_bound and max_upper_bound
        #[test]
        fn test_min_max_upper_bound() {
            let upper_open_3 =
                UpperBoundRuntime::Open(UpperBoundOpen::new(Real::try_new(3.0).unwrap()));
            let upper_closed_5 =
                UpperBoundRuntime::Closed(UpperBoundClosed::new(Real::try_new(5.0).unwrap()));

            // Test min_upper_bound
            let min_result = min_upper_bound(upper_open_3.clone(), upper_closed_5.clone());
            assert_eq!(min_result, upper_open_3);

            // Test max_upper_bound
            let max_result = max_upper_bound(upper_open_3.clone(), upper_closed_5.clone());
            assert_eq!(max_result, upper_closed_5);
        }
    }
}
//------------------------------------------------------------------------------------------------