Struct Vec2 

#[repr(C)]
pub struct Vec2<F>
where
    F: Float,
{
    pub x: F,
    pub y: F,
}

2D Euclidian vector with X and Y components.

Fields

x: F

y: F

Implementations

impl<F> Vec2<F>

where F: Float,

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

Creates new vector.

pub fn split(&self) -> (F, F)

Splits vector into X and Y components.

pub fn combine(xy: (F, F)) -> Self

Combines tuple into vector.

pub fn into_basis(self) -> (Self, Self)

Split vector into it’s basic vectors i, j.

pub fn dot(&self, other: Self) -> F

Computes dot product between two vectors.

pub fn dot_normalized(&self, other: Self) -> F

Computes dot product between two normalized copies of the vectors.

pub fn scale(&mut self, factor: F)

Scales all of the components by factor.

pub fn magnitude(&self) -> F

Computes the magnitude of the vector.

pub fn sqrt_magnitude(&self) -> F

Computes the squared magnitude of the vector.

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

Computes the distance between two vectors.

pub fn normalized(&self) -> Self

Returns the normalized version of the vector.

pub fn normalize(&mut self)

Normalizes the vector, preserving direction but reducing its magnitude to 1.

Trait Implementations

impl<F> Add for Vec2<F>

where F: Float,

type Output = Vec2<F>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<F> AddAssign for Vec2<F>

where F: Float,

fn add_assign(&mut self, rhs: Self)

Performs the += operation.

impl<F> Clone for Vec2<F>

where F: Float + Clone,

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

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<F> Copy for Vec2<F>

where F: Float + Copy,

impl<F> Debug for Vec2<F>

where F: Float + Debug,

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

Formats the value using the given formatter.

impl<F> Default for Vec2<F>

where F: Float + Default,

fn default() -> Vec2<F>

Returns the “default value” for a type.

impl<F> Div<F> for Vec2<F>

where F: Float,

type Output = Vec2<F>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<F> DivAssign<F> for Vec2<F>

where F: Float,

fn div_assign(&mut self, rhs: F)

Performs the /= operation.

impl<F> From<Complex<F>> for Vec2<F>

where F: Float,

fn from(z: Complex<F>) -> Self

Converts to this type from the input type.

impl<F> From<Vec2<F>> for Complex<F>

where F: Float,

fn from(v: Vec2<F>) -> Self

Converts to this type from the input type.

impl<F> Mul<F> for Vec2<F>

where F: Float,

type Output = Vec2<F>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<F> MulAssign<F> for Vec2<F>

where F: Float,

fn mul_assign(&mut self, rhs: F)

Performs the *= operation.

impl<F> Neg for Vec2<F>

where F: Float,

type Output = Vec2<F>

The resulting type after applying the - operator.

fn neg(self) -> Self::Output

Performs the unary - operation.

impl<F> PartialEq for Vec2<F>

where F: Float + PartialEq,

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

Equality operator ==.

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

Inequality operator !=.

impl<F> PartialOrd for Vec2<F>

where F: Float + PartialOrd,

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

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

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

Tests less than (for self and other) and is used by the < operator.

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

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

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

Tests greater than (for self and other) and is used by the > operator.

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

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

impl<F> StructuralPartialEq for Vec2<F>

where F: Float + PartialEq,

impl<F> Sub for Vec2<F>

where F: Float,

type Output = Vec2<F>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<F> SubAssign for Vec2<F>

where F: Float,

fn sub_assign(&mut self, rhs: Self)

Performs the -= operation.

impl<F> Vector<F> for Vec2<F>

where F: Float,

const SIZE: usize = 2

fn get(&self, i: usize) -> F

fn set(&mut self, i: usize, v: F)

impl<F> VectorConst<F> for Vec2<F>

where F: Float,

const SIZE: usize = 2

fn get<const I: usize>(&self) -> F

fn set<const I: usize>(&mut self, v: F)