Struct Vector 

#[repr(transparent)]
pub struct Vector<Repr, Space = ()>(pub Repr, _);

A generic vector type. Represents an element of a vector space or a module, a generalization of a vector space where the scalars can be integers (technically, the scalar type can be any ring-like type).

Type parameters

• Repr: Representation of the scalar components of the vector, for example an array or a SIMD vector.
• Space: The space that the vector is an element of. A tag type used to prevent mixing up vectors of different spaces and bases.

Examples

TODO

Tuple Fields

0: Repr

Implementations

impl Vector<[f32; 2], Polar>

pub fn r(&self) -> f32

Returns the radial component of self.

pub fn az(&self) -> Angle

Returns the azimuthal component of self.

impl Vector<[f32; 3], Spherical>

pub fn r(&self) -> f32

Returns the radial component of self.

pub fn az(&self) -> Angle

Returns the azimuthal component of self.

pub fn alt(&self) -> Angle

Returns the altitude (elevation) component of self.

impl<R, Sp> Vector<R, Sp>

pub const fn new(repr: R) -> Self

Returns a new vector with representation repr.

pub fn to<S>(self) -> Vector<R, S>

Returns a vector with value equal to self but in space S.

This method can be used to coerce a vector from one space to another in order to make types match. One use case is to cast a “generic” vector returned by one of the constructor functions to a more specific space.

impl<Sp, const N: usize> Vector<[f32; N], Sp>

pub fn normalize(&self) -> Self

Returns self normalized to unit length.

Examples

let normalized: Vec2 = vec2(3.0, 4.0).normalize();
assert_approx_eq!(normalized, vec2(0.6, 0.8), eps=1e-2);
assert_approx_eq!(normalized.len_sqr(), 1.0, eps=1e-2);

Panics

Panics in dev mode if self is a zero vector.

pub fn clamp(&self, min: &Self, max: &Self) -> Self

Returns self clamped component-wise to the given range.

In other words, for each component self[i], the result r has r[i] equal to self[i].clamp(min[i], max[i]).

Examples

let v: Vec3 = vec3(0.5, 1.5, -2.0);
// Clamp to the unit cube
let v = v.clamp(&splat(-1.0), &splat(1.0));
assert_eq!(v, vec3(0.5, 1.0, -1.0));

impl<Sc, Sp, const N: usize> Vector<[Sc; N], Sp>

where Self: Linear<Scalar = Sc>, Sc: Linear<Scalar = Sc> + Copy,

pub fn len_sqr(&self) -> Sc

Returns the length of self, squared.

This avoids taking the square root in cases it’s not needed and works with scalars for which a square root is not defined.

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

Returns the dot product of self and other.

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

where Sc: Div<Sc, Output = Sc>,

Returns the scalar projection of self onto other (the length of the component of self parallel to other).

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

where Sc: Div<Sc, Output = Sc>,

Returns the vector projection of self onto other (the vector component of self parallel to other).

           self
           ^
          /.
        /  .
      /    .
    /      .
  /       _.
 +-------'->-----> other
        result

pub fn map<T>(self, f: impl FnMut(Sc) -> T) -> Vector<[T; N], Sp>

Returns a vector of the same dimension as self by applying f component-wise.

impl<R, Sc, B> Vector<R, Real<2, B>>

where R: Index<usize, Output = Sc>, Sc: Copy,

pub fn x(&self) -> Sc

Returns the x component of self.

pub fn y(&self) -> Sc

Returns the y component of self.

impl<R, Sc, B> Vector<R, Real<3, B>>

where R: Index<usize, Output = Sc>, Sc: Copy,

pub fn x(&self) -> Sc

Returns the x component of self.

pub fn y(&self) -> Sc

Returns the y component of self.

pub fn z(&self) -> Sc

Returns the z component of self.

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

where Sc: Linear<Scalar = Sc>, [Sc; 3]: Into<Self>,

Returns the cross product of self with other.

The result is a vector perpendicular to both input vectors, its length proportional to the area of the parallelogram formed by the vectors. Specifically, the length is given by the identity:

    |𝗮 × 𝗯| = |𝗮| |𝗯| sin 𝜽

where |·| denotes the length of a vector and 𝜽 equals the angle between 𝗮 and 𝗯.

       ^
    r  |
    e  |
    s  |    other
    u  |     ^ - - - - - +
    l  |   /           /
    t  | /           /
       +-----------> self

impl<R, Sc> Vector<R, Proj4>

where R: Index<usize, Output = Sc>, Sc: Copy,

pub fn x(&self) -> Sc

Returns the x component of self.

pub fn y(&self) -> Sc

Returns the y component of self.

pub fn z(&self) -> Sc

Returns the z component of self.

pub fn w(&self) -> Sc

Returns the w component of self.

impl Vector<[f32; 2], Real<2, Tex>>

pub const fn u(&self) -> f32

Returns the u (horizontal) component of self.

pub const fn v(&self) -> f32

Returns the v (vertical) component of self.

Trait Implementations

impl<R, Sp> Add<<Vector<R, Sp> as Affine>::Diff> for Vector<R, Sp>

where Self: Affine,

fn add(self, rhs: <Self as Affine>::Diff) -> Self

TODO

type Output = Vector<R, Sp>

The resulting type after applying the + operator.

impl<R, Sp> AddAssign<<Vector<R, Sp> as Affine>::Diff> for Vector<R, Sp>

where Self: Affine,

The vector += vector operator.

fn add_assign(&mut self, rhs: <Self as Affine>::Diff)

Performs the += operation.

impl<Sc, Sp, const DIM: usize> Affine for Vector<[Sc; DIM], Sp>

where Sc: Affine, Sc::Diff: Linear<Scalar = Sc::Diff> + Copy,

