Struct figures::Point

pub struct Point<Unit> {
    pub x: Unit,
    pub y: Unit,
}

A coordinate in a 2d space.

Fields

x: Unit

The x-axis component.

y: Unit

The y-axis component

Implementations

impl<Unit> Point<Unit>

pub const fn new(x: Unit, y: Unit) -> Self

Returns a new point with the provided x and y components.

pub fn squared(i: Unit) -> Selfwhere Unit: Clone,

Returns a new point with both x and y initialized with i.

pub fn cast<NewUnit>(self) -> Point<NewUnit>where Unit: Into<NewUnit>,

Converts the contents of this point to NewUnit using From.

pub fn try_cast<NewUnit>(self) -> Result<Point<NewUnit>, Unit::Error>where Unit: TryInto<NewUnit>,

Converts the contents of this point to NewUnit using TryFrom.

Errors

Returns <NewUnit as TryFrom>::Error when the inner type cannot be converted. For this crate’s types, this genenerally will be TryFromIntError.

pub fn map<NewUnit>(self, map: impl FnMut(Unit) -> NewUnit) -> Point<NewUnit>

Maps each component to map and returns a new value with the mapped components.

pub fn dot(self, other: Point<Unit>) -> Unitwhere Unit: Mul<Output = Unit> + Add<Output = Unit>,

Returns the dot product of self and other.

pub fn magnitude(self) -> Unitwhere Unit: Mul<Output = Unit> + Add<Output = Unit> + Roots + Copy,

Returns the magnitude of self, which is the absolute distance from 0,0.

pub fn rotate_around(self, origin: Point<Unit>, angle: Angle) -> Point<Unit>where Unit: Copy + Add<Output = Unit> + Sub<Output = Unit> + Mul<Fraction, Output = Unit>,

Returns self rotated around origin by angle.

pub fn rotate_by(self, angle: Angle) -> Point<Unit>where Unit: Zero + Copy + Add<Output = Unit> + Sub<Output = Unit> + Mul<Fraction, Output = Unit>,

Returns self rotated around Point::ZERO by angle.

Trait Implementations

impl<Unit> Abs for Point<Unit>where Unit: Abs,

fn abs(&self) -> Self

Returns the positive difference between this value and 0.

impl<Unit> Add<Lp> for Point<Unit>where Unit: Add<Lp, Output = Unit>,

type Output = Point<Unit>

The resulting type after applying the + operator.

fn add(self, rhs: Lp) -> Self::Output

Performs the + operation.

impl<T, Unit> Add<Point<T>> for Point<Unit>where Unit: Add<T, Output = Unit>,

type Output = Point<Unit>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<T, Unit> Add<Point<T>> for Size<Unit>where Unit: Add<T, Output = Unit>,

type Output = Size<Unit>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<Unit> Add<Point<Unit>> for Rect<Unit>where Unit: Add<Output = Unit>,

type Output = Rect<Unit>

The resulting type after applying the + operator.

fn add(self, rhs: Point<Unit>) -> Self::Output

Performs the + operation.

impl<Unit> Add<Px> for Point<Unit>where Unit: Add<Px, Output = Unit>,

type Output = Point<Unit>

The resulting type after applying the + operator.

fn add(self, rhs: Px) -> Self::Output

Performs the + operation.

impl<T, Unit> Add<Size<T>> for Point<Unit>where Unit: Add<T, Output = Unit>,

type Output = Point<Unit>

The resulting type after applying the + operator.

fn add(self, rhs: Size<T>) -> Self::Output

Performs the + operation.

impl<Unit> Add<UPx> for Point<Unit>where Unit: Add<UPx, Output = Unit>,

type Output = Point<Unit>

The resulting type after applying the + operator.

fn add(self, rhs: UPx) -> Self::Output

Performs the + operation.

impl<Unit> Add<f32> for Point<Unit>where Unit: Add<f32, Output = Unit>,

type Output = Point<Unit>

The resulting type after applying the + operator.

fn add(self, rhs: f32) -> Self::Output

Performs the + operation.

