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

//! Look how roots of root varieties behave


use clap::Parser;
use adic::{
    error::AdicResult,
    normed::Valuation,
    traits::{AdicInteger, HasApproximateDigits, PrimedFrom},
    EAdic, ZAdic,
};


#[derive(Parser)]
struct Args {
    #[arg(short)]
    p: u32,
    #[arg(short, allow_hyphen_values=true)]
    a: i32,
}


fn printrrt<AI>(adic_int: &AI, n: u32, precision: usize) -> AdicResult<()>
where AI: AdicInteger + Into<ZAdic> {
    let vars = adic_int.nth_root(n, precision)?;
    if vars.is_empty() {
        println!("rt{n}({adic_int}): EMPTY");
    } else {
        println!("rt{n}({adic_int}): {}", adic_int.nth_root(n, 10)?);
    }
    Ok(())
}

fn printzrt(adic_int: &ZAdic, n: u32, precision: usize) -> AdicResult<()> {
    let vars = adic_int.nth_root(n, precision)?;
    let mut trunced_int = adic_int.clone();
    trunced_int.set_certainty(std::cmp::min(adic_int.certainty(), Valuation::Finite(10)));
    if vars.is_empty() {
        println!("rt{n}({trunced_int}): EMPTY");
    } else {
        println!("rt{n}({trunced_int}): {}", adic_int.nth_root(n, 10)?);
    }
    Ok(())
}


fn main() -> AdicResult<()> {
    let args = Args::parse();
    let a = &EAdic::primed_from(args.p, args.a);

    println!("Varieties of roots 1 to 15");

    printrrt(a, 1, 10)?;
    printrrt(a, 2, 10)?;
    printrrt(a, 3, 10)?;
    printrrt(a, 4, 10)?;
    printrrt(a, 5, 10)?;
    printrrt(a, 6, 10)?;
    printrrt(a, 7, 10)?;
    printrrt(a, 8, 10)?;
    printrrt(a, 9, 10)?;
    printrrt(a, 10, 10)?;
    printrrt(a, 11, 10)?;
    printrrt(a, 12, 10)?;
    printrrt(a, 13, 10)?;
    printrrt(a, 14, 10)?;
    printrrt(a, 15, 10)?;

    println!();
    println!("Varieties of combo roots 1 to 15");

    for var in a.nth_root(2, 70)?.roots() {
        println!("for rt2 var {var}");
        printzrt(var, 2, 10)?;
        printzrt(var, 3, 10)?;
        printzrt(var, 4, 10)?;
        printzrt(var, 5, 10)?;
        printzrt(var, 6, 10)?;
        printzrt(var, 7, 10)?;
    }

    for var in a.nth_root(3, 40)?.roots() {
        println!("for rt3 var {var}");
        printzrt(var, 2, 10)?;
        printzrt(var, 3, 10)?;
        printzrt(var, 4, 10)?;
    }

    for var in a.nth_root(4, 30)?.roots() {
        println!("for rt4 var {var}");
        printzrt(var, 2, 10)?;
        printzrt(var, 3, 10)?;
    }

    for var in a.nth_root(5, 30)?.roots() {
        println!("for rt5 var {var}");
        printzrt(var, 2, 10)?;
        printzrt(var, 3, 10)?;
    }

    for var in a.nth_root(6, 30)?.roots() {
        println!("for rt6 var {var}");
        printzrt(var, 2, 10)?;
    }

    for var in a.nth_root(7, 30)?.roots() {
        println!("for rt7 var {var}");
        printzrt(var, 2, 10)?;
    }

    Ok(())

}