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

//! Recurrent [`Sequences`](Sequence)

use std::iter::repeat_with;
use super::Sequence;


#[derive(Debug, Clone)]
/// Lucas [`Sequence`]
pub struct Lucas {
    initial_values: (u32, u32),
}

impl Lucas {
    /// Creates a new Lucas [`Sequence`]
    pub fn new(initial_values: (u32, u32)) -> Self {
        Self { initial_values }
    }

    /// Creates the Fibonacci [`Sequence`]
    pub fn fibonacci() -> Self {
        Self { initial_values: (0, 1) }
    }
}

impl Sequence for Lucas {
    type Term = u32;

    fn terms(&self) -> Box<dyn Iterator<Item = Self::Term> + '_> {
        let mut two_terms = self.initial_values;
        Box::new(repeat_with(move || {
            let out = two_terms.0;
            let sum = two_terms.0 + two_terms.1;
            two_terms.0 = two_terms.1;
            two_terms.1 = sum;

            out
        }))
    }

    fn approx_num_terms(&self) -> Option<usize> {
        None
    }
}

#[derive(Debug, Clone)]
/// Collatz [`Sequence`]
pub struct Collatz {
    /// Starting element for Collatz procedure
    starting_element: u32,
}

impl Collatz {
    /// Creates a new Collatz [`Sequence`] starting at the given element
    pub fn new(starting_element: u32)  -> Self {
        Self { starting_element }
    }
}

impl Sequence for Collatz {
    type Term = u32;

    fn terms(&self) -> Box<dyn Iterator<Item = Self::Term> + '_> {
        let mut last = self.starting_element;
        Box::new(std::iter::once(self.starting_element).chain(repeat_with(move || {
            last = if last.is_multiple_of(2) {
                last / 2
            } else {
                3 * last + 1
            };

            last
        })))
    }

    fn approx_num_terms(&self) -> Option<usize> {
        None
    }
}

#[derive(Debug, Clone)]
/// Thue-Morse [`Sequence`]
///
///```
/// # use adic::sequence::{factory, Sequence};
/// let t0 = factory::thue_morse(0);
/// assert_eq!(vec![0, 1, 1, 0, 1, 0, 0, 1, 1, 0], t0.truncation(10));
/// let t1 = factory::thue_morse(1);
/// assert_eq!(vec![1, 0, 0, 1, 0, 1, 1, 0, 0, 1], t1.truncation(10));
///
/// let t_added = t0.clone().term_add(t1.clone());
/// assert_eq!(vec![1, 1, 1, 1, 1, 1, 1, 1, 1, 1], t_added.truncation(10));
///
/// let t_mult = t0.clone().term_mul(t1.clone(), false);
/// assert_eq!(vec![0, 0, 0, 0, 0, 0, 0, 0, 0, 0], t_mult.truncation(10));
/// let t_mult = t0.term_mul(t1, true);
/// assert_eq!(vec![0, 0, 0, 0, 0, 0, 0, 0, 0, 0], t_mult.truncation(10));
///```
pub struct ThueMorse {
    /// Starting element for Thue-Morse sequence
    starting_element: u32,
}

impl ThueMorse {
    /// Creates a Thue-Morse [`Sequence`] given a starting element of 0 or 1
    pub fn new(starting_element: u32) -> Self {
        assert!([0, 1].contains(&starting_element), "Thue-Morse sequence starts with 0 or 1");
        Self { starting_element }
    }
}

impl Sequence for ThueMorse {
    type Term = u32;

    fn terms(&self) -> Box<dyn Iterator<Item = Self::Term> + '_> {
        // NOTE: There may be more performant ways of doing this (https://en.wikipedia.org/wiki/Thue%E2%80%93Morse_sequence)

        let starting_element = self.starting_element;

        let mut cached_sequence = vec![starting_element];

        Box::new(std::iter::once(starting_element).chain((1..).map(move |index| {
            let new_term = if index % 2 == 0 {
                cached_sequence[index/2]
            } else {
                1 - cached_sequence[index/2]
            };
            cached_sequence.push(new_term);
            new_term
        })))
    }

    fn approx_num_terms(&self) -> Option<usize> {
        None
    }
}