hexga_math 0.0.11-beta.53

Math related crate that define number and casting, and support array programming...
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

use super::*;

pub trait IterIndex<T, const N: usize>
{
    type IterIndex: Iterator<Item = Vector<T, N>>;

    /// Iter over all `Point` in self.
    ///
    /// The last value is always excluded.
    ///
    /// Work on `Point`, Rect and Grid ([`Point1`], [`Point2`], [`Point3`], [`Point4`], [`Rect1`], [`Rect2`], [`Rect3`], [`Rect4`]) for ex.
    ///
    /// ```rust
    /// use hexga_math::prelude::*;
    ///
    /// let expected_points = [(0, 0), (1, 0), (0, 1), (1, 1), (0, 2), (1, 2)].map(|(x,y)| point2(x, y));
    ///
    /// for (i, expected) in point2(2, 3).iter_index().zip(expected_points.iter())
    /// {
    ///     assert_eq!(&i, expected);
    /// }
    /// ```
    fn iter_index(&self) -> Self::IterIndex;
}

/// Iterates over all N-dimensional indices in a rectangular region.
///
/// Yields every `Vector<Idx, N>` from `Vector::ZERO` up to `end`
/// (exclusive).
#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
pub struct VectorIter<Idx, const N: usize>
where
    Idx: Integer,
{
    cur: Vector<Idx, N>,
    end: Vector<Idx, N>,
}

impl<Idx, const N: usize> VectorIter<Idx, N>
where
    Idx: Integer,
{
    pub fn from_cur_to_end(cur: Vector<Idx, N>, end: Vector<Idx, N>) -> Self
    {
        Self {
            cur,
            end: if end.have_area_usize()
            {
                end
            }
            else
            {
                Vector::ZERO
            },
        }
    }

    pub fn new(end: Vector<Idx, N>) -> Self { Self::from_cur_to_end(Vector::ZERO, end) }
}

impl<Idx, const N: usize> Iterator for VectorIter<Idx, N>
where
    Idx: Integer,
{
    type Item = Vector<Idx, N>;

    fn next(&mut self) -> Option<Self::Item>
    {
        let v = self.cur;
        let mut i = 0;

        while i < N
        {
            self.cur[i].increment();
            if self.cur[i] < self.end[i]
            {
                return Some(v);
            }
            self.cur[i] = Idx::ZERO;
            i += 1;
        }

        self.cur = self.end;

        if self.end.all_zero()
        {
            None
        }
        else
        {
            self.end = zero();
            Some(v)
        }
    }

    fn size_hint(&self) -> (usize, Option<usize>)
    {
        let len = self.len();
        (len, Some(len))
    }
}
impl<Idx, const N: usize> std::iter::FusedIterator for VectorIter<Idx, N> where Idx: Integer {}
impl<Idx, const N: usize> std::iter::ExactSizeIterator for VectorIter<Idx, N>
where
    Idx: Integer,
{
    fn len(&self) -> usize
    {
        self.end.area_usize() - unsafe { Vector::<Idx, N>::to_index_unchecked(self.cur, self.end) }
    }
}

impl<Idx, const N: usize> IterIndex<Idx, N> for Vector<Idx, N>
where
    Idx: Integer,
{
    type IterIndex = VectorIter<Idx, N>;

    fn iter_index(&self) -> Self::IterIndex { Self::IterIndex::new(*self) }
}