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

//! Error module for the [adic](crate) crate

use std::{convert::Infallible, error, fmt, num::TryFromIntError};
use num::bigint::TryFromBigIntError;


/// Result for [adic](crate) operations
pub type AdicResult<A> = Result<A, AdicError>;


#[derive(Debug, Clone, PartialEq, Eq, Hash)]
/// Error from [adic](crate) operations
pub enum AdicError {
    /// Error when an adic integer is expected but there are fractional components
    AdicIntegerExpected,
    /// Error that results when an Adic conversion fails
    BadConversion,
    /// A digit does not respect the proper base
    BadDigit,
    /// Dividing by prime in an integer context
    DivideByPrime,
    /// Divide-by-zero error
    DivideByZero,
    /// Taking sum or product of infinite series
    InfiniteOperation,
    /// Error from an ill-defined operation, e.g. 0-th root of a number
    IllDefined(String),
    /// Error that results when the requested precision cannot be acheived
    InappropriatePrecision(String),
    /// Error that involves mixing adic's with different primes
    MixedCharacteristic,
    /// No prime has been set for an adic number when necessary
    NoPrimeSet,
    /// Error propagated from [`TryFromIntError`](std::num::TryFromIntError)
    TryFromIntError,
    /// Generic severe error
    Severe(String),
}


impl fmt::Display for AdicError {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        write!(f, "{self:?}")
    }
}

impl error::Error for AdicError { }


impl From<TryFromIntError> for AdicError {
    fn from(_: TryFromIntError) -> Self {
        AdicError::TryFromIntError
    }
}

impl<BI> From<TryFromBigIntError<BI>> for AdicError {
    fn from(_: TryFromBigIntError<BI>) -> Self {
        AdicError::TryFromIntError
    }
}

impl From<Infallible> for AdicError {
    fn from(_: Infallible) -> Self {
        panic!("Infallible error; catastrophic")
    }
}