Struct Point

#[repr(C)]
pub struct Point<T> {
    pub x: T,
    pub y: T,
}

Two dimensional point with a generic coordinate type.

Fields

x: T

X coordinate.

y: T

Y coordinate.

Implementations

impl<T> Point<T>

pub const fn new(x: T, y: T) -> Point<T>

Creates a new point with the given x and y coordinates.

pub const fn broadcast(xy: T) -> Point<T>

where T: Copy,

Creates a new point from a single value assigned to both coordinates.

pub fn map<U>(self, f: impl FnMut(T) -> U) -> Point<U>

Maps Point<T> to Point<U> by applying a function to each coordinate.

Trait Implementations

impl<T> Add for Point<T>

where T: Add<Output = T>,

type Output = Point<T>

The resulting type after applying the + operator.

fn add(self, rhs: Point<T>) -> <Point<T> as Add>::Output

Performs the + operation.

impl<T> AddAssign for Point<T>

where T: AddAssign,

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

Performs the += operation.

impl<T> Clone for Point<T>

where T: Clone,

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

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T> Debug for Point<T>

where T: Debug,

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

Formats the value using the given formatter.

impl<T> Default for Point<T>

where T: Default,

fn default() -> Point<T>

Returns the “default value” for a type.

impl<T> Div<T> for Point<T>

where T: Div<Output = T> + Copy,

type Output = Point<T>

The resulting type after applying the / operator.

fn div(self, rhs: T) -> <Point<T> as Div<T>>::Output

Performs the / operation.

impl<T> Div for Point<T>

where T: Div<Output = T>,

type Output = Point<T>

The resulting type after applying the / operator.

fn div(self, rhs: Point<T>) -> <Point<T> as Div>::Output

Performs the / operation.

impl<T> DivAssign<T> for Point<T>

where T: DivAssign + Copy,

fn div_assign(&mut self, rhs: T)

Performs the /= operation.

impl<T> DivAssign for Point<T>

where T: DivAssign,

fn div_assign(&mut self, rhs: Point<T>)

Performs the /= operation.

impl<T> Mul<Point<T>> for Matrix<T>

where T: MatrixElement,

type Output = Point<T>

The resulting type after applying the * operator.

fn mul(self, rhs: Point<T>) -> <Matrix<T> as Mul<Point<T>>>::Output

Performs the * operation.

impl<T> Mul<T> for Point<T>

where T: Mul<Output = T> + Copy,

type Output = Point<T>

The resulting type after applying the * operator.

fn mul(self, rhs: T) -> <Point<T> as Mul<T>>::Output

Performs the * operation.

impl<T> Mul for Point<T>

where T: Mul<Output = T>,

type Output = Point<T>

The resulting type after applying the * operator.

fn mul(self, rhs: Point<T>) -> <Point<T> as Mul>::Output

Performs the * operation.

impl<T> MulAssign<T> for Point<T>

where T: MulAssign + Copy,

fn mul_assign(&mut self, rhs: T)

Performs the *= operation.

impl<T> MulAssign for Point<T>

where T: MulAssign,

fn mul_assign(&mut self, rhs: Point<T>)

Performs the *= operation.

impl<T> Neg for Point<T>

where T: Neg<Output = T>,

type Output = Point<T>

The resulting type after applying the - operator.

fn neg(self) -> <Point<T> as Neg>::Output

Performs the unary - operation.

impl<T> PartialEq for Point<T>

where T: PartialEq,

fn eq(&self, other: &Point<T>) -> 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> Sub for Point<T>

where T: Sub<Output = T>,

type Output = Point<T>

The resulting type after applying the - operator.

fn sub(self, rhs: Point<T>) -> <Point<T> as Sub>::Output

Performs the - operation.

impl<T> SubAssign for Point<T>

where T: SubAssign,

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

Performs the -= operation.

impl<T> Zeroable for Point<T>

where T: AnyBitPattern,

fn zeroed() -> Self

Calls zeroed.

impl<T> AnyBitPattern for Point<T>

where T: AnyBitPattern,

impl<T> Copy for Point<T>

where T: Copy,

impl<T> Eq for Point<T>

where T: Eq,

impl<T> NoUninit for Point<T>

where T: NoUninit,

SAFETY: This trait has four preconditions:

1. All fields in the struct must implement NoUninit
2. The struct must be #[repr(C)] or #[repr(transparent)]
3. The struct must not contain any padding bytes
4. The struct must contain no generic parameters

We satisfy the first and second preconditions trivially. The third condition is satisfied because the struct is repr(C) and contains two fields of the same type which guarantees no padding.

The fourth condition is obviously not satisfied which is what requires implementing this trait manually rather than deriving it. This condition only exists because the bytemuck derive macro cannot guarantee the first three conditions in a type with generic parameters.

impl<T> StructuralPartialEq for Point<T>