Struct Vector2 

pub struct Vector2<T: Float> {
    pub x: T,
    pub y: T,
}

2-D vector class.

This class defines simple 2-D vector data.

• tparam T - Type of the element

Fields

x: T

X (or the first) component of the vector.

y: T

Y (or the second) component of the vector.

Implementations

impl<T: Float> Vector2<T>

Constructors

pub fn new_default() -> Vector2<T>

Constructs default vector (0, 0).

use vox_geometry_rust::vector2::Vector2F;
let vec = Vector2F::new_default();
assert_eq!(0.0, vec.x);
assert_eq!(0.0, vec.y);

pub fn new(x_: T, y_: T) -> Vector2<T>

Constructs vector with given parameters x_ and y_.

use vox_geometry_rust::vector2::Vector2F;
let vec2 = Vector2F::new(5.0, 3.0);
assert_eq!(5.0, vec2.x);
assert_eq!(3.0, vec2.y);

pub fn new_lst(lst: [T; 2]) -> Vector2<T>

Constructs vector with initializer list.

use vox_geometry_rust::vector2::Vector2F;
let vec5 = Vector2F::new_lst([7.0, 6.0]);
assert_eq!(7.0, vec5.x);
assert_eq!(6.0, vec5.y);

impl<T: Float> Vector2<T>

Basic setters

pub fn set_scalar(&mut self, s: T)

Set both x and y components to s.

pub fn set_scalar2(&mut self, x: T, y: T)

Set x and y components with given parameters.

use vox_geometry_rust::vector2::Vector2F;
let mut vec = Vector2F::new_default();
vec.set_scalar2(4.0, 2.0);
assert_eq!(4.0, vec.x);
assert_eq!(2.0, vec.y);

pub fn set_lst(&mut self, lst: [T; 2])

Set x and y components with given initializer list.

use vox_geometry_rust::vector2::Vector2F;
let mut vec = Vector2F::new_default();
let lst = [0.0, 5.0];
vec.set_lst(lst);
assert_eq!(0.0, vec.x);
assert_eq!(5.0, vec.y);

pub fn set_self(&mut self, pt: Vector2<T>)

Set x and y with other vector pt.

use vox_geometry_rust::vector2::Vector2F;
let mut vec = Vector2F::new_default();
vec.set_self(Vector2F::new(9.0, 8.0));
assert_eq!(9.0, vec.x);
assert_eq!(8.0, vec.y);

pub fn set_zero(&mut self)

Set both x and y to zero.

use vox_geometry_rust::vector2::Vector2F;
let mut vec = Vector2F::new(3.0, 9.0);
vec.set_zero();
assert_eq!(0.0, vec.x);
assert_eq!(0.0, vec.y);

pub fn normalize(&mut self)

Normalizes self vector.

use vox_geometry_rust::vector2::Vector2F;
use vox_geometry_rust::assert_delta;
let mut vec = Vector2F::new_default();
vec.set_scalar2(4.0, 2.0);
vec.normalize();
let len = vec.x * vec.x + vec.y * vec.y;
assert_delta!(len, 1.0, 1e-6);

impl<T: Float> Vector2<T>

Binary operations: new instance = self (+) v

pub fn add_scalar(&self, v: T) -> Vector2<T>

Computes self + (v, v).

use vox_geometry_rust::vector2::Vector2F;
let mut vec = Vector2F::new(3.0, 9.0);
vec = vec.add_scalar(4.0);
assert_eq!(7.0, vec.x);
assert_eq!(13.0, vec.y);

pub fn add_vec(&self, v: Vector2<T>) -> Vector2<T>

Computes self + (v.x, v.y).

use vox_geometry_rust::vector2::Vector2F;
let mut vec = Vector2F::new(3.0, 9.0);
vec = vec.add_scalar(4.0);
vec = vec.add_vec(Vector2F::new(-2.0, 1.0));
assert_eq!(5.0, vec.x);
assert_eq!(14.0, vec.y);

pub fn sub_scalar(&self, v: T) -> Vector2<T>

Computes self - (v, v).

