Struct Vec2 

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

Vec2 vector.

Fields

x: T

y: T

Implementations

impl<T> Vec2<T>

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

Constructs a new vector from components.

pub const fn dup(u: T) -> Vec2<T>

where T: Copy,

Constructs a new vector by broadcasting to all its components.

impl<T: Zero> Vec2<T>

pub const ZERO: Vec2<T>

Vec2 of all zero.

pub const fn zero() -> Vec2<T>

Returns the origin for the vector space.

impl<T: One> Vec2<T>

pub const ONE: Vec2<T>

Vec2 of all one.

impl<T: Zero + One> Vec2<T>

pub const X: Vec2<T>

Unit vector in the x direction.

pub const Y: Vec2<T>

Unit vector in the y direction.

impl<T> Vec2<T>

pub fn set_x(self, x: T) -> Vec2<T>

Sets the x component.

pub fn set_y(self, y: T) -> Vec2<T>

Sets the y component.

pub fn vec3(self, z: T) -> Vec3<T>

Extends the 2D vector with a z component.

pub fn vec4(self, z: T, w: T) -> Vec4<T>

Extends the 2D vector with a z and w component.

impl<T: Copy> Vec2<T>

pub fn get<C>(self, _: C) -> T

where Self: ComponentImpl<T, C>,

Gets a component generically.

pub fn shuffle<X, Y>(self, x: X, y: Y) -> Vec2<T>

where Self: ComponentImpl<T, X> + ComponentImpl<T, Y>,

Shuffles the components.

impl<T> Vec2<T>

pub fn cast<U>(self) -> Vec2<U>

where T: CastTo<U>,

Casts to a vector of different type with the same dimensions.

pub fn map<U, F>(self, f: F) -> Vec2<U>

where F: FnMut(T) -> U,

Maps a callable over the components.

pub fn zip<U, F>(self, rhs: Vec2<T>, f: F) -> Vec2<U>

where F: FnMut(T, T) -> U,

Zips two vectors together.

pub fn reduce<F>(self, f: F) -> T

where F: Fn(T, T) -> T,

Reduces the vector.

pub fn fold<A, F>(self, acc: A, f: F) -> A

where F: Fn(A, T) -> A,

Folds the vector.

impl<T> Vec2<T>

pub fn as_bytes(&self) -> &[u8]

impl<T: Scalar> Vec2<T>

Operations on vectors of scalars.

pub fn sqr(self) -> Vec2<T>

Squares the components.

use cvmath::{Vec2, Vec3};

let this = Vec2 { x: -3, y: 4 };
assert_eq!(Vec2(9, 16), this.sqr());

let this = Vec3 { x: 2, y: 3, z: -6 };
assert_eq!(Vec3(4, 9, 36), this.sqr());

pub fn len_sqr(self) -> T

Calculates the squared length of the vector.

use cvmath::{Vec2, Vec3};

let this = Vec2 { x: -3, y: 4 };
assert_eq!(25, this.len_sqr());

let this = Vec3 { x: 2, y: -3, z: 6 };
assert_eq!(49, this.len_sqr());

pub fn len(self) -> T

where T: Float,

Calculates the length of the vector.

use cvmath::{Vec2, Vec3};

let this = Vec2 { x: -3.0, y: 4.0 };
assert_eq!(5.0, this.len());

let this = Vec3 { x: -2.0, y: 3.0, z: -6.0 };
assert_eq!(7.0, this.len());

pub fn len_hat(self) -> T

Calculates the manhattan length of the vector.

use cvmath::{Vec2, Vec3};

let this = Vec2 { x: 3, y: 4 };
assert_eq!(7, this.len_hat());

let this = Vec3 { x: 2, y: -3, z: -6 };
assert_eq!(11, this.len_hat());

pub fn distance_sqr(self, to: Vec2<T>) -> T

Calculates the squared euclidean distance to another vector.

use cvmath::Vec2;

let this = Vec2 { x: 1, y: 1 };
let to = Vec2 { x: 2, y: 2 };
assert_eq!(2, this.distance_sqr(to));

pub fn distance(self, to: Vec2<T>) -> T

where T: Float,

Calculates the euclidean distance to another vector.

use cvmath::Vec2;

let this = Vec2 { x: 10.0, y: 10.0 };
let to = Vec2 { x: 13.0, y: 14.0 };
assert_eq!(5.0, this.distance(to));

