# Struct euclid::vector::Vector2D

``````#[repr(C)]pub struct Vector2D<T, U> {
pub x: T,
pub y: T,
/* private fields */
}``````
Expand description

A 2d Vector tagged with a unit.

## Fields§

§`x: T`

The `x` (traditionally, horizontal) coordinate.

§`y: T`

The `y` (traditionally, vertical) coordinate.

## Implementations§

source§

### impl<T, U> Vector2D<T, U>

source

#### pub fn zero() -> Selfwhere T: Zero,

Constructor, setting all components to zero.

source

#### pub fn one() -> Selfwhere T: One,

Constructor, setting all components to one.

source

#### pub const fn new(x: T, y: T) -> Self

Constructor taking scalar values directly.

source

#### pub fn splat(v: T) -> Selfwhere T: Clone,

Constructor setting all components to the same value.

source

#### pub fn from_angle_and_length(angle: Angle<T>, length: T) -> Selfwhere T: Trig + Mul<Output = T> + Copy,

Constructor taking angle and length

source

#### pub fn from_lengths(x: Length<T, U>, y: Length<T, U>) -> Self

Constructor taking properly Lengths instead of scalar values.

source

#### pub fn from_untyped(p: Vector2D<T, UnknownUnit>) -> Self

Tag a unit-less value with units.

source

#### pub fn map<V, F: FnMut(T) -> V>(self, f: F) -> Vector2D<V, U>

Apply the function `f` to each component of this vector.

##### §Example

This may be used to perform unusual arithmetic which is not already offered as methods.

``````use euclid::default::Vector2D;

let p = Vector2D::<u32>::new(5, 11);
assert_eq!(p.map(|coord| coord.saturating_sub(10)), Vector2D::new(0, 1));``````
source

#### pub fn zip<V, F: FnMut(T, T) -> V>(self, rhs: Self, f: F) -> Vector2D<V, U>

Apply the function `f` to each pair of components of this point and `rhs`.

##### §Example

This may be used to perform unusual arithmetic which is not already offered as methods.

``````use euclid::default::Vector2D;

let a: Vector2D<u8> = Vector2D::new(50, 200);
let b: Vector2D<u8> = Vector2D::new(100, 100);
source

#### pub fn abs(self) -> Selfwhere T: Signed,

Computes the vector with absolute values of each component.

##### §Example
``````enum U {}

assert_eq!(vec2::<_, U>(-1, 2).abs(), vec2(1, 2));

let vec = vec2::<_, U>(f32::NAN, -f32::MAX).abs();
assert!(vec.x.is_nan());
assert_eq!(vec.y, f32::MAX);``````
##### §Panics

The behavior for each component follows the scalar type’s implementation of `num_traits::Signed::abs`.

source

Dot product.

source

#### pub fn cross(self, other: Self) -> Twhere T: Sub<Output = T> + Mul<Output = T>,

Returns the norm of the cross product [self.x, self.y, 0] x [other.x, other.y, 0].

source

#### pub fn component_mul(self, other: Self) -> Selfwhere T: Mul<Output = T>,

Returns the component-wise multiplication of the two vectors.

source

#### pub fn component_div(self, other: Self) -> Selfwhere T: Div<Output = T>,

Returns the component-wise division of the two vectors.

source§

### impl<T: Copy, U> Vector2D<T, U>

source

#### pub fn extend(self, z: T) -> Vector3D<T, U>

Create a 3d vector from this one, using the specified z value.

source

#### pub fn to_point(self) -> Point2D<T, U>

Cast this vector into a point.

Equivalent to adding this vector to the origin.

source

Swap x and y.

source

#### pub fn to_size(self) -> Size2D<T, U>

Cast this vector into a size.

source

#### pub fn to_untyped(self) -> Vector2D<T, UnknownUnit>

Drop the units, preserving only the numeric value.

source

Cast the unit.

source

#### pub fn to_array(self) -> [T; 2]

Cast into an array with x and y.

source

#### pub fn to_tuple(self) -> (T, T)

Cast into a tuple with x and y.

source

#### pub fn to_3d(self) -> Vector3D<T, U>where T: Zero,

Convert into a 3d vector with `z` coordinate equals to `T::zero()`.

source

#### pub fn round(self) -> Selfwhere T: Round,

Rounds each component to the nearest integer value.

This behavior is preserved for negative values (unlike the basic cast).

``````enum Mm {}

