Struct mathie::Vec2

#[repr(C)]
pub struct Vec2<T: Number>(_);

Implementations

impl<N: Number> Vec2<N>

pub const fn new(x: N, y: N) -> Vec2<N>

Creates a new Vec2D with a unit value.

pub const fn split(v: N) -> Vec2<N>

pub fn zero() -> Vec2<N>

pub fn one() -> Vec2<N>

pub fn cast<NO: Number>(self) -> Vec2<NO>

Tries to cast the values to different number type.

Examples

   use mathie::Vec2;
   assert_eq!(Vec2::<f32>::new(250.5, 250.5).cast(), Vec2::<u32>::new(250, 250));
   assert_eq!(Vec2::<f32>::new(0.5, 0.5).cast(), Vec2::<u32>::new(0, 0));

pub fn try_cast<NO: Number>(self) -> Option<Vec2<NO>>

Same as Self::cast but returns None if the cast failed.

pub fn any(self, func: impl Fn(N) -> bool) -> bool

Checks if any of the values match a condition.

Examples

let v0 = mathie::Vec2::new(2.0, 1.0);
assert!(v0.any(|v| v == 1.0))

pub fn all(self, func: impl Fn(N) -> bool) -> bool

Checks if all of the values match a condition.

Examples

let v0 = mathie::Vec2::new(2.0, 1.0);
assert!(!v0.all(|v| v == 1.0))

pub fn map<NO: Number>(self, func: impl Fn(N) -> NO) -> Vec2<NO>

Maps both of the values to the function result.

Examples

let v0 = mathie::Vec2::new(1.0, 1.0);
assert_eq!(v0.map(|v| v + 2.0), mathie::Vec2::new(1.0 + 2.0, 1.0 + 2.0))

pub fn map_x(self, func: impl FnOnce(N) -> N) -> Vec2<N>

Maps the X value to the function result.

Examples

let v0 = mathie::Vec2::new(1.0, 1.0);
assert_eq!(v0.map_x(|v| v + 2.0), mathie::Vec2::new(1.0 + 2.0, 1.0))

pub fn map_y(self, func: impl FnOnce(N) -> N) -> Vec2<N>

Maps the Y value to the function result.

Examples

let v0 = mathie::Vec2::new(1.0, 1.0);
assert_eq!(v0.map_y(|v| v + 2.0), mathie::Vec2::new(1.0, 1.0 + 2.0))

pub fn move_x(self, other: Vec2<N>) -> Vec2<N>

Moves the x value from the other value and keeps its original y

Arguments

• other: The vector to pull x from.

returns: Vec2D<N, U>

Examples

let v0 = mathie::Vec2::new(1.0, 1.0);
let other = mathie::Vec2::new(0.0, 0.0);
assert_eq!(v0.move_x(other), mathie::Vec2::new(0.0, 1.0))

pub fn move_y(self, other: Vec2<N>) -> Vec2<N>

Moves the y value from the other value and keeps its original x

Arguments

• other: The vector to pull y from.

returns: Vec2D<N, U>

Examples

let v0 = mathie::Vec2::new(1.0, 1.0);
let other = mathie::Vec2::new(0.0, 0.0);
assert_eq!(v0.move_y(other), mathie::Vec2::new(1.0, 0.0))

pub fn add_xy(self) -> N

Adds both of the values together.

Examples

let v0 = mathie::Vec2::new(1.0, 1.0);
assert_eq!(v0.add_xy(), 2.0)

pub fn sub_xy(self) -> N

Subtracts both of the values together.

Examples

let v0 = mathie::Vec2::new(1.0, 2.0);
assert_eq!(v0.sub_xy(), -1.0)

pub fn mul_xy(self) -> N

Multiplies both of the values together.

Examples

let v0 = mathie::Vec2::new(2.0, 2.0);
assert_eq!(v0.mul_xy(), 4.0)

pub fn div_xy(self) -> N

Divides x/y of the values together.

Examples

let v0 = mathie::Vec2::new(2.0, 4.0);
assert_eq!(v0.div_xy(), 0.5)

pub fn div_yx(self) -> N

Divides y/x of the values together.

Examples

let v0 = mathie::Vec2::new(2.0, 4.0);
assert_eq!(v0.div_yx(), 2.0)

