IT++ Logo

itfile.cpp

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

Generated on Fri Jul 25 12:42:58 2008 for IT++ by Doxygen 1.5.4