Struct VectorPrecise 

pub struct VectorPrecise<const L: usize> {
    pub data: [r32; L],
}

Vector type using rational components - allows for higher precision + implementation of Eq and Hash. Length of L, components are r32, indexable by usize index.

Fields

data: [r32; L]

Array of r32 components.

Implementations

impl<const L: usize> VectorPrecise<L>

pub fn new(data: [r32; L]) -> Self

Returns a new Vector of length L from an array of f32 with the same length.

pub fn dot(&self, other: VectorPrecise<L>) -> r32

Dot product with another Vector of same length.

pub fn as_row(&self) -> MatrixPrecise<1, L>

Returns the Vector as a Matrix with 1 row and L columns - aka the Vector as a single row matrix.

pub fn as_col(&self) -> MatrixPrecise<L, 1>

Returns the Vector as a Matrix with L rows and 1 column - aka the Vector as a single column matrix.

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

Utility function for adding vectors - used to implement std::ops.

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

Utility function for multiplying vectors - used to implement std::ops.

pub fn rational_mul(&self, other: r32) -> Self

Utility function for multiplying a vector by a rational - used to implement std::ops.

pub fn recip(&self) -> Self

Utility function for getting the reciprocal of the vector, component wise - used to implement std::ops.

pub fn sum(&self) -> r32

Returns the sum of the components of the vector.

pub fn sq_sum(&self) -> r32

Returns the sum of the squared components of the vector, i.e. the squared magnitude of the vector.

pub fn normalised(&self) -> Self

Returns a normalised copy of the vector.

impl VectorPrecise<2>

pub fn heading(&self) -> r32

Trait Implementations

impl<const L: usize> Add for VectorPrecise<L>

type Output = VectorPrecise<L>

The resulting type after applying the + operator.

fn add(self, other: VectorPrecise<L>) -> Self

Performs the + operation.

impl<const L: usize> Clone for VectorPrecise<L>

fn clone(&self) -> VectorPrecise<L>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<const L: usize> Debug for VectorPrecise<L>

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

Formats the value using the given formatter.

impl<const L: usize> Default for VectorPrecise<L>

fn default() -> VectorPrecise<L>

Returns the “default value” for a type.

impl<const L: usize> Display for VectorPrecise<L>

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

Formats the value using the given formatter.

impl<const L: usize> Div<r32> for VectorPrecise<L>

type Output = VectorPrecise<L>

The resulting type after applying the / operator.

fn div(self, other: r32) -> Self

Performs the / operation.

impl<const L: usize> Div for VectorPrecise<L>

type Output = VectorPrecise<L>

The resulting type after applying the / operator.

fn div(self, other: VectorPrecise<L>) -> Self

Performs the / operation.

impl<const L: usize> From<Vector<L>> for VectorPrecise<L>

fn from(v: Vector<L>) -> Self

Converts to this type from the input type.

impl<const L: usize> From<VectorPrecise<L>> for Vector<L>

fn from(v: VectorPrecise<L>) -> Self

Converts to this type from the input type.

impl<const L: usize> Hash for VectorPrecise<L>

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl<const L: usize> Identity for VectorPrecise<L>

fn identity() -> VectorPrecise<L>

impl<const L: usize> Index<usize> for VectorPrecise<L>

type Output = r32

The returned type after indexing.

fn index(&self, index: usize) -> &r32

Performs the indexing (container[index]) operation.

impl<const L: usize> IndexMut<usize> for VectorPrecise<L>

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

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

impl<const L: usize> Magnitude for VectorPrecise<L>

type Output = surd32

fn mag(&self) -> surd32

impl<const A: usize, const B: usize> Mul<MatrixPrecise<A, B>> for VectorPrecise<A>

type Output = VectorPrecise<B>

The resulting type after applying the * operator.

fn mul(self, other: MatrixPrecise<A, B>) -> VectorPrecise<B>

Performs the * operation.

impl<const A: usize, const B: usize> Mul<VectorPrecise<B>> for MatrixPrecise<A, B>

type Output = VectorPrecise<A>

The resulting type after applying the * operator.

fn mul(self, other: VectorPrecise<B>) -> VectorPrecise<A>

Performs the * operation.

impl<const L: usize> Mul<VectorPrecise<L>> for r32

type Output = VectorPrecise<L>

The resulting type after applying the * operator.

fn mul(self, other: VectorPrecise<L>) -> VectorPrecise<L>

Performs the * operation.

impl<const L: usize> Mul<r32> for VectorPrecise<L>

type Output = VectorPrecise<L>

The resulting type after applying the * operator.

fn mul(self, other: r32) -> Self

Performs the * operation.

impl<const L: usize> Mul for VectorPrecise<L>

type Output = VectorPrecise<L>

The resulting type after applying the * operator.

fn mul(self, other: VectorPrecise<L>) -> Self

Performs the * operation.

impl<const L: usize> PartialEq for VectorPrecise<L>

fn eq(&self, other: &VectorPrecise<L>) -> 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<const L: usize> Sub for VectorPrecise<L>

type Output = VectorPrecise<L>

The resulting type after applying the - operator.

fn sub(self, other: VectorPrecise<L>) -> Self

Performs the - operation.

impl<const L: usize> Copy for VectorPrecise<L>

impl<const L: usize> Eq for VectorPrecise<L>

impl<const L: usize> StructuralPartialEq for VectorPrecise<L>