IT++ Logo
itfile.cpp
Go to the documentation of this file.
00001 
00030 #include <itpp/base/itfile.h>
00031 
00032 
00033 namespace itpp
00034 {
00035 
00036 char it_file_base::file_magic[4] = { 'I', 'T', '+', '+' };
00037 char it_file_base::file_version = 3;
00038 
00039 // ----------------------------------------------------------------------
00040 // it_ifile class
00041 // ----------------------------------------------------------------------
00042 
00043 it_ifile::it_ifile() {}
00044 
00045 it_ifile::it_ifile(const std::string &name)
00046 {
00047   open(name);
00048 }
00049 
00050 void it_ifile::open(const std::string &name)
00051 {
00052   it_assert(exist(name), "it_ifile::open(): File does not exist");
00053   s.open_readonly(name, bfstream_base::l_endian);
00054   if (!read_check_file_header()) {
00055     s.close();
00056     it_error("it_ifile::open(): Corrupt file (not an it_file)");
00057   }
00058 }
00059 
00060 void it_ifile::close()
00061 {
00062   s.close();
00063 }
00064 
00065 bool it_ifile::seek(const std::string &name)
00066 {
00067   data_header h;
00068   std::streampos p;
00069 
00070   s.clear();
00071   s.seekg(sizeof(file_header));
00072 
00073   while (true) {
00074     p = s.tellg();
00075     read_data_header(h);
00076     if (s.eof()) {
00077       s.clear();
00078       return false;
00079     }
00080     if (h.type != "" && h.name == name) {
00081       s.seekg(p);
00082       break;
00083     }
00084     s.seekg(p + static_cast<std::streamoff>(h.block_bytes));
00085   }
00086 
00087   return true;
00088 }
00089 
00090 bool it_ifile::seek(int n)
00091 {
00092   data_header h;
00093   std::streampos p;
00094 
00095   s.clear();
00096   s.seekg(sizeof(file_header));
00097   for (int i = 0; i <= n; i++) {
00098     p = s.tellg();
00099     read_data_header(h);
00100     if (s.eof()) {
00101       s.clear();
00102       return false;
00103     }
00104     if (h.type == "")
00105       i--;
00106     s.seekg((i == n) ? p : p + static_cast<std::streamoff>(h.block_bytes));
00107   }
00108   return true;
00109 }
00110 
00111 void it_ifile::info(std::string &name, std::string &type,
00112                     std::string &desc, uint64_t &bytes)
00113 {
00114   data_header h;
00115   std::streampos p;
00116 
00117   p = s.tellg();
00118   read_data_header(h);
00119   s.seekg(p);
00120   name = h.name;
00121   type = h.type;
00122   desc = h.desc;
00123   bytes = h.data_bytes;
00124 }
00125 
00126 bool it_ifile::read_check_file_header()
00127 {
00128   file_header h;
00129   s.read(reinterpret_cast<char *>(&h), sizeof(h));
00130   return (memcmp(h.magic, file_magic, 4) == 0
00131           && (h.version == file_version));
00132 }
00133 
00134 void it_ifile::read_data_header(data_header &h)
00135 {
00136   std::streampos p = s.tellg();
00137   s.clear();
00138   s >> h.hdr_bytes;
00139   s >> h.data_bytes;
00140   s >> h.block_bytes;
00141   s >> h.name;
00142   s >> h.type;
00143   s >> h.desc;
00144 }
00145 
00146 void it_ifile::low_level_read(char &x)
00147 {
00148   s >> x;
00149 }
00150 
00151 void it_ifile::low_level_read(uint64_t &x)
00152 {
00153   s >> x;
00154 }
00155 
00156 void it_ifile::low_level_read(bool &x)
00157 {
00158   char tmp;
00159   s >> tmp;
00160   x = (tmp == 0) ? false : true;
00161 }
00162 
00163 
00164 void it_ifile::low_level_read(bin &x)
00165 {
00166   char tmp;
00167   s >> tmp;
00168   x = tmp;
00169 }
00170 
00171 void it_ifile::low_level_read(short &x)
00172 {
00173   int16_t tmp;
00174   s >> tmp;
00175   x = tmp;
00176 }
00177 
00178 void it_ifile::low_level_read(int &x)
00179 {
00180   int32_t tmp;
00181   s >> tmp;
00182   x = tmp;
00183 }
00184 
00185 void it_ifile::low_level_read(float &x)
00186 {
00187   s >> x;
00188 }
00189 
00190 void it_ifile::low_level_read(double &x)
00191 {
00192   s >> x;
00193 }
00194 
00195 void it_ifile::low_level_read(std::complex<float> &x)
00196 {
00197   float x_real, x_imag;
00198   s >> x_real;
00199   s >> x_imag;
00200   x = std::complex<float>(x_real, x_imag);
00201 }
00202 
00203 void it_ifile::low_level_read(std::complex<double> &x)
00204 {
00205   double x_real, x_imag;
00206   s >> x_real;
00207   s >> x_imag;
00208   x = std::complex<double>(x_real, x_imag);
00209 }
00210 
00211 void it_ifile::low_level_read(bvec &v)
00212 {
00213   uint64_t size;
00214   char tmp;
00215   s >> size;
00216   v.set_size(static_cast<int>(size), false);
00217   for (int i = 0; i < v.size(); ++i) {
00218     s >> tmp;
00219     v(i) = tmp;
00220   }
00221 }
00222 
00223 void it_ifile::low_level_read(svec &v)
00224 {
00225   uint64_t size;
00226   int16_t val;
00227   s >> size;
00228   v.set_size(static_cast<int>(size), false);
00229   for (int i = 0; i < v.size(); ++i) {
00230     s >> val;
00231     v(i) = val;
00232   }
00233 }
00234 
00235 void it_ifile::low_level_read(ivec &v)
00236 {
00237   uint64_t size;
00238   int32_t val;
00239   s >> size;
00240   v.set_size(static_cast<int>(size), false);
00241   for (int i = 0; i < v.size(); ++i) {
00242     s >> val;
00243     v(i) = val;
00244   }
00245 }
00246 
00247 void it_ifile::low_level_read_lo(vec &v)
00248 {
00249   uint64_t size;
00250   float val;
00251   s >> size;
00252   v.set_size(static_cast<int>(size), false);
00253   for (int i = 0; i < v.size(); ++i) {
00254     s >> val;
00255     v(i) = static_cast<double>(val);
00256   }
00257 }
00258 
00259 void it_ifile::low_level_read_hi(vec &v)
00260 {
00261   uint64_t size;
00262   s >> size;
00263   v.set_size(static_cast<int>(size), false);
00264   for (int i = 0; i < v.size(); ++i)
00265     s >> v(i);
00266 }
00267 
00268 void it_ifile::low_level_read_lo(cvec &v)
00269 {
00270   uint64_t size;
00271   float val_real, val_imag;
00272   s >> size;
00273   v.set_size(static_cast<int>(size), false);
00274   for (int i = 0; i < v.size(); ++i) {
00275     s >> val_real;
00276     s >> val_imag;
00277     v(i) = std::complex<double>(val_real, val_imag);
00278   }
00279 }
00280 
00281 void it_ifile::low_level_read_hi(cvec &v)
00282 {
00283   uint64_t size;
00284   double val_real, val_imag;
00285   s >> size;
00286   v.set_size(static_cast<int>(size), false);
00287   for (int i = 0; i < v.size(); ++i) {
00288     s >> val_real;
00289     s >> val_imag;
00290     v(i) = std::complex<double>(val_real, val_imag);
00291   }
00292 }
00293 
00294 void it_ifile::low_level_read(std::string &str)
00295 {
00296   uint64_t size;
00297   s >> size;
00298   std::string::size_type size2 = static_cast<std::string::size_type>(size);
00299   str.resize(size2);
00300   for (std::string::size_type i = 0; i < size2; ++i)
00301     s >> str[i];
00302 }
00303 
00304 void it_ifile::low_level_read(bmat &m)
00305 {
00306   uint64_t i, j;
00307   char tmp;
00308   s >> i >> j;
00309   m.set_size(static_cast<int>(i), static_cast<int>(j), false);
00310   for (int j = 0; j < m.cols(); ++j) {
00311     for (int i = 0; i < m.rows(); ++i) {
00312       s >> tmp;
00313       m(i, j) = tmp;
00314     }
00315   }
00316 }
00317 
00318 void it_ifile::low_level_read(smat &m)
00319 {
00320   uint64_t i, j;
00321   int16_t val;
00322   s >> i >> j;
00323   m.set_size(static_cast<int>(i), static_cast<int>(j), false);
00324   for (int j = 0; j < m.cols(); ++j)
00325     for (int i = 0; i < m.rows(); ++i) {
00326       s >> val;
00327       m(i, j) = val;
00328     }
00329 }
00330 
00331 void it_ifile::low_level_read(imat &m)
00332 {
00333   uint64_t i, j;
00334   int32_t val;
00335   s >> i >> j;
00336   m.set_size(static_cast<int>(i), static_cast<int>(j), false);
00337   for (int j = 0; j < m.cols(); ++j)
00338     for (int i = 0; i < m.rows(); ++i) {
00339       s >> val;
00340       m(i, j) = val;
00341     }
00342 }
00343 
00344 void it_ifile::low_level_read_lo(mat &m)
00345 {
00346   uint64_t i, j;
00347   float val;
00348   s >> i >> j;
00349   m.set_size(static_cast<int>(i), static_cast<int>(j), false);
00350   for (int j = 0; j < m.cols(); ++j)
00351     for (int i = 0; i < m.rows(); ++i) {
00352       s >> val;
00353       m(i, j) = static_cast<double>(val);
00354     }
00355 }
00356 
00357 void it_ifile::low_level_read_hi(mat &m)
00358 {
00359   uint64_t i, j;
00360   s >> i >> j;
00361   m.set_size(static_cast<int>(i), static_cast<int>(j), false);
00362   for (int j = 0; j < m.cols(); ++j)
00363     for (int i = 0; i < m.rows(); ++i)
00364       s >> m(i, j);
00365 }
00366 
00367 void it_ifile::low_level_read_lo(cmat &m)
00368 {
00369   uint64_t i, j;
00370   float val_real, val_imag;
00371   s >> i >> j;
00372   m.set_size(static_cast<int>(i), static_cast<int>(j), false);
00373   for (int j = 0; j < m.cols(); ++j)
00374     for (int i = 0; i < m.rows(); ++i) {
00375       s >> val_real;
00376       s >> val_imag;
00377       m(i, j) = std::complex<double>(val_real, val_imag);
00378     }
00379 }
00380 
00381 void it_ifile::low_level_read_hi(cmat &m)
00382 {
00383   uint64_t i, j;
00384   double val_real, val_imag;
00385   s >> i >> j;
00386   m.set_size(static_cast<int>(i), static_cast<int>(j), false);
00387   for (int j = 0; j < m.cols(); ++j)
00388     for (int i = 0; i < m.rows(); ++i) {
00389       s >> val_real;
00390       s >> val_imag;
00391       m(i, j) = std::complex<double>(val_real, val_imag);
00392     }
00393 }
00394 
00395 void it_ifile::low_level_read(Array<bin> &v)
00396 {
00397   uint64_t size;
00398   char tmp;
00399   s >> size;
00400   v.set_size(static_cast<int>(size), false);
00401   for (int i = 0; i < v.size(); ++i) {
00402     s >> tmp;
00403     v(i) = tmp;
00404   }
00405 }
00406 
00407 void it_ifile::low_level_read(Array<short> &v)
00408 {
00409   uint64_t size;
00410   int16_t val;
00411   s >> size;
00412   v.set_size(static_cast<int>(size), false);
00413   for (int i = 0; i < v.size(); ++i) {
00414     s >> val;
00415     v(i) = val;
00416   }
00417 }
00418 
00419 void it_ifile::low_level_read(Array<int> &v)
00420 {
00421   uint64_t size;
00422   int32_t val;
00423   s >> size;
00424   v.set_size(static_cast<int>(size), false);
00425   for (int i = 0; i < v.size(); ++i) {
00426     s >> val;
00427     v(i) = val;
00428   }
00429 }
00430 
00431 void it_ifile::low_level_read(Array<float> &v)
00432 {
00433   uint64_t size;
00434   s >> size;
00435   v.set_size(static_cast<int>(size), false);
00436   for (int i = 0; i < v.size(); ++i)
00437     s >> v(i);
00438 }
00439 
00440 void it_ifile::low_level_read_lo(Array<double> &v)
00441 {
00442   uint64_t size;
00443   float val;
00444   s >> size;
00445   v.set_size(static_cast<int>(size), false);
00446   for (int i = 0; i < v.size(); ++i) {
00447     s >> val;
00448     v(i) = static_cast<double>(val);
00449   }
00450 }
00451 
00452 void it_ifile::low_level_read_hi(Array<double> &v)
00453 {
00454   uint64_t size;
00455   s >> size;
00456   v.set_size(static_cast<int>(size), false);
00457   for (int i = 0; i < v.size(); ++i)
00458     s >> v(i);
00459 }
00460 
00461 void it_ifile::low_level_read(Array<std::complex<float> > &v)
00462 {
00463   uint64_t size;
00464   float val_real, val_imag;
00465   s >> size;
00466   v.set_size(static_cast<int>(size), false);
00467   for (int i = 0; i < v.size(); ++i) {
00468     s >> val_real;
00469     s >> val_imag;
00470     v(i) = std::complex<float>(val_real, val_imag);
00471   }
00472 }
00473 
00474 void it_ifile::low_level_read_lo(Array<std::complex<double> > &v)
00475 {
00476   uint64_t size;
00477   float val_real, val_imag;
00478   s >> size;
00479   v.set_size(static_cast<int>(size), false);
00480   for (int i = 0; i < v.size(); ++i) {
00481     s >> val_real;
00482     s >> val_imag;
00483     v(i) = std::complex<double>(val_real, val_imag);
00484   }
00485 }
00486 
00487 void it_ifile::low_level_read_hi(Array<std::complex<double> > &v)
00488 {
00489   uint64_t size;
00490   double val_real, val_imag;
00491   s >> size;
00492   v.set_size(static_cast<int>(size), false);
00493   for (int i = 0; i < v.size(); ++i) {
00494     s >> val_real;
00495     s >> val_imag;
00496     v(i) = std::complex<double>(val_real, val_imag);
00497   }
00498 }
00499 
00500 
00501 // ----------------------------------------------------------------------
00502 // it_file class
00503 // ----------------------------------------------------------------------
00504 
00505 it_file::it_file(): low_prec(false), next_name(""), next_desc(""),
00506     fname("") {}
00507 
00508 it_file::it_file(const std::string &name, bool trunc):
00509     low_prec(false), next_name(""), next_desc(""), fname("")
00510 {
00511   open(name, trunc);
00512 }
00513 
00514 void it_file::open(const std::string &name, bool trunc)
00515 {
00516   if (!exist(name))
00517     trunc = true;
00518 
00519   s.open(name, trunc, bfstream_base::l_endian);
00520   it_assert(s.is_open(), "it_file::open(): Could not open file for writing");
00521 
00522   if (trunc)
00523     write_file_header();
00524   else if (!read_check_file_header()) {
00525     s.close();
00526     it_error("it_file::open(): Corrupt file (not an it_file)");
00527   }
00528 
00529   fname = name;
00530 }
00531 
00532 void it_file::close()
00533 {
00534   s.close();
00535 }
00536 
00537 void it_file::flush()
00538 {
00539   s.flush();
00540 }
00541 
00542 void it_file::write_file_header()
00543 {
00544   s.write(file_magic, 4);
00545   s.put(file_version);
00546 }
00547 
00548 void it_file::write_data_header(const std::string &type, uint64_t size)
00549 {
00550   it_error_if(next_name == "", "it_file::write_data_header(): Can not "
00551               "write without a name");
00552   write_data_header(type, next_name, size, next_desc);
00553   next_name = "";
00554   next_desc = "";
00555 }
00556 
00557 void it_file::write_data_header(const std::string &type,
00558                                 const std::string &name, uint64_t size,
00559                                 const std::string &desc)
00560 {
00561   data_header h1, h2;
00562 
00563   // Prepare a new data header
00564   h1.hdr_bytes = 3 * sizeof(uint64_t) + type.size() + 1 + name.size() + 1
00565                  + desc.size() + 1;
00566   h1.data_bytes = size;
00567   h1.block_bytes = h1.hdr_bytes + h1.data_bytes;
00568   h1.name = name;
00569   h1.type = type;
00570   h1.desc = desc;
00571 
00572   // If variable exists, remove it first
00573   if (exists(name))
00574     remove();
00575 
00576   // Try to find an empty space
00577   s.clear();
00578   s.seekg(sizeof(file_header)); // skip file header
00579   while (true) {
00580     // save the current position
00581     std::streampos p = s.tellp();
00582     // read block at the current position
00583     read_data_header(h2);
00584     // if empty file, stop the search and set write pointer to the end of
00585     // file
00586     if (s.eof()) {
00587       s.clear();
00588       s.seekp(0, std::ios::end);
00589       break;
00590     }
00591     // save the size of the current read block
00592     std::streamoff skip = static_cast<std::streamoff>(h2.block_bytes);
00593     // check if we have enough empty space from previously deleted data
00594     if ((h2.type == "") && (h2.block_bytes >= h1.block_bytes)) {
00595       h1.block_bytes = h2.block_bytes;
00596       s.seekp(p);
00597       break;
00598     }
00599     // if not, maybe we can squeeze the current block to find space
00600     else if ((h2.block_bytes - h2.hdr_bytes - h2.data_bytes)
00601              >= h1.block_bytes) {
00602       h1.block_bytes = h2.block_bytes - h2.hdr_bytes - h2.data_bytes;
00603       h2.block_bytes = h2.hdr_bytes + h2.data_bytes;
00604       s.seekp(p);
00605       // rewrite squeezed data block
00606       write_data_header_here(h2);
00607       s.seekp(p + static_cast<std::streamoff>(h2.block_bytes));
00608       break;
00609     }
00610     // otherwise, skip the current block and try again
00611     s.seekg(p + skip);
00612   } // while(true)
00613 
00614   write_data_header_here(h1);
00615 }
00616 
00617 void it_file::write_data_header_here(const data_header &h)
00618 {
00619   s << h.hdr_bytes << h.data_bytes << h.block_bytes
00620   << h.name << h.type << h.desc;
00621 }
00622 
00623 void it_file::remove(const std::string &name)
00624 {
00625   seek(name);
00626   remove();
00627 }
00628 
00629 void it_file::remove()
00630 {
00631   data_header h;
00632   std::streampos p;
00633 
00634   p = s.tellp();
00635   read_data_header(h);
00636   h.type = "";
00637   h.name = "";
00638   h.desc = "";
00639   h.hdr_bytes = 3 * sizeof(uint64_t) + 1 + 1 + 1;
00640   h.data_bytes = 0;
00641   s.seekp(p);
00642   write_data_header_here(h);
00643   s.seekp(p + static_cast<std::streamoff>(h.block_bytes));
00644 }
00645 
00646 bool it_file::exists(const std::string &name)
00647 {
00648   return seek(name);
00649 }
00650 
00651 void it_file::pack()
00652 {
00653   it_assert(s.is_open(), "it_file::pack(): File has to be open");
00654 
00655   // check total file size
00656   s.seekg(0, std::ios::end);
00657   std::streampos p = s.tellg();
00658   s.seekg(0, std::ios::beg);
00659   s.clear();
00660 
00661   // allocate buffer of size equal to file size
00662   char* buffer = new char[int(p)];
00663   char* b_ptr = buffer;
00664 
00665   // copy file header and start counting the size of compacted file
00666   uint64_t size;
00667   for (size = 0; size < sizeof(file_header); ++size)
00668     s.get(*b_ptr++);
00669 
00670   // remove empty space between data blocks
00671   data_header h;
00672   while (true) {
00673     p = s.tellg();
00674     read_data_header(h);
00675     if (s.eof()) {
00676       s.clear();
00677       break;
00678     }
00679     if (h.type != "") {
00680       s.seekg(p);
00681       for (uint64_t i = 0; i < h.hdr_bytes + h.data_bytes; ++i)
00682         s.get(*b_ptr++);
00683       size += h.hdr_bytes + h.data_bytes;
00684     }
00685     s.seekg(p + static_cast<std::streamoff>(h.block_bytes));
00686   }
00687 
00688   // close and reopen file truncating it
00689   s.close();
00690   s.open(fname, true, bfstream_base::l_endian);
00691   // write compacted data to the reopend empty file
00692   for (uint64_t i = 0; i < size; ++i)
00693     s.put(buffer[i]);
00694 
00695   // free buffer memory
00696   delete buffer;
00697 
00698   // go back to the first data block (skiping file header)
00699   s.seekg(sizeof(file_header));
00700 
00701   // update block_bytes in headers of compacted data blocks
00702   while (true) {
00703     p = s.tellg();
00704     read_data_header(h);
00705     if (s.eof()) {
00706       s.clear();
00707       break;
00708     }
00709     if (h.hdr_bytes + h.data_bytes < h.block_bytes) {
00710       h.block_bytes = h.hdr_bytes + h.data_bytes;
00711       s.seekp(p);
00712       write_data_header_here(h);
00713     }
00714     s.seekg(p + static_cast<std::streamoff>(h.block_bytes));
00715   }
00716 }
00717 
00718 void it_file::low_level_write(char x)
00719 {
00720   s << x;
00721 }
00722 
00723 void it_file::low_level_write(uint64_t x)
00724 {
00725   s << x;
00726 }
00727 
00728 void it_file::low_level_write(bool x)
00729 {
00730   s << static_cast<char>(x);
00731 }
00732 
00733 void it_file::low_level_write(bin x)
00734 {
00735   s << x.value();
00736 }
00737 
00738 void it_file::low_level_write(short x)
00739 {
00740   s << static_cast<int16_t>(x);
00741 }
00742 
00743 void it_file::low_level_write(int x)
00744 {
00745   s << static_cast<int32_t>(x);
00746 }
00747 
00748 void it_file::low_level_write(float x)
00749 {
00750   s << x;
00751 }
00752 
00753 void it_file::low_level_write(double x)
00754 {
00755   s << x;
00756 }
00757 
00758 void it_file::low_level_write(const std::complex<float> &x)
00759 {
00760   s << x.real();
00761   s << x.imag();
00762 }
00763 
00764 void it_file::low_level_write(const std::complex<double> &x)
00765 {
00766   s << x.real();
00767   s << x.imag();
00768 }
00769 
00770 void it_file::low_level_write(const bvec &v)
00771 {
00772   s << static_cast<uint64_t>(v.size());
00773   for (int i = 0; i < v.size(); ++i)
00774     s << v(i).value();
00775 }
00776 
00777 void it_file::low_level_write(const svec &v)
00778 {
00779   s << static_cast<uint64_t>(v.size());
00780   for (int i = 0; i < v.size(); ++i)
00781     s << static_cast<int16_t>(v(i));
00782 }
00783 
00784 void it_file::low_level_write(const ivec &v)
00785 {
00786   s << static_cast<uint64_t>(v.size());
00787   for (int i = 0; i < v.size(); ++i)
00788     s << static_cast<int32_t>(v(i));
00789 }
00790 
00791 void it_file::low_level_write(const vec &v)
00792 {
00793   s << static_cast<uint64_t>(v.size());
00794   if (get_low_precision()) {
00795     for (int i = 0; i < v.size(); ++i)
00796       s << static_cast<float>(v(i));
00797   }
00798   else {
00799     for (int i = 0; i < v.size(); ++i)
00800       s << v(i);
00801   }
00802 }
00803 
00804 void it_file::low_level_write(const cvec &v)
00805 {
00806   s << static_cast<uint64_t>(v.size());
00807   if (get_low_precision()) {
00808     for (int i = 0; i < v.size(); ++i) {
00809       s << static_cast<float>(v(i).real());
00810       s << static_cast<float>(v(i).imag());
00811     }
00812   }
00813   else {
00814     for (int i = 0; i < v.size(); ++i) {
00815       s << v(i).real();
00816       s << v(i).imag();
00817     }
00818   }
00819 }
00820 
00821 void it_file::low_level_write(const std::string &str)
00822 {
00823   s << static_cast<uint64_t>(str.size());
00824   for (std::string::size_type i = 0; i < str.size(); ++i)
00825     s << str[i];
00826 }
00827 
00828 void it_file::low_level_write(const bmat &m)
00829 {
00830   s << static_cast<uint64_t>(m.rows())
00831   << static_cast<uint64_t>(m.cols());
00832   for (int j = 0; j < m.cols(); ++j)
00833     for (int i = 0; i < m.rows(); ++i)
00834       s << m(i, j).value();
00835 }
00836 
00837 void it_file::low_level_write(const smat &m)
00838 {
00839   s << static_cast<uint64_t>(m.rows())
00840   << static_cast<uint64_t>(m.cols());
00841   for (int j = 0; j < m.cols(); ++j)
00842     for (int i = 0; i < m.rows(); ++i)
00843       s << static_cast<int16_t>(m(i, j));
00844 }
00845 
00846 void it_file::low_level_write(const imat &m)
00847 {
00848   s << static_cast<uint64_t>(m.rows())
00849   << static_cast<uint64_t>(m.cols());
00850   for (int j = 0; j < m.cols(); ++j)
00851     for (int i = 0; i < m.rows(); ++i)
00852       s << static_cast<int32_t>(m(i, j));
00853 }
00854 
00855 void it_file::low_level_write(const mat &m)
00856 {
00857   s << static_cast<uint64_t>(m.rows())
00858   << static_cast<uint64_t>(m.cols());
00859   if (get_low_precision()) {
00860     for (int j = 0; j < m.cols(); ++j)
00861       for (int i = 0; i < m.rows(); ++i)
00862         s << static_cast<float>(m(i, j));
00863   }
00864   else {
00865     for (int j = 0; j < m.cols(); ++j)
00866       for (int i = 0; i < m.rows(); ++i)
00867         s << m(i, j);
00868   }
00869 }
00870 
00871 void it_file::low_level_write(const cmat &m)
00872 {
00873   s << static_cast<uint64_t>(m.rows())
00874   << static_cast<uint64_t>(m.cols());
00875   if (get_low_precision()) {
00876     for (int j = 0; j < m.cols(); ++j)
00877       for (int i = 0; i < m.rows(); ++i) {
00878         s << static_cast<float>(m(i, j).real());
00879         s << static_cast<float>(m(i, j).imag());
00880       }
00881   }
00882   else {
00883     for (int j = 0; j < m.cols(); ++j)
00884       for (int i = 0; i < m.rows(); ++i) {
00885         s << m(i, j).real();
00886         s << m(i, j).imag();
00887       }
00888   }
00889 }
00890 
00891 void it_file::low_level_write(const Array<bin> &v)
00892 {
00893   s << static_cast<uint64_t>(v.size());
00894   for (int i = 0; i < v.size(); ++i)
00895     s << v(i).value();
00896 }
00897 
00898 void it_file::low_level_write(const Array<short> &v)
00899 {
00900   s << static_cast<uint64_t>(v.size());
00901   for (int i = 0; i < v.size(); ++i)
00902     s << static_cast<int16_t>(v(i));
00903 }
00904 
00905 void it_file::low_level_write(const Array<int> &v)
00906 {
00907   s << static_cast<uint64_t>(v.size());
00908   for (int i = 0; i < v.size(); ++i)
00909     s << static_cast<int32_t>(v(i));
00910 }
00911 
00912 void it_file::low_level_write(const Array<float> &v)
00913 {
00914   s << static_cast<uint64_t>(v.size());
00915   for (int i = 0; i < v.size(); ++i)
00916     s << v(i);
00917 }
00918 
00919 void it_file::low_level_write(const Array<double> &v)
00920 {
00921   s << static_cast<uint64_t>(v.size());
00922   if (get_low_precision()) {
00923     for (int i = 0; i < v.size(); ++i)
00924       s << static_cast<float>(v(i));
00925   }
00926   else {
00927     for (int i = 0; i < v.size(); ++i)
00928       s << static_cast<double>(v(i));
00929   }
00930 }
00931 
00932 void it_file::low_level_write(const Array<std::complex<float> > &v)
00933 {
00934   s << static_cast<uint64_t>(v.size());
00935   for (int i = 0; i < v.size(); ++i) {
00936     s << v(i).real();
00937     s << v(i).imag();
00938   }
00939 }
00940 
00941 void it_file::low_level_write(const Array<std::complex<double> > &v)
00942 {
00943   s << static_cast<uint64_t>(v.size());
00944   if (get_low_precision()) {
00945     for (int i = 0; i < v.size(); ++i) {
00946       s << static_cast<float>(v(i).real());
00947       s << static_cast<float>(v(i).imag());
00948     }
00949   }
00950   else {
00951     for (int i = 0; i < v.size(); ++i) {
00952       s << v(i).real();
00953       s << v(i).imag();
00954     }
00955   }
00956 }
00957 
00958 
00959 it_ifile &operator>>(it_ifile &f, char &x)
00960 {
00961   it_file::data_header h;
00962   f.read_data_header(h);
00963   it_assert(h.type == "int8", "it_ifile::operator>>(): Wrong type");
00964   f.low_level_read(x);
00965   return f;
00966 }
00967 
00968 it_ifile &operator>>(it_ifile &f, bool &x)
00969 {
00970   it_file::data_header h;
00971   f.read_data_header(h);
00972   it_assert(h.type == "bool", "it_ifile::operator>>(): Wrong type");
00973   f.low_level_read(x);
00974   return f;
00975 }
00976 
00977 it_ifile &operator>>(it_ifile &f, bin &x)
00978 {
00979   it_file::data_header h;
00980   f.read_data_header(h);
00981   it_assert(h.type == "bin", "it_ifile::operator>>(): Wrong type");
00982   f.low_level_read(x);
00983   return f;
00984 }
00985 
00986 it_ifile &operator>>(it_ifile &f, short &x)
00987 {
00988   it_file::data_header h;
00989   f.read_data_header(h);
00990   it_assert(h.type == "int16", "it_ifile::operator>>(): Wrong type");
00991   f.low_level_read(x);
00992   return f;
00993 }
00994 
00995 it_ifile &operator>>(it_ifile &f, int &x)
00996 {
00997   it_file::data_header h;
00998   f.read_data_header(h);
00999   if (h.type == "int32")
01000     f.low_level_read(x);
01001   else if (h.type == "int16") {
01002     short x16;
01003     f.low_level_read(x16);
01004     x = static_cast<int>(x16);
01005   }
01006   else
01007     it_error("it_ifile::operator>>(): Wrong type");
01008 
01009   return f;
01010 }
01011 
01012 it_ifile &operator>>(it_ifile &f, float &x)
01013 {
01014   it_file::data_header h;
01015   f.read_data_header(h);
01016   it_assert(h.type == "float32", "it_ifile::operator>>(): Wrong type");
01017   f.low_level_read(x);
01018   return f;
01019 }
01020 
01021 it_ifile &operator>>(it_ifile &f, double &x)
01022 {
01023   it_file::data_header h;
01024   f.read_data_header(h);
01025   if (h.type == "float64")
01026     f.low_level_read(x);
01027   else if (h.type == "float32") {
01028     float f32;
01029     f.low_level_read(f32);
01030     x = static_cast<double>(f32);
01031   }
01032   else
01033     it_error("it_ifile::operator>>(): Wrong type");
01034 
01035   return f;
01036 }
01037 
01038 it_ifile &operator>>(it_ifile &f, std::complex<float> &x)
01039 {
01040   it_file::data_header h;
01041   f.read_data_header(h);
01042   it_assert(h.type == "cfloat32",
01043             "it_ifile::operator>>(): Wrong type");
01044   f.low_level_read(x);
01045   return f;
01046 }
01047 
01048 it_ifile &operator>>(it_ifile &f, std::complex<double> &x)
01049 {
01050   it_file::data_header h;
01051   f.read_data_header(h);
01052   if (h.type == "cfloat64")
01053     f.low_level_read(x);
01054   else if (h.type == "cfloat32") {
01055     std::complex<float> f32_c;
01056     f.low_level_read(f32_c);
01057     x = static_cast<std::complex<double> >(f32_c);
01058   }
01059   else
01060     it_error("it_ifile::operator>>(): Wrong type");
01061 
01062   return f;
01063 }
01064 
01065 it_ifile &operator>>(it_ifile &f, bvec &v)
01066 {
01067   it_file::data_header h;
01068   f.read_data_header(h);
01069   it_assert(h.type == "bvec", "it_ifile::operator>>(): Wrong type");
01070   f.low_level_read(v);
01071   return f;
01072 }
01073 
01074 it_ifile &operator>>(it_ifile &f, svec &v)
01075 {
01076   it_file::data_header h;
01077   f.read_data_header(h);
01078   it_assert(h.type == "svec", "it_ifile::operator>>(): Wrong type");
01079   f.low_level_read(v);
01080   return f;
01081 }
01082 
01083 it_ifile &operator>>(it_ifile &f, ivec &v)
01084 {
01085   it_file::data_header h;
01086   f.read_data_header(h);
01087   it_assert(h.type == "ivec", "it_ifile::operator>>(): Wrong type");
01088   f.low_level_read(v);
01089   return f;
01090 }
01091 
01092 it_ifile &operator>>(it_ifile &f, vec &v)
01093 {
01094   it_ifile::data_header h;
01095 
01096   f.read_data_header(h);
01097   if (h.type == "fvec")
01098     f.low_level_read_lo(v);
01099   else if (h.type == "dvec")
01100     f.low_level_read_hi(v);
01101   else
01102     it_error("it_ifile::operator>>(): Wrong type");
01103 
01104   return f;
01105 }
01106 
01107 it_ifile &operator>>(it_ifile &f, cvec &v)
01108 {
01109   it_file::data_header h;
01110 
01111   f.read_data_header(h);
01112   if (h.type == "fcvec")
01113     f.low_level_read_lo(v);
01114   else if (h.type == "dcvec")
01115     f.low_level_read_hi(v);
01116   else
01117     it_error("it_ifile::operator>>(): Wrong type");
01118 
01119   return f;
01120 }
01121 
01122 it_ifile &operator>>(it_ifile &f, std::string &str)
01123 {
01124   it_file::data_header h;
01125   f.read_data_header(h);
01126   it_assert(h.type == "string", "it_ifile::operator>>(): Wrong type");
01127   f.low_level_read(str);
01128   return f;
01129 }
01130 
01131 it_ifile &operator>>(it_ifile &f, bmat &m)
01132 {
01133   it_file::data_header h;
01134   f.read_data_header(h);
01135   it_assert(h.type == "bmat", "it_ifile::operator>>(): Wrong type");
01136   f.low_level_read(m);
01137   return f;
01138 }
01139 
01140 it_ifile &operator>>(it_ifile &f, smat &m)
01141 {
01142   it_file::data_header h;
01143   f.read_data_header(h);
01144   it_assert(h.type == "smat", "it_ifile::operator>>(): Wrong type");
01145   f.low_level_read(m);
01146   return f;
01147 }
01148 
01149 it_ifile &operator>>(it_ifile &f, imat &m)
01150 {
01151   it_file::data_header h;
01152   f.read_data_header(h);
01153   it_assert(h.type == "imat", "it_ifile::operator>>(): Wrong type");
01154   f.low_level_read(m);
01155   return f;
01156 }
01157 
01158 it_ifile &operator>>(it_ifile &f, mat &m)
01159 {
01160   it_file::data_header h;
01161 
01162   f.read_data_header(h);
01163   if (h.type == "fmat")
01164     f.low_level_read_lo(m);
01165   else if (h.type == "dmat")
01166     f.low_level_read_hi(m);
01167   else
01168     it_error("it_ifile::operator>>(): Wrong type");
01169 
01170   return f;
01171 }
01172 
01173 it_ifile &operator>>(it_ifile &f, cmat &m)
01174 {
01175   it_file::data_header h;
01176   f.read_data_header(h);
01177   if (h.type == "fcmat")
01178     f.low_level_read_lo(m);
01179   else if (h.type == "dcmat")
01180     f.low_level_read_hi(m);
01181   else
01182     it_error("it_ifile::operator>>(): Wrong type");
01183 
01184   return f;
01185 }
01186 
01187 it_ifile &operator>>(it_ifile &f, Array<bin> &v)
01188 {
01189   it_file::data_header h;
01190   f.read_data_header(h);
01191   it_assert(h.type == "bArray", "it_ifile::operator>>(): Wrong type");
01192   f.low_level_read(v);
01193   return f;
01194 }
01195 
01196 it_ifile &operator>>(it_ifile &f, Array<short> &v)
01197 {
01198   it_file::data_header h;
01199   f.read_data_header(h);
01200   it_assert(h.type == "sArray", "it_ifile::operator>>(): Wrong type");
01201   f.low_level_read(v);
01202   return f;
01203 }
01204 
01205 it_ifile &operator>>(it_ifile &f, Array<int> &v)
01206 {
01207   it_file::data_header h;
01208   f.read_data_header(h);
01209   it_assert(h.type == "iArray", "it_ifile::operator>>(): Wrong type");
01210   f.low_level_read(v);
01211   return f;
01212 }
01213 
01214 it_ifile &operator>>(it_ifile &f, Array<float> &v)
01215 {
01216   it_file::data_header h;
01217   f.read_data_header(h);
01218   it_assert(h.type == "fArray", "it_ifile::operator>>(): Wrong type");
01219   f.low_level_read(v);
01220   return f;
01221 }
01222 
01223 it_ifile &operator>>(it_ifile &f, Array<double> &v)
01224 {
01225   it_file::data_header h;
01226   f.read_data_header(h);
01227   if (h.type == "fArray")
01228     f.low_level_read_lo(v);
01229   else if (h.type == "dArray")
01230     f.low_level_read_hi(v);
01231   else
01232     it_error("it_ifile::operator>>(): Wrong type");
01233 
01234   return f;
01235 }
01236 
01237 it_ifile &operator>>(it_ifile &f, Array<std::complex<float> > &v)
01238 {
01239   it_file::data_header h;
01240   f.read_data_header(h);
01241   it_assert(h.type == "fcArray", "it_ifile::operator>>(): Wrong type");
01242   f.low_level_read(v);
01243   return f;
01244 }
01245 
01246 it_ifile &operator>>(it_ifile &f, Array<std::complex<double> > &v)
01247 {
01248   it_file::data_header h;
01249   f.read_data_header(h);
01250   if (h.type == "fcArray")
01251     f.low_level_read_lo(v);
01252   else if (h.type == "dcArray")
01253     f.low_level_read_hi(v);
01254   else
01255     it_error("it_ifile::operator>>(): Wrong type");
01256 
01257   return f;
01258 }
01259 
01260 it_ifile &operator>>(it_ifile &f, Array<bvec> &v)
01261 {
01262   it_file::data_header h;
01263   f.read_data_header(h);
01264   it_assert(h.type == "bvecArray", "it_ifile::operator>>(): Wrong type");
01265   uint64_t n;
01266   f.low_level_read(n);
01267   int size = static_cast<int>(n);
01268   v.set_size(size, false);
01269   for (int i = 0; i < size; ++i)
01270     f.low_level_read(v(i));
01271 
01272   return f;
01273 }
01274 
01275 it_ifile &operator>>(it_ifile &f, Array<svec> &v)
01276 {
01277   it_file::data_header h;
01278   f.read_data_header(h);
01279   it_assert(h.type == "svecArray", "it_ifile::operator>>(): Wrong type");
01280   uint64_t n;
01281   f.low_level_read(n);
01282   int size = static_cast<int>(n);
01283   v.set_size(size, false);
01284   for (int i = 0; i < size; ++i)
01285     f.low_level_read(v(i));
01286 
01287   return f;
01288 }
01289 
01290 it_ifile &operator>>(it_ifile &f, Array<ivec> &v)
01291 {
01292   it_file::data_header h;
01293   f.read_data_header(h);
01294   it_assert(h.type == "ivecArray", "it_ifile::operator>>(): Wrong type");
01295   uint64_t n;
01296   f.low_level_read(n);
01297   int size = static_cast<int>(n);
01298   v.set_size(size, false);
01299   for (int i = 0; i < size; ++i)
01300     f.low_level_read(v(i));
01301 
01302   return f;
01303 }
01304 
01305 it_ifile &operator>>(it_ifile &f, Array<vec> &v)
01306 {
01307   it_file::data_header h;
01308   f.read_data_header(h);
01309   it_assert(h.type == "vecArray", "it_ifile::operator>>(): Wrong type");
01310   uint64_t n;
01311   f.low_level_read(n);
01312   int size = static_cast<int>(n);
01313   v.set_size(size, false);
01314   for (int i = 0; i < size; ++i)
01315     f.low_level_read_hi(v(i));
01316 
01317   return f;
01318 }
01319 
01320 it_ifile &operator>>(it_ifile &f, Array<cvec> &v)
01321 {
01322   it_file::data_header h;
01323   f.read_data_header(h);
01324   it_assert(h.type == "cvecArray", "it_ifile::operator>>(): Wrong type");
01325   uint64_t n;
01326   f.low_level_read(n);
01327   int size = static_cast<int>(n);
01328   v.set_size(size, false);
01329   for (int i = 0; i < size; ++i)
01330     f.low_level_read_hi(v(i));
01331 
01332   return f;
01333 }
01334 
01335 it_ifile &operator>>(it_ifile &f, Array<std::string> &v)
01336 {
01337   it_file::data_header h;
01338   f.read_data_header(h);
01339   it_assert(h.type == "stringArray", "it_ifile::operator>>(): Wrong type");
01340   uint64_t n;
01341   f.low_level_read(n);
01342   int size = static_cast<int>(n);
01343   v.set_size(size, false);
01344   for (int i = 0; i < size; ++i)
01345     f.low_level_read(v(i));
01346 
01347   return f;
01348 }
01349 
01350 it_ifile &operator>>(it_ifile &f, Array<bmat> &v)
01351 {
01352   it_file::data_header h;
01353   f.read_data_header(h);
01354   it_assert(h.type == "bmatArray", "it_ifile::operator>>(): Wrong type");
01355   uint64_t n;
01356   f.low_level_read(n);
01357   int size = static_cast<int>(n);
01358   v.set_size(size, false);
01359   for (int i = 0; i < size; ++i)
01360     f.low_level_read(v(i));
01361 
01362   return f;
01363 }
01364 
01365 it_ifile &operator>>(it_ifile &f, Array<smat> &v)
01366 {
01367   it_file::data_header h;
01368   f.read_data_header(h);
01369   it_assert(h.type == "smatArray", "it_ifile::operator>>(): Wrong type");
01370   uint64_t n;
01371   f.low_level_read(n);
01372   int size = static_cast<int>(n);
01373   v.set_size(size, false);
01374   for (int i = 0; i < size; ++i)
01375     f.low_level_read(v(i));
01376 
01377   return f;
01378 }
01379 
01380 it_ifile &operator>>(it_ifile &f, Array<imat> &v)
01381 {
01382   it_file::data_header h;
01383   f.read_data_header(h);
01384   it_assert(h.type == "imatArray", "it_ifile::operator>>(): Wrong type");
01385   uint64_t n;
01386   f.low_level_read(n);
01387   int size = static_cast<int>(n);
01388   v.set_size(size, false);
01389   for (int i = 0; i < size; ++i)
01390     f.low_level_read(v(i));
01391 
01392   return f;
01393 }
01394 
01395 it_ifile &operator>>(it_ifile &f, Array<mat> &v)
01396 {
01397   it_file::data_header h;
01398   f.read_data_header(h);
01399   it_assert(h.type == "matArray", "it_ifile::operator>>(): Wrong type");
01400   uint64_t n;
01401   f.low_level_read(n);
01402   int size = static_cast<int>(n);
01403   v.set_size(size, false);
01404   for (int i = 0; i < size; ++i)
01405     f.low_level_read_hi(v(i));
01406 
01407   return f;
01408 }
01409 
01410 it_ifile &operator>>(it_ifile &f, Array<cmat> &v)
01411 {
01412   it_file::data_header h;
01413   f.read_data_header(h);
01414   it_assert(h.type == "cmatArray", "it_ifile::operator>>(): Wrong type");
01415   uint64_t n;
01416   f.low_level_read(n);
01417   int size = static_cast<int>(n);
01418   v.set_size(size, false);
01419   for (int i = 0; i < size; ++i)
01420     f.low_level_read_hi(v(i));
01421 
01422   return f;
01423 }
01424 
01425 
01426 it_file &operator<<(it_file &f, char x)
01427 {
01428   f.write_data_header("int8", sizeof(char));
01429   f.low_level_write(x);
01430   return f;
01431 }
01432 
01433 it_file &operator<<(it_file &f, bool x)
01434 {
01435   f.write_data_header("bool", sizeof(char));
01436   f.low_level_write(x);
01437   return f;
01438 }
01439 
01440 it_file &operator<<(it_file &f, bin x)
01441 {
01442   f.write_data_header("bin", sizeof(char));
01443   f.low_level_write(x);
01444   return f;
01445 }
01446 
01447 it_file &operator<<(it_file &f, short x)
01448 {
01449   f.write_data_header("int16", sizeof(int16_t));
01450   f.low_level_write(x);
01451   return f;
01452 }
01453 
01454 it_file &operator<<(it_file &f, int x)
01455 {
01456   f.write_data_header("int32", sizeof(int32_t));
01457   f.low_level_write(x);
01458   return f;
01459 }
01460 
01461 it_file &operator<<(it_file &f, float x)
01462 {
01463   f.write_data_header("float32", sizeof(float));
01464   f.low_level_write(x);
01465   return f;
01466 }
01467 
01468 it_file &operator<<(it_file &f, double x)
01469 {
01470   f.write_data_header("float64", sizeof(double));
01471   f.low_level_write(x);
01472   return f;
01473 }
01474 
01475 it_file &operator<<(it_file &f, std::complex<float> x)
01476 {
01477   f.write_data_header("cfloat32", 2 * sizeof(float));
01478   f.low_level_write(x);
01479   return f;
01480 }
01481 
01482 it_file &operator<<(it_file &f, std::complex<double> x)
01483 {
01484   f.write_data_header("cfloat64", 2 * sizeof(double));
01485   f.low_level_write(x);
01486   return f;
01487 }
01488 
01489 it_file &operator<<(it_file &f, const bvec &v)
01490 {
01491   f.write_data_header("bvec", sizeof(uint64_t) + v.size() * sizeof(char));
01492   f.low_level_write(v);
01493   return f;
01494 }
01495 
01496 it_file &operator<<(it_file &f, const svec &v)
01497 {
01498   f.write_data_header("svec", sizeof(uint64_t) + v.size() * sizeof(int16_t));
01499   f.low_level_write(v);
01500   return f;
01501 }
01502 
01503 it_file &operator<<(it_file &f, const ivec &v)
01504 {
01505   f.write_data_header("ivec", sizeof(uint64_t) + v.size() * sizeof(int32_t));
01506   f.low_level_write(v);
01507   return f;
01508 }
01509 
01510 it_file &operator<<(it_file &f, const vec &v)
01511 {
01512   if (f.get_low_precision())
01513     f.write_data_header("fvec", sizeof(uint64_t)
01514                         + v.size() * sizeof(float));
01515   else
01516     f.write_data_header("dvec", sizeof(uint64_t)
01517                         + v.size() * sizeof(double));
01518   f.low_level_write(v);
01519   return f;
01520 }
01521 
01522 it_file &operator<<(it_file &f, const cvec &v)
01523 {
01524   if (f.get_low_precision())
01525     f.write_data_header("fcvec", sizeof(uint64_t)
01526                         + v.size() * 2 * sizeof(float));
01527   else
01528     f.write_data_header("dcvec", sizeof(uint64_t)
01529                         + v.size() * 2 * sizeof(double));
01530   f.low_level_write(v);
01531   return f;
01532 }
01533 
01534 it_file &operator<<(it_file &f, const std::string &str)
01535 {
01536   f.write_data_header("string", sizeof(uint64_t) + str.size() * sizeof(char));
01537   f.low_level_write(str);
01538   return f;
01539 }
01540 
01541 it_file &operator<<(it_file &f, const bmat &m)
01542 {
01543   f.write_data_header("bmat", 2 * sizeof(uint64_t)
01544                       + m.rows() * m.cols() * sizeof(char));
01545   f.low_level_write(m);
01546   return f;
01547 }
01548 
01549 it_file &operator<<(it_file &f, const smat &m)
01550 {
01551   f.write_data_header("smat", 2 * sizeof(uint64_t)
01552                       + m.rows() * m.cols() * sizeof(int16_t));
01553   f.low_level_write(m);
01554   return f;
01555 }
01556 
01557 it_file &operator<<(it_file &f, const imat &m)
01558 {
01559   f.write_data_header("imat", 2 * sizeof(uint64_t)
01560                       + m.rows() * m.cols() * sizeof(int32_t));
01561   f.low_level_write(m);
01562   return f;
01563 }
01564 
01565 it_file &operator<<(it_file &f, const mat &m)
01566 {
01567   if (f.get_low_precision())
01568     f.write_data_header("fmat", 2 * sizeof(uint64_t)
01569                         + m.rows() * m.cols() * sizeof(float));
01570   else
01571     f.write_data_header("dmat", 2 * sizeof(uint64_t)
01572                         + m.rows() * m.cols() * sizeof(double));
01573   f.low_level_write(m);
01574   return f;
01575 }
01576 
01577 it_file &operator<<(it_file &f, const cmat &m)
01578 {
01579   if (f.get_low_precision())
01580     f.write_data_header("fcmat", 2 * sizeof(uint64_t)
01581                         + m.rows() * m.cols() * 2 * sizeof(float));
01582   else
01583     f.write_data_header("dcmat", 2 * sizeof(uint64_t)
01584                         + m.rows() * m.cols() * 2 * sizeof(double));
01585   f.low_level_write(m);
01586   return f;
01587 }
01588 
01589 it_file &operator<<(it_file &f, const Array<bin> &v)
01590 {
01591   f.write_data_header("bArray", sizeof(uint64_t) + v.size() * sizeof(char));
01592   f.low_level_write(v);
01593   return f;
01594 }
01595 
01596 it_file &operator<<(it_file &f, const Array<short> &v)
01597 {
01598   f.write_data_header("sArray", sizeof(uint64_t)
01599                       + v.size() * sizeof(int16_t));
01600   f.low_level_write(v);
01601   return f;
01602 }
01603 
01604 it_file &operator<<(it_file &f, const Array<int> &v)
01605 {
01606   f.write_data_header("iArray", sizeof(uint64_t)
01607                       + v.size() * sizeof(int32_t));
01608   f.low_level_write(v);
01609   return f;
01610 }
01611 
01612 it_file &operator<<(it_file &f, const Array<float> &v)
01613 {
01614   f.write_data_header("fArray", sizeof(uint64_t) + v.size() * sizeof(float));
01615   f.low_level_write(v);
01616   return f;
01617 }
01618 
01619 it_file &operator<<(it_file &f, const Array<double> &v)
01620 {
01621   if (f.get_low_precision())
01622     f.write_data_header("fArray", sizeof(uint64_t)
01623                         + v.size() * sizeof(float));
01624   else
01625     f.write_data_header("dArray", sizeof(uint64_t)
01626                         + v.size() * sizeof(double));
01627   f.low_level_write(v);
01628   return f;
01629 }
01630 
01631 it_file &operator<<(it_file &f, const Array<std::complex<float> > &v)
01632 {
01633   f.write_data_header("fcArray", sizeof(uint64_t)
01634                       + v.size() * 2 * sizeof(float));
01635   f.low_level_write(v);
01636   return f;
01637 }
01638 
01639 it_file &operator<<(it_file &f, const Array<std::complex<double> > &v)
01640 {
01641   if (f.get_low_precision())
01642     f.write_data_header("fcArray", sizeof(uint64_t)
01643                         + v.size() * 2 * sizeof(float));
01644   else
01645     f.write_data_header("dcArray", sizeof(uint64_t)
01646                         + v.size() * 2 * sizeof(double));
01647   f.low_level_write(v);
01648   return f;
01649 }
01650 
01651 it_file &operator<<(it_file &f, const Array<bvec> &v)
01652 {
01653   // calculate total length of Array
01654   int sum_l = 0;
01655   for (int i = 0; i < v.size(); ++i)
01656     sum_l += v(i).size();
01657 
01658   // write header
01659   f.write_data_header("bvecArray", sizeof(uint64_t) * (1 + v.size())
01660                       + sum_l * sizeof(char));
01661   // write the length of the array
01662   f.low_level_write(static_cast<uint64_t>(v.size()));
01663 
01664   // write one vector at a time (i.e. size and elements)
01665   for (int i = 0; i < v.size(); ++i)
01666     f.low_level_write(v(i));
01667 
01668   return f;
01669 }
01670 
01671 it_file &operator<<(it_file &f, const Array<svec> &v)
01672 {
01673   // calculate total length of Array
01674   int sum_l = 0;
01675   for (int i = 0; i < v.size(); ++i)
01676     sum_l += v(i).size();
01677 
01678   // write header
01679   f.write_data_header("svecArray", sizeof(uint64_t) * (1 + v.size())
01680                       + sum_l * sizeof(int16_t));
01681   // write the length of the array
01682   f.low_level_write(static_cast<uint64_t>(v.size()));
01683 
01684   // write one vector at a time (i.e. size and elements)
01685   for (int i = 0; i < v.size(); ++i)
01686     f.low_level_write(v(i));
01687 
01688   return f;
01689 }
01690 
01691 it_file &operator<<(it_file &f, const Array<ivec> &v)
01692 {
01693   // calculate total length of Array
01694   int sum_l = 0;
01695   for (int i = 0; i < v.size(); ++i)
01696     sum_l += v(i).size();
01697 
01698   // write header
01699   f.write_data_header("ivecArray", sizeof(uint64_t) * (1 + v.size())
01700                       + sum_l * sizeof(int32_t));
01701   // write the length of the array
01702   f.low_level_write(static_cast<uint64_t>(v.size()));
01703 
01704   // write one vector at a time (i.e. size and elements)
01705   for (int i = 0; i < v.size(); ++i)
01706     f.low_level_write(v(i));
01707 
01708   return f;
01709 }
01710 
01711 it_file &operator<<(it_file &f, const Array<vec> &v)
01712 {
01713   // calculate total length of Array
01714   int sum_l = 0;
01715   for (int i = 0; i < v.size(); ++i)
01716     sum_l += v(i).size();
01717 
01718   // write header
01719   f.write_data_header("vecArray", sizeof(uint64_t) * (1 + v.size())
01720                       + sum_l * sizeof(double));
01721   // write the length of the array
01722   f.low_level_write(static_cast<uint64_t>(v.size()));
01723 
01724   // write one vector at a time (i.e. size and elements)
01725   for (int i = 0; i < v.size(); ++i)
01726     f.low_level_write(v(i));
01727 
01728   return f;
01729 }
01730 
01731 it_file &operator<<(it_file &f, const Array<cvec> &v)
01732 {
01733   // calculate total length of Array
01734   int sum_l = 0;
01735   for (int i = 0; i < v.size(); ++i)
01736     sum_l += v(i).size();
01737 
01738   // write header
01739   f.write_data_header("cvecArray", sizeof(uint64_t) * (1 + v.size())
01740                       + sum_l * 2 * sizeof(double));
01741   // write the length of the array
01742   f.low_level_write(static_cast<uint64_t>(v.size()));
01743 
01744   // write one vector at a time (i.e. size and elements)
01745   for (int i = 0; i < v.size(); ++i)
01746     f.low_level_write(v(i));
01747 
01748   return f;
01749 }
01750 
01751 it_file &operator<<(it_file &f, const Array<std::string> &v)
01752 {
01753   // calculate total length of Array
01754   int sum_l = 0;
01755   for (int i = 0; i < v.size(); ++i)
01756     sum_l += v(i).size();
01757 
01758   // write header
01759   f.write_data_header("stringArray", sizeof(uint64_t) * (1 + v.size())
01760                       + sum_l * sizeof(char));
01761   // write the length of the array
01762   f.low_level_write(static_cast<uint64_t>(v.size()));
01763 
01764   // write one vector at a time (i.e. size and elements)
01765   for (int i = 0; i < v.size(); ++i)
01766     f.low_level_write(v(i));
01767 
01768   return f;
01769 }
01770 
01771 it_file &operator<<(it_file &f, const Array<bmat> &v)
01772 {
01773   // calculate total length of Array
01774   int sum_l = 0;
01775   for (int i = 0; i < v.size(); ++i)
01776     sum_l += v(i)._datasize();
01777 
01778   // write header
01779   f.write_data_header("bmatArray", sizeof(uint64_t) * (1 + 2 * v.size())
01780                       + sum_l * sizeof(char));
01781   // write the length of the array
01782   f.low_level_write(static_cast<uint64_t>(v.size()));
01783 
01784   // write one vector at a time (i.e. size and elements)
01785   for (int i = 0; i < v.size(); ++i)
01786     f.low_level_write(v(i));
01787 
01788   return f;
01789 }
01790 
01791 it_file &operator<<(it_file &f, const Array<smat> &v)
01792 {
01793   // calculate total length of Array
01794   int sum_l = 0;
01795   for (int i = 0; i < v.size(); ++i)
01796     sum_l += v(i)._datasize();
01797 
01798   // write header
01799   f.write_data_header("smatArray", sizeof(uint64_t) * (1 + 2 * v.size())
01800                       + sum_l * sizeof(int16_t));
01801   // write the length of the array
01802   f.low_level_write(static_cast<uint64_t>(v.size()));
01803 
01804   // write one vector at a time (i.e. size and elements)
01805   for (int i = 0; i < v.size(); ++i)
01806     f.low_level_write(v(i));
01807 
01808   return f;
01809 }
01810 
01811 it_file &operator<<(it_file &f, const Array<imat> &v)
01812 {
01813   // calculate total length of Array
01814   int sum_l = 0;
01815   for (int i = 0; i < v.size(); ++i)
01816     sum_l += v(i)._datasize();
01817 
01818   // write header
01819   f.write_data_header("imatArray", sizeof(uint64_t) * (1 + 2 * v.size())
01820                       + sum_l * sizeof(int32_t));
01821   // write the length of the array
01822   f.low_level_write(static_cast<uint64_t>(v.size()));
01823 
01824   // write one vector at a time (i.e. size and elements)
01825   for (int i = 0; i < v.size(); ++i)
01826     f.low_level_write(v(i));
01827 
01828   return f;
01829 }
01830 
01831 it_file &operator<<(it_file &f, const Array<mat> &v)
01832 {
01833   // calculate total length of Array
01834   int sum_l = 0;
01835   for (int i = 0; i < v.size(); ++i)
01836     sum_l += v(i)._datasize();
01837 
01838   // write header
01839   f.write_data_header("matArray", sizeof(uint64_t) * (1 + 2 * v.size())
01840                       + sum_l * sizeof(double));
01841   // write the length of the array
01842   f.low_level_write(static_cast<uint64_t>(v.size()));
01843 
01844   // write one vector at a time (i.e. size and elements)
01845   for (int i = 0; i < v.size(); ++i)
01846     f.low_level_write(v(i));
01847 
01848   return f;
01849 }
01850 
01851 it_file &operator<<(it_file &f, const Array<cmat> &v)
01852 {
01853   // calculate total length of Array
01854   int sum_l = 0;
01855   for (int i = 0; i < v.size(); ++i)
01856     sum_l += v(i)._datasize();
01857 
01858   // write header
01859   f.write_data_header("cmatArray", sizeof(uint64_t) * (1 + 2 * v.size())
01860                       + sum_l * 2 * sizeof(double));
01861   // write the length of the array
01862   f.low_level_write(static_cast<uint64_t>(v.size()));
01863 
01864   // write one vector at a time (i.e. size and elements)
01865   for (int i = 0; i < v.size(); ++i)
01866     f.low_level_write(v(i));
01867 
01868   return f;
01869 }
01870 
01871 
01872 
01873 // ----------------------------------------------------------------------
01874 // Deprecated implementation of IT++ file format version 2
01875 // Will be removed in future versions
01876 // ----------------------------------------------------------------------
01877 
01878 char it_file_base_old::file_magic[4] = { 'I', 'T', '+', '+' };
01879 char it_file_base_old::file_version = 2;
01880 
01881 it_ifile_old::it_ifile_old()
01882 {
01883 }
01884 
01885 it_ifile_old::it_ifile_old(const std::string &name)
01886 {
01887   open(name);
01888 }
01889 
01890 void it_ifile_old::open(const std::string &name)
01891 {
01892   it_assert(exist(name), "File does not exist");
01893 
01894   s.open_readonly(name);
01895 
01896   if (!read_check_file_header()) {
01897     s.close();
01898     it_error("Corrupt file (Not an it-file)");
01899   }
01900 
01901 }
01902 
01903 void it_ifile_old::close()
01904 {
01905   s.close();
01906 }
01907 
01908 bool it_ifile_old::seek(const std::string &name)
01909 {
01910   data_header h;
01911   std::streampos p;
01912 
01913   s.clear();
01914   s.seekg(sizeof(file_header));
01915 
01916   while (true) {
01917     p = s.tellg();
01918     read_data_header(h);
01919     if (s.eof()) {
01920       s.clear();
01921       return false;
01922     }
01923     if (h.type != "" && h.name == name) {
01924       s.seekg(p);
01925       break;
01926     }
01927     s.seekg(p + static_cast<std::streamoff>(h.block_bytes));
01928   }
01929 
01930   return true;
01931 }
01932 
01933 bool it_ifile_old::seek(int n)
01934 {
01935   data_header h;
01936   std::streampos p;
01937 
01938   s.clear();
01939   s.seekg(sizeof(file_header));
01940   for (int i = 0; i <= n; i++) {
01941     p = s.tellg(); // changed from tellp() since probably an error
01942     read_data_header(h);
01943     if (s.eof()) {
01944       s.clear();
01945       return false;
01946     }
01947     if (h.type == "")
01948       i--;
01949     s.seekg(i == n ? p : p + static_cast<std::streamoff>(h.block_bytes));
01950   }
01951   return true;
01952 }
01953 
01954 void it_ifile_old::info(std::string &name, std::string &type, int &bytes)
01955 {
01956   data_header h;
01957   std::streampos p;
01958 
01959   p = s.tellg(); // changed from tellp()
01960   read_data_header(h);
01961   s.seekg(p);
01962   name = h.name;
01963   type = h.type;
01964   bytes = h.data_bytes;
01965 }
01966 
01967 bool it_ifile_old::read_check_file_header()
01968 {
01969   file_header h;
01970 
01971   memset(&h, 0, sizeof(h)); // Clear the struct
01972   s.read(reinterpret_cast<char *>(&h), sizeof(h));
01973 
01974   return (memcmp(h.magic, file_magic, 4) == 0 && (h.version <= file_version));
01975 }
01976 
01977 void it_ifile_old::read_data_header(data_header &h)
01978 {
01979   std::streampos p = s.tellg();
01980   s.clear();
01981   s >> h.endianity;
01982   if (s.eof())
01983     return;
01984   s.set_endianity(static_cast<bfstream_base::endian>(h.endianity));
01985   uint32_t tmp;
01986   s >> tmp;
01987   h.hdr_bytes = tmp;
01988   s >> tmp;
01989   h.data_bytes = tmp;
01990   s >> tmp;
01991   h.block_bytes = tmp;
01992   s >> h.name;
01993   s >> h.type;
01994   s.seekg(p + static_cast<std::streamoff>(h.hdr_bytes));
01995 }
01996 
01997 void it_ifile_old::low_level_read(char &x)
01998 {
01999   s >> x;
02000 }
02001 
02002 void it_ifile_old::low_level_read(bin &x)
02003 {
02004   s >> x;
02005 }
02006 
02007 void it_ifile_old::low_level_read(short &x)
02008 {
02009   s >> x;
02010 }
02011 
02012 void it_ifile_old::low_level_read(int &x)
02013 {
02014   int32_t tmp;
02015   s >> tmp;
02016   x = tmp;
02017 }
02018 
02019 void it_ifile_old::low_level_read(float &x)
02020 {
02021   s >> x;
02022 }
02023 
02024 void it_ifile_old::low_level_read(double &x)
02025 {
02026   s >> x;
02027 }
02028 
02029 void it_ifile_old::low_level_read(std::complex<float> &x)
02030 {
02031   float x_real, x_imag;
02032   s >> x_real;
02033   s >> x_imag;
02034   x = std::complex<float>(x_real, x_imag);
02035 }
02036 
02037 void it_ifile_old::low_level_read(std::complex<double> &x)
02038 {
02039   double x_real, x_imag;
02040   s >> x_real;
02041   s >> x_imag;
02042   x = std::complex<double>(x_real, x_imag);
02043 }
02044 
02045 void it_ifile_old::low_level_read_lo(vec &v)
02046 {
02047   int32_t i;
02048   float val;
02049 
02050   s >> i;
02051   v.set_size(i, false);
02052   for (i = 0; i < v.size(); i++) {
02053     s >> val;
02054     v(i) = static_cast<double>(val);
02055   }
02056 }
02057 
02058 void it_ifile_old::low_level_read_hi(vec &v)
02059 {
02060   int32_t i;
02061   double val;
02062 
02063   s >> i;
02064   v.set_size(i, false);
02065   for (i = 0; i < v.size(); i++) {
02066     s >> val;
02067     v(i) = static_cast<double>(val);
02068   }
02069 }
02070 
02071 void it_ifile_old::low_level_read(ivec &v)
02072 {
02073   int32_t i, val;
02074 
02075   s >> i;
02076   v.set_size(i, false);
02077   for (i = 0; i < v.size(); i++) {
02078     s >> val;
02079     v(i) = val;
02080   }
02081 }
02082 
02083 void it_ifile_old::low_level_read(bvec &v)
02084 {
02085   int32_t i;
02086 
02087   s >> i;
02088   v.set_size(i, false);
02089   for (i = 0; i < v.size(); i++)
02090     s >> v(i);
02091 }
02092 
02093 void it_ifile_old::low_level_read_lo(cvec &v)
02094 {
02095   int32_t i;
02096   float val_real, val_imag;
02097 
02098   s >> i;
02099   v.set_size(i, false);
02100   for (i = 0; i < v.size(); i++) {
02101     s >> val_real;
02102     s >> val_imag;
02103     v(i) = std::complex<double>(val_real, val_imag);
02104   }
02105 }
02106 
02107 void it_ifile_old::low_level_read_hi(cvec &v)
02108 {
02109   int32_t i;
02110   double val_real, val_imag;
02111 
02112   s >> i;
02113   v.set_size(i, false);
02114   for (i = 0; i < v.size(); i++) {
02115     s >> val_real;
02116     s >> val_imag;
02117     v(i) = std::complex<double>(val_real, val_imag);
02118   }
02119 }
02120 
02121 void it_ifile_old::low_level_read(std::string &str)
02122 {
02123   int32_t i, j;
02124   char val;
02125   str = "";
02126 
02127   s >> i;
02128 
02129   for (j = 0; j < i; j++) {
02130     s >> val;
02131     str += val;
02132   }
02133 }
02134 
02135 void it_ifile_old::low_level_read_lo(mat &m)
02136 {
02137   int32_t i, j;
02138   float val;
02139 
02140   s >> i >> j;
02141   m.set_size(i, j, false);
02142   for (j = 0; j < m.cols(); j++)
02143     for (i = 0; i < m.rows(); i++) {
02144       s >> val;
02145       m(i, j) = static_cast<double>(val);
02146     }
02147 }
02148 
02149 void it_ifile_old::low_level_read_hi(mat &m)
02150 {
02151   int32_t i, j;
02152   double val;
02153 
02154   s >> i >> j;
02155   m.set_size(i, j, false);
02156   for (j = 0; j < m.cols(); j++)
02157     for (i = 0; i < m.rows(); i++) {
02158       s >> val;
02159       m(i, j) = static_cast<double>(val);
02160     }
02161 }
02162 
02163 void it_ifile_old::low_level_read(imat &m)
02164 {
02165   int32_t i, j, val;
02166 
02167   s >> i >> j;
02168   m.set_size(i, j, false);
02169   for (j = 0; j < m.cols(); j++)
02170     for (i = 0; i < m.rows(); i++) {
02171       s >> val;
02172       m(i, j) = val;
02173     }
02174 }
02175 
02176 void it_ifile_old::low_level_read(bmat &m)
02177 {
02178   int32_t i, j;
02179 
02180   s >> i >> j;
02181   m.set_size(i, j, false);
02182   for (j = 0; j < m.cols(); j++)
02183     for (i = 0; i < m.rows(); i++)
02184       s >> m(i, j);
02185 }
02186 
02187 void it_ifile_old::low_level_read_lo(cmat &m)
02188 {
02189   int32_t i, j;
02190   float val_real, val_imag;
02191 
02192   s >> i >> j;
02193   m.set_size(i, j, false);
02194   for (j = 0; j < m.cols(); j++)
02195     for (i = 0; i < m.rows(); i++) {
02196       s >> val_real;
02197       s >> val_imag;
02198       m(i, j) = std::complex<double>(val_real, val_imag);
02199     }
02200 }
02201 
02202 void it_ifile_old::low_level_read_hi(cmat &m)
02203 {
02204   int32_t i, j;
02205   double val_real, val_imag;
02206 
02207   s >> i >> j;
02208   m.set_size(i, j, false);
02209   for (j = 0; j < m.cols(); j++)
02210     for (i = 0; i < m.rows(); i++) {
02211       s >> val_real;
02212       s >> val_imag;
02213       m(i, j) = std::complex<double>(val_real, val_imag);
02214     }
02215 }
02216 
02217 
02218 void it_ifile_old::low_level_read_lo(Array<float> &v)
02219 {
02220   int32_t i;
02221   float val;
02222 
02223   s >> i;
02224   v.set_size(i, false);
02225   for (i = 0; i < v.size(); i++) {
02226     s >> val;
02227     v(i) = val;
02228   }
02229 }
02230 
02231 void it_ifile_old::low_level_read_lo(Array<double> &v)
02232 {
02233   int32_t i;
02234   float val;
02235 
02236   s >> i;
02237   v.set_size(i, false);
02238   for (i = 0; i < v.size(); i++) {
02239     s >> val;
02240     v(i) = static_cast<double>(val);
02241   }
02242 }
02243 
02244 void it_ifile_old::low_level_read_hi(Array<double> &v)
02245 {
02246   int32_t i;
02247   double val;
02248 
02249   s >> i;
02250   v.set_size(i, false);
02251   for (i = 0; i < v.size(); i++) {
02252     s >> val;
02253     v(i) = static_cast<double>(val);
02254   }
02255 }
02256 
02257 void it_ifile_old::low_level_read(Array<int> &v)
02258 {
02259   int32_t i, val;
02260 
02261   s >> i;
02262   v.set_size(i, false);
02263   for (i = 0; i < v.size(); i++) {
02264     s >> val;
02265     v(i) = val;
02266   }
02267 }
02268 
02269 void it_ifile_old::low_level_read(Array<bin> &v)
02270 {
02271   int32_t i;
02272 
02273   s >> i;
02274   v.set_size(i, false);
02275   for (i = 0; i < v.size(); i++)
02276     s >> v(i);
02277 }
02278 
02279 void it_ifile_old::low_level_read_lo(Array<std::complex<float> > &v)
02280 {
02281   int32_t i;
02282   float val_real, val_imag;
02283 
02284   s >> i;
02285   v.set_size(i, false);
02286   for (i = 0; i < v.size(); i++) {
02287     s >> val_real;
02288     s >> val_imag;
02289     v(i) = std::complex<float>(val_real, val_imag);
02290   }
02291 }
02292 
02293 void it_ifile_old::low_level_read_lo(Array<std::complex<double> > &v)
02294 {
02295   int32_t i;
02296   float val_real, val_imag;
02297 
02298   s >> i;
02299   v.set_size(i, false);
02300   for (i = 0; i < v.size(); i++) {
02301     s >> val_real;
02302     s >> val_imag;
02303     v(i) = std::complex<double>(val_real, val_imag);
02304   }
02305 }
02306 
02307 void it_ifile_old::low_level_read_hi(Array<std::complex<double> > &v)
02308 {
02309   int32_t i;
02310   double val_real, val_imag;
02311 
02312   s >> i;
02313   v.set_size(i, false);
02314   for (i = 0; i < v.size(); i++) {
02315     s >> val_real;
02316     s >> val_imag;
02317     v(i) = std::complex<double>(val_real, val_imag);
02318   }
02319 }
02320 
02321 it_file_old::it_file_old()
02322 {
02323   low_prec = false;
02324   next_name = "";
02325 }
02326 
02327 it_file_old::it_file_old(const std::string &name, bool trunc)
02328 {
02329   low_prec = false;
02330   next_name = "";
02331   open(name, trunc);
02332 }
02333 
02334 void it_file_old::open(const std::string &name, bool trunc)
02335 {
02336   if (!exist(name))
02337     trunc = true;
02338 
02339   s.open(name, trunc);
02340   it_error_if(!s.is_open(), "Could not open file for writing");
02341 
02342   if (trunc)
02343     write_file_header();
02344   else if (!read_check_file_header()) {
02345     s.close();
02346     it_error("Corrupt file (Not an it-file)");
02347   }
02348 }
02349 
02350 void it_file_old::close()
02351 {
02352   s.close();
02353 }
02354 
02355 void it_file_old::flush()
02356 {
02357   s.flush();
02358 }
02359 
02360 void it_file_old::write_file_header()
02361 {
02362   s.write(file_magic, 4);
02363   s << file_version;
02364 }
02365 
02366 void it_file_old::write_data_header(const std::string &type, uint32_t size)
02367 {
02368   it_error_if(next_name == "", "Try to write without a name");
02369   write_data_header(type, next_name, size);
02370   next_name = "";
02371 }
02372 
02373 void it_file_old::write_data_header(const std::string &type,
02374                                     const std::string &name, uint32_t size)
02375 {
02376   data_header h1, h2;
02377   std::streampos p;
02378   int availpos = 0;
02379   bool removed = false;
02380   int skip;
02381 
02382   h1.endianity = static_cast<char>(s.get_native_endianity());
02383   h1.hdr_bytes = 1 + 3 * 4 + type.size() + 1 + name.size() + 1;
02384   h1.data_bytes = size;
02385   h1.block_bytes = h1.hdr_bytes + h1.data_bytes;
02386   h1.name = name;
02387   h1.type = type;
02388 
02389   if (exists(name))
02390     remove();
02391 
02392   // Try to find an empty space
02393   s.clear();
02394   s.seekg(sizeof(file_header));
02395   while (true) {
02396     p = s.tellp();
02397     read_data_header(h2);
02398     if (s.eof()) {
02399       s.clear();
02400       break;
02401     }
02402     skip = h2.block_bytes;
02403     if (h2.type != "" && h2.name == name) {
02404       s.seekg(p);
02405       remove();
02406       s.seekg(p);
02407       read_data_header(h2);
02408       removed = true;
02409       if (availpos != 0)
02410         break;
02411     }
02412     if (availpos == 0) {
02413       if (h2.type == "" && h2.block_bytes >= h1.block_bytes) {
02414         h1.block_bytes = h2.block_bytes;
02415         availpos = int(p);
02416       }
02417       else if (h2.block_bytes - h2.hdr_bytes - h2.data_bytes >= h1.block_bytes) {
02418         h1.block_bytes = h2.block_bytes - h2.hdr_bytes - h2.data_bytes;
02419         h2.block_bytes = h2.hdr_bytes + h2.data_bytes;
02420         s.seekp(p);
02421         write_data_header_here(h2);
02422         availpos = static_cast<int>(p) + h2.block_bytes;
02423         if (removed)
02424           break;
02425       }
02426     }
02427     s.seekg(p + static_cast<std::streamoff>(skip));
02428   }
02429   if (availpos != 0)
02430     s.seekp(availpos);
02431   else
02432     s.seekp(0, std::ios::end);
02433 
02434   write_data_header_here(h1);
02435 }
02436 
02437 void it_file_old::write_data_header_here(const data_header &h)
02438 {
02439   s.set_endianity(static_cast<bfstream_base::endian>(h.endianity));
02440   s << h.endianity << h.hdr_bytes << h.data_bytes << h.block_bytes << h.name << h.type;
02441 }
02442 
02443 void it_file_old::remove(const std::string &name)
02444 {
02445   seek(name);
02446   remove();
02447 }
02448 
02449 void it_file_old::remove()
02450 {
02451   data_header h;
02452   std::streampos p;
02453 
02454   p = s.tellp();
02455   read_data_header(h);
02456   h.type = "";
02457   h.name = "";
02458   h.hdr_bytes = 1 + 3 * 4 + 1 + 1;
02459   h.data_bytes = 0;
02460   s.seekp(p);
02461   write_data_header_here(h);
02462   s.seekp(p + static_cast<std::streamoff>(h.block_bytes));
02463 }
02464 
02465 bool it_file_old::exists(const std::string &name)
02466 {
02467   if (seek(name))
02468     return true;
02469   else
02470     return false;
02471 }
02472 
02473 void it_file_old::pack()
02474 {
02475   it_warning("pack() is not implemented!");
02476 }
02477 
02478 void it_file_old::low_level_write(char x)
02479 {
02480   s << x;
02481 }
02482 
02483 void it_file_old::low_level_write(bin x)
02484 {
02485   s << x.value();
02486 }
02487 
02488 void it_file_old::low_level_write(short x)
02489 {
02490   s << x;
02491 }
02492 
02493 void it_file_old::low_level_write(int x)
02494 {
02495   s << static_cast<int32_t>(x);
02496 }
02497 
02498 void it_file_old::low_level_write(float x)
02499 {
02500   s << x;
02501 }
02502 
02503 void it_file_old::low_level_write(double x)
02504 {
02505   s << x;
02506 }
02507 
02508 void it_file_old::low_level_write(const std::complex<float> &x)
02509 {
02510   s << x.real();
02511   s << x.imag();
02512 }
02513 
02514 void it_file_old::low_level_write(const std::complex<double> &x)
02515 {
02516   s << x.real();
02517   s << x.imag();
02518 }
02519 
02520 void it_file_old::low_level_write(const vec &v)
02521 {
02522   if (get_low_precision()) {
02523     s << static_cast<int32_t>(v.size());
02524     for (int i = 0; i < v.size(); i++)
02525       s << static_cast<float>(v(i));
02526   }
02527   else {
02528     s << static_cast<int32_t>(v.size());
02529     for (int i = 0; i < v.size(); i++)
02530       s << static_cast<double>(v(i));
02531   }
02532 }
02533 
02534 void it_file_old::low_level_write(const ivec &v)
02535 {
02536   s << static_cast<int32_t>(v.size());
02537   for (int i = 0; i < v.size(); i++)
02538     s << static_cast<int32_t>(v(i));
02539 }
02540 
02541 void it_file_old::low_level_write(const bvec &v)
02542 {
02543   s << static_cast<int32_t>(v.size());
02544   for (int i = 0; i < v.size(); i++)
02545     s << v(i).value();
02546 }
02547 
02548 void it_file_old::low_level_write(const cvec &v)
02549 {
02550   if (get_low_precision()) {
02551     s << static_cast<int32_t>(v.size());
02552     for (int i = 0; i < v.size(); i++) {
02553       s << static_cast<float>(v(i).real());
02554       s << static_cast<float>(v(i).imag());
02555     }
02556   }
02557   else {
02558     s << static_cast<int32_t>(v.size());
02559     for (int i = 0; i < v.size(); i++) {
02560       s << static_cast<double>(v(i).real());
02561       s << static_cast<double>(v(i).imag());
02562     }
02563   }
02564 }
02565 
02566 void it_file_old::low_level_write(const std::string &str)
02567 {
02568   int size = str.size();
02569   s << static_cast<int32_t>(size);
02570 
02571   for (int i = 0; i < size; i++)
02572     s << str[i];
02573 }
02574 
02575 void it_file_old::low_level_write(const mat &m)
02576 {
02577   int i, j;
02578 
02579   if (get_low_precision()) {
02580     s << static_cast<int32_t>(m.rows()) << static_cast<int32_t>(m.cols());
02581     for (j = 0; j < m.cols(); j++)
02582       for (i = 0; i < m.rows(); i++)
02583         s << static_cast<float>(m(i, j));
02584   }
02585   else {
02586     s << static_cast<int32_t>(m.rows()) << static_cast<int32_t>(m.cols());
02587     for (j = 0; j < m.cols(); j++)
02588       for (i = 0; i < m.rows(); i++)
02589         s << static_cast<double>(m(i, j));
02590   }
02591 }
02592 
02593 void it_file_old::low_level_write(const imat &m)
02594 {
02595   int i, j;
02596 
02597   s << static_cast<int32_t>(m.rows()) << static_cast<int32_t>(m.cols());
02598   for (j = 0; j < m.cols(); j++)
02599     for (i = 0; i < m.rows(); i++)
02600       s << static_cast<int32_t>(m(i, j));
02601 }
02602 
02603 void it_file_old::low_level_write(const bmat &m)
02604 {
02605   int i, j;
02606 
02607   s << static_cast<int32_t>(m.rows()) << static_cast<int32_t>(m.cols());
02608   for (j = 0; j < m.cols(); j++)
02609     for (i = 0; i < m.rows(); i++)
02610       s << m(i, j).value();
02611 }
02612 
02613 void it_file_old::low_level_write(const cmat &m)
02614 {
02615   int i, j;
02616 
02617   if (get_low_precision()) {
02618     s << static_cast<int32_t>(m.rows()) << static_cast<int32_t>(m.cols());
02619     for (j = 0; j < m.cols(); j++)
02620       for (i = 0; i < m.rows(); i++) {
02621         s << static_cast<float>(m(i, j).real());
02622         s << static_cast<float>(m(i, j).imag());
02623       }
02624 
02625   }
02626   else {
02627     s << static_cast<int32_t>(m.rows()) << static_cast<int32_t>(m.cols());
02628     for (j = 0; j < m.cols(); j++)
02629       for (i = 0; i < m.rows(); i++) {
02630         s << static_cast<double>(m(i, j).real());
02631         s << static_cast<double>(m(i, j).imag());
02632       }
02633   }
02634 }
02635 
02636 void it_file_old::low_level_write(const Array<float> &v)
02637 {
02638   s << static_cast<int32_t>(v.size());
02639   for (int i = 0; i < v.size(); i++)
02640     s << v(i);
02641 }
02642 
02643 void it_file_old::low_level_write(const Array<double> &v)
02644 {
02645   if (get_low_precision()) {
02646     s << static_cast<int32_t>(v.size());
02647     for (int i = 0; i < v.size(); i++)
02648       s << static_cast<float>(v(i));
02649   }
02650   else {
02651     s << static_cast<int32_t>(v.size());
02652     for (int i = 0; i < v.size(); i++)
02653       s << static_cast<double>(v(i));
02654   }
02655 }
02656 
02657 void it_file_old::low_level_write(const Array<int> &v)
02658 {
02659   s << static_cast<int32_t>(v.size());
02660   for (int i = 0; i < v.size(); i++)
02661     s << static_cast<int32_t>(v(i));
02662 }
02663 
02664 void it_file_old::low_level_write(const Array<bin> &v)
02665 {
02666   s << static_cast<int32_t>(v.size());
02667   for (int i = 0; i < v.size(); i++)
02668     s << v(i).value();
02669 }
02670 
02671 void it_file_old::low_level_write(const Array<std::complex<float> > &v)
02672 {
02673   s << static_cast<int32_t>(v.size());
02674   for (int i = 0; i < v.size(); i++) {
02675     s << v(i).real();
02676     s << v(i).imag();
02677   }
02678 }
02679 
02680 void it_file_old::low_level_write(const Array<std::complex<double> > &v)
02681 {
02682   if (get_low_precision()) {
02683     s << static_cast<int32_t>(v.size());
02684     for (int i = 0; i < v.size(); i++) {
02685       s << static_cast<float>(v(i).real());
02686       s << static_cast<float>(v(i).imag());
02687     }
02688   }
02689   else {
02690     s << static_cast<int32_t>(v.size());
02691     for (int i = 0; i < v.size(); i++) {
02692       s << static_cast<double>(v(i).real());
02693       s << static_cast<double>(v(i).imag());
02694     }
02695   }
02696 }
02697 
02698 it_ifile_old &operator>>(it_ifile_old &f, char &x)
02699 {
02700   it_file_old::data_header h;
02701 
02702   f.read_data_header(h);
02703   if (h.type == "int8")
02704     f.low_level_read(x);
02705   else
02706     it_error("Wrong type");
02707 
02708   return f;
02709 }
02710 
02711 it_ifile_old &operator>>(it_ifile_old &f, bin &x)
02712 {
02713   it_file_old::data_header h;
02714 
02715   f.read_data_header(h);
02716   if (h.type == "bin")
02717     f.low_level_read(x);
02718   else
02719     it_error("Wrong type");
02720 
02721   return f;
02722 }
02723 
02724 it_ifile_old &operator>>(it_ifile_old &f, short &x)
02725 {
02726   it_file_old::data_header h;
02727 
02728   f.read_data_header(h);
02729   if (h.type == "int16")
02730     f.low_level_read(x);
02731   else
02732     it_error("Wrong type");
02733 
02734   return f;
02735 }
02736 
02737 it_ifile_old &operator>>(it_ifile_old &f, int &x)
02738 {
02739   it_file_old::data_header h;
02740 
02741   f.read_data_header(h);
02742   if (h.type == "int32")
02743     f.low_level_read(x);
02744   else if (h.type == "int16") {
02745     short x16;
02746     f.low_level_read(x16);
02747     x = x16;
02748   }
02749   else
02750     it_error("Wrong type");
02751 
02752   return f;
02753 }
02754 
02755 it_ifile_old &operator>>(it_ifile_old &f, double &x)
02756 {
02757   it_file_old::data_header h;
02758 
02759   f.read_data_header(h);
02760   if (h.type == "float64")
02761     f.low_level_read(x);
02762   else if (h.type == "float32") {
02763     float f32;
02764     f.low_level_read(f32);
02765     x = f32;
02766   }
02767   else
02768     it_error("Wrong type");
02769 
02770   return f;
02771 }
02772 
02773 it_ifile_old &operator>>(it_ifile_old &f, float &x)
02774 {
02775   it_file_old::data_header h;
02776 
02777   f.read_data_header(h);
02778   if (h.type == "float32")
02779     f.low_level_read(x);
02780   else
02781     it_error("Wrong type");
02782 
02783   return f;
02784 }
02785 
02786 it_ifile_old &operator>>(it_ifile_old &f, std::complex<float> &x)
02787 {
02788   it_file_old::data_header h;
02789 
02790   f.read_data_header(h);
02791 
02792   if (h.type == "float32_complex") {
02793     std::complex<float> f32_c;
02794     f.low_level_read(f32_c);
02795     x = f32_c;
02796   }
02797   else
02798     it_error("Wrong type");
02799 
02800   return f;
02801 }
02802 
02803 it_ifile_old &operator>>(it_ifile_old &f, std::complex<double> &x)
02804 {
02805   it_file_old::data_header h;
02806 
02807   f.read_data_header(h);
02808   if (h.type == "float64_complex")
02809     f.low_level_read(x);
02810   else if (h.type == "float32_complex") {
02811     std::complex<float> f32_c;
02812     f.low_level_read(f32_c);
02813     x = f32_c;
02814   }
02815   else
02816     it_error("Wrong type");
02817 
02818   return f;
02819 }
02820 
02821 it_ifile_old &operator>>(it_ifile_old &f, vec &v)
02822 {
02823   it_ifile_old::data_header h;
02824 
02825   f.read_data_header(h);
02826   if (h.type == "fvec")
02827     f.low_level_read_lo(v);
02828   else if (h.type == "dvec")
02829     f.low_level_read_hi(v);
02830   else
02831     it_error("Wrong type");
02832 
02833   return f;
02834 }
02835 
02836 it_ifile_old &operator>>(it_ifile_old &f, ivec &v)
02837 {
02838   it_file_old::data_header h;
02839 
02840   f.read_data_header(h);
02841   if (h.type == "ivec")
02842     f.low_level_read(v);
02843   else
02844     it_error("Wrong type");
02845 
02846   return f;
02847 }
02848 
02849 it_ifile_old &operator>>(it_ifile_old &f, bvec &v)
02850 {
02851   it_file_old::data_header h;
02852 
02853   f.read_data_header(h);
02854   if (h.type == "bvec")
02855     f.low_level_read(v);
02856   else
02857     it_error("Wrong type");
02858 
02859   return f;
02860 }
02861 
02862 it_ifile_old &operator>>(it_ifile_old &f, cvec &v)
02863 {
02864   it_file_old::data_header h;
02865 
02866   f.read_data_header(h);
02867   if (h.type == "fcvec")
02868     f.low_level_read_lo(v);
02869   else if (h.type == "dcvec")
02870     f.low_level_read_hi(v);
02871   else
02872     it_error("Wrong type");
02873 
02874   return f;
02875 }
02876 
02877 it_ifile_old &operator>>(it_ifile_old &f, std::string &str)
02878 {
02879   it_file_old::data_header h;
02880 
02881   f.read_data_header(h);
02882   if (h.type == "string")
02883     f.low_level_read(str);
02884   else
02885     it_error("Wrong type");
02886 
02887   return f;
02888 }
02889 
02890 it_ifile_old &operator>>(it_ifile_old &f, mat &m)
02891 {
02892   it_file_old::data_header h;
02893 
02894   f.read_data_header(h);
02895   if (h.type == "fmat")
02896     f.low_level_read_lo(m);
02897   else if (h.type == "dmat")
02898     f.low_level_read_hi(m);
02899   else
02900     it_error("Wrong type");
02901 
02902   return f;
02903 }
02904 
02905 it_ifile_old &operator>>(it_ifile_old &f, imat &m)
02906 {
02907   it_file_old::data_header h;
02908 
02909   f.read_data_header(h);
02910   if (h.type == "imat")
02911     f.low_level_read(m);
02912   else
02913     it_error("Wrong type");
02914 
02915   return f;
02916 }
02917 
02918 it_ifile_old &operator>>(it_ifile_old &f, bmat &m)
02919 {
02920   it_file_old::data_header h;
02921 
02922   f.read_data_header(h);
02923   if (h.type == "bmat")
02924     f.low_level_read(m);
02925   else
02926     it_error("Wrong type");
02927 
02928   return f;
02929 }
02930 
02931 it_ifile_old &operator>>(it_ifile_old &f, cmat &m)
02932 {
02933   it_file_old::data_header h;
02934 
02935   f.read_data_header(h);
02936   if (h.type == "fcmat")
02937     f.low_level_read_lo(m);
02938   else if (h.type == "dcmat")
02939     f.low_level_read_hi(m);
02940   else
02941     it_error("Wrong type");
02942 
02943   return f;
02944 }
02945 
02946 it_ifile_old &operator>>(it_ifile_old &f, Array<float> &v)
02947 {
02948   it_file_old::data_header h;
02949 
02950   f.read_data_header(h);
02951   if (h.type == "fArray")
02952     f.low_level_read_lo(v);
02953   else
02954     it_error("Wrong type");
02955 
02956   return f;
02957 }
02958 
02959 it_ifile_old &operator>>(it_ifile_old &f, Array<double> &v)
02960 {
02961   it_file_old::data_header h;
02962 
02963   f.read_data_header(h);
02964   if (h.type == "fArray")
02965     f.low_level_read_lo(v);
02966   else if (h.type == "dArray")
02967     f.low_level_read_hi(v);
02968   else
02969     it_error("Wrong type");
02970 
02971   return f;
02972 }
02973 
02974 it_ifile_old &operator>>(it_ifile_old &f, Array<int> &v)
02975 {
02976   it_file_old::data_header h;
02977 
02978   f.read_data_header(h);
02979   if (h.type == "iArray")
02980     f.low_level_read(v);
02981   else
02982     it_error("Wrong type");
02983 
02984   return f;
02985 }
02986 
02987 it_ifile_old &operator>>(it_ifile_old &f, Array<bin> &v)
02988 {
02989   it_file_old::data_header h;
02990 
02991   f.read_data_header(h);
02992   if (h.type == "bArray")
02993     f.low_level_read(v);
02994   else
02995     it_error("Wrong type");
02996 
02997   return f;
02998 }
02999 
03000 it_ifile_old &operator>>(it_ifile_old &f, Array<std::complex<float> > &v)
03001 {
03002   it_file_old::data_header h;
03003 
03004   f.read_data_header(h);
03005   if (h.type == "fcArray")
03006     f.low_level_read_lo(v);
03007   else
03008     it_error("Wrong type");
03009 
03010   return f;
03011 }
03012 
03013 it_ifile_old &operator>>(it_ifile_old &f, Array<std::complex<double> > &v)
03014 {
03015   it_file_old::data_header h;
03016 
03017   f.read_data_header(h);
03018   if (h.type == "fcArray")
03019     f.low_level_read_lo(v);
03020   else if (h.type == "dcArray")
03021     f.low_level_read_hi(v);
03022   else
03023     it_error("Wrong type");
03024 
03025   return f;
03026 }
03027 
03028 it_ifile_old &operator>>(it_ifile_old &f, Array<vec> &v)
03029 {
03030   it_file_old::data_header h;
03031 
03032   f.read_data_header(h);
03033   if (h.type == "vecArray") {
03034     int n;
03035     f.low_level_read(n);
03036     v.set_size(n, false);
03037     for (int i = 0; i < n; i++)
03038       f.low_level_read_hi(v(i));
03039   }
03040   else
03041     it_error("Wrong type");
03042 
03043   return f;
03044 }
03045 
03046 it_ifile_old &operator>>(it_ifile_old &f, Array<ivec> &v)
03047 {
03048   it_file_old::data_header h;
03049 
03050   f.read_data_header(h);
03051   if (h.type == "ivecArray") {
03052     int n;
03053     f.low_level_read(n);
03054     v.set_size(n, false);
03055     for (int i = 0; i < n; i++)
03056       f.low_level_read(v(i));
03057   }
03058   else
03059     it_error("Wrong type");
03060 
03061   return f;
03062 }
03063 
03064 it_ifile_old &operator>>(it_ifile_old &f, Array<bvec> &v)
03065 {
03066   it_file_old::data_header h;
03067 
03068   f.read_data_header(h);
03069   if (h.type == "bvecArray") {
03070     int n;
03071     f.low_level_read(n);
03072     v.set_size(n, false);
03073     for (int i = 0; i < n; i++)
03074       f.low_level_read(v(i));
03075   }
03076   else
03077     it_error("Wrong type");
03078 
03079   return f;
03080 }
03081 
03082 it_ifile_old &operator>>(it_ifile_old &f, Array<cvec> &v)
03083 {
03084   it_file_old::data_header h;
03085 
03086   f.read_data_header(h);
03087   if (h.type == "cvecArray") {
03088     int n;
03089     f.low_level_read(n);
03090     v.set_size(n, false);
03091     for (int i = 0; i < n; i++)
03092       f.low_level_read_hi(v(i));
03093   }
03094   else
03095     it_error("Wrong type");
03096 
03097   return f;
03098 }
03099 
03100 it_ifile_old &operator>>(it_ifile_old &f, Array<std::string> &v)
03101 {
03102   it_file_old::data_header h;
03103 
03104   f.read_data_header(h);
03105   if (h.type == "stringArray") {
03106     int n;
03107     f.low_level_read(n);
03108     v.set_size(n, false);
03109     for (int i = 0; i < n; i++)
03110       f.low_level_read(v(i));
03111   }
03112   else
03113     it_error("Wrong type");
03114 
03115   return f;
03116 }
03117 
03118 it_ifile_old &operator>>(it_ifile_old &f, Array<mat> &v)
03119 {
03120   it_file_old::data_header h;
03121 
03122   f.read_data_header(h);
03123   if (h.type == "matArray") {
03124     int n;
03125     f.low_level_read(n);
03126     v.set_size(n, false);
03127     for (int i = 0; i < n; i++)
03128       f.low_level_read_hi(v(i));
03129   }
03130   else
03131     it_error("Wrong type");
03132 
03133   return f;
03134 }
03135 
03136 it_ifile_old &operator>>(it_ifile_old &f, Array<imat> &v)
03137 {
03138   it_file_old::data_header h;
03139 
03140   f.read_data_header(h);
03141   if (h.type == "imatArray") {
03142     int n;
03143     f.low_level_read(n);
03144     v.set_size(n, false);
03145     for (int i = 0; i < n; i++)
03146       f.low_level_read(v(i));
03147   }
03148   else
03149     it_error("Wrong type");
03150 
03151   return f;
03152 }
03153 
03154 it_ifile_old &operator>>(it_ifile_old &f, Array<bmat> &v)
03155 {
03156   it_file_old::data_header h;
03157 
03158   f.read_data_header(h);
03159   if (h.type == "bmatArray") {
03160     int n;
03161     f.low_level_read(n);
03162     v.set_size(n, false);
03163     for (int i = 0; i < n; i++)
03164       f.low_level_read(v(i));
03165   }
03166   else
03167     it_error("Wrong type");
03168 
03169   return f;
03170 }
03171 
03172 it_ifile_old &operator>>(it_ifile_old &f, Array<cmat> &v)
03173 {
03174   it_file_old::data_header h;
03175 
03176   f.read_data_header(h);
03177   if (h.type == "cmatArray") {
03178     int n;
03179     f.low_level_read(n);
03180     v.set_size(n, false);
03181     for (int i = 0; i < n; i++)
03182       f.low_level_read_hi(v(i));
03183   }
03184   else
03185     it_error("Wrong type");
03186 
03187   return f;
03188 }
03189 
03190 it_file_old &operator<<(it_file_old &f, char x)
03191 {
03192   f.write_data_header("int8", sizeof(char));
03193   f.low_level_write(x);
03194 
03195   return f;
03196 }
03197 
03198 it_file_old &operator<<(it_file_old &f, bin x)
03199 {
03200   f.write_data_header("bin", sizeof(bin));
03201   f.low_level_write(x);
03202 
03203   return f;
03204 }
03205 
03206 it_file_old &operator<<(it_file_old &f, short x)
03207 {
03208   f.write_data_header("int16", sizeof(short));
03209   f.low_level_write(x);
03210 
03211   return f;
03212 }
03213 
03214 it_file_old &operator<<(it_file_old &f, int x)
03215 {
03216   f.write_data_header("int32", sizeof(int));
03217   f.low_level_write(x);
03218 
03219   return f;
03220 }
03221 
03222 it_file_old &operator<<(it_file_old &f, float x)
03223 {
03224   f.write_data_header("float32", sizeof(float));
03225   f.low_level_write(x);
03226 
03227   return f;
03228 }
03229 
03230 it_file_old &operator<<(it_file_old &f, double x)
03231 {
03232   f.write_data_header("float64", sizeof(double));
03233   f.low_level_write(x);
03234 
03235   return f;
03236 }
03237 
03238 it_file_old &operator<<(it_file_old &f, std::complex<float> x)
03239 {
03240   f.write_data_header("float32_complex", 2*sizeof(float));
03241   f.low_level_write(x);
03242 
03243   return f;
03244 }
03245 
03246 it_file_old &operator<<(it_file_old &f, std::complex<double> x)
03247 {
03248   f.write_data_header("float64_complex", 2*sizeof(double));
03249   f.low_level_write(x);
03250 
03251   return f;
03252 }
03253 
03254 it_file_old &operator<<(it_file_old &f, const vec &v)
03255 {
03256   if (f.get_low_precision())
03257     f.write_data_header("fvec", sizeof(int) + v.size() * sizeof(float));
03258   else
03259     f.write_data_header("dvec", sizeof(int) + v.size() * sizeof(double));
03260   f.low_level_write(v);
03261 
03262   return f;
03263 }
03264 
03265 it_file_old &operator<<(it_file_old &f, const ivec &v)
03266 {
03267   f.write_data_header("ivec", (1 + v.size()) * sizeof(int));
03268   f.low_level_write(v);
03269 
03270   return f;
03271 }
03272 
03273 it_file_old &operator<<(it_file_old &f, const bvec &v)
03274 {
03275   f.write_data_header("bvec", sizeof(int) + v.size() * sizeof(bin));
03276   f.low_level_write(v);
03277 
03278   return f;
03279 }
03280 
03281 it_file_old &operator<<(it_file_old &f, const cvec &v)
03282 {
03283   if (f.get_low_precision())
03284     f.write_data_header("fcvec", sizeof(int) + v.size() * 2 * sizeof(float));
03285   else
03286     f.write_data_header("dcvec", sizeof(int) + v.size() * 2 * sizeof(double));
03287   f.low_level_write(v);
03288 
03289   return f;
03290 }
03291 
03292 it_file_old &operator<<(it_file_old &f, const std::string &str)
03293 {
03294   f.write_data_header("string", sizeof(int) + str.size() * sizeof(char));
03295   f.low_level_write(str);
03296 
03297   return f;
03298 }
03299 
03300 it_file_old &operator<<(it_file_old &f, const mat &m)
03301 {
03302   if (f.get_low_precision())
03303     f.write_data_header("fmat", 2*sizeof(int) + m.rows()*m.cols()*sizeof(float));
03304   else
03305     f.write_data_header("dmat", 2*sizeof(int) + m.rows()*m.cols()*sizeof(double));
03306   f.low_level_write(m);
03307 
03308   return f;
03309 }
03310 
03311 it_file_old &operator<<(it_file_old &f, const imat &m)
03312 {
03313   f.write_data_header("imat", (2 + m.rows()*m.cols()) * sizeof(int));
03314   f.low_level_write(m);
03315 
03316   return f;
03317 }
03318 
03319 it_file_old &operator<<(it_file_old &f, const bmat &m)
03320 {
03321   f.write_data_header("bmat", 2*sizeof(int) + m.rows()*m.cols()*sizeof(bin));
03322   f.low_level_write(m);
03323 
03324   return f;
03325 }
03326 
03327 it_file_old &operator<<(it_file_old &f, const cmat &m)
03328 {
03329   if (f.get_low_precision())
03330     f.write_data_header("fcmat", 2*sizeof(int) + 2*m.rows()*m.cols()*sizeof(float));
03331   else
03332     f.write_data_header("dcmat", 2*sizeof(int) + 2*m.rows()*m.cols()*sizeof(double));
03333   f.low_level_write(m);
03334 
03335   return f;
03336 }
03337 
03338 it_file_old &operator<<(it_file_old &f, const Array<float> &v)
03339 {
03340   f.write_data_header("fArray", sizeof(int) + v.size() * sizeof(float));
03341   f.low_level_write(v);
03342 
03343   return f;
03344 }
03345 
03346 it_file_old &operator<<(it_file_old &f, const Array<double> &v)
03347 {
03348   if (f.get_low_precision())
03349     f.write_data_header("fArray", sizeof(int) + v.size() * sizeof(float));
03350   else
03351     f.write_data_header("dArray", sizeof(int) + v.size() * sizeof(double));
03352   f.low_level_write(v);
03353 
03354   return f;
03355 }
03356 
03357 it_file_old &operator<<(it_file_old &f, const Array<int> &v)
03358 {
03359   f.write_data_header("iArray", (1 + v.size()) * sizeof(int));
03360   f.low_level_write(v);
03361 
03362   return f;
03363 }
03364 
03365 it_file_old &operator<<(it_file_old &f, const Array<bin> &v)
03366 {
03367   f.write_data_header("bArray", sizeof(int) + v.size() * sizeof(bin));
03368   f.low_level_write(v);
03369 
03370   return f;
03371 }
03372 
03373 it_file_old &operator<<(it_file_old &f, const Array<std::complex<float> > &v)
03374 {
03375   f.write_data_header("fcArray", sizeof(int) + v.size() * 2 * sizeof(float));
03376   f.low_level_write(v);
03377 
03378   return f;
03379 }
03380 
03381 it_file_old &operator<<(it_file_old &f, const Array<std::complex<double> > &v)
03382 {
03383   if (f.get_low_precision())
03384     f.write_data_header("fcArray", sizeof(int) + v.size() * 2 * sizeof(float));
03385   else
03386     f.write_data_header("dcArray", sizeof(int) + v.size() * 2 * sizeof(double));
03387   f.low_level_write(v);
03388 
03389   return f;
03390 }
03391 
03392 it_file_old &operator<<(it_file_old &f, const Array<vec> &v)
03393 {
03394   int i, sum_l = 0;
03395 
03396   // calculate total length of Array
03397   for (i = 0; i < v.size(); i++) {
03398     sum_l += v(i).size();
03399   }
03400 
03401   // write header
03402   f.write_data_header("vecArray", sizeof(int)*(1 + v.size()) + sum_l * sizeof(double));
03403 
03404   f.low_level_write(v.size());  // the length of the array
03405 
03406   // write one vector at a time (i.e. size and elements)
03407   for (i = 0; i < v.size(); i++)
03408     f.low_level_write(v(i));
03409 
03410   return f;
03411 }
03412 
03413 it_file_old &operator<<(it_file_old &f, const Array<ivec> &v)
03414 {
03415   int i, sum_l = 0;
03416 
03417   // calculate total length of Array
03418   for (i = 0; i < v.size(); i++) {
03419     sum_l += v(i).size();
03420   }
03421 
03422   // write header
03423   f.write_data_header("ivecArray", sizeof(int)*(1 + v.size()) + sum_l * sizeof(int));
03424 
03425   f.low_level_write(v.size());  // the length of the array
03426 
03427   // write one vector at a time (i.e. size and elements)
03428   for (i = 0; i < v.size(); i++)
03429     f.low_level_write(v(i));
03430 
03431   return f;
03432 }
03433 
03434 it_file_old &operator<<(it_file_old &f, const Array<bvec> &v)
03435 {
03436   int i, sum_l = 0;
03437 
03438   // calculate total length of Array
03439   for (i = 0; i < v.size(); i++) {
03440     sum_l += v(i).size();
03441   }
03442 
03443   // write header
03444   f.write_data_header("bvecArray", sizeof(int)*(1 + v.size()) + sum_l * sizeof(bin));
03445 
03446   f.low_level_write(v.size());  // the length of the array
03447 
03448   // write one vector at a time (i.e. size and elements)
03449   for (i = 0; i < v.size(); i++)
03450     f.low_level_write(v(i));
03451 
03452   return f;
03453 }
03454 
03455 it_file_old &operator<<(it_file_old &f, const Array<cvec> &v)
03456 {
03457   int i, sum_l = 0;
03458 
03459   // calculate total length of Array
03460   for (i = 0; i < v.size(); i++) {
03461     sum_l += v(i).size();
03462   }
03463 
03464   // write header
03465   f.write_data_header("cvecArray", sizeof(int)*(1 + v.size()) + sum_l * sizeof(std::complex<double>));
03466 
03467   f.low_level_write(v.size());  // the length of the array
03468 
03469   // write one vector at a time (i.e. size and elements)
03470   for (i = 0; i < v.size(); i++)
03471     f.low_level_write(v(i));
03472 
03473   return f;
03474 }
03475 
03476 it_file_old &operator<<(it_file_old &f, const Array<std::string> &v)
03477 {
03478   int i, sum_l = 0;
03479 
03480   // calculate total length of Array
03481   for (i = 0; i < v.size(); i++) {
03482     sum_l += v(i).size();
03483   }
03484 
03485   // write header
03486   f.write_data_header("stringArray", sizeof(int)*(1 + v.size()) + sum_l * sizeof(char));
03487 
03488   f.low_level_write(v.size());  // the length of the array
03489 
03490   // write one vector at a time (i.e. size and elements)
03491   for (i = 0; i < v.size(); i++)
03492     f.low_level_write(v(i));
03493 
03494   return f;
03495 }
03496 
03497 it_file_old &operator<<(it_file_old &f, const Array<mat> &v)
03498 {
03499   int i, sum_l = 0;
03500 
03501   // calculate total length of Array
03502   for (i = 0; i < v.size(); i++) {
03503     sum_l += v(i)._datasize();
03504   }
03505 
03506   // write header
03507   f.write_data_header("matArray", sizeof(int)*(1 + 2*v.size()) + sum_l * sizeof(double));
03508 
03509   f.low_level_write(v.size());  // the length of the array
03510 
03511   // write one matrix at a time (i.e. size and elements)
03512   for (i = 0; i < v.size(); i++)
03513     f.low_level_write(v(i));
03514 
03515   return f;
03516 }
03517 
03518 it_file_old &operator<<(it_file_old &f, const Array<imat> &v)
03519 {
03520   int i, sum_l = 0;
03521 
03522   // calculate total length of Array
03523   for (i = 0; i < v.size(); i++) {
03524     sum_l += v(i)._datasize();
03525   }
03526 
03527   // write header
03528   f.write_data_header("imatArray", sizeof(int)*(1 + 2*v.size()) + sum_l * sizeof(int));
03529 
03530   f.low_level_write(v.size());  // the length of the array
03531 
03532   // write one matrix at a time (i.e. size and elements)
03533   for (i = 0; i < v.size(); i++)
03534     f.low_level_write(v(i));
03535 
03536   return f;
03537 }
03538 
03539 it_file_old &operator<<(it_file_old &f, const Array<bmat> &v)
03540 {
03541   int i, sum_l = 0;
03542 
03543   // calculate total length of Array
03544   for (i = 0; i < v.size(); i++) {
03545     sum_l += v(i)._datasize();
03546   }
03547 
03548   // write header
03549   f.write_data_header("bmatArray", sizeof(int)*(1 + 2*v.size()) + sum_l * sizeof(bin));
03550 
03551   f.low_level_write(v.size());  // the length of the array
03552 
03553   // write one matrix at a time (i.e. size and elements)
03554   for (i = 0; i < v.size(); i++)
03555     f.low_level_write(v(i));
03556 
03557   return f;
03558 }
03559 
03560 it_file_old &operator<<(it_file_old &f, const Array<cmat> &v)
03561 {
03562   int i, sum_l = 0;
03563 
03564   // calculate total length of Array
03565   for (i = 0; i < v.size(); i++) {
03566     sum_l += v(i)._datasize();
03567   }
03568 
03569   // write header
03570   f.write_data_header("cmatArray", sizeof(int)*(1 + 2*v.size()) + sum_l * sizeof(std::complex<double>));
03571 
03572   f.low_level_write(v.size());  // the length of the array
03573 
03574   // write one matrix at a time (i.e. size and elements)
03575   for (i = 0; i < v.size(); i++)
03576     f.low_level_write(v(i));
03577 
03578   return f;
03579 }
03580 
03581 } // namespace itpp
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Defines
SourceForge Logo

Generated on Wed Jul 27 2011 16:27:04 for IT++ by Doxygen 1.7.4