Struct Vec2d 

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

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<T: Add> Add for Vec2d<T>

Add two Vec2d together

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

The resulting type after applying the + operator.

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

Performs the + operation.

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

type Output = <Vec2d<f32> as Add>::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>::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>::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>::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<i8>> for Vec2d<i8>

type Output = <Vec2d<i8> as Add>::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>::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<i16>> for Vec2d<i16>

type Output = <Vec2d<i16> as Add>::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>::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>::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>::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>::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>::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<i128>> for Vec2d<i128>

type Output = <Vec2d<i128> as Add>::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>::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<isize>> for Vec2d<isize>

type Output = <Vec2d<isize> as Add>::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>::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<u8>> for Vec2d<u8>

type Output = <Vec2d<u8> as Add>::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>::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<u16>> for Vec2d<u16>

type Output = <Vec2d<u16> as Add>::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>::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>::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>::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>::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>::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<u128>> for Vec2d<u128>

type Output = <Vec2d<u128> as Add>::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>::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<usize>> for Vec2d<usize>

type Output = <Vec2d<usize> as Add>::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>::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<&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<&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<&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<&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<&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<&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<&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<&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 as Add>::Output>

The resulting type after applying the + operator.

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

Performs the + operation.

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

type Output = <Vec2d<f32> as Add>::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>::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<i8>> for &'a Vec2d<i8>

type Output = <Vec2d<i8> as Add>::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<i16>> for &'a Vec2d<i16>

type Output = <Vec2d<i16> as Add>::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>::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>::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<i128>> for &'a Vec2d<i128>

type Output = <Vec2d<i128> as Add>::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<isize>> for &'a Vec2d<isize>

type Output = <Vec2d<isize> as Add>::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<u8>> for &'a Vec2d<u8>

type Output = <Vec2d<u8> as Add>::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<u16>> for &'a Vec2d<u16>

type Output = <Vec2d<u16> as Add>::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>::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>::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<u128>> for &'a Vec2d<u128>

type Output = <Vec2d<u128> as Add>::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<usize>> for &'a Vec2d<usize>

type Output = <Vec2d<usize> as Add>::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<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<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<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<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<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<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<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<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<T: AddAssign> AddAssign for Vec2d<T>

Add Vec2d to this Vec2d

fn add_assign(&mut self, rhs: Self)

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<i8>> for Vec2d<i8>

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

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<i128>> for Vec2d<i128>

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

Performs the += operation.

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

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

Performs the += operation.

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

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

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<u128>> for Vec2d<u128>

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

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<&i8> for Vec2d<i8>

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

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<&i128> for Vec2d<i128>

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

Performs the += operation.

impl AddAssign<&isize> for Vec2d<isize>

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

Performs the += operation.

impl AddAssign<&u8> for Vec2d<u8>

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

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<&u128> for Vec2d<u128>

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

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: Clone> Clone for Vec2d<T>

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

Returns a duplicate 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<T: Div> Div for Vec2d<T>

Divide Vec2d by Vec2d

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

The resulting type after applying the / operator.

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

Performs the / operation.

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

type Output = <Vec2d<f32> as Div>::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>::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>::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>::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<i8>> for Vec2d<i8>

type Output = <Vec2d<i8> as Div>::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>::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<i16>> for Vec2d<i16>

type Output = <Vec2d<i16> as Div>::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>::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>::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>::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>::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>::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<i128>> for Vec2d<i128>

type Output = <Vec2d<i128> as Div>::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>::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<isize>> for Vec2d<isize>

type Output = <Vec2d<isize> as Div>::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>::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<u8>> for Vec2d<u8>

type Output = <Vec2d<u8> as Div>::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>::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<u16>> for Vec2d<u16>

type Output = <Vec2d<u16> as Div>::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>::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>::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>::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>::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>::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<u128>> for Vec2d<u128>

type Output = <Vec2d<u128> as Div>::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>::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<usize>> for Vec2d<usize>

type Output = <Vec2d<usize> as Div>::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>::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<&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<&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<&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<&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<&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<&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<&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<&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 as Div>::Output>

The resulting type after applying the / operator.

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

Performs the / operation.

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

type Output = <Vec2d<f32> as Div>::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>::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<i8>> for &'a Vec2d<i8>

