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 int size = str.size(); 00718 s << size; 00719 00720 for (int i=0; i< size; i++) 00721 s << str[i]; 00722 } 00723 00724 void it_file::low_level_write(const mat &m) 00725 { 00726 int i, j; 00727 00728 if (get_low_precision()) { 00729 s << m.rows() << m.cols(); 00730 for (j=0; j<m.cols(); j++) 00731 for (i=0; i<m.rows(); i++) 00732 s << static_cast<float>(m(i,j)); 00733 } 00734 else { 00735 s << m.rows() << m.cols(); 00736 for (j=0; j<m.cols(); j++) 00737 for (i=0; i<m.rows(); i++) 00738 s << static_cast<double>(m(i,j)); 00739 } 00740 } 00741 00742 void it_file::low_level_write(const imat &m) 00743 { 00744 int i, j; 00745 00746 s << m.rows() << m.cols(); 00747 for (j=0; j<m.cols(); j++) 00748 for (i=0; i<m.rows(); i++) 00749 s << m(i,j); 00750 } 00751 00752 void it_file::low_level_write(const bmat &m) 00753 { 00754 int i, j; 00755 00756 s << m.rows() << m.cols(); 00757 for (j=0; j<m.cols(); j++) 00758 for (i=0; i<m.rows(); i++) 00759 s << m(i,j); 00760 } 00761 00762 void it_file::low_level_write(const cmat &m) 00763 { 00764 int i, j; 00765 00766 if (get_low_precision()) { 00767 s << m.rows() << m.cols(); 00768 for (j=0; j<m.cols(); j++) 00769 for (i=0; i<m.rows(); i++) { 00770 s << static_cast<float>(m(i,j).real()); 00771 s << static_cast<float>(m(i,j).imag()); 00772 } 00773 00774 } 00775 else { 00776 s << m.rows() << m.cols(); 00777 for (j=0; j<m.cols(); j++) 00778 for (i=0; i<m.rows(); i++) { 00779 s << static_cast<double>(m(i,j).real()); 00780 s << static_cast<double>(m(i,j).imag()); 00781 } 00782 } 00783 } 00784 00785 void it_file::low_level_write(const Array<float> &v) 00786 { 00787 s << v.size(); 00788 for (int i=0; i<v.size(); i++) 00789 s << v(i); 00790 } 00791 00792 void it_file::low_level_write(const Array<double> &v) 00793 { 00794 if (get_low_precision()) { 00795 s << v.size(); 00796 for (int i=0; i<v.size(); i++) 00797 s << static_cast<float>(v(i)); 00798 } 00799 else { 00800 s << v.size(); 00801 for (int i=0; i<v.size(); i++) 00802 s << static_cast<double>(v(i)); 00803 } 00804 } 00805 00806 void it_file::low_level_write(const Array<int> &v) 00807 { 00808 s << v.size(); 00809 for (int i=0; i<v.size(); i++) 00810 s << v(i); 00811 } 00812 00813 void it_file::low_level_write(const Array<bin> &v) 00814 { 00815 s << v.size(); 00816 for (int i=0; i<v.size(); i++) 00817 s << v(i); 00818 } 00819 00820 void it_file::low_level_write(const Array<std::complex<float> > &v) 00821 { 00822 s << v.size(); 00823 for (int i=0; i<v.size(); i++) { 00824 s << v(i).real(); 00825 s << v(i).imag(); 00826 } 00827 } 00828 00829 void it_file::low_level_write(const Array<std::complex<double> > &v) 00830 { 00831 if (get_low_precision()) { 00832 s << v.size(); 00833 for (int i=0; i<v.size(); i++) { 00834 s << static_cast<float>(v(i).real()); 00835 s << static_cast<float>(v(i).imag()); 00836 } 00837 } 00838 else { 00839 s << v.size(); 00840 for (int i=0; i<v.size(); i++) { 00841 s << static_cast<double>(v(i).real()); 00842 s << static_cast<double>(v(i).imag()); 00843 } 00844 } 00845 } 00846 00847 it_ifile &operator>>(it_ifile &f, bin &x) 00848 { 00849 it_file::data_header h; 00850 00851 f.read_data_header(h); 00852 if (h.type == "bin") 00853 f.low_level_read(x); 00854 else 00855 it_error("Wrong type"); 00856 00857 return f; 00858 } 00859 00860 it_ifile &operator>>(it_ifile &f, short &x) 00861 { 00862 it_file::data_header h; 00863 00864 f.read_data_header(h); 00865 if (h.type == "int16") 00866 f.low_level_read(x); 00867 else 00868 it_error("Wrong type"); 00869 00870 return f; 00871 } 00872 00873 it_ifile &operator>>(it_ifile &f, int &x) 00874 { 00875 it_file::data_header h; 00876 00877 f.read_data_header(h); 00878 if (h.type == "int32") 00879 f.low_level_read(x); 00880 else if (h.type == "int16") { 00881 short x16; 00882 f.low_level_read(x16); 00883 x = x16; 00884 } 00885 else 00886 it_error("Wrong type"); 00887 00888 return f; 00889 } 00890 00891 it_ifile &operator>>(it_ifile &f, double &x) 00892 { 00893 it_file::data_header h; 00894 00895 f.read_data_header(h); 00896 if (h.type == "float64") 00897 f.low_level_read(x); 00898 else if (h.type == "float32") { 00899 float f32; 00900 f.low_level_read(f32); 00901 x = f32; 00902 } 00903 else 00904 it_error("Wrong type"); 00905 00906 return f; 00907 } 00908 00909 it_ifile &operator>>(it_ifile &f, float &x) 00910 { 00911 it_file::data_header h; 00912 00913 f.read_data_header(h); 00914 if (h.type == "float32") 00915 f.low_level_read(x); 00916 else 00917 it_error("Wrong type"); 00918 00919 return f; 00920 } 00921 00922 it_ifile &operator>>(it_ifile &f, std::complex<float> &x) 00923 { 00924 it_file::data_header h; 00925 00926 f.read_data_header(h); 00927 00928 if (h.type == "float32_complex") { 00929 std::complex<float> f32_c; 00930 f.low_level_read(f32_c); 00931 x = f32_c; 00932 } 00933 else 00934 it_error("Wrong type"); 00935 00936 return f; 00937 } 00938 00939 it_ifile &operator>>(it_ifile &f, std::complex<double> &x) 00940 { 00941 it_file::data_header h; 00942 00943 f.read_data_header(h); 00944 if (h.type == "float64_complex") 00945 f.low_level_read(x); 00946 else if (h.type == "float32_complex") { 00947 std::complex<float> f32_c; 00948 f.low_level_read(f32_c); 00949 x = f32_c; 00950 } 00951 else 00952 it_error("Wrong type"); 00953 00954 return f; 00955 } 00956 00957 it_ifile &operator>>(it_ifile &f, vec &v) 00958 { 00959 it_ifile::data_header h; 00960 00961 f.read_data_header(h); 00962 if (h.type == "fvec") 00963 f.low_level_read_lo(v); 00964 else if (h.type == "dvec") 00965 f.low_level_read_hi(v); 00966 else 00967 it_error("Wrong type"); 00968 00969 return f; 00970 } 00971 00972 it_ifile &operator>>(it_ifile &f, ivec &v) 00973 { 00974 it_file::data_header h; 00975 00976 f.read_data_header(h); 00977 if (h.type == "ivec") 00978 f.low_level_read(v); 00979 else 00980 it_error("Wrong type"); 00981 00982 return f; 00983 } 00984 00985 it_ifile &operator>>(it_ifile &f, bvec &v) 00986 { 00987 it_file::data_header h; 00988 00989 f.read_data_header(h); 00990 if (h.type == "bvec") 00991 f.low_level_read(v); 00992 else 00993 it_error("Wrong type"); 00994 00995 return f; 00996 } 00997 00998 it_ifile &operator>>(it_ifile &f, cvec &v) 00999 { 01000 it_file::data_header h; 01001 01002 f.read_data_header(h); 01003 if (h.type == "fcvec") 01004 f.low_level_read_lo(v); 01005 else if (h.type == "dcvec") 01006 f.low_level_read_hi(v); 01007 else 01008 it_error("Wrong type"); 01009 01010 return f; 01011 } 01012 01013 it_ifile &operator>>(it_ifile &f, std::string &str) 01014 { 01015 it_file::data_header h; 01016 01017 f.read_data_header(h); 01018 if (h.type == "string") 01019 f.low_level_read(str); 01020 else 01021 it_error("Wrong type"); 01022 01023 return f; 01024 } 01025 01026 it_ifile &operator>>(it_ifile &f, mat &m) 01027 { 01028 it_file::data_header h; 01029 01030 f.read_data_header(h); 01031 if (h.type == "fmat") 01032 f.low_level_read_lo(m); 01033 else if (h.type == "dmat") 01034 f.low_level_read_hi(m); 01035 else 01036 it_error("Wrong type"); 01037 01038 return f; 01039 } 01040 01041 it_ifile &operator>>(it_ifile &f, imat &m) 01042 { 01043 it_file::data_header h; 01044 01045 f.read_data_header(h); 01046 if (h.type == "imat") 01047 f.low_level_read(m); 01048 else 01049 it_error("Wrong type"); 01050 01051 return f; 01052 } 01053 01054 it_ifile &operator>>(it_ifile &f, bmat &m) 01055 { 01056 it_file::data_header h; 01057 01058 f.read_data_header(h); 01059 if (h.type == "bmat") 01060 f.low_level_read(m); 01061 else 01062 it_error("Wrong type"); 01063 01064 return f; 01065 } 01066 01067 it_ifile &operator>>(it_ifile &f, cmat &m) 01068 { 01069 it_file::data_header h; 01070 01071 f.read_data_header(h); 01072 if (h.type == "fcmat") 01073 f.low_level_read_lo(m); 01074 else if (h.type == "dcmat") 01075 f.low_level_read_hi(m); 01076 else 01077 it_error("Wrong type"); 01078 01079 return f; 01080 } 01081 01082 it_ifile &operator>>(it_ifile &f, Array<float> &v) 01083 { 01084 it_file::data_header h; 01085 01086 f.read_data_header(h); 01087 if (h.type == "fArray") 01088 f.low_level_read_lo(v); 01089 else 01090 it_error("Wrong type"); 01091 01092 return f; 01093 } 01094 01095 it_ifile &operator>>(it_ifile &f, Array<double> &v) 01096 { 01097 it_file::data_header h; 01098 01099 f.read_data_header(h); 01100 if (h.type == "fArray") 01101 f.low_level_read_lo(v); 01102 else if (h.type == "dArray") 01103 f.low_level_read_hi(v); 01104 else 01105 it_error("Wrong type"); 01106 01107 return f; 01108 } 01109 01110 it_ifile &operator>>(it_ifile &f, Array<int> &v) 01111 { 01112 it_file::data_header h; 01113 01114 f.read_data_header(h); 01115 if (h.type == "iArray") 01116 f.low_level_read(v); 01117 else 01118 it_error("Wrong type"); 01119 01120 return f; 01121 } 01122 01123 it_ifile &operator>>(it_ifile &f, Array<bin> &v) 01124 { 01125 it_file::data_header h; 01126 01127 f.read_data_header(h); 01128 if (h.type == "bArray") 01129 f.low_level_read(v); 01130 else 01131 it_error("Wrong type"); 01132 01133 return f; 01134 } 01135 01136 it_ifile &operator>>(it_ifile &f, Array<std::complex<float> > &v) 01137 { 01138 it_file::data_header h; 01139 01140 f.read_data_header(h); 01141 if (h.type == "fcArray") 01142 f.low_level_read_lo(v); 01143 else 01144 it_error("Wrong type"); 01145 01146 return f; 01147 } 01148 01149 it_ifile &operator>>(it_ifile &f, Array<std::complex<double> > &v) 01150 { 01151 it_file::data_header h; 01152 01153 f.read_data_header(h); 01154 if (h.type == "fcArray") 01155 f.low_level_read_lo(v); 01156 else if (h.type == "dcArray") 01157 f.low_level_read_hi(v); 01158 else 01159 it_error("Wrong type"); 01160 01161 return f; 01162 } 01163 01164 it_ifile &operator>>(it_ifile &f, Array<vec> &v) 01165 { 01166 it_file::data_header h; 01167 01168 f.read_data_header(h); 01169 if (h.type == "vecArray") { 01170 int n; 01171 f.low_level_read(n); 01172 v.set_size(n, false); 01173 for (int i=0; i<n; i++) 01174 f.low_level_read_hi(v(i)); 01175 } 01176 else 01177 it_error("Wrong type"); 01178 01179 return f; 01180 } 01181 01182 it_ifile &operator>>(it_ifile &f, Array<ivec> &v) 01183 { 01184 it_file::data_header h; 01185 01186 f.read_data_header(h); 01187 if (h.type == "ivecArray") { 01188 int n; 01189 f.low_level_read(n); 01190 v.set_size(n, false); 01191 for (int i=0; i<n; i++) 01192 f.low_level_read(v(i)); 01193 } 01194 else 01195 it_error("Wrong type"); 01196 01197 return f; 01198 } 01199 01200 it_ifile &operator>>(it_ifile &f, Array<bvec> &v) 01201 { 01202 it_file::data_header h; 01203 01204 f.read_data_header(h); 01205 if (h.type == "bvecArray") { 01206 int n; 01207 f.low_level_read(n); 01208 v.set_size(n, false); 01209 for (int i=0; i<n; i++) 01210 f.low_level_read(v(i)); 01211 } 01212 else 01213 it_error("Wrong type"); 01214 01215 return f; 01216 } 01217 01218 it_ifile &operator>>(it_ifile &f, Array<cvec> &v) 01219 { 01220 it_file::data_header h; 01221 01222 f.read_data_header(h); 01223 if (h.type == "cvecArray") { 01224 int n; 01225 f.low_level_read(n); 01226 v.set_size(n, false); 01227 for (int i=0; i<n; i++) 01228 f.low_level_read_hi(v(i)); 01229 } 01230 else 01231 it_error("Wrong type"); 01232 01233 return f; 01234 } 01235 01236 it_ifile &operator>>(it_ifile &f, Array<std::string> &v) 01237 { 01238 it_file::data_header h; 01239 01240 f.read_data_header(h); 01241 if (h.type == "stringArray") { 01242 int n; 01243 f.low_level_read(n); 01244 v.set_size(n, false); 01245 for (int i=0; i<n; i++) 01246 f.low_level_read(v(i)); 01247 } 01248 else 01249 it_error("Wrong type"); 01250 01251 return f; 01252 } 01253 01254 it_ifile &operator>>(it_ifile &f, Array<mat> &v) 01255 { 01256 it_file::data_header h; 01257 01258 f.read_data_header(h); 01259 if (h.type == "matArray") { 01260 int n; 01261 f.low_level_read(n); 01262 v.set_size(n, false); 01263 for (int i=0; i<n; i++) 01264 f.low_level_read_hi(v(i)); 01265 } 01266 else 01267 it_error("Wrong type"); 01268 01269 return f; 01270 } 01271 01272 it_ifile &operator>>(it_ifile &f, Array<imat> &v) 01273 { 01274 it_file::data_header h; 01275 01276 f.read_data_header(h); 01277 if (h.type == "imatArray") { 01278 int n; 01279 f.low_level_read(n); 01280 v.set_size(n, false); 01281 for (int i=0; i<n; i++) 01282 f.low_level_read(v(i)); 01283 } 01284 else 01285 it_error("Wrong type"); 01286 01287 return f; 01288 } 01289 01290 it_ifile &operator>>(it_ifile &f, Array<bmat> &v) 01291 { 01292 it_file::data_header h; 01293 01294 f.read_data_header(h); 01295 if (h.type == "bmatArray") { 01296 int n; 01297 f.low_level_read(n); 01298 v.set_size(n, false); 01299 for (int i=0; i<n; i++) 01300 f.low_level_read(v(i)); 01301 } 01302 else 01303 it_error("Wrong type"); 01304 01305 return f; 01306 } 01307 01308 it_ifile &operator>>(it_ifile &f, Array<cmat> &v) 01309 { 01310 it_file::data_header h; 01311 01312 f.read_data_header(h); 01313 if (h.type == "cmatArray") { 01314 int n; 01315 f.low_level_read(n); 01316 v.set_size(n, false); 01317 for (int i=0; i<n; i++) 01318 f.low_level_read_hi(v(i)); 01319 } 01320 else 01321 it_error("Wrong type"); 01322 01323 return f; 01324 } 01325 01326 it_file &operator<<(it_file &f, bin x) 01327 { 01328 f.write_data_header("bin", sizeof(bin)); 01329 f.low_level_write(x); 01330 01331 return f; 01332 } 01333 01334 it_file &operator<<(it_file &f, short x) 01335 { 01336 f.write_data_header("int16", sizeof(short)); 01337 f.low_level_write(x); 01338 01339 return f; 01340 } 01341 01342 it_file &operator<<(it_file &f, int x) 01343 { 01344 f.write_data_header("int32", sizeof(int)); 01345 f.low_level_write(x); 01346 01347 return f; 01348 } 01349 01350 it_file &operator<<(it_file &f, float x) 01351 { 01352 f.write_data_header("float32", sizeof(float)); 01353 f.low_level_write(x); 01354 01355 return f; 01356 } 01357 01358 it_file &operator<<(it_file &f, double x) 01359 { 01360 f.write_data_header("float64", sizeof(double)); 01361 f.low_level_write(x); 01362 01363 return f; 01364 } 01365 01366 it_file &operator<<(it_file &f, std::complex<float> x) 01367 { 01368 f.write_data_header("float32_complex", 2*sizeof(float)); 01369 f.low_level_write(x); 01370 01371 return f; 01372 } 01373 01374 it_file &operator<<(it_file &f, std::complex<double> x) 01375 { 01376 f.write_data_header("float64_complex", 2*sizeof(double)); 01377 f.low_level_write(x); 01378 01379 return f; 01380 } 01381 01382 it_file &operator<<(it_file &f, const vec &v) 01383 { 01384 if (f.get_low_precision()) 01385 f.write_data_header("fvec", sizeof(int) + v.size() * sizeof(float)); 01386 else 01387 f.write_data_header("dvec", sizeof(int) + v.size() * sizeof(double)); 01388 f.low_level_write(v); 01389 01390 return f; 01391 } 01392 01393 it_file &operator<<(it_file &f, const ivec &v) 01394 { 01395 f.write_data_header("ivec", (1 + v.size()) * sizeof(int)); 01396 f.low_level_write(v); 01397 01398 return f; 01399 } 01400 01401 it_file &operator<<(it_file &f, const bvec &v) 01402 { 01403 f.write_data_header("bvec", sizeof(int) + v.size() * sizeof(bin) ); 01404 f.low_level_write(v); 01405 01406 return f; 01407 } 01408 01409 it_file &operator<<(it_file &f, const cvec &v) 01410 { 01411 if (f.get_low_precision()) 01412 f.write_data_header("fcvec", sizeof(int) + v.size() * 2 * sizeof(float)); 01413 else 01414 f.write_data_header("dcvec", sizeof(int) + v.size() * 2 * sizeof(double)); 01415 f.low_level_write(v); 01416 01417 return f; 01418 } 01419 01420 it_file &operator<<(it_file &f, const std::string &str) 01421 { 01422 f.write_data_header("string", sizeof(int) + str.size() * sizeof(char) ); 01423 f.low_level_write(str); 01424 01425 return f; 01426 } 01427 01428 it_file &operator<<(it_file &f, const mat &m) 01429 { 01430 if (f.get_low_precision()) 01431 f.write_data_header("fmat", 2*sizeof(int) + m.rows()*m.cols()*sizeof(float)); 01432 else 01433 f.write_data_header("dmat", 2*sizeof(int) + m.rows()*m.cols()*sizeof(double)); 01434 f.low_level_write(m); 01435 01436 return f; 01437 } 01438 01439 it_file &operator<<(it_file &f, const imat &m) 01440 { 01441 f.write_data_header("imat", (2 + m.rows()*m.cols()) * sizeof(int)); 01442 f.low_level_write(m); 01443 01444 return f; 01445 } 01446 01447 it_file &operator<<(it_file &f, const bmat &m) 01448 { 01449 f.write_data_header("bmat", 2*sizeof(int) + m.rows()*m.cols()*sizeof(bin) ); 01450 f.low_level_write(m); 01451 01452 return f; 01453 } 01454 01455 it_file &operator<<(it_file &f, const cmat &m) 01456 { 01457 if (f.get_low_precision()) 01458 f.write_data_header("fcmat", 2*sizeof(int) + 2*m.rows()*m.cols()*sizeof(float)); 01459 else 01460 f.write_data_header("dcmat", 2*sizeof(int) + 2*m.rows()*m.cols()*sizeof(double)); 01461 f.low_level_write(m); 01462 01463 return f; 01464 } 01465 01466 it_file &operator<<(it_file &f, const Array<float> &v) 01467 { 01468 f.write_data_header("fArray", sizeof(int) + v.size() * sizeof(float)); 01469 f.low_level_write(v); 01470 01471 return f; 01472 } 01473 01474 it_file &operator<<(it_file &f, const Array<double> &v) 01475 { 01476 if (f.get_low_precision()) 01477 f.write_data_header("fArray", sizeof(int) + v.size() * sizeof(float)); 01478 else 01479 f.write_data_header("dArray", sizeof(int) + v.size() * sizeof(double)); 01480 f.low_level_write(v); 01481 01482 return f; 01483 } 01484 01485 it_file &operator<<(it_file &f, const Array<int> &v) 01486 { 01487 f.write_data_header("iArray", (1 + v.size()) * sizeof(int)); 01488 f.low_level_write(v); 01489 01490 return f; 01491 } 01492 01493 it_file &operator<<(it_file &f, const Array<bin> &v) 01494 { 01495 f.write_data_header("bArray", sizeof(int) + v.size() * sizeof(bin) ); 01496 f.low_level_write(v); 01497 01498 return f; 01499 } 01500 01501 it_file &operator<<(it_file &f, const Array<std::complex<float> > &v) 01502 { 01503 f.write_data_header("fcArray", sizeof(int) + v.size() * 2 * sizeof(float)); 01504 f.low_level_write(v); 01505 01506 return f; 01507 } 01508 01509 it_file &operator<<(it_file &f, const Array<std::complex<double> > &v) 01510 { 01511 if (f.get_low_precision()) 01512 f.write_data_header("fcArray", sizeof(int) + v.size() * 2 * sizeof(float)); 01513 else 01514 f.write_data_header("dcArray", sizeof(int) + v.size() * 2 * sizeof(double)); 01515 f.low_level_write(v); 01516 01517 return f; 01518 } 01519 01520 it_file &operator<<(it_file &f, const Array<vec> &v) 01521 { 01522 int i, sum_l=0; 01523 01524 // calculate total length of Array 01525 for (i=0; i<v.size(); i++) { 01526 sum_l += v(i).size(); 01527 } 01528 01529 // write header 01530 f.write_data_header("vecArray", sizeof(int)*(1+v.size()) + sum_l * sizeof(double)); 01531 01532 f.low_level_write(v.size()); // the length of the array 01533 01534 // write one vector at a time (i.e. size and elements) 01535 for (i=0; i<v.size(); i++) 01536 f.low_level_write(v(i)); 01537 01538 return f; 01539 } 01540 01541 it_file &operator<<(it_file &f, const Array<ivec> &v) 01542 { 01543 int i, sum_l=0; 01544 01545 // calculate total length of Array 01546 for (i=0; i<v.size(); i++) { 01547 sum_l += v(i).size(); 01548 } 01549 01550 // write header 01551 f.write_data_header("ivecArray", sizeof(int)*(1+v.size()) + sum_l * sizeof(int)); 01552 01553 f.low_level_write(v.size()); // the length of the array 01554 01555 // write one vector at a time (i.e. size and elements) 01556 for (i=0; i<v.size(); i++) 01557 f.low_level_write(v(i)); 01558 01559 return f; 01560 } 01561 01562 it_file &operator<<(it_file &f, const Array<bvec> &v) 01563 { 01564 int i, sum_l=0; 01565 01566 // calculate total length of Array 01567 for (i=0; i<v.size(); i++) { 01568 sum_l += v(i).size(); 01569 } 01570 01571 // write header 01572 f.write_data_header("bvecArray", sizeof(int)*(1+v.size()) + sum_l * sizeof(bin)); 01573 01574 f.low_level_write(v.size()); // the length of the array 01575 01576 // write one vector at a time (i.e. size and elements) 01577 for (i=0; i<v.size(); i++) 01578 f.low_level_write(v(i)); 01579 01580 return f; 01581 } 01582 01583 it_file &operator<<(it_file &f, const Array<cvec> &v) 01584 { 01585 int i, sum_l=0; 01586 01587 // calculate total length of Array 01588 for (i=0; i<v.size(); i++) { 01589 sum_l += v(i).size(); 01590 } 01591 01592 // write header 01593 f.write_data_header("cvecArray", sizeof(int)*(1+v.size()) + sum_l * sizeof(std::complex<double>)); 01594 01595 f.low_level_write(v.size()); // the length of the array 01596 01597 // write one vector at a time (i.e. size and elements) 01598 for (i=0; i<v.size(); i++) 01599 f.low_level_write(v(i)); 01600 01601 return f; 01602 } 01603 01604 it_file &operator<<(it_file &f, const Array<std::string> &v) 01605 { 01606 int i, sum_l=0; 01607 01608 // calculate total length of Array 01609 for (i=0; i<v.size(); i++) { 01610 sum_l += v(i).size(); 01611 } 01612 01613 // write header 01614 f.write_data_header("stringArray", sizeof(int)*(1+v.size()) + sum_l * sizeof(char)); 01615 01616 f.low_level_write(v.size()); // the length of the array 01617 01618 // write one vector at a time (i.e. size and elements) 01619 for (i=0; i<v.size(); i++) 01620 f.low_level_write(v(i)); 01621 01622 return f; 01623 } 01624 01625 it_file &operator<<(it_file &f, const Array<mat> &v) 01626 { 01627 int i, sum_l=0; 01628 01629 // calculate total length of Array 01630 for (i=0; i<v.size(); i++) { 01631 sum_l += v(i)._datasize(); 01632 } 01633 01634 // write header 01635 f.write_data_header("matArray", sizeof(int)*(1+2*v.size()) + sum_l * sizeof(double)); 01636 01637 f.low_level_write(v.size()); // the length of the array 01638 01639 // write one matrix at a time (i.e. size and elements) 01640 for (i=0; i<v.size(); i++) 01641 f.low_level_write(v(i)); 01642 01643 return f; 01644 } 01645 01646 it_file &operator<<(it_file &f, const Array<imat> &v) 01647 { 01648 int i, sum_l=0; 01649 01650 // calculate total length of Array 01651 for (i=0; i<v.size(); i++) { 01652 sum_l += v(i)._datasize(); 01653 } 01654 01655 // write header 01656 f.write_data_header("imatArray", sizeof(int)*(1+2*v.size()) + sum_l * sizeof(int)); 01657 01658 f.low_level_write(v.size()); // the length of the array 01659 01660 // write one matrix at a time (i.e. size and elements) 01661 for (i=0; i<v.size(); i++) 01662 f.low_level_write(v(i)); 01663 01664 return f; 01665 } 01666 01667 it_file &operator<<(it_file &f, const Array<bmat> &v) 01668 { 01669 int i, sum_l=0; 01670 01671 // calculate total length of Array 01672 for (i=0; i<v.size(); i++) { 01673 sum_l += v(i)._datasize(); 01674 } 01675 01676 // write header 01677 f.write_data_header("bmatArray", sizeof(int)*(1+2*v.size()) + sum_l * sizeof(bin)); 01678 01679 f.low_level_write(v.size()); // the length of the array 01680 01681 // write one matrix at a time (i.e. size and elements) 01682 for (i=0; i<v.size(); i++) 01683 f.low_level_write(v(i)); 01684 01685 return f; 01686 } 01687 01688 it_file &operator<<(it_file &f, const Array<cmat> &v) 01689 { 01690 int i, sum_l=0; 01691 01692 // calculate total length of Array 01693 for (i=0; i<v.size(); i++) { 01694 sum_l += v(i)._datasize(); 01695 } 01696 01697 // write header 01698 f.write_data_header("cmatArray", sizeof(int)*(1+2*v.size()) + sum_l * sizeof(std::complex<double>)); 01699 01700 f.low_level_write(v.size()); // the length of the array 01701 01702 // write one matrix at a time (i.e. size and elements) 01703 for (i=0; i<v.size(); i++) 01704 f.low_level_write(v(i)); 01705 01706 return f; 01707 } 01708 01709 } // namespace itpp
Generated on Fri Jun 8 01:07:08 2007 for IT++ by Doxygen 1.5.2