pub fn distance_hat(self, to: Vec2<T>) -> T

Calculates the manhattan distance to another vector.

use cvmath::{Vec2, Vec3};

let this = Vec2 { x: 1.0, y: 5.0 };
let to = Vec2 { x: 5.0, y: 2.0 };
assert_eq!(7.0, this.distance_hat(to));

let this = Vec3 { x: 1.0, y: 5.0, z: -1.0 };
let to = Vec3 { x: 2.0, y: 3.0, z: 1.0 };
assert_eq!(5.0, this.distance_hat(to));

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

where T: Float,

Normalizes the vector.

After normalizing the vector has the length 1.0 except the zero vector remains zero.

use cvmath::{Vec2, Vec3};

let this: Vec2<f32> = Vec2 { x: 3.0, y: -4.0 };
assert_eq!(Vec2(0.6, -0.8), this.norm());

let this = Vec3 { x: 0.0, y: 0.0, z: 0.0 };
assert_eq!(this, this.norm());

pub fn norm_len(self) -> (Vec2<T>, T)

where T: Float,

Calculates the normalized vector and its length.

After normalizing the vector has the length 1.0 except the zero vector remains zero.

use cvmath::{Vec2, Vec3};

let this: Vec2<f32> = Vec2 { x: 3.0, y: -4.0 };
assert_eq!((Vec2(0.6, -0.8), 5.0), this.norm_len());

let this = Vec3 { x: 0.0, y: 0.0, z: 0.0 };
assert_eq!((this, 0.0), this.norm_len());

pub fn resize(self, len: T) -> Vec2<T>

where T: Float,

Resizes the vector to the given length.

The zero vector remains zero.

use cvmath::{Vec2, Vec3};

let this = Vec2 { x: -3.0, y: -4.0 };
assert_eq!(Vec2(-1.5, -2.0), this.resize(2.5));

let this = Vec3 { x: 0.0, y: 0.0, z: 0.0 };
assert_eq!(Vec3(0.0, 0.0, 0.0), this.resize(2.0));

pub fn project_scalar(self, v: Vec2<T>) -> T

where T: Float,

Calculates the length of self projected onto v.

use cvmath::{Vec2, Vec3};

let this = Vec2 { x: 1.0, y: 2.0 };
let v = Vec2 { x: 3.0, y: 4.0 };
assert_eq!(2.2, this.project_scalar(v));

let this = Vec3 { x: 1.0, y: 4.0, z: 0.0 };
let v = Vec3 { x: 4.0, y: 2.0, z: 4.0 };
assert_eq!(2.0, this.project_scalar(v));

pub fn project(self, v: Vec2<T>) -> Vec2<T>

where T: Float,

Projection of self onto v.

use cvmath::{Vec2, Vec3};

let this = Vec2 { x: -5.0, y: -2.5 };
let v = Vec2 { x: 3.0, y: 4.0 };
assert_eq!(Vec2(-3.0, -4.0), this.project(v));

let this = Vec3 { x: -5.0, y: -2.5, z: 0.0 };
let v = Vec3 { x: 3.0, y: 4.0, z: 0.0 };
assert_eq!(Vec3(-3.0, -4.0, 0.0), this.project(v));

pub fn project_sat(self, v: Vec2<T>) -> Vec2<T>

Projection of self onto v clamped to v.

use cvmath::Vec2;

let this = Vec2 { x: -5.0, y: -2.5 };
let v = Vec2 { x: 3.0, y: 4.0 };
assert_eq!(Vec2(0.0, 0.0), this.project_sat(v));

pub fn reflect(self, v: Vec2<T>) -> Vec2<T>

where T: Float,

Reflects self around v.

use cvmath::Vec2;

let this = Vec2 { x: 1.0, y: 3.0 };
let v = Vec2 { x: 4.0, y: 4.0 };
assert_eq!(Vec2(3.0, 1.0), this.reflect(v));

pub fn reverse(self) -> Vec2<T>

Reverses the component order.

use cvmath::Vec2;

let this = Vec2 { x: 1, y: 2 };
assert_eq!(Vec2(2, 1), this.reverse());

pub fn polar_angle(self) -> Angle<T>

where T: Float,

Calculates the polar angle.

use cvmath::Vec2;

let this = Vec2 { x: 1.0, y: 1.0 };
assert_eq!(45.0, this.polar_angle().to_deg());

