Struct aljabar::Point

#[repr(transparent)]pub struct Point<T, const N: usize>(_);

A point in space.

Points are far less flexible and useful than vectors and are used to express the purpose or meaning of a variable through its type.

Points can be moved through space by adding or subtracting vectors from them.

The only mathematical operator supported between two points is subtraction, which results in the vector between the two points.

Points can be freely converted to and from vectors via From.

Implementations

impl<T, const N: usize> Point<T, { N }>

pub fn from_vec(v: Vector<T, { N }>) -> Self

Convenience method for converting from vector.

pub fn to_vec(self) -> Vector<T, { N }>

Convenience method for converting from vector.

impl<T, const N: usize> Point<T, { N }> where
    T: Clone, 

pub fn x(&self) -> T

Alias for .get(0).clone().

Panics

When N = 0.

pub fn y(&self) -> T

Alias for .get(1).clone().

Panics

When N < 2.

pub fn z(&self) -> T

Alias for .get(2).clone().

Panics

When N < 3.

pub fn w(&self) -> T

Alias for .get(3).clone().

Panics

When N < 4.

Trait Implementations

impl<A, B, const N: usize> Add<Vector<B, N>> for Point<A, { N }> where
    A: Add<B>, 

type Output = Point<<A as Add<B>>::Output, { N }>

The resulting type after applying the + operator.

fn add(self, rhs: Vector<B, { N }>) -> Self::Output

Performs the + operation.

impl<T, const N: usize> Clone for Point<T, { N }> where
    T: Clone, 

fn clone(&self) -> Self

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<T, const N: usize> Copy for Point<T, { N }> where
    T: Copy, 

impl<T, const N: usize> Debug for Point<T, { N }> where
    T: Debug, 

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

Formats the value using the given formatter.

impl<T, const N: usize> Deref for Point<T, { N }>

type Target = [T; N]

The resulting type after dereferencing.

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

Dereferences the value.

impl<T, const N: usize> DerefMut for Point<T, { N }>

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

Mutably dereferences the value.

impl<'de, T, const N: usize> Deserialize<'de> for Point<T, { N }> where
    T: Deserialize<'de>, 

fn deserialize<D>(deserializer: D) -> Result<Self, D::Error> where
    D: Deserializer<'de>, 

Deserialize this value from the given Serde deserializer.

impl<T, const N: usize> Distribution<Point<T, N>> for Standard where
    Standard: Distribution<T>, 

fn sample<R: Rng + ?Sized>(&self, rng: &mut R) -> Point<T, { N }>

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, 

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

impl<T, const N: usize> Eq for Point<T, { N }> where
    T: Eq, 

impl<T, const N: usize> From<[T; N]> for Point<T, { N }>

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

Performs the conversion.

impl<T, const N: usize> From<Vector<T, N>> for Point<T, { N }>

fn from(Vector: Vector<T, { N }>) -> Self

Performs the conversion.

impl<T, const N: usize> Hash for Point<T, { N }> where
    T: Hash, 

fn hash<H: Hasher>(&self, state: &mut H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H) where
    H: Hasher, 

Feeds a slice of this type into the given Hasher.

impl<T, const N: usize> Into<[T; N]> for Point<T, { N }>

fn into(self) -> [T; N]

Performs the conversion.

impl<T, const N: usize> IntoIterator for Point<T, { N }>

type Item = T

The type of the elements being iterated over.

type IntoIter = ArrayIter<T, { N }>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl<A, B, RHS, const N: usize> PartialEq<RHS> for Point<A, { N }> where
    RHS: Deref<Target = [B; N]>,
    A: PartialEq<B>, 

fn eq(&self, other: &RHS) -> bool

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

#[must_use]fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl<T, const N: usize> Serialize for Point<T, { N }> where
    T: Serialize, 

fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where
    S: Serializer, 

Serialize this value into the given Serde serializer.

impl<A, B, const N: usize> Sub<Point<B, N>> for Point<A, { N }> where
    A: Sub<B>, 

type Output = Vector<<A as Sub<B>>::Output, { N }>

The resulting type after applying the - operator.

fn sub(self, rhs: Point<B, { N }>) -> Self::Output

Performs the - operation.

impl<A, B, const N: usize> Sub<Vector<B, N>> for Point<A, { N }> where
    A: Sub<B>, 

type Output = Point<<A as Sub<B>>::Output, { N }>

The resulting type after applying the - operator.

fn sub(self, rhs: Vector<B, { N }>) -> Self::Output

Performs the - operation.