grid1d 0.5.3

#![deny(rustdoc::broken_intra_doc_links)]

//! Runtime-dispatched bound representation for dynamic or serialization-driven contexts.
//!
//! This module provides [`IntervalBoundRuntime<RealType, Side>`] — an enum whose
//! `Open`/`Closed` variant is chosen at runtime rather than encoded in the type.
//! It complements the compile-time bound types when the boundary inclusion semantics
//! are not known until runtime (e.g. user input, deserialization, configuration files).
//!
//! ## Types
//!
//! | Type | Description |
//! |------|-------------|
//! | [`IntervalBoundRuntime<T, Side>`] | Enum with `Open(IntervalBound<T, Side, Open>)` and `Closed(IntervalBound<T, Side, Closed>)` variants |
//! | [`LowerBoundRuntime<T>`] | Type alias for `IntervalBoundRuntime<T, Lower>` |
//! | [`UpperBoundRuntime<T>`] | Type alias for `IntervalBoundRuntime<T, Upper>` |
//!
//! ## When to Use
//!
//! Prefer the compile-time typed bounds ([`LowerBoundClosed`](crate::bounds::LowerBoundClosed),
//! [`UpperBoundOpen`](crate::bounds::UpperBoundOpen), etc.) whenever the open/closed nature is
//! known at compile time — they are zero-cost abstractions with stronger type guarantees.
//! Use the runtime enum when:
//!
//! - Constructing bounds from user input or configuration
//! - Deserializing bounds from JSON / other formats
//! - Writing algorithms that must handle both open and closed bounds generically
//!
//! ## Example
//!
//! ```rust
//! use grid1d::bounds::*;
//! use try_create::New;
//!
//! fn make_lower(value: f64, closed: bool) -> LowerBoundRuntime<f64> {
//!     if closed {
//!         IntervalBoundRuntime::Closed(LowerBoundClosed::new(value))
//!     } else {
//!         IntervalBoundRuntime::Open(LowerBoundOpen::new(value))
//!     }
//! }
//!
//! let b = make_lower(0.0, true);
//! assert!(b.is_closed());
//! assert!(b.value_within_bound(&0.0));
//! ```

use crate::bounds::{
    IntervalBound,
    markers::{Closed, Lower, Open, Upper},
    traits::{BoundChecks, BoundSide, BoundSideChecks, BoundTypeChecks, ValueWithinBound},
};
use duplicate::duplicate_item;
use num_valid::RealScalar;
use serde::{Deserialize, Serialize};
use std::{cmp::Ordering, fmt::Debug};
use try_create::{IntoInner, New};

//------------------------------------------------------------------------------------------------
/// Runtime-determined bound type that can be either open or closed.
///
/// [`IntervalBoundRuntime<RealType, Side>`] provides a unified enum for representing bounds
/// where the open/closed nature needs to be determined at runtime rather than
/// compile time. This is essential for dynamic interval construction, serialization,
/// configuration-driven applications, and algorithms that need to work with varying
/// boundary semantics.
///
/// ## Design Philosophy
///
/// ### Compile-Time vs Runtime Trade-offs
///
/// Unlike the compile-time typed bounds ([`LowerBoundOpen`](crate::bounds::LowerBoundOpen), [`LowerBoundClosed`](crate::bounds::LowerBoundClosed), etc.),
/// this enum moves the open/closed distinction from compile time to runtime:
///
/// | Aspect | Compile-Time Bounds | Runtime Bounds |
/// |--------|-------------------|----------------|
/// | **Type Safety** | ✅ Cannot mix open/closed at compile time | ❌ Open/closed confusion possible |
/// | **Performance** | ✅ Zero-cost abstractions, inlined | ⚡ Small pattern matching overhead |
/// | **Flexibility** | ❌ Fixed at compile time | ✅ Can change dynamically |
/// | **Serialization** | ❌ Complex (type information lost) | ✅ Natural enum serialization |
/// | **User Input** | ❌ Requires compile-time knowledge | ✅ Can handle dynamic input |
///
/// ### When to Use Runtime Bounds
///
/// ```rust
/// use grid1d::bounds::*;
/// use try_create::New;
///
/// // ✅ GOOD: Dynamic interval construction from user input
/// fn create_bound_from_config(value: f64, is_closed: bool) -> LowerBoundRuntime<f64> {
///     if is_closed {
///         IntervalBoundRuntime::Closed(LowerBoundClosed::new(value))
///     } else {
///         IntervalBoundRuntime::Open(LowerBoundOpen::new(value))
///     }
/// }
///
/// // ✅ GOOD: Serialization scenarios
/// let bound = create_bound_from_config(0.0, true);
/// let serialized = serde_json::to_string(&bound).unwrap();
/// let deserialized: LowerBoundRuntime<f64> = serde_json::from_str(&serialized).unwrap();
///
/// // ❌ AVOID: When bound type is known at compile time
/// fn bad_usage() -> LowerBoundRuntime<f64> {
///     // This should just be LowerBoundClosed::new(0.0)
///     IntervalBoundRuntime::Closed(LowerBoundClosed::new(0.0))
/// }
/// ```
///
/// ## Type Parameters
///
/// - **`RealType`**: Any scalar type implementing [`num_valid::RealScalar`]
/// - **`Side`**: Either [`Lower`] or [`Upper`] boundary side marker
///
/// ## Variants
///
/// ### [`IntervalBoundRuntime::Open`]
///
/// Contains an open bound that excludes the boundary value:
///
/// ```rust
/// use grid1d::bounds::*;
/// use try_create::New;
///
/// let open_lower = IntervalBoundRuntime::Open(LowerBoundOpen::new(5.0));
/// let open_upper = IntervalBoundRuntime::Open(UpperBoundOpen::new(10.0));
///
/// // Open bounds exclude their boundary values
/// assert!(!open_lower.value_within_bound(&5.0));   // 5 > 5 → false
/// assert!(!open_upper.value_within_bound(&10.0));  // 10 < 10 → false
///
/// // But include nearby values
/// assert!(open_lower.value_within_bound(&5.1));    // 5.1 > 5 → true
/// assert!(open_upper.value_within_bound(&9.9));    // 9.9 < 10 → true
/// ```
///
/// ### [`IntervalBoundRuntime::Closed`]
///
/// Contains a closed bound that includes the boundary value:
///
/// ```rust
/// use grid1d::bounds::*;
/// use try_create::New;
///
/// let closed_lower = IntervalBoundRuntime::Closed(LowerBoundClosed::new(5.0));
/// let closed_upper = IntervalBoundRuntime::Closed(UpperBoundClosed::new(10.0));
///
/// // Closed bounds include their boundary values
/// assert!(closed_lower.value_within_bound(&5.0));   // 5 ≥ 5 → true
/// assert!(closed_upper.value_within_bound(&10.0));  // 10 ≤ 10 → true
///
/// // And also include nearby values
/// assert!(closed_lower.value_within_bound(&5.1));   // 5.1 ≥ 5 → true
/// assert!(closed_upper.value_within_bound(&9.9));   // 9.9 ≤ 10 → true
/// ```
///
/// ## Type Aliases for Convenience
///
/// ```rust
/// use grid1d::bounds::*;
/// use try_create::New;
///
/// // Specific side aliases for cleaner code
/// type LowerBoundRuntime<T> = IntervalBoundRuntime<T, Lower>;
/// type UpperBoundRuntime<T> = IntervalBoundRuntime<T, Upper>;
///
/// // Usage examples
/// let lower: LowerBoundRuntime<f64> = IntervalBoundRuntime::Closed(LowerBoundClosed::new(0.0));
/// let upper: UpperBoundRuntime<f64> = IntervalBoundRuntime::Open(UpperBoundOpen::new(1.0));
/// ```
///
/// ## Core Operations
///
/// ### Boundary Constraint Testing
///
/// All runtime bounds implement [`BoundTypeChecks`] and provide constraint validation:
///
/// ```rust
/// use grid1d::bounds::*;
/// use num_valid::RealScalar;
/// use try_create::New;
///
/// fn test_constraint<T: RealScalar>(
///     bound: &IntervalBoundRuntime<T, Lower>,
///     test_value: &T
/// ) -> bool {
///     match bound {
///         IntervalBoundRuntime::Open(open_bound) => {
///             open_bound.value_within_bound(test_value)  // x > bound_value
///         }
///         IntervalBoundRuntime::Closed(closed_bound) => {
///             closed_bound.value_within_bound(test_value)  // x ≥ bound_value
///         }
///     }
/// }
///
/// let open_bound = IntervalBoundRuntime::Open(LowerBoundOpen::new(5.0));
/// let closed_bound = IntervalBoundRuntime::Closed(LowerBoundClosed::new(5.0));
///
/// assert!(!test_constraint(&open_bound, &5.0));    // 5 > 5 → false
/// assert!(test_constraint(&closed_bound, &5.0));   // 5 ≥ 5 → true
/// ```
///
/// ### Value Access and Manipulation
///
/// ```rust
/// use grid1d::bounds::*;
/// use try_create::{New, IntoInner};
///
/// let bound = IntervalBoundRuntime::Closed(LowerBoundClosed::new(3.14));
///
/// // Access the underlying value
/// 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);
/// ```
///
/// ### Type Information Queries
///
/// ```rust
/// use grid1d::bounds::*;
/// use try_create::New;
///
/// let open_bound = IntervalBoundRuntime::Open(LowerBoundOpen::new(1.0));
/// let closed_bound = IntervalBoundRuntime::Closed(UpperBoundClosed::new(2.0));
///
/// // Query boundary inclusion behavior
/// assert!(open_bound.is_open());
/// assert!(!open_bound.is_closed());
/// assert!(!open_bound.includes_boundary());
///
/// assert!(!closed_bound.is_open());
/// assert!(closed_bound.is_closed());
/// assert!(closed_bound.includes_boundary());
/// ```
///
/// ## Conversion Patterns
///
/// ### From Compile-Time to Runtime Bounds
///
/// ```rust
/// use grid1d::bounds::*;
/// use try_create::New;
///
/// // Automatic conversion via From trait
/// let compile_time_bound = LowerBoundClosed::new(5.0);
/// let runtime_bound: LowerBoundRuntime<f64> = compile_time_bound.into();
///
/// match runtime_bound {
///     IntervalBoundRuntime::Closed(bound) => {
///         println!("Converted to runtime closed bound: {}", bound.as_ref());
///     }
///     IntervalBoundRuntime::Open(_) => unreachable!(),
/// }
/// ```
///
/// ### Collection of Mixed Bound Types
///
/// ```rust
/// use grid1d::bounds::*;
/// use try_create::New;
///
/// // Store different bound types in the same collection
/// let bounds: Vec<LowerBoundRuntime<f64>> = vec![
///     LowerBoundClosed::new(0.0).into(),
///     LowerBoundOpen::new(1.0).into(),
///     LowerBoundClosed::new(2.0).into(),
///     LowerBoundOpen::new(3.0).into(),
/// ];
///
/// // Process them uniformly
/// for (i, bound) in bounds.iter().enumerate() {
///     let inclusion = if bound.is_closed() { "includes" } else { "excludes" };
///     println!("Bound {}: {} (value {})", i, inclusion, bound.as_ref());
/// }
/// ```
///
/// ## Mathematical Ordering
///
/// Runtime bounds maintain the same mathematical ordering as their compile-time counterparts:
///
/// ```rust
/// use grid1d::bounds::*;
/// use try_create::New;
///
/// let closed_lower = LowerBoundRuntime::Closed(LowerBoundClosed::new(5.0));
/// let open_lower = LowerBoundRuntime::Open(LowerBoundOpen::new(5.0));
///
/// // For lower bounds: closed is "tighter" than open
/// assert!(closed_lower < open_lower);  // [5 < (5
///
/// let open_upper = UpperBoundRuntime::Open(UpperBoundOpen::new(5.0));
/// let closed_upper = UpperBoundRuntime::Closed(UpperBoundClosed::new(5.0));
///
/// // For upper bounds: open is "tighter" than closed
/// assert!(open_upper < closed_upper);  // 5) < 5]
/// ```
///
/// ## Serialization Support
///
/// Runtime bounds have natural serialization support via `serde`:
///
/// ```rust
/// use grid1d::bounds::*;
/// use try_create::New;
/// use serde_json;
///
/// let bounds = vec![
///     LowerBoundRuntime::Closed(LowerBoundClosed::new(0.0)),
///     LowerBoundRuntime::Open(LowerBoundOpen::new(1.0)),
/// ];
///
/// // Serialize to JSON
/// let json = serde_json::to_string_pretty(&bounds).unwrap();
/// println!("Serialized bounds:\n{}", json);
///
/// // Deserialize back
/// let deserialized: Vec<LowerBoundRuntime<f64>> =
///     serde_json::from_str(&json).unwrap();
///
/// assert_eq!(bounds.len(), deserialized.len());
/// for (original, restored) in bounds.iter().zip(deserialized.iter()) {
///     assert_eq!(original.as_ref(), restored.as_ref());
///     assert_eq!(original.is_closed(), restored.is_closed());
/// }
/// ```
///
/// ## Advanced Usage Patterns
///
/// ### Dynamic Interval Construction
///
/// ```rust
/// use grid1d::bounds::*;
/// use try_create::New;
///
/// struct IntervalConfig {
///     lower_value: f64,
///     lower_closed: bool,
///     upper_value: f64,
///     upper_closed: bool,
/// }
///
/// fn create_dynamic_interval(config: IntervalConfig) -> (LowerBoundRuntime<f64>, UpperBoundRuntime<f64>) {
///     let lower = if config.lower_closed {
///         IntervalBoundRuntime::Closed(LowerBoundClosed::new(config.lower_value))
///     } else {
///         IntervalBoundRuntime::Open(LowerBoundOpen::new(config.lower_value))
///     };
///     
///     let upper = if config.upper_closed {
///         IntervalBoundRuntime::Closed(UpperBoundClosed::new(config.upper_value))
///     } else {
///         IntervalBoundRuntime::Open(UpperBoundOpen::new(config.upper_value))
///     };
///     
///     (lower, upper)
/// }
///
/// // Create different interval types from configuration
/// let closed_interval = create_dynamic_interval(IntervalConfig {
///     lower_value: 0.0, lower_closed: true,
///     upper_value: 1.0, upper_closed: true,
/// }); // Represents [0, 1]
///
/// let half_open_interval = create_dynamic_interval(IntervalConfig {
///     lower_value: 0.0, lower_closed: true,
///     upper_value: 1.0, upper_closed: false,
/// }); // Represents [0, 1)
/// ```
///
/// ### Generic Algorithm Implementation
///
/// ```rust
/// use grid1d::bounds::*;
/// use num_valid::RealScalar;
/// use try_create::New;
///
/// fn find_overlapping_bounds<T: RealScalar + std::fmt::Display>(
///     bounds: &[IntervalBoundRuntime<T, Lower>],
///     test_value: &T
/// ) -> Vec<usize> {
///     bounds.iter()
///         .enumerate()
///         .filter_map(|(i, bound)| {
///             let satisfies = match bound {
///                 IntervalBoundRuntime::Open(open_bound) => {
///                     open_bound.value_within_bound(test_value)
///                 }
///                 IntervalBoundRuntime::Closed(closed_bound) => {
///                     closed_bound.value_within_bound(test_value)
///                 }
///             };
///             if satisfies { Some(i) } else { None }
///         })
///         .collect()
/// }
///
/// let bounds = vec![
///     IntervalBoundRuntime::Closed(LowerBoundClosed::new(0.0)),  // [0 - includes 0.0
///     IntervalBoundRuntime::Open(LowerBoundOpen::new(0.0)),      // (0 - excludes 0.0
///     IntervalBoundRuntime::Closed(LowerBoundClosed::new(1.0)),  // [1 - excludes 0.0
/// ];
///
/// let overlapping = find_overlapping_bounds(&bounds, &0.0);
/// assert_eq!(overlapping, vec![0]); // Only the closed bound includes 0.0
/// ```
///
/// ## Performance Characteristics
///
/// ### Memory Layout
/// - **Size**: Same as underlying [`IntervalBound`] plus enum discriminant
/// - **Alignment**: Natural alignment of the largest variant
/// - **Overhead**: One byte discriminant plus potential padding
///
/// ### Operation Complexity
/// | Operation | Time | Notes |
/// |-----------|------|-------|
/// | Construction | O(1) | Simple enum wrapping |
/// | Pattern matching | O(1) | Compile-time branch prediction |
/// | Value access | O(1) | Direct field access |
/// | Constraint testing | O(1) | Inlined comparison operations |
/// | Serialization | O(1) | Direct enum serialization |
///
/// ### Performance vs Compile-Time Bounds
///
/// ```rust
/// use grid1d::bounds::*;
///
/// // Runtime bounds: small pattern matching overhead
/// fn check_runtime_bound(bound: &LowerBoundRuntime<f64>, value: f64) -> bool {
///     match bound {  // Small branching cost
///         IntervalBoundRuntime::Open(b) => value > *b.as_ref(),
///         IntervalBoundRuntime::Closed(b) => value >= *b.as_ref(),
///     }
/// }
///
/// // Compile-time bounds: zero overhead
/// fn check_compile_time_bound<T: BoundType>(bound: &LowerBound<f64, T>, value: f64) -> bool {
///     if T::is_open() {
///         value > *bound.as_ref()  // Optimized to direct comparison
///     } else {
///         value >= *bound.as_ref() // Optimized to direct comparison
///     }
/// }
/// ```
///
/// ## Best Practices
///
/// ### When to Use Runtime Bounds
/// - ✅ **User input**: Boundary types determined by configuration
/// - ✅ **Serialization**: Saving/loading interval data
/// - ✅ **Dynamic algorithms**: Boundary types vary during execution
/// - ✅ **Heterogeneous collections**: Storing different bound types together
///
/// ### When to Use Compile-Time Bounds
/// - ✅ **Known constraints**: Boundary types fixed at compile time
/// - ✅ **Performance critical**: Zero-overhead abstractions required
/// - ✅ **Type safety**: Prevent mixing incompatible boundary types
/// - ✅ **Generic algorithms**: Type-parameterized over boundary semantics
///
/// ### Conversion Strategy
/// ```rust
/// use grid1d::bounds::*;
/// use try_create::New;
///
/// // Pattern: Convert from runtime to compile-time when possible
/// fn extract_closed_bound(bound: LowerBoundRuntime<f64>) -> Option<LowerBoundClosed<f64>> {
///     match bound {
///         IntervalBoundRuntime::Closed(closed_bound) => Some(closed_bound),
///         IntervalBoundRuntime::Open(_) => None,
///     }
/// }
///
/// // Pattern: Use runtime bounds at API boundaries, compile-time internally
/// fn process_user_interval(
///     lower: LowerBoundRuntime<f64>,
///     upper: UpperBoundRuntime<f64>
/// ) -> String {
///     match (lower, upper) {
///         (IntervalBoundRuntime::Closed(l), IntervalBoundRuntime::Closed(u)) => {
///             process_closed_interval(l, u)  // Delegate to compile-time version
///         }
///         (IntervalBoundRuntime::Open(l), IntervalBoundRuntime::Open(u)) => {
///             process_open_interval(l, u)    // Delegate to compile-time version
///         }
///         // Handle mixed cases...
///         _ => "Mixed interval types".to_string(),
///     }
/// }
///
/// fn process_closed_interval(
///     lower: LowerBoundClosed<f64>,
///     upper: UpperBoundClosed<f64>
/// ) -> String {
///     format!("Closed interval: [{}, {}]", lower.as_ref(), upper.as_ref())
/// }
///
/// fn process_open_interval(
///     lower: LowerBoundOpen<f64>,
///     upper: UpperBoundOpen<f64>
/// ) -> String {
///     format!("Open interval: ({}, {})", lower.as_ref(), upper.as_ref())
/// }
/// ```
///
/// ## Integration with Grid1D
///
/// Runtime bounds integrate seamlessly with the broader grid1d ecosystem:
///
/// ```rust
/// use grid1d::{bounds::*, intervals::*};
/// use try_create::{IntoInner, New};
///
/// // Convert runtime bounds to actual intervals when needed
/// fn runtime_bounds_to_interval(
///     lower: LowerBoundRuntime<f64>,
///     upper: UpperBoundRuntime<f64>
/// ) -> Box<dyn std::fmt::Debug> {
///     match (lower, upper) {
///         (IntervalBoundRuntime::Closed(l), IntervalBoundRuntime::Closed(u)) => {
///             Box::new(IntervalClosed::new(l.into_inner(), u.into_inner()))
///         }
///         (IntervalBoundRuntime::Open(l), IntervalBoundRuntime::Open(u)) => {
///             Box::new(IntervalOpen::new(l.into_inner(), u.into_inner()))
///         }
///         (IntervalBoundRuntime::Closed(l), IntervalBoundRuntime::Open(u)) => {
///             Box::new(IntervalLowerClosedUpperOpen::new(l.into_inner(), u.into_inner()))
///         }
///         (IntervalBoundRuntime::Open(l), IntervalBoundRuntime::Closed(u)) => {
///             Box::new(IntervalLowerOpenUpperClosed::new(l.into_inner(), u.into_inner()))
///         }
///     }
/// }
/// ```
///
/// The [`IntervalBoundRuntime`] enum provides essential flexibility for dynamic interval
/// construction while maintaining mathematical correctness and integration with the
/// grid1d type system. Use it when runtime flexibility is needed, but prefer
/// compile-time bounds when the boundary semantics are known statically.
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[serde(bound(deserialize = "RealType: for<'a> Deserialize<'a>"))]
pub enum IntervalBoundRuntime<RealType: RealScalar, Side: BoundSide> {
    /// An open (exclusive) interval bound.
    Open(IntervalBound<RealType, Side, Open>),
    /// A closed (inclusive) interval bound.
    Closed(IntervalBound<RealType, Side, Closed>),
}