use vox_geometry_rust::vector2::Vector2F;
let mut vec = Vector2F::new(3.0, 9.0);
vec = vec.add_scalar(4.0);
vec = vec.add_vec(Vector2F::new(-2.0, 1.0));
vec = vec.sub_scalar(8.0);
assert_eq!(-3.0, vec.x);
assert_eq!(6.0, vec.y);

pub fn sub_vec(&self, v: Vector2<T>) -> Vector2<T>

Computes self - (v.x, v.y).

use vox_geometry_rust::vector2::Vector2F;
let mut vec = Vector2F::new(3.0, 9.0);
vec = vec.add_scalar(4.0);
vec = vec.add_vec(Vector2F::new(-2.0, 1.0));
vec = vec.sub_scalar(8.0);
vec = vec.sub_vec(Vector2F::new(-5.0, 3.0));
assert_eq!(2.0, vec.x);
assert_eq!(3.0, vec.y);

pub fn mul_scalar(&self, v: T) -> Vector2<T>

Computes self * (v, v).

use vox_geometry_rust::vector2::Vector2F;
let mut vec = Vector2F::new(3.0, 9.0);
vec = vec.add_scalar(4.0);
vec = vec.add_vec(Vector2F::new(-2.0, 1.0));
vec = vec.sub_scalar(8.0);
vec = vec.sub_vec(Vector2F::new(-5.0, 3.0));
vec = vec.mul_scalar(2.0);
assert_eq!(4.0, vec.x);
assert_eq!(6.0, vec.y);

pub fn mul_vec(&self, v: Vector2<T>) -> Vector2<T>

Computes self * (v.x, v.y).

use vox_geometry_rust::vector2::Vector2F;
let mut vec = Vector2F::new(3.0, 9.0);
vec = vec.add_scalar(4.0);
vec = vec.add_vec(Vector2F::new(-2.0, 1.0));
vec = vec.sub_scalar(8.0);
vec = vec.sub_vec(Vector2F::new(-5.0, 3.0));
vec = vec.mul_scalar(2.0);
vec = vec.mul_vec(Vector2F::new(3.0, -2.0));
assert_eq!(12.0, vec.x);
assert_eq!(-12.0, vec.y);

pub fn div_scalar(&self, v: T) -> Vector2<T>

Computes self / (v, v).

use vox_geometry_rust::vector2::Vector2F;
let mut vec = Vector2F::new(3.0, 9.0);
vec = vec.add_scalar(4.0);
vec = vec.add_vec(Vector2F::new(-2.0, 1.0));
vec = vec.sub_scalar(8.0);
vec = vec.sub_vec(Vector2F::new(-5.0, 3.0));
vec = vec.mul_scalar(2.0);
vec = vec.mul_vec(Vector2F::new(3.0, -2.0));
vec = vec.div_scalar(4.0);
assert_eq!(3.0, vec.x);
assert_eq!(-3.0, vec.y);

pub fn div_vec(&self, v: Vector2<T>) -> Vector2<T>

Computes self / (v.x, v.y).

use vox_geometry_rust::vector2::Vector2F;
let mut vec = Vector2F::new(3.0, 9.0);
vec = vec.add_scalar(4.0);
vec = vec.add_vec(Vector2F::new(-2.0, 1.0));
vec = vec.sub_scalar(8.0);
vec = vec.sub_vec(Vector2F::new(-5.0, 3.0));
vec = vec.mul_scalar(2.0);
vec = vec.mul_vec(Vector2F::new(3.0, -2.0));
vec = vec.div_scalar(4.0);
vec = vec.div_vec(Vector2F::new(3.0, -1.0));
assert_eq!(1.0, vec.x);
assert_eq!(3.0, vec.y);

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

Computes dot product.

use vox_geometry_rust::vector2::Vector2F;
let mut vec = Vector2F::new(3.0, 9.0);
vec = vec.add_scalar(4.0);
vec = vec.add_vec(Vector2F::new(-2.0, 1.0));
vec = vec.sub_scalar(8.0);
vec = vec.sub_vec(Vector2F::new(-5.0, 3.0));
vec = vec.mul_scalar(2.0);
vec = vec.mul_vec(Vector2F::new(3.0, -2.0));
vec = vec.div_scalar(4.0);
vec = vec.div_vec(Vector2F::new(3.0, -1.0));
let d = vec.dot(&Vector2F::new(4.0, 2.0));
assert_eq!(d, 10.0);

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

