Struct Point 

#[repr(C)]
pub struct Point<T1, T2> {
    pub xcoord: T1,
    pub ycoord: T2,
}

Generic Point struct with x and y coordinates

This struct represents a point in 2D space with coordinates of potentially different types. It provides various operations and functionalities for working with points, such as comparison operators, arithmetic operators, flipping, overlap checking, distance calculation, and more.

Properties:

• xcoord: The x-coordinate of the point
• ycoord: The y-coordinate of the point

Fields

xcoord: T1

x portion of the Point object

ycoord: T2

y portion of the Point object

Implementations

impl<T1, T2> Point<T1, T2>

pub const fn new(xcoord: T1, ycoord: T2) -> Self

Creates a new Point with the given x and y coordinates

Arguments

• xcoord - The x-coordinate of the point
• ycoord - The y-coordinate of the point

Examples

use physdes::point::Point;
assert_eq!(Point::new(3, 4).xcoord, 3);
assert_eq!(Point::new(3, 4).ycoord, 4);

pub fn xcoord(&self) -> &T1

Returns a reference to the x-coordinate

pub fn ycoord(&self) -> &T2

Returns a reference to the y-coordinate

pub fn xcoord_mut(&mut self) -> &mut T1

Returns a mutable reference to the x-coordinate

pub fn ycoord_mut(&mut self) -> &mut T2

Returns a mutable reference to the y-coordinate

pub fn flip_xy(&self) -> Point<T2, T1>

where T1: Clone, T2: Clone,

Flips the coordinates according to xcoord-ycoord diagonal line

Returns a new Point with x and y coordinates swapped

Examples

use physdes::point::Point;
let p = Point::new(1, 2);
assert_eq!(p.flip_xy(), Point::new(2, 1));

pub fn flip_y(&self) -> Point<T1, T2>

where T1: Clone + Neg<Output = T1>, T2: Clone,

Flips according to ycoord-axis (negates x-coordinate)

Returns a new Point with x-coordinate negated

Examples

use physdes::point::Point;
let p = Point::new(3, 4);
assert_eq!(p.flip_y(), Point::new(-3, 4));

Trait Implementations

impl<'a, 'b, T1: Clone + Num, T2: Clone + Num> Add<&'b Vector2<T1, T2>> for &'a Point<T1, T2>

type Output = Point<T1, T2>

The resulting type after applying the + operator.

fn add(self, other: &Vector2<T1, T2>) -> Self::Output

Performs the + operation.

impl<'a, T1: Clone + Num, T2: Clone + Num> Add<&'a Vector2<T1, T2>> for Point<T1, T2>

type Output = Point<T1, T2>

The resulting type after applying the + operator.

fn add(self, other: &Vector2<T1, T2>) -> Self::Output

Performs the + operation.

impl<'a, T1: Clone + Num, T2: Clone + Num> Add<Vector2<T1, T2>> for &'a Point<T1, T2>

type Output = Point<T1, T2>

The resulting type after applying the + operator.

fn add(self, other: Vector2<T1, T2>) -> Self::Output

Performs the + operation.

impl<T1: Clone + Num, T2: Clone + Num> Add<Vector2<T1, T2>> for Point<T1, T2>

fn add(self, other: Vector2<T1, T2>) -> Self::Output

Translate a point by a vector

Examples

use physdes::point::Point;
use physdes::vector2::Vector2;

assert_eq!(Point::new(3, 4) + Vector2::new(5, 3), Point::new(8, 7));
assert_eq!(Point::new(3, 4) + Vector2::new(-5, -3), Point::new(-2, 1));
assert_eq!(Point::new(3, 4) + Vector2::new(5, -3), Point::new(8, 1));
assert_eq!(Point::new(3, 4) + Vector2::new(-5, 3), Point::new(-2, 7));
assert_eq!(Point::new(3, 4) + Vector2::new(0, 0), Point::new(3, 4));
assert_eq!(Point::new(3, 4) + Vector2::new(0, 5), Point::new(3, 9));

type Output = Point<T1, T2>

The resulting type after applying the + operator.

