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 
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 
SourceForge Logo

Generated on Thu Apr 19 14:43:43 2007 for IT++ by Doxygen 1.5.1