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

use std::ops;
use num::{
    traits::Pow,
    Integer,
};
use crate::{
    error::validate_matching_p,
    local_num::LocalZero,
    normed::{UltraNormed, Valuation},
    traits::{AdicPrimitive, CanTruncate, HasApproximateDigits, HasDigits, PrimedFrom},
    IAdic, LazyDiv,
};
use super::ZAdic;



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



impl ops::Add for ZAdic {
    type Output = Self;
    fn add(self, rhs: Self) -> Self::Output {

        validate_matching_p([self.p(), rhs.p()]);
        let p = self.p();

        match std::cmp::min(self.c, rhs.c) {
            Valuation::PosInf => ZAdic::from(self.variant.clone() + rhs.variant.clone()),
            Valuation::Finite(c) => {
                let (ua, ub) = (self.variant.truncation(c), rhs.variant.truncation(c));
                ZAdic::new_approx(
                    p, c, ua.add(ub).digits().take(c).collect()
                )
            },
        }

    }
}


impl ops::Neg for ZAdic {
    type Output = Self;
    fn neg(self) -> Self::Output {

        let variant = match self.c {
            Valuation::PosInf => (-self.variant.clone()),
            Valuation::Finite(c) => {
                let u = self.variant.truncation(c);
                (-IAdic::from(u)).into()
            },
        };
        ZAdic{ c: self.c, variant }

    }
}


impl ops::Mul for ZAdic {
    type Output = Self;
    fn mul(self, rhs: Self) -> Self::Output {

        validate_matching_p([self.p(), rhs.p()]);

        let p = self.p();
        let ac = self.certainty();
        let av = self.valuation();
        let bc = rhs.certainty();
        let bv = rhs.valuation();

        match std::cmp::min(ac + bv, bc + av) {
            Valuation::PosInf => ZAdic::from(self.variant.clone() * rhs.variant.clone()),
            Valuation::Finite(c) => {
                let (ua, ub) = (self.variant.truncation(c), rhs.variant.truncation(c));
                ZAdic::new_approx(
                    p, c, ua.mul(ub).digits().take(c).collect()
                )
            },
        }

    }
}



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

impl ops::Div for ZAdic {
    type Output = ZAdic;
    fn div(self, rhs: Self) -> Self::Output {
        if self.is_certain() && rhs.is_certain() {
            let div = LazyDiv::new(self.variant, rhs.variant);
            div.int_div_exact().expect("Error during exact ZAdic division").into()
        } else {
            let div = LazyDiv::new(self, rhs);
            div.int_div_approx_max().expect("Error during approximate ZAdic division")
        }
    }
}

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

impl ops::Rem for ZAdic {
    type Output = ZAdic;
    fn rem(self, rhs: Self) -> Self::Output {
        if self.is_certain() && rhs.is_certain() {
            let div = LazyDiv::new(self.variant, rhs.variant);
            div.rem_exact().expect("Error during exact ZAdic remainder").into()
        } else {
            let div = LazyDiv::new(self, rhs);
            div.rem_approx_max().expect("Error during approximate ZAdic remainder")
        }
    }
}



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