Struct Vector3

pub struct Vector3<T>(pub T, pub T, pub T);

A 3D vector

Tuple Fields

0: T

1: T

2: T

Implementations

impl<T> Vector3<T>

pub fn new(x: T, y: T, z: T) -> Self

where T: Construct<T>,

A clean way of making a Vector3 <x, y, z>

Arguments

• x - The x direction scalar .0
• y - The y direction scalar .1
• z - The z direction scalar .2

pub fn normalize(&self, length: Option<T>) -> Vector3<T>

where T: Mul<T, Output = T> + Div<T, Output = T> + Add<T, Output = T> + F32Fmt + Copy,

Returns the Vector3 normalized to a given length

Arguments

• length - The length to normalize to. Default is 1

Examples

use feo_math::linear_algebra::vector3::Vector3;
let vec = Vector3::new(2, 0, 0);
assert_eq!(vec.normalize(Some(5)), Vector3::new(5, 0, 0));
assert_eq!(vec.normalize(None), Vector3::new(1, 0, 0));

pub fn norm(&self) -> T

where T: Add<T, Output = T> + Mul<T, Output = T> + F32Fmt + Copy,

Returns the magnitude, norm, or length of the vector denoted ||v||

Examples

use feo_math::linear_algebra::vector3::Vector3;
let vec = Vector3::new(2, 0, 0);
assert_eq!(vec.norm(), 2);

pub fn unit_vector(&self) -> Self

where Self: Div<T, Output = Self>, T: Add<T, Output = T> + Mul<T, Output = T> + F32Fmt + Copy,

Returns the unit vector of the vector denoted Uv

Examples

use feo_math::linear_algebra::vector3::Vector3;
let v = Vector3::new(1.0, 2.0, 3.0);
let Uv = v.unit_vector();
assert_eq!(Uv.norm(), 1.0);

pub fn cross_product(a: Self, b: Self) -> Self

where T: Mul<T, Output = T> + Sub<T, Output = T> + Copy,

Returns the cross product of 2 Vector4s denoted A x B A trick to know which direction the cross product vector will be pointing is the right hand rule

side view
         ^\ a x b (pointing up)
a _______|| _________ arm (you)
      ///_  
     | \__  
     |
     b (pointing left)

where your index finger is vector a pointing forwards along z your middle finger is vector b pointing left along x and your thumb is the cross product a x b pointing up If you want to think in standard camera space terms use the left hand rule and note that your index finger is pointing along -z

Arguments

• a - The first Vector4
• b - The second Vector4

Examples

use feo_math::linear_algebra::vector3::Vector3;
let a = Vector3(0, 0, -1);
let b = Vector3(-1, 0, 0);
assert_eq!(Vector3::cross_product(a, b), Vector3(0, 1, 0));

pub fn dot_product(a: Self, b: Self) -> T

where T: Mul<T, Output = T> + Add<T, Output = T> + Copy,

Returns the dot product of 2 Vector4s denoted A . B

Arguments

• a - The first Vector4
• b - The second Vector4

Examples

use feo_math::linear_algebra::vector3::Vector3;
let a = Vector3(0, 0, -1);
let b = Vector3(-1, 0, 0);
assert_eq!(Vector3::dot_product(a, b), 0);

Trait Implementations

impl<T> Add<T> for Vector3<T>

where T: Add<T, Output = T> + Copy,

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

Element wise addition

Examples

use feo_math::linear_algebra::vector3::Vector3;
assert_eq!(Vector3(1, 3, 2) + 2, Vector3(3, 5, 4));

type Output = Vector3<T>

The resulting type after applying the + operator.

impl<T> Add for Vector3<T>

where T: Add<T, Output = T> + Copy,

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

Vector

Examples

use feo_math::linear_algebra::vector3::Vector3;
let vec = Vector3::new(1, 2, 3);
let expected = Vector3::new(2, 4, 6);
assert_eq!(vec + vec, expected);

type Output = Vector3<T>

The resulting type after applying the + operator.

impl<T: Clone> Clone for Vector3<T>

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

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T> Debug for Vector3<T>

where T: Debug + Copy,

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

Formats the value using the given formatter.

impl<T> Div<T> for Vector3<T>

where T: Div<T, Output = T> + Copy,

type Output = Vector3<T>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<T> Div for Vector3<T>

where T: Div<T, Output = T> + Copy,

type Output = Vector3<T>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<T> F32Fmt for Vector3<T>

where T: F32Fmt + Copy,

fn sqrt(self) -> Self

Element wise square root

type F32Fmt = Vector3<<T as F32Fmt>::F32Fmt>

fn intoF32Fmt(self) -> Self::F32Fmt

fn fromF32Fmt(f32_fmt: Self::F32Fmt) -> Self

