IT++ Logo

vec.cpp

Go to the documentation of this file.
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 
SourceForge Logo

Generated on Sun Sep 14 18:54:52 2008 for IT++ by Doxygen 1.5.6