Struct Transducerdp 

pub struct Transducerdp<M, T, C>
where
    M: Monoid,
    T: Transducer,
    C: Container<Key = T::State, Value = M::T>,
{
    pub dp: C,
    /* private fields */
}

Fields

dp: C

Implementations

impl<M, T, C> Transducerdp<M, T, C>

where M: Monoid, T: Transducer, C: Container<Key = T::State, Value = M::T>,

pub fn new<F>(fst: T, init: M::T, factory: F) -> Self

where F: ContainerFactory<Container = C>,

Examples found in repository

crates/competitive/src/data_structure/transducer.rs (line 107)

    pub fn with_factory<F>(self, factory: F) -> Transducerdp<M, A, F::Container>
    where
        F: ContainerFactory,
        F::Container: Container<Key = A::State, Value = M::T>,
    {
        Transducerdp::new(self.fst, self.init, factory)
    }
    pub fn with_hashmap(self) -> Transducerdp<M, A, HashMap<A::State, M::T>>
    where
        A::State: Eq + Hash,
    {
        Transducerdp::new(self.fst, self.init, HashMapFactory::default())
    }
    pub fn with_vecmap<F>(
        self,
        key_to_index: F,
    ) -> Transducerdp<M, A, VecMap<false, A::State, M::T, F>>
    where
        F: Fn(&A::State) -> usize + Clone,
    {
        Transducerdp::new(self.fst, self.init, VecMapFactory::new(key_to_index))
    }
    pub fn with_fixed_vecmap<F>(
        self,
        key_to_index: F,
        len: usize,
    ) -> Transducerdp<M, A, VecMap<true, A::State, M::T, F>>
    where
        F: Fn(&A::State) -> usize + Clone,
    {
        Transducerdp::new(
            self.fst,
            self.init,
            FixedVecMapFactory::new(key_to_index, len),
        )
    }

pub fn step<S, I, B>(&mut self, sigma: S)

where S: FnMut() -> I, I: IntoIterator<Item = B>, B: Borrow<T::Input>,

Examples found in repository

crates/competitive/src/data_structure/transducer.rs (line 260)

    pub fn run<S, I, B>(&mut self, mut sigma: S, len: usize) -> M::T
    where
        S: FnMut() -> I,
        I: IntoIterator<Item = B>,
        B: Borrow<T::Input>,
    {
        for _ in 0..len {
            self.step(&mut sigma);
        }
        self.fold_accept()
    }

pub fn step_effect<S, I, B, F>(&mut self, sigma: S, effect: F)

where S: FnMut() -> I, I: IntoIterator<Item = B>, B: Borrow<T::Input>, F: FnMut(&M::T, &T::Output) -> M::T,

Examples found in repository

crates/competitive/src/data_structure/transducer.rs (line 272)

    pub fn run_effect<S, I, B, F>(&mut self, mut sigma: S, len: usize, mut effect: F) -> M::T
    where
        S: FnMut() -> I,
        I: IntoIterator<Item = B>,
        B: Borrow<T::Input>,
        F: FnMut(&M::T, &T::Output) -> M::T,
    {
        for _ in 0..len {
            self.step_effect(&mut sigma, &mut effect);
        }
        self.fold_accept()
    }

pub fn fold_accept(&self) -> M::T

Examples found in repository

crates/competitive/src/data_structure/transducer.rs (line 262)

    pub fn run<S, I, B>(&mut self, mut sigma: S, len: usize) -> M::T
    where
        S: FnMut() -> I,
        I: IntoIterator<Item = B>,
        B: Borrow<T::Input>,
    {
        for _ in 0..len {
            self.step(&mut sigma);
        }
        self.fold_accept()
    }
    pub fn run_effect<S, I, B, F>(&mut self, mut sigma: S, len: usize, mut effect: F) -> M::T
    where
        S: FnMut() -> I,
        I: IntoIterator<Item = B>,
        B: Borrow<T::Input>,
        F: FnMut(&M::T, &T::Output) -> M::T,
    {
        for _ in 0..len {
            self.step_effect(&mut sigma, &mut effect);
        }
        self.fold_accept()
    }

pub fn map_fold_accept<U, F, D>(&self, f: F, map: D) -> D

where F: FnMut(&T::State) -> U, D: Container<Key = U, Value = M::T>,

pub fn run<S, I, B>(&mut self, sigma: S, len: usize) -> M::T

where S: FnMut() -> I, I: IntoIterator<Item = B>, B: Borrow<T::Input>,

pub fn run_effect<S, I, B, F>( &mut self, sigma: S, len: usize, effect: F, ) -> M::T

where S: FnMut() -> I, I: IntoIterator<Item = B>, B: Borrow<T::Input>, F: FnMut(&M::T, &T::Output) -> M::T,

Trait Implementations

impl<M, T, C> Clone for Transducerdp<M, T, C>

where M: Monoid + Clone, T: Transducer + Clone, C: Container<Key = T::State, Value = M::T> + Clone,

fn clone(&self) -> Transducerdp<M, T, C>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<M, T, C> Debug for Transducerdp<M, T, C>

where M: Monoid, T: Transducer + Debug, T::State: Debug, M::T: Debug, C: Container<Key = T::State, Value = M::T> + Debug,

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

Formats the value using the given formatter.