00001 00031 #ifndef MATFUNC_H 00032 #define MATFUNC_H 00033 00034 #include <itpp/base/mat.h> 00035 #include <itpp/base/math/log_exp.h> 00036 #include <itpp/base/math/elem_math.h> 00037 00038 00039 namespace itpp 00040 { 00041 00046 00047 00049 template<class T> 00050 int length(const Vec<T> &v) { return v.length(); } 00051 00053 template<class T> 00054 int size(const Vec<T> &v) { return v.length(); } 00055 00057 template<class T> 00058 T sum(const Vec<T> &v) 00059 { 00060 T M = 0; 00061 00062 for (int i = 0;i < v.length();i++) 00063 M += v[i]; 00064 00065 return M; 00066 } 00067 00075 template<class T> 00076 Vec<T> sum(const Mat<T> &m, int dim = 1) 00077 { 00078 it_assert((dim == 1) || (dim == 2), "sum: dimension need to be 1 or 2"); 00079 Vec<T> out; 00080 00081 if (dim == 1) { 00082 out.set_size(m.cols(), false); 00083 00084 for (int i = 0; i < m.cols(); i++) 00085 out(i) = sum(m.get_col(i)); 00086 } 00087 else { 00088 out.set_size(m.rows(), false); 00089 00090 for (int i = 0; i < m.rows(); i++) 00091 out(i) = sum(m.get_row(i)); 00092 } 00093 00094 return out; 00095 } 00096 00097 00099 template<class T> 00100 T sumsum(const Mat<T> &X) 00101 { 00102 const T * X_data = X._data(); 00103 const int X_datasize = X._datasize(); 00104 T acc = 0; 00105 00106 for (int i = 0;i < X_datasize;i++) 00107 acc += X_data[i]; 00108 00109 return acc; 00110 } 00111 00112 00114 template<class T> 00115 T sum_sqr(const Vec<T> &v) 00116 { 00117 T M = 0; 00118 00119 for (int i = 0; i < v.length(); i++) 00120 M += v[i] * v[i]; 00121 00122 return M; 00123 } 00124 00132 template<class T> 00133 Vec<T> sum_sqr(const Mat<T> &m, int dim = 1) 00134 { 00135 it_assert((dim == 1) || (dim == 2), "sum_sqr: dimension need to be 1 or 2"); 00136 Vec<T> out; 00137 00138 if (dim == 1) { 00139 out.set_size(m.cols(), false); 00140 00141 for (int i = 0; i < m.cols(); i++) 00142 out(i) = sum_sqr(m.get_col(i)); 00143 } 00144 else { 00145 out.set_size(m.rows(), false); 00146 00147 for (int i = 0; i < m.rows(); i++) 00148 out(i) = sum_sqr(m.get_row(i)); 00149 } 00150 00151 return out; 00152 } 00153 00155 template<class T> 00156 Vec<T> cumsum(const Vec<T> &v) 00157 { 00158 Vec<T> out(v.size()); 00159 00160 out(0) = v(0); 00161 for (int i = 1; i < v.size(); i++) 00162 out(i) = out(i - 1) + v(i); 00163 00164 return out; 00165 } 00166 00174 template<class T> 00175 Mat<T> cumsum(const Mat<T> &m, int dim = 1) 00176 { 00177 it_assert((dim == 1) || (dim == 2), "cumsum: dimension need to be 1 or 2"); 00178 Mat<T> out(m.rows(), m.cols()); 00179 00180 if (dim == 1) { 00181 for (int i = 0; i < m.cols(); i++) 00182 out.set_col(i, cumsum(m.get_col(i))); 00183 } 00184 else { 00185 for (int i = 0; i < m.rows(); i++) 00186 out.set_row(i, cumsum(m.get_row(i))); 00187 } 00188 00189 return out; 00190 } 00191 00193 template<class T> 00194 T prod(const Vec<T> &v) 00195 { 00196 it_assert(v.size() >= 1, "prod: size of vector should be at least 1"); 00197 T out = v(0); 00198 00199 for (int i = 1; i < v.size(); i++) 00200 out *= v(i); 00201 00202 return out; 00203 } 00204 00212 template<class T> 00213 Vec<T> prod(const Mat<T> &m, int dim = 1) 00214 { 00215 it_assert((dim == 1) || (dim == 2), "prod: dimension need to be 1 or 2"); 00216 Vec<T> out(m.cols()); 00217 00218 if (dim == 1) { 00219 it_assert((m.cols() >= 1) && (m.rows() >= 1), 00220 "prod: number of columns should be at least 1"); 00221 out.set_size(m.cols(), false); 00222 00223 for (int i = 0; i < m.cols(); i++) 00224 out(i) = prod(m.get_col(i)); 00225 } 00226 else { 00227 it_assert((m.cols() >= 1) && (m.rows() >= 1), 00228 "prod: number of rows should be at least 1"); 00229 out.set_size(m.rows(), false); 00230 00231 for (int i = 0; i < m.rows(); i++) 00232 out(i) = prod(m.get_row(i)); 00233 } 00234 return out; 00235 } 00236 00238 template<class T> 00239 Vec<T> cross(const Vec<T> &v1, const Vec<T> &v2) 00240 { 00241 it_assert((v1.size() == 3) && (v2.size() == 3), 00242 "cross: vectors should be of size 3"); 00243 00244 Vec<T> r(3); 00245 00246 r(0) = v1(1) * v2(2) - v1(2) * v2(1); 00247 r(1) = v1(2) * v2(0) - v1(0) * v2(2); 00248 r(2) = v1(0) * v2(1) - v1(1) * v2(0); 00249 00250 return r; 00251 } 00252 00253 00255 template<class T> 00256 Vec<T> zero_pad(const Vec<T> &v, int n) 00257 { 00258 it_assert(n >= v.size(), "zero_pad() cannot shrink the vector!"); 00259 Vec<T> v2(n); 00260 v2.set_subvector(0, v.size() - 1, v); 00261 if (n > v.size()) 00262 v2.set_subvector(v.size(), n - 1, T(0)); 00263 00264 return v2; 00265 } 00266 00268 template<class T> 00269 Vec<T> zero_pad(const Vec<T> &v) 00270 { 00271 int n = pow2i(levels2bits(v.size())); 00272 00273 return (n == v.size()) ? v : zero_pad(v, n); 00274 } 00275 00277 template<class T> 00278 Mat<T> zero_pad(const Mat<T> &m, int rows, int cols) 00279 { 00280 it_assert((rows >= m.rows()) && (cols >= m.cols()), 00281 "zero_pad() cannot shrink the matrix!"); 00282 Mat<T> m2(rows, cols); 00283 m2.set_submatrix(0, m.rows() - 1, 0, m.cols() - 1, m); 00284 if (cols > m.cols()) // Zero 00285 m2.set_submatrix(0, m.rows() - 1, m.cols(), cols - 1, T(0)); 00286 if (rows > m.rows()) // Zero 00287 m2.set_submatrix(m.rows(), rows - 1, 0, cols - 1, T(0)); 00288 00289 return m2; 00290 } 00291 00292 00295 template<class T> 00296 T index_zero_pad(const Vec<T> &v, const int index) 00297 { 00298 if (index >= 0 && index < v.size()) 00299 return v(index); 00300 else 00301 return T(0); 00302 } 00303 00304 00306 template<class T> 00307 void transpose(const Mat<T> &m, Mat<T> &out) { out = m.T(); } 00308 00310 template<class T> 00311 Mat<T> transpose(const Mat<T> &m) { return m.T(); } 00312 00313 00316 template<class T> 00317 void hermitian_transpose(const Mat<T> &m, Mat<T> &out) { out = m.H(); } 00318 00320 template<class T> 00321 Mat<T> hermitian_transpose(const Mat<T> &m) { return m.H(); } 00322 00323 00324 00334 template<class Num_T> 00335 bool is_hermitian(const Mat<Num_T>& X) 00336 { 00337 00338 if (X == X.H()) 00339 return true; 00340 else 00341 return false; 00342 } 00343 00353 template<class Num_T> 00354 bool is_unitary(const Mat<Num_T>& X) 00355 { 00356 00357 if (inv(X) == X.H()) 00358 return true; 00359 else 00360 return false; 00361 } 00362 00363 00372 template<class T> 00373 Vec<T> repmat(const Vec<T> &v, int n) 00374 { 00375 it_assert(n > 0, "repmat(): Wrong repetition parameter"); 00376 int data_length = v.length(); 00377 it_assert(data_length > 0, "repmat(): Input vector can not be empty"); 00378 Vec<T> assembly(data_length * n); 00379 for (int j = 0; j < n; ++j) { 00380 assembly.set_subvector(j * data_length, v); 00381 } 00382 return assembly; 00383 } 00384 00385 00395 template<class T> 00396 Mat<T> repmat(const Mat<T> &data, int m, int n) 00397 { 00398 it_assert((m > 0) && (n > 0), "repmat(): Wrong repetition parameters"); 00399 int data_rows = data.rows(); 00400 int data_cols = data.cols(); 00401 it_assert((data_rows > 0) && (data_cols > 0), "repmat(): Input matrix can " 00402 "not be empty"); 00403 Mat<T> assembly(data_rows*m, data_cols*n); 00404 for (int i = 0; i < m; ++i) { 00405 for (int j = 0; j < n; ++j) { 00406 assembly.set_submatrix(i*data_rows, j*data_cols, data); 00407 } 00408 } 00409 return assembly; 00410 } 00411 00423 template<class T> inline 00424 Mat<T> repmat(const Vec<T> &v, int m, int n, bool transpose = false) 00425 { 00426 return repmat((transpose ? v.T() : Mat<T>(v)), m, n); 00427 } 00428 00429 00441 template<class Num_T> 00442 Mat<Num_T> kron(const Mat<Num_T>& X, const Mat<Num_T>& Y) 00443 { 00444 Mat<Num_T> result(X.rows() * Y.rows(), X.cols() * Y.cols()); 00445 00446 for (int i = 0; i < X.rows(); i++) 00447 for (int j = 0; j < X.cols(); j++) 00448 result.set_submatrix(i * Y.rows(), j * Y.cols(), X(i, j) * Y); 00449 00450 return result; 00451 } 00452 00453 00466 cmat sqrtm(const cmat& A); 00467 00480 cmat sqrtm(const mat& A); 00481 00483 00484 00485 00486 // -------------------- Diagonal matrix functions ------------------------- 00487 00490 00501 template<class T> 00502 Mat<T> diag(const Vec<T> &v, const int K = 0) 00503 { 00504 Mat<T> m(v.size() + std::abs(K), v.size() + std::abs(K)); 00505 m = T(0); 00506 if (K > 0) 00507 for (int i = v.size() - 1; i >= 0; i--) 00508 m(i, i + K) = v(i); 00509 else 00510 for (int i = v.size() - 1; i >= 0; i--) 00511 m(i - K, i) = v(i); 00512 00513 return m; 00514 } 00515 00525 template<class T> 00526 void diag(const Vec<T> &v, Mat<T> &m) 00527 { 00528 m.set_size(v.size(), v.size(), false); 00529 m = T(0); 00530 for (int i = v.size() - 1; i >= 0; i--) 00531 m(i, i) = v(i); 00532 } 00533 00541 template<class T> 00542 Vec<T> diag(const Mat<T> &m) 00543 { 00544 Vec<T> t(std::min(m.rows(), m.cols())); 00545 00546 for (int i = 0; i < t.size(); i++) 00547 t(i) = m(i, i); 00548 00549 return t; 00550 } 00551 00561 template<class T> 00562 Mat<T> bidiag(const Vec<T> &main, const Vec<T> &sup) 00563 { 00564 it_assert(main.size() == sup.size() + 1, "bidiag()"); 00565 00566 int n = main.size(); 00567 Mat<T> m(n, n); 00568 m = T(0); 00569 for (int i = 0; i < n - 1; i++) { 00570 m(i, i) = main(i); 00571 m(i, i + 1) = sup(i); 00572 } 00573 m(n - 1, n - 1) = main(n - 1); 00574 00575 return m; 00576 } 00577 00587 template<class T> 00588 void bidiag(const Vec<T> &main, const Vec<T> &sup, Mat<T> &m) 00589 { 00590 it_assert(main.size() == sup.size() + 1, "bidiag()"); 00591 00592 int n = main.size(); 00593 m.set_size(n, n); 00594 m = T(0); 00595 for (int i = 0; i < n - 1; i++) { 00596 m(i, i) = main(i); 00597 m(i, i + 1) = sup(i); 00598 } 00599 m(n - 1, n - 1) = main(n - 1); 00600 } 00601 00610 template<class T> 00611 void bidiag(const Mat<T> &m, Vec<T> &main, Vec<T> &sup) 00612 { 00613 it_assert(m.rows() == m.cols(), "bidiag(): Matrix must be square!"); 00614 00615 int n = m.cols(); 00616 main.set_size(n); 00617 sup.set_size(n - 1); 00618 for (int i = 0; i < n - 1; i++) { 00619 main(i) = m(i, i); 00620 sup(i) = m(i, i + 1); 00621 } 00622 main(n - 1) = m(n - 1, n - 1); 00623 } 00624 00634 template<class T> 00635 Mat<T> tridiag(const Vec<T> &main, const Vec<T> &sup, const Vec<T> &sub) 00636 { 00637 it_assert(main.size() == sup.size() + 1 && main.size() == sub.size() + 1, "bidiag()"); 00638 00639 int n = main.size(); 00640 Mat<T> m(n, n); 00641 m = T(0); 00642 for (int i = 0; i < n - 1; i++) { 00643 m(i, i) = main(i); 00644 m(i, i + 1) = sup(i); 00645 m(i + 1, i) = sub(i); 00646 } 00647 m(n - 1, n - 1) = main(n - 1); 00648 00649 return m; 00650 } 00651 00661 template<class T> 00662 void tridiag(const Vec<T> &main, const Vec<T> &sup, const Vec<T> &sub, Mat<T> &m) 00663 { 00664 it_assert(main.size() == sup.size() + 1 && main.size() == sub.size() + 1, "bidiag()"); 00665 00666 int n = main.size(); 00667 m.set_size(n, n); 00668 m = T(0); 00669 for (int i = 0; i < n - 1; i++) { 00670 m(i, i) = main(i); 00671 m(i, i + 1) = sup(i); 00672 m(i + 1, i) = sub(i); 00673 } 00674 m(n - 1, n - 1) = main(n - 1); 00675 } 00676 00685 template<class T> 00686 void tridiag(const Mat<T> &m, Vec<T> &main, Vec<T> &sup, Vec<T> &sub) 00687 { 00688 it_assert(m.rows() == m.cols(), "tridiag(): Matrix must be square!"); 00689 00690 int n = m.cols(); 00691 main.set_size(n); 00692 sup.set_size(n - 1); 00693 sub.set_size(n - 1); 00694 for (int i = 0; i < n - 1; i++) { 00695 main(i) = m(i, i); 00696 sup(i) = m(i, i + 1); 00697 sub(i) = m(i + 1, i); 00698 } 00699 main(n - 1) = m(n - 1, n - 1); 00700 } 00701 00702 00706 template<class T> 00707 T trace(const Mat<T> &m) 00708 { 00709 return sum(diag(m)); 00710 } 00711 00713 00714 00715 // ----------------- reshaping vectors and matrices ------------------------ 00716 00719 00721 template<class T> 00722 Vec<T> reverse(const Vec<T> &in) 00723 { 00724 int i, s = in.length(); 00725 00726 Vec<T> out(s); 00727 for (i = 0;i < s;i++) 00728 out[i] = in[s-1-i]; 00729 return out; 00730 } 00731 00733 template<class T> 00734 Vec<T> rvectorize(const Mat<T> &m) 00735 { 00736 int i, j, n = 0, r = m.rows(), c = m.cols(); 00737 Vec<T> v(r * c); 00738 00739 for (i = 0; i < r; i++) 00740 for (j = 0; j < c; j++) 00741 v(n++) = m(i, j); 00742 00743 return v; 00744 } 00745 00747 template<class T> 00748 Vec<T> cvectorize(const Mat<T> &m) 00749 { 00750 int i, j, n = 0, r = m.rows(), c = m.cols(); 00751 Vec<T> v(r * c); 00752 00753 for (j = 0; j < c; j++) 00754 for (i = 0; i < r; i++) 00755 v(n++) = m(i, j); 00756 00757 return v; 00758 } 00759 00766 template<class T> 00767 Mat<T> reshape(const Mat<T> &m, int rows, int cols) 00768 { 00769 it_assert_debug(m.rows()*m.cols() == rows*cols, "Mat<T>::reshape: Sizes must match"); 00770 Mat<T> temp(rows, cols); 00771 int i, j, ii = 0, jj = 0; 00772 for (j = 0; j < m.cols(); j++) { 00773 for (i = 0; i < m.rows(); i++) { 00774 temp(ii++, jj) = m(i, j); 00775 if (ii == rows) { 00776 jj++; 00777 ii = 0; 00778 } 00779 } 00780 } 00781 return temp; 00782 } 00783 00790 template<class T> 00791 Mat<T> reshape(const Vec<T> &v, int rows, int cols) 00792 { 00793 it_assert_debug(v.size() == rows*cols, "Mat<T>::reshape: Sizes must match"); 00794 Mat<T> temp(rows, cols); 00795 int i, j, ii = 0; 00796 for (j = 0; j < cols; j++) { 00797 for (i = 0; i < rows; i++) { 00798 temp(i, j) = v(ii++); 00799 } 00800 } 00801 return temp; 00802 } 00803 00805 00806 00808 bool all(const bvec &testvec); 00810 bool any(const bvec &testvec); 00811 00813 00814 // ---------------------------------------------------------------------- 00815 // Instantiations 00816 // ---------------------------------------------------------------------- 00817 00818 #ifdef HAVE_EXTERN_TEMPLATE 00819 00820 extern template int length(const vec &v); 00821 extern template int length(const cvec &v); 00822 extern template int length(const svec &v); 00823 extern template int length(const ivec &v); 00824 extern template int length(const bvec &v); 00825 00826 extern template double sum(const vec &v); 00827 extern template std::complex<double> sum(const cvec &v); 00828 extern template short sum(const svec &v); 00829 extern template int sum(const ivec &v); 00830 extern template bin sum(const bvec &v); 00831 00832 extern template double sum_sqr(const vec &v); 00833 extern template std::complex<double> sum_sqr(const cvec &v); 00834 extern template short sum_sqr(const svec &v); 00835 extern template int sum_sqr(const ivec &v); 00836 extern template bin sum_sqr(const bvec &v); 00837 00838 extern template vec cumsum(const vec &v); 00839 extern template cvec cumsum(const cvec &v); 00840 extern template svec cumsum(const svec &v); 00841 extern template ivec cumsum(const ivec &v); 00842 extern template bvec cumsum(const bvec &v); 00843 00844 extern template double prod(const vec &v); 00845 extern template std::complex<double> prod(const cvec &v); 00846 extern template short prod(const svec &v); 00847 extern template int prod(const ivec &v); 00848 extern template bin prod(const bvec &v); 00849 00850 extern template vec cross(const vec &v1, const vec &v2); 00851 extern template cvec cross(const cvec &v1, const cvec &v2); 00852 extern template ivec cross(const ivec &v1, const ivec &v2); 00853 extern template svec cross(const svec &v1, const svec &v2); 00854 extern template bvec cross(const bvec &v1, const bvec &v2); 00855 00856 extern template vec reverse(const vec &in); 00857 extern template cvec reverse(const cvec &in); 00858 extern template svec reverse(const svec &in); 00859 extern template ivec reverse(const ivec &in); 00860 extern template bvec reverse(const bvec &in); 00861 00862 extern template vec zero_pad(const vec &v, int n); 00863 extern template cvec zero_pad(const cvec &v, int n); 00864 extern template ivec zero_pad(const ivec &v, int n); 00865 extern template svec zero_pad(const svec &v, int n); 00866 extern template bvec zero_pad(const bvec &v, int n); 00867 00868 extern template vec zero_pad(const vec &v); 00869 extern template cvec zero_pad(const cvec &v); 00870 extern template ivec zero_pad(const ivec &v); 00871 extern template svec zero_pad(const svec &v); 00872 extern template bvec zero_pad(const bvec &v); 00873 00874 extern template mat zero_pad(const mat &, int, int); 00875 extern template cmat zero_pad(const cmat &, int, int); 00876 extern template imat zero_pad(const imat &, int, int); 00877 extern template smat zero_pad(const smat &, int, int); 00878 extern template bmat zero_pad(const bmat &, int, int); 00879 00880 extern template vec sum(const mat &m, int dim); 00881 extern template cvec sum(const cmat &m, int dim); 00882 extern template svec sum(const smat &m, int dim); 00883 extern template ivec sum(const imat &m, int dim); 00884 extern template bvec sum(const bmat &m, int dim); 00885 00886 extern template double sumsum(const mat &X); 00887 extern template std::complex<double> sumsum(const cmat &X); 00888 extern template short sumsum(const smat &X); 00889 extern template int sumsum(const imat &X); 00890 extern template bin sumsum(const bmat &X); 00891 00892 extern template vec sum_sqr(const mat & m, int dim); 00893 extern template cvec sum_sqr(const cmat &m, int dim); 00894 extern template svec sum_sqr(const smat &m, int dim); 00895 extern template ivec sum_sqr(const imat &m, int dim); 00896 extern template bvec sum_sqr(const bmat &m, int dim); 00897 00898 extern template mat cumsum(const mat &m, int dim); 00899 extern template cmat cumsum(const cmat &m, int dim); 00900 extern template smat cumsum(const smat &m, int dim); 00901 extern template imat cumsum(const imat &m, int dim); 00902 extern template bmat cumsum(const bmat &m, int dim); 00903 00904 extern template vec prod(const mat &m, int dim); 00905 extern template cvec prod(const cmat &v, int dim); 00906 extern template svec prod(const smat &m, int dim); 00907 extern template ivec prod(const imat &m, int dim); 00908 extern template bvec prod(const bmat &m, int dim); 00909 00910 extern template vec diag(const mat &in); 00911 extern template cvec diag(const cmat &in); 00912 extern template void diag(const vec &in, mat &m); 00913 extern template void diag(const cvec &in, cmat &m); 00914 extern template mat diag(const vec &v, const int K); 00915 extern template cmat diag(const cvec &v, const int K); 00916 00917 extern template mat bidiag(const vec &, const vec &); 00918 extern template cmat bidiag(const cvec &, const cvec &); 00919 extern template void bidiag(const vec &, const vec &, mat &); 00920 extern template void bidiag(const cvec &, const cvec &, cmat &); 00921 extern template void bidiag(const mat &, vec &, vec &); 00922 extern template void bidiag(const cmat &, cvec &, cvec &); 00923 00924 extern template mat tridiag(const vec &main, const vec &, const vec &); 00925 extern template cmat tridiag(const cvec &main, const cvec &, const cvec &); 00926 extern template void tridiag(const vec &main, const vec &, const vec &, mat &); 00927 extern template void tridiag(const cvec &main, const cvec &, const cvec &, cmat &); 00928 extern template void tridiag(const mat &m, vec &, vec &, vec &); 00929 extern template void tridiag(const cmat &m, cvec &, cvec &, cvec &); 00930 00931 extern template double trace(const mat &in); 00932 extern template std::complex<double> trace(const cmat &in); 00933 extern template short trace(const smat &in); 00934 extern template int trace(const imat &in); 00935 extern template bin trace(const bmat &in); 00936 00937 extern template void transpose(const mat &m, mat &out); 00938 extern template void transpose(const cmat &m, cmat &out); 00939 extern template void transpose(const smat &m, smat &out); 00940 extern template void transpose(const imat &m, imat &out); 00941 extern template void transpose(const bmat &m, bmat &out); 00942 00943 extern template mat transpose(const mat &m); 00944 extern template cmat transpose(const cmat &m); 00945 extern template smat transpose(const smat &m); 00946 extern template imat transpose(const imat &m); 00947 extern template bmat transpose(const bmat &m); 00948 00949 extern template void hermitian_transpose(const mat &m, mat &out); 00950 extern template void hermitian_transpose(const cmat &m, cmat &out); 00951 extern template void hermitian_transpose(const smat &m, smat &out); 00952 extern template void hermitian_transpose(const imat &m, imat &out); 00953 extern template void hermitian_transpose(const bmat &m, bmat &out); 00954 00955 extern template mat hermitian_transpose(const mat &m); 00956 extern template cmat hermitian_transpose(const cmat &m); 00957 extern template smat hermitian_transpose(const smat &m); 00958 extern template imat hermitian_transpose(const imat &m); 00959 extern template bmat hermitian_transpose(const bmat &m); 00960 00961 extern template bool is_hermitian(const mat &X); 00962 extern template bool is_hermitian(const cmat &X); 00963 00964 extern template bool is_unitary(const mat &X); 00965 extern template bool is_unitary(const cmat &X); 00966 00967 extern template vec rvectorize(const mat &m); 00968 extern template cvec rvectorize(const cmat &m); 00969 extern template ivec rvectorize(const imat &m); 00970 extern template svec rvectorize(const smat &m); 00971 extern template bvec rvectorize(const bmat &m); 00972 00973 extern template vec cvectorize(const mat &m); 00974 extern template cvec cvectorize(const cmat &m); 00975 extern template ivec cvectorize(const imat &m); 00976 extern template svec cvectorize(const smat &m); 00977 extern template bvec cvectorize(const bmat &m); 00978 00979 extern template mat reshape(const mat &m, int rows, int cols); 00980 extern template cmat reshape(const cmat &m, int rows, int cols); 00981 extern template imat reshape(const imat &m, int rows, int cols); 00982 extern template smat reshape(const smat &m, int rows, int cols); 00983 extern template bmat reshape(const bmat &m, int rows, int cols); 00984 00985 extern template mat reshape(const vec &m, int rows, int cols); 00986 extern template cmat reshape(const cvec &m, int rows, int cols); 00987 extern template imat reshape(const ivec &m, int rows, int cols); 00988 extern template smat reshape(const svec &m, int rows, int cols); 00989 extern template bmat reshape(const bvec &m, int rows, int cols); 00990 00991 extern template mat kron(const mat &X, const mat &Y); 00992 extern template cmat kron(const cmat &X, const cmat &Y); 00993 extern template imat kron(const imat &X, const imat &Y); 00994 extern template smat kron(const smat &X, const smat &Y); 00995 extern template bmat kron(const bmat &X, const bmat &Y); 00996 00997 extern template vec repmat(const vec &v, int n); 00998 extern template cvec repmat(const cvec &v, int n); 00999 extern template ivec repmat(const ivec &v, int n); 01000 extern template svec repmat(const svec &v, int n); 01001 extern template bvec repmat(const bvec &v, int n); 01002 01003 extern template mat repmat(const vec &v, int m, int n, bool transpose); 01004 extern template cmat repmat(const cvec &v, int m, int n, bool transpose); 01005 extern template imat repmat(const ivec &v, int m, int n, bool transpose); 01006 extern template smat repmat(const svec &v, int m, int n, bool transpose); 01007 extern template bmat repmat(const bvec &v, int m, int n, bool transpose); 01008 01009 extern template mat repmat(const mat &data, int m, int n); 01010 extern template cmat repmat(const cmat &data, int m, int n); 01011 extern template imat repmat(const imat &data, int m, int n); 01012 extern template smat repmat(const smat &data, int m, int n); 01013 extern template bmat repmat(const bmat &data, int m, int n); 01014 01015 #endif // HAVE_EXTERN_TEMPLATE 01016 01018 01019 } // namespace itpp 01020 01021 #endif // #ifndef MATFUNC_H
Generated on Wed Dec 7 2011 03:38:29 for IT++ by Doxygen 1.7.4