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