Struct vek2d::Vec2d

pub struct Vec2d<T> { /* fields omitted */ }

Implementations

impl Vec2d<f32>

pub fn unit_vector(direction: f32) -> Self

Creates a new unit vector in a specific direction

pub fn normalise(self) -> Self

Normalises the vector

pub fn magnitude(&self) -> f32

Returns the magnitude/length of the vector

pub fn square_magnitude(&self) -> f32

Returns the (non-sqrt) magnitude/length of the vector

pub fn direction(&self) -> f32

Returns direction the vector is pointing

pub fn clear(&mut self)

impl Vec2d<f64>

pub fn unit_vector(direction: f64) -> Self

Creates a new unit vector in a specific direction

pub fn normalise(self) -> Self

Normalises the vector

pub fn magnitude(&self) -> f64

Returns the magnitude/length of the vector

pub fn square_magnitude(&self) -> f64

Returns the (non-sqrt) magnitude/length of the vector

pub fn direction(&self) -> f64

Returns direction the vector is pointing

pub fn clear(&mut self)

impl<T> Vec2d<T>

pub fn new(x: T, y: T) -> Vec2d<T> where
    T: Add + Mul + Div + Sub + Copy, 

pub fn x(&self) -> T where
    T: Add + Mul + Div + Sub + Copy, 

pub fn set_x(&mut self, x: T) where
    T: Add + Mul + Div + Sub + Copy, 

pub fn y(&self) -> T where
    T: Add + Mul + Div + Sub + Copy, 

pub fn set_y(&mut self, y: T) where
    T: Add + Mul + Div + Sub + Copy, 

Trait Implementations

impl<'_> Add<&'_ Vec2d<f32>> for Vec2d<f32>

type Output = <Vec2d<f32> as Add<Vec2d<f32>>>::Output

The resulting type after applying the + operator.

fn add(self, other: &Vec2d<f32>) -> <Vec2d<f32> as Add<Vec2d<f32>>>::Output

Performs the + operation.

impl<'_, '_> Add<&'_ Vec2d<f32>> for &'_ Vec2d<f32>

type Output = <Vec2d<f32> as Add<Vec2d<f32>>>::Output

The resulting type after applying the + operator.

fn add(self, other: &Vec2d<f32>) -> <Vec2d<f32> as Add<Vec2d<f32>>>::Output

Performs the + operation.

impl<'_> Add<&'_ Vec2d<f64>> for Vec2d<f64>

type Output = <Vec2d<f64> as Add<Vec2d<f64>>>::Output

The resulting type after applying the + operator.

fn add(self, other: &Vec2d<f64>) -> <Vec2d<f64> as Add<Vec2d<f64>>>::Output

Performs the + operation.

impl<'_, '_> Add<&'_ Vec2d<f64>> for &'_ Vec2d<f64>

type Output = <Vec2d<f64> as Add<Vec2d<f64>>>::Output

The resulting type after applying the + operator.

fn add(self, other: &Vec2d<f64>) -> <Vec2d<f64> as Add<Vec2d<f64>>>::Output

Performs the + operation.

impl<'_> Add<&'_ Vec2d<i128>> for Vec2d<i128>

type Output = <Vec2d<i128> as Add<Vec2d<i128>>>::Output

The resulting type after applying the + operator.

fn add(self, other: &Vec2d<i128>) -> <Vec2d<i128> as Add<Vec2d<i128>>>::Output

Performs the + operation.

impl<'_, '_> Add<&'_ Vec2d<i128>> for &'_ Vec2d<i128>

type Output = <Vec2d<i128> as Add<Vec2d<i128>>>::Output

The resulting type after applying the + operator.

fn add(self, other: &Vec2d<i128>) -> <Vec2d<i128> as Add<Vec2d<i128>>>::Output

Performs the + operation.

impl<'_> Add<&'_ Vec2d<i16>> for Vec2d<i16>

type Output = <Vec2d<i16> as Add<Vec2d<i16>>>::Output

The resulting type after applying the + operator.

fn add(self, other: &Vec2d<i16>) -> <Vec2d<i16> as Add<Vec2d<i16>>>::Output

Performs the + operation.

impl<'_, '_> Add<&'_ Vec2d<i16>> for &'_ Vec2d<i16>

type Output = <Vec2d<i16> as Add<Vec2d<i16>>>::Output

The resulting type after applying the + operator.

fn add(self, other: &Vec2d<i16>) -> <Vec2d<i16> as Add<Vec2d<i16>>>::Output

Performs the + operation.

impl<'_> Add<&'_ Vec2d<i32>> for Vec2d<i32>

type Output = <Vec2d<i32> as Add<Vec2d<i32>>>::Output

The resulting type after applying the + operator.

fn add(self, other: &Vec2d<i32>) -> <Vec2d<i32> as Add<Vec2d<i32>>>::Output

Performs the + operation.

impl<'_, '_> Add<&'_ Vec2d<i32>> for &'_ Vec2d<i32>

type Output = <Vec2d<i32> as Add<Vec2d<i32>>>::Output

The resulting type after applying the + operator.

fn add(self, other: &Vec2d<i32>) -> <Vec2d<i32> as Add<Vec2d<i32>>>::Output

Performs the + operation.

impl<'_> Add<&'_ Vec2d<i64>> for Vec2d<i64>

type Output = <Vec2d<i64> as Add<Vec2d<i64>>>::Output

The resulting type after applying the + operator.

fn add(self, other: &Vec2d<i64>) -> <Vec2d<i64> as Add<Vec2d<i64>>>::Output

Performs the + operation.

impl<'_, '_> Add<&'_ Vec2d<i64>> for &'_ Vec2d<i64>

type Output = <Vec2d<i64> as Add<Vec2d<i64>>>::Output

The resulting type after applying the + operator.

fn add(self, other: &Vec2d<i64>) -> <Vec2d<i64> as Add<Vec2d<i64>>>::Output

Performs the + operation.

impl<'_> Add<&'_ Vec2d<i8>> for Vec2d<i8>

type Output = <Vec2d<i8> as Add<Vec2d<i8>>>::Output

The resulting type after applying the + operator.

fn add(self, other: &Vec2d<i8>) -> <Vec2d<i8> as Add<Vec2d<i8>>>::Output

Performs the + operation.

impl<'_, '_> Add<&'_ Vec2d<i8>> for &'_ Vec2d<i8>

type Output = <Vec2d<i8> as Add<Vec2d<i8>>>::Output

The resulting type after applying the + operator.

fn add(self, other: &Vec2d<i8>) -> <Vec2d<i8> as Add<Vec2d<i8>>>::Output

Performs the + operation.

impl<'_> Add<&'_ Vec2d<isize>> for Vec2d<isize>

type Output = <Vec2d<isize> as Add<Vec2d<isize>>>::Output

The resulting type after applying the + operator.

fn add(
    self,
    other: &Vec2d<isize>
) -> <Vec2d<isize> as Add<Vec2d<isize>>>::Output

Performs the + operation.

impl<'_, '_> Add<&'_ Vec2d<isize>> for &'_ Vec2d<isize>

type Output = <Vec2d<isize> as Add<Vec2d<isize>>>::Output

The resulting type after applying the + operator.

fn add(
    self,
    other: &Vec2d<isize>
) -> <Vec2d<isize> as Add<Vec2d<isize>>>::Output

Performs the + operation.

impl<'_> Add<&'_ Vec2d<u128>> for Vec2d<u128>

type Output = <Vec2d<u128> as Add<Vec2d<u128>>>::Output

The resulting type after applying the + operator.

fn add(self, other: &Vec2d<u128>) -> <Vec2d<u128> as Add<Vec2d<u128>>>::Output

Performs the + operation.

impl<'_, '_> Add<&'_ Vec2d<u128>> for &'_ Vec2d<u128>

type Output = <Vec2d<u128> as Add<Vec2d<u128>>>::Output

The resulting type after applying the + operator.

fn add(self, other: &Vec2d<u128>) -> <Vec2d<u128> as Add<Vec2d<u128>>>::Output

Performs the + operation.

impl<'_> Add<&'_ Vec2d<u16>> for Vec2d<u16>

type Output = <Vec2d<u16> as Add<Vec2d<u16>>>::Output

The resulting type after applying the + operator.

fn add(self, other: &Vec2d<u16>) -> <Vec2d<u16> as Add<Vec2d<u16>>>::Output

Performs the + operation.

impl<'_, '_> Add<&'_ Vec2d<u16>> for &'_ Vec2d<u16>

type Output = <Vec2d<u16> as Add<Vec2d<u16>>>::Output

The resulting type after applying the + operator.

fn add(self, other: &Vec2d<u16>) -> <Vec2d<u16> as Add<Vec2d<u16>>>::Output

Performs the + operation.

impl<'_> Add<&'_ Vec2d<u32>> for Vec2d<u32>

type Output = <Vec2d<u32> as Add<Vec2d<u32>>>::Output

The resulting type after applying the + operator.

fn add(self, other: &Vec2d<u32>) -> <Vec2d<u32> as Add<Vec2d<u32>>>::Output

Performs the + operation.

impl<'_, '_> Add<&'_ Vec2d<u32>> for &'_ Vec2d<u32>

type Output = <Vec2d<u32> as Add<Vec2d<u32>>>::Output

The resulting type after applying the + operator.

fn add(self, other: &Vec2d<u32>) -> <Vec2d<u32> as Add<Vec2d<u32>>>::Output

Performs the + operation.

impl<'_> Add<&'_ Vec2d<u64>> for Vec2d<u64>

type Output = <Vec2d<u64> as Add<Vec2d<u64>>>::Output

The resulting type after applying the + operator.

fn add(self, other: &Vec2d<u64>) -> <Vec2d<u64> as Add<Vec2d<u64>>>::Output

Performs the + operation.

impl<'_, '_> Add<&'_ Vec2d<u64>> for &'_ Vec2d<u64>

type Output = <Vec2d<u64> as Add<Vec2d<u64>>>::Output

The resulting type after applying the + operator.

fn add(self, other: &Vec2d<u64>) -> <Vec2d<u64> as Add<Vec2d<u64>>>::Output

Performs the + operation.

impl<'_> Add<&'_ Vec2d<u8>> for Vec2d<u8>

type Output = <Vec2d<u8> as Add<Vec2d<u8>>>::Output

The resulting type after applying the + operator.

fn add(self, other: &Vec2d<u8>) -> <Vec2d<u8> as Add<Vec2d<u8>>>::Output

Performs the + operation.

impl<'_, '_> Add<&'_ Vec2d<u8>> for &'_ Vec2d<u8>

type Output = <Vec2d<u8> as Add<Vec2d<u8>>>::Output

The resulting type after applying the + operator.

fn add(self, other: &Vec2d<u8>) -> <Vec2d<u8> as Add<Vec2d<u8>>>::Output

Performs the + operation.

impl<'_> Add<&'_ Vec2d<usize>> for Vec2d<usize>

type Output = <Vec2d<usize> as Add<Vec2d<usize>>>::Output

The resulting type after applying the + operator.

fn add(
    self,
    other: &Vec2d<usize>
) -> <Vec2d<usize> as Add<Vec2d<usize>>>::Output

Performs the + operation.

impl<'_, '_> Add<&'_ Vec2d<usize>> for &'_ Vec2d<usize>

type Output = <Vec2d<usize> as Add<Vec2d<usize>>>::Output

The resulting type after applying the + operator.

fn add(
    self,
    other: &Vec2d<usize>
) -> <Vec2d<usize> as Add<Vec2d<usize>>>::Output

Performs the + operation.

impl<'_> Add<&'_ f32> for Vec2d<f32>

type Output = <Vec2d<f32> as Add<f32>>::Output

The resulting type after applying the + operator.

fn add(self, other: &f32) -> <Vec2d<f32> as Add<f32>>::Output

Performs the + operation.

impl<'_, '_> Add<&'_ f32> for &'_ Vec2d<f32>

type Output = <Vec2d<f32> as Add<f32>>::Output

The resulting type after applying the + operator.

fn add(self, other: &f32) -> <Vec2d<f32> as Add<f32>>::Output

Performs the + operation.

impl<'_> Add<&'_ f64> for Vec2d<f64>

type Output = <Vec2d<f64> as Add<f64>>::Output

The resulting type after applying the + operator.

fn add(self, other: &f64) -> <Vec2d<f64> as Add<f64>>::Output

Performs the + operation.

impl<'_, '_> Add<&'_ f64> for &'_ Vec2d<f64>

type Output = <Vec2d<f64> as Add<f64>>::Output

The resulting type after applying the + operator.

fn add(self, other: &f64) -> <Vec2d<f64> as Add<f64>>::Output

Performs the + operation.

impl<'_> Add<&'_ i128> for Vec2d<i128>

type Output = <Vec2d<i128> as Add<i128>>::Output

The resulting type after applying the + operator.

fn add(self, other: &i128) -> <Vec2d<i128> as Add<i128>>::Output

Performs the + operation.

impl<'_, '_> Add<&'_ i128> for &'_ Vec2d<i128>

type Output = <Vec2d<i128> as Add<i128>>::Output

The resulting type after applying the + operator.

fn add(self, other: &i128) -> <Vec2d<i128> as Add<i128>>::Output

Performs the + operation.

impl<'_> Add<&'_ i16> for Vec2d<i16>

type Output = <Vec2d<i16> as Add<i16>>::Output

The resulting type after applying the + operator.

fn add(self, other: &i16) -> <Vec2d<i16> as Add<i16>>::Output

Performs the + operation.

impl<'_, '_> Add<&'_ i16> for &'_ Vec2d<i16>

type Output = <Vec2d<i16> as Add<i16>>::Output

The resulting type after applying the + operator.

fn add(self, other: &i16) -> <Vec2d<i16> as Add<i16>>::Output

Performs the + operation.

impl<'_> Add<&'_ i32> for Vec2d<i32>

type Output = <Vec2d<i32> as Add<i32>>::Output

The resulting type after applying the + operator.

fn add(self, other: &i32) -> <Vec2d<i32> as Add<i32>>::Output

Performs the + operation.

impl<'_, '_> Add<&'_ i32> for &'_ Vec2d<i32>

type Output = <Vec2d<i32> as Add<i32>>::Output

The resulting type after applying the + operator.

fn add(self, other: &i32) -> <Vec2d<i32> as Add<i32>>::Output

Performs the + operation.

impl<'_> Add<&'_ i64> for Vec2d<i64>

type Output = <Vec2d<i64> as Add<i64>>::Output

The resulting type after applying the + operator.

fn add(self, other: &i64) -> <Vec2d<i64> as Add<i64>>::Output

Performs the + operation.

impl<'_, '_> Add<&'_ i64> for &'_ Vec2d<i64>

type Output = <Vec2d<i64> as Add<i64>>::Output

The resulting type after applying the + operator.

fn add(self, other: &i64) -> <Vec2d<i64> as Add<i64>>::Output

Performs the + operation.

impl<'_> Add<&'_ i8> for Vec2d<i8>

type Output = <Vec2d<i8> as Add<i8>>::Output

The resulting type after applying the + operator.

fn add(self, other: &i8) -> <Vec2d<i8> as Add<i8>>::Output

Performs the + operation.

impl<'_, '_> Add<&'_ i8> for &'_ Vec2d<i8>

type Output = <Vec2d<i8> as Add<i8>>::Output

The resulting type after applying the + operator.

fn add(self, other: &i8) -> <Vec2d<i8> as Add<i8>>::Output

Performs the + operation.

impl<'_> Add<&'_ isize> for Vec2d<isize>

type Output = <Vec2d<isize> as Add<isize>>::Output

The resulting type after applying the + operator.

fn add(self, other: &isize) -> <Vec2d<isize> as Add<isize>>::Output

Performs the + operation.

impl<'_, '_> Add<&'_ isize> for &'_ Vec2d<isize>

type Output = <Vec2d<isize> as Add<isize>>::Output

The resulting type after applying the + operator.

fn add(self, other: &isize) -> <Vec2d<isize> as Add<isize>>::Output

Performs the + operation.

impl<'_> Add<&'_ u128> for Vec2d<u128>

type Output = <Vec2d<u128> as Add<u128>>::Output

The resulting type after applying the + operator.

fn add(self, other: &u128) -> <Vec2d<u128> as Add<u128>>::Output

Performs the + operation.

impl<'_, '_> Add<&'_ u128> for &'_ Vec2d<u128>

type Output = <Vec2d<u128> as Add<u128>>::Output

