elementwise 0.3.2

Elementwise operations implemented for standard Rust containers
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

macro_rules! impl_tuple {
    ($(($it:ident, $i:tt)),+; $ot:ident.$om:ident => $nt:ident.$nm:ident) => {
        impl<$($it),*> $nt for ($($it),*)
        where
            $($it: Copy + $ot<Output = $it>),*
        {
            fn $nm(&self, other: &($($it),*)) -> ($($it),*) {
                ($(self.$i.$om(other.$i)),*)
            }
        }
    };
    ($ot:ident.$om:ident => $nt:ident.$nm:ident) => {
        impl_tuple!((T1, 0), (T2, 1); $ot.$om => $nt.$nm);
        impl_tuple!((T1, 0), (T2, 1), (T3, 2); $ot.$om => $nt.$nm);
        impl_tuple!((T1, 0), (T2, 1), (T3, 2), (T4, 3); $ot.$om => $nt.$nm);
        impl_tuple!((T1, 0), (T2, 1), (T3, 2), (T4, 3), (T5, 4); $ot.$om => $nt.$nm);
        impl_tuple!((T1, 0), (T2, 1), (T3, 2), (T4, 3), (T5, 4), (T6, 5); $ot.$om => $nt.$nm);
        impl_tuple!((T1, 0), (T2, 1), (T3, 2), (T4, 3), (T5, 4), (T6, 5), (T7, 6);
                    $ot.$om => $nt.$nm);
        impl_tuple!((T1, 0), (T2, 1), (T3, 2), (T4, 3), (T5, 4), (T6, 5), (T7, 6), (T8, 7);
                    $ot.$om => $nt.$nm);
        impl_tuple!((T1, 0), (T2, 1), (T3, 2), (T4, 3), (T5, 4), (T6, 5), (T7, 6), (T8, 7),
                    (T9, 8); $ot.$om => $nt.$nm);
        impl_tuple!((T1, 0), (T2, 1), (T3, 2), (T4, 3), (T5, 4), (T6, 5), (T7, 6), (T8, 7),
                    (T9, 8), (T10, 9); $ot.$om => $nt.$nm);
        impl_tuple!((T1, 0), (T2, 1), (T3, 2), (T4, 3), (T5, 4), (T6, 5), (T7, 6), (T8, 7),
                    (T9, 8), (T10, 9), (T11, 10); $ot.$om => $nt.$nm);
        impl_tuple!((T1, 0), (T2, 1), (T3, 2), (T4, 3), (T5, 4), (T6, 5), (T7, 6), (T8, 7),
                    (T9, 8), (T10, 9), (T11, 10), (T12, 11); $ot.$om => $nt.$nm);
    };
}

macro_rules! impl_tuple_unary {
    ($(($it:ident, $i:tt)),+; $ot:ident.$om:ident => $nt:ident.$nm:ident) => {
        impl<$($it),*> $nt for ($($it),*)
        where
            $($it: Copy + $ot<Output = $it>),*
        {
            fn $nm(&self) -> ($($it),*) {
                ($(self.$i.$om()),*)
            }
        }
    };
    ($ot:ident.$om:ident => $nt:ident.$nm:ident) => {
        impl_tuple_unary!((T1, 0), (T2, 1); $ot.$om => $nt.$nm);
        impl_tuple_unary!((T1, 0), (T2, 1), (T3, 2); $ot.$om => $nt.$nm);
        impl_tuple_unary!((T1, 0), (T2, 1), (T3, 2), (T4, 3); $ot.$om => $nt.$nm);
        impl_tuple_unary!((T1, 0), (T2, 1), (T3, 2), (T4, 3), (T5, 4); $ot.$om => $nt.$nm);
        impl_tuple_unary!((T1, 0), (T2, 1), (T3, 2), (T4, 3), (T5, 4), (T6, 5);
                          $ot.$om => $nt.$nm);
        impl_tuple_unary!((T1, 0), (T2, 1), (T3, 2), (T4, 3), (T5, 4), (T6, 5), (T7, 6);
                          $ot.$om => $nt.$nm);
        impl_tuple_unary!((T1, 0), (T2, 1), (T3, 2), (T4, 3), (T5, 4), (T6, 5), (T7, 6), (T8, 7);
                          $ot.$om => $nt.$nm);
        impl_tuple_unary!((T1, 0), (T2, 1), (T3, 2), (T4, 3), (T5, 4), (T6, 5), (T7, 6), (T8, 7),
                          (T9, 8); $ot.$om => $nt.$nm);
        impl_tuple_unary!((T1, 0), (T2, 1), (T3, 2), (T4, 3), (T5, 4), (T6, 5), (T7, 6), (T8, 7),
                          (T9, 8), (T10, 9); $ot.$om => $nt.$nm);
        impl_tuple_unary!((T1, 0), (T2, 1), (T3, 2), (T4, 3), (T5, 4), (T6, 5), (T7, 6), (T8, 7),
                          (T9, 8), (T10, 9), (T11, 10); $ot.$om => $nt.$nm);
        impl_tuple_unary!((T1, 0), (T2, 1), (T3, 2), (T4, 3), (T5, 4), (T6, 5), (T7, 6), (T8, 7),
                          (T9, 8), (T10, 9), (T11, 10), (T12, 11); $ot.$om => $nt.$nm);
    };
}