1 #include <fstream>
2 #include "gtest/gtest.h"
3 #include "qpp.h"
4
5 using namespace qpp;
6
7 // Unit testing "input_output.hpp"
8
9 #if (0)
10 /******************************************************************************/
11 /// BEGIN template <typename Derived> dyn_mat<typename Derived::Scalar>
12 /// load(std::istream& is)
13 ///
14 /// template <typename Derived> void save(
15 /// const Eigen::MatrixBase<Derived>& A, std::ostream& os)
TEST(qpp_load_save,Matrix)16 TEST(qpp_load_save, Matrix) {
17 // matrices,complex, real and integer
18 // DA = 1, DB = 1 degenerate case
19 idx DA = 1, DB = 1;
20 cmat A = rand<cmat>(DA, DB), loadA;
21 dmat B = rand<dmat>(DA, DB), loadB;
22 dyn_mat<int> C = dyn_mat<int>::Random(DA, DB), loadC;
23 {
24 std::ofstream fout("mat.dat", std::ios::out | std::ios::binary);
25 save(A, fout);
26 }
27 {
28 std::ifstream fin("mat.dat", std::ios::in | std::ios::binary);
29 loadA = load<cmat>(fin);
30 }
31 EXPECT_NEAR(0, norm(loadA - A), 1e-7);
32
33 {
34 std::ofstream fout("mat.dat", std::ios::out | std::ios::binary);
35 save(B, fout);
36 }
37 {
38 std::ifstream fin("mat.dat", std::ios::in | std::ios::binary);
39 loadB = load<dmat>(fin);
40 }
41 EXPECT_NEAR(0, norm(loadB - B), 1e-7);
42
43 {
44 std::ofstream fout("mat.dat", std::ios::out | std::ios::binary);
45 save(C, fout);
46 }
47 {
48 std::ifstream fin("mat.dat", std::ios::in | std::ios::binary);
49 loadC = load<dyn_mat<int>>(fin);
50 }
51 EXPECT_NEAR(0, norm(loadC - C), 1e-7);
52
53 // DA = 1, DB = 10
54 DA = 1, DB = 10;
55 A = rand<cmat>(DA, DB);
56 B = rand<dmat>(DA, DB);
57 C = dyn_mat<int>::Random(DA, DB);
58 {
59 std::ofstream fout("mat.dat", std::ios::out | std::ios::binary);
60 save(A, fout);
61 }
62 {
63 std::ifstream fin("mat.dat", std::ios::in | std::ios::binary);
64 loadA = load<cmat>(fin);
65 }
66 EXPECT_NEAR(0, norm(loadA - A), 1e-7);
67
68 {
69 std::ofstream fout("mat.dat", std::ios::out | std::ios::binary);
70 save(B, fout);
71 }
72 {
73 std::ifstream fin("mat.dat", std::ios::in | std::ios::binary);
74 loadB = load<dmat>(fin);
75 }
76 EXPECT_NEAR(0, norm(loadB - B), 1e-7);
77
78 {
79 std::ofstream fout("mat.dat", std::ios::out | std::ios::binary);
80 save(C, fout);
81 }
82 {
83 std::ifstream fin("mat.dat", std::ios::in | std::ios::binary);
84 loadC = load<dyn_mat<int>>(fin);
85 }
86 EXPECT_NEAR(0, norm(loadC - C), 1e-7);
87
88 // DA = 32, DB = 24
89 DA = 32, DB = 24;
90 A = rand<cmat>(DA, DB);
91 B = rand<dmat>(DA, DB);
92 C = dyn_mat<int>::Random(DA, DB);
93
94 {
95 std::ofstream fout("mat.dat", std::ios::out | std::ios::binary);
96 save(A, fout);
97 }
98
99 {
100 std::ifstream fin("mat.dat", std::ios::in | std::ios::binary);
101 loadA = load<cmat>(fin);
102 }
103 EXPECT_NEAR(0, norm(loadA - A), 1e-7);
104
105 {
106 std::ofstream fout("mat.dat", std::ios::out | std::ios::binary);
107 save(B, fout);
108 }
109 {
110 std::ifstream fin("mat.dat", std::ios::in | std::ios::binary);
111 loadB = load<dmat>(fin);
112 }
113 EXPECT_NEAR(0, norm(loadB - B), 1e-7);
114
115 {
116 std::ofstream fout("mat.dat", std::ios::out | std::ios::binary);
117 save(C, fout);
118 }
119 {
120 std::ifstream fin("mat.dat", std::ios::in | std::ios::binary);
121 loadC = load<dyn_mat<int>>(fin);
122 }
123 EXPECT_NEAR(0, norm(loadC - C), 1e-7);
124
125 // expression
126 A = rand<cmat>(5, 5);
127 {
128 std::ofstream fout("mat.dat", std::ios::out | std::ios::binary);
129 save(A * A + A, fout);
130 }
131 cmat load_expression;
132 {
133 std::ifstream fin("mat.dat", std::ios::in | std::ios::binary);
134 load_expression = load<cmat>(fin);
135 }
136 EXPECT_NEAR(0, norm(load_expression - (A * A + A)), 1e-7);
137 }
138 /******************************************************************************/
TEST(qpp_load_save,Vector)139 TEST(qpp_load_save, Vector) {
140 // kets/row vectors, complex, real and integer
141
142 // D = 1 degenerate case
143 idx D = 1;
144 ket A = randket(D), loadA;
145 dyn_row_vect<double> B = dyn_row_vect<double>::Random(D), loadB;
146 dyn_row_vect<int> C = dyn_row_vect<int>::Random(D), loadC;
147
148 {
149 std::ofstream fout("mat.dat", std::ios::out | std::ios::binary);
150 save(A, fout);
151 }
152 {
153 std::ifstream fin("mat.dat", std::ios::in | std::ios::binary);
154 loadA = load<ket>(fin);
155 }
156 EXPECT_NEAR(0, norm(loadA - A), 1e-7);
157
158 {
159 std::ofstream fout("mat.dat", std::ios::out | std::ios::binary);
160 save(B, fout);
161 }
162 {
163 std::ifstream fin("mat.dat", std::ios::in | std::ios::binary);
164 loadB = load<dyn_row_vect<double>>(fin);
165 }
166 EXPECT_NEAR(0, norm(loadB - B), 1e-7);
167
168 {
169 std::ofstream fout("mat.dat", std::ios::out | std::ios::binary);
170 save(C, fout);
171 }
172 {
173 std::ifstream fin("mat.dat", std::ios::in | std::ios::binary);
174 loadC = load<dyn_row_vect<int>>(fin);
175 }
176 EXPECT_NEAR(0, norm(loadC - C), 1e-7);
177
178 // D = 32
179 D = 32;
180 A = randket(D);
181 B = dyn_row_vect<double>::Random(D);
182 C = dyn_row_vect<int>::Random(D);
183
184 {
185 std::ofstream fout("mat.dat", std::ios::out | std::ios::binary);
186 save(A, fout);
187 }
188 {
189 std::ifstream fin("mat.dat", std::ios::in | std::ios::binary);
190 loadA = load<ket>(fin);
191 }
192 EXPECT_NEAR(0, norm(loadA - A), 1e-7);
193
194 {
195 std::ofstream fout("mat.dat", std::ios::out | std::ios::binary);
196 save(B, fout);
197 }
198 {
199 std::ifstream fin("mat.dat", std::ios::in | std::ios::binary);
200 loadB = load<dyn_row_vect<double>>(fin);
201 }
202 EXPECT_NEAR(0, norm(loadB - B), 1e-7);
203
204 {
205 std::ofstream fout("mat.dat", std::ios::out | std::ios::binary);
206 save(C, fout);
207 }
208 {
209 std::ifstream fin("mat.dat", std::ios::in | std::ios::binary);
210 loadC = load<dyn_row_vect<int>>(fin);
211 }
212 EXPECT_NEAR(0, norm(loadC - C), 1e-7);
213
214 // expression
215 {
216 std::ofstream fout("mat.dat", std::ios::out | std::ios::binary);
217 save(3. * A + A, fout);
218 }
219 ket load_expression;
220 {
221 std::ifstream fin("mat.dat", std::ios::in | std::ios::binary);
222 load_expression = load<ket>(fin);
223 }
224 EXPECT_NEAR(0, norm(load_expression - (3. * A + A)), 1e-7);
225 }
226 #endif // if (0)
227
228 /******************************************************************************/
229 /// BEGIN template <typename Derived> dyn_mat<typename Derived::Scalar>
230 /// load(std::istream& is)
231 ///
232 /// template <typename Derived> void save(
233 /// const Eigen::MatrixBase<Derived>& A, std::ostream& os)
TEST(qpp_load_save,Matrix)234 TEST(qpp_load_save, Matrix) {
235 // matrices,complex, real and integer
236
237 // DA = 1, DB = 1 degenerate case
238 idx DA = 1, DB = 1;
239 cmat A = rand<cmat>(DA, DB), loadA;
240 dmat B = rand<dmat>(DA, DB), loadB;
241 dyn_mat<int> C = dyn_mat<int>::Random(DA, DB), loadC;
242 {
243 std::ofstream fout("mat.txt");
244 save(A, fout);
245 }
246 {
247 std::ifstream fin("mat.txt");
248 loadA = load<cmat>(fin);
249 }
250 EXPECT_NEAR(0, norm(loadA - A), 1e-7);
251
252 {
253 std::ofstream fout("mat.txt");
254 save(B, fout);
255 }
256 {
257 std::ifstream fin("mat.txt");
258 loadB = load<dmat>(fin);
259 }
260 EXPECT_NEAR(0, norm(loadB - B), 1e-7);
261
262 {
263 std::ofstream fout("mat.txt");
264 save(C, fout);
265 }
266 {
267 std::ifstream fin("mat.txt");
268 loadC = load<dyn_mat<int>>(fin);
269 }
270 EXPECT_NEAR(0, norm(loadC - C), 1e-7);
271
272 // DA = 1, DB = 10
273 DA = 1, DB = 10;
274 A = rand<cmat>(DA, DB);
275 B = rand<dmat>(DA, DB);
276 C = dyn_mat<int>::Random(DA, DB);
277 {
278 std::ofstream fout("mat.txt");
279 save(A, fout);
280 }
281 {
282 std::ifstream fin("mat.txt");
283 loadA = load<cmat>(fin);
284 }
285 EXPECT_NEAR(0, norm(loadA - A), 1e-7);
286
287 {
288 std::ofstream fout("mat.txt");
289 save(B, fout);
290 }
291 {
292 std::ifstream fin("mat.txt");
293 loadB = load<dmat>(fin);
294 }
295 EXPECT_NEAR(0, norm(loadB - B), 1e-7);
296
297 {
298 std::ofstream fout("mat.txt");
299 save(C, fout);
300 }
301 {
302 std::ifstream fin("mat.txt");
303 loadC = load<dyn_mat<int>>(fin);
304 }
305 EXPECT_NEAR(0, norm(loadC - C), 1e-7);
306
307 // DA = 32, DB = 24
308 DA = 32, DB = 24;
309 A = rand<cmat>(DA, DB);
310 B = rand<dmat>(DA, DB);
311 C = dyn_mat<int>::Random(DA, DB);
312
313 {
314 std::ofstream fout("mat.txt");
315 save(A, fout);
316 }
317
318 {
319 std::ifstream fin("mat.txt");
320 loadA = load<cmat>(fin);
321 }
322 EXPECT_NEAR(0, norm(loadA - A), 1e-7);
323
324 {
325 std::ofstream fout("mat.txt");
326 save(B, fout);
327 }
328 {
329 std::ifstream fin("mat.txt");
330 loadB = load<dmat>(fin);
331 }
332 EXPECT_NEAR(0, norm(loadB - B), 1e-7);
333
334 {
335 std::ofstream fout("mat.txt");
336 save(C, fout);
337 }
338 {
339 std::ifstream fin("mat.txt");
340 loadC = load<dyn_mat<int>>(fin);
341 }
342 EXPECT_NEAR(0, norm(loadC - C), 1e-7);
343
344 // expression
345 A = rand<cmat>(5, 5);
346 cmat expression = A * A + A, load_expression;
347 {
348 std::ofstream fout("mat.txt");
349 save(A * A + A, fout);
350 }
351 {
352 std::ifstream fin("mat.txt");
353 load_expression = load<cmat>(fin);
354 }
355 EXPECT_NEAR(0, norm(load_expression - expression), 1e-7);
356 }
357 /******************************************************************************/
TEST(qpp_load_save,Vector)358 TEST(qpp_load_save, Vector) {
359 // kets/row vectors, complex, real and integer
360
361 // D = 1 degenerate case
362 idx D = 1;
363 ket A = randket(D), loadA;
364 dyn_row_vect<double> B = dyn_row_vect<double>::Random(D), loadB;
365 dyn_row_vect<int> C = dyn_row_vect<int>::Random(D), loadC;
366
367 {
368 std::ofstream fout("mat.txt");
369 save(A, fout);
370 }
371 {
372 std::ifstream fin("mat.txt");
373 loadA = load<ket>(fin);
374 }
375 EXPECT_NEAR(0, norm(loadA - A), 1e-7);
376
377 {
378 std::ofstream fout("mat.txt");
379 save(B, fout);
380 }
381 {
382 std::ifstream fin("mat.txt");
383 loadB = load<dyn_row_vect<double>>(fin);
384 }
385 EXPECT_NEAR(0, norm(loadB - B), 1e-7);
386
387 {
388 std::ofstream fout("mat.txt");
389 save(C, fout);
390 }
391 {
392 std::ifstream fin("mat.txt");
393 loadC = load<dyn_row_vect<int>>(fin);
394 }
395 EXPECT_NEAR(0, norm(loadC - C), 1e-7);
396
397 // D = 32
398 D = 32;
399 A = randket(D);
400 B = dyn_row_vect<double>::Random(D);
401 C = dyn_row_vect<int>::Random(D);
402
403 {
404 std::ofstream fout("mat.txt");
405 save(A, fout);
406 }
407 {
408 std::ifstream fin("mat.txt");
409 loadA = load<ket>(fin);
410 }
411 EXPECT_NEAR(0, norm(loadA - A), 1e-7);
412
413 {
414 std::ofstream fout("mat.txt");
415 save(B, fout);
416 }
417 {
418 std::ifstream fin("mat.txt");
419 loadB = load<dyn_row_vect<double>>(fin);
420 }
421 EXPECT_NEAR(0, norm(loadB - B), 1e-7);
422
423 {
424 std::ofstream fout("mat.txt");
425 save(C, fout);
426 }
427 {
428 std::ifstream fin("mat.txt");
429 loadC = load<dyn_row_vect<int>>(fin);
430 }
431 EXPECT_NEAR(0, norm(loadC - C), 1e-7);
432
433 // expression
434 ket expression = 3. * A + A, load_expression;
435 {
436 std::ofstream fout("mat.txt");
437 save(3. * A + A, fout);
438 }
439 {
440 std::ifstream fin("mat.txt");
441 load_expression = load<ket>(fin);
442 }
443 EXPECT_NEAR(0, norm(load_expression - expression), 1e-7);
444 }
445 /******************************************************************************/
446