Struct coord::vec2::Vec2

pub struct Vec2<T: VecItem> {
    pub x: T,
    pub y: T,
}

Fields

x: T

y: T

Methods

impl<T: VecItem> Vec2<T>

pub fn new(x: T, y: T) -> Self

Creates a new Vec2 from multiple components

pub fn elements(&self) -> [T; 2]

Returns the elements of the vector as an array

pub fn map<U: VecItem, F: Fn(T) -> U>(&self, f: F) -> Vec2<U>

Apply an operation to all elements of this vector, returning the result

pub fn convert_to<U: VecItem + From<T>>(&self) -> Vec2<U>

Trait Implementations

impl<T> VecNum for Vec2<T> where
    T: VecItem + Num, 

fn sum(&self) -> Self::Item

Calculates the sum of all components of the vector

fn product(&self) -> Self::Item

Calculates the product of all components of the vector

impl<T> VecInt for Vec2<T> where
    T: VecItem + Integer, 

fn div_euc(&self, other: Self) -> Self

Performs a Eucledian division (i.e: rounds towards negative infinity) operation upon the vector

impl<T> VecSigned for Vec2<T> where
    T: VecItem + Signed, 

fn snake_length(&self) -> Self::Item

Calculates the snake length (also known as 'manhattan distance') of the vector

impl<T> VecFloat for Vec2<T> where
    T: VecItem + Float, 

fn length(&self) -> Self::Item

Calculates the magnitude of the vector

fn norm(&self) -> Self

Calculates the normalized form of the vector (i.e: a vector with identical direction but a magnitude of 1)

fn floor(&self) -> Self

Rounds each element of the vector down to the nearest whole number

fn ceil(&self) -> Self

Rounds each element of the vector up to the nearest whole number

fn round(&self) -> Self

Rounds each element of the vector to the nearest whole number

impl<T: VecItem> Vector for Vec2<T>

type Item = T

impl<T: VecItem> From<[T; 2]> for Vec2<T>

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

Performs the conversion.

impl<T: VecItem> From<(T, T)> for Vec2<T>

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

Performs the conversion.

impl<T: VecItem + Display> Display for Vec2<T>

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

Formats the value using the given formatter.

impl<T: VecItem + Debug> Debug for Vec2<T>

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

Formats the value using the given formatter.

impl<T> Div<Vec2<T>> for Vec2<T> where
    T: VecItem + Div,
    T::Output: VecItem + Div, 

type Output = Vec2<T::Output>

The resulting type after applying the / operator.

fn div(self, other: Self) -> Vec2<T::Output>

Performs the / operation.

impl<T> Div<T> for Vec2<T> where
    T: VecItem + Div,
    T::Output: VecItem + Div, 

type Output = Vec2<T::Output>

The resulting type after applying the / operator.

fn div(self, other: T) -> Vec2<T::Output>

Performs the / operation.

impl<T> Sub<Vec2<T>> for Vec2<T> where
    T: VecItem + Sub,
    T::Output: VecItem + Sub, 

type Output = Vec2<T::Output>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<T> Sub<T> for Vec2<T> where
    T: VecItem + Sub,
    T::Output: VecItem + Sub, 

type Output = Vec2<T::Output>

The resulting type after applying the - operator.

fn sub(self, other: T) -> Vec2<T::Output>

Performs the - operation.

impl<T: PartialEq + VecItem> PartialEq<Vec2<T>> for Vec2<T>

fn eq(&self, other: &Vec2<T>) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Vec2<T>) -> bool

This method tests for !=.

impl<T: Eq + VecItem> Eq for Vec2<T>

impl<T> Add<Vec2<T>> for Vec2<T> where
    T: VecItem + Add,
    T::Output: VecItem + Add, 

type Output = Vec2<T::Output>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<T> Add<T> for Vec2<T> where
    T: VecItem + Add,
    T::Output: VecItem + Add, 

type Output = Vec2<T::Output>

The resulting type after applying the + operator.

fn add(self, other: T) -> Vec2<T::Output>

Performs the + operation.

impl<T> Mul<Vec2<T>> for Vec2<T> where
    T: VecItem + Mul,
    T::Output: VecItem + Mul, 

type Output = Vec2<T::Output>

The resulting type after applying the * operator.

fn mul(self, other: Self) -> Vec2<T::Output>

Performs the * operation.

impl<T> Mul<T> for Vec2<T> where
    T: VecItem + Mul,
    T::Output: VecItem + Mul, 

type Output = Vec2<T::Output>

The resulting type after applying the * operator.

fn mul(self, other: T) -> Vec2<T::Output>

Performs the * operation.

impl<T> AddAssign<Vec2<T>> for Vec2<T> where
    T: VecItem + Add<Output = T>, 

fn add_assign(&mut self, other: Self)

Performs the += operation.

impl<T> AddAssign<T> for Vec2<T> where
    T: VecItem + Add<Output = T>, 

fn add_assign(&mut self, other: T)

Performs the += operation.

impl<T> SubAssign<Vec2<T>> for Vec2<T> where
    T: VecItem + Sub<Output = T>, 

fn sub_assign(&mut self, other: Self)

Performs the -= operation.

impl<T> SubAssign<T> for Vec2<T> where
    T: VecItem + Sub<Output = T>, 

fn sub_assign(&mut self, other: T)

Performs the -= operation.

impl<T> MulAssign<Vec2<T>> for Vec2<T> where
    T: VecItem + Mul<Output = T>, 

fn mul_assign(&mut self, other: Self)

Performs the *= operation.

impl<T> MulAssign<T> for Vec2<T> where
    T: VecItem + Mul<Output = T>, 

fn mul_assign(&mut self, other: T)

Performs the *= operation.

impl<T> DivAssign<Vec2<T>> for Vec2<T> where
    T: VecItem + Div<Output = T>, 

fn div_assign(&mut self, other: Self)

Performs the /= operation.

impl<T> DivAssign<T> for Vec2<T> where
    T: VecItem + Div<Output = T>, 

fn div_assign(&mut self, other: T)

Performs the /= operation.

impl<T: Hash + VecItem> Hash for Vec2<T>

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, 

Feeds a slice of this type into the given [Hasher].

impl<T: Copy + VecItem> Copy for Vec2<T>

impl<T: Clone + VecItem> Clone for Vec2<T>

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

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<T: Default + VecItem> Default for Vec2<T>

fn default() -> Vec2<T>

Returns the "default value" for a type.