1 #include <stan/math/prim.hpp>
2 #include <test/unit/util.hpp>
3 #include <gtest/gtest.h>
4 #include <vector>
5
TEST(MathMatrixPrimMat,conversions_1)6 TEST(MathMatrixPrimMat, conversions_1) {
7 using Eigen::Dynamic;
8 using Eigen::Matrix;
9 using stan::math::to_array_1d;
10 using stan::math::to_array_2d;
11 using stan::math::to_matrix;
12 using stan::math::to_row_vector;
13 using stan::math::to_vector;
14 using std::vector;
15 Matrix<double, Dynamic, Dynamic> a1(3, 2);
16 a1 << 1.1, 2.53, 3.98, 4.1, 5.1, 6.87;
17
18 Matrix<double, Dynamic, Dynamic> a2;
19
20 vector<vector<double> > b1(3, vector<double>(2));
21 b1[0][0] = 11.1;
22 b1[0][1] = 12.7;
23 b1[1][0] = 13.53;
24 b1[1][1] = 14.1;
25 b1[2][0] = 15;
26 b1[2][1] = 16.5;
27
28 vector<vector<double> > b2;
29
30 Matrix<double, Dynamic, 1> c1(3);
31 c1 << 21.0, 22.1, 23.53;
32
33 Matrix<double, Dynamic, 1> c2;
34
35 Matrix<double, 1, Dynamic> d1(3);
36 d1 << 31.3, 32.53, 33;
37
38 Matrix<double, 1, Dynamic> d2;
39
40 vector<double> e1(3);
41 e1[0] = 41.1;
42 e1[1] = 42.45;
43 e1[2] = 43.53;
44
45 vector<double> e2;
46
47 vector<vector<int> > f1(3, vector<int>(2));
48 f1[0][0] = 53;
49 f1[0][1] = 54;
50 f1[1][0] = 55;
51 f1[1][1] = 56;
52 f1[2][0] = 57;
53 f1[2][1] = 58;
54
55 vector<vector<int> > f2;
56
57 vector<int> g1(3);
58 g1[0] = 61;
59 g1[1] = 62;
60 g1[2] = 63;
61
62 vector<int> g2;
63
64 // Tests for empty containers
65 // matrix to_matrix(vector)
66 EXPECT_NO_THROW(to_matrix(a2));
67
68 // matrix to_matrix(vector)
69 EXPECT_NO_THROW(to_matrix(c2));
70
71 // matrix to_matrix(row_vector)
72 EXPECT_NO_THROW(to_matrix(d2));
73
74 // matrix to_matrix(real[, ])
75 EXPECT_NO_THROW(to_matrix(b2));
76
77 // matrix to_matrix(int[, ])
78 EXPECT_NO_THROW(to_matrix(f2));
79
80 // vector to_vector(matrix)
81 EXPECT_NO_THROW(to_vector(a2));
82
83 // vector to_vector(row_vector)
84 EXPECT_NO_THROW(to_vector(d2));
85
86 // vector to_vector(vector)
87 EXPECT_NO_THROW(to_vector(c2));
88
89 // vector to_vector(real[])
90 EXPECT_NO_THROW(to_vector(e2));
91
92 // vector to_vector(int[])
93 EXPECT_NO_THROW(to_vector(g2));
94
95 // row_vector to_row_vector(matrix)
96 EXPECT_NO_THROW(to_row_vector(a2));
97
98 // row_vector to_row_vector(vector)
99 EXPECT_NO_THROW(to_row_vector(c2));
100
101 // row_vector to_row_vector(row_vector)
102 EXPECT_NO_THROW(to_row_vector(d2));
103
104 // row_vector to_row_vector(real[])
105 EXPECT_NO_THROW(to_row_vector(e2));
106
107 // row_vector to_row_vector(int[])
108 EXPECT_NO_THROW(to_row_vector(g2));
109
110 // real[, ] to_array_2d(matrix)
111 EXPECT_NO_THROW(to_array_2d(a2));
112
113 // real[] to_array_1d(matrix)
114 EXPECT_NO_THROW(to_array_1d(a2));
115
116 // real[] to_array_1d(row_vector)
117 EXPECT_NO_THROW(to_array_1d(d2));
118
119 // real[] to_array_1d(vector)
120 EXPECT_NO_THROW(to_array_1d(c2));
121
122 // matrix to_matrix(vector)
123 a2 = to_matrix(a1);
124 EXPECT_MATRIX_FLOAT_EQ(a1, a2);
125
126 // matrix to_matrix(vector)
127 a2 = to_matrix(c1);
128 EXPECT_EQ(a2(0, 0), c1(0));
129 EXPECT_EQ(a2(1, 0), c1(1));
130 EXPECT_EQ(a2(2, 0), c1(2));
131
132 // matrix to_matrix(row_vector)
133 a2 = to_matrix(d1);
134 EXPECT_EQ(a2(0, 0), d1(0));
135 EXPECT_EQ(a2(0, 1), d1(1));
136 EXPECT_EQ(a2(0, 2), d1(2));
137
138 // matrix to_matrix(real[, ])
139 a2 = to_matrix(b1);
140
141 EXPECT_EQ(a2(0, 0), b1[0][0]);
142 EXPECT_EQ(a2(0, 1), b1[0][1]);
143 EXPECT_EQ(a2(1, 0), b1[1][0]);
144 EXPECT_EQ(a2(1, 1), b1[1][1]);
145 EXPECT_EQ(a2(2, 0), b1[2][0]);
146 EXPECT_EQ(a2(2, 1), b1[2][1]);
147
148 // matrix to_matrix(int[, ])
149 a2 = to_matrix(f1);
150
151 EXPECT_EQ(a2(0, 0), f1[0][0]);
152 EXPECT_EQ(a2(0, 1), f1[0][1]);
153 EXPECT_EQ(a2(1, 0), f1[1][0]);
154 EXPECT_EQ(a2(1, 1), f1[1][1]);
155 EXPECT_EQ(a2(2, 0), f1[2][0]);
156 EXPECT_EQ(a2(2, 1), f1[2][1]);
157
158 // vector to_vector(matrix)
159 c2 = to_vector(a1);
160 EXPECT_EQ(c2(0), a1(0, 0));
161 EXPECT_EQ(c2(1), a1(1, 0));
162 EXPECT_EQ(c2(2), a1(2, 0));
163 EXPECT_EQ(c2(3), a1(0, 1));
164 EXPECT_EQ(c2(4), a1(1, 1));
165 EXPECT_EQ(c2(5), a1(2, 1));
166
167 // vector to_vector(row_vector)
168 c2 = to_vector(d1);
169 for (int i = 0; i < 3; i++)
170 EXPECT_EQ(c2(i), d1(i));
171
172 // vector to_vector(vector)
173 c2 = to_vector(c1);
174 EXPECT_MATRIX_FLOAT_EQ(c1, c2);
175
176 // vector to_vector(real[])
177 c2 = to_vector(e1);
178
179 EXPECT_EQ(c2(0), e1[0]);
180 EXPECT_EQ(c2(1), e1[1]);
181 EXPECT_EQ(c2(2), e1[2]);
182
183 // vector to_vector(int[])
184 c2 = to_vector(g1);
185
186 EXPECT_EQ(c2(0), g1[0]);
187 EXPECT_EQ(c2(1), g1[1]);
188 EXPECT_EQ(c2(2), g1[2]);
189
190 // row_vector to_row_vector(matrix)
191 d2 = to_row_vector(a1);
192 EXPECT_EQ(d2(0), a1(0, 0));
193 EXPECT_EQ(d2(1), a1(1, 0));
194 EXPECT_EQ(d2(2), a1(2, 0));
195 EXPECT_EQ(d2(3), a1(0, 1));
196 EXPECT_EQ(d2(4), a1(1, 1));
197 EXPECT_EQ(d2(5), a1(2, 1));
198
199 // row_vector to_row_vector(vector)
200 d2 = to_row_vector(c1);
201 for (int i = 0; i < 3; i++)
202 EXPECT_EQ(d2(i), c1(i));
203
204 // row_vector to_row_vector(row_vector)
205 d2 = to_row_vector(d1);
206 EXPECT_MATRIX_FLOAT_EQ(d1, d2);
207
208 // row_vector to_row_vector(real[])
209 d2 = to_row_vector(e1);
210
211 EXPECT_EQ(d2(0), e1[0]);
212 EXPECT_EQ(d2(1), e1[1]);
213 EXPECT_EQ(d2(2), e1[2]);
214
215 // row_vector to_row_vector(int[])
216 d2 = to_row_vector(g1);
217
218 EXPECT_EQ(d2(0), g1[0]);
219 EXPECT_EQ(d2(1), g1[1]);
220 EXPECT_EQ(d2(2), g1[2]);
221
222 // real[, ] to_array_2d(matrix)
223 b2 = to_array_2d(a1);
224
225 EXPECT_EQ(a1(0, 0), b2[0][0]);
226 EXPECT_EQ(a1(0, 1), b2[0][1]);
227 EXPECT_EQ(a1(1, 0), b2[1][0]);
228 EXPECT_EQ(a1(1, 1), b2[1][1]);
229 EXPECT_EQ(a1(2, 0), b2[2][0]);
230 EXPECT_EQ(a1(2, 1), b2[2][1]);
231
232 // real[] to_array_1d(matrix)
233 e2 = to_array_1d(a1);
234
235 EXPECT_EQ(a1(0, 0), e2[0]);
236 EXPECT_EQ(a1(1, 0), e2[1]);
237 EXPECT_EQ(a1(2, 0), e2[2]);
238 EXPECT_EQ(a1(0, 1), e2[3]);
239 EXPECT_EQ(a1(1, 1), e2[4]);
240 EXPECT_EQ(a1(2, 1), e2[5]);
241
242 // real[] to_array_1d(row_vector)
243 e2 = to_array_1d(d1);
244 EXPECT_EQ(d1(0), e2[0]);
245 EXPECT_EQ(d1(1), e2[1]);
246 EXPECT_EQ(d1(2), e2[2]);
247
248 // real[] to_array_1d(vector)
249 e2 = to_array_1d(c1);
250 EXPECT_EQ(c1(0), e2[0]);
251 EXPECT_EQ(c1(1), e2[1]);
252 EXPECT_EQ(c1(2), e2[2]);
253
254 // Now we play with some lossless operations
255 EXPECT_MATRIX_FLOAT_EQ(a1, to_matrix(to_array_2d(a1)));
256 EXPECT_MATRIX_FLOAT_EQ(c1, to_vector(to_array_1d(c1)));
257 EXPECT_MATRIX_FLOAT_EQ(c1, to_vector(to_matrix(c1)));
258 EXPECT_MATRIX_FLOAT_EQ(c1, to_vector(to_row_vector(c1)));
259 EXPECT_MATRIX_FLOAT_EQ(d1, to_row_vector(to_array_1d(d1)));
260 EXPECT_MATRIX_FLOAT_EQ(d1, to_row_vector(to_matrix(d1)));
261 EXPECT_MATRIX_FLOAT_EQ(d1, to_row_vector(to_vector(d1)));
262 }
TEST(MathMatrixPrimMat,conversions_2)263 TEST(MathMatrixPrimMat, conversions_2) {
264 using Eigen::Dynamic;
265 using Eigen::Matrix;
266 using stan::math::to_array_1d;
267 using stan::math::to_array_2d;
268 using stan::math::to_matrix;
269 using stan::math::to_row_vector;
270 using stan::math::to_vector;
271 using std::vector;
272 vector<vector<vector<double> > > a1(
273 3, vector<vector<double> >(2, vector<double>(4)));
274 a1[0][0][0] = 11.341;
275 a1[0][1][0] = 12.734;
276 a1[1][0][0] = 13.5433;
277 a1[1][1][0] = 14.1124;
278 a1[2][0][0] = 15;
279 a1[2][1][0] = 16.456;
280 a1[0][0][1] = 11.5545;
281 a1[0][1][1] = 12.45437;
282 a1[1][0][1] = 13.3453;
283 a1[1][1][1] = 14.134;
284 a1[2][0][1] = 15.86;
285 a1[2][1][1] = 16.455;
286 a1[0][0][2] = 11.451;
287 a1[0][1][2] = 12.4537;
288 a1[1][0][2] = 13.53453;
289 a1[1][1][2] = 14.45431;
290 a1[2][0][2] = 15.8556;
291 a1[2][1][2] = 16.56545;
292 a1[0][0][3] = 11.6541;
293 a1[0][1][3] = 12.2237;
294 a1[1][0][3] = 13.5453;
295 a1[1][1][3] = 14.3451;
296 a1[2][0][3] = 15.7867;
297 a1[2][1][3] = 16.445;
298
299 vector<vector<vector<double> > > a2;
300
301 vector<vector<double> > b1(3, vector<double>(2));
302 b1[0][0] = 21.1;
303 b1[0][1] = 22.7;
304 b1[1][0] = 23.53;
305 b1[1][1] = 24.1;
306 b1[2][0] = 25;
307 b1[2][1] = 26.5;
308
309 vector<vector<double> > b2;
310
311 vector<double> c1(3);
312 c1[0] = 31.1;
313 c1[1] = 32.45;
314 c1[2] = 33.53;
315
316 vector<double> c2;
317
318 vector<vector<vector<int> > > d2;
319
320 vector<vector<int> > e1(3, vector<int>(2));
321 e1[0][0] = 53;
322 e1[0][1] = 54;
323 e1[1][0] = 55;
324 e1[1][1] = 56;
325 e1[2][0] = 57;
326 e1[2][1] = 58;
327
328 vector<vector<int> > e2;
329
330 vector<int> f1(3);
331 f1[0] = 61;
332 f1[1] = 62;
333 f1[2] = 63;
334
335 vector<int> f2;
336
337 EXPECT_NO_THROW(to_array_1d(a2));
338 EXPECT_NO_THROW(to_array_1d(b2));
339 EXPECT_NO_THROW(to_array_1d(c2));
340 EXPECT_NO_THROW(to_array_1d(d2));
341 EXPECT_NO_THROW(to_array_1d(e2));
342 EXPECT_NO_THROW(to_array_1d(f2));
343
344 c2 = to_array_1d(a1);
345 for (size_t i = 0, ijk = 0; i < 3; i++)
346 for (size_t j = 0; j < 2; j++)
347 for (size_t k = 0; k < 4; k++, ijk++)
348 EXPECT_EQ(a1[i][j][k], c2[ijk]);
349
350 c2 = to_array_1d(b1);
351 EXPECT_EQ(b1[0][0], c2[0]);
352 EXPECT_EQ(b1[0][1], c2[1]);
353 EXPECT_EQ(b1[1][0], c2[2]);
354 EXPECT_EQ(b1[1][1], c2[3]);
355 EXPECT_EQ(b1[2][0], c2[4]);
356 EXPECT_EQ(b1[2][1], c2[5]);
357
358 c2 = to_array_1d(c1);
359 EXPECT_EQ(c1[0], c2[0]);
360 EXPECT_EQ(c1[1], c2[1]);
361 EXPECT_EQ(c1[2], c2[2]);
362 }
363