Trait VectorSpace 

pub trait VectorSpace:
    Mul<Self::Scalar, Output = Self>
    + Div<Self::Scalar, Output = Self>
    + Add<Self, Output = Self>
    + Sub<Self, Output = Self>
    + Neg<Output = Self>
    + Default
    + Debug
    + Clone
    + Copy {
    type Scalar: ScalarField;

    const ZERO: Self;

    // Provided method
    fn lerp(self, rhs: Self, t: Self::Scalar) -> Self { ... }
}

A type that supports the mathematical operations of a real vector space, irrespective of dimension. In particular, this means that the implementing type supports:

• Scalar multiplication and division on the right by elements of Self::Scalar
• Negation
• Addition and subtraction
• Zero

Within the limitations of floating point arithmetic, all the following are required to hold:

• (Associativity of addition) For all u, v, w: Self, (u + v) + w == u + (v + w).
• (Commutativity of addition) For all u, v: Self, u + v == v + u.
• (Additive identity) For all v: Self, v + Self::ZERO == v.
• (Additive inverse) For all v: Self, v - v == v + (-v) == Self::ZERO.
• (Compatibility of multiplication) For all a, b: Self::Scalar, v: Self, v * (a * b) == (v * a) * b.
• (Multiplicative identity) For all v: Self, v * 1.0 == v.
• (Distributivity for vector addition) For all a: Self::Scalar, u, v: Self, (u + v) * a == u * a + v * a.
• (Distributivity for scalar addition) For all a, b: Self::Scalar, v: Self, v * (a + b) == v * a + v * b.

Note that, because implementing types use floating point arithmetic, they are not required to actually implement PartialEq or Eq.

Required Associated Constants

const ZERO: Self

The zero vector, which is the identity of addition for the vector space type.

Required Associated Types

type Scalar: ScalarField

The scalar type of this vector space.

Provided Methods

fn lerp(self, rhs: Self, t: Self::Scalar) -> Self

Perform vector space linear interpolation between this element and another, based on the parameter t. When t is 0, self is recovered. When t is 1, rhs is recovered.

Note that the value of t is not clamped by this function, so extrapolating outside of the interval [0,1] is allowed.

Dyn Compatibility

This trait is not dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety".

Implementors

impl VectorSpace for DVec2

const ZERO: Self = DVec2::ZERO

type Scalar = f64

impl VectorSpace for DVec3

const ZERO: Self = DVec3::ZERO

type Scalar = f64

impl VectorSpace for DVec4

const ZERO: Self = DVec4::ZERO

type Scalar = f64

impl VectorSpace for Vec2

const ZERO: Self = Vec2::ZERO

type Scalar = f32

impl VectorSpace for Vec3

const ZERO: Self = Vec3::ZERO

type Scalar = f32

impl VectorSpace for Vec4

const ZERO: Self = Vec4::ZERO

type Scalar = f32

impl VectorSpace for Vec3A

const ZERO: Self = Vec3A::ZERO

type Scalar = f32

impl<F: ScalarField, V, W> VectorSpace for Sum<V, W>

where V: VectorSpace<Scalar = F>, W: VectorSpace<Scalar = F>,

const ZERO: Self

type Scalar = F

impl<T: ScalarField> VectorSpace for T

const ZERO: Self = Self::ZERO

type Scalar = T