Struct Vec2 

pub struct Vec2 {
    pub x: f64,
    pub y: f64,
}

A 2-dimensional vector type

Provides common vector operations such as addition, subtraction, scalar and component-wise multiplication, normalization, dot and cross products.

Examples

use lars::Vec2;
let a = Vec2::new(3.0, 4.0);
assert_eq!(a.mag(), 5.0);

Fields

x: f64

X component of the vector.

y: f64

Y component of the vector.

Implementations

impl Vec2

pub const fn new(x: f64, y: f64) -> Vec2

impl Vec2

pub const ZERO: Vec2

A zero Vector (0.0, 0.0, 0.0)

pub const ONE: Vec2

A one Vector (1.0, 1.0, 1.0)

pub const UNIT_X: Vec2

A Unit Vector in X (1.0, 0.0, 0.0)

pub const UNIT_Y: Vec2

A Unit Vector in Y (0.0, 1.0, 0.0)

pub fn mag(&self) -> f64

Returns the magnitude (length) of the vector.

Examples

use lars::Vec2;
let v = Vec2::new(3.0, 4.0);
assert_eq!(v.mag(), 5.0);

pub fn dot(&self, other: &Vec2) -> f64

Returns the dot product between self and another Vec2.

The dot product measures the cosine of the angle between two vectors.

Examples

use lars::Vec2;
let a = Vec2::new(1.0, 2.0);
let b = Vec2::new(3.0, 4.0);
assert_eq!(a.dot(&b), 11.0);

pub fn cross(&self, other: &Vec2) -> f64

Returns the scalar 2D cross product between self and another Vec2.

Unlike the 3D cross product, the 2D version returns a scalar equal to the signed area of the parallelogram formed by the two vectors.

Examples

use lars::Vec2;
let a = Vec2::new(1.0, 0.0);
let b = Vec2::new(0.0, 1.0);
assert_eq!(a.cross(&b), 1.0);

pub fn map<F>(&self, f: F) -> Vec2

where F: Fn(f64) -> f64,

Applies a function f to each component (x, y) of the vector.

Examples

use lars::Vec2;
let v = Vec2::new(1.0, 2.0);
let squared = v.map(|x| x * x);
assert_eq!(squared, Vec2::new(1.0, 4.0));

pub fn normalize(&self) -> Vec2

Returns a normalized (unit-length) version of the vector.

Panics

Panics if the vector has zero magnitude (division by zero).

Examples

use lars::Vec2;
let v = Vec2::new(3.0, 0.0);
assert_eq!(v.normalize(), Vec2::new(1.0, 0.0));

pub fn mag_sq(&self) -> f64

Returns the magnitude of the vector, squared.

Examples

use lars::Vec2;
let v = Vec2::new(3.0, 4.0);
assert_eq!(v.mag_sq(), 25.0);

impl Vec2

pub fn dist(&self, other: &Point2D) -> f64

Finds the unsigned distance between self and another 3D point Other.

#examples

use lars::Point2D;
let a = Point2D::new(1.0, 0.0);
let b = Point2D::new(0.0, 0.0);
assert_eq!(a.dist(&b), 1.0)

pub fn dist_sq(&self, other: &Point2D) -> f64

Finds the unsigned distance between self and another 3D point Other, squared

#examples

use lars::Point2D;
let a = Point2D::new(2.0, 0.0);
let b = Point2D::new(0.0, 0.0);
assert_eq!(a.dist_sq(&b), 4.0)

Trait Implementations

impl Add for Vec2

type Output = Vec2

The resulting type after applying the + operator.

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

Performs the + operation.

impl Clone for Vec2

fn clone(&self) -> Vec2

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Vec2

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

Formats the value using the given formatter.

impl Default for Vec2

Returns (0.0, 0.0)

fn default() -> Self

Returns the “default value” for a type.

impl Display for Vec2

displays the vector in the form (X, Y)

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

Formats the value using the given formatter.

impl<__RhsT: Copy> Div<__RhsT> for Vec2

where f64: Div<__RhsT, Output = f64>,

type Output = Vec2

The resulting type after applying the / operator.

fn div(self, rhs: __RhsT) -> Vec2

Performs the / operation.

impl Mul<Mat2> for Vec2

type Output = Vec2

The resulting type after applying the * operator.

fn mul(self, m: Mat2) -> Vec2

Performs the * operation.

impl Mul<Vec2> for Mat2

Implements matrix–vector multiplication (Mat2 * Vec2).

Performs the linear transformation of the vector by the matrix.

[ \begin{bmatrix} a & b \ c & d \end{bmatrix} \begin{bmatrix} x \ y \end{bmatrix}

\begin{bmatrix} ax + by \ cx + dy \end{bmatrix} ]

Examples

use lars::{Mat2, Vec2};
let m = Mat2::new(1.0, 2.0, 3.0, 4.0);
let v = Vec2::new(1.0, 1.0);
assert_eq!(m * v, Vec2::new(3.0, 7.0));

type Output = Vec2

The resulting type after applying the * operator.

fn mul(self, v: Vec2) -> Vec2

Performs the * operation.

impl Mul<Vec2> for f64

Implements scalar multiplication for f64 * Vec2.

Examples

use lars::Vec2;
let v = Vec2::new(1.0, 2.0);
let scaled = 2.0 * v;
assert_eq!(scaled, Vec2::new(2.0, 4.0));

type Output = Vec2

The resulting type after applying the * operator.

fn mul(self, vector: Vec2) -> Vec2

Performs the * operation.

impl<__RhsT: Copy> Mul<__RhsT> for Vec2

where f64: Mul<__RhsT, Output = f64>,

type Output = Vec2

The resulting type after applying the * operator.

fn mul(self, rhs: __RhsT) -> Vec2

Performs the * operation.

impl Mul for Vec2

Implements component-wise multiplication between two Vec2s.

Examples

use lars::Vec2;
let a = Vec2::new(1.0, 2.0);
let b = Vec2::new(3.0, 4.0);
assert_eq!(a * b, Vec2::new(3.0, 8.0));

type Output = Vec2

The resulting type after applying the * operator.

fn mul(self, vector: Vec2) -> Vec2

Performs the * operation.

impl Neg for Vec2

type Output = Vec2

The resulting type after applying the - operator.

fn neg(self) -> Vec2

Performs the unary - operation.

impl PartialEq for Vec2

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 PartialOrd for Vec2

fn partial_cmp(&self, other: &Vec2) -> 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 Sub for Vec2

type Output = Vec2

The resulting type after applying the - operator.

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

Performs the - operation.

impl Copy for Vec2