00001 00030 #include <itpp/base/vec.h> 00031 #include <itpp/base/converters.h> 00032 #include <cstdio> 00033 #include <limits> 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 Mat<std::complex<double> > Vec<std::complex<double> >::hermitian_transpose() const 00785 { 00786 Mat<std::complex<double> > temp(1, datasize); 00787 for (int i = 0; i < datasize; i++) 00788 temp(i) = std::conj(data[i]); 00789 00790 return temp; 00791 } 00792 00793 00794 //--------------------------------------------------------------------- 00795 // Instantiations 00796 //--------------------------------------------------------------------- 00797 00798 template class Vec<double>; 00799 template class Vec<int>; 00800 template class Vec<short int>; 00801 template class Vec<std::complex<double> >; 00802 template class Vec<bin>; 00803 00804 // addition operator 00805 00806 template vec operator+(const vec &v1, const vec &v2); 00807 template cvec operator+(const cvec &v1, const cvec &v2); 00808 template ivec operator+(const ivec &v1, const ivec &v2); 00809 template svec operator+(const svec &v1, const svec &v2); 00810 template bvec operator+(const bvec &v1, const bvec &v2); 00811 00812 template vec operator+(const vec &v1, double t); 00813 template cvec operator+(const cvec &v1, std::complex<double> t); 00814 template ivec operator+(const ivec &v1, int t); 00815 template svec operator+(const svec &v1, short t); 00816 template bvec operator+(const bvec &v1, bin t); 00817 00818 template vec operator+(double t, const vec &v1); 00819 template cvec operator+(std::complex<double> t, const cvec &v1); 00820 template ivec operator+(int t, const ivec &v1); 00821 template svec operator+(short t, const svec &v1); 00822 template bvec operator+(bin t, const bvec &v1); 00823 00824 // subraction operator 00825 00826 template vec operator-(const vec &v1, const vec &v2); 00827 template cvec operator-(const cvec &v1, const cvec &v2); 00828 template ivec operator-(const ivec &v1, const ivec &v2); 00829 template svec operator-(const svec &v1, const svec &v2); 00830 template bvec operator-(const bvec &v1, const bvec &v2); 00831 00832 template vec operator-(const vec &v, double t); 00833 template cvec operator-(const cvec &v, std::complex<double> t); 00834 template ivec operator-(const ivec &v, int t); 00835 template svec operator-(const svec &v, short t); 00836 template bvec operator-(const bvec &v, bin t); 00837 00838 template vec operator-(double t, const vec &v); 00839 template cvec operator-(std::complex<double> t, const cvec &v); 00840 template ivec operator-(int t, const ivec &v); 00841 template svec operator-(short t, const svec &v); 00842 template bvec operator-(bin t, const bvec &v); 00843 00844 // unary minus 00845 00846 template vec operator-(const vec &v); 00847 template cvec operator-(const cvec &v); 00848 template ivec operator-(const ivec &v); 00849 template svec operator-(const svec &v); 00850 template bvec operator-(const bvec &v); 00851 00852 // multiplication operator 00853 00854 #if !defined(HAVE_BLAS) 00855 template double dot(const vec &v1, const vec &v2); 00856 #if !(defined(HAVE_ZDOTUSUB) || defined(HAVE_ZDOTU_VOID)) 00857 template std::complex<double> dot(const cvec &v1, const cvec &v2); 00858 #endif // !(HAVE_ZDOTUSUB || HAVE_ZDOTU_VOID) 00859 #endif // HAVE_BLAS 00860 template int dot(const ivec &v1, const ivec &v2); 00861 template short dot(const svec &v1, const svec &v2); 00862 template bin dot(const bvec &v1, const bvec &v2); 00863 00864 #if !defined(HAVE_BLAS) 00865 template double operator*(const vec &v1, const vec &v2); 00866 template std::complex<double> operator*(const cvec &v1, const cvec &v2); 00867 #endif 00868 template int operator*(const ivec &v1, const ivec &v2); 00869 template short operator*(const svec &v1, const svec &v2); 00870 template bin operator*(const bvec &v1, const bvec &v2); 00871 00872 #if !defined(HAVE_BLAS) 00873 template mat outer_product(const vec &v1, const vec &v2, bool hermitian); 00874 #endif 00875 template imat outer_product(const ivec &v1, const ivec &v2, bool hermitian); 00876 template smat outer_product(const svec &v1, const svec &v2, bool hermitian); 00877 template bmat outer_product(const bvec &v1, const bvec &v2, bool hermitian); 00878 00879 template vec operator*(const vec &v, double t); 00880 template cvec operator*(const cvec &v, std::complex<double> t); 00881 template ivec operator*(const ivec &v, int t); 00882 template svec operator*(const svec &v, short t); 00883 template bvec operator*(const bvec &v, bin t); 00884 00885 template vec operator*(double t, const vec &v); 00886 template cvec operator*(std::complex<double> t, const cvec &v); 00887 template ivec operator*(int t, const ivec &v); 00888 template svec operator*(short t, const svec &v); 00889 template bvec operator*(bin t, const bvec &v); 00890 00891 // elementwise multiplication 00892 00893 template vec elem_mult(const vec &a, const vec &b); 00894 template cvec elem_mult(const cvec &a, const cvec &b); 00895 template ivec elem_mult(const ivec &a, const ivec &b); 00896 template svec elem_mult(const svec &a, const svec &b); 00897 template bvec elem_mult(const bvec &a, const bvec &b); 00898 00899 template void elem_mult_out(const vec &a, const vec &b, vec &out); 00900 template void elem_mult_out(const cvec &a, const cvec &b, cvec &out); 00901 template void elem_mult_out(const ivec &a, const ivec &b, ivec &out); 00902 template void elem_mult_out(const svec &a, const svec &b, svec &out); 00903 template void elem_mult_out(const bvec &a, const bvec &b, bvec &out); 00904 00905 template vec elem_mult(const vec &a, const vec &b, const vec &c); 00906 template cvec elem_mult(const cvec &a, const cvec &b, const cvec &c); 00907 template ivec elem_mult(const ivec &a, const ivec &b, const ivec &c); 00908 template svec elem_mult(const svec &a, const svec &b, const svec &c); 00909 template bvec elem_mult(const bvec &a, const bvec &b, const bvec &c); 00910 00911 template void elem_mult_out(const vec &a, const vec &b, const vec &c, 00912 vec &out); 00913 template void elem_mult_out(const cvec &a, const cvec &b, const cvec &c, 00914 cvec &out); 00915 template void elem_mult_out(const ivec &a, const ivec &b, const ivec &c, 00916 ivec &out); 00917 template void elem_mult_out(const svec &a, const svec &b, const svec &c, 00918 svec &out); 00919 template void elem_mult_out(const bvec &a, const bvec &b, const bvec &c, 00920 bvec &out); 00921 00922 template vec elem_mult(const vec &a, const vec &b, const vec &c, 00923 const vec &d); 00924 template cvec elem_mult(const cvec &a, const cvec &b, const cvec &c, 00925 const cvec &d); 00926 template ivec elem_mult(const ivec &a, const ivec &b, const ivec &c, 00927 const ivec &d); 00928 template svec elem_mult(const svec &a, const svec &b, const svec &c, 00929 const svec &d); 00930 template bvec elem_mult(const bvec &a, const bvec &b, const bvec &c, 00931 const bvec &d); 00932 00933 template void elem_mult_out(const vec &a, const vec &b, const vec &c, 00934 const vec &d, vec &out); 00935 template void elem_mult_out(const cvec &a, const cvec &b, const cvec &c, 00936 const cvec &d, cvec &out); 00937 template void elem_mult_out(const ivec &a, const ivec &b, const ivec &c, 00938 const ivec &d, ivec &out); 00939 template void elem_mult_out(const svec &a, const svec &b, const svec &c, 00940 const svec &d, svec &out); 00941 template void elem_mult_out(const bvec &a, const bvec &b, const bvec &c, 00942 const bvec &d, bvec &out); 00943 00944 // in-place elementwise multiplication 00945 00946 template void elem_mult_inplace(const vec &a, vec &b); 00947 template void elem_mult_inplace(const cvec &a, cvec &b); 00948 template void elem_mult_inplace(const ivec &a, ivec &b); 00949 template void elem_mult_inplace(const svec &a, svec &b); 00950 template void elem_mult_inplace(const bvec &a, bvec &b); 00951 00952 // elementwise multiplication followed by summation 00953 00954 template double elem_mult_sum(const vec &a, const vec &b); 00955 template std::complex<double> elem_mult_sum(const cvec &a, const cvec &b); 00956 template int elem_mult_sum(const ivec &a, const ivec &b); 00957 template short elem_mult_sum(const svec &a, const svec &b); 00958 template bin elem_mult_sum(const bvec &a, const bvec &b); 00959 00960 // division operator 00961 00962 template vec operator/(const vec &v, double t); 00963 template cvec operator/(const cvec &v, std::complex<double> t); 00964 template ivec operator/(const ivec &v, int t); 00965 template svec operator/(const svec &v, short t); 00966 template bvec operator/(const bvec &v, bin t); 00967 00968 template vec operator/(double t, const vec &v); 00969 template cvec operator/(std::complex<double> t, const cvec &v); 00970 template ivec operator/(int t, const ivec &v); 00971 template svec operator/(short t, const svec &v); 00972 template bvec operator/(bin t, const bvec &v); 00973 00974 // elementwise division operator 00975 00976 template vec elem_div(const vec &a, const vec &b); 00977 template cvec elem_div(const cvec &a, const cvec &b); 00978 template ivec elem_div(const ivec &a, const ivec &b); 00979 template svec elem_div(const svec &a, const svec &b); 00980 template bvec elem_div(const bvec &a, const bvec &b); 00981 00982 template vec elem_div(double t, const vec &v); 00983 template cvec elem_div(std::complex<double> t, const cvec &v); 00984 template ivec elem_div(int t, const ivec &v); 00985 template svec elem_div(short t, const svec &v); 00986 template bvec elem_div(bin t, const bvec &v); 00987 00988 template void elem_div_out(const vec &a, const vec &b, vec &out); 00989 template void elem_div_out(const cvec &a, const cvec &b, cvec &out); 00990 template void elem_div_out(const ivec &a, const ivec &b, ivec &out); 00991 template void elem_div_out(const svec &a, const svec &b, svec &out); 00992 template void elem_div_out(const bvec &a, const bvec &b, bvec &out); 00993 00994 // elementwise division followed by summation 00995 00996 template double elem_div_sum(const vec &a, const vec &b); 00997 template std::complex<double> elem_div_sum(const cvec &a, const cvec &b); 00998 template int elem_div_sum(const ivec &a, const ivec &b); 00999 template short elem_div_sum(const svec &a, const svec &b); 01000 template bin elem_div_sum(const bvec &a, const bvec &b); 01001 01002 // concat operator 01003 01004 template vec concat(const vec &v, double a); 01005 template cvec concat(const cvec &v, std::complex<double> a); 01006 template ivec concat(const ivec &v, int a); 01007 template svec concat(const svec &v, short a); 01008 template bvec concat(const bvec &v, bin a); 01009 01010 template vec concat(double a, const vec &v); 01011 template cvec concat(std::complex<double> a, const cvec &v); 01012 template ivec concat(int a, const ivec &v); 01013 template svec concat(short a, const svec &v); 01014 template bvec concat(bin a, const bvec &v); 01015 01016 template vec concat(const vec &v1, const vec &v2); 01017 template cvec concat(const cvec &v1, const cvec &v2); 01018 template ivec concat(const ivec &v1, const ivec &v2); 01019 template svec concat(const svec &v1, const svec &v2); 01020 template bvec concat(const bvec &v1, const bvec &v2); 01021 01022 template vec concat(const vec &v1, const vec &v2, const vec &v3); 01023 template cvec concat(const cvec &v1, const cvec &v2, const cvec &v3); 01024 template ivec concat(const ivec &v1, const ivec &v2, const ivec &v3); 01025 template svec concat(const svec &v1, const svec &v2, const svec &v3); 01026 template bvec concat(const bvec &v1, const bvec &v2, const bvec &v3); 01027 01028 template vec concat(const vec &v1, const vec &v2, 01029 const vec &v3, const vec &v4); 01030 template cvec concat(const cvec &v1, const cvec &v2, 01031 const cvec &v3, const cvec &v4); 01032 template ivec concat(const ivec &v1, const ivec &v2, 01033 const ivec &v3, const ivec &v4); 01034 template svec concat(const svec &v1, const svec &v2, 01035 const svec &v3, const svec &v4); 01036 template bvec concat(const bvec &v1, const bvec &v2, 01037 const bvec &v3, const bvec &v4); 01038 01039 template vec concat(const vec &v1, const vec &v2, const vec &v3, 01040 const vec &v4, const vec &v5); 01041 template cvec concat(const cvec &v1, const cvec &v2, const cvec &v3, 01042 const cvec &v4, const cvec &v5); 01043 template ivec concat(const ivec &v1, const ivec &v2, const ivec &v3, 01044 const ivec &v4, const ivec &v5); 01045 template svec concat(const svec &v1, const svec &v2, const svec &v3, 01046 const svec &v4, const svec &v5); 01047 template bvec concat(const bvec &v1, const bvec &v2, const bvec &v3, 01048 const bvec &v4, const bvec &v5); 01049 01050 // I/O streams 01051 01052 template std::ostream &operator<<(std::ostream& os, const vec &vect); 01053 template std::ostream &operator<<(std::ostream& os, const cvec &vect); 01054 template std::ostream &operator<<(std::ostream& os, const svec &vect); 01055 template std::ostream &operator<<(std::ostream& os, const ivec &vect); 01056 template std::ostream &operator<<(std::ostream& os, const bvec &vect); 01057 template std::istream &operator>>(std::istream& is, vec &vect); 01058 template std::istream &operator>>(std::istream& is, cvec &vect); 01059 template std::istream &operator>>(std::istream& is, svec &vect); 01060 template std::istream &operator>>(std::istream& is, ivec &vect); 01061 template std::istream &operator>>(std::istream& is, bvec &vect); 01062 01063 } // namespace itpp 01064
Generated on Wed Jan 20 23:03:04 2010 for IT++ by Doxygen 1.6.2