Struct lfa::LFA

pub struct LFA<I: ?Sized, P: Projector<I>, A: Approximator<Projection>> {
    pub projector: P,
    pub approximator: A,
    /* private fields */
}

Linear function approximator.

Fields

projector: P

approximator: A

Implementations

impl<I: ?Sized, P: Projector<I>, A: Approximator<Projection>> LFA<I, P, A>

pub fn new(projector: P, approximator: A) -> Self

impl<I: ?Sized, P: Projector<I>> LFA<I, P, ScalarFunction>

pub fn scalar_valued(projector: P) -> Self

impl<I: ?Sized, P: Projector<I>> LFA<I, P, VectorFunction>

pub fn vector_valued(projector: P, n_outputs: usize) -> Self

Trait Implementations

impl<I, P, A> Approximator<I> for LFA<I, P, A>where
    I: ?Sized,
    P: Projector<I>,
    A: Approximator<Projection>,

type Value = <A as Approximator<Projection>>::Value

fn evaluate(&self, input: &I) -> EvaluationResult<Self::Value>

Evaluate the function and return its value.

fn update(&mut self, input: &I, update: Self::Value) -> UpdateResult<()>

Update the approximator’s estimate for the given input.

fn adapt(
    &mut self,
    new_features: &HashMap<IndexT, IndexSet>
) -> AdaptResult<usize>

Adapt the approximator in light of newly discovered features.

impl<I: Clone + ?Sized, P: Clone + Projector<I>, A: Clone + Approximator<Projection>> Clone for LFA<I, P, A>

fn clone(&self) -> LFA<I, P, A>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<'de, I: ?Sized, P: Projector<I>, A: Approximator<Projection>> Deserialize<'de> for LFA<I, P, A>where
    P: Deserialize<'de>,
    A: Deserialize<'de>,

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>where
    __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<I, P, A> Parameterised for LFA<I, P, A>where
    I: ?Sized,
    P: Projector<I>,
    A: Approximator<Projection> + Parameterised,

fn weights(&self) -> Matrix<f64>

Return a copy of the approximator weights.

impl<I, P, A> Projector<I> for LFA<I, P, A>where
    P: Projector<I>,
    A: Approximator<Projection>,

fn project(&self, input: &I) -> Projection

Project data from an input space onto the basis.

fn project_expanded(&self, input: &I) -> DenseT

Project data from an input space onto the basis and convert into a raw, dense vector.

impl<I: ?Sized, P: Projector<I>, A: Approximator<Projection>> Serialize for LFA<I, P, A>where
    P: Serialize,
    A: Serialize,

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>where
    __S: Serializer,

Serialize this value into the given Serde serializer.

impl<I, P: Projector<I>, A: Approximator<Projection>> Space for LFA<I, P, A>

type Value = Projection

The data representation of the space.

fn dim(&self) -> usize

Return the dimensionality of the space.

fn card(&self) -> Card

Return the number of elements in the set composing the space.