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