00001 00030 #include <itpp/base/vec.h> 00031 #include <itpp/base/converters.h> 00032 #include <limits> 00033 #include <cstdio> 00034 00036 00037 namespace itpp 00038 { 00039 00040 00041 template<class Num_T> 00042 std::string Vec<Num_T>::replace_commas(const std::string &str_in) 00043 { 00044 // copy an input sting into a local variable str 00045 std::string str(str_in); 00046 // find first occurence of comma in string str 00047 std::string::size_type index = str.find(',', 0); 00048 while (index != std::string::npos) { 00049 // replace character at position index with space 00050 str.replace(index, 1, 1, ' '); 00051 // find next occurence of comma in string str 00052 index = str.find(',', index); 00053 } 00054 return str; 00055 } 00056 00057 00058 template<> 00059 void Vec<double>::set(const std::string &str) 00060 { 00061 std::istringstream buffer(replace_commas(str)); 00062 double b = 0.0; 00063 double c = 0.0; 00064 double eps_margin; 00065 bool b_parsed = false; 00066 bool c_parsed = false; 00067 bool negative = false; 00068 bool nan_inf = false; 00069 int pos = 0, maxpos = 10; 00070 00071 free(); 00072 alloc(maxpos); 00073 00074 while (buffer.peek() != EOF) { 00075 switch (buffer.peek()) { 00076 // skip spaces 00077 case ' ': 00078 case '\t': 00079 buffer.seekg(1, std::ios_base::cur); 00080 break; 00081 00082 // skip '+' sign 00083 case '+': 00084 // check for not handled '-' sign 00085 it_assert(!negative, "Vec<double>::set(): Improper data string (-)"); 00086 buffer.seekg(1, std::ios_base::cur); 00087 break; 00088 00089 // check for '-' sign 00090 case '-': 00091 buffer.seekg(1, std::ios_base::cur); 00092 negative = true; 00093 break; 00094 00095 // check for NaN 00096 case 'N': 00097 case 'n': 00098 buffer.seekg(1, std::ios_base::cur); 00099 it_assert((buffer.peek() == 'A') || (buffer.peek() == 'a'), 00100 "Vec<double>::set(): Improper data string (NaN)"); 00101 buffer.seekg(1, std::ios_base::cur); 00102 it_assert((buffer.peek() == 'N') || (buffer.peek() == 'n'), 00103 "Vec<double>::set(): Improper data string (NaN)"); 00104 buffer.seekg(1, std::ios_base::cur); 00105 it_assert(!negative, "Vec<double>::set(): Improper data string " 00106 "(-NaN not exist)"); 00107 if (++pos > maxpos) { 00108 maxpos <<= 1; 00109 set_size(maxpos, true); 00110 } 00111 if (std::numeric_limits<double>::has_quiet_NaN) { 00112 data[pos-1] = std::numeric_limits<double>::quiet_NaN(); 00113 } 00114 else if (std::numeric_limits<double>::has_signaling_NaN) { 00115 data[pos-1] = std::numeric_limits<double>::signaling_NaN(); 00116 } 00117 else { 00118 it_error("Vec<double::set(): NaN not supported"); 00119 } 00120 nan_inf = true; 00121 break; // case 'N'... 00122 00123 // check for Inf 00124 case 'I': 00125 case 'i': 00126 buffer.seekg(1, std::ios_base::cur); 00127 it_assert((buffer.peek() == 'N') || (buffer.peek() == 'n'), 00128 "Vec<double>::set(): Improper data string (Inf)"); 00129 buffer.seekg(1, std::ios_base::cur); 00130 it_assert((buffer.peek() == 'F') || (buffer.peek() == 'f'), 00131 "Vec<double>::set(): Improper data string (Inf)"); 00132 buffer.seekg(1, std::ios_base::cur); 00133 it_assert(std::numeric_limits<double>::has_infinity, 00134 "Vec<double::set(): Inf not supported"); 00135 if (++pos > maxpos) { 00136 maxpos <<= 1; 00137 set_size(maxpos, true); 00138 } 00139 if (negative) { 00140 data[pos-1] = -std::numeric_limits<double>::infinity(); 00141 negative = false; 00142 } 00143 else { 00144 data[pos-1] = std::numeric_limits<double>::infinity(); 00145 } 00146 nan_inf = true; 00147 break; // case 'I'... 00148 00149 case ':': // reads format a:b:c or a:b 00150 it_assert(!negative, "Vec<double>::set(): Improper data string (-)"); 00151 it_assert(!nan_inf, "Vec<double>::set(): Improper data string (Nan/Inf " 00152 " can not be used with a:b or a:b:c)"); 00153 it_assert(pos == 1, "Vec<double>::set(): Improper data string (a:b)"); 00154 buffer.seekg(1, std::ios_base::cur); 00155 // parse b 00156 while (buffer.peek() != EOF) { 00157 switch (buffer.peek()) { 00158 case ' ': 00159 case '\t': 00160 buffer.seekg(1, std::ios_base::cur); 00161 break; 00162 00163 case ':': 00164 it_assert(b_parsed, "Vec<double>::set(): Improper data string " 00165 "(a:b)"); 00166 buffer.seekg(1, std::ios_base::cur); 00167 // parse c 00168 while (buffer.peek() != EOF) { 00169 switch (buffer.peek()) { 00170 case ' ': 00171 case '\t': 00172 buffer.seekg(1, std::ios_base::cur); 00173 break; 00174 00175 default: 00176 it_assert(!c_parsed, "Vec<double>::set(): Improper data " 00177 "string (a:b:c)"); 00178 buffer.clear(); 00179 buffer >> c; 00180 it_assert(!buffer.fail(), "Vec<double>::set(): Stream " 00181 "operation failed (buffer >> c)"); 00182 c_parsed = true; 00183 } 00184 } 00185 it_assert(c_parsed, "Vec<double>::set(): Improper data string " 00186 "(a:b:c)"); 00187 break; 00188 00189 default: 00190 it_assert(!b_parsed, "Vec<double>::set(): Improper data string " 00191 "(a:b)"); 00192 buffer.clear(); 00193 buffer >> b; 00194 it_assert(!buffer.fail(), "Vec<double>::set(): Stream operation " 00195 "failed (buffer >> b)"); 00196 b_parsed = true; 00197 } 00198 } 00199 it_assert(b_parsed, "Vec<double>::set(): Improper data string (a:b)"); 00200 00201 if (c_parsed) { 00202 // Adding this margin fixes precision problems in e.g. "0:0.2:3", 00203 // where the last value was 2.8 instead of 3. 00204 eps_margin = std::fabs((c - data[pos-1]) / b) * eps; 00205 if (b > 0 && c >= data[pos-1]) { 00206 while (data[pos-1] + b <= c + eps_margin) { 00207 if (++pos > maxpos) { 00208 maxpos <<= 1; 00209 set_size(maxpos, true); 00210 } 00211 data[pos-1] = data[pos-2] + b; 00212 } 00213 } 00214 else if (b < 0 && c <= data[pos-1]) { 00215 while (data[pos-1] + b >= c - eps_margin) { 00216 if (++pos > maxpos) { 00217 maxpos <<= 1; 00218 set_size(maxpos, true); 00219 } 00220 data[pos-1] = data[pos-2] + b; 00221 } 00222 } 00223 else if (b == 0 && c == data[pos-1]) { 00224 break; 00225 } 00226 else { 00227 it_error("Vec<double>::set(): Improper data string (a:b:c)"); 00228 } 00229 } // if (c_parsed) 00230 else if (b_parsed) { 00231 eps_margin = std::fabs(b - data[pos-1]) * eps; 00232 if (b < data[pos-1]) { 00233 while (data[pos-1] - 1.0 >= b - eps_margin) { 00234 if (++pos > maxpos) { 00235 maxpos <<= 1; 00236 set_size(maxpos, true); 00237 } 00238 data[pos-1] = data[pos-2] - 1.0; 00239 } 00240 } 00241 else { 00242 while (data[pos-1] + 1.0 <= b + eps_margin) { 00243 if (++pos > maxpos) { 00244 maxpos <<= 1; 00245 set_size(maxpos, true); 00246 } 00247 data[pos-1] = data[pos-2] + 1.0; 00248 } 00249 } 00250 } // else if (b_parsed) 00251 else { 00252 it_error("Vec<double>::set(): Improper data string (a:b)"); 00253 } 00254 break; // case ':' 00255 00256 default: 00257 if (++pos > maxpos) { 00258 maxpos <<= 1; 00259 set_size(maxpos, true); 00260 } 00261 buffer >> data[pos-1]; 00262 it_assert(!buffer.fail(), "Vec<double>::set(): Stream operation " 00263 "failed (buffer >> data)"); 00264 if (negative) { 00265 data[pos-1] = -data[pos-1]; 00266 negative = false; 00267 } 00268 break; // default 00269 } 00270 } 00271 set_size(pos, true); 00272 } 00273 00274 00275 template<> 00276 void Vec<std::complex<double> >::set(const std::string &str) 00277 { 00278 std::istringstream buffer(str); 00279 int pos = 0, maxpos = 10; 00280 00281 free(); 00282 alloc(maxpos); 00283 00284 while (buffer.peek() != EOF) { 00285 switch (buffer.peek()) { 00286 case ':': 00287 it_error("Vec<complex>::set(): a:b:c and a:b expressions not valid " 00288 "for cvec"); 00289 break; 00290 case ' ': 00291 case '\t': 00292 case ',': 00293 buffer.seekg(1, std::ios_base::cur); 00294 break; 00295 default: 00296 if (++pos > maxpos) { 00297 maxpos <<= 1; 00298 set_size(maxpos, true); 00299 } 00300 buffer >> data[pos-1]; 00301 it_assert(!buffer.fail(), "Vec<complex>::set(): Stream operation " 00302 "failed (buffer >> data)"); 00303 } 00304 } 00305 set_size(pos, true); 00306 } 00307 00308 00309 template<> 00310 void Vec<bin>::set(const std::string &str) 00311 { 00312 std::istringstream buffer(replace_commas(str)); 00313 int pos = 0, maxpos = 10; 00314 00315 free(); 00316 alloc(maxpos); 00317 00318 while (buffer.peek() != EOF) { 00319 switch (buffer.peek()) { 00320 case ':': 00321 it_error("Vec<bin>::set(): a:b:c and a:b expressions not valid " 00322 "for bvec"); 00323 break; 00324 case ' ': 00325 case '\t': 00326 buffer.seekg(1, std::ios_base::cur); 00327 break; 00328 default: 00329 if (++pos > maxpos) { 00330 maxpos <<= 1; 00331 set_size(maxpos, true); 00332 } 00333 buffer >> data[pos-1]; 00334 it_assert(!buffer.fail(), "Vec<bin>::set(): Stream operation failed " 00335 "(buffer >> data)"); 00336 } 00337 } 00338 set_size(pos, true); 00339 } 00340 00341 00342 template<> 00343 void Vec<int>::set(const std::string &str) 00344 { 00345 std::istringstream buffer(replace_commas(str)); 00346 int b = 0; 00347 int c = 0; 00348 bool b_parsed = false; 00349 bool c_parsed = false; 00350 bool negative = false; 00351 int pos = 0; 00352 int maxpos = 10; 00353 00354 free(); 00355 alloc(maxpos); 00356 00357 while (buffer.peek() != EOF) { 00358 switch (buffer.peek()) { 00359 // skip spaces and tabs 00360 case ' ': 00361 case '\t': 00362 buffer.seekg(1, std::ios_base::cur); 00363 break; 00364 00365 // skip '+' sign 00366 case '+': 00367 // check for not handled '-' sign 00368 it_assert(!negative, "Vec<double>::set(): Improper data string (-)"); 00369 buffer.seekg(1, std::ios_base::cur); 00370 break; 00371 00372 // check for '-' sign 00373 case '-': 00374 buffer.seekg(1, std::ios_base::cur); 00375 negative = true; 00376 break; 00377 00378 // hexadecimal number or octal number or zero 00379 case '0': 00380 buffer.seekg(1, std::ios_base::cur); 00381 switch (buffer.peek()) { 00382 // hexadecimal number 00383 case 'x': 00384 case 'X': 00385 buffer.clear(); 00386 buffer.seekg(-1, std::ios_base::cur); 00387 if (++pos > maxpos) { 00388 maxpos <<= 1; 00389 set_size(maxpos, true); 00390 } 00391 buffer >> std::hex >> data[pos-1]; 00392 it_assert(!buffer.fail(), "Vec<int>::set(): Stream operation " 00393 "failed (buffer >> hex >> data)"); 00394 break; // case 'x'... 00395 00396 // octal number 00397 case '1': 00398 case '2': 00399 case '3': 00400 case '4': 00401 case '5': 00402 case '6': 00403 case '7': 00404 buffer.clear(); 00405 buffer.seekg(-1, std::ios_base::cur); 00406 if (++pos > maxpos) { 00407 maxpos <<= 1; 00408 set_size(maxpos, true); 00409 } 00410 buffer >> std::oct >> data[pos-1]; 00411 it_assert(!buffer.fail(), "Vec<int>::set(): Stream operation " 00412 "failed (buffer >> oct >> data)"); 00413 break; // case '1'... 00414 00415 // zero 00416 case EOF: 00417 case ' ': 00418 case '\t': 00419 case ':': 00420 case '0': 00421 buffer.clear(); 00422 buffer.seekg(-1, std::ios_base::cur); 00423 if (++pos > maxpos) { 00424 maxpos <<= 1; 00425 set_size(maxpos, true); 00426 } 00427 buffer >> std::dec >> data[pos-1]; 00428 it_assert(!buffer.fail(), "Vec<int>::set(): Stream operation " 00429 "failed (buffer >> dec >> data)"); 00430 break; // case EOF... 00431 00432 default: 00433 it_error("Vec<int>::set(): Improper data string"); 00434 } 00435 // check if just parsed data was negative 00436 if (negative) { 00437 data[pos-1] = -data[pos-1]; 00438 negative = false; 00439 } 00440 break; // case '0' 00441 00442 // decimal number 00443 case '1': 00444 case '2': 00445 case '3': 00446 case '4': 00447 case '5': 00448 case '6': 00449 case '7': 00450 case '8': 00451 case '9': 00452 buffer.clear(); 00453 if (++pos > maxpos) { 00454 maxpos <<= 1; 00455 set_size(maxpos, true); 00456 } 00457 buffer >> std::dec >> data[pos-1]; 00458 it_assert(!buffer.fail(), "Vec<int>::set(): Stream operation " 00459 "failed (buffer >> dec >> data)"); 00460 // check if just parsed data was negative 00461 if (negative) { 00462 data[pos-1] = -data[pos-1]; 00463 negative = false; 00464 } 00465 break; // case '1'... 00466 00467 // parse format a:b:c or a:b 00468 case ':': 00469 it_assert(pos == 1, "Vec<int>::set(): Improper data string (a:b)"); 00470 buffer.seekg(1, std::ios_base::cur); 00471 // parse b 00472 while (buffer.peek() != EOF) { 00473 switch (buffer.peek()) { 00474 case ' ': 00475 case '\t': 00476 buffer.seekg(1, std::ios_base::cur); 00477 break; 00478 00479 // skip '+' sign 00480 case '+': 00481 // check for not handled '-' sign 00482 it_assert(!negative, "Vec<double>::set(): Improper data string " 00483 "(-)"); 00484 buffer.seekg(1, std::ios_base::cur); 00485 break; 00486 00487 // check for '-' sign 00488 case '-': 00489 buffer.seekg(1, std::ios_base::cur); 00490 negative = true; 00491 break; 00492 00493 // hexadecimal number or octal number or zero 00494 case '0': 00495 it_assert(!b_parsed, "Vec<int>::set(): Improper data string " 00496 "(a:b)"); 00497 buffer.seekg(1, std::ios_base::cur); 00498 switch (buffer.peek()) { 00499 // hexadecimal number 00500 case 'x': 00501 case 'X': 00502 buffer.clear(); 00503 buffer.seekg(-1, std::ios_base::cur); 00504 buffer >> std::hex >> b; 00505 it_assert(!buffer.fail(), "Vec<int>::set(): Stream operation " 00506 "failed (buffer >> hex >> data)"); 00507 break; // case 'x'... 00508 00509 // octal number 00510 case '1': 00511 case '2': 00512 case '3': 00513 case '4': 00514 case '5': 00515 case '6': 00516 case '7': 00517 buffer.clear(); 00518 buffer.seekg(-1, std::ios_base::cur); 00519 buffer >> std::oct >> b; 00520 it_assert(!buffer.fail(), "Vec<int>::set(): Stream operation " 00521 "failed (buffer >> oct >> data)"); 00522 break; // case '1'... 00523 00524 // zero 00525 case EOF: 00526 case ' ': 00527 case '\t': 00528 case ':': 00529 case '0': 00530 buffer.clear(); 00531 buffer.seekg(-1, std::ios_base::cur); 00532 buffer >> std::dec >> b; 00533 it_assert(!buffer.fail(), "Vec<int>::set(): Stream operation " 00534 "failed (buffer >> dec >> data)"); 00535 break; // case EOF... 00536 00537 default: 00538 it_error("Vec<int>::set(): Improper data string (a:b)"); 00539 } // switch (buffer.peek()) 00540 // check if just parsed data was negative 00541 if (negative) { 00542 b = -b; 00543 negative = false; 00544 } 00545 b_parsed = true; 00546 break; // case '0' 00547 00548 // decimal number 00549 case '1': 00550 case '2': 00551 case '3': 00552 case '4': 00553 case '5': 00554 case '6': 00555 case '7': 00556 case '8': 00557 case '9': 00558 it_assert(!b_parsed, "Vec<int>::set(): Improper data string " 00559 "(a:b)"); 00560 buffer.clear(); 00561 buffer >> std::dec >> b; 00562 it_assert(!buffer.fail(), "Vec<int>::set(): Stream operation " 00563 "failed (buffer >> dec >> data)"); 00564 // check if just parsed data was negative 00565 if (negative) { 00566 b = -b; 00567 negative = false; 00568 } 00569 b_parsed = true; 00570 break; // case '1'... 00571 00572 case ':': 00573 it_assert(b_parsed, "Vec<int>::set(): Improper data string (a:b)"); 00574 buffer.seekg(1, std::ios_base::cur); 00575 // parse c 00576 while (buffer.peek() != EOF) { 00577 switch (buffer.peek()) { 00578 case ' ': 00579 case '\t': 00580 buffer.seekg(1, std::ios_base::cur); 00581 break; 00582 00583 // skip '+' sign 00584 case '+': 00585 // check for not handled '-' sign 00586 it_assert(!negative, "Vec<double>::set(): Improper data " 00587 "string (-)"); 00588 buffer.seekg(1, std::ios_base::cur); 00589 break; 00590 00591 // check for '-' sign 00592 case '-': 00593 buffer.seekg(1, std::ios_base::cur); 00594 negative = true; 00595 break; 00596 00597 // hexadecimal number or octal number or zero 00598 case '0': 00599 it_assert(!c_parsed, "Vec<int>::set(): Improper data string " 00600 "(a:b:c)"); 00601 buffer.seekg(1, std::ios_base::cur); 00602 switch (buffer.peek()) { 00603 // hexadecimal number 00604 case 'x': 00605 case 'X': 00606 buffer.clear(); 00607 buffer.seekg(-1, std::ios_base::cur); 00608 buffer >> std::hex >> c; 00609 it_assert(!buffer.fail(), "Vec<int>::set(): Stream " 00610 "operation failed (buffer >> hex >> data)"); 00611 break; // case 'x'... 00612 00613 // octal number 00614 case '1': 00615 case '2': 00616 case '3': 00617 case '4': 00618 case '5': 00619 case '6': 00620 case '7': 00621 buffer.clear(); 00622 buffer.seekg(-1, std::ios_base::cur); 00623 buffer >> std::oct >> c; 00624 it_assert(!buffer.fail(), "Vec<int>::set(): Stream " 00625 "operation failed (buffer >> oct >> data)"); 00626 break; // case '1'... 00627 00628 // zero 00629 case EOF: 00630 case ' ': 00631 case '\t': 00632 case '0': 00633 buffer.clear(); 00634 buffer.seekg(-1, std::ios_base::cur); 00635 buffer >> std::dec >> c; 00636 it_assert(!buffer.fail(), "Vec<int>::set(): Stream " 00637 "operation failed (buffer >> dec >> data)"); 00638 break; // case EOF... 00639 00640 default: 00641 it_error("Vec<int>::set(): Improper data string (a:b:c)"); 00642 } 00643 c_parsed = true; 00644 break; // case '0' 00645 00646 // decimal number 00647 case '1': 00648 case '2': 00649 case '3': 00650 case '4': 00651 case '5': 00652 case '6': 00653 case '7': 00654 case '8': 00655 case '9': 00656 it_assert(!c_parsed, "Vec<int>::set(): Improper data string " 00657 "(a:b:c)"); 00658 buffer.clear(); 00659 buffer >> std::dec >> c; 00660 it_assert(!buffer.fail(), "Vec<int>::set(): Stream operation " 00661 "failed (buffer >> dec >> data)"); 00662 c_parsed = true; 00663 break; 00664 00665 default: 00666 it_error("Vec<int>::set(): Improper data string (a:b:c)"); 00667 } // switch (buffer.peek()) 00668 } // while (buffer.peek() != EOF) 00669 // check if just parsed data was negative 00670 if (negative) { 00671 c = -c; 00672 negative = false; 00673 } 00674 it_assert(c_parsed, "Vec<int>::set(): Improper data string " 00675 "(a:b:c)"); 00676 break; // case ':' 00677 00678 default: 00679 it_error("Vec<int>::set(): Improper data string (a:b)"); 00680 } // switch (buffer.peek()) 00681 } // while (buffer.peek() != EOF) 00682 00683 if (c_parsed) { 00684 if (b > 0 && c >= data[pos-1]) { 00685 while (data[pos-1] + b <= c) { 00686 if (++pos > maxpos) { 00687 maxpos <<= 1; 00688 set_size(maxpos, true); 00689 } 00690 data[pos-1] = data[pos-2] + b; 00691 } 00692 } 00693 else if (b < 0 && c <= data[pos-1]) { 00694 while (data[pos-1] + b >= c) { 00695 if (++pos > maxpos) { 00696 maxpos <<= 1; 00697 set_size(maxpos, true); 00698 } 00699 data[pos-1] = data[pos-2] + b; 00700 } 00701 } 00702 else if (b == 0 && c == data[pos-1]) { 00703 break; 00704 } 00705 else { 00706 it_error("Vec<int>::set(): Improper data string (a:b:c)"); 00707 } 00708 } // if (c_parsed) 00709 else if (b_parsed) { 00710 if (b < data[pos-1]) { 00711 while (data[pos-1] > b) { 00712 if (++pos > maxpos) { 00713 maxpos <<= 1; 00714 set_size(maxpos, true); 00715 } 00716 data[pos-1] = data[pos-2] - 1; 00717 } 00718 } 00719 else { 00720 while (data[pos-1] < b) { 00721 if (++pos > maxpos) { 00722 maxpos <<= 1; 00723 set_size(maxpos, true); 00724 } 00725 data[pos-1] = data[pos-2] + 1; 00726 } 00727 } 00728 } // else if (b_parsed) 00729 else { 00730 it_error("Vec<int>::set(): Improper data string (a:b)"); 00731 } 00732 break; // case ':' 00733 00734 default: 00735 it_error("Vec<int>::set(): Improper data string"); 00736 } 00737 } 00738 // resize the parsed vector to its final length 00739 set_size(pos, true); 00740 } 00741 00742 template<> 00743 void Vec<short int>::set(const std::string &str) 00744 { 00745 // parser for "short int" is the same as for "int", so reuse it here 00746 ivec iv(str); 00747 this->operator=(to_svec(iv)); 00748 } 00749 00750 00751 template<> 00752 bvec Vec<std::complex<double> >::operator==(std::complex<double>) const 00753 { 00754 it_error("operator==: not implemented for complex"); 00755 bvec temp; 00756 return temp; 00757 } 00758 00759 template<> 00760 bvec Vec<std::complex<double> >::operator!=(std::complex<double>) const 00761 { 00762 it_error("operator!=: not implemented for complex"); 00763 bvec temp; 00764 return temp; 00765 } 00766 00767 template<> 00768 bvec Vec<std::complex<double> >::operator<=(std::complex<double>) const 00769 { 00770 it_error("operator<=: not implemented for complex"); 00771 bvec temp; 00772 return temp; 00773 } 00774 00775 template<> 00776 bvec Vec<std::complex<double> >::operator>(std::complex<double>) const 00777 { 00778 it_error("operator>: not implemented for complex"); 00779 bvec temp; 00780 return temp; 00781 } 00782 00783 template<> 00784 bvec Vec<std::complex<double> >::operator<(std::complex<double>) const 00785 { 00786 it_error("operator<: not implemented for complex"); 00787 bvec temp; 00788 return temp; 00789 } 00790 00791 template<> 00792 bvec Vec<std::complex<double> >::operator>=(std::complex<double>) const 00793 { 00794 it_error("operator>=: not implemented for complex"); 00795 bvec temp; 00796 return temp; 00797 } 00798 00799 template<> 00800 Mat<std::complex<double> > Vec<std::complex<double> >::hermitian_transpose() const 00801 { 00802 Mat<std::complex<double> > temp(1, datasize); 00803 for (int i = 0; i < datasize; i++) 00804 temp(i) = std::conj(data[i]); 00805 00806 return temp; 00807 } 00808 00809 00810 //--------------------------------------------------------------------- 00811 // Instantiations 00812 //--------------------------------------------------------------------- 00813 00814 template class Vec<double>; 00815 template class Vec<int>; 00816 template class Vec<short int>; 00817 template class Vec<std::complex<double> >; 00818 template class Vec<bin>; 00819 00820 // addition operator 00821 00822 template vec operator+(const vec &v1, const vec &v2); 00823 template cvec operator+(const cvec &v1, const cvec &v2); 00824 template ivec operator+(const ivec &v1, const ivec &v2); 00825 template svec operator+(const svec &v1, const svec &v2); 00826 template bvec operator+(const bvec &v1, const bvec &v2); 00827 00828 template vec operator+(const vec &v1, double t); 00829 template cvec operator+(const cvec &v1, std::complex<double> t); 00830 template ivec operator+(const ivec &v1, int t); 00831 template svec operator+(const svec &v1, short t); 00832 template bvec operator+(const bvec &v1, bin t); 00833 00834 template vec operator+(double t, const vec &v1); 00835 template cvec operator+(std::complex<double> t, const cvec &v1); 00836 template ivec operator+(int t, const ivec &v1); 00837 template svec operator+(short t, const svec &v1); 00838 template bvec operator+(bin t, const bvec &v1); 00839 00840 // subraction operator 00841 00842 template vec operator-(const vec &v1, const vec &v2); 00843 template cvec operator-(const cvec &v1, const cvec &v2); 00844 template ivec operator-(const ivec &v1, const ivec &v2); 00845 template svec operator-(const svec &v1, const svec &v2); 00846 template bvec operator-(const bvec &v1, const bvec &v2); 00847 00848 template vec operator-(const vec &v, double t); 00849 template cvec operator-(const cvec &v, std::complex<double> t); 00850 template ivec operator-(const ivec &v, int t); 00851 template svec operator-(const svec &v, short t); 00852 template bvec operator-(const bvec &v, bin t); 00853 00854 template vec operator-(double t, const vec &v); 00855 template cvec operator-(std::complex<double> t, const cvec &v); 00856 template ivec operator-(int t, const ivec &v); 00857 template svec operator-(short t, const svec &v); 00858 template bvec operator-(bin t, const bvec &v); 00859 00860 // unary minus 00861 00862 template vec operator-(const vec &v); 00863 template cvec operator-(const cvec &v); 00864 template ivec operator-(const ivec &v); 00865 template svec operator-(const svec &v); 00866 template bvec operator-(const bvec &v); 00867 00868 // multiplication operator 00869 00870 #if !defined(HAVE_BLAS) 00871 template double dot(const vec &v1, const vec &v2); 00872 #if !(defined(HAVE_ZDOTUSUB) || defined(HAVE_ZDOTU_VOID)) 00873 template std::complex<double> dot(const cvec &v1, const cvec &v2); 00874 #endif // !(HAVE_ZDOTUSUB || HAVE_ZDOTU_VOID) 00875 #endif // HAVE_BLAS 00876 template int dot(const ivec &v1, const ivec &v2); 00877 template short dot(const svec &v1, const svec &v2); 00878 template bin dot(const bvec &v1, const bvec &v2); 00879 00880 #if !defined(HAVE_BLAS) 00881 template double operator*(const vec &v1, const vec &v2); 00882 template std::complex<double> operator*(const cvec &v1, const cvec &v2); 00883 #endif 00884 template int operator*(const ivec &v1, const ivec &v2); 00885 template short operator*(const svec &v1, const svec &v2); 00886 template bin operator*(const bvec &v1, const bvec &v2); 00887 00888 #if !defined(HAVE_BLAS) 00889 template mat outer_product(const vec &v1, const vec &v2, bool hermitian); 00890 #endif 00891 template imat outer_product(const ivec &v1, const ivec &v2, bool hermitian); 00892 template smat outer_product(const svec &v1, const svec &v2, bool hermitian); 00893 template bmat outer_product(const bvec &v1, const bvec &v2, bool hermitian); 00894 00895 template vec operator*(const vec &v, double t); 00896 template cvec operator*(const cvec &v, std::complex<double> t); 00897 template ivec operator*(const ivec &v, int t); 00898 template svec operator*(const svec &v, short t); 00899 template bvec operator*(const bvec &v, bin t); 00900 00901 template vec operator*(double t, const vec &v); 00902 template cvec operator*(std::complex<double> t, const cvec &v); 00903 template ivec operator*(int t, const ivec &v); 00904 template svec operator*(short t, const svec &v); 00905 template bvec operator*(bin t, const bvec &v); 00906 00907 // elementwise multiplication 00908 00909 template vec elem_mult(const vec &a, const vec &b); 00910 template cvec elem_mult(const cvec &a, const cvec &b); 00911 template ivec elem_mult(const ivec &a, const ivec &b); 00912 template svec elem_mult(const svec &a, const svec &b); 00913 template bvec elem_mult(const bvec &a, const bvec &b); 00914 00915 template void elem_mult_out(const vec &a, const vec &b, vec &out); 00916 template void elem_mult_out(const cvec &a, const cvec &b, cvec &out); 00917 template void elem_mult_out(const ivec &a, const ivec &b, ivec &out); 00918 template void elem_mult_out(const svec &a, const svec &b, svec &out); 00919 template void elem_mult_out(const bvec &a, const bvec &b, bvec &out); 00920 00921 template vec elem_mult(const vec &a, const vec &b, const vec &c); 00922 template cvec elem_mult(const cvec &a, const cvec &b, const cvec &c); 00923 template ivec elem_mult(const ivec &a, const ivec &b, const ivec &c); 00924 template svec elem_mult(const svec &a, const svec &b, const svec &c); 00925 template bvec elem_mult(const bvec &a, const bvec &b, const bvec &c); 00926 00927 template void elem_mult_out(const vec &a, const vec &b, const vec &c, 00928 vec &out); 00929 template void elem_mult_out(const cvec &a, const cvec &b, const cvec &c, 00930 cvec &out); 00931 template void elem_mult_out(const ivec &a, const ivec &b, const ivec &c, 00932 ivec &out); 00933 template void elem_mult_out(const svec &a, const svec &b, const svec &c, 00934 svec &out); 00935 template void elem_mult_out(const bvec &a, const bvec &b, const bvec &c, 00936 bvec &out); 00937 00938 template vec elem_mult(const vec &a, const vec &b, const vec &c, 00939 const vec &d); 00940 template cvec elem_mult(const cvec &a, const cvec &b, const cvec &c, 00941 const cvec &d); 00942 template ivec elem_mult(const ivec &a, const ivec &b, const ivec &c, 00943 const ivec &d); 00944 template svec elem_mult(const svec &a, const svec &b, const svec &c, 00945 const svec &d); 00946 template bvec elem_mult(const bvec &a, const bvec &b, const bvec &c, 00947 const bvec &d); 00948 00949 template void elem_mult_out(const vec &a, const vec &b, const vec &c, 00950 const vec &d, vec &out); 00951 template void elem_mult_out(const cvec &a, const cvec &b, const cvec &c, 00952 const cvec &d, cvec &out); 00953 template void elem_mult_out(const ivec &a, const ivec &b, const ivec &c, 00954 const ivec &d, ivec &out); 00955 template void elem_mult_out(const svec &a, const svec &b, const svec &c, 00956 const svec &d, svec &out); 00957 template void elem_mult_out(const bvec &a, const bvec &b, const bvec &c, 00958 const bvec &d, bvec &out); 00959 00960 // in-place elementwise multiplication 00961 00962 template void elem_mult_inplace(const vec &a, vec &b); 00963 template void elem_mult_inplace(const cvec &a, cvec &b); 00964 template void elem_mult_inplace(const ivec &a, ivec &b); 00965 template void elem_mult_inplace(const svec &a, svec &b); 00966 template void elem_mult_inplace(const bvec &a, bvec &b); 00967 00968 // elementwise multiplication followed by summation 00969 00970 template double elem_mult_sum(const vec &a, const vec &b); 00971 template std::complex<double> elem_mult_sum(const cvec &a, const cvec &b); 00972 template int elem_mult_sum(const ivec &a, const ivec &b); 00973 template short elem_mult_sum(const svec &a, const svec &b); 00974 template bin elem_mult_sum(const bvec &a, const bvec &b); 00975 00976 // division operator 00977 00978 template vec operator/(const vec &v, double t); 00979 template cvec operator/(const cvec &v, std::complex<double> t); 00980 template ivec operator/(const ivec &v, int t); 00981 template svec operator/(const svec &v, short t); 00982 template bvec operator/(const bvec &v, bin t); 00983 00984 template vec operator/(double t, const vec &v); 00985 template cvec operator/(std::complex<double> t, const cvec &v); 00986 template ivec operator/(int t, const ivec &v); 00987 template svec operator/(short t, const svec &v); 00988 template bvec operator/(bin t, const bvec &v); 00989 00990 // elementwise division operator 00991 00992 template vec elem_div(const vec &a, const vec &b); 00993 template cvec elem_div(const cvec &a, const cvec &b); 00994 template ivec elem_div(const ivec &a, const ivec &b); 00995 template svec elem_div(const svec &a, const svec &b); 00996 template bvec elem_div(const bvec &a, const bvec &b); 00997 00998 template vec elem_div(double t, const vec &v); 00999 template cvec elem_div(std::complex<double> t, const cvec &v); 01000 template ivec elem_div(int t, const ivec &v); 01001 template svec elem_div(short t, const svec &v); 01002 template bvec elem_div(bin t, const bvec &v); 01003 01004 template void elem_div_out(const vec &a, const vec &b, vec &out); 01005 template void elem_div_out(const cvec &a, const cvec &b, cvec &out); 01006 template void elem_div_out(const ivec &a, const ivec &b, ivec &out); 01007 template void elem_div_out(const svec &a, const svec &b, svec &out); 01008 template void elem_div_out(const bvec &a, const bvec &b, bvec &out); 01009 01010 // elementwise division followed by summation 01011 01012 template double elem_div_sum(const vec &a, const vec &b); 01013 template std::complex<double> elem_div_sum(const cvec &a, const cvec &b); 01014 template int elem_div_sum(const ivec &a, const ivec &b); 01015 template short elem_div_sum(const svec &a, const svec &b); 01016 template bin elem_div_sum(const bvec &a, const bvec &b); 01017 01018 // concat operator 01019 01020 template vec concat(const vec &v, double a); 01021 template cvec concat(const cvec &v, std::complex<double> a); 01022 template ivec concat(const ivec &v, int a); 01023 template svec concat(const svec &v, short a); 01024 template bvec concat(const bvec &v, bin a); 01025 01026 template vec concat(double a, const vec &v); 01027 template cvec concat(std::complex<double> a, const cvec &v); 01028 template ivec concat(int a, const ivec &v); 01029 template svec concat(short a, const svec &v); 01030 template bvec concat(bin a, const bvec &v); 01031 01032 template vec concat(const vec &v1, const vec &v2); 01033 template cvec concat(const cvec &v1, const cvec &v2); 01034 template ivec concat(const ivec &v1, const ivec &v2); 01035 template svec concat(const svec &v1, const svec &v2); 01036 template bvec concat(const bvec &v1, const bvec &v2); 01037 01038 template vec concat(const vec &v1, const vec &v2, const vec &v3); 01039 template cvec concat(const cvec &v1, const cvec &v2, const cvec &v3); 01040 template ivec concat(const ivec &v1, const ivec &v2, const ivec &v3); 01041 template svec concat(const svec &v1, const svec &v2, const svec &v3); 01042 template bvec concat(const bvec &v1, const bvec &v2, const bvec &v3); 01043 01044 template vec concat(const vec &v1, const vec &v2, 01045 const vec &v3, const vec &v4); 01046 template cvec concat(const cvec &v1, const cvec &v2, 01047 const cvec &v3, const cvec &v4); 01048 template ivec concat(const ivec &v1, const ivec &v2, 01049 const ivec &v3, const ivec &v4); 01050 template svec concat(const svec &v1, const svec &v2, 01051 const svec &v3, const svec &v4); 01052 template bvec concat(const bvec &v1, const bvec &v2, 01053 const bvec &v3, const bvec &v4); 01054 01055 template vec concat(const vec &v1, const vec &v2, const vec &v3, 01056 const vec &v4, const vec &v5); 01057 template cvec concat(const cvec &v1, const cvec &v2, const cvec &v3, 01058 const cvec &v4, const cvec &v5); 01059 template ivec concat(const ivec &v1, const ivec &v2, const ivec &v3, 01060 const ivec &v4, const ivec &v5); 01061 template svec concat(const svec &v1, const svec &v2, const svec &v3, 01062 const svec &v4, const svec &v5); 01063 template bvec concat(const bvec &v1, const bvec &v2, const bvec &v3, 01064 const bvec &v4, const bvec &v5); 01065 01066 // I/O streams 01067 01068 template std::ostream &operator<<(std::ostream& os, const vec &vect); 01069 template std::ostream &operator<<(std::ostream& os, const cvec &vect); 01070 template std::ostream &operator<<(std::ostream& os, const svec &vect); 01071 template std::ostream &operator<<(std::ostream& os, const ivec &vect); 01072 template std::ostream &operator<<(std::ostream& os, const bvec &vect); 01073 template std::istream &operator>>(std::istream& is, vec &vect); 01074 template std::istream &operator>>(std::istream& is, cvec &vect); 01075 template std::istream &operator>>(std::istream& is, svec &vect); 01076 template std::istream &operator>>(std::istream& is, ivec &vect); 01077 template std::istream &operator>>(std::istream& is, bvec &vect); 01078 01079 } // namespace itpp 01080
Generated on Wed Feb 9 2011 13:47:23 for IT++ by Doxygen 1.7.3