Struct gardiz::coord::Vec2

pub struct Vec2<T> {
    pub y: T,
    pub x: T,
}

Generic 2D vector. It could be a coordinate, it could be size, anything like that.

Fields

y: T

Value of the Y-coordinate.

x: T

Value of the X-coordinate.

Implementations

impl<T> Vec2<T>

pub fn from_axes<F>(mapper: F) -> Selfwhere F: FnMut(Axis) -> T,

Creates a vector from a function over axis to data.

pub fn as_ref(&self) -> Vec2<&T>

Maps coordinates to references.

pub fn as_mut(&mut self) -> Vec2<&mut T>

Maps coordinates to mutable references.

pub fn map<F, U>(self, mapper: F) -> Vec2<U>where F: FnMut(T) -> U,

Maps each coordinate to a given value and builds a new vector from the output of the mapping function.

pub fn map_with_axes<F, U>(self, mapper: F) -> Vec2<U>where F: FnMut(Axis, T) -> U,

Maps each coordinate to a given value in a new vector, but the mapping function gets the axis of each coordinate.

pub fn fold<F, U>(self, init: U, folder: F) -> Uwhere F: FnMut(T, U) -> U,

Performs a fold/reduce: i.e. accumulates the coordinates into a final result, given an initial value and an accumulator function, using first x and then y.

pub fn fold_rev<F, U>(self, init: U, folder: F) -> Uwhere F: FnMut(U, T) -> U,

Performs a fold/reduce: i.e. accumulates the coordinates given initial value and accumulator function, but using first y the x.

pub fn zip<U>(self, other: Vec2<U>) -> Vec2<(T, U)>

Zips two vectors into a vector of tuples. The result is:

zip([a,b], [c,d]) = [(a,c), (b,d)]

pub fn zip_with<F, U, B>(self, other: Vec2<U>, zipper: F) -> Vec2<B>where F: FnMut(T, U) -> B,

Zips two vectors using a zipper function f. The result is:

zip_with(f, [a,b], [c,d]) = [f(a,c), f(b,d)]

pub fn borrow<K>(&self) -> Vec2<&K>where T: Borrow<K>,

Borrows each coordinate.

pub fn borrow_mut<K>(&mut self) -> Vec2<&mut K>where T: BorrowMut<K>,

Borrows each coordinate as mutable references.

impl<'elems, T> Vec2<&'elems T>

pub fn cloned(self) -> Vec2<T>where T: Clone,

Clones every coordinate.

pub fn copied(self) -> Vec2<T>where T: Copy,

Copies every coordinate.

pub fn into_borrow<K>(self) -> Vec2<&'elems K>where T: Borrow<K>,

Borrows each coordinate.

impl<'elems, T> Vec2<&'elems mut T>

pub fn into_borrow_mut<K>(self) -> Vec2<&'elems mut K>where T: BorrowMut<K>,

Borrows each coordinate as mutable references.

impl<T> Vec2<T>

pub fn dot<U, A>(self, other: Vec2<U>) -> A::Outputwhere T: Mul<U, Output = A>, A: Add,

Computes the dot product of the vector, i.e. x1 * x2 + y1 * y2.

Examples

use gardiz::coord::Vec2;

let left: Vec2<u16> = Vec2 { x: 5, y: 3 };
let right = Vec2 { x: 4, y: 8 };
assert_eq!(left.dot(right), 5 * 4 + 3 * 8);

pub fn dot_ref<'this, 'other, U, A>( &'this self, other: &'other Vec2<U> ) -> A::Outputwhere &'this T: Mul<&'other U, Output = A>, A: Add,

Computes the dot product of the vector, by reference.

pub fn wrapping_dot(&self, other: &Self) -> Twhere T: WrappingAdd + WrappingMul,

Computes the dot product of the vector, wrapping around overflow.

pub fn saturating_dot(&self, other: &Self) -> Twhere T: SaturatingAdd + SaturatingMul,

Computes the dot product of the vector, saturating when it overflows.

pub fn checked_dot(&self, other: &Self) -> Option<T>where T: CheckedAdd + CheckedMul,

