00001 00033 #ifndef MATFUNC_H 00034 #define MATFUNC_H 00035 00036 #include <itpp/base/vec.h> 00037 #include <itpp/base/mat.h> 00038 00039 00040 namespace itpp { 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 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 00099 template<class T> 00100 T sum_sqr(const Vec<T> &v) 00101 { 00102 T M=0; 00103 00104 for (int i=0; i<v.length(); i++) 00105 M += v[i] * v[i]; 00106 00107 return M; 00108 } 00109 00117 template<class T> 00118 Vec<T> sum_sqr(const Mat<T> &m, int dim=1) 00119 { 00120 it_assert((dim == 1) || (dim == 2), "sum_sqr: dimension need to be 1 or 2"); 00121 Vec<T> out; 00122 00123 if (dim == 1) { 00124 out.set_size(m.cols(), false); 00125 00126 for (int i=0; i<m.cols(); i++) 00127 out(i) = sum_sqr(m.get_col(i)); 00128 } 00129 else { 00130 out.set_size(m.rows(), false); 00131 00132 for (int i=0; i<m.rows(); i++) 00133 out(i) = sum_sqr(m.get_row(i)); 00134 } 00135 00136 return out; 00137 } 00138 00140 template<class T> 00141 Vec<T> cumsum(const Vec<T> &v) 00142 { 00143 Vec<T> out(v.size()); 00144 00145 out(0)=v(0); 00146 for (int i=1; i<v.size(); i++) 00147 out(i) = out(i-1) + v(i); 00148 00149 return out; 00150 } 00151 00159 template<class T> 00160 Mat<T> cumsum(const Mat<T> &m, int dim=1) 00161 { 00162 it_assert((dim == 1) || (dim == 2), "cumsum: dimension need to be 1 or 2"); 00163 Mat<T> out(m.rows(), m.cols()); 00164 00165 if (dim == 1) { 00166 for (int i=0; i<m.cols(); i++) 00167 out.set_col(i, cumsum(m.get_col(i))); 00168 } else { 00169 for (int i=0; i<m.rows(); i++) 00170 out.set_row(i, cumsum(m.get_row(i))); 00171 } 00172 00173 return out; 00174 } 00175 00177 template<class T> 00178 T prod(const Vec<T> &v) 00179 { 00180 it_assert(v.size() >= 1, "prod: size of vector should be at least 1"); 00181 T out = v(0); 00182 00183 for (int i=1; i<v.size(); i++) 00184 out *= v(i); 00185 00186 return out; 00187 } 00188 00196 template<class T> 00197 Vec<T> prod(const Mat<T> &m, int dim=1) 00198 { 00199 it_assert((dim == 1) || (dim == 2), "prod: dimension need to be 1 or 2"); 00200 Vec<T> out(m.cols()); 00201 00202 if (dim == 1) { 00203 it_assert((m.cols() >= 1) && (m.rows() >= 1), 00204 "prod: number of columns should be at least 1"); 00205 out.set_size(m.cols(), false); 00206 00207 for (int i=0; i<m.cols(); i++) 00208 out(i) = prod(m.get_col(i)); 00209 } 00210 else { 00211 it_assert((m.cols() >= 1) && (m.rows() >= 1), 00212 "prod: number of rows should be at least 1"); 00213 out.set_size(m.rows(), false); 00214 00215 for (int i=0; i<m.rows(); i++) 00216 out(i) = prod(m.get_row(i)); 00217 } 00218 return out; 00219 } 00220 00222 template<class T> 00223 Vec<T> cross(const Vec<T> &v1, const Vec<T> &v2) 00224 { 00225 it_assert((v1.size() == 3) && (v2.size() == 3), 00226 "cross: vectors should be of size 3"); 00227 00228 Vec<T> r(3); 00229 00230 r(0) = v1(1) * v2(2) - v1(2) * v2(1); 00231 r(1) = v1(2) * v2(0) - v1(0) * v2(2); 00232 r(2) = v1(0) * v2(1) - v1(1) * v2(0); 00233 00234 return r; 00235 } 00236 00237 00239 template<class T, class fT> 00240 Vec<T> apply_function(fT (*f)(fT), const Vec<T> &data) 00241 { 00242 Vec<T> out(data.length()); 00243 00244 for (int i=0;i<data.length();i++) 00245 out[i]=T(f(fT(data[i]))); 00246 return out; 00247 } 00248 00249 00251 template<class T, class fT> 00252 Mat<T> apply_function(fT (*f)(fT), const Mat<T> &data) 00253 { 00254 Mat<T> out(data.rows(),data.cols()); 00255 00256 for (int i=0;i<out.rows();i++) 00257 for (int j=0;j<out.cols();j++) 00258 //out(i,j)=static_cast<T>(f(static_cast<fT>(data(i,j)))); 00259 out(i,j)=T(f(fT(data(i,j)))); 00260 00261 return out; 00262 } 00263 00264 00266 template<class T> 00267 Vec<T> zero_pad(const Vec<T> &v, int n) 00268 { 00269 it_assert(n >= v.size(), "zero_pad() cannot shrink the vector!"); 00270 Vec<T> v2(n); 00271 v2.set_subvector(0, v.size()-1, v); 00272 if (n > v.size()) 00273 v2.set_subvector(v.size(), n-1, T(0)); 00274 00275 return v2; 00276 } 00277 00279 template<class T> 00280 Vec<T> zero_pad(const Vec<T> &v) 00281 { 00282 int n = pow2i(levels2bits(v.size())); 00283 00284 return (n == v.size()) ? v : zero_pad(v, n); 00285 } 00286 00288 template<class T> 00289 Mat<T> zero_pad(const Mat<T> &m, int rows, int cols) 00290 { 00291 it_assert((rows >= m.rows()) && (cols >= m.cols()), 00292 "zero_pad() cannot shrink the matrix!"); 00293 Mat<T> m2(rows, cols); 00294 m2.set_submatrix(0,m.rows()-1,0,m.cols()-1, m); 00295 if (cols > m.cols()) // Zero 00296 m2.set_submatrix(0,m.rows()-1, m.cols(),cols-1, T(0)); 00297 if (rows > m.rows()) // Zero 00298 m2.set_submatrix(m.rows(), rows-1, 0, cols-1, T(0)); 00299 00300 return m2; 00301 } 00302 00303 00306 template<class T> 00307 T index_zero_pad(const Vec<T> &v, const int index) 00308 { 00309 if (index >= 0 && index < v.size()) 00310 return v(index); 00311 else 00312 return T(0); 00313 } 00314 00315 00317 template<class T> 00318 void transpose(const Mat<T> &m, Mat<T> &out) { out = m.T(); } 00319 00321 template<class T> 00322 Mat<T> transpose(const Mat<T> &m) { return m.T(); } 00323 00324 00327 template<class T> 00328 void hermitian_transpose(const Mat<T> &m, Mat<T> &out) { out = m.H(); } 00329 00331 template<class T> 00332 Mat<T> hermitian_transpose(const Mat<T> &m) { return m.H(); } 00333 00334 00335 00345 template<class Num_T> 00346 bool is_hermitian(const Mat<Num_T>& X) { 00347 00348 if (X == X.H() ) 00349 return true; 00350 else 00351 return false; 00352 } 00353 00363 template<class Num_T> 00364 bool is_unitary(const Mat<Num_T>& X) { 00365 00366 if ( inv(X) == X.H() ) 00367 return true; 00368 else 00369 return false; 00370 } 00371 00372 00384 template<class Num_T> 00385 Mat<Num_T> kron(const Mat<Num_T>& X, const Mat<Num_T>& Y) 00386 { 00387 Mat<Num_T> result(X.rows() * Y.rows(), X.cols() * Y.cols()); 00388 00389 for (int i = 0; i < X.rows(); i++) 00390 for (int j = 0; j < X.cols(); j++) 00391 result.set_submatrix(i * Y.rows(), j * Y.cols(), X(i, j) * Y); 00392 00393 return result; 00394 } 00395 00396 00409 cmat sqrtm(const cmat& A); 00410 00423 cmat sqrtm(const mat& A); 00424 00426 00427 00428 00429 // -------------------- Diagonal matrix functions --------------------------------------- 00430 00436 00437 00445 template<class T> 00446 Mat<T> diag(const Vec<T> &v, const int K = 0) 00447 { 00448 Mat<T> m(v.size()+abs(K), v.size()+abs(K)); 00449 m = T(0); 00450 if (K>0) 00451 for (int i=v.size()-1; i>=0; i--) 00452 m(i,i+K) = v(i); 00453 else 00454 for (int i=v.size()-1; i>=0; i--) 00455 m(i-K,i) = v(i); 00456 00457 return m; 00458 } 00459 00467 template<class T> 00468 void diag(const Vec<T> &v, Mat<T> &m) 00469 { 00470 m.set_size(v.size(), v.size(), false); 00471 m = T(0); 00472 for (int i=v.size()-1; i>=0; i--) 00473 m(i,i) = v(i); 00474 } 00475 00482 template<class T> 00483 Vec<T> diag(const Mat<T> &m) 00484 { 00485 Vec<T> t(std::min(m.rows(), m.cols())); 00486 00487 for (int i=0; i<t.size(); i++) 00488 t(i) = m(i,i); 00489 00490 return t; 00491 } 00492 00502 template<class T> 00503 Mat<T> bidiag(const Vec<T> &main, const Vec<T> &sup) 00504 { 00505 it_assert(main.size() == sup.size()+1, "bidiag()"); 00506 00507 int n=main.size(); 00508 Mat<T> m(n, n); 00509 m = T(0); 00510 for (int i=0; i<n-1; i++) { 00511 m(i,i) = main(i); 00512 m(i,i+1) = sup(i); 00513 } 00514 m(n-1,n-1) = main(n-1); 00515 00516 return m; 00517 } 00518 00528 template<class T> 00529 void bidiag(const Vec<T> &main, const Vec<T> &sup, Mat<T> &m) 00530 { 00531 it_assert(main.size() == sup.size()+1, "bidiag()"); 00532 00533 int n=main.size(); 00534 m.set_size(n, n); 00535 m = T(0); 00536 for (int i=0; i<n-1; i++) { 00537 m(i,i) = main(i); 00538 m(i,i+1) = sup(i); 00539 } 00540 m(n-1,n-1) = main(n-1); 00541 } 00542 00551 template<class T> 00552 void bidiag(const Mat<T> &m, Vec<T> &main, Vec<T> &sup) 00553 { 00554 it_assert(m.rows() == m.cols(), "bidiag(): Matrix must be square!"); 00555 00556 int n=m.cols(); 00557 main.set_size(n); 00558 sup.set_size(n-1); 00559 for (int i=0; i<n-1; i++) { 00560 main(i) = m(i,i); 00561 sup(i) = m(i,i+1); 00562 } 00563 main(n-1) = m(n-1,n-1); 00564 } 00565 00575 template<class T> 00576 Mat<T> tridiag(const Vec<T> &main, const Vec<T> &sup, const Vec<T> &sub) 00577 { 00578 it_assert(main.size()==sup.size()+1 && main.size()==sub.size()+1, "bidiag()"); 00579 00580 int n=main.size(); 00581 Mat<T> m(n, n); 00582 m = T(0); 00583 for (int i=0; i<n-1; i++) { 00584 m(i,i) = main(i); 00585 m(i,i+1) = sup(i); 00586 m(i+1,i) = sub(i); 00587 } 00588 m(n-1,n-1) = main(n-1); 00589 00590 return m; 00591 } 00592 00602 template<class T> 00603 void tridiag(const Vec<T> &main, const Vec<T> &sup, const Vec<T> &sub, Mat<T> &m) 00604 { 00605 it_assert(main.size()==sup.size()+1 && main.size()==sub.size()+1, "bidiag()"); 00606 00607 int n=main.size(); 00608 m.set_size(n, n); 00609 m = T(0); 00610 for (int i=0; i<n-1; i++) { 00611 m(i,i) = main(i); 00612 m(i,i+1) = sup(i); 00613 m(i+1,i) = sub(i); 00614 } 00615 m(n-1,n-1) = main(n-1); 00616 } 00617 00626 template<class T> 00627 void tridiag(const Mat<T> &m, Vec<T> &main, Vec<T> &sup, Vec<T> &sub) 00628 { 00629 it_assert(m.rows() == m.cols(), "tridiag(): Matrix must be square!"); 00630 00631 int n=m.cols(); 00632 main.set_size(n); 00633 sup.set_size(n-1); 00634 sub.set_size(n-1); 00635 for (int i=0; i<n-1; i++) { 00636 main(i) = m(i,i); 00637 sup(i) = m(i,i+1); 00638 sub(i) = m(i+1,i); 00639 } 00640 main(n-1) = m(n-1,n-1); 00641 } 00642 00643 00644 00648 template<class T> 00649 T trace(const Mat<T> &m) 00650 { 00651 return sum(diag(m)); 00652 } 00653 00655 00656 00657 // ----------------- reshaping vectors and matrices --------------------------- 00663 00664 00666 template<class T> 00667 Vec<T> reverse(const Vec<T> &in) 00668 { 00669 int i, s=in.length(); 00670 00671 Vec<T> out(s); 00672 for (i=0;i<s;i++) 00673 out[i]=in[s-1-i]; 00674 return out; 00675 } 00676 00678 template<class T> 00679 Vec<T> rvectorize(const Mat<T> &m) 00680 { 00681 int i, j, n=0, r=m.rows(), c=m.cols(); 00682 Vec<T> v(r * c); 00683 00684 for (i=0; i<r; i++) 00685 for (j=0; j<c; j++) 00686 v(n++) = m(i,j); 00687 00688 return v; 00689 } 00690 00692 template<class T> 00693 Vec<T> cvectorize(const Mat<T> &m) 00694 { 00695 int i, j, n=0, r=m.rows(), c=m.cols(); 00696 Vec<T> v(r * c); 00697 00698 for (j=0; j<c; j++) 00699 for (i=0; i<r; i++) 00700 v(n++) = m(i,j); 00701 00702 return v; 00703 } 00704 00711 template<class T> 00712 Mat<T> reshape(const Mat<T> &m, int rows, int cols) 00713 { 00714 it_assert1(m.rows()*m.cols() == rows*cols, "Mat<T>::reshape: Sizes must match"); 00715 Mat<T> temp(rows, cols); 00716 int i, j, ii=0, jj=0; 00717 for (j=0; j<m.cols(); j++) { 00718 for (i=0; i<m.rows(); i++) { 00719 temp(ii++,jj) = m(i,j); 00720 if (ii == rows) { 00721 jj++; ii=0; 00722 } 00723 } 00724 } 00725 return temp; 00726 } 00727 00734 template<class T> 00735 Mat<T> reshape(const Vec<T> &v, int rows, int cols) 00736 { 00737 it_assert1(v.size() == rows*cols, "Mat<T>::reshape: Sizes must match"); 00738 Mat<T> temp(rows, cols); 00739 int i, j, ii=0; 00740 for (j=0; j<cols; j++) { 00741 for (i=0; i<rows; i++) { 00742 temp(i,j) = v(ii++); 00743 } 00744 } 00745 return temp; 00746 } 00747 00749 00750 00755 00756 00758 template<class T> 00759 Vec<T> repeat(const Vec<T> &v, int norepeats) 00760 { 00761 Vec<T> temp(v.length()*norepeats); 00762 00763 for(int i=0; i<v.length(); i++) { 00764 for(int j=0;j<norepeats;j++) 00765 temp(i*norepeats+j)=v(i); 00766 } 00767 return temp; 00768 } 00769 00771 template<class T> 00772 Mat<T> repeat(const Mat<T> &m, int norepeats) 00773 { 00774 Mat<T> temp(m.rows(), m.cols()*norepeats); 00775 00776 for (int j=0; j<m.cols(); j++) { 00777 for (int i=0;i<norepeats;i++) { 00778 temp.set_col(j*norepeats+i, m.get_col(j)); 00779 } 00780 } 00781 return temp; 00782 } 00783 00785 template<class T> 00786 void upsample(const Vec<T> &v, int usf, Vec<T> &u) 00787 { 00788 it_assert1(usf >= 1, "upsample: upsampling factor must be equal or greater than one" ); 00789 u.set_size(v.length()*usf); 00790 u.clear(); 00791 for(long i=0;i<v.length();i++) 00792 u(i*usf)=v(i); 00793 } 00794 00795 00797 template<class T> 00798 Vec<T> upsample(const Vec<T> &v, int usf) 00799 { 00800 Vec<T> u; 00801 upsample(v,usf,u); 00802 return u; 00803 } 00804 00806 template<class T> 00807 void upsample(const Mat<T> &v, int usf, Mat<T> &u) 00808 { 00809 it_assert1(usf >= 1, "upsample: upsampling factor must be equal or greater than one" ); 00810 u.set_size(v.rows(),v.cols()*usf); 00811 u.clear(); 00812 for (long j=0;j<v.cols();j++) 00813 u.set_col(j*usf,v.get_col(j)); 00814 } 00815 00817 template<class T> 00818 Mat<T> upsample(const Mat<T> &v, int usf) 00819 { 00820 Mat<T> u; 00821 upsample(v,usf,u); 00822 return u; 00823 } 00824 00826 template<class T> 00827 void lininterp(const Mat<T> &m, int usf, Mat<T> &u) 00828 { 00829 it_assert1(usf >= 1, "lininterp: upsampling factor must be equal or greater than one" ); 00830 long L = (m.cols()-1)*usf+1; 00831 u.set_size(m.rows(),L); 00832 for (long i = 0; i < m.rows(); i++){ 00833 for (long j = 0; j < L-1; j++) 00834 u(i,j) = (m(i,j/usf) + (j % usf)/((double)usf)*(m(i,(j+usf)/usf)-m(i,j/usf))); 00835 u(i,L-1) = m(i,m.cols()-1); 00836 } 00837 } 00838 00850 template<class T> 00851 Mat<T> lininterp(const Mat<T> &m, const double f_base, const double f_ups, const int nrof_samples, const double t_start = 0) 00852 { 00853 double t_base = 1 / f_base; 00854 double t_ups = 1 / f_ups; 00855 int rows = m.rows(); 00856 int cols = m.cols(); 00857 it_assert1(f_ups > f_base, "lininterp: upsampled frequency must be greater than base frequency" ); 00858 it_assert1((t_start >= 0) && (t_start < cols * t_base), "lininterp: incorrect start time offset"); 00859 it_assert1((nrof_samples * t_ups + t_start) <= (cols * t_base), "lininterp: too many samples required or input data to short"); 00860 Mat<T> u(rows, nrof_samples); 00861 double curr_time = t_start; 00862 00863 int i = 0; 00864 int k = 0; 00865 while (i < cols - 1) { 00866 while ((curr_time < (i + 1) * t_base) && (k < nrof_samples)) { 00867 for (int j = 0; j < rows; j++) { 00868 u(j, k) = (m(j, i) * ((i + 1) * t_base - curr_time) 00869 - m(j, i + 1) * (i * t_base - curr_time)) / t_base; 00870 } 00871 k++; 00872 curr_time += t_ups; 00873 } 00874 i++; 00875 } 00876 return u; 00877 } 00878 00879 00881 template<class T> 00882 Mat<T> lininterp(const Mat<T> &m, int usf) 00883 { 00884 Mat<T> u; 00885 lininterp(m,usf,u); 00886 return u; 00887 } 00888 00890 template<class T> 00891 void lininterp(const Vec<T> &v, int usf, Vec<T> &u) 00892 { 00893 it_assert1(usf >= 1, "lininterp: upsampling factor must be equal or greater than one" ); 00894 long L = (v.length()-1)*usf+1; 00895 u.set_size(L); 00896 for (long j = 0; j < L-1; j++) { 00897 u(j) = (v(j/usf) + (j % usf)/((double)usf)*(v((j+usf)/usf)-v(j/usf))); 00898 } 00899 u(L-1) = v(v.length()-1); 00900 } 00901 00903 template<class T> 00904 Vec<T> lininterp(const Vec<T> &v, int usf) 00905 { 00906 Vec<T> u; 00907 lininterp(v,usf,u); 00908 return u; 00909 } 00910 00922 template<class T> 00923 Vec<T> lininterp(const Vec<T> &v, const double f_base, const double f_ups, const int nrof_samples, const double t_start = 0) 00924 { 00925 double t_base = 1 / f_base; 00926 double t_ups = 1 / f_ups; 00927 int len = v.length(); 00928 it_assert1(f_ups > f_base, "lininterp: upsampled frequency must be greater than base frequency" ); 00929 it_assert1((t_start >= 0) && (t_start < len * t_base), "lininterp: incorrect start time offset"); 00930 it_assert1((nrof_samples * t_ups + t_start) <= (len * t_base), "lininterp: too many samples required or input data to short"); 00931 Vec<T> u(nrof_samples); 00932 double curr_time = t_start; 00933 00934 int i = 0; 00935 int k = 0; 00936 while (i < len - 1) { 00937 while ((curr_time < (i + 1) * t_base) && (k < nrof_samples)) { 00938 u(k) = (v(i) * ((i + 1) * t_base - curr_time) 00939 - v(i + 1) * (i * t_base - curr_time)) / t_base; 00940 k++; 00941 curr_time += t_ups; 00942 } 00943 i++; 00944 } 00945 return u; 00946 } 00947 00949 00950 // ---------------------- Instantiations ----------------------------------------- 00951 #ifndef _MSC_VER 00952 00954 extern template int length(const vec &v); 00956 extern template int length(const cvec &v); 00958 extern template int length(const svec &v); 00960 extern template int length(const ivec &v); 00962 extern template int length(const bvec &v); 00963 00965 extern template double sum(const vec &v); 00967 extern template std::complex<double> sum(const cvec &v); 00969 extern template short sum(const svec &v); 00971 extern template int sum(const ivec &v); 00973 extern template bin sum(const bvec &v); 00974 00976 extern template double sum_sqr(const vec &v); 00978 extern template std::complex<double> sum_sqr(const cvec &v); 00980 extern template short sum_sqr(const svec &v); 00982 extern template int sum_sqr(const ivec &v); 00984 extern template bin sum_sqr(const bvec &v); 00985 00987 extern template vec cumsum(const vec &v); 00989 extern template cvec cumsum(const cvec &v); 00991 extern template svec cumsum(const svec &v); 00993 extern template ivec cumsum(const ivec &v); 00995 extern template bvec cumsum(const bvec &v); 00996 00998 extern template double prod(const vec &v); 01000 extern template std::complex<double> prod(const cvec &v); 01002 extern template short prod(const svec &v); 01004 extern template int prod(const ivec &v); 01006 extern template bin prod(const bvec &v); 01007 01009 extern template vec cross(const vec &v1, const vec &v2); 01011 extern template ivec cross(const ivec &v1, const ivec &v2); 01013 extern template svec cross(const svec &v1, const svec &v2); 01014 01016 extern template vec reverse(const vec &in); 01018 extern template cvec reverse(const cvec &in); 01020 extern template svec reverse(const svec &in); 01022 extern template ivec reverse(const ivec &in); 01024 extern template bvec reverse(const bvec &in); 01025 01027 extern template vec repeat(const vec &v, int norepeats); 01029 extern template cvec repeat(const cvec &v, int norepeats); 01031 extern template svec repeat(const svec &v, int norepeats); 01033 extern template ivec repeat(const ivec &v, int norepeats); 01035 extern template bvec repeat(const bvec &v, int norepeats); 01036 01038 extern template vec apply_function(float (*f)(float), const vec &data); 01040 extern template vec apply_function(double (*f)(double), const vec &data); 01042 extern template cvec apply_function(std::complex<double> (*f)(std::complex<double>), const cvec &data); 01044 extern template svec apply_function(short (*f)(short), const svec &data); 01046 extern template ivec apply_function(int (*f)(int), const ivec &data); 01048 extern template bvec apply_function(bin (*f)(bin), const bvec &data); 01049 01051 extern template ivec zero_pad(const ivec &v, int n); 01053 extern template vec zero_pad(const vec &v, int n); 01055 extern template cvec zero_pad(const cvec &v, int n); 01057 extern template bvec zero_pad(const bvec &v, int n); 01058 01060 extern template ivec zero_pad(const ivec &v); 01062 extern template vec zero_pad(const vec &v); 01064 extern template cvec zero_pad(const cvec &v); 01066 extern template bvec zero_pad(const bvec &v); 01067 01069 extern template mat zero_pad(const mat &, int, int); 01071 extern template cmat zero_pad(const cmat &, int, int); 01073 extern template imat zero_pad(const imat &, int, int); 01075 extern template bmat zero_pad(const bmat &, int, int); 01076 01078 extern template vec sum(const mat &m, int dim); 01080 extern template cvec sum(const cmat &m, int dim); 01082 extern template svec sum(const smat &m, int dim); 01084 extern template ivec sum(const imat &m, int dim); 01086 extern template bvec sum(const bmat &m, int dim); 01087 01089 extern template vec sum_sqr(const mat & m, int dim); 01091 extern template cvec sum_sqr(const cmat &m, int dim); 01093 extern template svec sum_sqr(const smat &m, int dim); 01095 extern template ivec sum_sqr(const imat &m, int dim); 01097 extern template bvec sum_sqr(const bmat &m, int dim); 01098 01100 extern template mat cumsum(const mat &m, int dim); 01102 extern template cmat cumsum(const cmat &m, int dim); 01104 extern template smat cumsum(const smat &m, int dim); 01106 extern template imat cumsum(const imat &m, int dim); 01108 extern template bmat cumsum(const bmat &m, int dim); 01109 01111 extern template vec prod(const mat &m, int dim); 01112 // Extern Template instantiation of product 01113 extern template cvec prod(const cmat &v, int dim); 01115 extern template svec prod(const smat &m, int dim); 01117 extern template ivec prod(const imat &m, int dim); 01118 01120 extern template vec diag(const mat &in); 01122 extern template cvec diag(const cmat &in); 01123 01125 extern template void diag(const vec &in, mat &m); 01127 extern template void diag(const cvec &in, cmat &m); 01128 01130 extern template mat diag(const vec &v, const int K); 01132 extern template cmat diag(const cvec &v, const int K); 01133 01135 extern template mat bidiag(const vec &, const vec &); 01137 extern template cmat bidiag(const cvec &, const cvec &); 01138 01140 extern template void bidiag(const vec &, const vec &, mat &); 01142 extern template void bidiag(const cvec &, const cvec &, cmat &); 01143 01145 extern template void bidiag(const mat &, vec &, vec &); 01147 extern template void bidiag(const cmat &, cvec &, cvec &); 01148 01150 extern template mat tridiag(const vec &main, const vec &, const vec &); 01152 extern template cmat tridiag(const cvec &main, const cvec &, const cvec &); 01153 01155 extern template void tridiag(const vec &main, const vec &, const vec &, mat &); 01157 extern template void tridiag(const cvec &main, const cvec &, const cvec &, cmat &); 01158 01160 extern template void tridiag(const mat &m, vec &, vec &, vec &); 01162 extern template void tridiag(const cmat &m, cvec &, cvec &, cvec &); 01163 01165 extern template double trace(const mat &in); 01167 extern template std::complex<double> trace(const cmat &in); 01169 extern template short trace(const smat &in); 01171 extern template int trace(const imat &in); 01173 extern template bin trace(const bmat &in); 01174 01176 extern template void transpose(const mat &m, mat &out); 01178 extern template void transpose(const cmat &m, cmat &out); 01180 extern template void transpose(const smat &m, smat &out); 01182 extern template void transpose(const imat &m, imat &out); 01184 extern template void transpose(const bmat &m, bmat &out); 01185 01187 extern template mat transpose(const mat &m); 01189 extern template cmat transpose(const cmat &m); 01191 extern template smat transpose(const smat &m); 01193 extern template imat transpose(const imat &m); 01195 extern template bmat transpose(const bmat &m); 01196 01197 01199 extern template void hermitian_transpose(const mat &m, mat &out); 01201 extern template void hermitian_transpose(const cmat &m, cmat &out); 01203 extern template void hermitian_transpose(const smat &m, smat &out); 01205 extern template void hermitian_transpose(const imat &m, imat &out); 01207 extern template void hermitian_transpose(const bmat &m, bmat &out); 01208 01210 extern template mat hermitian_transpose(const mat &m); 01212 extern template cmat hermitian_transpose(const cmat &m); 01214 extern template smat hermitian_transpose(const smat &m); 01216 extern template imat hermitian_transpose(const imat &m); 01218 extern template bmat hermitian_transpose(const bmat &m); 01219 01220 01222 extern template bool is_hermitian(const mat &X); 01224 extern template bool is_hermitian(const cmat &X); 01225 01227 extern template bool is_unitary(const mat &X); 01229 extern template bool is_unitary(const cmat &X); 01230 01232 extern template mat repeat(const mat &m, int norepeats); 01234 extern template cmat repeat(const cmat &m, int norepeats); 01236 extern template smat repeat(const smat &m, int norepeats); 01238 extern template imat repeat(const imat &m, int norepeats); 01240 extern template bmat repeat(const bmat &m, int norepeats); 01241 01243 extern template mat apply_function(float (*f)(float), const mat &data); 01245 extern template mat apply_function(double (*f)(double), const mat &data); 01247 extern template cmat apply_function(std::complex<double> (*f)(std::complex<double>), const cmat &data); 01249 extern template smat apply_function(short (*f)(short), const smat &data); 01251 extern template imat apply_function(int (*f)(int), const imat &data); 01253 extern template bmat apply_function(bin (*f)(bin), const bmat &data); 01254 01256 extern template vec rvectorize(const mat &m); 01258 extern template cvec rvectorize(const cmat &m); 01260 extern template ivec rvectorize(const imat &m); 01262 extern template bvec rvectorize(const bmat &m); 01263 01265 extern template vec cvectorize(const mat &m); 01267 extern template cvec cvectorize(const cmat &m); 01269 extern template ivec cvectorize(const imat &m); 01271 extern template bvec cvectorize(const bmat &m); 01272 01274 extern template mat reshape(const mat &m, int rows, int cols); 01276 extern template cmat reshape(const cmat &m, int rows, int cols); 01278 extern template imat reshape(const imat &m, int rows, int cols); 01280 extern template bmat reshape(const bmat &m, int rows, int cols); 01281 01283 extern template mat reshape(const vec &m, int rows, int cols); 01285 extern template cmat reshape(const cvec &m, int rows, int cols); 01287 extern template imat reshape(const ivec &m, int rows, int cols); 01289 extern template bmat reshape(const bvec &m, int rows, int cols); 01290 01292 extern template vec upsample(const vec &v, int usf); 01294 extern template cvec upsample(const cvec &v, int usf); 01296 extern template svec upsample(const svec &v, int usf); 01298 extern template ivec upsample(const ivec &v, int usf); 01300 extern template bvec upsample(const bvec &v, int usf); 01301 01303 extern template mat upsample(const mat &v, int usf); 01305 extern template cmat upsample(const cmat &v, int usf); 01307 extern template smat upsample(const smat &v, int usf); 01309 extern template imat upsample(const imat &v, int usf); 01311 extern template bmat upsample(const bmat &v, int usf); 01312 01314 extern template void upsample(const vec &v, int usf, vec &u); 01316 extern template void upsample(const cvec &v, int usf, cvec &u); 01318 extern template void upsample(const svec &v, int usf, svec &u); 01320 extern template void upsample(const ivec &v, int usf, ivec &u); 01322 extern template void upsample(const bvec &v, int usf, bvec &u); 01323 01325 extern template void upsample(const mat &v, int usf, mat &u); 01327 extern template void upsample(const cmat &v, int usf, cmat &u); 01329 extern template void upsample(const smat &v, int usf, smat &u); 01331 extern template void upsample(const imat &v, int usf, imat &u); 01333 extern template void upsample(const bmat &v, int usf, bmat &u); 01334 01336 extern template vec lininterp(const vec &v, int usf); 01338 extern template cvec lininterp(const cvec &v, int usf); 01339 01341 extern template mat lininterp(const mat &v, int usf); 01343 extern template cmat lininterp(const cmat &v, int usf); 01344 01346 extern template void lininterp(const vec &v, int usf, vec &u); 01348 extern template void lininterp(const cvec &v, int usf, cvec &u); 01349 01351 extern template void lininterp(const mat &v, int usf, mat &u); 01353 extern template void lininterp(const cmat &v, int usf, cmat &u); 01354 01356 extern template mat lininterp(const mat &m, const double f_base, const double f_ups, const int nrof_samples, const double t_start); 01358 extern template cmat lininterp(const cmat &m, const double f_base, const double f_ups, const int nrof_samples, const double t_start); 01359 01361 extern template vec lininterp(const vec &v, const double f_base, const double f_ups, const int nrof_samples, const double t_start); 01363 extern template cvec lininterp(const cvec &v, const double f_base, const double f_ups, const int nrof_samples, const double t_start); 01364 #endif 01365 01366 } // namespace itpp 01367 01368 #endif // #ifndef MATFUNC_H 01369
Generated on Sat Aug 25 23:37:27 2007 for IT++ by Doxygen 1.5.2