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