pub fn signed_angle(self, rhs: Vec2<T>) -> Angle<T>

where T: Float,

Returns the signed angle between two 2D vectors.

The sign of the angle follows the right-hand rule (counter-clockwise is positive).

use cvmath::Vec2;

let a = Vec2::X;
let b = Vec2::Y;
assert_eq!(90.0, a.signed_angle(b).to_deg());
assert_eq!(-90.0, b.signed_angle(a).to_deg());

pub fn ccw(self) -> Vec2<T>

Rotates the vector counter-clockwise by 90°.

The resulting vector is perpendicular to the given vector.

use cvmath::Vec2;

let this = Vec2 { x: 3.0, y: 4.0 };
assert_eq!(Vec2(4.0, -3.0), this.ccw());

pub fn cw(self) -> Vec2<T>

Rotates the vector clockwise by 90°.

The resulting vector is perpendicular to the given vector.

use cvmath::Vec2;

let this = Vec2 { x: 3.0, y: 4.0 };
assert_eq!(Vec2(-4.0, 3.0), this.cw());

pub fn cross(self, rhs: Vec2<T>) -> T

Calculates the magnitude of the 3D cross product where the inputs are extended with z = 0.

This result is equal to the area of the parallelogram between the two vectors. This result is equal to twice the area of the triangle between the two vectors.

Furthermore this area is signed; a positive value means the rhs is on the left side of self and a negative value means rhs is on the right side.

use cvmath::Vec2;

let lhs = Vec2 { x: -3, y: -4 };
let rhs = Vec2 { x: -1, y: 2 };
assert_eq!(-10, lhs.cross(rhs));
// Area under the parallelogram defined by (origin, lhs, rhs, lhs + rhs) equals 10
// Area under the triangle defined by (origin, lhs, rhs) equals 5

pub fn hsub(self) -> T

Horizontal subtracts the components.

use cvmath::Vec2;

let this = Vec2 { x: 3, y: 4 };
assert_eq!(-1, this.hsub());

pub fn y_intercept(self, x: T) -> Option<T>

Intercepts the vector with x = constant returning the y.

pub fn x_intercept(self, y: T) -> Option<T>

Intercepts the vector with y = constant returning the x.

pub fn dot(self, rhs: Vec2<T>) -> T

Calculates the dot product.

use cvmath::Vec3;

let lhs = Vec3 { x: 1, y: 2, z: 3 };
let rhs = Vec3 { x: 4, y: -5, z: 6 };
assert_eq!(12, Vec3::dot(lhs, rhs));

pub fn cos_angle(self, rhs: Vec2<T>) -> T

where T: Float,

Calculates the cosine of the angle between two vectors.

use cvmath::Vec2;

let lhs = Vec2 { x: 1.0, y: 1.0 };
let rhs = Vec2 { x: 1.0, y: 0.0 };
let sqrt_2_div_2 = 1.0 / 2_f32.sqrt(); // √2 ÷ 2
assert_eq!(sqrt_2_div_2, lhs.cos_angle(rhs));

pub fn angle(self, rhs: Vec2<T>) -> Angle<T>

where T: Float,

Calculates the angle between two vectors.

use cvmath::Vec2;

let lhs = Vec2 { x: 1.0, y: 1.0 };
let rhs = Vec2 { x: 1.0, y: 0.0 };
assert_eq!(45.0, lhs.angle(rhs).to_deg());

pub fn hadd(self) -> T

Horizontal adds all components.

use cvmath::{Vec2, Vec3};

let this = Vec2 { x: -2, y: 7 };
assert_eq!(5, this.hadd());

let this = Vec3 { x: 3, y: 4, z: 5 };
assert_eq!(12, this.hadd());

pub fn abs(self) -> Vec2<T>

Component-wise absolute value.

use cvmath::Vec2;

let this = Vec2 { x: -3, y: 5 };
assert_eq!(Vec2(3, 5), this.abs());

pub fn min(self, rhs: Vec2<T>) -> Vec2<T>

Component-wise minimum value.

use cvmath::Vec2;

let lhs = Vec2 { x: -3, y: 5 };
let rhs = Vec2 { x: 0, y: 2 };
assert_eq!(Vec2(-3, 2), lhs.min(rhs));

pub fn vmin(self) -> T

Horizontal minimum value.

pub fn max(self, rhs: Vec2<T>) -> Vec2<T>

