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
Generated on Fri Jun 8 00:27:15 2007 for IT++ by Doxygen 1.5.2