IT++ Logo Newcom Logo

vec.h

Go to the documentation of this file.
00001 
00033 #ifndef VEC_H
00034 #define VEC_H
00035 
00036 #ifndef _MSC_VER
00037 #  include <itpp/config.h>
00038 #else
00039 #  include <itpp/config_msvc.h>
00040 #endif
00041 
00042 #include <itpp/itconfig.h>
00043 #include <itpp/base/itassert.h>
00044 #include <itpp/base/scalfunc.h>
00045 #include <itpp/base/factory.h>
00046 #include <itpp/base/copy_vector.h>
00047 
00048 
00049 namespace itpp {
00050 
00051   // Declaration of Vec
00052   template<class Num_T> class Vec;
00053   // Declaration of Mat
00054   template<class Num_T> class Mat;
00055   // Declaration of bin
00056   class bin;
00057 
00058   //-----------------------------------------------------------------------------------
00059   // Declaration of Vec Friends 
00060   //-----------------------------------------------------------------------------------
00061 
00063   template<class Num_T> const Vec<Num_T> operator+(const Vec<Num_T> &v1, const Vec<Num_T> &v2);
00065   template<class Num_T> const Vec<Num_T> operator+(const Vec<Num_T> &v, const Num_T t);
00067   template<class Num_T> const Vec<Num_T> operator+(const Num_T t, const Vec<Num_T> &v);
00068 
00070   template<class Num_T> const Vec<Num_T> operator-(const Vec<Num_T> &v1, const Vec<Num_T> &v2);
00072   template<class Num_T> const Vec<Num_T> operator-(const Vec<Num_T> &v, const Num_T t);
00074   template<class Num_T> const Vec<Num_T> operator-(const Num_T t, const Vec<Num_T> &v);
00076   template<class Num_T> const Vec<Num_T> operator-(const Vec<Num_T> &v);
00077 
00079   template<class Num_T> Num_T dot(const Vec<Num_T> &v1, const Vec<Num_T> &v2);
00081   template<class Num_T> Num_T operator*(const Vec<Num_T> &v1, const Vec<Num_T> &v2)
00082   { return dot(v1, v2); }
00084   template<class Num_T> const Mat<Num_T> outer_product(const Vec<Num_T> &v1, const Vec<Num_T> &v2);
00086   template<class Num_T> const Vec<Num_T> operator*(const Vec<Num_T> &v, const Num_T t);
00088   template<class Num_T> const Vec<Num_T> operator*(const Num_T t, const Vec<Num_T> &v);
00090   template<class Num_T> const Vec<Num_T> elem_mult(const Vec<Num_T> &v1, const Vec<Num_T> &v2);
00092   template<class Num_T> const Vec<Num_T> elem_mult(const Vec<Num_T> &v1, const Vec<Num_T> &v2, const Vec<Num_T> &v3);
00094   template<class Num_T> const Vec<Num_T> elem_mult(const Vec<Num_T> &v1, const Vec<Num_T> &v2, const Vec<Num_T> &v3, const Vec<Num_T> &v4);
00095 
00097   template<class Num_T> const Vec<Num_T> operator/(const Vec<Num_T> &v, const Num_T t);
00099   template<class Num_T> const Vec<Num_T> operator/(const Num_T t, const Vec<Num_T> &v);
00101   template<class Num_T> const Vec<Num_T> elem_div(const Vec<Num_T> &v1, const Vec<Num_T> &v2);
00103   template<class Num_T> const Vec<Num_T> elem_div(const Num_T t, const Vec<Num_T> &v);
00104 
00106   template<class Num_T> const Vec<Num_T> concat(const Vec<Num_T> &v, const Num_T a);
00108   template<class Num_T> const Vec<Num_T> concat(const Num_T a, const Vec<Num_T> &v);
00110   template<class Num_T> const Vec<Num_T> concat(const Vec<Num_T> &v1,const Vec<Num_T> &v2);
00112   template<class Num_T> const Vec<Num_T> concat(const Vec<Num_T> &v1, const Vec<Num_T> &v2, const Vec<Num_T> &v3);
00114   template<class Num_T> const Vec<Num_T> concat(const Vec<Num_T> &v1, const Vec<Num_T> &v2, const Vec<Num_T> &v3, const Vec<Num_T> &v4);
00116   template<class Num_T> const Vec<Num_T> concat(const Vec<Num_T> &v1, const Vec<Num_T> &v2, const Vec<Num_T> &v3, const Vec<Num_T> &v4, const Vec<Num_T> &v5);
00117 
00118   //-----------------------------------------------------------------------------------
00119   // Declaration of Vec
00120   //-----------------------------------------------------------------------------------
00121 
00184   template<class Num_T>
00185   class Vec {
00186   public:
00188     typedef Num_T value_type;
00190     explicit Vec(const Factory &f = DEFAULT_FACTORY) : factory(f) { init(); }
00192     explicit Vec(const int size, const Factory &f = DEFAULT_FACTORY) : factory(f) { it_assert1(size>=0, "Negative size in Vec::Vec(int)"); init(); alloc(size); }
00194     Vec(const Vec<Num_T> &v);
00196     Vec(const Vec<Num_T> &v, const Factory &f);
00198     Vec(const char *values, const Factory &f = DEFAULT_FACTORY) : factory(f) { init(); set(values); }
00200     Vec(const std::string &values, const Factory &f = DEFAULT_FACTORY) : factory(f) { init(); set(values); }
00202     Vec(Num_T *c_array, const int size, const Factory &f = DEFAULT_FACTORY) : factory(f) { init(); alloc(size); copy_vector(size, c_array, data); }
00203 
00205     ~Vec() { free(); }
00206 
00208     int length() const { return datasize; }
00210     int size() const { return datasize; }
00211 
00213     void set_length(const int size, const bool copy=false) { set_size(size,copy); }
00215     void set_size(const int size, const bool copy=false);
00217     void zeros() { for (int i=0; i<datasize; i++) {data[i]=Num_T(0);} }
00219     void clear() { zeros(); }
00221     void ones() { for (int i=0; i<datasize; i++) {data[i]=Num_T(1);} }
00223     bool set(const char *str);
00225     bool set(const std::string &str);
00226 
00228     const Num_T &operator[](const int i) const { it_assert0(i>=0&&i<datasize, "operator[]"); return data[i]; }
00230     const Num_T &operator()(const int i) const { it_assert0(i>=0&&i<datasize, "operator()"); return data[i]; }
00232     Num_T &operator[](const int i) { it_assert0(i>=0&&i<datasize, "operator[]"); return data[i]; }
00234     Num_T &operator()(const int i) { it_assert0(i>=0&&i<datasize, "operator()"); return data[i]; }
00236     const Vec<Num_T> operator()(const int i1, const int i2) const;
00238     const Vec<Num_T> operator()(const Vec<int> &indexlist) const;
00239 
00241     const Num_T &get(const int i) const { it_assert0(i>=0&&i<datasize, "method get()"); return data[i]; }
00243     const Vec<Num_T> get(const int i1, const int i2) const;
00245     void set(const int i, const Num_T &v) { it_assert0(i>=0&&i<datasize, "method set()"); data[i]=v; }
00246 
00248     Mat<Num_T> transpose() const;
00250     Mat<Num_T> T() const { return this->transpose(); }
00252     Mat<Num_T> hermitian_transpose() const;
00254     Mat<Num_T> H() const { return this->hermitian_transpose(); }
00255 
00257     Vec<Num_T>& operator+=(const Vec<Num_T> &v);
00259     Vec<Num_T>& operator+=(const Num_T t);
00261     friend const Vec<Num_T> operator+<>(const Vec<Num_T> &v1, const Vec<Num_T> &v2);
00263     friend const Vec<Num_T> operator+<>(const Vec<Num_T> &v, const Num_T t);
00265     friend const Vec<Num_T> operator+<>(const Num_T t, const Vec<Num_T> &v);
00266 
00268     Vec<Num_T>& operator-=(const Vec<Num_T> &v);
00270     Vec<Num_T>& operator-=(const Num_T t);
00272     friend const Vec<Num_T> operator-<>(const Vec<Num_T> &v1, const Vec<Num_T> &v2);
00274     friend const Vec<Num_T> operator-<>(const Vec<Num_T> &v, const Num_T t);
00276     friend const Vec<Num_T> operator-<>(const Num_T t, const Vec<Num_T> &v);
00278     friend const Vec<Num_T> operator-<>(const Vec<Num_T> &v);
00279 
00281     Vec<Num_T>& operator*=(const Num_T t);
00283     friend Num_T operator*<>(const Vec<Num_T> &v1, const Vec<Num_T> &v2);
00285     friend Num_T dot <>(const Vec<Num_T> &v1, const Vec<Num_T> &v2);
00287     friend const Mat<Num_T> outer_product <>(const Vec<Num_T> &v1, const Vec<Num_T> &v2);
00289     friend const Vec<Num_T> operator*<>(const Vec<Num_T> &v, const Num_T t);
00291     friend const Vec<Num_T> operator*<>(const Num_T t, const Vec<Num_T> &v);
00293     friend const Vec<Num_T> elem_mult <>(const Vec<Num_T> &v1, const Vec<Num_T> &v2);
00295     friend const Vec<Num_T> elem_mult <>(const Vec<Num_T> &v1, const Vec<Num_T> &v2, const Vec<Num_T> &v3);
00297     friend const Vec<Num_T> elem_mult <>(const Vec<Num_T> &v1, const Vec<Num_T> &v2, const Vec<Num_T> &v3, const Vec<Num_T> &v4);
00298 
00300     Vec<Num_T>& operator/=(const Num_T t);
00302     Vec<Num_T>& operator/=(const Vec<Num_T> &v);
00304     friend const Vec<Num_T> operator/<>(const Vec<Num_T> &v, const Num_T t);
00306     friend const Vec<Num_T> operator/<>(const Num_T t, const Vec<Num_T> &v);
00308     friend const Vec<Num_T> elem_div <>(const Vec<Num_T> &v1, const Vec<Num_T> &v2);
00310     friend const Vec<Num_T> elem_div <>(const Num_T t, const Vec<Num_T> &v);
00311 
00313     Vec<Num_T> get(const Vec<bin> &binlist) const;
00315     Vec<Num_T> right(const int nr) const;
00317     Vec<Num_T> left(const int nr) const;
00319     Vec<Num_T> mid(const int start, const int nr) const;
00321     Vec<Num_T> split(const int pos);
00323     void shift_right(const Num_T In, const int n=1);
00325     void shift_right(const Vec<Num_T> &In);
00327     void shift_left(const Num_T In, const int n=1);
00329     void shift_left(const Vec<Num_T> &In);
00330 
00332     friend const Vec<Num_T> concat<>(const Vec<Num_T> &v, const Num_T a);
00334     friend const Vec<Num_T> concat<>(const Num_T a, const Vec<Num_T> &v);
00336     friend const Vec<Num_T> concat<>(const Vec<Num_T> &v1,const Vec<Num_T> &v2);
00338     friend const Vec<Num_T> concat<>(const Vec<Num_T> &v1, const Vec<Num_T> &v2, const Vec<Num_T> &v3);
00339 
00341     void set_subvector(int i1, int i2, const Vec<Num_T> &v);
00343     void set_subvector(const int i, const Vec<Num_T> &v);
00345     void set_subvector(int i1, int i2, const Num_T t);
00347     void replace_mid(const int pos, const Vec<Num_T> &v);
00349     void del(const int index);
00351     void del(const int i1, const int i2);
00353     void ins(const int index, const Num_T in);
00355     void ins(const int index, const Vec<Num_T> &in);
00356 
00358     Vec<Num_T>& operator=(const Num_T t);
00360     Vec<Num_T>& operator=(const Vec<Num_T> &v);
00362     Vec<Num_T>& operator=(const Mat<Num_T> &m);
00364     Vec<Num_T>& operator=(const char *values);
00365 
00367     Vec<bin> operator==(const Num_T value) const;
00369     Vec<bin> operator!=(const Num_T value) const;
00371     Vec<bin> operator<(const Num_T value) const;
00373     Vec<bin> operator<=(const Num_T value) const;
00375     Vec<bin> operator>(const Num_T value) const;
00377     Vec<bin> operator>=(const Num_T value) const;
00378 
00380     bool operator==(const Vec<Num_T> &v) const;
00382     bool operator!=(const Vec<Num_T> &v) const;
00383 
00385     Num_T &_elem(const int i) { return data[i]; }
00387     const Num_T &_elem(const int i) const { return data[i]; }
00388 
00390     Num_T *_data() { return data; }
00391 
00393     const Num_T *_data() const { return data; }
00394 
00395   protected:
00397     void alloc(const int size)
00398     {
00399       if ( datasize == size ) return;
00400 
00401       free();  // Free memory (if any allocated)
00402       if (size == 0) return;
00403 
00404       create_elements(data, size, factory);
00405       datasize=size;
00406       it_assert1(data, "Vec<Num_T>::alloc(): Out of memory");
00407     }
00408 
00410     void free() { delete [] data;  init(); }
00411 
00413     int datasize;
00415     Num_T *data;
00417     const Factory &factory;
00418 
00419   private:
00420     void init() { data = 0; datasize = 0; }
00421   };
00422 
00423   //-----------------------------------------------------------------------------------
00424   // Type definitions of vec, cvec, ivec, svec, and bvec
00425   //-----------------------------------------------------------------------------------
00426 
00431   typedef Vec<double> vec;
00432 
00437   typedef Vec<std::complex<double> > cvec;
00438 
00443   typedef Vec<int> ivec;
00444 
00449   typedef Vec<short int> svec;
00450 
00455   typedef Vec<bin> bvec;
00456 
00457 } //namespace itpp
00458 
00459 #include <itpp/base/mat.h>
00460 
00461 namespace itpp {
00462 
00463   //-----------------------------------------------------------------------------------
00464   // Declaration of input and output streams for Vec
00465   //-----------------------------------------------------------------------------------
00466 
00471   template <class Num_T>
00472   std::ostream &operator<<(std::ostream &os, const Vec<Num_T> &v);
00473 
00485   template <class Num_T>
00486   std::istream &operator>>(std::istream &is, Vec<Num_T> &v);
00487 
00488   //-----------------------------------------------------------------------------------
00489   // Implementation of templated Vec members and friends
00490   //-----------------------------------------------------------------------------------
00491 
00492   template<class Num_T> inline
00493   Vec<Num_T>::Vec(const Vec<Num_T> &v) : factory(v.factory)
00494   {
00495     init();
00496     alloc(v.datasize);
00497     copy_vector(datasize, v.data, data);
00498   }
00499 
00500   template<class Num_T> inline
00501   Vec<Num_T>::Vec(const Vec<Num_T> &v, const Factory &f) : factory(f)
00502   {
00503     init();
00504     alloc(v.datasize);
00505     copy_vector(datasize, v.data, data);
00506   }
00507 
00508   template<class Num_T>
00509   void Vec<Num_T>::set_size(const int size, bool copy)
00510   {
00511     it_assert1(size >= 0, "Vec<Num_T>::set_size(): New size must not be negative");
00512     if (size!=datasize) {
00513       if (copy) {
00514         Vec<Num_T> temp(*this);
00515 
00516         alloc(size);
00517         for (int i=0; i<size; i++)
00518           data[i] = i < temp.datasize ? temp.data[i] : Num_T(0);
00519       } else
00520         alloc(size);
00521     }
00522   }
00523 
00524   template<> bool Vec<std::complex<double> >::set(const char *values);
00525   template<> bool Vec<bin>::set(const char *values);
00526 
00527   template<class Num_T>
00528   bool Vec<Num_T>::set(const char *values)
00529   {
00530     std::istringstream buffer(values);
00531     Num_T b, c;
00532     int pos=0, maxpos=10;
00533     
00534     alloc(maxpos);
00535     
00536     while (buffer.peek()!=EOF) {
00537 
00538       switch (buffer.peek()) {
00539       case ':': // reads format a:b:c or a:b
00540         buffer.get();
00541         if (!buffer.eof()) {
00542           buffer >> b;
00543         }
00544         if (!buffer.eof() && buffer.peek() == ':') {
00545           buffer.get();
00546           if (!buffer.eof()) {
00547             buffer >> c;
00548 
00549             while (sign(b)*(data[pos-1]+b-c)<=0) {
00550               pos++;
00551               if (pos > maxpos) {
00552                 maxpos=maxpos*2;
00553                 set_size(maxpos, true);
00554               }
00555               data[pos-1]=data[pos-2]+b;
00556             }
00557           }
00558         } else {
00559           while (data[pos-1]<b) {
00560             pos++;
00561             if (pos > maxpos) {
00562               maxpos=maxpos*2;
00563               set_size(maxpos, true);
00564             }
00565             data[pos-1]=data[pos-2]+1;
00566           }
00567         }
00568         break;
00569 
00570       case ',':
00571         buffer.get();
00572         break;
00573 
00574       default:
00575         pos++;
00576         if (pos > maxpos) {
00577           maxpos *= 2;
00578           set_size(maxpos, true);
00579         }
00580         buffer >> data[pos-1];
00581         while (buffer.peek()==' ') { buffer.get(); }
00582         break;
00583       }
00584 
00585     }
00586     set_size(pos, true);
00587 
00588     return true;
00589   }
00590 
00591   template<class Num_T>
00592   bool Vec<Num_T>::set(const std::string &str)
00593   {
00594     return set(str.c_str());
00595   }
00596 
00597   template<class Num_T> inline
00598   const Vec<Num_T> Vec<Num_T>::operator()(const int i1, const int i2) const
00599   {
00600     int ii1=i1, ii2=i2;
00601 
00602     if (ii1 == -1) ii1 = datasize-1;
00603     if (ii2 == -1) ii2 = datasize-1;
00604 
00605     it_assert1(ii1>=0 && ii2>=0 && ii1<datasize && ii2<datasize, "Vec<Num_T>::operator()(i1,i2): indicies out of range");
00606     it_assert1(ii2>=ii1, "Vec<Num_T>::op(i1,i2): i2 >= i1 necessary");
00607 
00608     Vec<Num_T> s(ii2-ii1+1);
00609     copy_vector(s.datasize, data+ii1, s.data);
00610 
00611     return s;
00612   }
00613 
00614   template<class Num_T> inline
00615   const Vec<Num_T> Vec<Num_T>::get(const int i1, const int i2) const
00616   {
00617     return (*this)(i1, i2);
00618   }
00619 
00620   template<class Num_T>
00621   const Vec<Num_T> Vec<Num_T>::operator()(const Vec<int> &indexlist) const
00622   {
00623     Vec<Num_T> temp(indexlist.length());
00624     for (int i=0;i<indexlist.length();i++) {
00625       it_assert((indexlist(i)>=0) && (indexlist(i) < datasize), "Vec<Num_T>::operator()(ivec &): index outside range");
00626       temp(i)=data[indexlist(i)];
00627     }
00628     return temp;
00629   }
00630 
00631   template<class Num_T>
00632   Mat<Num_T> Vec<Num_T>::transpose() const
00633   {
00634     Mat<Num_T> temp(1, datasize);
00635     for (int i=0; i<datasize; i++)
00636       temp(i) = data[i];
00637 
00638     return temp;
00639   }
00640 
00641   template<> 
00642   Mat<std::complex<double> > Vec<std::complex<double> >::hermitian_transpose() const;
00643 
00644   template<class Num_T>
00645   Mat<Num_T> Vec<Num_T>::hermitian_transpose() const
00646   {
00647     Mat<Num_T> temp(1, datasize);
00648     for (int i=0; i<datasize; i++)
00649       temp(i) = data[i];
00650 
00651     return temp;
00652   }
00653 
00654   template<class Num_T> inline
00655   Vec<Num_T>& Vec<Num_T>::operator+=(const Vec<Num_T> &v)
00656   {
00657     if (this != &v) {
00658       int i;
00659       if (datasize == 0) { // if not assigned a size.
00660         alloc(v.datasize);
00661         for (i=0; i<v.datasize; i++)
00662           data[i] = v.data[i];
00663       } else {
00664         it_assert1(datasize==v.datasize, "Vec<Num_T>::operator+=: wrong sizes");
00665         for (i=0; i<datasize; i++)
00666           data[i] += v.data[i];
00667       }
00668     }
00669     return *this;
00670   }
00671 
00672   template<class Num_T> inline
00673   Vec<Num_T>& Vec<Num_T>::operator+=(const Num_T t)
00674   { 
00675     for (int i=0;i<datasize;i++) 
00676       data[i]+=t; 
00677     return *this;
00678   }
00679 
00680   template<class Num_T> inline
00681   const Vec<Num_T> operator+(const Vec<Num_T> &v1, const Vec<Num_T> &v2)
00682   {
00683     int i;
00684     Vec<Num_T> r(v1.datasize);
00685 
00686     it_assert1(v1.datasize==v2.datasize, "Vec<Num_T>::operator+: wrong sizes");
00687     for (i=0; i<v1.datasize; i++)
00688       r.data[i] = v1.data[i] + v2.data[i];
00689 
00690     return r;
00691   }
00692 
00693   template<class Num_T> inline
00694   const Vec<Num_T> operator+(const Vec<Num_T> &v, const Num_T t)
00695   {
00696     int i;
00697     Vec<Num_T> r(v.datasize);
00698 
00699     for (i=0; i<v.datasize; i++)
00700       r.data[i] = v.data[i] + t;
00701 
00702     return r;
00703   }
00704 
00705   template<class Num_T> inline
00706   const Vec<Num_T> operator+(const Num_T t, const Vec<Num_T> &v)
00707   {
00708     int i;
00709     Vec<Num_T> r(v.datasize);
00710 
00711     for (i=0; i<v.datasize; i++)
00712       r.data[i] = t + v.data[i];
00713 
00714     return r;
00715   }
00716 
00717   template<class Num_T> inline
00718   Vec<Num_T>& Vec<Num_T>::operator-=(const Vec<Num_T> &v)
00719   {
00720     if (this != &v) {
00721       int i;
00722       if (datasize == 0) { // if not assigned a size.
00723         alloc(v.datasize);
00724         for (i=0; i<v.datasize; i++)
00725           data[i] = -v.data[i];
00726       } else {
00727         it_assert1(datasize==v.datasize, "Vec<Num_T>::operator-=: wrong sizes");
00728         for (i=0; i<datasize; i++)
00729           data[i] -= v.data[i];
00730       }
00731     }
00732     return *this;
00733   }
00734 
00735   template<class Num_T> inline
00736   Vec<Num_T>& Vec<Num_T>::operator-=(const Num_T t)
00737   { 
00738     for (int i=0;i<datasize;i++) 
00739       data[i]-=t;
00740     return *this;
00741   }
00742 
00743   template<class Num_T> inline
00744   const Vec<Num_T> operator-(const Vec<Num_T> &v1, const Vec<Num_T> &v2)
00745   {
00746     int i;
00747     Vec<Num_T> r(v1.datasize);
00748 
00749     it_assert1(v1.datasize==v2.datasize, "Vec<Num_T>::operator-: wrong sizes");
00750     for (i=0; i<v1.datasize; i++)
00751       r.data[i] = v1.data[i] - v2.data[i];
00752 
00753     return r;
00754   }
00755 
00756   template<class Num_T> inline
00757   const Vec<Num_T> operator-(const Vec<Num_T> &v, const Num_T t)
00758   {
00759     int i;
00760     Vec<Num_T> r(v.datasize);
00761 
00762     for (i=0; i<v.datasize; i++)
00763       r.data[i] = v.data[i] - t;
00764 
00765     return r;
00766   }
00767 
00768   template<class Num_T> inline
00769   const Vec<Num_T> operator-(const Num_T t, const Vec<Num_T> &v)
00770   {
00771     int i;
00772     Vec<Num_T> r(v.datasize);
00773 
00774     for (i=0; i<v.datasize; i++)
00775       r.data[i] = t - v.data[i];
00776 
00777     return r;
00778   }
00779 
00780   template<class Num_T> inline
00781   const Vec<Num_T> operator-(const Vec<Num_T> &v)
00782   {
00783     int i;
00784     Vec<Num_T> r(v.datasize);
00785 
00786     for (i=0; i<v.datasize; i++)
00787       r.data[i] = -v.data[i];
00788 
00789     return r;
00790   }
00791 
00792   template<class Num_T> inline
00793   Vec<Num_T>& Vec<Num_T>::operator*=(const Num_T t)
00794   { 
00795     for (int i=0;i<datasize;i++) 
00796       data[i] *= t; 
00797     return *this;
00798   }
00799 
00800 #if defined(HAVE_CBLAS)
00801   template<> double dot(const vec &v1, const vec &v2);
00802   template<> std::complex<double> dot(const cvec &v1, const cvec &v2);
00803 #endif
00804 
00805   template<class Num_T> inline
00806   Num_T dot(const Vec<Num_T> &v1, const Vec<Num_T> &v2)
00807   {
00808     int i;
00809     Num_T r=Num_T(0);
00810 
00811     it_assert1(v1.datasize==v2.datasize, "Vec<Num_T>::dot: wrong sizes");
00812     for (i=0; i<v1.datasize; i++)
00813       r += v1.data[i] * v2.data[i];
00814 
00815     return r;
00816   }
00817 
00818   template<class Num_T> inline
00819   const Mat<Num_T> outer_product(const Vec<Num_T> &v1, const Vec<Num_T> &v2)
00820   {
00821     int i, j;
00822 
00823     it_assert1(v1.datasize>0 && v2.datasize>0, "Vec<Num_T>::outer_product:: Vector of zero size");
00824 
00825     Mat<Num_T> r(v1.datasize, v2.datasize);
00826 
00827     for (i=0; i<v1.datasize; i++) {
00828       for (j=0; j<v2.datasize; j++) {
00829         r(i,j) = v1.data[i] * v2.data[j];
00830       }
00831     }
00832 
00833     return r;
00834   }
00835 
00836   template<class Num_T> inline
00837   const Vec<Num_T> operator*(const Vec<Num_T> &v, const Num_T t)
00838   {
00839     int i;
00840     Vec<Num_T> r(v.datasize);
00841 
00842     for (i=0; i<v.datasize; i++)
00843       r.data[i] = v.data[i] * t;
00844 
00845     return r;
00846   }
00847 
00848   template<class Num_T> inline
00849   const Vec<Num_T> operator*(const Num_T t, const Vec<Num_T> &v)
00850   {
00851     int i;
00852     Vec<Num_T> r(v.datasize);
00853 
00854     for (i=0; i<v.datasize; i++)
00855       r.data[i] = t * v.data[i];
00856 
00857     return r;
00858   }
00859 
00860   template<class Num_T> inline
00861   const Vec<Num_T> elem_mult(const Vec<Num_T> &v1, const Vec<Num_T> &v2)
00862   {
00863     int i;
00864     Vec<Num_T> r(v1.datasize);
00865 
00866     it_assert1(v1.datasize==v2.datasize, "Vec<Num_T>::elem_mult: wrong sizes");
00867     for (i=0; i<v1.datasize; i++)
00868       r.data[i] = v1.data[i] * v2.data[i];
00869 
00870     return r;
00871   }
00872 
00873   template<class Num_T> inline
00874   const Vec<Num_T> elem_mult(const Vec<Num_T> &v1, const Vec<Num_T> &v2, const Vec<Num_T> &v3)
00875   {
00876     int i;
00877     Vec<Num_T> r(v1.datasize);
00878 
00879     it_assert1(v1.datasize==v2.datasize, "Vec<Num_T>::elem_mult: wrong sizes");
00880     it_assert1(v2.datasize==v3.datasize, "Vec<Num_T>::elem_mult: wrong sizes");
00881     for (i=0; i<v1.datasize; i++)
00882       r.data[i] = v1.data[i] * v2.data[i] * v3.data[i];
00883 
00884     return r;
00885   }
00886 
00887   template<class Num_T> inline
00888   const Vec<Num_T> elem_mult(const Vec<Num_T> &v1, const Vec<Num_T> &v2, const Vec<Num_T> &v3, const Vec<Num_T> &v4)
00889   {
00890     int i;
00891     Vec<Num_T> r(v1.datasize);
00892 
00893     it_assert1(v1.datasize==v2.datasize, "Vec<Num_T>::elem_mult: wrong sizes");
00894     it_assert1(v2.datasize==v3.datasize, "Vec<Num_T>::elem_mult: wrong sizes");
00895     it_assert1(v3.datasize==v4.datasize, "Vec<Num_T>::elem_mult: wrong sizes");
00896     for (i=0; i<v1.datasize; i++)
00897       r.data[i] = v1.data[i] * v2.data[i] * v3.data[i] * v4.data[i];
00898 
00899     return r;
00900   }
00901 
00902   template<class Num_T> inline
00903   const Vec<Num_T> operator/(const Vec<Num_T> &v, const Num_T t)
00904   {
00905     int i;
00906     Vec<Num_T> r(v.datasize);
00907 
00908     for (i=0; i<v.datasize; i++)
00909       r.data[i] = v.data[i] / t;
00910 
00911     return r;
00912   }
00913 
00914   template<class Num_T> inline
00915   const Vec<Num_T> operator/(const Num_T t, const Vec<Num_T> &v)
00916   {
00917     int i;
00918     Vec<Num_T> r(v.datasize);
00919 
00920     for (i=0; i<v.datasize; i++)
00921       r.data[i] = t / v.data[i];
00922 
00923     return r;
00924   }
00925 
00926   template<class Num_T> inline
00927   Vec<Num_T>& Vec<Num_T>::operator/=(const Num_T t)
00928   { 
00929     for (int i=0;i<datasize;i++) 
00930       data[i]/=t; 
00931     return *this;
00932   }
00933 
00934   template<class Num_T> inline
00935   Vec<Num_T>& Vec<Num_T>::operator/=(const Vec<Num_T> &v)
00936   {
00937     if (this != &v) {
00938       int i;
00939       it_assert1(datasize==v.datasize, "Vec<Num_T>::operator/=: wrong sizes");
00940       for (i=0; i<datasize; i++)
00941         data[i] /= v.data[i];
00942     }
00943     return *this;
00944   }
00945 
00946   template<class Num_T> inline
00947   const Vec<Num_T> elem_div(const Vec<Num_T> &v1, const Vec<Num_T> &v2)
00948   {
00949     int i;
00950     Vec<Num_T> r(v1.datasize);
00951 
00952     it_assert1(v1.datasize==v2.datasize, "Vec<Num_T>elem_div: wrong sizes");
00953     for (i=0; i<v1.datasize; i++)
00954       r.data[i] = v1.data[i] / v2.data[i];
00955 
00956     return r;
00957   }
00958 
00959   template<class Num_T> inline
00960   const Vec<Num_T> elem_div(const Num_T t, const Vec<Num_T> &v)
00961   {
00962     int i;
00963     Vec<Num_T> r(v.datasize);
00964 
00965     for (i=0; i<v.datasize; i++)
00966       r.data[i] = t / v.data[i];
00967 
00968     return r;
00969   }
00970 
00971   template<class Num_T>
00972   Vec<Num_T> Vec<Num_T>::get(const Vec<bin> &binlist) const
00973   {
00974     it_assert1(datasize == binlist.size(), "Vec<Num_T>::get(bvec &): wrong sizes");
00975     Vec<Num_T> temp(binlist.length());
00976     int j=0;
00977 
00978     for (int i=0;i<binlist.length();i++) {
00979       if (binlist(i) == bin(1)) {
00980         temp(j)=data[i];
00981         j++;
00982       }
00983     }
00984     temp.set_size(j, true);
00985     return temp;
00986   }
00987 
00988   template<class Num_T> inline
00989   Vec<Num_T> Vec<Num_T>::right(const int nr) const
00990   {
00991     it_assert1(nr<=datasize, "Vec<Num_T>::right: index out of range");
00992     Vec<Num_T> temp(nr);
00993     if (nr!=0) {
00994       copy_vector(nr, &data[datasize-nr], &temp[0]);
00995     }
00996     return temp;
00997   }
00998 
00999   template<class Num_T> inline
01000   Vec<Num_T> Vec<Num_T>::left(const int nr) const
01001   {
01002     it_assert1(nr<=datasize, "Vec<Num_T>::left: index out of range");
01003     Vec<Num_T> temp(nr);
01004     if (nr!=0) {
01005       copy_vector(nr, &data[0], &temp[0]);
01006     }
01007     return temp;
01008   }
01009 
01010   template<class Num_T> inline
01011   Vec<Num_T> Vec<Num_T>::mid(const int start, const int nr) const
01012   {
01013     it_assert1((start>=0)&& ((start+nr)<=datasize), "Vec<Num_T>::mid: indexing out of range");
01014     Vec<Num_T> temp(nr);
01015 
01016     if (nr!=0) {
01017       copy_vector(nr, &data[start], &temp[0]);
01018     }
01019     return temp;
01020   }
01021 
01022   template<class Num_T>
01023   Vec<Num_T> Vec<Num_T>::split(const int Position)
01024   {
01025     it_assert1((Position>=0) && (Position<=datasize), "Vec<Num_T>::split: index out of range");
01026     Vec<Num_T> Temp1(Position);
01027     Vec<Num_T> Temp2(datasize-Position);
01028     int  i;
01029 
01030     for (i=0;i<Position;i++) {
01031       Temp1[i]=data[i];
01032     }
01033     for (i=Position;i<datasize;i++) {
01034       Temp2[i-Position]=data[i];
01035     }
01036     (*this)=Temp2;
01037     return Temp1;
01038   }
01039 
01040   template<class Num_T>
01041   void Vec<Num_T>::shift_right(const Num_T In, const int n)
01042   {
01043     int i=datasize;
01044 
01045     it_assert1(n>=0, "Vec<Num_T>::shift_right: index out of range");
01046     while (--i >= n)
01047       data[i] = data[i-n];
01048     while (i >= 0)
01049       data[i--] = In;
01050   }
01051 
01052   template<class Num_T>
01053   void Vec<Num_T>::shift_right(const Vec<Num_T> &In)
01054   {
01055     int i;
01056 
01057     for (i=datasize-1; i>=In.datasize; i--)
01058       data[i]=data[i-In.datasize];
01059     for (i=0; i<In.datasize; i++)
01060       data[i]=In[i];
01061   }
01062 
01063   template<class Num_T>
01064   void Vec<Num_T>::shift_left(const Num_T In, const int n)
01065   {
01066     int i;
01067 
01068     it_assert1(n>=0, "Vec<Num_T>::shift_left: index out of range");
01069     for (i=0; i<datasize-n; i++)
01070       data[i] = data[i+n];
01071     while (i < datasize)
01072       data[i++] = In;
01073   }
01074 
01075   template<class Num_T>
01076   void Vec<Num_T>::shift_left(const Vec<Num_T> &In)
01077   {
01078     int i;
01079 
01080     for (i=0; i<datasize-In.datasize; i++)
01081       data[i]=data[i+In.datasize];
01082     for (i=datasize-In.datasize; i<datasize; i++)
01083       data[i]=In[i-datasize+In.datasize];
01084   }
01085 
01086   template<class Num_T>
01087   const Vec<Num_T> concat(const Vec<Num_T> &v, const Num_T a)
01088   {
01089     Vec<Num_T> temp(v.size()+1);
01090 
01091     for (int i=0; i<v.size(); i++)
01092       temp(i) = v(i);
01093     temp(v.size()) = a;
01094 
01095     return temp;
01096   }
01097 
01098   template<class Num_T>
01099   const Vec<Num_T> concat(const Num_T a, const Vec<Num_T> &v)
01100   {
01101     Vec<Num_T> temp(v.size()+1);
01102 
01103     temp(0) = a;
01104 
01105     for (int i=0; i<v.size(); i++)
01106       temp(i+1) = v(i);
01107 
01108     return temp;
01109   }
01110 
01111   template<class Num_T>
01112   const Vec<Num_T> concat(const Vec<Num_T> &v1, const Vec<Num_T> &v2)
01113   {
01114     int i;
01115     Vec<Num_T> temp(v1.size()+v2.size());
01116 
01117     for (i=0;i<v1.size();i++) {
01118       temp[i] = v1[i];
01119     }
01120     for (i=0;i<v2.size();i++) {
01121       temp[v1.size()+i] = v2[i];
01122     }
01123     return temp;
01124   }
01125 
01126   template<class Num_T>
01127   const Vec<Num_T> concat(const Vec<Num_T> &v1, const Vec<Num_T> &v2, const Vec<Num_T> &v3)
01128   {
01129     // There should be some error control?
01130     int i;
01131     Vec<Num_T> temp(v1.size()+v2.size()+v3.size());
01132 
01133     for (i=0;i<v1.size();i++) {
01134       temp[i] = v1[i];
01135     }
01136     for (i=0;i<v2.size();i++) {
01137       temp[v1.size()+i] = v2[i];
01138     }
01139     for (i=0;i<v3.size();i++) {
01140       temp[v1.size()+v2.size()+i] = v3[i];
01141     }
01142     return temp;
01143   }
01144 
01145   template<class Num_T>
01146   const Vec<Num_T> concat(const Vec<Num_T> &v1, const Vec<Num_T> &v2, const Vec<Num_T> &v3, const Vec<Num_T> &v4)
01147   {
01148     // There should be some error control?
01149     int i;
01150     Vec<Num_T> temp(v1.size()+v2.size()+v3.size()+v4.size());
01151 
01152     for (i=0;i<v1.size();i++) {
01153       temp[i] = v1[i];
01154     }
01155     for (i=0;i<v2.size();i++) {
01156       temp[v1.size()+i] = v2[i];
01157     }
01158     for (i=0;i<v3.size();i++) {
01159       temp[v1.size()+v2.size()+i] = v3[i];
01160     }
01161     for (i=0;i<v4.size();i++) {
01162       temp[v1.size()+v2.size()+v3.size()+i] = v4[i];
01163     }
01164     return temp;
01165   }
01166 
01167   template<class Num_T>
01168   const Vec<Num_T> concat(const Vec<Num_T> &v1, const Vec<Num_T> &v2, const Vec<Num_T> &v3, const Vec<Num_T> &v4, const Vec<Num_T> &v5)
01169   {
01170     // There should be some error control?
01171     int i;
01172     Vec<Num_T> temp(v1.size()+v2.size()+v3.size()+v4.size()+v5.size());
01173 
01174     for (i=0;i<v1.size();i++) {
01175       temp[i] = v1[i];
01176     }
01177     for (i=0;i<v2.size();i++) {
01178       temp[v1.size()+i] = v2[i];
01179     }
01180     for (i=0;i<v3.size();i++) {
01181       temp[v1.size()+v2.size()+i] = v3[i];
01182     }
01183     for (i=0;i<v4.size();i++) {
01184       temp[v1.size()+v2.size()+v3.size()+i] = v4[i];
01185     }
01186     for (i=0;i<v5.size();i++) {
01187       temp[v1.size()+v2.size()+v3.size()+v4.size()+i] = v5[i];
01188     }
01189     return temp;
01190   }
01191 
01192   template<class Num_T> inline
01193   void Vec<Num_T>::set_subvector(int i1, int i2, const Vec<Num_T> &v)
01194   {
01195     if (i1 == -1) i1 = datasize-1;
01196     if (i2 == -1) i2 = datasize-1;
01197 
01198     it_assert1(i1>=0 && i2>=0 && i1<datasize && i2<datasize, "Vec<Num_T>::set_subvector(): indicies out of range");
01199     it_assert1(i2>=i1, "Vec<Num_T>::set_subvector(): i2 >= i1 necessary");
01200     it_assert1(i2-i1+1 == v.datasize, "Vec<Num_T>::set_subvector(): wrong sizes");
01201 
01202     copy_vector(v.datasize, v.data, data+i1);
01203   }
01204 
01205   template<class Num_T> inline
01206   void Vec<Num_T>:: set_subvector(const int i, const Vec<Num_T> &v)
01207   {
01208     it_assert1(i>=0, "Vec<Num_T>::set_subvector(): index out of range");
01209     it_assert1(i+v.datasize <= datasize, "Vec<Num_T>::set_subvector(): too long input vector");
01210     copy_vector(v.datasize, v.data, data+i);
01211   }
01212 
01213   template<class Num_T>
01214   void Vec<Num_T>::set_subvector(int i1, int i2, const Num_T t)
01215   {
01216     if (i1 == -1) i1 = datasize-1;
01217     if (i2 == -1) i2 = datasize-1;
01218 
01219     it_assert1(i1>=0 && i2>=0 && i1<datasize && i2<datasize, "Vec<Num_T>::set_subvector(): indicies out of range");
01220     it_assert1(i2>=i1, "Vec<Num_T>::set_subvector(): i2 >= i1 necessary");
01221 
01222     for (int i=i1;i<=i2;i++)
01223       data[i] = t;
01224   }
01225 
01226   template<class Num_T>
01227   void Vec<Num_T>::replace_mid(const int pos, const Vec<Num_T> &v)
01228   {
01229     it_assert1((pos>=0) && ((pos+v.length())<=datasize), "Vec<Num_T>::replace_mid: indexing out of range");
01230     copy_vector(v.datasize, v.data, &data[pos]);
01231   }
01232 
01233   template<class Num_T>
01234   void Vec<Num_T>::del(const int index)
01235   {
01236     it_assert1((index>=0) && (index<datasize), "Vec<Num_T>::del: index out of range");
01237     Vec<Num_T> Temp(*this);
01238     int i;
01239 
01240     set_size(datasize-1, false);
01241     for (i=0;i<index;i++) {
01242       data[i]=Temp[i];
01243     }
01244     for (i=index;i<datasize;i++) {
01245       data[i]=Temp[i+1];
01246     }
01247   }
01248 
01249   template<class Num_T>
01250   void  Vec<Num_T>::del(const int i1, const int i2) 
01251   {
01252     it_assert1((i1>=0) && (i2<datasize) && (i1<i2), "Vec<Num_T>::del: index out of range");
01253 
01254     Vec<Num_T> Temp(*this);
01255     int new_size = datasize-(i2-i1+1);
01256     set_size(new_size, false);
01257     copy_vector(i1, Temp.data, data);
01258     copy_vector(datasize-i1, &Temp.data[i2+1], &data[i1]);
01259   }
01260 
01261   template<class Num_T>
01262   void Vec<Num_T>::ins(const int index, const Num_T in)
01263   {
01264     it_assert1((index>=0) && (index<=datasize), "Vec<Num_T>::ins: index out of range");
01265     Vec<Num_T> Temp(*this);
01266 
01267     set_size(datasize+1, false);
01268     copy_vector(index, Temp.data, data);
01269     data[index]=in;
01270     copy_vector(Temp.datasize-index, Temp.data+index, data+index+1);
01271   }
01272 
01273   template<class Num_T>
01274   void Vec<Num_T>::ins(const int index, const Vec<Num_T> &in)
01275   {
01276     it_assert1((index>=0) && (index<=datasize), "Vec<Num_T>::ins: index out of range");
01277     Vec<Num_T> Temp(*this);
01278 
01279     set_size(datasize+in.length(), false);
01280     copy_vector(index, Temp.data, data);
01281     copy_vector(in.size(), in.data, &data[index]);
01282     copy_vector(Temp.datasize-index, Temp.data+index, data+index+in.size());
01283   }
01284 
01285   template<class Num_T> inline
01286   Vec<Num_T>& Vec<Num_T>::operator=(const Num_T t)
01287   { 
01288     for (int i=0;i<datasize;i++) 
01289       data[i] = t; 
01290     return *this;
01291   }
01292 
01293   template<class Num_T> inline
01294   Vec<Num_T>& Vec<Num_T>::operator=(const Vec<Num_T> &v)
01295   {
01296     if (this != &v) {
01297       set_size(v.datasize, false);
01298       copy_vector(datasize, v.data, data);
01299     }
01300     return *this;
01301   }
01302 
01303   template<class Num_T> inline
01304   Vec<Num_T>& Vec<Num_T>::operator=(const Mat<Num_T> &m)
01305   {
01306     it_assert1( (m.cols() == 1 && datasize == m.rows()) ||
01307                 (m.rows() == 1 && datasize == m.cols()), "Vec<Num_T>::operator=(Mat<Num_T>): wrong size");
01308 
01309     if (m.cols() == 1) {
01310       set_size(m.rows(), false);
01311       copy_vector(m.rows(), m._data(), data);
01312     } else if (m.rows() == 1) {
01313       set_size(m.cols(), false);
01314       copy_vector(m.cols(), m._data(), m.rows(), data, 1);
01315     } else
01316       it_error("Vec<Num_T>::operator=(Mat<Num_T>): wrong size");
01317     return *this;
01318   }
01319 
01320   template<class Num_T> inline
01321   Vec<Num_T>& Vec<Num_T>::operator=(const char *values) 
01322   { 
01323     set(values);
01324     return *this;
01325   }
01326 
01327   template<> 
01328   bvec Vec<std::complex<double> >::operator==(const std::complex<double>) const;
01329 
01330   template<class Num_T>
01331   bvec Vec<Num_T>::operator==(const Num_T value) const
01332   {
01333     it_assert(datasize > 0, "Vec<Num_T>::operator==: vector must have size > 0");
01334     Vec<Num_T> invector(*this);
01335     bvec temp(invector.length());
01336 
01337     for (int i=0;i<invector.length();i++)
01338       temp(i)=(invector(i)==value);
01339 
01340     return temp;
01341   }
01342 
01343   template<> 
01344   bvec Vec<std::complex<double> >::operator!=(const std::complex<double>) const;
01345 
01346   template<class Num_T>
01347   bvec Vec<Num_T>::operator!=(const Num_T value) const
01348   {
01349     it_assert(datasize > 0, "Vec<Num_T>::operator!=: vector must have size > 0");
01350     Vec<Num_T> invector(*this);
01351     bvec temp(invector.length());
01352 
01353     for (int i=0;i<invector.length();i++)
01354       temp(i)=(invector(i)!=value);
01355 
01356     return temp;
01357   }
01358 
01359   template<> 
01360   bvec Vec<std::complex<double> >::operator<(const std::complex<double>) const;
01361 
01362   template<class Num_T>
01363   bvec Vec<Num_T>::operator<(const Num_T value) const
01364   {
01365     it_assert(datasize > 0, "Vec<Num_T>::operator<: vector must have size > 0");
01366     Vec<Num_T> invector(*this);
01367     bvec temp(invector.length());
01368 
01369     for (int i=0;i<invector.length();i++)
01370       temp(i)=(invector(i)<value);
01371 
01372     return temp;
01373   }
01374 
01375   template<> 
01376   bvec Vec<std::complex<double> >::operator<=(const std::complex<double>) const;
01377 
01378   template<class Num_T>
01379   bvec Vec<Num_T>::operator<=(const Num_T value) const
01380   {
01381     it_assert(datasize > 0, "Vec<Num_T>::operator<=: vector must have size > 0");
01382     Vec<Num_T> invector(*this);
01383     bvec temp(invector.length());
01384 
01385     for (int i=0;i<invector.length();i++)
01386       temp(i)=(invector(i)<=value);
01387 
01388     return temp;
01389   }
01390 
01391   template<>
01392   bvec Vec<std::complex<double> >::operator>(const std::complex<double>) const;
01393 
01394   template<class Num_T>
01395   bvec Vec<Num_T>::operator>(const Num_T value) const
01396   {
01397     it_assert(datasize > 0, "Vec<Num_T>::operator>: vector must have size > 0");
01398     Vec<Num_T> invector(*this);
01399     bvec temp(invector.length());
01400 
01401     for (int i=0;i<invector.length();i++)
01402       temp(i)=(invector(i)>value);
01403 
01404     return temp;
01405   }
01406 
01407   template<>
01408   bvec Vec<std::complex<double> >::operator>=(const std::complex<double>) const;
01409 
01410   template<class Num_T>
01411   bvec Vec<Num_T>::operator>=(const Num_T value) const
01412   {
01413     it_assert(datasize > 0, "Vec<Num_T>::operator>=: vector must have size > 0");
01414     Vec<Num_T> invector(*this);
01415     bvec temp(invector.length());
01416 
01417     for (int i=0;i<invector.length();i++)
01418       temp(i)=(invector(i)>=value);
01419 
01420     return temp;
01421   }
01422 
01423   template<class Num_T>
01424   bool Vec<Num_T>::operator==(const Vec<Num_T> &invector) const
01425   {
01426     // OBS ! if wrong size, return false
01427     if (datasize!=invector.datasize) return false;
01428     for (int i=0;i<datasize;i++) {
01429       if (data[i]!=invector.data[i]) return false;
01430     }
01431     return true;
01432   }
01433 
01434   template<class Num_T>
01435   bool Vec<Num_T>::operator!=(const Vec<Num_T> &invector) const
01436   {
01437     if (datasize!=invector.datasize) return true;
01438     for (int i=0;i<datasize;i++) {
01439       if (data[i]!=invector.data[i]) return true;
01440     }
01441     return false;
01442   }
01443 
01444   template <class Num_T>
01445   std::ostream &operator<<(std::ostream &os, const Vec<Num_T> &v)
01446   {
01447     int i, sz=v.length();
01448 
01449     os << "[" ;
01450     for (i=0; i<sz; i++) {
01451       os << v(i) ;
01452       if (i < sz-1)
01453         os << " ";
01454     }
01455     os << "]" ;
01456 
01457     return os;
01458   }
01459 
01460   template <class Num_T>
01461   std::istream &operator>>(std::istream &is, Vec<Num_T> &v)
01462   {
01463     std::ostringstream buffer;
01464     bool started = false;
01465     bool finished = false;
01466     bool brackets = false;
01467     char c;
01468 
01469     while (!finished) {
01470       if (is.eof()) {
01471         finished = true;
01472       } else {
01473         c = is.get();
01474 
01475         if (is.eof() || (c == '\n')) {
01476           if (brackets) {
01477             // Right bracket missing
01478             is.setstate(std::ios_base::failbit);
01479             finished = true;
01480           } else if (!((c == '\n') && !started)) {
01481             finished = true;
01482           }
01483         } else if ((c == ' ') || (c == '\t')) {
01484           if (started) {
01485             buffer << ' ';
01486           }
01487         } else if (c == '[') {
01488           if (started) {
01489             // Unexpected left bracket
01490             is.setstate(std::ios_base::failbit);
01491             finished = true;
01492           } else {
01493             started = true;
01494             brackets = true;
01495           }
01496         } else if (c == ']') {
01497           if (!started || !brackets) {
01498             // Unexpected right bracket
01499             is.setstate(std::ios_base::failbit);
01500             finished = true;
01501           } else {
01502             finished = true;
01503           }
01504           while (!is.eof() && (((c = is.peek()) == ' ') || (c == '\t'))) {
01505             is.get();
01506           }
01507           if (!is.eof() && (c == '\n')) {
01508             is.get();
01509           }
01510         } else {
01511           started = true;
01512           buffer << c;
01513         }
01514       }
01515     }
01516 
01517     if (!started) {
01518       v.set_size(0, false);
01519     } else {
01520       v.set(buffer.str());
01521     }
01522 
01523     return is;
01524   }
01525 
01526 #ifndef _MSC_VER
01527 
01528   //---------------------------------------------------------------------
01529   // Instantiations
01530   //---------------------------------------------------------------------
01531 
01532   //--------- class instantiations -------------
01533 
01535   extern template class Vec<double>;
01537   extern template class Vec<int>;
01539   extern template class Vec<short int>;
01541   extern template class Vec<std::complex<double> >;
01543   extern template class Vec<bin>;
01544 
01545   //------------- Addition operator ----------
01546 
01548   extern template const vec operator+(const vec &v1, const vec &v2);
01550   extern template const cvec operator+(const cvec &v1, const cvec &v2);
01552   extern template const ivec operator+(const ivec &v1, const ivec &v2);
01554   extern template const svec operator+(const svec &v1, const svec &v2);
01556   extern template const bvec operator+(const bvec &v1, const bvec &v2);
01557 
01559   extern template const vec operator+(const vec &v1, const double t);
01561   extern template const cvec operator+(const cvec &v1, std::complex<double> t);
01563   extern template const ivec operator+(const ivec &v1, const int t);
01565   extern template const svec operator+(const svec &v1, const short t);
01567   extern template const bvec operator+(const bvec &v1, const bin t);
01568 
01570   extern template const vec operator+(const double t, const vec &v1);
01572   extern template const cvec operator+(std::complex<double> t, const cvec &v1);
01574   extern template const ivec operator+(const int t, const ivec &v1);
01576   extern template const svec operator+(const short t, const svec &v1);
01578   extern template const bvec operator+(const bin t, const bvec &v1);
01579 
01580   //------------- Subraction operator ----------
01581 
01583   extern template const vec operator-(const vec &v1, const vec &v2);
01585   extern template const cvec operator-(const cvec &v1, const cvec &v2);
01587   extern template const ivec operator-(const ivec &v1, const ivec &v2);
01589   extern template const svec operator-(const svec &v1, const svec &v2);
01591   extern template const bvec operator-(const bvec &v1, const bvec &v2);
01592 
01594   extern template const vec operator-(const vec &v, const double t);
01596   extern template const cvec operator-(const cvec &v, std::complex<double> t);
01598   extern template const ivec operator-(const ivec &v, const int t);
01600   extern template const svec operator-(const svec &v, const short t);
01602   extern template const bvec operator-(const bvec &v, const bin t);
01603 
01605   extern template const vec operator-(const double t, const vec &v);
01607   extern template const cvec operator-(std::complex<double> t, const cvec &v);
01609   extern template const ivec operator-(const int t, const ivec &v);
01611   extern template const svec operator-(const short t, const svec &v);
01613   extern template const bvec operator-(const bin t, const bvec &v);
01614 
01615   //---------- Unary minus -------------
01616 
01618   extern template const vec operator-(const vec &v);
01620   extern template const cvec operator-(const cvec &v);
01622   extern template const ivec operator-(const ivec &v);
01624   extern template const svec operator-(const svec &v);
01626   extern template const bvec operator-(const bvec &v);
01627 
01628   //------------- Multiplication operator ----------
01629 
01630 #if !defined(HAVE_CBLAS)
01632   extern template double dot(const vec &v1, const vec &v2);
01634   extern template std::complex<double> dot(const cvec &v1, const cvec &v2);
01635 #endif
01637   extern template int dot(const ivec &v1, const ivec &v2);
01639   extern template short dot(const svec &v1, const svec &v2);
01641   extern template bin dot(const bvec &v1, const bvec &v2);
01642 
01644   extern template int operator*(const ivec &v1, const ivec &v2);
01646   extern template short operator*(const svec &v1, const svec &v2);
01648   extern template bin operator*(const bvec &v1, const bvec &v2);
01649 
01651   extern template const mat outer_product(const vec &v1, const vec &v2);
01653   extern template const cmat outer_product(const cvec &v1, const cvec &v2);
01655   extern template const imat outer_product(const ivec &v1, const ivec &v2);
01657   extern template const smat outer_product(const svec &v1, const svec &v2);
01659   extern template const bmat outer_product(const bvec &v1, const bvec &v2);
01660 
01662   extern template const vec operator*(const vec &v, const double t);
01664   extern template const cvec operator*(const cvec &v, std::complex<double> t);
01666   extern template const ivec operator*(const ivec &v, const int t);
01668   extern template const svec operator*(const svec &v, const short t);
01670   extern template const bvec operator*(const bvec &v, const bin t);
01671 
01673   extern template const vec operator*(const double t, const vec &v);
01675   extern template const cvec operator*(std::complex<double> t, const cvec &v);
01677   extern template const ivec operator*(const int t, const ivec &v);
01679   extern template const svec operator*(const short t, const svec &v);
01681   extern template const bvec operator*(const bin t, const bvec &v);
01682 
01683   //------------- Elementwise Multiplication operator (two vectors) ----------
01684 
01686   extern template const vec elem_mult(const vec &v1, const vec &v2);
01688   extern template const cvec elem_mult(const cvec &v1, const cvec &v2);
01690   extern template const ivec elem_mult(const ivec &v1, const ivec &v2);
01692   extern template const svec elem_mult(const svec &v1, const svec &v2);
01694   extern template const bvec elem_mult(const bvec &v1, const bvec &v2);
01695 
01696   //------------- Elementwise Multiplication operator (three vectors) ----------
01697 
01699   extern template const vec elem_mult(const vec &v1, const vec &v2, const vec &v3);
01701   extern template const cvec elem_mult(const cvec &v1, const cvec &v2, const cvec &v3);
01703   extern template const ivec elem_mult(const ivec &v1, const ivec &v2, const ivec &v3);
01705   extern template const svec elem_mult(const svec &v1, const svec &v2, const svec &v3);
01707   extern template const bvec elem_mult(const bvec &v1, const bvec &v2, const bvec &v3);
01708 
01709   //------------- Elementwise Multiplication operator (four vectors) ----------
01710 
01712   extern template const vec elem_mult(const vec &v1, const vec &v2, const vec &v3, const vec &v4);
01714   extern template const cvec elem_mult(const cvec &v1, const cvec &v2, const cvec &v3, const cvec &v4);
01716   extern template const ivec elem_mult(const ivec &v1, const ivec &v2, const ivec &v3, const ivec &v4);
01718   extern template const svec elem_mult(const svec &v1, const svec &v2, const svec &v3, const svec &v4);
01720   extern template const bvec elem_mult(const bvec &v1, const bvec &v2, const bvec &v3, const bvec &v4);
01721 
01722   //------------- Division operator ----------
01723 
01725   extern template const vec operator/(const vec &v, const double t);
01727   extern template const cvec operator/(const cvec &v, std::complex<double> t);
01729   extern template const ivec operator/(const ivec &v, const int t);
01731   extern template const svec operator/(const svec &v, const short t);
01733   extern template const bvec operator/(const bvec &v, const bin t);
01734 
01736   extern template const vec operator/(const double t, const vec &v);
01738   extern template const cvec operator/(const std::complex<double> t, const cvec &v);
01740   extern template const ivec operator/(const int t, const ivec &v);
01742   extern template const svec operator/(const short t, const svec &v);
01744   extern template const bvec operator/(const bin t, const bvec &v);
01745 
01746   //------------- Elementwise Division operator ----------
01747 
01749   extern template const vec elem_div(const vec &v1, const vec &v2);
01751   extern template const cvec elem_div(const cvec &v1, const cvec &v2);
01753   extern template const ivec elem_div(const ivec &v1, const ivec &v2);
01755   extern template const svec elem_div(const svec &v1, const svec &v2);
01757   extern template const bvec elem_div(const bvec &v1, const bvec &v2);
01758 
01760   extern template const vec elem_div(const double t, const vec &v);
01762   extern template const cvec elem_div(const std::complex<double> t, const cvec &v);
01764   extern template const ivec elem_div(const int t, const ivec &v);
01766   extern template const svec elem_div(const short t, const svec &v);
01768   extern template const bvec elem_div(const bin t, const bvec &v);
01769 
01770   //--------------------- concat operator -----------------
01771 
01773   extern template const vec concat(const vec &v, const double a);
01775   extern template const cvec concat(const cvec &v, const std::complex<double> a);
01777   extern template const ivec concat(const ivec &v, const int a);
01779   extern template const svec concat(const svec &v, const short a);
01781   extern template const bvec concat(const bvec &v, const bin a);
01782 
01784   extern template const vec concat(const double a, const vec &v);
01786   extern template const cvec concat(const std::complex<double> a, const cvec &v);
01788   extern template const ivec concat(const int a, const ivec &v);
01790   extern template const svec concat(const short a, const svec &v);
01792   extern template const bvec concat(const bin a, const bvec &v);
01793 
01795   extern template const vec concat(const vec &v1, const vec &v2);
01797   extern template const cvec concat(const cvec &v1, const cvec &v2);
01799   extern template const ivec concat(const ivec &v1, const ivec &v2);
01801   extern template const svec concat(const svec &v1, const svec &v2);
01803   extern template const bvec concat(const bvec &v1, const bvec &v2);
01804 
01806   extern template const vec concat(const vec &v1, const vec &v2, const vec &v3);
01808   extern template const cvec concat(const cvec &v1, const cvec &v2, const cvec &v3);
01810   extern template const ivec concat(const ivec &v1, const ivec &v2, const ivec &v3);
01812   extern template const svec concat(const svec &v1, const svec &v2, const svec &v3);
01814   extern template const bvec concat(const bvec &v1, const bvec &v2, const bvec &v3);
01815 
01817   extern template const vec concat(const vec &v1, const vec &v2, const vec &v3, const vec &v4);
01819   extern template const cvec concat(const cvec &v1, const cvec &v2, const cvec &v3, const cvec &v4);
01821   extern template const ivec concat(const ivec &v1, const ivec &v2, const ivec &v3, const ivec &v4);
01823   extern template const svec concat(const svec &v1, const svec &v2, const svec &v3, const svec &v4);
01825   extern template const bvec concat(const bvec &v1, const bvec &v2, const bvec &v3, const bvec &v4);
01826 
01828   extern template const vec concat(const vec &v1, const vec &v2, const vec &v3, const vec &v4, const vec &v5);
01830   extern template const cvec concat(const cvec &v1, const cvec &v2, const cvec &v3, const cvec &v4, const cvec &v5);
01832   extern template const ivec concat(const ivec &v1, const ivec &v2, const ivec &v3, const ivec &v4, const ivec &v5);
01834   extern template const svec concat(const svec &v1, const svec &v2, const svec &v3, const svec &v4, const svec &v5);
01836   extern template const bvec concat(const bvec &v1, const bvec &v2, const bvec &v3, const bvec &v4, const bvec &v5);
01837 
01838   // -------------- output stream --------------------
01839 
01841   extern template std::ostream &operator<<(std::ostream& os, const vec &vect);
01843   extern template std::ostream &operator<<(std::ostream& os, const cvec &vect);
01845   extern template std::ostream &operator<<(std::ostream& os, const svec &vect);
01847   extern template std::ostream &operator<<(std::ostream& os, const ivec &vect);
01849   extern template std::ostream &operator<<(std::ostream& os, const bvec &vect);
01850 
01851   // -------------- input stream --------------------
01852 
01854   extern template std::istream &operator>>(std::istream& is, vec &vect);
01856   extern template std::istream &operator>>(std::istream& is, cvec &vect);
01858   extern template std::istream &operator>>(std::istream& is, svec &vect);
01860   extern template std::istream &operator>>(std::istream& is, ivec &vect);
01862   extern template std::istream &operator>>(std::istream& is, bvec &vect);
01863 
01864 #endif // #ifndef _MSC_VER
01865 
01866 } // namespace itpp
01867 
01868 #endif // #ifndef VEC_H
SourceForge Logo

Generated on Wed Mar 21 12:21:40 2007 for IT++ by Doxygen 1.4.7