Component-wise maximum value.

use cvmath::Vec2;

let lhs = Vec2 { x: -3, y: 5 };
let rhs = Vec2 { x: 0, y: 2 };
assert_eq!(Vec2(0, 5), lhs.max(rhs));

pub fn vmax(self) -> T

Horizontal maximum value.

pub fn mul_add(self, vec: Vec2<T>, scale: T) -> Vec2<T>

Adds the scaled vector.

Equivalent to self + (vec * scale) with less rounding errors.

pub fn lerp(self, rhs: Vec2<T>, t: T) -> Vec2<T>

Linear interpolation between the vectors.

pub fn slerp(self, rhs: Vec2<T>, t: T) -> Vec2<T>

where T: Float,

Spherical interpolation between the vectors with constant velocity.

The result is linear interpolation of the angles between the vectors and their lengths.

This is fairly expensive to calculate requiring trigonometric functions. If constant velocity isn’t required, see the less expensive nlerp.

pub fn nlerp(self, rhs: Vec2<T>, t: T) -> Vec2<T>

where T: Float,

Cheap spherical interpolation between the vectors without constant velocity.

pub fn exp_decay(self, rhs: Vec2<T>, decay: T, dt: T) -> Vec2<T>

where T: Float,

Exponential decay smoothing.

Also known as lerp smoothing. Useful decay values range from approx 1.0 to 25.0, slow to fast.

use cvmath::Vec2;

struct Entity {
	pos: Vec2<f32>,
	target: Vec2<f32>,
}
impl Entity {
	fn update(&mut self, dt: f32) {
		// Smoothly move towards the target.
		self.pos = self.pos.exp_decay(self.target, 5.0, dt);
	}
}

impl<T: Float> Vec2<T>

pub fn floor(self) -> Vec2<T>

Component-wise floor.

pub fn ceil(self) -> Vec2<T>

Component-wise ceil.

pub fn round(self) -> Vec2<T>

Component-wise round.

pub fn fract(self) -> Vec2<T>

Component-wise fract.

impl<T: PartialOrd> Vec2<T>

pub fn spatial_lt(&self, rhs: &Vec2<T>) -> bool

pub fn spatial_le(&self, rhs: &Vec2<T>) -> bool

pub fn spatial_gt(&self, rhs: &Vec2<T>) -> bool

pub fn spatial_ge(&self, rhs: &Vec2<T>) -> bool

impl<T> Vec2<T>

pub fn is_finite(self) -> Bool2

where T: Float,

Creates a mask for finite components.

pub fn is_infinite(self) -> Bool2

where T: Float,

Creates a mask for infinite components.

pub fn eq(self, rhs: Vec2<T>) -> Bool2

where T: PartialEq,

Creates a mask for equal components.

pub fn ne(self, rhs: Vec2<T>) -> Bool2

where T: PartialEq,

Creates a mask for inequal components.

pub fn lt(self, rhs: Vec2<T>) -> Bool2

where T: PartialOrd,

Creates a mask for left-hand side components are less than the right-hand side.

pub fn le(self, rhs: Vec2<T>) -> Bool2

where T: PartialOrd,

Creates a mask for left-hand side components are less than or equal the right-hand side.

pub fn gt(self, rhs: Vec2<T>) -> Bool2

where T: PartialOrd,

Creates a mask for left-hand side components are greater than the right-hand side.

pub fn ge(self, rhs: Vec2<T>) -> Bool2

where T: PartialOrd,

Creates a mask for left-hand side components are greater than or equal the right-hand side.

impl<T> Vec2<T>

pub fn is_close(self, rhs: Vec2<T>) -> Bool2

where T: Float,

Creates a mask for approximately equal components.

pub fn all_close(self, rhs: Vec2<T>) -> bool

where T: Float,

Returns true if the values are approximately equal.

impl Vec2<bool>

pub const fn any(self) -> bool

Returns true if any of the components are true.

pub const fn all(self) -> bool

Returns true if all the components are true.

pub const fn none(self) -> bool

Returns true if none of the components are true.

pub fn select<T>(self, lhs: Vec2<T>, rhs: Vec2<T>) -> Vec2<T>

Combines two vectors based on the bools, selecting components from the left-hand side if true and right-hand side if false.

impl Vec2<u64>

pub const fn unpack64(v: u128) -> Vec2<u64>

Unpacks u128 into u64 u64.

use cvmath::Vec2;