Computes the dot product of the vector, returning None if it overflows.

pub fn sqr_magnitude<A>(self) -> A::Outputwhere T: Clone + Mul<Output = A>, A: Add,

Computes the square of the magnitude of the vector. The formula is: x * x + y * y.

Examples

use gardiz::coord::Vec2;

let vector: Vec2<u16> = Vec2 { x: 5, y: 3 };
assert_eq!(vector.sqr_magnitude(), 5 * 5 + 3 * 3);

pub fn sqr_magnitude_ref<'this, A>(&'this self) -> A::Outputwhere &'this T: Mul<Output = A>, A: Add,

Computes the square of the magnitude of the vector by reference.

pub fn wrapping_sqr_mag(&self) -> Twhere T: WrappingAdd + WrappingMul,

Computes the square of the magnitude of the vector, wrapping on overflow.

pub fn saturating_sqr_mag(&self) -> Twhere T: SaturatingMul + SaturatingAdd,

Computes the square of the magnitude of the vector, saturating on overflow.

pub fn checked_sqr_mag(&self) -> Option<T>where T: CheckedMul + CheckedAdd,

Computes the square of the magnitude of the vector, returning None on overflow.

pub fn magnitude<A>(self) -> A::Outputwhere T: Clone + Mul<Output = A>, A: Add, A::Output: Float,

Computes the magnitude of a float vector. The formula is sqrt(x*x + y*y).

pub fn magnitude_ref<'this, A>(&'this self) -> A::Outputwhere &'this T: Mul<&'this T, Output = A>, A: Add, A::Output: Float,

Computes the magnitude of a float vector by reference.

pub fn wrapping_mag(&self) -> Twhere T: WrappingAdd + WrappingMul + Float,

Computes the magnitude of a float vector wrapping around on overflow.

pub fn saturating_mag(&self) -> Twhere T: SaturatingAdd + SaturatingMul + Float,

Computes the magnitude of a float vector saturating on overflow.

pub fn checked_mag(&self) -> Option<T>where T: CheckedAdd + CheckedMul + Float,

Computes the magnitude of a float vector returning None on overflow.

pub fn int_magnitude<A>(self) -> A::Outputwhere T: Clone + Mul<Output = A>, A: Add, A::Output: Roots,

Computes the magnitude of the vector truncated (as an integer).

Examples

use gardiz::coord::Vec2;
use num::integer::Roots;

let vector: Vec2<u16> = Vec2 { x: 4, y: 3 };
assert_eq!(vector.int_magnitude(), 5);

pub fn int_magnitude_ref<'this, A>(&'this self) -> A::Outputwhere &'this T: Mul<&'this T, Output = A>, A: Add, A::Output: Roots,

Computes the magnitude of the vector truncated (as an integer), by reference.

pub fn wrapping_int_mag(&self) -> Twhere T: WrappingAdd + WrappingMul + Roots,

Computes the magnitude of the vector truncated (as an integer), wrapping around on overflow.

pub fn saturating_int_mag(&self) -> Twhere T: SaturatingAdd + SaturatingMul + Roots,

Computes the magnitude of the vector truncated (as an integer), saturating on overflow.

pub fn checked_int_mag(&self) -> Option<T>where T: CheckedAdd + CheckedMul + Roots,

Computes the magnitude of the vector truncated (as an integer), returning None on overflow.

pub fn move_one(self, direction: Direction) -> Selfwhere T: Add<Output = T> + Sub<Output = T> + One,

Moves this vector in the given direction by one.

Examples

use gardiz::coord::Vec2;
use gardiz::direc::Direction;

let vector: Vec2<u16> = Vec2 { x: 4, y: 3 };
assert_eq!(vector.move_one(Direction::Up), Vec2 { x: 4, y: 2 });

pub fn wrapping_move(self, direction: Direction) -> Selfwhere T: WrappingAdd + WrappingSub + One,

Moves this vector in the given direction by one, wrapping around on overflow.

