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
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167

use itertools::Itertools;
use num::traits::Pow;
use crate::traits::{AdicPrimitive, HasApproximateDigits, HasDigits};
use super::{MAdic, PowAdic};



impl<A> std::ops::Add for PowAdic<A>
where A: AdicPrimitive + std::ops::Add<Output=A> {
    type Output = PowAdic<A>;
    fn add(self, rhs: Self) -> Self::Output {
        assert_eq!(self.power(), rhs.power(), "Only adic powers with same power can be added");
        let power = self.power();
        Self::new(self.adic + rhs.adic, power)
    }
}

impl<A> std::ops::AddAssign for PowAdic<A>
where A: AdicPrimitive + std::ops::AddAssign {
    fn add_assign(&mut self, rhs: Self) {
        assert_eq!(self.power(), rhs.power(), "Only adic powers with same power can be added");
        self.adic += rhs.adic;
    }
}


impl<A> std::ops::Neg for PowAdic<A>
where A: AdicPrimitive + std::ops::Neg<Output=A> {
    type Output = PowAdic<A>;
    fn neg(self) -> Self::Output {
        let power = self.power();
        Self::new(-self.adic, power)
    }
}


impl<A> std::ops::Sub for PowAdic<A>
where A: AdicPrimitive + std::ops::Neg<Output=A> {
    type Output = PowAdic<A>;
    fn sub(self, rhs: PowAdic<A>) -> Self::Output {
        self + (-rhs)
    }
}

impl<A> std::ops::SubAssign for PowAdic<A>
where A: AdicPrimitive + std::ops::SubAssign {
    fn sub_assign(&mut self, rhs: Self) {
        assert_eq!(self.power(), rhs.power(), "Only adic powers with same power can be added");
        self.adic -= rhs.adic;
    }
}


impl<A> std::ops::Mul for PowAdic<A>
where A: AdicPrimitive + std::ops::Mul<Output=A> {
    type Output = Self;
    fn mul(self, rhs: Self) -> Self::Output {
        assert_eq!(self.power(), rhs.power(), "Only adic powers with same power can be multiplied");
        let power = self.power();
        Self::new(self.adic * rhs.adic, power)
    }
}

impl<A> std::ops::MulAssign for PowAdic<A>
where A: AdicPrimitive + std::ops::MulAssign {
    fn mul_assign(&mut self, rhs: Self) {
        assert_eq!(self.power(), rhs.power(), "Only adic powers with same power can be multiplied");
        self.adic *= rhs.adic;
    }
}

impl<A> Pow<u32> for PowAdic<A>
where A: AdicPrimitive + Pow<u32, Output = A> {
    type Output = PowAdic<A>;
    fn pow(self, power: u32) -> Self::Output {
        let self_power = self.power();
        Self::new(self.adic.pow(power), self_power)
    }
}


// Should probably impl Inv and Div too, giving a LazyDiv.
// But need to fix LazyDiv's use of usize/isize to include Ratio, first.


impl<A> std::ops::Add for MAdic<A>
where A: HasApproximateDigits + AdicPrimitive + std::ops::Add<Output=A> {
    type Output = MAdic<A>;
    fn add(self, rhs: Self) -> Self::Output {
        assert_eq!(self.base(), rhs.base(), "Only adic composites with same base can be added");
        Self::new(
            self.pow_adics.into_values().sorted_by_key(PowAdic::p)
                .zip(rhs.pow_adics.into_values().sorted_by_key(PowAdic::p))
                .map(|(a, b)| a + b)
        )
    }
}

impl<A> std::ops::AddAssign for MAdic<A>
where A: HasApproximateDigits + AdicPrimitive + std::ops::AddAssign {
    fn add_assign(&mut self, rhs: Self) {
        assert_eq!(self.base(), rhs.base(), "Only adic composites with same base can be added");
        self.pow_adics.values_mut().sorted_by_key(|a| a.p())
            .zip(rhs.pow_adics.into_values().sorted_by_key(PowAdic::p))
            .for_each(|(a, b)| { *a += b; });
    }
}


impl<A> std::ops::Neg for MAdic<A>
where A: HasApproximateDigits + AdicPrimitive + std::ops::Neg<Output=A> {
    type Output = MAdic<A>;
    fn neg(self) -> Self::Output {
        Self::new(self.pow_adics.into_values().map(|a| -a))
    }
}


impl<A> std::ops::Sub for MAdic<A>
where A: HasApproximateDigits + AdicPrimitive + std::ops::Neg<Output=A> {
    type Output = MAdic<A>;
    fn sub(self, rhs: MAdic<A>) -> Self::Output {
        self + (-rhs)
    }
}

impl<A> std::ops::SubAssign for MAdic<A>
where A: HasApproximateDigits + AdicPrimitive + std::ops::SubAssign {
    fn sub_assign(&mut self, rhs: Self) {
        assert_eq!(self.base(), rhs.base(), "Only adic composites with same base can be added");
        self.pow_adics.values_mut().sorted_by_key(|a| a.p())
            .zip(rhs.pow_adics.into_values().sorted_by_key(PowAdic::p))
            .for_each(|(a, b)| { *a -= b; });
    }
}


impl<A> std::ops::Mul for MAdic<A>
where A: HasApproximateDigits + AdicPrimitive + std::ops::Mul<Output=A> {
    type Output = MAdic<A>;
    fn mul(self, rhs: Self) -> Self::Output {
        assert_eq!(self.base(), rhs.base(), "Only adic composites with same base can be multiplied");
        Self::new(
            self.pow_adics.into_values().sorted_by_key(PowAdic::p)
                .zip(rhs.pow_adics.into_values().sorted_by_key(PowAdic::p))
                .map(|(a, b)| a * b)
        )
    }
}

impl<A> std::ops::MulAssign for MAdic<A>
where A: HasApproximateDigits + AdicPrimitive + std::ops::MulAssign {
    fn mul_assign(&mut self, rhs: Self) {
        assert_eq!(self.base(), rhs.base(), "Only adic composites with same base can be multiplied");
        self.pow_adics.values_mut().sorted_by_key(|a| a.p())
            .zip(rhs.pow_adics.into_values().sorted_by_key(PowAdic::p))
            .for_each(|(a, b)| { *a *= b; });
    }
}

impl<A> Pow<u32> for MAdic<A>
where A: HasApproximateDigits + AdicPrimitive + Pow<u32, Output = A> {
    type Output = MAdic<A>;
    fn pow(self, power: u32) -> Self::Output {
        Self::new(self.pow_adics.into_values().map(|a| a.pow(power)))
    }
}