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 00443 template<class T> 00444 Mat<T> diag(const Vec<T> &v, const int K = 0) 00445 { 00446 Mat<T> m(v.size()+abs(K), v.size()+abs(K)); 00447 m = T(0); 00448 if (K>0) 00449 for (int i=v.size()-1; i>=0; i--) 00450 m(i,i+K) = v(i); 00451 else 00452 for (int i=v.size()-1; i>=0; i--) 00453 m(i-K,i) = v(i); 00454 00455 return m; 00456 } 00457 00464 template<class T> 00465 void diag(const Vec<T> &v, Mat<T> &m) 00466 { 00467 m.set_size(v.size(), v.size(), false); 00468 m = T(0); 00469 for (int i=v.size()-1; i>=0; i--) 00470 m(i,i) = v(i); 00471 } 00472 00478 template<class T> 00479 Vec<T> diag(const Mat<T> &m) 00480 { 00481 Vec<T> t(std::min(m.rows(), m.cols())); 00482 00483 for (int i=0; i<t.size(); i++) 00484 t(i) = m(i,i); 00485 00486 return t; 00487 } 00488 00489 // 00497 template<class T> 00498 Mat<T> bidiag(const Vec<T> &main, const Vec<T> &sup) 00499 { 00500 it_assert(main.size() == sup.size()+1, "bidiag()"); 00501 00502 int n=main.size(); 00503 Mat<T> m(n, n); 00504 m = T(0); 00505 for (int i=0; i<n-1; i++) { 00506 m(i,i) = main(i); 00507 m(i,i+1) = sup(i); 00508 } 00509 m(n-1,n-1) = main(n-1); 00510 00511 return m; 00512 } 00513 00521 template<class T> 00522 void bidiag(const Vec<T> &main, const Vec<T> &sup, Mat<T> &m) 00523 { 00524 it_assert(main.size() == sup.size()+1, "bidiag()"); 00525 00526 int n=main.size(); 00527 m.set_size(n, n); 00528 m = T(0); 00529 for (int i=0; i<n-1; i++) { 00530 m(i,i) = main(i); 00531 m(i,i+1) = sup(i); 00532 } 00533 m(n-1,n-1) = main(n-1); 00534 } 00535 00542 template<class T> 00543 void bidiag(const Mat<T> &m, Vec<T> &main, Vec<T> &sup) 00544 { 00545 it_assert(m.rows() == m.cols(), "bidiag(): Matrix must be square!"); 00546 00547 int n=m.cols(); 00548 main.set_size(n); 00549 sup.set_size(n-1); 00550 for (int i=0; i<n-1; i++) { 00551 main(i) = m(i,i); 00552 sup(i) = m(i,i+1); 00553 } 00554 main(n-1) = m(n-1,n-1); 00555 } 00556 00564 template<class T> 00565 Mat<T> tridiag(const Vec<T> &main, const Vec<T> &sup, const Vec<T> &sub) 00566 { 00567 it_assert(main.size()==sup.size()+1 && main.size()==sub.size()+1, "bidiag()"); 00568 00569 int n=main.size(); 00570 Mat<T> m(n, n); 00571 m = T(0); 00572 for (int i=0; i<n-1; i++) { 00573 m(i,i) = main(i); 00574 m(i,i+1) = sup(i); 00575 m(i+1,i) = sub(i); 00576 } 00577 m(n-1,n-1) = main(n-1); 00578 00579 return m; 00580 } 00581 00589 template<class T> 00590 void tridiag(const Vec<T> &main, const Vec<T> &sup, const Vec<T> &sub, Mat<T> &m) 00591 { 00592 it_assert(main.size()==sup.size()+1 && main.size()==sub.size()+1, "bidiag()"); 00593 00594 int n=main.size(); 00595 m.set_size(n, n); 00596 m = T(0); 00597 for (int i=0; i<n-1; i++) { 00598 m(i,i) = main(i); 00599 m(i,i+1) = sup(i); 00600 m(i+1,i) = sub(i); 00601 } 00602 m(n-1,n-1) = main(n-1); 00603 } 00604 00611 template<class T> 00612 void tridiag(const Mat<T> &m, Vec<T> &main, Vec<T> &sup, Vec<T> &sub) 00613 { 00614 it_assert(m.rows() == m.cols(), "tridiag(): Matrix must be square!"); 00615 00616 int n=m.cols(); 00617 main.set_size(n); 00618 sup.set_size(n-1); 00619 sub.set_size(n-1); 00620 for (int i=0; i<n-1; i++) { 00621 main(i) = m(i,i); 00622 sup(i) = m(i,i+1); 00623 sub(i) = m(i+1,i); 00624 } 00625 main(n-1) = m(n-1,n-1); 00626 } 00627 00628 00629 00633 template<class T> 00634 T trace(const Mat<T> &m) 00635 { 00636 return sum(diag(m)); 00637 } 00638 00640 00641 00642 // ----------------- reshaping vectors and matrices --------------------------- 00648 00649 00651 template<class T> 00652 Vec<T> reverse(const Vec<T> &in) 00653 { 00654 int i, s=in.length(); 00655 00656 Vec<T> out(s); 00657 for (i=0;i<s;i++) 00658 out[i]=in[s-1-i]; 00659 return out; 00660 } 00661 00663 template<class T> 00664 Vec<T> rvectorize(const Mat<T> &m) 00665 { 00666 int i, j, n=0, r=m.rows(), c=m.cols(); 00667 Vec<T> v(r * c); 00668 00669 for (i=0; i<r; i++) 00670 for (j=0; j<c; j++) 00671 v(n++) = m(i,j); 00672 00673 return v; 00674 } 00675 00677 template<class T> 00678 Vec<T> cvectorize(const Mat<T> &m) 00679 { 00680 int i, j, n=0, r=m.rows(), c=m.cols(); 00681 Vec<T> v(r * c); 00682 00683 for (j=0; j<c; j++) 00684 for (i=0; i<r; i++) 00685 v(n++) = m(i,j); 00686 00687 return v; 00688 } 00689 00695 template<class T> 00696 Mat<T> reshape(const Mat<T> &m, int rows, int cols) 00697 { 00698 it_assert1(m.rows()*m.cols() == rows*cols, "Mat<T>::reshape: Sizes must match"); 00699 Mat<T> temp(rows, cols); 00700 int i, j, ii=0, jj=0; 00701 for (j=0; j<m.cols(); j++) { 00702 for (i=0; i<m.rows(); i++) { 00703 temp(ii++,jj) = m(i,j); 00704 if (ii == rows) { 00705 jj++; ii=0; 00706 } 00707 } 00708 } 00709 return temp; 00710 } 00711 00717 template<class T> 00718 Mat<T> reshape(const Vec<T> &v, int rows, int cols) 00719 { 00720 it_assert1(v.size() == rows*cols, "Mat<T>::reshape: Sizes must match"); 00721 Mat<T> temp(rows, cols); 00722 int i, j, ii=0; 00723 for (j=0; j<cols; j++) { 00724 for (i=0; i<rows; i++) { 00725 temp(i,j) = v(ii++); 00726 } 00727 } 00728 return temp; 00729 } 00730 00732 00733 00738 00739 00741 template<class T> 00742 Vec<T> repeat(const Vec<T> &v, int norepeats) 00743 { 00744 Vec<T> temp(v.length()*norepeats); 00745 00746 for(int i=0; i<v.length(); i++) { 00747 for(int j=0;j<norepeats;j++) 00748 temp(i*norepeats+j)=v(i); 00749 } 00750 return temp; 00751 } 00752 00754 template<class T> 00755 Mat<T> repeat(const Mat<T> &m, int norepeats) 00756 { 00757 Mat<T> temp(m.rows(), m.cols()*norepeats); 00758 00759 for (int j=0; j<m.cols(); j++) { 00760 for (int i=0;i<norepeats;i++) { 00761 temp.set_col(j*norepeats+i, m.get_col(j)); 00762 } 00763 } 00764 return temp; 00765 } 00766 00768 template<class T> 00769 void upsample(const Vec<T> &v, int usf, Vec<T> &u) 00770 { 00771 it_assert1(usf >= 1, "upsample: upsampling factor must be equal or greater than one" ); 00772 u.set_size(v.length()*usf); 00773 u.clear(); 00774 for(long i=0;i<v.length();i++) 00775 u(i*usf)=v(i); 00776 } 00777 00778 00780 template<class T> 00781 Vec<T> upsample(const Vec<T> &v, int usf) 00782 { 00783 Vec<T> u; 00784 upsample(v,usf,u); 00785 return u; 00786 } 00787 00789 template<class T> 00790 void upsample(const Mat<T> &v, int usf, Mat<T> &u) 00791 { 00792 it_assert1(usf >= 1, "upsample: upsampling factor must be equal or greater than one" ); 00793 u.set_size(v.rows(),v.cols()*usf); 00794 u.clear(); 00795 for (long j=0;j<v.cols();j++) 00796 u.set_col(j*usf,v.get_col(j)); 00797 } 00798 00800 template<class T> 00801 Mat<T> upsample(const Mat<T> &v, int usf) 00802 { 00803 Mat<T> u; 00804 upsample(v,usf,u); 00805 return u; 00806 } 00807 00809 template<class T> 00810 void lininterp(const Mat<T> &m, int usf, Mat<T> &u) 00811 { 00812 it_assert1(usf >= 1, "lininterp: upsampling factor must be equal or greater than one" ); 00813 long L = (m.cols()-1)*usf+1; 00814 u.set_size(m.rows(),L); 00815 for (long i = 0; i < m.rows(); i++){ 00816 for (long j = 0; j < L-1; j++) 00817 u(i,j) = (m(i,j/usf) + (j % usf)/((double)usf)*(m(i,(j+usf)/usf)-m(i,j/usf))); 00818 u(i,L-1) = m(i,m.cols()-1); 00819 } 00820 } 00821 00833 template<class T> 00834 Mat<T> lininterp(const Mat<T> &m, const double f_base, const double f_ups, const int nrof_samples, const double t_start = 0) 00835 { 00836 double t_base = 1 / f_base; 00837 double t_ups = 1 / f_ups; 00838 int rows = m.rows(); 00839 int cols = m.cols(); 00840 it_assert1(f_ups > f_base, "lininterp: upsampled frequency must be greater than base frequency" ); 00841 it_assert1((t_start >= 0) && (t_start < cols * t_base), "lininterp: incorrect start time offset"); 00842 it_assert1((nrof_samples * t_ups + t_start) <= (cols * t_base), "lininterp: too many samples required or input data to short"); 00843 Mat<T> u(rows, nrof_samples); 00844 double curr_time = t_start; 00845 00846 int i = 0; 00847 int k = 0; 00848 while (i < cols - 1) { 00849 while ((curr_time < (i + 1) * t_base) && (k < nrof_samples)) { 00850 for (int j = 0; j < rows; j++) { 00851 u(j, k) = (m(j, i) * ((i + 1) * t_base - curr_time) 00852 - m(j, i + 1) * (i * t_base - curr_time)) / t_base; 00853 } 00854 k++; 00855 curr_time += t_ups; 00856 } 00857 i++; 00858 } 00859 return u; 00860 } 00861 00862 00864 template<class T> 00865 Mat<T> lininterp(const Mat<T> &m, int usf) 00866 { 00867 Mat<T> u; 00868 lininterp(m,usf,u); 00869 return u; 00870 } 00871 00873 template<class T> 00874 void lininterp(const Vec<T> &v, int usf, Vec<T> &u) 00875 { 00876 it_assert1(usf >= 1, "lininterp: upsampling factor must be equal or greater than one" ); 00877 long L = (v.length()-1)*usf+1; 00878 u.set_size(L); 00879 for (long j = 0; j < L-1; j++) { 00880 u(j) = (v(j/usf) + (j % usf)/((double)usf)*(v((j+usf)/usf)-v(j/usf))); 00881 } 00882 u(L-1) = v(v.length()-1); 00883 } 00884 00886 template<class T> 00887 Vec<T> lininterp(const Vec<T> &v, int usf) 00888 { 00889 Vec<T> u; 00890 lininterp(v,usf,u); 00891 return u; 00892 } 00893 00905 template<class T> 00906 Vec<T> lininterp(const Vec<T> &v, const double f_base, const double f_ups, const int nrof_samples, const double t_start = 0) 00907 { 00908 double t_base = 1 / f_base; 00909 double t_ups = 1 / f_ups; 00910 int len = v.length(); 00911 it_assert1(f_ups > f_base, "lininterp: upsampled frequency must be greater than base frequency" ); 00912 it_assert1((t_start >= 0) && (t_start < len * t_base), "lininterp: incorrect start time offset"); 00913 it_assert1((nrof_samples * t_ups + t_start) <= (len * t_base), "lininterp: too many samples required or input data to short"); 00914 Vec<T> u(nrof_samples); 00915 double curr_time = t_start; 00916 00917 int i = 0; 00918 int k = 0; 00919 while (i < len - 1) { 00920 while ((curr_time < (i + 1) * t_base) && (k < nrof_samples)) { 00921 u(k) = (v(i) * ((i + 1) * t_base - curr_time) 00922 - v(i + 1) * (i * t_base - curr_time)) / t_base; 00923 k++; 00924 curr_time += t_ups; 00925 } 00926 i++; 00927 } 00928 return u; 00929 } 00930 00932 00933 // ---------------------- Instantiations ----------------------------------------- 00934 #ifndef _MSC_VER 00935 00937 extern template int length(const vec &v); 00939 extern template int length(const cvec &v); 00941 extern template int length(const svec &v); 00943 extern template int length(const ivec &v); 00945 extern template int length(const bvec &v); 00946 00948 extern template double sum(const vec &v); 00950 extern template std::complex<double> sum(const cvec &v); 00952 extern template short sum(const svec &v); 00954 extern template int sum(const ivec &v); 00956 extern template bin sum(const bvec &v); 00957 00959 extern template double sum_sqr(const vec &v); 00961 extern template std::complex<double> sum_sqr(const cvec &v); 00963 extern template short sum_sqr(const svec &v); 00965 extern template int sum_sqr(const ivec &v); 00967 extern template bin sum_sqr(const bvec &v); 00968 00970 extern template vec cumsum(const vec &v); 00972 extern template cvec cumsum(const cvec &v); 00974 extern template svec cumsum(const svec &v); 00976 extern template ivec cumsum(const ivec &v); 00978 extern template bvec cumsum(const bvec &v); 00979 00981 extern template double prod(const vec &v); 00983 extern template std::complex<double> prod(const cvec &v); 00985 extern template short prod(const svec &v); 00987 extern template int prod(const ivec &v); 00989 extern template bin prod(const bvec &v); 00990 00992 extern template vec cross(const vec &v1, const vec &v2); 00994 extern template ivec cross(const ivec &v1, const ivec &v2); 00996 extern template svec cross(const svec &v1, const svec &v2); 00997 00999 extern template vec reverse(const vec &in); 01001 extern template cvec reverse(const cvec &in); 01003 extern template svec reverse(const svec &in); 01005 extern template ivec reverse(const ivec &in); 01007 extern template bvec reverse(const bvec &in); 01008 01010 extern template vec repeat(const vec &v, int norepeats); 01012 extern template cvec repeat(const cvec &v, int norepeats); 01014 extern template svec repeat(const svec &v, int norepeats); 01016 extern template ivec repeat(const ivec &v, int norepeats); 01018 extern template bvec repeat(const bvec &v, int norepeats); 01019 01021 extern template vec apply_function(float (*f)(float), const vec &data); 01023 extern template vec apply_function(double (*f)(double), const vec &data); 01025 extern template cvec apply_function(std::complex<double> (*f)(std::complex<double>), const cvec &data); 01027 extern template svec apply_function(short (*f)(short), const svec &data); 01029 extern template ivec apply_function(int (*f)(int), const ivec &data); 01031 extern template bvec apply_function(bin (*f)(bin), const bvec &data); 01032 01034 extern template ivec zero_pad(const ivec &v, int n); 01036 extern template vec zero_pad(const vec &v, int n); 01038 extern template cvec zero_pad(const cvec &v, int n); 01040 extern template bvec zero_pad(const bvec &v, int n); 01041 01043 extern template ivec zero_pad(const ivec &v); 01045 extern template vec zero_pad(const vec &v); 01047 extern template cvec zero_pad(const cvec &v); 01049 extern template bvec zero_pad(const bvec &v); 01050 01052 extern template mat zero_pad(const mat &, int, int); 01054 extern template cmat zero_pad(const cmat &, int, int); 01056 extern template imat zero_pad(const imat &, int, int); 01058 extern template bmat zero_pad(const bmat &, int, int); 01059 01061 extern template vec sum(const mat &m, int dim); 01063 extern template cvec sum(const cmat &m, int dim); 01065 extern template svec sum(const smat &m, int dim); 01067 extern template ivec sum(const imat &m, int dim); 01069 extern template bvec sum(const bmat &m, int dim); 01070 01072 extern template vec sum_sqr(const mat & m, int dim); 01074 extern template cvec sum_sqr(const cmat &m, int dim); 01076 extern template svec sum_sqr(const smat &m, int dim); 01078 extern template ivec sum_sqr(const imat &m, int dim); 01080 extern template bvec sum_sqr(const bmat &m, int dim); 01081 01083 extern template mat cumsum(const mat &m, int dim); 01085 extern template cmat cumsum(const cmat &m, int dim); 01087 extern template smat cumsum(const smat &m, int dim); 01089 extern template imat cumsum(const imat &m, int dim); 01091 extern template bmat cumsum(const bmat &m, int dim); 01092 01094 extern template vec prod(const mat &m, int dim); 01095 // Extern Template instantiation of product 01096 extern template cvec prod(const cmat &v, int dim); 01098 extern template svec prod(const smat &m, int dim); 01100 extern template ivec prod(const imat &m, int dim); 01101 01103 extern template vec diag(const mat &in); 01105 extern template cvec diag(const cmat &in); 01106 01108 extern template void diag(const vec &in, mat &m); 01110 extern template void diag(const cvec &in, cmat &m); 01111 01113 extern template mat diag(const vec &v, const int K); 01115 extern template cmat diag(const cvec &v, const int K); 01116 01118 extern template mat bidiag(const vec &, const vec &); 01120 extern template cmat bidiag(const cvec &, const cvec &); 01121 01123 extern template void bidiag(const vec &, const vec &, mat &); 01125 extern template void bidiag(const cvec &, const cvec &, cmat &); 01126 01128 extern template void bidiag(const mat &, vec &, vec &); 01130 extern template void bidiag(const cmat &, cvec &, cvec &); 01131 01133 extern template mat tridiag(const vec &main, const vec &, const vec &); 01135 extern template cmat tridiag(const cvec &main, const cvec &, const cvec &); 01136 01138 extern template void tridiag(const vec &main, const vec &, const vec &, mat &); 01140 extern template void tridiag(const cvec &main, const cvec &, const cvec &, cmat &); 01141 01143 extern template void tridiag(const mat &m, vec &, vec &, vec &); 01145 extern template void tridiag(const cmat &m, cvec &, cvec &, cvec &); 01146 01148 extern template double trace(const mat &in); 01150 extern template std::complex<double> trace(const cmat &in); 01152 extern template short trace(const smat &in); 01154 extern template int trace(const imat &in); 01156 extern template bin trace(const bmat &in); 01157 01159 extern template void transpose(const mat &m, mat &out); 01161 extern template void transpose(const cmat &m, cmat &out); 01163 extern template void transpose(const smat &m, smat &out); 01165 extern template void transpose(const imat &m, imat &out); 01167 extern template void transpose(const bmat &m, bmat &out); 01168 01170 extern template mat transpose(const mat &m); 01172 extern template cmat transpose(const cmat &m); 01174 extern template smat transpose(const smat &m); 01176 extern template imat transpose(const imat &m); 01178 extern template bmat transpose(const bmat &m); 01179 01180 01182 extern template void hermitian_transpose(const mat &m, mat &out); 01184 extern template void hermitian_transpose(const cmat &m, cmat &out); 01186 extern template void hermitian_transpose(const smat &m, smat &out); 01188 extern template void hermitian_transpose(const imat &m, imat &out); 01190 extern template void hermitian_transpose(const bmat &m, bmat &out); 01191 01193 extern template mat hermitian_transpose(const mat &m); 01195 extern template cmat hermitian_transpose(const cmat &m); 01197 extern template smat hermitian_transpose(const smat &m); 01199 extern template imat hermitian_transpose(const imat &m); 01201 extern template bmat hermitian_transpose(const bmat &m); 01202 01203 01205 extern template bool is_hermitian(const mat &X); 01207 extern template bool is_hermitian(const cmat &X); 01208 01210 extern template bool is_unitary(const mat &X); 01212 extern template bool is_unitary(const cmat &X); 01213 01215 extern template mat repeat(const mat &m, int norepeats); 01217 extern template cmat repeat(const cmat &m, int norepeats); 01219 extern template smat repeat(const smat &m, int norepeats); 01221 extern template imat repeat(const imat &m, int norepeats); 01223 extern template bmat repeat(const bmat &m, int norepeats); 01224 01226 extern template mat apply_function(float (*f)(float), const mat &data); 01228 extern template mat apply_function(double (*f)(double), const mat &data); 01230 extern template cmat apply_function(std::complex<double> (*f)(std::complex<double>), const cmat &data); 01232 extern template smat apply_function(short (*f)(short), const smat &data); 01234 extern template imat apply_function(int (*f)(int), const imat &data); 01236 extern template bmat apply_function(bin (*f)(bin), const bmat &data); 01237 01239 extern template vec rvectorize(const mat &m); 01241 extern template cvec rvectorize(const cmat &m); 01243 extern template ivec rvectorize(const imat &m); 01245 extern template bvec rvectorize(const bmat &m); 01246 01248 extern template vec cvectorize(const mat &m); 01250 extern template cvec cvectorize(const cmat &m); 01252 extern template ivec cvectorize(const imat &m); 01254 extern template bvec cvectorize(const bmat &m); 01255 01257 extern template mat reshape(const mat &m, int rows, int cols); 01259 extern template cmat reshape(const cmat &m, int rows, int cols); 01261 extern template imat reshape(const imat &m, int rows, int cols); 01263 extern template bmat reshape(const bmat &m, int rows, int cols); 01264 01266 extern template mat reshape(const vec &m, int rows, int cols); 01268 extern template cmat reshape(const cvec &m, int rows, int cols); 01270 extern template imat reshape(const ivec &m, int rows, int cols); 01272 extern template bmat reshape(const bvec &m, int rows, int cols); 01273 01275 extern template vec upsample(const vec &v, int usf); 01277 extern template cvec upsample(const cvec &v, int usf); 01279 extern template svec upsample(const svec &v, int usf); 01281 extern template ivec upsample(const ivec &v, int usf); 01283 extern template bvec upsample(const bvec &v, int usf); 01284 01286 extern template mat upsample(const mat &v, int usf); 01288 extern template cmat upsample(const cmat &v, int usf); 01290 extern template smat upsample(const smat &v, int usf); 01292 extern template imat upsample(const imat &v, int usf); 01294 extern template bmat upsample(const bmat &v, int usf); 01295 01297 extern template void upsample(const vec &v, int usf, vec &u); 01299 extern template void upsample(const cvec &v, int usf, cvec &u); 01301 extern template void upsample(const svec &v, int usf, svec &u); 01303 extern template void upsample(const ivec &v, int usf, ivec &u); 01305 extern template void upsample(const bvec &v, int usf, bvec &u); 01306 01308 extern template void upsample(const mat &v, int usf, mat &u); 01310 extern template void upsample(const cmat &v, int usf, cmat &u); 01312 extern template void upsample(const smat &v, int usf, smat &u); 01314 extern template void upsample(const imat &v, int usf, imat &u); 01316 extern template void upsample(const bmat &v, int usf, bmat &u); 01317 01319 extern template vec lininterp(const vec &v, int usf); 01321 extern template cvec lininterp(const cvec &v, int usf); 01322 01324 extern template mat lininterp(const mat &v, int usf); 01326 extern template cmat lininterp(const cmat &v, int usf); 01327 01329 extern template void lininterp(const vec &v, int usf, vec &u); 01331 extern template void lininterp(const cvec &v, int usf, cvec &u); 01332 01334 extern template void lininterp(const mat &v, int usf, mat &u); 01336 extern template void lininterp(const cmat &v, int usf, cmat &u); 01337 01339 extern template mat lininterp(const mat &m, const double f_base, const double f_ups, const int nrof_samples, const double t_start); 01341 extern template cmat lininterp(const cmat &m, const double f_base, const double f_ups, const int nrof_samples, const double t_start); 01342 01344 extern template vec lininterp(const vec &v, const double f_base, const double f_ups, const int nrof_samples, const double t_start); 01346 extern template cvec lininterp(const cvec &v, const double f_base, const double f_ups, const int nrof_samples, const double t_start); 01347 #endif 01348 01349 } // namespace itpp 01350 01351 #endif // #ifndef MATFUNC_H 01352
Generated on Thu Apr 19 14:19:52 2007 for IT++ by Doxygen 1.4.6