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

Generated on Fri Mar 21 2014 17:14:12 for IT++ by Doxygen 1.8.1.2