adic 0.5.1

Arithmetic and rootfinding for p-adic numbers
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
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107

use num::{One, Zero};
use crate::traits::AdicPrimitive;
use super::maybe_primed::{MaybePrimed, RingBacking};


impl<A, N> Zero for MaybePrimed<A, N>
where A: AdicPrimitive, N: RingBacking<A> {
    fn zero() -> Self {
        Self::unprimed(N::zero())
    }
    fn is_zero(&self) -> bool {
        match self {
            Self::Primed(a) => a.is_local_zero(),
            Self::Unprimed(n) => n.is_zero(),
        }
    }
}

impl<A, N> One for MaybePrimed<A, N>
where A: AdicPrimitive, N: RingBacking<A> {
    fn one() -> Self {
        Self::unprimed(N::one())
    }
}


impl<A, N> std::ops::Add for MaybePrimed<A, N>
where A: AdicPrimitive, N: RingBacking<A> {
    type Output = Self;
    fn add(self, rhs: Self) -> Self::Output {
        match (self, rhs) {
            (Self::Primed(a), Self::Primed(b)) => Self::Primed(a + b),
            (Self::Primed(a), Self::Unprimed(n)) => {
                let p = a.p();
                Self::Primed(a + n.primed_into(p))
            },
            (Self::Unprimed(m), Self::Primed(b)) => {
                let p = b.p();
                Self::Primed(m.primed_into(p) + b)
            },
            (Self::Unprimed(m), Self::Unprimed(n)) => Self::Unprimed(m + n),
        }
    }
}

impl<A, N> std::ops::Neg for MaybePrimed<A, N>
where A: AdicPrimitive + std::ops::Neg<Output=A>,
N: RingBacking<A> + std::ops::Neg<Output=N> {
    type Output = Self;
    fn neg(self) -> Self::Output {
        match self {
            Self::Primed(a) => Self::Primed(-a),
            Self::Unprimed(n) => Self::Unprimed(-n),
        }
    }
}

impl<A, N> std::ops::Sub for MaybePrimed<A, N>
where A: AdicPrimitive + std::ops::Sub<Output=A>,
N: RingBacking<A> + std::ops::Sub<Output=N> {
    type Output = Self;
    fn sub(self, rhs: Self) -> Self::Output {
        match (self, rhs) {
            (Self::Primed(a), Self::Primed(b)) => Self::Primed(a - b),
            (Self::Primed(a), Self::Unprimed(n)) => {
                let p = a.p();
                Self::Primed(a - n.primed_into(p))
            },
            (Self::Unprimed(m), Self::Primed(b)) => {
                let p = b.p();
                Self::Primed(m.primed_into(p) - b)
            },
            (Self::Unprimed(m), Self::Unprimed(n)) => Self::Unprimed(m - n),
        }
    }
}

impl<A, N> std::ops::Mul for MaybePrimed<A, N>
where A: AdicPrimitive, N: RingBacking<A> {
    type Output = Self;
    fn mul(self, rhs: Self) -> Self::Output {
        match (self, rhs) {
            (Self::Primed(a), Self::Primed(b)) => Self::Primed(a * b),
            (Self::Primed(a), Self::Unprimed(n)) => {
                let p = a.p();
                Self::Primed(a * n.primed_into(p))
            },
            (Self::Unprimed(m), Self::Primed(b)) => {
                let p = b.p();
                Self::Primed(m.primed_into(p) * b)
            },
            (Self::Unprimed(m), Self::Unprimed(n)) => Self::Unprimed(m * n),
        }
    }
}

impl<A, N, RHS> num::traits::Pow<RHS> for MaybePrimed<A, N>
where A: AdicPrimitive + num::traits::Pow<RHS, Output=A>,
N: RingBacking<A> + num::traits::Pow<RHS, Output=N> {
    type Output = Self;
    fn pow(self, rhs: RHS) -> Self::Output {
        match self {
            Self::Primed(a) => Self::Primed(a.pow(rhs)),
            Self::Unprimed(n) => Self::Unprimed(n.pow(rhs)),
        }
    }
}