impl<Unit> Add<i32> for Point<Unit>where Unit: Add<i32, Output = Unit>,

type Output = Point<Unit>

The resulting type after applying the + operator.

fn add(self, rhs: i32) -> Self::Output

Performs the + operation.

impl<Unit> Add<u32> for Point<Unit>where Unit: Add<u32, Output = Unit>,

type Output = Point<Unit>

The resulting type after applying the + operator.

fn add(self, rhs: u32) -> Self::Output

Performs the + operation.

impl<Unit> AddAssign<Point<Unit>> for Size<Unit>where Unit: AddAssign,

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

Performs the += operation.

impl<Unit> AddAssign<Size<Unit>> for Point<Unit>where Unit: AddAssign,

fn add_assign(&mut self, rhs: Size<Unit>)

Performs the += operation.

impl<Unit> AddAssign<Unit> for Point<Unit>where Unit: AddAssign + Clone,

fn add_assign(&mut self, rhs: Unit)

Performs the += operation.

impl<Unit> AddAssign for Point<Unit>where Unit: AddAssign,

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

Performs the += operation.

impl<Unit: Clone> Clone for Point<Unit>

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

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<Unit: Debug> Debug for Point<Unit>

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

Formats the value using the given formatter.

impl<Unit: Default> Default for Point<Unit>

fn default() -> Point<Unit>

Returns the “default value” for a type.

impl<'de, Unit> Deserialize<'de> for Point<Unit>where Unit: Deserialize<'de>,

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

Deserialize this value from the given Serde deserializer.

impl<Unit> Div<Lp> for Point<Unit>where Unit: Div<Lp, Output = Unit>,

type Output = Point<Unit>

The resulting type after applying the / operator.

fn div(self, rhs: Lp) -> Self::Output

Performs the / operation.

impl<T, Unit> Div<Point<T>> for Point<Unit>where Unit: Div<T, Output = Unit>,

type Output = Point<Unit>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<T, Unit> Div<Point<T>> for Size<Unit>where Unit: Div<T, Output = Unit>,

type Output = Size<Unit>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<Unit> Div<Px> for Point<Unit>where Unit: Div<Px, Output = Unit>,

type Output = Point<Unit>

The resulting type after applying the / operator.

fn div(self, rhs: Px) -> Self::Output

Performs the / operation.

impl<T, Unit> Div<Size<T>> for Point<Unit>where Unit: Div<T, Output = Unit>,

type Output = Point<Unit>

The resulting type after applying the / operator.

fn div(self, rhs: Size<T>) -> Self::Output

Performs the / operation.

impl<Unit> Div<UPx> for Point<Unit>where Unit: Div<UPx, Output = Unit>,

type Output = Point<Unit>

The resulting type after applying the / operator.

fn div(self, rhs: UPx) -> Self::Output

Performs the / operation.

impl<Unit> Div<f32> for Point<Unit>where Unit: Div<f32, Output = Unit>,

type Output = Point<Unit>

The resulting type after applying the / operator.

fn div(self, rhs: f32) -> Self::Output

Performs the / operation.

impl<Unit> Div<i32> for Point<Unit>where Unit: Div<i32, Output = Unit>,

type Output = Point<Unit>

The resulting type after applying the / operator.

fn div(self, rhs: i32) -> Self::Output

Performs the / operation.

impl<Unit> Div<u32> for Point<Unit>where Unit: Div<u32, Output = Unit>,

type Output = Point<Unit>

The resulting type after applying the / operator.

fn div(self, rhs: u32) -> Self::Output

Performs the / operation.

impl<Unit> DivAssign<Point<Unit>> for Size<Unit>where Unit: DivAssign,

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

Performs the /= operation.

impl<Unit> DivAssign<Size<Unit>> for Point<Unit>where Unit: DivAssign,

fn div_assign(&mut self, rhs: Size<Unit>)

Performs the /= operation.

impl<Unit> DivAssign<Unit> for Point<Unit>where Unit: DivAssign + Clone,

fn div_assign(&mut self, rhs: Unit)

