Struct Point

pub struct Point<T = i32, const N: usize = 2>(/* private fields */);

A Point in N-dimensional space.

Please see the module-level documentation for examples.

Implementations

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

pub const fn new(coords: [T; N]) -> Self

Constructs a Point from [T; N] coordinates.

Examples

let p = Point::new([1]);
assert_eq!(p.coords(), [1]);

let p = Point::new([1, 2]);
assert_eq!(p.coords(), [1, 2]);

let p = Point::new([1, -2, 1]);
assert_eq!(p.coords(), [1, -2, 1]);

pub fn origin() -> Self

where T: Default,

Constructs a Point at the origin.

Example

let p: Point<i32> = Point::origin();
assert_eq!(p.coords(), [0, 0]);

impl<T> Point<T, 1>

pub const fn from_x(x: T) -> Self

Constructs a Point from an individual x coordinate.

impl<T> Point<T>

pub const fn from_xy(x: T, y: T) -> Self

Constructs a Point from individual x/y coordinates.

impl<T> Point<T, 3>

pub const fn from_xyz(x: T, y: T, z: T) -> Self

Constructs a Point from individual x/y/z coordinates.

impl<T: Copy, const N: usize> Point<T, N>

pub fn from_vector(v: Vector<T, N>) -> Self

Constructs a Point from a Vector.

Example

let v = vector!(1.0, 2.0);
let p = Point::from_vector(v);
assert_eq!(p.coords(), [1.0, 2.0]);

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

Returns Point coordinates as [T; N].

Example

let p = point!(2, 1, 3);
assert_eq!(p.coords(), [2, 1, 3]);

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

Returns Point coordinates as a mutable slice &mut [T; N].

Example

let mut p = point!(2, 1, 3);
for v in p.coords_mut() {
    *v *= 2;
}
assert_eq!(p.coords(), [4, 2, 6]);

pub fn x(&self) -> T

Returns the x-coordinate.

Panics

If Point has zero dimensions.

Example

let p = point!(1, 2);
assert_eq!(p.x(), 1);

pub fn set_x(&mut self, x: T)

Sets the x-coordinate.

Panics

If Vector has zero dimensions.

Example

let mut p = point!(1, 2);
p.set_x(3);
assert_eq!(p.coords(), [3, 2]);

pub fn y(&self) -> T

Returns the y-coordinate.

Panics

If Vector has less than 2 dimensions.

Example

let p = point!(1, 2);
assert_eq!(p.y(), 2);

pub fn set_y(&mut self, y: T)

Sets the y-coordinate.

Panics

If Vector has less than 2 dimensions.

Example

let mut p = point!(1, 2);
p.set_y(3);
assert_eq!(p.coords(), [1, 3]);

pub fn z(&self) -> T

Returns the z-coordinate.

Panics

If Vector has less than 3 dimensions.

Example

let p = point!(1, 2, 2);
assert_eq!(p.z(), 2);

pub fn set_z(&mut self, z: T)

Sets the z-magnitude.

Panics

If Vector has less than 3 dimensions.

Example

let mut p = point!(1, 2, 1);
p.set_z(3);
assert_eq!(p.coords(), [1, 2, 3]);

pub fn to_vec(self) -> Vec<T>

Returns Point as a Vec.

Example

let p = point!(1, 1, 0);
assert_eq!(p.to_vec(), vec![1, 1, 0]);

impl<T: Num, const N: usize> Point<T, N>

pub fn offset<P, const M: usize>(&mut self, offsets: P)

where P: Into<Point<T, M>>,

Offsets a Point by shifting coordinates by given amount.

Examples

let mut p = point!(2, 3, 1);
p.offset([2, -4]);
assert_eq!(p.coords(), [4, -1, 1]);

pub fn offset_x(&mut self, offset: T)

Offsets the x-coordinate of the point by a given amount.

Panics

If Point has zero dimensions.

pub fn offset_y(&mut self, offset: T)

Offsets the y-coordinate of the point by a given amount.

Panics

If Vector has less than 2 dimensions.

pub fn offset_z(&mut self, offset: T)

Offsets the z-coordinate of the point by a given amount.

Panics

If Vector has less than 3 dimensions.

