Struct crater::cuboid::CuPoint

pub struct CuPoint<T, const N: usize>
where
    T: Ord + Clone + NumRef,
{ /* private fields */ }

Represents a point in N-dimensional Euclidean space whose coordinates are numeric type T Wrapping CuPoint<i64, 3> or CuPoint<f64, 3> is a good way to get started quickly if you don’t need a topologically exotic implementation

Implementations

impl<T, const N: usize> CuPoint<T, N>

where T: Ord + Clone + NumRef,

pub fn make(buf: [T; N]) -> Self

make a point with a given value

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

get readonly access to the buffer

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

consume the point to mutably access the buffer

Trait Implementations

impl<T, const N: usize> Clone for CuPoint<T, N>

where T: Ord + Clone + NumRef + Clone,

fn clone(&self) -> CuPoint<T, N>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<T, const N: usize> Debug for CuPoint<T, N>

where T: Ord + Clone + NumRef + Debug,

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

Formats the value using the given formatter.

impl<T, const N: usize> Default for CuPoint<T, N>

where T: Ord + Clone + NumRef,

Generate a default point (all coordinates zero)

fn default() -> Self

Returns the “default value” for a type.

impl<T, const N: usize> Distribution<CuPoint<T, N>> for Uniform<T>

where T: Ord + Clone + NumRef + SampleUniform,

Generate a random point in a square/cube/etc. Given a Uniform distribution sampling from a range, this adds the ability to randomly generate CuPoints whose coordinates are iid (independent and identically distributed) from that range

fn sample<R>(&self, rng: &mut R) -> CuPoint<T, N>

where R: Rng + ?Sized,

Generate a random value of T, using rng as the source of randomness.

fn sample_iter<R>(self, rng: R) -> DistIter<Self, R, T>

where R: Rng, Self: Sized,

Create an iterator that generates random values of T, using rng as the source of randomness.

fn map<F, S>(self, func: F) -> DistMap<Self, F, T, S>

where F: Fn(T) -> S, Self: Sized,

Create a distribution of values of ‘S’ by mapping the output of Self through the closure F

impl<T, const N: usize> From<[T; N]> for CuPoint<T, N>

where T: Ord + Clone + NumRef,

fn from(buf: [T; N]) -> Self

Converts to this type from the input type.

impl<T, const N: usize> KdPoint for CuPoint<T, N>

where T: Ord + Clone + NumRef,

type Distance = T

The type used by sqdist and related KdRegion functions to represent (squared) distance. Must be totally ordered, where greater distances mean points are farther apart. Also must be Clone and have a meaningful minimum value (0)

fn cmp(&self, other: &Self, layer: usize) -> Ordering

Compare two points in some layer of the tree. This generalizes splitting different layers of the tree in different dimensions and is tied to KdRegion::split. Traditionally, points in a KD tree are compared by their 1st coordinate in layer 0, their 2nd in layer 1, …, onto their Kth in layer k - 1, and then in layer K it wraps around to 0 and repeats. So for a 3D KD tree, layer 0 would compare x coordinates with the root having the median x coordinate, all points in the first subtree having x coordinate <=, and all points in the second subtree having x coordinate >=. This method allows for more general strategies, but pushes some of the burden of layer-dependent behavior onto the point type. It’s still possible to just implement a by-coordinate cmp function of course, and this is what the prebuilt CuPoint does.

fn sqdist(&self, other: &Self) -> Self::Distance

The squared distance is more computationally convenient than the proper distance in many cases. The distance function only has to be topologically consistent and totally ordered. See KdRegion::min_sqdist for more info. The return value should be >= Distance::zero().

impl<T, const N: usize> PartialEq for CuPoint<T, N>

where T: Ord + Clone + NumRef + PartialEq,

fn eq(&self, other: &CuPoint<T, N>) -> 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<T: Ord + Copy + NumRef, const N: usize> Copy for CuPoint<T, N>

impl<T: Ord + Clone + NumRef, const N: usize> Eq for CuPoint<T, N>

impl<T, const N: usize> StructuralPartialEq for CuPoint<T, N>

where T: Ord + Clone + NumRef,