00001 00034 #include <itpp/base/itfile.h> 00035 00036 00037 namespace itpp { 00038 00039 char it_file_base::file_magic[4] = { 'I', 'T', '+', '+' }; 00040 char it_file_base::file_version = 2; 00041 00042 it_ifile::it_ifile() 00043 { 00044 } 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 if (!exist(name)) 00054 it_error("File does not exist"); 00055 00056 s.open_readonly(name); 00057 00058 if (!read_check_file_header()) { 00059 s.close(); 00060 it_error("Corrupt file (Not an it-file)"); 00061 } 00062 00063 } 00064 00065 void it_ifile::close() 00066 { 00067 s.close(); 00068 } 00069 00070 bool it_ifile::seek(const std::string &name) 00071 { 00072 data_header h; 00073 std::streampos p; 00074 00075 s.clear(); 00076 s.seekg(sizeof(file_header)); 00077 00078 while (true) { 00079 p = s.tellg(); 00080 read_data_header(h); 00081 if (s.eof()) { 00082 s.clear(); 00083 return false; 00084 } 00085 if (h.type != "" && h.name == name) { 00086 s.seekg(p); 00087 break; 00088 } 00089 s.seekg(p + static_cast<std::streampos>(h.block_bytes)); 00090 } 00091 00092 return true; 00093 } 00094 00095 bool it_ifile::seek(int n) 00096 { 00097 data_header h; 00098 std::streampos p; 00099 00100 s.clear(); 00101 s.seekg(sizeof(file_header)); 00102 for (int i=0; i<=n; i++) { 00103 p = s.tellg(); // changed from tellp() since probably an error 00104 read_data_header(h); 00105 if (s.eof()) { 00106 s.clear(); 00107 return false; 00108 } 00109 if (h.type == "") 00110 i--; 00111 s.seekg(i==n ? p : p+static_cast<std::streampos>(h.block_bytes)); 00112 } 00113 return true; 00114 } 00115 00116 void it_ifile::info(std::string &name, std::string &type, int &bytes) 00117 { 00118 data_header h; 00119 std::streampos p; 00120 00121 p = s.tellg(); // changed from tellp() 00122 read_data_header(h); 00123 s.seekg(p); 00124 name = h.name; 00125 type = h.type; 00126 bytes = h.data_bytes; 00127 } 00128 00129 bool it_ifile::read_check_file_header() 00130 { 00131 file_header h; 00132 00133 memset(&h, 0, sizeof(h)); // Clear the struct 00134 s.read(reinterpret_cast<char *>(&h), sizeof(h)); 00135 00136 return (memcmp(h.magic, file_magic, 4) == 0 && (h.version <= file_version) ); 00137 } 00138 00139 void it_ifile::read_data_header(data_header &h) 00140 { 00141 std::streampos p=s.tellg(); 00142 00143 s.clear(); 00144 s >> h.endianity; 00145 00146 if (s.eof()) 00147 return; 00148 s.set_endianity(static_cast<bfstream_base::endian>(h.endianity)); 00149 s >> h.hdr_bytes; 00150 s >> h.data_bytes; 00151 s >> h.block_bytes; 00152 s >> h.name; 00153 s >> h.type; 00154 s.seekg(p + static_cast<std::streampos>(h.hdr_bytes)); 00155 } 00156 00157 void it_ifile::low_level_read(bin &x) 00158 { 00159 s >> x; 00160 } 00161 00162 void it_ifile::low_level_read(short &x) 00163 { 00164 s >> x; 00165 } 00166 00167 void it_ifile::low_level_read(int &x) 00168 { 00169 s >> x; 00170 } 00171 00172 /* 00173 void it_ifile::low_level_read(long_long &x) 00174 { 00175 s >> x; 00176 } 00177 */ 00178 00179 void it_ifile::low_level_read(float &x) 00180 { 00181 s >> x; 00182 } 00183 00184 void it_ifile::low_level_read(double &x) 00185 { 00186 s >> x; 00187 } 00188 00189 void it_ifile::low_level_read(std::complex<float> &x) 00190 { 00191 float x_real, x_imag; 00192 s >> x_real; 00193 s >> x_imag; 00194 x = std::complex<float>(x_real, x_imag); 00195 } 00196 00197 void it_ifile::low_level_read(std::complex<double> &x) 00198 { 00199 double x_real, x_imag; 00200 s >> x_real; 00201 s >> x_imag; 00202 x = std::complex<double>(x_real, x_imag); 00203 } 00204 00205 void it_ifile::low_level_read_lo(vec &v) 00206 { 00207 int i; 00208 float val; 00209 00210 s >> i; 00211 v.set_size(i, false); 00212 for (i=0; i<v.size(); i++) { 00213 s >> val; 00214 v(i) = static_cast<double>(val); 00215 } 00216 } 00217 00218 void it_ifile::low_level_read_hi(vec &v) 00219 { 00220 int i; 00221 double val; 00222 00223 s >> i; 00224 v.set_size(i, false); 00225 for (i=0; i<v.size(); i++) { 00226 s >> val; 00227 v(i) = static_cast<double>(val); 00228 } 00229 } 00230 00231 void it_ifile::low_level_read(ivec &v) 00232 { 00233 int i; 00234 00235 s >> i; 00236 v.set_size(i, false); 00237 for (i=0; i<v.size(); i++) 00238 s >> v(i); 00239 } 00240 00241 void it_ifile::low_level_read(bvec &v) 00242 { 00243 int i; 00244 00245 s >> i; 00246 v.set_size(i, false); 00247 for (i=0; i<v.size(); i++) 00248 s >> v(i); 00249 } 00250 00251 void it_ifile::low_level_read_lo(cvec &v) 00252 { 00253 int i; 00254 float val_real, val_imag; 00255 00256 s >> i; 00257 v.set_size(i, false); 00258 for (i=0; i<v.size(); i++) { 00259 s >> val_real; 00260 s >> val_imag; 00261 v(i) = std::complex<double>(val_real, val_imag); 00262 } 00263 } 00264 00265 void it_ifile::low_level_read_hi(cvec &v) 00266 { 00267 int i; 00268 double val_real, val_imag; 00269 00270 s >> i; 00271 v.set_size(i, false); 00272 for (i=0; i<v.size(); i++) { 00273 s >> val_real; 00274 s >> val_imag; 00275 v(i) = std::complex<double>(val_real, val_imag); 00276 } 00277 } 00278 00279 void it_ifile::low_level_read(std::string &str) 00280 { 00281 int i, j; 00282 char val; 00283 str = ""; 00284 00285 s >> i; 00286 00287 for (j=0; j<i; j++) { 00288 s >> val; 00289 str += val; 00290 } 00291 } 00292 00293 void it_ifile::low_level_read_lo(mat &m) 00294 { 00295 int i, j; 00296 float val; 00297 00298 s >> i >> j; 00299 m.set_size(i, j, false); 00300 for (j=0; j<m.cols(); j++) 00301 for (i=0; i<m.rows(); i++) { 00302 s >> val; 00303 m(i,j) = static_cast<double>(val); 00304 } 00305 } 00306 00307 void it_ifile::low_level_read_hi(mat &m) 00308 { 00309 int i, j; 00310 double val; 00311 00312 s >> i >> j; 00313 m.set_size(i, j, false); 00314 for (j=0; j<m.cols(); j++) 00315 for (i=0; i<m.rows(); i++) { 00316 s >> val; 00317 m(i,j) = static_cast<double>(val); 00318 } 00319 } 00320 00321 void it_ifile::low_level_read(imat &m) 00322 { 00323 int i, j; 00324 00325 s >> i >> j; 00326 m.set_size(i, j, false); 00327 for (j=0; j<m.cols(); j++) 00328 for (i=0; i<m.rows(); i++) 00329 s >> m(i,j); 00330 } 00331 00332 void it_ifile::low_level_read(bmat &m) 00333 { 00334 int i, j; 00335 00336 s >> i >> j; 00337 m.set_size(i, j, false); 00338 for (j=0; j<m.cols(); j++) 00339 for (i=0; i<m.rows(); i++) 00340 s >> m(i,j); 00341 } 00342 00343 void it_ifile::low_level_read_lo(cmat &m) 00344 { 00345 int i, j; 00346 float val_real, val_imag; 00347 00348 s >> i >> j; 00349 m.set_size(i, j, false); 00350 for (j=0; j<m.cols(); j++) 00351 for (i=0; i<m.rows(); i++) { 00352 s >> val_real; 00353 s >> val_imag; 00354 m(i,j) = std::complex<double>(val_real, val_imag); 00355 } 00356 } 00357 00358 void it_ifile::low_level_read_hi(cmat &m) 00359 { 00360 int i, j; 00361 double val_real, val_imag; 00362 00363 s >> i >> j; 00364 m.set_size(i, j, false); 00365 for (j=0; j<m.cols(); j++) 00366 for (i=0; i<m.rows(); i++) { 00367 s >> val_real; 00368 s >> val_imag; 00369 m(i,j) = std::complex<double>(val_real, val_imag); 00370 } 00371 } 00372 00373 00374 void it_ifile::low_level_read_lo(Array<float> &v) 00375 { 00376 int i; 00377 float val; 00378 00379 s >> i; 00380 v.set_size(i, false); 00381 for (i=0; i<v.size(); i++) { 00382 s >> val; 00383 v(i) = val; 00384 } 00385 } 00386 00387 void it_ifile::low_level_read_lo(Array<double> &v) 00388 { 00389 int i; 00390 float val; 00391 00392 s >> i; 00393 v.set_size(i, false); 00394 for (i=0; i<v.size(); i++) { 00395 s >> val; 00396 v(i) = static_cast<double>(val); 00397 } 00398 } 00399 00400 void it_ifile::low_level_read_hi(Array<double> &v) 00401 { 00402 int i; 00403 double val; 00404 00405 s >> i; 00406 v.set_size(i, false); 00407 for (i=0; i<v.size(); i++) { 00408 s >> val; 00409 v(i) = static_cast<double>(val); 00410 } 00411 } 00412 00413 void it_ifile::low_level_read(Array<int> &v) 00414 { 00415 int i; 00416 00417 s >> i; 00418 v.set_size(i, false); 00419 for (i=0; i<v.size(); i++) 00420 s >> v(i); 00421 } 00422 00423 void it_ifile::low_level_read(Array<bin> &v) 00424 { 00425 int i; 00426 00427 s >> i; 00428 v.set_size(i, false); 00429 for (i=0; i<v.size(); i++) 00430 s >> v(i); 00431 } 00432 00433 void it_ifile::low_level_read_lo(Array<std::complex<float> > &v) 00434 { 00435 int i; 00436 float val_real, val_imag; 00437 00438 s >> i; 00439 v.set_size(i, false); 00440 for (i=0; i<v.size(); i++) { 00441 s >> val_real; 00442 s >> val_imag; 00443 v(i) = std::complex<float>(val_real, val_imag); 00444 } 00445 } 00446 00447 void it_ifile::low_level_read_lo(Array<std::complex<double> > &v) 00448 { 00449 int i; 00450 float val_real, val_imag; 00451 00452 s >> i; 00453 v.set_size(i, false); 00454 for (i=0; i<v.size(); i++) { 00455 s >> val_real; 00456 s >> val_imag; 00457 v(i) = std::complex<double>(val_real, val_imag); 00458 } 00459 } 00460 00461 void it_ifile::low_level_read_hi(Array<std::complex<double> > &v) 00462 { 00463 int i; 00464 double val_real, val_imag; 00465 00466 s >> i; 00467 v.set_size(i, false); 00468 for (i=0; i<v.size(); i++) { 00469 s >> val_real; 00470 s >> val_imag; 00471 v(i) = std::complex<double>(val_real, val_imag); 00472 } 00473 } 00474 00475 it_file::it_file() 00476 { 00477 low_prec = false; 00478 next_name = ""; 00479 } 00480 00481 it_file::it_file(const std::string &name, bool trunc) 00482 { 00483 low_prec = false; 00484 next_name = ""; 00485 open(name, trunc); 00486 } 00487 00488 void it_file::open(const std::string &name, bool trunc) 00489 { 00490 if (!exist(name)) 00491 trunc = true; 00492 00493 s.open(name, trunc); 00494 it_error_if(!s.is_open(), "Could not open file for writing"); 00495 00496 if (trunc) 00497 write_file_header(); 00498 else if (!read_check_file_header()) { 00499 s.close(); 00500 it_error("Corrupt file (Not an it-file)"); 00501 } 00502 } 00503 00504 void it_file::close() 00505 { 00506 s.close(); 00507 } 00508 00509 void it_file::flush() 00510 { 00511 s.flush(); 00512 } 00513 00514 void it_file::write_file_header() 00515 { 00516 s.write(file_magic, 4); 00517 s << file_version; 00518 } 00519 00520 void it_file::write_data_header(const std::string &type, it_u32 size) 00521 { 00522 if (next_name == "") 00523 it_error("Try to write without a name"); 00524 write_data_header(type, next_name, size); 00525 next_name = ""; 00526 } 00527 00528 void it_file::write_data_header(const std::string &type, const std::string &name, it_u32 size) 00529 { 00530 data_header h1, h2; 00531 std::streampos p; 00532 int availpos=0; 00533 bool removed=false; 00534 int skip; 00535 00536 h1.endianity = s.get_native_endianity(); 00537 h1.hdr_bytes = 1 + 3*4 + type.size()+1 + name.size()+1; 00538 h1.data_bytes = size; 00539 h1.block_bytes = h1.hdr_bytes + h1.data_bytes; 00540 h1.name = name; 00541 h1.type = type; 00542 00543 if (exists(name)) 00544 remove(); 00545 00546 // Try to find an empty space 00547 s.clear(); 00548 s.seekg(sizeof(file_header)); 00549 while (true) { 00550 p = s.tellp(); 00551 read_data_header(h2); 00552 if (s.eof()) { 00553 s.clear(); 00554 break; 00555 } 00556 skip = h2.block_bytes; 00557 if (h2.type != "" && h2.name == name) { 00558 s.seekg(p); 00559 remove(); 00560 s.seekg(p); 00561 read_data_header(h2); 00562 removed = true; 00563 if (availpos != 0) 00564 break; 00565 } 00566 if (availpos == 0) { 00567 if (h2.type == "" && h2.block_bytes >= h1.block_bytes) { 00568 h1.block_bytes = h2.block_bytes; 00569 availpos = p; 00570 } 00571 else if (h2.block_bytes-h2.hdr_bytes-h2.data_bytes >= h1.block_bytes) { 00572 h1.block_bytes = h2.block_bytes - h2.hdr_bytes - h2.data_bytes; 00573 h2.block_bytes = h2.hdr_bytes + h2.data_bytes; 00574 s.seekp(p); 00575 write_data_header_here(h2); 00576 availpos = static_cast<int>(p) + h2.block_bytes; 00577 if (removed) 00578 break; 00579 } 00580 } 00581 s.seekg(p + static_cast<std::streampos>(skip)); 00582 } 00583 if (availpos != 0) 00584 s.seekp(availpos); 00585 else 00586 s.seekp(0, std::ios::end); 00587 00588 write_data_header_here(h1); 00589 } 00590 00591 void it_file::write_data_header_here(const data_header &h) 00592 { 00593 s.set_endianity(static_cast<bfstream_base::endian>(h.endianity)); 00594 s << h.endianity << h.hdr_bytes << h.data_bytes << h.block_bytes << h.name << h.type; 00595 } 00596 00597 void it_file::remove(const std::string &name) 00598 { 00599 seek(name); 00600 remove(); 00601 } 00602 00603 void it_file::remove() 00604 { 00605 data_header h; 00606 std::streampos p; 00607 00608 p = s.tellp(); 00609 read_data_header(h); 00610 h.type = ""; 00611 h.name = ""; 00612 h.hdr_bytes = 1 + 3*4 + 1 + 1; 00613 h.data_bytes = 0; 00614 s.seekp(p); 00615 write_data_header_here(h); 00616 s.seekp(p + static_cast<std::streampos>(h.block_bytes)); 00617 } 00618 00619 bool it_file::exists(const std::string &name) 00620 { 00621 if (seek(name)) 00622 return true; 00623 else 00624 return false; 00625 } 00626 00627 void it_file::pack() 00628 { 00629 it_warning("pack() is not implemented!"); 00630 } 00631 00632 void it_file::low_level_write(bin x) 00633 { 00634 s << x; 00635 } 00636 00637 void it_file::low_level_write(short x) 00638 { 00639 s << x; 00640 } 00641 00642 void it_file::low_level_write(int x) 00643 { 00644 s << x; 00645 } 00646 00647 void it_file::low_level_write(float x) 00648 { 00649 s << x; 00650 } 00651 00652 void it_file::low_level_write(double x) 00653 { 00654 s << x; 00655 } 00656 00657 void it_file::low_level_write(const std::complex<float> &x) 00658 { 00659 s << x.real(); 00660 s << x.imag(); 00661 } 00662 00663 void it_file::low_level_write(const std::complex<double> &x) 00664 { 00665 s << x.real(); 00666 s << x.imag(); 00667 } 00668 00669 void it_file::low_level_write(const vec &v) 00670 { 00671 if (get_low_precision()) { 00672 s << v.size(); 00673 for (int i=0; i<v.size(); i++) 00674 s << static_cast<float>(v(i)); 00675 } 00676 else { 00677 s << v.size(); 00678 for (int i=0; i<v.size(); i++) 00679 s << static_cast<double>(v(i)); 00680 } 00681 } 00682 00683 void it_file::low_level_write(const ivec &v) 00684 { 00685 s << v.size(); 00686 for (int i=0; i<v.size(); i++) 00687 s << v(i); 00688 } 00689 00690 void it_file::low_level_write(const bvec &v) 00691 { 00692 s << v.size(); 00693 for (int i=0; i<v.size(); i++) 00694 s << v(i); 00695 } 00696 00697 void it_file::low_level_write(const cvec &v) 00698 { 00699 if (get_low_precision()) { 00700 s << v.size(); 00701 for (int i=0; i<v.size(); i++) { 00702 s << static_cast<float>(v(i).real()); 00703 s << static_cast<float>(v(i).imag()); 00704 } 00705 } 00706 else { 00707 s << v.size(); 00708 for (int i=0; i<v.size(); i++) { 00709 s << static_cast<double>(v(i).real()); 00710 s << static_cast<double>(v(i).imag()); 00711 } 00712 } 00713 } 00714 00715 void it_file::low_level_write(const std::string &str) 00716 { 00717 s << str.size(); 00718 00719 for (int i=0; i<(int)str.size(); i++) 00720 s << str[i]; 00721 } 00722 00723 void it_file::low_level_write(const mat &m) 00724 { 00725 int i, j; 00726 00727 if (get_low_precision()) { 00728 s << m.rows() << m.cols(); 00729 for (j=0; j<m.cols(); j++) 00730 for (i=0; i<m.rows(); i++) 00731 s << static_cast<float>(m(i,j)); 00732 } 00733 else { 00734 s << m.rows() << m.cols(); 00735 for (j=0; j<m.cols(); j++) 00736 for (i=0; i<m.rows(); i++) 00737 s << static_cast<double>(m(i,j)); 00738 } 00739 } 00740 00741 void it_file::low_level_write(const imat &m) 00742 { 00743 int i, j; 00744 00745 s << m.rows() << m.cols(); 00746 for (j=0; j<m.cols(); j++) 00747 for (i=0; i<m.rows(); i++) 00748 s << m(i,j); 00749 } 00750 00751 void it_file::low_level_write(const bmat &m) 00752 { 00753 int i, j; 00754 00755 s << m.rows() << m.cols(); 00756 for (j=0; j<m.cols(); j++) 00757 for (i=0; i<m.rows(); i++) 00758 s << m(i,j); 00759 } 00760 00761 void it_file::low_level_write(const cmat &m) 00762 { 00763 int i, j; 00764 00765 if (get_low_precision()) { 00766 s << m.rows() << m.cols(); 00767 for (j=0; j<m.cols(); j++) 00768 for (i=0; i<m.rows(); i++) { 00769 s << static_cast<float>(m(i,j).real()); 00770 s << static_cast<float>(m(i,j).imag()); 00771 } 00772 00773 } 00774 else { 00775 s << m.rows() << m.cols(); 00776 for (j=0; j<m.cols(); j++) 00777 for (i=0; i<m.rows(); i++) { 00778 s << static_cast<double>(m(i,j).real()); 00779 s << static_cast<double>(m(i,j).imag()); 00780 } 00781 } 00782 } 00783 00784 void it_file::low_level_write(const Array<float> &v) 00785 { 00786 s << v.size(); 00787 for (int i=0; i<v.size(); i++) 00788 s << v(i); 00789 } 00790 00791 void it_file::low_level_write(const Array<double> &v) 00792 { 00793 if (get_low_precision()) { 00794 s << v.size(); 00795 for (int i=0; i<v.size(); i++) 00796 s << static_cast<float>(v(i)); 00797 } 00798 else { 00799 s << v.size(); 00800 for (int i=0; i<v.size(); i++) 00801 s << static_cast<double>(v(i)); 00802 } 00803 } 00804 00805 void it_file::low_level_write(const Array<int> &v) 00806 { 00807 s << v.size(); 00808 for (int i=0; i<v.size(); i++) 00809 s << v(i); 00810 } 00811 00812 void it_file::low_level_write(const Array<bin> &v) 00813 { 00814 s << v.size(); 00815 for (int i=0; i<v.size(); i++) 00816 s << v(i); 00817 } 00818 00819 void it_file::low_level_write(const Array<std::complex<float> > &v) 00820 { 00821 s << v.size(); 00822 for (int i=0; i<v.size(); i++) { 00823 s << v(i).real(); 00824 s << v(i).imag(); 00825 } 00826 } 00827 00828 void it_file::low_level_write(const Array<std::complex<double> > &v) 00829 { 00830 if (get_low_precision()) { 00831 s << v.size(); 00832 for (int i=0; i<v.size(); i++) { 00833 s << static_cast<float>(v(i).real()); 00834 s << static_cast<float>(v(i).imag()); 00835 } 00836 } 00837 else { 00838 s << v.size(); 00839 for (int i=0; i<v.size(); i++) { 00840 s << static_cast<double>(v(i).real()); 00841 s << static_cast<double>(v(i).imag()); 00842 } 00843 } 00844 } 00845 00846 it_ifile &operator>>(it_ifile &f, bin &x) 00847 { 00848 it_file::data_header h; 00849 00850 f.read_data_header(h); 00851 if (h.type == "bin") 00852 f.low_level_read(x); 00853 else 00854 it_error("Wrong type"); 00855 00856 return f; 00857 } 00858 00859 it_ifile &operator>>(it_ifile &f, short &x) 00860 { 00861 it_file::data_header h; 00862 00863 f.read_data_header(h); 00864 if (h.type == "int16") 00865 f.low_level_read(x); 00866 else 00867 it_error("Wrong type"); 00868 00869 return f; 00870 } 00871 00872 it_ifile &operator>>(it_ifile &f, int &x) 00873 { 00874 it_file::data_header h; 00875 00876 f.read_data_header(h); 00877 if (h.type == "int32") 00878 f.low_level_read(x); 00879 else if (h.type == "int16") { 00880 short x16; 00881 f.low_level_read(x16); 00882 x = x16; 00883 } 00884 else 00885 it_error("Wrong type"); 00886 00887 return f; 00888 } 00889 00890 it_ifile &operator>>(it_ifile &f, double &x) 00891 { 00892 it_file::data_header h; 00893 00894 f.read_data_header(h); 00895 if (h.type == "float64") 00896 f.low_level_read(x); 00897 else if (h.type == "float32") { 00898 float f32; 00899 f.low_level_read(f32); 00900 x = f32; 00901 } 00902 else 00903 it_error("Wrong type"); 00904 00905 return f; 00906 } 00907 00908 it_ifile &operator>>(it_ifile &f, float &x) 00909 { 00910 it_file::data_header h; 00911 00912 f.read_data_header(h); 00913 if (h.type == "float32") 00914 f.low_level_read(x); 00915 else 00916 it_error("Wrong type"); 00917 00918 return f; 00919 } 00920 00921 it_ifile &operator>>(it_ifile &f, std::complex<float> &x) 00922 { 00923 it_file::data_header h; 00924 00925 f.read_data_header(h); 00926 00927 if (h.type == "float32_complex") { 00928 std::complex<float> f32_c; 00929 f.low_level_read(f32_c); 00930 x = f32_c; 00931 } 00932 else 00933 it_error("Wrong type"); 00934 00935 return f; 00936 } 00937 00938 it_ifile &operator>>(it_ifile &f, std::complex<double> &x) 00939 { 00940 it_file::data_header h; 00941 00942 f.read_data_header(h); 00943 if (h.type == "float64_complex") 00944 f.low_level_read(x); 00945 else if (h.type == "float32_complex") { 00946 std::complex<float> f32_c; 00947 f.low_level_read(f32_c); 00948 x = f32_c; 00949 } 00950 else 00951 it_error("Wrong type"); 00952 00953 return f; 00954 } 00955 00956 it_ifile &operator>>(it_ifile &f, vec &v) 00957 { 00958 it_ifile::data_header h; 00959 00960 f.read_data_header(h); 00961 if (h.type == "fvec") 00962 f.low_level_read_lo(v); 00963 else if (h.type == "dvec") 00964 f.low_level_read_hi(v); 00965 else 00966 it_error("Wrong type"); 00967 00968 return f; 00969 } 00970 00971 it_ifile &operator>>(it_ifile &f, ivec &v) 00972 { 00973 it_file::data_header h; 00974 00975 f.read_data_header(h); 00976 if (h.type == "ivec") 00977 f.low_level_read(v); 00978 else 00979 it_error("Wrong type"); 00980 00981 return f; 00982 } 00983 00984 it_ifile &operator>>(it_ifile &f, bvec &v) 00985 { 00986 it_file::data_header h; 00987 00988 f.read_data_header(h); 00989 if (h.type == "bvec") 00990 f.low_level_read(v); 00991 else 00992 it_error("Wrong type"); 00993 00994 return f; 00995 } 00996 00997 it_ifile &operator>>(it_ifile &f, cvec &v) 00998 { 00999 it_file::data_header h; 01000 01001 f.read_data_header(h); 01002 if (h.type == "fcvec") 01003 f.low_level_read_lo(v); 01004 else if (h.type == "dcvec") 01005 f.low_level_read_hi(v); 01006 else 01007 it_error("Wrong type"); 01008 01009 return f; 01010 } 01011 01012 it_ifile &operator>>(it_ifile &f, std::string &str) 01013 { 01014 it_file::data_header h; 01015 01016 f.read_data_header(h); 01017 if (h.type == "string") 01018 f.low_level_read(str); 01019 else 01020 it_error("Wrong type"); 01021 01022 return f; 01023 } 01024 01025 it_ifile &operator>>(it_ifile &f, mat &m) 01026 { 01027 it_file::data_header h; 01028 01029 f.read_data_header(h); 01030 if (h.type == "fmat") 01031 f.low_level_read_lo(m); 01032 else if (h.type == "dmat") 01033 f.low_level_read_hi(m); 01034 else 01035 it_error("Wrong type"); 01036 01037 return f; 01038 } 01039 01040 it_ifile &operator>>(it_ifile &f, imat &m) 01041 { 01042 it_file::data_header h; 01043 01044 f.read_data_header(h); 01045 if (h.type == "imat") 01046 f.low_level_read(m); 01047 else 01048 it_error("Wrong type"); 01049 01050 return f; 01051 } 01052 01053 it_ifile &operator>>(it_ifile &f, bmat &m) 01054 { 01055 it_file::data_header h; 01056 01057 f.read_data_header(h); 01058 if (h.type == "bmat") 01059 f.low_level_read(m); 01060 else 01061 it_error("Wrong type"); 01062 01063 return f; 01064 } 01065 01066 it_ifile &operator>>(it_ifile &f, cmat &m) 01067 { 01068 it_file::data_header h; 01069 01070 f.read_data_header(h); 01071 if (h.type == "fcmat") 01072 f.low_level_read_lo(m); 01073 else if (h.type == "dcmat") 01074 f.low_level_read_hi(m); 01075 else 01076 it_error("Wrong type"); 01077 01078 return f; 01079 } 01080 01081 it_ifile &operator>>(it_ifile &f, Array<float> &v) 01082 { 01083 it_file::data_header h; 01084 01085 f.read_data_header(h); 01086 if (h.type == "fArray") 01087 f.low_level_read_lo(v); 01088 else 01089 it_error("Wrong type"); 01090 01091 return f; 01092 } 01093 01094 it_ifile &operator>>(it_ifile &f, Array<double> &v) 01095 { 01096 it_file::data_header h; 01097 01098 f.read_data_header(h); 01099 if (h.type == "fArray") 01100 f.low_level_read_lo(v); 01101 else if (h.type == "dArray") 01102 f.low_level_read_hi(v); 01103 else 01104 it_error("Wrong type"); 01105 01106 return f; 01107 } 01108 01109 it_ifile &operator>>(it_ifile &f, Array<int> &v) 01110 { 01111 it_file::data_header h; 01112 01113 f.read_data_header(h); 01114 if (h.type == "iArray") 01115 f.low_level_read(v); 01116 else 01117 it_error("Wrong type"); 01118 01119 return f; 01120 } 01121 01122 it_ifile &operator>>(it_ifile &f, Array<bin> &v) 01123 { 01124 it_file::data_header h; 01125 01126 f.read_data_header(h); 01127 if (h.type == "bArray") 01128 f.low_level_read(v); 01129 else 01130 it_error("Wrong type"); 01131 01132 return f; 01133 } 01134 01135 it_ifile &operator>>(it_ifile &f, Array<std::complex<float> > &v) 01136 { 01137 it_file::data_header h; 01138 01139 f.read_data_header(h); 01140 if (h.type == "fcArray") 01141 f.low_level_read_lo(v); 01142 else 01143 it_error("Wrong type"); 01144 01145 return f; 01146 } 01147 01148 it_ifile &operator>>(it_ifile &f, Array<std::complex<double> > &v) 01149 { 01150 it_file::data_header h; 01151 01152 f.read_data_header(h); 01153 if (h.type == "fcArray") 01154 f.low_level_read_lo(v); 01155 else if (h.type == "dcArray") 01156 f.low_level_read_hi(v); 01157 else 01158 it_error("Wrong type"); 01159 01160 return f; 01161 } 01162 01163 it_ifile &operator>>(it_ifile &f, Array<vec> &v) 01164 { 01165 it_file::data_header h; 01166 01167 f.read_data_header(h); 01168 if (h.type == "vecArray") { 01169 int n; 01170 f.low_level_read(n); 01171 v.set_size(n, false); 01172 for (int i=0; i<n; i++) 01173 f.low_level_read_hi(v(i)); 01174 } 01175 else 01176 it_error("Wrong type"); 01177 01178 return f; 01179 } 01180 01181 it_ifile &operator>>(it_ifile &f, Array<ivec> &v) 01182 { 01183 it_file::data_header h; 01184 01185 f.read_data_header(h); 01186 if (h.type == "ivecArray") { 01187 int n; 01188 f.low_level_read(n); 01189 v.set_size(n, false); 01190 for (int i=0; i<n; i++) 01191 f.low_level_read(v(i)); 01192 } 01193 else 01194 it_error("Wrong type"); 01195 01196 return f; 01197 } 01198 01199 it_ifile &operator>>(it_ifile &f, Array<bvec> &v) 01200 { 01201 it_file::data_header h; 01202 01203 f.read_data_header(h); 01204 if (h.type == "bvecArray") { 01205 int n; 01206 f.low_level_read(n); 01207 v.set_size(n, false); 01208 for (int i=0; i<n; i++) 01209 f.low_level_read(v(i)); 01210 } 01211 else 01212 it_error("Wrong type"); 01213 01214 return f; 01215 } 01216 01217 it_ifile &operator>>(it_ifile &f, Array<cvec> &v) 01218 { 01219 it_file::data_header h; 01220 01221 f.read_data_header(h); 01222 if (h.type == "cvecArray") { 01223 int n; 01224 f.low_level_read(n); 01225 v.set_size(n, false); 01226 for (int i=0; i<n; i++) 01227 f.low_level_read_hi(v(i)); 01228 } 01229 else 01230 it_error("Wrong type"); 01231 01232 return f; 01233 } 01234 01235 it_ifile &operator>>(it_ifile &f, Array<std::string> &v) 01236 { 01237 it_file::data_header h; 01238 01239 f.read_data_header(h); 01240 if (h.type == "stringArray") { 01241 int n; 01242 f.low_level_read(n); 01243 v.set_size(n, false); 01244 for (int i=0; i<n; i++) 01245 f.low_level_read(v(i)); 01246 } 01247 else 01248 it_error("Wrong type"); 01249 01250 return f; 01251 } 01252 01253 it_ifile &operator>>(it_ifile &f, Array<mat> &v) 01254 { 01255 it_file::data_header h; 01256 01257 f.read_data_header(h); 01258 if (h.type == "matArray") { 01259 int n; 01260 f.low_level_read(n); 01261 v.set_size(n, false); 01262 for (int i=0; i<n; i++) 01263 f.low_level_read_hi(v(i)); 01264 } 01265 else 01266 it_error("Wrong type"); 01267 01268 return f; 01269 } 01270 01271 it_ifile &operator>>(it_ifile &f, Array<imat> &v) 01272 { 01273 it_file::data_header h; 01274 01275 f.read_data_header(h); 01276 if (h.type == "imatArray") { 01277 int n; 01278 f.low_level_read(n); 01279 v.set_size(n, false); 01280 for (int i=0; i<n; i++) 01281 f.low_level_read(v(i)); 01282 } 01283 else 01284 it_error("Wrong type"); 01285 01286 return f; 01287 } 01288 01289 it_ifile &operator>>(it_ifile &f, Array<bmat> &v) 01290 { 01291 it_file::data_header h; 01292 01293 f.read_data_header(h); 01294 if (h.type == "bmatArray") { 01295 int n; 01296 f.low_level_read(n); 01297 v.set_size(n, false); 01298 for (int i=0; i<n; i++) 01299 f.low_level_read(v(i)); 01300 } 01301 else 01302 it_error("Wrong type"); 01303 01304 return f; 01305 } 01306 01307 it_ifile &operator>>(it_ifile &f, Array<cmat> &v) 01308 { 01309 it_file::data_header h; 01310 01311 f.read_data_header(h); 01312 if (h.type == "cmatArray") { 01313 int n; 01314 f.low_level_read(n); 01315 v.set_size(n, false); 01316 for (int i=0; i<n; i++) 01317 f.low_level_read_hi(v(i)); 01318 } 01319 else 01320 it_error("Wrong type"); 01321 01322 return f; 01323 } 01324 01325 it_file &operator<<(it_file &f, bin x) 01326 { 01327 f.write_data_header("bin", sizeof(bin)); 01328 f.low_level_write(x); 01329 01330 return f; 01331 } 01332 01333 it_file &operator<<(it_file &f, short x) 01334 { 01335 f.write_data_header("int16", sizeof(short)); 01336 f.low_level_write(x); 01337 01338 return f; 01339 } 01340 01341 it_file &operator<<(it_file &f, int x) 01342 { 01343 f.write_data_header("int32", sizeof(int)); 01344 f.low_level_write(x); 01345 01346 return f; 01347 } 01348 01349 it_file &operator<<(it_file &f, float x) 01350 { 01351 f.write_data_header("float32", sizeof(float)); 01352 f.low_level_write(x); 01353 01354 return f; 01355 } 01356 01357 it_file &operator<<(it_file &f, double x) 01358 { 01359 f.write_data_header("float64", sizeof(double)); 01360 f.low_level_write(x); 01361 01362 return f; 01363 } 01364 01365 it_file &operator<<(it_file &f, std::complex<float> x) 01366 { 01367 f.write_data_header("float32_complex", 2*sizeof(float)); 01368 f.low_level_write(x); 01369 01370 return f; 01371 } 01372 01373 it_file &operator<<(it_file &f, std::complex<double> x) 01374 { 01375 f.write_data_header("float64_complex", 2*sizeof(double)); 01376 f.low_level_write(x); 01377 01378 return f; 01379 } 01380 01381 it_file &operator<<(it_file &f, const vec &v) 01382 { 01383 if (f.get_low_precision()) 01384 f.write_data_header("fvec", sizeof(int) + v.size() * sizeof(float)); 01385 else 01386 f.write_data_header("dvec", sizeof(int) + v.size() * sizeof(double)); 01387 f.low_level_write(v); 01388 01389 return f; 01390 } 01391 01392 it_file &operator<<(it_file &f, const ivec &v) 01393 { 01394 f.write_data_header("ivec", (1 + v.size()) * sizeof(int)); 01395 f.low_level_write(v); 01396 01397 return f; 01398 } 01399 01400 it_file &operator<<(it_file &f, const bvec &v) 01401 { 01402 f.write_data_header("bvec", sizeof(int) + v.size() * sizeof(bin) ); 01403 f.low_level_write(v); 01404 01405 return f; 01406 } 01407 01408 it_file &operator<<(it_file &f, const cvec &v) 01409 { 01410 if (f.get_low_precision()) 01411 f.write_data_header("fcvec", sizeof(int) + v.size() * 2 * sizeof(float)); 01412 else 01413 f.write_data_header("dcvec", sizeof(int) + v.size() * 2 * sizeof(double)); 01414 f.low_level_write(v); 01415 01416 return f; 01417 } 01418 01419 it_file &operator<<(it_file &f, const std::string &str) 01420 { 01421 f.write_data_header("string", sizeof(int) + str.size() * sizeof(char) ); 01422 f.low_level_write(str); 01423 01424 return f; 01425 } 01426 01427 it_file &operator<<(it_file &f, const mat &m) 01428 { 01429 if (f.get_low_precision()) 01430 f.write_data_header("fmat", 2*sizeof(int) + m.rows()*m.cols()*sizeof(float)); 01431 else 01432 f.write_data_header("dmat", 2*sizeof(int) + m.rows()*m.cols()*sizeof(double)); 01433 f.low_level_write(m); 01434 01435 return f; 01436 } 01437 01438 it_file &operator<<(it_file &f, const imat &m) 01439 { 01440 f.write_data_header("imat", (2 + m.rows()*m.cols()) * sizeof(int)); 01441 f.low_level_write(m); 01442 01443 return f; 01444 } 01445 01446 it_file &operator<<(it_file &f, const bmat &m) 01447 { 01448 f.write_data_header("bmat", 2*sizeof(int) + m.rows()*m.cols()*sizeof(bin) ); 01449 f.low_level_write(m); 01450 01451 return f; 01452 } 01453 01454 it_file &operator<<(it_file &f, const cmat &m) 01455 { 01456 if (f.get_low_precision()) 01457 f.write_data_header("fcmat", 2*sizeof(int) + 2*m.rows()*m.cols()*sizeof(float)); 01458 else 01459 f.write_data_header("dcmat", 2*sizeof(int) + 2*m.rows()*m.cols()*sizeof(double)); 01460 f.low_level_write(m); 01461 01462 return f; 01463 } 01464 01465 it_file &operator<<(it_file &f, const Array<float> &v) 01466 { 01467 f.write_data_header("fArray", sizeof(int) + v.size() * sizeof(float)); 01468 f.low_level_write(v); 01469 01470 return f; 01471 } 01472 01473 it_file &operator<<(it_file &f, const Array<double> &v) 01474 { 01475 if (f.get_low_precision()) 01476 f.write_data_header("fArray", sizeof(int) + v.size() * sizeof(float)); 01477 else 01478 f.write_data_header("dArray", sizeof(int) + v.size() * sizeof(double)); 01479 f.low_level_write(v); 01480 01481 return f; 01482 } 01483 01484 it_file &operator<<(it_file &f, const Array<int> &v) 01485 { 01486 f.write_data_header("iArray", (1 + v.size()) * sizeof(int)); 01487 f.low_level_write(v); 01488 01489 return f; 01490 } 01491 01492 it_file &operator<<(it_file &f, const Array<bin> &v) 01493 { 01494 f.write_data_header("bArray", sizeof(int) + v.size() * sizeof(bin) ); 01495 f.low_level_write(v); 01496 01497 return f; 01498 } 01499 01500 it_file &operator<<(it_file &f, const Array<std::complex<float> > &v) 01501 { 01502 f.write_data_header("fcArray", sizeof(int) + v.size() * 2 * sizeof(float)); 01503 f.low_level_write(v); 01504 01505 return f; 01506 } 01507 01508 it_file &operator<<(it_file &f, const Array<std::complex<double> > &v) 01509 { 01510 if (f.get_low_precision()) 01511 f.write_data_header("fcArray", sizeof(int) + v.size() * 2 * sizeof(float)); 01512 else 01513 f.write_data_header("dcArray", sizeof(int) + v.size() * 2 * sizeof(double)); 01514 f.low_level_write(v); 01515 01516 return f; 01517 } 01518 01519 it_file &operator<<(it_file &f, const Array<vec> &v) 01520 { 01521 int i, sum_l=0; 01522 01523 // calculate total length of Array 01524 for (i=0; i<v.size(); i++) { 01525 sum_l += v(i).size(); 01526 } 01527 01528 // write header 01529 f.write_data_header("vecArray", sizeof(int)*(1+v.size()) + sum_l * sizeof(double)); 01530 01531 f.low_level_write(v.size()); // the length of the array 01532 01533 // write one vector at a time (i.e. size and elements) 01534 for (i=0; i<v.size(); i++) 01535 f.low_level_write(v(i)); 01536 01537 return f; 01538 } 01539 01540 it_file &operator<<(it_file &f, const Array<ivec> &v) 01541 { 01542 int i, sum_l=0; 01543 01544 // calculate total length of Array 01545 for (i=0; i<v.size(); i++) { 01546 sum_l += v(i).size(); 01547 } 01548 01549 // write header 01550 f.write_data_header("ivecArray", sizeof(int)*(1+v.size()) + sum_l * sizeof(int)); 01551 01552 f.low_level_write(v.size()); // the length of the array 01553 01554 // write one vector at a time (i.e. size and elements) 01555 for (i=0; i<v.size(); i++) 01556 f.low_level_write(v(i)); 01557 01558 return f; 01559 } 01560 01561 it_file &operator<<(it_file &f, const Array<bvec> &v) 01562 { 01563 int i, sum_l=0; 01564 01565 // calculate total length of Array 01566 for (i=0; i<v.size(); i++) { 01567 sum_l += v(i).size(); 01568 } 01569 01570 // write header 01571 f.write_data_header("bvecArray", sizeof(int)*(1+v.size()) + sum_l * sizeof(bin)); 01572 01573 f.low_level_write(v.size()); // the length of the array 01574 01575 // write one vector at a time (i.e. size and elements) 01576 for (i=0; i<v.size(); i++) 01577 f.low_level_write(v(i)); 01578 01579 return f; 01580 } 01581 01582 it_file &operator<<(it_file &f, const Array<cvec> &v) 01583 { 01584 int i, sum_l=0; 01585 01586 // calculate total length of Array 01587 for (i=0; i<v.size(); i++) { 01588 sum_l += v(i).size(); 01589 } 01590 01591 // write header 01592 f.write_data_header("cvecArray", sizeof(int)*(1+v.size()) + sum_l * sizeof(std::complex<double>)); 01593 01594 f.low_level_write(v.size()); // the length of the array 01595 01596 // write one vector at a time (i.e. size and elements) 01597 for (i=0; i<v.size(); i++) 01598 f.low_level_write(v(i)); 01599 01600 return f; 01601 } 01602 01603 it_file &operator<<(it_file &f, const Array<std::string> &v) 01604 { 01605 int i, sum_l=0; 01606 01607 // calculate total length of Array 01608 for (i=0; i<v.size(); i++) { 01609 sum_l += v(i).size(); 01610 } 01611 01612 // write header 01613 f.write_data_header("stringArray", sizeof(int)*(1+v.size()) + sum_l * sizeof(char)); 01614 01615 f.low_level_write(v.size()); // the length of the array 01616 01617 // write one vector at a time (i.e. size and elements) 01618 for (i=0; i<v.size(); i++) 01619 f.low_level_write(v(i)); 01620 01621 return f; 01622 } 01623 01624 it_file &operator<<(it_file &f, const Array<mat> &v) 01625 { 01626 int i, sum_l=0; 01627 01628 // calculate total length of Array 01629 for (i=0; i<v.size(); i++) { 01630 sum_l += v(i)._datasize(); 01631 } 01632 01633 // write header 01634 f.write_data_header("matArray", sizeof(int)*(1+2*v.size()) + sum_l * sizeof(double)); 01635 01636 f.low_level_write(v.size()); // the length of the array 01637 01638 // write one matrix at a time (i.e. size and elements) 01639 for (i=0; i<v.size(); i++) 01640 f.low_level_write(v(i)); 01641 01642 return f; 01643 } 01644 01645 it_file &operator<<(it_file &f, const Array<imat> &v) 01646 { 01647 int i, sum_l=0; 01648 01649 // calculate total length of Array 01650 for (i=0; i<v.size(); i++) { 01651 sum_l += v(i)._datasize(); 01652 } 01653 01654 // write header 01655 f.write_data_header("imatArray", sizeof(int)*(1+2*v.size()) + sum_l * sizeof(int)); 01656 01657 f.low_level_write(v.size()); // the length of the array 01658 01659 // write one matrix at a time (i.e. size and elements) 01660 for (i=0; i<v.size(); i++) 01661 f.low_level_write(v(i)); 01662 01663 return f; 01664 } 01665 01666 it_file &operator<<(it_file &f, const Array<bmat> &v) 01667 { 01668 int i, sum_l=0; 01669 01670 // calculate total length of Array 01671 for (i=0; i<v.size(); i++) { 01672 sum_l += v(i)._datasize(); 01673 } 01674 01675 // write header 01676 f.write_data_header("bmatArray", sizeof(int)*(1+2*v.size()) + sum_l * sizeof(bin)); 01677 01678 f.low_level_write(v.size()); // the length of the array 01679 01680 // write one matrix at a time (i.e. size and elements) 01681 for (i=0; i<v.size(); i++) 01682 f.low_level_write(v(i)); 01683 01684 return f; 01685 } 01686 01687 it_file &operator<<(it_file &f, const Array<cmat> &v) 01688 { 01689 int i, sum_l=0; 01690 01691 // calculate total length of Array 01692 for (i=0; i<v.size(); i++) { 01693 sum_l += v(i)._datasize(); 01694 } 01695 01696 // write header 01697 f.write_data_header("cmatArray", sizeof(int)*(1+2*v.size()) + sum_l * sizeof(std::complex<double>)); 01698 01699 f.low_level_write(v.size()); // the length of the array 01700 01701 // write one matrix at a time (i.e. size and elements) 01702 for (i=0; i<v.size(); i++) 01703 f.low_level_write(v(i)); 01704 01705 return f; 01706 } 01707 01708 } // namespace itpp
Generated on Wed Mar 21 12:21:34 2007 for IT++ by Doxygen 1.4.7