Struct xyzvec::xy::XYVec

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

Implementations

impl<T: VecInner> XYVec<T>

pub fn new(inner: [T; 2]) -> Self

pub fn x(&self) -> T

x component of XYVec

pub fn y(&self) -> T

y component of XYVec

pub fn scale_by(&self, d: T) -> Self

   use xyzvec::XYVec;
   use approx::assert_relative_eq;

   let v = XYVec::new([1.0f64, -0.5f64]);
   let scaled_v = v.scale_by(5.0);
   assert_relative_eq!(scaled_v.x(), 5.0);
   assert_relative_eq!(scaled_v.y(), -2.5);

pub fn div_by(&self, d: T) -> Self

   use xyzvec::XYVec;
   use approx::assert_relative_eq;

   let v = XYVec::new([1.0f64, -0.5f64]);
   let scaled_v = v.div_by(0.2);
   assert_relative_eq!(scaled_v.x(), 5.0);
   assert_relative_eq!(scaled_v.y(), -2.5);

pub fn l1_norm(&self) -> T

   use xyzvec::XYVec;
   use approx::assert_relative_eq;

pub fn l2_norm_sqd(&self) -> T

   use xyzvec::XYVec;
   use approx::assert_relative_eq;

pub fn cross_prod(&self, other: Self) -> T

   use xyzvec::XYVec;
   use approx::assert_relative_eq;

   let v = XYVec::new([1.0f64, -0.5f64]);
   let w = XYVec::new([-2.0f64, 0.0f64]);
   assert_relative_eq!(v.cross_prod(w), -1.0);

pub fn cross_prod_sqd(&self, other: Self) -> T

   use xyzvec::XYVec;
   use approx::assert_relative_eq;

   let v = XYVec::new([1.0f64, -0.5f64]);
   let w = XYVec::new([-2.0f64, 0.0f64]);
   assert_relative_eq!(v.cross_prod_sqd(w), 1.0);

pub fn dot_prod(&self, other: Self) -> T

   use xyzvec::XYVec;
   use approx::assert_relative_eq;

   let v = XYVec::new([1.0f64, -0.5f64]);
   let w = XYVec::new([-2.0f64, 0.0f64]);
   assert_relative_eq!(v.dot_prod(w), -2.0);

pub fn translate_by(&self, x: T, y: T) -> Self

   use xyzvec::XYVec;
   use approx::assert_relative_eq;

   let v = XYVec::new([1.0f64, -0.5f64]);
   let scaled_v = v.translate_by(1.0, 1.0);
   assert_relative_eq!(scaled_v.x(), 2.0);
   assert_relative_eq!(scaled_v.y(), 0.5);

pub fn sum(&self) -> T

    use xyzvec::XYVec;
    use approx::assert_relative_eq;    

pub fn iter(&self) -> Iter<'_, T>

    use xyzvec::XYVec;
    use approx::assert_relative_eq;    
     
    let v = XYVec::new([1.0f64, -0.5f64]);
    let v2: XYVec<f64> = v.iter().map(|a| a + 1.0).collect();
    assert_relative_eq!(v2.x(), 2.0);
    assert_relative_eq!(v2.y(), 0.5);

impl XYVec<f32>

pub fn l2_norm(&self) -> f32

pub fn zeroes() -> Self

pub fn rotated_by(&self, theta: f32) -> Self

impl XYVec<f64>

pub fn l2_norm(&self) -> f64

pub fn zeroes() -> Self

pub fn rotated_by(&self, theta: f64) -> Self

impl<Frac> XYVec<FixedI64<Frac>>

pub fn zeroes() -> Self

Trait Implementations

impl<T: VecInner> Add for XYVec<T>

type Output = XYVec<T>

The resulting type after applying the + operator.

fn add(self, other: Self) -> Self

Performs the + operation.

impl<T: VecInner> AddAssign for XYVec<T>

fn add_assign(&mut self, other: Self)

Performs the += operation.

impl<T: Clone> Clone for XYVec<T>

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

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<T: VecInner> Debug for XYVec<T>

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

Formats the value using the given formatter.

impl<T: VecInner> Display for XYVec<T>

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

Formats the value using the given formatter.

impl<T: VecInner> FromIterator<T> for XYVec<T>

Build XYVec from iterator of size two. TODO: check for errors better

fn from_iter<I: IntoIterator<Item = T>>(iter: I) -> Self

Creates a value from an iterator.

impl<T: VecInner> Neg for XYVec<T>

type Output = XYVec<T>

The resulting type after applying the - operator.

fn neg(self) -> Self::Output

Performs the unary - operation.

impl<T: PartialEq> PartialEq for XYVec<T>

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

This method tests for self and other values to be equal, and is used by ==.

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

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

impl<T: VecInner> Sub for XYVec<T>

type Output = XYVec<T>

The resulting type after applying the - operator.

fn sub(self, other: Self) -> Self

Performs the - operation.

impl<T: VecInner> SubAssign for XYVec<T>

fn sub_assign(&mut self, other: Self)

Performs the -= operation.

impl<T: Copy> Copy for XYVec<T>

impl<T> StructuralPartialEq for XYVec<T>