impl<RealType: RealScalar, Side: BoundSide> IntervalBoundRuntime<RealType, Side> {
    /// Create a new open (exclusive) runtime bound.
    ///
    /// This is a convenience constructor that creates an open bound variant without
    /// requiring explicit construction of the underlying [`IntervalBound`].
    ///
    /// # Mathematical Meaning
    ///
    /// - For **lower bounds**: Creates `x > value` constraint (excludes the boundary)
    /// - For **upper bounds**: Creates `x < value` constraint (excludes the boundary)
    ///
    /// # Examples
    ///
    /// ## Lower Bound
    ///
    /// ```rust
    /// use grid1d::bounds::*;
    ///
    /// let lower_open: LowerBoundRuntime<f64> = IntervalBoundRuntime::new_open(5.0);
    ///
    /// // Excludes the boundary value
    /// assert!(!lower_open.value_within_bound(&5.0));  // 5 > 5 → false
    /// assert!(lower_open.value_within_bound(&5.1));   // 5.1 > 5 → true
    /// assert!(!lower_open.value_within_bound(&4.9));  // 4.9 > 5 → false
    ///
    /// assert!(lower_open.is_open());
    /// assert!(lower_open.is_open_variant());
    /// ```
    ///
    /// ## Upper Bound
    ///
    /// ```rust
    /// use grid1d::bounds::*;
    ///
    /// let upper_open: UpperBoundRuntime<f64> = IntervalBoundRuntime::new_open(10.0);
    ///
    /// // Excludes the boundary value
    /// assert!(!upper_open.value_within_bound(&10.0));  // 10 < 10 → false
    /// assert!(upper_open.value_within_bound(&9.9));    // 9.9 < 10 → true
    /// assert!(!upper_open.value_within_bound(&10.1));  // 10.1 < 10 → false
    ///
    /// assert!(upper_open.is_open());
    /// assert!(upper_open.is_open_variant());
    /// ```
    ///
    /// ## Comparison with Manual Construction
    ///
    /// ```rust
    /// use grid1d::bounds::*;
    /// use try_create::New;
    ///
    /// // Using convenience constructor (cleaner)
    /// let bound1: LowerBoundRuntime<f64> = IntervalBoundRuntime::new_open(5.0);
    ///
    /// // Manual construction (more verbose)
    /// let bound2: LowerBoundRuntime<f64> =
    ///     IntervalBoundRuntime::Open(LowerBoundOpen::new(5.0));
    ///
    /// assert_eq!(bound1, bound2);
    /// ```
    ///
    /// # See Also
    ///
    /// - [`new_closed`](Self::new_closed) - Create a closed (inclusive) bound
    /// - [`is_open_variant`](Self::is_open_variant) - Check if bound is open
    #[must_use]
    pub fn new_open(value: RealType) -> Self {
        Self::Open(IntervalBound::<RealType, Side, Open>::new(value))
    }

    /// Create a new closed (inclusive) runtime bound.
    ///
    /// This is a convenience constructor that creates a closed bound variant without
    /// requiring explicit construction of the underlying [`IntervalBound`].
    ///
    /// # Mathematical Meaning
    ///
    /// - For **lower bounds**: Creates `x ≥ value` constraint (includes the boundary)
    /// - For **upper bounds**: Creates `x ≤ value` constraint (includes the boundary)
    ///
    /// # Examples
    ///
    /// ## Lower Bound
    ///
    /// ```rust
    /// use grid1d::bounds::*;
    ///
    /// let lower_closed: LowerBoundRuntime<f64> = IntervalBoundRuntime::new_closed(5.0);
    ///
    /// // Includes the boundary value
    /// assert!(lower_closed.value_within_bound(&5.0));  // 5 ≥ 5 → true
    /// assert!(lower_closed.value_within_bound(&5.1));  // 5.1 ≥ 5 → true
    /// assert!(!lower_closed.value_within_bound(&4.9)); // 4.9 ≥ 5 → false
    ///
    /// assert!(lower_closed.is_closed());
    /// assert!(lower_closed.is_closed_variant());
    /// ```
    ///
    /// ## Upper Bound
    ///
    /// ```rust
    /// use grid1d::bounds::*;
    ///
    /// let upper_closed: UpperBoundRuntime<f64> = IntervalBoundRuntime::new_closed(10.0);
    ///
    /// // Includes the boundary value
    /// assert!(upper_closed.value_within_bound(&10.0));  // 10 ≤ 10 → true
    /// assert!(upper_closed.value_within_bound(&9.9));   // 9.9 ≤ 10 → true
    /// assert!(!upper_closed.value_within_bound(&10.1)); // 10.1 ≤ 10 → false
    ///
    /// assert!(upper_closed.is_closed());
    /// assert!(upper_closed.is_closed_variant());
    /// ```
    ///
    /// ## Comparison with Manual Construction
    ///
    /// ```rust
    /// use grid1d::bounds::*;
    /// use try_create::New;
    ///
    /// // Using convenience constructor (cleaner)
    /// let bound1: LowerBoundRuntime<f64> = IntervalBoundRuntime::new_closed(5.0);
    ///
    /// // Manual construction (more verbose)
    /// let bound2: LowerBoundRuntime<f64> =
    ///     IntervalBoundRuntime::Closed(LowerBoundClosed::new(5.0));
    ///
    /// assert_eq!(bound1, bound2);
    /// ```
    ///
    /// # See Also
    ///
    /// - [`new_open`](Self::new_open) - Create an open (exclusive) bound
    /// - [`is_closed_variant`](Self::is_closed_variant) - Check if bound is closed
    #[must_use]
    pub fn new_closed(value: RealType) -> Self {
        Self::Closed(IntervalBound::<RealType, Side, Closed>::new(value))
    }

    /// Check if this runtime bound is a closed variant without consuming it.
    ///
    /// This method provides a non-consuming way to check the bound type, which is useful
    /// when you need to inspect the bound type without pattern matching or when you want
    /// to check the type multiple times.
    ///
    /// # Returns
    ///
    /// - `true` if the bound is [`IntervalBoundRuntime::Closed`]
    /// - `false` if the bound is [`IntervalBoundRuntime::Open`]
    ///
    /// # Performance
    ///
    /// This is a zero-cost check that compiles to a simple discriminant comparison.
    ///
    /// # Examples
    ///
    /// ## Basic Usage
    ///
    /// ```rust
    /// use grid1d::bounds::*;
    ///
    /// let closed_bound: LowerBoundRuntime<f64> = IntervalBoundRuntime::new_closed(5.0);
    /// let open_bound: LowerBoundRuntime<f64> = IntervalBoundRuntime::new_open(5.0);
    ///
    /// assert!(closed_bound.is_closed_variant());
    /// assert!(!open_bound.is_closed_variant());
    /// ```
    ///
    /// ## Conditional Logic
    ///
    /// ```rust
    /// use grid1d::bounds::*;
    ///
    /// fn describe_bound(bound: &LowerBoundRuntime<f64>) -> String {
    ///     let inclusion = if bound.is_closed_variant() {
    ///         "inclusive"
    ///     } else {
    ///         "exclusive"
    ///     };
    ///     format!("Lower bound at {} ({})", bound.as_ref(), inclusion)
    /// }
    ///
    /// let bound = IntervalBoundRuntime::new_closed(10.0);
    /// assert_eq!(describe_bound(&bound), "Lower bound at 10 (inclusive)");
    /// ```
    ///
    /// ## Difference from `is_closed()` Trait Method
    ///
    /// ```rust
    /// use grid1d::bounds::*;
    ///
    /// let bound: LowerBoundRuntime<f64> = IntervalBoundRuntime::new_closed(5.0);
    ///
    /// // Both return the same result
    /// assert_eq!(bound.is_closed_variant(), bound.is_closed());
    ///
    /// // is_closed_variant() is more explicit about checking the enum variant
    /// // is_closed() comes from the BoundTypeChecks trait
    /// ```
    ///
    /// # See Also
    ///
    /// - [`is_open_variant`](Self::is_open_variant) - Check if bound is open
    /// - [`is_closed`](BoundTypeChecks::is_closed) - Trait method for same check
    /// - [`new_closed`](Self::new_closed) - Create a closed bound
    #[inline(always)]
    pub fn is_closed_variant(&self) -> bool {
        matches!(self, Self::Closed(_))
    }

    /// Check if this runtime bound is an open variant without consuming it.
    ///
    /// This method provides a non-consuming way to check the bound type, which is useful
    /// when you need to inspect the bound type without pattern matching or when you want
    /// to check the type multiple times.
    ///
    /// # Returns
    ///
    /// - `true` if the bound is [`IntervalBoundRuntime::Open`]
    /// - `false` if the bound is [`IntervalBoundRuntime::Closed`]
    ///
    /// # Performance
    ///
    /// This is a zero-cost check that compiles to a simple discriminant comparison.
    ///
    /// # Examples
    ///
    /// ## Basic Usage
    ///
    /// ```rust
    /// use grid1d::bounds::*;
    ///
    /// let open_bound: LowerBoundRuntime<f64> = IntervalBoundRuntime::new_open(5.0);
    /// let closed_bound: LowerBoundRuntime<f64> = IntervalBoundRuntime::new_closed(5.0);
    ///
    /// assert!(open_bound.is_open_variant());
    /// assert!(!closed_bound.is_open_variant());
    /// ```
    ///
    /// ## Conditional Logic
    ///
    /// ```rust
    /// use grid1d::bounds::*;
    ///
    /// fn describe_constraint(bound: &UpperBoundRuntime<f64>) -> String {
    ///     let symbol = if bound.is_open_variant() { "<" } else { "≤" };
    ///     format!("x {} {}", symbol, bound.as_ref())
    /// }
    ///
    /// let bound = IntervalBoundRuntime::new_open(100.0);
    /// assert_eq!(describe_constraint(&bound), "x < 100");
    /// ```
    ///
    /// ## Collecting by Type
    ///
    /// ```rust
    /// use grid1d::bounds::*;
    ///
    /// let bounds = vec![
    ///     LowerBoundRuntime::new_open(1.0),
    ///     LowerBoundRuntime::new_closed(2.0),
    ///     LowerBoundRuntime::new_open(3.0),
    ///     LowerBoundRuntime::new_closed(4.0),
    /// ];
    ///
    /// let open_count = bounds.iter().filter(|b| b.is_open_variant()).count();
    /// let closed_count = bounds.iter().filter(|b| b.is_closed_variant()).count();
    ///
    /// assert_eq!(open_count, 2);
    /// assert_eq!(closed_count, 2);
    /// ```
    ///
    /// ## Difference from `is_open()` Trait Method
    ///
    /// ```rust
    /// use grid1d::bounds::*;
    ///
    /// let bound: UpperBoundRuntime<f64> = IntervalBoundRuntime::new_open(5.0);
    ///
    /// // Both return the same result
    /// assert_eq!(bound.is_open_variant(), bound.is_open());
    ///
    /// // is_open_variant() is more explicit about checking the enum variant
    /// // is_open() comes from the BoundTypeChecks trait
    /// ```
    ///
    /// # See Also
    ///
    /// - [`is_closed_variant`](Self::is_closed_variant) - Check if bound is closed
    /// - [`is_open`](BoundTypeChecks::is_open) - Trait method for same check
    /// - [`new_open`](Self::new_open) - Create an open bound
    #[inline(always)]
    pub fn is_open_variant(&self) -> bool {
        matches!(self, Self::Open(_))
    }