Computes cross product.

use vox_geometry_rust::vector2::Vector2F;
let mut vec = Vector2F::new(3.0, 9.0);
vec = vec.add_scalar(4.0);
vec = vec.add_vec(Vector2F::new(-2.0, 1.0));
vec = vec.sub_scalar(8.0);
vec = vec.sub_vec(Vector2F::new(-5.0, 3.0));
vec = vec.mul_scalar(2.0);
vec = vec.mul_vec(Vector2F::new(3.0, -2.0));
vec = vec.div_scalar(4.0);
vec = vec.div_vec(Vector2F::new(3.0, -1.0));
let c = vec.cross(&Vector2F::new(5.0, -7.0));
assert_eq!(c, -22.0);

impl<T: Float> Vector2<T>

Binary operations: new instance = v (+) self

pub fn rsub_scalar(&self, v: T) -> Vector2<T>

Computes (v, v) - self.

use vox_geometry_rust::vector2::Vector2F;
let mut vec = Vector2F::new(3.0, 9.0);
vec = vec.rsub_scalar(8.0);
assert_eq!(5.0, vec.x);
assert_eq!(-1.0, vec.y);

pub fn rsub_vec(&self, v: Vector2<T>) -> Vector2<T>

Computes (v.x, v.y) - self.

use vox_geometry_rust::vector2::Vector2F;
let mut vec = Vector2F::new(3.0, 9.0);
vec = vec.rsub_scalar(8.0);
vec = vec.rsub_vec(Vector2F::new(-5.0, 3.0));
assert_eq!(-10.0, vec.x);
assert_eq!(4.0, vec.y);

pub fn rdiv_scalar(&self, v: T) -> Vector2<T>

Computes (v, v) / self.

use vox_geometry_rust::vector2::Vector2F;
let mut vec = Vector2F::new(-4.0, -3.0);
vec = vec.rdiv_scalar(12.0);
assert_eq!(-3.0, vec.x);
assert_eq!(vec.y, -4.0);

pub fn rdiv_vec(&self, v: Vector2<T>) -> Vector2<T>

Computes (v.x, v.y) / self.

use vox_geometry_rust::vector2::Vector2F;
let mut vec = Vector2F::new(-4.0, -3.0);
vec = vec.rdiv_scalar(12.0);
vec = vec.rdiv_vec(Vector2F::new(3.0, -16.0));
assert_eq!(-1.0, vec.x);
assert_eq!(4.0, vec.y);

pub fn rcross(&self, v: Vector2<T>) -> T

Computes v cross self.

use vox_geometry_rust::vector2::Vector2F;
let mut vec = Vector2F::new(-4.0, -3.0);
vec = vec.rdiv_scalar(12.0);
vec = vec.rdiv_vec(Vector2F::new(3.0, -16.0));
let c = vec.rcross(Vector2F::new(5.0, -7.0));
assert_eq!(c, 13.0);

impl<T: Float> Vector2<T>

Augmented operations: self (+)= v

pub fn iadd_scalar(&mut self, v: T)

Computes self += (v, v).

use vox_geometry_rust::vector2::Vector2F;
let mut vec = Vector2F::new(3.0, 9.0);
vec.iadd_scalar(4.0);
assert_eq!(7.0, vec.x);
assert_eq!(vec.y, 13.0);

pub fn iadd_vec(&mut self, v: Vector2<T>)

Computes self += (v.x, v.y).

use vox_geometry_rust::vector2::Vector2F;
let mut vec = Vector2F::new(3.0, 9.0);
vec.iadd_scalar(4.0);
vec.iadd_vec(Vector2F::new(-2.0, 1.0));
assert_eq!(5.0, vec.x);
assert_eq!(vec.y, 14.0);

pub fn isub_scalar(&mut self, v: T)

Computes self -= (v, v).

use vox_geometry_rust::vector2::Vector2F;
let mut vec = Vector2F::new(3.0, 9.0);
vec.iadd_scalar(4.0);
vec.iadd_vec(Vector2F::new(-2.0, 1.0));
vec.isub_scalar(8.0);
assert_eq!(-3.0, vec.x);
assert_eq!(6.0, vec.y);

