Struct RangeSumRangeChminChmaxAdd 

pub struct RangeSumRangeChminChmaxAdd<T> {
    min: T,
    max: T,
    min2: T,
    max2: T,
    pub sum: T,
    size: T,
    n_min: T,
    n_max: T,
}

Fields

min: T

max: T

min2: T

max2: T

sum: T

size: T

n_min: T

n_max: T

Implementations

impl<T> RangeSumRangeChminChmaxAdd<T>

where T: Copy + Zero + One + Ord + Bounded + Add<Output = T> + Sub<Output = T> + Mul<Output = T> + PartialEq,

pub fn single(key: T, size: T) -> Self

Examples found in repository

crates/competitive/src/algebra/lazy_map.rs (line 550)

    fn single_agg(&key: &Self::Key) -> Self::Agg {
        Self::single(key, T::one())
    }
    fn act_agg(x: &Self::Agg, a: &Self::Act) -> Option<Self::Agg> {
        Some(if Self::is_act_unit(a) {
            x.clone()
        } else if x.size.is_zero() {
            Self::unit()
        } else if x.min == x.max || a.lb == a.ub || a.lb >= x.max || a.ub <= x.min {
            Self::single(x.min.max(a.lb).min(a.ub) + a.bias, x.size)
        } else if x.min2 == x.max {
            let mut x = x.clone();
            let min = x.min.max(a.lb) + a.bias;
            let max = x.max.min(a.ub) + a.bias;
            x.min = min;
            x.max2 = min;
            x.max = max;
            x.min2 = max;
            x.sum = min * x.n_min + max * x.n_max;
            x
        } else if a.lb < x.min2 && x.max2 < a.ub {
            let mut x = x.clone();
            let min = x.min.max(a.lb);
            let max = x.max.min(a.ub);
            x.sum = x.sum + (min - x.min) * x.n_min + (max - x.max) * x.n_max + a.bias * x.size;
            x.min = min + a.bias;
            x.max = max + a.bias;
            x.min2 = x.min2 + a.bias;
            x.max2 = x.max2 + a.bias;
            x
        } else {
            return None;
        })
    }

Trait Implementations

impl<T> Associative for RangeSumRangeChminChmaxAdd<T>

where T: Copy + Zero + One + Ord + Bounded + Add<Output = T> + Sub<Output = T> + Mul<Output = T> + PartialEq,

impl<T: Clone> Clone for RangeSumRangeChminChmaxAdd<T>

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T: Debug> Debug for RangeSumRangeChminChmaxAdd<T>

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

Formats the value using the given formatter.

impl<T: Eq> Eq for RangeSumRangeChminChmaxAdd<T>

impl<T> LazyMapMonoid for RangeSumRangeChminChmaxAdd<T>

where T: Copy + Zero + One + Ord + Bounded + Add<Output = T> + Sub<Output = T> + Mul<Output = T> + PartialEq,

type Key = T

type Agg = RangeSumRangeChminChmaxAdd<T>

type Act = RangeChminChmaxAdd<T>

type AggMonoid = RangeSumRangeChminChmaxAdd<T>

type ActMonoid = RangeChminChmaxAdd<T>

type KeyAct = RangeChminChmaxAdd<T>

fn single_agg(key: &Self::Key) -> Self::Agg

fn act_agg(x: &Self::Agg, a: &Self::Act) -> Option<Self::Agg>

fn toggle(_x: &mut Self::Agg)

fn is_act_unit(act: &Self::Act) -> bool

fn act_key(x: &Self::Key, a: &Self::Act) -> Self::Key

fn agg_unit() -> Self::Agg

fn act_unit() -> Self::Act

fn agg_operate(x: &Self::Agg, y: &Self::Agg) -> Self::Agg

fn act_operate(x: &Self::Act, y: &Self::Act) -> Self::Act

fn agg_operate_assign(x: &mut Self::Agg, y: &Self::Agg)

fn act_operate_assign(x: &mut Self::Act, y: &Self::Act)

impl<T> Magma for RangeSumRangeChminChmaxAdd<T>

where T: Copy + Zero + One + Ord + Bounded + Add<Output = T> + Sub<Output = T> + Mul<Output = T> + PartialEq,

type T = RangeSumRangeChminChmaxAdd<T>

type of operands: $T$

fn operate(x: &Self::T, y: &Self::T) -> Self::T

binary operaion: $\circ$

fn reverse_operate(x: &Self::T, y: &Self::T) -> Self::T

fn operate_assign(x: &mut Self::T, y: &Self::T)

impl<T: PartialEq> PartialEq for RangeSumRangeChminChmaxAdd<T>

fn eq(&self, other: &Self) -> bool

Equality operator ==.

fn ne(&self, other: &Rhs) -> bool

Inequality operator !=.

impl<T: PartialEq> StructuralPartialEq for RangeSumRangeChminChmaxAdd<T>

impl<T> Unital for RangeSumRangeChminChmaxAdd<T>

where T: Copy + Zero + One + Ord + Bounded + Add<Output = T> + Sub<Output = T> + Mul<Output = T> + PartialEq,

fn unit() -> Self::T

identity element: $e$

fn is_unit(x: &Self::T) -> bool

where Self::T: PartialEq,

fn set_unit(x: &mut Self::T)