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

use std::ops;
use num::{
    traits::Pow,
    Integer,
};
use crate::{
    local_num::LocalZero,
    num_adic::{IAdic, IntegerVariant, RAdic},
    traits::{AdicPrimitive, PrimedFrom},
    LazyDiv, UAdic,
};
use super::EAdic;



impl std::ops::Mul<EAdic> for u32 {
    type Output=EAdic;
    fn mul(self, adic_int: EAdic) -> Self::Output {
        let p = adic_int.p();
        EAdic::primed_from(p, self) * adic_int
    }
}



impl ops::Add for EAdic {
    type Output = Self;
    fn add(self, rhs: Self) -> Self::Output {
        match ExactDoubleVariant::new(self, rhs) {
            ExactDoubleVariant::Unsigned(ua, ub) => EAdic::from(ua + ub),
            ExactDoubleVariant::Signed(ia, ib) => EAdic::from(ia + ib),
            ExactDoubleVariant::Rational(ra, rb) => EAdic::from(ra + rb),
        }
    }
}


impl ops::Neg for EAdic {
    type Output = Self;
    fn neg(self) -> Self::Output {
        match self.variant {
            IntegerVariant::Unsigned(u) => IntegerVariant::Signed(-IAdic::from(u)),
            IntegerVariant::Signed(i) => IntegerVariant::Signed(-i),
            IntegerVariant::Rational(r) => IntegerVariant::Rational(-r),
        }.into()
    }
}


impl ops::Mul for EAdic {
    type Output = Self;
    fn mul(self, rhs: Self) -> Self::Output {
        match ExactDoubleVariant::new(self, rhs) {
            ExactDoubleVariant::Unsigned(ua, ub) => EAdic::from(ua * ub),
            ExactDoubleVariant::Signed(ia, ib) => EAdic::from(ia * ib),
            ExactDoubleVariant::Rational(ra, rb) => EAdic::from(ra * rb),
        }
    }
}



impl num::traits::Inv for EAdic {
    type Output = EAdic;
    fn inv(self) -> Self::Output {
        Self::one(self.p()) / self
    }
}

impl ops::Div for EAdic {
    type Output = EAdic;
    fn div(self, rhs: Self) -> Self::Output {
        LazyDiv::new(self, rhs).int_div_exact().expect("Error during EAdic division")
    }
}

impl num::CheckedDiv for EAdic {
    fn checked_div(&self, v: &Self) -> Option<Self> {
        if v.is_local_zero() {
            return None
        }
        Some(self.clone() / v.clone())
    }
}


impl ops::Rem for EAdic {
    type Output = EAdic;
    fn rem(self, rhs: Self) -> Self::Output {
        LazyDiv::new(self, rhs).rem_exact().expect("Error during EAdic remainder")
    }
}



impl_add_assign_from_add!(EAdic);
impl_mul_assign_from_mul!(EAdic);
impl_sub_from_neg!(EAdic);
impl_sub_assign_from_sub!(EAdic);
impl_pow_by_squaring!(EAdic);



enum ExactDoubleVariant {
    Unsigned(UAdic, UAdic),
    Signed(IAdic, IAdic),
    Rational(RAdic, RAdic),
}
impl ExactDoubleVariant {
    fn new(a: EAdic, b: EAdic) -> Self {
        use IntegerVariant::{Unsigned, Signed, Rational};
        match (a.variant, b.variant) {
            (Unsigned(ua), Unsigned(ub)) => ExactDoubleVariant::Unsigned(ua, ub),
            (Unsigned(ua), Signed(ib)) => ExactDoubleVariant::Signed(IAdic::from(ua), ib),
            (Signed(ia), Unsigned(ub)) => ExactDoubleVariant::Signed(ia, IAdic::from(ub)),
            (Signed(ia), Signed(ib)) => ExactDoubleVariant::Signed(ia, ib),
            (Unsigned(ua), Rational(rb)) => ExactDoubleVariant::Rational(RAdic::from(ua), rb),
            (Signed(ia), Rational(rb)) => ExactDoubleVariant::Rational(RAdic::from(ia), rb),
            (Rational(ra), Unsigned(ub)) => ExactDoubleVariant::Rational(ra, RAdic::from(ub)),
            (Rational(ra), Signed(ib)) => ExactDoubleVariant::Rational(ra, RAdic::from(ib)),
            (Rational(ra), Rational(rb)) => ExactDoubleVariant::Rational(ra, rb),
        }
    }
}