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
Generated on Sat Apr 19 10:41:11 2008 for IT++ by Doxygen 1.5.5