assert_eq!(
	Vec2 { x: 0x01010101_01010101, y: 0xFEFEFEFE_FEFEFEFE },
	Vec2::unpack64(0xFEFEFEFE_FEFEFEFE_01010101_01010101)
);

pub const fn pack(self) -> u128

Packs into u128.

use cvmath::Vec2;

let this: Vec2<u64> = Vec2 { x: 0x01010101_01010101, y: 0xFEFEFEFE_FEFEFEFE };
assert_eq!(0xFEFEFEFE_FEFEFEFE_01010101_01010101, this.pack());

impl Vec2<u32>

pub const fn unpack32(v: u64) -> Vec2<u32>

Unpacks u64 into u32 u32.

use cvmath::Vec2;

assert_eq!(
	Vec2 { x: 0x01010101, y: 0xFEFEFEFE },
	Vec2::unpack32(0xFEFEFEFE_01010101)
);

pub const fn pack(self) -> u64

Packs into u64.

use cvmath::Vec2;

let this: Vec2<u32> = Vec2 { x: 0x01010101, y: 0xFEFEFEFE };
assert_eq!(0xFEFEFEFE_01010101, this.pack());

impl Vec2<u16>

pub const fn unpack16(v: u32) -> Vec2<u16>

Unpacks u32 into u16 u16.

use cvmath::Vec2;

assert_eq!(
	Vec2 { x: 0x0101, y: 0xFEFE },
	Vec2::unpack16(0xFEFE_0101)
);

pub const fn pack(self) -> u32

Packs into u32.

use cvmath::Vec2;

let this: Vec2<u16> = Vec2 { x: 0x0101, y: 0xFEFE };
assert_eq!(0xFEFE_0101, this.pack());

impl Vec2<u8>

pub const fn unpack8(v: u16) -> Vec2<u8>

Unpacks u16 into u8 u8.

use cvmath::Vec2;

assert_eq!(
	Vec2 { x: 0x01, y: 0xFE },
	Vec2::unpack8(0xFE_01)
);

pub const fn pack(self) -> u16

Packs into u16.

use cvmath::Vec2;

let this: Vec2<u8> = Vec2 { x: 0x01, y: 0xFE };
assert_eq!(0xFE_01, this.pack());

Trait Implementations

impl<T: Copy + Add<T, Output = T>> Add<Vec2<T>> for Bounds2<T>

type Output = Bounds2<T>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<T: Copy + Add<T, Output = T>> Add<Vec2<T>> for Rect<T>

type Output = Rect<T>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<U, T: Add<U>> Add<Vec2<U>> for Vec2<T>

type Output = Vec2<<T as Add<U>>::Output>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<T: Copy + AddAssign<T>> AddAssign<Vec2<T>> for Bounds2<T>

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

Performs the += operation.

impl<T: Copy + AddAssign<T>> AddAssign<Vec2<T>> for Rect<T>

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

Performs the += operation.

impl<U, T: AddAssign<U>> AddAssign<Vec2<U>> for Vec2<T>

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

Performs the += operation.

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

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

Converts this type into a mutable reference of the (usually inferred) input type.

impl<T> AsMut<[T]> for Vec2<T>

fn as_mut(&mut self) -> &mut [T]

Converts this type into a mutable reference of the (usually inferred) input type.

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

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

Converts this type into a shared reference of the (usually inferred) input type.

impl<T> AsRef<[T]> for Vec2<T>

fn as_ref(&self) -> &[T]

Converts this type into a shared reference of the (usually inferred) input type.

impl<T: Binary> Binary for Vec2<T>

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

Formats the value using the given formatter.

impl<U, T: BitAnd<U>> BitAnd<Vec2<U>> for Vec2<T>

type Output = Vec2<<T as BitAnd<U>>::Output>

The resulting type after applying the & operator.

fn bitand(self, rhs: Vec2<U>) -> Vec2<T::Output>

Performs the & operation.

impl<U, T: BitOr<U>> BitOr<Vec2<U>> for Vec2<T>

type Output = Vec2<<T as BitOr<U>>::Output>

The resulting type after applying the | operator.

fn bitor(self, rhs: Vec2<U>) -> Vec2<T::Output>

Performs the | operation.

impl<U, T: BitXor<U>> BitXor<Vec2<U>> for Vec2<T>

type Output = Vec2<<T as BitXor<U>>::Output>

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: Vec2<U>) -> Vec2<T::Output>

