Struct Vector2 

pub struct Vector2<T1, T2> {
    pub x_: T1,
    pub y_: T2,
}

The code defines a generic struct called Vector2 with two fields, x_ and y_.

Properties:

• x_: The x_ property represents the x-coordinate of the Vector2 object. It is of type T, which means it can be any type specified when creating an instance of the Vector2 struct.
• y_: The y_ property is the y-coordinate of the Vector2 object. It represents the vertical position of the vector in a 2D coordinate system.

Fields

x_: T1

x portion of the Vector2 object

y_: T2

y portion of the Vector2 object

Implementations

impl<T1, T2> Vector2<T1, T2>

pub const fn new(x_: T1, y_: T2) -> Self

The function new creates a new Vector2 with the given x and y values.

Arguments:

• x_: The parameter x_ represents the x-coordinate of the Vector2.
• y_: The parameter y_ represents the y-coordinate of the Vector2. It is of type T, which means it can be any type that is specified when the Vector2 is created.

Returns:

The new function is returning a new instance of the Vector2 struct with the provided x_ and y_ values.

Example

use physdes::vector2::Vector2;

assert_eq!(Vector2::new(1, 2), Vector2 { x_: 1, y_: 2 });
assert_eq!(Vector2::new(3, 4), Vector2 { x_: 3, y_: 4 });

impl<T1: Clone + Num> Vector2<T1, T1>

pub fn dot(&self, other: &Self) -> T1

The dot function calculates the dot product of two vectors.

Arguments:

• other: The other parameter is of the same type as self, which means it is an instance of the same struct or class that the dot method is defined in.

Returns:

The dot product of two vectors is being returned.

Example

use physdes::vector2::Vector2;

assert_eq!(Vector2::new(1, 2).dot(&Vector2::new(3, 4)), 11);
assert_eq!(Vector2::new(3, 4).dot(&Vector2::new(1, 2)), 11);

pub fn cross(&self, other: &Self) -> T1

The cross function calculates the cross product of two vectors.

Arguments:

• other: The other parameter is of type Self, which means it is the same type as the current object.

Example

use physdes::vector2::Vector2;

assert_eq!(Vector2::new(1, 2).cross(&Vector2::new(3, 4)), -2);
assert_eq!(Vector2::new(3, 4).cross(&Vector2::new(1, 2)), 2);

pub fn scale(&self, t: T1) -> Self

The scale function multiplies the vector by a scalar value.

Arguments:

• t: The parameter t is a scalar value that will be used to multiply each component of self.

Returns:

The scale method returns a new instance of the same type as self. Multiplies self by the scalar t.

Example

use physdes::vector2::Vector2;

assert_eq!(Vector2::new(1, 2).scale(3), Vector2::new(3, 6));
assert_eq!(Vector2::new(3, 4).scale(2), Vector2::new(6, 8));

pub fn unscale(&self, t: T1) -> Self

The unscale function divides the coordinates of a vector by a scalar value.

Arguments:

• t: The parameter t is a scalar value that is used to divide the self object. It is of type T, which is a generic type parameter. The division operation is performed on the x_ and y_ fields of the self object.

Returns:

The unscale method returns a new instance of the same type as self. Divides self by the scalar t.

Example

use physdes::vector2::Vector2;

assert_eq!(Vector2::new(3, 6).unscale(3), Vector2::new(1, 2));
assert_eq!(Vector2::new(6, 8).unscale(2), Vector2::new(3, 4));

impl<T1: Clone + Signed> Vector2<T1, T1>

pub fn l1_norm(&self) -> T1

The l1_norm function calculates the Manhattan distance from the origin.

Returns:

The L1 norm, which is the Manhattan distance from the origin. Returns the L1 norm |x_| + |y_| – the Manhattan distance from the origin.

Example

use physdes::vector2::Vector2;

assert_eq!(Vector2::new(1, 2).l1_norm(), 3);
assert_eq!(Vector2::new(3, 4).l1_norm(), 7);

impl<T1: Clone + PartialOrd> Vector2<T1, T1>

pub fn norm_inf(&self) -> T1

The norm_inf function returns the maximum absolute value between x_ and y_.

Returns:

The norm_inf function returns the maximum value between |x_| and |y_|. Returns the infinity norm max(|x_| + |y_|)

