Struct axgeom::Vec2

#[must_use]
pub struct Vec2<N> {
    pub x: N,
    pub y: N,
}

A 2D vector.

Fields

x: N

y: N

Methods

impl<S: Copy + Neg<Output = S> + PartialOrd + Zero> Vec2<S>

pub fn abs(&self) -> Vec2<S>

pub fn rotate_90deg_right(&self) -> Vec2<S>

pub fn rotate_90deg_left(&self) -> Vec2<S>

pub fn split_into_components(&self) -> [Vec2<S>; 2]

impl<S: Add<Output = S> + Sub<Output = S> + PartialOrd + Copy> Vec2<S>

pub fn manhattan_dis(&self, other: Vec2<S>) -> S

impl<T: Copy + PartialOrd + Sub<Output = T> + Mul<Output = T> + Add<Output = T>> Vec2<T>

pub fn distance_squared_to_point(&self, point: Vec2<T>) -> T

If the point is outisde the rectangle, returns the squared distance from a point to a rectangle. If the point is inside the rectangle, it will return None.

impl<S: Mul<Output = S> + Div<Output = S> + Add<Output = S> + Copy> Vec2<S>

pub fn scale(&self, other: Vec2<S>) -> Vec2<S>

pub fn inv_scale(&self, other: Vec2<S>) -> Vec2<S>

pub fn magnitude2(&self) -> S

pub fn dot(&self, other: Vec2<S>) -> S

impl<S: Float> Vec2<S>

pub fn truncate_at(&self, mag: S) -> Vec2<S>

pub fn normalize_to(&self, mag: S) -> Vec2<S>

pub fn magnitude(&self) -> S

impl<B: Copy> Vec2<B>

pub fn inner_as<A: PrimitiveFrom<B>>(&self) -> Vec2<A>

impl<B> Vec2<B>

pub fn get_axis(&self, axis: impl Axis) -> &B

Get the range of one axis.

pub fn get_axis_mut(&mut self, axis: impl Axis) -> &mut B

Get the mutable range of one axis.

pub fn inner_into<A: From<B>>(self) -> Vec2<A>

pub fn inner_try_into<A: TryFrom<B>>(self) -> Result<Vec2<A>, A::Error>

Trait Implementations

impl<S: Add<Output = S> + Copy> Add<Vec2<S>> for Vec2<S>

type Output = Self

The resulting type after applying the + operator.

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

Performs the + operation.

impl<S: AddAssign<S> + Copy> AddAssign<Vec2<S>> for Vec2<S>

fn add_assign(&mut self, rhs: Self)

Performs the += operation.

impl<B> AsMut<[B; 2]> for Vec2<B>

fn as_mut(&mut self) -> &mut [B; 2]

Performs the conversion.

impl<B> AsRef<[B; 2]> for Vec2<B>

fn as_ref(&self) -> &[B; 2]

Performs the conversion.

impl<N: Float> AsRef<Vec2<N>> for Vec2<NotNan<N>>

fn as_ref(&self) -> &Vec2<N>

Performs the conversion.

impl<N: Clone> Clone for Vec2<N>

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

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<N: Copy> Copy for Vec2<N>

impl<N: Debug> Debug for Vec2<N>

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

Formats the value using the given formatter.

impl<S: Div<Output = S> + Copy> Div<S> for Vec2<S>

type Output = Self

The resulting type after applying the / operator.

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

Performs the / operation.

impl<S: DivAssign<S> + Copy> DivAssign<S> for Vec2<S>

fn div_assign(&mut self, scalar: S)

Performs the /= operation.

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

impl<'a, B> From<&'a [B; 2]> for &'a Vec2<B>

fn from(a: &'a [B; 2]) -> Self

Performs the conversion.

impl<'a, B> From<&'a mut [B; 2]> for &'a mut Vec2<B>

fn from(a: &'a mut [B; 2]) -> Self

Performs the conversion.

impl<B> From<[B; 2]> for Vec2<B>

fn from(a: [B; 2]) -> Self

Performs the conversion.

impl<N: Hash> Hash for Vec2<N>

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<B> Into<[B; 2]> for Vec2<B>

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

Performs the conversion.

impl<S: Mul<Output = S> + Copy> Mul<S> for Vec2<S>

type Output = Self

The resulting type after applying the * operator.

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

Performs the * operation.

impl<S: MulAssign<S> + Copy> MulAssign<S> for Vec2<S>

fn mul_assign(&mut self, scalar: S)

Performs the *= operation.

impl<S: Neg<Output = S>> Neg for Vec2<S>

type Output = Vec2<S>

The resulting type after applying the - operator.

fn neg(self) -> Vec2<S>

Performs the unary - operation.

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

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

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

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

This method tests for !=.

impl<N> StructuralEq for Vec2<N>

impl<N> StructuralPartialEq for Vec2<N>

impl<S: Sub<Output = S> + Copy> Sub<Vec2<S>> for Vec2<S>

type Output = Self

The resulting type after applying the - operator.

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

Performs the - operation.

impl<S: SubAssign<S> + Copy> SubAssign<Vec2<S>> for Vec2<S>

fn sub_assign(&mut self, rhs: Self)

Performs the -= operation.

impl<S: Zero + Eq + Copy> Zero for Vec2<S>

fn zero() -> Vec2<S>

Returns the additive identity element of Self, 0. # Purity

fn is_zero(&self) -> bool

Returns true if self is equal to the additive identity.

fn set_zero(&mut self)

Sets self to the additive identity element of Self, 0.