Struct cgmath::Vector2

pub struct Vector2<S> {
    pub x: S,
    pub y: S,
}

Fields

x: S

y: S

Implementations

impl<S> Vector2<S>

pub fn new(x: S, y: S) -> Vector2<S>

Construct a new vector, using the provided values.

impl<S: Copy + Neg<Output = S>> Vector2<S>

pub fn neg_self(&mut self)

Negate this vector in-place (multiply by -1).

impl<S: NumCast + Copy> Vector2<S>

pub fn cast<T: NumCast>(&self) -> Vector2<T>

Component-wise casting to another type

impl<S: BaseNum> Vector2<S>

Operations specific to numeric two-dimensional vectors.

pub fn unit_x() -> Vector2<S>

A unit vector in the x direction.

pub fn unit_y() -> Vector2<S>

A unit vector in the y direction.

pub fn perp_dot(self, other: Vector2<S>) -> S

The perpendicular dot product of the vector and other.

pub fn extend(self, z: S) -> Vector3<S>

Create a Vector3, using the x and y values from this vector, and the provided z.

Trait Implementations

impl<'a, 'b, S: BaseNum> Add<&'a Vector2<S>> for &'b Point2<S>

type Output = Point2<S>

The resulting type after applying the + operator.

fn add(self, v: &'a Vector2<S>) -> Point2<S>

Performs the + operation.

impl<'a, 'b, S: BaseNum> Add<&'a Vector2<S>> for &'b Vector2<S>

type Output = Vector2<S>

The resulting type after applying the + operator.

fn add(self, other: &'a Vector2<S>) -> Vector2<S>

Performs the + operation.

impl<'a, S: BaseNum> Add<&'a Vector2<S>> for Point2<S>

type Output = Point2<S>

The resulting type after applying the + operator.

fn add(self, v: &'a Vector2<S>) -> Point2<S>

Performs the + operation.

impl<'a, S: BaseNum> Add<&'a Vector2<S>> for Vector2<S>

type Output = Vector2<S>

The resulting type after applying the + operator.

fn add(self, other: &'a Vector2<S>) -> Vector2<S>

Performs the + operation.

impl<'a, S: BaseNum> Add<S> for &'a Vector2<S>

type Output = Vector2<S>

The resulting type after applying the + operator.

fn add(self, scalar: S) -> Vector2<S>

Performs the + operation.

impl<S: BaseNum> Add<S> for Vector2<S>

type Output = Vector2<S>

The resulting type after applying the + operator.

fn add(self, scalar: S) -> Vector2<S>

Performs the + operation.

impl<'a, S: BaseNum> Add<Vector2<S>> for &'a Point2<S>

type Output = Point2<S>

The resulting type after applying the + operator.

fn add(self, v: Vector2<S>) -> Point2<S>

Performs the + operation.

impl<'a, S: BaseNum> Add<Vector2<S>> for &'a Vector2<S>

type Output = Vector2<S>

The resulting type after applying the + operator.

fn add(self, other: Vector2<S>) -> Vector2<S>

Performs the + operation.

impl<S: BaseNum> Add<Vector2<S>> for Point2<S>

type Output = Point2<S>

The resulting type after applying the + operator.

fn add(self, v: Vector2<S>) -> Point2<S>

Performs the + operation.

impl<S: BaseNum> Add<Vector2<S>> for Vector2<S>

type Output = Vector2<S>

The resulting type after applying the + operator.

fn add(self, other: Vector2<S>) -> Vector2<S>

Performs the + operation.

impl<S: BaseFloat> ApproxEq for Vector2<S>

type Epsilon = S

fn approx_eq_eps(&self, other: &Vector2<S>, epsilon: &S) -> bool

fn approx_epsilon() -> Self::Epsilon

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

impl<S: Copy> Array for Vector2<S>

type Element = S

fn sum(self) -> Swhere S: Add<Output = S>,

The sum of the elements of the array.

fn product(self) -> Swhere S: Mul<Output = S>,

The product of the elements of the array.

fn min(self) -> Swhere S: PartialOrd,

The minimum element of the array.

fn max(self) -> Swhere S: PartialOrd,

The maximum element of the array.

fn as_ptr(&self) -> *const Self::Element

Get the pointer to the first element of the array.

fn as_mut_ptr(&mut self) -> *mut Self::Element

Get a mutable pointer to the first element of the array.

fn swap_elements(&mut self, i: usize, j: usize)

Swap the elements at indices i and j in-place.

impl<S> AsMut<[S; 2]> for Vector2<S>

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

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

impl<S> AsMut<(S, S)> for Vector2<S>

fn as_mut(&mut self) -> &mut (S, S)

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

impl<S> AsRef<[S; 2]> for Vector2<S>

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

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

impl<S> AsRef<(S, S)> for Vector2<S>

fn as_ref(&self) -> &(S, S)

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

impl<S: Clone> Clone for Vector2<S>

fn clone(&self) -> Vector2<S>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<S: BaseNum> Debug for Vector2<S>

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

Formats the value using the given formatter.

impl<S: Decodable> Decodable for Vector2<S>

fn decode<__D: Decoder>(d: &mut __D) -> Result<Vector2<S>, __D::Error>

Deserialize a value using a Decoder.

impl<'a, 'b, S: BaseNum> Div<&'a Vector2<S>> for &'b Vector2<S>

type Output = Vector2<S>

The resulting type after applying the / operator.

fn div(self, other: &'a Vector2<S>) -> Vector2<S>

Performs the / operation.

impl<'a, S: BaseNum> Div<&'a Vector2<S>> for Vector2<S>

type Output = Vector2<S>

The resulting type after applying the / operator.

fn div(self, other: &'a Vector2<S>) -> Vector2<S>

Performs the / operation.

impl<'a, S: BaseNum> Div<S> for &'a Vector2<S>

type Output = Vector2<S>

The resulting type after applying the / operator.

fn div(self, scalar: S) -> Vector2<S>

Performs the / operation.

impl<S: BaseNum> Div<S> for Vector2<S>

type Output = Vector2<S>

The resulting type after applying the / operator.

fn div(self, scalar: S) -> Vector2<S>

Performs the / operation.

impl<'a, S: BaseNum> Div<Vector2<S>> for &'a Vector2<S>

type Output = Vector2<S>

The resulting type after applying the / operator.

fn div(self, other: Vector2<S>) -> Vector2<S>

Performs the / operation.

impl<S: BaseNum> Div<Vector2<S>> for Vector2<S>

type Output = Vector2<S>

The resulting type after applying the / operator.

fn div(self, other: Vector2<S>) -> Vector2<S>

Performs the / operation.

impl<S: Encodable> Encodable for Vector2<S>

fn encode<__S: Encoder>(&self, s: &mut __S) -> Result<(), __S::Error>

Serialize a value using an Encoder.

impl<S: BaseFloat> EuclideanVector for Vector2<S>

fn angle(self, other: Vector2<S>) -> Rad<S>

The angle between the vector and other, in radians.

fn is_perpendicular(self, other: Self) -> bool

Returns true if the vector is perpendicular (at right angles) to the other vector.

fn length2(self) -> Self::Scalar

Returns the squared length of the vector. This does not perform an expensive square root operation like in the length method and can therefore be more efficient for comparing the lengths of two vectors.

fn length(self) -> Self::Scalar

The norm of the vector.

fn normalize(self) -> Self

Returns a vector with the same direction, but with a length (or norm) of 1.

fn normalize_to(self, length: Self::Scalar) -> Self

Returns a vector with the same direction and a given length.

fn lerp(self, other: Self, amount: Self::Scalar) -> Self

Returns the result of linarly interpolating the length of the vector towards the length of other by the specified amount.

fn normalize_self(&mut self)

Normalises the vector to a length of 1.

fn normalize_self_to(&mut self, length: Self::Scalar)

Normalizes the vector to length.

fn lerp_self(&mut self, other: Self, amount: Self::Scalar)

Linearly interpolates the length of the vector towards the length of other by the specified amount.

impl<'a, S> From<&'a [S; 2]> for &'a Vector2<S>

fn from(v: &'a [S; 2]) -> &'a Vector2<S>

Converts to this type from the input type.

impl<'a, S> From<&'a (S, S)> for &'a Vector2<S>

fn from(v: &'a (S, S)) -> &'a Vector2<S>

Converts to this type from the input type.

impl<'a, S> From<&'a mut [S; 2]> for &'a mut Vector2<S>

fn from(v: &'a mut [S; 2]) -> &'a mut Vector2<S>

Converts to this type from the input type.

impl<'a, S> From<&'a mut (S, S)> for &'a mut Vector2<S>

fn from(v: &'a mut (S, S)) -> &'a mut Vector2<S>

Converts to this type from the input type.

impl<S: Clone> From<[S; 2]> for Vector2<S>

fn from(v: [S; 2]) -> Vector2<S>

Converts to this type from the input type.

impl<S> From<(S, S)> for Vector2<S>

fn from(v: (S, S)) -> Vector2<S>

Converts to this type from the input type.

impl<S: Hash> Hash for Vector2<S>

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<S> Index<Range<usize>> for Vector2<S>

type Output = [S]

The returned type after indexing.

fn index<'a>(&'a self, i: Range<usize>) -> &'a [S]

Performs the indexing (container[index]) operation.

impl<S> Index<RangeFrom<usize>> for Vector2<S>

type Output = [S]

The returned type after indexing.

fn index<'a>(&'a self, i: RangeFrom<usize>) -> &'a [S]

Performs the indexing (container[index]) operation.

impl<S> Index<RangeFull> for Vector2<S>

type Output = [S]

The returned type after indexing.

fn index<'a>(&'a self, i: RangeFull) -> &'a [S]

Performs the indexing (container[index]) operation.

impl<S> Index<RangeTo<usize>> for Vector2<S>

type Output = [S]

The returned type after indexing.

fn index<'a>(&'a self, i: RangeTo<usize>) -> &'a [S]

Performs the indexing (container[index]) operation.

impl<S> Index<usize> for Vector2<S>

type Output = S

The returned type after indexing.

fn index<'a>(&'a self, i: usize) -> &'a S

Performs the indexing (container[index]) operation.

impl<S> IndexMut<Range<usize>> for Vector2<S>

fn index_mut<'a>(&'a mut self, i: Range<usize>) -> &'a mut [S]

Performs the mutable indexing (container[index]) operation.

impl<S> IndexMut<RangeFrom<usize>> for Vector2<S>

fn index_mut<'a>(&'a mut self, i: RangeFrom<usize>) -> &'a mut [S]

Performs the mutable indexing (container[index]) operation.

impl<S> IndexMut<RangeFull> for Vector2<S>

fn index_mut<'a>(&'a mut self, i: RangeFull) -> &'a mut [S]

Performs the mutable indexing (container[index]) operation.

impl<S> IndexMut<RangeTo<usize>> for Vector2<S>

fn index_mut<'a>(&'a mut self, i: RangeTo<usize>) -> &'a mut [S]

Performs the mutable indexing (container[index]) operation.

impl<S> IndexMut<usize> for Vector2<S>

fn index_mut<'a>(&'a mut self, i: usize) -> &'a mut S

