41 template<
class Num_T>
class Vec;
43 template<
class Num_T>
class Mat;
56 Mat<Num_T>
operator+(
const Mat<Num_T> &m1,
const Mat<Num_T> &m2);
59 Mat<Num_T>
operator+(
const Mat<Num_T> &m, Num_T t);
62 Mat<Num_T>
operator+(Num_T t,
const Mat<Num_T> &m);
66 Mat<Num_T>
operator-(
const Mat<Num_T> &m1,
const Mat<Num_T> &m2);
69 Mat<Num_T>
operator-(
const Mat<Num_T> &m, Num_T t);
72 Mat<Num_T>
operator-(Num_T t,
const Mat<Num_T> &m);
75 Mat<Num_T>
operator-(
const Mat<Num_T> &m);
79 Mat<Num_T>
operator*(
const Mat<Num_T> &m1,
const Mat<Num_T> &m2);
82 Vec<Num_T>
operator*(
const Mat<Num_T> &m,
const Vec<Num_T> &v);
85 Mat<Num_T>
operator*(
const Mat<Num_T> &m, Num_T t);
88 Mat<Num_T>
operator*(Num_T t,
const Mat<Num_T> &m);
92 Mat<Num_T>
elem_mult(
const Mat<Num_T> &m1,
const Mat<Num_T> &m2);
95 void elem_mult_out(
const Mat<Num_T> &m1,
const Mat<Num_T> &m2,
99 void elem_mult_out(
const Mat<Num_T> &m1,
const Mat<Num_T> &m2,
100 const Mat<Num_T> &m3, Mat<Num_T> &out);
102 template<
class Num_T>
103 void elem_mult_out(
const Mat<Num_T> &m1,
const Mat<Num_T> &m2,
104 const Mat<Num_T> &m3,
const Mat<Num_T> &m4,
107 template<
class Num_T>
110 template<
class Num_T>
111 Num_T
elem_mult_sum(
const Mat<Num_T> &m1,
const Mat<Num_T> &m2);
114 template<
class Num_T>
115 Mat<Num_T>
operator/(
const Mat<Num_T> &m, Num_T t);
117 template<
class Num_T>
118 Mat<Num_T>
operator/(Num_T t,
const Mat<Num_T> &m);
121 template<
class Num_T>
122 Mat<Num_T>
elem_div(
const Mat<Num_T> &m1,
const Mat<Num_T> &m2);
124 template<
class Num_T>
125 void elem_div_out(
const Mat<Num_T> &m1,
const Mat<Num_T> &m2,
128 template<
class Num_T>
129 Num_T
elem_div_sum(
const Mat<Num_T> &m1,
const Mat<Num_T> &m2);
200 template<
class Num_T>
228 Mat(
const Num_T *c_array,
int rows,
int cols,
bool row_major =
true,
249 void set(
const std::string &str);
251 void set(
const char *str);
262 const Num_T &
get(
int r,
int c)
const;
264 const Num_T &
get(
int i)
const;
266 void set(
int r,
int c, Num_T t);
279 Mat<Num_T> get(
int r1,
int r2,
int c1,
int c2)
const;
471 bool in_range(
int r,
int c)
const {
475 bool row_in_range(
int r)
const {
return ((r >= 0) && (r <
no_rows)); }
477 bool col_in_range(
int c)
const {
return ((c >= 0) && (c <
no_cols)); }
479 bool in_range(
int i)
const {
return ((i >= 0) && (i <
datasize)); }
534 template <
class Num_T>
535 std::ostream &operator<<(std::ostream &os, const Mat<Num_T> &m);
548 template <
class Num_T>
549 std::istream &
operator>>(std::istream &is, Mat<Num_T> &m);
555 template<
class Num_T>
inline
558 if ((rows > 0) && (cols > 0)) {
559 datasize = rows * cols;
572 template<
class Num_T>
inline
582 template<
class Num_T>
inline
584 datasize(0), no_rows(0), no_cols(0), data(0), factory(f) {}
586 template<
class Num_T>
inline
588 datasize(0), no_rows(0), no_cols(0), data(0), factory(f)
590 it_assert_debug((rows >= 0) && (cols >= 0),
"Mat<>::Mat(): Wrong size");
594 template<
class Num_T>
inline
596 datasize(0), no_rows(0), no_cols(0), data(0), factory(m.factory)
602 template<
class Num_T>
inline
604 datasize(0), no_rows(0), no_cols(0), data(0), factory(f)
610 template<
class Num_T>
inline
612 datasize(0), no_rows(0), no_cols(0), data(0), factory(f)
619 template<
class Num_T>
inline
621 datasize(0), no_rows(0), no_cols(0), data(0), factory(f)
626 template<
class Num_T>
inline
628 datasize(0), no_rows(0), no_cols(0), data(0), factory(f)
630 set(std::string(str));
633 template<
class Num_T>
636 datasize(0), no_rows(0), no_cols(0), data(0), factory(f)
642 for (
int i = 0; i <
rows; i++)
643 for (
int j = 0; j <
cols; j++)
647 template<
class Num_T>
inline
654 template<
class Num_T>
658 "Mat<>::set_size(): Wrong size");
660 if ((no_rows == rows) && (no_cols == cols))
663 if ((rows == 0) || (cols == 0)) {
672 int old_datasize = datasize;
673 int old_rows = no_rows;
675 int min_r = (no_rows < rows) ? no_rows : rows;
676 int min_c = (no_cols < cols) ? no_cols : cols;
680 for (
int i = 0; i < min_c; ++i) {
681 copy_vector(min_r, &tmp[i*old_rows], &data[i*no_rows]);
684 for (
int i = min_r; i < rows; ++i)
685 for (
int j = 0; j < cols; ++j)
686 data[i+j*rows] = Num_T(0);
687 for (
int j = min_c; j < cols; ++j)
688 for (
int i = 0; i < min_r; ++i)
689 data[i+j*rows] = Num_T(0);
694 else if (datasize == rows * cols) {
705 template<
class Num_T>
inline
708 for (
int i = 0; i < datasize; i++)
712 template<
class Num_T>
inline
715 for (
int i = 0; i < datasize; i++)
719 template<
class Num_T>
inline
723 "Mat<>::operator(): Indexing out of range");
724 return data[r+c*no_rows];
727 template<
class Num_T>
inline
731 "Mat<>::operator(): Indexing out of range");
732 return data[r+c*no_rows];
735 template<
class Num_T>
inline
742 template<
class Num_T>
inline
749 template<
class Num_T>
inline
752 return (*
this)(r, c);
755 template<
class Num_T>
inline
761 template<
class Num_T>
inline
764 it_assert_debug(in_range(r, c),
"Mat<>::set(): Indexing out of range");
765 data[r+c*no_rows] = t;
769 template<
class Num_T>
781 std::string::size_type beg = 0;
782 std::string::size_type end = 0;
783 while (end != std::string::npos) {
785 end = str.find(
';', beg);
788 int v_size = v.
size();
792 if ((end != std::string::npos) || (v_size > 0)) {
795 set_size(maxrows, v_size,
true);
800 if ((rows == maxrows) || (v_size != no_cols)) {
802 if (rows == maxrows) {
806 if (v_size > no_cols) {
807 set_size(maxrows, v_size,
true);
810 set_size(maxrows, no_cols,
true);
812 v.set_size(no_cols,
true);
824 set_size(rows, no_cols,
true);
827 template<
class Num_T>
inline
830 set(std::string(str));
833 template<
class Num_T>
inline
836 if (r1 == -1) r1 = no_rows - 1;
837 if (r2 == -1) r2 = no_rows - 1;
838 if (c1 == -1) c1 = no_cols - 1;
839 if (c2 == -1) c2 = no_cols - 1;
842 (c1 >= 0) && (c1 <= c2) && (c2 < no_cols),
843 "Mat<>::operator()(r1, r2, c1, c2): Wrong indexing");
847 for (
int i = 0;i < s.
no_cols;i++)
853 template<
class Num_T>
inline
856 return (*
this)(r1, r2, c1, c2);
859 template<
class Num_T>
inline
862 it_assert_debug(row_in_range(r),
"Mat<>::get_row(): Index out of range");
865 copy_vector(no_cols, data + r, no_rows, a.
_data(), 1);
869 template<
class Num_T>
873 "Mat<>::get_rows(): Wrong indexing");
876 for (
int i = 0; i < m.
rows(); i++)
877 copy_vector(no_cols, data + i + r1, no_rows, m.
data + i, m.
no_rows);
882 template<
class Num_T>
887 for (
int i = 0;i < indexlist.
size();i++) {
889 "Mat<>::get_rows(indexlist): Indexing out of range");
890 copy_vector(no_cols, data + indexlist(i), no_rows, m.
data + i, m.no_rows);
896 template<
class Num_T>
inline
899 it_assert_debug(col_in_range(c),
"Mat<>::get_col(): Index out of range");
902 copy_vector(no_rows, data + c*no_rows, a.
_data());
907 template<
class Num_T>
911 "Mat<>::get_cols(): Wrong indexing");
914 for (
int i = 0; i < m.
cols(); i++)
915 copy_vector(no_rows, data + (i + c1)*no_rows, m.
data + i*m.
no_rows);
920 template<
class Num_T>
925 for (
int i = 0; i < indexlist.
size(); i++) {
927 "Mat<>::get_cols(indexlist): Indexing out of range");
928 copy_vector(no_rows, data + indexlist(i)*no_rows, m.
data + i*m.no_rows);
934 template<
class Num_T>
inline
937 it_assert_debug(row_in_range(r),
"Mat<>::set_row(): Index out of range");
939 "Mat<>::set_row(): Wrong size of input vector");
940 copy_vector(v.
size(), v.
_data(), 1, data + r, no_rows);
943 template<
class Num_T>
inline
946 it_assert_debug(col_in_range(c),
"Mat<>::set_col(): Index out of range");
948 "Mat<>::set_col(): Wrong size of input vector");
949 copy_vector(v.
size(), v.
_data(), data + c*no_rows);
953 template<
class Num_T>
956 it_assert_debug(row_in_range(r),
"Mat<>::set_rows(): Index out of range");
958 "Mat<>::set_rows(): Column sizes do not match");
960 "Mat<>::set_rows(): Not enough rows");
962 for (
int i = 0; i < m.
rows(); ++i) {
963 copy_vector(no_cols, m.
data + i, m.
no_rows, data + i + r, no_rows);
967 template<
class Num_T>
970 it_assert_debug(col_in_range(c),
"Mat<>::set_cols(): Index out of range");
972 "Mat<>::set_cols(): Row sizes do not match");
974 "Mat<>::set_cols(): Not enough colums");
976 for (
int i = 0; i < m.
cols(); ++i) {
977 copy_vector(no_rows, m.
data + i*no_rows, data + (i + c)*no_rows);
982 template<
class Num_T>
inline
986 "Mat<>::copy_row(): Indexing out of range");
990 copy_vector(no_cols, data + from, no_rows, data + to, no_rows);
993 template<
class Num_T>
inline
997 "Mat<>::copy_col(): Indexing out of range");
1001 copy_vector(no_rows, data + from*no_rows, data + to*no_rows);
1004 template<
class Num_T>
inline
1008 "Mat<>::swap_rows(): Indexing out of range");
1012 swap_vector(no_cols, data + r1, no_rows, data + r2, no_rows);
1015 template<
class Num_T>
inline
1019 "Mat<>::swap_cols(): Indexing out of range");
1023 swap_vector(no_rows, data + c1*no_rows, data + c2*no_rows);
1026 template<
class Num_T>
1029 it_warning(
"Mat<>::set_submatrix(r1, r2, r3, r4, m): This function is "
1030 "deprecated and might be removed from future IT++ releases. "
1031 "Please use Mat<>::set_submatrix(r, c, m) function instead.");
1032 set_submatrix(r1, c1, m);
1035 template<
class Num_T>
inline
1039 (c >= 0) && (c + m.
no_cols <= no_cols),
1040 "Mat<>::set_submatrix(): Indexing out of range "
1041 "or wrong input matrix");
1042 for (
int i = 0; i < m.
no_cols; i++)
1048 template<
class Num_T>
inline
1051 if (r1 == -1) r1 = no_rows - 1;
1052 if (r2 == -1) r2 = no_rows - 1;
1053 if (c1 == -1) c1 = no_cols - 1;
1054 if (c2 == -1) c2 = no_cols - 1;
1056 (c1 >= 0) && (c1 <= c2) && (c2 < no_cols),
1057 "Mat<>::set_submatrix(): Wrong indexing");
1058 for (
int i = c1; i <= c2; i++) {
1059 int pos = i * no_rows + r1;
1060 for (
int j = r1; j <= r2; j++)
1065 template<
class Num_T>
1068 it_assert_debug(row_in_range(r),
"Mat<>::del_row(): Index out of range");
1070 set_size(no_rows - 1, no_cols,
false);
1071 for (
int i = 0 ; i < r ; i++) {
1072 copy_vector(no_cols, &Temp.
data[i], no_rows + 1, &data[i], no_rows);
1074 for (
int i = r ; i < no_rows ; i++) {
1075 copy_vector(no_cols, &Temp.
data[i+1], no_rows + 1, &data[i], no_rows);
1080 template<
class Num_T>
1084 "Mat<>::del_rows(): Indexing out of range");
1086 int no_del_rows = r2 - r1 + 1;
1087 set_size(no_rows - no_del_rows, no_cols,
false);
1088 for (
int i = 0; i < r1 ; ++i) {
1089 copy_vector(no_cols, &Temp.
data[i], Temp.
no_rows, &data[i], no_rows);
1091 for (
int i = r2 + 1; i < Temp.
no_rows; ++i) {
1092 copy_vector(no_cols, &Temp.
data[i], Temp.
no_rows, &data[i-no_del_rows],
1097 template<
class Num_T>
1100 it_assert_debug(col_in_range(c),
"Mat<>::del_col(): Index out of range");
1103 set_size(no_rows, no_cols - 1,
false);
1104 copy_vector(c*no_rows, Temp.
data, data);
1105 copy_vector((no_cols - c)*no_rows, &Temp.
data[(c+1)*no_rows], &data[c*no_rows]);
1108 template<
class Num_T>
1112 "Mat<>::del_cols(): Indexing out of range");
1114 int n_deleted_cols = c2 - c1 + 1;
1115 set_size(no_rows, no_cols - n_deleted_cols,
false);
1116 copy_vector(c1*no_rows, Temp.
data, data);
1117 copy_vector((no_cols - c1)*no_rows, &Temp.
data[(c2+1)*no_rows], &data[c1*no_rows]);
1120 template<
class Num_T>
1124 "Mat<>::ins_row(): Index out of range");
1126 "Mat<>::ins_row(): Wrong size of the input vector");
1133 set_size(no_rows + 1, no_cols,
false);
1135 for (
int i = 0 ; i < r ; i++) {
1136 copy_vector(no_cols, &Temp.
data[i], no_rows - 1, &data[i], no_rows);
1138 copy_vector(no_cols, v.
_data(), 1, &data[r], no_rows);
1139 for (
int i = r + 1 ; i < no_rows ; i++) {
1140 copy_vector(no_cols, &Temp.
data[i-1], no_rows - 1, &data[i], no_rows);
1144 template<
class Num_T>
1148 "Mat<>::ins_col(): Index out of range");
1150 "Mat<>::ins_col(): Wrong size of the input vector");
1157 set_size(no_rows, no_cols + 1,
false);
1159 copy_vector(c*no_rows, Temp.
data, data);
1160 copy_vector(no_rows, v.
_data(), &data[c*no_rows]);
1161 copy_vector((no_cols - c - 1)*no_rows, &Temp.
data[c*no_rows], &data[(c+1)*no_rows]);
1164 template<
class Num_T>
inline
1167 ins_row(no_rows, v);
1170 template<
class Num_T>
inline
1173 ins_col(no_cols, v);
1176 template<
class Num_T>
1180 for (
int i = 0; i < no_rows; ++i) {
1181 copy_vector(no_cols, &data[i], no_rows, &temp.
data[i * no_cols], 1);
1191 template<
class Num_T>
1195 for (
int i = 0; i < no_rows; ++i) {
1196 copy_vector(no_cols, &data[i], no_rows, &temp.
data[i * no_cols], 1);
1201 template<
class Num_T>
1210 "Mat<>::concat_horizontal(): Wrong sizes");
1213 for (
int i = 0; i < m1.
no_cols; ++i) {
1214 copy_vector(no_rows, &m1.
data[i * no_rows], &temp.
data[i * no_rows]);
1216 for (
int i = 0; i < m2.
no_cols; ++i) {
1217 copy_vector(no_rows, &m2.
data[i * no_rows], &temp.
data[(m1.
no_cols + i)
1223 template<
class Num_T>
1232 "Mat<>::concat_vertical(): Wrong sizes");
1235 for (
int i = 0; i < no_cols; ++i) {
1244 template<
class Num_T>
inline
1247 for (
int i = 0; i < datasize; i++)
1252 template<
class Num_T>
inline
1263 template<
class Num_T>
inline
1267 || ((no_cols == 1) && (no_rows == v.
size())),
1268 "Mat<>::operator=(): Wrong size of the input vector");
1269 set_size(v.
size(), 1,
false);
1274 template<
class Num_T>
inline
1281 template<
class Num_T>
inline
1284 set(std::string(str));
1290 template<
class Num_T>
1296 int i, j, m_pos = 0, pos = 0;
1298 for (i = 0; i < no_cols; i++) {
1299 for (j = 0; j < no_rows; j++)
1300 data[pos+j] += m.
data[m_pos+j];
1308 template<
class Num_T>
inline
1311 for (
int i = 0; i < datasize; i++)
1316 template<
class Num_T>
1320 int i, j, m1_pos = 0, m2_pos = 0, r_pos = 0;
1323 "Mat<>::operator+(): Wrong sizes");
1325 for (i = 0; i < r.
no_cols; i++) {
1326 for (j = 0; j < r.
no_rows; j++)
1327 r.
data[r_pos+j] = m1.
data[m1_pos+j] + m2.
data[m2_pos+j];
1338 template<
class Num_T>
1343 for (
int i = 0; i < r.
datasize; i++)
1349 template<
class Num_T>
1354 for (
int i = 0; i < r.
datasize; i++)
1360 template<
class Num_T>
1363 int i, j, m_pos = 0, pos = 0;
1365 if (datasize == 0) {
1367 for (i = 0; i < no_cols; i++) {
1368 for (j = 0; j < no_rows; j++)
1369 data[pos+j] = -m.
data[m_pos+j];
1377 "Mat<>::operator-=(): Wrong sizes");
1378 for (i = 0; i < no_cols; i++) {
1379 for (j = 0; j < no_rows; j++)
1380 data[pos+j] -= m.
data[m_pos+j];
1389 template<
class Num_T>
1393 int i, j, m1_pos = 0, m2_pos = 0, r_pos = 0;
1395 "Mat<>::operator-(): Wrong sizes");
1397 for (i = 0; i < r.
no_cols; i++) {
1398 for (j = 0; j < r.
no_rows; j++)
1399 r.
data[r_pos+j] = m1.
data[m1_pos+j] - m2.
data[m2_pos+j];
1409 template<
class Num_T>
inline
1412 for (
int i = 0; i < datasize; i++)
1417 template<
class Num_T>
1421 int i, j, m_pos = 0, r_pos = 0;
1423 for (i = 0; i < r.
no_cols; i++) {
1424 for (j = 0; j < r.
no_rows; j++)
1425 r.
data[r_pos+j] = m.
data[m_pos+j] - t;
1434 template<
class Num_T>
1438 int i, j, m_pos = 0, r_pos = 0;
1440 for (i = 0; i < r.
no_cols; i++) {
1441 for (j = 0; j < r.
no_rows; j++)
1442 r.
data[r_pos+j] = t - m.
data[m_pos+j];
1451 template<
class Num_T>
1455 int i, j, m_pos = 0, r_pos = 0;
1457 for (i = 0; i < r.
no_cols; i++) {
1458 for (j = 0; j < r.
no_rows; j++)
1459 r.
data[r_pos+j] = -m.
data[m_pos+j];
1469 template<> mat& mat::operator*=(
const mat &m);
1470 template<> cmat& cmat::operator*=(
const cmat &m);
1472 template<
class Num_T>
1480 int i, j, k, r_pos = 0, pos = 0, m_pos = 0;
1482 for (i = 0; i < r.
no_cols; i++) {
1483 for (j = 0; j < r.
no_rows; j++) {
1486 for (k = 0; k < no_cols; k++) {
1487 tmp += data[pos+j] * m.
data[m_pos+k];
1490 r.
data[r_pos+j] = tmp;
1499 template<
class Num_T>
inline
1502 scal_vector(datasize, t, data);
1507 template<> mat
operator*(
const mat &m1,
const mat &m2);
1508 template<> cmat
operator*(
const cmat &m1,
const cmat &m2);
1510 template<
class Num_T>
1514 "Mat<>::operator*(): Wrong sizes");
1519 Num_T *tr = r.
data, *t1, *t2 = m2.
data;
1521 for (i = 0; i < r.
no_cols; i++) {
1522 for (j = 0; j < r.
no_rows; j++) {
1525 for (k = m1.
no_cols; k > 0; k--) {
1526 tmp += *(t1) * *(t2++);
1539 template<> vec
operator*(
const mat &m,
const vec &v);
1540 template<> cvec
operator*(
const cmat &m,
const cvec &v);
1542 template<
class Num_T>
1546 "Mat<>::operator*(): Wrong sizes");
1550 for (i = 0; i < m.
no_rows; i++) {
1553 for (k = 0; k < m.
no_cols; k++) {
1554 r(i) += m.
data[m_pos+i] * v(k);
1562 template<
class Num_T>
1567 for (
int i = 0; i < r.
datasize; i++)
1573 template<
class Num_T>
inline
1579 template<
class Num_T>
inline
1587 template<
class Num_T>
1592 "Mat<>::elem_mult_out(): Wrong sizes");
1594 for (
int i = 0; i < out.
datasize; i++)
1598 template<
class Num_T>
1604 "Mat<>::elem_mult_out(): Wrong sizes");
1606 for (
int i = 0; i < out.
datasize; i++)
1610 template<
class Num_T>
1618 "Mat<>::elem_mult_out(): Wrong sizes");
1620 for (
int i = 0; i < out.
datasize; i++)
1624 template<
class Num_T>
1631 "Mat<>::elem_mult_inplace(): Wrong sizes");
1632 for (
int i = 0; i < m2.
datasize; i++)
1636 template<
class Num_T>
inline
1640 "Mat<>::elem_mult_sum(): Wrong sizes");
1643 for (
int i = 0; i < m1.
datasize; i++)
1649 template<
class Num_T>
inline
1652 for (
int i = 0; i < datasize; i++)
1657 template<
class Num_T>
inline
1661 "Mat<>::operator/=(): Wrong sizes");
1662 for (
int i = 0; i < datasize; i++)
1663 data[i] /= m.
data[i];
1667 template<
class Num_T>
1671 for (
int i = 0; i < r.
datasize; ++i)
1676 template<
class Num_T>
1680 for (
int i = 0; i < r.
datasize; ++i)
1685 template<
class Num_T>
inline
1693 template<
class Num_T>
1698 "Mat<>::elem_div_out(): Wrong sizes");
1703 for (
int i = 0; i < out.
datasize; i++)
1707 template<
class Num_T>
inline
1711 "Mat<>::elem_div_sum(): Wrong sizes");
1714 for (
int i = 0; i < m1.
datasize; i++)
1720 template<
class Num_T>
1724 for (
int i = 0;i < datasize;i++) {
1725 if (data[i] != m.
data[i])
return false;
1730 template<
class Num_T>
1734 for (
int i = 0;i < datasize;i++) {
1735 if (data[i] != m.
data[i])
return true;
1740 template <
class Num_T>
1741 std::ostream &operator<<(std::ostream &os, const Mat<Num_T> &m)
1750 os <<
'[' << m.get_row(0) <<
']';
1753 os <<
'[' << m.get_row(0) << std::endl;
1754 for (i = 1; i < m.rows() - 1; i++)
1755 os <<
' ' << m.get_row(i) << std::endl;
1756 os <<
' ' << m.get_row(m.rows() - 1) <<
']';
1762 template <
class Num_T>
1765 std::ostringstream buffer;
1766 bool started =
false;
1767 bool finished =
false;
1768 bool brackets =
false;
1769 bool within_double_brackets =
false;
1779 if (is.eof() || (c ==
'\n')) {
1782 is.setstate(std::ios_base::failbit);
1785 else if (!((c ==
'\n') && !started)) {
1789 else if ((c ==
' ') || (c ==
'\t')) {
1794 else if (c ==
'[') {
1795 if ((started && !brackets) || within_double_brackets) {
1797 is.setstate(std::ios_base::failbit);
1800 else if (!started) {
1805 within_double_brackets =
true;
1808 else if (c ==
']') {
1809 if (!started || !brackets) {
1811 is.setstate(std::ios_base::failbit);
1814 else if (within_double_brackets) {
1815 within_double_brackets =
false;
1821 while (!is.eof() && (((c =
static_cast<char>(is.peek())) ==
' ')
1825 if (!is.eof() && (c ==
'\n')) {
1840 m.
set(buffer.str());
1856 extern template class Mat<double>;
1857 extern template class Mat<std::complex<double> >;
1858 extern template class Mat<int>;
1859 extern template class Mat<short int>;
1860 extern template class Mat<bin>;
1864 extern template mat
operator+(
const mat &m1,
const mat &m2);
1865 extern template cmat
operator+(
const cmat &m1,
const cmat &m2);
1866 extern template imat
operator+(
const imat &m1,
const imat &m2);
1867 extern template smat
operator+(
const smat &m1,
const smat &m2);
1870 extern template mat
operator+(
const mat &m,
double t);
1871 extern template cmat
operator+(
const cmat &m, std::complex<double> t);
1872 extern template imat
operator+(
const imat &m,
int t);
1873 extern template smat
operator+(
const smat &m,
short t);
1876 extern template mat
operator+(
double t,
const mat &m);
1877 extern template cmat
operator+(std::complex<double> t,
const cmat &m);
1878 extern template imat
operator+(
int t,
const imat &m);
1879 extern template smat
operator+(
short t,
const smat &m);
1884 extern template mat
operator-(
const mat &m1,
const mat &m2);
1885 extern template cmat
operator-(
const cmat &m1,
const cmat &m2);
1886 extern template imat
operator-(
const imat &m1,
const imat &m2);
1887 extern template smat
operator-(
const smat &m1,
const smat &m2);
1890 extern template mat
operator-(
const mat &m,
double t);
1891 extern template cmat
operator-(
const cmat &m, std::complex<double> t);
1892 extern template imat
operator-(
const imat &m,
int t);
1893 extern template smat
operator-(
const smat &m,
short t);
1896 extern template mat
operator-(
double t,
const mat &m);
1897 extern template cmat
operator-(std::complex<double> t,
const cmat &m);
1898 extern template imat
operator-(
int t,
const imat &m);
1899 extern template smat
operator-(
short t,
const smat &m);
1904 extern template mat
operator-(
const mat &m);
1905 extern template cmat
operator-(
const cmat &m);
1906 extern template imat
operator-(
const imat &m);
1907 extern template smat
operator-(
const smat &m);
1912 extern template imat
operator*(
const imat &m1,
const imat &m2);
1913 extern template smat
operator*(
const smat &m1,
const smat &m2);
1916 extern template ivec
operator*(
const imat &m,
const ivec &v);
1917 extern template svec
operator*(
const smat &m,
const svec &v);
1918 extern template bvec
operator*(
const bmat &m,
const bvec &v);
1920 extern template mat
operator*(
const mat &m,
double t);
1921 extern template cmat
operator*(
const cmat &m, std::complex<double> t);
1922 extern template imat
operator*(
const imat &m,
int t);
1923 extern template smat
operator*(
const smat &m,
short t);
1926 extern template mat
operator*(
double t,
const mat &m);
1927 extern template cmat
operator*(std::complex<double> t,
const cmat &m);
1928 extern template imat
operator*(
int t,
const imat &m);
1929 extern template smat
operator*(
short t,
const smat &m);
1934 extern template mat
elem_mult(
const mat &m1,
const mat &m2);
1935 extern template cmat
elem_mult(
const cmat &m1,
const cmat &m2);
1936 extern template imat
elem_mult(
const imat &m1,
const imat &m2);
1937 extern template smat
elem_mult(
const smat &m1,
const smat &m2);
1940 extern template void elem_mult_out(
const mat &m1,
const mat &m2, mat &out);
1941 extern template void elem_mult_out(
const cmat &m1,
const cmat &m2,
1943 extern template void elem_mult_out(
const imat &m1,
const imat &m2,
1945 extern template void elem_mult_out(
const smat &m1,
const smat &m2,
1950 extern template void elem_mult_out(
const mat &m1,
const mat &m2,
1951 const mat &m3, mat &out);
1952 extern template void elem_mult_out(
const cmat &m1,
const cmat &m2,
1953 const cmat &m3, cmat &out);
1954 extern template void elem_mult_out(
const imat &m1,
const imat &m2,
1955 const imat &m3, imat &out);
1956 extern template void elem_mult_out(
const smat &m1,
const smat &m2,
1957 const smat &m3, smat &out);
1961 extern template void elem_mult_out(
const mat &m1,
const mat &m2,
1962 const mat &m3,
const mat &m4, mat &out);
1963 extern template void elem_mult_out(
const cmat &m1,
const cmat &m2,
1964 const cmat &m3,
const cmat &m4,
1966 extern template void elem_mult_out(
const imat &m1,
const imat &m2,
1967 const imat &m3,
const imat &m4,
1969 extern template void elem_mult_out(
const smat &m1,
const smat &m2,
1970 const smat &m3,
const smat &m4,
1982 extern template double elem_mult_sum(
const mat &m1,
const mat &m2);
1983 extern template std::complex<double>
elem_mult_sum(
const cmat &m1,
1985 extern template int elem_mult_sum(
const imat &m1,
const imat &m2);
1986 extern template short elem_mult_sum(
const smat &m1,
const smat &m2);
1991 extern template mat
operator/(
double t,
const mat &m);
1992 extern template cmat
operator/(std::complex<double> t,
const cmat &m);
1993 extern template imat
operator/(
int t,
const imat &m);
1994 extern template smat
operator/(
short t,
const smat &m);
1997 extern template mat
operator/(
const mat &m,
double t);
1998 extern template cmat
operator/(
const cmat &m, std::complex<double> t);
1999 extern template imat
operator/(
const imat &m,
int t);
2000 extern template smat
operator/(
const smat &m,
short t);
2005 extern template mat
elem_div(
const mat &m1,
const mat &m2);
2006 extern template cmat
elem_div(
const cmat &m1,
const cmat &m2);
2007 extern template imat
elem_div(
const imat &m1,
const imat &m2);
2008 extern template smat
elem_div(
const smat &m1,
const smat &m2);
2011 extern template void elem_div_out(
const mat &m1,
const mat &m2, mat &out);
2012 extern template void elem_div_out(
const cmat &m1,
const cmat &m2, cmat &out);
2013 extern template void elem_div_out(
const imat &m1,
const imat &m2, imat &out);
2014 extern template void elem_div_out(
const smat &m1,
const smat &m2, smat &out);
2017 extern template double elem_div_sum(
const mat &m1,
const mat &m2);
2018 extern template std::complex<double>
elem_div_sum(
const cmat &m1,
2020 extern template int elem_div_sum(
const imat &m1,
const imat &m2);
2021 extern template short elem_div_sum(
const smat &m1,
const smat &m2);
2040 extern template std::ostream &
operator<<(std::ostream &os,
const mat &m);
2041 extern template std::ostream &
operator<<(std::ostream &os,
const cmat &m);
2042 extern template std::ostream &
operator<<(std::ostream &os,
const imat &m);
2043 extern template std::ostream &
operator<<(std::ostream &os,
const smat &m);
2044 extern template std::ostream &
operator<<(std::ostream &os,
const bmat &m);
2046 extern template std::istream &
operator>>(std::istream &is, mat &m);
2047 extern template std::istream &
operator>>(std::istream &is, cmat &m);
2048 extern template std::istream &
operator>>(std::istream &is, imat &m);
2049 extern template std::istream &
operator>>(std::istream &is, smat &m);
2050 extern template std::istream &
operator>>(std::istream &is,
bmat &m);
2058 #endif // #ifndef MAT_H