IT++ Logo
vec.h
Go to the documentation of this file.
1 
29 #ifndef VEC_H
30 #define VEC_H
31 
32 #include <itpp/base/itassert.h>
33 #include <itpp/base/math/misc.h>
34 #include <itpp/base/copy_vector.h>
35 #include <itpp/base/factory.h>
36 #include <vector>
37 #include <itpp/itexports.h>
38 
39 namespace itpp
40 {
41 
42 // Declaration of Vec
43 template<class Num_T> class Vec;
44 // Declaration of Mat
45 template<class Num_T> class Mat;
46 // Declaration of bin
47 class bin;
48 
49 //-----------------------------------------------------------------------------------
50 // Declaration of Vec Friends
51 //-----------------------------------------------------------------------------------
52 
54 template<class Num_T>
55 Vec<Num_T> operator+(const Vec<Num_T> &v1, const Vec<Num_T> &v2);
57 template<class Num_T>
58 Vec<Num_T> operator+(const Vec<Num_T> &v, Num_T t);
60 template<class Num_T>
61 Vec<Num_T> operator+(Num_T t, const Vec<Num_T> &v);
62 
64 template<class Num_T>
65 Vec<Num_T> operator-(const Vec<Num_T> &v1, const Vec<Num_T> &v2);
67 template<class Num_T>
68 Vec<Num_T> operator-(const Vec<Num_T> &v, Num_T t);
70 template<class Num_T>
71 Vec<Num_T> operator-(Num_T t, const Vec<Num_T> &v);
73 template<class Num_T>
74 Vec<Num_T> operator-(const Vec<Num_T> &v);
75 
77 template<class Num_T>
78 Num_T dot(const Vec<Num_T> &v1, const Vec<Num_T> &v2);
80 template<class Num_T>
81 Num_T operator*(const Vec<Num_T> &v1, const Vec<Num_T> &v2);
90 template<class Num_T>
91 Mat<Num_T> outer_product(const Vec<Num_T> &v1, const Vec<Num_T> &v2,
92  bool hermitian = false);
94 template<class Num_T>
95 Vec<Num_T> operator*(const Vec<Num_T> &v, Num_T t);
97 template<class Num_T>
98 Vec<Num_T> operator*(Num_T t, const Vec<Num_T> &v);
99 
101 template<class Num_T>
102 Vec<Num_T> elem_mult(const Vec<Num_T> &a, const Vec<Num_T> &b);
104 template<class Num_T>
105 Vec<Num_T> elem_mult(const Vec<Num_T> &a, const Vec<Num_T> &b,
106  const Vec<Num_T> &c);
108 template<class Num_T>
109 Vec<Num_T> elem_mult(const Vec<Num_T> &a, const Vec<Num_T> &b,
110  const Vec<Num_T> &c, const Vec<Num_T> &d);
111 
113 template<class Num_T>
114 void elem_mult_out(const Vec<Num_T> &a, const Vec<Num_T> &b,
115  Vec<Num_T> &out);
117 template<class Num_T>
118 void elem_mult_out(const Vec<Num_T> &a, const Vec<Num_T> &b,
119  const Vec<Num_T> &c, Vec<Num_T> &out);
121 template<class Num_T>
122 void elem_mult_out(const Vec<Num_T> &a, const Vec<Num_T> &b,
123  const Vec<Num_T> &c, const Vec<Num_T> &d,
124  Vec<Num_T> &out);
125 
127 template<class Num_T>
128 void elem_mult_inplace(const Vec<Num_T> &a, Vec<Num_T> &b);
130 template<class Num_T>
131 Num_T elem_mult_sum(const Vec<Num_T> &a, const Vec<Num_T> &b);
132 
134 template<class Num_T>
135 Vec<Num_T> operator/(const Vec<Num_T> &v, Num_T t);
137 template<class Num_T>
138 Vec<Num_T> operator/(Num_T t, const Vec<Num_T> &v);
139 
141 template<class Num_T>
142 Vec<Num_T> elem_div(const Vec<Num_T> &a, const Vec<Num_T> &b);
144 template<class Num_T>
145 Vec<Num_T> elem_div(Num_T t, const Vec<Num_T> &v);
147 template<class Num_T>
148 void elem_div_out(const Vec<Num_T> &a, const Vec<Num_T> &b, Vec<Num_T> &out);
150 template<class Num_T>
151 Num_T elem_div_sum(const Vec<Num_T> &a, const Vec<Num_T> &b);
152 
154 template<class Num_T>
155 Vec<Num_T> concat(const Vec<Num_T> &v, Num_T a);
157 template<class Num_T>
158 Vec<Num_T> concat(Num_T a, const Vec<Num_T> &v);
160 template<class Num_T>
161 Vec<Num_T> concat(const Vec<Num_T> &v1, const Vec<Num_T> &v2);
163 template<class Num_T>
164 Vec<Num_T> concat(const Vec<Num_T> &v1, const Vec<Num_T> &v2,
165  const Vec<Num_T> &v3);
167 template<class Num_T>
168 Vec<Num_T> concat(const Vec<Num_T> &v1, const Vec<Num_T> &v2,
169  const Vec<Num_T> &v3, const Vec<Num_T> &v4);
171 template<class Num_T>
172 Vec<Num_T> concat(const Vec<Num_T> &v1, const Vec<Num_T> &v2,
173  const Vec<Num_T> &v3, const Vec<Num_T> &v4,
174  const Vec<Num_T> &v5);
175 
176 //-----------------------------------------------------------------------------------
177 // Declaration of Vec
178 //-----------------------------------------------------------------------------------
179 
243 template<class Num_T>
244 class Vec
245 {
246 public:
248  typedef Num_T value_type;
249 
251  explicit Vec(const Factory &f = DEFAULT_FACTORY);
253  explicit Vec(int size, const Factory &f = DEFAULT_FACTORY);
255  Vec(const Vec<Num_T> &v);
257  Vec(const Vec<Num_T> &v, const Factory &f);
259  Vec(const char *str, const Factory &f = DEFAULT_FACTORY);
261  Vec(const std::string &str, const Factory &f = DEFAULT_FACTORY);
263  Vec(const Num_T *c_array, int size, const Factory &f = DEFAULT_FACTORY);
264 
266  ~Vec();
267 
269  int length() const { return datasize; }
271  int size() const { return datasize; }
272 
274  void set_size(int size, bool copy = false);
276  void set_length(int size, bool copy = false) { set_size(size, copy); }
278  void zeros();
280  void clear() { zeros(); }
282  void ones();
284  void set(const char *str);
286  void set(const std::string &str);
287 
289  const Num_T &operator[](int i) const;
291  const Num_T &operator()(int i) const;
293  Num_T &operator[](int i);
295  Num_T &operator()(int i);
297  Vec<Num_T> operator()(int i1, int i2) const;
299  Vec<Num_T> operator()(const Vec<int> &indexlist) const;
301  Vec<Num_T> operator()(const Vec<bin> &binlist) const;
302 
304  const Num_T &get(int i) const;
306  Vec<Num_T> get(int i1, int i2) const;
308  Vec<Num_T> get(const Vec<int> &indexlist) const;
310  Vec<Num_T> get(const Vec<bin> &binlist) const;
311 
313  void set(int i, Num_T t);
314 
316  Mat<Num_T> transpose() const;
318  Mat<Num_T> T() const { return this->transpose(); }
322  Mat<Num_T> H() const { return this->hermitian_transpose(); }
323 
325  Vec<Num_T>& operator+=(const Vec<Num_T> &v);
327  Vec<Num_T>& operator+=(Num_T t);
329  friend Vec<Num_T> operator+<>(const Vec<Num_T> &v1, const Vec<Num_T> &v2);
331  friend Vec<Num_T> operator+<>(const Vec<Num_T> &v, Num_T t);
333  friend Vec<Num_T> operator+<>(Num_T t, const Vec<Num_T> &v);
334 
336  Vec<Num_T>& operator-=(const Vec<Num_T> &v);
338  Vec<Num_T>& operator-=(Num_T t);
340  friend Vec<Num_T> operator-<>(const Vec<Num_T> &v1, const Vec<Num_T> &v2);
342  friend Vec<Num_T> operator-<>(const Vec<Num_T> &v, Num_T t);
344  friend Vec<Num_T> operator-<>(Num_T t, const Vec<Num_T> &v);
346  friend Vec<Num_T> operator-<>(const Vec<Num_T> &v);
347 
349  Vec<Num_T>& operator*=(Num_T t);
351  friend Vec<Num_T> operator*<>(const Vec<Num_T> &v, Num_T t);
353  friend Vec<Num_T> operator*<>(Num_T t, const Vec<Num_T> &v);
354 
356  friend Vec<Num_T> elem_mult<>(const Vec<Num_T> &a, const Vec<Num_T> &b);
358  friend Vec<Num_T> elem_mult<>(const Vec<Num_T> &a, const Vec<Num_T> &b,
359  const Vec<Num_T> &c);
361  friend Vec<Num_T> elem_mult<>(const Vec<Num_T> &a, const Vec<Num_T> &b,
362  const Vec<Num_T> &c, const Vec<Num_T> &d);
363 
365  friend void elem_mult_out<>(const Vec<Num_T> &a, const Vec<Num_T> &b,
366  Vec<Num_T> &out);
368  friend void elem_mult_out<>(const Vec<Num_T> &a, const Vec<Num_T> &b,
369  const Vec<Num_T> &c, Vec<Num_T> &out);
371  friend void elem_mult_out<>(const Vec<Num_T> &a, const Vec<Num_T> &b,
372  const Vec<Num_T> &c, const Vec<Num_T> &d,
373  Vec<Num_T> &out);
374 
376  friend void elem_mult_inplace<>(const Vec<Num_T> &a, Vec<Num_T> &b);
378  friend Num_T elem_mult_sum<>(const Vec<Num_T> &a, const Vec<Num_T> &b);
379 
381  Vec<Num_T>& operator/=(Num_T t);
383  Vec<Num_T>& operator/=(const Vec<Num_T> &v);
384 
386  friend Vec<Num_T> operator/<>(const Vec<Num_T> &v, Num_T t);
388  friend Vec<Num_T> operator/<>(Num_T t, const Vec<Num_T> &v);
389 
391  friend Vec<Num_T> elem_div<>(const Vec<Num_T> &v1, const Vec<Num_T> &v2);
393  friend Vec<Num_T> elem_div<>(Num_T t, const Vec<Num_T> &v);
395  friend void elem_div_out<>(const Vec<Num_T> &v1, const Vec<Num_T> &v2,
396  Vec<Num_T> &out);
398  friend Num_T elem_div_sum<>(const Vec<Num_T> &a, const Vec<Num_T> &b);
399 
401  Vec<Num_T> right(int nr) const;
403  Vec<Num_T> left(int nr) const;
405  Vec<Num_T> mid(int start, int nr) const;
413  Vec<Num_T> split(int pos);
415  void shift_right(Num_T t, int n = 1);
417  void shift_right(const Vec<Num_T> &v);
419  void shift_left(Num_T t, int n = 1);
421  void shift_left(const Vec<Num_T> &v);
422 
424  friend Vec<Num_T> concat<>(const Vec<Num_T> &v, Num_T t);
426  friend Vec<Num_T> concat<>(Num_T t, const Vec<Num_T> &v);
428  friend Vec<Num_T> concat<>(const Vec<Num_T> &v1, const Vec<Num_T> &v2);
430  friend Vec<Num_T> concat<>(const Vec<Num_T> &v1, const Vec<Num_T> &v2,
431  const Vec<Num_T> &v3);
433  friend Vec<Num_T> concat<>(const Vec<Num_T> &v1, const Vec<Num_T> &v2,
434  const Vec<Num_T> &v3, const Vec<Num_T> &v4);
436  friend Vec<Num_T> concat<>(const Vec<Num_T> &v1, const Vec<Num_T> &v2,
437  const Vec<Num_T> &v3, const Vec<Num_T> &v4,
438  const Vec<Num_T> &v5);
439 
441  void set_subvector(int i1, int i2, const Vec<Num_T> &v);
443  void set_subvector(int i, const Vec<Num_T> &v);
445  void set_subvector(int i1, int i2, Num_T t);
447  void replace_mid(int i, const Vec<Num_T> &v);
449  void del(int i);
451  void del(int i1, int i2);
453  void ins(int i, Num_T t);
455  void ins(int i, const Vec<Num_T> &v);
456 
458  Vec<Num_T>& operator=(Num_T t);
460  Vec<Num_T>& operator=(const Vec<Num_T> &v);
462  Vec<Num_T>& operator=(const Mat<Num_T> &m);
464  Vec<Num_T>& operator=(const char *str);
466  Vec<Num_T>& operator=(const std::string &str);
467 
469  Vec<bin> operator==(Num_T t) const;
471  Vec<bin> operator!=(Num_T t) const;
473  Vec<bin> operator<(Num_T t) const;
475  Vec<bin> operator<=(Num_T t) const;
477  Vec<bin> operator>(Num_T t) const;
479  Vec<bin> operator>=(Num_T t) const;
480 
482  bool operator==(const Vec<Num_T> &v) const;
484  bool operator!=(const Vec<Num_T> &v) const;
485 
487  Num_T &_elem(int i) { return data[i]; }
489  const Num_T &_elem(int i) const { return data[i]; }
490 
492  Num_T *_data() { return data; }
494  const Num_T *_data() const { return data; }
495 
496 protected:
498  void alloc(int size);
500  void free();
501 
503  int datasize;
505  Num_T *data;
507  const Factory &factory;
508 private:
509  // Clean up and tokenize input initialisation string
510  std::vector<std::string> tokenize(const std::string &str,
511  bool &abc_format) const;
512  // Parse double and integer values from string tokens
513  Num_T parse_token(const std::string &s) const;
514  // Parse \c a, \c b and \c c values from "a:b:c" format
515  void parse_abc_token(const std::string &s, Num_T &a, Num_T &b,
516  Num_T &c) const;
518  bool in_range(int i) const { return ((i < datasize) && (i >= 0)); }
519 };
520 
521 //-----------------------------------------------------------------------------------
522 // Type definitions of vec, cvec, ivec, svec, and bvec
523 //-----------------------------------------------------------------------------------
524 
529 typedef Vec<double> vec;
530 
535 typedef Vec<std::complex<double> > cvec;
536 
541 typedef Vec<int> ivec;
542 
547 typedef Vec<short int> svec;
548 
553 typedef Vec<bin> bvec;
554 
555 } //namespace itpp
556 
557 
558 #include <itpp/base/mat.h>
559 
560 namespace itpp
561 {
562 
563 //-----------------------------------------------------------------------------------
564 // Declaration of input and output streams for Vec
565 //-----------------------------------------------------------------------------------
566 
571 template<class Num_T>
572 std::ostream &operator<<(std::ostream &os, const Vec<Num_T> &v);
573 
585 template<class Num_T>
586 std::istream &operator>>(std::istream &is, Vec<Num_T> &v);
587 
588 //-----------------------------------------------------------------------------------
589 // Implementation of templated Vec members and friends
590 //-----------------------------------------------------------------------------------
591 
592 template<class Num_T> inline
594 {
595  if (size > 0) {
596  create_elements(data, size, factory);
597  datasize = size;
598  }
599  else {
600  data = 0;
601  datasize = 0;
602  }
603 }
604 
605 template<class Num_T> inline
607 {
608  destroy_elements(data, datasize);
609  datasize = 0;
610 }
611 
612 
613 template<class Num_T> inline
614 Vec<Num_T>::Vec(const Factory &f) : datasize(0), data(0), factory(f) {}
615 
616 template<class Num_T> inline
617 Vec<Num_T>::Vec(int size, const Factory &f) : datasize(0), data(0), factory(f)
618 {
619  it_assert_debug(size >= 0, "Negative size in Vec::Vec(int)");
620  alloc(size);
621 }
622 
623 template<class Num_T> inline
624 Vec<Num_T>::Vec(const Vec<Num_T> &v) : datasize(0), data(0), factory(v.factory)
625 {
626  alloc(v.datasize);
627  copy_vector(datasize, v.data, data);
628 }
629 
630 template<class Num_T> inline
631 Vec<Num_T>::Vec(const Vec<Num_T> &v, const Factory &f) : datasize(0), data(0), factory(f)
632 {
633  alloc(v.datasize);
634  copy_vector(datasize, v.data, data);
635 }
636 
637 template<class Num_T> inline
638 Vec<Num_T>::Vec(const char *str, const Factory &f) : datasize(0), data(0), factory(f)
639 {
640  set(std::string(str));
641 }
642 
643 template<class Num_T> inline
644 Vec<Num_T>::Vec(const std::string &str, const Factory &f) : datasize(0), data(0), factory(f)
645 {
646  set(str);
647 }
648 
649 template<class Num_T> inline
650 Vec<Num_T>::Vec(const Num_T *c_array, int size, const Factory &f) : datasize(0), data(0), factory(f)
651 {
652  alloc(size);
653  copy_vector(size, c_array, data);
654 }
655 
656 template<class Num_T> inline
658 {
659  free();
660 }
661 
662 template<class Num_T>
663 void Vec<Num_T>::set_size(int size, bool copy)
664 {
665  it_assert_debug(size >= 0, "Vec::set_size(): New size must not be negative");
666  if (datasize == size)
667  return;
668  if (copy) {
669  // create a temporary pointer to the allocated data
670  Num_T* tmp = data;
671  // store the current number of elements
672  int old_datasize = datasize;
673  // check how many elements we need to copy
674  int min = datasize < size ? datasize : size;
675  // allocate new memory
676  alloc(size);
677  // copy old elements into a new memory region
678  copy_vector(min, tmp, data);
679  // initialize the rest of resized vector
680  for (int i = min; i < size; ++i)
681  data[i] = Num_T(0);
682  // delete old elements
683  destroy_elements(tmp, old_datasize);
684  }
685  else {
686  free();
687  alloc(size);
688  }
689 }
690 
691 template<class Num_T> inline
692 const Num_T& Vec<Num_T>::operator[](int i) const
693 {
694  it_assert_debug(in_range(i), "Vec<>::operator[]: Index out of range");
695  return data[i];
696 }
697 
698 template<class Num_T> inline
699 const Num_T& Vec<Num_T>::operator()(int i) const
700 {
701  return (*this)[i];
702 }
703 
704 template<class Num_T> inline
706 {
707  it_assert_debug(in_range(i), "Vec<>::operator[]: Index out of range");
708  return data[i];
709 }
710 
711 template<class Num_T> inline
713 {
714  return (*this)[i];
715 }
716 
717 template<class Num_T> inline
718 Vec<Num_T> Vec<Num_T>::operator()(int i1, int i2) const
719 {
720  if (i1 == -1) i1 = datasize - 1;
721  if (i2 == -1) i2 = datasize - 1;
722 
723  it_assert_debug((i1 >= 0) && (i1 <= i2) && (i2 < datasize),
724  "Vec<>::operator()(i1, i2): Indexing out of range");
725 
726  Vec<Num_T> s(i2 - i1 + 1);
727  copy_vector(s.datasize, data + i1, s.data);
728 
729  return s;
730 }
731 
732 template<class Num_T>
734 {
735  int size = indexlist.size();
736  Vec<Num_T> temp(size);
737  for (int i = 0; i < size; ++i) {
738  it_assert_debug(in_range(indexlist(i)), "Vec<>::operator()(ivec &): "
739  "Index i=" << i << " out of range");
740  temp(i) = data[indexlist(i)];
741  }
742  return temp;
743 }
744 
745 template<class Num_T>
747 {
748  int size = binlist.size();
749  it_assert_debug(datasize == size, "Vec<>::operator()(bvec &): "
750  "Wrong size of binlist vector");
751  Vec<Num_T> temp(size);
752  int j = 0;
753  for (int i = 0; i < size; ++i)
754  if (binlist(i) == bin(1))
755  temp(j++) = data[i];
756  temp.set_size(j, true);
757  return temp;
758 }
759 
760 
761 template<class Num_T> inline
762 const Num_T& Vec<Num_T>::get(int i) const
763 {
764  return (*this)[i];
765 }
766 
767 template<class Num_T> inline
768 Vec<Num_T> Vec<Num_T>::get(int i1, int i2) const
769 {
770  return (*this)(i1, i2);
771 }
772 
773 template<class Num_T> inline
774 Vec<Num_T> Vec<Num_T>::get(const Vec<int> &indexlist) const
775 {
776  return (*this)(indexlist);
777 }
778 
779 template<class Num_T> inline
780 Vec<Num_T> Vec<Num_T>::get(const Vec<bin> &binlist) const
781 {
782  return (*this)(binlist);
783 }
784 
785 template<class Num_T> inline
787 {
788  for (int i = 0; i < datasize; i++)
789  data[i] = Num_T(0);
790 }
791 
792 template<class Num_T> inline
794 {
795  for (int i = 0; i < datasize; i++)
796  data[i] = Num_T(1);
797 }
798 
799 template<class Num_T> inline
800 void Vec<Num_T>::set(int i, Num_T t)
801 {
802  it_assert_debug(in_range(i), "Vec<>::set(i, t): Index out of range");
803  data[i] = t;
804 }
805 
806 template<class Num_T> inline
807 void Vec<Num_T>::set(const std::string &str)
808 {
809  it_error("Vec::set(): Only `double', `complex<double>', `int', "
810  "`short int' and `bin' types supported");
811 }
812 
813 template<class Num_T> inline
814 void Vec<Num_T>::set(const char *str)
815 {
816  set(std::string(str));
817 }
818 
820 template<>
821 ITPP_EXPORT void Vec<double>::set(const std::string &str);
822 template<>
823 ITPP_EXPORT void Vec<std::complex<double> >::set(const std::string &str);
824 template<>
825 ITPP_EXPORT void Vec<int>::set(const std::string &str);
826 template<>
827 ITPP_EXPORT void Vec<short int>::set(const std::string &str);
828 template<>
829 ITPP_EXPORT void Vec<bin>::set(const std::string &str);
831 
832 template<class Num_T>
834 {
835  Mat<Num_T> temp(1, datasize);
836  copy_vector(datasize, data, temp._data());
837  return temp;
838 }
839 
840 template<class Num_T>
842 {
843  Mat<Num_T> temp(1, datasize);
844  copy_vector(datasize, data, temp._data());
845  return temp;
846 }
847 
849 template<>
852 
853 
854 template<class Num_T>
856 {
857  if (datasize == 0) { // if not assigned a size.
858  if (this != &v) { // check for self addition
859  alloc(v.datasize);
860  copy_vector(datasize, v.data, data);
861  }
862  }
863  else {
864  it_assert_debug(datasize == v.datasize, "Vec::operator+=: Wrong sizes");
865  for (int i = 0; i < datasize; i++)
866  data[i] += v.data[i];
867  }
868  return *this;
869 }
870 
871 template<class Num_T> inline
873 {
874  for (int i = 0;i < datasize;i++)
875  data[i] += t;
876  return *this;
877 }
878 
879 template<class Num_T>
881 {
882  int i;
883  Vec<Num_T> r(v1.datasize);
884 
885  it_assert_debug(v1.datasize == v2.datasize, "Vec::operator+: wrong sizes");
886  for (i = 0; i < v1.datasize; i++)
887  r.data[i] = v1.data[i] + v2.data[i];
888 
889  return r;
890 }
891 
892 template<class Num_T>
893 Vec<Num_T> operator+(const Vec<Num_T> &v, Num_T t)
894 {
895  int i;
896  Vec<Num_T> r(v.datasize);
897 
898  for (i = 0; i < v.datasize; i++)
899  r.data[i] = v.data[i] + t;
900 
901  return r;
902 }
903 
904 template<class Num_T>
905 Vec<Num_T> operator+(Num_T t, const Vec<Num_T> &v)
906 {
907  int i;
908  Vec<Num_T> r(v.datasize);
909 
910  for (i = 0; i < v.datasize; i++)
911  r.data[i] = t + v.data[i];
912 
913  return r;
914 }
915 
916 template<class Num_T>
918 {
919  if (datasize == 0) { // if not assigned a size.
920  if (this != &v) { // check for self decrementation
921  alloc(v.datasize);
922  for (int i = 0; i < v.datasize; i++)
923  data[i] = -v.data[i];
924  }
925  }
926  else {
927  it_assert_debug(datasize == v.datasize, "Vec::operator-=: Wrong sizes");
928  for (int i = 0; i < datasize; i++)
929  data[i] -= v.data[i];
930  }
931  return *this;
932 }
933 
934 template<class Num_T> inline
936 {
937  for (int i = 0;i < datasize;i++)
938  data[i] -= t;
939  return *this;
940 }
941 
942 template<class Num_T>
944 {
945  int i;
946  Vec<Num_T> r(v1.datasize);
947 
948  it_assert_debug(v1.datasize == v2.datasize, "Vec::operator-: wrong sizes");
949  for (i = 0; i < v1.datasize; i++)
950  r.data[i] = v1.data[i] - v2.data[i];
951 
952  return r;
953 }
954 
955 template<class Num_T>
956 Vec<Num_T> operator-(const Vec<Num_T> &v, Num_T t)
957 {
958  int i;
959  Vec<Num_T> r(v.datasize);
960 
961  for (i = 0; i < v.datasize; i++)
962  r.data[i] = v.data[i] - t;
963 
964  return r;
965 }
966 
967 template<class Num_T>
968 Vec<Num_T> operator-(Num_T t, const Vec<Num_T> &v)
969 {
970  int i;
971  Vec<Num_T> r(v.datasize);
972 
973  for (i = 0; i < v.datasize; i++)
974  r.data[i] = t - v.data[i];
975 
976  return r;
977 }
978 
979 template<class Num_T>
981 {
982  int i;
983  Vec<Num_T> r(v.datasize);
984 
985  for (i = 0; i < v.datasize; i++)
986  r.data[i] = -v.data[i];
987 
988  return r;
989 }
990 
991 template<class Num_T> inline
993 {
994  scal_vector(datasize, t, data);
995  return *this;
996 }
997 
998 template<class Num_T> inline
999 Num_T operator*(const Vec<Num_T> &v1, const Vec<Num_T> &v2)
1000 {
1001  return dot(v1, v2);
1002 }
1003 
1004 template<class Num_T>
1005 Num_T dot(const Vec<Num_T> &v1, const Vec<Num_T> &v2)
1006 {
1007  it_assert_debug(v1.length() == v2.length(), "Vec::dot(): Wrong sizes");
1008  Num_T r = Num_T(0);
1009  for (int i = 0; i < v1.length(); ++i)
1010  r += v1._data()[i] * v2._data()[i];
1011  return r;
1012 }
1013 
1015 template<>
1016 ITPP_EXPORT double dot(const vec &v1, const vec &v2);
1018 
1019 
1020 template<class Num_T>
1021 Mat<Num_T> outer_product(const Vec<Num_T> &v1, const Vec<Num_T> &v2, bool)
1022 {
1023  it_assert_debug((v1.length() > 0) && (v2.length() > 0),
1024  "Vec::outer_product:: Input vector of zero size");
1025 
1026  Mat<Num_T> r(v1.length(), v2.length());
1027  for (int i = 0; i < v1.length(); ++i) {
1028  for (int j = 0; j < v2.length(); ++j) {
1029  r(i, j) = v1._data()[i] * v2._data()[j];
1030  }
1031  }
1032  return r;
1033 }
1034 
1036 template<>
1037 ITPP_EXPORT mat outer_product(const vec &v1, const vec &v2, bool);
1038 
1039 template<>
1040 ITPP_EXPORT cmat outer_product(const cvec &v1, const cvec &v2, bool hermitian);
1042 
1043 template<class Num_T>
1044 Vec<Num_T> operator*(const Vec<Num_T> &v, Num_T t)
1045 {
1046  int i;
1047  Vec<Num_T> r(v.datasize);
1048  for (i = 0; i < v.datasize; i++)
1049  r.data[i] = v.data[i] * t;
1050 
1051  return r;
1052 }
1053 
1054 template<class Num_T> inline
1055 Vec<Num_T> operator*(Num_T t, const Vec<Num_T> &v)
1056 {
1057  return operator*(v, t);
1058 }
1059 
1060 template<class Num_T> inline
1062 {
1063  Vec<Num_T> out;
1064  elem_mult_out(a, b, out);
1065  return out;
1066 }
1067 
1068 template<class Num_T> inline
1070  const Vec<Num_T> &c)
1071 {
1072  Vec<Num_T> out;
1073  elem_mult_out(a, b, c, out);
1074  return out;
1075 }
1076 
1077 template<class Num_T> inline
1079  const Vec<Num_T> &c, const Vec<Num_T> &d)
1080 {
1081  Vec<Num_T> out;
1082  elem_mult_out(a, b, c, d, out);
1083  return out;
1084 }
1085 
1086 template<class Num_T>
1087 void elem_mult_out(const Vec<Num_T> &a, const Vec<Num_T> &b, Vec<Num_T> &out)
1088 {
1090  "Vec<>::elem_mult_out(): Wrong sizes");
1091  out.set_size(a.datasize);
1092  for (int i = 0; i < a.datasize; i++)
1093  out.data[i] = a.data[i] * b.data[i];
1094 }
1095 
1096 template<class Num_T>
1097 void elem_mult_out(const Vec<Num_T> &a, const Vec<Num_T> &b,
1098  const Vec<Num_T> &c, Vec<Num_T> &out)
1099 {
1100  it_assert_debug((a.datasize == b.datasize) && (a.datasize == c.datasize),
1101  "Vec<>::elem_mult_out(): Wrong sizes");
1102  out.set_size(a.datasize);
1103  for (int i = 0; i < a.datasize; i++)
1104  out.data[i] = a.data[i] * b.data[i] * c.data[i];
1105 }
1106 
1107 template<class Num_T>
1108 void elem_mult_out(const Vec<Num_T> &a, const Vec<Num_T> &b,
1109  const Vec<Num_T> &c, const Vec<Num_T> &d, Vec<Num_T> &out)
1110 {
1111  it_assert_debug((a.datasize == b.datasize) && (a.datasize == c.datasize)
1112  && (a.datasize == d.datasize),
1113  "Vec<>::elem_mult_out(): Wrong sizes");
1114  out.set_size(a.datasize);
1115  for (int i = 0; i < a.datasize; i++)
1116  out.data[i] = a.data[i] * b.data[i] * c.data[i] * d.data[i];
1117 }
1118 
1119 template<class Num_T>
1120 #ifndef _MSC_VER
1121 inline
1122 #endif
1124 {
1126  "Vec<>::elem_mult_inplace(): Wrong sizes");
1127  for (int i = 0; i < a.datasize; i++)
1128  b.data[i] *= a.data[i];
1129 }
1130 
1131 template<class Num_T> inline
1132 Num_T elem_mult_sum(const Vec<Num_T> &a, const Vec<Num_T> &b)
1133 {
1135  "Vec<>::elem_mult_sum(): Wrong sizes");
1136  Num_T acc = 0;
1137  for (int i = 0; i < a.datasize; i++)
1138  acc += a.data[i] * b.data[i];
1139  return acc;
1140 }
1141 
1142 template<class Num_T>
1143 Vec<Num_T> operator/(const Vec<Num_T> &v, Num_T t)
1144 {
1145  int i;
1146  Vec<Num_T> r(v.datasize);
1147 
1148  for (i = 0; i < v.datasize; i++)
1149  r.data[i] = v.data[i] / t;
1150 
1151  return r;
1152 }
1153 
1154 template<class Num_T>
1155 Vec<Num_T> operator/(Num_T t, const Vec<Num_T> &v)
1156 {
1157  int i;
1158  Vec<Num_T> r(v.datasize);
1159 
1160  for (i = 0; i < v.datasize; i++)
1161  r.data[i] = t / v.data[i];
1162 
1163  return r;
1164 }
1165 
1166 template<class Num_T>
1167 Vec<Num_T> elem_div(Num_T t, const Vec<Num_T> &v)
1168 {
1169  it_warning("Vec<>::elem_div(Num_T, const Vec<Num_T> &): This function is "
1170  "deprecated and might be removed from future IT++ releases. "
1171  "Please use Vec<>::operator/(Num_T, const Vec<Num_T> &) "
1172  "instead.");
1173  return operator/(t, v);
1174 }
1175 
1176 template<class Num_T> inline
1178 {
1179  for (int i = 0; i < datasize; ++i) {
1180  data[i] /= t;
1181  }
1182  return *this;
1183 }
1184 
1185 template<class Num_T> inline
1187 {
1188  it_assert_debug(datasize == v.datasize, "Vec::operator/=(): wrong sizes");
1189  for (int i = 0; i < datasize; ++i) {
1190  data[i] /= v.data[i];
1191  }
1192  return *this;
1193 }
1194 
1195 template<class Num_T> inline
1197 {
1198  Vec<Num_T> out;
1199  elem_div_out(a, b, out);
1200  return out;
1201 }
1202 
1203 template<class Num_T>
1204 void elem_div_out(const Vec<Num_T> &a, const Vec<Num_T> &b, Vec<Num_T> &out)
1205 {
1206  it_assert_debug(a.datasize == b.datasize, "Vecelem_div_out: wrong sizes");
1207 
1208  out.set_size(a.size());
1209 
1210  for (int i = 0; i < a.datasize; i++)
1211  out.data[i] = a.data[i] / b.data[i];
1212 }
1213 
1214 template<class Num_T> inline
1215 Num_T elem_div_sum(const Vec<Num_T> &a, const Vec<Num_T> &b)
1216 {
1217  it_assert_debug(a.datasize == b.datasize, "Vec::elem_div_sum: wrong sizes");
1218 
1219  Num_T acc = 0;
1220 
1221  for (int i = 0; i < a.datasize; i++)
1222  acc += a.data[i] / b.data[i];
1223 
1224  return acc;
1225 }
1226 
1227 template<class Num_T>
1229 {
1230  it_assert_debug(nr <= datasize, "Vec::right(): index out of range");
1231  Vec<Num_T> temp(nr);
1232  if (nr > 0) {
1233  copy_vector(nr, &data[datasize-nr], temp.data);
1234  }
1235  return temp;
1236 }
1237 
1238 template<class Num_T>
1240 {
1241  it_assert_debug(nr <= datasize, "Vec::left(): index out of range");
1242  Vec<Num_T> temp(nr);
1243  if (nr > 0) {
1244  copy_vector(nr, data, temp.data);
1245  }
1246  return temp;
1247 }
1248 
1249 template<class Num_T>
1250 Vec<Num_T> Vec<Num_T>::mid(int start, int nr) const
1251 {
1252  it_assert_debug((start >= 0) && ((start + nr) <= datasize),
1253  "Vec::mid(): indexing out of range");
1254  Vec<Num_T> temp(nr);
1255  if (nr > 0) {
1256  copy_vector(nr, &data[start], temp.data);
1257  }
1258  return temp;
1259 }
1260 
1261 template<class Num_T>
1263 {
1264  it_assert_debug((pos >= 0) && (pos <= datasize),
1265  "Vec<>::split(): Index out of range");
1266  Vec<Num_T> temp1(pos);
1267  if (pos > 0) {
1268  copy_vector(pos, data, temp1.data);
1269  if (pos < datasize) {
1270  Vec<Num_T> temp2(datasize - pos);
1271  copy_vector(datasize - pos, &data[pos], temp2.data);
1272  (*this) = temp2;
1273  }
1274  else {
1275  set_size(0);
1276  }
1277  }
1278  return temp1;
1279 }
1280 
1281 template<class Num_T>
1282 void Vec<Num_T>::shift_right(Num_T t, int n)
1283 {
1284  int i = datasize;
1285 
1286  it_assert_debug(n >= 0, "Vec::shift_right: index out of range");
1287  while (--i >= n)
1288  data[i] = data[i-n];
1289  while (i >= 0)
1290  data[i--] = t;
1291 }
1292 
1293 template<class Num_T>
1295 {
1296  for (int i = datasize - 1; i >= v.datasize; i--)
1297  data[i] = data[i-v.datasize];
1298  for (int i = 0; i < v.datasize; i++)
1299  data[i] = v[i];
1300 }
1301 
1302 template<class Num_T>
1303 void Vec<Num_T>::shift_left(Num_T t, int n)
1304 {
1305  int i;
1306 
1307  it_assert_debug(n >= 0, "Vec::shift_left: index out of range");
1308  for (i = 0; i < datasize - n; i++)
1309  data[i] = data[i+n];
1310  while (i < datasize)
1311  data[i++] = t;
1312 }
1313 
1314 template<class Num_T>
1316 {
1317  for (int i = 0; i < datasize - v.datasize; i++)
1318  data[i] = data[i+v.datasize];
1319  for (int i = datasize - v.datasize; i < datasize; i++)
1320  data[i] = v[i-datasize+v.datasize];
1321 }
1322 
1323 template<class Num_T>
1324 Vec<Num_T> concat(const Vec<Num_T> &v, Num_T t)
1325 {
1326  int size = v.size();
1327  Vec<Num_T> temp(size + 1);
1328  copy_vector(size, v.data, temp.data);
1329  temp(size) = t;
1330  return temp;
1331 }
1332 
1333 template<class Num_T>
1334 Vec<Num_T> concat(Num_T t, const Vec<Num_T> &v)
1335 {
1336  int size = v.size();
1337  Vec<Num_T> temp(size + 1);
1338  temp(0) = t;
1339  copy_vector(size, v.data, &temp.data[1]);
1340  return temp;
1341 }
1342 
1343 template<class Num_T>
1345 {
1346  int size1 = v1.size();
1347  int size2 = v2.size();
1348  Vec<Num_T> temp(size1 + size2);
1349  copy_vector(size1, v1.data, temp.data);
1350  copy_vector(size2, v2.data, &temp.data[size1]);
1351  return temp;
1352 }
1353 
1354 template<class Num_T>
1356  const Vec<Num_T> &v3)
1357 {
1358  int size1 = v1.size();
1359  int size2 = v2.size();
1360  int size3 = v3.size();
1361  Vec<Num_T> temp(size1 + size2 + size3);
1362  copy_vector(size1, v1.data, temp.data);
1363  copy_vector(size2, v2.data, &temp.data[size1]);
1364  copy_vector(size3, v3.data, &temp.data[size1+size2]);
1365  return temp;
1366 }
1367 
1368 template<class Num_T>
1370  const Vec<Num_T> &v3, const Vec<Num_T> &v4)
1371 {
1372  int size1 = v1.size();
1373  int size2 = v2.size();
1374  int size3 = v3.size();
1375  int size4 = v4.size();
1376  Vec<Num_T> temp(size1 + size2 + size3 + size4);
1377  copy_vector(size1, v1.data, temp.data);
1378  copy_vector(size2, v2.data, &temp.data[size1]);
1379  copy_vector(size3, v3.data, &temp.data[size1+size2]);
1380  copy_vector(size4, v4.data, &temp.data[size1+size2+size3]);
1381  return temp;
1382 }
1383 
1384 template<class Num_T>
1386  const Vec<Num_T> &v3, const Vec<Num_T> &v4,
1387  const Vec<Num_T> &v5)
1388 {
1389  int size1 = v1.size();
1390  int size2 = v2.size();
1391  int size3 = v3.size();
1392  int size4 = v4.size();
1393  int size5 = v5.size();
1394  Vec<Num_T> temp(size1 + size2 + size3 + size4 + size5);
1395  copy_vector(size1, v1.data, temp.data);
1396  copy_vector(size2, v2.data, &temp.data[size1]);
1397  copy_vector(size3, v3.data, &temp.data[size1+size2]);
1398  copy_vector(size4, v4.data, &temp.data[size1+size2+size3]);
1399  copy_vector(size5, v5.data, &temp.data[size1+size2+size3+size4]);
1400  return temp;
1401 }
1402 
1403 template<class Num_T>
1404 void Vec<Num_T>::set_subvector(int i1, int, const Vec<Num_T> &v)
1405 {
1406  it_warning("Vec<>::set_subvector(int, int, const Vec<> &): This function "
1407  "is deprecated and might be removed from future IT++ releases. "
1408  "Please use Vec<>::set_subvector(int, const Vec<> &) instead.");
1409  set_subvector(i1, v);
1410 }
1411 
1412 template<class Num_T> inline
1414 {
1415  it_assert_debug((i >= 0) && (i + v.datasize <= datasize),
1416  "Vec<>::set_subvector(int, const Vec<> &): "
1417  "Index out of range or too long input vector");
1418  copy_vector(v.datasize, v.data, data + i);
1419 }
1420 
1421 template<class Num_T> inline
1422 void Vec<Num_T>::set_subvector(int i1, int i2, Num_T t)
1423 {
1424  if (i1 == -1) i1 = datasize - 1;
1425  if (i2 == -1) i2 = datasize - 1;
1426  it_assert_debug((i1 >= 0) && (i1 <= i2) && (i2 < datasize),
1427  "Vec<>::set_subvector(int, int, Num_T): Indexing out "
1428  "of range");
1429  for (int i = i1; i <= i2; i++)
1430  data[i] = t;
1431 }
1432 
1433 template<class Num_T> inline
1435 {
1436  set_subvector(i, v);
1437 }
1438 
1439 template<class Num_T>
1440 void Vec<Num_T>::del(int index)
1441 {
1442  it_assert_debug(in_range(index), "Vec<>::del(int): Index out of range");
1443  Vec<Num_T> temp(*this);
1444  set_size(datasize - 1, false);
1445  copy_vector(index, temp.data, data);
1446  copy_vector(datasize - index, &temp.data[index+1], &data[index]);
1447 }
1448 
1449 template<class Num_T>
1450 void Vec<Num_T>::del(int i1, int i2)
1451 {
1452  if (i1 == -1) i1 = datasize - 1;
1453  if (i2 == -1) i2 = datasize - 1;
1454  it_assert_debug((i1 >= 0) && (i1 <= i2) && (i2 < datasize),
1455  "Vec<>::del(int, int): Indexing out of range");
1456  Vec<Num_T> temp(*this);
1457  int new_size = datasize - (i2 - i1 + 1);
1458  set_size(new_size, false);
1459  copy_vector(i1, temp.data, data);
1460  copy_vector(datasize - i1, &temp.data[i2+1], &data[i1]);
1461 }
1462 
1463 template<class Num_T>
1464 void Vec<Num_T>::ins(int index, const Num_T t)
1465 {
1466  it_assert_debug((index >= 0) && (index <= datasize),
1467  "Vec<>::ins(): Index out of range");
1468  Vec<Num_T> Temp(*this);
1469 
1470  set_size(datasize + 1, false);
1471  copy_vector(index, Temp.data, data);
1472  data[index] = t;
1473  copy_vector(Temp.datasize - index, Temp.data + index, data + index + 1);
1474 }
1475 
1476 template<class Num_T>
1477 void Vec<Num_T>::ins(int index, const Vec<Num_T> &v)
1478 {
1479  it_assert_debug((index >= 0) && (index <= datasize),
1480  "Vec<>::ins(): Index out of range");
1481  Vec<Num_T> Temp(*this);
1482 
1483  set_size(datasize + v.length(), false);
1484  copy_vector(index, Temp.data, data);
1485  copy_vector(v.size(), v.data, &data[index]);
1486  copy_vector(Temp.datasize - index, Temp.data + index, data + index + v.size());
1487 }
1488 
1489 template<class Num_T> inline
1491 {
1492  for (int i = 0;i < datasize;i++)
1493  data[i] = t;
1494  return *this;
1495 }
1496 
1497 template<class Num_T> inline
1499 {
1500  if (this != &v) {
1501  set_size(v.datasize, false);
1502  copy_vector(datasize, v.data, data);
1503  }
1504  return *this;
1505 }
1506 
1507 template<class Num_T>
1509 {
1510  if (m.cols() == 1) {
1511  set_size(m.rows(), false);
1512  copy_vector(m.rows(), m._data(), data);
1513  }
1514  else if (m.rows() == 1) {
1515  set_size(m.cols(), false);
1516  copy_vector(m.cols(), m._data(), m.rows(), data, 1);
1517  }
1518  else
1519  it_error("Vec<>::operator=(Mat<Num_T> &): Wrong size of input matrix");
1520  return *this;
1521 }
1522 
1523 template<class Num_T> inline
1525 {
1526  set(std::string(str));
1527  return *this;
1528 }
1529 
1530 template<class Num_T> inline
1531 Vec<Num_T>& Vec<Num_T>::operator=(const std::string &str)
1532 {
1533  set(str);
1534  return *this;
1535 }
1536 
1537 template<class Num_T>
1538 bvec Vec<Num_T>::operator==(Num_T t) const
1539 {
1540  it_assert_debug(datasize > 0, "Vec<>::operator==(): Wrong size");
1541  bvec temp(datasize);
1542  for (int i = 0; i < datasize; i++)
1543  temp(i) = (data[i] == t);
1544  return temp;
1545 }
1546 
1547 template<class Num_T>
1548 bvec Vec<Num_T>::operator!=(Num_T t) const
1549 {
1550  it_assert_debug(datasize > 0, "Vec<>::operator!=(): Wrong size");
1551  bvec temp(datasize);
1552  for (int i = 0; i < datasize; i++)
1553  temp(i) = (data[i] != t);
1554  return temp;
1555 }
1556 
1558 template<>
1559 bvec Vec<std::complex<double> >::operator<(std::complex<double>) const;
1561 
1562 template<class Num_T>
1563 bvec Vec<Num_T>::operator<(Num_T t) const
1564 {
1565  it_assert_debug(datasize > 0, "Vec<>::operator<(): Wrong size");
1566  bvec temp(datasize);
1567  for (int i = 0; i < datasize; i++)
1568  temp(i) = (data[i] < t);
1569  return temp;
1570 }
1571 
1572 template<class Num_T>
1573 bvec Vec<Num_T>::operator<=(Num_T t) const
1574 {
1575  it_assert_debug(datasize > 0, "Vec<>::operator<=(): Wrong size");
1576  bvec temp(datasize);
1577  for (int i = 0; i < datasize; i++)
1578  temp(i) = (data[i] <= t);
1579  return temp;
1580 }
1581 
1583 template<>
1584 ITPP_EXPORT bvec Vec<std::complex<double> >::operator<=(std::complex<double>) const;
1586 
1587 template<class Num_T>
1588 bvec Vec<Num_T>::operator>(Num_T t) const
1589 {
1590  it_assert_debug(datasize > 0, "Vec<>::operator>(): Wrong size");
1591  bvec temp(datasize);
1592  for (int i = 0; i < datasize; i++)
1593  temp(i) = (data[i] > t);
1594  return temp;
1595 }
1596 
1598 template<>
1599 ITPP_EXPORT bvec Vec<std::complex<double> >::operator>(std::complex<double>) const;
1601 
1602 template<class Num_T>
1603 bvec Vec<Num_T>::operator>=(Num_T t) const
1604 {
1605  it_assert_debug(datasize > 0, "Vec<>::operator>=(): Wrong size");
1606  bvec temp(datasize);
1607  for (int i = 0; i < datasize; i++)
1608  temp(i) = (data[i] >= t);
1609  return temp;
1610 }
1611 
1613 template<>
1614 ITPP_EXPORT bvec Vec<std::complex<double> >::operator>=(std::complex<double>) const;
1616 
1617 template<class Num_T>
1618 bool Vec<Num_T>::operator==(const Vec<Num_T> &invector) const
1619 {
1620  // OBS ! if wrong size, return false
1621  if (datasize != invector.datasize) return false;
1622  for (int i = 0;i < datasize;i++) {
1623  if (data[i] != invector.data[i]) return false;
1624  }
1625  return true;
1626 }
1627 
1628 template<class Num_T>
1629 bool Vec<Num_T>::operator!=(const Vec<Num_T> &invector) const
1630 {
1631  if (datasize != invector.datasize) return true;
1632  for (int i = 0;i < datasize;i++) {
1633  if (data[i] != invector.data[i]) return true;
1634  }
1635  return false;
1636 }
1637 
1639 template<class Num_T>
1640 std::ostream &operator<<(std::ostream &os, const Vec<Num_T> &v)
1641 {
1642  int i, sz = v.length();
1643 
1644  os << "[" ;
1645  for (i = 0; i < sz; i++) {
1646  os << v(i) ;
1647  if (i < sz - 1)
1648  os << " ";
1649  }
1650  os << "]" ;
1651 
1652  return os;
1653 }
1654 
1656 template<class Num_T>
1657 std::istream &operator>>(std::istream &is, Vec<Num_T> &v)
1658 {
1659  std::ostringstream buffer;
1660  bool started = false;
1661  bool finished = false;
1662  bool brackets = false;
1663  char c = 0;
1664 
1665  while (!finished) {
1666  if (is.eof()) {
1667  finished = true;
1668  }
1669  else {
1670  is.get(c);
1671 
1672  if (is.eof() || (c == '\n')) {
1673  if (brackets) {
1674  // Right bracket missing
1675  is.setstate(std::ios_base::failbit);
1676  finished = true;
1677  }
1678  else if (!((c == '\n') && !started)) {
1679  finished = true;
1680  }
1681  }
1682  else if ((c == ' ') || (c == '\t')) {
1683  if (started) {
1684  buffer << ' ';
1685  }
1686  }
1687  else if (c == '[') {
1688  if (started) {
1689  // Unexpected left bracket
1690  is.setstate(std::ios_base::failbit);
1691  finished = true;
1692  }
1693  else {
1694  started = true;
1695  brackets = true;
1696  }
1697  }
1698  else if (c == ']') {
1699  if (!started || !brackets) {
1700  // Unexpected right bracket
1701  is.setstate(std::ios_base::failbit);
1702  finished = true;
1703  }
1704  else {
1705  finished = true;
1706  }
1707  while (!is.eof() && (((c = static_cast<char>(is.peek())) == ' ')
1708  || (c == '\t'))) {
1709  is.get();
1710  }
1711  if (!is.eof() && (c == '\n')) {
1712  is.get();
1713  }
1714  }
1715  else {
1716  started = true;
1717  buffer << c;
1718  }
1719  }
1720  }
1721 
1722  if (!started) {
1723  v.set_size(0, false);
1724  }
1725  else {
1726  v.set(buffer.str());
1727  }
1728 
1729  return is;
1730 }
1731 
1733 
1734 // ----------------------------------------------------------------------
1735 // Private functions
1736 // ----------------------------------------------------------------------
1737 
1738 template<class Num_T>
1739 void Vec<Num_T>::parse_abc_token(const std::string &s, Num_T &a, Num_T &b,
1740  Num_T &c) const
1741 {
1742  std::string::size_type beg = 0;
1743  std::string::size_type end = s.find(':', 0);
1744  a = parse_token(s.substr(beg, end-beg));
1745  beg = end + 1;
1746  end = s.find(':', beg);
1747  if (end != std::string::npos) {
1748  b = parse_token(s.substr(beg, end-beg));
1749  c = parse_token(s.substr(end+1, s.size()-end));
1750  }
1751  else {
1752  b = Num_T(1);
1753  c = parse_token(s.substr(beg, end-beg-1));
1754  }
1755 }
1756 
1757 template<class Num_T>
1758 Num_T Vec<Num_T>::parse_token(const std::string &s) const
1759 {
1760  it_error("Vec::parse_token(): Only `double' and `int' types are supported");
1761  return 0;
1762 }
1763 
1765 template<>
1766 ITPP_EXPORT double Vec<double>::parse_token(const std::string &s) const;
1767 template<>
1768 ITPP_EXPORT int Vec<int>::parse_token(const std::string &s) const;
1770 
1771 template<class Num_T>
1772 std::vector<std::string> Vec<Num_T>::tokenize(const std::string &str_in,
1773  bool &abc_format) const
1774 {
1775  std::vector<std::string> vs; // vector for storing parsed tokens
1776  std::string s; // currently processed token string
1777  bool start = true;
1778  bool space = false;
1779  bool colon = false;
1780  bool comma = false;
1781  bool lparen = false;
1782  abc_format = false;
1783  for (std::string::size_type i = 0; i < str_in.size(); ++i) {
1784  char c = str_in[i];
1785  switch (c) {
1786  case ' ': case '\t':
1787  space = true; // set flag for whitespaces
1788  break;
1789  case ',':
1790  if (lparen)
1791  comma = true; // set flag for comma in "(re,im)" format
1792  else
1793  space = true; // otherwise treat comma as separator
1794  break;
1795  case ')':
1796  s.push_back('i'); // replace right paren in "(re,im)" with 'i'
1797  break;
1798  case ':':
1799  colon = true; // set flag for "a:b[:c]" format string
1800  space = false; // reset flag for whitespaces
1801  abc_format = true; // set external flag for "a:b[:c]" format
1802  s.push_back(c);
1803  break;
1804  case '(':
1805  lparen = true; // set flag for complex "(re,im)" format
1806  break;
1807  default:
1808  if (colon) { // reset colon and space flags
1809  colon = false; // to get rid of whitespaces around ":"
1810  space = false;
1811  }
1812  else if (lparen && comma) { // support for "(re,im)" format
1813  lparen = false;
1814  comma = false;
1815  space = false;
1816  if ((c != '-') && (c != '+')) // if needed
1817  s.push_back('+'); // insert '+' between "re" and "im"
1818  }
1819  else if (space) { // new token detected
1820  space = false;
1821  if (!start) { // if not at the beginning of the string
1822  vs.push_back(s); // store already parsed token
1823  s.clear(); // and start parsing the next token
1824  }
1825  }
1826  s.push_back(c); // append next character to the current token
1827  start = false; // reset the "beginning of the string" flag
1828  break;
1829  }
1830  }
1831  if (!s.empty()) // if the final token is not an empty string
1832  vs.push_back(s); // store it in the output vector
1833  return vs;
1834 }
1835 
1836 // ----------------------------------------------------------------------
1837 // Instantiations
1838 // ----------------------------------------------------------------------
1839 ITPP_EXPORT_TEMPLATE template class ITPP_EXPORT Vec<double>;
1840 ITPP_EXPORT_TEMPLATE template class ITPP_EXPORT Vec<int>;
1841 ITPP_EXPORT_TEMPLATE template class ITPP_EXPORT Vec<short int>;
1842 ITPP_EXPORT_TEMPLATE template class ITPP_EXPORT Vec<std::complex<double> >;
1843 ITPP_EXPORT_TEMPLATE template class ITPP_EXPORT Vec<bin>;
1844 
1845 // addition operator
1846 
1847 ITPP_EXPORT_TEMPLATE template ITPP_EXPORT vec operator+(const vec &v1, const vec &v2);
1848 ITPP_EXPORT_TEMPLATE template ITPP_EXPORT cvec operator+(const cvec &v1, const cvec &v2);
1849 ITPP_EXPORT_TEMPLATE template ITPP_EXPORT ivec operator+(const ivec &v1, const ivec &v2);
1850 ITPP_EXPORT_TEMPLATE template ITPP_EXPORT svec operator+(const svec &v1, const svec &v2);
1851 ITPP_EXPORT_TEMPLATE template ITPP_EXPORT bvec operator+(const bvec &v1, const bvec &v2);
1852 
1853 ITPP_EXPORT_TEMPLATE template ITPP_EXPORT vec operator+(const vec &v1, double t);
1854 ITPP_EXPORT_TEMPLATE template ITPP_EXPORT cvec operator+(const cvec &v1, std::complex<double> t);
1855 ITPP_EXPORT_TEMPLATE template ITPP_EXPORT ivec operator+(const ivec &v1, int t);
1856 ITPP_EXPORT_TEMPLATE template ITPP_EXPORT svec operator+(const svec &v1, short t);
1857 ITPP_EXPORT_TEMPLATE template ITPP_EXPORT bvec operator+(const bvec &v1, bin t);
1858 
1859 ITPP_EXPORT_TEMPLATE template ITPP_EXPORT vec operator+(double t, const vec &v1);
1860 ITPP_EXPORT_TEMPLATE template ITPP_EXPORT cvec operator+(std::complex<double> t, const cvec &v1);
1861 ITPP_EXPORT_TEMPLATE template ITPP_EXPORT ivec operator+(int t, const ivec &v1);
1862 ITPP_EXPORT_TEMPLATE template ITPP_EXPORT svec operator+(short t, const svec &v1);
1863 ITPP_EXPORT_TEMPLATE template ITPP_EXPORT bvec operator+(bin t, const bvec &v1);
1864 
1865 // subtraction operator
1866 
1867 ITPP_EXPORT_TEMPLATE template ITPP_EXPORT vec operator-(const vec &v1, const vec &v2);
1868 ITPP_EXPORT_TEMPLATE template ITPP_EXPORT cvec operator-(const cvec &v1, const cvec &v2);
1869 ITPP_EXPORT_TEMPLATE template ITPP_EXPORT ivec operator-(const ivec &v1, const ivec &v2);
1870 ITPP_EXPORT_TEMPLATE template ITPP_EXPORT svec operator-(const svec &v1, const svec &v2);
1871 ITPP_EXPORT_TEMPLATE template ITPP_EXPORT bvec operator-(const bvec &v1, const bvec &v2);
1872 
1873 ITPP_EXPORT_TEMPLATE template ITPP_EXPORT vec operator-(const vec &v, double t);
1874 ITPP_EXPORT_TEMPLATE template ITPP_EXPORT cvec operator-(const cvec &v, std::complex<double> t);
1875 ITPP_EXPORT_TEMPLATE template ITPP_EXPORT ivec operator-(const ivec &v, int t);
1876 ITPP_EXPORT_TEMPLATE template ITPP_EXPORT svec operator-(const svec &v, short t);
1877 ITPP_EXPORT_TEMPLATE template ITPP_EXPORT bvec operator-(const bvec &v, bin t);
1878 
1879 ITPP_EXPORT_TEMPLATE template ITPP_EXPORT vec operator-(double t, const vec &v);
1880 ITPP_EXPORT_TEMPLATE template ITPP_EXPORT cvec operator-(std::complex<double> t, const cvec &v);
1881 ITPP_EXPORT_TEMPLATE template ITPP_EXPORT ivec operator-(int t, const ivec &v);
1882 ITPP_EXPORT_TEMPLATE template ITPP_EXPORT svec operator-(short t, const svec &v);
1883 ITPP_EXPORT_TEMPLATE template ITPP_EXPORT bvec operator-(bin t, const bvec &v);
1884 
1885 // unary minus
1886 
1887 ITPP_EXPORT_TEMPLATE template ITPP_EXPORT vec operator-(const vec &v);
1888 ITPP_EXPORT_TEMPLATE template ITPP_EXPORT cvec operator-(const cvec &v);
1889 ITPP_EXPORT_TEMPLATE template ITPP_EXPORT ivec operator-(const ivec &v);
1890 ITPP_EXPORT_TEMPLATE template ITPP_EXPORT svec operator-(const svec &v);
1891 ITPP_EXPORT_TEMPLATE template ITPP_EXPORT bvec operator-(const bvec &v);
1892 
1893 // multiplication operator
1894 ITPP_EXPORT_TEMPLATE template ITPP_EXPORT std::complex<double> dot(const cvec &v1, const cvec &v2);
1895 ITPP_EXPORT_TEMPLATE template ITPP_EXPORT int dot(const ivec &v1, const ivec &v2);
1896 ITPP_EXPORT_TEMPLATE template ITPP_EXPORT short dot(const svec &v1, const svec &v2);
1897 ITPP_EXPORT_TEMPLATE template ITPP_EXPORT bin dot(const bvec &v1, const bvec &v2);
1898 
1899 ITPP_EXPORT_TEMPLATE template ITPP_EXPORT double operator*(const vec &v1, const vec &v2);
1900 ITPP_EXPORT_TEMPLATE template ITPP_EXPORT std::complex<double> operator*(const cvec &v1, const cvec &v2);
1901 ITPP_EXPORT_TEMPLATE template ITPP_EXPORT int operator*(const ivec &v1, const ivec &v2);
1902 ITPP_EXPORT_TEMPLATE template ITPP_EXPORT short operator*(const svec &v1, const svec &v2);
1903 ITPP_EXPORT_TEMPLATE template ITPP_EXPORT bin operator*(const bvec &v1, const bvec &v2);
1904 
1905 ITPP_EXPORT_TEMPLATE template ITPP_EXPORT imat outer_product(const ivec &v1, const ivec &v2,
1906  bool hermitian);
1907 ITPP_EXPORT_TEMPLATE template ITPP_EXPORT smat outer_product(const svec &v1, const svec &v2,
1908  bool hermitian);
1909 ITPP_EXPORT_TEMPLATE template ITPP_EXPORT bmat outer_product(const bvec &v1, const bvec &v2,
1910  bool hermitian);
1911 
1912 ITPP_EXPORT_TEMPLATE template ITPP_EXPORT vec operator*(const vec &v, double t);
1913 ITPP_EXPORT_TEMPLATE template ITPP_EXPORT cvec operator*(const cvec &v, std::complex<double> t);
1914 ITPP_EXPORT_TEMPLATE template ITPP_EXPORT ivec operator*(const ivec &v, int t);
1915 ITPP_EXPORT_TEMPLATE template ITPP_EXPORT svec operator*(const svec &v, short t);
1916 ITPP_EXPORT_TEMPLATE template ITPP_EXPORT bvec operator*(const bvec &v, bin t);
1917 
1918 ITPP_EXPORT_TEMPLATE template ITPP_EXPORT vec operator*(double t, const vec &v);
1919 ITPP_EXPORT_TEMPLATE template ITPP_EXPORT cvec operator*(std::complex<double> t, const cvec &v);
1920 ITPP_EXPORT_TEMPLATE template ITPP_EXPORT ivec operator*(int t, const ivec &v);
1921 ITPP_EXPORT_TEMPLATE template ITPP_EXPORT svec operator*(short t, const svec &v);
1922 ITPP_EXPORT_TEMPLATE template ITPP_EXPORT bvec operator*(bin t, const bvec &v);
1923 
1924 // elementwise multiplication
1925 
1926 ITPP_EXPORT_TEMPLATE template ITPP_EXPORT vec elem_mult(const vec &a, const vec &b);
1927 ITPP_EXPORT_TEMPLATE template ITPP_EXPORT cvec elem_mult(const cvec &a, const cvec &b);
1928 ITPP_EXPORT_TEMPLATE template ITPP_EXPORT ivec elem_mult(const ivec &a, const ivec &b);
1929 ITPP_EXPORT_TEMPLATE template ITPP_EXPORT svec elem_mult(const svec &a, const svec &b);
1930 ITPP_EXPORT_TEMPLATE template ITPP_EXPORT bvec elem_mult(const bvec &a, const bvec &b);
1931 
1932 ITPP_EXPORT_TEMPLATE template ITPP_EXPORT void elem_mult_out(const vec &a, const vec &b, vec &out);
1933 ITPP_EXPORT_TEMPLATE template ITPP_EXPORT void elem_mult_out(const cvec &a, const cvec &b, cvec &out);
1934 ITPP_EXPORT_TEMPLATE template ITPP_EXPORT void elem_mult_out(const ivec &a, const ivec &b, ivec &out);
1935 ITPP_EXPORT_TEMPLATE template ITPP_EXPORT void elem_mult_out(const svec &a, const svec &b, svec &out);
1936 ITPP_EXPORT_TEMPLATE template ITPP_EXPORT void elem_mult_out(const bvec &a, const bvec &b, bvec &out);
1937 
1938 ITPP_EXPORT_TEMPLATE template ITPP_EXPORT vec elem_mult(const vec &a, const vec &b, const vec &c);
1939 ITPP_EXPORT_TEMPLATE template ITPP_EXPORT cvec elem_mult(const cvec &a, const cvec &b, const cvec &c);
1940 ITPP_EXPORT_TEMPLATE template ITPP_EXPORT ivec elem_mult(const ivec &a, const ivec &b, const ivec &c);
1941 ITPP_EXPORT_TEMPLATE template ITPP_EXPORT svec elem_mult(const svec &a, const svec &b, const svec &c);
1942 ITPP_EXPORT_TEMPLATE template ITPP_EXPORT bvec elem_mult(const bvec &a, const bvec &b, const bvec &c);
1943 
1944 ITPP_EXPORT_TEMPLATE template ITPP_EXPORT void elem_mult_out(const vec &a, const vec &b,
1945  const vec &c, vec &out);
1946 ITPP_EXPORT_TEMPLATE template ITPP_EXPORT void elem_mult_out(const cvec &a, const cvec &b,
1947  const cvec &c, cvec &out);
1948 ITPP_EXPORT_TEMPLATE template ITPP_EXPORT void elem_mult_out(const ivec &a, const ivec &b,
1949  const ivec &c, ivec &out);
1950 ITPP_EXPORT_TEMPLATE template ITPP_EXPORT void elem_mult_out(const svec &a, const svec &b,
1951  const svec &c, svec &out);
1952 ITPP_EXPORT_TEMPLATE template ITPP_EXPORT void elem_mult_out(const bvec &a, const bvec &b,
1953  const bvec &c, bvec &out);
1954 
1955 ITPP_EXPORT_TEMPLATE template ITPP_EXPORT vec elem_mult(const vec &a, const vec &b,
1956  const vec &c, const vec &d);
1957 ITPP_EXPORT_TEMPLATE template ITPP_EXPORT cvec elem_mult(const cvec &a, const cvec &b,
1958  const cvec &c, const cvec &d);
1959 ITPP_EXPORT_TEMPLATE template ITPP_EXPORT ivec elem_mult(const ivec &a, const ivec &b,
1960  const ivec &c, const ivec &d);
1961 ITPP_EXPORT_TEMPLATE template ITPP_EXPORT svec elem_mult(const svec &a, const svec &b,
1962  const svec &c, const svec &d);
1963 ITPP_EXPORT_TEMPLATE template ITPP_EXPORT bvec elem_mult(const bvec &a, const bvec &b,
1964  const bvec &c, const bvec &d);
1965 
1966 ITPP_EXPORT_TEMPLATE template ITPP_EXPORT void elem_mult_out(const vec &a, const vec &b, const vec &c,
1967  const vec &d, vec &out);
1968 ITPP_EXPORT_TEMPLATE template ITPP_EXPORT void elem_mult_out(const cvec &a, const cvec &b,
1969  const cvec &c, const cvec &d, cvec &out);
1970 ITPP_EXPORT_TEMPLATE template ITPP_EXPORT void elem_mult_out(const ivec &a, const ivec &b,
1971  const ivec &c, const ivec &d, ivec &out);
1972 ITPP_EXPORT_TEMPLATE template ITPP_EXPORT void elem_mult_out(const svec &a, const svec &b,
1973  const svec &c, const svec &d, svec &out);
1974 ITPP_EXPORT_TEMPLATE template ITPP_EXPORT void elem_mult_out(const bvec &a, const bvec &b,
1975  const bvec &c, const bvec &d, bvec &out);
1976 
1977 // in-place elementwise multiplication
1978 
1979 ITPP_EXPORT_TEMPLATE template ITPP_EXPORT void elem_mult_inplace(const vec &a, vec &b);
1980 ITPP_EXPORT_TEMPLATE template ITPP_EXPORT void elem_mult_inplace(const cvec &a, cvec &b);
1981 ITPP_EXPORT_TEMPLATE template ITPP_EXPORT void elem_mult_inplace(const ivec &a, ivec &b);
1982 ITPP_EXPORT_TEMPLATE template ITPP_EXPORT void elem_mult_inplace(const svec &a, svec &b);
1983 ITPP_EXPORT_TEMPLATE template ITPP_EXPORT void elem_mult_inplace(const bvec &a, bvec &b);
1984 
1985 // elementwise multiplication followed by summation
1986 
1987 ITPP_EXPORT_TEMPLATE template ITPP_EXPORT double elem_mult_sum(const vec &a, const vec &b);
1988 ITPP_EXPORT_TEMPLATE template ITPP_EXPORT std::complex<double> elem_mult_sum(const cvec &a,
1989  const cvec &b);
1990 ITPP_EXPORT_TEMPLATE template ITPP_EXPORT int elem_mult_sum(const ivec &a, const ivec &b);
1991 ITPP_EXPORT_TEMPLATE template ITPP_EXPORT short elem_mult_sum(const svec &a, const svec &b);
1992 ITPP_EXPORT_TEMPLATE template ITPP_EXPORT bin elem_mult_sum(const bvec &a, const bvec &b);
1993 
1994 // division operator
1995 
1996 ITPP_EXPORT_TEMPLATE template ITPP_EXPORT vec operator/(const vec &v, double t);
1997 ITPP_EXPORT_TEMPLATE template ITPP_EXPORT cvec operator/(const cvec &v, std::complex<double> t);
1998 ITPP_EXPORT_TEMPLATE template ITPP_EXPORT ivec operator/(const ivec &v, int t);
1999 ITPP_EXPORT_TEMPLATE template ITPP_EXPORT svec operator/(const svec &v, short t);
2000 ITPP_EXPORT_TEMPLATE template ITPP_EXPORT bvec operator/(const bvec &v, bin t);
2001 
2002 ITPP_EXPORT_TEMPLATE template ITPP_EXPORT vec operator/(double t, const vec &v);
2003 ITPP_EXPORT_TEMPLATE template ITPP_EXPORT cvec operator/(std::complex<double> t, const cvec &v);
2004 ITPP_EXPORT_TEMPLATE template ITPP_EXPORT ivec operator/(int t, const ivec &v);
2005 ITPP_EXPORT_TEMPLATE template ITPP_EXPORT svec operator/(short t, const svec &v);
2006 ITPP_EXPORT_TEMPLATE template ITPP_EXPORT bvec operator/(bin t, const bvec &v);
2007 
2008 // elementwise division operator
2009 
2010 ITPP_EXPORT_TEMPLATE template ITPP_EXPORT vec elem_div(const vec &a, const vec &b);
2011 ITPP_EXPORT_TEMPLATE template ITPP_EXPORT cvec elem_div(const cvec &a, const cvec &b);
2012 ITPP_EXPORT_TEMPLATE template ITPP_EXPORT ivec elem_div(const ivec &a, const ivec &b);
2013 ITPP_EXPORT_TEMPLATE template ITPP_EXPORT svec elem_div(const svec &a, const svec &b);
2014 ITPP_EXPORT_TEMPLATE template ITPP_EXPORT bvec elem_div(const bvec &a, const bvec &b);
2015 
2016 ITPP_EXPORT_TEMPLATE template ITPP_EXPORT vec elem_div(double t, const vec &v);
2017 ITPP_EXPORT_TEMPLATE template ITPP_EXPORT cvec elem_div(std::complex<double> t, const cvec &v);
2018 ITPP_EXPORT_TEMPLATE template ITPP_EXPORT ivec elem_div(int t, const ivec &v);
2019 ITPP_EXPORT_TEMPLATE template ITPP_EXPORT svec elem_div(short t, const svec &v);
2020 ITPP_EXPORT_TEMPLATE template ITPP_EXPORT bvec elem_div(bin t, const bvec &v);
2021 
2022 ITPP_EXPORT_TEMPLATE template ITPP_EXPORT void elem_div_out(const vec &a, const vec &b, vec &out);
2023 ITPP_EXPORT_TEMPLATE template ITPP_EXPORT void elem_div_out(const cvec &a, const cvec &b, cvec &out);
2024 ITPP_EXPORT_TEMPLATE template ITPP_EXPORT void elem_div_out(const ivec &a, const ivec &b, ivec &out);
2025 ITPP_EXPORT_TEMPLATE template ITPP_EXPORT void elem_div_out(const svec &a, const svec &b, svec &out);
2026 ITPP_EXPORT_TEMPLATE template ITPP_EXPORT void elem_div_out(const bvec &a, const bvec &b, bvec &out);
2027 
2028 // elementwise division followed by summation
2029 
2030 ITPP_EXPORT_TEMPLATE template ITPP_EXPORT double elem_div_sum(const vec &a, const vec &b);
2031 ITPP_EXPORT_TEMPLATE template ITPP_EXPORT std::complex<double> elem_div_sum(const cvec &a,
2032  const cvec &b);
2033 ITPP_EXPORT_TEMPLATE template ITPP_EXPORT int elem_div_sum(const ivec &a, const ivec &b);
2034 ITPP_EXPORT_TEMPLATE template ITPP_EXPORT short elem_div_sum(const svec &a, const svec &b);
2035 ITPP_EXPORT_TEMPLATE template ITPP_EXPORT bin elem_div_sum(const bvec &a, const bvec &b);
2036 
2037 // concat operator
2038 
2039 ITPP_EXPORT_TEMPLATE template ITPP_EXPORT vec concat(const vec &v, double a);
2040 ITPP_EXPORT_TEMPLATE template ITPP_EXPORT cvec concat(const cvec &v, std::complex<double> a);
2041 ITPP_EXPORT_TEMPLATE template ITPP_EXPORT ivec concat(const ivec &v, int a);
2042 ITPP_EXPORT_TEMPLATE template ITPP_EXPORT svec concat(const svec &v, short a);
2043 ITPP_EXPORT_TEMPLATE template ITPP_EXPORT bvec concat(const bvec &v, bin a);
2044 
2045 ITPP_EXPORT_TEMPLATE template ITPP_EXPORT vec concat(double a, const vec &v);
2046 ITPP_EXPORT_TEMPLATE template ITPP_EXPORT cvec concat(std::complex<double> a, const cvec &v);
2047 ITPP_EXPORT_TEMPLATE template ITPP_EXPORT ivec concat(int a, const ivec &v);
2048 ITPP_EXPORT_TEMPLATE template ITPP_EXPORT svec concat(short a, const svec &v);
2049 ITPP_EXPORT_TEMPLATE template ITPP_EXPORT bvec concat(bin a, const bvec &v);
2050 
2051 ITPP_EXPORT_TEMPLATE template ITPP_EXPORT vec concat(const vec &v1, const vec &v2);
2052 ITPP_EXPORT_TEMPLATE template ITPP_EXPORT cvec concat(const cvec &v1, const cvec &v2);
2053 ITPP_EXPORT_TEMPLATE template ITPP_EXPORT ivec concat(const ivec &v1, const ivec &v2);
2054 ITPP_EXPORT_TEMPLATE template ITPP_EXPORT svec concat(const svec &v1, const svec &v2);
2055 ITPP_EXPORT_TEMPLATE template ITPP_EXPORT bvec concat(const bvec &v1, const bvec &v2);
2056 
2057 ITPP_EXPORT_TEMPLATE template ITPP_EXPORT vec concat(const vec &v1, const vec &v2, const vec &v3);
2058 ITPP_EXPORT_TEMPLATE template ITPP_EXPORT cvec concat(const cvec &v1, const cvec &v2, const cvec &v3);
2059 ITPP_EXPORT_TEMPLATE template ITPP_EXPORT ivec concat(const ivec &v1, const ivec &v2, const ivec &v3);
2060 ITPP_EXPORT_TEMPLATE template ITPP_EXPORT svec concat(const svec &v1, const svec &v2, const svec &v3);
2061 ITPP_EXPORT_TEMPLATE template ITPP_EXPORT bvec concat(const bvec &v1, const bvec &v2, const bvec &v3);
2062 
2063 ITPP_EXPORT_TEMPLATE template ITPP_EXPORT vec concat(const vec &v1, const vec &v2,
2064  const vec &v3, const vec &v4);
2065 ITPP_EXPORT_TEMPLATE template ITPP_EXPORT cvec concat(const cvec &v1, const cvec &v2,
2066  const cvec &v3, const cvec &v4);
2067 ITPP_EXPORT_TEMPLATE template ITPP_EXPORT ivec concat(const ivec &v1, const ivec &v2,
2068  const ivec &v3, const ivec &v4);
2069 ITPP_EXPORT_TEMPLATE template ITPP_EXPORT svec concat(const svec &v1, const svec &v2,
2070  const svec &v3, const svec &v4);
2071 ITPP_EXPORT_TEMPLATE template ITPP_EXPORT bvec concat(const bvec &v1, const bvec &v2,
2072  const bvec &v3, const bvec &v4);
2073 
2074 ITPP_EXPORT_TEMPLATE template ITPP_EXPORT vec concat(const vec &v1, const vec &v2, const vec &v3,
2075  const vec &v4, const vec &v5);
2076 ITPP_EXPORT_TEMPLATE template ITPP_EXPORT cvec concat(const cvec &v1, const cvec &v2, const cvec &v3,
2077  const cvec &v4, const cvec &v5);
2078 ITPP_EXPORT_TEMPLATE template ITPP_EXPORT ivec concat(const ivec &v1, const ivec &v2, const ivec &v3,
2079  const ivec &v4, const ivec &v5);
2080 ITPP_EXPORT_TEMPLATE template ITPP_EXPORT svec concat(const svec &v1, const svec &v2, const svec &v3,
2081  const svec &v4, const svec &v5);
2082 ITPP_EXPORT_TEMPLATE template ITPP_EXPORT bvec concat(const bvec &v1, const bvec &v2, const bvec &v3,
2083  const bvec &v4, const bvec &v5);
2084 
2085 // I/O streams
2086 
2087 ITPP_EXPORT_TEMPLATE template ITPP_EXPORT std::ostream &operator<<(std::ostream& os, const vec &vect);
2088 ITPP_EXPORT_TEMPLATE template ITPP_EXPORT std::ostream &operator<<(std::ostream& os, const cvec &vect);
2089 ITPP_EXPORT_TEMPLATE template ITPP_EXPORT std::ostream &operator<<(std::ostream& os, const svec &vect);
2090 ITPP_EXPORT_TEMPLATE template ITPP_EXPORT std::ostream &operator<<(std::ostream& os, const ivec &vect);
2091 ITPP_EXPORT_TEMPLATE template ITPP_EXPORT std::ostream &operator<<(std::ostream& os, const bvec &vect);
2092 ITPP_EXPORT_TEMPLATE template ITPP_EXPORT std::istream &operator>>(std::istream& is, vec &vect);
2093 ITPP_EXPORT_TEMPLATE template ITPP_EXPORT std::istream &operator>>(std::istream& is, cvec &vect);
2094 ITPP_EXPORT_TEMPLATE template ITPP_EXPORT std::istream &operator>>(std::istream& is, svec &vect);
2095 ITPP_EXPORT_TEMPLATE template ITPP_EXPORT std::istream &operator>>(std::istream& is, ivec &vect);
2096 ITPP_EXPORT_TEMPLATE template ITPP_EXPORT std::istream &operator>>(std::istream& is, bvec &vect);
2097 
2099 
2100 } // namespace itpp
2101 
2102 #endif // #ifndef VEC_H
SourceForge Logo

Generated on Sat Jul 6 2013 10:54:22 for IT++ by Doxygen 1.8.2