IT++ Logo
itfile.cpp
Go to the documentation of this file.
1
30#include <itpp/base/itfile.h>
31
32
33namespace itpp
34{
35
36char it_file_base::file_magic[4] = { 'I', 'T', '+', '+' };
38
39// ----------------------------------------------------------------------
40// it_ifile class
41// ----------------------------------------------------------------------
42
44
45it_ifile::it_ifile(const std::string &name)
46{
47 open(name);
48}
49
50void it_ifile::open(const std::string &name)
51{
52 it_assert(exist(name), "it_ifile::open(): File does not exist");
53 s.open_readonly(name, bfstream_base::l_endian);
55 s.close();
56 it_error("it_ifile::open(): Corrupt file (not an it_file)");
57 }
58}
59
61{
62 s.close();
63}
64
65bool it_ifile::seek(const std::string &name)
66{
68 std::streampos p;
69
70 s.clear();
71 s.seekg(sizeof(file_header));
72
73 while (true) {
74 p = s.tellg();
76 if (s.eof()) {
77 s.clear();
78 return false;
79 }
80 if (h.type != "" && h.name == name) {
81 s.seekg(p);
82 break;
83 }
84 s.seekg(p + static_cast<std::streamoff>(h.block_bytes));
85 }
86
87 return true;
88}
89
90bool it_ifile::seek(int n)
91{
93 std::streampos p;
94
95 s.clear();
96 s.seekg(sizeof(file_header));
97 for (int i = 0; i <= n; i++) {
98 p = s.tellg();
100 if (s.eof()) {
101 s.clear();
102 return false;
103 }
104 if (h.type == "")
105 i--;
106 s.seekg((i == n) ? p : p + static_cast<std::streamoff>(h.block_bytes));
107 }
108 return true;
109}
110
111void it_ifile::info(std::string &name, std::string &type,
112 std::string &desc, uint64_t &bytes)
113{
114 data_header h;
115 std::streampos p;
116
117 p = s.tellg();
119 s.seekg(p);
120 name = h.name;
121 type = h.type;
122 desc = h.desc;
123 bytes = h.data_bytes;
124}
125
127{
128 file_header h;
129 s.read(reinterpret_cast<char *>(&h), sizeof(h));
130 return (memcmp(h.magic, file_magic, 4) == 0
131 && (h.version == file_version));
132}
133
135{
136 s.clear();
137 s >> h.hdr_bytes;
138 s >> h.data_bytes;
139 s >> h.block_bytes;
140 s >> h.name;
141 s >> h.type;
142 s >> h.desc;
143}
144
146{
147 s >> x;
148}
149
151{
152 s >> x;
153}
154
156{
157 char tmp;
158 s >> tmp;
159 x = (tmp == 0) ? false : true;
160}
161
162
164{
165 char tmp;
166 s >> tmp;
167 x = tmp;
168}
169
171{
172 int16_t tmp;
173 s >> tmp;
174 x = tmp;
175}
176
178{
179 int32_t tmp;
180 s >> tmp;
181 x = tmp;
182}
183
185{
186 s >> x;
187}
188
190{
191 s >> x;
192}
193
194void it_ifile::low_level_read(std::complex<float> &x)
195{
196 float x_real, x_imag;
197 s >> x_real;
198 s >> x_imag;
199 x = std::complex<float>(x_real, x_imag);
200}
201
202void it_ifile::low_level_read(std::complex<double> &x)
203{
204 double x_real, x_imag;
205 s >> x_real;
206 s >> x_imag;
207 x = std::complex<double>(x_real, x_imag);
208}
209
211{
212 uint64_t size;
213 char tmp;
214 s >> size;
215 v.set_size(static_cast<int>(size), false);
216 for (int i = 0; i < v.size(); ++i) {
217 s >> tmp;
218 v(i) = tmp;
219 }
220}
221
223{
224 uint64_t size;
225 int16_t val;
226 s >> size;
227 v.set_size(static_cast<int>(size), false);
228 for (int i = 0; i < v.size(); ++i) {
229 s >> val;
230 v(i) = val;
231 }
232}
233
235{
236 uint64_t size;
237 int32_t val;
238 s >> size;
239 v.set_size(static_cast<int>(size), false);
240 for (int i = 0; i < v.size(); ++i) {
241 s >> val;
242 v(i) = val;
243 }
244}
245
247{
248 uint64_t size;
249 float val;
250 s >> size;
251 v.set_size(static_cast<int>(size), false);
252 for (int i = 0; i < v.size(); ++i) {
253 s >> val;
254 v(i) = static_cast<double>(val);
255 }
256}
257
259{
260 uint64_t size;
261 s >> size;
262 v.set_size(static_cast<int>(size), false);
263 for (int i = 0; i < v.size(); ++i)
264 s >> v(i);
265}
266
268{
269 uint64_t size;
270 float val_real, val_imag;
271 s >> size;
272 v.set_size(static_cast<int>(size), false);
273 for (int i = 0; i < v.size(); ++i) {
274 s >> val_real;
275 s >> val_imag;
276 v(i) = std::complex<double>(val_real, val_imag);
277 }
278}
279
281{
282 uint64_t size;
283 double val_real, val_imag;
284 s >> size;
285 v.set_size(static_cast<int>(size), false);
286 for (int i = 0; i < v.size(); ++i) {
287 s >> val_real;
288 s >> val_imag;
289 v(i) = std::complex<double>(val_real, val_imag);
290 }
291}
292
293void it_ifile::low_level_read(std::string &str)
294{
295 uint64_t size;
296 s >> size;
297 std::string::size_type size2 = static_cast<std::string::size_type>(size);
298 str.resize(size2);
299 for (std::string::size_type i = 0; i < size2; ++i)
300 s >> str[i];
301}
302
304{
305 uint64_t i, j;
306 char tmp;
307 s >> i >> j;
308 m.set_size(static_cast<int>(i), static_cast<int>(j), false);
309 for (int j = 0; j < m.cols(); ++j) {
310 for (int i = 0; i < m.rows(); ++i) {
311 s >> tmp;
312 m(i, j) = tmp;
313 }
314 }
315}
316
318{
319 uint64_t i, j;
320 int16_t val;
321 s >> i >> j;
322 m.set_size(static_cast<int>(i), static_cast<int>(j), false);
323 for (int j = 0; j < m.cols(); ++j)
324 for (int i = 0; i < m.rows(); ++i) {
325 s >> val;
326 m(i, j) = val;
327 }
328}
329
331{
332 uint64_t i, j;
333 int32_t val;
334 s >> i >> j;
335 m.set_size(static_cast<int>(i), static_cast<int>(j), false);
336 for (int j = 0; j < m.cols(); ++j)
337 for (int i = 0; i < m.rows(); ++i) {
338 s >> val;
339 m(i, j) = val;
340 }
341}
342
344{
345 uint64_t i, j;
346 float val;
347 s >> i >> j;
348 m.set_size(static_cast<int>(i), static_cast<int>(j), false);
349 for (int j = 0; j < m.cols(); ++j)
350 for (int i = 0; i < m.rows(); ++i) {
351 s >> val;
352 m(i, j) = static_cast<double>(val);
353 }
354}
355
357{
358 uint64_t i, j;
359 s >> i >> j;
360 m.set_size(static_cast<int>(i), static_cast<int>(j), false);
361 for (int j = 0; j < m.cols(); ++j)
362 for (int i = 0; i < m.rows(); ++i)
363 s >> m(i, j);
364}
365
367{
368 uint64_t i, j;
369 float val_real, val_imag;
370 s >> i >> j;
371 m.set_size(static_cast<int>(i), static_cast<int>(j), false);
372 for (int j = 0; j < m.cols(); ++j)
373 for (int i = 0; i < m.rows(); ++i) {
374 s >> val_real;
375 s >> val_imag;
376 m(i, j) = std::complex<double>(val_real, val_imag);
377 }
378}
379
381{
382 uint64_t i, j;
383 double val_real, val_imag;
384 s >> i >> j;
385 m.set_size(static_cast<int>(i), static_cast<int>(j), false);
386 for (int j = 0; j < m.cols(); ++j)
387 for (int i = 0; i < m.rows(); ++i) {
388 s >> val_real;
389 s >> val_imag;
390 m(i, j) = std::complex<double>(val_real, val_imag);
391 }
392}
393
395{
396 uint64_t size;
397 char tmp;
398 s >> size;
399 v.set_size(static_cast<int>(size), false);
400 for (int i = 0; i < v.size(); ++i) {
401 s >> tmp;
402 v(i) = tmp;
403 }
404}
405
407{
408 uint64_t size;
409 int16_t val;
410 s >> size;
411 v.set_size(static_cast<int>(size), false);
412 for (int i = 0; i < v.size(); ++i) {
413 s >> val;
414 v(i) = val;
415 }
416}
417
419{
420 uint64_t size;
421 int32_t val;
422 s >> size;
423 v.set_size(static_cast<int>(size), false);
424 for (int i = 0; i < v.size(); ++i) {
425 s >> val;
426 v(i) = val;
427 }
428}
429
431{
432 uint64_t size;
433 s >> size;
434 v.set_size(static_cast<int>(size), false);
435 for (int i = 0; i < v.size(); ++i)
436 s >> v(i);
437}
438
440{
441 uint64_t size;
442 float val;
443 s >> size;
444 v.set_size(static_cast<int>(size), false);
445 for (int i = 0; i < v.size(); ++i) {
446 s >> val;
447 v(i) = static_cast<double>(val);
448 }
449}
450
452{
453 uint64_t size;
454 s >> size;
455 v.set_size(static_cast<int>(size), false);
456 for (int i = 0; i < v.size(); ++i)
457 s >> v(i);
458}
459
460void it_ifile::low_level_read(Array<std::complex<float> > &v)
461{
462 uint64_t size;
463 float val_real, val_imag;
464 s >> size;
465 v.set_size(static_cast<int>(size), false);
466 for (int i = 0; i < v.size(); ++i) {
467 s >> val_real;
468 s >> val_imag;
469 v(i) = std::complex<float>(val_real, val_imag);
470 }
471}
472
473void it_ifile::low_level_read_lo(Array<std::complex<double> > &v)
474{
475 uint64_t size;
476 float val_real, val_imag;
477 s >> size;
478 v.set_size(static_cast<int>(size), false);
479 for (int i = 0; i < v.size(); ++i) {
480 s >> val_real;
481 s >> val_imag;
482 v(i) = std::complex<double>(val_real, val_imag);
483 }
484}
485
486void it_ifile::low_level_read_hi(Array<std::complex<double> > &v)
487{
488 uint64_t size;
489 double val_real, val_imag;
490 s >> size;
491 v.set_size(static_cast<int>(size), false);
492 for (int i = 0; i < v.size(); ++i) {
493 s >> val_real;
494 s >> val_imag;
495 v(i) = std::complex<double>(val_real, val_imag);
496 }
497}
498
499
500// ----------------------------------------------------------------------
501// it_file class
502// ----------------------------------------------------------------------
503
504it_file::it_file(): low_prec(false), _strings(new Strings_Holder) {}
505
506it_file::it_file(const std::string &name, bool trunc):
507 low_prec(false), _strings(new Strings_Holder)
508{
509 open(name, trunc);
510}
511
512void it_file::open(const std::string &name, bool trunc)
513{
514 if (!exist(name))
515 trunc = true;
516
517 s.open(name, trunc, bfstream_base::l_endian);
518 it_assert(s.is_open(), "it_file::open(): Could not open file for writing");
519
520 if (trunc)
522 else if (!read_check_file_header()) {
523 s.close();
524 it_error("it_file::open(): Corrupt file (not an it_file)");
525 }
526
527 fname() = name;
528}
529
531{
532 s.close();
533}
534
536{
537 s.flush();
538}
539
545
546void it_file::write_data_header(const std::string &type, uint64_t size)
547{
548 it_error_if(next_name() == "", "it_file::write_data_header(): Can not "
549 "write without a name");
551 next_name() = "";
552 next_desc() = "";
553}
554
555void it_file::write_data_header(const std::string &type,
556 const std::string &name, uint64_t size,
557 const std::string &desc)
558{
559 data_header h1, h2;
560
561 // Prepare a new data header
562 h1.hdr_bytes = 3 * sizeof(uint64_t) + type.size() + 1 + name.size() + 1
563 + desc.size() + 1;
564 h1.data_bytes = size;
565 h1.block_bytes = h1.hdr_bytes + h1.data_bytes;
566 h1.name = name;
567 h1.type = type;
568 h1.desc = desc;
569
570 // If variable exists, remove it first
571 if (exists(name))
572 remove();
573
574 // Try to find an empty space
575 s.clear();
576 s.seekg(sizeof(file_header)); // skip file header
577 while (true) {
578 // save the current position
579 std::streampos p = s.tellp();
580 // read block at the current position
582 // if empty file, stop the search and set write pointer to the end of
583 // file
584 if (s.eof()) {
585 s.clear();
586 s.seekp(0, std::ios::end);
587 break;
588 }
589 // save the size of the current read block
590 std::streamoff skip = static_cast<std::streamoff>(h2.block_bytes);
591 // check if we have enough empty space from previously deleted data
592 if ((h2.type == "") && (h2.block_bytes >= h1.block_bytes)) {
593 h1.block_bytes = h2.block_bytes;
594 s.seekp(p);
595 break;
596 }
597 // if not, maybe we can squeeze the current block to find space
598 else if ((h2.block_bytes - h2.hdr_bytes - h2.data_bytes)
599 >= h1.block_bytes) {
601 h2.block_bytes = h2.hdr_bytes + h2.data_bytes;
602 s.seekp(p);
603 // rewrite squeezed data block
605 s.seekp(p + static_cast<std::streamoff>(h2.block_bytes));
606 break;
607 }
608 // otherwise, skip the current block and try again
609 s.seekg(p + skip);
610 } // while(true)
611
613}
614
616{
617 s << h.hdr_bytes << h.data_bytes << h.block_bytes
618 << h.name << h.type << h.desc;
619}
620
621void it_file::remove(const std::string &name)
622{
623 seek(name);
624 remove();
625}
626
628{
629 data_header h;
630 std::streampos p;
631
632 p = s.tellp();
634 h.type = "";
635 h.name = "";
636 h.desc = "";
637 h.hdr_bytes = 3 * sizeof(uint64_t) + 1 + 1 + 1;
638 h.data_bytes = 0;
639 s.seekp(p);
641 s.seekp(p + static_cast<std::streamoff>(h.block_bytes));
642}
643
644bool it_file::exists(const std::string &name)
645{
646 return seek(name);
647}
648
650{
651 it_assert(s.is_open(), "it_file::pack(): File has to be open");
652
653 // check total file size
654 s.seekg(0, std::ios::end);
655 std::streampos p = s.tellg();
656 s.seekg(0, std::ios::beg);
657 s.clear();
658
659 // allocate buffer of size equal to file size
660 char* buffer = new char[int(p)];
661 char* b_ptr = buffer;
662
663 // copy file header and start counting the size of compacted file
664 uint64_t size;
665 for (size = 0; size < sizeof(file_header); ++size)
666 s.get(*b_ptr++);
667
668 // remove empty space between data blocks
669 data_header h;
670 while (true) {
671 p = s.tellg();
673 if (s.eof()) {
674 s.clear();
675 break;
676 }
677 if (h.type != "") {
678 s.seekg(p);
679 for (uint64_t i = 0; i < h.hdr_bytes + h.data_bytes; ++i)
680 s.get(*b_ptr++);
681 size += h.hdr_bytes + h.data_bytes;
682 }
683 s.seekg(p + static_cast<std::streamoff>(h.block_bytes));
684 }
685
686 // close and reopen file truncating it
687 s.close();
688 s.open(fname(), true, bfstream_base::l_endian);
689 // write compacted data to the reopend empty file
690 for (uint64_t i = 0; i < size; ++i)
691 s.put(buffer[i]);
692
693 // free buffer memory
694 delete buffer;
695
696 // go back to the first data block (skiping file header)
697 s.seekg(sizeof(file_header));
698
699 // update block_bytes in headers of compacted data blocks
700 while (true) {
701 p = s.tellg();
703 if (s.eof()) {
704 s.clear();
705 break;
706 }
707 if (h.hdr_bytes + h.data_bytes < h.block_bytes) {
709 s.seekp(p);
711 }
712 s.seekg(p + static_cast<std::streamoff>(h.block_bytes));
713 }
714}
715
717{
718 s << x;
719}
720
722{
723 s << x;
724}
725
730
732{
733 s << x.value();
734}
735
740
745
747{
748 s << x;
749}
750
752{
753 s << x;
754}
755
756void it_file::low_level_write(const std::complex<float> &x)
757{
758 s << x.real();
759 s << x.imag();
760}
761
762void it_file::low_level_write(const std::complex<double> &x)
763{
764 s << x.real();
765 s << x.imag();
766}
767
768void it_file::low_level_write(const bvec &v)
769{
771 for (int i = 0; i < v.size(); ++i)
772 s << v(i).value();
773}
774
775void it_file::low_level_write(const svec &v)
776{
778 for (int i = 0; i < v.size(); ++i)
779 s << static_cast<int16_t>(v(i));
780}
781
782void it_file::low_level_write(const ivec &v)
783{
785 for (int i = 0; i < v.size(); ++i)
786 s << static_cast<int32_t>(v(i));
787}
788
789void it_file::low_level_write(const vec &v)
790{
792 if (get_low_precision()) {
793 for (int i = 0; i < v.size(); ++i)
794 s << static_cast<float>(v(i));
795 }
796 else {
797 for (int i = 0; i < v.size(); ++i)
798 s << v(i);
799 }
800}
801
802void it_file::low_level_write(const cvec &v)
803{
805 if (get_low_precision()) {
806 for (int i = 0; i < v.size(); ++i) {
809 }
810 }
811 else {
812 for (int i = 0; i < v.size(); ++i) {
813 s << v(i).real();
814 s << v(i).imag();
815 }
816 }
817}
818
819void it_file::low_level_write(const std::string &str)
820{
821 s << static_cast<uint64_t>(str.size());
822 for (std::string::size_type i = 0; i < str.size(); ++i)
823 s << str[i];
824}
825
827{
829 << static_cast<uint64_t>(m.cols());
830 for (int j = 0; j < m.cols(); ++j)
831 for (int i = 0; i < m.rows(); ++i)
832 s << m(i, j).value();
833}
834
835void it_file::low_level_write(const smat &m)
836{
838 << static_cast<uint64_t>(m.cols());
839 for (int j = 0; j < m.cols(); ++j)
840 for (int i = 0; i < m.rows(); ++i)
841 s << static_cast<int16_t>(m(i, j));
842}
843
844void it_file::low_level_write(const imat &m)
845{
847 << static_cast<uint64_t>(m.cols());
848 for (int j = 0; j < m.cols(); ++j)
849 for (int i = 0; i < m.rows(); ++i)
850 s << static_cast<int32_t>(m(i, j));
851}
852
853void it_file::low_level_write(const mat &m)
854{
856 << static_cast<uint64_t>(m.cols());
857 if (get_low_precision()) {
858 for (int j = 0; j < m.cols(); ++j)
859 for (int i = 0; i < m.rows(); ++i)
860 s << static_cast<float>(m(i, j));
861 }
862 else {
863 for (int j = 0; j < m.cols(); ++j)
864 for (int i = 0; i < m.rows(); ++i)
865 s << m(i, j);
866 }
867}
868
869void it_file::low_level_write(const cmat &m)
870{
872 << static_cast<uint64_t>(m.cols());
873 if (get_low_precision()) {
874 for (int j = 0; j < m.cols(); ++j)
875 for (int i = 0; i < m.rows(); ++i) {
876 s << static_cast<float>(m(i, j).real());
877 s << static_cast<float>(m(i, j).imag());
878 }
879 }
880 else {
881 for (int j = 0; j < m.cols(); ++j)
882 for (int i = 0; i < m.rows(); ++i) {
883 s << m(i, j).real();
884 s << m(i, j).imag();
885 }
886 }
887}
888
890{
892 for (int i = 0; i < v.size(); ++i)
893 s << v(i).value();
894}
895
897{
899 for (int i = 0; i < v.size(); ++i)
900 s << static_cast<int16_t>(v(i));
901}
902
904{
906 for (int i = 0; i < v.size(); ++i)
907 s << static_cast<int32_t>(v(i));
908}
909
911{
913 for (int i = 0; i < v.size(); ++i)
914 s << v(i);
915}
916
918{
920 if (get_low_precision()) {
921 for (int i = 0; i < v.size(); ++i)
922 s << static_cast<float>(v(i));
923 }
924 else {
925 for (int i = 0; i < v.size(); ++i)
926 s << static_cast<double>(v(i));
927 }
928}
929
930void it_file::low_level_write(const Array<std::complex<float> > &v)
931{
933 for (int i = 0; i < v.size(); ++i) {
934 s << v(i).real();
935 s << v(i).imag();
936 }
937}
938
939void it_file::low_level_write(const Array<std::complex<double> > &v)
940{
942 if (get_low_precision()) {
943 for (int i = 0; i < v.size(); ++i) {
946 }
947 }
948 else {
949 for (int i = 0; i < v.size(); ++i) {
950 s << v(i).real();
951 s << v(i).imag();
952 }
953 }
954}
955
956
958{
960 f.read_data_header(h);
961 it_assert(h.type == "int8", "it_ifile::operator>>(): Wrong type");
962 f.low_level_read(x);
963 return f;
964}
965
967{
969 f.read_data_header(h);
970 it_assert(h.type == "bool", "it_ifile::operator>>(): Wrong type");
971 f.low_level_read(x);
972 return f;
973}
974
976{
978 f.read_data_header(h);
979 it_assert(h.type == "bin", "it_ifile::operator>>(): Wrong type");
980 f.low_level_read(x);
981 return f;
982}
983
985{
987 f.read_data_header(h);
988 it_assert(h.type == "int16", "it_ifile::operator>>(): Wrong type");
989 f.low_level_read(x);
990 return f;
991}
992
994{
996 f.read_data_header(h);
997 if (h.type == "int32")
998 f.low_level_read(x);
999 else if (h.type == "int16") {
1000 short x16;
1001 f.low_level_read(x16);
1002 x = static_cast<int>(x16);
1003 }
1004 else
1005 it_error("it_ifile::operator>>(): Wrong type");
1006
1007 return f;
1008}
1009
1011{
1013 f.read_data_header(h);
1014 it_assert(h.type == "float32", "it_ifile::operator>>(): Wrong type");
1015 f.low_level_read(x);
1016 return f;
1017}
1018
1020{
1022 f.read_data_header(h);
1023 if (h.type == "float64")
1024 f.low_level_read(x);
1025 else if (h.type == "float32") {
1026 float f32;
1027 f.low_level_read(f32);
1028 x = static_cast<double>(f32);
1029 }
1030 else
1031 it_error("it_ifile::operator>>(): Wrong type");
1032
1033 return f;
1034}
1035
1036it_ifile &operator>>(it_ifile &f, std::complex<float> &x)
1037{
1039 f.read_data_header(h);
1040 it_assert(h.type == "cfloat32",
1041 "it_ifile::operator>>(): Wrong type");
1042 f.low_level_read(x);
1043 return f;
1044}
1045
1046it_ifile &operator>>(it_ifile &f, std::complex<double> &x)
1047{
1049 f.read_data_header(h);
1050 if (h.type == "cfloat64")
1051 f.low_level_read(x);
1052 else if (h.type == "cfloat32") {
1053 std::complex<float> f32_c;
1054 f.low_level_read(f32_c);
1055 x = static_cast<std::complex<double> >(f32_c);
1056 }
1057 else
1058 it_error("it_ifile::operator>>(): Wrong type");
1059
1060 return f;
1061}
1062
1064{
1066 f.read_data_header(h);
1067 it_assert(h.type == "bvec", "it_ifile::operator>>(): Wrong type");
1068 f.low_level_read(v);
1069 return f;
1070}
1071
1073{
1075 f.read_data_header(h);
1076 it_assert(h.type == "svec", "it_ifile::operator>>(): Wrong type");
1077 f.low_level_read(v);
1078 return f;
1079}
1080
1082{
1084 f.read_data_header(h);
1085 it_assert(h.type == "ivec", "it_ifile::operator>>(): Wrong type");
1086 f.low_level_read(v);
1087 return f;
1088}
1089
1091{
1093
1094 f.read_data_header(h);
1095 if (h.type == "fvec")
1096 f.low_level_read_lo(v);
1097 else if (h.type == "dvec")
1098 f.low_level_read_hi(v);
1099 else
1100 it_error("it_ifile::operator>>(): Wrong type");
1101
1102 return f;
1103}
1104
1106{
1108
1109 f.read_data_header(h);
1110 if (h.type == "fcvec")
1111 f.low_level_read_lo(v);
1112 else if (h.type == "dcvec")
1113 f.low_level_read_hi(v);
1114 else
1115 it_error("it_ifile::operator>>(): Wrong type");
1116
1117 return f;
1118}
1119
1120it_ifile &operator>>(it_ifile &f, std::string &str)
1121{
1123 f.read_data_header(h);
1124 it_assert(h.type == "string", "it_ifile::operator>>(): Wrong type");
1125 f.low_level_read(str);
1126 return f;
1127}
1128
1130{
1132 f.read_data_header(h);
1133 it_assert(h.type == "bmat", "it_ifile::operator>>(): Wrong type");
1134 f.low_level_read(m);
1135 return f;
1136}
1137
1139{
1141 f.read_data_header(h);
1142 it_assert(h.type == "smat", "it_ifile::operator>>(): Wrong type");
1143 f.low_level_read(m);
1144 return f;
1145}
1146
1148{
1150 f.read_data_header(h);
1151 it_assert(h.type == "imat", "it_ifile::operator>>(): Wrong type");
1152 f.low_level_read(m);
1153 return f;
1154}
1155
1157{
1159
1160 f.read_data_header(h);
1161 if (h.type == "fmat")
1162 f.low_level_read_lo(m);
1163 else if (h.type == "dmat")
1164 f.low_level_read_hi(m);
1165 else
1166 it_error("it_ifile::operator>>(): Wrong type");
1167
1168 return f;
1169}
1170
1172{
1174 f.read_data_header(h);
1175 if (h.type == "fcmat")
1176 f.low_level_read_lo(m);
1177 else if (h.type == "dcmat")
1178 f.low_level_read_hi(m);
1179 else
1180 it_error("it_ifile::operator>>(): Wrong type");
1181
1182 return f;
1183}
1184
1186{
1188 f.read_data_header(h);
1189 it_assert(h.type == "bArray", "it_ifile::operator>>(): Wrong type");
1190 f.low_level_read(v);
1191 return f;
1192}
1193
1195{
1197 f.read_data_header(h);
1198 it_assert(h.type == "sArray", "it_ifile::operator>>(): Wrong type");
1199 f.low_level_read(v);
1200 return f;
1201}
1202
1204{
1206 f.read_data_header(h);
1207 it_assert(h.type == "iArray", "it_ifile::operator>>(): Wrong type");
1208 f.low_level_read(v);
1209 return f;
1210}
1211
1213{
1215 f.read_data_header(h);
1216 it_assert(h.type == "fArray", "it_ifile::operator>>(): Wrong type");
1217 f.low_level_read(v);
1218 return f;
1219}
1220
1222{
1224 f.read_data_header(h);
1225 if (h.type == "fArray")
1226 f.low_level_read_lo(v);
1227 else if (h.type == "dArray")
1228 f.low_level_read_hi(v);
1229 else
1230 it_error("it_ifile::operator>>(): Wrong type");
1231
1232 return f;
1233}
1234
1235it_ifile &operator>>(it_ifile &f, Array<std::complex<float> > &v)
1236{
1238 f.read_data_header(h);
1239 it_assert(h.type == "fcArray", "it_ifile::operator>>(): Wrong type");
1240 f.low_level_read(v);
1241 return f;
1242}
1243
1244it_ifile &operator>>(it_ifile &f, Array<std::complex<double> > &v)
1245{
1247 f.read_data_header(h);
1248 if (h.type == "fcArray")
1249 f.low_level_read_lo(v);
1250 else if (h.type == "dcArray")
1251 f.low_level_read_hi(v);
1252 else
1253 it_error("it_ifile::operator>>(): Wrong type");
1254
1255 return f;
1256}
1257
1259{
1261 f.read_data_header(h);
1262 it_assert(h.type == "bvecArray", "it_ifile::operator>>(): Wrong type");
1263 uint64_t n;
1264 f.low_level_read(n);
1265 int size = static_cast<int>(n);
1266 v.set_size(size, false);
1267 for (int i = 0; i < size; ++i)
1268 f.low_level_read(v(i));
1269
1270 return f;
1271}
1272
1274{
1276 f.read_data_header(h);
1277 it_assert(h.type == "svecArray", "it_ifile::operator>>(): Wrong type");
1278 uint64_t n;
1279 f.low_level_read(n);
1280 int size = static_cast<int>(n);
1281 v.set_size(size, false);
1282 for (int i = 0; i < size; ++i)
1283 f.low_level_read(v(i));
1284
1285 return f;
1286}
1287
1289{
1291 f.read_data_header(h);
1292 it_assert(h.type == "ivecArray", "it_ifile::operator>>(): Wrong type");
1293 uint64_t n;
1294 f.low_level_read(n);
1295 int size = static_cast<int>(n);
1296 v.set_size(size, false);
1297 for (int i = 0; i < size; ++i)
1298 f.low_level_read(v(i));
1299
1300 return f;
1301}
1302
1304{
1306 f.read_data_header(h);
1307 it_assert(h.type == "vecArray", "it_ifile::operator>>(): Wrong type");
1308 uint64_t n;
1309 f.low_level_read(n);
1310 int size = static_cast<int>(n);
1311 v.set_size(size, false);
1312 for (int i = 0; i < size; ++i)
1313 f.low_level_read_hi(v(i));
1314
1315 return f;
1316}
1317
1319{
1321 f.read_data_header(h);
1322 it_assert(h.type == "cvecArray", "it_ifile::operator>>(): Wrong type");
1323 uint64_t n;
1324 f.low_level_read(n);
1325 int size = static_cast<int>(n);
1326 v.set_size(size, false);
1327 for (int i = 0; i < size; ++i)
1328 f.low_level_read_hi(v(i));
1329
1330 return f;
1331}
1332
1334{
1336 f.read_data_header(h);
1337 it_assert(h.type == "stringArray", "it_ifile::operator>>(): Wrong type");
1338 uint64_t n;
1339 f.low_level_read(n);
1340 int size = static_cast<int>(n);
1341 v.set_size(size, false);
1342 for (int i = 0; i < size; ++i)
1343 f.low_level_read(v(i));
1344
1345 return f;
1346}
1347
1349{
1351 f.read_data_header(h);
1352 it_assert(h.type == "bmatArray", "it_ifile::operator>>(): Wrong type");
1353 uint64_t n;
1354 f.low_level_read(n);
1355 int size = static_cast<int>(n);
1356 v.set_size(size, false);
1357 for (int i = 0; i < size; ++i)
1358 f.low_level_read(v(i));
1359
1360 return f;
1361}
1362
1364{
1366 f.read_data_header(h);
1367 it_assert(h.type == "smatArray", "it_ifile::operator>>(): Wrong type");
1368 uint64_t n;
1369 f.low_level_read(n);
1370 int size = static_cast<int>(n);
1371 v.set_size(size, false);
1372 for (int i = 0; i < size; ++i)
1373 f.low_level_read(v(i));
1374
1375 return f;
1376}
1377
1379{
1381 f.read_data_header(h);
1382 it_assert(h.type == "imatArray", "it_ifile::operator>>(): Wrong type");
1383 uint64_t n;
1384 f.low_level_read(n);
1385 int size = static_cast<int>(n);
1386 v.set_size(size, false);
1387 for (int i = 0; i < size; ++i)
1388 f.low_level_read(v(i));
1389
1390 return f;
1391}
1392
1394{
1396 f.read_data_header(h);
1397 it_assert(h.type == "matArray", "it_ifile::operator>>(): Wrong type");
1398 uint64_t n;
1399 f.low_level_read(n);
1400 int size = static_cast<int>(n);
1401 v.set_size(size, false);
1402 for (int i = 0; i < size; ++i)
1403 f.low_level_read_hi(v(i));
1404
1405 return f;
1406}
1407
1409{
1411 f.read_data_header(h);
1412 it_assert(h.type == "cmatArray", "it_ifile::operator>>(): Wrong type");
1413 uint64_t n;
1414 f.low_level_read(n);
1415 int size = static_cast<int>(n);
1416 v.set_size(size, false);
1417 for (int i = 0; i < size; ++i)
1418 f.low_level_read_hi(v(i));
1419
1420 return f;
1421}
1422
1423
1425{
1426 f.write_data_header("int8", sizeof(char));
1427 f.low_level_write(x);
1428 return f;
1429}
1430
1432{
1433 f.write_data_header("bool", sizeof(char));
1434 f.low_level_write(x);
1435 return f;
1436}
1437
1439{
1440 f.write_data_header("bin", sizeof(char));
1441 f.low_level_write(x);
1442 return f;
1443}
1444
1446{
1447 f.write_data_header("int16", sizeof(int16_t));
1448 f.low_level_write(x);
1449 return f;
1450}
1451
1453{
1454 f.write_data_header("int32", sizeof(int32_t));
1455 f.low_level_write(x);
1456 return f;
1457}
1458
1460{
1461 f.write_data_header("float32", sizeof(float));
1462 f.low_level_write(x);
1463 return f;
1464}
1465
1467{
1468 f.write_data_header("float64", sizeof(double));
1469 f.low_level_write(x);
1470 return f;
1471}
1472
1473it_file &operator<<(it_file &f, std::complex<float> x)
1474{
1475 f.write_data_header("cfloat32", 2 * sizeof(float));
1476 f.low_level_write(x);
1477 return f;
1478}
1479
1480it_file &operator<<(it_file &f, std::complex<double> x)
1481{
1482 f.write_data_header("cfloat64", 2 * sizeof(double));
1483 f.low_level_write(x);
1484 return f;
1485}
1486
1487it_file &operator<<(it_file &f, const bvec &v)
1488{
1489 f.write_data_header("bvec", sizeof(uint64_t) + v.size() * sizeof(char));
1490 f.low_level_write(v);
1491 return f;
1492}
1493
1494it_file &operator<<(it_file &f, const svec &v)
1495{
1496 f.write_data_header("svec", sizeof(uint64_t) + v.size() * sizeof(int16_t));
1497 f.low_level_write(v);
1498 return f;
1499}
1500
1501it_file &operator<<(it_file &f, const ivec &v)
1502{
1503 f.write_data_header("ivec", sizeof(uint64_t) + v.size() * sizeof(int32_t));
1504 f.low_level_write(v);
1505 return f;
1506}
1507
1508it_file &operator<<(it_file &f, const vec &v)
1509{
1510 if (f.get_low_precision())
1511 f.write_data_header("fvec", sizeof(uint64_t)
1512 + v.size() * sizeof(float));
1513 else
1514 f.write_data_header("dvec", sizeof(uint64_t)
1515 + v.size() * sizeof(double));
1516 f.low_level_write(v);
1517 return f;
1518}
1519
1520it_file &operator<<(it_file &f, const cvec &v)
1521{
1522 if (f.get_low_precision())
1523 f.write_data_header("fcvec", sizeof(uint64_t)
1524 + v.size() * 2 * sizeof(float));
1525 else
1526 f.write_data_header("dcvec", sizeof(uint64_t)
1527 + v.size() * 2 * sizeof(double));
1528 f.low_level_write(v);
1529 return f;
1530}
1531
1532it_file &operator<<(it_file &f, const std::string &str)
1533{
1534 f.write_data_header("string", sizeof(uint64_t) + str.size() * sizeof(char));
1535 f.low_level_write(str);
1536 return f;
1537}
1538
1540{
1541 f.write_data_header("bmat", 2 * sizeof(uint64_t)
1542 + m.rows() * m.cols() * sizeof(char));
1543 f.low_level_write(m);
1544 return f;
1545}
1546
1547it_file &operator<<(it_file &f, const smat &m)
1548{
1549 f.write_data_header("smat", 2 * sizeof(uint64_t)
1550 + m.rows() * m.cols() * sizeof(int16_t));
1551 f.low_level_write(m);
1552 return f;
1553}
1554
1555it_file &operator<<(it_file &f, const imat &m)
1556{
1557 f.write_data_header("imat", 2 * sizeof(uint64_t)
1558 + m.rows() * m.cols() * sizeof(int32_t));
1559 f.low_level_write(m);
1560 return f;
1561}
1562
1563it_file &operator<<(it_file &f, const mat &m)
1564{
1565 if (f.get_low_precision())
1566 f.write_data_header("fmat", 2 * sizeof(uint64_t)
1567 + m.rows() * m.cols() * sizeof(float));
1568 else
1569 f.write_data_header("dmat", 2 * sizeof(uint64_t)
1570 + m.rows() * m.cols() * sizeof(double));
1571 f.low_level_write(m);
1572 return f;
1573}
1574
1575it_file &operator<<(it_file &f, const cmat &m)
1576{
1577 if (f.get_low_precision())
1578 f.write_data_header("fcmat", 2 * sizeof(uint64_t)
1579 + m.rows() * m.cols() * 2 * sizeof(float));
1580 else
1581 f.write_data_header("dcmat", 2 * sizeof(uint64_t)
1582 + m.rows() * m.cols() * 2 * sizeof(double));
1583 f.low_level_write(m);
1584 return f;
1585}
1586
1588{
1589 f.write_data_header("bArray", sizeof(uint64_t) + v.size() * sizeof(char));
1590 f.low_level_write(v);
1591 return f;
1592}
1593
1595{
1596 f.write_data_header("sArray", sizeof(uint64_t)
1597 + v.size() * sizeof(int16_t));
1598 f.low_level_write(v);
1599 return f;
1600}
1601
1603{
1604 f.write_data_header("iArray", sizeof(uint64_t)
1605 + v.size() * sizeof(int32_t));
1606 f.low_level_write(v);
1607 return f;
1608}
1609
1611{
1612 f.write_data_header("fArray", sizeof(uint64_t) + v.size() * sizeof(float));
1613 f.low_level_write(v);
1614 return f;
1615}
1616
1618{
1619 if (f.get_low_precision())
1620 f.write_data_header("fArray", sizeof(uint64_t)
1621 + v.size() * sizeof(float));
1622 else
1623 f.write_data_header("dArray", sizeof(uint64_t)
1624 + v.size() * sizeof(double));
1625 f.low_level_write(v);
1626 return f;
1627}
1628
1629it_file &operator<<(it_file &f, const Array<std::complex<float> > &v)
1630{
1631 f.write_data_header("fcArray", sizeof(uint64_t)
1632 + v.size() * 2 * sizeof(float));
1633 f.low_level_write(v);
1634 return f;
1635}
1636
1637it_file &operator<<(it_file &f, const Array<std::complex<double> > &v)
1638{
1639 if (f.get_low_precision())
1640 f.write_data_header("fcArray", sizeof(uint64_t)
1641 + v.size() * 2 * sizeof(float));
1642 else
1643 f.write_data_header("dcArray", sizeof(uint64_t)
1644 + v.size() * 2 * sizeof(double));
1645 f.low_level_write(v);
1646 return f;
1647}
1648
1650{
1651 // calculate total length of Array
1652 int sum_l = 0;
1653 for (int i = 0; i < v.size(); ++i)
1654 sum_l += v(i).size();
1655
1656 // write header
1657 f.write_data_header("bvecArray", sizeof(uint64_t) * (1 + v.size())
1658 + sum_l * sizeof(char));
1659 // write the length of the array
1660 f.low_level_write(static_cast<uint64_t>(v.size()));
1661
1662 // write one vector at a time (i.e. size and elements)
1663 for (int i = 0; i < v.size(); ++i)
1664 f.low_level_write(v(i));
1665
1666 return f;
1667}
1668
1670{
1671 // calculate total length of Array
1672 int sum_l = 0;
1673 for (int i = 0; i < v.size(); ++i)
1674 sum_l += v(i).size();
1675
1676 // write header
1677 f.write_data_header("svecArray", sizeof(uint64_t) * (1 + v.size())
1678 + sum_l * sizeof(int16_t));
1679 // write the length of the array
1680 f.low_level_write(static_cast<uint64_t>(v.size()));
1681
1682 // write one vector at a time (i.e. size and elements)
1683 for (int i = 0; i < v.size(); ++i)
1684 f.low_level_write(v(i));
1685
1686 return f;
1687}
1688
1690{
1691 // calculate total length of Array
1692 int sum_l = 0;
1693 for (int i = 0; i < v.size(); ++i)
1694 sum_l += v(i).size();
1695
1696 // write header
1697 f.write_data_header("ivecArray", sizeof(uint64_t) * (1 + v.size())
1698 + sum_l * sizeof(int32_t));
1699 // write the length of the array
1700 f.low_level_write(static_cast<uint64_t>(v.size()));
1701
1702 // write one vector at a time (i.e. size and elements)
1703 for (int i = 0; i < v.size(); ++i)
1704 f.low_level_write(v(i));
1705
1706 return f;
1707}
1708
1710{
1711 // calculate total length of Array
1712 int sum_l = 0;
1713 for (int i = 0; i < v.size(); ++i)
1714 sum_l += v(i).size();
1715
1716 // write header
1717 f.write_data_header("vecArray", sizeof(uint64_t) * (1 + v.size())
1718 + sum_l * sizeof(double));
1719 // write the length of the array
1720 f.low_level_write(static_cast<uint64_t>(v.size()));
1721
1722 // write one vector at a time (i.e. size and elements)
1723 for (int i = 0; i < v.size(); ++i)
1724 f.low_level_write(v(i));
1725
1726 return f;
1727}
1728
1730{
1731 // calculate total length of Array
1732 int sum_l = 0;
1733 for (int i = 0; i < v.size(); ++i)
1734 sum_l += v(i).size();
1735
1736 // write header
1737 f.write_data_header("cvecArray", sizeof(uint64_t) * (1 + v.size())
1738 + sum_l * 2 * sizeof(double));
1739 // write the length of the array
1740 f.low_level_write(static_cast<uint64_t>(v.size()));
1741
1742 // write one vector at a time (i.e. size and elements)
1743 for (int i = 0; i < v.size(); ++i)
1744 f.low_level_write(v(i));
1745
1746 return f;
1747}
1748
1750{
1751 // calculate total length of Array
1752 int sum_l = 0;
1753 for (int i = 0; i < v.size(); ++i)
1754 sum_l += int(v(i).size());
1755
1756 // write header
1757 f.write_data_header("stringArray", sizeof(uint64_t) * (1 + v.size())
1758 + sum_l * sizeof(char));
1759 // write the length of the array
1760 f.low_level_write(static_cast<uint64_t>(v.size()));
1761
1762 // write one vector at a time (i.e. size and elements)
1763 for (int i = 0; i < v.size(); ++i)
1764 f.low_level_write(v(i));
1765
1766 return f;
1767}
1768
1770{
1771 // calculate total length of Array
1772 int sum_l = 0;
1773 for (int i = 0; i < v.size(); ++i)
1774 sum_l += v(i)._datasize();
1775
1776 // write header
1777 f.write_data_header("bmatArray", sizeof(uint64_t) * (1 + 2 * v.size())
1778 + sum_l * sizeof(char));
1779 // write the length of the array
1780 f.low_level_write(static_cast<uint64_t>(v.size()));
1781
1782 // write one vector at a time (i.e. size and elements)
1783 for (int i = 0; i < v.size(); ++i)
1784 f.low_level_write(v(i));
1785
1786 return f;
1787}
1788
1790{
1791 // calculate total length of Array
1792 int sum_l = 0;
1793 for (int i = 0; i < v.size(); ++i)
1794 sum_l += v(i)._datasize();
1795
1796 // write header
1797 f.write_data_header("smatArray", sizeof(uint64_t) * (1 + 2 * v.size())
1798 + sum_l * sizeof(int16_t));
1799 // write the length of the array
1800 f.low_level_write(static_cast<uint64_t>(v.size()));
1801
1802 // write one vector at a time (i.e. size and elements)
1803 for (int i = 0; i < v.size(); ++i)
1804 f.low_level_write(v(i));
1805
1806 return f;
1807}
1808
1810{
1811 // calculate total length of Array
1812 int sum_l = 0;
1813 for (int i = 0; i < v.size(); ++i)
1814 sum_l += v(i)._datasize();
1815
1816 // write header
1817 f.write_data_header("imatArray", sizeof(uint64_t) * (1 + 2 * v.size())
1818 + sum_l * sizeof(int32_t));
1819 // write the length of the array
1820 f.low_level_write(static_cast<uint64_t>(v.size()));
1821
1822 // write one vector at a time (i.e. size and elements)
1823 for (int i = 0; i < v.size(); ++i)
1824 f.low_level_write(v(i));
1825
1826 return f;
1827}
1828
1830{
1831 // calculate total length of Array
1832 int sum_l = 0;
1833 for (int i = 0; i < v.size(); ++i)
1834 sum_l += v(i)._datasize();
1835
1836 // write header
1837 f.write_data_header("matArray", sizeof(uint64_t) * (1 + 2 * v.size())
1838 + sum_l * sizeof(double));
1839 // write the length of the array
1840 f.low_level_write(static_cast<uint64_t>(v.size()));
1841
1842 // write one vector at a time (i.e. size and elements)
1843 for (int i = 0; i < v.size(); ++i)
1844 f.low_level_write(v(i));
1845
1846 return f;
1847}
1848
1850{
1851 // calculate total length of Array
1852 int sum_l = 0;
1853 for (int i = 0; i < v.size(); ++i)
1854 sum_l += v(i)._datasize();
1855
1856 // write header
1857 f.write_data_header("cmatArray", sizeof(uint64_t) * (1 + 2 * v.size())
1858 + sum_l * 2 * sizeof(double));
1859 // write the length of the array
1860 f.low_level_write(static_cast<uint64_t>(v.size()));
1861
1862 // write one vector at a time (i.e. size and elements)
1863 for (int i = 0; i < v.size(); ++i)
1864 f.low_level_write(v(i));
1865
1866 return f;
1867}
1868
1869
1870
1871// ----------------------------------------------------------------------
1872// Deprecated implementation of IT++ file format version 2
1873// Will be removed in future versions
1874// ----------------------------------------------------------------------
1875
1876char it_file_base_old::file_magic[4] = { 'I', 'T', '+', '+' };
1878
1882
1883it_ifile_old::it_ifile_old(const std::string &name)
1884{
1885 open(name);
1886}
1887
1888void it_ifile_old::open(const std::string &name)
1889{
1890 it_assert(exist(name), "File does not exist");
1891
1892 s.open_readonly(name);
1893
1894 if (!read_check_file_header()) {
1895 s.close();
1896 it_error("Corrupt file (Not an it-file)");
1897 }
1898
1899}
1900
1902{
1903 s.close();
1904}
1905
1906bool it_ifile_old::seek(const std::string &name)
1907{
1908 data_header h;
1909 std::streampos p;
1910
1911 s.clear();
1912 s.seekg(sizeof(file_header));
1913
1914 while (true) {
1915 p = s.tellg();
1917 if (s.eof()) {
1918 s.clear();
1919 return false;
1920 }
1921 if (h.type != "" && h.name == name) {
1922 s.seekg(p);
1923 break;
1924 }
1925 s.seekg(p + static_cast<std::streamoff>(h.block_bytes));
1926 }
1927
1928 return true;
1929}
1930
1932{
1933 data_header h;
1934 std::streampos p;
1935
1936 s.clear();
1937 s.seekg(sizeof(file_header));
1938 for (int i = 0; i <= n; i++) {
1939 p = s.tellg(); // changed from tellp() since probably an error
1941 if (s.eof()) {
1942 s.clear();
1943 return false;
1944 }
1945 if (h.type == "")
1946 i--;
1947 s.seekg(i == n ? p : p + static_cast<std::streamoff>(h.block_bytes));
1948 }
1949 return true;
1950}
1951
1952void it_ifile_old::info(std::string &name, std::string &type, int &bytes)
1953{
1954 data_header h;
1955 std::streampos p;
1956
1957 p = s.tellg(); // changed from tellp()
1959 s.seekg(p);
1960 name = h.name;
1961 type = h.type;
1962 bytes = h.data_bytes;
1963}
1964
1966{
1967 file_header h;
1968
1969 memset(&h, 0, sizeof(h)); // Clear the struct
1970 s.read(reinterpret_cast<char *>(&h), sizeof(h));
1971
1972 return (memcmp(h.magic, file_magic, 4) == 0 && (h.version <= file_version));
1973}
1974
1976{
1977 std::streampos p = s.tellg();
1978 s.clear();
1979 s >> h.endianity;
1980 if (s.eof())
1981 return;
1983 uint32_t tmp;
1984 s >> tmp;
1985 h.hdr_bytes = tmp;
1986 s >> tmp;
1987 h.data_bytes = tmp;
1988 s >> tmp;
1989 h.block_bytes = tmp;
1990 s >> h.name;
1991 s >> h.type;
1992 s.seekg(p + static_cast<std::streamoff>(h.hdr_bytes));
1993}
1994
1996{
1997 s >> x;
1998}
1999
2001{
2002 s >> x;
2003}
2004
2006{
2007 s >> x;
2008}
2009
2011{
2012 int32_t tmp;
2013 s >> tmp;
2014 x = tmp;
2015}
2016
2018{
2019 s >> x;
2020}
2021
2023{
2024 s >> x;
2025}
2026
2027void it_ifile_old::low_level_read(std::complex<float> &x)
2028{
2029 float x_real, x_imag;
2030 s >> x_real;
2031 s >> x_imag;
2032 x = std::complex<float>(x_real, x_imag);
2033}
2034
2035void it_ifile_old::low_level_read(std::complex<double> &x)
2036{
2037 double x_real, x_imag;
2038 s >> x_real;
2039 s >> x_imag;
2040 x = std::complex<double>(x_real, x_imag);
2041}
2042
2044{
2045 int32_t i;
2046 float val;
2047
2048 s >> i;
2049 v.set_size(i, false);
2050 for (i = 0; i < v.size(); i++) {
2051 s >> val;
2052 v(i) = static_cast<double>(val);
2053 }
2054}
2055
2057{
2058 int32_t i;
2059 double val;
2060
2061 s >> i;
2062 v.set_size(i, false);
2063 for (i = 0; i < v.size(); i++) {
2064 s >> val;
2065 v(i) = static_cast<double>(val);
2066 }
2067}
2068
2070{
2071 int32_t i, val;
2072
2073 s >> i;
2074 v.set_size(i, false);
2075 for (i = 0; i < v.size(); i++) {
2076 s >> val;
2077 v(i) = val;
2078 }
2079}
2080
2082{
2083 int32_t i;
2084
2085 s >> i;
2086 v.set_size(i, false);
2087 for (i = 0; i < v.size(); i++)
2088 s >> v(i);
2089}
2090
2092{
2093 int32_t i;
2094 float val_real, val_imag;
2095
2096 s >> i;
2097 v.set_size(i, false);
2098 for (i = 0; i < v.size(); i++) {
2099 s >> val_real;
2100 s >> val_imag;
2101 v(i) = std::complex<double>(val_real, val_imag);
2102 }
2103}
2104
2106{
2107 int32_t i;
2108 double val_real, val_imag;
2109
2110 s >> i;
2111 v.set_size(i, false);
2112 for (i = 0; i < v.size(); i++) {
2113 s >> val_real;
2114 s >> val_imag;
2115 v(i) = std::complex<double>(val_real, val_imag);
2116 }
2117}
2118
2119void it_ifile_old::low_level_read(std::string &str)
2120{
2121 int32_t i, j;
2122 char val;
2123 str = "";
2124
2125 s >> i;
2126
2127 for (j = 0; j < i; j++) {
2128 s >> val;
2129 str += val;
2130 }
2131}
2132
2134{
2135 int32_t i, j;
2136 float val;
2137
2138 s >> i >> j;
2139 m.set_size(i, j, false);
2140 for (j = 0; j < m.cols(); j++)
2141 for (i = 0; i < m.rows(); i++) {
2142 s >> val;
2143 m(i, j) = static_cast<double>(val);
2144 }
2145}
2146
2148{
2149 int32_t i, j;
2150 double val;
2151
2152 s >> i >> j;
2153 m.set_size(i, j, false);
2154 for (j = 0; j < m.cols(); j++)
2155 for (i = 0; i < m.rows(); i++) {
2156 s >> val;
2157 m(i, j) = static_cast<double>(val);
2158 }
2159}
2160
2162{
2163 int32_t i, j, val;
2164
2165 s >> i >> j;
2166 m.set_size(i, j, false);
2167 for (j = 0; j < m.cols(); j++)
2168 for (i = 0; i < m.rows(); i++) {
2169 s >> val;
2170 m(i, j) = val;
2171 }
2172}
2173
2175{
2176 int32_t i, j;
2177
2178 s >> i >> j;
2179 m.set_size(i, j, false);
2180 for (j = 0; j < m.cols(); j++)
2181 for (i = 0; i < m.rows(); i++)
2182 s >> m(i, j);
2183}
2184
2186{
2187 int32_t i, j;
2188 float val_real, val_imag;
2189
2190 s >> i >> j;
2191 m.set_size(i, j, false);
2192 for (j = 0; j < m.cols(); j++)
2193 for (i = 0; i < m.rows(); i++) {
2194 s >> val_real;
2195 s >> val_imag;
2196 m(i, j) = std::complex<double>(val_real, val_imag);
2197 }
2198}
2199
2201{
2202 int32_t i, j;
2203 double val_real, val_imag;
2204
2205 s >> i >> j;
2206 m.set_size(i, j, false);
2207 for (j = 0; j < m.cols(); j++)
2208 for (i = 0; i < m.rows(); i++) {
2209 s >> val_real;
2210 s >> val_imag;
2211 m(i, j) = std::complex<double>(val_real, val_imag);
2212 }
2213}
2214
2215
2217{
2218 int32_t i;
2219 float val;
2220
2221 s >> i;
2222 v.set_size(i, false);
2223 for (i = 0; i < v.size(); i++) {
2224 s >> val;
2225 v(i) = val;
2226 }
2227}
2228
2230{
2231 int32_t i;
2232 float val;
2233
2234 s >> i;
2235 v.set_size(i, false);
2236 for (i = 0; i < v.size(); i++) {
2237 s >> val;
2238 v(i) = static_cast<double>(val);
2239 }
2240}
2241
2243{
2244 int32_t i;
2245 double val;
2246
2247 s >> i;
2248 v.set_size(i, false);
2249 for (i = 0; i < v.size(); i++) {
2250 s >> val;
2251 v(i) = static_cast<double>(val);
2252 }
2253}
2254
2256{
2257 int32_t i, val;
2258
2259 s >> i;
2260 v.set_size(i, false);
2261 for (i = 0; i < v.size(); i++) {
2262 s >> val;
2263 v(i) = val;
2264 }
2265}
2266
2268{
2269 int32_t i;
2270
2271 s >> i;
2272 v.set_size(i, false);
2273 for (i = 0; i < v.size(); i++)
2274 s >> v(i);
2275}
2276
2277void it_ifile_old::low_level_read_lo(Array<std::complex<float> > &v)
2278{
2279 int32_t i;
2280 float val_real, val_imag;
2281
2282 s >> i;
2283 v.set_size(i, false);
2284 for (i = 0; i < v.size(); i++) {
2285 s >> val_real;
2286 s >> val_imag;
2287 v(i) = std::complex<float>(val_real, val_imag);
2288 }
2289}
2290
2291void it_ifile_old::low_level_read_lo(Array<std::complex<double> > &v)
2292{
2293 int32_t i;
2294 float val_real, val_imag;
2295
2296 s >> i;
2297 v.set_size(i, false);
2298 for (i = 0; i < v.size(); i++) {
2299 s >> val_real;
2300 s >> val_imag;
2301 v(i) = std::complex<double>(val_real, val_imag);
2302 }
2303}
2304
2305void it_ifile_old::low_level_read_hi(Array<std::complex<double> > &v)
2306{
2307 int32_t i;
2308 double val_real, val_imag;
2309
2310 s >> i;
2311 v.set_size(i, false);
2312 for (i = 0; i < v.size(); i++) {
2313 s >> val_real;
2314 s >> val_imag;
2315 v(i) = std::complex<double>(val_real, val_imag);
2316 }
2317}
2318
2319it_file_old::it_file_old():_string(new String_Holder())
2320{
2321 low_prec = false;
2322}
2323
2324it_file_old::it_file_old(const std::string &name, bool trunc):
2325_string(new String_Holder())
2326{
2327 low_prec = false;
2328 open(name, trunc);
2329}
2330
2331void it_file_old::open(const std::string &name, bool trunc)
2332{
2333 if (!exist(name))
2334 trunc = true;
2335
2336 s.open(name, trunc);
2337 it_error_if(!s.is_open(), "Could not open file for writing");
2338
2339 if (trunc)
2341 else if (!read_check_file_header()) {
2342 s.close();
2343 it_error("Corrupt file (Not an it-file)");
2344 }
2345}
2346
2348{
2349 s.close();
2350}
2351
2353{
2354 s.flush();
2355}
2356
2358{
2359 s.write(file_magic, 4);
2360 s << file_version;
2361}
2362
2363void it_file_old::write_data_header(const std::string &type, uint32_t size)
2364{
2365 it_error_if(next_name() == "", "Try to write without a name");
2367 next_name() = "";
2368}
2369
2370void it_file_old::write_data_header(const std::string &type,
2371 const std::string &name, uint32_t size)
2372{
2373 data_header h1, h2;
2374 std::streampos p;
2375 int availpos = 0;
2376 bool removed = false;
2377 int skip;
2378
2379 h1.endianity = static_cast<char>(s.get_native_endianity());
2380 h1.hdr_bytes = 1 + 3 * 4 + int(type.size()) + 1 + int(name.size()) + 1;
2381 h1.data_bytes = size;
2382 h1.block_bytes = h1.hdr_bytes + h1.data_bytes;
2383 h1.name = name;
2384 h1.type = type;
2385
2386 if (exists(name))
2387 remove();
2388
2389 // Try to find an empty space
2390 s.clear();
2391 s.seekg(sizeof(file_header));
2392 while (true) {
2393 p = s.tellp();
2394 read_data_header(h2);
2395 if (s.eof()) {
2396 s.clear();
2397 break;
2398 }
2399 skip = h2.block_bytes;
2400 if (h2.type != "" && h2.name == name) {
2401 s.seekg(p);
2402 remove();
2403 s.seekg(p);
2404 read_data_header(h2);
2405 removed = true;
2406 if (availpos != 0)
2407 break;
2408 }
2409 if (availpos == 0) {
2410 if (h2.type == "" && h2.block_bytes >= h1.block_bytes) {
2411 h1.block_bytes = h2.block_bytes;
2412 availpos = int(p);
2413 }
2414 else if (h2.block_bytes - h2.hdr_bytes - h2.data_bytes >= h1.block_bytes) {
2415 h1.block_bytes = h2.block_bytes - h2.hdr_bytes - h2.data_bytes;
2416 h2.block_bytes = h2.hdr_bytes + h2.data_bytes;
2417 s.seekp(p);
2419 availpos = static_cast<int>(p) + h2.block_bytes;
2420 if (removed)
2421 break;
2422 }
2423 }
2424 s.seekg(p + static_cast<std::streamoff>(skip));
2425 }
2426 if (availpos != 0)
2427 s.seekp(availpos);
2428 else
2429 s.seekp(0, std::ios::end);
2430
2432}
2433
2435{
2437 s << h.endianity << h.hdr_bytes << h.data_bytes << h.block_bytes << h.name << h.type;
2438}
2439
2440void it_file_old::remove(const std::string &name)
2441{
2442 seek(name);
2443 remove();
2444}
2445
2447{
2448 data_header h;
2449 std::streampos p;
2450
2451 p = s.tellp();
2453 h.type = "";
2454 h.name = "";
2455 h.hdr_bytes = 1 + 3 * 4 + 1 + 1;
2456 h.data_bytes = 0;
2457 s.seekp(p);
2459 s.seekp(p + static_cast<std::streamoff>(h.block_bytes));
2460}
2461
2462bool it_file_old::exists(const std::string &name)
2463{
2464 if (seek(name))
2465 return true;
2466 else
2467 return false;
2468}
2469
2471{
2472 it_warning("pack() is not implemented!");
2473}
2474
2476{
2477 s << x;
2478}
2479
2481{
2482 s << x.value();
2483}
2484
2486{
2487 s << x;
2488}
2489
2494
2496{
2497 s << x;
2498}
2499
2501{
2502 s << x;
2503}
2504
2505void it_file_old::low_level_write(const std::complex<float> &x)
2506{
2507 s << x.real();
2508 s << x.imag();
2509}
2510
2511void it_file_old::low_level_write(const std::complex<double> &x)
2512{
2513 s << x.real();
2514 s << x.imag();
2515}
2516
2518{
2519 if (get_low_precision()) {
2520 s << static_cast<int32_t>(v.size());
2521 for (int i = 0; i < v.size(); i++)
2522 s << static_cast<float>(v(i));
2523 }
2524 else {
2525 s << static_cast<int32_t>(v.size());
2526 for (int i = 0; i < v.size(); i++)
2527 s << static_cast<double>(v(i));
2528 }
2529}
2530
2532{
2533 s << static_cast<int32_t>(v.size());
2534 for (int i = 0; i < v.size(); i++)
2535 s << static_cast<int32_t>(v(i));
2536}
2537
2539{
2540 s << static_cast<int32_t>(v.size());
2541 for (int i = 0; i < v.size(); i++)
2542 s << v(i).value();
2543}
2544
2546{
2547 if (get_low_precision()) {
2548 s << static_cast<int32_t>(v.size());
2549 for (int i = 0; i < v.size(); i++) {
2552 }
2553 }
2554 else {
2555 s << static_cast<int32_t>(v.size());
2556 for (int i = 0; i < v.size(); i++) {
2559 }
2560 }
2561}
2562
2563void it_file_old::low_level_write(const std::string &str)
2564{
2565 int size = int(str.size());
2567
2568 for (int i = 0; i < size; i++)
2569 s << str[i];
2570}
2571
2573{
2574 int i, j;
2575
2576 if (get_low_precision()) {
2577 s << static_cast<int32_t>(m.rows()) << static_cast<int32_t>(m.cols());
2578 for (j = 0; j < m.cols(); j++)
2579 for (i = 0; i < m.rows(); i++)
2580 s << static_cast<float>(m(i, j));
2581 }
2582 else {
2583 s << static_cast<int32_t>(m.rows()) << static_cast<int32_t>(m.cols());
2584 for (j = 0; j < m.cols(); j++)
2585 for (i = 0; i < m.rows(); i++)
2586 s << static_cast<double>(m(i, j));
2587 }
2588}
2589
2591{
2592 int i, j;
2593
2594 s << static_cast<int32_t>(m.rows()) << static_cast<int32_t>(m.cols());
2595 for (j = 0; j < m.cols(); j++)
2596 for (i = 0; i < m.rows(); i++)
2597 s << static_cast<int32_t>(m(i, j));
2598}
2599
2601{
2602 int i, j;
2603
2604 s << static_cast<int32_t>(m.rows()) << static_cast<int32_t>(m.cols());
2605 for (j = 0; j < m.cols(); j++)
2606 for (i = 0; i < m.rows(); i++)
2607 s << m(i, j).value();
2608}
2609
2611{
2612 int i, j;
2613
2614 if (get_low_precision()) {
2615 s << static_cast<int32_t>(m.rows()) << static_cast<int32_t>(m.cols());
2616 for (j = 0; j < m.cols(); j++)
2617 for (i = 0; i < m.rows(); i++) {
2618 s << static_cast<float>(m(i, j).real());
2619 s << static_cast<float>(m(i, j).imag());
2620 }
2621
2622 }
2623 else {
2624 s << static_cast<int32_t>(m.rows()) << static_cast<int32_t>(m.cols());
2625 for (j = 0; j < m.cols(); j++)
2626 for (i = 0; i < m.rows(); i++) {
2627 s << static_cast<double>(m(i, j).real());
2628 s << static_cast<double>(m(i, j).imag());
2629 }
2630 }
2631}
2632
2634{
2636 for (int i = 0; i < v.size(); i++)
2637 s << v(i);
2638}
2639
2641{
2642 if (get_low_precision()) {
2644 for (int i = 0; i < v.size(); i++)
2645 s << static_cast<float>(v(i));
2646 }
2647 else {
2649 for (int i = 0; i < v.size(); i++)
2650 s << static_cast<double>(v(i));
2651 }
2652}
2653
2655{
2657 for (int i = 0; i < v.size(); i++)
2658 s << static_cast<int32_t>(v(i));
2659}
2660
2662{
2664 for (int i = 0; i < v.size(); i++)
2665 s << v(i).value();
2666}
2667
2668void it_file_old::low_level_write(const Array<std::complex<float> > &v)
2669{
2670 s << static_cast<int32_t>(v.size());
2671 for (int i = 0; i < v.size(); i++) {
2672 s << v(i).real();
2673 s << v(i).imag();
2674 }
2675}
2676
2677void it_file_old::low_level_write(const Array<std::complex<double> > &v)
2678{
2679 if (get_low_precision()) {
2680 s << static_cast<int32_t>(v.size());
2681 for (int i = 0; i < v.size(); i++) {
2684 }
2685 }
2686 else {
2687 s << static_cast<int32_t>(v.size());
2688 for (int i = 0; i < v.size(); i++) {
2691 }
2692 }
2693}
2694
2696{
2698
2699 f.read_data_header(h);
2700 if (h.type == "int8")
2701 f.low_level_read(x);
2702 else
2703 it_error("Wrong type");
2704
2705 return f;
2706}
2707
2709{
2711
2712 f.read_data_header(h);
2713 if (h.type == "bin")
2714 f.low_level_read(x);
2715 else
2716 it_error("Wrong type");
2717
2718 return f;
2719}
2720
2722{
2724
2725 f.read_data_header(h);
2726 if (h.type == "int16")
2727 f.low_level_read(x);
2728 else
2729 it_error("Wrong type");
2730
2731 return f;
2732}
2733
2735{
2737
2738 f.read_data_header(h);
2739 if (h.type == "int32")
2740 f.low_level_read(x);
2741 else if (h.type == "int16") {
2742 short x16;
2743 f.low_level_read(x16);
2744 x = x16;
2745 }
2746 else
2747 it_error("Wrong type");
2748
2749 return f;
2750}
2751
2753{
2755
2756 f.read_data_header(h);
2757 if (h.type == "float64")
2758 f.low_level_read(x);
2759 else if (h.type == "float32") {
2760 float f32;
2761 f.low_level_read(f32);
2762 x = f32;
2763 }
2764 else
2765 it_error("Wrong type");
2766
2767 return f;
2768}
2769
2771{
2773
2774 f.read_data_header(h);
2775 if (h.type == "float32")
2776 f.low_level_read(x);
2777 else
2778 it_error("Wrong type");
2779
2780 return f;
2781}
2782
2783it_ifile_old &operator>>(it_ifile_old &f, std::complex<float> &x)
2784{
2786
2787 f.read_data_header(h);
2788
2789 if (h.type == "float32_complex") {
2790 std::complex<float> f32_c;
2791 f.low_level_read(f32_c);
2792 x = f32_c;
2793 }
2794 else
2795 it_error("Wrong type");
2796
2797 return f;
2798}
2799
2800it_ifile_old &operator>>(it_ifile_old &f, std::complex<double> &x)
2801{
2803
2804 f.read_data_header(h);
2805 if (h.type == "float64_complex")
2806 f.low_level_read(x);
2807 else if (h.type == "float32_complex") {
2808 std::complex<float> f32_c;
2809 f.low_level_read(f32_c);
2810 x = f32_c;
2811 }
2812 else
2813 it_error("Wrong type");
2814
2815 return f;
2816}
2817
2819{
2821
2822 f.read_data_header(h);
2823 if (h.type == "fvec")
2824 f.low_level_read_lo(v);
2825 else if (h.type == "dvec")
2826 f.low_level_read_hi(v);
2827 else
2828 it_error("Wrong type");
2829
2830 return f;
2831}
2832
2834{
2836
2837 f.read_data_header(h);
2838 if (h.type == "ivec")
2839 f.low_level_read(v);
2840 else
2841 it_error("Wrong type");
2842
2843 return f;
2844}
2845
2847{
2849
2850 f.read_data_header(h);
2851 if (h.type == "bvec")
2852 f.low_level_read(v);
2853 else
2854 it_error("Wrong type");
2855
2856 return f;
2857}
2858
2860{
2862
2863 f.read_data_header(h);
2864 if (h.type == "fcvec")
2865 f.low_level_read_lo(v);
2866 else if (h.type == "dcvec")
2867 f.low_level_read_hi(v);
2868 else
2869 it_error("Wrong type");
2870
2871 return f;
2872}
2873
2875{
2877
2878 f.read_data_header(h);
2879 if (h.type == "string")
2880 f.low_level_read(str);
2881 else
2882 it_error("Wrong type");
2883
2884 return f;
2885}
2886
2888{
2890
2891 f.read_data_header(h);
2892 if (h.type == "fmat")
2893 f.low_level_read_lo(m);
2894 else if (h.type == "dmat")
2895 f.low_level_read_hi(m);
2896 else
2897 it_error("Wrong type");
2898
2899 return f;
2900}
2901
2903{
2905
2906 f.read_data_header(h);
2907 if (h.type == "imat")
2908 f.low_level_read(m);
2909 else
2910 it_error("Wrong type");
2911
2912 return f;
2913}
2914
2916{
2918
2919 f.read_data_header(h);
2920 if (h.type == "bmat")
2921 f.low_level_read(m);
2922 else
2923 it_error("Wrong type");
2924
2925 return f;
2926}
2927
2929{
2931
2932 f.read_data_header(h);
2933 if (h.type == "fcmat")
2934 f.low_level_read_lo(m);
2935 else if (h.type == "dcmat")
2936 f.low_level_read_hi(m);
2937 else
2938 it_error("Wrong type");
2939
2940 return f;
2941}
2942
2944{
2946
2947 f.read_data_header(h);
2948 if (h.type == "fArray")
2949 f.low_level_read_lo(v);
2950 else
2951 it_error("Wrong type");
2952
2953 return f;
2954}
2955
2957{
2959
2960 f.read_data_header(h);
2961 if (h.type == "fArray")
2962 f.low_level_read_lo(v);
2963 else if (h.type == "dArray")
2964 f.low_level_read_hi(v);
2965 else
2966 it_error("Wrong type");
2967
2968 return f;
2969}
2970
2972{
2974
2975 f.read_data_header(h);
2976 if (h.type == "iArray")
2977 f.low_level_read(v);
2978 else
2979 it_error("Wrong type");
2980
2981 return f;
2982}
2983
2985{
2987
2988 f.read_data_header(h);
2989 if (h.type == "bArray")
2990 f.low_level_read(v);
2991 else
2992 it_error("Wrong type");
2993
2994 return f;
2995}
2996
2997it_ifile_old &operator>>(it_ifile_old &f, Array<std::complex<float> > &v)
2998{
3000
3001 f.read_data_header(h);
3002 if (h.type == "fcArray")
3003 f.low_level_read_lo(v);
3004 else
3005 it_error("Wrong type");
3006
3007 return f;
3008}
3009
3010it_ifile_old &operator>>(it_ifile_old &f, Array<std::complex<double> > &v)
3011{
3013
3014 f.read_data_header(h);
3015 if (h.type == "fcArray")
3016 f.low_level_read_lo(v);
3017 else if (h.type == "dcArray")
3018 f.low_level_read_hi(v);
3019 else
3020 it_error("Wrong type");
3021
3022 return f;
3023}
3024
3026{
3028
3029 f.read_data_header(h);
3030 if (h.type == "vecArray") {
3031 int n;
3032 f.low_level_read(n);
3033 v.set_size(n, false);
3034 for (int i = 0; i < n; i++)
3035 f.low_level_read_hi(v(i));
3036 }
3037 else
3038 it_error("Wrong type");
3039
3040 return f;
3041}
3042
3044{
3046
3047 f.read_data_header(h);
3048 if (h.type == "ivecArray") {
3049 int n;
3050 f.low_level_read(n);
3051 v.set_size(n, false);
3052 for (int i = 0; i < n; i++)
3053 f.low_level_read(v(i));
3054 }
3055 else
3056 it_error("Wrong type");
3057
3058 return f;
3059}
3060
3062{
3064
3065 f.read_data_header(h);
3066 if (h.type == "bvecArray") {
3067 int n;
3068 f.low_level_read(n);
3069 v.set_size(n, false);
3070 for (int i = 0; i < n; i++)
3071 f.low_level_read(v(i));
3072 }
3073 else
3074 it_error("Wrong type");
3075
3076 return f;
3077}
3078
3080{
3082
3083 f.read_data_header(h);
3084 if (h.type == "cvecArray") {
3085 int n;
3086 f.low_level_read(n);
3087 v.set_size(n, false);
3088 for (int i = 0; i < n; i++)
3089 f.low_level_read_hi(v(i));
3090 }
3091 else
3092 it_error("Wrong type");
3093
3094 return f;
3095}
3096
3098{
3100
3101 f.read_data_header(h);
3102 if (h.type == "stringArray") {
3103 int n;
3104 f.low_level_read(n);
3105 v.set_size(n, false);
3106 for (int i = 0; i < n; i++)
3107 f.low_level_read(v(i));
3108 }
3109 else
3110 it_error("Wrong type");
3111
3112 return f;
3113}
3114
3116{
3118
3119 f.read_data_header(h);
3120 if (h.type == "matArray") {
3121 int n;
3122 f.low_level_read(n);
3123 v.set_size(n, false);
3124 for (int i = 0; i < n; i++)
3125 f.low_level_read_hi(v(i));
3126 }
3127 else
3128 it_error("Wrong type");
3129
3130 return f;
3131}
3132
3134{
3136
3137 f.read_data_header(h);
3138 if (h.type == "imatArray") {
3139 int n;
3140 f.low_level_read(n);
3141 v.set_size(n, false);
3142 for (int i = 0; i < n; i++)
3143 f.low_level_read(v(i));
3144 }
3145 else
3146 it_error("Wrong type");
3147
3148 return f;
3149}
3150
3152{
3154
3155 f.read_data_header(h);
3156 if (h.type == "bmatArray") {
3157 int n;
3158 f.low_level_read(n);
3159 v.set_size(n, false);
3160 for (int i = 0; i < n; i++)
3161 f.low_level_read(v(i));
3162 }
3163 else
3164 it_error("Wrong type");
3165
3166 return f;
3167}
3168
3170{
3172
3173 f.read_data_header(h);
3174 if (h.type == "cmatArray") {
3175 int n;
3176 f.low_level_read(n);
3177 v.set_size(n, false);
3178 for (int i = 0; i < n; i++)
3179 f.low_level_read_hi(v(i));
3180 }
3181 else
3182 it_error("Wrong type");
3183
3184 return f;
3185}
3186
3188{
3189 f.write_data_header("int8", sizeof(char));
3190 f.low_level_write(x);
3191
3192 return f;
3193}
3194
3196{
3197 f.write_data_header("bin", sizeof(bin));
3198 f.low_level_write(x);
3199
3200 return f;
3201}
3202
3204{
3205 f.write_data_header("int16", sizeof(short));
3206 f.low_level_write(x);
3207
3208 return f;
3209}
3210
3212{
3213 f.write_data_header("int32", sizeof(int));
3214 f.low_level_write(x);
3215
3216 return f;
3217}
3218
3220{
3221 f.write_data_header("float32", sizeof(float));
3222 f.low_level_write(x);
3223
3224 return f;
3225}
3226
3228{
3229 f.write_data_header("float64", sizeof(double));
3230 f.low_level_write(x);
3231
3232 return f;
3233}
3234
3235it_file_old &operator<<(it_file_old &f, std::complex<float> x)
3236{
3237 f.write_data_header("float32_complex", 2*sizeof(float));
3238 f.low_level_write(x);
3239
3240 return f;
3241}
3242
3243it_file_old &operator<<(it_file_old &f, std::complex<double> x)
3244{
3245 f.write_data_header("float64_complex", 2*sizeof(double));
3246 f.low_level_write(x);
3247
3248 return f;
3249}
3250
3252{
3253 if (f.get_low_precision())
3254 f.write_data_header("fvec", sizeof(int) + v.size() * sizeof(float));
3255 else
3256 f.write_data_header("dvec", sizeof(int) + v.size() * sizeof(double));
3257 f.low_level_write(v);
3258
3259 return f;
3260}
3261
3263{
3264 f.write_data_header("ivec", (1 + v.size()) * sizeof(int));
3265 f.low_level_write(v);
3266
3267 return f;
3268}
3269
3271{
3272 f.write_data_header("bvec", sizeof(int) + v.size() * sizeof(bin));
3273 f.low_level_write(v);
3274
3275 return f;
3276}
3277
3279{
3280 if (f.get_low_precision())
3281 f.write_data_header("fcvec", sizeof(int) + v.size() * 2 * sizeof(float));
3282 else
3283 f.write_data_header("dcvec", sizeof(int) + v.size() * 2 * sizeof(double));
3284 f.low_level_write(v);
3285
3286 return f;
3287}
3288
3289it_file_old &operator<<(it_file_old &f, const std::string &str)
3290{
3291 f.write_data_header("string", sizeof(int) + int(str.size()) * sizeof(char));
3292 f.low_level_write(str);
3293
3294 return f;
3295}
3296
3298{
3299 if (f.get_low_precision())
3300 f.write_data_header("fmat", 2*sizeof(int) + m.rows()*m.cols()*sizeof(float));
3301 else
3302 f.write_data_header("dmat", 2*sizeof(int) + m.rows()*m.cols()*sizeof(double));
3303 f.low_level_write(m);
3304
3305 return f;
3306}
3307
3309{
3310 f.write_data_header("imat", (2 + m.rows()*m.cols()) * sizeof(int));
3311 f.low_level_write(m);
3312
3313 return f;
3314}
3315
3317{
3318 f.write_data_header("bmat", 2*sizeof(int) + m.rows()*m.cols()*sizeof(bin));
3319 f.low_level_write(m);
3320
3321 return f;
3322}
3323
3325{
3326 if (f.get_low_precision())
3327 f.write_data_header("fcmat", 2*sizeof(int) + 2*m.rows()*m.cols()*sizeof(float));
3328 else
3329 f.write_data_header("dcmat", 2*sizeof(int) + 2*m.rows()*m.cols()*sizeof(double));
3330 f.low_level_write(m);
3331
3332 return f;
3333}
3334
3336{
3337 f.write_data_header("fArray", sizeof(int) + v.size() * sizeof(float));
3338 f.low_level_write(v);
3339
3340 return f;
3341}
3342
3344{
3345 if (f.get_low_precision())
3346 f.write_data_header("fArray", sizeof(int) + v.size() * sizeof(float));
3347 else
3348 f.write_data_header("dArray", sizeof(int) + v.size() * sizeof(double));
3349 f.low_level_write(v);
3350
3351 return f;
3352}
3353
3355{
3356 f.write_data_header("iArray", (1 + v.size()) * sizeof(int));
3357 f.low_level_write(v);
3358
3359 return f;
3360}
3361
3363{
3364 f.write_data_header("bArray", sizeof(int) + v.size() * sizeof(bin));
3365 f.low_level_write(v);
3366
3367 return f;
3368}
3369
3370it_file_old &operator<<(it_file_old &f, const Array<std::complex<float> > &v)
3371{
3372 f.write_data_header("fcArray", sizeof(int) + v.size() * 2 * sizeof(float));
3373 f.low_level_write(v);
3374
3375 return f;
3376}
3377
3378it_file_old &operator<<(it_file_old &f, const Array<std::complex<double> > &v)
3379{
3380 if (f.get_low_precision())
3381 f.write_data_header("fcArray", sizeof(int) + v.size() * 2 * sizeof(float));
3382 else
3383 f.write_data_header("dcArray", sizeof(int) + v.size() * 2 * sizeof(double));
3384 f.low_level_write(v);
3385
3386 return f;
3387}
3388
3390{
3391 int i, sum_l = 0;
3392
3393 // calculate total length of Array
3394 for (i = 0; i < v.size(); i++) {
3395 sum_l += v(i).size();
3396 }
3397
3398 // write header
3399 f.write_data_header("vecArray", sizeof(int)*(1 + v.size()) + sum_l * sizeof(double));
3400
3401 f.low_level_write(v.size()); // the length of the array
3402
3403 // write one vector at a time (i.e. size and elements)
3404 for (i = 0; i < v.size(); i++)
3405 f.low_level_write(v(i));
3406
3407 return f;
3408}
3409
3411{
3412 int i, sum_l = 0;
3413
3414 // calculate total length of Array
3415 for (i = 0; i < v.size(); i++) {
3416 sum_l += v(i).size();
3417 }
3418
3419 // write header
3420 f.write_data_header("ivecArray", sizeof(int)*(1 + v.size()) + sum_l * sizeof(int));
3421
3422 f.low_level_write(v.size()); // the length of the array
3423
3424 // write one vector at a time (i.e. size and elements)
3425 for (i = 0; i < v.size(); i++)
3426 f.low_level_write(v(i));
3427
3428 return f;
3429}
3430
3432{
3433 int i, sum_l = 0;
3434
3435 // calculate total length of Array
3436 for (i = 0; i < v.size(); i++) {
3437 sum_l += v(i).size();
3438 }
3439
3440 // write header
3441 f.write_data_header("bvecArray", sizeof(int)*(1 + v.size()) + sum_l * sizeof(bin));
3442
3443 f.low_level_write(v.size()); // the length of the array
3444
3445 // write one vector at a time (i.e. size and elements)
3446 for (i = 0; i < v.size(); i++)
3447 f.low_level_write(v(i));
3448
3449 return f;
3450}
3451
3453{
3454 int i, sum_l = 0;
3455
3456 // calculate total length of Array
3457 for (i = 0; i < v.size(); i++) {
3458 sum_l += v(i).size();
3459 }
3460
3461 // write header
3462 f.write_data_header("cvecArray", sizeof(int)*(1 + v.size()) + sum_l * sizeof(std::complex<double>));
3463
3464 f.low_level_write(v.size()); // the length of the array
3465
3466 // write one vector at a time (i.e. size and elements)
3467 for (i = 0; i < v.size(); i++)
3468 f.low_level_write(v(i));
3469
3470 return f;
3471}
3472
3474{
3475 int i, sum_l = 0;
3476
3477 // calculate total length of Array
3478 for (i = 0; i < v.size(); i++) {
3479 sum_l += int(v(i).size());
3480 }
3481
3482 // write header
3483 f.write_data_header("stringArray", sizeof(int)*(1 + v.size()) + sum_l * sizeof(char));
3484
3485 f.low_level_write(v.size()); // the length of the array
3486
3487 // write one vector at a time (i.e. size and elements)
3488 for (i = 0; i < v.size(); i++)
3489 f.low_level_write(v(i));
3490
3491 return f;
3492}
3493
3495{
3496 int i, sum_l = 0;
3497
3498 // calculate total length of Array
3499 for (i = 0; i < v.size(); i++) {
3500 sum_l += v(i)._datasize();
3501 }
3502
3503 // write header
3504 f.write_data_header("matArray", sizeof(int)*(1 + 2*v.size()) + sum_l * sizeof(double));
3505
3506 f.low_level_write(v.size()); // the length of the array
3507
3508 // write one matrix at a time (i.e. size and elements)
3509 for (i = 0; i < v.size(); i++)
3510 f.low_level_write(v(i));
3511
3512 return f;
3513}
3514
3516{
3517 int i, sum_l = 0;
3518
3519 // calculate total length of Array
3520 for (i = 0; i < v.size(); i++) {
3521 sum_l += v(i)._datasize();
3522 }
3523
3524 // write header
3525 f.write_data_header("imatArray", sizeof(int)*(1 + 2*v.size()) + sum_l * sizeof(int));
3526
3527 f.low_level_write(v.size()); // the length of the array
3528
3529 // write one matrix at a time (i.e. size and elements)
3530 for (i = 0; i < v.size(); i++)
3531 f.low_level_write(v(i));
3532
3533 return f;
3534}
3535
3537{
3538 int i, sum_l = 0;
3539
3540 // calculate total length of Array
3541 for (i = 0; i < v.size(); i++) {
3542 sum_l += v(i)._datasize();
3543 }
3544
3545 // write header
3546 f.write_data_header("bmatArray", sizeof(int)*(1 + 2*v.size()) + sum_l * sizeof(bin));
3547
3548 f.low_level_write(v.size()); // the length of the array
3549
3550 // write one matrix at a time (i.e. size and elements)
3551 for (i = 0; i < v.size(); i++)
3552 f.low_level_write(v(i));
3553
3554 return f;
3555}
3556
3558{
3559 int i, sum_l = 0;
3560
3561 // calculate total length of Array
3562 for (i = 0; i < v.size(); i++) {
3563 sum_l += v(i)._datasize();
3564 }
3565
3566 // write header
3567 f.write_data_header("cmatArray", sizeof(int)*(1 + 2*v.size()) + sum_l * sizeof(std::complex<double>));
3568
3569 f.low_level_write(v.size()); // the length of the array
3570
3571 // write one matrix at a time (i.e. size and elements)
3572 for (i = 0; i < v.size(); i++)
3573 f.low_level_write(v(i));
3574
3575 return f;
3576}
3577
3578} // namespace itpp
General array class.
Definition factory.h:40
int size() const
Returns the number of data elements in the array object.
Definition array.h:155
void set_size(int n, bool copy=false)
Resizing an Array<T>.
Definition array.h:257
endian get_native_endianity() const
Returns the native endianity for this computer architecture.
Definition binfile.h:105
void set_endianity(endian e)
Set the endianity for this class.
Definition binfile.h:110
endian
Definition of the endian data type.
Definition binfile.h:74
void open_readonly(const std::string &name, endian e=b_endian)
Open a file for reading only and set the endianity.
Definition binfile.cpp:373
void open(const std::string &name, bool trunc=false, endian e=b_endian)
Open a file for reading and writing and set the endianity.
Definition binfile.cpp:359
Binary arithmetic (boolean) class.
Definition binary.h:57
char value() const
Output the binary value of the object.
Definition binary.h:152
bool eof() const
This method returns true if eof is reached.
Definition binfile.h:437
Fstream_Binfile_Facade & seekg(std::streampos pos)
Set position.
Definition binfile.h:428
Fstream_Binfile_Facade & put(const char c)
Output single char.
Definition binfile.h:379
Fstream_Binfile_Facade & read(char *s, std::streamsize n)
Read n chars from stream.
Definition binfile.h:414
void close()
Method to close corresponding file.
Definition binfile.h:373
void clear(std::ios_base::iostate state=std::ios_base::goodbit)
Method to set stream state (overwrites stream state flags)
Definition binfile.h:453
std::streampos tellp()
Get position.
Definition binfile.h:382
Fstream_Binfile_Facade & flush()
Flushes stream buffer.
Definition binfile.h:390
Fstream_Binfile_Facade & seekp(std::streampos pos)
Set position.
Definition binfile.h:384
std::streampos tellg()
Get position.
Definition binfile.h:426
Fstream_Binfile_Facade & write(const char *c, std::streamsize n)
Output multiple characters.
Definition binfile.h:376
static char file_version
ACTION: Add documentation.
Definition itfile.h:698
static char file_magic[4]
ACTION: Add documentation.
Definition itfile.h:696
static char file_magic[4]
IT++ file marker: "IT++".
Definition itfile.h:122
static char file_version
IT++ file version.
Definition itfile.h:124
The old (version 2) IT++ file format reading and writing class.
Definition itfile.h:807
void write_data_header(const std::string &type, uint32_t size)
Write the data header for a variable, specifying the type and size of the data to follow.
Definition itfile.cpp:2363
bool low_prec
ACTION: Add documenation for this protected member.
Definition itfile.h:923
void flush()
Flush the data to disk.
Definition itfile.cpp:2352
void close()
Close the file.
Definition itfile.cpp:2347
bool get_low_precision()
Get the precision.
Definition itfile.h:847
bool exists(const std::string &name)
Returns true if the variable name exists in the file.
Definition itfile.cpp:2462
it_file_old()
Constructor.
Definition itfile.cpp:2319
std::string & next_name()
ACTION: Add documenation for this protected member.
Definition itfile.h:925
void write_file_header()
Write the header for the it_file_old.
Definition itfile.cpp:2357
void low_level_write(char x)
Write a char value at the current file pointer position.
Definition itfile.cpp:2475
void remove()
ACTION: Add documenation for this protected member.
Definition itfile.cpp:2446
void open(const std::string &name, bool trunc=false)
Open a file for reading and writing.
Definition itfile.cpp:2331
void write_data_header_here(const data_header &h)
ACTION: Add documenation for this protected member.
Definition itfile.cpp:2434
void pack()
Remove slack space from the file.
Definition itfile.cpp:2470
The IT++ file format reading and writing class.
Definition itfile.h:246
void write_data_header(const std::string &type, uint64_t size)
Write the data header for a variable, specifying the type and size of the data to follow.
Definition itfile.cpp:546
void flush()
Flush the data to disk.
Definition itfile.cpp:535
bool get_low_precision() const
Get the precision.
Definition itfile.h:284
std::string & next_name()
Name to be used for saving the next variable.
Definition itfile.h:380
void open(const std::string &filename, bool trunc=false)
Open a file for reading and writing.
Definition itfile.cpp:512
void write_data_header_here(const data_header &h)
Write data header h at the current file position.
Definition itfile.cpp:615
void close()
Close the file.
Definition itfile.cpp:530
std::string & next_desc()
Description to be used for saving the next variable.
Definition itfile.h:382
void write_file_header()
Write the header for the it_file.
Definition itfile.cpp:540
void remove()
Remove the current variable, denoted by next_name.
Definition itfile.cpp:627
bool exists(const std::string &name)
Returns true if the variable name exists in the file.
Definition itfile.cpp:644
it_file()
Default constructor.
Definition itfile.cpp:504
void pack()
Remove slack space from the file.
Definition itfile.cpp:649
void low_level_write(char x)
Write a char value at the current file pointer position.
Definition itfile.cpp:716
The old (version 2) IT++ file format reading class.
Definition itfile.h:708
void open(const std::string &name)
Open a file. The file must exist.
Definition itfile.cpp:1888
void low_level_read_lo(vec &v)
Read a vector of float values at the current file pointer position.
Definition itfile.cpp:2043
bool seek(const std::string &name)
Find the variable name.
Definition itfile.cpp:1906
void low_level_read_hi(vec &v)
Read a vector of double values at the current file pointer position.
Definition itfile.cpp:2056
it_ifile_old()
Constructor.
Definition itfile.cpp:1879
void info(std::string &name, std::string &type, int &bytes)
Get information about the current variable.
Definition itfile.cpp:1952
void low_level_read(char &x)
Read a char value at the current file pointer position.
Definition itfile.cpp:1995
void read_data_header(data_header &h)
Read the data header and return the result in the variable h.
Definition itfile.cpp:1975
virtual void close()
Close a file.
Definition itfile.cpp:1901
bool read_check_file_header()
Reads and checks the file data header. Returns true if the header is valid and false otherwise.
Definition itfile.cpp:1965
bfstream s
Protected binary file stream.
Definition itfile.h:797
The IT++ file format reading class.
Definition itfile.h:133
bool seek(const std::string &name)
Find the variable name.
Definition itfile.cpp:65
void open(const std::string &filename)
Open an existing file in read-only mode.
Definition itfile.cpp:50
virtual void close()
Close the file.
Definition itfile.cpp:60
void low_level_read(char &x)
Read a char value at the current file pointer position.
Definition itfile.cpp:145
void low_level_read_lo(vec &v)
Read a vector of float values at the current file pointer position.
Definition itfile.cpp:246
bool read_check_file_header()
Read and check the file header. Return true if the header is valid and false otherwise.
Definition itfile.cpp:126
void read_data_header(it_file_base::data_header &h)
Read data header and return the result in the variable h.
Definition itfile.cpp:134
bfstream s
Protected binary file stream.
Definition itfile.h:237
void info(std::string &name, std::string &type, std::string &desc, uint64_t &bytes)
Get information about the current variable.
Definition itfile.cpp:111
void low_level_read_hi(vec &v)
Read a vector of double values at the current file pointer position.
Definition itfile.cpp:258
it_ifile()
Default constructor.
Definition itfile.cpp:43
#define it_error_if(t, s)
Abort if t is true.
Definition itassert.h:117
#define it_error(s)
Abort unconditionally.
Definition itassert.h:126
#define it_warning(s)
Display a warning message.
Definition itassert.h:173
#define it_assert(t, s)
Abort if t is not true.
Definition itassert.h:94
bool exist(const std::string &name)
Checks if a file named name already exists on the disk.
Definition binfile.cpp:98
int size(const Vec< T > &v)
Length of vector.
Definition matfunc.h:55
vec imag(const cvec &data)
Imaginary part of complex values.
vec real(const cvec &data)
Real part of complex values.
Definition of classes for the IT++ file format.
Mat< bin > bmat
bin matrix
Definition mat.h:508
itpp namespace
Definition itmex.h:37
std::ostream & operator<<(std::ostream &output, const bin &inbin)
Output stream of bin.
Definition binary.cpp:36
std::istream & operator>>(std::istream &input, bin &outbin)
Input stream of bin.
Definition binary.cpp:42
Data header structure.
Definition itfile.h:98
std::string name
Data name.
Definition itfile.h:106
uint64_t hdr_bytes
Number of bytes of the header.
Definition itfile.h:100
uint64_t block_bytes
Number of bytes of the header + data.
Definition itfile.h:104
std::string type
Data type, e.g. int32, float32, etc. type = "" means deleted.
Definition itfile.h:108
std::string desc
Data description.
Definition itfile.h:110
uint64_t data_bytes
Number of bytes of the data.
Definition itfile.h:102
File header structure.
Definition itfile.h:115
char magic[4]
IT++ file marker: "IT++".
Definition itfile.h:117
char version
IT++ file format version.
Definition itfile.h:119
Data header structure.
Definition itfile.h:673
std::string type
data type, e.g. int32, float32, etc. type = "" means deleted
Definition itfile.h:683
std::string name
data name
Definition itfile.h:681
char endianity
0=little, 1=big
Definition itfile.h:675
File header structure.
Definition itfile.h:689
char version
ACTION: Add documentation.
Definition itfile.h:693
char magic[4]
ACTION: Add documentation.
Definition itfile.h:691
SourceForge Logo

Generated on Mon Apr 7 2025 07:53:18 for IT++ by Doxygen 1.11.0