mathru 0.16.2

Fundamental algorithms for scientific computing in Rust
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69

//! Magma
use super::operator::{Addition, Multiplication, Operator};
use std::ops::{Add, AddAssign, Mul, MulAssign};

/// A Magma is a pair $(\mathbb{M}, \circ)$, composed by a set $\mathbb{M}$
/// and a binary inner operation $\circ$:
///
/// ```math
/// \circ: \mathbb{M} \times \mathbb{M} \rightarrow \mathbb{M} ,\\\\ (x, y) \mapsto x \circ y
/// ```
pub trait Magma<O: Operator>: Clone + PartialEq + Sync + Send {
    /// binary operation
    fn operate(self, rhs: Self) -> Self;
}

macro_rules! impl_magma
(
    ($O:ty; $op: ident; $($T:ty),*) =>
    {
        $(
            impl Magma<$O> for $T
            {
                fn operate(self, rhs: Self) -> Self
                {
                    self.$op(rhs)
                }
            }
        )*
    }
);

impl_magma!(Addition; add; u8, u16, u32, u64, u128, i8, i16, i32, i64, i128, f32, f64);
impl_magma!(Multiplication; mul; u8, u16, u32, u64, u128, i8, i16, i32, i64, i128, f32, f64);

/// Syntactic sugar for `Magma::<Addition>::operate(a, b)`
pub trait MagmaAdd: Magma<Addition> + Add<Self, Output = Self> + AddAssign<Self> {}

macro_rules! impl_magmaadd
(
    ($($T:ty),*) =>
    {
        $(
            impl MagmaAdd for $T
            {

            }
        )*
    }
);

impl_magmaadd!(u8, u16, u32, u64, u128, i8, i16, i32, i64, i128, f32, f64);

/// Syntactic sugar for `Magma::<Multiplication>::operate(a, b)`
pub trait MagmaMul: Magma<Multiplication> + Mul<Self, Output = Self> + MulAssign<Self> {}

macro_rules! impl_magmamul
(
    ($($T:ty),*) =>
    {
        $(
            impl MagmaMul for $T
            {

            }
        )*
    }
);

impl_magmamul!(u8, u16, u32, u64, u128, i8, i16, i32, i64, i128, f32, f64);