    /// Convert this bound to the opposite bound type, preserving the value.
    ///
    /// This method transforms an open bound to a closed bound with the same value, or vice versa.
    /// The side (lower/upper) is preserved - only the inclusion/exclusion semantics change.
    ///
    /// # Mathematical Meaning
    ///
    /// ## For Lower Bounds
    /// - **Open → Closed**: `(a` becomes `[a` — changes `x > a` to `x ≥ a`
    /// - **Closed → Open**: `[a` becomes `(a` — changes `x ≥ a` to `x > a`
    ///
    /// ## For Upper Bounds
    /// - **Open → Closed**: `b)` becomes `b]` — changes `x < b` to `x ≤ b`
    /// - **Closed → Open**: `b]` becomes `b)` — changes `x ≤ b` to `x < b`
    ///
    /// # Use Cases
    ///
    /// This method is particularly useful when:
    /// - Adjusting interval boundaries in set difference operations
    /// - Converting between interval types (e.g., `[a, b)` ↔ `(a, b]`)
    /// - Implementing boundary adjustments in computational geometry
    /// - Handling boundary conditions in numerical algorithms
    ///
    /// # Examples
    ///
    /// ## Lower Bound Conversion
    ///
    /// ```rust
    /// use grid1d::bounds::*;
    ///
    /// let open_lower: LowerBoundRuntime<f64> = IntervalBoundRuntime::new_open(5.0);
    ///
    /// // Check properties before conversion
    /// assert!(open_lower.is_open_variant());
    /// assert!(!open_lower.value_within_bound(&5.0));   // 5 > 5 → false
    ///
    /// // Convert (consumes original)
    /// let closed_lower = open_lower.flip_bound_type();
    ///
    /// // Value is preserved
    /// assert_eq!(*closed_lower.as_ref(), 5.0);
    ///
    /// // But semantics change
    /// assert!(closed_lower.is_closed_variant());
    /// assert!(closed_lower.value_within_bound(&5.0));  // 5 ≥ 5 → true
    /// ```
    ///
    /// ## Upper Bound Conversion
    ///
    /// ```rust
    /// use grid1d::bounds::*;
    ///
    /// let closed_upper: UpperBoundRuntime<f64> = IntervalBoundRuntime::new_closed(10.0);
    ///
    /// // Check properties before conversion
    /// assert!(closed_upper.is_closed_variant());
    /// assert!(closed_upper.value_within_bound(&10.0));  // 10 ≤ 10 → true
    ///
    /// // Convert (consumes original)
    /// let open_upper = closed_upper.flip_bound_type();
    ///
    /// // Value is preserved
    /// assert_eq!(*open_upper.as_ref(), 10.0);
    ///
    /// // But semantics change
    /// assert!(open_upper.is_open_variant());
    /// assert!(!open_upper.value_within_bound(&10.0));   // 10 < 10 → false
    /// ```
    ///
    /// ## Interval Boundary Adjustment
    ///
    /// ```rust
    /// use grid1d::bounds::*;
    ///
    /// // When computing interval difference A \ B, we often need to flip boundaries
    /// // If B has lower bound [b, we need to create upper bound b) for the left remainder
    /// let b_lower: LowerBoundRuntime<f64> = IntervalBoundRuntime::new_closed(3.0);  // [3
    /// let left_upper = b_lower.flip_bound_type();            // 3) — exclude what B includes
    ///
    /// // Similarly for upper bounds
    /// let b_upper: UpperBoundRuntime<f64> = IntervalBoundRuntime::new_open(7.0);    // 7)
    /// let right_lower = b_upper.flip_bound_type();          // [7 — include what B excludes
    ///
    /// assert!(left_upper.is_open_variant());
    /// assert!(right_lower.is_closed_variant());
    /// ```
    ///
    /// ## Round-Trip Consistency
    ///
    /// ```rust
    /// use grid1d::bounds::*;
    ///
    /// let original: LowerBoundRuntime<f64> = IntervalBoundRuntime::new_closed(2.5);
    ///
    /// // Save properties for comparison
    /// let original_value = *original.as_ref();
    /// let was_closed = original.is_closed_variant();
    ///
    /// // Double flip restores the type
    /// let flipped = original.flip_bound_type();
    /// let restored = flipped.flip_bound_type();
    ///
    /// // Value preserved through transformations
    /// assert_eq!(*restored.as_ref(), original_value);
    ///
    /// // Type restored
    /// assert_eq!(was_closed, restored.is_closed_variant());
    /// ```
    ///
    /// ## Dynamic Interval Adjustment
    ///
    /// ```rust
    /// use grid1d::bounds::*;
    ///
    /// fn adjust_boundary_for_exclusion(bound: LowerBoundRuntime<f64>) -> LowerBoundRuntime<f64> {
    ///     // Convert any lower bound to open (exclusive) form
    ///     if bound.is_closed_variant() {
    ///         bound.flip_bound_type()
    ///     } else {
    ///         bound
    ///     }
    /// }
    ///
    /// let closed = IntervalBoundRuntime::new_closed(1.0);
    /// let open = adjust_boundary_for_exclusion(closed);
    ///
    /// assert!(!open.value_within_bound(&1.0));  // Now excludes the boundary
    /// assert!(open.value_within_bound(&1.1));   // But includes values above
    /// ```
    ///
    /// # Performance
    ///
    /// This is an O(1) operation that:
    /// - Extracts the underlying scalar value (moving it)
    /// - Constructs a new enum variant
    /// - Has no allocations or clones
    ///
    /// For `Copy` types like `f64`, this is a single register move. For non-`Copy` types,
    /// it moves the value without cloning.
    ///
    /// If you need to preserve the original bound, clone it before calling this method:
    /// ```rust
    /// use grid1d::bounds::*;
    ///
    /// let original: LowerBoundRuntime<f64> = IntervalBoundRuntime::new_open(5.0);
    /// let flipped = original.clone().flip_bound_type();  // Keep original
    ///
    /// assert!(original.is_open_variant());
    /// assert!(flipped.is_closed_variant());
    /// ```
    ///
    /// # See Also
    ///
    /// - [`new_open`](Self::new_open) - Create an open bound
    /// - [`new_closed`](Self::new_closed) - Create a closed bound
    /// - [`is_open_variant`](Self::is_open_variant) - Check if bound is open
    /// - [`is_closed_variant`](Self::is_closed_variant) - Check if bound is closed
    #[inline(always)]
    pub fn flip_bound_type(self) -> Self {
        match self {
            Self::Open(bound) => Self::Closed(IntervalBound::new(bound.into_inner())),
            Self::Closed(bound) => Self::Open(IntervalBound::new(bound.into_inner())),
        }
    }

    /// Converts a bound to the opposite side while preserving the open/closed type.
    ///
    /// This function transforms an `IntervalBoundRuntime<RealType, Side>` to
    /// `IntervalBoundRuntime<RealType, Side::Opposite>`, changing `Lower` ↔ `Upper`
    /// while keeping `Open` ↔ `Open` and `Closed` ↔ `Closed`.
    ///
    /// The return type is determined by the [`BoundSide::Opposite`] associated type,
    /// so no turbofish syntax is needed - the type system automatically infers the
    /// correct opposite side based on the input.
    ///
    /// # Type Transformations
    ///
    /// | Input Type | Output Type |
    /// |------------|-------------|
    /// | `LowerBoundRuntime::Open(a)` | `UpperBoundRuntime::Open(a)` |
    /// | `LowerBoundRuntime::Closed(a)` | `UpperBoundRuntime::Closed(a)` |
    /// | `UpperBoundRuntime::Open(b)` | `LowerBoundRuntime::Open(b)` |
    /// | `UpperBoundRuntime::Closed(b)` | `LowerBoundRuntime::Closed(b)` |
    ///
    /// # Use Cases
    ///
    /// This function is primarily useful in interval set operations (like difference)
    /// where you need to take a bound from one interval and use it as the opposite
    /// side for another interval, while flipping the inclusion/exclusion semantics.
    ///
    /// # Examples
    ///
    /// ## Converting Lower to Upper Bounds
    ///
    /// ```rust
    /// use grid1d::bounds::*;
    ///
    /// // Convert lower bound to upper bound (both open)
    /// let lower_open = LowerBoundRuntime::new_open(5.0);
    /// let upper_open: UpperBoundRuntime<f64> = lower_open.flip_bound_side();
    /// assert!(upper_open.is_open_variant());
    /// assert_eq!(*upper_open.as_ref(), 5.0);
    ///
    /// // Convert lower bound to upper bound (both closed)
    /// let lower_closed = LowerBoundRuntime::new_closed(10.0);
    /// let upper_closed: UpperBoundRuntime<f64> = lower_closed.flip_bound_side();
    /// assert!(upper_closed.is_closed_variant());
    /// assert_eq!(*upper_closed.as_ref(), 10.0);
    /// ```
    ///
    /// ## Converting Upper to Lower Bounds
    ///
    /// ```rust
    /// use grid1d::bounds::*;
    ///
    /// // Convert upper bound to lower bound (both open)
    /// let upper_open = UpperBoundRuntime::new_open(20.0);
    /// let lower_open: LowerBoundRuntime<f64> = upper_open.flip_bound_side();
    /// assert!(lower_open.is_open_variant());
    /// assert_eq!(*lower_open.as_ref(), 20.0);
    ///
    /// // Convert upper bound to lower bound (both closed)
    /// let upper_closed = UpperBoundRuntime::new_closed(15.0);
    /// let lower_closed: LowerBoundRuntime<f64> = upper_closed.flip_bound_side();
    /// assert!(lower_closed.is_closed_variant());
    /// assert_eq!(*lower_closed.as_ref(), 15.0);
    /// ```
    ///
    /// ## Combining with Bound Type Flipping
    ///
    /// You can combine `flip_bound_side()` with `flip_bound_type()` to perform
    /// both transformations:
    ///
    /// ```rust
    /// use grid1d::bounds::*;
    ///
    /// // Start with a closed lower bound
    /// let lower_closed = LowerBoundRuntime::new_closed(3.0);
    ///
    /// // Convert to open upper bound (both transformations)
    /// let upper_open: UpperBoundRuntime<f64> = lower_closed
    ///     .flip_bound_side()  // Lower Closed -> Upper Closed
    ///     .flip_bound_type();  // Upper Closed -> Upper Open
    ///
    /// assert!(upper_open.is_open_variant());
    /// assert_eq!(*upper_open.as_ref(), 3.0);
    /// ```
    ///
    /// ## Use in Interval Difference Operations
    ///
    /// ```rust
    /// use grid1d::bounds::*;
    ///
    /// // When computing A \ B, if B has lower bound [5, we need upper bound )5
    /// let b_lower = LowerBoundRuntime::new_closed(5.0);
    ///
    /// // Convert and flip for the difference result
    /// let result_upper: UpperBoundRuntime<f64> = b_lower
    ///     .flip_bound_side()   // Lower -> Upper
    ///     .flip_bound_type();   // Closed -> Open
    ///
    /// assert!(result_upper.is_open_variant());
    /// assert_eq!(*result_upper.as_ref(), 5.0);
    /// // This creates the upper bound )5 from the lower bound [5
    /// ```
    ///
    /// # Performance
    ///
    /// - **Time Complexity**: O(1) - just moves the underlying value
    /// - **Memory**: Consumes `self`, no allocation or cloning required
    /// - **Inlining**: Marked `#[inline(always)]` for zero-cost abstraction
    ///
    /// # See Also
    ///
    /// - [`flip_bound_type`](Self::flip_bound_type) - Change Open ↔ Closed
    /// - [`new_open`](Self::new_open) - Create an open bound
    /// - [`new_closed`](Self::new_closed) - Create a closed bound
    #[inline(always)]
    pub fn flip_bound_side(self) -> IntervalBoundRuntime<RealType, Side::Opposite> {
        match self {
            Self::Open(bound) => IntervalBoundRuntime::Open(IntervalBound::new(bound.into_inner())),
            Self::Closed(bound) => {
                IntervalBoundRuntime::Closed(IntervalBound::new(bound.into_inner()))
            }
        }
    }

    /// 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 atomically:
    /// - 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 |
    /// |------------|-------------|
    /// | `LowerBoundRuntime::Open(a)` | `UpperBoundRuntime::Closed(a)` |
    /// | `LowerBoundRuntime::Closed(a)` | `UpperBoundRuntime::Open(a)` |
    /// | `UpperBoundRuntime::Open(b)` | `LowerBoundRuntime::Closed(b)` |
    /// | `UpperBoundRuntime::Closed(b)` | `LowerBoundRuntime::Open(b)` |
    ///
    /// # 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
    ///
    /// This function is essential for interval difference operations (`A \ B`) where
    /// bounds from the subtracted interval need to become complementary bounds in the result.
    ///
    /// # Examples
    ///
    /// ## Basic Transformations
    ///
    /// ```rust
    /// use grid1d::bounds::*;
    ///
    /// // Lower Closed -> Upper Open
    /// let lower_closed = LowerBoundRuntime::new_closed(5.0);
    /// let upper_open: UpperBoundRuntime<f64> = lower_closed.flip_bound_side_and_type();
    /// assert!(upper_open.is_open_variant());
    /// assert_eq!(*upper_open.as_ref(), 5.0);
    ///
    /// // Lower Open -> Upper Closed
    /// let lower_open = LowerBoundRuntime::new_open(10.0);
    /// let upper_closed: UpperBoundRuntime<f64> = lower_open.flip_bound_side_and_type();
    /// assert!(upper_closed.is_closed_variant());
    /// assert_eq!(*upper_closed.as_ref(), 10.0);
    ///
    /// // Upper Closed -> Lower Open
    /// let upper_closed = UpperBoundRuntime::new_closed(15.0);
    /// let lower_open: LowerBoundRuntime<f64> = upper_closed.flip_bound_side_and_type();
    /// assert!(lower_open.is_open_variant());
    /// assert_eq!(*lower_open.as_ref(), 15.0);
    ///
    /// // Upper Open -> Lower Closed
    /// let upper_open = UpperBoundRuntime::new_open(20.0);
    /// let lower_closed: LowerBoundRuntime<f64> = upper_open.flip_bound_side_and_type();
    /// assert!(lower_closed.is_closed_variant());
    /// assert_eq!(*lower_closed.as_ref(), 20.0);
    /// ```
    ///
    /// ## Interval Difference: Why This Matters
    ///
    /// ```rust
    /// use grid1d::bounds::*;
    ///
    /// // 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 = LowerBoundRuntime::new_closed(5.0);
    /// let left_upper: UpperBoundRuntime<f64> = b_lower.flip_bound_side_and_type();
    /// assert!(left_upper.is_open_variant());
    /// assert_eq!(*left_upper.as_ref(), 5.0);
    /// // 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 = UpperBoundRuntime::new_closed(7.0);
    /// let right_lower: LowerBoundRuntime<f64> = b_upper.flip_bound_side_and_type();
    /// assert!(right_lower.is_open_variant());
    /// assert_eq!(*right_lower.as_ref(), 7.0);
    /// // This creates (7, 10] - the right part of A \ B
    /// ```
    ///
    /// ## Comparison with Sequential Operations
    ///
    /// ```rust
    /// use grid1d::bounds::*;
    ///
    /// let bound = LowerBoundRuntime::new_closed(3.0);
    ///
    /// // These are equivalent:
    /// let result1: UpperBoundRuntime<f64> = bound.clone().flip_bound_side_and_type();
    /// let result2: UpperBoundRuntime<f64> = bound.flip_bound_side().flip_bound_type();
    ///
    /// assert_eq!(result1.is_open_variant(), result2.is_open_variant());
    /// assert_eq!(*result1.as_ref(), *result2.as_ref());
    /// ```
    ///
    /// ## Involutive Property
    ///
    /// Applying this transformation twice returns to the original state (modulo the value):
    ///
    /// ```rust
    /// use grid1d::bounds::*;
    ///
    /// let original = LowerBoundRuntime::new_closed(7.5);
    /// let was_closed = original.is_closed_variant();
    /// let original_value = *original.as_ref();
    ///
    /// // Apply transformation twice
    /// let transformed: UpperBoundRuntime<f64> = original.flip_bound_side_and_type();
    /// let back: LowerBoundRuntime<f64> = transformed.flip_bound_side_and_type();
    ///
    /// // Returns to original type and value
    /// assert_eq!(back.is_closed_variant(), was_closed);
    /// assert_eq!(*back.as_ref(), original_value);
    /// ```
    ///
    /// # Performance
    ///
    /// - **Time Complexity**: O(1) - single pattern match and value move
    /// - **Memory**: Consumes `self`, no allocation or cloning required
    /// - **Inlining**: Marked `#[inline(always)]` for zero-cost abstraction
    /// - **Optimization**: Compiler can optimize to a simple field swap
    ///
    /// # 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)
    /// - [`new_open`](Self::new_open) - Create an open bound
    /// - [`new_closed`](Self::new_closed) - Create a closed bound
    #[inline(always)]
    pub fn flip_bound_side_and_type(self) -> IntervalBoundRuntime<RealType, Side::Opposite> {
        match self {
            Self::Open(bound) => {
                IntervalBoundRuntime::Closed(IntervalBound::new(bound.into_inner()))
            }
            Self::Closed(bound) => {
                IntervalBoundRuntime::Open(IntervalBound::new(bound.into_inner()))
            }
        }
    }
}