pub fn saturating_move(self, direction: Direction) -> Selfwhere T: SaturatingAdd + SaturatingSub + One,

Moves this vector in the given direction by one, saturating on overflow.

pub fn checked_move(self, direction: Direction) -> Option<Self>where T: CheckedAdd + CheckedSub + One,

Moves this vector in the given direction by one, returning None on overflow.

pub fn move_by<U>(self, vector: DirecVector<U>) -> Selfwhere T: Add<U, Output = T> + Sub<U, Output = T>,

Moves this vector in the given direction by the given amount.

Examples

use gardiz::coord::Vec2;
use gardiz::direc::{Direction, DirecVector};

let vector: Vec2<u16> = Vec2 { x: 4, y: 3 };
let direc_vector = DirecVector { direction: Direction::Right, magnitude: 5 };
assert_eq!(vector.move_by(direc_vector), Vec2 { x: 9, y: 3 });

pub fn wrapping_move_by(self, vector: &DirecVector<T>) -> Selfwhere T: WrappingAdd + WrappingSub,

Moves this vector in the given direction by the given amount, wrapping around on overflow.

pub fn saturating_move_by(self, vector: &DirecVector<T>) -> Selfwhere T: SaturatingAdd + SaturatingSub,

Moves this vector in the given direction by the given amount, saturating on overflow.

pub fn checked_move_by(self, vector: &DirecVector<T>) -> Option<Self>where T: CheckedAdd + CheckedSub,

Moves this vector in the given direction by the given amount, returning None on overflow.

pub fn direction_to(&self, other: &Self) -> Option<Direction>where T: Ord,

Returns a “straight” direction into another point. Returns None if there is no straight direction between this point and the other point.

pub fn flip_y(self) -> Selfwhere T: Sub<Output = T> + Neg<Output = T> + One,

Useful for showing signed coordinates to humans, when the vector represents coordinates. Flips the Y coordinate, i.e. inverts the number line, the greatest value becomes the lesser, the lesser becomes the greatest, made for 2’s complement numbers. The formula is something like this:

flip_y([x,y]) = [x, -1 - y]

pub fn center_origin_at<U>(self, origin: &Vec2<T>) -> Vec2<U>where Self: ExcessToSigned<Target = Vec2<U>>, U: Sub<Output = U> + Neg<Output = U> + One,

Useful for showing unsigned coordinates to humans, when the vector represents coordinates. First, it reinterprets the unsigned coordinats as “excess of N” numbers, such that N is the new origin, then it flips the Y coordinate. The formula is something like this:

center_origin_at([x,y], N) = [x - N, -1 - (y - N)]

Examples

use gardiz::coord::Vec2;

let vector: Vec2<u8> = Vec2 { x: 105, y: 97 };
let centered: Vec2<i8> = Vec2 { x: 5, y: 102 };
assert_eq!(
    vector.center_origin_at(&Vec2 { x: 100, y: 200 }),
    centered
);

pub fn center_origin<U>(self) -> Vec2<U>where Self: ExcessToSigned<Target = Vec2<U>> + HalfExcess, U: Sub<Output = U> + Neg<Output = U> + One,

Useful for showing unsigned coordinates to humans, when the vector represents coordinates. Like center_origin_at, but it uses half of the unsigned type’s maximum value as the excess (with truncated division). First of all, half the maximum value becomes the new zero, then Y-axis is flipped. The formula is something like this:

center_origin_at([x,y]) = [x - 1000...0000, -1 - (y - 1000...0000)]

Examples

use gardiz::coord::Vec2;

let vector: Vec2<u8> = Vec2 { x: 127, y: 130 };
let centered: Vec2<i8> = Vec2 { x: -1, y: -3 };
assert_eq!(vector.center_origin(), centered);

impl<T> Vec2<Option<T>>

pub fn transpose(self) -> Option<Vec2<T>>

Transpose a vector of options into an option of vectors: a single coordinate with None makes the return value be None, while both being Some make it be Some.

impl<T, E> Vec2<Result<T, E>>

pub fn transpose_err_x(self) -> Result<Vec2<T>, E>