pub fn isub_vec(&mut self, v: Vector2<T>)

Computes self -= (v.x, v.y).

use vox_geometry_rust::vector2::Vector2F;
let mut vec = Vector2F::new(3.0, 9.0);
vec.iadd_scalar(4.0);
vec.iadd_vec(Vector2F::new(-2.0, 1.0));
vec.isub_scalar(8.0);
vec.isub_vec(Vector2F::new(-5.0, 3.0));
assert_eq!(2.0, vec.x);
assert_eq!(3.0, vec.y);

pub fn imul_scalar(&mut self, v: T)

Computes self *= (v, v).

use vox_geometry_rust::vector2::Vector2F;
let mut vec = Vector2F::new(3.0, 9.0);
vec.iadd_scalar(4.0);
vec.iadd_vec(Vector2F::new(-2.0, 1.0));
vec.isub_scalar(8.0);
vec.isub_vec(Vector2F::new(-5.0, 3.0));
vec.imul_scalar(2.0);
assert_eq!(4.0, vec.x);
assert_eq!(6.0, vec.y);

pub fn imul_vec(&mut self, v: Vector2<T>)

Computes self *= (v.x, v.y).

use vox_geometry_rust::vector2::Vector2F;
let mut vec = Vector2F::new(3.0, 9.0);
vec.iadd_scalar(4.0);
vec.iadd_vec(Vector2F::new(-2.0, 1.0));
vec.isub_scalar(8.0);
vec.isub_vec(Vector2F::new(-5.0, 3.0));
vec.imul_scalar(2.0);
vec.imul_vec(Vector2F::new(3.0, -2.0));
assert_eq!(12.0, vec.x);
assert_eq!(-12.0, vec.y);

pub fn idiv_scalar(&mut self, v: T)

Computes self /= (v, v).

use vox_geometry_rust::vector2::Vector2F;
let mut vec = Vector2F::new(3.0, 9.0);
vec.iadd_scalar(4.0);
vec.iadd_vec(Vector2F::new(-2.0, 1.0));
vec.isub_scalar(8.0);
vec.isub_vec(Vector2F::new(-5.0, 3.0));
vec.imul_scalar(2.0);
vec.imul_vec(Vector2F::new(3.0, -2.0));
vec.idiv_scalar(4.0);
assert_eq!(3.0, vec.x);
assert_eq!(-3.0, vec.y);

pub fn idiv_vec(&mut self, v: Vector2<T>)

Computes self /= (v.x, v.y).

use vox_geometry_rust::vector2::Vector2F;
let mut vec = Vector2F::new(3.0, 9.0);
vec.iadd_scalar(4.0);
vec.iadd_vec(Vector2F::new(-2.0, 1.0));
vec.isub_scalar(8.0);
vec.isub_vec(Vector2F::new(-5.0, 3.0));
vec.imul_scalar(2.0);
vec.imul_vec(Vector2F::new(3.0, -2.0));
vec.idiv_scalar(4.0);
vec.idiv_vec(Vector2F::new(3.0, -1.0));
assert_eq!(1.0, vec.x);
assert_eq!(3.0, vec.y);

impl<T: Float> Vector2<T>

Basic getters

pub fn at(&self, i: usize) -> &T

Returns const reference to the i -th element of the vector.

use vox_geometry_rust::vector2::Vector2F;
let vec = Vector2F::new(8.0, 9.0);
assert_eq!(*vec.at(0), 8.0);
assert_eq!(*vec.at(1), 9.0);

pub fn at_mut(&mut self, i: usize) -> &mut T

Returns reference to the i -th element of the vector.

use vox_geometry_rust::vector2::Vector2F;
let mut a = Vector2F::new_default();
*a.at_mut(0) =  10.0_f32;
*a.at_mut(1) =  20.0_f32;
assert_eq!(*a.at(0), 10.0);
assert_eq!(*a.at(1), 20.0);

pub fn sum(&self) -> T

Returns the sum of all the components (i.e. x + y).