The resulting type after applying the + operator.

fn add(self, other: &u128) -> <Vec2d<u128> as Add<u128>>::Output

Performs the + operation.

impl<'_> Add<&'_ u16> for Vec2d<u16>

type Output = <Vec2d<u16> as Add<u16>>::Output

The resulting type after applying the + operator.

fn add(self, other: &u16) -> <Vec2d<u16> as Add<u16>>::Output

Performs the + operation.

impl<'_, '_> Add<&'_ u16> for &'_ Vec2d<u16>

type Output = <Vec2d<u16> as Add<u16>>::Output

The resulting type after applying the + operator.

fn add(self, other: &u16) -> <Vec2d<u16> as Add<u16>>::Output

Performs the + operation.

impl<'_> Add<&'_ u32> for Vec2d<u32>

type Output = <Vec2d<u32> as Add<u32>>::Output

The resulting type after applying the + operator.

fn add(self, other: &u32) -> <Vec2d<u32> as Add<u32>>::Output

Performs the + operation.

impl<'_, '_> Add<&'_ u32> for &'_ Vec2d<u32>

type Output = <Vec2d<u32> as Add<u32>>::Output

The resulting type after applying the + operator.

fn add(self, other: &u32) -> <Vec2d<u32> as Add<u32>>::Output

Performs the + operation.

impl<'_> Add<&'_ u64> for Vec2d<u64>

type Output = <Vec2d<u64> as Add<u64>>::Output

The resulting type after applying the + operator.

fn add(self, other: &u64) -> <Vec2d<u64> as Add<u64>>::Output

Performs the + operation.

impl<'_, '_> Add<&'_ u64> for &'_ Vec2d<u64>

type Output = <Vec2d<u64> as Add<u64>>::Output

The resulting type after applying the + operator.

fn add(self, other: &u64) -> <Vec2d<u64> as Add<u64>>::Output

Performs the + operation.

impl<'_> Add<&'_ u8> for Vec2d<u8>

type Output = <Vec2d<u8> as Add<u8>>::Output

The resulting type after applying the + operator.

fn add(self, other: &u8) -> <Vec2d<u8> as Add<u8>>::Output

Performs the + operation.

impl<'_, '_> Add<&'_ u8> for &'_ Vec2d<u8>

type Output = <Vec2d<u8> as Add<u8>>::Output

The resulting type after applying the + operator.

fn add(self, other: &u8) -> <Vec2d<u8> as Add<u8>>::Output

Performs the + operation.

impl<'_> Add<&'_ usize> for Vec2d<usize>

type Output = <Vec2d<usize> as Add<usize>>::Output

The resulting type after applying the + operator.

fn add(self, other: &usize) -> <Vec2d<usize> as Add<usize>>::Output

Performs the + operation.

impl<'_, '_> Add<&'_ usize> for &'_ Vec2d<usize>

type Output = <Vec2d<usize> as Add<usize>>::Output

The resulting type after applying the + operator.

fn add(self, other: &usize) -> <Vec2d<usize> as Add<usize>>::Output

Performs the + operation.

impl<T: Add + Copy> Add<T> for Vec2d<T>

Add scalar to Vec2d

type Output = Vec2d<T::Output>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<T: Add> Add<Vec2d<T>> for Vec2d<T>

Add two Vec2d together

type Output = Vec2d<T::Output>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<'a> Add<Vec2d<f32>> for &'a Vec2d<f32>

type Output = <Vec2d<f32> as Add<Vec2d<f32>>>::Output

The resulting type after applying the + operator.

fn add(self, other: Vec2d<f32>) -> <Vec2d<f32> as Add<Vec2d<f32>>>::Output

Performs the + operation.

impl<'a> Add<Vec2d<f64>> for &'a Vec2d<f64>

type Output = <Vec2d<f64> as Add<Vec2d<f64>>>::Output

The resulting type after applying the + operator.

fn add(self, other: Vec2d<f64>) -> <Vec2d<f64> as Add<Vec2d<f64>>>::Output

Performs the + operation.

impl<'a> Add<Vec2d<i128>> for &'a Vec2d<i128>

type Output = <Vec2d<i128> as Add<Vec2d<i128>>>::Output

The resulting type after applying the + operator.

fn add(self, other: Vec2d<i128>) -> <Vec2d<i128> as Add<Vec2d<i128>>>::Output

Performs the + operation.

impl<'a> Add<Vec2d<i16>> for &'a Vec2d<i16>

type Output = <Vec2d<i16> as Add<Vec2d<i16>>>::Output

The resulting type after applying the + operator.

fn add(self, other: Vec2d<i16>) -> <Vec2d<i16> as Add<Vec2d<i16>>>::Output

Performs the + operation.

impl<'a> Add<Vec2d<i32>> for &'a Vec2d<i32>

type Output = <Vec2d<i32> as Add<Vec2d<i32>>>::Output

The resulting type after applying the + operator.

fn add(self, other: Vec2d<i32>) -> <Vec2d<i32> as Add<Vec2d<i32>>>::Output

Performs the + operation.

impl<'a> Add<Vec2d<i64>> for &'a Vec2d<i64>

type Output = <Vec2d<i64> as Add<Vec2d<i64>>>::Output

The resulting type after applying the + operator.

fn add(self, other: Vec2d<i64>) -> <Vec2d<i64> as Add<Vec2d<i64>>>::Output

Performs the + operation.

impl<'a> Add<Vec2d<i8>> for &'a Vec2d<i8>

type Output = <Vec2d<i8> as Add<Vec2d<i8>>>::Output

The resulting type after applying the + operator.

fn add(self, other: Vec2d<i8>) -> <Vec2d<i8> as Add<Vec2d<i8>>>::Output

Performs the + operation.

impl<'a> Add<Vec2d<isize>> for &'a Vec2d<isize>

type Output = <Vec2d<isize> as Add<Vec2d<isize>>>::Output

The resulting type after applying the + operator.

fn add(self, other: Vec2d<isize>) -> <Vec2d<isize> as Add<Vec2d<isize>>>::Output

Performs the + operation.

impl<'a> Add<Vec2d<u128>> for &'a Vec2d<u128>

type Output = <Vec2d<u128> as Add<Vec2d<u128>>>::Output

The resulting type after applying the + operator.

fn add(self, other: Vec2d<u128>) -> <Vec2d<u128> as Add<Vec2d<u128>>>::Output

Performs the + operation.

impl<'a> Add<Vec2d<u16>> for &'a Vec2d<u16>

type Output = <Vec2d<u16> as Add<Vec2d<u16>>>::Output

The resulting type after applying the + operator.

fn add(self, other: Vec2d<u16>) -> <Vec2d<u16> as Add<Vec2d<u16>>>::Output

Performs the + operation.

impl<'a> Add<Vec2d<u32>> for &'a Vec2d<u32>

type Output = <Vec2d<u32> as Add<Vec2d<u32>>>::Output

The resulting type after applying the + operator.

fn add(self, other: Vec2d<u32>) -> <Vec2d<u32> as Add<Vec2d<u32>>>::Output

Performs the + operation.

impl<'a> Add<Vec2d<u64>> for &'a Vec2d<u64>

type Output = <Vec2d<u64> as Add<Vec2d<u64>>>::Output

The resulting type after applying the + operator.

fn add(self, other: Vec2d<u64>) -> <Vec2d<u64> as Add<Vec2d<u64>>>::Output

Performs the + operation.

impl<'a> Add<Vec2d<u8>> for &'a Vec2d<u8>

type Output = <Vec2d<u8> as Add<Vec2d<u8>>>::Output

The resulting type after applying the + operator.

fn add(self, other: Vec2d<u8>) -> <Vec2d<u8> as Add<Vec2d<u8>>>::Output

Performs the + operation.

impl<'a> Add<Vec2d<usize>> for &'a Vec2d<usize>

type Output = <Vec2d<usize> as Add<Vec2d<usize>>>::Output

The resulting type after applying the + operator.

fn add(self, other: Vec2d<usize>) -> <Vec2d<usize> as Add<Vec2d<usize>>>::Output

Performs the + operation.

impl<'a> Add<f32> for &'a Vec2d<f32>

type Output = <Vec2d<f32> as Add<f32>>::Output

The resulting type after applying the + operator.

fn add(self, other: f32) -> <Vec2d<f32> as Add<f32>>::Output

Performs the + operation.

impl<'a> Add<f64> for &'a Vec2d<f64>

type Output = <Vec2d<f64> as Add<f64>>::Output

The resulting type after applying the + operator.

fn add(self, other: f64) -> <Vec2d<f64> as Add<f64>>::Output

Performs the + operation.

impl<'a> Add<i128> for &'a Vec2d<i128>

type Output = <Vec2d<i128> as Add<i128>>::Output

The resulting type after applying the + operator.

fn add(self, other: i128) -> <Vec2d<i128> as Add<i128>>::Output

Performs the + operation.

impl<'a> Add<i16> for &'a Vec2d<i16>

type Output = <Vec2d<i16> as Add<i16>>::Output

The resulting type after applying the + operator.

fn add(self, other: i16) -> <Vec2d<i16> as Add<i16>>::Output

Performs the + operation.

impl<'a> Add<i32> for &'a Vec2d<i32>

type Output = <Vec2d<i32> as Add<i32>>::Output

The resulting type after applying the + operator.

fn add(self, other: i32) -> <Vec2d<i32> as Add<i32>>::Output

Performs the + operation.

impl<'a> Add<i64> for &'a Vec2d<i64>

type Output = <Vec2d<i64> as Add<i64>>::Output

The resulting type after applying the + operator.

fn add(self, other: i64) -> <Vec2d<i64> as Add<i64>>::Output

Performs the + operation.

impl<'a> Add<i8> for &'a Vec2d<i8>

type Output = <Vec2d<i8> as Add<i8>>::Output

The resulting type after applying the + operator.

fn add(self, other: i8) -> <Vec2d<i8> as Add<i8>>::Output

Performs the + operation.

impl<'a> Add<isize> for &'a Vec2d<isize>

type Output = <Vec2d<isize> as Add<isize>>::Output

The resulting type after applying the + operator.

fn add(self, other: isize) -> <Vec2d<isize> as Add<isize>>::Output

Performs the + operation.

impl<'a> Add<u128> for &'a Vec2d<u128>

type Output = <Vec2d<u128> as Add<u128>>::Output

The resulting type after applying the + operator.

fn add(self, other: u128) -> <Vec2d<u128> as Add<u128>>::Output

Performs the + operation.

impl<'a> Add<u16> for &'a Vec2d<u16>

type Output = <Vec2d<u16> as Add<u16>>::Output

The resulting type after applying the + operator.

fn add(self, other: u16) -> <Vec2d<u16> as Add<u16>>::Output

Performs the + operation.

impl<'a> Add<u32> for &'a Vec2d<u32>

type Output = <Vec2d<u32> as Add<u32>>::Output

The resulting type after applying the + operator.

fn add(self, other: u32) -> <Vec2d<u32> as Add<u32>>::Output

Performs the + operation.

impl<'a> Add<u64> for &'a Vec2d<u64>

type Output = <Vec2d<u64> as Add<u64>>::Output

The resulting type after applying the + operator.

fn add(self, other: u64) -> <Vec2d<u64> as Add<u64>>::Output

Performs the + operation.

impl<'a> Add<u8> for &'a Vec2d<u8>

type Output = <Vec2d<u8> as Add<u8>>::Output

The resulting type after applying the + operator.

fn add(self, other: u8) -> <Vec2d<u8> as Add<u8>>::Output

Performs the + operation.

impl<'a> Add<usize> for &'a Vec2d<usize>

type Output = <Vec2d<usize> as Add<usize>>::Output

The resulting type after applying the + operator.

fn add(self, other: usize) -> <Vec2d<usize> as Add<usize>>::Output

Performs the + operation.

impl<'_> AddAssign<&'_ Vec2d<f32>> for Vec2d<f32>

fn add_assign(&mut self, other: &Vec2d<f32>)

Performs the += operation.

impl<'_> AddAssign<&'_ Vec2d<f64>> for Vec2d<f64>

fn add_assign(&mut self, other: &Vec2d<f64>)

Performs the += operation.

impl<'_> AddAssign<&'_ Vec2d<i128>> for Vec2d<i128>

fn add_assign(&mut self, other: &Vec2d<i128>)

Performs the += operation.

impl<'_> AddAssign<&'_ Vec2d<i16>> for Vec2d<i16>

fn add_assign(&mut self, other: &Vec2d<i16>)

Performs the += operation.

impl<'_> AddAssign<&'_ Vec2d<i32>> for Vec2d<i32>

fn add_assign(&mut self, other: &Vec2d<i32>)

Performs the += operation.

impl<'_> AddAssign<&'_ Vec2d<i64>> for Vec2d<i64>

fn add_assign(&mut self, other: &Vec2d<i64>)

Performs the += operation.

impl<'_> AddAssign<&'_ Vec2d<i8>> for Vec2d<i8>

fn add_assign(&mut self, other: &Vec2d<i8>)

Performs the += operation.

impl<'_> AddAssign<&'_ Vec2d<isize>> for Vec2d<isize>

fn add_assign(&mut self, other: &Vec2d<isize>)

Performs the += operation.

impl<'_> AddAssign<&'_ Vec2d<u128>> for Vec2d<u128>

fn add_assign(&mut self, other: &Vec2d<u128>)

Performs the += operation.

impl<'_> AddAssign<&'_ Vec2d<u16>> for Vec2d<u16>

fn add_assign(&mut self, other: &Vec2d<u16>)

Performs the += operation.

impl<'_> AddAssign<&'_ Vec2d<u32>> for Vec2d<u32>

fn add_assign(&mut self, other: &Vec2d<u32>)

Performs the += operation.

impl<'_> AddAssign<&'_ Vec2d<u64>> for Vec2d<u64>

fn add_assign(&mut self, other: &Vec2d<u64>)

Performs the += operation.

impl<'_> AddAssign<&'_ Vec2d<u8>> for Vec2d<u8>

fn add_assign(&mut self, other: &Vec2d<u8>)

Performs the += operation.

impl<'_> AddAssign<&'_ Vec2d<usize>> for Vec2d<usize>

fn add_assign(&mut self, other: &Vec2d<usize>)

Performs the += operation.

impl<'_> AddAssign<&'_ f32> for Vec2d<f32>

fn add_assign(&mut self, other: &f32)

Performs the += operation.

impl<'_> AddAssign<&'_ f64> for Vec2d<f64>

fn add_assign(&mut self, other: &f64)

Performs the += operation.

impl<'_> AddAssign<&'_ i128> for Vec2d<i128>

fn add_assign(&mut self, other: &i128)

Performs the += operation.

impl<'_> AddAssign<&'_ i16> for Vec2d<i16>

fn add_assign(&mut self, other: &i16)

Performs the += operation.

impl<'_> AddAssign<&'_ i32> for Vec2d<i32>

fn add_assign(&mut self, other: &i32)

Performs the += operation.

impl<'_> AddAssign<&'_ i64> for Vec2d<i64>

fn add_assign(&mut self, other: &i64)

Performs the += operation.

impl<'_> AddAssign<&'_ i8> for Vec2d<i8>

fn add_assign(&mut self, other: &i8)

Performs the += operation.

impl<'_> AddAssign<&'_ isize> for Vec2d<isize>

fn add_assign(&mut self, other: &isize)

Performs the += operation.

impl<'_> AddAssign<&'_ u128> for Vec2d<u128>

fn add_assign(&mut self, other: &u128)

Performs the += operation.

impl<'_> AddAssign<&'_ u16> for Vec2d<u16>

fn add_assign(&mut self, other: &u16)

Performs the += operation.

impl<'_> AddAssign<&'_ u32> for Vec2d<u32>

fn add_assign(&mut self, other: &u32)

Performs the += operation.

impl<'_> AddAssign<&'_ u64> for Vec2d<u64>

fn add_assign(&mut self, other: &u64)

Performs the += operation.

impl<'_> AddAssign<&'_ u8> for Vec2d<u8>

fn add_assign(&mut self, other: &u8)

Performs the += operation.

impl<'_> AddAssign<&'_ usize> for Vec2d<usize>

fn add_assign(&mut self, other: &usize)

Performs the += operation.

impl<T: AddAssign + Copy> AddAssign<T> for Vec2d<T>

Add scalar to this Vec2d

fn add_assign(&mut self, rhs: T)

Performs the += operation.

