Struct Vec2

#[repr(C)]
pub struct Vec2<T>
where
    T: Copy,
{
    pub x: T,
    pub y: T,
}

2D generic vector Implemented for f32, f64, i32

Fields

x: T

y: T

Implementations

impl<T> Vec2<T>

where T: Scalar,

pub fn new(x: T, y: T) -> Vec2<T>

Constructs a new Vec2 from the given components

pub fn broadcast(a: T) -> Vec2<T>

Constructs a new Vec2 from a scalar value by copying that value to all members

Examples

// V2f32 is a type alias for Vec2::<f32>
use imath::vec::V2f32;
let v = V2f32::broadcast(1.0);
assert!(v.x == 1.0 && v.y == 1.0)

pub fn dot(self, v: Vec2<T>) -> T

Dot product

pub fn cross(self, v: Vec2<T>) -> T

Right-handed cross product

pub fn equal_with_abs_error(self, v: Vec2<T>, e: T) -> bool

where T: Scalar,

Returns true if self and v are equal with error no greater than e

pub fn equal_with_rel_error(self, v: Vec2<T>, e: T) -> bool

where T: Real,

Returns true if self and v are equal with a relative error no greater than e

pub fn length2(self) -> T

where T: Scalar,

Calculate the squared length of the vector

impl<T> Vec2<T>

where T: Real,

pub fn length(self) -> T

Length of the vector

pub fn normalized(self) -> Vec2<T>

Returns a normalized copy of this vector

Trait Implementations

impl<T> Add<T> for Vec2<T>

where T: Scalar,

Addition by a T

type Output = Vec2<T>

The resulting type after applying the + operator.

fn add(self, rhs: T) -> Vec2<T>

Performs the + operation.

impl Add<Vec2<f32>> for f32

type Output = Vec2<f32>

The resulting type after applying the + operator.

fn add(self, rhs: Vec2<f32>) -> Vec2<f32>

Performs the + operation.

impl Add<Vec2<f64>> for f64

type Output = Vec2<f64>

The resulting type after applying the + operator.

fn add(self, rhs: Vec2<f64>) -> Vec2<f64>

Performs the + operation.

impl Add<Vec2<i32>> for i32

type Output = Vec2<i32>

The resulting type after applying the + operator.

fn add(self, rhs: Vec2<i32>) -> Vec2<i32>

Performs the + operation.

impl<T> Add for Vec2<T>

where T: Scalar,

Addition operator

type Output = Vec2<T>

The resulting type after applying the + operator.

fn add(self, rhs: Vec2<T>) -> Vec2<T>

Performs the + operation.

impl<T> Bounded for Vec2<T>

where T: Scalar,

fn min_value() -> Vec2<T>

Returns the smallest finite number this type can represent

fn max_value() -> Vec2<T>

Returns the largest finite number this type can represent

impl<T> Clone for Vec2<T>

where T: Copy + Clone,

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

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<T> Debug for Vec2<T>

where T: Copy + Debug,

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

Formats the value using the given formatter.

impl<T> Default for Vec2<T>

where T: Copy + Default,

fn default() -> Vec2<T>

Returns the “default value” for a type.

impl<T> Display for Vec2<T>

where T: Scalar + Display,

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

Formats the value using the given formatter.

impl<T> Div<T> for Vec2<T>

where T: Scalar,

Division by a T

type Output = Vec2<T>

The resulting type after applying the / operator.

fn div(self, rhs: T) -> Vec2<T>

Performs the / operation.

impl Div<Vec2<f32>> for f32

type Output = Vec2<f32>

The resulting type after applying the / operator.

fn div(self, rhs: Vec2<f32>) -> Vec2<f32>

Performs the / operation.

impl Div<Vec2<f64>> for f64

type Output = Vec2<f64>

The resulting type after applying the / operator.

fn div(self, rhs: Vec2<f64>) -> Vec2<f64>

Performs the / operation.

impl Div<Vec2<i32>> for i32

type Output = Vec2<i32>

The resulting type after applying the / operator.

fn div(self, rhs: Vec2<i32>) -> Vec2<i32>

Performs the / operation.

impl<T> Div for Vec2<T>

where T: Scalar,

Division operator

type Output = Vec2<T>

The resulting type after applying the / operator.

fn div(self, rhs: Vec2<T>) -> Vec2<T>

Performs the / operation.

impl<T> From<Vec2<T>> for Vec3<T>

where T: Scalar,

fn from(v: Vec2<T>) -> Self

Converts a Vec2 to a Vec3, adding a 0 z element

impl<T> From<Vec2<T>> for Vec4<T>

where T: Scalar,

