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   char it_file_base::file_magic[4] = { 'I', 'T', '+', '+' };
00037   char it_file_base::file_version = 3;
00038 
00039   // ----------------------------------------------------------------------
00040   // it_ifile class
00041   // ----------------------------------------------------------------------
00042 
00043   it_ifile::it_ifile() {}
00044 
00045   it_ifile::it_ifile(const std::string &name)
00046   {
00047     open(name);
00048   }
00049 
00050   void it_ifile::open(const std::string &name)
00051   {
00052     it_assert(exist(name), "it_ifile::open(): File does not exist");
00053     s.open_readonly(name, bfstream_base::l_endian);
00054     if (!read_check_file_header()) {
00055       s.close();
00056       it_error("it_ifile::open(): Corrupt file (not an it_file)");
00057     }
00058   }
00059 
00060   void it_ifile::close()
00061   {
00062     s.close();
00063   }
00064 
00065   bool it_ifile::seek(const std::string &name)
00066   {
00067     data_header h;
00068     std::streampos p;
00069 
00070     s.clear();
00071     s.seekg(sizeof(file_header));
00072 
00073     while (true) {
00074       p = s.tellg();
00075       read_data_header(h);
00076       if (s.eof()) {
00077         s.clear();
00078         return false;
00079       }
00080       if (h.type != "" && h.name == name) {
00081         s.seekg(p);
00082         break;
00083       }
00084       s.seekg(p + static_cast<std::streamoff>(h.block_bytes));
00085     }
00086 
00087     return true;
00088   }
00089 
00090   bool it_ifile::seek(int n)
00091   {
00092     data_header h;
00093     std::streampos p;
00094 
00095     s.clear();
00096     s.seekg(sizeof(file_header));
00097     for (int i=0; i<=n; i++) {
00098       p = s.tellg();
00099       read_data_header(h);
00100       if (s.eof()) {
00101         s.clear();
00102         return false;
00103       }
00104       if (h.type == "")
00105         i--;
00106       s.seekg((i == n) ? p : p + static_cast<std::streamoff>(h.block_bytes));
00107     }
00108     return true;
00109   }
00110 
00111   void it_ifile::info(std::string &name, std::string &type,
00112                       std::string &desc, uint64_t &bytes)
00113   {
00114     data_header h;
00115     std::streampos p;
00116 
00117     p = s.tellg();
00118     read_data_header(h);
00119     s.seekg(p);
00120     name = h.name;
00121     type = h.type;
00122     desc = h.desc;
00123     bytes = h.data_bytes;
00124   }
00125 
00126   bool it_ifile::read_check_file_header()
00127   {
00128     file_header h;
00129     s.read(reinterpret_cast<char *>(&h), sizeof(h));
00130     return (memcmp(h.magic, file_magic, 4) == 0
00131             && (h.version == file_version));
00132   }
00133 
00134   void it_ifile::read_data_header(data_header &h)
00135   {
00136     std::streampos p = s.tellg();
00137     s.clear();
00138     s >> h.hdr_bytes;
00139     s >> h.data_bytes;
00140     s >> h.block_bytes;
00141     s >> h.name;
00142     s >> h.type;
00143     s >> h.desc;
00144     s.seekg(p + static_cast<std::streamoff>(h.hdr_bytes));
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     if (!exist(name))
01894       it_error("File does not exist");
01895 
01896     s.open_readonly(name);
01897 
01898     if (!read_check_file_header()) {
01899       s.close();
01900      it_error("Corrupt file (Not an it-file)");
01901     }
01902 
01903   }
01904 
01905   void it_ifile_old::close()
01906   {
01907     s.close();
01908   }
01909 
01910   bool it_ifile_old::seek(const std::string &name)
01911   {
01912     data_header h;
01913     std::streampos p;
01914 
01915     s.clear();
01916     s.seekg(sizeof(file_header));
01917 
01918     while (true) {
01919       p = s.tellg();
01920       read_data_header(h);
01921       if (s.eof()) {
01922         s.clear();
01923         return false;
01924       }
01925       if (h.type != "" && h.name == name) {
01926         s.seekg(p);
01927         break;
01928       }
01929       s.seekg(p + static_cast<std::streamoff>(h.block_bytes));
01930     }
01931 
01932     return true;
01933   }
01934 
01935   bool it_ifile_old::seek(int n)
01936   {
01937     data_header h;
01938     std::streampos p;
01939 
01940     s.clear();
01941     s.seekg(sizeof(file_header));
01942     for (int i=0; i<=n; i++) {
01943       p = s.tellg(); // changed from tellp() since probably an error
01944       read_data_header(h);
01945       if (s.eof()) {
01946         s.clear();
01947         return false;
01948       }
01949       if (h.type == "")
01950         i--;
01951       s.seekg(i==n ? p : p+static_cast<std::streamoff>(h.block_bytes));
01952     }
01953     return true;
01954   }
01955 
01956   void it_ifile_old::info(std::string &name, std::string &type, int &bytes)
01957   {
01958     data_header h;
01959     std::streampos p;
01960 
01961     p = s.tellg(); // changed from tellp()
01962     read_data_header(h);
01963     s.seekg(p);
01964     name = h.name;
01965     type = h.type;
01966     bytes = h.data_bytes;
01967   }
01968 
01969   bool it_ifile_old::read_check_file_header()
01970   {
01971     file_header h;
01972 
01973     memset(&h, 0, sizeof(h)); // Clear the struct
01974     s.read(reinterpret_cast<char *>(&h), sizeof(h));
01975 
01976     return (memcmp(h.magic, file_magic, 4) == 0 && (h.version <= file_version) );
01977   }
01978 
01979   void it_ifile_old::read_data_header(data_header &h)
01980   {
01981     std::streampos p=s.tellg();
01982     s.clear();
01983     s >> h.endianity;
01984     if (s.eof())
01985       return;
01986     s.set_endianity(static_cast<bfstream_base::endian>(h.endianity));
01987                 uint32_t tmp;
01988     s >> tmp; h.hdr_bytes = tmp;
01989     s >> tmp; h.data_bytes = tmp;
01990     s >> tmp; h.block_bytes = tmp;
01991     s >> h.name;
01992     s >> h.type;
01993     s.seekg(p + static_cast<std::streamoff>(h.hdr_bytes));
01994   }
01995 
01996   void it_ifile_old::low_level_read(char &x)
01997   {
01998     s >> x;
01999   }
02000 
02001   void it_ifile_old::low_level_read(bin &x)
02002   {
02003     s >> x;
02004   }
02005 
02006   void it_ifile_old::low_level_read(short &x)
02007   {
02008     s >> x;
02009   }
02010 
02011   void it_ifile_old::low_level_read(int &x)
02012   {
02013                 int32_t tmp;
02014     s >> tmp; x = tmp;
02015   }
02016 
02017   void it_ifile_old::low_level_read(float &x)
02018   {
02019     s >> x;
02020   }
02021 
02022   void it_ifile_old::low_level_read(double &x)
02023   {
02024     s >> x;
02025   }
02026 
02027   void it_ifile_old::low_level_read(std::complex<float> &x)
02028   {
02029     float x_real, x_imag;
02030     s >> x_real;
02031     s >> x_imag;
02032     x = std::complex<float>(x_real, x_imag);
02033   }
02034 
02035   void it_ifile_old::low_level_read(std::complex<double> &x)
02036   {
02037     double x_real, x_imag;
02038     s >> x_real;
02039     s >> x_imag;
02040     x = std::complex<double>(x_real, x_imag);
02041   }
02042 
02043   void it_ifile_old::low_level_read_lo(vec &v)
02044   {
02045     int32_t i;
02046     float val;
02047 
02048     s >> i;
02049     v.set_size(i, false);
02050     for (i=0; i<v.size(); i++) {
02051       s >> val;
02052       v(i) = static_cast<double>(val);
02053     }
02054   }
02055 
02056   void it_ifile_old::low_level_read_hi(vec &v)
02057   {
02058     int32_t i;
02059     double val;
02060 
02061     s >> i;
02062     v.set_size(i, false);
02063     for (i=0; i<v.size(); i++) {
02064       s >> val;
02065       v(i) = static_cast<double>(val);
02066     }
02067   }
02068 
02069   void it_ifile_old::low_level_read(ivec &v)
02070   {
02071     int32_t i, val;
02072 
02073     s >> i;
02074     v.set_size(i, false);
02075     for (i=0; i<v.size(); i++) {
02076       s >> val; v(i) = val;
02077                 }
02078   }
02079 
02080   void it_ifile_old::low_level_read(bvec &v)
02081   {
02082     int32_t i;
02083 
02084     s >> i;
02085     v.set_size(i, false);
02086     for (i=0; i<v.size(); i++)
02087       s >> v(i);
02088   }
02089 
02090   void it_ifile_old::low_level_read_lo(cvec &v)
02091   {
02092     int32_t i;
02093     float val_real, val_imag;
02094 
02095     s >> i;
02096     v.set_size(i, false);
02097     for (i=0; i<v.size(); i++) {
02098       s >> val_real;
02099       s >> val_imag;
02100       v(i) = std::complex<double>(val_real, val_imag);
02101     }
02102   }
02103 
02104   void it_ifile_old::low_level_read_hi(cvec &v)
02105   {
02106     int32_t i;
02107     double val_real, val_imag;
02108 
02109     s >> i;
02110     v.set_size(i, false);
02111     for (i=0; i<v.size(); i++) {
02112       s >> val_real;
02113       s >> val_imag;
02114       v(i) = std::complex<double>(val_real, val_imag);
02115     }
02116   }
02117 
02118   void it_ifile_old::low_level_read(std::string &str)
02119   {
02120     int32_t i, j;
02121     char val;
02122     str = "";
02123 
02124     s >> i;
02125 
02126     for (j=0; j<i; j++) {
02127       s >> val;
02128       str += val;
02129     }
02130   }
02131 
02132   void it_ifile_old::low_level_read_lo(mat &m)
02133   {
02134     int32_t i, j;
02135     float val;
02136 
02137     s >> i >> j;
02138     m.set_size(i, j, false);
02139     for (j=0; j<m.cols(); j++)
02140       for (i=0; i<m.rows(); i++) {
02141         s >> val;
02142         m(i,j) = static_cast<double>(val);
02143       }
02144   }
02145 
02146   void it_ifile_old::low_level_read_hi(mat &m)
02147   {
02148     int32_t i, j;
02149     double val;
02150 
02151     s >> i >> j;
02152     m.set_size(i, j, false);
02153     for (j=0; j<m.cols(); j++)
02154       for (i=0; i<m.rows(); i++) {
02155         s >> val;
02156         m(i,j) = static_cast<double>(val);
02157       }
02158   }
02159 
02160   void it_ifile_old::low_level_read(imat &m)
02161   {
02162     int32_t i, j, val;
02163 
02164     s >> i >> j;
02165     m.set_size(i, j, false);
02166     for (j=0; j<m.cols(); j++)
02167       for (i=0; i<m.rows(); i++) {
02168         s >> val; m(i,j) = val;
02169                         }
02170   }
02171 
02172   void it_ifile_old::low_level_read(bmat &m)
02173   {
02174     int32_t i, j;
02175 
02176     s >> i >> j;
02177     m.set_size(i, j, false);
02178     for (j=0; j<m.cols(); j++)
02179       for (i=0; i<m.rows(); i++)
02180         s >> m(i,j);
02181   }
02182 
02183   void it_ifile_old::low_level_read_lo(cmat &m)
02184   {
02185     int32_t i, j;
02186     float val_real, val_imag;
02187 
02188     s >> i >> j;
02189     m.set_size(i, j, false);
02190     for (j=0; j<m.cols(); j++)
02191       for (i=0; i<m.rows(); i++) {
02192         s >> val_real;
02193         s >> val_imag;
02194         m(i,j) = std::complex<double>(val_real, val_imag);
02195       }
02196   }
02197 
02198   void it_ifile_old::low_level_read_hi(cmat &m)
02199   {
02200     int32_t i, j;
02201     double val_real, val_imag;
02202 
02203     s >> i >> j;
02204     m.set_size(i, j, false);
02205     for (j=0; j<m.cols(); j++)
02206       for (i=0; i<m.rows(); i++) {
02207         s >> val_real;
02208         s >> val_imag;
02209         m(i,j) = std::complex<double>(val_real, val_imag);
02210       }
02211   }
02212 
02213 
02214   void it_ifile_old::low_level_read_lo(Array<float> &v)
02215   {
02216     int32_t i;
02217     float val;
02218 
02219     s >> i;
02220     v.set_size(i, false);
02221     for (i=0; i<v.size(); i++) {
02222       s >> val;
02223       v(i) = val;
02224     }
02225   }
02226 
02227   void it_ifile_old::low_level_read_lo(Array<double> &v)
02228   {
02229     int32_t i;
02230     float val;
02231 
02232     s >> i;
02233     v.set_size(i, false);
02234     for (i=0; i<v.size(); i++) {
02235       s >> val;
02236       v(i) = static_cast<double>(val);
02237     }
02238   }
02239 
02240   void it_ifile_old::low_level_read_hi(Array<double> &v)
02241   {
02242     int32_t i;
02243     double val;
02244 
02245     s >> i;
02246     v.set_size(i, false);
02247     for (i=0; i<v.size(); i++) {
02248       s >> val;
02249       v(i) = static_cast<double>(val);
02250     }
02251   }
02252 
02253   void it_ifile_old::low_level_read(Array<int> &v)
02254   {
02255     int32_t i, val;
02256 
02257     s >> i;
02258     v.set_size(i, false);
02259     for (i=0; i<v.size(); i++) {
02260       s >> val; v(i) = val;
02261                 }
02262   }
02263 
02264   void it_ifile_old::low_level_read(Array<bin> &v)
02265   {
02266     int32_t i;
02267 
02268     s >> i;
02269     v.set_size(i, false);
02270     for (i=0; i<v.size(); i++)
02271       s >> v(i);
02272   }
02273 
02274   void it_ifile_old::low_level_read_lo(Array<std::complex<float> > &v)
02275   {
02276     int32_t i;
02277     float val_real, val_imag;
02278 
02279     s >> i;
02280     v.set_size(i, false);
02281     for (i=0; i<v.size(); i++) {
02282       s >> val_real;
02283       s >> val_imag;
02284       v(i) = std::complex<float>(val_real, val_imag);
02285     }
02286   }
02287 
02288   void it_ifile_old::low_level_read_lo(Array<std::complex<double> > &v)
02289   {
02290     int32_t i;
02291     float val_real, val_imag;
02292 
02293     s >> i;
02294     v.set_size(i, false);
02295     for (i=0; i<v.size(); i++) {
02296       s >> val_real;
02297       s >> val_imag;
02298       v(i) = std::complex<double>(val_real, val_imag);
02299     }
02300   }
02301 
02302   void it_ifile_old::low_level_read_hi(Array<std::complex<double> > &v)
02303   {
02304     int32_t i;
02305     double val_real, val_imag;
02306 
02307     s >> i;
02308     v.set_size(i, false);
02309     for (i=0; i<v.size(); i++) {
02310       s >> val_real;
02311       s >> val_imag;
02312       v(i) = std::complex<double>(val_real, val_imag);
02313     }
02314   }
02315 
02316   it_file_old::it_file_old()
02317   {
02318     low_prec = false;
02319     next_name = "";
02320   }
02321 
02322   it_file_old::it_file_old(const std::string &name, bool trunc)
02323   {
02324     low_prec = false;
02325     next_name = "";
02326     open(name, trunc);
02327   }
02328 
02329   void it_file_old::open(const std::string &name, bool trunc)
02330   {
02331     if (!exist(name))
02332       trunc = true;
02333 
02334     s.open(name, trunc);
02335     it_error_if(!s.is_open(), "Could not open file for writing");
02336 
02337     if (trunc)
02338       write_file_header();
02339     else if (!read_check_file_header()) {
02340       s.close();
02341       it_error("Corrupt file (Not an it-file)");
02342     }
02343   }
02344 
02345   void it_file_old::close()
02346   {
02347     s.close();
02348   }
02349 
02350   void it_file_old::flush()
02351   {
02352     s.flush();
02353   }
02354 
02355   void it_file_old::write_file_header()
02356   {
02357     s.write(file_magic, 4);
02358     s << file_version;
02359   }
02360 
02361   void it_file_old::write_data_header(const std::string &type, uint32_t size)
02362   {
02363     if (next_name == "")
02364       it_error("Try to write without a name");
02365     write_data_header(type, next_name, size);
02366     next_name = "";
02367   }
02368 
02369   void it_file_old::write_data_header(const std::string &type,
02370                                   const std::string &name, uint32_t size)
02371   {
02372     data_header h1, h2;
02373     std::streampos p;
02374     int availpos=0;
02375     bool removed=false;
02376     int skip;
02377 
02378     h1.endianity = s.get_native_endianity();
02379     h1.hdr_bytes = 1 + 3*4 + type.size()+1 + name.size()+1;
02380     h1.data_bytes = size;
02381     h1.block_bytes = h1.hdr_bytes + h1.data_bytes;
02382     h1.name = name;
02383     h1.type = type;
02384 
02385     if (exists(name))
02386       remove();
02387 
02388     // Try to find an empty space
02389     s.clear();
02390     s.seekg(sizeof(file_header));
02391     while (true) {
02392       p = s.tellp();
02393       read_data_header(h2);
02394       if (s.eof()) {
02395         s.clear();
02396         break;
02397       }
02398       skip = h2.block_bytes;
02399       if (h2.type != "" && h2.name == name) {
02400         s.seekg(p);
02401         remove();
02402         s.seekg(p);
02403         read_data_header(h2);
02404         removed = true;
02405         if (availpos != 0)
02406           break;
02407       }
02408       if (availpos == 0) {
02409         if (h2.type == "" && h2.block_bytes >= h1.block_bytes) {
02410           h1.block_bytes = h2.block_bytes;
02411           availpos = p;
02412         }
02413         else if (h2.block_bytes-h2.hdr_bytes-h2.data_bytes >= h1.block_bytes) {
02414           h1.block_bytes = h2.block_bytes - h2.hdr_bytes - h2.data_bytes;
02415           h2.block_bytes = h2.hdr_bytes + h2.data_bytes;
02416           s.seekp(p);
02417           write_data_header_here(h2);
02418           availpos = static_cast<int>(p) + h2.block_bytes;
02419           if (removed)
02420             break;
02421         }
02422       }
02423       s.seekg(p + static_cast<std::streamoff>(skip));
02424     }
02425     if (availpos != 0)
02426       s.seekp(availpos);
02427     else
02428       s.seekp(0, std::ios::end);
02429 
02430     write_data_header_here(h1);
02431   }
02432 
02433   void it_file_old::write_data_header_here(const data_header &h)
02434   {
02435     s.set_endianity(static_cast<bfstream_base::endian>(h.endianity));
02436     s << h.endianity << h.hdr_bytes << h.data_bytes << h.block_bytes << h.name << h.type;
02437   }
02438 
02439   void it_file_old::remove(const std::string &name)
02440   {
02441     seek(name);
02442     remove();
02443   }
02444 
02445   void it_file_old::remove()
02446   {
02447     data_header h;
02448     std::streampos p;
02449 
02450     p = s.tellp();
02451     read_data_header(h);
02452     h.type = "";
02453     h.name = "";
02454     h.hdr_bytes = 1 + 3*4 + 1 + 1;
02455     h.data_bytes = 0;
02456     s.seekp(p);
02457     write_data_header_here(h);
02458     s.seekp(p + static_cast<std::streamoff>(h.block_bytes));
02459   }
02460 
02461   bool it_file_old::exists(const std::string &name)
02462   {
02463     if (seek(name))
02464       return true;
02465     else
02466       return false;
02467   }
02468 
02469   void it_file_old::pack()
02470   {
02471     it_warning("pack() is not implemented!");
02472   }
02473 
02474   void it_file_old::low_level_write(char x)
02475   {
02476     s << x;
02477   }
02478 
02479   void it_file_old::low_level_write(bin x)
02480   {
02481     s << x.value();
02482   }
02483 
02484   void it_file_old::low_level_write(short x)
02485   {
02486     s << x;
02487   }
02488 
02489   void it_file_old::low_level_write(int x)
02490   {
02491     s << static_cast<int32_t>(x);
02492   }
02493 
02494   void it_file_old::low_level_write(float x)
02495   {
02496     s << x;
02497   }
02498 
02499   void it_file_old::low_level_write(double x)
02500   {
02501     s << x;
02502   }
02503 
02504   void it_file_old::low_level_write(const std::complex<float> &x)
02505   {
02506     s << x.real();
02507     s << x.imag();
02508   }
02509 
02510   void it_file_old::low_level_write(const std::complex<double> &x)
02511   {
02512     s << x.real();
02513     s << x.imag();
02514   }
02515 
02516   void it_file_old::low_level_write(const vec &v)
02517   {
02518     if (get_low_precision()) {
02519       s << static_cast<int32_t>(v.size());
02520       for (int i=0; i<v.size(); i++)
02521         s << static_cast<float>(v(i));
02522     }
02523     else {
02524       s << static_cast<int32_t>(v.size());
02525       for (int i=0; i<v.size(); i++)
02526         s << static_cast<double>(v(i));
02527     }
02528   }
02529 
02530   void it_file_old::low_level_write(const ivec &v)
02531   {
02532     s << static_cast<int32_t>(v.size());
02533     for (int i=0; i<v.size(); i++)
02534       s << static_cast<int32_t>(v(i));
02535   }
02536 
02537   void it_file_old::low_level_write(const bvec &v)
02538   {
02539     s << static_cast<int32_t>(v.size());
02540     for (int i=0; i<v.size(); i++)
02541       s << v(i).value();
02542   }
02543 
02544   void it_file_old::low_level_write(const cvec &v)
02545   {
02546     if (get_low_precision()) {
02547       s << static_cast<int32_t>(v.size());
02548       for (int i=0; i<v.size(); i++) {
02549         s << static_cast<float>(v(i).real());
02550         s << static_cast<float>(v(i).imag());
02551       }
02552     }
02553     else {
02554       s << static_cast<int32_t>(v.size());
02555       for (int i=0; i<v.size(); i++) {
02556         s << static_cast<double>(v(i).real());
02557         s << static_cast<double>(v(i).imag());
02558       }
02559     }
02560   }
02561 
02562   void it_file_old::low_level_write(const std::string &str)
02563   {
02564     int size = str.size();
02565     s << static_cast<int32_t>(size);
02566 
02567     for (int i=0; i< size; i++)
02568       s << str[i];
02569   }
02570 
02571   void it_file_old::low_level_write(const mat &m)
02572   {
02573     int i, j;
02574 
02575     if (get_low_precision()) {
02576       s << static_cast<int32_t>(m.rows()) << static_cast<int32_t>(m.cols());
02577       for (j=0; j<m.cols(); j++)
02578         for (i=0; i<m.rows(); i++)
02579           s << static_cast<float>(m(i,j));
02580     }
02581     else {
02582       s << static_cast<int32_t>(m.rows()) << static_cast<int32_t>(m.cols());
02583       for (j=0; j<m.cols(); j++)
02584         for (i=0; i<m.rows(); i++)
02585           s << static_cast<double>(m(i,j));
02586     }
02587   }
02588 
02589   void it_file_old::low_level_write(const imat &m)
02590   {
02591     int i, j;
02592 
02593     s << static_cast<int32_t>(m.rows()) << static_cast<int32_t>(m.cols());
02594     for (j=0; j<m.cols(); j++)
02595       for (i=0; i<m.rows(); i++)
02596         s << static_cast<int32_t>(m(i,j));
02597   }
02598 
02599   void it_file_old::low_level_write(const bmat &m)
02600   {
02601     int i, j;
02602 
02603     s << static_cast<int32_t>(m.rows()) << static_cast<int32_t>(m.cols());
02604      for (j=0; j<m.cols(); j++)
02605       for (i=0; i<m.rows(); i++)
02606         s << m(i,j).value();
02607   }
02608 
02609   void it_file_old::low_level_write(const cmat &m)
02610   {
02611     int i, j;
02612 
02613     if (get_low_precision()) {
02614       s << static_cast<int32_t>(m.rows()) << static_cast<int32_t>(m.cols());
02615       for (j=0; j<m.cols(); j++)
02616         for (i=0; i<m.rows(); i++) {
02617           s << static_cast<float>(m(i,j).real());
02618           s << static_cast<float>(m(i,j).imag());
02619         }
02620 
02621     }
02622     else {
02623       s << static_cast<int32_t>(m.rows()) << static_cast<int32_t>(m.cols());
02624       for (j=0; j<m.cols(); j++)
02625         for (i=0; i<m.rows(); i++) {
02626           s << static_cast<double>(m(i,j).real());
02627           s << static_cast<double>(m(i,j).imag());
02628         }
02629     }
02630   }
02631 
02632   void it_file_old::low_level_write(const Array<float> &v)
02633   {
02634     s << static_cast<int32_t>(v.size());
02635     for (int i=0; i<v.size(); i++)
02636       s << v(i);
02637   }
02638 
02639   void it_file_old::low_level_write(const Array<double> &v)
02640   {
02641     if (get_low_precision()) {
02642       s << static_cast<int32_t>(v.size());
02643       for (int i=0; i<v.size(); i++)
02644         s << static_cast<float>(v(i));
02645     }
02646     else {
02647       s << static_cast<int32_t>(v.size());
02648       for (int i=0; i<v.size(); i++)
02649         s << static_cast<double>(v(i));
02650     }
02651   }
02652 
02653   void it_file_old::low_level_write(const Array<int> &v)
02654   {
02655     s << static_cast<int32_t>(v.size());
02656     for (int i=0; i<v.size(); i++)
02657       s << static_cast<int32_t>(v(i));
02658   }
02659 
02660   void it_file_old::low_level_write(const Array<bin> &v)
02661   {
02662     s << static_cast<int32_t>(v.size());
02663     for (int i=0; i<v.size(); i++)
02664       s << v(i).value();
02665   }
02666 
02667   void it_file_old::low_level_write(const Array<std::complex<float> > &v)
02668   {
02669     s << static_cast<int32_t>(v.size());
02670     for (int i=0; i<v.size(); i++) {
02671       s << v(i).real();
02672       s << v(i).imag();
02673     }
02674   }
02675 
02676   void it_file_old::low_level_write(const Array<std::complex<double> > &v)
02677   {
02678     if (get_low_precision()) {
02679       s << static_cast<int32_t>(v.size());
02680       for (int i=0; i<v.size(); i++) {
02681         s << static_cast<float>(v(i).real());
02682         s << static_cast<float>(v(i).imag());
02683       }
02684     }
02685     else {
02686       s << static_cast<int32_t>(v.size());
02687       for (int i=0; i<v.size(); i++) {
02688         s << static_cast<double>(v(i).real());
02689         s << static_cast<double>(v(i).imag());
02690       }
02691     }
02692   }
02693 
02694   it_ifile_old &operator>>(it_ifile_old &f, char &x)
02695   {
02696     it_file_old::data_header h;
02697 
02698     f.read_data_header(h);
02699     if (h.type == "int8")
02700       f.low_level_read(x);
02701     else
02702       it_error("Wrong type");
02703 
02704     return f;
02705   }
02706 
02707   it_ifile_old &operator>>(it_ifile_old &f, bin &x)
02708   {
02709     it_file_old::data_header h;
02710 
02711     f.read_data_header(h);
02712     if (h.type == "bin")
02713       f.low_level_read(x);
02714     else
02715       it_error("Wrong type");
02716 
02717     return f;
02718   }
02719 
02720   it_ifile_old &operator>>(it_ifile_old &f, short &x)
02721   {
02722     it_file_old::data_header h;
02723 
02724     f.read_data_header(h);
02725     if (h.type == "int16")
02726       f.low_level_read(x);
02727     else
02728       it_error("Wrong type");
02729 
02730     return f;
02731   }
02732 
02733   it_ifile_old &operator>>(it_ifile_old &f, int &x)
02734   {
02735     it_file_old::data_header h;
02736 
02737     f.read_data_header(h);
02738     if (h.type == "int32")
02739       f.low_level_read(x);
02740     else if (h.type == "int16") {
02741       short x16;
02742       f.low_level_read(x16);
02743       x = x16;
02744     }
02745     else
02746       it_error("Wrong type");
02747 
02748     return f;
02749   }
02750 
02751   it_ifile_old &operator>>(it_ifile_old &f, double &x)
02752   {
02753     it_file_old::data_header h;
02754 
02755     f.read_data_header(h);
02756     if (h.type == "float64")
02757       f.low_level_read(x);
02758     else if (h.type == "float32") {
02759       float f32;
02760       f.low_level_read(f32);
02761       x = f32;
02762     }
02763     else
02764       it_error("Wrong type");
02765 
02766     return f;
02767   }
02768 
02769   it_ifile_old &operator>>(it_ifile_old &f, float &x)
02770   {
02771     it_file_old::data_header h;
02772 
02773     f.read_data_header(h);
02774     if (h.type == "float32")
02775       f.low_level_read(x);
02776     else
02777       it_error("Wrong type");
02778 
02779     return f;
02780   }
02781 
02782   it_ifile_old &operator>>(it_ifile_old &f, std::complex<float> &x)
02783   {
02784     it_file_old::data_header h;
02785 
02786     f.read_data_header(h);
02787 
02788     if (h.type == "float32_complex") {
02789       std::complex<float> f32_c;
02790       f.low_level_read(f32_c);
02791       x = f32_c;
02792     }
02793     else
02794       it_error("Wrong type");
02795 
02796     return f;
02797   }
02798 
02799   it_ifile_old &operator>>(it_ifile_old &f, std::complex<double> &x)
02800   {
02801     it_file_old::data_header h;
02802 
02803     f.read_data_header(h);
02804     if (h.type == "float64_complex")
02805       f.low_level_read(x);
02806     else if (h.type == "float32_complex") {
02807       std::complex<float> f32_c;
02808       f.low_level_read(f32_c);
02809       x = f32_c;
02810     }
02811     else
02812       it_error("Wrong type");
02813 
02814     return f;
02815   }
02816 
02817   it_ifile_old &operator>>(it_ifile_old &f, vec &v)
02818   {
02819     it_ifile_old::data_header h;
02820 
02821     f.read_data_header(h);
02822     if (h.type == "fvec")
02823       f.low_level_read_lo(v);
02824     else if (h.type == "dvec")
02825       f.low_level_read_hi(v);
02826     else
02827       it_error("Wrong type");
02828 
02829     return f;
02830   }
02831 
02832   it_ifile_old &operator>>(it_ifile_old &f, ivec &v)
02833   {
02834     it_file_old::data_header h;
02835 
02836     f.read_data_header(h);
02837     if (h.type == "ivec")
02838       f.low_level_read(v);
02839     else
02840       it_error("Wrong type");
02841 
02842     return f;
02843   }
02844 
02845   it_ifile_old &operator>>(it_ifile_old &f, bvec &v)
02846   {
02847     it_file_old::data_header h;
02848 
02849     f.read_data_header(h);
02850     if (h.type == "bvec")
02851       f.low_level_read(v);
02852     else
02853       it_error("Wrong type");
02854 
02855     return f;
02856   }
02857 
02858   it_ifile_old &operator>>(it_ifile_old &f, cvec &v)
02859   {
02860     it_file_old::data_header h;
02861 
02862     f.read_data_header(h);
02863     if (h.type == "fcvec")
02864       f.low_level_read_lo(v);
02865     else if (h.type == "dcvec")
02866       f.low_level_read_hi(v);
02867     else
02868       it_error("Wrong type");
02869 
02870     return f;
02871   }
02872 
02873   it_ifile_old &operator>>(it_ifile_old &f, std::string &str)
02874   {
02875     it_file_old::data_header h;
02876 
02877     f.read_data_header(h);
02878     if (h.type == "string")
02879       f.low_level_read(str);
02880     else
02881       it_error("Wrong type");
02882 
02883     return f;
02884   }
02885 
02886   it_ifile_old &operator>>(it_ifile_old &f, mat &m)
02887   {
02888     it_file_old::data_header h;
02889 
02890     f.read_data_header(h);
02891     if (h.type == "fmat")
02892       f.low_level_read_lo(m);
02893     else if (h.type == "dmat")
02894       f.low_level_read_hi(m);
02895     else
02896       it_error("Wrong type");
02897 
02898     return f;
02899   }
02900 
02901   it_ifile_old &operator>>(it_ifile_old &f, imat &m)
02902   {
02903     it_file_old::data_header h;
02904 
02905     f.read_data_header(h);
02906     if (h.type == "imat")
02907       f.low_level_read(m);
02908     else
02909       it_error("Wrong type");
02910 
02911     return f;
02912   }
02913 
02914   it_ifile_old &operator>>(it_ifile_old &f, bmat &m)
02915   {
02916     it_file_old::data_header h;
02917 
02918     f.read_data_header(h);
02919     if (h.type == "bmat")
02920       f.low_level_read(m);
02921     else
02922       it_error("Wrong type");
02923 
02924     return f;
02925   }
02926 
02927   it_ifile_old &operator>>(it_ifile_old &f, cmat &m)
02928   {
02929     it_file_old::data_header h;
02930 
02931     f.read_data_header(h);
02932     if (h.type == "fcmat")
02933       f.low_level_read_lo(m);
02934     else if (h.type == "dcmat")
02935       f.low_level_read_hi(m);
02936     else
02937       it_error("Wrong type");
02938 
02939     return f;
02940   }
02941 
02942   it_ifile_old &operator>>(it_ifile_old &f, Array<float> &v)
02943   {
02944     it_file_old::data_header h;
02945 
02946     f.read_data_header(h);
02947     if (h.type == "fArray")
02948       f.low_level_read_lo(v);
02949     else
02950       it_error("Wrong type");
02951 
02952     return f;
02953   }
02954 
02955   it_ifile_old &operator>>(it_ifile_old &f, Array<double> &v)
02956   {
02957     it_file_old::data_header h;
02958 
02959     f.read_data_header(h);
02960     if (h.type == "fArray")
02961       f.low_level_read_lo(v);
02962     else if (h.type == "dArray")
02963       f.low_level_read_hi(v);
02964     else
02965       it_error("Wrong type");
02966 
02967     return f;
02968   }
02969 
02970   it_ifile_old &operator>>(it_ifile_old &f, Array<int> &v)
02971   {
02972     it_file_old::data_header h;
02973 
02974     f.read_data_header(h);
02975     if (h.type == "iArray")
02976       f.low_level_read(v);
02977     else
02978       it_error("Wrong type");
02979 
02980     return f;
02981   }
02982 
02983   it_ifile_old &operator>>(it_ifile_old &f, Array<bin> &v)
02984   {
02985     it_file_old::data_header h;
02986 
02987     f.read_data_header(h);
02988     if (h.type == "bArray")
02989       f.low_level_read(v);
02990     else
02991       it_error("Wrong type");
02992 
02993     return f;
02994   }
02995 
02996   it_ifile_old &operator>>(it_ifile_old &f, Array<std::complex<float> > &v)
02997   {
02998     it_file_old::data_header h;
02999 
03000     f.read_data_header(h);
03001     if (h.type == "fcArray")
03002       f.low_level_read_lo(v);
03003     else
03004       it_error("Wrong type");
03005 
03006     return f;
03007   }
03008 
03009   it_ifile_old &operator>>(it_ifile_old &f, Array<std::complex<double> > &v)
03010   {
03011     it_file_old::data_header h;
03012 
03013     f.read_data_header(h);
03014     if (h.type == "fcArray")
03015       f.low_level_read_lo(v);
03016     else if (h.type == "dcArray")
03017       f.low_level_read_hi(v);
03018     else
03019       it_error("Wrong type");
03020 
03021     return f;
03022   }
03023 
03024   it_ifile_old &operator>>(it_ifile_old &f, Array<vec> &v)
03025   {
03026     it_file_old::data_header h;
03027 
03028     f.read_data_header(h);
03029     if (h.type == "vecArray") {
03030       int n;
03031       f.low_level_read(n);
03032       v.set_size(n, false);
03033       for (int i=0; i<n; i++)
03034         f.low_level_read_hi(v(i));
03035     }
03036     else
03037       it_error("Wrong type");
03038 
03039     return f;
03040   }
03041 
03042   it_ifile_old &operator>>(it_ifile_old &f, Array<ivec> &v)
03043   {
03044     it_file_old::data_header h;
03045 
03046     f.read_data_header(h);
03047     if (h.type == "ivecArray") {
03048       int n;
03049       f.low_level_read(n);
03050       v.set_size(n, false);
03051       for (int i=0; i<n; i++)
03052         f.low_level_read(v(i));
03053     }
03054     else
03055       it_error("Wrong type");
03056 
03057     return f;
03058   }
03059 
03060   it_ifile_old &operator>>(it_ifile_old &f, Array<bvec> &v)
03061   {
03062     it_file_old::data_header h;
03063 
03064     f.read_data_header(h);
03065     if (h.type == "bvecArray") {
03066       int n;
03067       f.low_level_read(n);
03068       v.set_size(n, false);
03069       for (int i=0; i<n; i++)
03070         f.low_level_read(v(i));
03071     }
03072     else
03073       it_error("Wrong type");
03074 
03075     return f;
03076   }
03077 
03078   it_ifile_old &operator>>(it_ifile_old &f, Array<cvec> &v)
03079   {
03080     it_file_old::data_header h;
03081 
03082     f.read_data_header(h);
03083     if (h.type == "cvecArray") {
03084       int n;
03085       f.low_level_read(n);
03086       v.set_size(n, false);
03087       for (int i=0; i<n; i++)
03088         f.low_level_read_hi(v(i));
03089     }
03090     else
03091       it_error("Wrong type");
03092 
03093     return f;
03094   }
03095 
03096   it_ifile_old &operator>>(it_ifile_old &f, Array<std::string> &v)
03097   {
03098     it_file_old::data_header h;
03099 
03100     f.read_data_header(h);
03101     if (h.type == "stringArray") {
03102       int n;
03103       f.low_level_read(n);
03104       v.set_size(n, false);
03105       for (int i=0; i<n; i++)
03106         f.low_level_read(v(i));
03107     }
03108     else
03109       it_error("Wrong type");
03110 
03111     return f;
03112   }
03113 
03114   it_ifile_old &operator>>(it_ifile_old &f, Array<mat> &v)
03115   {
03116     it_file_old::data_header h;
03117 
03118     f.read_data_header(h);
03119     if (h.type == "matArray") {
03120       int n;
03121       f.low_level_read(n);
03122       v.set_size(n, false);
03123       for (int i=0; i<n; i++)
03124         f.low_level_read_hi(v(i));
03125     }
03126     else
03127       it_error("Wrong type");
03128 
03129     return f;
03130   }
03131 
03132   it_ifile_old &operator>>(it_ifile_old &f, Array<imat> &v)
03133   {
03134     it_file_old::data_header h;
03135 
03136     f.read_data_header(h);
03137     if (h.type == "imatArray") {
03138       int n;
03139       f.low_level_read(n);
03140       v.set_size(n, false);
03141       for (int i=0; i<n; i++)
03142         f.low_level_read(v(i));
03143     }
03144     else
03145       it_error("Wrong type");
03146 
03147     return f;
03148   }
03149 
03150   it_ifile_old &operator>>(it_ifile_old &f, Array<bmat> &v)
03151   {
03152     it_file_old::data_header h;
03153 
03154     f.read_data_header(h);
03155     if (h.type == "bmatArray") {
03156       int n;
03157       f.low_level_read(n);
03158       v.set_size(n, false);
03159       for (int i=0; i<n; i++)
03160         f.low_level_read(v(i));
03161     }
03162     else
03163       it_error("Wrong type");
03164 
03165     return f;
03166   }
03167 
03168   it_ifile_old &operator>>(it_ifile_old &f, Array<cmat> &v)
03169   {
03170     it_file_old::data_header h;
03171 
03172     f.read_data_header(h);
03173     if (h.type == "cmatArray") {
03174       int n;
03175       f.low_level_read(n);
03176       v.set_size(n, false);
03177       for (int i=0; i<n; i++)
03178         f.low_level_read_hi(v(i));
03179     }
03180     else
03181       it_error("Wrong type");
03182 
03183     return f;
03184   }
03185 
03186   it_file_old &operator<<(it_file_old &f, char x)
03187   {
03188     f.write_data_header("int8", sizeof(char));
03189     f.low_level_write(x);
03190 
03191     return f;
03192   }
03193 
03194   it_file_old &operator<<(it_file_old &f, bin x)
03195   {
03196     f.write_data_header("bin", sizeof(bin));
03197     f.low_level_write(x);
03198 
03199     return f;
03200   }
03201 
03202   it_file_old &operator<<(it_file_old &f, short x)
03203   {
03204     f.write_data_header("int16", sizeof(short));
03205     f.low_level_write(x);
03206 
03207     return f;
03208   }
03209 
03210   it_file_old &operator<<(it_file_old &f, int x)
03211   {
03212     f.write_data_header("int32", sizeof(int));
03213     f.low_level_write(x);
03214 
03215     return f;
03216   }
03217 
03218   it_file_old &operator<<(it_file_old &f, float x)
03219   {
03220     f.write_data_header("float32", sizeof(float));
03221     f.low_level_write(x);
03222 
03223     return f;
03224   }
03225 
03226   it_file_old &operator<<(it_file_old &f, double x)
03227   {
03228     f.write_data_header("float64", sizeof(double));
03229     f.low_level_write(x);
03230 
03231     return f;
03232   }
03233 
03234   it_file_old &operator<<(it_file_old &f, std::complex<float> x)
03235   {
03236     f.write_data_header("float32_complex", 2*sizeof(float));
03237     f.low_level_write(x);
03238 
03239     return f;
03240   }
03241 
03242   it_file_old &operator<<(it_file_old &f, std::complex<double> x)
03243   {
03244     f.write_data_header("float64_complex", 2*sizeof(double));
03245     f.low_level_write(x);
03246 
03247     return f;
03248   }
03249 
03250   it_file_old &operator<<(it_file_old &f, const vec &v)
03251   {
03252     if (f.get_low_precision())
03253       f.write_data_header("fvec", sizeof(int) + v.size() * sizeof(float));
03254     else
03255       f.write_data_header("dvec", sizeof(int) + v.size() * sizeof(double));
03256     f.low_level_write(v);
03257 
03258     return f;
03259   }
03260 
03261   it_file_old &operator<<(it_file_old &f, const ivec &v)
03262   {
03263     f.write_data_header("ivec", (1 + v.size()) * sizeof(int));
03264     f.low_level_write(v);
03265 
03266     return f;
03267   }
03268 
03269   it_file_old &operator<<(it_file_old &f, const bvec &v)
03270   {
03271     f.write_data_header("bvec", sizeof(int) + v.size() * sizeof(bin) );
03272     f.low_level_write(v);
03273 
03274     return f;
03275   }
03276 
03277   it_file_old &operator<<(it_file_old &f, const cvec &v)
03278   {
03279     if (f.get_low_precision())
03280       f.write_data_header("fcvec", sizeof(int) + v.size() * 2 * sizeof(float));
03281     else
03282       f.write_data_header("dcvec", sizeof(int) + v.size() * 2 * sizeof(double));
03283     f.low_level_write(v);
03284 
03285     return f;
03286   }
03287 
03288   it_file_old &operator<<(it_file_old &f, const std::string &str)
03289   {
03290     f.write_data_header("string", sizeof(int) + str.size() * sizeof(char) );
03291     f.low_level_write(str);
03292 
03293     return f;
03294   }
03295 
03296   it_file_old &operator<<(it_file_old &f, const mat &m)
03297   {
03298     if (f.get_low_precision())
03299       f.write_data_header("fmat", 2*sizeof(int) + m.rows()*m.cols()*sizeof(float));
03300     else
03301       f.write_data_header("dmat", 2*sizeof(int) + m.rows()*m.cols()*sizeof(double));
03302     f.low_level_write(m);
03303 
03304     return f;
03305   }
03306 
03307   it_file_old &operator<<(it_file_old &f, const imat &m)
03308   {
03309     f.write_data_header("imat", (2 + m.rows()*m.cols()) * sizeof(int));
03310     f.low_level_write(m);
03311 
03312     return f;
03313   }
03314 
03315   it_file_old &operator<<(it_file_old &f, const bmat &m)
03316   {
03317     f.write_data_header("bmat", 2*sizeof(int) + m.rows()*m.cols()*sizeof(bin) );
03318     f.low_level_write(m);
03319 
03320     return f;
03321   }
03322 
03323   it_file_old &operator<<(it_file_old &f, const cmat &m)
03324   {
03325     if (f.get_low_precision())
03326       f.write_data_header("fcmat", 2*sizeof(int) + 2*m.rows()*m.cols()*sizeof(float));
03327     else
03328       f.write_data_header("dcmat", 2*sizeof(int) + 2*m.rows()*m.cols()*sizeof(double));
03329     f.low_level_write(m);
03330 
03331     return f;
03332   }
03333 
03334   it_file_old &operator<<(it_file_old &f, const Array<float> &v)
03335   {
03336     f.write_data_header("fArray", sizeof(int) + v.size() * sizeof(float));
03337     f.low_level_write(v);
03338 
03339     return f;
03340   }
03341 
03342   it_file_old &operator<<(it_file_old &f, const Array<double> &v)
03343   {
03344     if (f.get_low_precision())
03345       f.write_data_header("fArray", sizeof(int) + v.size() * sizeof(float));
03346     else
03347       f.write_data_header("dArray", sizeof(int) + v.size() * sizeof(double));
03348     f.low_level_write(v);
03349 
03350     return f;
03351   }
03352 
03353   it_file_old &operator<<(it_file_old &f, const Array<int> &v)
03354   {
03355     f.write_data_header("iArray", (1 + v.size()) * sizeof(int));
03356     f.low_level_write(v);
03357 
03358     return f;
03359   }
03360 
03361   it_file_old &operator<<(it_file_old &f, const Array<bin> &v)
03362   {
03363     f.write_data_header("bArray", sizeof(int) + v.size() * sizeof(bin) );
03364     f.low_level_write(v);
03365 
03366     return f;
03367   }
03368 
03369   it_file_old &operator<<(it_file_old &f, const Array<std::complex<float> > &v)
03370   {
03371     f.write_data_header("fcArray", sizeof(int) + v.size() * 2 * sizeof(float));
03372     f.low_level_write(v);
03373 
03374     return f;
03375   }
03376 
03377   it_file_old &operator<<(it_file_old &f, const Array<std::complex<double> > &v)
03378   {
03379     if (f.get_low_precision())
03380       f.write_data_header("fcArray", sizeof(int) + v.size() * 2 * sizeof(float));
03381     else
03382       f.write_data_header("dcArray", sizeof(int) + v.size() * 2 * sizeof(double));
03383     f.low_level_write(v);
03384 
03385     return f;
03386   }
03387 
03388   it_file_old &operator<<(it_file_old &f, const Array<vec> &v)
03389   {
03390     int i, sum_l=0;
03391 
03392     // calculate total length of Array
03393     for (i=0; i<v.size(); i++) {
03394       sum_l += v(i).size();
03395     }
03396 
03397     // write header
03398     f.write_data_header("vecArray", sizeof(int)*(1+v.size()) + sum_l * sizeof(double));
03399 
03400     f.low_level_write(v.size());  // the length of the array
03401 
03402     // write one vector at a time (i.e. size and elements)
03403     for (i=0; i<v.size(); i++)
03404       f.low_level_write(v(i));
03405 
03406     return f;
03407   }
03408 
03409   it_file_old &operator<<(it_file_old &f, const Array<ivec> &v)
03410   {
03411     int i, sum_l=0;
03412 
03413     // calculate total length of Array
03414     for (i=0; i<v.size(); i++) {
03415       sum_l += v(i).size();
03416     }
03417 
03418     // write header
03419     f.write_data_header("ivecArray", sizeof(int)*(1+v.size()) + sum_l * sizeof(int));
03420 
03421     f.low_level_write(v.size());  // the length of the array
03422 
03423     // write one vector at a time (i.e. size and elements)
03424     for (i=0; i<v.size(); i++)
03425       f.low_level_write(v(i));
03426 
03427     return f;
03428   }
03429 
03430   it_file_old &operator<<(it_file_old &f, const Array<bvec> &v)
03431   {
03432     int i, sum_l=0;
03433 
03434     // calculate total length of Array
03435     for (i=0; i<v.size(); i++) {
03436       sum_l += v(i).size();
03437     }
03438 
03439     // write header
03440     f.write_data_header("bvecArray", sizeof(int)*(1+v.size()) + sum_l * sizeof(bin));
03441 
03442     f.low_level_write(v.size());  // the length of the array
03443 
03444     // write one vector at a time (i.e. size and elements)
03445     for (i=0; i<v.size(); i++)
03446       f.low_level_write(v(i));
03447 
03448     return f;
03449   }
03450 
03451   it_file_old &operator<<(it_file_old &f, const Array<cvec> &v)
03452   {
03453     int i, sum_l=0;
03454 
03455     // calculate total length of Array
03456     for (i=0; i<v.size(); i++) {
03457       sum_l += v(i).size();
03458     }
03459 
03460     // write header
03461     f.write_data_header("cvecArray", sizeof(int)*(1+v.size()) + sum_l * sizeof(std::complex<double>));
03462 
03463     f.low_level_write(v.size());  // the length of the array
03464 
03465     // write one vector at a time (i.e. size and elements)
03466     for (i=0; i<v.size(); i++)
03467       f.low_level_write(v(i));
03468 
03469     return f;
03470   }
03471 
03472   it_file_old &operator<<(it_file_old &f, const Array<std::string> &v)
03473   {
03474     int i, sum_l=0;
03475 
03476     // calculate total length of Array
03477     for (i=0; i<v.size(); i++) {
03478       sum_l += v(i).size();
03479     }
03480 
03481     // write header
03482     f.write_data_header("stringArray", sizeof(int)*(1+v.size()) + sum_l * sizeof(char));
03483 
03484     f.low_level_write(v.size());  // the length of the array
03485 
03486     // write one vector at a time (i.e. size and elements)
03487     for (i=0; i<v.size(); i++)
03488       f.low_level_write(v(i));
03489 
03490     return f;
03491   }
03492 
03493   it_file_old &operator<<(it_file_old &f, const Array<mat> &v)
03494   {
03495     int i, sum_l=0;
03496 
03497     // calculate total length of Array
03498     for (i=0; i<v.size(); i++) {
03499       sum_l += v(i)._datasize();
03500     }
03501 
03502     // write header
03503     f.write_data_header("matArray", sizeof(int)*(1+2*v.size()) + sum_l * sizeof(double));
03504 
03505     f.low_level_write(v.size());  // the length of the array
03506 
03507     // write one matrix at a time (i.e. size and elements)
03508     for (i=0; i<v.size(); i++)
03509       f.low_level_write(v(i));
03510 
03511     return f;
03512   }
03513 
03514   it_file_old &operator<<(it_file_old &f, const Array<imat> &v)
03515   {
03516     int i, sum_l=0;
03517 
03518     // calculate total length of Array
03519     for (i=0; i<v.size(); i++) {
03520       sum_l += v(i)._datasize();
03521     }
03522 
03523     // write header
03524     f.write_data_header("imatArray", sizeof(int)*(1+2*v.size()) + sum_l * sizeof(int));
03525 
03526     f.low_level_write(v.size());  // the length of the array
03527 
03528     // write one matrix at a time (i.e. size and elements)
03529     for (i=0; i<v.size(); i++)
03530       f.low_level_write(v(i));
03531 
03532     return f;
03533   }
03534 
03535   it_file_old &operator<<(it_file_old &f, const Array<bmat> &v)
03536   {
03537     int i, sum_l=0;
03538 
03539     // calculate total length of Array
03540     for (i=0; i<v.size(); i++) {
03541       sum_l += v(i)._datasize();
03542     }
03543 
03544     // write header
03545     f.write_data_header("bmatArray", sizeof(int)*(1+2*v.size()) + sum_l * sizeof(bin));
03546 
03547     f.low_level_write(v.size());  // the length of the array
03548 
03549     // write one matrix at a time (i.e. size and elements)
03550     for (i=0; i<v.size(); i++)
03551       f.low_level_write(v(i));
03552 
03553     return f;
03554   }
03555 
03556   it_file_old &operator<<(it_file_old &f, const Array<cmat> &v)
03557   {
03558     int i, sum_l=0;
03559 
03560     // calculate total length of Array
03561     for (i=0; i<v.size(); i++) {
03562       sum_l += v(i)._datasize();
03563     }
03564 
03565     // write header
03566     f.write_data_header("cmatArray", sizeof(int)*(1+2*v.size()) + sum_l * sizeof(std::complex<double>));
03567 
03568     f.low_level_write(v.size());  // the length of the array
03569 
03570     // write one matrix at a time (i.e. size and elements)
03571     for (i=0; i<v.size(); i++)
03572       f.low_level_write(v(i));
03573 
03574     return f;
03575   }
03576 
03577 } // namespace itpp
SourceForge Logo

Generated on Mon Jan 7 22:28:55 2008 for IT++ by Doxygen 1.5.4