IT++ Logo Newcom Logo

matfunc.h

Go to the documentation of this file.
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 
SourceForge Logo

Generated on Sat Aug 25 23:40:53 2007 for IT++ by Doxygen 1.5.2