pub fn scale<U>(&mut self, s: U)

where T: MulAssign<U>, U: Num,

Constructs a Point by multiplying it by the given scale factor.

Examples

let mut p = point!(2, 3);
p.scale(2);
assert_eq!(p.coords(), [4, 6]);

pub fn wrap(&mut self, wrap: [T; N], size: T)

where T: Signed,

Examples

let mut p = point!(200.0, 300.0);
p.wrap([150.0, 400.0], 10.0);
assert_eq!(p.coords(), [-10.0, 300.0]);

let mut p = point!(-100.0, 300.0);
p.wrap([150.0, 400.0], 10.0);
assert_eq!(p.coords(), [160.0, 300.0]);

impl<T: Num + Float, const N: usize> Point<T, N>

pub fn dist<P>(&self, p: P) -> T

where P: Into<Point<T, N>>,

Returns the Euclidean distance between two Points.

Example

let p1 = point!(1.0, 0.0, 0.0);
let p2 = point!(0.0, 1.0, 0.0);
let dist = p1.dist(p2);
let abs_difference: f64 = (dist - std::f64::consts::SQRT_2).abs();
assert!(abs_difference <= 1e-4);

pub fn lerp<P>(&self, o: P, amt: T) -> Self

where P: Into<Point<T, N>>,

Constructs a Point by linear interpolating between two Points by a given amount between 0.0 and 1.0.

Example

let p1 = point!(1.0, 1.0, 0.0);
let p2 = point!(3.0, 3.0, 0.0);
let p3 = p1.lerp(p2, 0.5);
assert_eq!(p3.coords(), [2.0, 2.0, 0.0]);

pub fn approx_eq(&self, other: Point<T, N>, epsilon: T) -> bool

Returns whether two Points are approximately equal.

Example

let p1 = point!(10.0, 20.0);
let p2 = point!(10.0001, 20.0);
assert!(p1.approx_eq(p2, 1e-3));

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

pub fn as_<U>(&self) -> Point<U, N>

where U: 'static + Copy, T: AsPrimitive<U>,

Converts Point < T, N > to Point < U, N >.

impl<T: Float, const N: usize> Point<T, N>

pub fn round(&self) -> Self

Returns Point < T, N > with the nearest integers to the numbers. Round half-way cases away from 0.0.

pub fn floor(&self) -> Self

Returns Point < T, N > with the largest integers less than or equal to the numbers.

pub fn ceil(&self) -> Self

Returns Point < T, N > with the smallest integers greater than or equal to the numbers.

Methods from Deref<Target = [T; N]>

pub fn as_slice(&self) -> &[T]

Returns a slice containing the entire array. Equivalent to &s[..].

pub fn as_mut_slice(&mut self) -> &mut [T]

Returns a mutable slice containing the entire array. Equivalent to &mut s[..].

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

Borrows each element and returns an array of references with the same size as self.

Example

let floats = [3.1, 2.7, -1.0];
let float_refs: [&f64; 3] = floats.each_ref();
assert_eq!(float_refs, [&3.1, &2.7, &-1.0]);

This method is particularly useful if combined with other methods, like map. This way, you can avoid moving the original array if its elements are not Copy.

let strings = ["Ferris".to_string(), "♥".to_string(), "Rust".to_string()];
let is_ascii = strings.each_ref().map(|s| s.is_ascii());
assert_eq!(is_ascii, [true, false, true]);

// We can still access the original array: it has not been moved.
assert_eq!(strings.len(), 3);

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

Borrows each element mutably and returns an array of mutable references with the same size as self.

Example

let mut floats = [3.1, 2.7, -1.0];
let float_refs: [&mut f64; 3] = floats.each_mut();
*float_refs[0] = 0.0;
assert_eq!(float_refs, [&mut 0.0, &mut 2.7, &mut -1.0]);
assert_eq!(floats, [0.0, 2.7, -1.0]);

pub fn split_array_ref<const M: usize>(&self) -> (&[T; M], &[T])

🔬This is a nightly-only experimental API. (split_array)

Divides one array reference into two at an index.

The first will contain all indices from [0, M) (excluding the index M itself) and the second will contain all indices from [M, N) (excluding the index N itself).