type Output = <Vec2d<i8> as Div>::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<i16>> for &'a Vec2d<i16>

type Output = <Vec2d<i16> as Div>::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>::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>::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<i128>> for &'a Vec2d<i128>

type Output = <Vec2d<i128> as Div>::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<isize>> for &'a Vec2d<isize>

type Output = <Vec2d<isize> as Div>::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<u8>> for &'a Vec2d<u8>

type Output = <Vec2d<u8> as Div>::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<u16>> for &'a Vec2d<u16>

type Output = <Vec2d<u16> as Div>::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>::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>::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<u128>> for &'a Vec2d<u128>

type Output = <Vec2d<u128> as Div>::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<usize>> for &'a Vec2d<usize>

type Output = <Vec2d<usize> as Div>::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<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<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<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<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<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<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<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<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<T: DivAssign> DivAssign for Vec2d<T>

Divide this Vec2d by a Vec2d

fn div_assign(&mut self, rhs: Self)

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<i8>> for Vec2d<i8>

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

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<i128>> for Vec2d<i128>

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

Performs the /= operation.

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

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

Performs the /= operation.

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

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

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<u128>> for Vec2d<u128>

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

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<&i8> for Vec2d<i8>

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

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<&i128> for Vec2d<i128>

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

Performs the /= operation.

impl DivAssign<&isize> for Vec2d<isize>

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

Performs the /= operation.

impl DivAssign<&u8> for Vec2d<u8>

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

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<&u128> for Vec2d<u128>

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

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: Eq> Eq for Vec2d<T>

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

Convert a tuple to a Vec2d

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

Converts to this type from the input type.

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

Convert a slice to a Vec2d

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

Converts to this type from the input type.

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

Return a tuple for this Vec2d

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

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

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

Return a slice for this Vec2d

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

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

impl<T: Mul + Add> Mul 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 Mul<&Vec2d<f32>> for Vec2d<f32>

type Output = <Vec2d<f32> as Mul>::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>::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>::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>::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<i8>> for Vec2d<i8>

type Output = <Vec2d<i8> as Mul>::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>::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<i16>> for Vec2d<i16>

type Output = <Vec2d<i16> as Mul>::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>::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>::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>::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>::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>::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<i128>> for Vec2d<i128>

type Output = <Vec2d<i128> as Mul>::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>::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<isize>> for Vec2d<isize>

type Output = <Vec2d<isize> as Mul>::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>::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<u8>> for Vec2d<u8>

type Output = <Vec2d<u8> as Mul>::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>::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<u16>> for Vec2d<u16>

type Output = <Vec2d<u16> as Mul>::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>::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>::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>::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>::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>::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<u128>> for Vec2d<u128>

type Output = <Vec2d<u128> as Mul>::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>::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<usize>> for Vec2d<usize>

type Output = <Vec2d<usize> as Mul>::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>::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<&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<&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<&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<&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<&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<&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<&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<&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 as Mul>::Output>

The resulting type after applying the * operator.

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

Performs the * operation.

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

type Output = <Vec2d<f32> as Mul>::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>::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<i8>> for &'a Vec2d<i8>

type Output = <Vec2d<i8> as Mul>::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<i16>> for &'a Vec2d<i16>

type Output = <Vec2d<i16> as Mul>::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>::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>::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<i128>> for &'a Vec2d<i128>

type Output = <Vec2d<i128> as Mul>::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<isize>> for &'a Vec2d<isize>

type Output = <Vec2d<isize> as Mul>::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<u8>> for &'a Vec2d<u8>

type Output = <Vec2d<u8> as Mul>::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<u16>> for &'a Vec2d<u16>

type Output = <Vec2d<u16> as Mul>::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>::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>::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<u128>> for &'a Vec2d<u128>

type Output = <Vec2d<u128> as Mul>::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<usize>> for &'a Vec2d<usize>

type Output = <Vec2d<usize> as Mul>::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<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<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<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<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<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<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<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<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<T: MulAssign> MulAssign for Vec2d<T>

Multiply this Vec2d by a Vec2d

fn mul_assign(&mut self, rhs: Self)

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<i8>> for Vec2d<i8>

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

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<i128>> for Vec2d<i128>

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