const DIM: usize = DIM

The dimension (number of components) of Self.

type Space = Sp

The space that Self is the element type of.

type Diff = Vector<[<Sc as Affine>::Diff; DIM], Sp>

The (signed) difference of two values of Self. Diff must have the same dimension as Self.

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

Adds diff to self component-wise.

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

Subtracts other from self, returning the (signed) difference.

impl<Sc: ApproxEq, Sp, const N: usize> ApproxEq<Vector<[Sc; N], Sp>, Sc> for Vector<[Sc; N], Sp>

fn approx_eq_eps(&self, other: &Self, eps: &Sc) -> bool

Returns whether self and other are approximately equal, using the relative epsilon rel_eps.

fn relative_epsilon() -> Sc

Returns the default relative epsilon of type E.

fn approx_eq(&self, other: &Other) -> bool

Returns whether self and other are approximately equal. Uses the epsilon returned by Self::relative_epsilon.

impl<R: Clone, S> Clone for Vector<R, S>

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<R: Debug, Sp: Debug + Default> Debug for Vector<R, Sp>

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

Formats the value using the given formatter.

impl<R: Default, S> Default for Vector<R, S>

fn default() -> Self

Returns the “default value” for a type.

impl<R, Sp> Div<f32> for Vector<R, Sp>

where Self: Linear<Scalar = f32>,

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

TODO

type Output = Vector<R, Sp>

The resulting type after applying the / operator.

impl<R, Sp> DivAssign<f32> for Vector<R, Sp>

where Self: Linear<Scalar = f32>,

fn div_assign(&mut self, rhs: f32)

Performs the /= operation.

impl<R, Sp> From<R> for Vector<R, Sp>

fn from(els: R) -> Self

Converts to this type from the input type.

impl<Sp, Sc: Clone, const DIM: usize> From<Sc> for Vector<[Sc; DIM], Sp>

fn from(scalar: Sc) -> Self

Returns a vector with all components equal to scalar.

This operation is also called “splat” or “broadcast”.

impl<R, Sp> Index<usize> for Vector<R, Sp>

where Self: Affine, R: Index<usize>,

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

Returns the component of self with index i.

Panics

If i >= Self::DIM. Note that Self::DIM can be less than the number of elements in R.

type Output = <R as Index<usize>>::Output

The returned type after indexing.

impl<R, Sp> IndexMut<usize> for Vector<R, Sp>

where Self: Affine, R: IndexMut<usize>,

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

Returns a mutable reference to the component of self with index i.

Panics

If i >= Self::DIM. Note that Self::DIM can be less than the number of elements in R.

impl<Sc, Sp, const DIM: usize> Linear for Vector<[Sc; DIM], Sp>

where Self: Affine<Diff = Self>, Sc: Linear<Scalar = Sc> + Copy,

fn zero() -> Self

Returns a vector with all-zero components, also called a null vector.

type Scalar = Sc

The scalar type associated with Self.

fn neg(&self) -> Self

Returns the additive inverse of self.

fn mul(&self, scalar: Self::Scalar) -> Self

Multiplies all components of self by scalar.

impl<R, Sp> Mul<<Vector<R, Sp> as Linear>::Scalar> for Vector<R, Sp>

where Self: Linear,

fn mul(self, rhs: <Self as Linear>::Scalar) -> Self

TODO

type Output = Vector<R, Sp>

The resulting type after applying the * operator.

impl<R, Sp> Mul<Vector<R, Sp>> for f32

where Vector<R, Sp>: Linear<Scalar = f32>,

type Output = Vector<R, Sp>

The resulting type after applying the * operator.

fn mul(self, rhs: Vector<R, Sp>) -> Self::Output

Performs the * operation.

impl<R, Sp> Mul<Vector<R, Sp>> for i32

where Vector<R, Sp>: Linear<Scalar = i32>,

type Output = Vector<R, Sp>

The resulting type after applying the * operator.

fn mul(self, rhs: Vector<R, Sp>) -> Self::Output

Performs the * operation.

impl<R, Sp> Mul<Vector<R, Sp>> for u32

where Vector<R, Sp>: Linear<Scalar = u32>,

type Output = Vector<R, Sp>

The resulting type after applying the * operator.

fn mul(self, rhs: Vector<R, Sp>) -> Self::Output

Performs the * operation.

impl<R, Sp> MulAssign<<Vector<R, Sp> as Linear>::Scalar> for Vector<R, Sp>

where Self: Linear,

fn mul_assign(&mut self, rhs: <Self as Linear>::Scalar)

Performs the *= operation.

impl<R, Sp> Neg for Vector<R, Sp>

where Self: Linear,

The vector negation operator.

type Output = Vector<R, Sp>

The resulting type after applying the - operator.

fn neg(self) -> Self::Output

Performs the unary - operation.

impl<R: PartialEq, S> PartialEq for Vector<R, S>

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<R, Sp> Sub<<Vector<R, Sp> as Affine>::Diff> for Vector<R, Sp>

where Self: Affine,

fn sub(self, rhs: <Self as Affine>::Diff) -> Self

TODO

type Output = Vector<R, Sp>

The resulting type after applying the - operator.

impl<R, Sp> SubAssign<<Vector<R, Sp> as Affine>::Diff> for Vector<R, Sp>

where Self: Affine,

The vector -= vector operator.

fn sub_assign(&mut self, rhs: <Self as Affine>::Diff)

Performs the -= operation.

impl<R, Sp> Sum for Vector<R, Sp>

where Self: Linear,

fn sum<I: Iterator<Item = Self>>(iter: I) -> Self

Takes an iterator and generates Self from the elements by “summing up” the items.

impl<R: Copy, S> Copy for Vector<R, S>

impl<R: Eq, S> Eq for Vector<R, S>