impl<T: AddAssign> AddAssign<Vec2d<T>> for Vec2d<T>

Add Vec2d to this Vec2d

fn add_assign(&mut self, rhs: Self)

Performs the += operation.

impl<T: Clone> Clone for Vec2d<T>

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

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<T: Copy> Copy for Vec2d<T>

impl<T: Debug> Debug for Vec2d<T>

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

Formats the value using the given formatter.

impl<T: Default> Default for Vec2d<T>

fn default() -> Vec2d<T>

Returns the "default value" for a type.

impl<'_> Div<&'_ Vec2d<f32>> for Vec2d<f32>

type Output = <Vec2d<f32> as Div<Vec2d<f32>>>::Output

The resulting type after applying the / operator.

fn div(self, other: &Vec2d<f32>) -> <Vec2d<f32> as Div<Vec2d<f32>>>::Output

Performs the / operation.

impl<'_, '_> Div<&'_ Vec2d<f32>> for &'_ Vec2d<f32>

type Output = <Vec2d<f32> as Div<Vec2d<f32>>>::Output

The resulting type after applying the / operator.

fn div(self, other: &Vec2d<f32>) -> <Vec2d<f32> as Div<Vec2d<f32>>>::Output

Performs the / operation.

impl<'_> Div<&'_ Vec2d<f64>> for Vec2d<f64>

type Output = <Vec2d<f64> as Div<Vec2d<f64>>>::Output

The resulting type after applying the / operator.

fn div(self, other: &Vec2d<f64>) -> <Vec2d<f64> as Div<Vec2d<f64>>>::Output

Performs the / operation.

impl<'_, '_> Div<&'_ Vec2d<f64>> for &'_ Vec2d<f64>

type Output = <Vec2d<f64> as Div<Vec2d<f64>>>::Output

The resulting type after applying the / operator.

fn div(self, other: &Vec2d<f64>) -> <Vec2d<f64> as Div<Vec2d<f64>>>::Output

Performs the / operation.

impl<'_> Div<&'_ Vec2d<i128>> for Vec2d<i128>

type Output = <Vec2d<i128> as Div<Vec2d<i128>>>::Output

The resulting type after applying the / operator.

fn div(self, other: &Vec2d<i128>) -> <Vec2d<i128> as Div<Vec2d<i128>>>::Output

Performs the / operation.

impl<'_, '_> Div<&'_ Vec2d<i128>> for &'_ Vec2d<i128>

type Output = <Vec2d<i128> as Div<Vec2d<i128>>>::Output

The resulting type after applying the / operator.

fn div(self, other: &Vec2d<i128>) -> <Vec2d<i128> as Div<Vec2d<i128>>>::Output

Performs the / operation.

impl<'_> Div<&'_ Vec2d<i16>> for Vec2d<i16>

type Output = <Vec2d<i16> as Div<Vec2d<i16>>>::Output

The resulting type after applying the / operator.

fn div(self, other: &Vec2d<i16>) -> <Vec2d<i16> as Div<Vec2d<i16>>>::Output

Performs the / operation.

impl<'_, '_> Div<&'_ Vec2d<i16>> for &'_ Vec2d<i16>

type Output = <Vec2d<i16> as Div<Vec2d<i16>>>::Output

The resulting type after applying the / operator.

fn div(self, other: &Vec2d<i16>) -> <Vec2d<i16> as Div<Vec2d<i16>>>::Output

Performs the / operation.

impl<'_> Div<&'_ Vec2d<i32>> for Vec2d<i32>

type Output = <Vec2d<i32> as Div<Vec2d<i32>>>::Output

The resulting type after applying the / operator.

fn div(self, other: &Vec2d<i32>) -> <Vec2d<i32> as Div<Vec2d<i32>>>::Output

Performs the / operation.

impl<'_, '_> Div<&'_ Vec2d<i32>> for &'_ Vec2d<i32>

type Output = <Vec2d<i32> as Div<Vec2d<i32>>>::Output

The resulting type after applying the / operator.

fn div(self, other: &Vec2d<i32>) -> <Vec2d<i32> as Div<Vec2d<i32>>>::Output

Performs the / operation.

impl<'_> Div<&'_ Vec2d<i64>> for Vec2d<i64>

type Output = <Vec2d<i64> as Div<Vec2d<i64>>>::Output

The resulting type after applying the / operator.

fn div(self, other: &Vec2d<i64>) -> <Vec2d<i64> as Div<Vec2d<i64>>>::Output

Performs the / operation.

impl<'_, '_> Div<&'_ Vec2d<i64>> for &'_ Vec2d<i64>

type Output = <Vec2d<i64> as Div<Vec2d<i64>>>::Output

The resulting type after applying the / operator.

fn div(self, other: &Vec2d<i64>) -> <Vec2d<i64> as Div<Vec2d<i64>>>::Output

Performs the / operation.

impl<'_> Div<&'_ Vec2d<i8>> for Vec2d<i8>

type Output = <Vec2d<i8> as Div<Vec2d<i8>>>::Output

The resulting type after applying the / operator.

fn div(self, other: &Vec2d<i8>) -> <Vec2d<i8> as Div<Vec2d<i8>>>::Output

Performs the / operation.

impl<'_, '_> Div<&'_ Vec2d<i8>> for &'_ Vec2d<i8>

type Output = <Vec2d<i8> as Div<Vec2d<i8>>>::Output

The resulting type after applying the / operator.

fn div(self, other: &Vec2d<i8>) -> <Vec2d<i8> as Div<Vec2d<i8>>>::Output

Performs the / operation.

impl<'_> Div<&'_ Vec2d<isize>> for Vec2d<isize>

type Output = <Vec2d<isize> as Div<Vec2d<isize>>>::Output

The resulting type after applying the / operator.

fn div(
    self,
    other: &Vec2d<isize>
) -> <Vec2d<isize> as Div<Vec2d<isize>>>::Output

Performs the / operation.

impl<'_, '_> Div<&'_ Vec2d<isize>> for &'_ Vec2d<isize>

type Output = <Vec2d<isize> as Div<Vec2d<isize>>>::Output

The resulting type after applying the / operator.

fn div(
    self,
    other: &Vec2d<isize>
) -> <Vec2d<isize> as Div<Vec2d<isize>>>::Output

Performs the / operation.

impl<'_> Div<&'_ Vec2d<u128>> for Vec2d<u128>

type Output = <Vec2d<u128> as Div<Vec2d<u128>>>::Output

The resulting type after applying the / operator.

fn div(self, other: &Vec2d<u128>) -> <Vec2d<u128> as Div<Vec2d<u128>>>::Output

Performs the / operation.

impl<'_, '_> Div<&'_ Vec2d<u128>> for &'_ Vec2d<u128>

type Output = <Vec2d<u128> as Div<Vec2d<u128>>>::Output

The resulting type after applying the / operator.

fn div(self, other: &Vec2d<u128>) -> <Vec2d<u128> as Div<Vec2d<u128>>>::Output

Performs the / operation.

impl<'_> Div<&'_ Vec2d<u16>> for Vec2d<u16>

type Output = <Vec2d<u16> as Div<Vec2d<u16>>>::Output

The resulting type after applying the / operator.

fn div(self, other: &Vec2d<u16>) -> <Vec2d<u16> as Div<Vec2d<u16>>>::Output

Performs the / operation.

impl<'_, '_> Div<&'_ Vec2d<u16>> for &'_ Vec2d<u16>

type Output = <Vec2d<u16> as Div<Vec2d<u16>>>::Output

The resulting type after applying the / operator.

fn div(self, other: &Vec2d<u16>) -> <Vec2d<u16> as Div<Vec2d<u16>>>::Output

Performs the / operation.

impl<'_> Div<&'_ Vec2d<u32>> for Vec2d<u32>

type Output = <Vec2d<u32> as Div<Vec2d<u32>>>::Output

The resulting type after applying the / operator.

fn div(self, other: &Vec2d<u32>) -> <Vec2d<u32> as Div<Vec2d<u32>>>::Output

Performs the / operation.

impl<'_, '_> Div<&'_ Vec2d<u32>> for &'_ Vec2d<u32>

type Output = <Vec2d<u32> as Div<Vec2d<u32>>>::Output

The resulting type after applying the / operator.

fn div(self, other: &Vec2d<u32>) -> <Vec2d<u32> as Div<Vec2d<u32>>>::Output

Performs the / operation.

impl<'_> Div<&'_ Vec2d<u64>> for Vec2d<u64>

type Output = <Vec2d<u64> as Div<Vec2d<u64>>>::Output

The resulting type after applying the / operator.

fn div(self, other: &Vec2d<u64>) -> <Vec2d<u64> as Div<Vec2d<u64>>>::Output

Performs the / operation.

impl<'_, '_> Div<&'_ Vec2d<u64>> for &'_ Vec2d<u64>

type Output = <Vec2d<u64> as Div<Vec2d<u64>>>::Output

The resulting type after applying the / operator.

fn div(self, other: &Vec2d<u64>) -> <Vec2d<u64> as Div<Vec2d<u64>>>::Output

Performs the / operation.

impl<'_> Div<&'_ Vec2d<u8>> for Vec2d<u8>

type Output = <Vec2d<u8> as Div<Vec2d<u8>>>::Output

The resulting type after applying the / operator.

fn div(self, other: &Vec2d<u8>) -> <Vec2d<u8> as Div<Vec2d<u8>>>::Output

Performs the / operation.

impl<'_, '_> Div<&'_ Vec2d<u8>> for &'_ Vec2d<u8>

type Output = <Vec2d<u8> as Div<Vec2d<u8>>>::Output

The resulting type after applying the / operator.

fn div(self, other: &Vec2d<u8>) -> <Vec2d<u8> as Div<Vec2d<u8>>>::Output

Performs the / operation.

impl<'_> Div<&'_ Vec2d<usize>> for Vec2d<usize>

type Output = <Vec2d<usize> as Div<Vec2d<usize>>>::Output

The resulting type after applying the / operator.

fn div(
    self,
    other: &Vec2d<usize>
) -> <Vec2d<usize> as Div<Vec2d<usize>>>::Output

Performs the / operation.

impl<'_, '_> Div<&'_ Vec2d<usize>> for &'_ Vec2d<usize>

type Output = <Vec2d<usize> as Div<Vec2d<usize>>>::Output

The resulting type after applying the / operator.

fn div(
    self,
    other: &Vec2d<usize>
) -> <Vec2d<usize> as Div<Vec2d<usize>>>::Output

Performs the / operation.

impl<'_> Div<&'_ f32> for Vec2d<f32>

type Output = <Vec2d<f32> as Div<f32>>::Output

The resulting type after applying the / operator.

fn div(self, other: &f32) -> <Vec2d<f32> as Div<f32>>::Output

Performs the / operation.

impl<'_, '_> Div<&'_ f32> for &'_ Vec2d<f32>

type Output = <Vec2d<f32> as Div<f32>>::Output

The resulting type after applying the / operator.

fn div(self, other: &f32) -> <Vec2d<f32> as Div<f32>>::Output

Performs the / operation.

impl<'_> Div<&'_ f64> for Vec2d<f64>

type Output = <Vec2d<f64> as Div<f64>>::Output

The resulting type after applying the / operator.

fn div(self, other: &f64) -> <Vec2d<f64> as Div<f64>>::Output

Performs the / operation.

impl<'_, '_> Div<&'_ f64> for &'_ Vec2d<f64>

type Output = <Vec2d<f64> as Div<f64>>::Output

The resulting type after applying the / operator.

fn div(self, other: &f64) -> <Vec2d<f64> as Div<f64>>::Output

Performs the / operation.

impl<'_> Div<&'_ i128> for Vec2d<i128>

type Output = <Vec2d<i128> as Div<i128>>::Output

The resulting type after applying the / operator.

fn div(self, other: &i128) -> <Vec2d<i128> as Div<i128>>::Output

Performs the / operation.

impl<'_, '_> Div<&'_ i128> for &'_ Vec2d<i128>

type Output = <Vec2d<i128> as Div<i128>>::Output

The resulting type after applying the / operator.

fn div(self, other: &i128) -> <Vec2d<i128> as Div<i128>>::Output

Performs the / operation.

impl<'_> Div<&'_ i16> for Vec2d<i16>

type Output = <Vec2d<i16> as Div<i16>>::Output

The resulting type after applying the / operator.

fn div(self, other: &i16) -> <Vec2d<i16> as Div<i16>>::Output

Performs the / operation.

impl<'_, '_> Div<&'_ i16> for &'_ Vec2d<i16>

type Output = <Vec2d<i16> as Div<i16>>::Output

The resulting type after applying the / operator.

fn div(self, other: &i16) -> <Vec2d<i16> as Div<i16>>::Output

Performs the / operation.

impl<'_> Div<&'_ i32> for Vec2d<i32>

type Output = <Vec2d<i32> as Div<i32>>::Output

The resulting type after applying the / operator.

fn div(self, other: &i32) -> <Vec2d<i32> as Div<i32>>::Output

Performs the / operation.

impl<'_, '_> Div<&'_ i32> for &'_ Vec2d<i32>

type Output = <Vec2d<i32> as Div<i32>>::Output

The resulting type after applying the / operator.

fn div(self, other: &i32) -> <Vec2d<i32> as Div<i32>>::Output

Performs the / operation.

impl<'_> Div<&'_ i64> for Vec2d<i64>

type Output = <Vec2d<i64> as Div<i64>>::Output

The resulting type after applying the / operator.

fn div(self, other: &i64) -> <Vec2d<i64> as Div<i64>>::Output

Performs the / operation.

impl<'_, '_> Div<&'_ i64> for &'_ Vec2d<i64>

type Output = <Vec2d<i64> as Div<i64>>::Output

The resulting type after applying the / operator.

fn div(self, other: &i64) -> <Vec2d<i64> as Div<i64>>::Output

Performs the / operation.

impl<'_> Div<&'_ i8> for Vec2d<i8>

type Output = <Vec2d<i8> as Div<i8>>::Output

The resulting type after applying the / operator.

fn div(self, other: &i8) -> <Vec2d<i8> as Div<i8>>::Output

Performs the / operation.

impl<'_, '_> Div<&'_ i8> for &'_ Vec2d<i8>

type Output = <Vec2d<i8> as Div<i8>>::Output

The resulting type after applying the / operator.

fn div(self, other: &i8) -> <Vec2d<i8> as Div<i8>>::Output

Performs the / operation.

impl<'_> Div<&'_ isize> for Vec2d<isize>

type Output = <Vec2d<isize> as Div<isize>>::Output

The resulting type after applying the / operator.

fn div(self, other: &isize) -> <Vec2d<isize> as Div<isize>>::Output

Performs the / operation.

impl<'_, '_> Div<&'_ isize> for &'_ Vec2d<isize>

type Output = <Vec2d<isize> as Div<isize>>::Output

The resulting type after applying the / operator.

fn div(self, other: &isize) -> <Vec2d<isize> as Div<isize>>::Output

Performs the / operation.

impl<'_> Div<&'_ u128> for Vec2d<u128>

type Output = <Vec2d<u128> as Div<u128>>::Output

The resulting type after applying the / operator.

fn div(self, other: &u128) -> <Vec2d<u128> as Div<u128>>::Output

Performs the / operation.

impl<'_, '_> Div<&'_ u128> for &'_ Vec2d<u128>

type Output = <Vec2d<u128> as Div<u128>>::Output

The resulting type after applying the / operator.

fn div(self, other: &u128) -> <Vec2d<u128> as Div<u128>>::Output

Performs the / operation.

impl<'_> Div<&'_ u16> for Vec2d<u16>

type Output = <Vec2d<u16> as Div<u16>>::Output

The resulting type after applying the / operator.

fn div(self, other: &u16) -> <Vec2d<u16> as Div<u16>>::Output

Performs the / operation.

impl<'_, '_> Div<&'_ u16> for &'_ Vec2d<u16>

type Output = <Vec2d<u16> as Div<u16>>::Output

The resulting type after applying the / operator.

fn div(self, other: &u16) -> <Vec2d<u16> as Div<u16>>::Output

Performs the / operation.

impl<'_> Div<&'_ u32> for Vec2d<u32>

type Output = <Vec2d<u32> as Div<u32>>::Output

The resulting type after applying the / operator.

fn div(self, other: &u32) -> <Vec2d<u32> as Div<u32>>::Output

Performs the / operation.

impl<'_, '_> Div<&'_ u32> for &'_ Vec2d<u32>

