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.

       y
       ^
       |
       |
  (x,y)*-----> x
       |
       |
       O-----> x

Properties:

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

Examples

use physdes::point::Point;

let p = Point::new(3, 4);
assert_eq!(p.xcoord, 3);
assert_eq!(p.ycoord, 4);

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

$$(x, y) \to (y, x)$$

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)

$$(x, y) \to (-x, y)$$

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));

impl Point<Interval<i32>, Interval<i32>>

pub fn nearest_to(&self, other: &Point<i32, i32>) -> Point<i32, i32>

Returns the point on this rectangle that is nearest to other. Clips each coordinate to the interval bounds:

$$x’ = \text{clip}(x,; lb_x,; ub_x), \quad y’ = \text{clip}(y,; lb_y,; ub_y)$$

pub fn blocks(&self, other: &Self) -> bool

Checks if this rectangle blocks the path represented by other rectangle. A rectangle self blocks other if: self.x contains other.x AND other.y contains self.y OR self.y contains other.y AND other.x contains self.x This matches the Python blocks method semantics and is distinct from simple rectangle overlap — it catches paths that must cross the keepout regardless of L-shape choice.

Trait Implementations

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, '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<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

$$P’ = (x + v_x,; y + v_y)$$

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>

Translates the point by adding a vector reference to its coordinates

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>

Translates the point by adding a vector to its coordinates

$$P \mathrel{+}= (v_x, v_y) \implies (x + v_x,; y + v_y)$$

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

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>,

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

Displacement vector between two points:

$$\vec{d} = (x_1 - x_2,; y_1 - y_2)$$

type Output = Vector2<T1, T2>

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

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

Formats the point as (x, y).

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,

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

Enlarges a point to a rectangle: $x \to [x-\alpha,; x+\alpha]$, $y \to [y-\alpha,; y+\alpha]$

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

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

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>,

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

Component-wise hull (bounding box) of two points:

$$\text{hull}(A,B) = (\min(A_x,B_x)..\max(A_x,B_x),; \min(A_y,B_y)..\max(A_y,B_y))$$

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

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

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

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

Component-wise intersection of two points (when coordinates are intervals):

$$\text{intersect}(A,B) = (\max(A_x,B_x)..\min(A_x,B_x),; \max(A_y,B_y)..\min(A_y,B_y))$$

type Output = Point<<T1 as Intersect<T1>>::Output, <T2 as Intersect<T2>>::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

Manhattan distance: $d = |x_1 - x_2| + |y_1 - y_2|$

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

$$-P = (-x,; -y)$$

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: 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: 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

Points overlap iff both coordinates overlap: $x_1 \cap x_2 \land y_1 \cap y_2$

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<T1: PartialEq, T2: PartialEq> StructuralPartialEq for Point<T1, T2>

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

$$\vec{d} = (x_1 - x_2,; y_1 - y_2)$$

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, 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, '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<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)

$$P’ = (x - v_x,; y - v_y)$$

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<'a, T1: Clone + Num + SubAssign, T2: Clone + Num + SubAssign> SubAssign<&'a Vector2<T1, T2>> for Point<T1, T2>

Translates the point by subtracting a vector reference from its coordinates

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>

Translates the point by subtracting a vector from its coordinates

$$P \mathrel{-}= (v_x, v_y) \implies (x - v_x,; y - v_y)$$

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

Performs the -= operation.