Panics

Panics if M > N.

Examples

#![feature(split_array)]

let v = [1, 2, 3, 4, 5, 6];

{
   let (left, right) = v.split_array_ref::<0>();
   assert_eq!(left, &[]);
   assert_eq!(right, &[1, 2, 3, 4, 5, 6]);
}

{
    let (left, right) = v.split_array_ref::<2>();
    assert_eq!(left, &[1, 2]);
    assert_eq!(right, &[3, 4, 5, 6]);
}

{
    let (left, right) = v.split_array_ref::<6>();
    assert_eq!(left, &[1, 2, 3, 4, 5, 6]);
    assert_eq!(right, &[]);
}

pub fn split_array_mut<const M: usize>(&mut self) -> (&mut [T; M], &mut [T])

🔬This is a nightly-only experimental API. (split_array)

Divides one mutable array reference into two at an index.

The first will contain all indices from [0, M) (excluding the index M itself) and the second will contain all indices from [M, N) (excluding the index N itself).

Panics

Panics if M > N.

Examples

#![feature(split_array)]

let mut v = [1, 0, 3, 0, 5, 6];
let (left, right) = v.split_array_mut::<2>();
assert_eq!(left, &mut [1, 0][..]);
assert_eq!(right, &mut [3, 0, 5, 6]);
left[1] = 2;
right[1] = 4;
assert_eq!(v, [1, 2, 3, 4, 5, 6]);

pub fn rsplit_array_ref<const M: usize>(&self) -> (&[T], &[T; M])

🔬This is a nightly-only experimental API. (split_array)

Divides one array reference into two at an index from the end.

The first will contain all indices from [0, N - M) (excluding the index N - M itself) and the second will contain all indices from [N - M, N) (excluding the index N itself).

Panics

Panics if M > N.

Examples

#![feature(split_array)]

let v = [1, 2, 3, 4, 5, 6];

{
   let (left, right) = v.rsplit_array_ref::<0>();
   assert_eq!(left, &[1, 2, 3, 4, 5, 6]);
   assert_eq!(right, &[]);
}

{
    let (left, right) = v.rsplit_array_ref::<2>();
    assert_eq!(left, &[1, 2, 3, 4]);
    assert_eq!(right, &[5, 6]);
}

{
    let (left, right) = v.rsplit_array_ref::<6>();
    assert_eq!(left, &[]);
    assert_eq!(right, &[1, 2, 3, 4, 5, 6]);
}

pub fn rsplit_array_mut<const M: usize>(&mut self) -> (&mut [T], &mut [T; M])

🔬This is a nightly-only experimental API. (split_array)

Divides one mutable array reference into two at an index from the end.

The first will contain all indices from [0, N - M) (excluding the index N - M itself) and the second will contain all indices from [N - M, N) (excluding the index N itself).

Panics

Panics if M > N.

Examples

#![feature(split_array)]

let mut v = [1, 0, 3, 0, 5, 6];
let (left, right) = v.rsplit_array_mut::<4>();
assert_eq!(left, &mut [1, 0]);
assert_eq!(right, &mut [3, 0, 5, 6][..]);
left[1] = 2;
right[1] = 4;
assert_eq!(v, [1, 2, 3, 4, 5, 6]);

Trait Implementations

impl<T, const N: usize> Add<Point<T, N>> for Vector<T, N>

where T: Num + Add,

type Output = Point<T, N>

The resulting type after applying the + operator.

fn add(self, other: Point<T, N>) -> Self::Output

Performs the + operation.

impl Add<Point> for Rect

type Output = Rect

The resulting type after applying the + operator.

fn add(self, p: Point<i32>) -> Self::Output

Performs the + operation.

impl<T, U, const N: usize> Add<U> for Point<T, N>

where T: Num + Add<U, Output = T>, U: Num,

type Output = Point<T, N>

The resulting type after applying the + operator.

fn add(self, val: U) -> Self::Output

Performs the + operation.

impl<T, const N: usize> Add<Vector<T, N>> for Point<T, N>

where T: Num + Add,

type Output = Point<T, N>

The resulting type after applying the + operator.

fn add(self, other: Vector<T, N>) -> Self::Output

