Trait Affine 

pub trait Affine: Sized {
    type Space;
    type Diff: Linear;

    const DIM: usize;

    // Required methods
    fn add(&self, diff: &Self::Diff) -> Self;
    fn sub(&self, other: &Self) -> Self::Diff;

    // Provided method
    fn combine<S: Copy, const N: usize>(
        weights: &[S; N],
        points: &[Self; N],
    ) -> Self
       where Self: Clone,
             Self::Diff: Linear<Scalar = S> { ... }
}

Trait for types representing elements of an affine space.

TODO More documentation, definition of affine space

Required Associated Constants

const DIM: usize

The dimension of Self.

Required Associated Types

type Space

The space that Self is the element type of.

type Diff: Linear

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

Required Methods

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

Adds diff to self component-wise.

add is commutative and associative.

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

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

sub is anti-commutative: v.sub(w) == w.sub(v).neg().

Provided Methods

fn combine<S: Copy, const N: usize>( weights: &[S; N], points: &[Self; N], ) -> Self

where Self: Clone, Self::Diff: Linear<Scalar = S>,

Returns an affine combination of points.

Given a list of weights (w₁, …, w_n) and points (P₁, …, P_n), returns

w₁ * P₁ + … + w_n * P_n

Dyn Compatibility

This trait is not dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety", so this trait is not object safe.

Implementations on Foreign Types

impl Affine for f32

const DIM: usize = 1usize

type Space = ()

type Diff = f32

fn add(&self, other: &f32) -> f32

fn sub(&self, other: &f32) -> f32

impl Affine for i32

const DIM: usize = 1usize

type Space = ()

type Diff = i32

fn add(&self, rhs: &i32) -> i32

fn sub(&self, rhs: &i32) -> i32

impl Affine for u32

const DIM: usize = 1usize

type Space = ()

type Diff = i32

fn add(&self, rhs: &i32) -> u32

fn sub(&self, rhs: &u32) -> i32

Implementors

impl Affine for Angle

const DIM: usize = 1usize

type Space = ()

type Diff = Angle

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

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

const DIM: usize = DIM

type Space = Sp

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

impl<ScSelf, ScDiff, Sp, const N: usize> Affine for Point<[ScSelf; N], Sp>

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

const DIM: usize = N

type Space = Sp

type Diff = Vector<[ScDiff; N], Sp>

impl<Sp, const DIM: usize> Affine for Color<[f32; DIM], Sp>

const DIM: usize = DIM

type Space = Sp

type Diff = Color<[f32; DIM], Sp>

impl<Sp, const DIM: usize> Affine for Color<[u8; DIM], Sp>

const DIM: usize = DIM

type Space = Sp

type Diff = Vector<[i32; DIM], Sp>