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