assert_eq!(vec2::<_, Mm>(-0.1, -0.8).round(), vec2::<_, Mm>(0.0, -1.0))``````
source

#### pub fn ceil(self) -> Selfwhere T: Ceil,

Rounds each component to the smallest integer equal or greater than the original value.

This behavior is preserved for negative values (unlike the basic cast).

``````enum Mm {}

assert_eq!(vec2::<_, Mm>(-0.1, -0.8).ceil(), vec2::<_, Mm>(0.0, 0.0))``````
source

#### pub fn floor(self) -> Selfwhere T: Floor,

Rounds each component to the biggest integer equal or lower than the original value.

This behavior is preserved for negative values (unlike the basic cast).

``````enum Mm {}

assert_eq!(vec2::<_, Mm>(-0.1, -0.8).floor(), vec2::<_, Mm>(-1.0, -1.0))``````
source

#### pub fn angle_from_x_axis(self) -> Angle<T>where T: Trig,

Returns the signed angle between this vector and the x axis. Positive values counted counterclockwise, where 0 is `+x` axis, `PI/2` is `+y` axis.

The returned angle is between -PI and PI.

source

#### pub fn to_transform(self) -> Transform2D<T, U, U>where T: Zero + One,

Creates translation by this vector in vector units.

source§

### impl<T, U> Vector2D<T, U>where T: Copy + Mul<T, Output = T> + Add<T, Output = T>,

source

#### pub fn square_length(self) -> T

Returns the vector’s length squared.

source

#### pub fn project_onto_vector(self, onto: Self) -> Selfwhere T: Sub<T, Output = T> + Div<T, Output = T>,

Returns this vector projected onto another one.

Projecting onto a nil vector will cause a division by zero.

source

#### pub fn angle_to(self, other: Self) -> Angle<T>where T: Sub<Output = T> + Trig,

Returns the signed angle between this vector and another vector.

The returned angle is between -PI and PI.

source§

### impl<T: Float, U> Vector2D<T, U>

source

#### pub fn robust_normalize(self) -> Self

Return the normalized vector even if the length is larger than the max value of Float.

source

#### pub fn is_finite(self) -> bool

Returns true if all members are finite.

source§

### impl<T: Real, U> Vector2D<T, U>

source

#### pub fn length(self) -> T

Returns the vector length.

source

#### pub fn normalize(self) -> Self

Returns the vector with length of one unit.

source

#### pub fn try_normalize(self) -> Option<Self>

Returns the vector with length of one unit.

Unlike `Vector2D::normalize`, this returns None in the case that the length of the vector is zero.

source

#### pub fn with_length(self, length: T) -> Self

Return this vector scaled to fit the provided length.

source

#### pub fn with_max_length(self, max_length: T) -> Self

Return this vector capped to a maximum length.

source

#### pub fn with_min_length(self, min_length: T) -> Self

Return this vector with a minimum length applied.

source

#### pub fn clamp_length(self, min: T, max: T) -> Self

Return this vector with minimum and maximum lengths applied.

source§

### impl<T, U> Vector2D<T, U>where T: Copy + One + Add<Output = T> + Sub<Output = T> + Mul<Output = T>,

source

#### pub fn lerp(self, other: Self, t: T) -> Self

Linearly interpolate each component between this vector and another vector.

##### §Example
``````use euclid::vec2;
use euclid::default::Vector2D;

let from: Vector2D<_> = vec2(0.0, 10.0);
let to:  Vector2D<_> = vec2(8.0, -4.0);

assert_eq!(from.lerp(to, -1.0), vec2(-8.0,  24.0));
assert_eq!(from.lerp(to,  0.0), vec2( 0.0,  10.0));
assert_eq!(from.lerp(to,  0.5), vec2( 4.0,   3.0));
assert_eq!(from.lerp(to,  1.0), vec2( 8.0,  -4.0));
assert_eq!(from.lerp(to,  2.0), vec2(16.0, -18.0));``````
source

#### pub fn reflect(self, normal: Self) -> Self

Returns a reflection vector using an incident ray and a surface normal.

source§

### impl<T: PartialOrd, U> Vector2D<T, U>

source

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

Returns the vector each component of which are minimum of this vector and another.

source

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

Returns the vector each component of which are maximum of this vector and another.

source

#### pub fn clamp(self, start: Self, end: Self) -> Selfwhere T: Copy,

Returns the vector each component of which is clamped by corresponding components of `start` and `end`.

Shortcut for `self.max(start).min(end)`.

