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