Trait Hull 

pub trait Hull<RHS = Self> {
    type Output;

    // Required method
    fn hull(&self, rhs: &RHS) -> Self::Output;
}

Calculates a new range covering both ranges.

Required Associated Types

type Output

Required Methods

fn hull(&self, rhs: &RHS) -> Self::Output

Dyn Compatibility

This trait is dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety".

Implementations on Foreign Types

impl Hull<Interval<i8>> for i8

fn hull(&self, other: &Interval<i8>) -> Interval<i8>

Calculates the smallest interval containing an interval and a value.

assert_eq!((3 as i8).hull(&Interval::new(5, 8)), Interval::new(3, 8));
assert_eq!((2 as i8).hull(&Interval::new(1, 3)), Interval::new(1, 3));
assert_eq!((9 as i8).hull(&Interval::new(2, 6)), Interval::new(2, 9));
assert_eq!((4 as i8).hull(&Interval::singleton(4)), Interval::singleton(4));
assert_eq!((5 as i8).hull(&Interval::empty()), Interval::singleton(5));

type Output = Interval<i8>

impl Hull<Interval<i16>> for i16

fn hull(&self, other: &Interval<i16>) -> Interval<i16>

Calculates the smallest interval containing an interval and a value.

assert_eq!((3 as i16).hull(&Interval::new(5, 8)), Interval::new(3, 8));
assert_eq!((2 as i16).hull(&Interval::new(1, 3)), Interval::new(1, 3));
assert_eq!((9 as i16).hull(&Interval::new(2, 6)), Interval::new(2, 9));
assert_eq!((4 as i16).hull(&Interval::singleton(4)), Interval::singleton(4));
assert_eq!((5 as i16).hull(&Interval::empty()), Interval::singleton(5));

type Output = Interval<i16>

impl Hull<Interval<i32>> for i32

fn hull(&self, other: &Interval<i32>) -> Interval<i32>

Calculates the smallest interval containing an interval and a value.

assert_eq!((3 as i32).hull(&Interval::new(5, 8)), Interval::new(3, 8));
assert_eq!((2 as i32).hull(&Interval::new(1, 3)), Interval::new(1, 3));
assert_eq!((9 as i32).hull(&Interval::new(2, 6)), Interval::new(2, 9));
assert_eq!((4 as i32).hull(&Interval::singleton(4)), Interval::singleton(4));
assert_eq!((5 as i32).hull(&Interval::empty()), Interval::singleton(5));

type Output = Interval<i32>

impl Hull<Interval<i64>> for i64

fn hull(&self, other: &Interval<i64>) -> Interval<i64>

Calculates the smallest interval containing an interval and a value.

assert_eq!((3 as i64).hull(&Interval::new(5, 8)), Interval::new(3, 8));
assert_eq!((2 as i64).hull(&Interval::new(1, 3)), Interval::new(1, 3));
assert_eq!((9 as i64).hull(&Interval::new(2, 6)), Interval::new(2, 9));
assert_eq!((4 as i64).hull(&Interval::singleton(4)), Interval::singleton(4));
assert_eq!((5 as i64).hull(&Interval::empty()), Interval::singleton(5));

type Output = Interval<i64>

impl Hull<Interval<isize>> for isize

fn hull(&self, other: &Interval<isize>) -> Interval<isize>

Calculates the smallest interval containing an interval and a value.

assert_eq!((3 as isize).hull(&Interval::new(5, 8)), Interval::new(3, 8));
assert_eq!((2 as isize).hull(&Interval::new(1, 3)), Interval::new(1, 3));
assert_eq!((9 as isize).hull(&Interval::new(2, 6)), Interval::new(2, 9));
assert_eq!((4 as isize).hull(&Interval::singleton(4)), Interval::singleton(4));
assert_eq!((5 as isize).hull(&Interval::empty()), Interval::singleton(5));

type Output = Interval<isize>

impl Hull<Interval<u8>> for u8

fn hull(&self, other: &Interval<u8>) -> Interval<u8>

Calculates the smallest interval containing an interval and a value.

assert_eq!((3 as u8).hull(&Interval::new(5, 8)), Interval::new(3, 8));
assert_eq!((2 as u8).hull(&Interval::new(1, 3)), Interval::new(1, 3));
assert_eq!((9 as u8).hull(&Interval::new(2, 6)), Interval::new(2, 9));
assert_eq!((4 as u8).hull(&Interval::singleton(4)), Interval::singleton(4));
assert_eq!((5 as u8).hull(&Interval::empty()), Interval::singleton(5));

type Output = Interval<u8>

impl Hull<Interval<u16>> for u16

fn hull(&self, other: &Interval<u16>) -> Interval<u16>

Calculates the smallest interval containing an interval and a value.

assert_eq!((3 as u16).hull(&Interval::new(5, 8)), Interval::new(3, 8));
assert_eq!((2 as u16).hull(&Interval::new(1, 3)), Interval::new(1, 3));
assert_eq!((9 as u16).hull(&Interval::new(2, 6)), Interval::new(2, 9));
assert_eq!((4 as u16).hull(&Interval::singleton(4)), Interval::singleton(4));
assert_eq!((5 as u16).hull(&Interval::empty()), Interval::singleton(5));

type Output = Interval<u16>

impl Hull<Interval<u32>> for u32

fn hull(&self, other: &Interval<u32>) -> Interval<u32>

Calculates the smallest interval containing an interval and a value.

assert_eq!((3 as u32).hull(&Interval::new(5, 8)), Interval::new(3, 8));
assert_eq!((2 as u32).hull(&Interval::new(1, 3)), Interval::new(1, 3));
assert_eq!((9 as u32).hull(&Interval::new(2, 6)), Interval::new(2, 9));
assert_eq!((4 as u32).hull(&Interval::singleton(4)), Interval::singleton(4));
assert_eq!((5 as u32).hull(&Interval::empty()), Interval::singleton(5));

type Output = Interval<u32>

impl Hull<Interval<u64>> for u64

fn hull(&self, other: &Interval<u64>) -> Interval<u64>

Calculates the smallest interval containing an interval and a value.

assert_eq!((3 as u64).hull(&Interval::new(5, 8)), Interval::new(3, 8));
assert_eq!((2 as u64).hull(&Interval::new(1, 3)), Interval::new(1, 3));
assert_eq!((9 as u64).hull(&Interval::new(2, 6)), Interval::new(2, 9));
assert_eq!((4 as u64).hull(&Interval::singleton(4)), Interval::singleton(4));
assert_eq!((5 as u64).hull(&Interval::empty()), Interval::singleton(5));

type Output = Interval<u64>

impl Hull<Interval<usize>> for usize

fn hull(&self, other: &Interval<usize>) -> Interval<usize>

Calculates the smallest interval containing an interval and a value.

assert_eq!((3 as usize).hull(&Interval::new(5, 8)), Interval::new(3, 8));
assert_eq!((2 as usize).hull(&Interval::new(1, 3)), Interval::new(1, 3));
assert_eq!((9 as usize).hull(&Interval::new(2, 6)), Interval::new(2, 9));
assert_eq!((4 as usize).hull(&Interval::singleton(4)), Interval::singleton(4));
assert_eq!((5 as usize).hull(&Interval::empty()), Interval::singleton(5));

type Output = Interval<usize>

Implementors

impl<Bound> Hull for Interval<Bound>

where Bound: Width + Num,

type Output = Interval<Bound>

impl<Bound> Hull<Bound> for Interval<Bound>

where Bound: Width + Num,

type Output = Interval<Bound>