/// Runtime-determined lower bound that can be either open or closed.
///
/// [`LowerBoundRuntime<RealType>`] is a convenient type alias for [`IntervalBoundRuntime<RealType, Lower>`]
/// that specifically represents lower boundaries where the open/closed nature is determined at runtime.
/// This type is essential for dynamic interval construction, user configuration, serialization,
/// and algorithms that work with varying lower boundary semantics.
///
/// ## Type Definition
///
/// ```rust
/// use grid1d::bounds::*;
///
/// // These are equivalent:
/// type LowerBoundRuntime<T> = IntervalBoundRuntime<T, Lower>;
/// type ExplicitForm<T> = IntervalBoundRuntime<T, Lower>;
/// ```
///
/// ## Mathematical Properties
///
/// Lower bounds define minimum constraints for intervals and domains with runtime-determined inclusion:
///
/// | Variant | Mathematical Constraint | Notation | Value at Boundary |
/// |---------|------------------------|----------|-------------------|
/// | `Open(LowerBoundOpen)`   | `x > lower_value` | `(a` | **Excluded** |
/// | `Closed(LowerBoundClosed)` | `x ≥ lower_value` | `[a` | **Included** |
///
/// ## When to Use Lower Bound Runtime
///
/// ### ✅ **Recommended Use Cases**
///
/// ```rust
/// use grid1d::bounds::*;
/// use try_create::New;
///
/// // ✅ GOOD: User input with configuration
/// fn create_constraint_from_user_input(min_value: f64, inclusive: bool) -> LowerBoundRuntime<f64> {
///     if inclusive {
///         IntervalBoundRuntime::Closed(LowerBoundClosed::new(min_value))
///     } else {
///         IntervalBoundRuntime::Open(LowerBoundOpen::new(min_value))
///     }
/// }
///
/// // ✅ GOOD: Configuration-driven interval construction
/// struct DomainConfig {
///     start: f64,
///     include_start: bool,
///     end: f64,
///     include_end: bool,
/// }
///
/// fn build_dynamic_domain(config: DomainConfig) -> (LowerBoundRuntime<f64>, UpperBoundRuntime<f64>) {
///     let lower = create_constraint_from_user_input(config.start, config.include_start);
///     let upper = if config.include_end {
///         IntervalBoundRuntime::Closed(UpperBoundClosed::new(config.end))
///     } else {
///         IntervalBoundRuntime::Open(UpperBoundOpen::new(config.end))
///     };
///     (lower, upper)
/// }
/// ```
///
/// ### ❌ **Avoid When**
///
/// ```rust
/// use grid1d::bounds::*;
/// use try_create::New;
///
/// // ❌ AVOID: When boundary type is known at compile time
/// fn bad_usage() -> LowerBoundRuntime<f64> {
///     // This should just be LowerBoundClosed::new(0.0)
///     IntervalBoundRuntime::Closed(LowerBoundClosed::new(0.0))
/// }
///
/// // ✅ BETTER: Use compile-time types when semantics are fixed
/// fn good_usage() -> LowerBoundClosed<f64> {
///     LowerBoundClosed::new(0.0)
/// }
/// ```
///
/// ## Core Operations
///
/// ### Constraint Testing
///
/// ```rust
/// use grid1d::bounds::*;
/// use try_create::New;
///
/// let closed_lower = IntervalBoundRuntime::Closed(LowerBoundClosed::new(5.0));
/// let open_lower = IntervalBoundRuntime::Open(LowerBoundOpen::new(5.0));
///
/// // Test the boundary value itself
/// assert!(closed_lower.value_within_bound(&5.0));  // 5 ≥ 5 → true
/// assert!(!open_lower.value_within_bound(&5.0));   // 5 > 5 → false
///
/// // Test values above the boundary
/// assert!(closed_lower.value_within_bound(&5.1));  // 5.1 ≥ 5 → true
/// assert!(open_lower.value_within_bound(&5.1));    // 5.1 > 5 → true
///
/// // Test values below the boundary
/// assert!(!closed_lower.value_within_bound(&4.9)); // 4.9 ≥ 5 → false
/// assert!(!open_lower.value_within_bound(&4.9));   // 4.9 > 5 → false
/// ```
///
/// ### Type Information Queries
///
/// ```rust
/// use grid1d::bounds::*;
/// use try_create::New;
///
/// let closed_bound = IntervalBoundRuntime::Closed(LowerBoundClosed::new(1.0));
/// let open_bound = IntervalBoundRuntime::Open(LowerBoundOpen::new(1.0));
///
/// // Query boundary inclusion behavior
/// assert!(closed_bound.is_closed());
/// assert!(!closed_bound.is_open());
/// assert!(closed_bound.includes_boundary());
///
/// assert!(!open_bound.is_closed());
/// assert!(open_bound.is_open());
/// assert!(!open_bound.includes_boundary());
///
/// // All lower bounds share this property
/// assert!(closed_bound.is_lower_bound());
/// assert!(open_bound.is_lower_bound());
/// assert!(!closed_bound.is_upper_bound());
/// assert!(!open_bound.is_upper_bound());
/// ```
///
/// ### Value Access
///
/// ```rust
/// use grid1d::bounds::*;
/// use try_create::{New, IntoInner};
///
/// let bound = IntervalBoundRuntime::Closed(LowerBoundClosed::new(3.14));
///
/// // Access the underlying 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);
/// ```
///
/// ## Mathematical Ordering
///
/// Lower bounds maintain mathematically correct ordering where "tighter" constraints are considered smaller:
///
/// ```rust
/// use grid1d::bounds::*;
/// use try_create::New;
///
/// let closed_lower = IntervalBoundRuntime::Closed(LowerBoundClosed::new(5.0));  // [5
/// let open_lower = IntervalBoundRuntime::Open(LowerBoundOpen::new(5.0));        // (5
///
/// // Closed bound is "tighter" (more restrictive) than open bound
/// assert!(closed_lower < open_lower);  // [5 < (5
///
/// // This ordering ensures correct interval operations:
/// // intersection([5, 10]) ∩ (5, 10]) = (5, 10] (the looser constraint wins)
/// ```
///
/// ## Practical Usage Patterns
///
/// ### Dynamic Interval Construction
///
/// ```rust
/// use grid1d::bounds::*;
/// use try_create::New;
///
/// struct IntervalBuilder {
///     lower_value: f64,
///     lower_inclusive: bool,
/// }
///
/// impl IntervalBuilder {
///     fn build_lower_bound(&self) -> LowerBoundRuntime<f64> {
///         if self.lower_inclusive {
///             IntervalBoundRuntime::Closed(LowerBoundClosed::new(self.lower_value))
///         } else {
///             IntervalBoundRuntime::Open(LowerBoundOpen::new(self.lower_value))
///         }
///     }
///     
///     fn set_constraint(&mut self, value: f64, inclusive: bool) {
///         self.lower_value = value;
///         self.lower_inclusive = inclusive;
///     }
/// }
///
/// let mut builder = IntervalBuilder { lower_value: 0.0, lower_inclusive: true };
/// let bound1 = builder.build_lower_bound(); // [0
///
/// builder.set_constraint(1.0, false);
/// let bound2 = builder.build_lower_bound(); // (1
///
/// assert!(bound1.is_closed());
/// assert!(bound2.is_open());
/// ```
///
/// ### Configuration-Driven Systems
///
/// ```rust
/// use grid1d::bounds::*;
/// use try_create::New;
/// use serde::{Deserialize, Serialize};
///
/// #[derive(Serialize, Deserialize)]
/// struct ConstraintConfig {
///     minimum_value: f64,
///     include_minimum: bool,
/// }
///
/// impl ConstraintConfig {
///     fn to_lower_bound(&self) -> LowerBoundRuntime<f64> {
///         if self.include_minimum {
///             IntervalBoundRuntime::Closed(LowerBoundClosed::new(self.minimum_value))
///         } else {
///             IntervalBoundRuntime::Open(LowerBoundOpen::new(self.minimum_value))
///         }
///     }
/// }
///
/// // Load from configuration file or user input
/// let config = ConstraintConfig {
///     minimum_value: 0.0,
///     include_minimum: true,
/// };
///
/// let lower_bound = config.to_lower_bound();
/// assert!(lower_bound.value_within_bound(&0.0)); // Includes minimum
/// ```
///
/// ### Collection Processing
///
/// ```rust
/// use grid1d::bounds::*;
/// use try_create::New;
///
/// // Store different lower bound types in the same collection
/// let constraints: Vec<LowerBoundRuntime<f64>> = vec![
///     IntervalBoundRuntime::Closed(LowerBoundClosed::new(0.0)),   // [0
///     IntervalBoundRuntime::Open(LowerBoundOpen::new(1.0)),       // (1
///     IntervalBoundRuntime::Closed(LowerBoundClosed::new(2.0)),   // [2
///     IntervalBoundRuntime::Open(LowerBoundOpen::new(3.0)),       // (3
/// ];
///
/// // Process them uniformly
/// for (i, constraint) in constraints.iter().enumerate() {
///     let inclusion = if constraint.is_closed() { "≥" } else { ">" };
///     println!("Constraint {}: x {} {}", i, inclusion, constraint.as_ref());
/// }
/// // Output:
/// // Constraint 0: x ≥ 0
/// // Constraint 1: x > 1
/// // Constraint 2: x ≥ 2
/// // Constraint 3: x > 3
///
/// // Find all constraints satisfied by a test value
/// let test_value = 2.0;
/// let satisfied: Vec<usize> = constraints.iter()
///     .enumerate()
///     .filter(|(_, constraint)| constraint.value_within_bound(&test_value))
///     .map(|(i, _)| i)
///     .collect();
///
/// assert_eq!(satisfied, vec![0, 1, 2]); // Only [0, (1 and [2 include 2.0
/// ```
///
/// ## Serialization Support
///
/// Runtime bounds have natural serialization support, making them ideal for persistent configuration:
///
/// ```rust
/// use grid1d::bounds::*;
/// use try_create::New;
/// use serde_json;
///
/// let bounds = vec![
///     IntervalBoundRuntime::Closed(LowerBoundClosed::new(0.0)),
///     IntervalBoundRuntime::Open(LowerBoundOpen::new(1.5)),
/// ];
///
/// // Serialize to JSON
/// let json = serde_json::to_string_pretty(&bounds).unwrap();
/// println!("Serialized lower bounds:\n{}", json);
///
/// // Deserialize back
/// let deserialized: Vec<LowerBoundRuntime<f64>> =
///     serde_json::from_str(&json).unwrap();
///
/// // Verify round-trip correctness
/// for (original, restored) in bounds.iter().zip(deserialized.iter()) {
///     assert_eq!(original.as_ref(), restored.as_ref());
///     assert_eq!(original.is_closed(), restored.is_closed());
///     assert_eq!(original.value_within_bound(&0.0), restored.value_within_bound(&0.0));
/// }
/// ```
///
/// ## Generic Algorithm Support
///
/// ```rust
/// use grid1d::bounds::*;
/// use num_valid::RealScalar;
/// use try_create::New;
///
/// fn find_minimum_satisfying_constraint<T: RealScalar + Copy>(
///     candidates: &[T],
///     constraint: &LowerBoundRuntime<T>
/// ) -> Option<T>
/// where
///     T: PartialOrd,
/// {
///     candidates.iter()
///         .filter(|&&value| constraint.value_within_bound(&value))
///         .min_by(|a, b| a.partial_cmp(b).unwrap())
///         .copied()
/// }
///
/// let values = vec![0.0, 0.5, 1.0, 1.5, 2.0];
///
/// let closed_constraint = IntervalBoundRuntime::Closed(LowerBoundClosed::new(1.0));
/// let open_constraint = IntervalBoundRuntime::Open(LowerBoundOpen::new(1.0));
///
/// assert_eq!(find_minimum_satisfying_constraint(&values, &closed_constraint), Some(1.0)); // x ≥ 1
/// assert_eq!(find_minimum_satisfying_constraint(&values, &open_constraint), Some(1.5));   // x > 1
/// ```
///
/// ## Performance vs Compile-Time Bounds
///
/// ### Runtime Performance
/// - **Memory**: Same as underlying bound plus small enum discriminant (~9 bytes for f64)
/// - **Operations**: Small pattern matching overhead (~1-2 CPU cycles)
/// - **Constraint Testing**: O(1) with inlined comparisons
///
/// ### Comparison with Compile-Time Bounds
///
/// ```rust
/// use grid1d::bounds::*;
/// use try_create::New;
///
/// // Runtime bound: small branching cost
/// fn check_runtime_constraint(bound: &LowerBoundRuntime<f64>, value: f64) -> bool {
///     match bound {  // Runtime dispatch (small cost)
///         IntervalBoundRuntime::Open(b) => value > *b.as_ref(),
///         IntervalBoundRuntime::Closed(b) => value >= *b.as_ref(),
///     }
/// }
///
/// // Compile-time bound: zero overhead
/// fn check_compile_time_constraint<T: BoundType>(bound: &LowerBound<f64, T>, value: f64) -> bool {
///     if T::is_open() {
///         value > *bound.as_ref()  // Direct comparison, no branching
///     } else {
///         value >= *bound.as_ref() // Direct comparison, no branching
///     }
/// }
/// ```
///
/// ## Integration with Grid1D
///
/// Runtime bounds integrate seamlessly with interval construction:
///
/// ```rust
/// use grid1d::{bounds::*, intervals::*};
/// use try_create::{IntoInner, New};
///
/// fn create_interval_from_runtime_bounds(
///     lower: LowerBoundRuntime<f64>,
///     upper: UpperBoundRuntime<f64>
/// ) -> Box<dyn std::fmt::Debug> {
///     match (lower, upper) {
///         (IntervalBoundRuntime::Closed(l), IntervalBoundRuntime::Closed(u)) => {
///             Box::new(IntervalClosed::new(l.into_inner(), u.into_inner()))
///         }
///         (IntervalBoundRuntime::Open(l), IntervalBoundRuntime::Open(u)) => {
///             Box::new(IntervalOpen::new(l.into_inner(), u.into_inner()))
///         }
///         (IntervalBoundRuntime::Closed(l), IntervalBoundRuntime::Open(u)) => {
///             Box::new(IntervalLowerClosedUpperOpen::new(l.into_inner(), u.into_inner()))
///         }
///         (IntervalBoundRuntime::Open(l), IntervalBoundRuntime::Closed(u)) => {
///             Box::new(IntervalLowerOpenUpperClosed::new(l.into_inner(), u.into_inner()))
///         }
///     }
/// }
///
/// // Example usage
/// let lower = IntervalBoundRuntime::Closed(LowerBoundClosed::new(0.0));
/// let upper = IntervalBoundRuntime::Open(UpperBoundOpen::new(1.0));
/// let interval = create_interval_from_runtime_bounds(lower, upper); // Creates [0, 1)
/// ```
///
/// ## Conversion Patterns
///
/// ### Extract Specific Bound Types
///
/// ```rust
/// use grid1d::bounds::*;
/// use try_create::New;
///
/// fn extract_closed_lower_bound(bound: LowerBoundRuntime<f64>) -> Option<LowerBoundClosed<f64>> {
///     match bound {
///         IntervalBoundRuntime::Closed(closed_bound) => Some(closed_bound),
///         IntervalBoundRuntime::Open(_) => None,
///     }
/// }
///
/// let runtime_bound = IntervalBoundRuntime::Closed(LowerBoundClosed::new(5.0));
/// let compile_time_bound = extract_closed_lower_bound(runtime_bound);
/// assert!(compile_time_bound.is_some());
/// ```
///
/// ### Convert to Compile-Time When Possible
///
/// ```rust
/// use grid1d::bounds::*;
/// use try_create::New;
///
/// // Pattern: Use runtime bounds at API boundaries, compile-time internally
/// fn process_constraint(constraint: LowerBoundRuntime<f64>) -> String {
///     match constraint {
///         IntervalBoundRuntime::Closed(closed_bound) => {
///             // Delegate to compile-time optimized function
///             process_closed_constraint(closed_bound)
///         }
///         IntervalBoundRuntime::Open(open_bound) => {
///             // Delegate to compile-time optimized function
///             process_open_constraint(open_bound)
///         }
///     }
/// }
///
/// fn process_closed_constraint(bound: LowerBoundClosed<f64>) -> String {
///     format!("Inclusive lower bound: x ≥ {}", bound.as_ref())
/// }
///
/// fn process_open_constraint(bound: LowerBoundOpen<f64>) -> String {
///     format!("Exclusive lower bound: x > {}", bound.as_ref())
/// }
/// ```
///
/// ## Best Practices
///
/// ### 1. **Use at API Boundaries**
/// ```rust
/// use grid1d::bounds::*;
///
/// // ✅ GOOD: Runtime bounds for user-facing APIs
/// pub fn create_domain_from_config(
///     lower: LowerBoundRuntime<f64>,
///     upper: UpperBoundRuntime<f64>
/// ) -> Result<Box<dyn std::fmt::Debug>, String> {
///     // Implementation...
///     Ok(Box::new(format!("Domain created")))
/// }
///
/// // ✅ GOOD: Compile-time bounds for internal algorithms
/// fn optimize_grid_spacing<T: BoundType>(
///     lower: &LowerBound<f64, T>
/// ) -> f64 {
///     // High-performance internal computation
///     *lower.as_ref() * 1.1
/// }
/// ```
///
/// ### 2. **Pattern Match Early**
/// ```rust
/// use grid1d::bounds::*;
/// use try_create::New;
///
/// // ✅ GOOD: Extract compile-time types early
/// fn efficient_processing(constraint: LowerBoundRuntime<f64>) -> f64 {
///     match constraint {
///         IntervalBoundRuntime::Closed(bound) => {
///             // Use compile-time optimized path
///             bound.as_ref() * 1.0  // Zero overhead
///         }
///         IntervalBoundRuntime::Open(bound) => {
///             // Use compile-time optimized path
///             bound.as_ref() + f64::EPSILON  // Zero overhead
///         }
///     }
/// }
/// ```
///
/// ### 3. **Validate Early**
/// ```rust
/// use grid1d::bounds::*;
/// use try_create::New;
///
/// fn create_constraint_with_validation(
///     value: f64,
///     inclusive: bool
/// ) -> Result<LowerBoundRuntime<f64>, String> {
///     if !value.is_finite() {
///         return Err(format!("Constraint value must be finite, got: {}", value));
///     }
///     
///     let bound = if inclusive {
///         IntervalBoundRuntime::Closed(LowerBoundClosed::new(value))
///     } else {
///         IntervalBoundRuntime::Open(LowerBoundOpen::new(value))
///     };
///     
///     Ok(bound)
/// }
/// ```
///
/// ## Mathematical Guarantees
///
/// The [`LowerBoundRuntime`] type maintains mathematical correctness by:
///
/// - **Constraint Semantics**: Properly implements `x ≥ a` (closed) vs `x > a` (open)
/// - **Ordering Consistency**: Maintains mathematical ordering where `[a < (a`
/// - **Type Safety**: Prevents mixing with upper bounds at compile time
/// - **Value Preservation**: Maintains exact scalar values without precision loss
/// - **Conversion Safety**: Provides safe extraction of compile-time types
///
/// Use [`LowerBoundRuntime`] when you need the flexibility of runtime boundary semantics
/// while maintaining mathematical correctness and integration with the grid1d ecosystem.
/// For maximum performance when boundary types are known at compile time, prefer the
/// direct types [`LowerBoundClosed`](crate::bounds::LowerBoundClosed) and [`LowerBoundOpen`](crate::bounds::LowerBoundOpen).
pub type LowerBoundRuntime<RealType> = IntervalBoundRuntime<RealType, Lower>;