fn cbrt(self) -> Self

fn f32_const_mul(self, constant: f32) -> Self

fn sin_mul(self, _mul_by: Self) -> Self

where Self: Mul<Self, Output = Self> + Sized,

fn cos_mul(self, _mul_by: Self) -> Self

where Self: Mul<Self, Output = Self> + Sized,

fn tan_mul(self, _mul_by: Self) -> Self

where Self: Mul<Self, Output = Self> + Sized,

fn asin_mul(self, _mul_by: Self) -> Self

where Self: Mul<Self, Output = Self> + Sized,

fn acos_mul(self, _mul_by: Self) -> Self

where Self: Mul<Self, Output = Self> + Sized,

fn atan_mul(self, _mul_by: Self) -> Self

where Self: Mul<Self, Output = Self> + Sized,

fn atan2_mul(self, _other: Self, _mul_by: Self) -> Self

where Self: Mul<Self, Output = Self> + Sized,

fn sinh_mul(self, _mul_by: Self) -> Self

where Self: Mul<Self, Output = Self> + Sized,

fn cosh_mul(self, _mul_by: Self) -> Self

where Self: Mul<Self, Output = Self> + Sized,

fn tanh_mul(self, _mul_by: Self) -> Self

where Self: Mul<Self, Output = Self> + Sized,

impl<T> From<[T; 3]> for Vector3<T>

where T: Copy,

fn from(other: [T; 3]) -> Self

Converts to this type from the input type.

impl<T> From<Quaternion<T>> for Vector3<T>

where T: Copy,

fn from(other: Quaternion<T>) -> Vector3<T>

Converts to this type from the input type.

impl<T> From<Vector3<T>> for [T; 3]

where T: Copy,

fn from(other: Vector3<T>) -> [T; 3]

Converts to this type from the input type.

impl<T> From<Vector4<T>> for Vector3<T>

where T: Copy,

fn from(other: Vector4<T>) -> Vector3<T>

Converts to this type from the input type.

impl<T> Mul<T> for Vector3<T>

where T: Mul<T, Output = T> + Copy,

type Output = Vector3<T>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<T> Mul<Vector3<T>> for Matrix3<T>

where T: Add<T, Output = T> + Mul<T, Output = T> + Copy,

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

Matrix * Vector3 = Vector3

[r0c0, r0c1, r0c2]   [x]   [x']
[r1c0, r1c1, r1c2] * [y] = [y']
[r2c0, r2c1, r2c2]   [z]   [z']

Examples

use feo_math::linear_algebra::vector3::Vector3;
use feo_math::linear_algebra::matrix3::Matrix3;
let mat = Matrix3::new(
    [3, 2, 1],
    [1, 3, 2],
    [2, 1, 3]
);
let vec = Vector3::new(1, 3, 2);
assert_eq!(mat * vec, Vector3::new(11, 14, 11));

type Output = Vector3<T>

The resulting type after applying the * operator.

impl<T> Mul for Vector3<T>

where T: Mul<T, Output = T> + Copy,

type Output = Vector3<T>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<T> Neg for Vector3<T>

where T: Neg<Output = T> + Copy,

type Output = Vector3<T>

The resulting type after applying the - operator.

fn neg(self) -> Self::Output

Performs the unary - operation.

impl<T> One for Vector3<T>

where T: One,

const ONE: Self

impl<T: PartialEq> PartialEq for Vector3<T>

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

where T: Rem<T, Output = T> + Copy,

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

Examples

use feo_math::linear_algebra::vector3;

type Output = Vector3<T>

The resulting type after applying the % operator.

impl<T> Rem for Vector3<T>

where T: Rem<T, Output = T> + Copy,

type Output = Vector3<T>

The resulting type after applying the % operator.

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

Performs the % operation.

impl<T> SignOps for Vector3<T>

fn ptcopysign(self, _sign: Self) -> Self

fn ptsignum(self) -> i8

fn abs(self) -> Self

impl<T> Sub<T> for Vector3<T>

where T: Sub<T, Output = T> + Copy,

type Output = Vector3<T>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<T> Sub for Vector3<T>

where T: Sub<T, Output = T> + Copy,

type Output = Vector3<T>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<T> Two for Vector3<T>

where T: Two,

const TWO: Self

impl<T> Zero for Vector3<T>

where T: Zero,

const ZERO: Self

impl<T> Construct<T> for Vector3<T>

where T: Construct<T>,

impl<T: Copy> Copy for Vector3<T>

impl<T> SqMatrix<T, Vector3<T>> for Matrix3<T>

where T: Construct<T>,

impl<T> StructuralPartialEq for Vector3<T>

impl<T> Vector<T> for Vector3<T>

where T: Construct<T>,