type Output = <Vec2d<u32> as Div<u32>>::Output

The resulting type after applying the / operator.

fn div(self, other: &u32) -> <Vec2d<u32> as Div<u32>>::Output

Performs the / operation.

impl<'_> Div<&'_ u64> for Vec2d<u64>

type Output = <Vec2d<u64> as Div<u64>>::Output

The resulting type after applying the / operator.

fn div(self, other: &u64) -> <Vec2d<u64> as Div<u64>>::Output

Performs the / operation.

impl<'_, '_> Div<&'_ u64> for &'_ Vec2d<u64>

type Output = <Vec2d<u64> as Div<u64>>::Output

The resulting type after applying the / operator.

fn div(self, other: &u64) -> <Vec2d<u64> as Div<u64>>::Output

Performs the / operation.

impl<'_> Div<&'_ u8> for Vec2d<u8>

type Output = <Vec2d<u8> as Div<u8>>::Output

The resulting type after applying the / operator.

fn div(self, other: &u8) -> <Vec2d<u8> as Div<u8>>::Output

Performs the / operation.

impl<'_, '_> Div<&'_ u8> for &'_ Vec2d<u8>

type Output = <Vec2d<u8> as Div<u8>>::Output

The resulting type after applying the / operator.

fn div(self, other: &u8) -> <Vec2d<u8> as Div<u8>>::Output

Performs the / operation.

impl<'_> Div<&'_ usize> for Vec2d<usize>

type Output = <Vec2d<usize> as Div<usize>>::Output

The resulting type after applying the / operator.

fn div(self, other: &usize) -> <Vec2d<usize> as Div<usize>>::Output

Performs the / operation.

impl<'_, '_> Div<&'_ usize> for &'_ Vec2d<usize>

type Output = <Vec2d<usize> as Div<usize>>::Output

The resulting type after applying the / operator.

fn div(self, other: &usize) -> <Vec2d<usize> as Div<usize>>::Output

Performs the / operation.

impl<T: Div + Copy> Div<T> for Vec2d<T>

Divide Vec2d by scalar

type Output = Vec2d<T::Output>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<T: Div> Div<Vec2d<T>> for Vec2d<T>

Divide Vec2d by Vec2d

type Output = Vec2d<T::Output>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<'a> Div<Vec2d<f32>> for &'a Vec2d<f32>

type Output = <Vec2d<f32> as Div<Vec2d<f32>>>::Output

The resulting type after applying the / operator.

fn div(self, other: Vec2d<f32>) -> <Vec2d<f32> as Div<Vec2d<f32>>>::Output

Performs the / operation.

impl<'a> Div<Vec2d<f64>> for &'a Vec2d<f64>

type Output = <Vec2d<f64> as Div<Vec2d<f64>>>::Output

The resulting type after applying the / operator.

fn div(self, other: Vec2d<f64>) -> <Vec2d<f64> as Div<Vec2d<f64>>>::Output

Performs the / operation.

impl<'a> Div<Vec2d<i128>> for &'a Vec2d<i128>

type Output = <Vec2d<i128> as Div<Vec2d<i128>>>::Output

The resulting type after applying the / operator.

fn div(self, other: Vec2d<i128>) -> <Vec2d<i128> as Div<Vec2d<i128>>>::Output

Performs the / operation.

impl<'a> Div<Vec2d<i16>> for &'a Vec2d<i16>

type Output = <Vec2d<i16> as Div<Vec2d<i16>>>::Output

The resulting type after applying the / operator.

fn div(self, other: Vec2d<i16>) -> <Vec2d<i16> as Div<Vec2d<i16>>>::Output

Performs the / operation.

impl<'a> Div<Vec2d<i32>> for &'a Vec2d<i32>

type Output = <Vec2d<i32> as Div<Vec2d<i32>>>::Output

The resulting type after applying the / operator.

fn div(self, other: Vec2d<i32>) -> <Vec2d<i32> as Div<Vec2d<i32>>>::Output

Performs the / operation.

impl<'a> Div<Vec2d<i64>> for &'a Vec2d<i64>

type Output = <Vec2d<i64> as Div<Vec2d<i64>>>::Output

The resulting type after applying the / operator.

fn div(self, other: Vec2d<i64>) -> <Vec2d<i64> as Div<Vec2d<i64>>>::Output

Performs the / operation.

impl<'a> Div<Vec2d<i8>> for &'a Vec2d<i8>

type Output = <Vec2d<i8> as Div<Vec2d<i8>>>::Output

The resulting type after applying the / operator.

fn div(self, other: Vec2d<i8>) -> <Vec2d<i8> as Div<Vec2d<i8>>>::Output

Performs the / operation.

impl<'a> Div<Vec2d<isize>> for &'a Vec2d<isize>

type Output = <Vec2d<isize> as Div<Vec2d<isize>>>::Output

The resulting type after applying the / operator.

fn div(self, other: Vec2d<isize>) -> <Vec2d<isize> as Div<Vec2d<isize>>>::Output

Performs the / operation.

impl<'a> Div<Vec2d<u128>> for &'a Vec2d<u128>

type Output = <Vec2d<u128> as Div<Vec2d<u128>>>::Output

The resulting type after applying the / operator.

fn div(self, other: Vec2d<u128>) -> <Vec2d<u128> as Div<Vec2d<u128>>>::Output

Performs the / operation.

impl<'a> Div<Vec2d<u16>> for &'a Vec2d<u16>

type Output = <Vec2d<u16> as Div<Vec2d<u16>>>::Output

The resulting type after applying the / operator.

fn div(self, other: Vec2d<u16>) -> <Vec2d<u16> as Div<Vec2d<u16>>>::Output

Performs the / operation.

impl<'a> Div<Vec2d<u32>> for &'a Vec2d<u32>

type Output = <Vec2d<u32> as Div<Vec2d<u32>>>::Output

The resulting type after applying the / operator.

fn div(self, other: Vec2d<u32>) -> <Vec2d<u32> as Div<Vec2d<u32>>>::Output

Performs the / operation.

impl<'a> Div<Vec2d<u64>> for &'a Vec2d<u64>

type Output = <Vec2d<u64> as Div<Vec2d<u64>>>::Output

The resulting type after applying the / operator.

fn div(self, other: Vec2d<u64>) -> <Vec2d<u64> as Div<Vec2d<u64>>>::Output

Performs the / operation.

impl<'a> Div<Vec2d<u8>> for &'a Vec2d<u8>

type Output = <Vec2d<u8> as Div<Vec2d<u8>>>::Output

The resulting type after applying the / operator.

fn div(self, other: Vec2d<u8>) -> <Vec2d<u8> as Div<Vec2d<u8>>>::Output

Performs the / operation.

impl<'a> Div<Vec2d<usize>> for &'a Vec2d<usize>

type Output = <Vec2d<usize> as Div<Vec2d<usize>>>::Output

The resulting type after applying the / operator.

fn div(self, other: Vec2d<usize>) -> <Vec2d<usize> as Div<Vec2d<usize>>>::Output

Performs the / operation.

impl<'a> Div<f32> for &'a Vec2d<f32>

type Output = <Vec2d<f32> as Div<f32>>::Output

The resulting type after applying the / operator.

fn div(self, other: f32) -> <Vec2d<f32> as Div<f32>>::Output

Performs the / operation.

impl<'a> Div<f64> for &'a Vec2d<f64>

type Output = <Vec2d<f64> as Div<f64>>::Output

The resulting type after applying the / operator.

fn div(self, other: f64) -> <Vec2d<f64> as Div<f64>>::Output

Performs the / operation.

impl<'a> Div<i128> for &'a Vec2d<i128>

type Output = <Vec2d<i128> as Div<i128>>::Output

The resulting type after applying the / operator.

fn div(self, other: i128) -> <Vec2d<i128> as Div<i128>>::Output

Performs the / operation.

impl<'a> Div<i16> for &'a Vec2d<i16>

type Output = <Vec2d<i16> as Div<i16>>::Output

The resulting type after applying the / operator.

fn div(self, other: i16) -> <Vec2d<i16> as Div<i16>>::Output

Performs the / operation.

impl<'a> Div<i32> for &'a Vec2d<i32>

type Output = <Vec2d<i32> as Div<i32>>::Output

The resulting type after applying the / operator.

fn div(self, other: i32) -> <Vec2d<i32> as Div<i32>>::Output

Performs the / operation.

impl<'a> Div<i64> for &'a Vec2d<i64>

type Output = <Vec2d<i64> as Div<i64>>::Output

The resulting type after applying the / operator.

fn div(self, other: i64) -> <Vec2d<i64> as Div<i64>>::Output

Performs the / operation.

impl<'a> Div<i8> for &'a Vec2d<i8>

type Output = <Vec2d<i8> as Div<i8>>::Output

The resulting type after applying the / operator.

fn div(self, other: i8) -> <Vec2d<i8> as Div<i8>>::Output

Performs the / operation.

impl<'a> Div<isize> for &'a Vec2d<isize>

type Output = <Vec2d<isize> as Div<isize>>::Output

The resulting type after applying the / operator.

fn div(self, other: isize) -> <Vec2d<isize> as Div<isize>>::Output

Performs the / operation.

impl<'a> Div<u128> for &'a Vec2d<u128>

type Output = <Vec2d<u128> as Div<u128>>::Output

The resulting type after applying the / operator.

fn div(self, other: u128) -> <Vec2d<u128> as Div<u128>>::Output

Performs the / operation.

impl<'a> Div<u16> for &'a Vec2d<u16>

type Output = <Vec2d<u16> as Div<u16>>::Output

The resulting type after applying the / operator.

fn div(self, other: u16) -> <Vec2d<u16> as Div<u16>>::Output

Performs the / operation.

impl<'a> Div<u32> for &'a Vec2d<u32>

type Output = <Vec2d<u32> as Div<u32>>::Output

The resulting type after applying the / operator.

fn div(self, other: u32) -> <Vec2d<u32> as Div<u32>>::Output

Performs the / operation.

impl<'a> Div<u64> for &'a Vec2d<u64>

type Output = <Vec2d<u64> as Div<u64>>::Output

The resulting type after applying the / operator.

fn div(self, other: u64) -> <Vec2d<u64> as Div<u64>>::Output

Performs the / operation.

impl<'a> Div<u8> for &'a Vec2d<u8>

type Output = <Vec2d<u8> as Div<u8>>::Output

The resulting type after applying the / operator.

fn div(self, other: u8) -> <Vec2d<u8> as Div<u8>>::Output

Performs the / operation.

impl<'a> Div<usize> for &'a Vec2d<usize>

type Output = <Vec2d<usize> as Div<usize>>::Output

The resulting type after applying the / operator.

fn div(self, other: usize) -> <Vec2d<usize> as Div<usize>>::Output

Performs the / operation.

impl<'_> DivAssign<&'_ Vec2d<f32>> for Vec2d<f32>

fn div_assign(&mut self, other: &Vec2d<f32>)

Performs the /= operation.

impl<'_> DivAssign<&'_ Vec2d<f64>> for Vec2d<f64>

fn div_assign(&mut self, other: &Vec2d<f64>)

Performs the /= operation.

impl<'_> DivAssign<&'_ Vec2d<i128>> for Vec2d<i128>

fn div_assign(&mut self, other: &Vec2d<i128>)

Performs the /= operation.

impl<'_> DivAssign<&'_ Vec2d<i16>> for Vec2d<i16>

fn div_assign(&mut self, other: &Vec2d<i16>)

Performs the /= operation.

impl<'_> DivAssign<&'_ Vec2d<i32>> for Vec2d<i32>

fn div_assign(&mut self, other: &Vec2d<i32>)

Performs the /= operation.

impl<'_> DivAssign<&'_ Vec2d<i64>> for Vec2d<i64>

fn div_assign(&mut self, other: &Vec2d<i64>)

Performs the /= operation.

impl<'_> DivAssign<&'_ Vec2d<i8>> for Vec2d<i8>

fn div_assign(&mut self, other: &Vec2d<i8>)

Performs the /= operation.

impl<'_> DivAssign<&'_ Vec2d<isize>> for Vec2d<isize>

fn div_assign(&mut self, other: &Vec2d<isize>)

Performs the /= operation.

impl<'_> DivAssign<&'_ Vec2d<u128>> for Vec2d<u128>

fn div_assign(&mut self, other: &Vec2d<u128>)

Performs the /= operation.

impl<'_> DivAssign<&'_ Vec2d<u16>> for Vec2d<u16>

fn div_assign(&mut self, other: &Vec2d<u16>)

Performs the /= operation.

impl<'_> DivAssign<&'_ Vec2d<u32>> for Vec2d<u32>

fn div_assign(&mut self, other: &Vec2d<u32>)

Performs the /= operation.

impl<'_> DivAssign<&'_ Vec2d<u64>> for Vec2d<u64>

fn div_assign(&mut self, other: &Vec2d<u64>)

Performs the /= operation.

impl<'_> DivAssign<&'_ Vec2d<u8>> for Vec2d<u8>

fn div_assign(&mut self, other: &Vec2d<u8>)

Performs the /= operation.

impl<'_> DivAssign<&'_ Vec2d<usize>> for Vec2d<usize>

fn div_assign(&mut self, other: &Vec2d<usize>)

Performs the /= operation.

impl<'_> DivAssign<&'_ f32> for Vec2d<f32>

fn div_assign(&mut self, other: &f32)

Performs the /= operation.

impl<'_> DivAssign<&'_ f64> for Vec2d<f64>

fn div_assign(&mut self, other: &f64)

Performs the /= operation.

impl<'_> DivAssign<&'_ i128> for Vec2d<i128>

fn div_assign(&mut self, other: &i128)

Performs the /= operation.

impl<'_> DivAssign<&'_ i16> for Vec2d<i16>

fn div_assign(&mut self, other: &i16)

Performs the /= operation.

impl<'_> DivAssign<&'_ i32> for Vec2d<i32>

fn div_assign(&mut self, other: &i32)

Performs the /= operation.

impl<'_> DivAssign<&'_ i64> for Vec2d<i64>

fn div_assign(&mut self, other: &i64)

Performs the /= operation.

impl<'_> DivAssign<&'_ i8> for Vec2d<i8>

fn div_assign(&mut self, other: &i8)

Performs the /= operation.

impl<'_> DivAssign<&'_ isize> for Vec2d<isize>

fn div_assign(&mut self, other: &isize)

Performs the /= operation.

impl<'_> DivAssign<&'_ u128> for Vec2d<u128>

fn div_assign(&mut self, other: &u128)

Performs the /= operation.

impl<'_> DivAssign<&'_ u16> for Vec2d<u16>

fn div_assign(&mut self, other: &u16)

Performs the /= operation.

impl<'_> DivAssign<&'_ u32> for Vec2d<u32>

fn div_assign(&mut self, other: &u32)

Performs the /= operation.

impl<'_> DivAssign<&'_ u64> for Vec2d<u64>

fn div_assign(&mut self, other: &u64)

Performs the /= operation.

impl<'_> DivAssign<&'_ u8> for Vec2d<u8>

fn div_assign(&mut self, other: &u8)

Performs the /= operation.

impl<'_> DivAssign<&'_ usize> for Vec2d<usize>

fn div_assign(&mut self, other: &usize)

Performs the /= operation.

impl<T: DivAssign + Copy> DivAssign<T> for Vec2d<T>

Divide this Vec2d by scalar

fn div_assign(&mut self, rhs: T)

Performs the /= operation.

impl<T: DivAssign> DivAssign<Vec2d<T>> for Vec2d<T>

Divide this Vec2d by a Vec2d

fn div_assign(&mut self, rhs: Self)

Performs the /= operation.

impl<T: Eq> Eq for Vec2d<T>

impl<T: Copy> From<[T; 2]> for Vec2d<T>

Convert a slice to a Vec2d

fn from(array: [T; 2]) -> Self

Performs the conversion.

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

Convert a tuple to a Vec2d

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

Performs the conversion.

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

Return a slice for this Vec2d

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

Performs the conversion.

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

Return a tuple for this Vec2d

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

Performs the conversion.

impl<'_> Mul<&'_ Vec2d<f32>> for Vec2d<f32>

type Output = <Vec2d<f32> as Mul<Vec2d<f32>>>::Output

The resulting type after applying the * operator.

fn mul(self, other: &Vec2d<f32>) -> <Vec2d<f32> as Mul<Vec2d<f32>>>::Output

Performs the * operation.

