1 //! Helper traits for tupling/untupling
2 
3 use crate::stats::Distribution;
4 
5 /// Any tuple: `(A, B, ..)`
6 pub trait Tuple: Sized {
7     /// A tuple of distributions associated with this tuple
8     type Distributions: TupledDistributions<Item = Self>;
9 
10     /// A tuple of vectors associated with this tuple
11     type Builder: TupledDistributionsBuilder<Item = Self>;
12 }
13 
14 /// A tuple of distributions: `(Distribution<A>, Distribution<B>, ..)`
15 pub trait TupledDistributions: Sized {
16     /// A tuple that can be pushed/inserted into the tupled distributions
17     type Item: Tuple<Distributions = Self>;
18 }
19 
20 /// A tuple of vecs used to build distributions.
21 pub trait TupledDistributionsBuilder: Sized {
22     /// A tuple that can be pushed/inserted into the tupled distributions
23     type Item: Tuple<Builder = Self>;
24 
25     /// Creates a new tuple of vecs
new(size: usize) -> Self26     fn new(size: usize) -> Self;
27 
28     /// Push one element into each of the vecs
push(&mut self, tuple: Self::Item)29     fn push(&mut self, tuple: Self::Item);
30 
31     /// Append one tuple of vecs to this one, leaving the vecs in the other tuple empty
extend(&mut self, other: &mut Self)32     fn extend(&mut self, other: &mut Self);
33 
34     /// Convert the tuple of vectors into a tuple of distributions
complete(self) -> <Self::Item as Tuple>::Distributions35     fn complete(self) -> <Self::Item as Tuple>::Distributions;
36 }
37 
38 impl<A> Tuple for (A,)
39 where
40     A: Copy,
41 {
42     type Distributions = (Distribution<A>,);
43     type Builder = (Vec<A>,);
44 }
45 
46 impl<A> TupledDistributions for (Distribution<A>,)
47 where
48     A: Copy,
49 {
50     type Item = (A,);
51 }
52 impl<A> TupledDistributionsBuilder for (Vec<A>,)
53 where
54     A: Copy,
55 {
56     type Item = (A,);
57 
new(size: usize) -> (Vec<A>,)58     fn new(size: usize) -> (Vec<A>,) {
59         (Vec::with_capacity(size),)
60     }
61 
push(&mut self, tuple: (A,))62     fn push(&mut self, tuple: (A,)) {
63         (self.0).push(tuple.0);
64     }
65 
extend(&mut self, other: &mut (Vec<A>,))66     fn extend(&mut self, other: &mut (Vec<A>,)) {
67         (self.0).append(&mut other.0);
68     }
69 
complete(self) -> (Distribution<A>,)70     fn complete(self) -> (Distribution<A>,) {
71         (Distribution(self.0.into_boxed_slice()),)
72     }
73 }
74 
75 impl<A, B> Tuple for (A, B)
76 where
77     A: Copy,
78     B: Copy,
79 {
80     type Distributions = (Distribution<A>, Distribution<B>);
81     type Builder = (Vec<A>, Vec<B>);
82 }
83 
84 impl<A, B> TupledDistributions for (Distribution<A>, Distribution<B>)
85 where
86     A: Copy,
87     B: Copy,
88 {
89     type Item = (A, B);
90 }
91 impl<A, B> TupledDistributionsBuilder for (Vec<A>, Vec<B>)
92 where
93     A: Copy,
94     B: Copy,
95 {
96     type Item = (A, B);
97 
new(size: usize) -> (Vec<A>, Vec<B>)98     fn new(size: usize) -> (Vec<A>, Vec<B>) {
99         (Vec::with_capacity(size), Vec::with_capacity(size))
100     }
101 
push(&mut self, tuple: (A, B))102     fn push(&mut self, tuple: (A, B)) {
103         (self.0).push(tuple.0);
104         (self.1).push(tuple.1);
105     }
106 
extend(&mut self, other: &mut (Vec<A>, Vec<B>))107     fn extend(&mut self, other: &mut (Vec<A>, Vec<B>)) {
108         (self.0).append(&mut other.0);
109         (self.1).append(&mut other.1);
110     }
111 
complete(self) -> (Distribution<A>, Distribution<B>)112     fn complete(self) -> (Distribution<A>, Distribution<B>) {
113         (
114             Distribution(self.0.into_boxed_slice()),
115             Distribution(self.1.into_boxed_slice()),
116         )
117     }
118 }
119 
120 impl<A, B, C> Tuple for (A, B, C)
121 where
122     A: Copy,
123     B: Copy,
124     C: Copy,
125 {
126     type Distributions = (Distribution<A>, Distribution<B>, Distribution<C>);
127     type Builder = (Vec<A>, Vec<B>, Vec<C>);
128 }
129 
130 impl<A, B, C> TupledDistributions for (Distribution<A>, Distribution<B>, Distribution<C>)
131 where
132     A: Copy,
133     B: Copy,
134     C: Copy,
135 {
136     type Item = (A, B, C);
137 }
138 impl<A, B, C> TupledDistributionsBuilder for (Vec<A>, Vec<B>, Vec<C>)
139 where
140     A: Copy,
141     B: Copy,
142     C: Copy,
143 {
144     type Item = (A, B, C);
145 
new(size: usize) -> (Vec<A>, Vec<B>, Vec<C>)146     fn new(size: usize) -> (Vec<A>, Vec<B>, Vec<C>) {
147         (
148             Vec::with_capacity(size),
149             Vec::with_capacity(size),
150             Vec::with_capacity(size),
151         )
152     }
153 
push(&mut self, tuple: (A, B, C))154     fn push(&mut self, tuple: (A, B, C)) {
155         (self.0).push(tuple.0);
156         (self.1).push(tuple.1);
157         (self.2).push(tuple.2);
158     }
159 
extend(&mut self, other: &mut (Vec<A>, Vec<B>, Vec<C>))160     fn extend(&mut self, other: &mut (Vec<A>, Vec<B>, Vec<C>)) {
161         (self.0).append(&mut other.0);
162         (self.1).append(&mut other.1);
163         (self.2).append(&mut other.2);
164     }
165 
complete(self) -> (Distribution<A>, Distribution<B>, Distribution<C>)166     fn complete(self) -> (Distribution<A>, Distribution<B>, Distribution<C>) {
167         (
168             Distribution(self.0.into_boxed_slice()),
169             Distribution(self.1.into_boxed_slice()),
170             Distribution(self.2.into_boxed_slice()),
171         )
172     }
173 }
174 
175 impl<A, B, C, D> Tuple for (A, B, C, D)
176 where
177     A: Copy,
178     B: Copy,
179     C: Copy,
180     D: Copy,
181 {
182     type Distributions = (
183         Distribution<A>,
184         Distribution<B>,
185         Distribution<C>,
186         Distribution<D>,
187     );
188     type Builder = (Vec<A>, Vec<B>, Vec<C>, Vec<D>);
189 }
190 
191 impl<A, B, C, D> TupledDistributions
192     for (
193         Distribution<A>,
194         Distribution<B>,
195         Distribution<C>,
196         Distribution<D>,
197     )
198 where
199     A: Copy,
200     B: Copy,
201     C: Copy,
202     D: Copy,
203 {
204     type Item = (A, B, C, D);
205 }
206 impl<A, B, C, D> TupledDistributionsBuilder for (Vec<A>, Vec<B>, Vec<C>, Vec<D>)
207 where
208     A: Copy,
209     B: Copy,
210     C: Copy,
211     D: Copy,
212 {
213     type Item = (A, B, C, D);
214 
new(size: usize) -> (Vec<A>, Vec<B>, Vec<C>, Vec<D>)215     fn new(size: usize) -> (Vec<A>, Vec<B>, Vec<C>, Vec<D>) {
216         (
217             Vec::with_capacity(size),
218             Vec::with_capacity(size),
219             Vec::with_capacity(size),
220             Vec::with_capacity(size),
221         )
222     }
223 
push(&mut self, tuple: (A, B, C, D))224     fn push(&mut self, tuple: (A, B, C, D)) {
225         (self.0).push(tuple.0);
226         (self.1).push(tuple.1);
227         (self.2).push(tuple.2);
228         (self.3).push(tuple.3);
229     }
230 
extend(&mut self, other: &mut (Vec<A>, Vec<B>, Vec<C>, Vec<D>))231     fn extend(&mut self, other: &mut (Vec<A>, Vec<B>, Vec<C>, Vec<D>)) {
232         (self.0).append(&mut other.0);
233         (self.1).append(&mut other.1);
234         (self.2).append(&mut other.2);
235         (self.3).append(&mut other.3);
236     }
237 
complete( self, ) -> ( Distribution<A>, Distribution<B>, Distribution<C>, Distribution<D>, )238     fn complete(
239         self,
240     ) -> (
241         Distribution<A>,
242         Distribution<B>,
243         Distribution<C>,
244         Distribution<D>,
245     ) {
246         (
247             Distribution(self.0.into_boxed_slice()),
248             Distribution(self.1.into_boxed_slice()),
249             Distribution(self.2.into_boxed_slice()),
250             Distribution(self.3.into_boxed_slice()),
251         )
252     }
253 }
254