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

Generated on Fri Jul 25 12:42:58 2008 for IT++ by Doxygen 1.5.4