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

Generated on Fri Jun 8 00:37:34 2007 for IT++ by Doxygen 1.5.2