fn from(v: Vec2<T>) -> Self

Converts a Vec2 to a Vec4, adding 0 z and w elements

impl<T> From<Vec3<T>> for Vec2<T>

where T: Scalar,

fn from(v: Vec3<T>) -> Self

Converts a Vec3 to a Vec2, dropping the z element

impl<T> From<Vec4<T>> for Vec2<T>

where T: Scalar,

fn from(v: Vec4<T>) -> Self

Converts a Vec4 to a Vec2, dropping the z element

impl<T> Index<usize> for Vec2<T>

where T: Scalar,

type Output = T

The returned type after indexing.

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

Performs the indexing (container[index]) operation.

impl<T> IndexMut<usize> for Vec2<T>

where T: Scalar,

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

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

impl<T> Mul<T> for Vec2<T>

where T: Scalar,

Multiplication by a T

type Output = Vec2<T>

The resulting type after applying the * operator.

fn mul(self, rhs: T) -> Vec2<T>

Performs the * operation.

impl Mul<Vec2<f32>> for f32

type Output = Vec2<f32>

The resulting type after applying the * operator.

fn mul(self, rhs: Vec2<f32>) -> Vec2<f32>

Performs the * operation.

impl Mul<Vec2<f64>> for f64

type Output = Vec2<f64>

The resulting type after applying the * operator.

fn mul(self, rhs: Vec2<f64>) -> Vec2<f64>

Performs the * operation.

impl Mul<Vec2<i32>> for i32

type Output = Vec2<i32>

The resulting type after applying the * operator.

fn mul(self, rhs: Vec2<i32>) -> Vec2<i32>

Performs the * operation.

impl<T> Mul for Vec2<T>

where T: Scalar,

Multiplication operator

type Output = Vec2<T>

The resulting type after applying the * operator.

fn mul(self, rhs: Vec2<T>) -> Vec2<T>

Performs the * operation.

impl<T> Neg for Vec2<T>

where T: Scalar,

Unary negation

type Output = Vec2<T>

The resulting type after applying the - operator.

fn neg(self) -> Vec2<T>

Performs the unary - operation.

impl<T> One for Vec2<T>

where T: Scalar,

fn one() -> Vec2<T>

where T: Scalar,

Returns the multiplicative identity element of Self, 1.

fn set_one(&mut self)

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

fn is_one(&self) -> bool

where Self: PartialEq,

Returns true if self is equal to the multiplicative identity.

impl<T> PartialEq for Vec2<T>

where T: Copy + PartialEq,

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

where T: Copy + PartialOrd,

fn partial_cmp(&self, other: &Vec2<T>) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

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

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

where T: Scalar,

Subtraction by a T

type Output = Vec2<T>

The resulting type after applying the - operator.

fn sub(self, rhs: T) -> Vec2<T>

Performs the - operation.

impl Sub<Vec2<f32>> for f32

type Output = Vec2<f32>

The resulting type after applying the - operator.

fn sub(self, rhs: Vec2<f32>) -> Vec2<f32>

Performs the - operation.

impl Sub<Vec2<f64>> for f64

type Output = Vec2<f64>

The resulting type after applying the - operator.

fn sub(self, rhs: Vec2<f64>) -> Vec2<f64>

Performs the - operation.

impl Sub<Vec2<i32>> for i32

type Output = Vec2<i32>

The resulting type after applying the - operator.

fn sub(self, rhs: Vec2<i32>) -> Vec2<i32>

Performs the - operation.

impl<T> Sub for Vec2<T>

where T: Scalar,

Subtraction operator

type Output = Vec2<T>

The resulting type after applying the - operator.

fn sub(self, rhs: Vec2<T>) -> Vec2<T>

Performs the - operation.

impl<T> Vector for Vec2<T>

where T: Scalar,

type Component = T

fn min(self, other: Vec2<T>) -> Vec2<T>

fn max(self, other: Vec2<T>) -> Vec2<T>

fn major_axis(self) -> usize

where T: Scalar,

fn dot(a: Vec2<T>, b: Vec2<T>) -> T

fn length2(self) -> T

impl<T> Zero for Vec2<T>

where T: Scalar,

fn zero() -> Vec2<T>

where T: Scalar,

Returns the additive identity element of Self, 0.

fn is_zero(&self) -> bool

where T: Scalar,

Returns true if self is equal to the additive identity.

fn set_zero(&mut self)

Sets self to the additive identity element of Self, 0.

impl<T> Copy for Vec2<T>

where T: Copy + Copy,

impl<T> Eq for Vec2<T>

where T: Copy + Eq,

impl<T> StructuralPartialEq for Vec2<T>

where T: Copy,