Performs the /= operation.

impl<Unit> DivAssign for Point<Unit>where Unit: DivAssign,

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

Performs the /= operation.

impl<T> FloatConversion for Point<T>where T: FloatConversion,

type Float = Point<<T as FloatConversion>::Float>

The type that represents this type in floating point form.

fn into_float(self) -> Self::Float

Returns this value in floating point form.

fn from_float(float: Self::Float) -> Self

Converts from floating point to this form.

impl<Unit> From<PhysicalPosition<f64>> for Point<Unit>where Unit: FloatConversion<Float = f32>,

fn from(point: PhysicalPosition<f64>) -> Self

Converts to this type from the input type.

impl From<PhysicalPosition<i32>> for Point<Px>

fn from(point: PhysicalPosition<i32>) -> Self

Converts to this type from the input type.

impl From<PhysicalPosition<u32>> for Point<UPx>

fn from(point: PhysicalPosition<u32>) -> Self

Converts to this type from the input type.

impl From<Point<Px>> for PhysicalPosition<i32>

fn from(point: Point<Px>) -> Self

Converts to this type from the input type.

impl From<Point<UPx>> for Origin3d

fn from(value: Point<UPx>) -> Self

Converts to this type from the input type.

impl From<Point<UPx>> for PhysicalPosition<u32>

fn from(point: Point<UPx>) -> Self

Converts to this type from the input type.

impl<Unit> From<Point<Unit>> for Point2D<f32, UnknownUnit>where Unit: FloatConversion<Float = f32>,

fn from(point: Point<Unit>) -> Self

Converts to this type from the input type.

impl<Unit> From<Point<Unit>> for Size<Unit>

fn from(value: Point<Unit>) -> Self

Converts to this type from the input type.

impl<Unit> From<Point2D<f32, UnknownUnit>> for Point<Unit>where Unit: FloatConversion<Float = f32>,

fn from(point: Point2D<f32, UnknownUnit>) -> Self

Converts to this type from the input type.

impl<Unit> From<Size<Unit>> for Point<Unit>

fn from(value: Size<Unit>) -> Self

Converts to this type from the input type.

impl<Unit> FromComponents<Unit> for Point<Unit>

fn from_components(components: (Unit, Unit)) -> Self

Returns a new instance from the 2d vector components provided.

fn from_vec<Type>(other: Type) -> Selfwhere Type: IntoComponents<Unit>,

Converts this type to another type using FromComponents and IntoComponents.

impl<Unit: Hash> Hash for Point<Unit>

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<Unit> IntoComponents<Unit> for Point<Unit>

fn into_components(self) -> (Unit, Unit)

Extracts this type’s 2d vector components.

fn to_vec<Type>(self) -> Typewhere Type: FromComponents<Unit>,

Converts this type to another type using FromComponents and IntoComponents.

impl<Unit> IntoSigned for Point<Unit>where Unit: IntoSigned,

type Signed = Point<<Unit as IntoSigned>::Signed>

The signed representation of this type.

fn into_signed(self) -> Self::Signed

Returns this value as an unsigned value. Values that are larger than can fit in an i32 are converted to i32::MAX.

impl<Unit> IntoUnsigned for Point<Unit>where Unit: IntoUnsigned,

type Unsigned = Point<<Unit as IntoUnsigned>::Unsigned>

The unsigned representation of this type.

fn into_unsigned(self) -> Self::Unsigned

Returns this value as an unsigned value. Negative values will be converted to 0.

impl<Unit> Mul<Lp> for Point<Unit>where Unit: Mul<Lp, Output = Unit>,

type Output = Point<Unit>

The resulting type after applying the * operator.

fn mul(self, rhs: Lp) -> Self::Output

Performs the * operation.

impl<T, Unit> Mul<Point<T>> for Point<Unit>where Unit: Mul<T, Output = Unit>,

type Output = Point<Unit>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<T, Unit> Mul<Point<T>> for Size<Unit>where Unit: Mul<T, Output = Unit>,