/// Runtime-determined upper bound that can be either open or closed.
///
/// [`UpperBoundRuntime<RealType>`] is a convenient type alias for [`IntervalBoundRuntime<RealType, Upper>`]
/// that specifically represents upper boundaries where the open/closed nature is determined at runtime.
/// This type is essential for dynamic interval construction, user configuration, serialization,
/// and algorithms that work with varying upper boundary semantics.
///
/// ## Type Definition
///
/// ```rust
/// use grid1d::bounds::*;
///
/// // These are equivalent:
/// type UpperBoundRuntime<T> = IntervalBoundRuntime<T, Upper>;
/// type ExplicitForm<T> = IntervalBoundRuntime<T, Upper>;
/// ```
///
/// ## Mathematical Properties
///
/// Upper bounds define maximum constraints for intervals and domains with runtime-determined inclusion:
///
/// | Variant | Mathematical Constraint | Notation | Value at Boundary |
/// |---------|------------------------|----------|-------------------|
/// | `Open(UpperBoundOpen)`   | `x < upper_value` | `b)` | **Excluded** |
/// | `Closed(UpperBoundClosed)` | `x ≤ upper_value` | `b]` | **Included** |
///
/// ## When to Use Upper Bound Runtime
///
/// ### ✅ **Recommended Use Cases**
///
/// ```rust
/// use grid1d::bounds::*;
/// use try_create::New;
///
/// // ✅ GOOD: User input with configuration
/// fn create_upper_constraint_from_user_input(max_value: f64, inclusive: bool) -> UpperBoundRuntime<f64> {
///     if inclusive {
///         IntervalBoundRuntime::Closed(UpperBoundClosed::new(max_value))
///     } else {
///         IntervalBoundRuntime::Open(UpperBoundOpen::new(max_value))
///     }
/// }
///
/// // ✅ GOOD: Configuration-driven interval construction
/// struct RangeConfig {
///     start: f64,
///     include_start: bool,
///     end: f64,
///     include_end: bool,
/// }
///
/// fn build_dynamic_range(config: RangeConfig) -> (LowerBoundRuntime<f64>, UpperBoundRuntime<f64>) {
///     let lower = if config.include_start {
///         IntervalBoundRuntime::Closed(LowerBoundClosed::new(config.start))
///     } else {
///         IntervalBoundRuntime::Open(LowerBoundOpen::new(config.start))
///     };
///     
///     let upper = create_upper_constraint_from_user_input(config.end, config.include_end);
///     (lower, upper)
/// }
/// ```
///
/// ### ❌ **Avoid When**
///
/// ```rust
/// use grid1d::bounds::*;
/// use try_create::New;
///
/// // ❌ AVOID: When boundary type is known at compile time
/// fn bad_usage() -> UpperBoundRuntime<f64> {
///     // This should just be UpperBoundOpen::new(10.0)
///     IntervalBoundRuntime::Open(UpperBoundOpen::new(10.0))
/// }
///
/// // ✅ BETTER: Use compile-time types when semantics are fixed
/// fn good_usage() -> UpperBoundOpen<f64> {
///     UpperBoundOpen::new(10.0)
/// }
/// ```
///
/// ## Core Operations
///
/// ### Constraint Testing
///
/// ```rust
/// use grid1d::bounds::*;
/// use try_create::New;
///
/// let closed_upper = IntervalBoundRuntime::Closed(UpperBoundClosed::new(10.0));
/// let open_upper = IntervalBoundRuntime::Open(UpperBoundOpen::new(10.0));
///
/// // Test the boundary value itself
/// assert!(closed_upper.value_within_bound(&10.0));  // 10 ≤ 10 → true
/// assert!(!open_upper.value_within_bound(&10.0));   // 10 < 10 → false
///
/// // Test values below the boundary
/// assert!(closed_upper.value_within_bound(&9.5));   // 9.5 ≤ 10 → true
/// assert!(open_upper.value_within_bound(&9.5));     // 9.5 < 10 → true
///
/// // Test values above the boundary
/// assert!(!closed_upper.value_within_bound(&10.5)); // 10.5 ≤ 10 → false
/// assert!(!open_upper.value_within_bound(&10.5));   // 10.5 < 10 → false
/// ```
///
/// ### Type Information Queries
///
/// ```rust
/// use grid1d::bounds::*;
/// use try_create::New;
///
/// let closed_bound = IntervalBoundRuntime::Closed(UpperBoundClosed::new(5.0));
/// let open_bound = IntervalBoundRuntime::Open(UpperBoundOpen::new(5.0));
///
/// // Query boundary inclusion behavior
/// assert!(closed_bound.is_closed());
/// assert!(!closed_bound.is_open());
/// assert!(closed_bound.includes_boundary());
///
/// assert!(!open_bound.is_closed());
/// assert!(open_bound.is_open());
/// assert!(!open_bound.includes_boundary());
///
/// // All upper bounds share this property
/// assert!(closed_bound.is_upper_bound());
/// assert!(open_bound.is_upper_bound());
/// assert!(!closed_bound.is_lower_bound());
/// assert!(!open_bound.is_lower_bound());
/// ```
///
/// ### Value Access
///
/// ```rust
/// use grid1d::bounds::*;
/// use try_create::{New, IntoInner};
///
/// let bound = IntervalBoundRuntime::Closed(UpperBoundClosed::new(2.718));
///
/// // Access the underlying value by reference
/// let value_ref: &f64 = bound.as_ref();
/// assert_eq!(*value_ref, 2.718);
///
/// // Extract the value (consuming the bound)
/// let value: f64 = bound.into_inner();
/// assert_eq!(value, 2.718);
/// ```
///
/// ## Mathematical Ordering
///
/// Upper bounds maintain mathematically correct ordering where "tighter" constraints are considered smaller:
///
/// ```rust
/// use grid1d::bounds::*;
/// use try_create::New;
///
/// let open_upper = IntervalBoundRuntime::Open(UpperBoundOpen::new(10.0));        // 10)
/// let closed_upper = IntervalBoundRuntime::Closed(UpperBoundClosed::new(10.0));  // 10]
///
/// // Open bound is "tighter" (more restrictive) than closed bound
/// assert!(open_upper < closed_upper);  // 10) < 10]
///
/// // This ordering ensures correct interval operations:
/// // intersection([0, 10)) ∩ [0, 10]) = [0, 10) (the tighter constraint wins)
/// ```
///
/// ## Practical Usage Patterns
///
/// ### Dynamic Range Construction
///
/// ```rust
/// use grid1d::bounds::*;
/// use try_create::New;
///
/// struct RangeBuilder {
///     upper_value: f64,
///     upper_inclusive: bool,
/// }
///
/// impl RangeBuilder {
///     fn build_upper_bound(&self) -> UpperBoundRuntime<f64> {
///         if self.upper_inclusive {
///             IntervalBoundRuntime::Closed(UpperBoundClosed::new(self.upper_value))
///         } else {
///             IntervalBoundRuntime::Open(UpperBoundOpen::new(self.upper_value))
///         }
///     }
///     
///     fn set_maximum(&mut self, value: f64, inclusive: bool) {
///         self.upper_value = value;
///         self.upper_inclusive = inclusive;
///     }
/// }
///
/// let mut builder = RangeBuilder { upper_value: 100.0, upper_inclusive: true };
/// let bound1 = builder.build_upper_bound(); // 100]
///
/// builder.set_maximum(50.0, false);
/// let bound2 = builder.build_upper_bound(); // 50)
///
/// assert!(bound1.is_closed());
/// assert!(bound2.is_open());
/// ```
///
/// ### Configuration-Driven Systems
///
/// ```rust
/// use grid1d::bounds::*;
/// use try_create::New;
/// use serde::{Deserialize, Serialize};
///
/// #[derive(Serialize, Deserialize)]
/// struct MaximumConfig {
///     maximum_value: f64,
///     include_maximum: bool,
/// }
///
/// impl MaximumConfig {
///     fn to_upper_bound(&self) -> UpperBoundRuntime<f64> {
///         if self.include_maximum {
///             IntervalBoundRuntime::Closed(UpperBoundClosed::new(self.maximum_value))
///         } else {
///             IntervalBoundRuntime::Open(UpperBoundOpen::new(self.maximum_value))
///         }
///     }
/// }
///
/// // Load from configuration file or user input
/// let config = MaximumConfig {
///     maximum_value: 100.0,
///     include_maximum: false,
/// };
///
/// let upper_bound = config.to_upper_bound();
/// assert!(!upper_bound.value_within_bound(&100.0)); // Excludes maximum
/// assert!(upper_bound.value_within_bound(&99.9));   // Includes values below
/// ```
///
/// ### Collection Processing
///
/// ```rust
/// use grid1d::bounds::*;
/// use try_create::New;
///
/// // Store different upper bound types in the same collection
/// let constraints: Vec<UpperBoundRuntime<f64>> = vec![
///     IntervalBoundRuntime::Closed(UpperBoundClosed::new(10.0)),  // 10]
///     IntervalBoundRuntime::Open(UpperBoundOpen::new(20.0)),      // 20)
///     IntervalBoundRuntime::Closed(UpperBoundClosed::new(30.0)),  // 30]
///     IntervalBoundRuntime::Open(UpperBoundOpen::new(40.0)),      // 40)
/// ];
///
/// // Process them uniformly
/// for (i, constraint) in constraints.iter().enumerate() {
///     let inclusion = if constraint.is_closed() { "≤" } else { "<" };
///     println!("Constraint {}: x {} {}", i, inclusion, constraint.as_ref());
/// }
/// // Output:
/// // Constraint 0: x ≤ 10
/// // Constraint 1: x < 20
/// // Constraint 2: x ≤ 30
/// // Constraint 3: x < 40
///
/// // Find all constraints satisfied by a test value
/// let test_value = 20.0;
/// let satisfied: Vec<usize> = constraints.iter()
///     .enumerate()
///     .filter(|(_, constraint)| constraint.value_within_bound(&test_value))
///     .map(|(i, _)| i)
///     .collect();
///
/// assert_eq!(satisfied, vec![2, 3]); // Only 30] and 40) include 20.0
/// ```
///
/// ## Serialization Support
///
/// Runtime bounds have natural serialization support, making them ideal for persistent configuration:
///
/// ```rust
/// use grid1d::bounds::*;
/// use try_create::New;
/// use serde_json;
///
/// let bounds = vec![
///     IntervalBoundRuntime::Closed(UpperBoundClosed::new(100.0)),
///     IntervalBoundRuntime::Open(UpperBoundOpen::new(50.0)),
/// ];
///
/// // Serialize to JSON
/// let json = serde_json::to_string_pretty(&bounds).unwrap();
/// println!("Serialized upper bounds:\n{}", json);
///
/// // Deserialize back
/// let deserialized: Vec<UpperBoundRuntime<f64>> =
///     serde_json::from_str(&json).unwrap();
///
/// // Verify round-trip correctness
/// for (original, restored) in bounds.iter().zip(deserialized.iter()) {
///     assert_eq!(original.as_ref(), restored.as_ref());
///     assert_eq!(original.is_closed(), restored.is_closed());
///     assert_eq!(original.value_within_bound(&50.0), restored.value_within_bound(&50.0));
/// }
/// ```
///
/// ## Generic Algorithm Support
///
/// ```rust
/// use grid1d::bounds::*;
/// use num_valid::RealScalar;
/// use try_create::New;
///
/// fn find_maximum_satisfying_constraint<T: RealScalar + Copy>(
///     candidates: &[T],
///     constraint: &UpperBoundRuntime<T>
/// ) -> Option<T>
/// where
///     T: PartialOrd,
/// {
///     candidates.iter()
///         .filter(|&&value| constraint.value_within_bound(&value))
///         .max_by(|a, b| a.partial_cmp(b).unwrap())
///         .copied()
/// }
///
/// let values = vec![8.0, 9.0, 10.0, 11.0, 12.0];
///
/// let closed_constraint = IntervalBoundRuntime::Closed(UpperBoundClosed::new(10.0));
/// let open_constraint = IntervalBoundRuntime::Open(UpperBoundOpen::new(10.0));
///
/// assert_eq!(find_maximum_satisfying_constraint(&values, &closed_constraint), Some(10.0)); // x ≤ 10
/// assert_eq!(find_maximum_satisfying_constraint(&values, &open_constraint), Some(9.0));    // x < 10
/// ```
///
/// ## Performance vs Compile-Time Bounds
///
/// ### Runtime Performance
/// - **Memory**: Same as underlying bound plus small enum discriminant (~9 bytes for f64)
/// - **Operations**: Small pattern matching overhead (~1-2 CPU cycles)
/// - **Constraint Testing**: O(1) with inlined comparisons
///
/// ### Comparison with Compile-Time Bounds
///
/// ```rust
/// use grid1d::bounds::*;
/// use try_create::New;
///
/// // Runtime bound: small branching cost
/// fn check_runtime_constraint(bound: &UpperBoundRuntime<f64>, value: f64) -> bool {
///     match bound {  // Runtime dispatch (small cost)
///         IntervalBoundRuntime::Open(b) => value < *b.as_ref(),
///         IntervalBoundRuntime::Closed(b) => value <= *b.as_ref(),
///     }
/// }
///
/// // Compile-time bound: zero overhead
/// fn check_compile_time_constraint<T: BoundType>(bound: &UpperBound<f64, T>, value: f64) -> bool {
///     if T::is_open() {
///         value < *bound.as_ref()  // Direct comparison, no branching
///     } else {
///         value <= *bound.as_ref() // Direct comparison, no branching
///     }
/// }
/// ```
///
/// ## Integration with Grid1D
///
/// Runtime bounds integrate seamlessly with interval construction:
///
/// ```rust
/// use grid1d::{bounds::*, intervals::*};
/// use try_create::{IntoInner, New};
///
/// fn create_interval_from_runtime_bounds(
///     lower: LowerBoundRuntime<f64>,
///     upper: UpperBoundRuntime<f64>
/// ) -> Box<dyn std::fmt::Debug> {
///     match (lower, upper) {
///         (IntervalBoundRuntime::Closed(l), IntervalBoundRuntime::Closed(u)) => {
///             Box::new(IntervalClosed::new(l.into_inner(), u.into_inner()))
///         }
///         (IntervalBoundRuntime::Open(l), IntervalBoundRuntime::Open(u)) => {
///             Box::new(IntervalOpen::new(l.into_inner(), u.into_inner()))
///         }
///         (IntervalBoundRuntime::Closed(l), IntervalBoundRuntime::Open(u)) => {
///             Box::new(IntervalLowerClosedUpperOpen::new(l.into_inner(), u.into_inner()))
///         }
///         (IntervalBoundRuntime::Open(l), IntervalBoundRuntime::Closed(u)) => {
///             Box::new(IntervalLowerOpenUpperClosed::new(l.into_inner(), u.into_inner()))
///         }
///     }
/// }
///
/// // Example usage
/// let lower = IntervalBoundRuntime::Open(LowerBoundOpen::new(0.0));
/// let upper = IntervalBoundRuntime::Closed(UpperBoundClosed::new(1.0));
/// let interval = create_interval_from_runtime_bounds(lower, upper); // Creates (0, 1]
/// ```
///
/// ## Conversion Patterns
///
/// ### Extract Specific Bound Types
///
/// ```rust
/// use grid1d::bounds::*;
/// use try_create::New;
///
/// fn extract_open_upper_bound(bound: UpperBoundRuntime<f64>) -> Option<UpperBoundOpen<f64>> {
///     match bound {
///         IntervalBoundRuntime::Open(open_bound) => Some(open_bound),
///         IntervalBoundRuntime::Closed(_) => None,
///     }
/// }
///
/// let runtime_bound = IntervalBoundRuntime::Open(UpperBoundOpen::new(10.0));
/// let compile_time_bound = extract_open_upper_bound(runtime_bound);
/// assert!(compile_time_bound.is_some());
/// ```
///
/// ### Convert to Compile-Time When Possible
///
/// ```rust
/// use grid1d::bounds::*;
/// use try_create::New;
///
/// // Pattern: Use runtime bounds at API boundaries, compile-time internally
/// fn process_upper_constraint(constraint: UpperBoundRuntime<f64>) -> String {
///     match constraint {
///         IntervalBoundRuntime::Closed(closed_bound) => {
///             // Delegate to compile-time optimized function
///             process_closed_upper_constraint(closed_bound)
///         }
///         IntervalBoundRuntime::Open(open_bound) => {
///             // Delegate to compile-time optimized function
///             process_open_upper_constraint(open_bound)
///         }
///     }
/// }
///
/// fn process_closed_upper_constraint(bound: UpperBoundClosed<f64>) -> String {
///     format!("Inclusive upper bound: x ≤ {}", bound.as_ref())
/// }
///
/// fn process_open_upper_constraint(bound: UpperBoundOpen<f64>) -> String {
///     format!("Exclusive upper bound: x < {}", bound.as_ref())
/// }
/// ```
///
/// ## Best Practices
///
/// ### 1. **Use at API Boundaries**
/// ```rust
/// use grid1d::bounds::*;
///
/// // ✅ GOOD: Runtime bounds for user-facing APIs
/// pub fn create_range_from_config(
///     lower: LowerBoundRuntime<f64>,
///     upper: UpperBoundRuntime<f64>
/// ) -> Result<Box<dyn std::fmt::Debug>, String> {
///     // Implementation...
///     Ok(Box::new(format!("Range created")))
/// }
///
/// // ✅ GOOD: Compile-time bounds for internal algorithms
/// fn optimize_upper_limit<T: BoundType>(
///     upper: &UpperBound<f64, T>
/// ) -> f64 {
///     // High-performance internal computation
///     *upper.as_ref() * 0.9
/// }
/// ```
///
/// ### 2. **Pattern Match Early**
/// ```rust
/// use grid1d::bounds::*;
/// use try_create::New;
///
/// // ✅ GOOD: Extract compile-time types early
/// fn efficient_upper_processing(constraint: UpperBoundRuntime<f64>) -> f64 {
///     match constraint {
///         IntervalBoundRuntime::Closed(bound) => {
///             // Use compile-time optimized path
///             *bound.as_ref()  // Zero overhead
///         }
///         IntervalBoundRuntime::Open(bound) => {
///             // Use compile-time optimized path
///             *bound.as_ref() - f64::EPSILON  // Zero overhead
///         }
///     }
/// }
/// ```
///
/// ### 3. **Validate Early**
/// ```rust
/// use grid1d::bounds::*;
/// use try_create::New;
///
/// fn create_upper_constraint_with_validation(
///     value: f64,
///     inclusive: bool
/// ) -> Result<UpperBoundRuntime<f64>, String> {
///     if !value.is_finite() {
///         return Err(format!("Upper bound value must be finite, got: {}", value));
///     }
///     
///     let bound = if inclusive {
///         IntervalBoundRuntime::Closed(UpperBoundClosed::new(value))
///     } else {
///         IntervalBoundRuntime::Open(UpperBoundOpen::new(value))
///     };
///     
///     Ok(bound)
/// }
/// ```
///
/// ## Array-Like Range Construction
///
/// Upper bounds work naturally with Rust-style range construction:
///
/// ```rust
/// use grid1d::bounds::*;
/// use try_create::New;
///
/// // Pattern: Rust-style ranges with runtime bounds
/// fn create_rust_like_range(start: f64, end: f64, end_inclusive: bool) -> (LowerBoundClosed<f64>, UpperBoundRuntime<f64>) {
///     let lower = LowerBoundClosed::new(start);  // Always include start like [start, ...)
///     let upper = if end_inclusive {
///         IntervalBoundRuntime::Closed(UpperBoundClosed::new(end))  // [start, end]
///     } else {
///         IntervalBoundRuntime::Open(UpperBoundOpen::new(end))      // [start, end)
///     };
///     (lower, upper)
/// }
///
/// let (lower, upper_inclusive) = create_rust_like_range(0.0, 10.0, true);   // [0, 10]
/// let (_, upper_exclusive) = create_rust_like_range(0.0, 10.0, false);      // [0, 10)
///
/// assert!(upper_inclusive.value_within_bound(&10.0));  // 10 ≤ 10 → true
/// assert!(!upper_exclusive.value_within_bound(&10.0)); // 10 < 10 → false
/// ```
///
/// ## Mathematical Guarantees
///
/// The [`UpperBoundRuntime`] type maintains mathematical correctness by:
///
/// - **Constraint Semantics**: Properly implements `x ≤ b` (closed) vs `x < b` (open)
/// - **Ordering Consistency**: Maintains mathematical ordering where `b) < b]`
/// - **Type Safety**: Prevents mixing with lower bounds at compile time
/// - **Value Preservation**: Maintains exact scalar values without precision loss
/// - **Conversion Safety**: Provides safe extraction of compile-time types
///
/// Use [`UpperBoundRuntime`] when you need the flexibility of runtime boundary semantics
/// while maintaining mathematical correctness and integration with the grid1d ecosystem.
/// For maximum performance when boundary types are known at compile time, prefer the
/// direct types [`UpperBoundClosed`](crate::bounds::UpperBoundClosed) and [`UpperBoundOpen`](crate::bounds::UpperBoundOpen).
pub type UpperBoundRuntime<RealType> = IntervalBoundRuntime<RealType, Upper>;

