#[repr(C)]pub struct Vector2<T> {
pub x: T,
pub y: T,
}
Expand description
Utility type for manipulating 2-dimensional vectors.
Vector2
is a simple type that defines
a mathematical vector with two coordinates (x and y).
It can be used to represent anything that has two dimensions: a size, a point, a velocity, etc.
The type parameter T is the type of the coordinates.
You generally don’t have to care about the generic form (Vector2<T>
), the most common
specializations have special type aliases:
The Vector2
type has a small and simple interface, its x and y members can be
accessed directly (there are no accessors like set_x()
, get_x()
) and it contains no
mathematical function like dot product, cross product, length, etc.
Usage example
let mut v1 = Vector2f::new(16.5, 24.0);
v1.x = 18.2;
let y = v1.y;
let v2 = v1 * 5.0;
let v3 = v1 + v2;
assert_ne!(v2, v3);
Note: for 3-dimensional vectors, see Vector3
.
Fields
x: T
X coordinate of the vector.
y: T
Y coordinate of the vector.
Implementations
sourceimpl<T> Vector2<T>
impl<T> Vector2<T>
sourcepub const fn new(x: T, y: T) -> Self
pub const fn new(x: T, y: T) -> Self
Creates a new vector from its coordinates.
Usage example
let v: Vector2<isize> = Vector2::new(6969, 6969);
sourcepub fn into_other<U>(self) -> Vector2<U>where
T: Into<U>,
pub fn into_other<U>(self) -> Vector2<U>where
T: Into<U>,
Lossless conversion into Vector2<U>
.
Usage example
let vu: Vector2<u16> = Vector2::new(6969, 6969);
let vi: Vector2<i32> = vu.into_other();
assert_eq!(vu.x, vi.x.try_into().unwrap());
assert_eq!(vu.y, vu.y.try_into().unwrap());
sourcepub fn try_into_other<U>(self) -> Result<Vector2<U>, T::Error>where
T: TryInto<U>,
pub fn try_into_other<U>(self) -> Result<Vector2<U>, T::Error>where
T: TryInto<U>,
Fallible conversion into Vector2<U>
Usage example
// Passing case
let vi: Vector2<i32> = Vector2::new(21, 21);
let vu: Vector2<u32> = vi.try_into_other().unwrap(); // or any other Result resolution
assert_eq!(u32::try_from(vi.x).unwrap(), vu.x);
assert_eq!(u32::try_from(vi.y).unwrap(), vu.y);
// Failing case
let vi: Vector2<i32> = Vector2::new(-21, -21);
let vu = vi.try_into_other::<u32>();
assert!(vu.is_err());
sourcepub fn as_other<U: 'static + Copy>(self) -> Vector2<U>where
T: AsPrimitive<U>,
pub fn as_other<U: 'static + Copy>(self) -> Vector2<U>where
T: AsPrimitive<U>,
Lossy conversion into Vector2<U>
Usage example
let vf: Vector2<f32> = Vector2::new(696969.6969, 6969.6969);
let vi: Vector2<i32> = vf.as_other();
assert_eq!(vf.x as i32, vi.x);
assert_eq!(vf.y as i32, vi.y);
sourceimpl<T: Mul<Output = T> + Add<Output = T> + Copy> Vector2<T>
impl<T: Mul<Output = T> + Add<Output = T> + Copy> Vector2<T>
sourcepub fn dot(self, rhs: Self) -> T
pub fn dot(self, rhs: Self) -> T
Dot product of two 2D vectors.
Usage example
let a = Vector2i::new(16, 64);
let b = Vector2i::new(2, 4);
assert_eq!(a.dot(b), 288);
sourcepub fn length_sq(self) -> T
pub fn length_sq(self) -> T
Square of vector’s length.
Usage example
let a = Vector2i::new(10, 9);
assert_eq!(a.length_sq(), 181);
sourceimpl<T: Mul<Output = T> + Sub<Output = T> + Copy> Vector2<T>
impl<T: Mul<Output = T> + Sub<Output = T> + Copy> Vector2<T>
sourcepub fn cross(self, rhs: Self) -> T
pub fn cross(self, rhs: Self) -> T
Z component of the cross product of two 2D vectors.
Usage example
let a = Vector2i::new(69, 420);
let b = Vector2i::new(21, 101);
assert_eq!(a.cross(b), -1851);
sourceimpl<T: Mul<Output = T>> Vector2<T>
impl<T: Mul<Output = T>> Vector2<T>
sourcepub fn cwise_mul(self, rhs: Self) -> Vector2<T>
pub fn cwise_mul(self, rhs: Self) -> Vector2<T>
Component-wise multiplication of self and rhs.
Usage example
let a = Vector2i::new(1, 1);
let b = Vector2i::new(2, 2);
assert_eq!(a.cwise_mul(b), Vector2i::new(2, 2));
sourceimpl<T: Div<Output = T>> Vector2<T>
impl<T: Div<Output = T>> Vector2<T>
sourcepub fn cwise_div(self, rhs: Self) -> Vector2<T>
pub fn cwise_div(self, rhs: Self) -> Vector2<T>
Component-wise division of self and rhs. Panics on divide by zero
Usage example
let a = Vector2i::new(69, 69);
let b = Vector2i::new(3, 3);
assert_eq!(a.cwise_div(b), Vector2i::new(23, 23));
sourceimpl<T: Div<Output = T> + CheckedDiv> Vector2<T>
impl<T: Div<Output = T> + CheckedDiv> Vector2<T>
sourcepub fn cwise_checked_div(self, rhs: Self) -> Option<Vector2<T>>
pub fn cwise_checked_div(self, rhs: Self) -> Option<Vector2<T>>
Component-wise checked division of self and rhs. Returns None on divide by zero
Usage example
// Passing case
let a = Vector2i::new(69, 69);
let b = Vector2i::new(3, 3);
assert_eq!(a.cwise_checked_div(b), Some(Vector2i::new(23, 23)));
// Failing case
let b = Vector2i::new(0, 3);
assert_eq!(a.cwise_checked_div(b), None);
sourceimpl<T: Neg<Output = T>> Vector2<T>
impl<T: Neg<Output = T>> Vector2<T>
sourcepub fn perpendicular(self) -> Vector2<T>
pub fn perpendicular(self) -> Vector2<T>
Returns a perpendicular vector rotated +90 degrees
Usage example
let a = Vector2i::new(21, -21);
assert_eq!(a.perpendicular(), Vector2i::new(21, 21));
sourceimpl<T: CheckedDiv> Vector2<T>
impl<T: CheckedDiv> Vector2<T>
sourcepub fn checked_div(self, rhs: T) -> Option<Vector2<T>>
pub fn checked_div(self, rhs: T) -> Option<Vector2<T>>
checked_div
for scalar division
Usage Example
// Passing case
let a = Vector2i::new(420, 69);
assert_eq!(a.checked_div(1000), Some(Vector2i::new(0, 0)));
// Failing case
assert_eq!(a.checked_div(0), None);
Trait Implementations
sourceimpl<T: AddAssign> AddAssign<Vector2<T>> for Vector2<T>
impl<T: AddAssign> AddAssign<Vector2<T>> for Vector2<T>
sourcefn add_assign(&mut self, rhs: Self)
fn add_assign(&mut self, rhs: Self)
Performs component wise addition assignment
Usage Example
let mut a = Vector2i::new(9, 10);
let b = Vector2i::new(10, 9);
a += b;
assert_eq!(a, Vector2i::new(19, 19));
sourceimpl<T: DivAssign + Copy> DivAssign<T> for Vector2<T>
impl<T: DivAssign + Copy> DivAssign<T> for Vector2<T>
sourcefn div_assign(&mut self, rhs: T)
fn div_assign(&mut self, rhs: T)
Performs scalar division assignment
Usage Example
let mut a = Vector2i::new(9, 10);
a /= 3;
assert_eq!(a, Vector2i::new(3, 3));
sourceimpl<T> From<(T, T)> for Vector2<T>
impl<T> From<(T, T)> for Vector2<T>
sourcefn from(src: (T, T)) -> Self
fn from(src: (T, T)) -> Self
Constructs a Vector2
from (x, y)
.
Usage example
let a: Vector2<u16> = Vector2::from((69u16, 420u16));
assert_eq!(a.x, 69u16);
assert_eq!(a.y, 420u16);
sourceimpl<T: MulAssign + Copy> MulAssign<T> for Vector2<T>
impl<T: MulAssign + Copy> MulAssign<T> for Vector2<T>
sourcefn mul_assign(&mut self, rhs: T)
fn mul_assign(&mut self, rhs: T)
Performs scalar multiplication assignment
Usage Example
let mut a = Vector2i::new(9, 10);
a *= 420;
assert_eq!(a, Vector2i::new(3780, 4200));
sourceimpl<T: Neg<Output = T>> Neg for Vector2<T>
impl<T: Neg<Output = T>> Neg for Vector2<T>
sourcefn neg(self) -> Self
fn neg(self) -> Self
Negates the vector
Usage Example
use std::ops::Neg;
let a = Vector2i::new(21, 21);
assert_eq!(a.neg(), Vector2i::new(-21, -21));
sourceimpl<T: PartialEq> PartialEq<Vector2<T>> for Vector2<T>
impl<T: PartialEq> PartialEq<Vector2<T>> for Vector2<T>
sourceimpl<T: Sub> Sub<Vector2<T>> for Vector2<T>
impl<T: Sub> Sub<Vector2<T>> for Vector2<T>
sourceimpl<T: SubAssign> SubAssign<Vector2<T>> for Vector2<T>
impl<T: SubAssign> SubAssign<Vector2<T>> for Vector2<T>
sourcefn sub_assign(&mut self, rhs: Self)
fn sub_assign(&mut self, rhs: Self)
Performs component wise subtraction assignment
Usage Example
let mut a = Vector2i::new(9, 10);
let b = Vector2i::new(10, 9);
a -= b;
assert_eq!(a, Vector2i::new(-1, 1));