type Output = Size<Unit>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<Unit> Mul<Px> for Point<Unit>where Unit: Mul<Px, Output = Unit>,

type Output = Point<Unit>

The resulting type after applying the * operator.

fn mul(self, rhs: Px) -> Self::Output

Performs the * operation.

impl<T, Unit> Mul<Size<T>> for Point<Unit>where Unit: Mul<T, Output = Unit>,

type Output = Point<Unit>

The resulting type after applying the * operator.

fn mul(self, rhs: Size<T>) -> Self::Output

Performs the * operation.

impl<Unit> Mul<UPx> for Point<Unit>where Unit: Mul<UPx, Output = Unit>,

type Output = Point<Unit>

The resulting type after applying the * operator.

fn mul(self, rhs: UPx) -> Self::Output

Performs the * operation.

impl<Unit> Mul<f32> for Point<Unit>where Unit: Mul<f32, Output = Unit>,

type Output = Point<Unit>

The resulting type after applying the * operator.

fn mul(self, rhs: f32) -> Self::Output

Performs the * operation.

impl<Unit> Mul<i32> for Point<Unit>where Unit: Mul<i32, Output = Unit>,

type Output = Point<Unit>

The resulting type after applying the * operator.

fn mul(self, rhs: i32) -> Self::Output

Performs the * operation.

impl<Unit> Mul<u32> for Point<Unit>where Unit: Mul<u32, Output = Unit>,

type Output = Point<Unit>

The resulting type after applying the * operator.

fn mul(self, rhs: u32) -> Self::Output

Performs the * operation.

impl<Unit> MulAssign<Point<Unit>> for Size<Unit>where Unit: MulAssign,

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

Performs the *= operation.

impl<Unit> MulAssign<Size<Unit>> for Point<Unit>where Unit: MulAssign,

fn mul_assign(&mut self, rhs: Size<Unit>)

Performs the *= operation.

impl<Unit> MulAssign<Unit> for Point<Unit>where Unit: MulAssign + Clone,

fn mul_assign(&mut self, rhs: Unit)

Performs the *= operation.

impl<Unit> MulAssign for Point<Unit>where Unit: MulAssign,

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

Performs the *= operation.

impl<Unit> Neg for Point<Unit>where Unit: Neg<Output = Unit>,

type Output = Point<Unit>

The resulting type after applying the - operator.

fn neg(self) -> Self::Output

Performs the unary - operation.

impl<Unit> Ord for Point<Unit>where Unit: Ord + Copy + Mul<Output = Unit>,

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

This method returns an Ordering between self and other.

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

Compares and returns the maximum of two values.

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

Compares and returns the minimum of two values.

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

Restrict a value to a certain interval.

impl<Unit: PartialEq> PartialEq for Point<Unit>

fn eq(&self, other: &Point<Unit>) -> 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<Unit> PartialOrd for Point<Unit>where Unit: Ord + Copy + Mul<Output = Unit>,

fn partial_cmp(&self, other: &Self) -> Option<Ordering>

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

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

This method tests less than (for self and other) and is used by the < operator.

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

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

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

This method tests greater than (for self and other) and is used by the > operator.

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

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

impl<Unit> Pow for Point<Unit>where Unit: Pow,

fn pow(&self, exp: u32) -> Self

Returns the saturating result of raising self to the exp power.

impl<Unit> Ranged for Point<Unit>where Unit: Ranged,

const MAX: Self = _

The maximum value for this type.

const MIN: Self = _

The minimum value for this type.

impl<Unit> Rem<Lp> for Point<Unit>where Unit: Rem<Lp, Output = Unit>,

type Output = Point<Unit>

The resulting type after applying the % operator.

fn rem(self, rhs: Lp) -> Self::Output

Performs the % operation.

impl<T, Unit> Rem<Point<T>> for Point<Unit>where Unit: Rem<T, Output = Unit>,

type Output = Point<Unit>

The resulting type after applying the % operator.

fn rem(self, rhs: Point<T>) -> Self::Output

Performs the % operation.

impl<T, Unit> Rem<Point<T>> for Size<Unit>where Unit: Rem<T, Output = Unit>,

