Struct inter_val::BoxN

pub struct BoxN<const N: usize, T, L = Inclusive, R = L>(/* private fields */);

n-dimensional axis-aligned box as a cartesian product set of intervals, i.g., [a, b)^n.

Implementations

impl<const N: usize, T, L, R> BoxN<N, T, L, R>

pub fn from_array(src: [Interval<T, L, R>; N]) -> Self

pub fn into_array(self) -> [Interval<T, L, R>; N]

impl<T, L, R> BoxN<2, T, L, R>

pub fn new(x: Interval<T, L, R>, y: Interval<T, L, R>) -> Self

impl<T, L, R> BoxN<3, T, L, R>

pub fn new( x: Interval<T, L, R>, y: Interval<T, L, R>, z: Interval<T, L, R> ) -> Self

impl<T, L, R> BoxN<4, T, L, R>

pub fn new( x: Interval<T, L, R>, y: Interval<T, L, R>, z: Interval<T, L, R>, w: Interval<T, L, R> ) -> Self

impl<const N: usize, T: PartialOrd + Clone, L: BoundaryOf<Left>, R: BoundaryOf<Right>> BoxN<N, T, L, R>

pub fn try_between(a: &[T; N], b: &[T; N]) -> Option<Self>

where T: Into<Bound<T, L>> + Into<Bound<T, R>>,

use inter_val::{Box2, Exclusive};
let a: Box2<i32> = Box2::try_between(&[0, 0], &[10, 20]).unwrap();
assert_eq!(a.x.inf(), &0);
assert_eq!(a.y.sup(), &20);

assert!(Box2::<i32, Exclusive>::try_between(&[0, 0], &[0, 1]).is_none());

pub fn between(a: &[T; N], b: &[T; N]) -> Self

where T: Into<Bound<T, L>> + Into<Bound<T, R>>,

use inter_val::Box2;
let a: Box2<i32> = Box2::between(&[0, 0], &[10, 20]);
assert_eq!(a.inf(), [0, 0]);
assert_eq!(a.sup(), [10, 20]);

pub fn inf(&self) -> NDim<N, T>

pub fn sup(&self) -> NDim<N, T>

pub fn contains(&self, t: &[T; N]) -> bool

pub fn includes(&self, other: &Self) -> bool

pub fn overlaps(&self, other: &Self) -> bool

pub fn closure(&self) -> BoxN<N, T, Inclusive>

pub fn interior(&self) -> Option<BoxN<N, T, Exclusive>>

pub fn intersection(&self, other: &Self) -> Option<Self>

pub fn span(&self, other: &Self) -> Self

pub fn dilate(&self, delta: T) -> Self

where T: Add<Output = T> + Sub<Output = T>,

pub fn hull(self, p: &[T; N]) -> Self

use inter_val::Box2;
let a: Box2<i32> = Box2::between(&[0, 0], &[10, 10]);
let b = a.hull(&[20, 5]);
assert_eq!(b, Box2::between(&[0, 0], &[20, 10]));

pub fn span_many<A: Into<Self>>( items: impl IntoIterator<Item = A> ) -> Option<Self>

pub fn hull_many<'a>( items: impl IntoIterator<Item = &'a [T; N]> ) -> Option<Self>

where T: Clone + Into<Bound<T, L>> + Into<Bound<T, R>> + 'a,

impl<const N: usize, T, L, R> BoxN<N, T, L, R>

where T: PartialOrd + Clone + Num, L: BoundaryOf<Left>, R: BoundaryOf<Right>,

pub fn size(&self) -> NDim<N, T>

pub fn measure(&self) -> T

impl<const N: usize, T: Float, L: BoundaryOf<Left>, R: BoundaryOf<Right>> BoxN<N, T, L, R>

pub fn center(&self) -> NDim<N, T>

Methods from Deref<Target = NDim<N, Interval<T, L, R>>>

pub fn as_array(&self) -> &[T; N]

pub fn as_array_mut(&mut self) -> &mut [T; N]

pub fn iter(&self) -> Iter<'_, T>

Trait Implementations

impl<const N: usize, T, L, R> AsRef<[Interval<T, L, R>; N]> for BoxN<N, T, L, R>

fn as_ref(&self) -> &[Interval<T, L, R>; N]

Converts this type into a shared reference of the (usually inferred) input type.

impl<const N: usize, T: Clone, L: Clone, R: Clone> Clone for BoxN<N, T, L, R>

fn clone(&self) -> BoxN<N, T, L, R>

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<const N: usize, T: Debug, L: Debug, R: Debug> Debug for BoxN<N, T, L, R>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<const N: usize, T, L, R> Deref for BoxN<N, T, L, R>

type Target = NDim<N, Interval<T, L, R>>

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.

impl<const N: usize, T, L, R> DerefMut for BoxN<N, T, L, R>

fn deref_mut(&mut self) -> &mut Self::Target

Mutably dereferences the value.

impl<const N: usize, T, L, R> From<[Interval<T, L, R>; N]> for BoxN<N, T, L, R>

fn from(src: [Interval<T, L, R>; N]) -> Self

Converts to this type from the input type.

impl<const N: usize, T, L, R> From<BoxN<N, T, L, R>> for [Interval<T, L, R>; N]

fn from(src: BoxN<N, T, L, R>) -> Self

Converts to this type from the input type.

impl<const N: usize, T: PartialEq, L: PartialEq, R: PartialEq> PartialEq for BoxN<N, T, L, R>

fn eq(&self, other: &BoxN<N, T, L, R>) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<const N: usize, T: Copy, L: Copy, R: Copy> Copy for BoxN<N, T, L, R>

impl<const N: usize, T: Eq, L: Eq, R: Eq> Eq for BoxN<N, T, L, R>

impl<const N: usize, T, L, R> StructuralEq for BoxN<N, T, L, R>

impl<const N: usize, T, L, R> StructuralPartialEq for BoxN<N, T, L, R>