feanor-math 3.5.18

A library for number theory, providing implementations for arithmetic in various rings and algorithms working on them.
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

use std::marker::PhantomData;

use super::*;

#[derive(Debug)]
pub struct StepBy<V: VectorView<T>, T: ?Sized> {
    base: V,
    step_by: usize,
    element: PhantomData<T>,
}

impl<V: VectorView<T>, T: ?Sized> StepBy<V, T> {
    pub fn new(base: V, step_by: usize) -> Self {
        assert!(step_by > 0);
        Self {
            base,
            step_by,
            element: PhantomData,
        }
    }
}

impl<V: Clone + VectorView<T>, T: ?Sized> Clone for StepBy<V, T> {
    fn clone(&self) -> Self {
        Self {
            base: self.base.clone(),
            step_by: self.step_by,
            element: PhantomData,
        }
    }
}

impl<V: Copy + VectorView<T>, T: ?Sized> Copy for StepBy<V, T> {}

impl<V: VectorView<T>, T: ?Sized> VectorView<T> for StepBy<V, T> {
    fn len(&self) -> usize {
        if self.base.len() == 0 {
            0
        } else {
            (self.base.len() - 1) / self.step_by + 1
        }
    }

    fn at(&self, i: usize) -> &T { self.base.at(i * self.step_by) }
}

impl<V: VectorViewMut<T>, T: ?Sized> VectorViewMut<T> for StepBy<V, T> {
    fn at_mut(&mut self, i: usize) -> &mut T { self.base.at_mut(i * self.step_by) }
}

impl<V: SwappableVectorViewMut<T>, T: ?Sized> SwappableVectorViewMut<T> for StepBy<V, T> {
    fn swap(&mut self, i: usize, j: usize) { self.base.swap(i * self.step_by, j * self.step_by) }
}

#[derive(Debug)]
pub struct StepByFn<V: VectorFn<T>, T> {
    base: V,
    step_by: usize,
    element: PhantomData<T>,
}

impl<V: VectorFn<T>, T> StepByFn<V, T> {
    pub fn new(base: V, step_by: usize) -> Self {
        assert!(step_by > 0);
        Self {
            base,
            step_by,
            element: PhantomData,
        }
    }
}

impl<V: Clone + VectorFn<T>, T> Clone for StepByFn<V, T> {
    fn clone(&self) -> Self {
        Self {
            base: self.base.clone(),
            step_by: self.step_by,
            element: PhantomData,
        }
    }
}

impl<V: Copy + VectorFn<T>, T> Copy for StepByFn<V, T> {}

impl<V: VectorFn<T>, T> VectorFn<T> for StepByFn<V, T> {
    fn len(&self) -> usize {
        if self.base.len() == 0 {
            0
        } else {
            (self.base.len() - 1) / self.step_by + 1
        }
    }

    fn at(&self, i: usize) -> T { self.base.at(i * self.step_by) }
}

#[test]
fn test_step_by() {
    let vec = [0, 1, 2, 3, 4, 5, 6, 7];
    let zero: [i32; 0] = [];
    assert_eq!(0, zero.step_by_view(1).len());
    assert_eq!(4, vec.step_by_view(2).len());
    assert_eq!(3, vec.step_by_view(3).len());
    assert_eq!(6, *vec.step_by_view(2).at(3));
    assert_eq!(0, *vec.step_by_view(3).at(0));
    assert_eq!(3, *vec.step_by_view(3).at(1));
}

#[test]
fn test_step_by_fn() {
    let vec = [0, 1, 2, 3, 4, 5, 6, 7].into_copy_els();
    let zero: CloneElFn<[i32; 0], _, _> = [].into_copy_els();
    assert_eq!(0, zero.step_by_fn(1).len());
    assert_eq!(4, vec.step_by_fn(2).len());
    assert_eq!(3, vec.step_by_fn(3).len());
    assert_eq!(6, vec.step_by_fn(2).at(3));
    assert_eq!(0, vec.step_by_fn(3).at(0));
    assert_eq!(3, vec.step_by_fn(3).at(1));
}