impl<'a, T1: Clone + Num + AddAssign, T2: Clone + Num + AddAssign> AddAssign<&'a Vector2<T1, T2>> for Point<T1, T2>

fn add_assign(&mut self, other: &'a Vector2<T1, T2>)

Performs the += operation.

impl<T1: Clone + Num + AddAssign, T2: Clone + Num + AddAssign> AddAssign<Vector2<T1, T2>> for Point<T1, T2>

fn add_assign(&mut self, other: Vector2<T1, T2>)

Performs the += operation.

impl<T1: Clone, T2: Clone> Clone for Point<T1, T2>

fn clone(&self) -> Point<T1, T2>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T1, T2, U1, U2> Contain<Point<U1, U2>> for Point<T1, T2>

where T1: Contain<U1>, T2: Contain<U2>,

fn contains(&self, other: &Point<U1, U2>) -> bool

impl<T1: Debug, T2: Debug> Debug for Point<T1, T2>

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

Formats the value using the given formatter.

impl<T1: Default, T2: Default> Default for Point<T1, T2>

fn default() -> Point<T1, T2>

Returns the “default value” for a type.

impl<T1, T2> Displacement<Point<T1, T2>> for Point<T1, T2>

where T1: Displacement<T1, Output = T1>, T2: Displacement<T2, Output = T2>,

type Output = Vector2<T1, T2>

fn displace(&self, other: &Point<T1, T2>) -> Self::Output

Displace the current value by the provided other value.

impl<T1: Display, T2: Display> Display for Point<T1, T2>

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

Formats the value using the given formatter.

impl<T1, T2, Alpha> Enlarge<Alpha> for Point<T1, T2>

where T1: Enlarge<Alpha, Output = Interval<T1>> + Copy, T2: Enlarge<Alpha, Output = Interval<T2>> + Copy, Alpha: Copy,

type Output = Point<Interval<T1>, Interval<T2>>

fn enlarge_with(&self, alpha: Alpha) -> Self::Output

impl<T1: Hash, T2: Hash> Hash for Point<T1, T2>

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<T1, T2> Hull<Point<T1, T2>> for Point<T1, T2>

where T1: Hull<T1>, T2: Hull<T2>,

type Output = Point<<T1 as Hull<T1>>::Output, <T2 as Hull<T2>>::Output>

fn hull_with(&self, other: &Point<T1, T2>) -> Self::Output

impl<T1, T2> Intersect<Point<T1, T2>> for Point<T1, T2>

where T1: Intersect<T1>, T2: Intersect<T2>,

type Output = Point<<T1 as Intersect<T1>>::Output, <T2 as Intersect<T2>>::Output>

fn intersect_with(&self, other: &Point<T1, T2>) -> Self::Output

impl<T1, T2, U1, U2> MinDist<Point<U1, U2>> for Point<T1, T2>

where T1: MinDist<U1>, T2: MinDist<U2>,

fn min_dist_with(&self, other: &Point<U1, U2>) -> u32

Calculates the minimum distance between the current value and the provided value.

impl<T1: Clone + Num + Neg<Output = T1>, T2: Clone + Num + Neg<Output = T2>> Neg for &Point<T1, T2>

type Output = Point<T1, T2>

The resulting type after applying the - operator.

fn neg(self) -> Self::Output

Performs the unary - operation.

impl<T1: Clone + Num + Neg<Output = T1>, T2: Clone + Num + Neg<Output = T2>> Neg for Point<T1, T2>

fn neg(self) -> Self::Output

Negate a Point

Examples

use physdes::point::Point;

assert_eq!(-Point::new(3, 4), Point::new(-3, -4));
assert_eq!(-Point::new(0, 0), Point::new(0, 0));

type Output = Point<T1, T2>

The resulting type after applying the - operator.

impl<T1: Ord, T2: Ord> Ord for Point<T1, T2>

fn cmp(&self, other: &Point<T1, T2>) -> 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<T1, T2, U1, U2> Overlap<Point<U1, U2>> for Point<T1, T2>

where T1: Overlap<U1>, T2: Overlap<U2>,

fn overlaps(&self, other: &Point<U1, U2>) -> bool

impl<T1: PartialEq, T2: PartialEq> PartialEq for Point<T1, T2>

fn eq(&self, other: &Point<T1, T2>) -> 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<T1: PartialOrd, T2: PartialOrd> PartialOrd for Point<T1, T2>

fn partial_cmp(&self, other: &Point<T1, T2>) -> 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, 'b, T1: Clone + Num, T2: Clone + Num> Sub<&'b Vector2<T1, T2>> for &'a Point<T1, T2>

type Output = Point<T1, T2>

The resulting type after applying the - operator.

fn sub(self, other: &Vector2<T1, T2>) -> Self::Output

Performs the - operation.

impl<'a, T1: Clone + Num, T2: Clone + Num> Sub<&'a Vector2<T1, T2>> for Point<T1, T2>

type Output = Point<T1, T2>

The resulting type after applying the - operator.

fn sub(self, other: &Vector2<T1, T2>) -> Self::Output

Performs the - operation.

impl<'a, T1: Clone + Num, T2: Clone + Num> Sub<Vector2<T1, T2>> for &'a Point<T1, T2>

type Output = Point<T1, T2>

The resulting type after applying the - operator.

fn sub(self, other: Vector2<T1, T2>) -> Self::Output

Performs the - operation.

impl<T1: Clone + Num, T2: Clone + Num> Sub<Vector2<T1, T2>> for Point<T1, T2>

fn sub(self, other: Vector2<T1, T2>) -> Self::Output

Translate a point by a vector (subtraction)

Examples

use physdes::point::Point;
use physdes::vector2::Vector2;
assert_eq!(Point::new(3, 4) - Vector2::new(5, 3), Point::new(-2, 1));
assert_eq!(Point::new(3, 4) - Vector2::new(-5, -3), Point::new(8, 7));
assert_eq!(Point::new(3, 4) - Vector2::new(5, -3), Point::new(-2, 7));
assert_eq!(Point::new(3, 4) - Vector2::new(-5, 3), Point::new(8, 1));
assert_eq!(Point::new(3, 4) - Vector2::new(0, 0), Point::new(3, 4));
assert_eq!(Point::new(3, 4) - Vector2::new(0, 5), Point::new(3, -1));
assert_eq!(Point::new(3, 4) - Vector2::new(5, 0), Point::new(-2, 4));

type Output = Point<T1, T2>

The resulting type after applying the - operator.

impl<T1: Clone + Num, T2: Clone + Num> Sub for Point<T1, T2>

fn sub(self, other: Self) -> Self::Output

Calculate displacement vector between two points

Examples

use physdes::point::Point;
use physdes::vector2::Vector2;

assert_eq!(Point::new(3, 4) - Point::new(5, 3), Vector2::new(-2, 1));
assert_eq!(Point::new(3, 4) - Point::new(-5, -3), Vector2::new(8, 7));
assert_eq!(Point::new(3, 4) - Point::new(5, -3), Vector2::new(-2, 7));
assert_eq!(Point::new(3, 4) - Point::new(-5, 3), Vector2::new(8, 1));
assert_eq!(Point::new(3, 4) - Point::new(0, 0), Vector2::new(3, 4));

type Output = Vector2<T1, T2>

The resulting type after applying the - operator.

impl<'a, T1: Clone + Num + SubAssign, T2: Clone + Num + SubAssign> SubAssign<&'a Vector2<T1, T2>> for Point<T1, T2>

fn sub_assign(&mut self, other: &'a Vector2<T1, T2>)

Performs the -= operation.

impl<T1: Clone + Num + SubAssign, T2: Clone + Num + SubAssign> SubAssign<Vector2<T1, T2>> for Point<T1, T2>

fn sub_assign(&mut self, other: Vector2<T1, T2>)

Performs the -= operation.

impl<T1: Copy, T2: Copy> Copy for Point<T1, T2>

impl<T1: Eq, T2: Eq> Eq for Point<T1, T2>

impl<T1, T2> StructuralPartialEq for Point<T1, T2>