pub fn x(self) -> N

Returns the X value.

pub fn y(self) -> N

Returns the Y value.

pub fn xy(self) -> Vec2<N>

Does nothing.

pub fn yx(self) -> Vec2<N>

Returns X as Y and Y as X. (Basically inverts the values.)

impl<N: Number + Ord> Vec2<N>

pub fn min_val(self) -> N

Gets the smallest coordinate of the Vector.

Examples

let v0 = mathie::Vec2::new(1, 2);
assert_eq!(v0.min_val(), 1)

pub fn max_val(self) -> N

Gets the biggest coordinate of the Vector.

Examples

let v0 = mathie::Vec2::new(1, 2);
assert_eq!(v0.max_val(), 2)

pub fn min(self, other: Vec2<N>) -> Vec2<N>

Gets the smallest coordinates of both of the vectors.

Examples

let v0 = mathie::Vec2::new(1, 2);
let other = mathie::Vec2::new(5, 1);
assert_eq!(v0.min(other), mathie::Vec2::new(1, 1))

pub fn max(self, other: Vec2<N>) -> Vec2<N>

Gets the biggest coordinates of both of the vectors.

Examples

let v0 = mathie::Vec2::new(1, 2);
let other = mathie::Vec2::new(5, 1);
assert_eq!(v0.max(other), mathie::Vec2::new(5, 2))

impl<F: Number + Float> Vec2<F>

pub fn norm(self) -> Vec2<F>

Gets the normalized vector from this vector. Meaning a vector the length of 1

Examples

use mathie::Vec2;
let value = Vec2::new(4.0, 3.0);
assert_eq!(value.norm(), Vec2::new(4.0 / 5.0, 3.0 / 5.0));
assert_eq!(value.norm().hypot(), 1.0);

let value = Vec2::new(69.0, 420.0);
assert_eq!(value.norm().hypot(), 1.0);

pub fn lerp(self, other: Vec2<F>, t: F) -> Vec2<F>

Linearly interpolated the value of self and other by the value t where 0 is self and 1 is other.

Arguments

• other: The target value.
• t: A value which says where the value should be.

returns: Vec2D<N, U>

Examples

let v0 = mathie::Vec2::new(1.0, 1.0);
let other = mathie::Vec2::new(2.0, 2.0);
assert_eq!(v0.lerp(other, 0.0), v0);
assert_eq!(v0.lerp(other, 1.0), other);
assert_eq!(v0.lerp(other, 0.5), mathie::Vec2::new(1.5, 1.5));

pub fn minf_val(self) -> F

The same as Self::min_val but for floating-point numbers.

pub fn maxf_val(self) -> F

The same as Self::max_val but for floating-point numbers.

pub fn minf(self, other: Vec2<F>) -> Vec2<F>

The same as Self::min but for floating-point numbers.

pub fn maxf(self, other: Vec2<F>) -> Vec2<F>

The same as Self::max but for floating-point numbers.

pub fn hypot(self) -> F

Gets the hypotenuse of the vector. In other terms the length.

Trait Implementations

impl<T: Number + Add> Add<T> for Vec2<T>

type Output = Vec2<T>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<T: Number> Add<Vec2<T>> for Rect<T>

type Output = Rect<T>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<T: Number + Add> Add<Vec2<T>> for Vec2<T>

type Output = Vec2<T>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<T: Number + Add> AddAssign<T> for Vec2<T>

fn add_assign(&mut self, rhs: T)

Performs the += operation.

impl<T: Number> AddAssign<Vec2<T>> for Rect<T>

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

Performs the += operation.

impl<T: Number + Add> AddAssign<Vec2<T>> for Vec2<T>

fn add_assign(&mut self, rhs: Self)

Performs the += operation.

impl<T: Clone + Number> 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: Debug + Number> Debug for Vec2<T>

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

Formats the value using the given formatter.

impl<T: Number + Div> Div<T> for Vec2<T>

type Output = Vec2<T>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<T: Number> Div<Vec2<T>> for Rect<T>

type Output = Rect<T>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<T: Number + Div> Div<Vec2<T>> for Vec2<T>

type Output = Vec2<T>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<T: Number + Div> DivAssign<T> for Vec2<T>