Performs the + operation.

impl<T, const N: usize> Add for Point<T, N>

where T: Num + Add,

type Output = Vector<T, N>

The resulting type after applying the + operator.

fn add(self, other: Point<T, N>) -> Self::Output

Performs the + operation.

impl<T, U, const N: usize> AddAssign<U> for Point<T, N>

where T: Num + AddAssign<U>, U: Num,

fn add_assign(&mut self, val: U)

Performs the += operation.

impl<T: Num, const N: usize> AddAssign<Vector<T, N>> for Point<T, N>

fn add_assign(&mut self, other: Vector<T, N>)

Performs the += operation.

impl<T: Num, const N: usize> AddAssign for Point<T, N>

fn add_assign(&mut self, other: Point<T, N>)

Performs the += operation.

impl<T, const N: usize> AsMut<[T; N]> for Point<T, N>

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

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

impl<T, const N: usize> AsRef<[T; N]> for Point<T, N>

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

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

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

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

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T: Num> Contains<Point<T>> for Ellipse<T>

fn contains(&self, p: Point<T>) -> bool

Returns whether this ellipse contains a given Point.

impl<T: Num> Contains<Point<T>> for Rect<T>

fn contains(&self, p: Point<T>) -> bool

Returns whether this rectangle contains a given Point.

impl<T: Num> Contains<Point<T>> for Sphere<T>

fn contains(&self, p: Point<T>) -> bool

Returns whether this sphere contains a given Point.

impl<T: Num> Contains<Point<T>> for Tri<T>

fn contains(&self, p: Point<T>) -> bool

Returns whether this rectangle contains a given Point.

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

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

Formats the value using the given formatter.

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

fn default() -> Self

Return default Point as origin.

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: Serialize + DeserializeOwned,

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> Display for Point<T, N>

where [T; N]: Debug,

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

Display Point as a string of coordinates.

impl<T, U, const N: usize> Div<U> for Point<T, N>

where T: Num + Div<U, Output = T>, U: Num,

type Output = Point<T, N>

The resulting type after applying the / operator.

fn div(self, val: U) -> Self::Output

Performs the / operation.

impl<T, U, const N: usize> DivAssign<U> for Point<T, N>

where T: Num + DivAssign<U>, U: Num,

fn div_assign(&mut self, val: U)

Performs the /= operation.

impl Draw for Point<i32>

fn draw(&self, s: &mut PixState) -> Result<()>

Draw point to the current PixState canvas.

impl<T: Copy, const N: usize> From<&[T; N]> for Point<T, N>

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

Converts &[T; M] to Point < T, N >.

impl<T: Copy, const N: usize> From<&Point<T, N>> for [T; N]

fn from(t: &Point<T, N>) -> Self

Converts Point < T, N > to &[T; M].

impl<T: Copy, const N: usize> From<&Point<T, N>> for Vector<T, N>

fn from(p: &Point<T, N>) -> Self

Converts to this type from the input type.

impl<T: Copy, const N: usize> From<&Vector<T, N>> for Point<T, N>

fn from(v: &Vector<T, N>) -> Self

Converts to this type from the input type.

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

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

Converts [T; M] to Point < T, N >.

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

fn from(t: Point<T, N>) -> Self

Converts Point < T, N > to [T; M].

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

fn from(p: Point<T, N>) -> Self

Converts to this type from the input type.

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

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

Converts to this type from the input type.

impl<T: Default, const N: usize> FromIterator<Point<T, N>> for Line<T, N>

fn from_iter<I>(iter: I) -> Self

where I: IntoIterator<Item = Point<T, N>>,

Creates a value from an iterator.

impl<T: Default, const N: usize> FromIterator<Point<T, N>> for Quad<T, N>

fn from_iter<I>(iter: I) -> Self

where I: IntoIterator<Item = Point<T, N>>,

Creates a value from an iterator.

impl<T: Default, const N: usize> FromIterator<Point<T, N>> for Tri<T, N>

fn from_iter<I>(iter: I) -> Self

where I: IntoIterator<Item = Point<T, N>>,

Creates a value from an iterator.

impl<T: Default, const N: usize> FromIterator<T> for Point<T, N>

