Struct mathie::Vec2D

#[repr(C)]
pub struct Vec2D<T: Number, U: Unit = ()> { /* private fields */ }

Implementations

impl<T: Number> Vec2D<T>

pub const fn new_any(x: T, y: T) -> Vec2D<T>

Creates a new Vec2D with an unknown unit.

pub fn zero() -> Vec2D<T>

pub fn one() -> Vec2D<T>

impl<T: Number, U: Unit + Default> Vec2D<T, U>

pub fn new(x: T, y: T) -> Vec2D<T, U>

Creates a new Vec2D with the default unit value.

impl<N: Number, U: Unit> Vec2D<N, U>

pub const fn new_u(x: N, y: N, unit: U) -> Vec2D<N, U>

Creates a new Vec2D with a unit value.

pub fn cast<NO: Number>(self) -> Vec2D<NO, U>

Tries to cast the values to different number type.

Examples

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

pub fn try_cast<NO: Number>(self) -> Option<Vec2D<NO, U>>

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

pub fn convert<UO: UnitCompatibility<N, U> + Default>(self) -> Vec2D<N, UO>

Same as Self::try_convert but panics if the conversion failed.

pub fn try_convert<UO: UnitCompatibility<N, U> + Default>(
    self
) -> Option<Vec2D<N, UO>>

Converts the value to a different unit type by using UnitCompatibility::convert_pos2. This is Self::convert_u but it uses the target unit default value for easier usage.

Arguments

returns: Option<Vec2D<N, UO>>

Examples

   use mathie::unit::metric::Centimeter;

   let v0 = mathie::Vec2D::<f32, Centimeter>::new(250.0, 250.0);
   let v1 = v0.try_convert_u(()).unwrap();
   assert_eq!(v1, mathie::Vec2D::new(2.5, 2.5));

See also

Self::convert

pub fn convert_u<UO: UnitCompatibility<N, U>>(self, to: UO) -> Vec2D<N, UO>

Same as Self::try_convert_u but panics if the conversion failed.

pub fn try_convert_u<UO: UnitCompatibility<N, U>>(
    self,
    to: UO
) -> Option<Vec2D<N, UO>>

Converts the value to a different unit type by using UnitCompatibility::convert_pos2

Arguments

• to: The target unit to convert to.

returns: Option<Vec2D<N, UO>>

Examples

   use mathie::unit::metric::Centimeter;

   let v0 = mathie::Vec2D::<f32, Centimeter>::new(250.0, 250.0);
   let v1 = v0.try_convert_u(()).unwrap();
   assert_eq!(v1, mathie::Vec2D::new(2.5, 2.5));

See also

Self::convert

pub fn any_unit(self) -> Vec2D<N, ()>

Clears the unit value and converts this to an un-united vector.

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

Checks if any of the values match a condition.

Examples