source

#### pub fn greater_than(self, other: Self) -> BoolVector2D

Returns vector with results of “greater than” operation on each component.

source

#### pub fn lower_than(self, other: Self) -> BoolVector2D

Returns vector with results of “lower than” operation on each component.

source§

### impl<T: PartialEq, U> Vector2D<T, U>

source

#### pub fn equal(self, other: Self) -> BoolVector2D

Returns vector with results of “equal” operation on each component.

source

#### pub fn not_equal(self, other: Self) -> BoolVector2D

Returns vector with results of “not equal” operation on each component.

source§

### impl<T: NumCast + Copy, U> Vector2D<T, U>

source

#### pub fn cast<NewT: NumCast>(self) -> Vector2D<NewT, U>

Cast from one numeric representation to another, preserving the units.

When casting from floating vector to integer coordinates, the decimals are truncated as one would expect from a simple cast, but this behavior does not always make sense geometrically. Consider using `round()`, `ceil()` or `floor()` before casting.

source

#### pub fn try_cast<NewT: NumCast>(self) -> Option<Vector2D<NewT, U>>

Fallible cast from one numeric representation to another, preserving the units.

When casting from floating vector to integer coordinates, the decimals are truncated as one would expect from a simple cast, but this behavior does not always make sense geometrically. Consider using `round()`, `ceil()` or `floor()` before casting.

source

#### pub fn to_f32(self) -> Vector2D<f32, U>

Cast into an `f32` vector.

source

#### pub fn to_f64(self) -> Vector2D<f64, U>

Cast into an `f64` vector.

source

#### pub fn to_usize(self) -> Vector2D<usize, U>

Cast into an `usize` vector, truncating decimals if any.

When casting from floating vector vectors, it is worth considering whether to `round()`, `ceil()` or `floor()` before the cast in order to obtain the desired conversion behavior.

source

#### pub fn to_u32(self) -> Vector2D<u32, U>

Cast into an `u32` vector, truncating decimals if any.

When casting from floating vector vectors, it is worth considering whether to `round()`, `ceil()` or `floor()` before the cast in order to obtain the desired conversion behavior.

source

#### pub fn to_i32(self) -> Vector2D<i32, U>

Cast into an i32 vector, truncating decimals if any.

When casting from floating vector vectors, it is worth considering whether to `round()`, `ceil()` or `floor()` before the cast in order to obtain the desired conversion behavior.

source

#### pub fn to_i64(self) -> Vector2D<i64, U>

Cast into an i64 vector, truncating decimals if any.

When casting from floating vector vectors, it is worth considering whether to `round()`, `ceil()` or `floor()` before the cast in order to obtain the desired conversion behavior.

## Trait Implementations§

source§

§

#### type Output = Vector2D<<T as Add>::Output, U>

The resulting type after applying the `+` operator.
source§

#### fn add(self, other: &Self) -> Self::Output

Performs the `+` operation. Read more
source§

§

#### type Output = Point2D<<T as Add>::Output, U>

The resulting type after applying the `+` operator.
source§

#### fn add(self, other: Vector2D<T, U>) -> Self::Output

Performs the `+` operation. Read more
source§

§

#### type Output = Vector2D<<T as Add>::Output, U>

The resulting type after applying the `+` operator.
source§

#### fn add(self, other: Self) -> Self::Output

Performs the `+` operation. Read more
source§

### impl<T: Copy + Add<T, Output = T>, U> AddAssign<Vector2D<T, U>> for Point2D<T, U>

source§

#### fn add_assign(&mut self, other: Vector2D<T, U>)

Performs the `+=` operation. Read more
source§

### impl<T: Copy + Add<T, Output = T>, U> AddAssign for Vector2D<T, U>

source§

#### fn add_assign(&mut self, other: Self)

Performs the `+=` operation. Read more
source§

### impl<T: ApproxEq<T>, U> ApproxEq<Vector2D<T, U>> for Vector2D<T, U>

source§

#### fn approx_epsilon() -> Self

Default epsilon value
source§

#### fn approx_eq_eps(&self, other: &Self, eps: &Self) -> bool

Returns `true` is this object is approximately equal to the other one, using a provided epsilon value.
source§

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

Returns `true` is this object is approximately equal to the other one, using the `approx_epsilon()` epsilon value.
source§

source§

source§

### impl<T: Clone, U> Clone for Vector2D<T, U>

source§

#### fn clone(&self) -> Self

