amalie 0.1.2

Mathmatical library written for rust and python
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
70
71

use super::ZZ;
use std::cmp::Ordering;

impl PartialEq for ZZ {
    fn eq(&self, rhs: &Self) -> bool {
        self.v == rhs.v
    }
}
impl Eq for ZZ {}


impl PartialOrd for ZZ {
    fn partial_cmp(&self, rhs: &Self) -> Option<Ordering> {
        self.v.partial_cmp(&rhs.v)
    }
}
impl Ord for ZZ {
    fn cmp(&self, rhs: &Self) -> Ordering {
        self.v.cmp(&rhs.v)
    }
}

macro_rules! impl_compare {
    ($($type:ident),*) => {
        $(
            impl PartialEq<ZZ> for $type {
                fn eq(&self, rhs: &ZZ) -> bool {
                    &ZZ::from(*self) == rhs
                }
            }
            impl PartialEq<&ZZ> for $type {
                fn eq(&self, rhs: &&ZZ) -> bool {
                    &ZZ::from(*self) == *rhs
                }
            }
            impl PartialEq<$type> for ZZ {
                fn eq(&self, rhs: &$type) -> bool {
                     self == &ZZ::from(*rhs)
                }
            }
            impl PartialEq<$type> for &ZZ {
                fn eq(&self, rhs: &$type) -> bool {
                     self == &&ZZ::from(*rhs)
                }
            }

            impl PartialOrd<ZZ> for $type {
                fn partial_cmp(&self, rhs: &ZZ) -> Option<Ordering> {
                    ZZ::from(*self).partial_cmp(rhs)
                }
            }
            impl PartialOrd<&ZZ> for $type {
                fn partial_cmp(&self, rhs: &&ZZ) -> Option<Ordering> {
                    ZZ::from(*self).partial_cmp(*rhs)
                }
            }
            impl PartialOrd<$type> for ZZ {
                fn partial_cmp(&self, rhs: &$type) -> Option<Ordering> {
                    self.partial_cmp(&ZZ::from(*rhs))
                }
            }
            impl PartialOrd<$type> for &ZZ {
                fn partial_cmp(&self, rhs: &$type) -> Option<Ordering> {
                    (*self).partial_cmp(&ZZ::from(*rhs))
                }
            }
        )*
    }
}

impl_compare!(isize, i8, i16, i32, i64, i128, usize, u8, u16, u32, u64, u128);