let v0 = mathie::Vec2D::new_any(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::Vec2D::new_any(2.0, 1.0);
assert!(!v0.all(|v| v == 1.0))

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

Maps both of the values to the function result.

Examples

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

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

Maps the X value to the function result.

Examples

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

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

Maps the Y value to the function result.

Examples

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

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

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::Vec2D::new_any(1.0, 1.0);
let other = mathie::Vec2D::new_any(0.0, 0.0);
assert_eq!(v0.move_x(other), mathie::Vec2D::new_any(0.0, 1.0))

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

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::Vec2D::new_any(1.0, 1.0);
let other = mathie::Vec2D::new_any(0.0, 0.0);
assert_eq!(v0.move_y(other), mathie::Vec2D::new_any(1.0, 0.0))

pub fn add_vals(self) -> N

Adds both of the values together.

Examples

let v0 = mathie::Vec2D::new_any(1.0, 1.0);
assert_eq!(v0.add_vals(), 2.0)

pub fn sub_vals(self) -> N

Subtracts both of the values together.

Examples

let v0 = mathie::Vec2D::new_any(1.0, 2.0);
assert_eq!(v0.sub_vals(), -1.0)

pub fn mul_vals(self) -> N

Multiplies both of the values together.

Examples

let v0 = mathie::Vec2D::new_any(2.0, 2.0);
assert_eq!(v0.mul_vals(), 4.0)

pub fn div_vals(self) -> N

Divides both of the values together.

Examples

let v0 = mathie::Vec2D::new_any(2.0, 4.0);
assert_eq!(v0.div_vals(), 0.5)

pub fn unit(self) -> U

Returns the unit of this vector.

pub fn x(self) -> N

Returns the X value.

pub fn y(self) -> N

Returns the Y value.

pub fn xy(self) -> Vec2D<N, U>

Does nothing.

pub fn yx(self) -> Vec2D<N, U>

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

impl<N: Number + Ord, U: Unit> Vec2D<N, U>

pub fn min(self) -> N

Gets the smallest value of the Vector.

Examples

let v0 = mathie::Vec2D::new_any(1, 2);
assert_eq!(v0.min(), 1)

pub fn max(self) -> N

Gets the biggest value of the Vector.

Examples

let v0 = mathie::Vec2D::new_any(1, 2);
assert_eq!(v0.max(), 2)

impl<N: Number + Float, U: Unit> Vec2D<N, U>

pub fn normalize(self) -> Vec2D<N, U>

Gets the normalized vector from this vector.

pub fn lerp(self, other: Vec2D<N, U>, t: N) -> Vec2D<N, U>

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::Vec2D::new_any(1.0, 1.0);
let other = mathie::Vec2D::new_any(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::Vec2D::new_any(1.5, 1.5));

pub fn minf(self) -> N

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

pub fn maxf(self) -> N

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

pub fn hypot(self) -> N

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

Trait Implementations

impl<T: Number + Add, U: Unit> Add<T> for Vec2D<T, U>

type Output = Vec2D<T, U>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<T: Number, U: Unit> Add<Vec2D<T, U>> for Rect<T, U>

type Output = Rect<T, U>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<T: Number + Add, U: Unit> Add<Vec2D<T, U>> for Vec2D<T, U>

type Output = Vec2D<T, U>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<T: Number + Add, U: Unit> AddAssign<T> for Vec2D<T, U>

fn add_assign(&mut self, rhs: T)

Performs the += operation.

impl<T: Number, U: Unit> AddAssign<Vec2D<T, U>> for Rect<T, U>

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

Performs the += operation.

impl<T: Number + Add, U: Unit> AddAssign<Vec2D<T, U>> for Vec2D<T, U>

fn add_assign(&mut self, rhs: Self)

Performs the += operation.

impl<T: Clone + Number, U: Clone + Unit> Clone for Vec2D<T, U>

fn clone(&self) -> Vec2D<T, U>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<T: Debug + Number, U: Debug + Unit> Debug for Vec2D<T, U>

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

Formats the value using the given formatter.

impl<T: Number + Div, U: Unit> Div<T> for Vec2D<T, U>

type Output = Vec2D<T, U>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<T: Number, U: Unit> Div<Vec2D<T, U>> for Rect<T, U>

type Output = Rect<T, U>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<T: Number + Div, U: Unit> Div<Vec2D<T, U>> for Vec2D<T, U>

type Output = Vec2D<T, U>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<T: Number + Div, U: Unit> DivAssign<T> for Vec2D<T, U>

fn div_assign(&mut self, rhs: T)

Performs the /= operation.

impl<T: Number, U: Unit> DivAssign<Vec2D<T, U>> for Rect<T, U>

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

Performs the /= operation.

impl<T: Number + Div, U: Unit> DivAssign<Vec2D<T, U>> for Vec2D<T, U>

fn div_assign(&mut self, rhs: Self)

Performs the /= operation.

impl<N: Number, U: Unit> Into<[N; 2]> for Vec2D<N, U>

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

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

impl<N: Number, U: Unit> Into<(N, N)> for Vec2D<N, U>

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

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

impl<T: Number + Mul, U: Unit> Mul<T> for Vec2D<T, U>

type Output = Vec2D<T, U>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<T: Number, U: Unit> Mul<Vec2D<T, U>> for Rect<T, U>

type Output = Rect<T, U>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<T: Number + Mul, U: Unit> Mul<Vec2D<T, U>> for Vec2D<T, U>

type Output = Vec2D<T, U>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<T: Number + Mul, U: Unit> MulAssign<T> for Vec2D<T, U>

fn mul_assign(&mut self, rhs: T)

Performs the *= operation.

impl<T: Number, U: Unit> MulAssign<Vec2D<T, U>> for Rect<T, U>

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

Performs the *= operation.

impl<T: Number + Mul, U: Unit> MulAssign<Vec2D<T, U>> for Vec2D<T, U>

fn mul_assign(&mut self, rhs: Self)

Performs the *= operation.

impl<N: Number + Neg<Output = N>, U: Unit> Neg for Vec2D<N, U>

type Output = Vec2D<N, U>

The resulting type after applying the - operator.

fn neg(self) -> Self::Output

Performs the unary - operation.

impl<N: Number + Ord, U: Unit> Ord for Vec2D<N, U>

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) -> Self where
    Self: PartialOrd<Self>, 

Restrict a value to a certain interval.

impl<N: Number, U: Unit> PartialEq<Vec2D<N, U>> for Vec2D<N, U>

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 !=.

impl<N: Number, U: Unit> PartialOrd<Vec2D<N, U>> for Vec2D<N, U>

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, U: Unit> Rem<T> for Vec2D<T, U>

type Output = Vec2D<T, U>

The resulting type after applying the % operator.

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

Performs the % operation.

impl<T: Number, U: Unit> Rem<Vec2D<T, U>> for Rect<T, U>

type Output = Rect<T, U>

The resulting type after applying the % operator.

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

Performs the % operation.

impl<T: Number + Rem, U: Unit> Rem<Vec2D<T, U>> for Vec2D<T, U>

type Output = Vec2D<T, U>

The resulting type after applying the % operator.

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

Performs the % operation.

impl<T: Number + Rem, U: Unit> RemAssign<T> for Vec2D<T, U>

fn rem_assign(&mut self, rhs: T)

Performs the %= operation.

impl<T: Number, U: Unit> RemAssign<Vec2D<T, U>> for Rect<T, U>

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

Performs the %= operation.

impl<T: Number + Rem, U: Unit> RemAssign<Vec2D<T, U>> for Vec2D<T, U>

fn rem_assign(&mut self, rhs: Self)

Performs the %= operation.

impl<T: Number + Sub, U: Unit> Sub<T> for Vec2D<T, U>

type Output = Vec2D<T, U>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<T: Number, U: Unit> Sub<Vec2D<T, U>> for Rect<T, U>

type Output = Rect<T, U>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<T: Number + Sub, U: Unit> Sub<Vec2D<T, U>> for Vec2D<T, U>

type Output = Vec2D<T, U>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<T: Number + Sub, U: Unit> SubAssign<T> for Vec2D<T, U>

fn sub_assign(&mut self, rhs: T)

Performs the -= operation.

impl<T: Number, U: Unit> SubAssign<Vec2D<T, U>> for Rect<T, U>

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

Performs the -= operation.

impl<T: Number + Sub, U: Unit> SubAssign<Vec2D<T, U>> for Vec2D<T, U>

fn sub_assign(&mut self, rhs: Self)

Performs the -= operation.

impl<T: Copy + Number, U: Copy + Unit> Copy for Vec2D<T, U>

impl<N: Number, U: Unit> Eq for Vec2D<N, U>