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

Generated on Wed Jan 20 23:03:04 2010 for IT++ by Doxygen 1.6.2