impl<'_, '_> Mul<&'_ Vec2d<f32>> for &'_ Vec2d<f32>

type Output = <Vec2d<f32> as Mul<Vec2d<f32>>>::Output

The resulting type after applying the * operator.

fn mul(self, other: &Vec2d<f32>) -> <Vec2d<f32> as Mul<Vec2d<f32>>>::Output

Performs the * operation.

impl<'_> Mul<&'_ Vec2d<f64>> for Vec2d<f64>

type Output = <Vec2d<f64> as Mul<Vec2d<f64>>>::Output

The resulting type after applying the * operator.

fn mul(self, other: &Vec2d<f64>) -> <Vec2d<f64> as Mul<Vec2d<f64>>>::Output

Performs the * operation.

impl<'_, '_> Mul<&'_ Vec2d<f64>> for &'_ Vec2d<f64>

type Output = <Vec2d<f64> as Mul<Vec2d<f64>>>::Output

The resulting type after applying the * operator.

fn mul(self, other: &Vec2d<f64>) -> <Vec2d<f64> as Mul<Vec2d<f64>>>::Output

Performs the * operation.

impl<'_> Mul<&'_ Vec2d<i128>> for Vec2d<i128>

type Output = <Vec2d<i128> as Mul<Vec2d<i128>>>::Output

The resulting type after applying the * operator.

fn mul(self, other: &Vec2d<i128>) -> <Vec2d<i128> as Mul<Vec2d<i128>>>::Output

Performs the * operation.

impl<'_, '_> Mul<&'_ Vec2d<i128>> for &'_ Vec2d<i128>

type Output = <Vec2d<i128> as Mul<Vec2d<i128>>>::Output

The resulting type after applying the * operator.

fn mul(self, other: &Vec2d<i128>) -> <Vec2d<i128> as Mul<Vec2d<i128>>>::Output

Performs the * operation.

impl<'_> Mul<&'_ Vec2d<i16>> for Vec2d<i16>

type Output = <Vec2d<i16> as Mul<Vec2d<i16>>>::Output

The resulting type after applying the * operator.

fn mul(self, other: &Vec2d<i16>) -> <Vec2d<i16> as Mul<Vec2d<i16>>>::Output

Performs the * operation.

impl<'_, '_> Mul<&'_ Vec2d<i16>> for &'_ Vec2d<i16>

type Output = <Vec2d<i16> as Mul<Vec2d<i16>>>::Output

The resulting type after applying the * operator.

fn mul(self, other: &Vec2d<i16>) -> <Vec2d<i16> as Mul<Vec2d<i16>>>::Output

Performs the * operation.

impl<'_> Mul<&'_ Vec2d<i32>> for Vec2d<i32>

type Output = <Vec2d<i32> as Mul<Vec2d<i32>>>::Output

The resulting type after applying the * operator.

fn mul(self, other: &Vec2d<i32>) -> <Vec2d<i32> as Mul<Vec2d<i32>>>::Output

Performs the * operation.

impl<'_, '_> Mul<&'_ Vec2d<i32>> for &'_ Vec2d<i32>

type Output = <Vec2d<i32> as Mul<Vec2d<i32>>>::Output

The resulting type after applying the * operator.

fn mul(self, other: &Vec2d<i32>) -> <Vec2d<i32> as Mul<Vec2d<i32>>>::Output

Performs the * operation.

impl<'_> Mul<&'_ Vec2d<i64>> for Vec2d<i64>

type Output = <Vec2d<i64> as Mul<Vec2d<i64>>>::Output

The resulting type after applying the * operator.

fn mul(self, other: &Vec2d<i64>) -> <Vec2d<i64> as Mul<Vec2d<i64>>>::Output

Performs the * operation.

impl<'_, '_> Mul<&'_ Vec2d<i64>> for &'_ Vec2d<i64>

type Output = <Vec2d<i64> as Mul<Vec2d<i64>>>::Output

The resulting type after applying the * operator.

fn mul(self, other: &Vec2d<i64>) -> <Vec2d<i64> as Mul<Vec2d<i64>>>::Output

Performs the * operation.

impl<'_> Mul<&'_ Vec2d<i8>> for Vec2d<i8>

type Output = <Vec2d<i8> as Mul<Vec2d<i8>>>::Output

The resulting type after applying the * operator.

fn mul(self, other: &Vec2d<i8>) -> <Vec2d<i8> as Mul<Vec2d<i8>>>::Output

Performs the * operation.

impl<'_, '_> Mul<&'_ Vec2d<i8>> for &'_ Vec2d<i8>

type Output = <Vec2d<i8> as Mul<Vec2d<i8>>>::Output

The resulting type after applying the * operator.

fn mul(self, other: &Vec2d<i8>) -> <Vec2d<i8> as Mul<Vec2d<i8>>>::Output

Performs the * operation.

impl<'_> Mul<&'_ Vec2d<isize>> for Vec2d<isize>

type Output = <Vec2d<isize> as Mul<Vec2d<isize>>>::Output

The resulting type after applying the * operator.

fn mul(
    self,
    other: &Vec2d<isize>
) -> <Vec2d<isize> as Mul<Vec2d<isize>>>::Output

Performs the * operation.

impl<'_, '_> Mul<&'_ Vec2d<isize>> for &'_ Vec2d<isize>

type Output = <Vec2d<isize> as Mul<Vec2d<isize>>>::Output

The resulting type after applying the * operator.

fn mul(
    self,
    other: &Vec2d<isize>
) -> <Vec2d<isize> as Mul<Vec2d<isize>>>::Output

Performs the * operation.

impl<'_> Mul<&'_ Vec2d<u128>> for Vec2d<u128>

type Output = <Vec2d<u128> as Mul<Vec2d<u128>>>::Output

The resulting type after applying the * operator.

fn mul(self, other: &Vec2d<u128>) -> <Vec2d<u128> as Mul<Vec2d<u128>>>::Output

Performs the * operation.

impl<'_, '_> Mul<&'_ Vec2d<u128>> for &'_ Vec2d<u128>

type Output = <Vec2d<u128> as Mul<Vec2d<u128>>>::Output

The resulting type after applying the * operator.

fn mul(self, other: &Vec2d<u128>) -> <Vec2d<u128> as Mul<Vec2d<u128>>>::Output

Performs the * operation.

impl<'_> Mul<&'_ Vec2d<u16>> for Vec2d<u16>

type Output = <Vec2d<u16> as Mul<Vec2d<u16>>>::Output

The resulting type after applying the * operator.

fn mul(self, other: &Vec2d<u16>) -> <Vec2d<u16> as Mul<Vec2d<u16>>>::Output

Performs the * operation.

impl<'_, '_> Mul<&'_ Vec2d<u16>> for &'_ Vec2d<u16>

type Output = <Vec2d<u16> as Mul<Vec2d<u16>>>::Output

The resulting type after applying the * operator.

fn mul(self, other: &Vec2d<u16>) -> <Vec2d<u16> as Mul<Vec2d<u16>>>::Output

Performs the * operation.

impl<'_> Mul<&'_ Vec2d<u32>> for Vec2d<u32>

type Output = <Vec2d<u32> as Mul<Vec2d<u32>>>::Output

The resulting type after applying the * operator.

fn mul(self, other: &Vec2d<u32>) -> <Vec2d<u32> as Mul<Vec2d<u32>>>::Output

Performs the * operation.

impl<'_, '_> Mul<&'_ Vec2d<u32>> for &'_ Vec2d<u32>

type Output = <Vec2d<u32> as Mul<Vec2d<u32>>>::Output

The resulting type after applying the * operator.

fn mul(self, other: &Vec2d<u32>) -> <Vec2d<u32> as Mul<Vec2d<u32>>>::Output

Performs the * operation.

impl<'_> Mul<&'_ Vec2d<u64>> for Vec2d<u64>

type Output = <Vec2d<u64> as Mul<Vec2d<u64>>>::Output

The resulting type after applying the * operator.

fn mul(self, other: &Vec2d<u64>) -> <Vec2d<u64> as Mul<Vec2d<u64>>>::Output

Performs the * operation.

impl<'_, '_> Mul<&'_ Vec2d<u64>> for &'_ Vec2d<u64>

type Output = <Vec2d<u64> as Mul<Vec2d<u64>>>::Output

The resulting type after applying the * operator.

fn mul(self, other: &Vec2d<u64>) -> <Vec2d<u64> as Mul<Vec2d<u64>>>::Output

Performs the * operation.

impl<'_> Mul<&'_ Vec2d<u8>> for Vec2d<u8>

type Output = <Vec2d<u8> as Mul<Vec2d<u8>>>::Output

The resulting type after applying the * operator.

fn mul(self, other: &Vec2d<u8>) -> <Vec2d<u8> as Mul<Vec2d<u8>>>::Output

Performs the * operation.

impl<'_, '_> Mul<&'_ Vec2d<u8>> for &'_ Vec2d<u8>

type Output = <Vec2d<u8> as Mul<Vec2d<u8>>>::Output

The resulting type after applying the * operator.

fn mul(self, other: &Vec2d<u8>) -> <Vec2d<u8> as Mul<Vec2d<u8>>>::Output

Performs the * operation.

impl<'_> Mul<&'_ Vec2d<usize>> for Vec2d<usize>

type Output = <Vec2d<usize> as Mul<Vec2d<usize>>>::Output

The resulting type after applying the * operator.

fn mul(
    self,
    other: &Vec2d<usize>
) -> <Vec2d<usize> as Mul<Vec2d<usize>>>::Output

Performs the * operation.

impl<'_, '_> Mul<&'_ Vec2d<usize>> for &'_ Vec2d<usize>

type Output = <Vec2d<usize> as Mul<Vec2d<usize>>>::Output

The resulting type after applying the * operator.

fn mul(
    self,
    other: &Vec2d<usize>
) -> <Vec2d<usize> as Mul<Vec2d<usize>>>::Output

Performs the * operation.

impl<'_> Mul<&'_ f32> for Vec2d<f32>

type Output = <Vec2d<f32> as Mul<f32>>::Output

The resulting type after applying the * operator.

fn mul(self, other: &f32) -> <Vec2d<f32> as Mul<f32>>::Output

Performs the * operation.

impl<'_, '_> Mul<&'_ f32> for &'_ Vec2d<f32>

type Output = <Vec2d<f32> as Mul<f32>>::Output

The resulting type after applying the * operator.

fn mul(self, other: &f32) -> <Vec2d<f32> as Mul<f32>>::Output

Performs the * operation.

impl<'_> Mul<&'_ f64> for Vec2d<f64>

type Output = <Vec2d<f64> as Mul<f64>>::Output

The resulting type after applying the * operator.

fn mul(self, other: &f64) -> <Vec2d<f64> as Mul<f64>>::Output

Performs the * operation.

impl<'_, '_> Mul<&'_ f64> for &'_ Vec2d<f64>

type Output = <Vec2d<f64> as Mul<f64>>::Output

The resulting type after applying the * operator.

fn mul(self, other: &f64) -> <Vec2d<f64> as Mul<f64>>::Output

Performs the * operation.

impl<'_> Mul<&'_ i128> for Vec2d<i128>

type Output = <Vec2d<i128> as Mul<i128>>::Output

The resulting type after applying the * operator.

fn mul(self, other: &i128) -> <Vec2d<i128> as Mul<i128>>::Output

Performs the * operation.

impl<'_, '_> Mul<&'_ i128> for &'_ Vec2d<i128>

type Output = <Vec2d<i128> as Mul<i128>>::Output

The resulting type after applying the * operator.

fn mul(self, other: &i128) -> <Vec2d<i128> as Mul<i128>>::Output

Performs the * operation.

impl<'_> Mul<&'_ i16> for Vec2d<i16>

type Output = <Vec2d<i16> as Mul<i16>>::Output

The resulting type after applying the * operator.

fn mul(self, other: &i16) -> <Vec2d<i16> as Mul<i16>>::Output

Performs the * operation.

impl<'_, '_> Mul<&'_ i16> for &'_ Vec2d<i16>

type Output = <Vec2d<i16> as Mul<i16>>::Output

The resulting type after applying the * operator.

fn mul(self, other: &i16) -> <Vec2d<i16> as Mul<i16>>::Output

Performs the * operation.

impl<'_> Mul<&'_ i32> for Vec2d<i32>

type Output = <Vec2d<i32> as Mul<i32>>::Output

The resulting type after applying the * operator.

fn mul(self, other: &i32) -> <Vec2d<i32> as Mul<i32>>::Output

Performs the * operation.

impl<'_, '_> Mul<&'_ i32> for &'_ Vec2d<i32>

type Output = <Vec2d<i32> as Mul<i32>>::Output

The resulting type after applying the * operator.

fn mul(self, other: &i32) -> <Vec2d<i32> as Mul<i32>>::Output

Performs the * operation.

impl<'_> Mul<&'_ i64> for Vec2d<i64>

type Output = <Vec2d<i64> as Mul<i64>>::Output

The resulting type after applying the * operator.

fn mul(self, other: &i64) -> <Vec2d<i64> as Mul<i64>>::Output

Performs the * operation.

impl<'_, '_> Mul<&'_ i64> for &'_ Vec2d<i64>

type Output = <Vec2d<i64> as Mul<i64>>::Output

The resulting type after applying the * operator.

fn mul(self, other: &i64) -> <Vec2d<i64> as Mul<i64>>::Output

Performs the * operation.

impl<'_> Mul<&'_ i8> for Vec2d<i8>

type Output = <Vec2d<i8> as Mul<i8>>::Output

The resulting type after applying the * operator.

fn mul(self, other: &i8) -> <Vec2d<i8> as Mul<i8>>::Output

Performs the * operation.

impl<'_, '_> Mul<&'_ i8> for &'_ Vec2d<i8>

type Output = <Vec2d<i8> as Mul<i8>>::Output

The resulting type after applying the * operator.

fn mul(self, other: &i8) -> <Vec2d<i8> as Mul<i8>>::Output

Performs the * operation.

impl<'_> Mul<&'_ isize> for Vec2d<isize>

type Output = <Vec2d<isize> as Mul<isize>>::Output

The resulting type after applying the * operator.

fn mul(self, other: &isize) -> <Vec2d<isize> as Mul<isize>>::Output

Performs the * operation.

impl<'_, '_> Mul<&'_ isize> for &'_ Vec2d<isize>

type Output = <Vec2d<isize> as Mul<isize>>::Output

The resulting type after applying the * operator.

fn mul(self, other: &isize) -> <Vec2d<isize> as Mul<isize>>::Output

Performs the * operation.

impl<'_> Mul<&'_ u128> for Vec2d<u128>

type Output = <Vec2d<u128> as Mul<u128>>::Output

The resulting type after applying the * operator.

fn mul(self, other: &u128) -> <Vec2d<u128> as Mul<u128>>::Output

Performs the * operation.

impl<'_, '_> Mul<&'_ u128> for &'_ Vec2d<u128>

type Output = <Vec2d<u128> as Mul<u128>>::Output

The resulting type after applying the * operator.

fn mul(self, other: &u128) -> <Vec2d<u128> as Mul<u128>>::Output

Performs the * operation.

impl<'_> Mul<&'_ u16> for Vec2d<u16>

type Output = <Vec2d<u16> as Mul<u16>>::Output

The resulting type after applying the * operator.

fn mul(self, other: &u16) -> <Vec2d<u16> as Mul<u16>>::Output

Performs the * operation.

impl<'_, '_> Mul<&'_ u16> for &'_ Vec2d<u16>

type Output = <Vec2d<u16> as Mul<u16>>::Output

The resulting type after applying the * operator.

fn mul(self, other: &u16) -> <Vec2d<u16> as Mul<u16>>::Output

Performs the * operation.

impl<'_> Mul<&'_ u32> for Vec2d<u32>

type Output = <Vec2d<u32> as Mul<u32>>::Output

The resulting type after applying the * operator.

fn mul(self, other: &u32) -> <Vec2d<u32> as Mul<u32>>::Output

Performs the * operation.

impl<'_, '_> Mul<&'_ u32> for &'_ Vec2d<u32>

type Output = <Vec2d<u32> as Mul<u32>>::Output

The resulting type after applying the * operator.

fn mul(self, other: &u32) -> <Vec2d<u32> as Mul<u32>>::Output

Performs the * operation.

impl<'_> Mul<&'_ u64> for Vec2d<u64>

type Output = <Vec2d<u64> as Mul<u64>>::Output