use vox_geometry_rust::vector2::Vector2F;
let vec = Vector2F::new(3.0, 7.0);
let sum = vec.sum();
assert_eq!(sum, 10.0);

pub fn avg(&self) -> T

Returns the average of all the components.

use vox_geometry_rust::vector2::Vector2F;
let vec = Vector2F::new(3.0, 7.0);
let avg = vec.avg();
assert_eq!(avg, 5.0);

pub fn min(&self) -> T

Returns the minimum value among x and y.

use vox_geometry_rust::vector2::Vector2F;
let vec = Vector2F::new(3.0, 7.0);
let min = vec.min();
assert_eq!(min, 3.0);

pub fn max(&self) -> T

Returns the maximum value among x and y.

use vox_geometry_rust::vector2::Vector2F;
let vec = Vector2F::new(3.0, 7.0);
let max = vec.max();
assert_eq!(max, 7.0);

pub fn absmin(&self) -> T

Returns the absolute minimum value among x and y.

use vox_geometry_rust::vector2::Vector2F;
let vec = Vector2F::new(-3.0, -7.0);
let absmin = vec.absmin();
assert_eq!(absmin, -3.0);

pub fn absmax(&self) -> T

Returns the absolute maximum value among x and y.

use vox_geometry_rust::vector2::Vector2F;
let vec = Vector2F::new(-3.0, -7.0);
let absmax = vec.absmax();
assert_eq!(absmax, -7.0);

pub fn dominant_axis(&self) -> usize

Returns the index of the dominant axis.

use vox_geometry_rust::vector2::Vector2F;
let vec = Vector2F::new(3.0, 7.0);
let dominant_axis = vec.dominant_axis();
assert_eq!(dominant_axis, 1);

pub fn subminant_axis(&self) -> usize

Returns the index of the subminant axis.

use vox_geometry_rust::vector2::Vector2F;
let vec = Vector2F::new(3.0, 7.0);
let subminant_axis = vec.subminant_axis();
assert_eq!(subminant_axis, 0);

pub fn normalized(&self) -> Vector2<T>

Returns normalized vector.

use vox_geometry_rust::vector2::Vector2F;
use vox_geometry_rust::assert_delta;
let eps = 1e-6_f32;
let vec = Vector2F::new(3.0, 7.0);
let vec2 = vec.normalized();
let len_sqr = vec2.x * vec2.x + vec2.y * vec2.y;
assert_delta!(len_sqr, 1.0, eps);

pub fn length(&self) -> T

Returns the length of the vector.

use vox_geometry_rust::vector2::Vector2F;
use vox_geometry_rust::assert_delta;
let eps = 1e-6_f32;
let vec = Vector2F::new(3.0, 7.0);
let mut vec2 = vec.normalized();
vec2.imul_scalar(2.0);
let len = vec2.length();
assert_delta!(len, 2.0, eps);

pub fn length_squared(&self) -> T

Returns the squared length of the vector.

use vox_geometry_rust::vector2::Vector2F;
use vox_geometry_rust::assert_delta;
let eps = 1e-6_f32;
let vec = Vector2F::new(3.0, 7.0);
let mut vec2 = vec.normalized();
vec2.imul_scalar(2.0);
let len = vec2.length_squared();
assert_delta!(len, 4.0, eps);

pub fn distance_to(&self, other: Vector2<T>) -> T

Returns the distance to the other vector.

pub fn distance_squared_to(&self, other: Vector2<T>) -> T

Returns the squared distance to the other vector.

pub fn reflected(&self, normal: &Vector2<T>) -> Vector2<T>

Returns the reflection vector to the surface with given surface normal.

use vox_geometry_rust::vector2::Vector2D;
use vox_geometry_rust::assert_delta;
let v = Vector2D::new(2.0, 1.0).normalized();
let normal = Vector2D::new(1.0, 1.0).normalized();

let reflected = v.reflected(&normal);
let reflected_answer = Vector2D::new(-1.0, -2.0).normalized();
assert_delta!(reflected.distance_to(reflected_answer), 0.0, 1e-9);

pub fn projected(&self, normal: &Vector2<T>) -> Vector2<T>

Returns the projected vector to the surface with given surface normal.