fn from_iter<I>(iter: I) -> Self

where I: IntoIterator<Item = T>,

Creates a value from an iterator.

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

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, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl<T, const N: usize> Index<usize> for Point<T, N>

type Output = T

The returned type after indexing.

fn index(&self, idx: usize) -> &Self::Output

Performs the indexing (container[index]) operation.

impl<T, const N: usize> IndexMut<usize> for Point<T, N>

fn index_mut(&mut self, idx: usize) -> &mut Self::Output

Performs the mutable indexing (container[index]) operation.

impl<'a, T, const N: usize> IntoIterator for &'a Point<T, N>

type Item = &'a T

The type of the elements being iterated over.

type IntoIter = Iter<'a, T>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl<'a, T, const N: usize> IntoIterator for &'a mut Point<T, N>

type Item = &'a mut T

The type of the elements being iterated over.

type IntoIter = IterMut<'a, T>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

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

type Item = T

The type of the elements being iterated over.

type IntoIter = IntoIter<<Point<T, N> as IntoIterator>::Item, N>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl<const N: usize> Mul<Point<f32, N>> for f32

fn mul(self, t: Point<f32, N>) -> Self::Output

T * Point.

type Output = Point<f32, N>

The resulting type after applying the * operator.

impl<const N: usize> Mul<Point<f64, N>> for f64

fn mul(self, t: Point<f64, N>) -> Self::Output

T * Point.

type Output = Point<f64, N>

The resulting type after applying the * operator.

impl<const N: usize> Mul<Point<i128, N>> for i128

fn mul(self, t: Point<i128, N>) -> Self::Output

T * Point.

type Output = Point<i128, N>

The resulting type after applying the * operator.

impl<const N: usize> Mul<Point<i16, N>> for i16

fn mul(self, t: Point<i16, N>) -> Self::Output

T * Point.

type Output = Point<i16, N>

The resulting type after applying the * operator.

impl<const N: usize> Mul<Point<i32, N>> for i32

fn mul(self, t: Point<i32, N>) -> Self::Output

T * Point.

type Output = Point<i32, N>

The resulting type after applying the * operator.

impl<const N: usize> Mul<Point<i64, N>> for i64

fn mul(self, t: Point<i64, N>) -> Self::Output

T * Point.

type Output = Point<i64, N>

The resulting type after applying the * operator.

impl<const N: usize> Mul<Point<i8, N>> for i8

fn mul(self, t: Point<i8, N>) -> Self::Output

T * Point.

type Output = Point<i8, N>

The resulting type after applying the * operator.

impl<const N: usize> Mul<Point<isize, N>> for isize

fn mul(self, t: Point<isize, N>) -> Self::Output

T * Point.

type Output = Point<isize, N>

The resulting type after applying the * operator.

impl<const N: usize> Mul<Point<u128, N>> for u128

fn mul(self, t: Point<u128, N>) -> Self::Output

T * Point.

type Output = Point<u128, N>

The resulting type after applying the * operator.

impl<const N: usize> Mul<Point<u16, N>> for u16

fn mul(self, t: Point<u16, N>) -> Self::Output

T * Point.

type Output = Point<u16, N>

The resulting type after applying the * operator.

impl<const N: usize> Mul<Point<u32, N>> for u32

fn mul(self, t: Point<u32, N>) -> Self::Output

T * Point.

type Output = Point<u32, N>

The resulting type after applying the * operator.

impl<const N: usize> Mul<Point<u64, N>> for u64

fn mul(self, t: Point<u64, N>) -> Self::Output

T * Point.

type Output = Point<u64, N>

The resulting type after applying the * operator.

impl<const N: usize> Mul<Point<u8, N>> for u8

fn mul(self, t: Point<u8, N>) -> Self::Output

T * Point.

type Output = Point<u8, N>

The resulting type after applying the * operator.

impl<const N: usize> Mul<Point<usize, N>> for usize

fn mul(self, t: Point<usize, N>) -> Self::Output

T * Point.

type Output = Point<usize, N>

The resulting type after applying the * operator.

impl<T, U, const N: usize> Mul<U> for Point<T, N>

where T: Num + Mul<U, Output = T>, U: Num,