Performs the ^ operation.

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

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

Returns a duplicate of the value.

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

Performs copy-assignment from source.

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

impl<T: Scalar> Cross for Vec2<T>

type Output = T

fn cross(self, rhs: Vec2<T>) -> T

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

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

Formats the value using the given formatter.

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

fn default() -> Vec2<T>

Returns the “default value” for a type.

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

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

Formats the value using the given formatter.

impl<T: Float> Distance for Vec2<T>

type T = T

fn distance(self, rhs: Vec2<T>) -> T

impl<T: Float> Distance<Vec2<T>> for Line2<T>

type T = T

fn distance(self, pt: Point2<T>) -> T

impl<T: Float> Distance<Vec2<T>> for Plane2<T>

type T = T

fn distance(self, pt: Point2<T>) -> T

impl<U: Scalar, T: Div<U>> Div<U> for Vec2<T>

type Output = Vec2<<T as Div<U>>::Output>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<U, T: Div<U>> Div<Vec2<U>> for Vec2<T>

type Output = Vec2<<T as Div<U>>::Output>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<U: Scalar, T: DivAssign<U>> DivAssign<U> for Vec2<T>

fn div_assign(&mut self, rhs: U)

Performs the /= operation.

impl<U, T: DivAssign<U>> DivAssign<Vec2<U>> for Vec2<T>

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

Performs the /= operation.

impl<T: Scalar> Dot for Vec2<T>

type T = T

fn dot(self, rhs: Vec2<T>) -> T

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

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

fn from(val: (T, T)) -> Vec2<T>

Converts to this type from the input type.

impl<T> From<Complex<T>> for Vec2<T>

fn from(complex: Complex<T>) -> Vec2<T>

Converts to this type from the input type.

impl<T: Float> From<Polar<T>> for Vec2<T>

fn from(polar: Polar<T>) -> Vec2<T>

Converts to this type from the input type.

impl<T: Scalar> From<T> for Vec2<T>

fn from(val: T) -> Vec2<T>

Converts to this type from the input type.

impl<T> From<Vec2<T>> for Complex<T>

fn from(vec: Vec2<T>) -> Complex<T>

Converts to this type from the input type.

impl<T: Float> From<Vec2<T>> for Polar<T>

fn from(vec: Vec2<T>) -> Polar<T>

Converts to this type from the input type.

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

fn from(val: [T; 2]) -> Vec2<T>

Converts to this type from the input type.

impl<T: Float> FromIterator<Vec2<T>> for Bounds2<T>

fn from_iter<I: IntoIterator<Item = Point2<T>>>(iter: I) -> Self

Creates a value from an iterator.

impl<T: FromStr> FromStr for Vec2<T>

type Err = ParseVecError<<T as FromStr>::Err>

The associated error which can be returned from parsing.

fn from_str(s: &str) -> Result<Vec2<T>, Self::Err>

Parses a string s to return a value of this type.

impl<T: Hash> 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, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl<T> Index<usize> for Vec2<T>

type Output = T

The returned type after indexing.

fn index(&self, i: usize) -> &T

Performs the indexing (container[index]) operation.

impl<T> Into<(T, T)> for Vec2<T>

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

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

impl<T> Into<[T; 2]> for Vec2<T>

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

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

impl<T: Scalar> Lerp for Vec2<T>

type T = T

fn lerp(self, rhs: Vec2<T>, t: T) -> Vec2<T>

impl<T: LowerExp> LowerExp for Vec2<T>

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

Formats the value using the given formatter.

impl<T: LowerHex> LowerHex for Vec2<T>

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

Formats the value using the given formatter.

impl<T> Mul<&Vec2<T>> for Mat2<T>

where Mat2<T>: Mul<Vec2<T>, Output = Vec2<T>>, Vec2<T>: Copy,

type Output = Vec2<T>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<T> Mul<&Vec2<T>> for &Mat2<T>

where Mat2<T>: Copy + Mul<Vec2<T>, Output = Vec2<T>>, Vec2<T>: Copy,

type Output = Vec2<T>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<T> Mul<&Vec2<T>> for Transform2<T>

where Transform2<T>: Mul<Vec2<T>, Output = Vec2<T>>, Vec2<T>: Copy,

type Output = Vec2<T>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<T> Mul<&Vec2<T>> for &Transform2<T>

