Struct RelaxedConvolution 

pub struct RelaxedConvolution<T, C>
where
    C: ConvolveSteps<T = Vec<T>>,
{
    a: Vec<T>,
    b: Vec<T>,
    c: Vec<T>,
    _marker: PhantomData<fn() -> C>,
}

Fields

a: Vec<T>

b: Vec<T>

c: Vec<T>

_marker: PhantomData<fn() -> C>

Implementations

impl<T, C> RelaxedConvolution<T, C>

where T: Clone + Zero + AddAssign<T>, C: ConvolveSteps<T = Vec<T>>,

pub fn push(&mut self, x: T, y: T)

fn calc_block(&mut self, la: usize, lb: usize, size: usize)

Examples found in repository

crates/competitive/src/math/relaxed_convolution.rs (line 64)

    pub fn push(&mut self, x: T, y: T) {
        let q = self.a.len();
        self.a.push(x);
        self.b.push(y);
        self.c.push(T::zero());
        if q != 0 {
            self.c.push(T::zero());
        }
        let k = (q + 2).trailing_zeros();
        let mut s = 0;
        for k in 0..k + 1 - (1 << k == q + 2) as u32 {
            let size = 1 << k;
            self.calc_block(s, q + 1 - size, size);
            if q + 1 - size != s {
                self.calc_block(q + 1 - size, s, size);
            }
            s += size;
        }
    }

Trait Implementations

impl<T: Debug, C> Debug for RelaxedConvolution<T, C>

where C: ConvolveSteps<T = Vec<T>>,

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

Formats the value using the given formatter.

impl<T, C> Default for RelaxedConvolution<T, C>

where C: ConvolveSteps<T = Vec<T>>,

fn default() -> Self

Returns the “default value” for a type.

impl<T, C, I> Index<I> for RelaxedConvolution<T, C>

where C: ConvolveSteps<T = Vec<T>>, I: SliceIndex<[T]>,

type Output = <I as SliceIndex<[T]>>::Output

The returned type after indexing.

fn index(&self, index: I) -> &Self::Output

Performs the indexing (container[index]) operation.