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 00497 template<class T> 00498 Mat<T> diag(const Vec<T> &v, const int K = 0) 00499 { 00500 Mat<T> m(v.size() + std::abs(K), v.size() + std::abs(K)); 00501 m = T(0); 00502 if (K>0) 00503 for (int i=v.size()-1; i>=0; i--) 00504 m(i,i+K) = v(i); 00505 else 00506 for (int i=v.size()-1; i>=0; i--) 00507 m(i-K,i) = v(i); 00508 00509 return m; 00510 } 00511 00521 template<class T> 00522 void diag(const Vec<T> &v, Mat<T> &m) 00523 { 00524 m.set_size(v.size(), v.size(), false); 00525 m = T(0); 00526 for (int i=v.size()-1; i>=0; i--) 00527 m(i,i) = v(i); 00528 } 00529 00537 template<class T> 00538 Vec<T> diag(const Mat<T> &m) 00539 { 00540 Vec<T> t(std::min(m.rows(), m.cols())); 00541 00542 for (int i=0; i<t.size(); i++) 00543 t(i) = m(i,i); 00544 00545 return t; 00546 } 00547 00557 template<class T> 00558 Mat<T> bidiag(const Vec<T> &main, const Vec<T> &sup) 00559 { 00560 it_assert(main.size() == sup.size()+1, "bidiag()"); 00561 00562 int n=main.size(); 00563 Mat<T> m(n, n); 00564 m = T(0); 00565 for (int i=0; i<n-1; i++) { 00566 m(i,i) = main(i); 00567 m(i,i+1) = sup(i); 00568 } 00569 m(n-1,n-1) = main(n-1); 00570 00571 return m; 00572 } 00573 00583 template<class T> 00584 void bidiag(const Vec<T> &main, const Vec<T> &sup, Mat<T> &m) 00585 { 00586 it_assert(main.size() == sup.size()+1, "bidiag()"); 00587 00588 int n=main.size(); 00589 m.set_size(n, n); 00590 m = T(0); 00591 for (int i=0; i<n-1; i++) { 00592 m(i,i) = main(i); 00593 m(i,i+1) = sup(i); 00594 } 00595 m(n-1,n-1) = main(n-1); 00596 } 00597 00606 template<class T> 00607 void bidiag(const Mat<T> &m, Vec<T> &main, Vec<T> &sup) 00608 { 00609 it_assert(m.rows() == m.cols(), "bidiag(): Matrix must be square!"); 00610 00611 int n=m.cols(); 00612 main.set_size(n); 00613 sup.set_size(n-1); 00614 for (int i=0; i<n-1; i++) { 00615 main(i) = m(i,i); 00616 sup(i) = m(i,i+1); 00617 } 00618 main(n-1) = m(n-1,n-1); 00619 } 00620 00630 template<class T> 00631 Mat<T> tridiag(const Vec<T> &main, const Vec<T> &sup, const Vec<T> &sub) 00632 { 00633 it_assert(main.size()==sup.size()+1 && main.size()==sub.size()+1, "bidiag()"); 00634 00635 int n=main.size(); 00636 Mat<T> m(n, n); 00637 m = T(0); 00638 for (int i=0; i<n-1; i++) { 00639 m(i,i) = main(i); 00640 m(i,i+1) = sup(i); 00641 m(i+1,i) = sub(i); 00642 } 00643 m(n-1,n-1) = main(n-1); 00644 00645 return m; 00646 } 00647 00657 template<class T> 00658 void tridiag(const Vec<T> &main, const Vec<T> &sup, const Vec<T> &sub, Mat<T> &m) 00659 { 00660 it_assert(main.size()==sup.size()+1 && main.size()==sub.size()+1, "bidiag()"); 00661 00662 int n=main.size(); 00663 m.set_size(n, n); 00664 m = T(0); 00665 for (int i=0; i<n-1; i++) { 00666 m(i,i) = main(i); 00667 m(i,i+1) = sup(i); 00668 m(i+1,i) = sub(i); 00669 } 00670 m(n-1,n-1) = main(n-1); 00671 } 00672 00681 template<class T> 00682 void tridiag(const Mat<T> &m, Vec<T> &main, Vec<T> &sup, Vec<T> &sub) 00683 { 00684 it_assert(m.rows() == m.cols(), "tridiag(): Matrix must be square!"); 00685 00686 int n=m.cols(); 00687 main.set_size(n); 00688 sup.set_size(n-1); 00689 sub.set_size(n-1); 00690 for (int i=0; i<n-1; i++) { 00691 main(i) = m(i,i); 00692 sup(i) = m(i,i+1); 00693 sub(i) = m(i+1,i); 00694 } 00695 main(n-1) = m(n-1,n-1); 00696 } 00697 00698 00702 template<class T> 00703 T trace(const Mat<T> &m) 00704 { 00705 return sum(diag(m)); 00706 } 00707 00709 00710 00711 // ----------------- reshaping vectors and matrices ------------------------ 00712 00715 00717 template<class T> 00718 Vec<T> reverse(const Vec<T> &in) 00719 { 00720 int i, s=in.length(); 00721 00722 Vec<T> out(s); 00723 for (i=0;i<s;i++) 00724 out[i]=in[s-1-i]; 00725 return out; 00726 } 00727 00729 template<class T> 00730 Vec<T> rvectorize(const Mat<T> &m) 00731 { 00732 int i, j, n=0, r=m.rows(), c=m.cols(); 00733 Vec<T> v(r * c); 00734 00735 for (i=0; i<r; i++) 00736 for (j=0; j<c; j++) 00737 v(n++) = m(i,j); 00738 00739 return v; 00740 } 00741 00743 template<class T> 00744 Vec<T> cvectorize(const Mat<T> &m) 00745 { 00746 int i, j, n=0, r=m.rows(), c=m.cols(); 00747 Vec<T> v(r * c); 00748 00749 for (j=0; j<c; j++) 00750 for (i=0; i<r; i++) 00751 v(n++) = m(i,j); 00752 00753 return v; 00754 } 00755 00762 template<class T> 00763 Mat<T> reshape(const Mat<T> &m, int rows, int cols) 00764 { 00765 it_assert_debug(m.rows()*m.cols() == rows*cols, "Mat<T>::reshape: Sizes must match"); 00766 Mat<T> temp(rows, cols); 00767 int i, j, ii=0, jj=0; 00768 for (j=0; j<m.cols(); j++) { 00769 for (i=0; i<m.rows(); i++) { 00770 temp(ii++,jj) = m(i,j); 00771 if (ii == rows) { 00772 jj++; ii=0; 00773 } 00774 } 00775 } 00776 return temp; 00777 } 00778 00785 template<class T> 00786 Mat<T> reshape(const Vec<T> &v, int rows, int cols) 00787 { 00788 it_assert_debug(v.size() == rows*cols, "Mat<T>::reshape: Sizes must match"); 00789 Mat<T> temp(rows, cols); 00790 int i, j, ii=0; 00791 for (j=0; j<cols; j++) { 00792 for (i=0; i<rows; i++) { 00793 temp(i,j) = v(ii++); 00794 } 00795 } 00796 return temp; 00797 } 00798 00800 00801 00803 bool all(const bvec &testvec); 00805 bool any(const bvec &testvec); 00806 00808 00809 // ---------------------------------------------------------------------- 00810 // Instantiations 00811 // ---------------------------------------------------------------------- 00812 00813 #ifdef HAVE_EXTERN_TEMPLATE 00814 00815 extern template int length(const vec &v); 00816 extern template int length(const cvec &v); 00817 extern template int length(const svec &v); 00818 extern template int length(const ivec &v); 00819 extern template int length(const bvec &v); 00820 00821 extern template double sum(const vec &v); 00822 extern template std::complex<double> sum(const cvec &v); 00823 extern template short sum(const svec &v); 00824 extern template int sum(const ivec &v); 00825 extern template bin sum(const bvec &v); 00826 00827 extern template double sum_sqr(const vec &v); 00828 extern template std::complex<double> sum_sqr(const cvec &v); 00829 extern template short sum_sqr(const svec &v); 00830 extern template int sum_sqr(const ivec &v); 00831 extern template bin sum_sqr(const bvec &v); 00832 00833 extern template vec cumsum(const vec &v); 00834 extern template cvec cumsum(const cvec &v); 00835 extern template svec cumsum(const svec &v); 00836 extern template ivec cumsum(const ivec &v); 00837 extern template bvec cumsum(const bvec &v); 00838 00839 extern template double prod(const vec &v); 00840 extern template std::complex<double> prod(const cvec &v); 00841 extern template short prod(const svec &v); 00842 extern template int prod(const ivec &v); 00843 extern template bin prod(const bvec &v); 00844 00845 extern template vec cross(const vec &v1, const vec &v2); 00846 extern template cvec cross(const cvec &v1, const cvec &v2); 00847 extern template ivec cross(const ivec &v1, const ivec &v2); 00848 extern template svec cross(const svec &v1, const svec &v2); 00849 extern template bvec cross(const bvec &v1, const bvec &v2); 00850 00851 extern template vec reverse(const vec &in); 00852 extern template cvec reverse(const cvec &in); 00853 extern template svec reverse(const svec &in); 00854 extern template ivec reverse(const ivec &in); 00855 extern template bvec reverse(const bvec &in); 00856 00857 extern template vec zero_pad(const vec &v, int n); 00858 extern template cvec zero_pad(const cvec &v, int n); 00859 extern template ivec zero_pad(const ivec &v, int n); 00860 extern template svec zero_pad(const svec &v, int n); 00861 extern template bvec zero_pad(const bvec &v, int n); 00862 00863 extern template vec zero_pad(const vec &v); 00864 extern template cvec zero_pad(const cvec &v); 00865 extern template ivec zero_pad(const ivec &v); 00866 extern template svec zero_pad(const svec &v); 00867 extern template bvec zero_pad(const bvec &v); 00868 00869 extern template mat zero_pad(const mat &, int, int); 00870 extern template cmat zero_pad(const cmat &, int, int); 00871 extern template imat zero_pad(const imat &, int, int); 00872 extern template smat zero_pad(const smat &, int, int); 00873 extern template bmat zero_pad(const bmat &, int, int); 00874 00875 extern template vec sum(const mat &m, int dim); 00876 extern template cvec sum(const cmat &m, int dim); 00877 extern template svec sum(const smat &m, int dim); 00878 extern template ivec sum(const imat &m, int dim); 00879 extern template bvec sum(const bmat &m, int dim); 00880 00881 extern template double sumsum(const mat &X); 00882 extern template std::complex<double> sumsum(const cmat &X); 00883 extern template short sumsum(const smat &X); 00884 extern template int sumsum(const imat &X); 00885 extern template bin sumsum(const bmat &X); 00886 00887 extern template vec sum_sqr(const mat & m, int dim); 00888 extern template cvec sum_sqr(const cmat &m, int dim); 00889 extern template svec sum_sqr(const smat &m, int dim); 00890 extern template ivec sum_sqr(const imat &m, int dim); 00891 extern template bvec sum_sqr(const bmat &m, int dim); 00892 00893 extern template mat cumsum(const mat &m, int dim); 00894 extern template cmat cumsum(const cmat &m, int dim); 00895 extern template smat cumsum(const smat &m, int dim); 00896 extern template imat cumsum(const imat &m, int dim); 00897 extern template bmat cumsum(const bmat &m, int dim); 00898 00899 extern template vec prod(const mat &m, int dim); 00900 extern template cvec prod(const cmat &v, int dim); 00901 extern template svec prod(const smat &m, int dim); 00902 extern template ivec prod(const imat &m, int dim); 00903 extern template bvec prod(const bmat &m, int dim); 00904 00905 extern template vec diag(const mat &in); 00906 extern template cvec diag(const cmat &in); 00907 extern template void diag(const vec &in, mat &m); 00908 extern template void diag(const cvec &in, cmat &m); 00909 extern template mat diag(const vec &v, const int K); 00910 extern template cmat diag(const cvec &v, const int K); 00911 00912 extern template mat bidiag(const vec &, const vec &); 00913 extern template cmat bidiag(const cvec &, const cvec &); 00914 extern template void bidiag(const vec &, const vec &, mat &); 00915 extern template void bidiag(const cvec &, const cvec &, cmat &); 00916 extern template void bidiag(const mat &, vec &, vec &); 00917 extern template void bidiag(const cmat &, cvec &, cvec &); 00918 00919 extern template mat tridiag(const vec &main, const vec &, const vec &); 00920 extern template cmat tridiag(const cvec &main, const cvec &, const cvec &); 00921 extern template void tridiag(const vec &main, const vec &, const vec &, mat &); 00922 extern template void tridiag(const cvec &main, const cvec &, const cvec &, cmat &); 00923 extern template void tridiag(const mat &m, vec &, vec &, vec &); 00924 extern template void tridiag(const cmat &m, cvec &, cvec &, cvec &); 00925 00926 extern template double trace(const mat &in); 00927 extern template std::complex<double> trace(const cmat &in); 00928 extern template short trace(const smat &in); 00929 extern template int trace(const imat &in); 00930 extern template bin trace(const bmat &in); 00931 00932 extern template void transpose(const mat &m, mat &out); 00933 extern template void transpose(const cmat &m, cmat &out); 00934 extern template void transpose(const smat &m, smat &out); 00935 extern template void transpose(const imat &m, imat &out); 00936 extern template void transpose(const bmat &m, bmat &out); 00937 00938 extern template mat transpose(const mat &m); 00939 extern template cmat transpose(const cmat &m); 00940 extern template smat transpose(const smat &m); 00941 extern template imat transpose(const imat &m); 00942 extern template bmat transpose(const bmat &m); 00943 00944 extern template void hermitian_transpose(const mat &m, mat &out); 00945 extern template void hermitian_transpose(const cmat &m, cmat &out); 00946 extern template void hermitian_transpose(const smat &m, smat &out); 00947 extern template void hermitian_transpose(const imat &m, imat &out); 00948 extern template void hermitian_transpose(const bmat &m, bmat &out); 00949 00950 extern template mat hermitian_transpose(const mat &m); 00951 extern template cmat hermitian_transpose(const cmat &m); 00952 extern template smat hermitian_transpose(const smat &m); 00953 extern template imat hermitian_transpose(const imat &m); 00954 extern template bmat hermitian_transpose(const bmat &m); 00955 00956 extern template bool is_hermitian(const mat &X); 00957 extern template bool is_hermitian(const cmat &X); 00958 00959 extern template bool is_unitary(const mat &X); 00960 extern template bool is_unitary(const cmat &X); 00961 00962 extern template vec rvectorize(const mat &m); 00963 extern template cvec rvectorize(const cmat &m); 00964 extern template ivec rvectorize(const imat &m); 00965 extern template svec rvectorize(const smat &m); 00966 extern template bvec rvectorize(const bmat &m); 00967 00968 extern template vec cvectorize(const mat &m); 00969 extern template cvec cvectorize(const cmat &m); 00970 extern template ivec cvectorize(const imat &m); 00971 extern template svec cvectorize(const smat &m); 00972 extern template bvec cvectorize(const bmat &m); 00973 00974 extern template mat reshape(const mat &m, int rows, int cols); 00975 extern template cmat reshape(const cmat &m, int rows, int cols); 00976 extern template imat reshape(const imat &m, int rows, int cols); 00977 extern template smat reshape(const smat &m, int rows, int cols); 00978 extern template bmat reshape(const bmat &m, int rows, int cols); 00979 00980 extern template mat reshape(const vec &m, int rows, int cols); 00981 extern template cmat reshape(const cvec &m, int rows, int cols); 00982 extern template imat reshape(const ivec &m, int rows, int cols); 00983 extern template smat reshape(const svec &m, int rows, int cols); 00984 extern template bmat reshape(const bvec &m, int rows, int cols); 00985 00986 extern template mat kron(const mat &X, const mat &Y); 00987 extern template cmat kron(const cmat &X, const cmat &Y); 00988 extern template imat kron(const imat &X, const imat &Y); 00989 extern template smat kron(const smat &X, const smat &Y); 00990 extern template bmat kron(const bmat &X, const bmat &Y); 00991 00992 extern template vec repmat(const vec &v, int n); 00993 extern template cvec repmat(const cvec &v, int n); 00994 extern template ivec repmat(const ivec &v, int n); 00995 extern template svec repmat(const svec &v, int n); 00996 extern template bvec repmat(const bvec &v, int n); 00997 00998 extern template mat repmat(const vec &v, int m, int n, bool transpose); 00999 extern template cmat repmat(const cvec &v, int m, int n, bool transpose); 01000 extern template imat repmat(const ivec &v, int m, int n, bool transpose); 01001 extern template smat repmat(const svec &v, int m, int n, bool transpose); 01002 extern template bmat repmat(const bvec &v, int m, int n, bool transpose); 01003 01004 extern template mat repmat(const mat &data, int m, int n); 01005 extern template cmat repmat(const cmat &data, int m, int n); 01006 extern template imat repmat(const imat &data, int m, int n); 01007 extern template smat repmat(const smat &data, int m, int n); 01008 extern template bmat repmat(const bmat &data, int m, int n); 01009 01010 #endif // HAVE_EXTERN_TEMPLATE 01011 01013 01014 } // namespace itpp 01015 01016 #endif // #ifndef MATFUNC_H
Generated on Sun Apr 20 12:40:05 2008 for IT++ by Doxygen 1.5.5