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 00045 00046 00048 template<class T> 00049 int length(const Vec<T> &v) { return v.length(); } 00050 00052 template<class T> 00053 int size(const Vec<T> &v) { return v.length(); } 00054 00056 template<class T> 00057 T sum(const Vec<T> &v) 00058 { 00059 T M = 0; 00060 00061 for (int i=0;i<v.length();i++) 00062 M += v[i]; 00063 00064 return M; 00065 } 00066 00074 template<class T> 00075 Vec<T> sum(const Mat<T> &m, int dim=1) 00076 { 00077 it_assert((dim == 1) || (dim == 2), "sum: dimension need to be 1 or 2"); 00078 Vec<T> out; 00079 00080 if (dim == 1) { 00081 out.set_size(m.cols(), false); 00082 00083 for (int i=0; i<m.cols(); i++) 00084 out(i) = sum(m.get_col(i)); 00085 } 00086 else { 00087 out.set_size(m.rows(), false); 00088 00089 for (int i=0; i<m.rows(); i++) 00090 out(i) = sum(m.get_row(i)); 00091 } 00092 00093 return out; 00094 } 00095 00096 00098 template<class T> 00099 T sumsum(const Mat<T> &X) 00100 { 00101 const T * X_data = X._data(); 00102 const int X_datasize = X._datasize(); 00103 T acc = 0; 00104 00105 for(int i=0;i<X_datasize;i++) 00106 acc += X_data[i]; 00107 00108 return acc; 00109 } 00110 00111 00113 template<class T> 00114 T sum_sqr(const Vec<T> &v) 00115 { 00116 T M=0; 00117 00118 for (int i=0; i<v.length(); i++) 00119 M += v[i] * v[i]; 00120 00121 return M; 00122 } 00123 00131 template<class T> 00132 Vec<T> sum_sqr(const Mat<T> &m, int dim=1) 00133 { 00134 it_assert((dim == 1) || (dim == 2), "sum_sqr: dimension need to be 1 or 2"); 00135 Vec<T> out; 00136 00137 if (dim == 1) { 00138 out.set_size(m.cols(), false); 00139 00140 for (int i=0; i<m.cols(); i++) 00141 out(i) = sum_sqr(m.get_col(i)); 00142 } 00143 else { 00144 out.set_size(m.rows(), false); 00145 00146 for (int i=0; i<m.rows(); i++) 00147 out(i) = sum_sqr(m.get_row(i)); 00148 } 00149 00150 return out; 00151 } 00152 00154 template<class T> 00155 Vec<T> cumsum(const Vec<T> &v) 00156 { 00157 Vec<T> out(v.size()); 00158 00159 out(0)=v(0); 00160 for (int i=1; i<v.size(); i++) 00161 out(i) = out(i-1) + v(i); 00162 00163 return out; 00164 } 00165 00173 template<class T> 00174 Mat<T> cumsum(const Mat<T> &m, int dim=1) 00175 { 00176 it_assert((dim == 1) || (dim == 2), "cumsum: dimension need to be 1 or 2"); 00177 Mat<T> out(m.rows(), m.cols()); 00178 00179 if (dim == 1) { 00180 for (int i=0; i<m.cols(); i++) 00181 out.set_col(i, cumsum(m.get_col(i))); 00182 } else { 00183 for (int i=0; i<m.rows(); i++) 00184 out.set_row(i, cumsum(m.get_row(i))); 00185 } 00186 00187 return out; 00188 } 00189 00191 template<class T> 00192 T prod(const Vec<T> &v) 00193 { 00194 it_assert(v.size() >= 1, "prod: size of vector should be at least 1"); 00195 T out = v(0); 00196 00197 for (int i=1; i<v.size(); i++) 00198 out *= v(i); 00199 00200 return out; 00201 } 00202 00210 template<class T> 00211 Vec<T> prod(const Mat<T> &m, int dim=1) 00212 { 00213 it_assert((dim == 1) || (dim == 2), "prod: dimension need to be 1 or 2"); 00214 Vec<T> out(m.cols()); 00215 00216 if (dim == 1) { 00217 it_assert((m.cols() >= 1) && (m.rows() >= 1), 00218 "prod: number of columns should be at least 1"); 00219 out.set_size(m.cols(), false); 00220 00221 for (int i=0; i<m.cols(); i++) 00222 out(i) = prod(m.get_col(i)); 00223 } 00224 else { 00225 it_assert((m.cols() >= 1) && (m.rows() >= 1), 00226 "prod: number of rows should be at least 1"); 00227 out.set_size(m.rows(), false); 00228 00229 for (int i=0; i<m.rows(); i++) 00230 out(i) = prod(m.get_row(i)); 00231 } 00232 return out; 00233 } 00234 00236 template<class T> 00237 Vec<T> cross(const Vec<T> &v1, const Vec<T> &v2) 00238 { 00239 it_assert((v1.size() == 3) && (v2.size() == 3), 00240 "cross: vectors should be of size 3"); 00241 00242 Vec<T> r(3); 00243 00244 r(0) = v1(1) * v2(2) - v1(2) * v2(1); 00245 r(1) = v1(2) * v2(0) - v1(0) * v2(2); 00246 r(2) = v1(0) * v2(1) - v1(1) * v2(0); 00247 00248 return r; 00249 } 00250 00251 00253 template<class T> 00254 Vec<T> zero_pad(const Vec<T> &v, int n) 00255 { 00256 it_assert(n >= v.size(), "zero_pad() cannot shrink the vector!"); 00257 Vec<T> v2(n); 00258 v2.set_subvector(0, v.size()-1, v); 00259 if (n > v.size()) 00260 v2.set_subvector(v.size(), n-1, T(0)); 00261 00262 return v2; 00263 } 00264 00266 template<class T> 00267 Vec<T> zero_pad(const Vec<T> &v) 00268 { 00269 int n = pow2i(levels2bits(v.size())); 00270 00271 return (n == v.size()) ? v : zero_pad(v, n); 00272 } 00273 00275 template<class T> 00276 Mat<T> zero_pad(const Mat<T> &m, int rows, int cols) 00277 { 00278 it_assert((rows >= m.rows()) && (cols >= m.cols()), 00279 "zero_pad() cannot shrink the matrix!"); 00280 Mat<T> m2(rows, cols); 00281 m2.set_submatrix(0,m.rows()-1,0,m.cols()-1, m); 00282 if (cols > m.cols()) // Zero 00283 m2.set_submatrix(0,m.rows()-1, m.cols(),cols-1, T(0)); 00284 if (rows > m.rows()) // Zero 00285 m2.set_submatrix(m.rows(), rows-1, 0, cols-1, T(0)); 00286 00287 return m2; 00288 } 00289 00290 00293 template<class T> 00294 T index_zero_pad(const Vec<T> &v, const int index) 00295 { 00296 if (index >= 0 && index < v.size()) 00297 return v(index); 00298 else 00299 return T(0); 00300 } 00301 00302 00304 template<class T> 00305 void transpose(const Mat<T> &m, Mat<T> &out) { out = m.T(); } 00306 00308 template<class T> 00309 Mat<T> transpose(const Mat<T> &m) { return m.T(); } 00310 00311 00314 template<class T> 00315 void hermitian_transpose(const Mat<T> &m, Mat<T> &out) { out = m.H(); } 00316 00318 template<class T> 00319 Mat<T> hermitian_transpose(const Mat<T> &m) { return m.H(); } 00320 00321 00322 00332 template<class Num_T> 00333 bool is_hermitian(const Mat<Num_T>& X) { 00334 00335 if (X == X.H() ) 00336 return true; 00337 else 00338 return false; 00339 } 00340 00350 template<class Num_T> 00351 bool is_unitary(const Mat<Num_T>& X) { 00352 00353 if ( inv(X) == X.H() ) 00354 return true; 00355 else 00356 return false; 00357 } 00358 00359 00368 template<class T> 00369 Vec<T> repmat(const Vec<T> &v, int n) 00370 { 00371 it_assert(n > 0, "repmat(): Wrong repetition parameter"); 00372 int data_length = v.length(); 00373 it_assert(data_length > 0, "repmat(): Input vector can not be empty"); 00374 Vec<T> assembly(data_length * n); 00375 for (int j = 0; j < n; ++j) { 00376 assembly.set_subvector(j * data_length, v); 00377 } 00378 return assembly; 00379 } 00380 00381 00391 template<class T> 00392 Mat<T> repmat(const Mat<T> &data, int m, int n) 00393 { 00394 it_assert((m > 0) && (n > 0), "repmat(): Wrong repetition parameters"); 00395 int data_rows = data.rows(); 00396 int data_cols = data.cols(); 00397 it_assert((data_rows > 0) && (data_cols > 0), "repmat(): Input matrix can " 00398 "not be empty"); 00399 Mat<T> assembly(data_rows*m, data_cols*n); 00400 for (int i = 0; i < m; ++i) { 00401 for (int j = 0; j < n; ++j) { 00402 assembly.set_submatrix(i*data_rows, j*data_cols, data); 00403 } 00404 } 00405 return assembly; 00406 } 00407 00419 template<class T> inline 00420 Mat<T> repmat(const Vec<T> &v, int m, int n, bool transpose = false) 00421 { 00422 return repmat((transpose ? v.T() : Mat<T>(v)), m, n); 00423 } 00424 00425 00437 template<class Num_T> 00438 Mat<Num_T> kron(const Mat<Num_T>& X, const Mat<Num_T>& Y) 00439 { 00440 Mat<Num_T> result(X.rows() * Y.rows(), X.cols() * Y.cols()); 00441 00442 for (int i = 0; i < X.rows(); i++) 00443 for (int j = 0; j < X.cols(); j++) 00444 result.set_submatrix(i * Y.rows(), j * Y.cols(), X(i, j) * Y); 00445 00446 return result; 00447 } 00448 00449 00462 cmat sqrtm(const cmat& A); 00463 00476 cmat sqrtm(const mat& A); 00477 00479 00480 00481 00482 // -------------------- Diagonal matrix functions ------------------------- 00483 00486 00494 template<class T> 00495 Mat<T> diag(const Vec<T> &v, const int K = 0) 00496 { 00497 Mat<T> m(v.size() + std::abs(K), v.size() + std::abs(K)); 00498 m = T(0); 00499 if (K>0) 00500 for (int i=v.size()-1; i>=0; i--) 00501 m(i,i+K) = v(i); 00502 else 00503 for (int i=v.size()-1; i>=0; i--) 00504 m(i-K,i) = v(i); 00505 00506 return m; 00507 } 00508 00516 template<class T> 00517 void diag(const Vec<T> &v, Mat<T> &m) 00518 { 00519 m.set_size(v.size(), v.size(), false); 00520 m = T(0); 00521 for (int i=v.size()-1; i>=0; i--) 00522 m(i,i) = v(i); 00523 } 00524 00531 template<class T> 00532 Vec<T> diag(const Mat<T> &m) 00533 { 00534 Vec<T> t(std::min(m.rows(), m.cols())); 00535 00536 for (int i=0; i<t.size(); i++) 00537 t(i) = m(i,i); 00538 00539 return t; 00540 } 00541 00542 // 00552 template<class T> 00553 Mat<T> bidiag(const Vec<T> &main, const Vec<T> &sup) 00554 { 00555 it_assert(main.size() == sup.size()+1, "bidiag()"); 00556 00557 int n=main.size(); 00558 Mat<T> m(n, n); 00559 m = T(0); 00560 for (int i=0; i<n-1; i++) { 00561 m(i,i) = main(i); 00562 m(i,i+1) = sup(i); 00563 } 00564 m(n-1,n-1) = main(n-1); 00565 00566 return m; 00567 } 00568 00578 template<class T> 00579 void bidiag(const Vec<T> &main, const Vec<T> &sup, Mat<T> &m) 00580 { 00581 it_assert(main.size() == sup.size()+1, "bidiag()"); 00582 00583 int n=main.size(); 00584 m.set_size(n, n); 00585 m = T(0); 00586 for (int i=0; i<n-1; i++) { 00587 m(i,i) = main(i); 00588 m(i,i+1) = sup(i); 00589 } 00590 m(n-1,n-1) = main(n-1); 00591 } 00592 00601 template<class T> 00602 void bidiag(const Mat<T> &m, Vec<T> &main, Vec<T> &sup) 00603 { 00604 it_assert(m.rows() == m.cols(), "bidiag(): Matrix must be square!"); 00605 00606 int n=m.cols(); 00607 main.set_size(n); 00608 sup.set_size(n-1); 00609 for (int i=0; i<n-1; i++) { 00610 main(i) = m(i,i); 00611 sup(i) = m(i,i+1); 00612 } 00613 main(n-1) = m(n-1,n-1); 00614 } 00615 00625 template<class T> 00626 Mat<T> tridiag(const Vec<T> &main, const Vec<T> &sup, const Vec<T> &sub) 00627 { 00628 it_assert(main.size()==sup.size()+1 && main.size()==sub.size()+1, "bidiag()"); 00629 00630 int n=main.size(); 00631 Mat<T> m(n, n); 00632 m = T(0); 00633 for (int i=0; i<n-1; i++) { 00634 m(i,i) = main(i); 00635 m(i,i+1) = sup(i); 00636 m(i+1,i) = sub(i); 00637 } 00638 m(n-1,n-1) = main(n-1); 00639 00640 return m; 00641 } 00642 00652 template<class T> 00653 void tridiag(const Vec<T> &main, const Vec<T> &sup, const Vec<T> &sub, Mat<T> &m) 00654 { 00655 it_assert(main.size()==sup.size()+1 && main.size()==sub.size()+1, "bidiag()"); 00656 00657 int n=main.size(); 00658 m.set_size(n, n); 00659 m = T(0); 00660 for (int i=0; i<n-1; i++) { 00661 m(i,i) = main(i); 00662 m(i,i+1) = sup(i); 00663 m(i+1,i) = sub(i); 00664 } 00665 m(n-1,n-1) = main(n-1); 00666 } 00667 00676 template<class T> 00677 void tridiag(const Mat<T> &m, Vec<T> &main, Vec<T> &sup, Vec<T> &sub) 00678 { 00679 it_assert(m.rows() == m.cols(), "tridiag(): Matrix must be square!"); 00680 00681 int n=m.cols(); 00682 main.set_size(n); 00683 sup.set_size(n-1); 00684 sub.set_size(n-1); 00685 for (int i=0; i<n-1; i++) { 00686 main(i) = m(i,i); 00687 sup(i) = m(i,i+1); 00688 sub(i) = m(i+1,i); 00689 } 00690 main(n-1) = m(n-1,n-1); 00691 } 00692 00693 00697 template<class T> 00698 T trace(const Mat<T> &m) 00699 { 00700 return sum(diag(m)); 00701 } 00702 00704 00705 00706 // ----------------- reshaping vectors and matrices ------------------------ 00707 00710 00712 template<class T> 00713 Vec<T> reverse(const Vec<T> &in) 00714 { 00715 int i, s=in.length(); 00716 00717 Vec<T> out(s); 00718 for (i=0;i<s;i++) 00719 out[i]=in[s-1-i]; 00720 return out; 00721 } 00722 00724 template<class T> 00725 Vec<T> rvectorize(const Mat<T> &m) 00726 { 00727 int i, j, n=0, r=m.rows(), c=m.cols(); 00728 Vec<T> v(r * c); 00729 00730 for (i=0; i<r; i++) 00731 for (j=0; j<c; j++) 00732 v(n++) = m(i,j); 00733 00734 return v; 00735 } 00736 00738 template<class T> 00739 Vec<T> cvectorize(const Mat<T> &m) 00740 { 00741 int i, j, n=0, r=m.rows(), c=m.cols(); 00742 Vec<T> v(r * c); 00743 00744 for (j=0; j<c; j++) 00745 for (i=0; i<r; i++) 00746 v(n++) = m(i,j); 00747 00748 return v; 00749 } 00750 00757 template<class T> 00758 Mat<T> reshape(const Mat<T> &m, int rows, int cols) 00759 { 00760 it_assert_debug(m.rows()*m.cols() == rows*cols, "Mat<T>::reshape: Sizes must match"); 00761 Mat<T> temp(rows, cols); 00762 int i, j, ii=0, jj=0; 00763 for (j=0; j<m.cols(); j++) { 00764 for (i=0; i<m.rows(); i++) { 00765 temp(ii++,jj) = m(i,j); 00766 if (ii == rows) { 00767 jj++; ii=0; 00768 } 00769 } 00770 } 00771 return temp; 00772 } 00773 00780 template<class T> 00781 Mat<T> reshape(const Vec<T> &v, int rows, int cols) 00782 { 00783 it_assert_debug(v.size() == rows*cols, "Mat<T>::reshape: Sizes must match"); 00784 Mat<T> temp(rows, cols); 00785 int i, j, ii=0; 00786 for (j=0; j<cols; j++) { 00787 for (i=0; i<rows; i++) { 00788 temp(i,j) = v(ii++); 00789 } 00790 } 00791 return temp; 00792 } 00793 00795 00796 00798 bool all(const bvec &testvec); 00800 bool any(const bvec &testvec); 00801 00803 00804 // ---------------------------------------------------------------------- 00805 // Instantiations 00806 // ---------------------------------------------------------------------- 00807 00808 #ifdef HAVE_EXTERN_TEMPLATE 00809 00810 extern template int length(const vec &v); 00811 extern template int length(const cvec &v); 00812 extern template int length(const svec &v); 00813 extern template int length(const ivec &v); 00814 extern template int length(const bvec &v); 00815 00816 extern template double sum(const vec &v); 00817 extern template std::complex<double> sum(const cvec &v); 00818 extern template short sum(const svec &v); 00819 extern template int sum(const ivec &v); 00820 extern template bin sum(const bvec &v); 00821 00822 extern template double sum_sqr(const vec &v); 00823 extern template std::complex<double> sum_sqr(const cvec &v); 00824 extern template short sum_sqr(const svec &v); 00825 extern template int sum_sqr(const ivec &v); 00826 extern template bin sum_sqr(const bvec &v); 00827 00828 extern template vec cumsum(const vec &v); 00829 extern template cvec cumsum(const cvec &v); 00830 extern template svec cumsum(const svec &v); 00831 extern template ivec cumsum(const ivec &v); 00832 extern template bvec cumsum(const bvec &v); 00833 00834 extern template double prod(const vec &v); 00835 extern template std::complex<double> prod(const cvec &v); 00836 extern template short prod(const svec &v); 00837 extern template int prod(const ivec &v); 00838 extern template bin prod(const bvec &v); 00839 00840 extern template vec cross(const vec &v1, const vec &v2); 00841 extern template cvec cross(const cvec &v1, const cvec &v2); 00842 extern template ivec cross(const ivec &v1, const ivec &v2); 00843 extern template svec cross(const svec &v1, const svec &v2); 00844 extern template bvec cross(const bvec &v1, const bvec &v2); 00845 00846 extern template vec reverse(const vec &in); 00847 extern template cvec reverse(const cvec &in); 00848 extern template svec reverse(const svec &in); 00849 extern template ivec reverse(const ivec &in); 00850 extern template bvec reverse(const bvec &in); 00851 00852 extern template vec zero_pad(const vec &v, int n); 00853 extern template cvec zero_pad(const cvec &v, int n); 00854 extern template ivec zero_pad(const ivec &v, int n); 00855 extern template svec zero_pad(const svec &v, int n); 00856 extern template bvec zero_pad(const bvec &v, int n); 00857 00858 extern template vec zero_pad(const vec &v); 00859 extern template cvec zero_pad(const cvec &v); 00860 extern template ivec zero_pad(const ivec &v); 00861 extern template svec zero_pad(const svec &v); 00862 extern template bvec zero_pad(const bvec &v); 00863 00864 extern template mat zero_pad(const mat &, int, int); 00865 extern template cmat zero_pad(const cmat &, int, int); 00866 extern template imat zero_pad(const imat &, int, int); 00867 extern template smat zero_pad(const smat &, int, int); 00868 extern template bmat zero_pad(const bmat &, int, int); 00869 00870 extern template vec sum(const mat &m, int dim); 00871 extern template cvec sum(const cmat &m, int dim); 00872 extern template svec sum(const smat &m, int dim); 00873 extern template ivec sum(const imat &m, int dim); 00874 extern template bvec sum(const bmat &m, int dim); 00875 00876 extern template double sumsum(const mat &X); 00877 extern template std::complex<double> sumsum(const cmat &X); 00878 extern template short sumsum(const smat &X); 00879 extern template int sumsum(const imat &X); 00880 extern template bin sumsum(const bmat &X); 00881 00882 extern template vec sum_sqr(const mat & m, int dim); 00883 extern template cvec sum_sqr(const cmat &m, int dim); 00884 extern template svec sum_sqr(const smat &m, int dim); 00885 extern template ivec sum_sqr(const imat &m, int dim); 00886 extern template bvec sum_sqr(const bmat &m, int dim); 00887 00888 extern template mat cumsum(const mat &m, int dim); 00889 extern template cmat cumsum(const cmat &m, int dim); 00890 extern template smat cumsum(const smat &m, int dim); 00891 extern template imat cumsum(const imat &m, int dim); 00892 extern template bmat cumsum(const bmat &m, int dim); 00893 00894 extern template vec prod(const mat &m, int dim); 00895 extern template cvec prod(const cmat &v, int dim); 00896 extern template svec prod(const smat &m, int dim); 00897 extern template ivec prod(const imat &m, int dim); 00898 extern template bvec prod(const bmat &m, int dim); 00899 00900 extern template vec diag(const mat &in); 00901 extern template cvec diag(const cmat &in); 00902 extern template void diag(const vec &in, mat &m); 00903 extern template void diag(const cvec &in, cmat &m); 00904 extern template mat diag(const vec &v, const int K); 00905 extern template cmat diag(const cvec &v, const int K); 00906 00907 extern template mat bidiag(const vec &, const vec &); 00908 extern template cmat bidiag(const cvec &, const cvec &); 00909 extern template void bidiag(const vec &, const vec &, mat &); 00910 extern template void bidiag(const cvec &, const cvec &, cmat &); 00911 extern template void bidiag(const mat &, vec &, vec &); 00912 extern template void bidiag(const cmat &, cvec &, cvec &); 00913 00914 extern template mat tridiag(const vec &main, const vec &, const vec &); 00915 extern template cmat tridiag(const cvec &main, const cvec &, const cvec &); 00916 extern template void tridiag(const vec &main, const vec &, const vec &, mat &); 00917 extern template void tridiag(const cvec &main, const cvec &, const cvec &, cmat &); 00918 extern template void tridiag(const mat &m, vec &, vec &, vec &); 00919 extern template void tridiag(const cmat &m, cvec &, cvec &, cvec &); 00920 00921 extern template double trace(const mat &in); 00922 extern template std::complex<double> trace(const cmat &in); 00923 extern template short trace(const smat &in); 00924 extern template int trace(const imat &in); 00925 extern template bin trace(const bmat &in); 00926 00927 extern template void transpose(const mat &m, mat &out); 00928 extern template void transpose(const cmat &m, cmat &out); 00929 extern template void transpose(const smat &m, smat &out); 00930 extern template void transpose(const imat &m, imat &out); 00931 extern template void transpose(const bmat &m, bmat &out); 00932 00933 extern template mat transpose(const mat &m); 00934 extern template cmat transpose(const cmat &m); 00935 extern template smat transpose(const smat &m); 00936 extern template imat transpose(const imat &m); 00937 extern template bmat transpose(const bmat &m); 00938 00939 extern template void hermitian_transpose(const mat &m, mat &out); 00940 extern template void hermitian_transpose(const cmat &m, cmat &out); 00941 extern template void hermitian_transpose(const smat &m, smat &out); 00942 extern template void hermitian_transpose(const imat &m, imat &out); 00943 extern template void hermitian_transpose(const bmat &m, bmat &out); 00944 00945 extern template mat hermitian_transpose(const mat &m); 00946 extern template cmat hermitian_transpose(const cmat &m); 00947 extern template smat hermitian_transpose(const smat &m); 00948 extern template imat hermitian_transpose(const imat &m); 00949 extern template bmat hermitian_transpose(const bmat &m); 00950 00951 extern template bool is_hermitian(const mat &X); 00952 extern template bool is_hermitian(const cmat &X); 00953 00954 extern template bool is_unitary(const mat &X); 00955 extern template bool is_unitary(const cmat &X); 00956 00957 extern template vec rvectorize(const mat &m); 00958 extern template cvec rvectorize(const cmat &m); 00959 extern template ivec rvectorize(const imat &m); 00960 extern template svec rvectorize(const smat &m); 00961 extern template bvec rvectorize(const bmat &m); 00962 00963 extern template vec cvectorize(const mat &m); 00964 extern template cvec cvectorize(const cmat &m); 00965 extern template ivec cvectorize(const imat &m); 00966 extern template svec cvectorize(const smat &m); 00967 extern template bvec cvectorize(const bmat &m); 00968 00969 extern template mat reshape(const mat &m, int rows, int cols); 00970 extern template cmat reshape(const cmat &m, int rows, int cols); 00971 extern template imat reshape(const imat &m, int rows, int cols); 00972 extern template smat reshape(const smat &m, int rows, int cols); 00973 extern template bmat reshape(const bmat &m, int rows, int cols); 00974 00975 extern template mat reshape(const vec &m, int rows, int cols); 00976 extern template cmat reshape(const cvec &m, int rows, int cols); 00977 extern template imat reshape(const ivec &m, int rows, int cols); 00978 extern template smat reshape(const svec &m, int rows, int cols); 00979 extern template bmat reshape(const bvec &m, int rows, int cols); 00980 00981 extern template mat kron(const mat &X, const mat &Y); 00982 extern template cmat kron(const cmat &X, const cmat &Y); 00983 extern template imat kron(const imat &X, const imat &Y); 00984 extern template smat kron(const smat &X, const smat &Y); 00985 extern template bmat kron(const bmat &X, const bmat &Y); 00986 00987 extern template vec repmat(const vec &v, int n); 00988 extern template cvec repmat(const cvec &v, int n); 00989 extern template ivec repmat(const ivec &v, int n); 00990 extern template svec repmat(const svec &v, int n); 00991 extern template bvec repmat(const bvec &v, int n); 00992 00993 extern template mat repmat(const vec &v, int m, int n, bool transpose); 00994 extern template cmat repmat(const cvec &v, int m, int n, bool transpose); 00995 extern template imat repmat(const ivec &v, int m, int n, bool transpose); 00996 extern template smat repmat(const svec &v, int m, int n, bool transpose); 00997 extern template bmat repmat(const bvec &v, int m, int n, bool transpose); 00998 00999 extern template mat repmat(const mat &data, int m, int n); 01000 extern template cmat repmat(const cmat &data, int m, int n); 01001 extern template imat repmat(const imat &data, int m, int n); 01002 extern template smat repmat(const smat &data, int m, int n); 01003 extern template bmat repmat(const bmat &data, int m, int n); 01004 01005 #endif // HAVE_EXTERN_TEMPLATE 01006 01008 01009 } // namespace itpp 01010 01011 #endif // #ifndef MATFUNC_H
Generated on Sun Sep 14 18:52:34 2008 for IT++ by Doxygen 1.5.6