impl<RealType: RealScalar, Side: BoundSide> BoundTypeChecks
    for IntervalBoundRuntime<RealType, Side>
{
    #[inline(always)]
    fn includes_boundary(&self) -> bool {
        matches!(self, IntervalBoundRuntime::Closed(_))
    }
}

impl<RealType: RealScalar> BoundSideChecks for LowerBoundRuntime<RealType> {
    #[inline(always)]
    fn is_upper_bound(&self) -> bool {
        false
    }
}

impl<RealType: RealScalar> BoundSideChecks for UpperBoundRuntime<RealType> {
    #[inline(always)]
    fn is_upper_bound(&self) -> bool {
        true
    }
}

impl<RealType: RealScalar, Side: BoundSide> ValueWithinBound
    for IntervalBoundRuntime<RealType, Side>
where
    IntervalBound<RealType, Side, Open>: ValueWithinBound<RealType = RealType>,
    IntervalBound<RealType, Side, Closed>: ValueWithinBound<RealType = RealType>,
{
    type RealType = RealType;

    #[inline(always)]
    fn value_within_bound(&self, value: &RealType) -> bool {
        match self {
            IntervalBoundRuntime::Open(bound) => bound.value_within_bound(value),
            IntervalBoundRuntime::Closed(bound) => bound.value_within_bound(value),
        }
    }
}

impl<RealType: RealScalar, Side: BoundSide> AsRef<RealType>
    for IntervalBoundRuntime<RealType, Side>
{
    #[inline(always)]
    fn as_ref(&self) -> &RealType {
        match self {
            IntervalBoundRuntime::Open(bound) => bound.as_ref(),
            IntervalBoundRuntime::Closed(bound) => bound.as_ref(),
        }
    }
}

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

    #[inline(always)]
    fn into_inner(self) -> RealType {
        match self {
            IntervalBoundRuntime::Open(bound) => bound.into_inner(),
            IntervalBoundRuntime::Closed(bound) => bound.into_inner(),
        }
    }
}

impl<RealType: RealScalar, Side: BoundSide> BoundChecks for IntervalBoundRuntime<RealType, Side> where
    Self: BoundSideChecks
{
}

#[duplicate_item(
    Type;
    [Open];
    [Closed];
)]
impl<RealType: RealScalar, Side: BoundSide> From<IntervalBound<RealType, Side, Type>>
    for IntervalBoundRuntime<RealType, Side>
{
    #[inline(always)]
    fn from(bound: IntervalBound<RealType, Side, Type>) -> Self {
        IntervalBoundRuntime::Type(bound)
    }
}

impl<RealType: RealScalar> PartialOrd for LowerBoundRuntime<RealType> {
    #[inline]
    fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
        if self.as_ref() == other.as_ref() {
            // Same value, closed is "less than" open
            Some(match (self, other) {
                (LowerBoundRuntime::Closed(_), LowerBoundRuntime::Open(_)) => Ordering::Less,
                (LowerBoundRuntime::Open(_), LowerBoundRuntime::Closed(_)) => Ordering::Greater,
                _ => Ordering::Equal,
            })
        } else {
            // different values, compare normally
            self.as_ref().partial_cmp(other.as_ref())
        }
    }
}

impl<RealType: RealScalar> PartialOrd for UpperBoundRuntime<RealType> {
    #[inline]
    fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
        if self.as_ref() == other.as_ref() {
            // Same value, closed is "less than" open
            Some(match (self, other) {
                (UpperBoundRuntime::Closed(_), UpperBoundRuntime::Open(_)) => Ordering::Greater,
                (UpperBoundRuntime::Open(_), UpperBoundRuntime::Closed(_)) => Ordering::Less,
                _ => Ordering::Equal,
            })
        } else {
            // different values, compare normally
            self.as_ref().partial_cmp(other.as_ref())
        }
    }
}
//------------------------------------------------------------------------------------------------

#[cfg(test)]
mod test {
    use super::*;
    use crate::bounds::*;

    mod 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 interval_bounds_runtime {
        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().unwrap(),
                c.upper_bound_runtime().unwrap(),
            );
            assert_eq!(lower, LowerBoundRuntime::Closed(LowerBoundClosed::new(1.0)));
            assert_eq!(upper, UpperBoundRuntime::Closed(UpperBoundClosed::new(2.0)));
            assert_eq!(c.clone().into_bounds_pair(), (1., 2.));

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

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