Performs the mutable indexing (container[index]) operation.

impl<S> Into<[S; 2]> for Vector2<S>

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

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

impl<S> Into<(S, S)> for Vector2<S>

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

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

impl<'a, 'b, S: BaseFloat> Mul<&'a Vector2<S>> for &'b Matrix2<S>

type Output = Vector2<S>

The resulting type after applying the * operator.

fn mul(self, v: &'a Vector2<S>) -> Vector2<S>

Performs the * operation.

impl<'a, 'b, S: BaseNum> Mul<&'a Vector2<S>> for &'b Vector2<S>

type Output = Vector2<S>

The resulting type after applying the * operator.

fn mul(self, other: &'a Vector2<S>) -> Vector2<S>

Performs the * operation.

impl<'a, S: BaseNum> Mul<&'a Vector2<S>> for Vector2<S>

type Output = Vector2<S>

The resulting type after applying the * operator.

fn mul(self, other: &'a Vector2<S>) -> Vector2<S>

Performs the * operation.

impl<'a, S: BaseNum> Mul<S> for &'a Vector2<S>

type Output = Vector2<S>

The resulting type after applying the * operator.

fn mul(self, scalar: S) -> Vector2<S>

Performs the * operation.

impl<S: BaseNum> Mul<S> for Vector2<S>

type Output = Vector2<S>

The resulting type after applying the * operator.

fn mul(self, scalar: S) -> Vector2<S>

Performs the * operation.

impl<'a, S: BaseFloat> Mul<Vector2<S>> for &'a Matrix2<S>

type Output = Vector2<S>

The resulting type after applying the * operator.

fn mul(self, v: Vector2<S>) -> Vector2<S>

Performs the * operation.

impl<'a, S: BaseNum> Mul<Vector2<S>> for &'a Vector2<S>

type Output = Vector2<S>

The resulting type after applying the * operator.

fn mul(self, other: Vector2<S>) -> Vector2<S>

Performs the * operation.

impl<S: BaseNum> Mul<Vector2<S>> for Vector2<S>

type Output = Vector2<S>

The resulting type after applying the * operator.

fn mul(self, other: Vector2<S>) -> Vector2<S>

Performs the * operation.

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

type Output = Vector2<S>

The resulting type after applying the - operator.

fn neg(self) -> Vector2<S>

Performs the unary - operation.

impl<S: PartialEq> PartialEq<Vector2<S>> for Vector2<S>

fn eq(&self, other: &Vector2<S>) -> 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 !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<S: BaseFloat + Rand> Rand for Vector2<S>

fn rand<R: Rng>(rng: &mut R) -> Vector2<S>

Generates a random instance of this type using the specified source of randomness.

impl<'a, 'b, S: BaseNum> Rem<&'a Vector2<S>> for &'b Vector2<S>

type Output = Vector2<S>

The resulting type after applying the % operator.

fn rem(self, other: &'a Vector2<S>) -> Vector2<S>

Performs the % operation.

impl<'a, S: BaseNum> Rem<&'a Vector2<S>> for Vector2<S>

type Output = Vector2<S>

The resulting type after applying the % operator.

fn rem(self, other: &'a Vector2<S>) -> Vector2<S>

Performs the % operation.

impl<'a, S: BaseNum> Rem<S> for &'a Vector2<S>

type Output = Vector2<S>

The resulting type after applying the % operator.

fn rem(self, scalar: S) -> Vector2<S>

Performs the % operation.

impl<S: BaseNum> Rem<S> for Vector2<S>

type Output = Vector2<S>

The resulting type after applying the % operator.

fn rem(self, scalar: S) -> Vector2<S>

Performs the % operation.

impl<'a, S: BaseNum> Rem<Vector2<S>> for &'a Vector2<S>

type Output = Vector2<S>

The resulting type after applying the % operator.

fn rem(self, other: Vector2<S>) -> Vector2<S>

Performs the % operation.

impl<S: BaseNum> Rem<Vector2<S>> for Vector2<S>

type Output = Vector2<S>

The resulting type after applying the % operator.

fn rem(self, other: Vector2<S>) -> Vector2<S>

Performs the % operation.

impl<'a, 'b, S: BaseNum> Sub<&'a Vector2<S>> for &'b Vector2<S>

type Output = Vector2<S>

The resulting type after applying the - operator.

fn sub(self, other: &'a Vector2<S>) -> Vector2<S>

Performs the - operation.

impl<'a, S: BaseNum> Sub<&'a Vector2<S>> for Vector2<S>

type Output = Vector2<S>

The resulting type after applying the - operator.

fn sub(self, other: &'a Vector2<S>) -> Vector2<S>

Performs the - operation.

impl<'a, S: BaseNum> Sub<S> for &'a Vector2<S>

type Output = Vector2<S>

The resulting type after applying the - operator.

fn sub(self, scalar: S) -> Vector2<S>

Performs the - operation.

impl<S: BaseNum> Sub<S> for Vector2<S>

type Output = Vector2<S>

The resulting type after applying the - operator.

fn sub(self, scalar: S) -> Vector2<S>

Performs the - operation.

impl<'a, S: BaseNum> Sub<Vector2<S>> for &'a Vector2<S>

type Output = Vector2<S>

The resulting type after applying the - operator.

fn sub(self, other: Vector2<S>) -> Vector2<S>

Performs the - operation.

impl<S: BaseNum> Sub<Vector2<S>> for Vector2<S>

type Output = Vector2<S>

The resulting type after applying the - operator.

fn sub(self, other: Vector2<S>) -> Vector2<S>

Performs the - operation.

impl<S: BaseNum> Vector for Vector2<S>

type Scalar = S

The associated scalar.

fn from_value(scalar: S) -> Vector2<S>

Construct a vector from a single value, replicating it.

fn add_s(self, scalar: S) -> Vector2<S>

Add a scalar to this vector, returning a new vector.

fn sub_s(self, scalar: S) -> Vector2<S>

Subtract a scalar from this vector, returning a new vector.

fn mul_s(self, scalar: S) -> Vector2<S>

Multiply this vector by a scalar, returning a new vector.

fn div_s(self, scalar: S) -> Vector2<S>

Divide this vector by a scalar, returning a new vector.

fn rem_s(self, scalar: S) -> Vector2<S>

Take the remainder of this vector by a scalar, returning a new vector.

fn add_v(self, v: Vector2<S>) -> Vector2<S>

Add this vector to another, returning a new vector.

fn sub_v(self, v: Vector2<S>) -> Vector2<S>

Subtract another vector from this one, returning a new vector.

fn mul_v(self, v: Vector2<S>) -> Vector2<S>

Multiply this vector by another, returning a new vector.

fn div_v(self, v: Vector2<S>) -> Vector2<S>

Divide this vector by another, returning a new vector.

fn rem_v(self, v: Vector2<S>) -> Vector2<S>

Take the remainder of this vector by another, returning a new scalar.

fn add_self_s(&mut self, scalar: S)

Add a scalar to this vector in-place.

fn sub_self_s(&mut self, scalar: S)

Subtract a scalar from this vector, in-place.

fn mul_self_s(&mut self, scalar: S)

Multiply this vector by a scalar, in-place.

fn div_self_s(&mut self, scalar: S)

Divide this vector by a scalar, in-place.

fn rem_self_s(&mut self, scalar: S)

Take the remainder of this vector by a scalar, in-place.

fn add_self_v(&mut self, v: Vector2<S>)

Add another vector to this one, in-place.

fn sub_self_v(&mut self, v: Vector2<S>)

Subtract another vector from this one, in-place.

fn mul_self_v(&mut self, v: Vector2<S>)

Multiply this matrix by another, in-place.

fn div_self_v(&mut self, v: Vector2<S>)

Divide this matrix by anothor, in-place.

fn rem_self_v(&mut self, v: Vector2<S>)

Take the remainder of this vector by another, in-place.

fn dot(self, other: Vector2<S>) -> S

Vector dot product

fn zero() -> Self

The zero vector (with all components set to zero)

fn one() -> Self

The identity vector (with all components set to one)

impl<S: Copy> Copy for Vector2<S>

impl<S: Eq> Eq for Vector2<S>

impl<S> StructuralEq for Vector2<S>

impl<S> StructuralPartialEq for Vector2<S>