37 #include <itpp/itexports.h> 43 template<
class Num_T>
class Vec;
45 template<
class Num_T>
class Mat;
55 Vec<Num_T>
operator+(
const Vec<Num_T> &v1,
const Vec<Num_T> &v2);
58 Vec<Num_T>
operator+(
const Vec<Num_T> &v, Num_T t);
61 Vec<Num_T>
operator+(Num_T t,
const Vec<Num_T> &v);
65 Vec<Num_T>
operator-(
const Vec<Num_T> &v1,
const Vec<Num_T> &v2);
68 Vec<Num_T>
operator-(
const Vec<Num_T> &v, Num_T t);
71 Vec<Num_T>
operator-(Num_T t,
const Vec<Num_T> &v);
74 Vec<Num_T>
operator-(
const Vec<Num_T> &v);
78 Num_T
dot(
const Vec<Num_T> &v1,
const Vec<Num_T> &v2);
81 Num_T
operator*(
const Vec<Num_T> &v1,
const Vec<Num_T> &v2);
91 Mat<Num_T>
outer_product(
const Vec<Num_T> &v1,
const Vec<Num_T> &v2,
92 bool hermitian =
false);
95 Vec<Num_T>
operator*(
const Vec<Num_T> &v, Num_T t);
98 Vec<Num_T>
operator*(Num_T t,
const Vec<Num_T> &v);
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);
113 template<
class Num_T>
117 template<
class Num_T>
119 const Vec<Num_T> &c, Vec<Num_T> &out);
121 template<
class Num_T>
123 const Vec<Num_T> &c,
const Vec<Num_T> &d,
127 template<
class Num_T>
130 template<
class Num_T>
131 Num_T
elem_mult_sum(
const Vec<Num_T> &a,
const Vec<Num_T> &b);
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);
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);
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);
243 template<
class Num_T>
284 void set(
const char *str);
286 void set(
const std::string &str);
304 const Num_T &
get(
int i)
const;
313 void set(
int i, Num_T t);
451 void del(
int i1,
int i2);
453 void ins(
int i, Num_T t);
510 std::vector<std::string> tokenize(
const std::string &str,
511 bool &abc_format)
const;
513 Num_T parse_token(
const std::string &s)
const;
515 void parse_abc_token(
const std::string &s, Num_T &a, Num_T &b,
518 bool in_range(
int i)
const {
return ((i <
datasize) && (i >= 0)); }
571 template<
class Num_T>
572 std::ostream &operator<<(std::ostream &os, const Vec<Num_T> &v);
585 template<
class Num_T>
592 template<
class Num_T>
inline 605 template<
class Num_T>
inline 613 template<
class Num_T>
inline 616 template<
class Num_T>
inline 623 template<
class Num_T>
inline 627 copy_vector(datasize, v.data, data);
630 template<
class Num_T>
inline 634 copy_vector(datasize, v.data, data);
637 template<
class Num_T>
inline 640 set(std::string(str));
643 template<
class Num_T>
inline 649 template<
class Num_T>
inline 653 copy_vector(
size, c_array, data);
656 template<
class Num_T>
inline 662 template<
class Num_T>
666 if (datasize ==
size)
672 int old_datasize = datasize;
678 copy_vector(
min, tmp, data);
680 for (
int i =
min; i <
size; ++i)
691 template<
class Num_T>
inline 698 template<
class Num_T>
inline 704 template<
class Num_T>
inline 711 template<
class Num_T>
inline 717 template<
class Num_T>
inline 720 if (i1 == -1) i1 = datasize - 1;
721 if (i2 == -1) i2 = datasize - 1;
724 "Vec<>::operator()(i1, i2): Indexing out of range");
727 copy_vector(s.datasize, data + i1, s.data);
732 template<
class Num_T>
735 int size = indexlist.size();
737 for (
int i = 0; i <
size; ++i) {
739 "Index i=" << i <<
" out of range");
740 temp(i) = data[indexlist(i)];
745 template<
class Num_T>
748 int size = binlist.size();
750 "Wrong size of binlist vector");
753 for (
int i = 0; i <
size; ++i)
754 if (binlist(i) ==
bin(1))
756 temp.set_size(j,
true);
761 template<
class Num_T>
inline 767 template<
class Num_T>
inline 770 return (*
this)(i1, i2);
773 template<
class Num_T>
inline 776 return (*
this)(indexlist);
779 template<
class Num_T>
inline 782 return (*
this)(binlist);
785 template<
class Num_T>
inline 788 for (
int i = 0; i < datasize; i++)
792 template<
class Num_T>
inline 795 for (
int i = 0; i < datasize; i++)
799 template<
class Num_T>
inline 806 template<
class Num_T>
inline 809 it_error(
"Vec::set(): Only `double', `complex<double>', `int', " 810 "`short int' and `bin' types supported");
813 template<
class Num_T>
inline 816 set(std::string(str));
832 template<
class Num_T>
836 copy_vector(datasize, data, temp.
_data());
840 template<
class Num_T>
844 copy_vector(datasize, data, temp.
_data());
854 template<
class Num_T>
860 copy_vector(datasize, v.data, data);
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];
871 template<
class Num_T>
inline 874 for (
int i = 0;i < datasize;i++)
879 template<
class Num_T>
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];
892 template<
class Num_T>
898 for (i = 0; i < v.datasize; i++)
899 r.data[i] = v.data[i] + t;
904 template<
class Num_T>
910 for (i = 0; i < v.datasize; i++)
911 r.data[i] = t + v.data[i];
916 template<
class Num_T>
922 for (
int i = 0; i < v.datasize; i++)
923 data[i] = -v.data[i];
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];
934 template<
class Num_T>
inline 937 for (
int i = 0;i < datasize;i++)
942 template<
class Num_T>
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];
955 template<
class Num_T>
961 for (i = 0; i < v.datasize; i++)
962 r.data[i] = v.data[i] - t;
967 template<
class Num_T>
973 for (i = 0; i < v.datasize; i++)
974 r.data[i] = t - v.data[i];
979 template<
class Num_T>
985 for (i = 0; i < v.datasize; i++)
986 r.data[i] = -v.data[i];
991 template<
class Num_T>
inline 994 scal_vector(datasize, t, data);
998 template<
class Num_T>
inline 1004 template<
class Num_T>
1007 it_assert_debug(v1.length() == v2.length(),
"Vec::dot(): Wrong sizes");
1009 for (
int i = 0; i < v1.length(); ++i)
1010 r += v1._data()[i] * v2._data()[i];
1016 ITPP_EXPORT
double dot(
const vec &v1,
const vec &v2);
1020 template<
class Num_T>
1024 "Vec::outer_product:: Input vector of zero size");
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];
1037 ITPP_EXPORT
mat outer_product(
const vec &v1,
const vec &v2,
bool);
1040 ITPP_EXPORT
cmat outer_product(
const cvec &v1,
const cvec &v2,
bool hermitian);
1043 template<
class Num_T>
1048 for (i = 0; i < v.datasize; i++)
1049 r.data[i] = v.data[i] * t;
1054 template<
class Num_T>
inline 1060 template<
class Num_T>
inline 1068 template<
class Num_T>
inline 1077 template<
class Num_T>
inline 1086 template<
class Num_T>
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];
1096 template<
class Num_T>
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];
1107 template<
class Num_T>
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];
1119 template<
class Num_T>
1126 "Vec<>::elem_mult_inplace(): Wrong sizes");
1127 for (
int i = 0; i < a.datasize; i++)
1128 b.data[i] *= a.data[i];
1131 template<
class Num_T>
inline 1135 "Vec<>::elem_mult_sum(): Wrong sizes");
1137 for (
int i = 0; i < a.datasize; i++)
1138 acc += a.data[i] * b.data[i];
1142 template<
class Num_T>
1148 for (i = 0; i < v.datasize; i++)
1149 r.data[i] = v.data[i] / t;
1154 template<
class Num_T>
1160 for (i = 0; i < v.datasize; i++)
1161 r.data[i] = t / v.data[i];
1166 template<
class Num_T>
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> &) " 1176 template<
class Num_T>
inline 1179 for (
int i = 0; i < datasize; ++i) {
1185 template<
class Num_T>
inline 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];
1195 template<
class Num_T>
inline 1203 template<
class Num_T>
1206 it_assert_debug(a.datasize == b.datasize,
"Vecelem_div_out: wrong sizes");
1208 out.set_size(a.size());
1210 for (
int i = 0; i < a.datasize; i++)
1211 out.data[i] = a.data[i] / b.data[i];
1214 template<
class Num_T>
inline 1217 it_assert_debug(a.datasize == b.datasize,
"Vec::elem_div_sum: wrong sizes");
1221 for (
int i = 0; i < a.datasize; i++)
1222 acc += a.data[i] / b.data[i];
1227 template<
class Num_T>
1233 copy_vector(nr, &data[datasize-nr], temp.data);
1238 template<
class Num_T>
1244 copy_vector(nr, data, temp.data);
1249 template<
class Num_T>
1253 "Vec::mid(): indexing out of range");
1256 copy_vector(nr, &data[start], temp.data);
1261 template<
class Num_T>
1265 "Vec<>::split(): Index out of range");
1268 copy_vector(pos, data, temp1.data);
1269 if (pos < datasize) {
1271 copy_vector(datasize - pos, &data[pos], temp2.data);
1281 template<
class Num_T>
1288 data[i] = data[i-n];
1293 template<
class Num_T>
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++)
1302 template<
class Num_T>
1308 for (i = 0; i < datasize - n; i++)
1309 data[i] = data[i+n];
1310 while (i < datasize)
1314 template<
class Num_T>
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];
1323 template<
class Num_T>
1326 int size = v.size();
1328 copy_vector(
size, v.data, temp.data);
1333 template<
class Num_T>
1336 int size = v.size();
1339 copy_vector(
size, v.data, &temp.data[1]);
1343 template<
class Num_T>
1346 int size1 = v1.size();
1347 int size2 = v2.size();
1349 copy_vector(size1, v1.data, temp.data);
1350 copy_vector(size2, v2.data, &temp.data[size1]);
1354 template<
class Num_T>
1358 int size1 = v1.size();
1359 int size2 = v2.size();
1360 int size3 = v3.size();
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]);
1368 template<
class Num_T>
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]);
1384 template<
class Num_T>
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]);
1403 template<
class Num_T>
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);
1412 template<
class Num_T>
inline 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);
1421 template<
class Num_T>
inline 1424 if (i1 == -1) i1 = datasize - 1;
1425 if (i2 == -1) i2 = datasize - 1;
1427 "Vec<>::set_subvector(int, int, Num_T): Indexing out " 1429 for (
int i = i1; i <= i2; i++)
1433 template<
class Num_T>
inline 1436 set_subvector(i, v);
1439 template<
class Num_T>
1442 it_assert_debug(in_range(index),
"Vec<>::del(int): Index out of range");
1444 set_size(datasize - 1,
false);
1445 copy_vector(index, temp.data, data);
1446 copy_vector(datasize - index, &temp.data[index+1], &data[index]);
1449 template<
class Num_T>
1452 if (i1 == -1) i1 = datasize - 1;
1453 if (i2 == -1) i2 = datasize - 1;
1455 "Vec<>::del(int, int): Indexing out of range");
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]);
1463 template<
class Num_T>
1467 "Vec<>::ins(): Index out of range");
1470 set_size(datasize + 1,
false);
1471 copy_vector(index, Temp.data, data);
1473 copy_vector(Temp.datasize - index, Temp.data + index, data + index + 1);
1476 template<
class Num_T>
1480 "Vec<>::ins(): Index out of range");
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());
1489 template<
class Num_T>
inline 1492 for (
int i = 0;i < datasize;i++)
1497 template<
class Num_T>
inline 1501 set_size(v.datasize,
false);
1502 copy_vector(datasize, v.data, data);
1507 template<
class Num_T>
1510 if (m.
cols() == 1) {
1511 set_size(m.
rows(),
false);
1514 else if (m.
rows() == 1) {
1515 set_size(m.
cols(),
false);
1519 it_error(
"Vec<>::operator=(Mat<Num_T> &): Wrong size of input matrix");
1523 template<
class Num_T>
inline 1526 set(std::string(str));
1530 template<
class Num_T>
inline 1537 template<
class Num_T>
1541 bvec temp(datasize);
1542 for (
int i = 0; i < datasize; i++)
1543 temp(i) = (data[i] == t);
1547 template<
class Num_T>
1551 bvec temp(datasize);
1552 for (
int i = 0; i < datasize; i++)
1553 temp(i) = (data[i] != t);
1562 template<
class Num_T>
1566 bvec temp(datasize);
1567 for (
int i = 0; i < datasize; i++)
1568 temp(i) = (data[i] < t);
1572 template<
class Num_T>
1576 bvec temp(datasize);
1577 for (
int i = 0; i < datasize; i++)
1578 temp(i) = (data[i] <= t);
1587 template<
class Num_T>
1591 bvec temp(datasize);
1592 for (
int i = 0; i < datasize; i++)
1593 temp(i) = (data[i] > t);
1602 template<
class Num_T>
1606 bvec temp(datasize);
1607 for (
int i = 0; i < datasize; i++)
1608 temp(i) = (data[i] >= t);
1617 template<
class Num_T>
1621 if (datasize != invector.datasize)
return false;
1622 for (
int i = 0;i < datasize;i++) {
1623 if (data[i] != invector.data[i])
return false;
1628 template<
class Num_T>
1631 if (datasize != invector.datasize)
return true;
1632 for (
int i = 0;i < datasize;i++) {
1633 if (data[i] != invector.data[i])
return true;
1639 template<
class Num_T>
1640 std::ostream &operator<<(std::ostream &os, const Vec<Num_T> &v)
1642 int i, sz = v.length();
1645 for (i = 0; i < sz; i++) {
1656 template<
class Num_T>
1659 std::ostringstream buffer;
1660 bool started =
false;
1661 bool finished =
false;
1662 bool brackets =
false;
1672 if (is.eof() || (c ==
'\n')) {
1675 is.setstate(std::ios_base::failbit);
1678 else if (!((c ==
'\n') && !started)) {
1682 else if ((c ==
' ') || (c ==
'\t')) {
1687 else if (c ==
'[') {
1690 is.setstate(std::ios_base::failbit);
1698 else if (c ==
']') {
1699 if (!started || !brackets) {
1701 is.setstate(std::ios_base::failbit);
1707 while (!is.eof() && (((c =
static_cast<char>(is.peek())) ==
' ')
1711 if (!is.eof() && (c ==
'\n')) {
1723 v.set_size(0,
false);
1726 v.set(buffer.str());
1738 template<
class Num_T>
1739 void Vec<Num_T>::parse_abc_token(
const std::string &s, Num_T &a, Num_T &b,
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));
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));
1753 c = parse_token(s.substr(beg, end-beg-1));
1757 template<
class Num_T>
1758 Num_T Vec<Num_T>::parse_token(
const std::string &s)
const 1760 it_error(
"Vec::parse_token(): Only `double' and `int' types are supported");
1766 ITPP_EXPORT
double Vec<double>::parse_token(
const std::string &s)
const;
1768 ITPP_EXPORT
int Vec<int>::parse_token(
const std::string &s)
const;
1771 template<
class Num_T>
1772 std::vector<std::string> Vec<Num_T>::tokenize(
const std::string &str_in,
1773 bool &abc_format)
const 1775 std::vector<std::string> vs;
1781 bool lparen =
false;
1783 for (std::string::size_type i = 0; i < str_in.size(); ++i) {
1786 case ' ':
case '\t':
1812 else if (lparen && comma) {
1816 if ((c !=
'-') && (c !=
'+'))
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>;
1847 ITPP_EXPORT_TEMPLATE
template ITPP_EXPORT
vec operator+(
const vec &v1,
const vec &v2);
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);
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);
1867 ITPP_EXPORT_TEMPLATE
template ITPP_EXPORT
vec operator-(
const vec &v1,
const vec &v2);
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);
1876 ITPP_EXPORT_TEMPLATE
template ITPP_EXPORT
svec operator-(
const svec &v,
short t);
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);
1882 ITPP_EXPORT_TEMPLATE
template ITPP_EXPORT
svec operator-(
short t,
const svec &v);
1887 ITPP_EXPORT_TEMPLATE
template ITPP_EXPORT
vec operator-(
const vec &v);
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);
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);
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);
1915 ITPP_EXPORT_TEMPLATE
template ITPP_EXPORT
svec operator*(
const svec &v,
short t);
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);
1921 ITPP_EXPORT_TEMPLATE
template ITPP_EXPORT
svec operator*(
short t,
const svec &v);
1956 const vec &c,
const vec &d);
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,
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);
1999 ITPP_EXPORT_TEMPLATE
template ITPP_EXPORT
svec operator/(
const svec &v,
short t);
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);
2005 ITPP_EXPORT_TEMPLATE
template ITPP_EXPORT
svec operator/(
short t,
const svec &v);
2010 ITPP_EXPORT_TEMPLATE
template ITPP_EXPORT
vec elem_div(
const vec &a,
const vec &b);
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);
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,
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);
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);
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);
2057 ITPP_EXPORT_TEMPLATE
template ITPP_EXPORT
vec concat(
const vec &v1,
const vec &v2,
const vec &v3);
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,
2067 ITPP_EXPORT_TEMPLATE
template ITPP_EXPORT
ivec concat(
const ivec &v1,
const ivec &v2,
2069 ITPP_EXPORT_TEMPLATE
template ITPP_EXPORT
svec concat(
const svec &v1,
const svec &v2,
2071 ITPP_EXPORT_TEMPLATE
template ITPP_EXPORT
bvec concat(
const bvec &v1,
const bvec &v2,
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);
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);
2102 #endif // #ifndef VEC_H int size() const
The size of the vector.
Num_T value_type
The type of the vector values.
Mat< Num_T > elem_div(const Mat< Num_T > &m1, const Mat< Num_T > &m2)
Element wise division of two matrices.
std::ostream & operator<<(std::ostream &os, const Array< T > &a)
Output stream for Array<T>. T must have ostream operator<< defined.
Vec< Num_T > & operator+=(const Vec< Num_T > &v)
Addition of vector.
Vec< bin > operator<(Num_T t) const
Elementwise less than the scalar t.
Mat< Num_T > operator/(const Mat< Num_T > &m, Num_T t)
Element-wise division by a scalar.
Mat< double > mat
Default Matrix Type.
Vector copy functions for internal use.
void free()
Free the storage space allocated by the vector.
Miscellaneous functions - header file.
std::istream & operator>>(std::istream &is, Array< T > &a)
Input stream for Array<T>. T must have istream operator>> defined.
Vec< Num_T > split(int pos)
Split the vector into two parts at element pos.
Vec< bin > operator!=(Num_T t) const
Elementwise not-equal to the scalar t.
Num_T * _data()
Get the pointer to the internal structure. Not recommended for use.
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.
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.
const Factory & factory
Element factory (set to DEFAULT_FACTORY to use Num_T default constructors only)
Vec< std::complex< double > > cvec
Definition of complex<double> vector type.
void replace_mid(int i, const Vec< Num_T > &v)
An alias function of set_subvector(i, &v)
Vec(const Factory &f=DEFAULT_FACTORY)
Default constructor. An element factory f can be specified.
void shift_right(Num_T t, int n=1)
Shift in element t at position 0 n times.
void destroy_elements(T *&ptr, int n)
Destroy an array of Array, Vec or Mat elements.
Vec< short int > svec
Definition of short vector type.
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...
Mat< Num_T > elem_mult(const Mat< Num_T > &m1, const Mat< Num_T > &m2)
Element wise multiplication of two matrices.
ITPP_EXPORT GF2mat operator*(const GF2mat &X, const GF2mat &Y)
GF(2) matrix multiplication.
Num_T * data
A pointer to the data area.
vec operator/(const vec &v, const float &s)
Division operator for vec and float.
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. Fast version of sumsum(elem_div(A, B)).
Mat< Num_T > hermitian_transpose() const
Hermitian matrix transpose. Converts to a matrix with the conjugate of the vector in the first row...
void ones()
Set the vector to the all one vector.
Vec< bin > bvec
Definition of binary vector type.
Vec< Num_T > right(int nr) const
Get the right nr elements from the vector.
Vec< Num_T > mid(int start, int nr) const
Get the middle part of vector from start including nr elements.
void set_size(int size, bool copy=false)
Set length of vector. if copy = true then keeping the old values.
vec operator-(const float &s, const vec &v)
Subtraction operator for float and vec.
Vec< Num_T > & operator/=(Num_T t)
Elementwise division.
int datasize
The current number of elements in the vector.
#define it_assert_debug(t, s)
Abort if t is not true and NDEBUG is not defined.
const Num_T & operator()(int i) const
Index operator. First element is 0.
Base class for class factories.
Mat< short int > smat
short int matrix
ITPP_EXPORT vec zeros(int size)
A Double vector of zeros.
Vec< bin > operator<=(Num_T t) const
Elementwise less than and equal to the scalar t.
int cols() const
The number of columns.
T min(const Vec< T > &in)
Minimum value of vector.
Mat< Num_T > operator-(const Mat< Num_T > &m1, const Mat< Num_T > &m2)
Subtraction of two matrices.
Matrix Class Definitions.
Mat< std::complex< double > > cmat
Default Complex Matrix Type.
GF2mat operator+(const GF2mat &X, const GF2mat &Y)
GF(2) matrix addition.
const Factory DEFAULT_FACTORY
Default (dummy) factory.
Vec< bin > operator>=(Num_T t) const
Elementwise greater than and equal to the scalar t.
Mat< Num_T > transpose() const
Matrix transpose. Converts to a matrix with the vector in the first row.
void ins(int i, Num_T t)
Insert element t before element with index i (0 <= i <= datasize)
ITPP_EXPORT GF2mat operator+(const GF2mat &X, const GF2mat &Y)
GF(2) matrix addition.
int size(const Vec< T > &v)
Length of vector.
Base class for class factories and memory allocation functions.
Vec< Num_T > left(int nr) const
Get the left nr elements from the vector.
void del(int i)
Delete element number i.
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.
ITPP_EXPORT vec ones(int size)
A float vector of ones.
GF2mat operator*(const GF2mat &X, const GF2mat &Y)
GF(2) matrix multiplication.
Error handling functions - header file.
int length() const
The size of the vector.
void set_length(int size, bool copy=false)
Set length of vector. if copy = true then keeping the old values.
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, B).
Vec< Num_T > & operator*=(Num_T t)
Multiply with a scalar.
Vec< Num_T > & operator-=(const Vec< Num_T > &v)
Subtraction of vector.
const Num_T & _elem(int i) const
Index operator without boundary check. Not recommended for use.
Num_T * _data()
Access of the internal data structure (not recommended to use)
void hermitian_transpose(const Mat< T > &m, Mat< T > &out)
#define it_warning(s)
Display a warning message.
const Num_T * _data() const
Get the pointer to the internal structure. Not recommended for use.
Binary arithmetic (boolean) class.
#define it_error(s)
Abort unconditionally.
void transpose(const Mat< T > &m, Mat< T > &out)
Transposition of the matrix m returning the transposed matrix in out.
Mat< int > imat
Integer matrix.
int rows() const
The number of rows.
const Num_T & operator[](int i) const
C-style index operator. First element is 0.
Vec< Num_T > & operator=(Num_T t)
Assign all elements in vector to t.
void alloc(int size)
Allocate storage for a vector of length size.
Vec< int > ivec
Definition of integer vector type.
void set_subvector(int i1, int i2, const Vec< Num_T > &v)
This function is deprecated. Please use set_subvector(i, v) instead.
Num_T & _elem(int i)
Index operator without boundary check. Not recommended for use.
Vec< bin > operator>(Num_T t) const
Elementwise greater than the scalar t.
void clear()
Set the vector to the all zero vector.
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.
Mat< Num_T > T() const
Matrix transpose. Converts to a matrix with the vector in the first row.
Vec< bin > operator==(Num_T t) const
Elementwise equal to the scalar t.
Num_T dot(const Vec< Num_T > &v1, const Vec< Num_T > &v2)
Inner (dot) product of two vectors v1 and v2.
void zeros()
Set the vector to the all zero vector.
std::istream & operator>>(std::istream &input, bin &outbin)
Input stream of bin.
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...
Mat< Num_T > H() const
Hermitian matrix transpose. Converts to a matrix with the conjugate of the vector in the first row...
Vec< double > vec
Definition of double vector type.
Mat< bin > bmat
bin matrix
const Array< T > concat(const Array< T > &a, const T &e)
Append element e to the end of the Array a.