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