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