type Output = Size<Unit>

The resulting type after applying the % operator.

fn rem(self, rhs: Point<T>) -> Self::Output

Performs the % operation.

impl<Unit> Rem<Px> for Point<Unit>where Unit: Rem<Px, Output = Unit>,

type Output = Point<Unit>

The resulting type after applying the % operator.

fn rem(self, rhs: Px) -> Self::Output

Performs the % operation.

impl<T, Unit> Rem<Size<T>> for Point<Unit>where Unit: Rem<T, Output = Unit>,

type Output = Point<Unit>

The resulting type after applying the % operator.

fn rem(self, rhs: Size<T>) -> Self::Output

Performs the % operation.

impl<Unit> Rem<UPx> for Point<Unit>where Unit: Rem<UPx, Output = Unit>,

type Output = Point<Unit>

The resulting type after applying the % operator.

fn rem(self, rhs: UPx) -> Self::Output

Performs the % operation.

impl<Unit> Rem<f32> for Point<Unit>where Unit: Rem<f32, Output = Unit>,

type Output = Point<Unit>

The resulting type after applying the % operator.

fn rem(self, rhs: f32) -> Self::Output

Performs the % operation.

impl<Unit> Rem<i32> for Point<Unit>where Unit: Rem<i32, Output = Unit>,

type Output = Point<Unit>

The resulting type after applying the % operator.

fn rem(self, rhs: i32) -> Self::Output

Performs the % operation.

impl<Unit> Rem<u32> for Point<Unit>where Unit: Rem<u32, Output = Unit>,

type Output = Point<Unit>

The resulting type after applying the % operator.

fn rem(self, rhs: u32) -> Self::Output

Performs the % operation.

impl<Unit> RemAssign<Point<Unit>> for Size<Unit>where Unit: RemAssign,

fn rem_assign(&mut self, rhs: Point<Unit>)

Performs the %= operation.

impl<Unit> RemAssign<Size<Unit>> for Point<Unit>where Unit: RemAssign,

fn rem_assign(&mut self, rhs: Size<Unit>)

Performs the %= operation.

impl<Unit> RemAssign<Unit> for Point<Unit>where Unit: RemAssign + Clone,

fn rem_assign(&mut self, rhs: Unit)

Performs the %= operation.

impl<Unit> RemAssign for Point<Unit>where Unit: RemAssign,

fn rem_assign(&mut self, rhs: Point<Unit>)

Performs the %= operation.

impl<Unit> Round for Point<Unit>where Unit: Round,

fn round(self) -> Self

Returns self rounded to the nearest whole number.

fn ceil(self) -> Self

Returns self raised to the next whole number further away from 0.

fn floor(self) -> Self

Returns self lowered to the next whole number closer to 0.

impl<Unit> ScreenScale for Point<Unit>where Unit: ScreenScale<Lp = Lp, Px = Px, UPx = UPx>,

type Lp = Point<Lp>

This type when measuring with Lp.

type Px = Point<Px>

This type when measuring with Px.

type UPx = Point<UPx>

This type when measuring with UPx.

fn into_px(self, scale: Fraction) -> Self::Px

Converts this value from its current unit into device pixels (Px) using the provided scale factor.

fn from_px(px: Self::Px, scale: Fraction) -> Self

Converts from pixels into this type, using the provided scale factor.

fn into_lp(self, scale: Fraction) -> Self::Lp

Converts this value from its current unit into device independent pixels (Lp) using the provided scale factor.

fn from_lp(lp: Self::Lp, scale: Fraction) -> Self

Converts from Lp into this type, using the provided scale factor.

fn into_upx(self, scale: Fraction) -> Self::UPx

Converts this value from its current unit into device pixels (UPx) using the provided scale factor.

fn from_upx(px: Self::UPx, scale: Fraction) -> Self

Converts from unsigned pixels into this type, using the provided scale factor.

impl<Unit> Serialize for Point<Unit>where Unit: Serialize,

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

Serialize this value into the given Serde serializer.

