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==(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!=(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<=(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>(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<(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>=(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 vec operator+(const vec &v1, const vec &v2);
00757   template cvec operator+(const cvec &v1, const cvec &v2);
00758   template ivec operator+(const ivec &v1, const ivec &v2);
00759   template svec operator+(const svec &v1, const svec &v2);
00760   template bvec operator+(const bvec &v1, const bvec &v2);
00761 
00762   template vec operator+(const vec &v1, double t);
00763   template cvec operator+(const cvec &v1, std::complex<double> t);
00764   template ivec operator+(const ivec &v1, int t);
00765   template svec operator+(const svec &v1, short t);
00766   template bvec operator+(const bvec &v1, bin t);
00767 
00768   template vec operator+(double t, const vec &v1);
00769   template cvec operator+(std::complex<double> t, const cvec &v1);
00770   template ivec operator+(int t, const ivec &v1);
00771   template svec operator+(short t, const svec &v1);
00772   template bvec operator+(bin t, const bvec &v1);
00773 
00774   // subraction operator
00775 
00776   template vec operator-(const vec &v1, const vec &v2);
00777   template cvec operator-(const cvec &v1, const cvec &v2);
00778   template ivec operator-(const ivec &v1, const ivec &v2);
00779   template svec operator-(const svec &v1, const svec &v2);
00780   template bvec operator-(const bvec &v1, const bvec &v2);
00781 
00782   template vec operator-(const vec &v, double t);
00783   template cvec operator-(const cvec &v, std::complex<double> t);
00784   template ivec operator-(const ivec &v, int t);
00785   template svec operator-(const svec &v, short t);
00786   template bvec operator-(const bvec &v, bin t);
00787 
00788   template vec operator-(double t, const vec &v);
00789   template cvec operator-(std::complex<double> t, const cvec &v);
00790   template ivec operator-(int t, const ivec &v);
00791   template svec operator-(short t, const svec &v);
00792   template bvec operator-(bin t, const bvec &v);
00793 
00794   // unary minus
00795 
00796   template vec operator-(const vec &v);
00797   template cvec operator-(const cvec &v);
00798   template ivec operator-(const ivec &v);
00799   template svec operator-(const svec &v);
00800   template 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 #if !(defined(HAVE_ZDOTUSUB) || defined(HAVE_ZDOTU_VOID))
00807   template std::complex<double> dot(const cvec &v1, const cvec &v2);
00808 #endif // !(HAVE_ZDOTUSUB || HAVE_ZDOTU_VOID)
00809 #endif // HAVE_BLAS
00810   template int dot(const ivec &v1, const ivec &v2);
00811   template short dot(const svec &v1, const svec &v2);
00812   template bin dot(const bvec &v1, const bvec &v2);
00813 
00814 #if !defined(HAVE_BLAS)
00815   template double operator*(const vec &v1, const vec &v2);
00816   template std::complex<double> operator*(const cvec &v1, const cvec &v2);
00817 #endif
00818   template int operator*(const ivec &v1, const ivec &v2);
00819   template short operator*(const svec &v1, const svec &v2);
00820   template bin operator*(const bvec &v1, const bvec &v2);
00821 
00822 #if !defined(HAVE_BLAS)
00823   template mat outer_product(const vec &v1, const vec &v2, bool hermitian);
00824 #endif
00825   template imat outer_product(const ivec &v1, const ivec &v2, bool hermitian);
00826   template smat outer_product(const svec &v1, const svec &v2, bool hermitian);
00827   template bmat outer_product(const bvec &v1, const bvec &v2, bool hermitian);
00828 
00829   template vec operator*(const vec &v, double t);
00830   template cvec operator*(const cvec &v, std::complex<double> t);
00831   template ivec operator*(const ivec &v, int t);
00832   template svec operator*(const svec &v, short t);
00833   template bvec operator*(const bvec &v, bin t);
00834 
00835   template vec operator*(double t, const vec &v);
00836   template cvec operator*(std::complex<double> t, const cvec &v);
00837   template ivec operator*(int t, const ivec &v);
00838   template svec operator*(short t, const svec &v);
00839   template bvec operator*(bin t, const bvec &v);
00840 
00841   // elementwise multiplication
00842 
00843   template vec elem_mult(const vec &a, const vec &b);
00844   template cvec elem_mult(const cvec &a, const cvec &b);
00845   template ivec elem_mult(const ivec &a, const ivec &b);
00846   template svec elem_mult(const svec &a, const svec &b);
00847   template bvec elem_mult(const bvec &a, const bvec &b);
00848 
00849   template void elem_mult_out(const vec &a, const vec &b, vec &out);
00850   template void elem_mult_out(const cvec &a, const cvec &b, cvec &out);
00851   template void elem_mult_out(const ivec &a, const ivec &b, ivec &out);
00852   template void elem_mult_out(const svec &a, const svec &b, svec &out);
00853   template void elem_mult_out(const bvec &a, const bvec &b, bvec &out);
00854 
00855   template vec elem_mult(const vec &a, const vec &b, const vec &c);
00856   template cvec elem_mult(const cvec &a, const cvec &b, const cvec &c);
00857   template ivec elem_mult(const ivec &a, const ivec &b, const ivec &c);
00858   template svec elem_mult(const svec &a, const svec &b, const svec &c);
00859   template bvec elem_mult(const bvec &a, const bvec &b, const bvec &c);
00860 
00861   template void elem_mult_out(const vec &a, const vec &b, const vec &c,
00862                               vec &out);
00863   template void elem_mult_out(const cvec &a, const cvec &b, const cvec &c,
00864                               cvec &out);
00865   template void elem_mult_out(const ivec &a, const ivec &b, const ivec &c,
00866                               ivec &out);
00867   template void elem_mult_out(const svec &a, const svec &b, const svec &c,
00868                               svec &out);
00869   template void elem_mult_out(const bvec &a, const bvec &b, const bvec &c,
00870                               bvec &out);
00871 
00872   template vec elem_mult(const vec &a, const vec &b, const vec &c,
00873                          const vec &d);
00874   template cvec elem_mult(const cvec &a, const cvec &b, const cvec &c,
00875                           const cvec &d);
00876   template ivec elem_mult(const ivec &a, const ivec &b, const ivec &c,
00877                           const ivec &d);
00878   template svec elem_mult(const svec &a, const svec &b, const svec &c,
00879                           const svec &d);
00880   template bvec elem_mult(const bvec &a, const bvec &b, const bvec &c,
00881                           const bvec &d);
00882 
00883   template void elem_mult_out(const vec &a, const vec &b, const vec &c,
00884                               const vec &d, vec &out);
00885   template void elem_mult_out(const cvec &a, const cvec &b, const cvec &c,
00886                               const cvec &d, cvec &out);
00887   template void elem_mult_out(const ivec &a, const ivec &b, const ivec &c,
00888                               const ivec &d, ivec &out);
00889   template void elem_mult_out(const svec &a, const svec &b, const svec &c,
00890                               const svec &d, svec &out);
00891   template void elem_mult_out(const bvec &a, const bvec &b, const bvec &c,
00892                               const bvec &d, bvec &out);
00893 
00894   // in-place elementwise multiplication
00895 
00896   template void elem_mult_inplace(const vec &a, vec &b);
00897   template void elem_mult_inplace(const cvec &a, cvec &b);
00898   template void elem_mult_inplace(const ivec &a, ivec &b);
00899   template void elem_mult_inplace(const svec &a, svec &b);
00900   template void elem_mult_inplace(const bvec &a, bvec &b);
00901 
00902   // elementwise multiplication followed by summation
00903 
00904   template double elem_mult_sum(const vec &a, const vec &b);
00905   template std::complex<double> elem_mult_sum(const cvec &a, const cvec &b);
00906   template int elem_mult_sum(const ivec &a, const ivec &b);
00907   template short elem_mult_sum(const svec &a, const svec &b);
00908   template bin elem_mult_sum(const bvec &a, const bvec &b);
00909 
00910   // division operator
00911 
00912   template vec operator/(const vec &v, double t);
00913   template cvec operator/(const cvec &v, std::complex<double> t);
00914   template ivec operator/(const ivec &v, int t);
00915   template svec operator/(const svec &v, short t);
00916   template bvec operator/(const bvec &v, bin t);
00917 
00918   template vec operator/(double t, const vec &v);
00919   template cvec operator/(std::complex<double> t, const cvec &v);
00920   template ivec operator/(int t, const ivec &v);
00921   template svec operator/(short t, const svec &v);
00922   template bvec operator/(bin t, const bvec &v);
00923 
00924   // elementwise division operator
00925 
00926   template vec elem_div(const vec &a, const vec &b);
00927   template cvec elem_div(const cvec &a, const cvec &b);
00928   template ivec elem_div(const ivec &a, const ivec &b);
00929   template svec elem_div(const svec &a, const svec &b);
00930   template bvec elem_div(const bvec &a, const bvec &b);
00931 
00932   template vec elem_div(double t, const vec &v);
00933   template cvec elem_div(std::complex<double> t, const cvec &v);
00934   template ivec elem_div(int t, const ivec &v);
00935   template svec elem_div(short t, const svec &v);
00936   template bvec elem_div(bin t, const bvec &v);
00937 
00938   template void elem_div_out(const vec &a, const vec &b, vec &out);
00939   template void elem_div_out(const cvec &a, const cvec &b, cvec &out);
00940   template void elem_div_out(const ivec &a, const ivec &b, ivec &out);
00941   template void elem_div_out(const svec &a, const svec &b, svec &out);
00942   template void elem_div_out(const bvec &a, const bvec &b, bvec &out);
00943 
00944   // elementwise division followed by summation
00945 
00946   template double elem_div_sum(const vec &a, const vec &b);
00947   template std::complex<double> elem_div_sum(const cvec &a, const cvec &b);
00948   template int elem_div_sum(const ivec &a, const ivec &b);
00949   template short elem_div_sum(const svec &a, const svec &b);
00950   template bin elem_div_sum(const bvec &a, const bvec &b);
00951 
00952   // concat operator
00953 
00954   template vec concat(const vec &v, double a);
00955   template cvec concat(const cvec &v, std::complex<double> a);
00956   template ivec concat(const ivec &v, int a);
00957   template svec concat(const svec &v, short a);
00958   template bvec concat(const bvec &v, bin a);
00959 
00960   template vec concat(double a, const vec &v);
00961   template cvec concat(std::complex<double> a, const cvec &v);
00962   template ivec concat(int a, const ivec &v);
00963   template svec concat(short a, const svec &v);
00964   template bvec concat(bin a, const bvec &v);
00965 
00966   template vec concat(const vec &v1, const vec &v2);
00967   template cvec concat(const cvec &v1, const cvec &v2);
00968   template ivec concat(const ivec &v1, const ivec &v2);
00969   template svec concat(const svec &v1, const svec &v2);
00970   template bvec concat(const bvec &v1, const bvec &v2);
00971 
00972   template vec concat(const vec &v1, const vec &v2, const vec &v3);
00973   template cvec concat(const cvec &v1, const cvec &v2, const cvec &v3);
00974   template ivec concat(const ivec &v1, const ivec &v2, const ivec &v3);
00975   template svec concat(const svec &v1, const svec &v2, const svec &v3);
00976   template bvec concat(const bvec &v1, const bvec &v2, const bvec &v3);
00977 
00978   template vec concat(const vec &v1, const vec &v2,
00979                       const vec &v3, const vec &v4);
00980   template cvec concat(const cvec &v1, const cvec &v2,
00981                        const cvec &v3, const cvec &v4);
00982   template ivec concat(const ivec &v1, const ivec &v2,
00983                        const ivec &v3, const ivec &v4);
00984   template svec concat(const svec &v1, const svec &v2,
00985                        const svec &v3, const svec &v4);
00986   template bvec concat(const bvec &v1, const bvec &v2,
00987                        const bvec &v3, const bvec &v4);
00988 
00989   template vec concat(const vec &v1, const vec &v2, const vec &v3,
00990                       const vec &v4, const vec &v5);
00991   template cvec concat(const cvec &v1, const cvec &v2, const cvec &v3,
00992                        const cvec &v4, const cvec &v5);
00993   template ivec concat(const ivec &v1, const ivec &v2, const ivec &v3,
00994                        const ivec &v4, const ivec &v5);
00995   template svec concat(const svec &v1, const svec &v2, const svec &v3,
00996                        const svec &v4, const svec &v5);
00997   template bvec concat(const bvec &v1, const bvec &v2, const bvec &v3,
00998                        const bvec &v4, const bvec &v5);
00999 
01000   // I/O streams
01001 
01002   template std::ostream &operator<<(std::ostream& os, const vec &vect);
01003   template std::ostream &operator<<(std::ostream& os, const cvec &vect);
01004   template std::ostream &operator<<(std::ostream& os, const svec &vect);
01005   template std::ostream &operator<<(std::ostream& os, const ivec &vect);
01006   template std::ostream &operator<<(std::ostream& os, const bvec &vect);
01007   template std::istream &operator>>(std::istream& is, vec &vect);
01008   template std::istream &operator>>(std::istream& is, cvec &vect);
01009   template std::istream &operator>>(std::istream& is, svec &vect);
01010   template std::istream &operator>>(std::istream& is, ivec &vect);
01011   template std::istream &operator>>(std::istream& is, bvec &vect);
01012 
01013 } // namespace itpp
01014 
SourceForge Logo

Generated on Sat Apr 19 10:41:55 2008 for IT++ by Doxygen 1.5.5