Performs the *= operation.

impl MulAssign<&Vec2d<isize>> for Vec2d<isize>

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

Performs the *= operation.

impl MulAssign<&Vec2d<u8>> for Vec2d<u8>

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

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<u128>> for Vec2d<u128>

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

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<&i8> for Vec2d<i8>

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

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<&i128> for Vec2d<i128>

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

Performs the *= operation.

impl MulAssign<&isize> for Vec2d<isize>

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

Performs the *= operation.

impl MulAssign<&u8> for Vec2d<u8>

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

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<&u128> for Vec2d<u128>

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

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: Neg> Neg for Vec2d<T>

Invert the sign of a Vec2d

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

The resulting type after applying the - operator.

fn neg(self) -> Self::Output

Performs the unary - operation.

impl<T: PartialEq> PartialEq for Vec2d<T>

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

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

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

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

impl<T: PartialOrd> PartialOrd for 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: &Rhs) -> bool

Tests less than (for self and other) and is used by the < operator.

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

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

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

Tests greater than (for self and other) and is used by the > operator.

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

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

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

impl<T: Sub> Sub for Vec2d<T>

Subtract a Vec2d from this Vec2d

type Output = Vec2d<<T as Sub>::Output>

The resulting type after applying the - operator.

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

Performs the - operation.

impl Sub<&Vec2d<f32>> for Vec2d<f32>

type Output = <Vec2d<f32> as Sub>::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>::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>::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>::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<i8>> for Vec2d<i8>

type Output = <Vec2d<i8> as Sub>::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>::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<i16>> for Vec2d<i16>

type Output = <Vec2d<i16> as Sub>::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>::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>::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>::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>::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>::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<i128>> for Vec2d<i128>

type Output = <Vec2d<i128> as Sub>::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>::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<isize>> for Vec2d<isize>

type Output = <Vec2d<isize> as Sub>::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>::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<u8>> for Vec2d<u8>

type Output = <Vec2d<u8> as Sub>::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>::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<u16>> for Vec2d<u16>

type Output = <Vec2d<u16> as Sub>::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>::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>::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>::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>::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>::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<u128>> for Vec2d<u128>

type Output = <Vec2d<u128> as Sub>::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>::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<usize>> for Vec2d<usize>

type Output = <Vec2d<usize> as Sub>::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>::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<&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<&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<&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<&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<&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<&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<&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<&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 as Sub>::Output>

The resulting type after applying the - operator.

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

Performs the - operation.

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

type Output = <Vec2d<f32> as Sub>::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>::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<i8>> for &'a Vec2d<i8>

type Output = <Vec2d<i8> as Sub>::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<i16>> for &'a Vec2d<i16>

type Output = <Vec2d<i16> as Sub>::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>::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>::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<i128>> for &'a Vec2d<i128>

type Output = <Vec2d<i128> as Sub>::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<isize>> for &'a Vec2d<isize>

type Output = <Vec2d<isize> as Sub>::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<u8>> for &'a Vec2d<u8>

type Output = <Vec2d<u8> as Sub>::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<u16>> for &'a Vec2d<u16>

type Output = <Vec2d<u16> as Sub>::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>::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>::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<u128>> for &'a Vec2d<u128>

type Output = <Vec2d<u128> as Sub>::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<usize>> for &'a Vec2d<usize>

type Output = <Vec2d<usize> as Sub>::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<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<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<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<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<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<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<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<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<T: SubAssign> SubAssign for Vec2d<T>

Subtract Vec2d from this Vec2d

fn sub_assign(&mut self, rhs: Self)

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<i8>> for Vec2d<i8>

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

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<i128>> for Vec2d<i128>

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

Performs the -= operation.

impl SubAssign<&Vec2d<isize>> for Vec2d<isize>

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

Performs the -= operation.

impl SubAssign<&Vec2d<u8>> for Vec2d<u8>

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

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<u128>> for Vec2d<u128>

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

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<&i8> for Vec2d<i8>

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

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<&i128> for Vec2d<i128>

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

Performs the -= operation.

impl SubAssign<&isize> for Vec2d<isize>

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

Performs the -= operation.

impl SubAssign<&u8> for Vec2d<u8>

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

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<&u128> for Vec2d<u128>

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

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.