where Transform2<T>: Copy + Mul<Vec2<T>, Output = Vec2<T>>, Vec2<T>: Copy,

type Output = Vec2<T>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<U: Scalar, T: Mul<U>> Mul<U> for Vec2<T>

type Output = Vec2<<T as Mul<U>>::Output>

The resulting type after applying the * operator.

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

Performs the * operation.

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

type Output = Vec2<T>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<T: Copy + Add<Output = T> + Mul<Output = T>> Mul<Vec2<T>> for Mat2<T>

type Output = Vec2<T>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<T> Mul<Vec2<T>> for &Mat2<T>

where Mat2<T>: Copy + Mul<Vec2<T>, Output = Vec2<T>>,

type Output = Vec2<T>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<T: Copy + Add<Output = T> + Mul<Output = T>> Mul<Vec2<T>> for Transform2<T>

type Output = Vec2<T>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<T> Mul<Vec2<T>> for &Transform2<T>

where Transform2<T>: Copy + Mul<Vec2<T>, Output = Vec2<T>>,

type Output = Vec2<T>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<U, T: Mul<U>> Mul<Vec2<U>> for Vec2<T>

type Output = Vec2<<T as Mul<U>>::Output>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<U: Scalar, T: MulAssign<U>> MulAssign<U> for Vec2<T>

fn mul_assign(&mut self, rhs: U)

Performs the *= operation.

impl<U, T: MulAssign<U>> MulAssign<Vec2<U>> for Vec2<T>

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

Performs the *= operation.

impl<T: Neg> Neg for Vec2<T>

type Output = Vec2<<T as Neg>::Output>

The resulting type after applying the - operator.

fn neg(self) -> Vec2<T::Output>

Performs the unary - operation.

impl<T: Not> Not for Vec2<T>

type Output = Vec2<<T as Not>::Output>

The resulting type after applying the ! operator.

fn not(self) -> Vec2<T::Output>

Performs the unary ! operation.

impl<T: Octal> Octal for Vec2<T>

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

Formats the value using the given formatter.

impl<T: Ord> Ord for Vec2<T>

fn cmp(&self, other: &Vec2<T>) -> Ordering

This method returns an Ordering between self and other.

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

where Self: Sized,

Compares and returns the maximum of two values.

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

where Self: Sized,

Compares and returns the minimum of two values.

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

where Self: Sized,

Restrict a value to a certain interval.

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

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

Tests for self and other values to be equal, and is used by ==.

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

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

impl<T: PartialOrd> PartialOrd for Vec2<T>

fn partial_cmp(&self, other: &Vec2<T>) -> 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<U: Scalar, T: Rem<U>> Rem<U> for Vec2<T>

type Output = Vec2<<T as Rem<U>>::Output>

The resulting type after applying the % operator.

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

Performs the % operation.

impl<U, T: Rem<U>> Rem<Vec2<U>> for Vec2<T>

type Output = Vec2<<T as Rem<U>>::Output>

The resulting type after applying the % operator.

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

Performs the % operation.

impl<U: Scalar, T: RemAssign<U>> RemAssign<U> for Vec2<T>

fn rem_assign(&mut self, rhs: U)

Performs the %= operation.

impl<U, T: RemAssign<U>> RemAssign<Vec2<U>> for Vec2<T>

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

Performs the %= operation.

impl<T: PartialEq> StructuralPartialEq for Vec2<T>

impl<T: Copy + Sub<T, Output = T>> Sub<Vec2<T>> for Bounds2<T>

type Output = Bounds2<T>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<T: Copy + Sub<T, Output = T>> Sub<Vec2<T>> for Rect<T>

type Output = Rect<T>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<U, T: Sub<U>> Sub<Vec2<U>> for Vec2<T>

type Output = Vec2<<T as Sub<U>>::Output>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<T: Copy + SubAssign<T>> SubAssign<Vec2<T>> for Bounds2<T>

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

Performs the -= operation.

impl<T: Copy + SubAssign<T>> SubAssign<Vec2<T>> for Rect<T>

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

Performs the -= operation.

impl<U, T: SubAssign<U>> SubAssign<Vec2<U>> for Vec2<T>

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

Performs the -= operation.

impl<T: UpperExp> UpperExp for Vec2<T>

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

Formats the value using the given formatter.

impl<T: UpperHex> UpperHex for Vec2<T>

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

Formats the value using the given formatter.