Example

use physdes::vector2::Vector2;

assert_eq!(Vector2::new(1, 2).norm_inf(), 2);
assert_eq!(Vector2::new(3, 4).norm_inf(), 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<T1: Clone + Num, T2: Clone + Num> Add for Vector2<T1, T2>

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

The function add takes two values of the same type and returns their sum.

Arguments:

• other: The other parameter is of the same type as self and represents the other object that you want to add to self.

Example

use physdes::vector2::Vector2;
use std::ops::Add;

assert_eq!(Vector2::new(1, 2).add(Vector2::new(3, 4)), Vector2::new(4, 6));
assert_eq!(Vector2::new(3, 4).add(Vector2::new(1, 2)), Vector2::new(4, 6));

type Output = Vector2<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<'a, T1: Clone + NumAssign, T2: Clone + NumAssign> AddAssign<&'a Vector2<T1, T2>> for Vector2<T1, T2>

fn add_assign(&mut self, other: &Self)

Performs the += operation.

impl<T: AddAssign + Clone + Num> AddAssign<Vector2<T, T>> for Polygon<T>

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

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 + NumAssign, T2: Clone + NumAssign> AddAssign for Vector2<T1, T2>

fn add_assign(&mut self, other: Self)

The function add_assign adds the values of other.x_ and other.y_ to self.x_ and self.y_ respectively.

Arguments:

• other: The “other” parameter is of type Self, which means it is a reference to another instance of the same struct or class that the method is defined in. In this case, it represents another instance of the struct or class that has the same fields or properties as self.

Example

use physdes::vector2::Vector2;
use std::ops::AddAssign;

let mut v = Vector2::new(1, 2);
let v2 = Vector2::new(3, 4);
v.add_assign(v2);
assert_eq!(v, Vector2::new(4, 6));

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

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

Returns a duplicate of the value.

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

Performs copy-assignment from source.

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

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

Formats the value using the given formatter.

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

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

Returns the “default value” for a type.

impl<T1: Clone + Num> Div<T1> for Vector2<T1, T1>

type Output = Vector2<T1, T1>

The resulting type after applying the / operator.

fn div(self, other: T1) -> Self::Output

Performs the / operation.

impl<'a, T1: Clone + NumAssign> DivAssign<&'a T1> for Vector2<T1, T1>

fn div_assign(&mut self, other: &T1)

Performs the /= operation.

impl<T1: Clone + NumAssign> DivAssign<T1> for Vector2<T1, T1>

fn div_assign(&mut self, other: T1)

The function divides the values of self.x_ and self.y_ by the value of other.

Arguments:

• other: The parameter other is of type T, which means it can be any type that implements the Clone trait.

Example

use physdes::vector2::Vector2;
use std::ops::DivAssign;

let mut v = Vector2::new(3, 6);
v.div_assign(3);
assert_eq!(v, Vector2::new(1, 2));

impl<T1: Hash, T2: Hash> Hash for Vector2<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<'a, 'b, T1: Clone + Num> Mul<&'a T1> for &'b Vector2<T1, T1>

type Output = Vector2<T1, T1>

The resulting type after applying the * operator.

fn mul(self, other: &T1) -> Self::Output

Performs the * operation.

impl<'a, T1: Clone + Num> Mul<&'a T1> for Vector2<T1, T1>

type Output = Vector2<T1, T1>

The resulting type after applying the * operator.

fn mul(self, other: &T1) -> Self::Output

Performs the * operation.

impl<'a, 'b> Mul<&'a Vector2<f32, f32>> for &'b f32

type Output = Vector2<f32, f32>

The resulting type after applying the * operator.

fn mul(self, other: &Vector2<f32, f32>) -> Vector2<f32, f32>

Performs the * operation.

impl<'a> Mul<&'a Vector2<f32, f32>> for f32

type Output = Vector2<f32, f32>

The resulting type after applying the * operator.

fn mul(self, other: &Vector2<f32, f32>) -> Vector2<f32, f32>

Performs the * operation.

impl<'a, 'b> Mul<&'a Vector2<f64, f64>> for &'b f64

type Output = Vector2<f64, f64>

The resulting type after applying the * operator.

fn mul(self, other: &Vector2<f64, f64>) -> Vector2<f64, f64>

Performs the * operation.

impl<'a> Mul<&'a Vector2<f64, f64>> for f64

type Output = Vector2<f64, f64>

The resulting type after applying the * operator.

fn mul(self, other: &Vector2<f64, f64>) -> Vector2<f64, f64>

Performs the * operation.

impl<'a, 'b> Mul<&'a Vector2<i128, i128>> for &'b i128

type Output = Vector2<i128, i128>

The resulting type after applying the * operator.

fn mul(self, other: &Vector2<i128, i128>) -> Vector2<i128, i128>

Performs the * operation.

impl<'a> Mul<&'a Vector2<i128, i128>> for i128

type Output = Vector2<i128, i128>

The resulting type after applying the * operator.

fn mul(self, other: &Vector2<i128, i128>) -> Vector2<i128, i128>

Performs the * operation.

impl<'a, 'b> Mul<&'a Vector2<i16, i16>> for &'b i16

type Output = Vector2<i16, i16>

The resulting type after applying the * operator.

fn mul(self, other: &Vector2<i16, i16>) -> Vector2<i16, i16>

Performs the * operation.

impl<'a> Mul<&'a Vector2<i16, i16>> for i16

type Output = Vector2<i16, i16>

The resulting type after applying the * operator.

fn mul(self, other: &Vector2<i16, i16>) -> Vector2<i16, i16>

Performs the * operation.

impl<'a, 'b> Mul<&'a Vector2<i32, i32>> for &'b i32

type Output = Vector2<i32, i32>

The resulting type after applying the * operator.

fn mul(self, other: &Vector2<i32, i32>) -> Vector2<i32, i32>

Performs the * operation.

impl<'a> Mul<&'a Vector2<i32, i32>> for i32

type Output = Vector2<i32, i32>

The resulting type after applying the * operator.

fn mul(self, other: &Vector2<i32, i32>) -> Vector2<i32, i32>

Performs the * operation.

impl<'a, 'b> Mul<&'a Vector2<i64, i64>> for &'b i64

type Output = Vector2<i64, i64>

The resulting type after applying the * operator.

fn mul(self, other: &Vector2<i64, i64>) -> Vector2<i64, i64>

Performs the * operation.

impl<'a> Mul<&'a Vector2<i64, i64>> for i64

type Output = Vector2<i64, i64>

The resulting type after applying the * operator.

fn mul(self, other: &Vector2<i64, i64>) -> Vector2<i64, i64>

Performs the * operation.

impl<'a, 'b> Mul<&'a Vector2<i8, i8>> for &'b i8

type Output = Vector2<i8, i8>

The resulting type after applying the * operator.

fn mul(self, other: &Vector2<i8, i8>) -> Vector2<i8, i8>

Performs the * operation.

impl<'a> Mul<&'a Vector2<i8, i8>> for i8

type Output = Vector2<i8, i8>

The resulting type after applying the * operator.

fn mul(self, other: &Vector2<i8, i8>) -> Vector2<i8, i8>

Performs the * operation.

impl<'a, 'b> Mul<&'a Vector2<isize, isize>> for &'b isize

type Output = Vector2<isize, isize>

The resulting type after applying the * operator.

fn mul(self, other: &Vector2<isize, isize>) -> Vector2<isize, isize>

Performs the * operation.

impl<'a> Mul<&'a Vector2<isize, isize>> for isize

type Output = Vector2<isize, isize>

The resulting type after applying the * operator.

fn mul(self, other: &Vector2<isize, isize>) -> Vector2<isize, isize>

Performs the * operation.

impl<'a, 'b> Mul<&'a Vector2<u128, u128>> for &'b u128

type Output = Vector2<u128, u128>

The resulting type after applying the * operator.

fn mul(self, other: &Vector2<u128, u128>) -> Vector2<u128, u128>

Performs the * operation.

impl<'a> Mul<&'a Vector2<u128, u128>> for u128

type Output = Vector2<u128, u128>

The resulting type after applying the * operator.

fn mul(self, other: &Vector2<u128, u128>) -> Vector2<u128, u128>

Performs the * operation.

impl<'a, 'b> Mul<&'a Vector2<u16, u16>> for &'b u16

type Output = Vector2<u16, u16>

The resulting type after applying the * operator.

fn mul(self, other: &Vector2<u16, u16>) -> Vector2<u16, u16>

Performs the * operation.

impl<'a> Mul<&'a Vector2<u16, u16>> for u16

type Output = Vector2<u16, u16>

The resulting type after applying the * operator.

fn mul(self, other: &Vector2<u16, u16>) -> Vector2<u16, u16>

Performs the * operation.

impl<'a, 'b> Mul<&'a Vector2<u32, u32>> for &'b u32

type Output = Vector2<u32, u32>

The resulting type after applying the * operator.

fn mul(self, other: &Vector2<u32, u32>) -> Vector2<u32, u32>

Performs the * operation.

impl<'a> Mul<&'a Vector2<u32, u32>> for u32

type Output = Vector2<u32, u32>

The resulting type after applying the * operator.

fn mul(self, other: &Vector2<u32, u32>) -> Vector2<u32, u32>

Performs the * operation.

impl<'a, 'b> Mul<&'a Vector2<u64, u64>> for &'b u64

type Output = Vector2<u64, u64>

The resulting type after applying the * operator.

fn mul(self, other: &Vector2<u64, u64>) -> Vector2<u64, u64>

Performs the * operation.

impl<'a> Mul<&'a Vector2<u64, u64>> for u64

type Output = Vector2<u64, u64>

The resulting type after applying the * operator.

fn mul(self, other: &Vector2<u64, u64>) -> Vector2<u64, u64>

Performs the * operation.

impl<'a, 'b> Mul<&'a Vector2<u8, u8>> for &'b u8

type Output = Vector2<u8, u8>

The resulting type after applying the * operator.

fn mul(self, other: &Vector2<u8, u8>) -> Vector2<u8, u8>

Performs the * operation.

impl<'a> Mul<&'a Vector2<u8, u8>> for u8

type Output = Vector2<u8, u8>

The resulting type after applying the * operator.

fn mul(self, other: &Vector2<u8, u8>) -> Vector2<u8, u8>

Performs the * operation.

impl<'a, 'b> Mul<&'a Vector2<usize, usize>> for &'b usize

type Output = Vector2<usize, usize>

The resulting type after applying the * operator.

fn mul(self, other: &Vector2<usize, usize>) -> Vector2<usize, usize>

Performs the * operation.

impl<'a> Mul<&'a Vector2<usize, usize>> for usize

type Output = Vector2<usize, usize>

The resulting type after applying the * operator.

fn mul(self, other: &Vector2<usize, usize>) -> Vector2<usize, usize>

Performs the * operation.

impl<'a, T1: Clone + Num> Mul<T1> for &'a Vector2<T1, T1>

type Output = Vector2<T1, T1>

The resulting type after applying the * operator.

fn mul(self, other: T1) -> Self::Output

Performs the * operation.

impl<T1: Clone + Num> Mul<T1> for Vector2<T1, T1>

type Output = Vector2<T1, T1>

The resulting type after applying the * operator.

fn mul(self, other: T1) -> Self::Output

Performs the * operation.

impl<'a> Mul<Vector2<f32, f32>> for &'a f32

type Output = Vector2<f32, f32>

The resulting type after applying the * operator.

fn mul(self, other: Vector2<f32, f32>) -> Vector2<f32, f32>

Performs the * operation.

impl Mul<Vector2<f32, f32>> for f32

type Output = Vector2<f32, f32>

The resulting type after applying the * operator.

fn mul(self, other: Vector2<f32, f32>) -> Self::Output

Performs the * operation.

impl<'a> Mul<Vector2<f64, f64>> for &'a f64

type Output = Vector2<f64, f64>

The resulting type after applying the * operator.

fn mul(self, other: Vector2<f64, f64>) -> Vector2<f64, f64>

Performs the * operation.

impl Mul<Vector2<f64, f64>> for f64

type Output = Vector2<f64, f64>

The resulting type after applying the * operator.

fn mul(self, other: Vector2<f64, f64>) -> Self::Output

Performs the * operation.

impl<'a> Mul<Vector2<i128, i128>> for &'a i128

type Output = Vector2<i128, i128>

The resulting type after applying the * operator.

fn mul(self, other: Vector2<i128, i128>) -> Vector2<i128, i128>

Performs the * operation.

impl Mul<Vector2<i128, i128>> for i128

type Output = Vector2<i128, i128>

The resulting type after applying the * operator.

fn mul(self, other: Vector2<i128, i128>) -> Self::Output

Performs the * operation.

impl<'a> Mul<Vector2<i16, i16>> for &'a i16

type Output = Vector2<i16, i16>

The resulting type after applying the * operator.

fn mul(self, other: Vector2<i16, i16>) -> Vector2<i16, i16>

Performs the * operation.

impl Mul<Vector2<i16, i16>> for i16

type Output = Vector2<i16, i16>

The resulting type after applying the * operator.

fn mul(self, other: Vector2<i16, i16>) -> Self::Output

Performs the * operation.

impl<'a> Mul<Vector2<i32, i32>> for &'a i32

type Output = Vector2<i32, i32>

The resulting type after applying the * operator.

fn mul(self, other: Vector2<i32, i32>) -> Vector2<i32, i32>

Performs the * operation.

impl Mul<Vector2<i32, i32>> for i32

type Output = Vector2<i32, i32>

The resulting type after applying the * operator.

fn mul(self, other: Vector2<i32, i32>) -> Self::Output

Performs the * operation.

impl<'a> Mul<Vector2<i64, i64>> for &'a i64

type Output = Vector2<i64, i64>

The resulting type after applying the * operator.

fn mul(self, other: Vector2<i64, i64>) -> Vector2<i64, i64>

Performs the * operation.

impl Mul<Vector2<i64, i64>> for i64

type Output = Vector2<i64, i64>

The resulting type after applying the * operator.

fn mul(self, other: Vector2<i64, i64>) -> Self::Output

Performs the * operation.

impl<'a> Mul<Vector2<i8, i8>> for &'a i8

type Output = Vector2<i8, i8>

The resulting type after applying the * operator.

fn mul(self, other: Vector2<i8, i8>) -> Vector2<i8, i8>

Performs the * operation.

impl Mul<Vector2<i8, i8>> for i8

type Output = Vector2<i8, i8>

The resulting type after applying the * operator.

fn mul(self, other: Vector2<i8, i8>) -> Self::Output

Performs the * operation.

impl<'a> Mul<Vector2<isize, isize>> for &'a isize

type Output = Vector2<isize, isize>

The resulting type after applying the * operator.

fn mul(self, other: Vector2<isize, isize>) -> Vector2<isize, isize>

Performs the * operation.

impl Mul<Vector2<isize, isize>> for isize

type Output = Vector2<isize, isize>

The resulting type after applying the * operator.

fn mul(self, other: Vector2<isize, isize>) -> Self::Output

Performs the * operation.

impl<'a> Mul<Vector2<u128, u128>> for &'a u128

type Output = Vector2<u128, u128>

The resulting type after applying the * operator.

fn mul(self, other: Vector2<u128, u128>) -> Vector2<u128, u128>

Performs the * operation.

impl Mul<Vector2<u128, u128>> for u128

type Output = Vector2<u128, u128>

The resulting type after applying the * operator.

fn mul(self, other: Vector2<u128, u128>) -> Self::Output

Performs the * operation.

impl<'a> Mul<Vector2<u16, u16>> for &'a u16

type Output = Vector2<u16, u16>

The resulting type after applying the * operator.

fn mul(self, other: Vector2<u16, u16>) -> Vector2<u16, u16>

Performs the * operation.

impl Mul<Vector2<u16, u16>> for u16

type Output = Vector2<u16, u16>

The resulting type after applying the * operator.

fn mul(self, other: Vector2<u16, u16>) -> Self::Output

Performs the * operation.

impl<'a> Mul<Vector2<u32, u32>> for &'a u32

type Output = Vector2<u32, u32>

The resulting type after applying the * operator.

fn mul(self, other: Vector2<u32, u32>) -> Vector2<u32, u32>

Performs the * operation.

impl Mul<Vector2<u32, u32>> for u32

type Output = Vector2<u32, u32>

The resulting type after applying the * operator.

fn mul(self, other: Vector2<u32, u32>) -> Self::Output

Performs the * operation.

impl<'a> Mul<Vector2<u64, u64>> for &'a u64

type Output = Vector2<u64, u64>

The resulting type after applying the * operator.

fn mul(self, other: Vector2<u64, u64>) -> Vector2<u64, u64>

Performs the * operation.

impl Mul<Vector2<u64, u64>> for u64

type Output = Vector2<u64, u64>

The resulting type after applying the * operator.

fn mul(self, other: Vector2<u64, u64>) -> Self::Output

Performs the * operation.

impl<'a> Mul<Vector2<u8, u8>> for &'a u8

type Output = Vector2<u8, u8>

The resulting type after applying the * operator.

fn mul(self, other: Vector2<u8, u8>) -> Vector2<u8, u8>

Performs the * operation.

impl Mul<Vector2<u8, u8>> for u8

type Output = Vector2<u8, u8>

The resulting type after applying the * operator.

fn mul(self, other: Vector2<u8, u8>) -> Self::Output

Performs the * operation.

impl<'a> Mul<Vector2<usize, usize>> for &'a usize

type Output = Vector2<usize, usize>

The resulting type after applying the * operator.

fn mul(self, other: Vector2<usize, usize>) -> Vector2<usize, usize>

Performs the * operation.

impl Mul<Vector2<usize, usize>> for usize

type Output = Vector2<usize, usize>

The resulting type after applying the * operator.

fn mul(self, other: Vector2<usize, usize>) -> Self::Output

Performs the * operation.

impl<'a, T1: Clone + NumAssign> MulAssign<&'a T1> for Vector2<T1, T1>

fn mul_assign(&mut self, other: &T1)

Performs the *= operation.

impl<T1: Clone + NumAssign> MulAssign<T1> for Vector2<T1, T1>

fn mul_assign(&mut self, other: T1)

The function multiplies the values of self.x_ and self.y_ by the value of other.

Arguments:

• other: The parameter other is of type T, which means it can be any type that implements the Clone trait.

Example

use physdes::vector2::Vector2;
use std::ops::MulAssign;

let mut v = Vector2::new(1, 2);
v.mul_assign(3);
assert_eq!(v, Vector2::new(3, 6));

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

type Output = Vector2<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 Vector2<T1, T2>

fn neg(self) -> Self::Output

The neg function returns a new instance of the same type with the negated values of x_ and y_.

Example

use physdes::vector2::Vector2;
use std::ops::Neg;

let v = Vector2::new(1, 2);
assert_eq!(-v, Vector2::new(-1, -2));

type Output = Vector2<T1, T2>

The resulting type after applying the - operator.

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

fn eq(&self, other: &Vector2<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: Clone + Num> Rem<T1> for Vector2<T1, T1>

type Output = Vector2<T1, T1>

The resulting type after applying the % operator.

fn rem(self, other: T1) -> 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<&'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 Vector2<T1, T2>

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

The function subtracts the coordinates of two points and returns a new point.

Arguments:

• other: The other parameter is of the same type as self and represents the other value that you want to subtract from self.

Example

use physdes::vector2::Vector2;
use std::ops::Sub;

assert_eq!(Vector2::new(1, 2).sub(Vector2::new(3, 4)), Vector2::new(-2, -2));
assert_eq!(Vector2::new(3, 4).sub(Vector2::new(1, 2)), Vector2::new(2, 2));

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

fn sub_assign(&mut self, other: &Self)

Performs the -= operation.

impl<T: SubAssign + Clone + Num> SubAssign<Vector2<T, T>> for Polygon<T>

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

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: Clone + NumAssign, T2: Clone + NumAssign> SubAssign for Vector2<T1, T2>

fn sub_assign(&mut self, other: Self)

The function subtracts the values of another object from the values of the current object.

Arguments:

• other: The parameter “other” is of type Self, which means it is a reference to another instance of the same struct or class that the method is defined in. In this case, it is a reference to another instance of the struct or class that has the same fields as self (x_ and y_)

Example

use physdes::vector2::Vector2;
use std::ops::SubAssign;
let mut v = Vector2::new(1, 2);
let v2 = Vector2::new(3, 4);
v.sub_assign(v2);
assert_eq!(v, Vector2::new(-2, -2));

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

fn zero() -> Self

Returns the additive identity element of Self, 0.

fn is_zero(&self) -> bool

Returns true if self is equal to the additive identity.

fn set_zero(&mut self)

Sets self to the additive identity element of Self, 0.

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

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

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