use vox_geometry_rust::vector2::Vector2D;
use vox_geometry_rust::assert_delta;
let v = Vector2D::new(2.0, 1.0).normalized();
let normal = Vector2D::new(1.0, 1.0).normalized();
let projected = v.projected(&normal);
assert_delta!(projected.dot(&normal), 0.0, 1e-9);

pub fn tangential(&self) -> Vector2<T>

Returns the tangential vector for self vector.

use vox_geometry_rust::vector2::Vector2D;
use vox_geometry_rust::assert_delta;
let normal = Vector2D::new(1.0, 1.0).normalized();
let tangential = normal.tangential();
assert_delta!(tangential.dot(&normal), 0.0, 1e-9);

pub fn is_equal(&self, other: &Vector2<T>) -> bool

Returns true if other is the same as self vector.

pub fn is_similar(&self, other: &Vector2<T>, epsilon: Option<T>) -> bool

Returns true if other is similar to self vector.

Trait Implementations

impl<T: Float> Add<T> for Vector2<T>

Computes (a, a) + (b.x, b.y).

use vox_geometry_rust::vector2::Vector2F;
let mut vec = Vector2F::new(3.0, 9.0);
vec = vec + 4.0;
assert_eq!(7.0, vec.x);
assert_eq!(vec.y, 13.0);

type Output = Vector2<T>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<T: Float> Add for Vector2<T>

Computes (a.x, a.y) + (b.x, b.y).

use vox_geometry_rust::vector2::Vector2F;
let mut vec = Vector2F::new(3.0, 9.0);
vec = vec + 4.0;
vec = vec + Vector2F::new(-2.0, 1.0);
assert_eq!(5.0, vec.x);
assert_eq!(vec.y, 14.0);

type Output = Vector2<T>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<T: Float> AddAssign<T> for Vector2<T>

Computes self += (v, v)

use vox_geometry_rust::vector2::Vector2F;
let mut vec = Vector2F::new(3.0, 9.0);
vec += 4.0;
assert_eq!(7.0, vec.x);
assert_eq!(vec.y, 13.0);

fn add_assign(&mut self, rhs: T)

Performs the += operation.

impl<T: Float> AddAssign for Vector2<T>

Computes self += (v.x, v.y)

use vox_geometry_rust::vector2::Vector2F;
let mut vec = Vector2F::new(3.0, 9.0);
vec += 4.0;
vec += Vector2F::new(-2.0, 1.0);
assert_eq!(5.0, vec.x);
assert_eq!(vec.y, 14.0);

fn add_assign(&mut self, rhs: Self)

Performs the += operation.

impl<T: Float> Clone for Vector2<T>

Copy constructor.

use vox_geometry_rust::vector2::Vector2F;
let mut vec5 = Vector2F::new_lst([7.0, 6.0]);
let mut vec6 = vec5.clone();
vec6.x = 10.0;
assert_eq!(10.0, vec6.x);
assert_eq!(7.0, vec5.x);

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T: Float + Debug> Debug for Vector2<T>

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

Example

use vox_geometry_rust::vector2::Vector2F;
let vec = Vector2F::new(10.0, 20.0);
assert_eq!(format!("{:?}", vec), "(10.0, 20.0)");

assert_eq!(format!("{:#?}", vec), "(
    10.0,
    20.0,
)");

impl<T: Float + Display> Display for Vector2<T>

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

Formats the value using the given formatter.

impl<T: Float> Div<T> for Vector2<T>

Computes (a.x, a.y) / (b, b).

use vox_geometry_rust::vector2::Vector2F;
let mut vec = Vector2F::new(3.0, 9.0);
vec = vec + 4.0;
vec = vec + Vector2F::new(-2.0, 1.0);
vec = vec - 8.0;
vec = vec - Vector2F::new(-5.0, 3.0);
vec = vec * 2.0;
vec = vec * Vector2F::new(3.0, -2.0);
vec = vec / 4.0;
assert_eq!(3.0, vec.x);
assert_eq!(-3.0, vec.y);

type Output = Vector2<T>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<T: Float> Div for Vector2<T>

Computes (a.x, a.y) / (b.x, b.y).

