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