Struct Vector2

pub struct Vector2<T>(pub T, pub T);

Representation of a mathematical vector e.g. a position or velocity

Tuple Fields

0: T

1: T

Implementations

impl<T: Float> Vector2<T>

pub fn unit_vector(direction: T) -> Self

Creates a new unit vector in a specific direction

pub fn normalise(self) -> Self

Normalises the vector

pub fn length(self) -> T

Returns the magnitude/length of the vector

pub fn length_squared(self) -> T

Returns the magnitude/length of the vector squared

pub fn direction(self) -> T

Returns direction the vector is pointing

pub fn direction_to(self, other: Self) -> T

Returns direction towards another vector

pub fn distance_to(self, other: Self) -> T

Returns the distance betweens two vectors

pub fn distance_to_squared(self, other: Self) -> T

Returns the distance betweens two vectors

pub fn is_any_nan(&self) -> bool

Returns true if either component is NaN.

pub fn is_any_infinite(&self) -> bool

Returns true if either component is positive or negative infinity.

pub fn is_all_finite(&self) -> bool

Returns true if both components are neither infinite nor NaN.

pub fn is_all_normal(&self) -> bool

Returns true if both components are neither zero, infinite, subnormal nor NaN.

impl<T> Vector2<T>

pub fn normal(self) -> Self

where T: Neg<Output = T>,

Returns the normal vector (aka. hat vector) of this vector i.e. a perpendicular vector

Not to be confused with normalise which returns a unit vector

Defined as (-y, x)

pub fn dot(self, other: Self) -> <<T as Mul>::Output as Add>::Output

where T: Mul, <T as Mul>::Output: Add,

Returns the dot product of two vectors

pub fn det(self, other: Self) -> <<T as Mul>::Output as Sub>::Output

where T: Mul, <T as Mul>::Output: Sub,

Returns the determinant of two vectors

Trait Implementations

impl<T: Add> Add for Vector2<T>

type Output = Vector2<<T as Add>::Output>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<T: AddAssign> AddAssign for Vector2<T>

fn add_assign(&mut self, rhs: Self)

Performs the += operation.

impl<T: Clone> Clone for Vector2<T>

fn clone(&self) -> Vector2<T>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<T: Debug> Debug for Vector2<T>

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

Formats the value using the given formatter.

impl<T: Default> Default for Vector2<T>

fn default() -> Vector2<T>

Returns the “default value” for a type.

impl<T: Div + Copy> Div<T> for Vector2<T>

type Output = Vector2<<T as Div>::Output>

The resulting type after applying the / operator.

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

Performs the / operation.

impl Div<Vector2<f32>> for f32

type Output = Vector2<f32>

The resulting type after applying the / operator.

fn div(self, rhs: Vector2<f32>) -> Vector2<f32>

Performs the / operation.

impl Div<Vector2<f64>> for f64

type Output = Vector2<f64>

The resulting type after applying the / operator.

fn div(self, rhs: Vector2<f64>) -> Vector2<f64>

Performs the / operation.

impl<T: DivAssign + Copy> DivAssign<T> for Vector2<T>

fn div_assign(&mut self, rhs: T)

Performs the /= operation.

impl<T: Copy> From<[T; 2]> for Vector2<T>

fn from(array: [T; 2]) -> Self

Converts to this type from the input type.

impl<T> From<(T, T)> for Vector2<T>

fn from(tuple: (T, T)) -> Self

Converts to this type from the input type.

impl<T> Into<[T; 2]> for Vector2<T>

fn into(self) -> [T; 2]

Converts this type into the (usually inferred) input type.

impl<T> Into<(T, T)> for Vector2<T>

fn into(self) -> (T, T)

Converts this type into the (usually inferred) input type.

impl<T: Mul + Copy> Mul<T> for Vector2<T>

type Output = Vector2<<T as Mul>::Output>

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul<Vector2<f32>> for f32

type Output = Vector2<f32>

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul<Vector2<f64>> for f64

type Output = Vector2<f64>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<T: MulAssign + Copy> MulAssign<T> for Vector2<T>

fn mul_assign(&mut self, rhs: T)

Performs the *= operation.

impl<T: Neg> Neg for Vector2<T>

type Output = Vector2<<T as Neg>::Output>

The resulting type after applying the - operator.

fn neg(self) -> Self::Output

Performs the unary - operation.

impl<T: PartialEq> PartialEq for Vector2<T>

fn eq(&self, other: &Vector2<T>) -> 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<T: Sub> Sub for Vector2<T>

type Output = Vector2<<T as Sub>::Output>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<T: SubAssign> SubAssign for Vector2<T>

fn sub_assign(&mut self, rhs: Self)

Performs the -= operation.

impl<T: Copy> Copy for Vector2<T>

impl<T: Eq> Eq for Vector2<T>

impl<T> StructuralPartialEq for Vector2<T>