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

use num::{rational::Ratio, Num};
use crate::error::{AdicError, AdicResult};


/// A ring that can represent a finite valuation
pub trait ValuationRing: Clone + Copy + PartialOrd + Ord + Num {

    /// Convert `usize` to `ValuationRing`
    ///
    /// # Errors
    /// Error if val conversion fails, e.g. usize -> isize
    fn try_from_usize(val: usize) -> AdicResult<Self>;
    /// Convert `ValuationRing` to `usize`
    ///
    /// # Errors
    /// Error if val conversion fails, e.g. isize -> usize
    fn try_into_usize(self) -> AdicResult<usize>;

    /// Convert `isize` to `ValuationRing`
    ///
    /// # Errors
    /// Error if val conversion fails, e.g. isize -> usize
    fn try_from_isize(val: isize) -> AdicResult<Self>;
    /// Convert `ValuationRing` to `isize`
    ///
    /// # Errors
    /// Error if val conversion fails, e.g. usize -> isize
    fn try_into_isize(self) -> AdicResult<isize>;

    /// Convert `u32` to `ValuationRing`
    ///
    /// # Errors
    /// Error if val conversion fails, e.g. u32 -> isize
    fn try_from_u32(val: u32) -> AdicResult<Self> {
        Self::try_from_usize(usize::try_from(val)?)
    }
    /// Convert `ValuationRing` to `u32`
    ///
    /// # Errors
    /// Error if val conversion fails, e.g. isize -> u32
    fn try_into_u32(self) -> AdicResult<u32> {
        Ok(self.try_into_usize()?.try_into()?)
    }

    /// Convert `i32` to `ValuationRing`
    ///
    /// # Errors
    /// Error if val conversion fails, e.g. i32 -> usize
    fn try_from_i32(val: i32) -> AdicResult<Self> {
        Self::try_from_isize(isize::try_from(val)?)
    }
    /// Convert `ValuationRing` to `i32`
    ///
    /// # Errors
    /// Error if val conversion fails, e.g. usize -> i32
    fn try_into_i32(self) -> AdicResult<u32> {
        Ok(self.try_into_isize()?.try_into()?)
    }

}
impl ValuationRing for usize {
    fn try_from_usize(val: usize) -> AdicResult<Self> {
        Ok(val)
    }
    fn try_into_usize(self) -> AdicResult<usize> {
        Ok(self)
    }
    fn try_from_isize(val: isize) -> AdicResult<Self> {
        Ok(val.try_into()?)
    }
    fn try_into_isize(self) -> AdicResult<isize> {
        Ok(self.try_into()?)
    }
}
impl ValuationRing for isize {
    fn try_from_usize(val: usize) -> AdicResult<Self> {
        Ok(val.try_into()?)
    }
    fn try_into_usize(self) -> AdicResult<usize> {
        Ok(self.try_into()?)
    }
    fn try_from_isize(val: isize) -> AdicResult<Self> {
        Ok(val)
    }
    fn try_into_isize(self) -> AdicResult<isize> {
        Ok(self)
    }
}
impl ValuationRing for Ratio<usize> {
    fn try_from_usize(val: usize) -> AdicResult<Self> {
        Ok(Ratio::from_integer(val))
    }
    fn try_into_usize(self) -> AdicResult<usize> {
        if self.is_integer() {
            Ok(self.to_integer())
        } else {
            Err(AdicError::BadConversion)
        }
    }
    fn try_from_isize(val: isize) -> AdicResult<Self> {
        Ok(Ratio::from_integer(val.try_into_usize()?))
    }
    fn try_into_isize(self) -> AdicResult<isize> {
        if self.is_integer() {
            Ok(self.to_integer().try_into_isize()?)
        } else {
            Err(AdicError::BadConversion)
        }
    }
}
impl ValuationRing for Ratio<isize> {
    fn try_from_usize(val: usize) -> AdicResult<Self> {
        Ok(Ratio::from_integer(val.try_into()?))
    }
    fn try_into_usize(self) -> AdicResult<usize> {
        if self.is_integer() {
            Ok(self.to_integer().try_into()?)
        } else {
            Err(AdicError::BadConversion)
        }
    }
    fn try_from_isize(val: isize) -> AdicResult<Self> {
        Ok(Ratio::from_integer(val))
    }
    fn try_into_isize(self) -> AdicResult<isize> {
        if self.is_integer() {
            Ok(self.to_integer())
        } else {
            Err(AdicError::BadConversion)
        }
    }
}