orx-parallel 4.0.0

Performant parallel computations with an expressive iterator API.
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

use crate::infallible_use::fun::{UMap, UMapEnum};
use crate::infallible_use::{XapUse, XapUseEnumByInput};
use crate::sizes::Many;
use core::iter::FusedIterator;

pub struct UManyM<X: XapUse<Size = Many>, G: UMap<U = X::U, I = X::O>> {
    x: X,
    g: G,
}

impl<X: XapUse<Size = Many>, G: UMap<U = X::U, I = X::O>> Clone for UManyM<X, G> {
    fn clone(&self) -> Self {
        *self
    }
}

impl<X: XapUse<Size = Many>, G: UMap<U = X::U, I = X::O>> Copy for UManyM<X, G> {}

impl<X: XapUse<Size = Many>, G: UMap<U = X::U, I = X::O>> UManyM<X, G> {
    pub fn new(x: X, g: G) -> Self {
        Self { x, g }
    }
}

impl<X: XapUseEnumByInput<Size = Many>, G: UMap<U = X::U, I = X::O>> XapUseEnumByInput
    for UManyM<X, G>
{
    type Enumerated = UManyM<X::Enumerated, UMapEnum<G>>;

    fn enumerate(self) -> Self::Enumerated {
        let g = UMapEnum::new(self.g);
        let x = self.x.enumerate();
        UManyM::new(x, g)
    }
}

impl<X: XapUse<Size = Many>, G: UMap<U = X::U, I = X::O>> XapUse for UManyM<X, G> {
    type I = X::I;

    type O = G::O;

    type Size = Many;

    type Values = UIterManyM<<X::Values as IntoIterator>::IntoIter, G>;

    type U = X::U;

    fn xap_use(&self, u: *mut Self::U, i: Self::I) -> Self::Values {
        let i = self.x.xap_use(u, i).into_iter();
        UIterManyM { u, i, g: self.g }
    }
}

// iter

pub struct UIterManyM<I, G>
where
    I: Iterator,
    G: UMap<I = I::Item>,
{
    u: *mut G::U,
    i: I,
    g: G,
}

impl<I, G> Iterator for UIterManyM<I, G>
where
    I: Iterator,
    G: UMap<I = I::Item>,
{
    type Item = G::O;

    #[inline(always)]
    fn next(&mut self) -> Option<Self::Item> {
        self.i
            .next()
            .map(|x| self.g.map(unsafe { &mut *self.u }, x))
    }

    #[inline(always)]
    fn size_hint(&self) -> (usize, Option<usize>) {
        self.i.size_hint()
    }

    #[inline]
    fn fold<B, F>(self, init: B, f: F) -> B
    where
        Self: Sized,
        F: FnMut(B, Self::Item) -> B,
    {
        self.i
            .map(|x| self.g.map(unsafe { &mut *self.u }, x))
            .fold(init, f)
    }

    #[inline]
    fn count(self) -> usize
    where
        Self: Sized,
    {
        self.i.count()
    }
}

impl<I, G> ExactSizeIterator for UIterManyM<I, G>
where
    I: ExactSizeIterator,
    G: UMap<I = I::Item>,
{
    #[inline(always)]
    fn len(&self) -> usize {
        self.i.len()
    }
}

impl<I, G> FusedIterator for UIterManyM<I, G>
where
    I: FusedIterator,
    G: UMap<I = I::Item>,
{
}

impl<I, G> DoubleEndedIterator for UIterManyM<I, G>
where
    I: DoubleEndedIterator,
    G: UMap<I = I::Item>,
{
    fn next_back(&mut self) -> Option<Self::Item> {
        self.i
            .next_back()
            .map(|x| self.g.map(unsafe { &mut *self.u }, x))
    }
}