impl<Unit> Sub<Lp> for Point<Unit>where Unit: Sub<Lp, Output = Unit>,

type Output = Point<Unit>

The resulting type after applying the - operator.

fn sub(self, rhs: Lp) -> Self::Output

Performs the - operation.

impl<T, Unit> Sub<Point<T>> for Point<Unit>where Unit: Sub<T, Output = Unit>,

type Output = Point<Unit>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<T, Unit> Sub<Point<T>> for Size<Unit>where Unit: Sub<T, Output = Unit>,

type Output = Size<Unit>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<Unit> Sub<Point<Unit>> for Rect<Unit>where Unit: Sub<Output = Unit>,

type Output = Rect<Unit>

The resulting type after applying the - operator.

fn sub(self, rhs: Point<Unit>) -> Self::Output

Performs the - operation.

impl<Unit> Sub<Px> for Point<Unit>where Unit: Sub<Px, Output = Unit>,

type Output = Point<Unit>

The resulting type after applying the - operator.

fn sub(self, rhs: Px) -> Self::Output

Performs the - operation.

impl<T, Unit> Sub<Size<T>> for Point<Unit>where Unit: Sub<T, Output = Unit>,

type Output = Point<Unit>

The resulting type after applying the - operator.

fn sub(self, rhs: Size<T>) -> Self::Output

Performs the - operation.

impl<Unit> Sub<UPx> for Point<Unit>where Unit: Sub<UPx, Output = Unit>,

type Output = Point<Unit>

The resulting type after applying the - operator.

fn sub(self, rhs: UPx) -> Self::Output

Performs the - operation.

impl<Unit> Sub<f32> for Point<Unit>where Unit: Sub<f32, Output = Unit>,

type Output = Point<Unit>

The resulting type after applying the - operator.

fn sub(self, rhs: f32) -> Self::Output

Performs the - operation.

impl<Unit> Sub<i32> for Point<Unit>where Unit: Sub<i32, Output = Unit>,

type Output = Point<Unit>

The resulting type after applying the - operator.

fn sub(self, rhs: i32) -> Self::Output

Performs the - operation.

impl<Unit> Sub<u32> for Point<Unit>where Unit: Sub<u32, Output = Unit>,

type Output = Point<Unit>

The resulting type after applying the - operator.

fn sub(self, rhs: u32) -> Self::Output

Performs the - operation.

impl<Unit> SubAssign<Point<Unit>> for Size<Unit>where Unit: SubAssign,

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

Performs the -= operation.

impl<Unit> SubAssign<Size<Unit>> for Point<Unit>where Unit: SubAssign,

fn sub_assign(&mut self, rhs: Size<Unit>)

Performs the -= operation.

impl<Unit> SubAssign<Unit> for Point<Unit>where Unit: SubAssign + Clone,

fn sub_assign(&mut self, rhs: Unit)

Performs the -= operation.

impl<Unit> SubAssign for Point<Unit>where Unit: SubAssign,

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

Performs the -= operation.

impl<Unit> Zero for Point<Unit>where Unit: Zero,

const ZERO: Self = _

The zero value for this type.

fn is_zero(&self) -> bool

Returns true if self represents 0.

impl Zeroable for Point<Lp>

fn zeroed() -> Self

Calls zeroed.

impl Zeroable for Point<Px>

fn zeroed() -> Self

Calls zeroed.

impl Zeroable for Point<f32>

fn zeroed() -> Self

Calls zeroed.

impl Zeroable for Point<i32>

fn zeroed() -> Self

Calls zeroed.

impl Zeroable for Point<u32>

fn zeroed() -> Self

Calls zeroed.

impl<Unit: Copy> Copy for Point<Unit>

impl<Unit: Eq> Eq for Point<Unit>

impl Pod for Point<Lp>

impl Pod for Point<Px>

impl Pod for Point<f32>

impl Pod for Point<i32>

impl Pod for Point<u32>

impl<Unit> StructuralEq for Point<Unit>

impl<Unit> StructuralPartialEq for Point<Unit>