Transpose a vector of Result into a Result of vectors: a single coordinate with Err makes the return value be Err, while both being Ok make it be Ok. An error on x gets priority over an error on y.

pub fn transpose_err_y(self) -> Result<Vec2<T>, E>

Transpose a vector of Result into a Result of vectors: a single coordinate with Err makes the return value be Err, while both being Ok make it be Ok. An error on y gets priority over an error on x.

Trait Implementations

impl<'this, 'other, T, U> Add<&'other Vec2<U>> for &'this Vec2<T>where &'this T: Add<&'other U>,

type Output = Vec2<<&'this T as Add<&'other U>>::Output>

The resulting type after applying the + operator.

fn add(self, other: &'other Vec2<U>) -> Self::Output

Performs the + operation.

impl<'other, T, U> Add<&'other Vec2<U>> for Vec2<T>where T: Add<&'other U>,

type Output = Vec2<<T as Add<&'other U>>::Output>

The resulting type after applying the + operator.

fn add(self, other: &'other Vec2<U>) -> Self::Output

Performs the + operation.

impl<'this, T, U> Add<Vec2<U>> for &'this Vec2<T>where &'this T: Add<U>,

type Output = Vec2<<&'this T as Add<U>>::Output>

The resulting type after applying the + operator.

fn add(self, other: Vec2<U>) -> Self::Output

Performs the + operation.

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

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

The resulting type after applying the + operator.

fn add(self, other: Vec2<U>) -> Self::Output

Performs the + operation.

impl<'param, T, U> AddAssign<&'param Vec2<U>> for Vec2<T>where T: AddAssign<&'param U>,

fn add_assign(&mut self, other: &'param Vec2<U>)

Performs the += operation.

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

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

Performs the += operation.

impl<T> Bounded for Vec2<T>where T: Bounded,

fn min_value() -> Self

Returns the smallest finite number this type can represent

fn max_value() -> Self

Returns the largest finite number this type can represent

impl<T> CastSigned for Vec2<T>where T: CastSigned,

type Target = Vec2<<T as CastSigned>::Target>

Type of the target signed version.

fn cast_signed(&self) -> Self::Target

Bit-casts the given (self) unsigned number into a signed version.

impl<T> CastUnsigned for Vec2<T>where T: CastUnsigned,

type Target = Vec2<<T as CastUnsigned>::Target>

Type of the target unsigned version.

fn cast_unsigned(&self) -> Self::Target

Bit-casts the given (self) signed number into an unsigned version.

impl<T> CheckedAdd for Vec2<T>where T: CheckedAdd,

fn checked_add(&self, other: &Self) -> Option<Self>

Adds two numbers, checking for overflow. If overflow happens, None is returned.

impl<T> CheckedDiv for Vec2<T>where T: CheckedDiv,

fn checked_div(&self, other: &Self) -> Option<Self>

Divides two numbers, checking for underflow, overflow and division by zero. If any of that happens, None is returned.

impl<T> CheckedMul for Vec2<T>where T: CheckedMul,

fn checked_mul(&self, other: &Self) -> Option<Self>

Multiplies two numbers, checking for underflow or overflow. If underflow or overflow happens, None is returned.

impl<T> CheckedNeg for Vec2<T>where T: CheckedNeg,

fn checked_neg(&self) -> Option<Self>

Negates a number, returning None for results that can’t be represented, like signed MIN values that can’t be positive, or non-zero unsigned values that can’t be negative.

impl<T> CheckedRem for Vec2<T>where T: CheckedRem,

fn checked_rem(&self, other: &Self) -> Option<Self>

Finds the remainder of dividing two numbers, checking for underflow, overflow and division by zero. If any of that happens, None is returned.

impl<T> CheckedSub for Vec2<T>where T: CheckedSub,

fn checked_sub(&self, other: &Self) -> Option<Self>

Subtracts two numbers, checking for underflow. If underflow happens, None is returned.

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

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

Returns a copy of the value.

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

Performs copy-assignment from source.

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<'de, T> Deserialize<'de> for Vec2<T>where T: Deserialize<'de>,

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

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

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

Formats the value using the given formatter.

impl<'this, 'other, T, U> Div<&'other Vec2<U>> for &'this Vec2<T>where &'this T: Div<&'other U>,

type Output = Vec2<<&'this T as Div<&'other U>>::Output>

The resulting type after applying the / operator.

fn div(self, other: &'other Vec2<U>) -> Self::Output

Performs the / operation.

impl<'other, T, U> Div<&'other Vec2<U>> for Vec2<T>where T: Div<&'other U>,

type Output = Vec2<<T as Div<&'other U>>::Output>

The resulting type after applying the / operator.

fn div(self, other: &'other Vec2<U>) -> Self::Output

Performs the / operation.

impl<'this, T, U> Div<Vec2<U>> for &'this Vec2<T>where &'this T: Div<U>,

type Output = Vec2<<&'this T as Div<U>>::Output>

The resulting type after applying the / operator.

fn div(self, other: Vec2<U>) -> Self::Output

Performs the / operation.

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

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

The resulting type after applying the / operator.

fn div(self, other: Vec2<U>) -> Self::Output

Performs the / operation.

impl<'param, T, U> DivAssign<&'param Vec2<U>> for Vec2<T>where T: DivAssign<&'param U>,

fn div_assign(&mut self, other: &'param Vec2<U>)

Performs the /= operation.

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

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

Performs the /= operation.

impl<T> Extend<Vec2<T>> for Set<T>where T: Ord + Clone,

fn extend<I>(&mut self, iter: I)where I: IntoIterator<Item = Vec2<T>>,

Extends a collection with the contents of an iterator.

fn extend_one(&mut self, item: A)

🔬This is a nightly-only experimental API. (extend_one)

Extends a collection with exactly one element.

fn extend_reserve(&mut self, additional: usize)

🔬This is a nightly-only experimental API. (extend_one)

Reserves capacity in a collection for the given number of additional elements.

impl<'this, T> From<&'this Vec2<T>> for Vec2<&'this T>

fn from(input: &'this Vec2<T>) -> Self

Converts to this type from the input type.

impl<'this, T> From<&'this mut Vec2<T>> for Vec2<&'this mut T>

fn from(input: &'this mut Vec2<T>) -> Self

Converts to this type from the input type.

impl<T> FromIterator<Vec2<T>> for Set<T>where T: Ord + Clone,

fn from_iter<I>(iter: I) -> Selfwhere I: IntoIterator<Item = Vec2<T>>,

Creates a value from an iterator.

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<Axis> for Vec2<T>

type Output = T

The returned type after indexing.

fn index(&self, axis: Axis) -> &Self::Output

Performs the indexing (container[index]) operation.

impl<T> IndexMut<Axis> for Vec2<T>

fn index_mut(&mut self, axis: Axis) -> &mut Self::Output

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

impl<'this, 'other, T, U> Mul<&'other Vec2<U>> for &'this Vec2<T>where &'this T: Mul<&'other U>,

type Output = Vec2<<&'this T as Mul<&'other U>>::Output>

The resulting type after applying the * operator.

fn mul(self, other: &'other Vec2<U>) -> Self::Output

Performs the * operation.

impl<'other, T, U> Mul<&'other Vec2<U>> for Vec2<T>where T: Mul<&'other U>,

type Output = Vec2<<T as Mul<&'other U>>::Output>

The resulting type after applying the * operator.

fn mul(self, other: &'other Vec2<U>) -> Self::Output

Performs the * operation.

impl<'this, T, U> Mul<Vec2<U>> for &'this Vec2<T>where &'this T: Mul<U>,

type Output = Vec2<<&'this T as Mul<U>>::Output>

The resulting type after applying the * operator.

fn mul(self, other: Vec2<U>) -> Self::Output

Performs the * operation.

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

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

The resulting type after applying the * operator.

fn mul(self, other: Vec2<U>) -> Self::Output

Performs the * operation.

impl<'param, T, U> MulAssign<&'param Vec2<U>> for Vec2<T>where T: MulAssign<&'param U>,

fn mul_assign(&mut self, other: &'param Vec2<U>)

Performs the *= operation.

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

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

Performs the *= operation.

impl<'this, T> Neg for &'this Vec2<T>where &'this T: Neg,

type Output = Vec2<<&'this T as Neg>::Output>

The resulting type after applying the - operator.

fn neg(self) -> Self::Output

Performs the unary - operation.

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

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

The resulting type after applying the - operator.

fn neg(self) -> Self::Output

Performs the unary - operation.

impl<T> Not for Vec2<T>

type Output = Vec2<T>

The resulting type after applying the ! operator.

fn not(self) -> Self::Output

Performs the unary ! operation.

impl<T> Num for Vec2<T>where T: Num,

type FromStrRadixErr = FromStrRadixErr<<T as Num>::FromStrRadixErr>

fn from_str_radix( input: &str, radix: u32 ) -> Result<Self, Self::FromStrRadixErr>

Convert from a string and radix (typically 2..=36).

impl<T> One for Vec2<T>where T: One,

fn one() -> Self

Returns the multiplicative identity element of Self, 1.

fn set_one(&mut self)

Sets self to the multiplicative identity element of Self, 1.

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) -> Selfwhere Self: Sized,

Compares and returns the maximum of two values.

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

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Selfwhere Self: Sized + PartialOrd<Self>,

Restrict a value to a certain interval.

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

fn eq(&self, other: &Vec2<T>) -> 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<T: PartialOrd> PartialOrd<Vec2<T>> 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

This method tests less than (for self and other) and is used by the < operator.

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

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

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

This method tests greater than (for self and other) and is used by the > operator.

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

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

impl<'this, 'other, T, U> Pow<&'other Vec2<U>> for &'this Vec2<T>where &'this T: Pow<&'other U>,

type Output = Vec2<<&'this T as Pow<&'other U>>::Output>

The result after applying the operator.

fn pow(self, other: &'other Vec2<U>) -> Self::Output

Returns self to the power rhs.

impl<'other, T, U> Pow<&'other Vec2<U>> for Vec2<T>where T: Pow<&'other U>,

type Output = Vec2<<T as Pow<&'other U>>::Output>

The result after applying the operator.

fn pow(self, other: &'other Vec2<U>) -> Self::Output

Returns self to the power rhs.

impl<'this, T, U> Pow<Vec2<U>> for &'this Vec2<T>where &'this T: Pow<U>,

type Output = Vec2<<&'this T as Pow<U>>::Output>

The result after applying the operator.

fn pow(self, other: Vec2<U>) -> Self::Output

Returns self to the power rhs.

impl<T, U> Pow<Vec2<U>> for Vec2<T>where T: Pow<U>,

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

The result after applying the operator.

fn pow(self, other: Vec2<U>) -> Self::Output

Returns self to the power rhs.

impl<'this, 'other, T, U> Rem<&'other Vec2<U>> for &'this Vec2<T>where &'this T: Rem<&'other U>,

type Output = Vec2<<&'this T as Rem<&'other U>>::Output>

The resulting type after applying the % operator.

fn rem(self, other: &'other Vec2<U>) -> Self::Output

Performs the % operation.

impl<'other, T, U> Rem<&'other Vec2<U>> for Vec2<T>where T: Rem<&'other U>,

type Output = Vec2<<T as Rem<&'other U>>::Output>

The resulting type after applying the % operator.

fn rem(self, other: &'other Vec2<U>) -> Self::Output

Performs the % operation.

impl<'this, T, U> Rem<Vec2<U>> for &'this Vec2<T>where &'this T: Rem<U>,

type Output = Vec2<<&'this T as Rem<U>>::Output>

The resulting type after applying the % operator.

fn rem(self, other: Vec2<U>) -> Self::Output

Performs the % operation.

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

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

The resulting type after applying the % operator.

fn rem(self, other: Vec2<U>) -> Self::Output

Performs the % operation.

impl<'param, T, U> RemAssign<&'param Vec2<U>> for Vec2<T>where T: RemAssign<&'param U>,

fn rem_assign(&mut self, other: &'param Vec2<U>)

Performs the %= operation.

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

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

Performs the %= operation.

impl<T> SaturatingAdd for Vec2<T>where T: SaturatingAdd,

fn saturating_add(&self, other: &Self) -> Self

Saturating addition. Computes self + other, saturating at the relevant high or low boundary of the type.

impl<T> SaturatingMul for Vec2<T>where T: SaturatingMul,

fn saturating_mul(&self, other: &Self) -> Self

Saturating multiplication. Computes self * other, saturating at the relevant high or low boundary of the type.

impl<T> SaturatingSub for Vec2<T>where T: SaturatingSub,

fn saturating_sub(&self, other: &Self) -> Self

Saturating subtraction. Computes self - other, saturating at the relevant high or low boundary of the type.

impl<T> Serialize for Vec2<T>where T: Serialize,

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>where __S: Serializer,

Serialize this value into the given Serde serializer.

impl<T> Signed for Vec2<T>where T: Signed,

fn abs(&self) -> Self

Computes the absolute value.

fn abs_sub(&self, other: &Self) -> Self

The positive difference of two numbers.

fn signum(&self) -> Self

Returns the sign of the number.

fn is_positive(&self) -> bool

Returns true if the number is positive and false if the number is zero or negative.

fn is_negative(&self) -> bool

Returns true if the number is negative and false if the number is zero or positive.

impl<'this, 'other, T, U> Sub<&'other Vec2<U>> for &'this Vec2<T>where &'this T: Sub<&'other U>,

type Output = Vec2<<&'this T as Sub<&'other U>>::Output>

The resulting type after applying the - operator.

fn sub(self, other: &'other Vec2<U>) -> Self::Output

Performs the - operation.

impl<'other, T, U> Sub<&'other Vec2<U>> for Vec2<T>where T: Sub<&'other U>,

type Output = Vec2<<T as Sub<&'other U>>::Output>

The resulting type after applying the - operator.

fn sub(self, other: &'other Vec2<U>) -> Self::Output

Performs the - operation.

impl<'this, T, U> Sub<Vec2<U>> for &'this Vec2<T>where &'this T: Sub<U>,

type Output = Vec2<<&'this T as Sub<U>>::Output>

The resulting type after applying the - operator.

fn sub(self, other: Vec2<U>) -> Self::Output

Performs the - operation.

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

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

The resulting type after applying the - operator.

fn sub(self, other: Vec2<U>) -> Self::Output

Performs the - operation.

impl<'param, T, U> SubAssign<&'param Vec2<U>> for Vec2<T>where T: SubAssign<&'param U>,

fn sub_assign(&mut self, other: &'param Vec2<U>)

Performs the -= operation.

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

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

Performs the -= operation.

impl<T> WrappingAdd for Vec2<T>where T: WrappingAdd,

fn wrapping_add(&self, other: &Self) -> Self

Wrapping (modular) addition. Computes self + other, wrapping around at the boundary of the type.

impl<T> WrappingMul for Vec2<T>where T: WrappingMul,

fn wrapping_mul(&self, other: &Self) -> Self

Wrapping (modular) multiplication. Computes self * other, wrapping around at the boundary of the type.

impl<T> WrappingNeg for Vec2<T>where T: WrappingNeg,

fn wrapping_neg(&self) -> Self

Wrapping (modular) negation. Computes -self, wrapping around at the boundary of the type.

impl<T> WrappingSub for Vec2<T>where T: WrappingSub,

fn wrapping_sub(&self, other: &Self) -> Self

Wrapping (modular) subtraction. Computes self - other, wrapping around at the boundary of the type.

impl<T> Zero for Vec2<T>where T: Zero,

fn zero() -> Self

Returns the additive identity element of Self, 0.

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.

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

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

impl<T> StructuralEq for Vec2<T>

impl<T> StructuralPartialEq for Vec2<T>

impl<T> Unsigned for Vec2<T>where T: Unsigned,