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

Generated on Sat Apr 19 10:59:22 2008 for IT++ by Doxygen 1.5.5