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 (datasize == 0) { // if not assigned a size.
00665       if (this != &v) { // check for self addition
00666         alloc(v.datasize);
00667         for (int i = 0; i < v.datasize; i++)
00668           data[i] = v.data[i];
00669       }
00670     } else {
00671       it_assert1(datasize == v.datasize, "Vec::operator+=: Wrong sizes");
00672       for (int i = 0; i < datasize; i++)
00673         data[i] += v.data[i];
00674     }
00675     return *this;
00676   }
00677 
00678   template<class Num_T> inline
00679   Vec<Num_T>& Vec<Num_T>::operator+=(const Num_T t)
00680   { 
00681     for (int i=0;i<datasize;i++) 
00682       data[i]+=t; 
00683     return *this;
00684   }
00685 
00686   template<class Num_T> inline
00687   const Vec<Num_T> operator+(const Vec<Num_T> &v1, const Vec<Num_T> &v2)
00688   {
00689     int i;
00690     Vec<Num_T> r(v1.datasize);
00691 
00692     it_assert1(v1.datasize==v2.datasize, "Vec<Num_T>::operator+: wrong sizes");
00693     for (i=0; i<v1.datasize; i++)
00694       r.data[i] = v1.data[i] + v2.data[i];
00695 
00696     return r;
00697   }
00698 
00699   template<class Num_T> inline
00700   const Vec<Num_T> operator+(const Vec<Num_T> &v, const Num_T t)
00701   {
00702     int i;
00703     Vec<Num_T> r(v.datasize);
00704 
00705     for (i=0; i<v.datasize; i++)
00706       r.data[i] = v.data[i] + t;
00707 
00708     return r;
00709   }
00710 
00711   template<class Num_T> inline
00712   const Vec<Num_T> operator+(const Num_T t, const Vec<Num_T> &v)
00713   {
00714     int i;
00715     Vec<Num_T> r(v.datasize);
00716 
00717     for (i=0; i<v.datasize; i++)
00718       r.data[i] = t + v.data[i];
00719 
00720     return r;
00721   }
00722 
00723   template<class Num_T> inline
00724   Vec<Num_T>& Vec<Num_T>::operator-=(const Vec<Num_T> &v)
00725   {
00726     if (datasize == 0) { // if not assigned a size.
00727       if (this != &v) { // check for self decrementation
00728         alloc(v.datasize);
00729         for (int i = 0; i < v.datasize; i++)
00730           data[i] = -v.data[i];
00731       }
00732     } else {
00733       it_assert1(datasize == v.datasize, "Vec::operator-=: Wrong sizes");
00734       for (int i = 0; i < datasize; i++)
00735         data[i] -= v.data[i];
00736     }
00737     return *this;
00738   }
00739 
00740   template<class Num_T> inline
00741   Vec<Num_T>& Vec<Num_T>::operator-=(const Num_T t)
00742   { 
00743     for (int i=0;i<datasize;i++) 
00744       data[i]-=t;
00745     return *this;
00746   }
00747 
00748   template<class Num_T> inline
00749   const Vec<Num_T> operator-(const Vec<Num_T> &v1, const Vec<Num_T> &v2)
00750   {
00751     int i;
00752     Vec<Num_T> r(v1.datasize);
00753 
00754     it_assert1(v1.datasize==v2.datasize, "Vec<Num_T>::operator-: wrong sizes");
00755     for (i=0; i<v1.datasize; i++)
00756       r.data[i] = v1.data[i] - v2.data[i];
00757 
00758     return r;
00759   }
00760 
00761   template<class Num_T> inline
00762   const Vec<Num_T> operator-(const Vec<Num_T> &v, const Num_T t)
00763   {
00764     int i;
00765     Vec<Num_T> r(v.datasize);
00766 
00767     for (i=0; i<v.datasize; i++)
00768       r.data[i] = v.data[i] - t;
00769 
00770     return r;
00771   }
00772 
00773   template<class Num_T> inline
00774   const Vec<Num_T> operator-(const Num_T t, const Vec<Num_T> &v)
00775   {
00776     int i;
00777     Vec<Num_T> r(v.datasize);
00778 
00779     for (i=0; i<v.datasize; i++)
00780       r.data[i] = t - v.data[i];
00781 
00782     return r;
00783   }
00784 
00785   template<class Num_T> inline
00786   const Vec<Num_T> operator-(const Vec<Num_T> &v)
00787   {
00788     int i;
00789     Vec<Num_T> r(v.datasize);
00790 
00791     for (i=0; i<v.datasize; i++)
00792       r.data[i] = -v.data[i];
00793 
00794     return r;
00795   }
00796 
00797   template<class Num_T> inline
00798   Vec<Num_T>& Vec<Num_T>::operator*=(const Num_T t)
00799   { 
00800     for (int i=0;i<datasize;i++) 
00801       data[i] *= t; 
00802     return *this;
00803   }
00804 
00805 #if defined(HAVE_CBLAS)
00806   template<> double dot(const vec &v1, const vec &v2);
00807   template<> std::complex<double> dot(const cvec &v1, const cvec &v2);
00808 #endif
00809 
00810   template<class Num_T> inline
00811   Num_T dot(const Vec<Num_T> &v1, const Vec<Num_T> &v2)
00812   {
00813     int i;
00814     Num_T r=Num_T(0);
00815 
00816     it_assert1(v1.datasize==v2.datasize, "Vec<Num_T>::dot: wrong sizes");
00817     for (i=0; i<v1.datasize; i++)
00818       r += v1.data[i] * v2.data[i];
00819 
00820     return r;
00821   }
00822 
00823   template<class Num_T> inline
00824   const Mat<Num_T> outer_product(const Vec<Num_T> &v1, const Vec<Num_T> &v2)
00825   {
00826     int i, j;
00827 
00828     it_assert1(v1.datasize>0 && v2.datasize>0, "Vec<Num_T>::outer_product:: Vector of zero size");
00829 
00830     Mat<Num_T> r(v1.datasize, v2.datasize);
00831 
00832     for (i=0; i<v1.datasize; i++) {
00833       for (j=0; j<v2.datasize; j++) {
00834         r(i,j) = v1.data[i] * v2.data[j];
00835       }
00836     }
00837 
00838     return r;
00839   }
00840 
00841   template<class Num_T> inline
00842   const Vec<Num_T> operator*(const Vec<Num_T> &v, const Num_T t)
00843   {
00844     int i;
00845     Vec<Num_T> r(v.datasize);
00846 
00847     for (i=0; i<v.datasize; i++)
00848       r.data[i] = v.data[i] * t;
00849 
00850     return r;
00851   }
00852 
00853   template<class Num_T> inline
00854   const Vec<Num_T> operator*(const Num_T t, const Vec<Num_T> &v)
00855   {
00856     int i;
00857     Vec<Num_T> r(v.datasize);
00858 
00859     for (i=0; i<v.datasize; i++)
00860       r.data[i] = t * v.data[i];
00861 
00862     return r;
00863   }
00864 
00865   template<class Num_T> inline
00866   const Vec<Num_T> elem_mult(const Vec<Num_T> &v1, const Vec<Num_T> &v2)
00867   {
00868     int i;
00869     Vec<Num_T> r(v1.datasize);
00870 
00871     it_assert1(v1.datasize==v2.datasize, "Vec<Num_T>::elem_mult: wrong sizes");
00872     for (i=0; i<v1.datasize; i++)
00873       r.data[i] = v1.data[i] * v2.data[i];
00874 
00875     return r;
00876   }
00877 
00878   template<class Num_T> inline
00879   const Vec<Num_T> elem_mult(const Vec<Num_T> &v1, const Vec<Num_T> &v2, const Vec<Num_T> &v3)
00880   {
00881     int i;
00882     Vec<Num_T> r(v1.datasize);
00883 
00884     it_assert1(v1.datasize==v2.datasize, "Vec<Num_T>::elem_mult: wrong sizes");
00885     it_assert1(v2.datasize==v3.datasize, "Vec<Num_T>::elem_mult: wrong sizes");
00886     for (i=0; i<v1.datasize; i++)
00887       r.data[i] = v1.data[i] * v2.data[i] * v3.data[i];
00888 
00889     return r;
00890   }
00891 
00892   template<class Num_T> inline
00893   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)
00894   {
00895     int i;
00896     Vec<Num_T> r(v1.datasize);
00897 
00898     it_assert1(v1.datasize==v2.datasize, "Vec<Num_T>::elem_mult: wrong sizes");
00899     it_assert1(v2.datasize==v3.datasize, "Vec<Num_T>::elem_mult: wrong sizes");
00900     it_assert1(v3.datasize==v4.datasize, "Vec<Num_T>::elem_mult: wrong sizes");
00901     for (i=0; i<v1.datasize; i++)
00902       r.data[i] = v1.data[i] * v2.data[i] * v3.data[i] * v4.data[i];
00903 
00904     return r;
00905   }
00906 
00907   template<class Num_T> inline
00908   const Vec<Num_T> operator/(const Vec<Num_T> &v, const Num_T t)
00909   {
00910     int i;
00911     Vec<Num_T> r(v.datasize);
00912 
00913     for (i=0; i<v.datasize; i++)
00914       r.data[i] = v.data[i] / t;
00915 
00916     return r;
00917   }
00918 
00919   template<class Num_T> inline
00920   const Vec<Num_T> operator/(const Num_T t, const Vec<Num_T> &v)
00921   {
00922     int i;
00923     Vec<Num_T> r(v.datasize);
00924 
00925     for (i=0; i<v.datasize; i++)
00926       r.data[i] = t / v.data[i];
00927 
00928     return r;
00929   }
00930 
00931   template<class Num_T> inline
00932   Vec<Num_T>& Vec<Num_T>::operator/=(const Num_T t)
00933   { 
00934     for (int i=0;i<datasize;i++) 
00935       data[i]/=t; 
00936     return *this;
00937   }
00938 
00939   template<class Num_T> inline
00940   Vec<Num_T>& Vec<Num_T>::operator/=(const Vec<Num_T> &v)
00941   {
00942     if (this != &v) {
00943       int i;
00944       it_assert1(datasize==v.datasize, "Vec<Num_T>::operator/=: wrong sizes");
00945       for (i=0; i<datasize; i++)
00946         data[i] /= v.data[i];
00947     }
00948     return *this;
00949   }
00950 
00951   template<class Num_T> inline
00952   const Vec<Num_T> elem_div(const Vec<Num_T> &v1, const Vec<Num_T> &v2)
00953   {
00954     int i;
00955     Vec<Num_T> r(v1.datasize);
00956 
00957     it_assert1(v1.datasize==v2.datasize, "Vec<Num_T>elem_div: wrong sizes");
00958     for (i=0; i<v1.datasize; i++)
00959       r.data[i] = v1.data[i] / v2.data[i];
00960 
00961     return r;
00962   }
00963 
00964   template<class Num_T> inline
00965   const Vec<Num_T> elem_div(const Num_T t, const Vec<Num_T> &v)
00966   {
00967     int i;
00968     Vec<Num_T> r(v.datasize);
00969 
00970     for (i=0; i<v.datasize; i++)
00971       r.data[i] = t / v.data[i];
00972 
00973     return r;
00974   }
00975 
00976   template<class Num_T>
00977   Vec<Num_T> Vec<Num_T>::get(const Vec<bin> &binlist) const
00978   {
00979     it_assert1(datasize == binlist.size(), "Vec<Num_T>::get(bvec &): wrong sizes");
00980     Vec<Num_T> temp(binlist.length());
00981     int j=0;
00982 
00983     for (int i=0;i<binlist.length();i++) {
00984       if (binlist(i) == bin(1)) {
00985         temp(j)=data[i];
00986         j++;
00987       }
00988     }
00989     temp.set_size(j, true);
00990     return temp;
00991   }
00992 
00993   template<class Num_T> inline
00994   Vec<Num_T> Vec<Num_T>::right(const int nr) const
00995   {
00996     it_assert1(nr<=datasize, "Vec<Num_T>::right: index out of range");
00997     Vec<Num_T> temp(nr);
00998     if (nr!=0) {
00999       copy_vector(nr, &data[datasize-nr], &temp[0]);
01000     }
01001     return temp;
01002   }
01003 
01004   template<class Num_T> inline
01005   Vec<Num_T> Vec<Num_T>::left(const int nr) const
01006   {
01007     it_assert1(nr<=datasize, "Vec<Num_T>::left: index out of range");
01008     Vec<Num_T> temp(nr);
01009     if (nr!=0) {
01010       copy_vector(nr, &data[0], &temp[0]);
01011     }
01012     return temp;
01013   }
01014 
01015   template<class Num_T> inline
01016   Vec<Num_T> Vec<Num_T>::mid(const int start, const int nr) const
01017   {
01018     it_assert1((start>=0)&& ((start+nr)<=datasize), "Vec<Num_T>::mid: indexing out of range");
01019     Vec<Num_T> temp(nr);
01020 
01021     if (nr!=0) {
01022       copy_vector(nr, &data[start], &temp[0]);
01023     }
01024     return temp;
01025   }
01026 
01027   template<class Num_T>
01028   Vec<Num_T> Vec<Num_T>::split(const int Position)
01029   {
01030     it_assert1((Position>=0) && (Position<=datasize), "Vec<Num_T>::split: index out of range");
01031     Vec<Num_T> Temp1(Position);
01032     Vec<Num_T> Temp2(datasize-Position);
01033     int  i;
01034 
01035     for (i=0;i<Position;i++) {
01036       Temp1[i]=data[i];
01037     }
01038     for (i=Position;i<datasize;i++) {
01039       Temp2[i-Position]=data[i];
01040     }
01041     (*this)=Temp2;
01042     return Temp1;
01043   }
01044 
01045   template<class Num_T>
01046   void Vec<Num_T>::shift_right(const Num_T In, const int n)
01047   {
01048     int i=datasize;
01049 
01050     it_assert1(n>=0, "Vec<Num_T>::shift_right: index out of range");
01051     while (--i >= n)
01052       data[i] = data[i-n];
01053     while (i >= 0)
01054       data[i--] = In;
01055   }
01056 
01057   template<class Num_T>
01058   void Vec<Num_T>::shift_right(const Vec<Num_T> &In)
01059   {
01060     int i;
01061 
01062     for (i=datasize-1; i>=In.datasize; i--)
01063       data[i]=data[i-In.datasize];
01064     for (i=0; i<In.datasize; i++)
01065       data[i]=In[i];
01066   }
01067 
01068   template<class Num_T>
01069   void Vec<Num_T>::shift_left(const Num_T In, const int n)
01070   {
01071     int i;
01072 
01073     it_assert1(n>=0, "Vec<Num_T>::shift_left: index out of range");
01074     for (i=0; i<datasize-n; i++)
01075       data[i] = data[i+n];
01076     while (i < datasize)
01077       data[i++] = In;
01078   }
01079 
01080   template<class Num_T>
01081   void Vec<Num_T>::shift_left(const Vec<Num_T> &In)
01082   {
01083     int i;
01084 
01085     for (i=0; i<datasize-In.datasize; i++)
01086       data[i]=data[i+In.datasize];
01087     for (i=datasize-In.datasize; i<datasize; i++)
01088       data[i]=In[i-datasize+In.datasize];
01089   }
01090 
01091   template<class Num_T>
01092   const Vec<Num_T> concat(const Vec<Num_T> &v, const Num_T a)
01093   {
01094     Vec<Num_T> temp(v.size()+1);
01095 
01096     for (int i=0; i<v.size(); i++)
01097       temp(i) = v(i);
01098     temp(v.size()) = a;
01099 
01100     return temp;
01101   }
01102 
01103   template<class Num_T>
01104   const Vec<Num_T> concat(const Num_T a, const Vec<Num_T> &v)
01105   {
01106     Vec<Num_T> temp(v.size()+1);
01107 
01108     temp(0) = a;
01109 
01110     for (int i=0; i<v.size(); i++)
01111       temp(i+1) = v(i);
01112 
01113     return temp;
01114   }
01115 
01116   template<class Num_T>
01117   const Vec<Num_T> concat(const Vec<Num_T> &v1, const Vec<Num_T> &v2)
01118   {
01119     int i;
01120     Vec<Num_T> temp(v1.size()+v2.size());
01121 
01122     for (i=0;i<v1.size();i++) {
01123       temp[i] = v1[i];
01124     }
01125     for (i=0;i<v2.size();i++) {
01126       temp[v1.size()+i] = v2[i];
01127     }
01128     return temp;
01129   }
01130 
01131   template<class Num_T>
01132   const Vec<Num_T> concat(const Vec<Num_T> &v1, const Vec<Num_T> &v2, const Vec<Num_T> &v3)
01133   {
01134     // There should be some error control?
01135     int i;
01136     Vec<Num_T> temp(v1.size()+v2.size()+v3.size());
01137 
01138     for (i=0;i<v1.size();i++) {
01139       temp[i] = v1[i];
01140     }
01141     for (i=0;i<v2.size();i++) {
01142       temp[v1.size()+i] = v2[i];
01143     }
01144     for (i=0;i<v3.size();i++) {
01145       temp[v1.size()+v2.size()+i] = v3[i];
01146     }
01147     return temp;
01148   }
01149 
01150   template<class Num_T>
01151   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)
01152   {
01153     // There should be some error control?
01154     int i;
01155     Vec<Num_T> temp(v1.size()+v2.size()+v3.size()+v4.size());
01156 
01157     for (i=0;i<v1.size();i++) {
01158       temp[i] = v1[i];
01159     }
01160     for (i=0;i<v2.size();i++) {
01161       temp[v1.size()+i] = v2[i];
01162     }
01163     for (i=0;i<v3.size();i++) {
01164       temp[v1.size()+v2.size()+i] = v3[i];
01165     }
01166     for (i=0;i<v4.size();i++) {
01167       temp[v1.size()+v2.size()+v3.size()+i] = v4[i];
01168     }
01169     return temp;
01170   }
01171 
01172   template<class Num_T>
01173   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)
01174   {
01175     // There should be some error control?
01176     int i;
01177     Vec<Num_T> temp(v1.size()+v2.size()+v3.size()+v4.size()+v5.size());
01178 
01179     for (i=0;i<v1.size();i++) {
01180       temp[i] = v1[i];
01181     }
01182     for (i=0;i<v2.size();i++) {
01183       temp[v1.size()+i] = v2[i];
01184     }
01185     for (i=0;i<v3.size();i++) {
01186       temp[v1.size()+v2.size()+i] = v3[i];
01187     }
01188     for (i=0;i<v4.size();i++) {
01189       temp[v1.size()+v2.size()+v3.size()+i] = v4[i];
01190     }
01191     for (i=0;i<v5.size();i++) {
01192       temp[v1.size()+v2.size()+v3.size()+v4.size()+i] = v5[i];
01193     }
01194     return temp;
01195   }
01196 
01197   template<class Num_T> inline
01198   void Vec<Num_T>::set_subvector(int i1, int i2, const Vec<Num_T> &v)
01199   {
01200     if (i1 == -1) i1 = datasize-1;
01201     if (i2 == -1) i2 = datasize-1;
01202 
01203     it_assert1(i1>=0 && i2>=0 && i1<datasize && i2<datasize, "Vec<Num_T>::set_subvector(): indicies out of range");
01204     it_assert1(i2>=i1, "Vec<Num_T>::set_subvector(): i2 >= i1 necessary");
01205     it_assert1(i2-i1+1 == v.datasize, "Vec<Num_T>::set_subvector(): wrong sizes");
01206 
01207     copy_vector(v.datasize, v.data, data+i1);
01208   }
01209 
01210   template<class Num_T> inline
01211   void Vec<Num_T>:: set_subvector(const int i, const Vec<Num_T> &v)
01212   {
01213     it_assert1(i>=0, "Vec<Num_T>::set_subvector(): index out of range");
01214     it_assert1(i+v.datasize <= datasize, "Vec<Num_T>::set_subvector(): too long input vector");
01215     copy_vector(v.datasize, v.data, data+i);
01216   }
01217 
01218   template<class Num_T>
01219   void Vec<Num_T>::set_subvector(int i1, int i2, const Num_T t)
01220   {
01221     if (i1 == -1) i1 = datasize-1;
01222     if (i2 == -1) i2 = datasize-1;
01223 
01224     it_assert1(i1>=0 && i2>=0 && i1<datasize && i2<datasize, "Vec<Num_T>::set_subvector(): indicies out of range");
01225     it_assert1(i2>=i1, "Vec<Num_T>::set_subvector(): i2 >= i1 necessary");
01226 
01227     for (int i=i1;i<=i2;i++)
01228       data[i] = t;
01229   }
01230 
01231   template<class Num_T>
01232   void Vec<Num_T>::replace_mid(const int pos, const Vec<Num_T> &v)
01233   {
01234     it_assert1((pos>=0) && ((pos+v.length())<=datasize), "Vec<Num_T>::replace_mid: indexing out of range");
01235     copy_vector(v.datasize, v.data, &data[pos]);
01236   }
01237 
01238   template<class Num_T>
01239   void Vec<Num_T>::del(const int index)
01240   {
01241     it_assert1((index>=0) && (index<datasize), "Vec<Num_T>::del: index out of range");
01242     Vec<Num_T> Temp(*this);
01243     int i;
01244 
01245     set_size(datasize-1, false);
01246     for (i=0;i<index;i++) {
01247       data[i]=Temp[i];
01248     }
01249     for (i=index;i<datasize;i++) {
01250       data[i]=Temp[i+1];
01251     }
01252   }
01253 
01254   template<class Num_T>
01255   void  Vec<Num_T>::del(const int i1, const int i2) 
01256   {
01257     it_assert1((i1>=0) && (i2<datasize) && (i1<i2), "Vec<Num_T>::del: index out of range");
01258 
01259     Vec<Num_T> Temp(*this);
01260     int new_size = datasize-(i2-i1+1);
01261     set_size(new_size, false);
01262     copy_vector(i1, Temp.data, data);
01263     copy_vector(datasize-i1, &Temp.data[i2+1], &data[i1]);
01264   }
01265 
01266   template<class Num_T>
01267   void Vec<Num_T>::ins(const int index, const Num_T in)
01268   {
01269     it_assert1((index>=0) && (index<=datasize), "Vec<Num_T>::ins: index out of range");
01270     Vec<Num_T> Temp(*this);
01271 
01272     set_size(datasize+1, false);
01273     copy_vector(index, Temp.data, data);
01274     data[index]=in;
01275     copy_vector(Temp.datasize-index, Temp.data+index, data+index+1);
01276   }
01277 
01278   template<class Num_T>
01279   void Vec<Num_T>::ins(const int index, const Vec<Num_T> &in)
01280   {
01281     it_assert1((index>=0) && (index<=datasize), "Vec<Num_T>::ins: index out of range");
01282     Vec<Num_T> Temp(*this);
01283 
01284     set_size(datasize+in.length(), false);
01285     copy_vector(index, Temp.data, data);
01286     copy_vector(in.size(), in.data, &data[index]);
01287     copy_vector(Temp.datasize-index, Temp.data+index, data+index+in.size());
01288   }
01289 
01290   template<class Num_T> inline
01291   Vec<Num_T>& Vec<Num_T>::operator=(const Num_T t)
01292   { 
01293     for (int i=0;i<datasize;i++) 
01294       data[i] = t; 
01295     return *this;
01296   }
01297 
01298   template<class Num_T> inline
01299   Vec<Num_T>& Vec<Num_T>::operator=(const Vec<Num_T> &v)
01300   {
01301     if (this != &v) {
01302       set_size(v.datasize, false);
01303       copy_vector(datasize, v.data, data);
01304     }
01305     return *this;
01306   }
01307 
01308   template<class Num_T> inline
01309   Vec<Num_T>& Vec<Num_T>::operator=(const Mat<Num_T> &m)
01310   {
01311     it_assert1( (m.cols() == 1 && datasize == m.rows()) ||
01312                 (m.rows() == 1 && datasize == m.cols()), "Vec<Num_T>::operator=(Mat<Num_T>): wrong size");
01313 
01314     if (m.cols() == 1) {
01315       set_size(m.rows(), false);
01316       copy_vector(m.rows(), m._data(), data);
01317     } else if (m.rows() == 1) {
01318       set_size(m.cols(), false);
01319       copy_vector(m.cols(), m._data(), m.rows(), data, 1);
01320     } else
01321       it_error("Vec<Num_T>::operator=(Mat<Num_T>): wrong size");
01322     return *this;
01323   }
01324 
01325   template<class Num_T> inline
01326   Vec<Num_T>& Vec<Num_T>::operator=(const char *values) 
01327   { 
01328     set(values);
01329     return *this;
01330   }
01331 
01332   template<> 
01333   bvec Vec<std::complex<double> >::operator==(const std::complex<double>) const;
01334 
01335   template<class Num_T>
01336   bvec Vec<Num_T>::operator==(const Num_T value) const
01337   {
01338     it_assert(datasize > 0, "Vec<Num_T>::operator==: vector must have size > 0");
01339     Vec<Num_T> invector(*this);
01340     bvec temp(invector.length());
01341 
01342     for (int i=0;i<invector.length();i++)
01343       temp(i)=(invector(i)==value);
01344 
01345     return temp;
01346   }
01347 
01348   template<> 
01349   bvec Vec<std::complex<double> >::operator!=(const std::complex<double>) const;
01350 
01351   template<class Num_T>
01352   bvec Vec<Num_T>::operator!=(const Num_T value) const
01353   {
01354     it_assert(datasize > 0, "Vec<Num_T>::operator!=: vector must have size > 0");
01355     Vec<Num_T> invector(*this);
01356     bvec temp(invector.length());
01357 
01358     for (int i=0;i<invector.length();i++)
01359       temp(i)=(invector(i)!=value);
01360 
01361     return temp;
01362   }
01363 
01364   template<> 
01365   bvec Vec<std::complex<double> >::operator<(const std::complex<double>) const;
01366 
01367   template<class Num_T>
01368   bvec Vec<Num_T>::operator<(const Num_T value) const
01369   {
01370     it_assert(datasize > 0, "Vec<Num_T>::operator<: vector must have size > 0");
01371     Vec<Num_T> invector(*this);
01372     bvec temp(invector.length());
01373 
01374     for (int i=0;i<invector.length();i++)
01375       temp(i)=(invector(i)<value);
01376 
01377     return temp;
01378   }
01379 
01380   template<> 
01381   bvec Vec<std::complex<double> >::operator<=(const std::complex<double>) const;
01382 
01383   template<class Num_T>
01384   bvec Vec<Num_T>::operator<=(const Num_T value) const
01385   {
01386     it_assert(datasize > 0, "Vec<Num_T>::operator<=: vector must have size > 0");
01387     Vec<Num_T> invector(*this);
01388     bvec temp(invector.length());
01389 
01390     for (int i=0;i<invector.length();i++)
01391       temp(i)=(invector(i)<=value);
01392 
01393     return temp;
01394   }
01395 
01396   template<>
01397   bvec Vec<std::complex<double> >::operator>(const std::complex<double>) const;
01398 
01399   template<class Num_T>
01400   bvec Vec<Num_T>::operator>(const Num_T value) const
01401   {
01402     it_assert(datasize > 0, "Vec<Num_T>::operator>: vector must have size > 0");
01403     Vec<Num_T> invector(*this);
01404     bvec temp(invector.length());
01405 
01406     for (int i=0;i<invector.length();i++)
01407       temp(i)=(invector(i)>value);
01408 
01409     return temp;
01410   }
01411 
01412   template<>
01413   bvec Vec<std::complex<double> >::operator>=(const std::complex<double>) const;
01414 
01415   template<class Num_T>
01416   bvec Vec<Num_T>::operator>=(const Num_T value) const
01417   {
01418     it_assert(datasize > 0, "Vec<Num_T>::operator>=: vector must have size > 0");
01419     Vec<Num_T> invector(*this);
01420     bvec temp(invector.length());
01421 
01422     for (int i=0;i<invector.length();i++)
01423       temp(i)=(invector(i)>=value);
01424 
01425     return temp;
01426   }
01427 
01428   template<class Num_T>
01429   bool Vec<Num_T>::operator==(const Vec<Num_T> &invector) const
01430   {
01431     // OBS ! if wrong size, return false
01432     if (datasize!=invector.datasize) return false;
01433     for (int i=0;i<datasize;i++) {
01434       if (data[i]!=invector.data[i]) return false;
01435     }
01436     return true;
01437   }
01438 
01439   template<class Num_T>
01440   bool Vec<Num_T>::operator!=(const Vec<Num_T> &invector) const
01441   {
01442     if (datasize!=invector.datasize) return true;
01443     for (int i=0;i<datasize;i++) {
01444       if (data[i]!=invector.data[i]) return true;
01445     }
01446     return false;
01447   }
01448 
01449   template <class Num_T>
01450   std::ostream &operator<<(std::ostream &os, const Vec<Num_T> &v)
01451   {
01452     int i, sz=v.length();
01453 
01454     os << "[" ;
01455     for (i=0; i<sz; i++) {
01456       os << v(i) ;
01457       if (i < sz-1)
01458         os << " ";
01459     }
01460     os << "]" ;
01461 
01462     return os;
01463   }
01464 
01465   template <class Num_T>
01466   std::istream &operator>>(std::istream &is, Vec<Num_T> &v)
01467   {
01468     std::ostringstream buffer;
01469     bool started = false;
01470     bool finished = false;
01471     bool brackets = false;
01472     char c;
01473 
01474     while (!finished) {
01475       if (is.eof()) {
01476         finished = true;
01477       } else {
01478         c = is.get();
01479 
01480         if (is.eof() || (c == '\n')) {
01481           if (brackets) {
01482             // Right bracket missing
01483             is.setstate(std::ios_base::failbit);
01484             finished = true;
01485           } else if (!((c == '\n') && !started)) {
01486             finished = true;
01487           }
01488         } else if ((c == ' ') || (c == '\t')) {
01489           if (started) {
01490             buffer << ' ';
01491           }
01492         } else if (c == '[') {
01493           if (started) {
01494             // Unexpected left bracket
01495             is.setstate(std::ios_base::failbit);
01496             finished = true;
01497           } else {
01498             started = true;
01499             brackets = true;
01500           }
01501         } else if (c == ']') {
01502           if (!started || !brackets) {
01503             // Unexpected right bracket
01504             is.setstate(std::ios_base::failbit);
01505             finished = true;
01506           } else {
01507             finished = true;
01508           }
01509           while (!is.eof() && (((c = is.peek()) == ' ') || (c == '\t'))) {
01510             is.get();
01511           }
01512           if (!is.eof() && (c == '\n')) {
01513             is.get();
01514           }
01515         } else {
01516           started = true;
01517           buffer << c;
01518         }
01519       }
01520     }
01521 
01522     if (!started) {
01523       v.set_size(0, false);
01524     } else {
01525       v.set(buffer.str());
01526     }
01527 
01528     return is;
01529   }
01530 
01531 #ifndef _MSC_VER
01532 
01533   //---------------------------------------------------------------------
01534   // Instantiations
01535   //---------------------------------------------------------------------
01536 
01537   //--------- class instantiations -------------
01538 
01540   extern template class Vec<double>;
01542   extern template class Vec<int>;
01544   extern template class Vec<short int>;
01546   extern template class Vec<std::complex<double> >;
01548   extern template class Vec<bin>;
01549 
01550   //------------- Addition operator ----------
01551 
01553   extern template const vec operator+(const vec &v1, const vec &v2);
01555   extern template const cvec operator+(const cvec &v1, const cvec &v2);
01557   extern template const ivec operator+(const ivec &v1, const ivec &v2);
01559   extern template const svec operator+(const svec &v1, const svec &v2);
01561   extern template const bvec operator+(const bvec &v1, const bvec &v2);
01562 
01564   extern template const vec operator+(const vec &v1, const double t);
01566   extern template const cvec operator+(const cvec &v1, std::complex<double> t);
01568   extern template const ivec operator+(const ivec &v1, const int t);
01570   extern template const svec operator+(const svec &v1, const short t);
01572   extern template const bvec operator+(const bvec &v1, const bin t);
01573 
01575   extern template const vec operator+(const double t, const vec &v1);
01577   extern template const cvec operator+(std::complex<double> t, const cvec &v1);
01579   extern template const ivec operator+(const int t, const ivec &v1);
01581   extern template const svec operator+(const short t, const svec &v1);
01583   extern template const bvec operator+(const bin t, const bvec &v1);
01584 
01585   //------------- Subraction operator ----------
01586 
01588   extern template const vec operator-(const vec &v1, const vec &v2);
01590   extern template const cvec operator-(const cvec &v1, const cvec &v2);
01592   extern template const ivec operator-(const ivec &v1, const ivec &v2);
01594   extern template const svec operator-(const svec &v1, const svec &v2);
01596   extern template const bvec operator-(const bvec &v1, const bvec &v2);
01597 
01599   extern template const vec operator-(const vec &v, const double t);
01601   extern template const cvec operator-(const cvec &v, std::complex<double> t);
01603   extern template const ivec operator-(const ivec &v, const int t);
01605   extern template const svec operator-(const svec &v, const short t);
01607   extern template const bvec operator-(const bvec &v, const bin t);
01608 
01610   extern template const vec operator-(const double t, const vec &v);
01612   extern template const cvec operator-(std::complex<double> t, const cvec &v);
01614   extern template const ivec operator-(const int t, const ivec &v);
01616   extern template const svec operator-(const short t, const svec &v);
01618   extern template const bvec operator-(const bin t, const bvec &v);
01619 
01620   //---------- Unary minus -------------
01621 
01623   extern template const vec operator-(const vec &v);
01625   extern template const cvec operator-(const cvec &v);
01627   extern template const ivec operator-(const ivec &v);
01629   extern template const svec operator-(const svec &v);
01631   extern template const bvec operator-(const bvec &v);
01632 
01633   //------------- Multiplication operator ----------
01634 
01635 #if !defined(HAVE_CBLAS)
01637   extern template double dot(const vec &v1, const vec &v2);
01639   extern template std::complex<double> dot(const cvec &v1, const cvec &v2);
01640 #endif
01642   extern template int dot(const ivec &v1, const ivec &v2);
01644   extern template short dot(const svec &v1, const svec &v2);
01646   extern template bin dot(const bvec &v1, const bvec &v2);
01647 
01649   extern template int operator*(const ivec &v1, const ivec &v2);
01651   extern template short operator*(const svec &v1, const svec &v2);
01653   extern template bin operator*(const bvec &v1, const bvec &v2);
01654 
01656   extern template const mat outer_product(const vec &v1, const vec &v2);
01658   extern template const cmat outer_product(const cvec &v1, const cvec &v2);
01660   extern template const imat outer_product(const ivec &v1, const ivec &v2);
01662   extern template const smat outer_product(const svec &v1, const svec &v2);
01664   extern template const bmat outer_product(const bvec &v1, const bvec &v2);
01665 
01667   extern template const vec operator*(const vec &v, const double t);
01669   extern template const cvec operator*(const cvec &v, std::complex<double> t);
01671   extern template const ivec operator*(const ivec &v, const int t);
01673   extern template const svec operator*(const svec &v, const short t);
01675   extern template const bvec operator*(const bvec &v, const bin t);
01676 
01678   extern template const vec operator*(const double t, const vec &v);
01680   extern template const cvec operator*(std::complex<double> t, const cvec &v);
01682   extern template const ivec operator*(const int t, const ivec &v);
01684   extern template const svec operator*(const short t, const svec &v);
01686   extern template const bvec operator*(const bin t, const bvec &v);
01687 
01688   //------------- Elementwise Multiplication operator (two vectors) ----------
01689 
01691   extern template const vec elem_mult(const vec &v1, const vec &v2);
01693   extern template const cvec elem_mult(const cvec &v1, const cvec &v2);
01695   extern template const ivec elem_mult(const ivec &v1, const ivec &v2);
01697   extern template const svec elem_mult(const svec &v1, const svec &v2);
01699   extern template const bvec elem_mult(const bvec &v1, const bvec &v2);
01700 
01701   //------------- Elementwise Multiplication operator (three vectors) ----------
01702 
01704   extern template const vec elem_mult(const vec &v1, const vec &v2, const vec &v3);
01706   extern template const cvec elem_mult(const cvec &v1, const cvec &v2, const cvec &v3);
01708   extern template const ivec elem_mult(const ivec &v1, const ivec &v2, const ivec &v3);
01710   extern template const svec elem_mult(const svec &v1, const svec &v2, const svec &v3);
01712   extern template const bvec elem_mult(const bvec &v1, const bvec &v2, const bvec &v3);
01713 
01714   //------------- Elementwise Multiplication operator (four vectors) ----------
01715 
01717   extern template const vec elem_mult(const vec &v1, const vec &v2, const vec &v3, const vec &v4);
01719   extern template const cvec elem_mult(const cvec &v1, const cvec &v2, const cvec &v3, const cvec &v4);
01721   extern template const ivec elem_mult(const ivec &v1, const ivec &v2, const ivec &v3, const ivec &v4);
01723   extern template const svec elem_mult(const svec &v1, const svec &v2, const svec &v3, const svec &v4);
01725   extern template const bvec elem_mult(const bvec &v1, const bvec &v2, const bvec &v3, const bvec &v4);
01726 
01727   //------------- Division operator ----------
01728 
01730   extern template const vec operator/(const vec &v, const double t);
01732   extern template const cvec operator/(const cvec &v, std::complex<double> t);
01734   extern template const ivec operator/(const ivec &v, const int t);
01736   extern template const svec operator/(const svec &v, const short t);
01738   extern template const bvec operator/(const bvec &v, const bin t);
01739 
01741   extern template const vec operator/(const double t, const vec &v);
01743   extern template const cvec operator/(const std::complex<double> t, const cvec &v);
01745   extern template const ivec operator/(const int t, const ivec &v);
01747   extern template const svec operator/(const short t, const svec &v);
01749   extern template const bvec operator/(const bin t, const bvec &v);
01750 
01751   //------------- Elementwise Division operator ----------
01752 
01754   extern template const vec elem_div(const vec &v1, const vec &v2);
01756   extern template const cvec elem_div(const cvec &v1, const cvec &v2);
01758   extern template const ivec elem_div(const ivec &v1, const ivec &v2);
01760   extern template const svec elem_div(const svec &v1, const svec &v2);
01762   extern template const bvec elem_div(const bvec &v1, const bvec &v2);
01763 
01765   extern template const vec elem_div(const double t, const vec &v);
01767   extern template const cvec elem_div(const std::complex<double> t, const cvec &v);
01769   extern template const ivec elem_div(const int t, const ivec &v);
01771   extern template const svec elem_div(const short t, const svec &v);
01773   extern template const bvec elem_div(const bin t, const bvec &v);
01774 
01775   //--------------------- concat operator -----------------
01776 
01778   extern template const vec concat(const vec &v, const double a);
01780   extern template const cvec concat(const cvec &v, const std::complex<double> a);
01782   extern template const ivec concat(const ivec &v, const int a);
01784   extern template const svec concat(const svec &v, const short a);
01786   extern template const bvec concat(const bvec &v, const bin a);
01787 
01789   extern template const vec concat(const double a, const vec &v);
01791   extern template const cvec concat(const std::complex<double> a, const cvec &v);
01793   extern template const ivec concat(const int a, const ivec &v);
01795   extern template const svec concat(const short a, const svec &v);
01797   extern template const bvec concat(const bin a, const bvec &v);
01798 
01800   extern template const vec concat(const vec &v1, const vec &v2);
01802   extern template const cvec concat(const cvec &v1, const cvec &v2);
01804   extern template const ivec concat(const ivec &v1, const ivec &v2);
01806   extern template const svec concat(const svec &v1, const svec &v2);
01808   extern template const bvec concat(const bvec &v1, const bvec &v2);
01809 
01811   extern template const vec concat(const vec &v1, const vec &v2, const vec &v3);
01813   extern template const cvec concat(const cvec &v1, const cvec &v2, const cvec &v3);
01815   extern template const ivec concat(const ivec &v1, const ivec &v2, const ivec &v3);
01817   extern template const svec concat(const svec &v1, const svec &v2, const svec &v3);
01819   extern template const bvec concat(const bvec &v1, const bvec &v2, const bvec &v3);
01820 
01822   extern template const vec concat(const vec &v1, const vec &v2, const vec &v3, const vec &v4);
01824   extern template const cvec concat(const cvec &v1, const cvec &v2, const cvec &v3, const cvec &v4);
01826   extern template const ivec concat(const ivec &v1, const ivec &v2, const ivec &v3, const ivec &v4);
01828   extern template const svec concat(const svec &v1, const svec &v2, const svec &v3, const svec &v4);
01830   extern template const bvec concat(const bvec &v1, const bvec &v2, const bvec &v3, const bvec &v4);
01831 
01833   extern template const vec concat(const vec &v1, const vec &v2, const vec &v3, const vec &v4, const vec &v5);
01835   extern template const cvec concat(const cvec &v1, const cvec &v2, const cvec &v3, const cvec &v4, const cvec &v5);
01837   extern template const ivec concat(const ivec &v1, const ivec &v2, const ivec &v3, const ivec &v4, const ivec &v5);
01839   extern template const svec concat(const svec &v1, const svec &v2, const svec &v3, const svec &v4, const svec &v5);
01841   extern template const bvec concat(const bvec &v1, const bvec &v2, const bvec &v3, const bvec &v4, const bvec &v5);
01842 
01843   // -------------- output stream --------------------
01844 
01846   extern template std::ostream &operator<<(std::ostream& os, const vec &vect);
01848   extern template std::ostream &operator<<(std::ostream& os, const cvec &vect);
01850   extern template std::ostream &operator<<(std::ostream& os, const svec &vect);
01852   extern template std::ostream &operator<<(std::ostream& os, const ivec &vect);
01854   extern template std::ostream &operator<<(std::ostream& os, const bvec &vect);
01855 
01856   // -------------- input stream --------------------
01857 
01859   extern template std::istream &operator>>(std::istream& is, vec &vect);
01861   extern template std::istream &operator>>(std::istream& is, cvec &vect);
01863   extern template std::istream &operator>>(std::istream& is, svec &vect);
01865   extern template std::istream &operator>>(std::istream& is, ivec &vect);
01867   extern template std::istream &operator>>(std::istream& is, bvec &vect);
01868 
01869 #endif // #ifndef _MSC_VER
01870 
01871 } // namespace itpp
01872 
01873 #endif // #ifndef VEC_H
SourceForge Logo

Generated on Sat Aug 25 23:37:27 2007 for IT++ by Doxygen 1.5.2