Returns a copy of the value. Read more
1.0.0 · source§

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

Performs copy-assignment from `source`. Read more
source§

### impl<T: Debug, U> Debug for Vector2D<T, U>

source§

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

Formats the value using the given formatter. Read more
source§

### impl<T: Default, U> Default for Vector2D<T, U>

source§

#### fn default() -> Self

Returns the “default value” for a type. Read more
source§

### impl<'de, T, U> Deserialize<'de> for Vector2D<T, U>where T: Deserialize<'de>,

source§

#### fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>where D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer. Read more
source§

### impl<T: Copy + Div, U1, U2> Div<Scale<T, U1, U2>> for Vector2D<T, U2>

§

#### type Output = Vector2D<<T as Div>::Output, U1>

The resulting type after applying the `/` operator.
source§

#### fn div(self, scale: Scale<T, U1, U2>) -> Self::Output

Performs the `/` operation. Read more
source§

### impl<T: Copy + Div, U> Div<T> for Vector2D<T, U>

§

#### type Output = Vector2D<<T as Div>::Output, U>

The resulting type after applying the `/` operator.
source§

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

Performs the `/` operation. Read more
source§

### impl<T: Copy + DivAssign, U> DivAssign<Scale<T, U, U>> for Vector2D<T, U>

source§

#### fn div_assign(&mut self, scale: Scale<T, U, U>)

Performs the `/=` operation. Read more
source§

### impl<T: Copy + Div<T, Output = T>, U> DivAssign<T> for Vector2D<T, U>

source§

#### fn div_assign(&mut self, scale: T)

Performs the `/=` operation. Read more
source§

source§

source§

### impl<T, U> From<[T; 2]> for Vector2D<T, U>

source§

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

Converts to this type from the input type.
source§

### impl<T, U> From<(T, T)> for Vector2D<T, U>

source§

#### fn from(tuple: (T, T)) -> Self

Converts to this type from the input type.
source§

### impl<T, U> From<Size2D<T, U>> for Vector2D<T, U>

source§

#### fn from(s: Size2D<T, U>) -> Self

Converts to this type from the input type.
source§

### impl<T, Src, Dst> From<Translation2D<T, Src, Dst>> for Vector2D<T, Src>

source§

#### fn from(t: Translation2D<T, Src, Dst>) -> Self

Converts to this type from the input type.
source§

### impl<T, Src, Dst> From<Vector2D<T, Src>> for Translation2D<T, Src, Dst>

source§

#### fn from(v: Vector2D<T, Src>) -> Self

Converts to this type from the input type.
source§

### impl<T, U> From<Vector2D<T, U>> for [T; 2]

source§

#### fn from(v: Vector2D<T, U>) -> Self

Converts to this type from the input type.
source§

### impl<T, U> From<Vector2D<T, U>> for (T, T)

source§

#### fn from(v: Vector2D<T, U>) -> Self

Converts to this type from the input type.
source§

### impl<T: Zero, U> From<Vector2D<T, U>> for HomogeneousVector<T, U>

source§

#### fn from(v: Vector2D<T, U>) -> Self

Converts to this type from the input type.
source§

### impl<T, U> From<Vector2D<T, U>> for Size2D<T, U>

source§

#### fn from(v: Vector2D<T, U>) -> Self

Converts to this type from the input type.
source§

### impl<T: Hash, U> Hash for Vector2D<T, U>

source§

#### fn hash<H: Hasher>(&self, h: &mut H)

Feeds this value into the given `Hasher`. Read more
1.3.0 · source§

#### fn hash_slice<H>(data: &[Self], state: &mut H)where H: Hasher, Self: Sized,

Feeds a slice of this type into the given `Hasher`. Read more
source§

### impl<T: Copy + Mul, U1, U2> Mul<Scale<T, U1, U2>> for Vector2D<T, U1>

§

#### type Output = Vector2D<<T as Mul>::Output, U2>

The resulting type after applying the `*` operator.
source§

#### fn mul(self, scale: Scale<T, U1, U2>) -> Self::Output

Performs the `*` operation. Read more
source§

### impl<T: Copy + Mul, U> Mul<T> for Vector2D<T, U>

§

#### type Output = Vector2D<<T as Mul>::Output, U>

The resulting type after applying the `*` operator.
source§

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

Performs the `*` operation. Read more
source§

### impl<T: Copy + MulAssign, U> MulAssign<Scale<T, U, U>> for Vector2D<T, U>

