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) 01636 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 01641 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
Generated on Fri Jan 11 08:51:38 2008 for IT++ by Doxygen 1.3.9.1