The resulting type after applying the * operator.

fn mul(self, other: &u64) -> <Vec2d<u64> as Mul<u64>>::Output

Performs the * operation.

impl<'_, '_> Mul<&'_ u64> for &'_ Vec2d<u64>

type Output = <Vec2d<u64> as Mul<u64>>::Output

The resulting type after applying the * operator.

fn mul(self, other: &u64) -> <Vec2d<u64> as Mul<u64>>::Output

Performs the * operation.

impl<'_> Mul<&'_ u8> for Vec2d<u8>

type Output = <Vec2d<u8> as Mul<u8>>::Output

The resulting type after applying the * operator.

fn mul(self, other: &u8) -> <Vec2d<u8> as Mul<u8>>::Output

Performs the * operation.

impl<'_, '_> Mul<&'_ u8> for &'_ Vec2d<u8>

type Output = <Vec2d<u8> as Mul<u8>>::Output

The resulting type after applying the * operator.

fn mul(self, other: &u8) -> <Vec2d<u8> as Mul<u8>>::Output

Performs the * operation.

impl<'_> Mul<&'_ usize> for Vec2d<usize>

type Output = <Vec2d<usize> as Mul<usize>>::Output

The resulting type after applying the * operator.

fn mul(self, other: &usize) -> <Vec2d<usize> as Mul<usize>>::Output

Performs the * operation.

impl<'_, '_> Mul<&'_ usize> for &'_ Vec2d<usize>

type Output = <Vec2d<usize> as Mul<usize>>::Output

The resulting type after applying the * operator.

fn mul(self, other: &usize) -> <Vec2d<usize> as Mul<usize>>::Output

Performs the * operation.

impl<T: Mul + Copy> Mul<T> for Vec2d<T>

Multiply Vec2d by scalar

type Output = Vec2d<T::Output>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<T: Mul + Add> Mul<Vec2d<T>> for Vec2d<T> where
    <T as Mul>::Output: Add, 

Calculate and return the scalar product of this Vec2d by Vec2d

type Output = <<T as Mul>::Output as Add>::Output

The resulting type after applying the * operator.

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

Performs the * operation.

impl<'a> Mul<Vec2d<f32>> for &'a Vec2d<f32>

type Output = <Vec2d<f32> as Mul<Vec2d<f32>>>::Output

The resulting type after applying the * operator.

fn mul(self, other: Vec2d<f32>) -> <Vec2d<f32> as Mul<Vec2d<f32>>>::Output

Performs the * operation.

impl<'a> Mul<Vec2d<f64>> for &'a Vec2d<f64>

type Output = <Vec2d<f64> as Mul<Vec2d<f64>>>::Output

The resulting type after applying the * operator.

fn mul(self, other: Vec2d<f64>) -> <Vec2d<f64> as Mul<Vec2d<f64>>>::Output

Performs the * operation.

impl<'a> Mul<Vec2d<i128>> for &'a Vec2d<i128>

type Output = <Vec2d<i128> as Mul<Vec2d<i128>>>::Output

The resulting type after applying the * operator.

fn mul(self, other: Vec2d<i128>) -> <Vec2d<i128> as Mul<Vec2d<i128>>>::Output

Performs the * operation.

impl<'a> Mul<Vec2d<i16>> for &'a Vec2d<i16>

type Output = <Vec2d<i16> as Mul<Vec2d<i16>>>::Output

The resulting type after applying the * operator.

fn mul(self, other: Vec2d<i16>) -> <Vec2d<i16> as Mul<Vec2d<i16>>>::Output

Performs the * operation.

impl<'a> Mul<Vec2d<i32>> for &'a Vec2d<i32>

type Output = <Vec2d<i32> as Mul<Vec2d<i32>>>::Output

The resulting type after applying the * operator.

fn mul(self, other: Vec2d<i32>) -> <Vec2d<i32> as Mul<Vec2d<i32>>>::Output

Performs the * operation.

impl<'a> Mul<Vec2d<i64>> for &'a Vec2d<i64>

type Output = <Vec2d<i64> as Mul<Vec2d<i64>>>::Output

The resulting type after applying the * operator.

fn mul(self, other: Vec2d<i64>) -> <Vec2d<i64> as Mul<Vec2d<i64>>>::Output

Performs the * operation.

impl<'a> Mul<Vec2d<i8>> for &'a Vec2d<i8>

type Output = <Vec2d<i8> as Mul<Vec2d<i8>>>::Output

The resulting type after applying the * operator.

fn mul(self, other: Vec2d<i8>) -> <Vec2d<i8> as Mul<Vec2d<i8>>>::Output

Performs the * operation.

impl<'a> Mul<Vec2d<isize>> for &'a Vec2d<isize>

type Output = <Vec2d<isize> as Mul<Vec2d<isize>>>::Output

The resulting type after applying the * operator.

fn mul(self, other: Vec2d<isize>) -> <Vec2d<isize> as Mul<Vec2d<isize>>>::Output

Performs the * operation.

impl<'a> Mul<Vec2d<u128>> for &'a Vec2d<u128>

type Output = <Vec2d<u128> as Mul<Vec2d<u128>>>::Output

The resulting type after applying the * operator.

fn mul(self, other: Vec2d<u128>) -> <Vec2d<u128> as Mul<Vec2d<u128>>>::Output

Performs the * operation.

impl<'a> Mul<Vec2d<u16>> for &'a Vec2d<u16>

type Output = <Vec2d<u16> as Mul<Vec2d<u16>>>::Output

The resulting type after applying the * operator.

fn mul(self, other: Vec2d<u16>) -> <Vec2d<u16> as Mul<Vec2d<u16>>>::Output

Performs the * operation.

impl<'a> Mul<Vec2d<u32>> for &'a Vec2d<u32>

type Output = <Vec2d<u32> as Mul<Vec2d<u32>>>::Output

The resulting type after applying the * operator.

fn mul(self, other: Vec2d<u32>) -> <Vec2d<u32> as Mul<Vec2d<u32>>>::Output

Performs the * operation.

impl<'a> Mul<Vec2d<u64>> for &'a Vec2d<u64>

type Output = <Vec2d<u64> as Mul<Vec2d<u64>>>::Output

The resulting type after applying the * operator.

fn mul(self, other: Vec2d<u64>) -> <Vec2d<u64> as Mul<Vec2d<u64>>>::Output

Performs the * operation.

impl<'a> Mul<Vec2d<u8>> for &'a Vec2d<u8>

type Output = <Vec2d<u8> as Mul<Vec2d<u8>>>::Output

The resulting type after applying the * operator.

fn mul(self, other: Vec2d<u8>) -> <Vec2d<u8> as Mul<Vec2d<u8>>>::Output

Performs the * operation.

impl<'a> Mul<Vec2d<usize>> for &'a Vec2d<usize>

type Output = <Vec2d<usize> as Mul<Vec2d<usize>>>::Output

The resulting type after applying the * operator.

fn mul(self, other: Vec2d<usize>) -> <Vec2d<usize> as Mul<Vec2d<usize>>>::Output

Performs the * operation.

impl<'a> Mul<f32> for &'a Vec2d<f32>

type Output = <Vec2d<f32> as Mul<f32>>::Output

The resulting type after applying the * operator.

fn mul(self, other: f32) -> <Vec2d<f32> as Mul<f32>>::Output

Performs the * operation.

impl<'a> Mul<f64> for &'a Vec2d<f64>

type Output = <Vec2d<f64> as Mul<f64>>::Output

The resulting type after applying the * operator.

fn mul(self, other: f64) -> <Vec2d<f64> as Mul<f64>>::Output

Performs the * operation.

impl<'a> Mul<i128> for &'a Vec2d<i128>

type Output = <Vec2d<i128> as Mul<i128>>::Output

The resulting type after applying the * operator.

fn mul(self, other: i128) -> <Vec2d<i128> as Mul<i128>>::Output

Performs the * operation.

impl<'a> Mul<i16> for &'a Vec2d<i16>

type Output = <Vec2d<i16> as Mul<i16>>::Output

The resulting type after applying the * operator.

fn mul(self, other: i16) -> <Vec2d<i16> as Mul<i16>>::Output

Performs the * operation.

impl<'a> Mul<i32> for &'a Vec2d<i32>

type Output = <Vec2d<i32> as Mul<i32>>::Output

The resulting type after applying the * operator.

fn mul(self, other: i32) -> <Vec2d<i32> as Mul<i32>>::Output

Performs the * operation.

impl<'a> Mul<i64> for &'a Vec2d<i64>

type Output = <Vec2d<i64> as Mul<i64>>::Output

The resulting type after applying the * operator.

fn mul(self, other: i64) -> <Vec2d<i64> as Mul<i64>>::Output

Performs the * operation.

impl<'a> Mul<i8> for &'a Vec2d<i8>

type Output = <Vec2d<i8> as Mul<i8>>::Output

The resulting type after applying the * operator.

fn mul(self, other: i8) -> <Vec2d<i8> as Mul<i8>>::Output

Performs the * operation.

impl<'a> Mul<isize> for &'a Vec2d<isize>

type Output = <Vec2d<isize> as Mul<isize>>::Output

The resulting type after applying the * operator.

fn mul(self, other: isize) -> <Vec2d<isize> as Mul<isize>>::Output

Performs the * operation.

impl<'a> Mul<u128> for &'a Vec2d<u128>

type Output = <Vec2d<u128> as Mul<u128>>::Output

The resulting type after applying the * operator.

fn mul(self, other: u128) -> <Vec2d<u128> as Mul<u128>>::Output

Performs the * operation.

impl<'a> Mul<u16> for &'a Vec2d<u16>

type Output = <Vec2d<u16> as Mul<u16>>::Output

The resulting type after applying the * operator.

fn mul(self, other: u16) -> <Vec2d<u16> as Mul<u16>>::Output

Performs the * operation.

impl<'a> Mul<u32> for &'a Vec2d<u32>

type Output = <Vec2d<u32> as Mul<u32>>::Output

The resulting type after applying the * operator.

fn mul(self, other: u32) -> <Vec2d<u32> as Mul<u32>>::Output

Performs the * operation.

impl<'a> Mul<u64> for &'a Vec2d<u64>

type Output = <Vec2d<u64> as Mul<u64>>::Output

The resulting type after applying the * operator.

fn mul(self, other: u64) -> <Vec2d<u64> as Mul<u64>>::Output

Performs the * operation.

impl<'a> Mul<u8> for &'a Vec2d<u8>

type Output = <Vec2d<u8> as Mul<u8>>::Output

The resulting type after applying the * operator.

fn mul(self, other: u8) -> <Vec2d<u8> as Mul<u8>>::Output

Performs the * operation.

impl<'a> Mul<usize> for &'a Vec2d<usize>

type Output = <Vec2d<usize> as Mul<usize>>::Output

The resulting type after applying the * operator.

fn mul(self, other: usize) -> <Vec2d<usize> as Mul<usize>>::Output

Performs the * operation.

impl<'_> MulAssign<&'_ Vec2d<f32>> for Vec2d<f32>

fn mul_assign(&mut self, other: &Vec2d<f32>)

Performs the *= operation.

impl<'_> MulAssign<&'_ Vec2d<f64>> for Vec2d<f64>

fn mul_assign(&mut self, other: &Vec2d<f64>)

Performs the *= operation.

impl<'_> MulAssign<&'_ Vec2d<i128>> for Vec2d<i128>

fn mul_assign(&mut self, other: &Vec2d<i128>)

Performs the *= operation.

impl<'_> MulAssign<&'_ Vec2d<i16>> for Vec2d<i16>

fn mul_assign(&mut self, other: &Vec2d<i16>)

Performs the *= operation.

impl<'_> MulAssign<&'_ Vec2d<i32>> for Vec2d<i32>

fn mul_assign(&mut self, other: &Vec2d<i32>)

Performs the *= operation.

impl<'_> MulAssign<&'_ Vec2d<i64>> for Vec2d<i64>

fn mul_assign(&mut self, other: &Vec2d<i64>)

Performs the *= operation.

impl<'_> MulAssign<&'_ Vec2d<i8>> for Vec2d<i8>

fn mul_assign(&mut self, other: &Vec2d<i8>)

Performs the *= operation.

impl<'_> MulAssign<&'_ Vec2d<isize>> for Vec2d<isize>

fn mul_assign(&mut self, other: &Vec2d<isize>)

Performs the *= operation.

impl<'_> MulAssign<&'_ Vec2d<u128>> for Vec2d<u128>

fn mul_assign(&mut self, other: &Vec2d<u128>)

Performs the *= operation.

impl<'_> MulAssign<&'_ Vec2d<u16>> for Vec2d<u16>

fn mul_assign(&mut self, other: &Vec2d<u16>)

Performs the *= operation.

impl<'_> MulAssign<&'_ Vec2d<u32>> for Vec2d<u32>

fn mul_assign(&mut self, other: &Vec2d<u32>)

Performs the *= operation.

impl<'_> MulAssign<&'_ Vec2d<u64>> for Vec2d<u64>

fn mul_assign(&mut self, other: &Vec2d<u64>)

Performs the *= operation.

impl<'_> MulAssign<&'_ Vec2d<u8>> for Vec2d<u8>

fn mul_assign(&mut self, other: &Vec2d<u8>)

Performs the *= operation.

impl<'_> MulAssign<&'_ Vec2d<usize>> for Vec2d<usize>

fn mul_assign(&mut self, other: &Vec2d<usize>)

Performs the *= operation.

impl<'_> MulAssign<&'_ f32> for Vec2d<f32>

fn mul_assign(&mut self, other: &f32)

Performs the *= operation.

impl<'_> MulAssign<&'_ f64> for Vec2d<f64>

fn mul_assign(&mut self, other: &f64)

Performs the *= operation.

impl<'_> MulAssign<&'_ i128> for Vec2d<i128>

fn mul_assign(&mut self, other: &i128)

Performs the *= operation.

impl<'_> MulAssign<&'_ i16> for Vec2d<i16>

fn mul_assign(&mut self, other: &i16)

Performs the *= operation.

impl<'_> MulAssign<&'_ i32> for Vec2d<i32>

fn mul_assign(&mut self, other: &i32)

Performs the *= operation.

impl<'_> MulAssign<&'_ i64> for Vec2d<i64>

fn mul_assign(&mut self, other: &i64)

Performs the *= operation.

impl<'_> MulAssign<&'_ i8> for Vec2d<i8>

fn mul_assign(&mut self, other: &i8)

Performs the *= operation.

impl<'_> MulAssign<&'_ isize> for Vec2d<isize>

fn mul_assign(&mut self, other: &isize)

Performs the *= operation.

impl<'_> MulAssign<&'_ u128> for Vec2d<u128>

fn mul_assign(&mut self, other: &u128)

Performs the *= operation.

impl<'_> MulAssign<&'_ u16> for Vec2d<u16>

fn mul_assign(&mut self, other: &u16)

Performs the *= operation.

impl<'_> MulAssign<&'_ u32> for Vec2d<u32>

fn mul_assign(&mut self, other: &u32)

Performs the *= operation.

impl<'_> MulAssign<&'_ u64> for Vec2d<u64>

fn mul_assign(&mut self, other: &u64)

Performs the *= operation.

impl<'_> MulAssign<&'_ u8> for Vec2d<u8>

fn mul_assign(&mut self, other: &u8)

Performs the *= operation.

impl<'_> MulAssign<&'_ usize> for Vec2d<usize>

fn mul_assign(&mut self, other: &usize)

Performs the *= operation.

impl<T: MulAssign + Copy> MulAssign<T> for Vec2d<T>

Multiply this Vec2d by scalar

fn mul_assign(&mut self, rhs: T)

Performs the *= operation.

impl<T: MulAssign> MulAssign<Vec2d<T>> for Vec2d<T>

Multiply this Vec2d by a Vec2d

fn mul_assign(&mut self, rhs: Self)

Performs the *= operation.

impl<T: Neg> Neg for Vec2d<T>

Invert the sign of a Vec2d

type Output = Vec2d<T::Output>

The resulting type after applying the - operator.

fn neg(self) -> Self::Output

Performs the unary - operation.

impl<T: PartialEq> PartialEq<Vec2d<T>> for Vec2d<T>

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

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Vec2d<T>) -> bool

This method tests for !=.

impl<T: PartialOrd> PartialOrd<Vec2d<T>> for Vec2d<T>

fn partial_cmp(&self, other: &Vec2d<T>) -> Option<Ordering>

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