            let (lower, upper) = (
                r.lower_bound_runtime().unwrap(),
                r.upper_bound_runtime().unwrap(),
            );
            assert_eq!(lower, LowerBoundRuntime::Closed(LowerBoundClosed::new(1.0)));
            assert_eq!(upper, 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 bounds_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);
        }

        /// Test new_open and new_closed constructors for LowerBoundRuntime
        #[test]
        fn test_lower_bound_runtime_constructors() {
            let value = Real::try_new(5.0).unwrap();

            // Test new_open
            let open_bound = LowerBoundRuntime::new_open(value);
            assert!(open_bound.is_open());
            assert!(open_bound.is_open_variant());
            assert!(!open_bound.is_closed());
            assert!(!open_bound.is_closed_variant());
            assert_eq!(open_bound.as_ref(), &value);

            // Test new_closed
            let closed_bound = LowerBoundRuntime::new_closed(value);
            assert!(closed_bound.is_closed());
            assert!(closed_bound.is_closed_variant());
            assert!(!closed_bound.is_open());
            assert!(!closed_bound.is_open_variant());
            assert_eq!(closed_bound.as_ref(), &value);

            // Test constraint semantics for open bound
            assert!(!open_bound.value_within_bound(&value)); // 5 > 5 → false
            assert!(open_bound.value_within_bound(&Real::try_new(5.1).unwrap())); // 5.1 > 5 → true
            assert!(!open_bound.value_within_bound(&Real::try_new(4.9).unwrap())); // 4.9 > 5 → false

            // Test constraint semantics for closed bound
            assert!(closed_bound.value_within_bound(&value)); // 5 ≥ 5 → true
            assert!(closed_bound.value_within_bound(&Real::try_new(5.1).unwrap())); // 5.1 ≥ 5 → true
            assert!(!closed_bound.value_within_bound(&Real::try_new(4.9).unwrap())); // 4.9 ≥ 5 → false
        }

        /// Test new_open and new_closed constructors for UpperBoundRuntime
        #[test]
        fn test_upper_bound_runtime_constructors() {
            let value = Real::try_new(10.0).unwrap();

            // Test new_open
            let open_bound = UpperBoundRuntime::new_open(value);
            assert!(open_bound.is_open());
            assert!(open_bound.is_open_variant());
            assert!(!open_bound.is_closed());
            assert!(!open_bound.is_closed_variant());
            assert_eq!(open_bound.as_ref(), &value);

            // Test new_closed
            let closed_bound = UpperBoundRuntime::new_closed(value);
            assert!(closed_bound.is_closed());
            assert!(closed_bound.is_closed_variant());
            assert!(!closed_bound.is_open());
            assert!(!closed_bound.is_open_variant());
            assert_eq!(closed_bound.as_ref(), &value);

            // Test constraint semantics for open bound
            assert!(!open_bound.value_within_bound(&value)); // 10 < 10 → false
            assert!(open_bound.value_within_bound(&Real::try_new(9.9).unwrap())); // 9.9 < 10 → true
            assert!(!open_bound.value_within_bound(&Real::try_new(10.1).unwrap())); // 10.1 < 10 → false

            // Test constraint semantics for closed bound
            assert!(closed_bound.value_within_bound(&value)); // 10 ≤ 10 → true
            assert!(closed_bound.value_within_bound(&Real::try_new(9.9).unwrap())); // 9.9 ≤ 10 → true
            assert!(!closed_bound.value_within_bound(&Real::try_new(10.1).unwrap())); // 10.1 ≤ 10 → false
        }

        /// Test equivalence between convenience constructors and manual construction
        #[test]
        fn test_constructor_equivalence() {
            let value = Real::try_new(7.5).unwrap();

            // Lower bounds
            let lower_open_convenience = LowerBoundRuntime::new_open(value);
            let lower_open_manual = LowerBoundRuntime::Open(LowerBoundOpen::new(value));
            assert_eq!(lower_open_convenience, lower_open_manual);

            let lower_closed_convenience = LowerBoundRuntime::new_closed(value);
            let lower_closed_manual = LowerBoundRuntime::Closed(LowerBoundClosed::new(value));
            assert_eq!(lower_closed_convenience, lower_closed_manual);

            // Upper bounds
            let upper_open_convenience = UpperBoundRuntime::new_open(value);
            let upper_open_manual = UpperBoundRuntime::Open(UpperBoundOpen::new(value));
            assert_eq!(upper_open_convenience, upper_open_manual);

            let upper_closed_convenience = UpperBoundRuntime::new_closed(value);
            let upper_closed_manual = UpperBoundRuntime::Closed(UpperBoundClosed::new(value));
            assert_eq!(upper_closed_convenience, upper_closed_manual);
        }

        /// Test is_open_variant and is_closed_variant consistency
        #[test]
        fn test_variant_check_consistency() {
            let value = Real::try_new(3.5).unwrap();

            // Lower bounds
            let lower_open = LowerBoundRuntime::new_open(value);
            let lower_closed = LowerBoundRuntime::new_closed(value);

            // Verify is_open_variant matches is_open() from trait
            assert_eq!(lower_open.is_open_variant(), lower_open.is_open());
            assert_eq!(lower_closed.is_open_variant(), lower_closed.is_open());

            // Verify is_closed_variant matches is_closed() from trait
            assert_eq!(lower_open.is_closed_variant(), lower_open.is_closed());
            assert_eq!(lower_closed.is_closed_variant(), lower_closed.is_closed());

            // Verify complementary relationship
            assert_eq!(
                lower_open.is_open_variant(),
                !lower_open.is_closed_variant()
            );
            assert_eq!(
                lower_closed.is_open_variant(),
                !lower_closed.is_closed_variant()
            );

            // Upper bounds
            let upper_open = UpperBoundRuntime::new_open(value);
            let upper_closed = UpperBoundRuntime::new_closed(value);

            assert_eq!(upper_open.is_open_variant(), upper_open.is_open());
            assert_eq!(upper_closed.is_open_variant(), upper_closed.is_open());
            assert_eq!(upper_open.is_closed_variant(), upper_open.is_closed());
            assert_eq!(upper_closed.is_closed_variant(), upper_closed.is_closed());
            assert_eq!(
                upper_open.is_open_variant(),
                !upper_open.is_closed_variant()
            );
            assert_eq!(
                upper_closed.is_open_variant(),
                !upper_closed.is_closed_variant()
            );
        }

        /// Test variant checks for filtering and categorization
        #[test]
        fn test_variant_checks_for_filtering() {
            let bounds = [
                LowerBoundRuntime::new_open(Real::try_new(1.0).unwrap()),
                LowerBoundRuntime::new_closed(Real::try_new(2.0).unwrap()),
                LowerBoundRuntime::new_open(Real::try_new(3.0).unwrap()),
                LowerBoundRuntime::new_closed(Real::try_new(4.0).unwrap()),
                LowerBoundRuntime::new_open(Real::try_new(5.0).unwrap()),
            ];

            // Filter by variant type
            let open_bounds: Vec<_> = bounds.iter().filter(|b| b.is_open_variant()).collect();
            let closed_bounds: Vec<_> = bounds.iter().filter(|b| b.is_closed_variant()).collect();

            assert_eq!(open_bounds.len(), 3);
            assert_eq!(closed_bounds.len(), 2);

            // Verify all categorized correctly
            for bound in &open_bounds {
                assert!(bound.is_open_variant());
                assert!(!bound.is_closed_variant());
            }
            for bound in &closed_bounds {
                assert!(bound.is_closed_variant());
                assert!(!bound.is_open_variant());
            }
        }

        /// Test variant checks are non-consuming
        #[test]
        fn test_variant_checks_non_consuming() {
            let bound = LowerBoundRuntime::new_open(Real::try_new(42.0).unwrap());

            // Can check multiple times without consuming
            assert!(bound.is_open_variant());
            assert!(bound.is_open_variant());
            assert!(!bound.is_closed_variant());
            assert!(!bound.is_closed_variant());

            // Can still use the bound after checks
            assert!(bound.value_within_bound(&Real::try_new(50.0).unwrap()));
            assert_eq!(bound.as_ref(), &Real::try_new(42.0).unwrap());
        }

        /// Test constructors with different scalar types
        #[test]
        fn test_constructors_with_different_scalars() {
            // Test with f64
            let f64_open = LowerBoundRuntime::new_open(5.0_f64);
            let f64_closed = LowerBoundRuntime::new_closed(5.0_f64);
            assert!(f64_open.is_open_variant());
            assert!(f64_closed.is_closed_variant());

            // Test with validated scalar
            let validated_value = Real::try_new(10.0).unwrap();
            let validated_open = UpperBoundRuntime::new_open(validated_value);
            let validated_closed = UpperBoundRuntime::new_closed(validated_value);
            assert!(validated_open.is_open_variant());
            assert!(validated_closed.is_closed_variant());
        }

        /// Test constructors in dynamic interval creation scenarios
        #[test]
        fn test_constructors_dynamic_interval_creation() {
            let create_bound_from_config =
                |value: f64, inclusive: bool| -> LowerBoundRuntime<Real> {
                    let real_value = Real::try_new(value).unwrap();
                    if inclusive {
                        LowerBoundRuntime::new_closed(real_value)
                    } else {
                        LowerBoundRuntime::new_open(real_value)
                    }
                };

            // Test inclusive bound
            let inclusive_bound = create_bound_from_config(0.0, true);
            assert!(inclusive_bound.is_closed_variant());
            assert!(inclusive_bound.value_within_bound(&Real::try_new(0.0).unwrap()));

            // Test exclusive bound
            let exclusive_bound = create_bound_from_config(0.0, false);
            assert!(exclusive_bound.is_open_variant());
            assert!(!exclusive_bound.value_within_bound(&Real::try_new(0.0).unwrap()));
        }

        /// Test that constructors maintain proper ordering relationships
        #[test]
        fn test_constructor_ordering() {
            let value = Real::try_new(5.0).unwrap();

            // For lower bounds: closed < open at same value
            let lower_closed = LowerBoundRuntime::new_closed(value);
            let lower_open = LowerBoundRuntime::new_open(value);
            assert!(lower_closed < lower_open);

            // For upper bounds: open < closed at same value
            let upper_open = UpperBoundRuntime::new_open(value);
            let upper_closed = UpperBoundRuntime::new_closed(value);
            assert!(upper_open < upper_closed);
        }
    }

    /// Tests for new helper functions for hull computation with optional bounds
    mod maybe_unbounded_helpers {
        use super::*;
        use num_valid::RealNative64StrictFiniteInDebug;
        use try_create::TryNew;

        type Real = RealNative64StrictFiniteInDebug;

        /// Test min_lower_bound_maybe_unbounded with both bounds present (closed wins)
        #[test]
        fn test_min_lower_bound_both_present_closed_wins() {
            let value = Real::try_new(5.0).unwrap();
            let closed = LowerBoundRuntime::new_closed(value);
            let open = LowerBoundRuntime::new_open(value);

            let result = min_lower_bound_maybe_unbounded(Some(closed), Some(open));

            assert!(result.is_some());
            assert!(
                result.unwrap().is_closed_variant(),
                "Closed should win over open at same value"
            );
        }

        /// Test min_lower_bound_maybe_unbounded with different values
        #[test]
        fn test_min_lower_bound_different_values() {
            let value1 = Real::try_new(3.0).unwrap();
            let value2 = Real::try_new(7.0).unwrap();
            let bound1 = LowerBoundRuntime::new_closed(value1);
            let bound2 = LowerBoundRuntime::new_open(value2);

            let result = min_lower_bound_maybe_unbounded(Some(bound1.clone()), Some(bound2));

            assert!(result.is_some());
            let result_bound = result.unwrap();
            assert_eq!(result_bound.as_ref(), &3.0, "Should select minimum value");
            assert!(result_bound.is_closed_variant());
        }

        /// Test min_lower_bound_maybe_unbounded with first None (unbounded wins)
        #[test]
        fn test_min_lower_bound_first_none() {
            let value = Real::try_new(5.0).unwrap();
            let bound = LowerBoundRuntime::new_closed(value);

            let result = min_lower_bound_maybe_unbounded(None, Some(bound));

            assert!(result.is_none(), "None (unbounded) should win");
        }

        /// Test min_lower_bound_maybe_unbounded with second None (unbounded wins)
        #[test]
        fn test_min_lower_bound_second_none() {
            let value = Real::try_new(5.0).unwrap();
            let bound = LowerBoundRuntime::new_closed(value);

            let result = min_lower_bound_maybe_unbounded(Some(bound), None);

            assert!(result.is_none(), "None (unbounded) should win");
        }

        /// Test min_lower_bound_maybe_unbounded with both None
        #[test]
        fn test_min_lower_bound_both_none() {
            let result = min_lower_bound_maybe_unbounded::<Real>(None, None);

            assert!(result.is_none());
        }

        /// Test max_upper_bound_maybe_unbounded with both bounds present (closed wins)
        #[test]
        fn test_max_upper_bound_both_present_closed_wins() {
            let value = Real::try_new(5.0).unwrap();
            let closed = UpperBoundRuntime::new_closed(value);
            let open = UpperBoundRuntime::new_open(value);

            let result = max_upper_bound_maybe_unbounded(Some(closed.clone()), Some(open.clone()));

            assert!(result.is_some());
            assert!(
                result.unwrap().is_closed_variant(),
                "Closed should win over open at same value"
            );
        }

        /// Test max_upper_bound_maybe_unbounded with different values
        #[test]
        fn test_max_upper_bound_different_values() {
            let value1 = Real::try_new(3.0).unwrap();
            let value2 = Real::try_new(7.0).unwrap();
            let bound1 = UpperBoundRuntime::new_open(value1);
            let bound2 = UpperBoundRuntime::new_closed(value2);

            let result = max_upper_bound_maybe_unbounded(Some(bound1), Some(bound2.clone()));

            assert!(result.is_some());
            let result_bound = result.unwrap();
            assert_eq!(result_bound.as_ref(), &7.0, "Should select maximum value");
            assert!(result_bound.is_closed_variant());
        }

        /// Test max_upper_bound_maybe_unbounded with first None (unbounded wins)
        #[test]
        fn test_max_upper_bound_first_none() {
            let value = Real::try_new(5.0).unwrap();
            let bound = UpperBoundRuntime::new_closed(value);

            let result = max_upper_bound_maybe_unbounded(None, Some(bound));

            assert!(result.is_none(), "None (unbounded) should win");
        }

        /// Test max_upper_bound_maybe_unbounded with second None (unbounded wins)
        #[test]
        fn test_max_upper_bound_second_none() {
            let value = Real::try_new(5.0).unwrap();
            let bound = UpperBoundRuntime::new_closed(value);

            let result = max_upper_bound_maybe_unbounded(Some(bound), None);

            assert!(result.is_none(), "None (unbounded) should win");
        }

        /// Test max_upper_bound_maybe_unbounded with both None
        #[test]
        fn test_max_upper_bound_both_none() {
            let result = max_upper_bound_maybe_unbounded::<Real>(None, None);

            assert!(result.is_none());
        }

        /// Test symmetry: swapping arguments doesn't change result
        #[test]
        fn test_min_lower_bound_symmetry() {
            let value1 = Real::try_new(3.0).unwrap();
            let value2 = Real::try_new(7.0).unwrap();
            let bound1 = LowerBoundRuntime::new_closed(value1);
            let bound2 = LowerBoundRuntime::new_open(value2);

            let result1 =
                min_lower_bound_maybe_unbounded(Some(bound1.clone()), Some(bound2.clone()));
            let result2 = min_lower_bound_maybe_unbounded(Some(bound2), Some(bound1));

            assert_eq!(result1, result2, "Operation should be commutative");
        }

        /// Test symmetry for upper bounds
        #[test]
        fn test_max_upper_bound_symmetry() {
            let value1 = Real::try_new(3.0).unwrap();
            let value2 = Real::try_new(7.0).unwrap();
            let bound1 = UpperBoundRuntime::new_closed(value1);
            let bound2 = UpperBoundRuntime::new_open(value2);

            let result1 =
                max_upper_bound_maybe_unbounded(Some(bound1.clone()), Some(bound2.clone()));
            let result2 = max_upper_bound_maybe_unbounded(Some(bound2), Some(bound1));

            assert_eq!(result1, result2, "Operation should be commutative");
        }

        /// Test interaction with min_lower_bound (existing function)
        #[test]
        fn test_consistency_with_existing_min_lower_bound() {
            let value1 = Real::try_new(3.0).unwrap();
            let value2 = Real::try_new(7.0).unwrap();
            let bound1 = LowerBoundRuntime::new_closed(value1);
            let bound2 = LowerBoundRuntime::new_open(value2);

            // Using the new maybe_unbounded function with Some
            let result_maybe =
                min_lower_bound_maybe_unbounded(Some(bound1.clone()), Some(bound2.clone()))
                    .unwrap();

            // Using the existing function
            let result_direct = min_lower_bound(bound1, bound2);

            assert_eq!(
                result_maybe, result_direct,
                "Should be consistent with existing function"
            );
        }

        /// Test interaction with max_upper_bound (existing function)
        #[test]
        fn test_consistency_with_existing_max_upper_bound() {
            let value1 = Real::try_new(3.0).unwrap();
            let value2 = Real::try_new(7.0).unwrap();
            let bound1 = UpperBoundRuntime::new_closed(value1);
            let bound2 = UpperBoundRuntime::new_open(value2);

            // Using the new maybe_unbounded function with Some
            let result_maybe =
                max_upper_bound_maybe_unbounded(Some(bound1.clone()), Some(bound2.clone()))
                    .unwrap();

            // Using the existing function
            let result_direct = max_upper_bound(bound1, bound2);

            assert_eq!(
                result_maybe, result_direct,
                "Should be consistent with existing function"
            );
        }

        /// Test with multiple calls (associativity)
        #[test]
        fn test_min_lower_bound_associativity() {
            let v1 = Real::try_new(1.0).unwrap();
            let v2 = Real::try_new(2.0).unwrap();
            let v3 = Real::try_new(3.0).unwrap();
            let b1 = LowerBoundRuntime::new_closed(v1);
            let b2 = LowerBoundRuntime::new_open(v2);
            let b3 = LowerBoundRuntime::new_closed(v3);

            // (b1 min b2) min b3
            let temp = min_lower_bound_maybe_unbounded(Some(b1.clone()), Some(b2.clone()));
            let result1 = min_lower_bound_maybe_unbounded(temp, Some(b3.clone()));

            // b1 min (b2 min b3)
            let temp = min_lower_bound_maybe_unbounded(Some(b2), Some(b3));
            let result2 = min_lower_bound_maybe_unbounded(Some(b1), temp);

            assert_eq!(result1, result2, "Operation should be associative");
        }
    }

    // Tests for IntervalBoundRuntime::flip_bound_type() and flip_bound_side()
    mod transformations {
        use super::*;

        /// Test flip_bound_type() on LowerBoundRuntime variants
        #[test]
        fn flip_bound_type_lower_open_to_closed() {
            let lower_open = LowerBoundRuntime::new_open(5.0);
            let lower_closed = lower_open.flip_bound_type();

            assert!(lower_closed.is_closed_variant());
            assert!(!lower_closed.is_open_variant());
            assert_eq!(*lower_closed.as_ref(), 5.0);
        }

        #[test]
        fn flip_bound_type_lower_closed_to_open() {
            let lower_closed = LowerBoundRuntime::new_closed(10.0);
            let lower_open = lower_closed.flip_bound_type();

            assert!(lower_open.is_open_variant());
            assert!(!lower_open.is_closed_variant());
            assert_eq!(*lower_open.as_ref(), 10.0);
        }

        /// Test flip_bound_type() on UpperBoundRuntime variants
        #[test]
        fn flip_bound_type_upper_open_to_closed() {
            let upper_open = UpperBoundRuntime::new_open(20.0);
            let upper_closed = upper_open.flip_bound_type();

            assert!(upper_closed.is_closed_variant());
            assert!(!upper_closed.is_open_variant());
            assert_eq!(*upper_closed.as_ref(), 20.0);
        }

        #[test]
        fn flip_bound_type_upper_closed_to_open() {
            let upper_closed = UpperBoundRuntime::new_closed(15.0);
            let upper_open = upper_closed.flip_bound_type();

            assert!(upper_open.is_open_variant());
            assert!(!upper_open.is_closed_variant());
            assert_eq!(*upper_open.as_ref(), 15.0);
        }

        /// Test that flipping bound type twice returns to original
        #[test]
        fn flip_bound_type_idempotent() {
            // Lower bounds
            let lower_open_original = LowerBoundRuntime::new_open(3.0);
            let lower_open_roundtrip = lower_open_original
                .clone()
                .flip_bound_type()
                .flip_bound_type();
            assert_eq!(lower_open_original, lower_open_roundtrip);

            let lower_closed_original = LowerBoundRuntime::new_closed(7.0);
            let lower_closed_roundtrip = lower_closed_original
                .clone()
                .flip_bound_type()
                .flip_bound_type();
            assert_eq!(lower_closed_original, lower_closed_roundtrip);

            // Upper bounds
            let upper_open_original = UpperBoundRuntime::new_open(12.0);
            let upper_open_roundtrip = upper_open_original
                .clone()
                .flip_bound_type()
                .flip_bound_type();
            assert_eq!(upper_open_original, upper_open_roundtrip);

            let upper_closed_original = UpperBoundRuntime::new_closed(18.0);
            let upper_closed_roundtrip = upper_closed_original
                .clone()
                .flip_bound_type()
                .flip_bound_type();
            assert_eq!(upper_closed_original, upper_closed_roundtrip);
        }

        /// Test flip_bound_side() from lower to upper bounds
        #[test]
        fn flip_bound_side_lower_open_to_upper_open() {
            let lower_open = LowerBoundRuntime::new_open(5.0);
            let upper_open: UpperBoundRuntime<f64> = lower_open.flip_bound_side();

            assert!(upper_open.is_open_variant());
            assert_eq!(*upper_open.as_ref(), 5.0);
        }

        #[test]
        fn flip_bound_side_lower_closed_to_upper_closed() {
            let lower_closed = LowerBoundRuntime::new_closed(10.0);
            let upper_closed: UpperBoundRuntime<f64> = lower_closed.flip_bound_side();

            assert!(upper_closed.is_closed_variant());
            assert_eq!(*upper_closed.as_ref(), 10.0);
        }

        /// Test flip_bound_side() from upper to lower bounds
        #[test]
        fn flip_bound_side_upper_open_to_lower_open() {
            let upper_open = UpperBoundRuntime::new_open(20.0);
            let lower_open: LowerBoundRuntime<f64> = upper_open.flip_bound_side();

            assert!(lower_open.is_open_variant());
            assert_eq!(*lower_open.as_ref(), 20.0);
        }

        #[test]
        fn flip_bound_side_upper_closed_to_lower_closed() {
            let upper_closed = UpperBoundRuntime::new_closed(15.0);
            let lower_closed: LowerBoundRuntime<f64> = upper_closed.flip_bound_side();

            assert!(lower_closed.is_closed_variant());
            assert_eq!(*lower_closed.as_ref(), 15.0);
        }

        /// Test that flipping bound side twice returns to original side
        #[test]
        fn flip_bound_side_roundtrip() {
            // Lower to upper to lower
            let lower_open_original = LowerBoundRuntime::new_open(3.0);
            let upper_open: UpperBoundRuntime<f64> = lower_open_original.clone().flip_bound_side();
            let lower_open_back: LowerBoundRuntime<f64> = upper_open.flip_bound_side();
            assert_eq!(lower_open_original, lower_open_back);

            let lower_closed_original = LowerBoundRuntime::new_closed(7.0);
            let upper_closed: UpperBoundRuntime<f64> =
                lower_closed_original.clone().flip_bound_side();
            let lower_closed_back: LowerBoundRuntime<f64> = upper_closed.flip_bound_side();
            assert_eq!(lower_closed_original, lower_closed_back);

            // Upper to lower to upper
            let upper_open_original = UpperBoundRuntime::new_open(12.0);
            let lower_open_temp: LowerBoundRuntime<f64> =
                upper_open_original.clone().flip_bound_side();
            let upper_open_back: UpperBoundRuntime<f64> = lower_open_temp.flip_bound_side();
            assert_eq!(upper_open_original, upper_open_back);

            let upper_closed_original = UpperBoundRuntime::new_closed(18.0);
            let lower_closed_temp: LowerBoundRuntime<f64> =
                upper_closed_original.clone().flip_bound_side();
            let upper_closed_back: UpperBoundRuntime<f64> = lower_closed_temp.flip_bound_side();
            assert_eq!(upper_closed_original, upper_closed_back);
        }

        /// Test combining flip_bound_side() and flip_bound_type()
        #[test]
        fn combined_flip_lower_closed_to_upper_open() {
            let lower_closed = LowerBoundRuntime::new_closed(3.0);
            let upper_open: UpperBoundRuntime<f64> = lower_closed
                .flip_bound_side() // Lower Closed -> Upper Closed
                .flip_bound_type(); // Upper Closed -> Upper Open

            assert!(upper_open.is_open_variant());
            assert_eq!(*upper_open.as_ref(), 3.0);
        }

        #[test]
        fn combined_flip_lower_open_to_upper_closed() {
            let lower_open = LowerBoundRuntime::new_open(8.0);
            let upper_closed: UpperBoundRuntime<f64> = lower_open
                .flip_bound_side() // Lower Open -> Upper Open
                .flip_bound_type(); // Upper Open -> Upper Closed

            assert!(upper_closed.is_closed_variant());
            assert_eq!(*upper_closed.as_ref(), 8.0);
        }

        #[test]
        fn combined_flip_upper_closed_to_lower_open() {
            let upper_closed = UpperBoundRuntime::new_closed(15.0);
            let lower_open: LowerBoundRuntime<f64> = upper_closed
                .flip_bound_side() // Upper Closed -> Lower Closed
                .flip_bound_type(); // Lower Closed -> Lower Open

            assert!(lower_open.is_open_variant());
            assert_eq!(*lower_open.as_ref(), 15.0);
        }

        #[test]
        fn combined_flip_upper_open_to_lower_closed() {
            let upper_open = UpperBoundRuntime::new_open(22.0);
            let lower_closed: LowerBoundRuntime<f64> = upper_open
                .flip_bound_side() // Upper Open -> Lower Open
                .flip_bound_type(); // Lower Open -> Lower Closed

            assert!(lower_closed.is_closed_variant());
            assert_eq!(*lower_closed.as_ref(), 22.0);
        }

        /// Test flip_bound_type() preserves value with negative numbers
        #[test]
        fn flip_bound_type_negative_values() {
            let lower_open = LowerBoundRuntime::new_open(-5.0);
            let lower_closed = lower_open.flip_bound_type();
            assert_eq!(*lower_closed.as_ref(), -5.0);
            assert!(lower_closed.is_closed_variant());

            let upper_closed = UpperBoundRuntime::new_closed(-10.0);
            let upper_open = upper_closed.flip_bound_type();
            assert_eq!(*upper_open.as_ref(), -10.0);
            assert!(upper_open.is_open_variant());
        }

        /// Test flip_bound_side() preserves value with negative numbers
        #[test]
        fn flip_bound_side_negative_values() {
            let lower_open = LowerBoundRuntime::new_open(-3.0);
            let upper_open: UpperBoundRuntime<f64> = lower_open.flip_bound_side();
            assert_eq!(*upper_open.as_ref(), -3.0);
            assert!(upper_open.is_open_variant());

            let upper_closed = UpperBoundRuntime::new_closed(-7.0);
            let lower_closed: LowerBoundRuntime<f64> = upper_closed.flip_bound_side();
            assert_eq!(*lower_closed.as_ref(), -7.0);
            assert!(lower_closed.is_closed_variant());
        }

        /// Test with zero values
        #[test]
        fn transformations_with_zero() {
            let lower_zero_open = LowerBoundRuntime::new_open(0.0);
            let lower_zero_closed = lower_zero_open.flip_bound_type();
            assert_eq!(*lower_zero_closed.as_ref(), 0.0);
            assert!(lower_zero_closed.is_closed_variant());

            let upper_zero_closed = UpperBoundRuntime::new_closed(0.0);
            let lower_zero_from_upper: LowerBoundRuntime<f64> = upper_zero_closed.flip_bound_side();
            assert_eq!(*lower_zero_from_upper.as_ref(), 0.0);
            assert!(lower_zero_from_upper.is_closed_variant());
        }

        /// Test with very small positive values (edge case)
        #[test]
        fn transformations_with_small_values() {
            let tiny_value = 1e-100;

            let lower_open = LowerBoundRuntime::new_open(tiny_value);
            let lower_closed = lower_open.flip_bound_type();
            assert_eq!(*lower_closed.as_ref(), tiny_value);

            let upper_open = UpperBoundRuntime::new_open(tiny_value);
            let lower_open_from_upper: LowerBoundRuntime<f64> = upper_open.flip_bound_side();
            assert_eq!(*lower_open_from_upper.as_ref(), tiny_value);
        }

        /// Test with very large values
        #[test]
        fn transformations_with_large_values() {
            let large_value = 1e100;

            let upper_closed = UpperBoundRuntime::new_closed(large_value);
            let upper_open = upper_closed.flip_bound_type();
            assert_eq!(*upper_open.as_ref(), large_value);
            assert!(upper_open.is_open_variant());

            let lower_closed = LowerBoundRuntime::new_closed(large_value);
            let upper_closed_from_lower: UpperBoundRuntime<f64> = lower_closed.flip_bound_side();
            assert_eq!(*upper_closed_from_lower.as_ref(), large_value);
            assert!(upper_closed_from_lower.is_closed_variant());
        }

        /// Test commutativity: order of flip_bound_side and flip_bound_type shouldn't matter
        #[test]
        fn flip_operations_commute() {
            let original = LowerBoundRuntime::new_closed(5.0);

            // Side first, then type
            let result1: UpperBoundRuntime<f64> = original
                .clone()
                .flip_bound_side() // Lower Closed -> Upper Closed
                .flip_bound_type(); // Upper Closed -> Upper Open

            // Type first, then side
            let result2: UpperBoundRuntime<f64> = original
                .flip_bound_type() // Lower Closed -> Lower Open
                .flip_bound_side(); // Lower Open -> Upper Open

            assert_eq!(result1, result2);
            assert!(result1.is_open_variant());
            assert_eq!(*result1.as_ref(), 5.0);
        }

        /// Test that flip_bound_side preserves the type (open/closed)
        #[test]
        fn flip_bound_side_preserves_type() {
            // Open bounds stay open
            let lower_open = LowerBoundRuntime::new_open(5.0);
            let upper_open: UpperBoundRuntime<f64> = lower_open.flip_bound_side();
            assert!(upper_open.is_open_variant());

            let upper_open2 = UpperBoundRuntime::new_open(10.0);
            let lower_open2: LowerBoundRuntime<f64> = upper_open2.flip_bound_side();
            assert!(lower_open2.is_open_variant());

            // Closed bounds stay closed
            let lower_closed = LowerBoundRuntime::new_closed(15.0);
            let upper_closed: UpperBoundRuntime<f64> = lower_closed.flip_bound_side();
            assert!(upper_closed.is_closed_variant());

            let upper_closed2 = UpperBoundRuntime::new_closed(20.0);
            let lower_closed2: LowerBoundRuntime<f64> = upper_closed2.flip_bound_side();
            assert!(lower_closed2.is_closed_variant());
        }

        /// Test that flip_bound_type preserves the side (lower/upper)
        #[test]
        fn flip_bound_type_preserves_side() {
            // Lower bounds stay lower (test by trying to use as lower bounds)
            let lower_open = LowerBoundRuntime::new_open(5.0);
            let lower_closed = lower_open.flip_bound_type();
            // If this compiles and runs, the type is still LowerBoundRuntime
            assert_eq!(*lower_closed.as_ref(), 5.0);

            // Upper bounds stay upper
            let upper_closed = UpperBoundRuntime::new_closed(10.0);
            let upper_open = upper_closed.flip_bound_type();
            // If this compiles and runs, the type is still UpperBoundRuntime
            assert_eq!(*upper_open.as_ref(), 10.0);
        }

        /// Test use case: interval difference computation
        /// When computing A \ B, we need to flip bounds appropriately
        #[test]
        fn interval_difference_use_case() {
            // A = [0, 10], B = [5, 7]
            // Result should be [0, 5) ∪ (7, 10]

            // B's lower bound [5 needs to become upper bound )5 for left part
            let b_lower = LowerBoundRuntime::new_closed(5.0);
            let left_upper: UpperBoundRuntime<f64> = b_lower
                .flip_bound_side() // Lower Closed -> Upper Closed
                .flip_bound_type(); // Upper Closed -> Upper Open

            assert!(left_upper.is_open_variant());
            assert_eq!(*left_upper.as_ref(), 5.0);
            // This creates the upper bound )5 for interval [0, 5)

            // B's upper bound ]7 needs to become lower bound (7 for right part
            let b_upper = UpperBoundRuntime::new_closed(7.0);
            let right_lower: LowerBoundRuntime<f64> = b_upper
                .flip_bound_side() // Upper Closed -> Lower Closed
                .flip_bound_type(); // Lower Closed -> Lower Open

            assert!(right_lower.is_open_variant());
            assert_eq!(*right_lower.as_ref(), 7.0);
            // This creates the lower bound (7 for interval (7, 10]
        }

        /// Test with validated scalar types
        #[test]
        fn transformations_with_validated_types() {
            use num_valid::RealNative64StrictFiniteInDebug;
            use try_create::TryNew;

            let value = RealNative64StrictFiniteInDebug::try_new(5.0).unwrap();

            let lower_open = LowerBoundRuntime::new_open(value);
            let lower_closed = lower_open.flip_bound_type();
            assert!(lower_closed.is_closed_variant());
            assert_eq!(*lower_closed.as_ref(), value);

            let upper_closed = UpperBoundRuntime::new_closed(value);
            let lower_closed_from_upper: LowerBoundRuntime<_> = upper_closed.flip_bound_side();
            assert!(lower_closed_from_upper.is_closed_variant());
            assert_eq!(*lower_closed_from_upper.as_ref(), value);
        }

        /// Test multiple sequential transformations
        #[test]
        fn multiple_sequential_transformations() {
            let original = LowerBoundRuntime::new_open(10.0);

            // Apply transformations in sequence
            let step1 = original.flip_bound_type(); // Lower Open -> Lower Closed
            let step2: UpperBoundRuntime<f64> = step1.flip_bound_side(); // Lower Closed -> Upper Closed
            let step3 = step2.flip_bound_type(); // Upper Closed -> Upper Open
            let step4: LowerBoundRuntime<f64> = step3.flip_bound_side(); // Upper Open -> Lower Open

            // Should return to same type as original
            assert!(step4.is_open_variant());
            assert_eq!(*step4.as_ref(), 10.0);
        }

        /// Test flip_bound_side_and_type method on IntervalBound
        #[test]
        fn test_flip_bound_side_and_type() {
            let lower_closed = IntervalBound::<f64, Lower, Closed>::new(5.0);
            let upper_open: IntervalBound<f64, Upper, Open> =
                lower_closed.flip_bound_side_and_type();
            assert_eq!(*upper_open.as_ref(), 5.0);

            let upper_open2 = IntervalBound::<f64, Upper, Open>::new(10.0);
            let lower_closed2: IntervalBound<f64, Lower, Closed> =
                upper_open2.flip_bound_side_and_type();
            assert_eq!(*lower_closed2.as_ref(), 10.0);

            let lower_open = IntervalBound::<f64, Lower, Open>::new(3.0);
            let upper_closed: IntervalBound<f64, Upper, Closed> =
                lower_open.flip_bound_side_and_type();
            assert_eq!(*upper_closed.as_ref(), 3.0);

            let upper_closed2 = IntervalBound::<f64, Upper, Closed>::new(7.0);
            let lower_open2: IntervalBound<f64, Lower, Open> =
                upper_closed2.flip_bound_side_and_type();
            assert_eq!(*lower_open2.as_ref(), 7.0);
        }

        /// Test BoundSide::is_lower() method
        #[test]
        fn test_bound_side() {
            assert!(Upper::is_upper());
            assert!(!Upper::is_lower());
            assert!(!Lower::is_upper());
            assert!(Lower::is_lower());
        }

        /// Test BoundSideChecks trait methods
        #[test]
        fn test_bound_side_checks() {
            let lower = LowerBoundRuntime::new_closed(5.0);
            assert!(!lower.is_upper_bound());

            let upper = UpperBoundRuntime::new_open(10.0);
            assert!(upper.is_upper_bound());
        }

        /// Test IntoInner trait on IntervalBoundRuntime
        #[test]
        fn test_interval_bound_runtime_into_inner() {
            let lower_open = LowerBoundRuntime::new_open(5.0);
            let value = lower_open.into_inner();
            assert_eq!(value, 5.0);

            let lower_closed = LowerBoundRuntime::new_closed(7.0);
            let value2 = lower_closed.into_inner();
            assert_eq!(value2, 7.0);

            let upper_open = UpperBoundRuntime::new_open(3.0);
            let value3 = upper_open.into_inner();
            assert_eq!(value3, 3.0);

            let upper_closed = UpperBoundRuntime::new_closed(9.0);
            let value4 = upper_closed.into_inner();
            assert_eq!(value4, 9.0);
        }

        /// Test BoundType::is_open() method
        #[test]
        fn test_bound_type_is_open() {
            // is_open() is defined as !includes_boundary()
            // Ensure it compiles and works
            assert!(Closed::includes_boundary() != Closed::is_open());
            assert!(Open::is_open());
            assert!(!Closed::is_open());
        }
    }

    mod 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);
        }
    }
}