source§

#### fn mul_assign(&mut self, scale: Scale<T, U, U>)

Performs the `*=` operation. Read more
source§

### impl<T: Copy + Mul<T, Output = T>, U> MulAssign<T> for Vector2D<T, U>

source§

#### fn mul_assign(&mut self, scale: T)

Performs the `*=` operation. Read more
source§

### impl<T: Neg, U> Neg for Vector2D<T, U>

§

#### type Output = Vector2D<<T as Neg>::Output, U>

The resulting type after applying the `-` operator.
source§

#### fn neg(self) -> Self::Output

Performs the unary `-` operation. Read more
source§

### impl<T: PartialEq, U> PartialEq for Vector2D<T, U>

source§

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

This method tests for `self` and `other` values to be equal, and is used by `==`.
1.0.0 · source§

#### 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.
source§

source§

source§

### impl<T, U> Serialize for Vector2D<T, U>where T: Serialize,

source§

#### fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>where S: Serializer,

Serialize this value into the given Serde serializer. Read more
source§

### impl<T: Sub, U> Sub<Vector2D<T, U>> for Point2D<T, U>

§

#### type Output = Point2D<<T as Sub>::Output, U>

The resulting type after applying the `-` operator.
source§

#### fn sub(self, other: Vector2D<T, U>) -> Self::Output

Performs the `-` operation. Read more
source§

### impl<T: Sub, U> Sub for Vector2D<T, U>

§

#### type Output = Vector2D<<T as Sub>::Output, U>

The resulting type after applying the `-` operator.
source§

#### fn sub(self, other: Self) -> Self::Output

Performs the `-` operation. Read more
source§

### impl<T: Copy + Sub<T, Output = T>, U> SubAssign<Vector2D<T, U>> for Point2D<T, U>

source§

#### fn sub_assign(&mut self, other: Vector2D<T, U>)

Performs the `-=` operation. Read more
source§

### impl<T: Copy + Sub<T, Output = T>, U> SubAssign for Vector2D<T, U>

source§

#### fn sub_assign(&mut self, other: Self)

Performs the `-=` operation. Read more
source§

### impl<'a, T: 'a + Add<Output = T> + Copy + Zero, U: 'a> Sum<&'a Vector2D<T, U>> for Vector2D<T, U>

source§

#### fn sum<I: Iterator<Item = &'a Self>>(iter: I) -> Self

Method which takes an iterator and generates `Self` from the elements by “summing up” the items.
source§

### impl<T: Add<Output = T> + Zero, U> Sum for Vector2D<T, U>

source§

#### fn sum<I: Iterator<Item = Self>>(iter: I) -> Self

Method which takes an iterator and generates `Self` from the elements by “summing up” the items.
source§

### impl<T: Zero, U> Zero for Vector2D<T, U>

source§

#### fn zero() -> Self

Constructor, setting all components to zero.

source§

source§

§

§

§

§

§

§

## Blanket Implementations§

source§

### impl<T> Any for Twhere T: 'static + ?Sized,

source§

#### fn type_id(&self) -> TypeId

Gets the `TypeId` of `self`. Read more
source§

### impl<T> Borrow<T> for Twhere T: ?Sized,

source§

#### fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more
source§

### impl<T> BorrowMut<T> for Twhere T: ?Sized,

source§

#### fn borrow_mut(&mut self) -> &mut T

Mutably borrows from an owned value. Read more
source§

### impl<T> From<T> for T

source§

#### fn from(t: T) -> T

Returns the argument unchanged.

source§

### impl<T, U> Into<U> for Twhere U: From<T>,

source§

#### fn into(self) -> U

Calls `U::from(self)`.

That is, this conversion is whatever the implementation of `From<T> for U` chooses to do.

source§

### impl<T> ToOwned for Twhere T: Clone,

§

#### type Owned = T

The resulting type after obtaining ownership.
source§

#### fn to_owned(&self) -> T

Creates owned data from borrowed data, usually by cloning. Read more
source§

#### fn clone_into(&self, target: &mut T)

Uses borrowed data to replace owned data, usually by cloning. Read more
source§

### impl<T, U> TryFrom<U> for Twhere U: Into<T>,

§

#### type Error = Infallible

The type returned in the event of a conversion error.
source§

#### fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

Performs the conversion.
source§

### impl<T, U> TryInto<U> for Twhere U: TryFrom<T>,

§

#### type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.
source§

#### fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

Performs the conversion.
source§