Struct LinearOperation 

pub struct LinearOperation<T>
where
    T: Clone + Zero + Add<Output = T> + One + Mul<Output = T>,
{
    _marker: PhantomData<fn() -> T>,
}

$(a, b) \circ (c, d) = \lambda x. c \times (a \times x + b) + d$

Fields

_marker: PhantomData<fn() -> T>

Implementations

impl<T> LinearOperation<T>

where T: Clone + Zero + Add<Output = T> + One + Mul<Output = T>,

pub fn apply(f: &(T, T), x: &T) -> T

Examples found in repository

crates/library_checker/src/tree/dynamic_tree_vertex_set_path_composite.rs (line 103)

pub fn dynamic_tree_vertex_set_path_composite(reader: impl Read, writer: impl Write) {
    prepare_io!(reader, writer);
    sc!(n, q, ab: [Affine; n], edges: [(usize, usize); n - 1]);
    let mut tree = PathLinkCutTree::<PathComposite>::from_edges(ab, &edges);
    for _ in 0..q {
        sc!(query: Query);
        match query {
            Query::Relink { u, v, w, x } => {
                tree.cut(u, v);
                tree.link(w, x);
            }
            Query::Set { p, cd } => tree.set(p, cd),
            Query::Apply { u, v, x } => {
                pp!(LinearOperation::apply(&tree.fold_path(u, v).0, &x));
            }
        }
    }
}

#[verify::library_checker("dynamic_tree_vertex_set_path_composite")]
pub fn dynamic_tree_vertex_set_path_composite_top_tree(reader: impl Read, writer: impl Write) {
    prepare_io!(reader, writer);
    sc!(n, q, ab: [Affine; n], edges: [(usize, usize); n - 1]);
    let mut tree = TopTree::<PathComposite>::from_edges(ab, &edges);
    for _ in 0..q {
        sc!(query: Query);
        match query {
            Query::Relink { u, v, w, x } => {
                tree.cut(u, v);
                tree.link(w, x);
            }
            Query::Set { p, cd } => tree.set(p, cd),
            Query::Apply { u, v, x } => {
                pp!(LinearOperation::apply(&tree.fold_path(u, v).0, &x));
            }
        }
    }
}

Trait Implementations

impl<T> Associative for LinearOperation<T>

where T: Clone + Zero + One + Add<Output = T> + Mul<Output = T>,

impl<T> Invertible for LinearOperation<T>

where T: Clone + Zero + One + Add<Output = T> + Sub<Output = T> + Neg<Output = T> + Mul<Output = T> + Div<Output = T>,

fn inverse(x: &Self::T) -> Self::T

$a$ where $a \circ x = e$

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

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

impl<T> Magma for LinearOperation<T>

where T: Clone + Zero + One + Add<Output = T> + Mul<Output = T>,

type T = (T, 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> Unital for LinearOperation<T>

where T: Clone + Zero + One + Add<Output = T> + Mul<Output = T>,

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)