type Output = Point<T, N>

The resulting type after applying the * operator.

fn mul(self, val: U) -> Self::Output

Performs the * operation.

impl<T, U, const N: usize> MulAssign<U> for Point<T, N>

where T: Num + MulAssign<U>, U: Num,

fn mul_assign(&mut self, val: U)

Performs the *= operation.

impl<T, const N: usize> Neg for Point<T, N>

where T: Num + Neg<Output = T>,

type Output = Point<T, N>

The resulting type after applying the - operator.

fn neg(self) -> Self::Output

Performs the unary - operation.

impl<T: Ord, const N: usize> Ord for Point<T, N>

fn cmp(&self, other: &Point<T, N>) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

where Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

where Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

where Self: Sized,

Restrict a value to a certain interval.

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

fn eq(&self, other: &Point<T, N>) -> bool

Tests for self and other values to be equal, and is used by ==.

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

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

impl<T: PartialOrd, const N: usize> PartialOrd for Point<T, N>

fn partial_cmp(&self, other: &Point<T, N>) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

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

Tests less than (for self and other) and is used by the < operator.

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

Tests less than or equal to (for self and other) and is used by the <= operator.

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

Tests greater than (for self and other) and is used by the > operator.

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

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl<'a, T, const N: usize> Product<&'a Point<T, N>> for Point<T, N>

where Self: Default + Mul<Output = Self>, T: Num,

fn product<I>(iter: I) -> Self

where I: Iterator<Item = &'a Self>,

Takes an iterator and generates Self from the elements by multiplying the items.

impl<T, const N: usize> Product for Point<T, N>

where Self: Default + Mul<Output = Self>, T: Num,

fn product<I>(iter: I) -> Self

where I: Iterator<Item = Self>,

Takes an iterator and generates Self from the elements by multiplying the items.

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

where T: Serialize + DeserializeOwned,

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl<T, const N: usize> Sub<Point<T, N>> for Vector<T, N>

where T: Num + Sub,

type Output = Point<T, N>

The resulting type after applying the - operator.

fn sub(self, other: Point<T, N>) -> Self::Output

Performs the - operation.

impl Sub<Point> for Rect

type Output = Rect

The resulting type after applying the - operator.

fn sub(self, p: Point<i32>) -> Self::Output

Performs the - operation.

impl<T, U, const N: usize> Sub<U> for Point<T, N>

where T: Num + Sub<U, Output = T>, U: Num,

type Output = Point<T, N>

The resulting type after applying the - operator.

fn sub(self, val: U) -> Self::Output

Performs the - operation.

impl<T, const N: usize> Sub<Vector<T, N>> for Point<T, N>

where T: Num + Sub,

type Output = Point<T, N>

The resulting type after applying the - operator.

fn sub(self, other: Vector<T, N>) -> Self::Output

Performs the - operation.

impl<T, const N: usize> Sub for Point<T, N>

where T: Num + Sub,

type Output = Vector<T, N>

The resulting type after applying the - operator.

fn sub(self, other: Point<T, N>) -> Self::Output

Performs the - operation.

impl<T, U, const N: usize> SubAssign<U> for Point<T, N>

where T: Num + SubAssign<U>, U: Num,

fn sub_assign(&mut self, val: U)

Performs the -= operation.

impl<T: Num, const N: usize> SubAssign<Vector<T, N>> for Point<T, N>

fn sub_assign(&mut self, other: Vector<T, N>)

Performs the -= operation.

impl<T: Num, const N: usize> SubAssign for Point<T, N>

fn sub_assign(&mut self, other: Point<T, N>)

Performs the -= operation.

impl<'a, T, const N: usize> Sum<&'a Point<T, N>> for Point<T, N>

where Self: Default + Add<Output = Self>, T: Num,

fn sum<I>(iter: I) -> Self

where I: Iterator<Item = &'a Self>,

Takes an iterator and generates Self from the elements by “summing up” the items.

impl<T, const N: usize> Sum for Point<T, N>

where Self: Default + Add<Output = Self>, T: Num,

fn sum<I>(iter: I) -> Self

where I: Iterator<Item = Self>,

Takes an iterator and generates Self from the elements by “summing up” the items.

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

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

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