IT++ 4.3.1
vec.h
Go to the documentation of this file.
1
28
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
39namespace itpp
40{
41
42// Declaration of Vec
43template<class Num_T> class Vec;
44// Declaration of Mat
45template<class Num_T> class Mat;
46// Declaration of bin
47class bin;
48
49//-----------------------------------------------------------------------------------
50// Declaration of Vec Friends
51//-----------------------------------------------------------------------------------
52
54template<class Num_T>
55Vec<Num_T> operator+(const Vec<Num_T> &v1, const Vec<Num_T> &v2);
57template<class Num_T>
58Vec<Num_T> operator+(const Vec<Num_T> &v, Num_T t);
60template<class Num_T>
61Vec<Num_T> operator+(Num_T t, const Vec<Num_T> &v);
62
64template<class Num_T>
65Vec<Num_T> operator-(const Vec<Num_T> &v1, const Vec<Num_T> &v2);
67template<class Num_T>
68Vec<Num_T> operator-(const Vec<Num_T> &v, Num_T t);
70template<class Num_T>
71Vec<Num_T> operator-(Num_T t, const Vec<Num_T> &v);
73template<class Num_T>
74Vec<Num_T> operator-(const Vec<Num_T> &v);
75
77template<class Num_T>
78Num_T dot(const Vec<Num_T> &v1, const Vec<Num_T> &v2);
80template<class Num_T>
81Num_T operator*(const Vec<Num_T> &v1, const Vec<Num_T> &v2);
90template<class Num_T>
91Mat<Num_T> outer_product(const Vec<Num_T> &v1, const Vec<Num_T> &v2,
92 bool hermitian = false);
94template<class Num_T>
95Vec<Num_T> operator*(const Vec<Num_T> &v, Num_T t);
97template<class Num_T>
98Vec<Num_T> operator*(Num_T t, const Vec<Num_T> &v);
99
101template<class Num_T>
102Vec<Num_T> elem_mult(const Vec<Num_T> &a, const Vec<Num_T> &b);
104template<class Num_T>
105Vec<Num_T> elem_mult(const Vec<Num_T> &a, const Vec<Num_T> &b,
106 const Vec<Num_T> &c);
108template<class Num_T>
109Vec<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
113template<class Num_T>
114void elem_mult_out(const Vec<Num_T> &a, const Vec<Num_T> &b,
115 Vec<Num_T> &out);
117template<class Num_T>
118void elem_mult_out(const Vec<Num_T> &a, const Vec<Num_T> &b,
119 const Vec<Num_T> &c, Vec<Num_T> &out);
121template<class Num_T>
122void 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
127template<class Num_T>
128void elem_mult_inplace(const Vec<Num_T> &a, Vec<Num_T> &b);
130template<class Num_T>
131Num_T elem_mult_sum(const Vec<Num_T> &a, const Vec<Num_T> &b);
132
134template<class Num_T>
135Vec<Num_T> operator/(const Vec<Num_T> &v, Num_T t);
137template<class Num_T>
138Vec<Num_T> operator/(Num_T t, const Vec<Num_T> &v);
139
141template<class Num_T>
142Vec<Num_T> elem_div(const Vec<Num_T> &a, const Vec<Num_T> &b);
144template<class Num_T>
145Vec<Num_T> elem_div(Num_T t, const Vec<Num_T> &v);
147template<class Num_T>
148void elem_div_out(const Vec<Num_T> &a, const Vec<Num_T> &b, Vec<Num_T> &out);
150template<class Num_T>
151Num_T elem_div_sum(const Vec<Num_T> &a, const Vec<Num_T> &b);
152
154template<class Num_T>
155Vec<Num_T> concat(const Vec<Num_T> &v, Num_T a);
157template<class Num_T>
158Vec<Num_T> concat(Num_T a, const Vec<Num_T> &v);
160template<class Num_T>
161Vec<Num_T> concat(const Vec<Num_T> &v1, const Vec<Num_T> &v2);
163template<class Num_T>
164Vec<Num_T> concat(const Vec<Num_T> &v1, const Vec<Num_T> &v2,
165 const Vec<Num_T> &v3);
167template<class Num_T>
168Vec<Num_T> concat(const Vec<Num_T> &v1, const Vec<Num_T> &v2,
169 const Vec<Num_T> &v3, const Vec<Num_T> &v4);
171template<class Num_T>
172Vec<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
243template<class Num_T>
244class Vec
245{
246public:
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(); }
320 Mat<Num_T> hermitian_transpose() const;
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
496protected:
498 void alloc(int size);
500 void free();
501
503 int datasize;
505 Num_T *data;
507 const Factory &factory;
508private:
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
529typedef Vec<double> vec;
530
535typedef Vec<std::complex<double> > cvec;
536
541typedef Vec<int> ivec;
542
547typedef Vec<short int> svec;
548
553typedef Vec<bin> bvec;
554
555} //namespace itpp
556
557
558#include <itpp/base/mat.h>
559
560namespace itpp
561{
562
563//-----------------------------------------------------------------------------------
564// Declaration of input and output streams for Vec
565//-----------------------------------------------------------------------------------
566
571template<class Num_T>
572std::ostream &operator<<(std::ostream &os, const Vec<Num_T> &v);
573
585template<class Num_T>
586std::istream &operator>>(std::istream &is, Vec<Num_T> &v);
587
588//-----------------------------------------------------------------------------------
589// Implementation of templated Vec members and friends
590//-----------------------------------------------------------------------------------
591
592template<class Num_T> inline
593void Vec<Num_T>::alloc(int size)
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
605template<class Num_T> inline
606void Vec<Num_T>::free()
607{
608 destroy_elements(data, datasize);
609 datasize = 0;
610}
611
612
613template<class Num_T> inline
614Vec<Num_T>::Vec(const Factory &f) : datasize(0), data(0), factory(f) {}
615
616template<class Num_T> inline
617Vec<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
623template<class Num_T> inline
624Vec<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
630template<class Num_T> inline
631Vec<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
637template<class Num_T> inline
638Vec<Num_T>::Vec(const char *str, const Factory &f) : datasize(0), data(0), factory(f)
639{
640 set(std::string(str));
641}
642
643template<class Num_T> inline
644Vec<Num_T>::Vec(const std::string &str, const Factory &f) : datasize(0), data(0), factory(f)
645{
646 set(str);
647}
648
649template<class Num_T> inline
650Vec<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
656template<class Num_T> inline
657Vec<Num_T>::~Vec()
658{
659 free();
660}
661
662template<class Num_T>
663void 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
691template<class Num_T> inline
692const 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
698template<class Num_T> inline
699const Num_T& Vec<Num_T>::operator()(int i) const
700{
701 return (*this)[i];
702}
703
704template<class Num_T> inline
705Num_T& Vec<Num_T>::operator[](int i)
706{
707 it_assert_debug(in_range(i), "Vec<>::operator[]: Index out of range");
708 return data[i];
709}
710
711template<class Num_T> inline
712Num_T& Vec<Num_T>::operator()(int i)
713{
714 return (*this)[i];
715}
716
717template<class Num_T> inline
718Vec<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
732template<class Num_T>
733Vec<Num_T> Vec<Num_T>::operator()(const Vec<int> &indexlist) const
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
745template<class Num_T>
746Vec<Num_T> Vec<Num_T>::operator()(const Vec<bin> &binlist) const
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
761template<class Num_T> inline
762const Num_T& Vec<Num_T>::get(int i) const
763{
764 return (*this)[i];
765}
766
767template<class Num_T> inline
768Vec<Num_T> Vec<Num_T>::get(int i1, int i2) const
769{
770 return (*this)(i1, i2);
771}
772
773template<class Num_T> inline
774Vec<Num_T> Vec<Num_T>::get(const Vec<int> &indexlist) const
775{
776 return (*this)(indexlist);
777}
778
779template<class Num_T> inline
780Vec<Num_T> Vec<Num_T>::get(const Vec<bin> &binlist) const
781{
782 return (*this)(binlist);
783}
784
785template<class Num_T> inline
786void Vec<Num_T>::zeros()
787{
788 for (int i = 0; i < datasize; i++)
789 data[i] = Num_T(0);
790}
791
792template<class Num_T> inline
793void Vec<Num_T>::ones()
794{
795 for (int i = 0; i < datasize; i++)
796 data[i] = Num_T(1);
797}
798
799template<class Num_T> inline
800void 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
806template<class Num_T> inline
807void 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
813template<class Num_T> inline
814void Vec<Num_T>::set(const char *str)
815{
816 set(std::string(str));
817}
818
820template<>
821ITPP_EXPORT void Vec<double>::set(const std::string &str);
822template<>
823ITPP_EXPORT void Vec<std::complex<double> >::set(const std::string &str);
824template<>
825ITPP_EXPORT void Vec<int>::set(const std::string &str);
826template<>
827ITPP_EXPORT void Vec<short int>::set(const std::string &str);
828template<>
829ITPP_EXPORT void Vec<bin>::set(const std::string &str);
831
832template<class Num_T>
833Mat<Num_T> Vec<Num_T>::transpose() const
834{
835 Mat<Num_T> temp(1, datasize);
836 copy_vector(datasize, data, temp._data());
837 return temp;
838}
839
840template<class Num_T>
841Mat<Num_T> Vec<Num_T>::hermitian_transpose() const
842{
843 Mat<Num_T> temp(1, datasize);
844 copy_vector(datasize, data, temp._data());
845 return temp;
846}
847
849template<>
850ITPP_EXPORT Mat<std::complex<double> > Vec<std::complex<double> >::hermitian_transpose() const;
852
853
854template<class Num_T>
855Vec<Num_T>& Vec<Num_T>::operator+=(const Vec<Num_T> &v)
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
871template<class Num_T> inline
872Vec<Num_T>& Vec<Num_T>::operator+=(Num_T t)
873{
874 for (int i = 0;i < datasize;i++)
875 data[i] += t;
876 return *this;
877}
878
879template<class Num_T>
880Vec<Num_T> operator+(const Vec<Num_T> &v1, const Vec<Num_T> &v2)
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
892template<class Num_T>
893Vec<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
904template<class Num_T>
905Vec<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
916template<class Num_T>
917Vec<Num_T>& Vec<Num_T>::operator-=(const Vec<Num_T> &v)
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
934template<class Num_T> inline
935Vec<Num_T>& Vec<Num_T>::operator-=(Num_T t)
936{
937 for (int i = 0;i < datasize;i++)
938 data[i] -= t;
939 return *this;
940}
941
942template<class Num_T>
943Vec<Num_T> operator-(const Vec<Num_T> &v1, const Vec<Num_T> &v2)
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
955template<class Num_T>
956Vec<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
967template<class Num_T>
968Vec<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
979template<class Num_T>
980Vec<Num_T> operator-(const Vec<Num_T> &v)
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
991template<class Num_T> inline
992Vec<Num_T>& Vec<Num_T>::operator*=(Num_T t)
993{
994 scal_vector(datasize, t, data);
995 return *this;
996}
997
998template<class Num_T> inline
999Num_T operator*(const Vec<Num_T> &v1, const Vec<Num_T> &v2)
1000{
1001 return dot(v1, v2);
1002}
1003
1004template<class Num_T>
1005Num_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
1015template<>
1016ITPP_EXPORT double dot(const vec &v1, const vec &v2);
1018
1019
1020template<class Num_T>
1021Mat<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
1036template<>
1037ITPP_EXPORT mat outer_product(const vec &v1, const vec &v2, bool);
1038
1039template<>
1040ITPP_EXPORT cmat outer_product(const cvec &v1, const cvec &v2, bool hermitian);
1042
1043template<class Num_T>
1044Vec<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
1054template<class Num_T> inline
1055Vec<Num_T> operator*(Num_T t, const Vec<Num_T> &v)
1056{
1057 return operator*(v, t);
1058}
1059
1060template<class Num_T> inline
1061Vec<Num_T> elem_mult(const Vec<Num_T> &a, const Vec<Num_T> &b)
1062{
1063 Vec<Num_T> out;
1064 elem_mult_out(a, b, out);
1065 return out;
1066}
1067
1068template<class Num_T> inline
1069Vec<Num_T> elem_mult(const Vec<Num_T> &a, const Vec<Num_T> &b,
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
1077template<class Num_T> inline
1078Vec<Num_T> elem_mult(const Vec<Num_T> &a, const Vec<Num_T> &b,
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
1086template<class Num_T>
1087void elem_mult_out(const Vec<Num_T> &a, const Vec<Num_T> &b, Vec<Num_T> &out)
1088{
1089 it_assert_debug(a.datasize == b.datasize,
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
1096template<class Num_T>
1097void 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
1107template<class Num_T>
1108void 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
1119template<class Num_T>
1120#ifndef _MSC_VER
1121inline
1122#endif
1123void elem_mult_inplace(const Vec<Num_T> &a, Vec<Num_T> &b)
1124{
1125 it_assert_debug(a.datasize == b.datasize,
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
1131template<class Num_T> inline
1132Num_T elem_mult_sum(const Vec<Num_T> &a, const Vec<Num_T> &b)
1133{
1134 it_assert_debug(a.datasize == b.datasize,
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
1142template<class Num_T>
1143Vec<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
1154template<class Num_T>
1155Vec<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
1166template<class Num_T>
1167Vec<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
1176template<class Num_T> inline
1177Vec<Num_T>& Vec<Num_T>::operator/=(Num_T t)
1178{
1179 for (int i = 0; i < datasize; ++i) {
1180 data[i] /= t;
1181 }
1182 return *this;
1183}
1184
1185template<class Num_T> inline
1186Vec<Num_T>& Vec<Num_T>::operator/=(const Vec<Num_T> &v)
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
1195template<class Num_T> inline
1196Vec<Num_T> elem_div(const Vec<Num_T> &a, const Vec<Num_T> &b)
1197{
1198 Vec<Num_T> out;
1199 elem_div_out(a, b, out);
1200 return out;
1201}
1202
1203template<class Num_T>
1204void 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
1214template<class Num_T> inline
1215Num_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
1227template<class Num_T>
1228Vec<Num_T> Vec<Num_T>::right(int nr) const
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
1238template<class Num_T>
1239Vec<Num_T> Vec<Num_T>::left(int nr) const
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
1249template<class Num_T>
1250Vec<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
1261template<class Num_T>
1262Vec<Num_T> Vec<Num_T>::split(int pos)
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
1281template<class Num_T>
1282void 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
1293template<class Num_T>
1294void Vec<Num_T>::shift_right(const Vec<Num_T> &v)
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
1302template<class Num_T>
1303void 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
1314template<class Num_T>
1315void Vec<Num_T>::shift_left(const Vec<Num_T> &v)
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
1323template<class Num_T>
1324Vec<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
1333template<class Num_T>
1334Vec<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
1343template<class Num_T>
1344Vec<Num_T> concat(const Vec<Num_T> &v1, const Vec<Num_T> &v2)
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
1354template<class Num_T>
1355Vec<Num_T> concat(const Vec<Num_T> &v1, const Vec<Num_T> &v2,
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
1368template<class Num_T>
1369Vec<Num_T> concat(const Vec<Num_T> &v1, const Vec<Num_T> &v2,
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
1384template<class Num_T>
1385Vec<Num_T> concat(const Vec<Num_T> &v1, const Vec<Num_T> &v2,
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
1403template<class Num_T>
1404void 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
1412template<class Num_T> inline
1413void Vec<Num_T>:: set_subvector(int i, const Vec<Num_T> &v)
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
1421template<class Num_T> inline
1422void 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
1433template<class Num_T> inline
1434void Vec<Num_T>::replace_mid(int i, const Vec<Num_T> &v)
1435{
1436 set_subvector(i, v);
1437}
1438
1439template<class Num_T>
1440void 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
1449template<class Num_T>
1450void 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
1463template<class Num_T>
1464void 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
1476template<class Num_T>
1477void 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
1489template<class Num_T> inline
1490Vec<Num_T>& Vec<Num_T>::operator=(Num_T t)
1491{
1492 for (int i = 0;i < datasize;i++)
1493 data[i] = t;
1494 return *this;
1495}
1496
1497template<class Num_T> inline
1498Vec<Num_T>& Vec<Num_T>::operator=(const Vec<Num_T> &v)
1499{
1500 if (this != &v) {
1501 set_size(v.datasize, false);
1502 copy_vector(datasize, v.data, data);
1503 }
1504 return *this;
1505}
1506
1507template<class Num_T>
1508Vec<Num_T>& Vec<Num_T>::operator=(const Mat<Num_T> &m)
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
1523template<class Num_T> inline
1524Vec<Num_T>& Vec<Num_T>::operator=(const char *str)
1525{
1526 set(std::string(str));
1527 return *this;
1528}
1529
1530template<class Num_T> inline
1531Vec<Num_T>& Vec<Num_T>::operator=(const std::string &str)
1532{
1533 set(str);
1534 return *this;
1535}
1536
1537template<class Num_T>
1538bvec 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
1547template<class Num_T>
1548bvec 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
1558template<>
1559bvec Vec<std::complex<double> >::operator<(std::complex<double>) const;
1561
1562template<class Num_T>
1563bvec 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
1572template<class Num_T>
1573bvec 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
1583template<>
1584ITPP_EXPORT bvec Vec<std::complex<double> >::operator<=(std::complex<double>) const;
1586
1587template<class Num_T>
1588bvec 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
1598template<>
1599ITPP_EXPORT bvec Vec<std::complex<double> >::operator>(std::complex<double>) const;
1601
1602template<class Num_T>
1603bvec 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
1613template<>
1614ITPP_EXPORT bvec Vec<std::complex<double> >::operator>=(std::complex<double>) const;
1616
1617template<class Num_T>
1618bool 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
1628template<class Num_T>
1629bool 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
1639template<class Num_T>
1640std::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
1656template<class Num_T>
1657std::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
1738template<class Num_T>
1739void 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
1757template<class Num_T>
1758Num_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
1765template<>
1766ITPP_EXPORT double Vec<double>::parse_token(const std::string &s) const;
1767template<>
1768ITPP_EXPORT int Vec<int>::parse_token(const std::string &s) const;
1770
1771template<class Num_T>
1772std::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// ----------------------------------------------------------------------
1839ITPP_EXPORT_TEMPLATE template class ITPP_EXPORT Vec<double>;
1840ITPP_EXPORT_TEMPLATE template class ITPP_EXPORT Vec<int>;
1841ITPP_EXPORT_TEMPLATE template class ITPP_EXPORT Vec<short int>;
1842ITPP_EXPORT_TEMPLATE template class ITPP_EXPORT Vec<std::complex<double> >;
1843ITPP_EXPORT_TEMPLATE template class ITPP_EXPORT Vec<bin>;
1844
1845// addition operator
1846
1847ITPP_EXPORT_TEMPLATE template ITPP_EXPORT vec operator+(const vec &v1, const vec &v2);
1848ITPP_EXPORT_TEMPLATE template ITPP_EXPORT cvec operator+(const cvec &v1, const cvec &v2);
1849ITPP_EXPORT_TEMPLATE template ITPP_EXPORT ivec operator+(const ivec &v1, const ivec &v2);
1850ITPP_EXPORT_TEMPLATE template ITPP_EXPORT svec operator+(const svec &v1, const svec &v2);
1851ITPP_EXPORT_TEMPLATE template ITPP_EXPORT bvec operator+(const bvec &v1, const bvec &v2);
1852
1853ITPP_EXPORT_TEMPLATE template ITPP_EXPORT vec operator+(const vec &v1, double t);
1854ITPP_EXPORT_TEMPLATE template ITPP_EXPORT cvec operator+(const cvec &v1, std::complex<double> t);
1855ITPP_EXPORT_TEMPLATE template ITPP_EXPORT ivec operator+(const ivec &v1, int t);
1856ITPP_EXPORT_TEMPLATE template ITPP_EXPORT svec operator+(const svec &v1, short t);
1857ITPP_EXPORT_TEMPLATE template ITPP_EXPORT bvec operator+(const bvec &v1, bin t);
1858
1859ITPP_EXPORT_TEMPLATE template ITPP_EXPORT vec operator+(double t, const vec &v1);
1860ITPP_EXPORT_TEMPLATE template ITPP_EXPORT cvec operator+(std::complex<double> t, const cvec &v1);
1861ITPP_EXPORT_TEMPLATE template ITPP_EXPORT ivec operator+(int t, const ivec &v1);
1862ITPP_EXPORT_TEMPLATE template ITPP_EXPORT svec operator+(short t, const svec &v1);
1863ITPP_EXPORT_TEMPLATE template ITPP_EXPORT bvec operator+(bin t, const bvec &v1);
1864
1865// subtraction operator
1866
1867ITPP_EXPORT_TEMPLATE template ITPP_EXPORT vec operator-(const vec &v1, const vec &v2);
1868ITPP_EXPORT_TEMPLATE template ITPP_EXPORT cvec operator-(const cvec &v1, const cvec &v2);
1869ITPP_EXPORT_TEMPLATE template ITPP_EXPORT ivec operator-(const ivec &v1, const ivec &v2);
1870ITPP_EXPORT_TEMPLATE template ITPP_EXPORT svec operator-(const svec &v1, const svec &v2);
1871ITPP_EXPORT_TEMPLATE template ITPP_EXPORT bvec operator-(const bvec &v1, const bvec &v2);
1872
1873ITPP_EXPORT_TEMPLATE template ITPP_EXPORT vec operator-(const vec &v, double t);
1874ITPP_EXPORT_TEMPLATE template ITPP_EXPORT cvec operator-(const cvec &v, std::complex<double> t);
1875ITPP_EXPORT_TEMPLATE template ITPP_EXPORT ivec operator-(const ivec &v, int t);
1876ITPP_EXPORT_TEMPLATE template ITPP_EXPORT svec operator-(const svec &v, short t);
1877ITPP_EXPORT_TEMPLATE template ITPP_EXPORT bvec operator-(const bvec &v, bin t);
1878
1879ITPP_EXPORT_TEMPLATE template ITPP_EXPORT vec operator-(double t, const vec &v);
1880ITPP_EXPORT_TEMPLATE template ITPP_EXPORT cvec operator-(std::complex<double> t, const cvec &v);
1881ITPP_EXPORT_TEMPLATE template ITPP_EXPORT ivec operator-(int t, const ivec &v);
1882ITPP_EXPORT_TEMPLATE template ITPP_EXPORT svec operator-(short t, const svec &v);
1883ITPP_EXPORT_TEMPLATE template ITPP_EXPORT bvec operator-(bin t, const bvec &v);
1884
1885// unary minus
1886
1887ITPP_EXPORT_TEMPLATE template ITPP_EXPORT vec operator-(const vec &v);
1888ITPP_EXPORT_TEMPLATE template ITPP_EXPORT cvec operator-(const cvec &v);
1889ITPP_EXPORT_TEMPLATE template ITPP_EXPORT ivec operator-(const ivec &v);
1890ITPP_EXPORT_TEMPLATE template ITPP_EXPORT svec operator-(const svec &v);
1891ITPP_EXPORT_TEMPLATE template ITPP_EXPORT bvec operator-(const bvec &v);
1892
1893// multiplication operator
1894ITPP_EXPORT_TEMPLATE template ITPP_EXPORT std::complex<double> dot(const cvec &v1, const cvec &v2);
1895ITPP_EXPORT_TEMPLATE template ITPP_EXPORT int dot(const ivec &v1, const ivec &v2);
1896ITPP_EXPORT_TEMPLATE template ITPP_EXPORT short dot(const svec &v1, const svec &v2);
1897ITPP_EXPORT_TEMPLATE template ITPP_EXPORT bin dot(const bvec &v1, const bvec &v2);
1898
1899ITPP_EXPORT_TEMPLATE template ITPP_EXPORT double operator*(const vec &v1, const vec &v2);
1900ITPP_EXPORT_TEMPLATE template ITPP_EXPORT std::complex<double> operator*(const cvec &v1, const cvec &v2);
1901ITPP_EXPORT_TEMPLATE template ITPP_EXPORT int operator*(const ivec &v1, const ivec &v2);
1902ITPP_EXPORT_TEMPLATE template ITPP_EXPORT short operator*(const svec &v1, const svec &v2);
1903ITPP_EXPORT_TEMPLATE template ITPP_EXPORT bin operator*(const bvec &v1, const bvec &v2);
1904
1905ITPP_EXPORT_TEMPLATE template ITPP_EXPORT imat outer_product(const ivec &v1, const ivec &v2,
1906 bool hermitian);
1907ITPP_EXPORT_TEMPLATE template ITPP_EXPORT smat outer_product(const svec &v1, const svec &v2,
1908 bool hermitian);
1909ITPP_EXPORT_TEMPLATE template ITPP_EXPORT bmat outer_product(const bvec &v1, const bvec &v2,
1910 bool hermitian);
1911
1912ITPP_EXPORT_TEMPLATE template ITPP_EXPORT vec operator*(const vec &v, double t);
1913ITPP_EXPORT_TEMPLATE template ITPP_EXPORT cvec operator*(const cvec &v, std::complex<double> t);
1914ITPP_EXPORT_TEMPLATE template ITPP_EXPORT ivec operator*(const ivec &v, int t);
1915ITPP_EXPORT_TEMPLATE template ITPP_EXPORT svec operator*(const svec &v, short t);
1916ITPP_EXPORT_TEMPLATE template ITPP_EXPORT bvec operator*(const bvec &v, bin t);
1917
1918ITPP_EXPORT_TEMPLATE template ITPP_EXPORT vec operator*(double t, const vec &v);
1919ITPP_EXPORT_TEMPLATE template ITPP_EXPORT cvec operator*(std::complex<double> t, const cvec &v);
1920ITPP_EXPORT_TEMPLATE template ITPP_EXPORT ivec operator*(int t, const ivec &v);
1921ITPP_EXPORT_TEMPLATE template ITPP_EXPORT svec operator*(short t, const svec &v);
1922ITPP_EXPORT_TEMPLATE template ITPP_EXPORT bvec operator*(bin t, const bvec &v);
1923
1924// elementwise multiplication
1925
1926ITPP_EXPORT_TEMPLATE template ITPP_EXPORT vec elem_mult(const vec &a, const vec &b);
1927ITPP_EXPORT_TEMPLATE template ITPP_EXPORT cvec elem_mult(const cvec &a, const cvec &b);
1928ITPP_EXPORT_TEMPLATE template ITPP_EXPORT ivec elem_mult(const ivec &a, const ivec &b);
1929ITPP_EXPORT_TEMPLATE template ITPP_EXPORT svec elem_mult(const svec &a, const svec &b);
1930ITPP_EXPORT_TEMPLATE template ITPP_EXPORT bvec elem_mult(const bvec &a, const bvec &b);
1931
1932ITPP_EXPORT_TEMPLATE template ITPP_EXPORT void elem_mult_out(const vec &a, const vec &b, vec &out);
1933ITPP_EXPORT_TEMPLATE template ITPP_EXPORT void elem_mult_out(const cvec &a, const cvec &b, cvec &out);
1934ITPP_EXPORT_TEMPLATE template ITPP_EXPORT void elem_mult_out(const ivec &a, const ivec &b, ivec &out);
1935ITPP_EXPORT_TEMPLATE template ITPP_EXPORT void elem_mult_out(const svec &a, const svec &b, svec &out);
1936ITPP_EXPORT_TEMPLATE template ITPP_EXPORT void elem_mult_out(const bvec &a, const bvec &b, bvec &out);
1937
1938ITPP_EXPORT_TEMPLATE template ITPP_EXPORT vec elem_mult(const vec &a, const vec &b, const vec &c);
1939ITPP_EXPORT_TEMPLATE template ITPP_EXPORT cvec elem_mult(const cvec &a, const cvec &b, const cvec &c);
1940ITPP_EXPORT_TEMPLATE template ITPP_EXPORT ivec elem_mult(const ivec &a, const ivec &b, const ivec &c);
1941ITPP_EXPORT_TEMPLATE template ITPP_EXPORT svec elem_mult(const svec &a, const svec &b, const svec &c);
1942ITPP_EXPORT_TEMPLATE template ITPP_EXPORT bvec elem_mult(const bvec &a, const bvec &b, const bvec &c);
1943
1944ITPP_EXPORT_TEMPLATE template ITPP_EXPORT void elem_mult_out(const vec &a, const vec &b,
1945 const vec &c, vec &out);
1946ITPP_EXPORT_TEMPLATE template ITPP_EXPORT void elem_mult_out(const cvec &a, const cvec &b,
1947 const cvec &c, cvec &out);
1948ITPP_EXPORT_TEMPLATE template ITPP_EXPORT void elem_mult_out(const ivec &a, const ivec &b,
1949 const ivec &c, ivec &out);
1950ITPP_EXPORT_TEMPLATE template ITPP_EXPORT void elem_mult_out(const svec &a, const svec &b,
1951 const svec &c, svec &out);
1952ITPP_EXPORT_TEMPLATE template ITPP_EXPORT void elem_mult_out(const bvec &a, const bvec &b,
1953 const bvec &c, bvec &out);
1954
1955ITPP_EXPORT_TEMPLATE template ITPP_EXPORT vec elem_mult(const vec &a, const vec &b,
1956 const vec &c, const vec &d);
1957ITPP_EXPORT_TEMPLATE template ITPP_EXPORT cvec elem_mult(const cvec &a, const cvec &b,
1958 const cvec &c, const cvec &d);
1959ITPP_EXPORT_TEMPLATE template ITPP_EXPORT ivec elem_mult(const ivec &a, const ivec &b,
1960 const ivec &c, const ivec &d);
1961ITPP_EXPORT_TEMPLATE template ITPP_EXPORT svec elem_mult(const svec &a, const svec &b,
1962 const svec &c, const svec &d);
1963ITPP_EXPORT_TEMPLATE template ITPP_EXPORT bvec elem_mult(const bvec &a, const bvec &b,
1964 const bvec &c, const bvec &d);
1965
1966ITPP_EXPORT_TEMPLATE template ITPP_EXPORT void elem_mult_out(const vec &a, const vec &b, const vec &c,
1967 const vec &d, vec &out);
1968ITPP_EXPORT_TEMPLATE template ITPP_EXPORT void elem_mult_out(const cvec &a, const cvec &b,
1969 const cvec &c, const cvec &d, cvec &out);
1970ITPP_EXPORT_TEMPLATE template ITPP_EXPORT void elem_mult_out(const ivec &a, const ivec &b,
1971 const ivec &c, const ivec &d, ivec &out);
1972ITPP_EXPORT_TEMPLATE template ITPP_EXPORT void elem_mult_out(const svec &a, const svec &b,
1973 const svec &c, const svec &d, svec &out);
1974ITPP_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
1979ITPP_EXPORT_TEMPLATE template ITPP_EXPORT void elem_mult_inplace(const vec &a, vec &b);
1980ITPP_EXPORT_TEMPLATE template ITPP_EXPORT void elem_mult_inplace(const cvec &a, cvec &b);
1981ITPP_EXPORT_TEMPLATE template ITPP_EXPORT void elem_mult_inplace(const ivec &a, ivec &b);
1982ITPP_EXPORT_TEMPLATE template ITPP_EXPORT void elem_mult_inplace(const svec &a, svec &b);
1983ITPP_EXPORT_TEMPLATE template ITPP_EXPORT void elem_mult_inplace(const bvec &a, bvec &b);
1984
1985// elementwise multiplication followed by summation
1986
1987ITPP_EXPORT_TEMPLATE template ITPP_EXPORT double elem_mult_sum(const vec &a, const vec &b);
1988ITPP_EXPORT_TEMPLATE template ITPP_EXPORT std::complex<double> elem_mult_sum(const cvec &a,
1989 const cvec &b);
1990ITPP_EXPORT_TEMPLATE template ITPP_EXPORT int elem_mult_sum(const ivec &a, const ivec &b);
1991ITPP_EXPORT_TEMPLATE template ITPP_EXPORT short elem_mult_sum(const svec &a, const svec &b);
1992ITPP_EXPORT_TEMPLATE template ITPP_EXPORT bin elem_mult_sum(const bvec &a, const bvec &b);
1993
1994// division operator
1995
1996ITPP_EXPORT_TEMPLATE template ITPP_EXPORT vec operator/(const vec &v, double t);
1997ITPP_EXPORT_TEMPLATE template ITPP_EXPORT cvec operator/(const cvec &v, std::complex<double> t);
1998ITPP_EXPORT_TEMPLATE template ITPP_EXPORT ivec operator/(const ivec &v, int t);
1999ITPP_EXPORT_TEMPLATE template ITPP_EXPORT svec operator/(const svec &v, short t);
2000ITPP_EXPORT_TEMPLATE template ITPP_EXPORT bvec operator/(const bvec &v, bin t);
2001
2002ITPP_EXPORT_TEMPLATE template ITPP_EXPORT vec operator/(double t, const vec &v);
2003ITPP_EXPORT_TEMPLATE template ITPP_EXPORT cvec operator/(std::complex<double> t, const cvec &v);
2004ITPP_EXPORT_TEMPLATE template ITPP_EXPORT ivec operator/(int t, const ivec &v);
2005ITPP_EXPORT_TEMPLATE template ITPP_EXPORT svec operator/(short t, const svec &v);
2006ITPP_EXPORT_TEMPLATE template ITPP_EXPORT bvec operator/(bin t, const bvec &v);
2007
2008// elementwise division operator
2009
2010ITPP_EXPORT_TEMPLATE template ITPP_EXPORT vec elem_div(const vec &a, const vec &b);
2011ITPP_EXPORT_TEMPLATE template ITPP_EXPORT cvec elem_div(const cvec &a, const cvec &b);
2012ITPP_EXPORT_TEMPLATE template ITPP_EXPORT ivec elem_div(const ivec &a, const ivec &b);
2013ITPP_EXPORT_TEMPLATE template ITPP_EXPORT svec elem_div(const svec &a, const svec &b);
2014ITPP_EXPORT_TEMPLATE template ITPP_EXPORT bvec elem_div(const bvec &a, const bvec &b);
2015
2016ITPP_EXPORT_TEMPLATE template ITPP_EXPORT vec elem_div(double t, const vec &v);
2017ITPP_EXPORT_TEMPLATE template ITPP_EXPORT cvec elem_div(std::complex<double> t, const cvec &v);
2018ITPP_EXPORT_TEMPLATE template ITPP_EXPORT ivec elem_div(int t, const ivec &v);
2019ITPP_EXPORT_TEMPLATE template ITPP_EXPORT svec elem_div(short t, const svec &v);
2020ITPP_EXPORT_TEMPLATE template ITPP_EXPORT bvec elem_div(bin t, const bvec &v);
2021
2022ITPP_EXPORT_TEMPLATE template ITPP_EXPORT void elem_div_out(const vec &a, const vec &b, vec &out);
2023ITPP_EXPORT_TEMPLATE template ITPP_EXPORT void elem_div_out(const cvec &a, const cvec &b, cvec &out);
2024ITPP_EXPORT_TEMPLATE template ITPP_EXPORT void elem_div_out(const ivec &a, const ivec &b, ivec &out);
2025ITPP_EXPORT_TEMPLATE template ITPP_EXPORT void elem_div_out(const svec &a, const svec &b, svec &out);
2026ITPP_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
2030ITPP_EXPORT_TEMPLATE template ITPP_EXPORT double elem_div_sum(const vec &a, const vec &b);
2031ITPP_EXPORT_TEMPLATE template ITPP_EXPORT std::complex<double> elem_div_sum(const cvec &a,
2032 const cvec &b);
2033ITPP_EXPORT_TEMPLATE template ITPP_EXPORT int elem_div_sum(const ivec &a, const ivec &b);
2034ITPP_EXPORT_TEMPLATE template ITPP_EXPORT short elem_div_sum(const svec &a, const svec &b);
2035ITPP_EXPORT_TEMPLATE template ITPP_EXPORT bin elem_div_sum(const bvec &a, const bvec &b);
2036
2037// concat operator
2038
2039ITPP_EXPORT_TEMPLATE template ITPP_EXPORT vec concat(const vec &v, double a);
2040ITPP_EXPORT_TEMPLATE template ITPP_EXPORT cvec concat(const cvec &v, std::complex<double> a);
2041ITPP_EXPORT_TEMPLATE template ITPP_EXPORT ivec concat(const ivec &v, int a);
2042ITPP_EXPORT_TEMPLATE template ITPP_EXPORT svec concat(const svec &v, short a);
2043ITPP_EXPORT_TEMPLATE template ITPP_EXPORT bvec concat(const bvec &v, bin a);
2044
2045ITPP_EXPORT_TEMPLATE template ITPP_EXPORT vec concat(double a, const vec &v);
2046ITPP_EXPORT_TEMPLATE template ITPP_EXPORT cvec concat(std::complex<double> a, const cvec &v);
2047ITPP_EXPORT_TEMPLATE template ITPP_EXPORT ivec concat(int a, const ivec &v);
2048ITPP_EXPORT_TEMPLATE template ITPP_EXPORT svec concat(short a, const svec &v);
2049ITPP_EXPORT_TEMPLATE template ITPP_EXPORT bvec concat(bin a, const bvec &v);
2050
2051ITPP_EXPORT_TEMPLATE template ITPP_EXPORT vec concat(const vec &v1, const vec &v2);
2052ITPP_EXPORT_TEMPLATE template ITPP_EXPORT cvec concat(const cvec &v1, const cvec &v2);
2053ITPP_EXPORT_TEMPLATE template ITPP_EXPORT ivec concat(const ivec &v1, const ivec &v2);
2054ITPP_EXPORT_TEMPLATE template ITPP_EXPORT svec concat(const svec &v1, const svec &v2);
2055ITPP_EXPORT_TEMPLATE template ITPP_EXPORT bvec concat(const bvec &v1, const bvec &v2);
2056
2057ITPP_EXPORT_TEMPLATE template ITPP_EXPORT vec concat(const vec &v1, const vec &v2, const vec &v3);
2058ITPP_EXPORT_TEMPLATE template ITPP_EXPORT cvec concat(const cvec &v1, const cvec &v2, const cvec &v3);
2059ITPP_EXPORT_TEMPLATE template ITPP_EXPORT ivec concat(const ivec &v1, const ivec &v2, const ivec &v3);
2060ITPP_EXPORT_TEMPLATE template ITPP_EXPORT svec concat(const svec &v1, const svec &v2, const svec &v3);
2061ITPP_EXPORT_TEMPLATE template ITPP_EXPORT bvec concat(const bvec &v1, const bvec &v2, const bvec &v3);
2062
2063ITPP_EXPORT_TEMPLATE template ITPP_EXPORT vec concat(const vec &v1, const vec &v2,
2064 const vec &v3, const vec &v4);
2065ITPP_EXPORT_TEMPLATE template ITPP_EXPORT cvec concat(const cvec &v1, const cvec &v2,
2066 const cvec &v3, const cvec &v4);
2067ITPP_EXPORT_TEMPLATE template ITPP_EXPORT ivec concat(const ivec &v1, const ivec &v2,
2068 const ivec &v3, const ivec &v4);
2069ITPP_EXPORT_TEMPLATE template ITPP_EXPORT svec concat(const svec &v1, const svec &v2,
2070 const svec &v3, const svec &v4);
2071ITPP_EXPORT_TEMPLATE template ITPP_EXPORT bvec concat(const bvec &v1, const bvec &v2,
2072 const bvec &v3, const bvec &v4);
2073
2074ITPP_EXPORT_TEMPLATE template ITPP_EXPORT vec concat(const vec &v1, const vec &v2, const vec &v3,
2075 const vec &v4, const vec &v5);
2076ITPP_EXPORT_TEMPLATE template ITPP_EXPORT cvec concat(const cvec &v1, const cvec &v2, const cvec &v3,
2077 const cvec &v4, const cvec &v5);
2078ITPP_EXPORT_TEMPLATE template ITPP_EXPORT ivec concat(const ivec &v1, const ivec &v2, const ivec &v3,
2079 const ivec &v4, const ivec &v5);
2080ITPP_EXPORT_TEMPLATE template ITPP_EXPORT svec concat(const svec &v1, const svec &v2, const svec &v3,
2081 const svec &v4, const svec &v5);
2082ITPP_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
2087ITPP_EXPORT_TEMPLATE template ITPP_EXPORT std::ostream &operator<<(std::ostream& os, const vec &vect);
2088ITPP_EXPORT_TEMPLATE template ITPP_EXPORT std::ostream &operator<<(std::ostream& os, const cvec &vect);
2089ITPP_EXPORT_TEMPLATE template ITPP_EXPORT std::ostream &operator<<(std::ostream& os, const svec &vect);
2090ITPP_EXPORT_TEMPLATE template ITPP_EXPORT std::ostream &operator<<(std::ostream& os, const ivec &vect);
2091ITPP_EXPORT_TEMPLATE template ITPP_EXPORT std::ostream &operator<<(std::ostream& os, const bvec &vect);
2092ITPP_EXPORT_TEMPLATE template ITPP_EXPORT std::istream &operator>>(std::istream& is, vec &vect);
2093ITPP_EXPORT_TEMPLATE template ITPP_EXPORT std::istream &operator>>(std::istream& is, cvec &vect);
2094ITPP_EXPORT_TEMPLATE template ITPP_EXPORT std::istream &operator>>(std::istream& is, svec &vect);
2095ITPP_EXPORT_TEMPLATE template ITPP_EXPORT std::istream &operator>>(std::istream& is, ivec &vect);
2096ITPP_EXPORT_TEMPLATE template ITPP_EXPORT std::istream &operator>>(std::istream& is, bvec &vect);
2097
2099
2100} // namespace itpp
2101
2102#endif // #ifndef VEC_H
itpp::Factory
Base class for class factories.
Definition factory.h:130
itpp::Mat
Matrix Class (Templated).
Definition mat.h:202
itpp::Mat::rows
int rows() const
The number of rows.
Definition mat.h:237
itpp::Mat::cols
int cols() const
The number of columns.
Definition mat.h:235
itpp::Mat::_data
Num_T * _data()
Access of the internal data structure (not recommended to use).
Definition mat.h:440
itpp::Vec
Vector Class (Templated).
Definition vec.h:245
itpp::Vec::vec
Vec< double > vec
Definition of double vector type.
Definition vec.h:529
itpp::Vec::operator=
Vec< Num_T > & operator=(const char *str)
Assign vector the values in the string str.
Definition vec.h:1524
itpp::Vec::get
Vec< Num_T > get(const Vec< int > &indexlist) const
Get the elements given by the list of indices indexlist.
Definition vec.h:774
itpp::Vec::operator+=
Vec< Num_T > & operator+=(Num_T t)
Addition of scalar.
Definition vec.h:872
itpp::Vec::operator=
Vec< Num_T > & operator=(Num_T t)
Assign all elements in vector to t.
Definition vec.h:1490
itpp::Vec::H
Mat< Num_T > H() const
Hermitian matrix transpose. Converts to a matrix with the conjugate of the vector in the first row.
Definition vec.h:322
itpp::Vec< double >::operator-
friend Vec< double > operator-(const Vec< double > &v1, const Vec< double > &v2)
itpp::Vec< double >::operator<
Vec< bin > operator<(double t) const
itpp::Vec::_elem
Num_T & _elem(int i)
Index operator without boundary check. Not recommended for use.
Definition vec.h:487
itpp::Vec::shift_left
void shift_left(Num_T t, int n=1)
Shift out the n left elements and at the same time shift in the element t at last position n times.
Definition vec.h:1303
itpp::Vec< double >::concat
friend Vec< double > concat(const Vec< double > &v, double t)
itpp::Vec< double >::operator*
friend Vec< double > operator*(const Vec< double > &v, double t)
itpp::Vec::operator+=
Vec< Num_T > & operator+=(const Vec< Num_T > &v)
Addition of vector.
Definition vec.h:855
itpp::Vec::operator=
Vec< Num_T > & operator=(const std::string &str)
Assign vector the values in the string str.
Definition vec.h:1531
itpp::Vec::operator/=
Vec< Num_T > & operator/=(Num_T t)
Elementwise division.
Definition vec.h:1177
itpp::Vec::del
void del(int i)
Delete element number i.
Definition vec.h:1440
itpp::Vec::set
void set(const char *str)
Set the vector equal to the values in the str string.
Definition vec.h:814
itpp::Vec::~Vec
~Vec()
Destructor.
Definition vec.h:657
itpp::Vec::ins
void ins(int i, Num_T t)
Insert element t before element with index i (0 <= i <= datasize).
Definition vec.h:1464
itpp::Vec::ins
void ins(int i, const Vec< Num_T > &v)
Insert vector v before element with index i (0 <= i <= datasize).
Definition vec.h:1477
itpp::Vec::value_type
Num_T value_type
The type of the vector values.
Definition vec.h:248
itpp::Vec::shift_right
void shift_right(Num_T t, int n=1)
Shift in element t at position 0 n times.
Definition vec.h:1282
itpp::Vec::_elem
const Num_T & _elem(int i) const
Index operator without boundary check. Not recommended for use.
Definition vec.h:489
itpp::Vec::operator>
Vec< bin > operator>(Num_T t) const
Elementwise greater than the scalar t.
Definition vec.h:1588
itpp::Vec::operator==
Vec< bin > operator==(Num_T t) const
Elementwise equal to the scalar t.
Definition vec.h:1538
itpp::Vec::transpose
Mat< Num_T > transpose() const
Matrix transpose. Converts to a matrix with the vector in the first row.
Definition vec.h:833
itpp::Vec::free
void free()
Free the storage space allocated by the vector.
Definition vec.h:606
itpp::Vec::_data
const Num_T * _data() const
Get the pointer to the internal structure. Not recommended for use.
Definition vec.h:494
itpp::Vec< double >::elem_div_sum
friend double elem_div_sum(const Vec< double > &a, const Vec< double > &b)
itpp::Vec::operator>=
Vec< bin > operator>=(Num_T t) const
Elementwise greater than and equal to the scalar t.
Definition vec.h:1603
itpp::Vec< double >::operator+
friend Vec< double > operator+(const Vec< double > &v1, const Vec< double > &v2)
itpp::Vec::shift_left
void shift_left(const Vec< Num_T > &v)
Shift in vector v at last positions.
Definition vec.h:1315
itpp::Vec< double >::elem_div_out
friend void elem_div_out(const Vec< double > &v1, const Vec< double > &v2, Vec< double > &out)
itpp::Vec< double >::operator/
friend Vec< double > operator/(const Vec< double > &v, double t)
itpp::Vec::get
Vec< Num_T > get(const Vec< bin > &binlist) const
Get the elements with indexes where binlist is 1.
Definition vec.h:780
itpp::Vec::operator*=
Vec< Num_T > & operator*=(Num_T t)
Multiply with a scalar.
Definition vec.h:992
itpp::Vec::Vec
Vec(int size, const Factory &f=DEFAULT_FACTORY)
Constructor with size parameter. An element factory f can be specified.
Definition vec.h:617
itpp::Vec::operator()
Vec< Num_T > operator()(const Vec< bin > &binlist) const
Sub-vector with elements with indexes where binlist is 1.
Definition vec.h:746
itpp::Vec::_data
Num_T * _data()
Get the pointer to the internal structure. Not recommended for use.
Definition vec.h:492
itpp::Vec< double >::elem_mult_out
friend void elem_mult_out(const Vec< double > &a, const Vec< double > &b, Vec< double > &out)
itpp::Vec< double >::size
int size() const
Definition vec.h:271
itpp::Vec::operator==
bool operator==(const Vec< Num_T > &v) const
Compare with vector v. Return false if sizes or values differ.
Definition vec.h:1618
itpp::Vec::operator=
Vec< Num_T > & operator=(const Mat< Num_T > &m)
Assign vector equal to the 1-dimensional matrix m.
Definition vec.h:1508
itpp::Vec::del
void del(int i1, int i2)
Delete elements from i1 to i2.
Definition vec.h:1450
itpp::Vec::replace_mid
void replace_mid(int i, const Vec< Num_T > &v)
An alias function of set_subvector(i, &v).
Definition vec.h:1434
itpp::Vec< double >::data
double * data
Definition vec.h:505
itpp::Vec::clear
void clear()
Set the vector to the all zero vector.
Definition vec.h:280
itpp::Vec< double >::operator<=
Vec< bin > operator<=(double t) const
itpp::Vec::operator()
Vec< Num_T > operator()(const Vec< int > &indexlist) const
Sub-vector with elements given by the list of indices indexlist.
Definition vec.h:733
itpp::Vec::operator[]
Num_T & operator[](int i)
C-style index operator. First element is 0.
Definition vec.h:705
itpp::Vec< double >::svec
Vec< short int > svec
Definition vec.h:547
itpp::Vec< double >::elem_mult
friend Vec< double > elem_mult(const Vec< double > &a, const Vec< double > &b)
itpp::Vec::set_subvector
void set_subvector(int i, const Vec< Num_T > &v)
Set subvector to elements of vector v starting from element i.
Definition vec.h:1413
itpp::Vec::operator!=
bool operator!=(const Vec< Num_T > &v) const
Compare with vector v. Return true if sizes or values differ.
Definition vec.h:1629
itpp::Vec::operator=
Vec< Num_T > & operator=(const Vec< Num_T > &v)
Assign vector the value and length of v.
Definition vec.h:1498
itpp::Vec::mid
Vec< Num_T > mid(int start, int nr) const
Get the middle part of vector from start including nr elements.
Definition vec.h:1250
itpp::Vec::zeros
void zeros()
Set the vector to the all zero vector.
Definition vec.h:786
itpp::Vec::shift_right
void shift_right(const Vec< Num_T > &v)
Shift in vector v at position 0.
Definition vec.h:1294
itpp::Vec::ones
void ones()
Set the vector to the all one vector.
Definition vec.h:793
itpp::Vec::get
const Num_T & get(int i) const
Accessor-style method. First element is 0.
Definition vec.h:762
itpp::Vec::split
Vec< Num_T > split(int pos)
Split the vector into two parts at element pos.
Definition vec.h:1262
itpp::Vec::set_size
void set_size(int size, bool copy=false)
Set length of vector. if copy = true then keeping the old values.
Definition vec.h:663
itpp::Vec::Vec
Vec(const Vec< Num_T > &v)
Copy constructor.
Definition vec.h:624
itpp::Vec< double >::elem_mult_sum
friend double elem_mult_sum(const Vec< double > &a, const Vec< double > &b)
itpp::Vec< double >::ivec
Vec< int > ivec
Definition vec.h:541
itpp::Vec::Vec
Vec(const Vec< Num_T > &v, const Factory &f)
Copy constructor, which takes an element factory f as an additional argument.
Definition vec.h:631
itpp::Vec< double >::elem_mult_inplace
friend void elem_mult_inplace(const Vec< double > &a, Vec< double > &b)
itpp::Vec::Vec
Vec(const char *str, const Factory &f=DEFAULT_FACTORY)
Constructor taking a char string as input. An element factory f can be specified.
Definition vec.h:638
itpp::Vec::operator<<
std::ostream & operator<<(std::ostream &os, const Vec< Num_T > &v)
Stream output of vector.
Definition vec.h:1640
itpp::Vec< double >::factory
const Factory & factory
Definition vec.h:507
itpp::Vec::operator-=
Vec< Num_T > & operator-=(const Vec< Num_T > &v)
Subtraction of vector.
Definition vec.h:917
itpp::Vec::right
Vec< Num_T > right(int nr) const
Get the right nr elements from the vector.
Definition vec.h:1228
itpp::Vec::set
void set(const std::string &str)
Set the vector equal to the values in the str string.
Definition vec.h:807
itpp::Vec::operator[]
const Num_T & operator[](int i) const
C-style index operator. First element is 0.
Definition vec.h:692
itpp::Vec::get
Vec< Num_T > get(int i1, int i2) const
Get the elements from i1 to i2. Index -1 indicates the last element.
Definition vec.h:768
itpp::Vec::operator()
const Num_T & operator()(int i) const
Index operator. First element is 0.
Definition vec.h:699
itpp::Vec::alloc
void alloc(int size)
Allocate storage for a vector of length size.
Definition vec.h:593
itpp::Vec::set_length
void set_length(int size, bool copy=false)
Set length of vector. if copy = true then keeping the old values.
Definition vec.h:276
itpp::Vec::operator>>
std::istream & operator>>(std::istream &is, Vec< Num_T > &v)
Stream input of vector.
Definition vec.h:1657
itpp::Vec::T
Mat< Num_T > T() const
Matrix transpose. Converts to a matrix with the vector in the first row.
Definition vec.h:318
itpp::Vec::operator/=
Vec< Num_T > & operator/=(const Vec< Num_T > &v)
Elementwise division.
Definition vec.h:1186
itpp::Vec::Vec
Vec(const Factory &f=DEFAULT_FACTORY)
Default constructor. An element factory f can be specified.
Definition vec.h:614
itpp::Vec::set_subvector
void set_subvector(int i1, int i2, Num_T t)
Set subvector defined by indices i1 and i2 to t.
Definition vec.h:1422
itpp::Vec::set
void set(int i, Num_T t)
Modifier-style method. First element is 0.
Definition vec.h:800
itpp::Vec< double >::bvec
Vec< bin > bvec
Definition vec.h:553
itpp::Vec::Vec
Vec(const Num_T *c_array, int size, const Factory &f=DEFAULT_FACTORY)
Constructor taking a C-array as input. Copies all data. An element factory f can be specified.
Definition vec.h:650
itpp::Vec::operator()
Num_T & operator()(int i)
Index operator. First element is 0.
Definition vec.h:712
itpp::Vec< double >::cvec
Vec< std::complex< double > > cvec
Definition vec.h:535
itpp::Vec::length
int length() const
The size of the vector.
Definition vec.h:269
itpp::Vec::operator-=
Vec< Num_T > & operator-=(Num_T t)
Subtraction of scalar.
Definition vec.h:935
itpp::Vec::operator!=
Vec< bin > operator!=(Num_T t) const
Elementwise not-equal to the scalar t.
Definition vec.h:1548
itpp::Vec::Vec
Vec(const std::string &str, const Factory &f=DEFAULT_FACTORY)
Constructor taking a string as input. An element factory f can be specified.
Definition vec.h:644
itpp::Vec::operator()
Vec< Num_T > operator()(int i1, int i2) const
Sub-vector with elements from i1 to i2. Index -1 indicates the last element.
Definition vec.h:718
itpp::Vec::hermitian_transpose
Mat< Num_T > hermitian_transpose() const
Hermitian matrix transpose. Converts to a matrix with the conjugate of the vector in the first row.
Definition vec.h:841
itpp::Vec< double >::elem_div
friend Vec< double > elem_div(const Vec< double > &v1, const Vec< double > &v2)
itpp::Vec::set_subvector
void set_subvector(int i1, int i2, const Vec< Num_T > &v)
This function is deprecated. Please use set_subvector(i, v) instead.
Definition vec.h:1404
itpp::Vec::left
Vec< Num_T > left(int nr) const
Get the left nr elements from the vector.
Definition vec.h:1239
itpp::bin
Binary arithmetic (boolean) class.
Definition binary.h:57
itpp::bin::bin
bin()
Default constructor.
Definition binary.h:60
copy_vector.h
Vector copy functions for internal use.
factory.h
Base class for class factories and memory allocation functions.
it_error
#define it_error(s)
Abort unconditionally.
Definition itassert.h:126
it_warning
#define it_warning(s)
Display a warning message.
Definition itassert.h:173
it_assert_debug
#define it_assert_debug(t, s)
Abort if t is not true and NDEBUG is not defined.
Definition itassert.h:107
itpp::hermitian_transpose
void hermitian_transpose(const Mat< T > &m, Mat< T > &out)
Definition matfunc.h:318
itpp::min
T min(const Vec< T > &in)
Minimum value of vector.
Definition min_max.h:125
itassert.h
Error handling functions - header file.
mat.h
Matrix Class Definitions.
bmat
Mat< bin > bmat
bin matrix
Definition mat.h:508
misc.h
Miscellaneous functions - header file.
itpp
itpp namespace
Definition itmex.h:37
itpp::elem_mult_inplace
void elem_mult_inplace(const Mat< Num_T > &m1, Mat< Num_T > &m2)
In-place element wise multiplication of two matrices. Fast version of B = elem_mult(A,...
Definition mat.h:1630
itpp::operator<<
std::ostream & operator<<(std::ostream &output, const bin &inbin)
Output stream of bin.
Definition binary.cpp:36
itpp::operator-
Mat< Num_T > operator-(const Mat< Num_T > &m1, const Mat< Num_T > &m2)
Subtraction of two matrices.
Definition mat.h:1382
itpp::concat
const Array< T > concat(const Array< T > &a, const T &e)
Append element e to the end of the Array a.
Definition array.h:486
itpp::operator*
GF2mat operator*(const GF2mat &X, const GF2mat &Y)
GF(2) matrix multiplication.
Definition gf2mat.cpp:847
itpp::operator/
Mat< Num_T > operator/(const Mat< Num_T > &m, Num_T t)
Element-wise division by a scalar.
Definition mat.h:1670
itpp::dot
Num_T dot(const Vec< Num_T > &v1, const Vec< Num_T > &v2)
Inner (dot) product of two vectors v1 and v2.
Definition vec.h:1005
itpp::destroy_elements
void destroy_elements(T *&ptr, int n)
Destroy an array of Array, Vec or Mat elements.
Definition factory.h:214
itpp::elem_div_out
void elem_div_out(const Mat< Num_T > &m1, const Mat< Num_T > &m2, Mat< Num_T > &out)
Element wise division of two matrices, storing the result in matrix out.
Definition mat.h:1696
itpp::operator>>
std::istream & operator>>(std::istream &input, bin &outbin)
Input stream of bin.
Definition binary.cpp:42
itpp::elem_div
Mat< Num_T > elem_div(const Mat< Num_T > &m1, const Mat< Num_T > &m2)
Element wise division of two matrices.
Definition mat.h:1688
itpp::elem_div_sum
Num_T elem_div_sum(const Mat< Num_T > &m1, const Mat< Num_T > &m2)
Element wise division of two matrices, followed by summation of the resultant elements....
Definition mat.h:1710
itpp::operator+
GF2mat operator+(const GF2mat &X, const GF2mat &Y)
GF(2) matrix addition.
Definition gf2mat.cpp:948
itpp::DEFAULT_FACTORY
const Factory DEFAULT_FACTORY
Default (dummy) factory.
Definition factory.h:139
itpp::elem_mult
Mat< Num_T > elem_mult(const Mat< Num_T > &m1, const Mat< Num_T > &m2)
Element wise multiplication of two matrices.
Definition mat.h:1582
itpp::elem_mult_sum
Num_T elem_mult_sum(const Mat< Num_T > &m1, const Mat< Num_T > &m2)
Element wise multiplication of two matrices, followed by summation of the resultant elements....
Definition mat.h:1639
itpp::elem_mult_out
void elem_mult_out(const Mat< Num_T > &m1, const Mat< Num_T > &m2, Mat< Num_T > &out)
Element wise multiplication of two matrices, storing the result in matrix out.
Definition mat.h:1590
itpp::create_elements
void create_elements(T *&ptr, int n, const Factory &)
Create an n-length array of T to be used as Array, Vec or Mat elements.
Definition factory.h:144
itpp::outer_product
Mat< Num_T > outer_product(const Vec< Num_T > &v1, const Vec< Num_T > &v2, bool hermitian=false)
Outer product of two vectors v1 and v2.
Definition vec.h:1021
Generated by doxygen 1.18.0