use vox_geometry_rust::vector2::Vector2F;
let mut vec = Vector2F::new(3.0, 9.0);
vec = vec + 4.0;
vec = vec + Vector2F::new(-2.0, 1.0);
vec = vec - 8.0;
vec = vec - Vector2F::new(-5.0, 3.0);
vec = vec * 2.0;
vec = vec * Vector2F::new(3.0, -2.0);
vec = vec / 4.0;
vec = vec / Vector2F::new(3.0, -1.0);
assert_eq!(1.0, vec.x);
assert_eq!(3.0, vec.y);

type Output = Vector2<T>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<T: Float> DivAssign<T> for Vector2<T>

Computes self /= (v, v)

use vox_geometry_rust::vector2::Vector2F;
let mut vec = Vector2F::new(3.0, 9.0);
vec += 4.0;
vec += Vector2F::new(-2.0, 1.0);
vec -= 8.0;
vec -= Vector2F::new(-5.0, 3.0);
vec *= 2.0;
vec *= Vector2F::new(3.0, -2.0);
vec /= 4.0;
assert_eq!(3.0, vec.x);
assert_eq!(-3.0, vec.y);

fn div_assign(&mut self, rhs: T)

Performs the /= operation.

impl<T: Float> DivAssign for Vector2<T>

Computes self /= (v.x, v.y)

use vox_geometry_rust::vector2::Vector2F;
let mut vec = Vector2F::new(3.0, 9.0);
vec += 4.0;
vec += Vector2F::new(-2.0, 1.0);
vec -= 8.0;
vec -= Vector2F::new(-5.0, 3.0);
vec *= 2.0;
vec *= Vector2F::new(3.0, -2.0);
vec /= 4.0;
vec /= Vector2F::new(3.0, -1.0);
assert_eq!(1.0, vec.x);
assert_eq!(3.0, vec.y);

fn div_assign(&mut self, rhs: Self)

Performs the /= operation.

impl<T: Float> Index<usize> for Vector2<T>

Operators

Returns const reference to the i -th element of the vector.

use vox_geometry_rust::vector2::Vector2F;
let vec = Vector2F::new(8.0, 9.0);
assert_eq!(vec[0], 8.0);
assert_eq!(vec[1], 9.0);

type Output = T

The returned type after indexing.

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

Performs the indexing (container[index]) operation.

impl<T: Float> IndexMut<usize> for Vector2<T>

Returns reference to the i -th element of the vector.

use vox_geometry_rust::vector2::Vector2F;
let mut vec = Vector2F::new(8.0, 9.0);
vec[0] = 7.0;
vec[1] = 6.0;
assert_eq!(7.0, vec.x);
assert_eq!(6.0, vec.y);

fn index_mut(&mut self, index: usize) -> &mut Self::Output

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

impl<T: Float> Mul<T> for Vector2<T>

Computes (a.x, a.y) * (b, b).

use vox_geometry_rust::vector2::Vector2F;
let mut vec = Vector2F::new(3.0, 9.0);
vec = vec + 4.0;
vec = vec + Vector2F::new(-2.0, 1.0);
vec = vec - 8.0;
vec = vec - Vector2F::new(-5.0, 3.0);
vec = vec * 2.0;
assert_eq!(4.0, vec.x);
assert_eq!(6.0, vec.y);

type Output = Vector2<T>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<T: Float> Mul<Vector2<T>> for Matrix2x2<T>

Returns a * b.

type Output = Vector2<T>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<T: Float> Mul for Vector2<T>

Computes (a.x, a.y) * (b.x, b.y).

use vox_geometry_rust::vector2::Vector2F;
let mut vec = Vector2F::new(3.0, 9.0);
vec = vec + 4.0;
vec = vec + Vector2F::new(-2.0, 1.0);
vec = vec - 8.0;
vec = vec - Vector2F::new(-5.0, 3.0);
vec = vec * 2.0;
vec = vec * Vector2F::new(3.0, -2.0);
assert_eq!(12.0, vec.x);
assert_eq!(-12.0, vec.y);

type Output = Vector2<T>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<T: Float> MulAssign<T> for Vector2<T>

Computes self *= (v, v)

