[−][src]Trait lfa::composition::Composable

pub trait Composable: Sized {
    fn lfa<A: Approximator>(self, approximator: A) -> LFA<Self, A> { ... }

    fn stack<P>(self, p: P) -> Stack<Self, P> { ... }

    fn add<P: Space>(self, p: P) -> Sum<Self, P>
    where
        Self: Space,
    { ... }

    fn subtract<P: Space>(self, p: P) -> Sum<Self, Negate<P>>
    where
        Self: Space,
    { ... }

    fn shift(self, offset: f64) -> Shift<Self> { ... }

    fn multiply<P: Space>(self, p: P) -> Product<Self, P>
    where
        Self: Space,
    { ... }

    fn divide<P: Space>(self, p: P) -> Product<Self, Reciprocal<P>>
    where
        Self: Space,
    { ... }

    fn scale(self, factor: f64) -> Scale<Self> { ... }

    fn normalise_l1(self) -> L1Normalise<Self> { ... }

    fn normalise_l2(self) -> L2Normalise<Self> { ... }

    fn normalise_lp(self, p: u8) -> LpNormalise<Self> { ... }

    fn normalise_linf(self) -> LinfNormalise<Self> { ... }

    fn with_constant(self) -> Stack<Self, Constant> { ... }
}

Trait for composition of any support LFA types.

Provided methods

fn lfa<A: Approximator>(self, approximator: A) -> LFA<Self, A>

Return an LFA using this Projector instance and a given Approximator.

fn stack<P>(self, p: P) -> Stack<Self, P>

Return a Stack of this Projector over another.

fn add<P: Space>(self, p: P) -> Sum<Self, P> where
    Self: Space, 

Return the Sum of this Projector and another.

fn subtract<P: Space>(self, p: P) -> Sum<Self, Negate<P>> where
    Self: Space, 

Return the Sum of this Projector and the Negated other.

fn shift(self, offset: f64) -> Shift<Self>

Return the original Projector with all activations Shifted by some offset.

fn multiply<P: Space>(self, p: P) -> Product<Self, P> where
    Self: Space, 

Return the Product of this Projector and another.

fn divide<P: Space>(self, p: P) -> Product<Self, Reciprocal<P>> where
    Self: Space, 

Return the Product of this Projector and the Reciprocal of the other.

fn scale(self, factor: f64) -> Scale<Self>

Return the original Projector with all activations Scaled by some factor.

fn normalise_l1(self) -> L1Normalise<Self>

Return the original Projector with all activations normalised in L₁.

fn normalise_l2(self) -> L2Normalise<Self>

Return the original Projector with all activations normalised in L₂.

fn normalise_lp(self, p: u8) -> LpNormalise<Self>

Return the original Projector with all activations normalised in Lp.

fn normalise_linf(self) -> LinfNormalise<Self>

Return the original Projector with all activations normalised in L∞.

fn with_constant(self) -> Stack<Self, Constant>

Return the a Stack of this Projector with a single constant feature term.

Loading content...

Implementors

impl<T> Composable for T[src]

fn lfa<A: Approximator>(self, approximator: A) -> LFA<Self, A>[src]

fn stack<P>(self, p: P) -> Stack<Self, P>[src]

fn add<P: Space>(self, p: P) -> Sum<Self, P> where
    Self: Space, [src]

fn subtract<P: Space>(self, p: P) -> Sum<Self, Negate<P>> where
    Self: Space, [src]

fn shift(self, offset: f64) -> Shift<Self>[src]

fn multiply<P: Space>(self, p: P) -> Product<Self, P> where
    Self: Space, [src]

fn divide<P: Space>(self, p: P) -> Product<Self, Reciprocal<P>> where
    Self: Space, [src]

fn scale(self, factor: f64) -> Scale<Self>[src]

fn normalise_l1(self) -> L1Normalise<Self>[src]

fn normalise_l2(self) -> L2Normalise<Self>[src]

fn normalise_lp(self, p: u8) -> LpNormalise<Self>[src]

fn normalise_linf(self) -> LinfNormalise<Self>[src]

fn with_constant(self) -> Stack<Self, Constant>[src]

Loading content...