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