paradis 0.2.1

Parallel processing with disjoint indices
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
136
137
138

use crate::index::{IndexList, UniqueIndexList};
use paradis_core::Bounds;

/// The result of zipping two *equal-length* index sets.
///
/// See [IndexList::index_zip](crate::index::IndexList::index_zip) for more
/// information.
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct IndexZip<A, B>(A, B);

impl<A, B> IndexZip<A, B>
where
    A: IndexList,
    B: IndexList,
{
    /// Zip two index lists.
    ///
    /// # Panics
    ///
    /// Panics if the two index lists do not have the same number of indices.
    pub fn new(a: A, b: B) -> Self {
        assert_eq!(
            a.num_indices(),
            b.num_indices(),
            "IndexZip requires the number of indices to be equal in the zipped index sets"
        );
        Self(a, b)
    }
}

// TODO: Test this impl
unsafe impl<A, B> IndexList for IndexZip<A, B>
where
    A: IndexList,
    B: IndexList,
{
    type Index = (A::Index, B::Index);

    const ALWAYS_BOUNDED: bool = A::ALWAYS_BOUNDED && B::ALWAYS_BOUNDED;

    unsafe fn get_index_unchecked(&self, loc: usize) -> Self::Index {
        unsafe {
            (
                self.0.get_index_unchecked(loc),
                self.1.get_index_unchecked(loc),
            )
        }
    }

    fn num_indices(&self) -> usize {
        debug_assert_eq!(self.0.num_indices(), self.1.num_indices());
        self.0.num_indices()
    }

    fn bounds(&self) -> Option<Bounds<Self::Index>> {
        self.0.bounds().zip(self.1.bounds()).map(|(a, b)| a.zip(b))
    }
}

unsafe impl<A, B> UniqueIndexList for IndexZip<A, B>
where
    // TODO: IndexZip would satisfy UniqueIndexList if *either* A or B
    // has unique indices. However, we are unable to
    // express this in Rust's type system as this would require specialization
    // or at least lattice impls
    // We still need a way for users to work around this though
    A: UniqueIndexList,
    B: IndexList,
{
}

/// [`IndexZip`] where uniqueness is determined by the *second* argument.
///
/// See [IndexList::index_azip](crate::index::IndexList::index_azip) for more
/// information.
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct IndexAZip<A, B>(A, B);

impl<A, B> IndexAZip<A, B>
where
    A: IndexList,
    B: IndexList,
{
    /// Zip two index lists.
    ///
    /// # Panics
    ///
    /// Panics if the two index lists do not have the same number of indices.
    pub fn new(a: A, b: B) -> Self {
        assert_eq!(
            a.num_indices(),
            b.num_indices(),
            "IndexAZip requires the number of indices to be equal in the zipped index sets"
        );
        Self(a, b)
    }
}

// TODO: Test this impl
unsafe impl<A, B> IndexList for IndexAZip<A, B>
where
    A: IndexList,
    B: IndexList,
{
    type Index = (A::Index, B::Index);

    const ALWAYS_BOUNDED: bool = A::ALWAYS_BOUNDED && B::ALWAYS_BOUNDED;

    unsafe fn get_index_unchecked(&self, loc: usize) -> Self::Index {
        unsafe {
            (
                self.0.get_index_unchecked(loc),
                self.1.get_index_unchecked(loc),
            )
        }
    }

    fn num_indices(&self) -> usize {
        debug_assert_eq!(self.0.num_indices(), self.1.num_indices());
        self.0.num_indices()
    }

    fn bounds(&self) -> Option<Bounds<Self::Index>> {
        self.0.bounds().zip(self.1.bounds()).map(|(a, b)| a.zip(b))
    }
}

unsafe impl<A, B> UniqueIndexList for IndexAZip<A, B>
where
    // TODO: IndexZip would satisfy UniqueIndexList if *either* A or B
    // has unique indices. However, we are unable to
    // express this in Rust's type system as this would require specialization
    // or at least lattice impls
    // We still need a way for users to work around this though
    A: IndexList,
    B: UniqueIndexList,
{
}