Trait Invertible

Source
pub trait Invertible: Magma {
    // Required method
    fn inverse(x: &Self::T) -> Self::T;

    // Provided methods
    fn rinv_operate(x: &Self::T, y: &Self::T) -> Self::T { ... }
    fn rinv_operate_assign(x: &mut Self::T, y: &Self::T) { ... }
}
Expand description

$\exists e \in T, \forall a \in T, \exists b,c \in T, b \circ a = a \circ c = e$

Required Methods§

Source

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

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

Provided Methods§

Source

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

Examples found in repository?
crates/competitive/src/algebra/magma.rs (line 147)
146    fn rinv_operate_assign(x: &mut Self::T, y: &Self::T) {
147        *x = Self::rinv_operate(x, y);
148    }
More examples
Hide additional examples
crates/competitive/src/algebra/ring.rs (line 47)
46    fn sub(x: &Self::T, y: &Self::T) -> Self::T {
47        <Self::Additive as Invertible>::rinv_operate(x, y)
48    }
49
50    fn sub_assign(x: &mut Self::T, y: &Self::T) {
51        <Self::Additive as Invertible>::rinv_operate_assign(x, y);
52    }
53}
54
55impl<R> Ring for R
56where
57    R: SemiRing,
58    R::Additive: Invertible,
59{
60}
61
62pub trait Field: Ring
63where
64    Self::Additive: Invertible,
65    Self::Multiplicative: Invertible,
66{
67    /// multiplicative inverse: $-$
68    fn inv(x: &Self::T) -> Self::T {
69        <Self::Multiplicative as Invertible>::inverse(x)
70    }
71    /// multiplicative right inversed operaion: $-$
72    fn div(x: &Self::T, y: &Self::T) -> Self::T {
73        <Self::Multiplicative as Invertible>::rinv_operate(x, y)
74    }
crates/competitive/src/math/bitwiseand_convolve.rs (line 24)
23    pub fn mobius_transform(f: &mut [G::T]) {
24        bitwise_transform(f, |x, y| *x = G::rinv_operate(x, y));
25    }
crates/competitive/src/math/bitwiseor_convolve.rs (line 24)
23    pub fn mobius_transform(f: &mut [G::T]) {
24        bitwise_transform(f, |y, x| *x = G::rinv_operate(x, y));
25    }
crates/competitive/src/math/bitwisexor_convolve.rs (line 15)
12    pub fn hadamard_transform(f: &mut [G::T]) {
13        bitwise_transform(f, |x, y| {
14            let t = G::operate(x, y);
15            *y = G::rinv_operate(x, y);
16            *x = t;
17        });
18    }
crates/competitive/src/math/gcd_convolve.rs (line 35)
30    pub fn mobius_transform(f: &mut [G::T]) {
31        let n = f.len().saturating_sub(1) as u64;
32        with_prime_list(n, |pl| {
33            for &p in pl.primes_lte(n).iter() {
34                for (i, j) in (0..f.len()).step_by(p as _).enumerate() {
35                    f[i] = G::rinv_operate(&f[i], &f[j]);
36                }
37            }
38        })
39    }
Source

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

Examples found in repository?
crates/competitive/src/algebra/ring.rs (line 51)
50    fn sub_assign(x: &mut Self::T, y: &Self::T) {
51        <Self::Additive as Invertible>::rinv_operate_assign(x, y);
52    }
53}
54
55impl<R> Ring for R
56where
57    R: SemiRing,
58    R::Additive: Invertible,
59{
60}
61
62pub trait Field: Ring
63where
64    Self::Additive: Invertible,
65    Self::Multiplicative: Invertible,
66{
67    /// multiplicative inverse: $-$
68    fn inv(x: &Self::T) -> Self::T {
69        <Self::Multiplicative as Invertible>::inverse(x)
70    }
71    /// multiplicative right inversed operaion: $-$
72    fn div(x: &Self::T, y: &Self::T) -> Self::T {
73        <Self::Multiplicative as Invertible>::rinv_operate(x, y)
74    }
75
76    fn div_assign(x: &mut Self::T, y: &Self::T) {
77        <Self::Multiplicative as Invertible>::rinv_operate_assign(x, y);
78    }
More examples
Hide additional examples
crates/competitive/src/math/quotient_array.rs (line 74)
61    pub fn lucy_dp<G>(mut self, mut mul_p: impl FnMut(T, u64) -> T) -> Self
62    where
63        G: Group<T = T>,
64    {
65        with_prime_list(self.isqrtn, |pl| {
66            for &p in pl.primes_lte(self.isqrtn) {
67                let k = self.quotient_index(p - 1);
68                let p2 = p * p;
69                for (i, q) in Self::index_iter(self.n, self.isqrtn).enumerate() {
70                    if q < p2 {
71                        break;
72                    }
73                    let diff = mul_p(G::rinv_operate(&self[q / p], &self.data[k]), p);
74                    G::rinv_operate_assign(&mut self.data[i], &diff);
75                }
76            }
77        });
78        self
79    }

Dyn Compatibility§

This trait is not dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety", so this trait is not object safe.

Implementations on Foreign Types§

Source§

impl Invertible for ()

Source§

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

Source§

impl<A: Invertible> Invertible for (A,)

Source§

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

Source§

impl<A: Invertible, B: Invertible> Invertible for (A, B)

Source§

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

Source§

impl<A: Invertible, B: Invertible, C: Invertible> Invertible for (A, B, C)

Source§

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

Source§

impl<A: Invertible, B: Invertible, C: Invertible, D: Invertible> Invertible for (A, B, C, D)

Source§

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

Source§

impl<A: Invertible, B: Invertible, C: Invertible, D: Invertible, E: Invertible> Invertible for (A, B, C, D, E)

Source§

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

Source§

impl<A: Invertible, B: Invertible, C: Invertible, D: Invertible, E: Invertible, F: Invertible> Invertible for (A, B, C, D, E, F)

Source§

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

Source§

impl<A: Invertible, B: Invertible, C: Invertible, D: Invertible, E: Invertible, F: Invertible, G: Invertible> Invertible for (A, B, C, D, E, F, G)

Source§

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

Source§

impl<A: Invertible, B: Invertible, C: Invertible, D: Invertible, E: Invertible, F: Invertible, G: Invertible, H: Invertible> Invertible for (A, B, C, D, E, F, G, H)

Source§

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

Source§

impl<A: Invertible, B: Invertible, C: Invertible, D: Invertible, E: Invertible, F: Invertible, G: Invertible, H: Invertible, I: Invertible> Invertible for (A, B, C, D, E, F, G, H, I)

Source§

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

Source§

impl<A: Invertible, B: Invertible, C: Invertible, D: Invertible, E: Invertible, F: Invertible, G: Invertible, H: Invertible, I: Invertible, J: Invertible> Invertible for (A, B, C, D, E, F, G, H, I, J)

Source§

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

Implementors§

Source§

impl Invertible for PermutationOperation

Source§

impl<M> Invertible for ReverseOperation<M>
where M: Invertible,

Source§

impl<M, const N: usize> Invertible for ArrayOperation<M, N>
where M: Invertible,

Source§

impl<T> Invertible for AdditiveOperation<T>
where T: Clone + Zero + Add<Output = T> + Sub<Output = T> + Neg<Output = T>,

Source§

impl<T> Invertible for BitXorOperation<T>
where T: Clone + BitXorIdentity,

Source§

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>,

Source§

impl<T> Invertible for MultiplicativeOperation<T>
where T: Clone + One + Mul<Output = T> + Div<Output = T>,