IT++ Logo

vec.cpp

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

Generated on Thu Apr 24 13:38:59 2008 for IT++ by Doxygen 1.5.5