fn lt(&self, other: &Vec2d<T>) -> bool

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

fn le(&self, other: &Vec2d<T>) -> bool

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

fn gt(&self, other: &Vec2d<T>) -> bool

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

fn ge(&self, other: &Vec2d<T>) -> bool

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

impl<T> StructuralEq for Vec2d<T>

impl<T> StructuralPartialEq for Vec2d<T>

impl<'_> Sub<&'_ Vec2d<f32>> for Vec2d<f32>

type Output = <Vec2d<f32> as Sub<Vec2d<f32>>>::Output

The resulting type after applying the - operator.

fn sub(self, other: &Vec2d<f32>) -> <Vec2d<f32> as Sub<Vec2d<f32>>>::Output

Performs the - operation.

impl<'_, '_> Sub<&'_ Vec2d<f32>> for &'_ Vec2d<f32>

type Output = <Vec2d<f32> as Sub<Vec2d<f32>>>::Output

The resulting type after applying the - operator.

fn sub(self, other: &Vec2d<f32>) -> <Vec2d<f32> as Sub<Vec2d<f32>>>::Output

Performs the - operation.

impl<'_> Sub<&'_ Vec2d<f64>> for Vec2d<f64>

type Output = <Vec2d<f64> as Sub<Vec2d<f64>>>::Output

The resulting type after applying the - operator.

fn sub(self, other: &Vec2d<f64>) -> <Vec2d<f64> as Sub<Vec2d<f64>>>::Output

Performs the - operation.

impl<'_, '_> Sub<&'_ Vec2d<f64>> for &'_ Vec2d<f64>

type Output = <Vec2d<f64> as Sub<Vec2d<f64>>>::Output

The resulting type after applying the - operator.

fn sub(self, other: &Vec2d<f64>) -> <Vec2d<f64> as Sub<Vec2d<f64>>>::Output

Performs the - operation.

impl<'_> Sub<&'_ Vec2d<i128>> for Vec2d<i128>

type Output = <Vec2d<i128> as Sub<Vec2d<i128>>>::Output

The resulting type after applying the - operator.

fn sub(self, other: &Vec2d<i128>) -> <Vec2d<i128> as Sub<Vec2d<i128>>>::Output

Performs the - operation.

impl<'_, '_> Sub<&'_ Vec2d<i128>> for &'_ Vec2d<i128>

type Output = <Vec2d<i128> as Sub<Vec2d<i128>>>::Output

The resulting type after applying the - operator.

fn sub(self, other: &Vec2d<i128>) -> <Vec2d<i128> as Sub<Vec2d<i128>>>::Output

Performs the - operation.

impl<'_> Sub<&'_ Vec2d<i16>> for Vec2d<i16>

type Output = <Vec2d<i16> as Sub<Vec2d<i16>>>::Output

The resulting type after applying the - operator.

fn sub(self, other: &Vec2d<i16>) -> <Vec2d<i16> as Sub<Vec2d<i16>>>::Output

Performs the - operation.

impl<'_, '_> Sub<&'_ Vec2d<i16>> for &'_ Vec2d<i16>

type Output = <Vec2d<i16> as Sub<Vec2d<i16>>>::Output

The resulting type after applying the - operator.

fn sub(self, other: &Vec2d<i16>) -> <Vec2d<i16> as Sub<Vec2d<i16>>>::Output

Performs the - operation.

impl<'_> Sub<&'_ Vec2d<i32>> for Vec2d<i32>

type Output = <Vec2d<i32> as Sub<Vec2d<i32>>>::Output

The resulting type after applying the - operator.

fn sub(self, other: &Vec2d<i32>) -> <Vec2d<i32> as Sub<Vec2d<i32>>>::Output

Performs the - operation.

impl<'_, '_> Sub<&'_ Vec2d<i32>> for &'_ Vec2d<i32>

type Output = <Vec2d<i32> as Sub<Vec2d<i32>>>::Output

The resulting type after applying the - operator.

fn sub(self, other: &Vec2d<i32>) -> <Vec2d<i32> as Sub<Vec2d<i32>>>::Output

Performs the - operation.

impl<'_> Sub<&'_ Vec2d<i64>> for Vec2d<i64>

type Output = <Vec2d<i64> as Sub<Vec2d<i64>>>::Output

The resulting type after applying the - operator.

fn sub(self, other: &Vec2d<i64>) -> <Vec2d<i64> as Sub<Vec2d<i64>>>::Output

Performs the - operation.

impl<'_, '_> Sub<&'_ Vec2d<i64>> for &'_ Vec2d<i64>

type Output = <Vec2d<i64> as Sub<Vec2d<i64>>>::Output

The resulting type after applying the - operator.

fn sub(self, other: &Vec2d<i64>) -> <Vec2d<i64> as Sub<Vec2d<i64>>>::Output

Performs the - operation.

impl<'_> Sub<&'_ Vec2d<i8>> for Vec2d<i8>

type Output = <Vec2d<i8> as Sub<Vec2d<i8>>>::Output

The resulting type after applying the - operator.

fn sub(self, other: &Vec2d<i8>) -> <Vec2d<i8> as Sub<Vec2d<i8>>>::Output

Performs the - operation.

impl<'_, '_> Sub<&'_ Vec2d<i8>> for &'_ Vec2d<i8>

type Output = <Vec2d<i8> as Sub<Vec2d<i8>>>::Output

The resulting type after applying the - operator.

fn sub(self, other: &Vec2d<i8>) -> <Vec2d<i8> as Sub<Vec2d<i8>>>::Output

Performs the - operation.

impl<'_> Sub<&'_ Vec2d<isize>> for Vec2d<isize>

type Output = <Vec2d<isize> as Sub<Vec2d<isize>>>::Output

The resulting type after applying the - operator.

fn sub(
    self,
    other: &Vec2d<isize>
) -> <Vec2d<isize> as Sub<Vec2d<isize>>>::Output

Performs the - operation.

impl<'_, '_> Sub<&'_ Vec2d<isize>> for &'_ Vec2d<isize>

type Output = <Vec2d<isize> as Sub<Vec2d<isize>>>::Output

The resulting type after applying the - operator.

fn sub(
    self,
    other: &Vec2d<isize>
) -> <Vec2d<isize> as Sub<Vec2d<isize>>>::Output

Performs the - operation.

impl<'_> Sub<&'_ Vec2d<u128>> for Vec2d<u128>

type Output = <Vec2d<u128> as Sub<Vec2d<u128>>>::Output

The resulting type after applying the - operator.

fn sub(self, other: &Vec2d<u128>) -> <Vec2d<u128> as Sub<Vec2d<u128>>>::Output

Performs the - operation.

impl<'_, '_> Sub<&'_ Vec2d<u128>> for &'_ Vec2d<u128>

type Output = <Vec2d<u128> as Sub<Vec2d<u128>>>::Output

The resulting type after applying the - operator.

fn sub(self, other: &Vec2d<u128>) -> <Vec2d<u128> as Sub<Vec2d<u128>>>::Output

Performs the - operation.

impl<'_> Sub<&'_ Vec2d<u16>> for Vec2d<u16>

type Output = <Vec2d<u16> as Sub<Vec2d<u16>>>::Output

The resulting type after applying the - operator.

fn sub(self, other: &Vec2d<u16>) -> <Vec2d<u16> as Sub<Vec2d<u16>>>::Output

Performs the - operation.

impl<'_, '_> Sub<&'_ Vec2d<u16>> for &'_ Vec2d<u16>

type Output = <Vec2d<u16> as Sub<Vec2d<u16>>>::Output

The resulting type after applying the - operator.

fn sub(self, other: &Vec2d<u16>) -> <Vec2d<u16> as Sub<Vec2d<u16>>>::Output

Performs the - operation.

impl<'_> Sub<&'_ Vec2d<u32>> for Vec2d<u32>

type Output = <Vec2d<u32> as Sub<Vec2d<u32>>>::Output

The resulting type after applying the - operator.

fn sub(self, other: &Vec2d<u32>) -> <Vec2d<u32> as Sub<Vec2d<u32>>>::Output

Performs the - operation.

impl<'_, '_> Sub<&'_ Vec2d<u32>> for &'_ Vec2d<u32>

type Output = <Vec2d<u32> as Sub<Vec2d<u32>>>::Output

The resulting type after applying the - operator.

fn sub(self, other: &Vec2d<u32>) -> <Vec2d<u32> as Sub<Vec2d<u32>>>::Output

Performs the - operation.

impl<'_> Sub<&'_ Vec2d<u64>> for Vec2d<u64>

type Output = <Vec2d<u64> as Sub<Vec2d<u64>>>::Output

The resulting type after applying the - operator.

fn sub(self, other: &Vec2d<u64>) -> <Vec2d<u64> as Sub<Vec2d<u64>>>::Output

Performs the - operation.

impl<'_, '_> Sub<&'_ Vec2d<u64>> for &'_ Vec2d<u64>

type Output = <Vec2d<u64> as Sub<Vec2d<u64>>>::Output

The resulting type after applying the - operator.

fn sub(self, other: &Vec2d<u64>) -> <Vec2d<u64> as Sub<Vec2d<u64>>>::Output

Performs the - operation.

impl<'_> Sub<&'_ Vec2d<u8>> for Vec2d<u8>

type Output = <Vec2d<u8> as Sub<Vec2d<u8>>>::Output

The resulting type after applying the - operator.

fn sub(self, other: &Vec2d<u8>) -> <Vec2d<u8> as Sub<Vec2d<u8>>>::Output

Performs the - operation.

impl<'_, '_> Sub<&'_ Vec2d<u8>> for &'_ Vec2d<u8>

type Output = <Vec2d<u8> as Sub<Vec2d<u8>>>::Output

The resulting type after applying the - operator.

fn sub(self, other: &Vec2d<u8>) -> <Vec2d<u8> as Sub<Vec2d<u8>>>::Output

Performs the - operation.

impl<'_> Sub<&'_ Vec2d<usize>> for Vec2d<usize>

type Output = <Vec2d<usize> as Sub<Vec2d<usize>>>::Output

The resulting type after applying the - operator.

fn sub(
    self,
    other: &Vec2d<usize>
) -> <Vec2d<usize> as Sub<Vec2d<usize>>>::Output

Performs the - operation.

impl<'_, '_> Sub<&'_ Vec2d<usize>> for &'_ Vec2d<usize>

type Output = <Vec2d<usize> as Sub<Vec2d<usize>>>::Output

The resulting type after applying the - operator.

fn sub(
    self,
    other: &Vec2d<usize>
) -> <Vec2d<usize> as Sub<Vec2d<usize>>>::Output

Performs the - operation.

impl<'_> Sub<&'_ f32> for Vec2d<f32>

type Output = <Vec2d<f32> as Sub<f32>>::Output

The resulting type after applying the - operator.

fn sub(self, other: &f32) -> <Vec2d<f32> as Sub<f32>>::Output

Performs the - operation.

impl<'_, '_> Sub<&'_ f32> for &'_ Vec2d<f32>

type Output = <Vec2d<f32> as Sub<f32>>::Output

The resulting type after applying the - operator.

fn sub(self, other: &f32) -> <Vec2d<f32> as Sub<f32>>::Output

Performs the - operation.

impl<'_> Sub<&'_ f64> for Vec2d<f64>

type Output = <Vec2d<f64> as Sub<f64>>::Output

The resulting type after applying the - operator.

fn sub(self, other: &f64) -> <Vec2d<f64> as Sub<f64>>::Output

Performs the - operation.

impl<'_, '_> Sub<&'_ f64> for &'_ Vec2d<f64>

type Output = <Vec2d<f64> as Sub<f64>>::Output

The resulting type after applying the - operator.

fn sub(self, other: &f64) -> <Vec2d<f64> as Sub<f64>>::Output

Performs the - operation.

impl<'_> Sub<&'_ i128> for Vec2d<i128>

type Output = <Vec2d<i128> as Sub<i128>>::Output

The resulting type after applying the - operator.

fn sub(self, other: &i128) -> <Vec2d<i128> as Sub<i128>>::Output

Performs the - operation.

impl<'_, '_> Sub<&'_ i128> for &'_ Vec2d<i128>

type Output = <Vec2d<i128> as Sub<i128>>::Output

The resulting type after applying the - operator.

fn sub(self, other: &i128) -> <Vec2d<i128> as Sub<i128>>::Output

Performs the - operation.

impl<'_> Sub<&'_ i16> for Vec2d<i16>

type Output = <Vec2d<i16> as Sub<i16>>::Output

The resulting type after applying the - operator.

fn sub(self, other: &i16) -> <Vec2d<i16> as Sub<i16>>::Output

Performs the - operation.

impl<'_, '_> Sub<&'_ i16> for &'_ Vec2d<i16>

type Output = <Vec2d<i16> as Sub<i16>>::Output

The resulting type after applying the - operator.

fn sub(self, other: &i16) -> <Vec2d<i16> as Sub<i16>>::Output

Performs the - operation.

impl<'_> Sub<&'_ i32> for Vec2d<i32>

type Output = <Vec2d<i32> as Sub<i32>>::Output

The resulting type after applying the - operator.

fn sub(self, other: &i32) -> <Vec2d<i32> as Sub<i32>>::Output

Performs the - operation.

impl<'_, '_> Sub<&'_ i32> for &'_ Vec2d<i32>

type Output = <Vec2d<i32> as Sub<i32>>::Output

The resulting type after applying the - operator.

fn sub(self, other: &i32) -> <Vec2d<i32> as Sub<i32>>::Output

Performs the - operation.

impl<'_> Sub<&'_ i64> for Vec2d<i64>

type Output = <Vec2d<i64> as Sub<i64>>::Output

The resulting type after applying the - operator.

fn sub(self, other: &i64) -> <Vec2d<i64> as Sub<i64>>::Output

Performs the - operation.

impl<'_, '_> Sub<&'_ i64> for &'_ Vec2d<i64>

type Output = <Vec2d<i64> as Sub<i64>>::Output

The resulting type after applying the - operator.

fn sub(self, other: &i64) -> <Vec2d<i64> as Sub<i64>>::Output

Performs the - operation.

impl<'_> Sub<&'_ i8> for Vec2d<i8>

type Output = <Vec2d<i8> as Sub<i8>>::Output

The resulting type after applying the - operator.

fn sub(self, other: &i8) -> <Vec2d<i8> as Sub<i8>>::Output

Performs the - operation.

impl<'_, '_> Sub<&'_ i8> for &'_ Vec2d<i8>

type Output = <Vec2d<i8> as Sub<i8>>::Output

The resulting type after applying the - operator.

fn sub(self, other: &i8) -> <Vec2d<i8> as Sub<i8>>::Output

Performs the - operation.

impl<'_> Sub<&'_ isize> for Vec2d<isize>

type Output = <Vec2d<isize> as Sub<isize>>::Output

The resulting type after applying the - operator.

fn sub(self, other: &isize) -> <Vec2d<isize> as Sub<isize>>::Output

Performs the - operation.

impl<'_, '_> Sub<&'_ isize> for &'_ Vec2d<isize>

type Output = <Vec2d<isize> as Sub<isize>>::Output

The resulting type after applying the - operator.

fn sub(self, other: &isize) -> <Vec2d<isize> as Sub<isize>>::Output

Performs the - operation.

impl<'_> Sub<&'_ u128> for Vec2d<u128>

type Output = <Vec2d<u128> as Sub<u128>>::Output

The resulting type after applying the - operator.

fn sub(self, other: &u128) -> <Vec2d<u128> as Sub<u128>>::Output

Performs the - operation.

impl<'_, '_> Sub<&'_ u128> for &'_ Vec2d<u128>

type Output = <Vec2d<u128> as Sub<u128>>::Output

The resulting type after applying the - operator.

fn sub(self, other: &u128) -> <Vec2d<u128> as Sub<u128>>::Output

Performs the - operation.

impl<'_> Sub<&'_ u16> for Vec2d<u16>

type Output = <Vec2d<u16> as Sub<u16>>::Output

The resulting type after applying the - operator.

fn sub(self, other: &u16) -> <Vec2d<u16> as Sub<u16>>::Output

Performs the - operation.

impl<'_, '_> Sub<&'_ u16> for &'_ Vec2d<u16>

type Output = <Vec2d<u16> as Sub<u16>>::Output

The resulting type after applying the - operator.

fn sub(self, other: &u16) -> <Vec2d<u16> as Sub<u16>>::Output

Performs the - operation.