fn div_assign(&mut self, rhs: T)

Performs the /= operation.

impl<T: Number> DivAssign<Vec2<T>> for Rect<T>

fn div_assign(&mut self, rhs: Vec2<T>)

Performs the /= operation.

impl<T: Number + Div> DivAssign<Vec2<T>> for Vec2<T>

fn div_assign(&mut self, rhs: Self)

Performs the /= operation.

impl<N: Number> From<[N; 2]> for Vec2<N>

fn from([x, y]: [N; 2]) -> Self

Converts to this type from the input type.

impl<N: Number> From<(N, N)> for Vec2<N>

fn from((x, y): (N, N)) -> Self

Converts to this type from the input type.

impl<N: Number> From<Vec2<N>> for [N; 2]

fn from(vec: Vec2<N>) -> Self

Converts to this type from the input type.

impl<N: Number> From<Vec2<N>> for (N, N)

fn from(vec: Vec2<N>) -> Self

Converts to this type from the input type.

impl<T: Number + Mul> Mul<T> for Vec2<T>

type Output = Vec2<T>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<T: Number> Mul<Vec2<T>> for Rect<T>

type Output = Rect<T>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<T: Number + Mul> Mul<Vec2<T>> for Vec2<T>

type Output = Vec2<T>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<T: Number + Mul> MulAssign<T> for Vec2<T>

fn mul_assign(&mut self, rhs: T)

Performs the *= operation.

impl<T: Number> MulAssign<Vec2<T>> for Rect<T>

fn mul_assign(&mut self, rhs: Vec2<T>)

Performs the *= operation.

impl<T: Number + Mul> MulAssign<Vec2<T>> for Vec2<T>

fn mul_assign(&mut self, rhs: Self)

Performs the *= operation.

impl<N: Number + Neg<Output = N>> Neg for Vec2<N>

type Output = Vec2<N>

The resulting type after applying the - operator.

fn neg(self) -> Self::Output

Performs the unary - operation.

impl<N: Number + Ord> Ord for Vec2<N>

fn cmp(&self, other: &Self) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Selfwhere
    Self: PartialOrd<Self>,

Restrict a value to a certain interval.

impl<N: Number> PartialEq<Vec2<N>> for Vec2<N>

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

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

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<N: Number> PartialOrd<Vec2<N>> for Vec2<N>

fn partial_cmp(&self, other: &Self) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, other: &Rhs) -> bool

This method tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

This method tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl<T: Number + Rem> Rem<T> for Vec2<T>

type Output = Vec2<T>

The resulting type after applying the % operator.

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

Performs the % operation.

impl<T: Number> Rem<Vec2<T>> for Rect<T>

type Output = Rect<T>

The resulting type after applying the % operator.

fn rem(self, rhs: Vec2<T>) -> Self::Output

Performs the % operation.

impl<T: Number + Rem> Rem<Vec2<T>> for Vec2<T>

type Output = Vec2<T>

The resulting type after applying the % operator.

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

Performs the % operation.

impl<T: Number + Rem> RemAssign<T> for Vec2<T>

fn rem_assign(&mut self, rhs: T)

Performs the %= operation.

impl<T: Number> RemAssign<Vec2<T>> for Rect<T>

fn rem_assign(&mut self, rhs: Vec2<T>)

Performs the %= operation.

impl<T: Number + Rem> RemAssign<Vec2<T>> for Vec2<T>

fn rem_assign(&mut self, rhs: Self)

Performs the %= operation.

impl<T: Number + Sub> Sub<T> for Vec2<T>

type Output = Vec2<T>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<T: Number> Sub<Vec2<T>> for Rect<T>

type Output = Rect<T>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<T: Number + Sub> Sub<Vec2<T>> for Vec2<T>

type Output = Vec2<T>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<T: Number + Sub> SubAssign<T> for Vec2<T>

fn sub_assign(&mut self, rhs: T)

Performs the -= operation.

impl<T: Number> SubAssign<Vec2<T>> for Rect<T>

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

Performs the -= operation.

impl<T: Number + Sub> SubAssign<Vec2<T>> for Vec2<T>

fn sub_assign(&mut self, rhs: Self)

Performs the -= operation.

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

impl<N: Number> Eq for Vec2<N>