use vox_geometry_rust::vector2::Vector2F;
let mut vec = Vector2F::new(3.0, 9.0);
vec += 4.0;
vec += Vector2F::new(-2.0, 1.0);
vec -= 8.0;
vec -= Vector2F::new(-5.0, 3.0);
vec *= 2.0;
assert_eq!(4.0, vec.x);
assert_eq!(6.0, vec.y);

fn mul_assign(&mut self, rhs: T)

Performs the *= operation.

impl<T: Float> MulAssign for Vector2<T>

Computes self *= (v.x, v.y)

use vox_geometry_rust::vector2::Vector2F;
let mut vec = Vector2F::new(3.0, 9.0);
vec += 4.0;
vec += Vector2F::new(-2.0, 1.0);
vec -= 8.0;
vec -= Vector2F::new(-5.0, 3.0);
vec *= 2.0;
vec *= Vector2F::new(3.0, -2.0);
assert_eq!(12.0, vec.x);
assert_eq!(-12.0, vec.y);

fn mul_assign(&mut self, rhs: Self)

Performs the *= operation.

impl<T: Float> Neg for Vector2<T>

fn neg(self) -> Self::Output

Negative sign operator.

type Output = Vector2<T>

The resulting type after applying the - operator.

impl<T: Float> PartialEq for Vector2<T>

Returns true if other is the same as self vector.

use vox_geometry_rust::vector2::Vector2F;
let mut vec = Vector2F::new_default();
let vec2 = Vector2F::new(3.0, 7.0);
let vec3 = Vector2F::new(3.0, 5.0);
let vec4 = Vector2F::new(5.0, 1.0);
vec = vec2;
assert_eq!(vec == vec2, true);
assert_eq!(vec == vec3, false);
assert_eq!(vec != vec2, false);
assert_eq!(vec != vec3, true);
assert_eq!(vec != vec4, true);

fn eq(&self, other: &Self) -> 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: Float> Sub<T> for Vector2<T>

Computes (a.x, a.y) - (b, b).

use vox_geometry_rust::vector2::Vector2F;
let mut vec = Vector2F::new(3.0, 9.0);
vec = vec + 4.0;
vec = vec + Vector2F::new(-2.0, 1.0);
vec = vec - 8.0;
assert_eq!(-3.0, vec.x);
assert_eq!(6.0, vec.y);

type Output = Vector2<T>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<T: Float> Sub for Vector2<T>

Computes (a.x, a.y) - (b.x, b.y).

use vox_geometry_rust::vector2::Vector2F;
let mut vec = Vector2F::new(3.0, 9.0);
vec = vec + 4.0;
vec = vec + Vector2F::new(-2.0, 1.0);
vec = vec - 8.0;
vec = vec - Vector2F::new(-5.0, 3.0);
assert_eq!(2.0, vec.x);
assert_eq!(3.0, vec.y);

type Output = Vector2<T>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<T: Float> SubAssign<T> for Vector2<T>

Computes self -= (v, v)

use vox_geometry_rust::vector2::Vector2F;
let mut vec = Vector2F::new(3.0, 9.0);
vec += 4.0;
vec += Vector2F::new(-2.0, 1.0);
vec -= 8.0;
assert_eq!(-3.0, vec.x);
assert_eq!(6.0, vec.y);

fn sub_assign(&mut self, rhs: T)

Performs the -= operation.

impl<T: Float> SubAssign for Vector2<T>

Computes self -= (v.x, v.y)

use vox_geometry_rust::vector2::Vector2F;
let mut vec = Vector2F::new(3.0, 9.0);
vec += 4.0;
vec += Vector2F::new(-2.0, 1.0);
vec -= 8.0;
vec -= Vector2F::new(-5.0, 3.0);
assert_eq!(2.0, vec.x);
assert_eq!(3.0, vec.y);

fn sub_assign(&mut self, rhs: Self)

Performs the -= operation.

impl<T: Float> Copy for Vector2<T>

use vox_geometry_rust::vector2::Vector2F;
let vec = Vector2F::new(5.0, 1.0);
let mut vec2 = Vector2F::new(3.0, 3.0);
vec2 = vec;
assert_eq!(5.0, vec2.x);
assert_eq!(vec2.y, 1.0);

impl<T: Float> Eq for Vector2<T>