impl<'_> Sub<&'_ u32> for Vec2d<u32>

type Output = <Vec2d<u32> as Sub<u32>>::Output

The resulting type after applying the - operator.

fn sub(self, other: &u32) -> <Vec2d<u32> as Sub<u32>>::Output

Performs the - operation.

impl<'_, '_> Sub<&'_ u32> for &'_ Vec2d<u32>

type Output = <Vec2d<u32> as Sub<u32>>::Output

The resulting type after applying the - operator.

fn sub(self, other: &u32) -> <Vec2d<u32> as Sub<u32>>::Output

Performs the - operation.

impl<'_> Sub<&'_ u64> for Vec2d<u64>

type Output = <Vec2d<u64> as Sub<u64>>::Output

The resulting type after applying the - operator.

fn sub(self, other: &u64) -> <Vec2d<u64> as Sub<u64>>::Output

Performs the - operation.

impl<'_, '_> Sub<&'_ u64> for &'_ Vec2d<u64>

type Output = <Vec2d<u64> as Sub<u64>>::Output

The resulting type after applying the - operator.

fn sub(self, other: &u64) -> <Vec2d<u64> as Sub<u64>>::Output

Performs the - operation.

impl<'_> Sub<&'_ u8> for Vec2d<u8>

type Output = <Vec2d<u8> as Sub<u8>>::Output

The resulting type after applying the - operator.

fn sub(self, other: &u8) -> <Vec2d<u8> as Sub<u8>>::Output

Performs the - operation.

impl<'_, '_> Sub<&'_ u8> for &'_ Vec2d<u8>

type Output = <Vec2d<u8> as Sub<u8>>::Output

The resulting type after applying the - operator.

fn sub(self, other: &u8) -> <Vec2d<u8> as Sub<u8>>::Output

Performs the - operation.

impl<'_> Sub<&'_ usize> for Vec2d<usize>

type Output = <Vec2d<usize> as Sub<usize>>::Output

The resulting type after applying the - operator.

fn sub(self, other: &usize) -> <Vec2d<usize> as Sub<usize>>::Output

Performs the - operation.

impl<'_, '_> Sub<&'_ usize> for &'_ Vec2d<usize>

type Output = <Vec2d<usize> as Sub<usize>>::Output

The resulting type after applying the - operator.

fn sub(self, other: &usize) -> <Vec2d<usize> as Sub<usize>>::Output

Performs the - operation.

impl<T: Sub + Copy> Sub<T> for Vec2d<T>

Subtract a scalar from this Vec2d

type Output = Vec2d<T::Output>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<T: Sub> Sub<Vec2d<T>> for Vec2d<T>

Subtract a Vec2d from this Vec2d

type Output = Vec2d<T::Output>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<'a> Sub<Vec2d<f32>> for &'a Vec2d<f32>

type Output = <Vec2d<f32> as Sub<Vec2d<f32>>>::Output

The resulting type after applying the - operator.

fn sub(self, other: Vec2d<f32>) -> <Vec2d<f32> as Sub<Vec2d<f32>>>::Output

Performs the - operation.

impl<'a> Sub<Vec2d<f64>> for &'a Vec2d<f64>

type Output = <Vec2d<f64> as Sub<Vec2d<f64>>>::Output

The resulting type after applying the - operator.

fn sub(self, other: Vec2d<f64>) -> <Vec2d<f64> as Sub<Vec2d<f64>>>::Output

Performs the - operation.

impl<'a> Sub<Vec2d<i128>> for &'a Vec2d<i128>

type Output = <Vec2d<i128> as Sub<Vec2d<i128>>>::Output

The resulting type after applying the - operator.

fn sub(self, other: Vec2d<i128>) -> <Vec2d<i128> as Sub<Vec2d<i128>>>::Output

Performs the - operation.

impl<'a> Sub<Vec2d<i16>> for &'a Vec2d<i16>

type Output = <Vec2d<i16> as Sub<Vec2d<i16>>>::Output

The resulting type after applying the - operator.

fn sub(self, other: Vec2d<i16>) -> <Vec2d<i16> as Sub<Vec2d<i16>>>::Output

Performs the - operation.

impl<'a> Sub<Vec2d<i32>> for &'a Vec2d<i32>

type Output = <Vec2d<i32> as Sub<Vec2d<i32>>>::Output

The resulting type after applying the - operator.

fn sub(self, other: Vec2d<i32>) -> <Vec2d<i32> as Sub<Vec2d<i32>>>::Output

Performs the - operation.

impl<'a> Sub<Vec2d<i64>> for &'a Vec2d<i64>

type Output = <Vec2d<i64> as Sub<Vec2d<i64>>>::Output

The resulting type after applying the - operator.

fn sub(self, other: Vec2d<i64>) -> <Vec2d<i64> as Sub<Vec2d<i64>>>::Output

Performs the - operation.

impl<'a> Sub<Vec2d<i8>> for &'a Vec2d<i8>

type Output = <Vec2d<i8> as Sub<Vec2d<i8>>>::Output

The resulting type after applying the - operator.

fn sub(self, other: Vec2d<i8>) -> <Vec2d<i8> as Sub<Vec2d<i8>>>::Output

Performs the - operation.

impl<'a> Sub<Vec2d<isize>> for &'a Vec2d<isize>

type Output = <Vec2d<isize> as Sub<Vec2d<isize>>>::Output

The resulting type after applying the - operator.

fn sub(self, other: Vec2d<isize>) -> <Vec2d<isize> as Sub<Vec2d<isize>>>::Output

Performs the - operation.

impl<'a> Sub<Vec2d<u128>> for &'a Vec2d<u128>

type Output = <Vec2d<u128> as Sub<Vec2d<u128>>>::Output

The resulting type after applying the - operator.

fn sub(self, other: Vec2d<u128>) -> <Vec2d<u128> as Sub<Vec2d<u128>>>::Output

Performs the - operation.

impl<'a> Sub<Vec2d<u16>> for &'a Vec2d<u16>

type Output = <Vec2d<u16> as Sub<Vec2d<u16>>>::Output

The resulting type after applying the - operator.

fn sub(self, other: Vec2d<u16>) -> <Vec2d<u16> as Sub<Vec2d<u16>>>::Output

Performs the - operation.

impl<'a> Sub<Vec2d<u32>> for &'a Vec2d<u32>

type Output = <Vec2d<u32> as Sub<Vec2d<u32>>>::Output

The resulting type after applying the - operator.

fn sub(self, other: Vec2d<u32>) -> <Vec2d<u32> as Sub<Vec2d<u32>>>::Output

Performs the - operation.

impl<'a> Sub<Vec2d<u64>> for &'a Vec2d<u64>

type Output = <Vec2d<u64> as Sub<Vec2d<u64>>>::Output

The resulting type after applying the - operator.

fn sub(self, other: Vec2d<u64>) -> <Vec2d<u64> as Sub<Vec2d<u64>>>::Output

Performs the - operation.

impl<'a> Sub<Vec2d<u8>> for &'a Vec2d<u8>

type Output = <Vec2d<u8> as Sub<Vec2d<u8>>>::Output

The resulting type after applying the - operator.

fn sub(self, other: Vec2d<u8>) -> <Vec2d<u8> as Sub<Vec2d<u8>>>::Output

Performs the - operation.

impl<'a> Sub<Vec2d<usize>> for &'a Vec2d<usize>

type Output = <Vec2d<usize> as Sub<Vec2d<usize>>>::Output

The resulting type after applying the - operator.

fn sub(self, other: Vec2d<usize>) -> <Vec2d<usize> as Sub<Vec2d<usize>>>::Output

Performs the - operation.

impl<'a> Sub<f32> for &'a Vec2d<f32>

type Output = <Vec2d<f32> as Sub<f32>>::Output

The resulting type after applying the - operator.

fn sub(self, other: f32) -> <Vec2d<f32> as Sub<f32>>::Output

Performs the - operation.

impl<'a> Sub<f64> for &'a Vec2d<f64>

type Output = <Vec2d<f64> as Sub<f64>>::Output

The resulting type after applying the - operator.

fn sub(self, other: f64) -> <Vec2d<f64> as Sub<f64>>::Output

Performs the - operation.

impl<'a> Sub<i128> for &'a Vec2d<i128>

type Output = <Vec2d<i128> as Sub<i128>>::Output

The resulting type after applying the - operator.

fn sub(self, other: i128) -> <Vec2d<i128> as Sub<i128>>::Output

Performs the - operation.

impl<'a> Sub<i16> for &'a Vec2d<i16>

type Output = <Vec2d<i16> as Sub<i16>>::Output

The resulting type after applying the - operator.

fn sub(self, other: i16) -> <Vec2d<i16> as Sub<i16>>::Output

Performs the - operation.

impl<'a> Sub<i32> for &'a Vec2d<i32>

type Output = <Vec2d<i32> as Sub<i32>>::Output

The resulting type after applying the - operator.

fn sub(self, other: i32) -> <Vec2d<i32> as Sub<i32>>::Output

Performs the - operation.

impl<'a> Sub<i64> for &'a Vec2d<i64>

type Output = <Vec2d<i64> as Sub<i64>>::Output

The resulting type after applying the - operator.

fn sub(self, other: i64) -> <Vec2d<i64> as Sub<i64>>::Output

Performs the - operation.

impl<'a> Sub<i8> for &'a Vec2d<i8>

type Output = <Vec2d<i8> as Sub<i8>>::Output

The resulting type after applying the - operator.

fn sub(self, other: i8) -> <Vec2d<i8> as Sub<i8>>::Output

Performs the - operation.

impl<'a> Sub<isize> for &'a Vec2d<isize>

type Output = <Vec2d<isize> as Sub<isize>>::Output

The resulting type after applying the - operator.

fn sub(self, other: isize) -> <Vec2d<isize> as Sub<isize>>::Output

Performs the - operation.

impl<'a> Sub<u128> for &'a Vec2d<u128>

type Output = <Vec2d<u128> as Sub<u128>>::Output

The resulting type after applying the - operator.

fn sub(self, other: u128) -> <Vec2d<u128> as Sub<u128>>::Output

Performs the - operation.

impl<'a> Sub<u16> for &'a Vec2d<u16>

type Output = <Vec2d<u16> as Sub<u16>>::Output

The resulting type after applying the - operator.

fn sub(self, other: u16) -> <Vec2d<u16> as Sub<u16>>::Output

Performs the - operation.

impl<'a> Sub<u32> for &'a Vec2d<u32>

type Output = <Vec2d<u32> as Sub<u32>>::Output

The resulting type after applying the - operator.

fn sub(self, other: u32) -> <Vec2d<u32> as Sub<u32>>::Output

Performs the - operation.

impl<'a> Sub<u64> for &'a Vec2d<u64>

type Output = <Vec2d<u64> as Sub<u64>>::Output

The resulting type after applying the - operator.

fn sub(self, other: u64) -> <Vec2d<u64> as Sub<u64>>::Output

Performs the - operation.

impl<'a> Sub<u8> for &'a Vec2d<u8>

type Output = <Vec2d<u8> as Sub<u8>>::Output

The resulting type after applying the - operator.

fn sub(self, other: u8) -> <Vec2d<u8> as Sub<u8>>::Output

Performs the - operation.

impl<'a> Sub<usize> for &'a Vec2d<usize>

type Output = <Vec2d<usize> as Sub<usize>>::Output

The resulting type after applying the - operator.

fn sub(self, other: usize) -> <Vec2d<usize> as Sub<usize>>::Output

Performs the - operation.

impl<'_> SubAssign<&'_ Vec2d<f32>> for Vec2d<f32>

fn sub_assign(&mut self, other: &Vec2d<f32>)

Performs the -= operation.

impl<'_> SubAssign<&'_ Vec2d<f64>> for Vec2d<f64>

fn sub_assign(&mut self, other: &Vec2d<f64>)

Performs the -= operation.

impl<'_> SubAssign<&'_ Vec2d<i128>> for Vec2d<i128>

fn sub_assign(&mut self, other: &Vec2d<i128>)

Performs the -= operation.

impl<'_> SubAssign<&'_ Vec2d<i16>> for Vec2d<i16>

fn sub_assign(&mut self, other: &Vec2d<i16>)

Performs the -= operation.

impl<'_> SubAssign<&'_ Vec2d<i32>> for Vec2d<i32>

fn sub_assign(&mut self, other: &Vec2d<i32>)

Performs the -= operation.

impl<'_> SubAssign<&'_ Vec2d<i64>> for Vec2d<i64>

fn sub_assign(&mut self, other: &Vec2d<i64>)

Performs the -= operation.

impl<'_> SubAssign<&'_ Vec2d<i8>> for Vec2d<i8>

fn sub_assign(&mut self, other: &Vec2d<i8>)

Performs the -= operation.

impl<'_> SubAssign<&'_ Vec2d<isize>> for Vec2d<isize>

fn sub_assign(&mut self, other: &Vec2d<isize>)

Performs the -= operation.

impl<'_> SubAssign<&'_ Vec2d<u128>> for Vec2d<u128>

fn sub_assign(&mut self, other: &Vec2d<u128>)

Performs the -= operation.

impl<'_> SubAssign<&'_ Vec2d<u16>> for Vec2d<u16>

fn sub_assign(&mut self, other: &Vec2d<u16>)

Performs the -= operation.

impl<'_> SubAssign<&'_ Vec2d<u32>> for Vec2d<u32>

fn sub_assign(&mut self, other: &Vec2d<u32>)

Performs the -= operation.

impl<'_> SubAssign<&'_ Vec2d<u64>> for Vec2d<u64>

fn sub_assign(&mut self, other: &Vec2d<u64>)

Performs the -= operation.

impl<'_> SubAssign<&'_ Vec2d<u8>> for Vec2d<u8>

fn sub_assign(&mut self, other: &Vec2d<u8>)

Performs the -= operation.

impl<'_> SubAssign<&'_ Vec2d<usize>> for Vec2d<usize>

fn sub_assign(&mut self, other: &Vec2d<usize>)

Performs the -= operation.

impl<'_> SubAssign<&'_ f32> for Vec2d<f32>

fn sub_assign(&mut self, other: &f32)

Performs the -= operation.

impl<'_> SubAssign<&'_ f64> for Vec2d<f64>

fn sub_assign(&mut self, other: &f64)

Performs the -= operation.

impl<'_> SubAssign<&'_ i128> for Vec2d<i128>

fn sub_assign(&mut self, other: &i128)

Performs the -= operation.

impl<'_> SubAssign<&'_ i16> for Vec2d<i16>

fn sub_assign(&mut self, other: &i16)

Performs the -= operation.

impl<'_> SubAssign<&'_ i32> for Vec2d<i32>

fn sub_assign(&mut self, other: &i32)

Performs the -= operation.

impl<'_> SubAssign<&'_ i64> for Vec2d<i64>

fn sub_assign(&mut self, other: &i64)

Performs the -= operation.

impl<'_> SubAssign<&'_ i8> for Vec2d<i8>

fn sub_assign(&mut self, other: &i8)

Performs the -= operation.

impl<'_> SubAssign<&'_ isize> for Vec2d<isize>

fn sub_assign(&mut self, other: &isize)

Performs the -= operation.

impl<'_> SubAssign<&'_ u128> for Vec2d<u128>

fn sub_assign(&mut self, other: &u128)

Performs the -= operation.

impl<'_> SubAssign<&'_ u16> for Vec2d<u16>

fn sub_assign(&mut self, other: &u16)

Performs the -= operation.

impl<'_> SubAssign<&'_ u32> for Vec2d<u32>

fn sub_assign(&mut self, other: &u32)

Performs the -= operation.

impl<'_> SubAssign<&'_ u64> for Vec2d<u64>

fn sub_assign(&mut self, other: &u64)

Performs the -= operation.

impl<'_> SubAssign<&'_ u8> for Vec2d<u8>

fn sub_assign(&mut self, other: &u8)

Performs the -= operation.

impl<'_> SubAssign<&'_ usize> for Vec2d<usize>

fn sub_assign(&mut self, other: &usize)

Performs the -= operation.

impl<T: SubAssign + Copy> SubAssign<T> for Vec2d<T>

Subtract scalar from this Vec2d

fn sub_assign(&mut self, rhs: T)

Performs the -= operation.

impl<T: SubAssign> SubAssign<Vec2d<T>> for Vec2d<T>

Subtract Vec2d from this Vec2d

fn sub_assign(&mut self, rhs: Self)

Performs the -= operation.