IT++ Logo

matfunc.h

Go to the documentation of this file.
00001 
00031 #ifndef MATFUNC_H
00032 #define MATFUNC_H
00033 
00034 #include <itpp/base/mat.h>
00035 #include <itpp/base/math/log_exp.h>
00036 #include <itpp/base/math/elem_math.h>
00037 
00038 
00039 namespace itpp {
00040 
00045 
00046 
00048   template<class T>
00049   int length(const Vec<T> &v) { return v.length(); }
00050 
00052   template<class T>
00053   int size(const Vec<T> &v) { return v.length(); }
00054 
00056   template<class T>
00057   T sum(const Vec<T> &v)
00058   {
00059     T M = 0;
00060 
00061     for (int i=0;i<v.length();i++)
00062       M += v[i];
00063 
00064     return M;
00065   }
00066 
00074   template<class T>
00075   Vec<T> sum(const Mat<T> &m, int dim=1)
00076   {
00077     it_assert((dim == 1) || (dim == 2), "sum: dimension need to be 1 or 2");
00078     Vec<T> out;
00079 
00080     if (dim == 1) {
00081       out.set_size(m.cols(), false);
00082 
00083       for (int i=0; i<m.cols(); i++)
00084         out(i) = sum(m.get_col(i));
00085     }
00086     else {
00087       out.set_size(m.rows(), false);
00088 
00089       for (int i=0; i<m.rows(); i++)
00090         out(i) = sum(m.get_row(i));
00091     }
00092 
00093     return out;
00094   }
00095 
00096 
00098   template<class T>
00099   T sumsum(const Mat<T> &X)
00100   {
00101     const T * X_data = X._data();
00102     const int X_datasize = X._datasize();
00103     T acc = 0;
00104 
00105     for(int i=0;i<X_datasize;i++)
00106       acc += X_data[i];
00107 
00108     return acc;
00109   }
00110 
00111 
00113   template<class T>
00114   T sum_sqr(const Vec<T> &v)
00115   {
00116     T M=0;
00117 
00118     for (int i=0; i<v.length(); i++)
00119       M += v[i] * v[i];
00120 
00121     return M;
00122   }
00123 
00131   template<class T>
00132   Vec<T> sum_sqr(const Mat<T> &m, int dim=1)
00133   {
00134     it_assert((dim == 1) || (dim == 2), "sum_sqr: dimension need to be 1 or 2");
00135     Vec<T> out;
00136 
00137     if (dim == 1) {
00138       out.set_size(m.cols(), false);
00139 
00140       for (int i=0; i<m.cols(); i++)
00141   out(i) = sum_sqr(m.get_col(i));
00142     }
00143     else {
00144       out.set_size(m.rows(), false);
00145 
00146       for (int i=0; i<m.rows(); i++)
00147   out(i) = sum_sqr(m.get_row(i));
00148     }
00149 
00150     return out;
00151   }
00152 
00154   template<class T>
00155   Vec<T> cumsum(const Vec<T> &v)
00156   {
00157     Vec<T> out(v.size());
00158 
00159     out(0)=v(0);
00160     for (int i=1; i<v.size(); i++)
00161       out(i) = out(i-1) + v(i);
00162 
00163     return out;
00164   }
00165 
00173   template<class T>
00174   Mat<T> cumsum(const Mat<T> &m, int dim=1)
00175   {
00176     it_assert((dim == 1) || (dim == 2), "cumsum: dimension need to be 1 or 2");
00177     Mat<T> out(m.rows(), m.cols());
00178 
00179     if (dim == 1) {
00180       for (int i=0; i<m.cols(); i++)
00181   out.set_col(i, cumsum(m.get_col(i)));
00182     } else {
00183       for (int i=0; i<m.rows(); i++)
00184   out.set_row(i, cumsum(m.get_row(i)));
00185     }
00186 
00187     return out;
00188   }
00189 
00191   template<class T>
00192   T prod(const Vec<T> &v)
00193   {
00194     it_assert(v.size() >= 1, "prod: size of vector should be at least 1");
00195     T out = v(0);
00196 
00197     for (int i=1; i<v.size(); i++)
00198       out *= v(i);
00199 
00200     return out;
00201   }
00202 
00210   template<class T>
00211   Vec<T> prod(const Mat<T> &m, int dim=1)
00212   {
00213     it_assert((dim == 1) || (dim == 2), "prod: dimension need to be 1 or 2");
00214     Vec<T> out(m.cols());
00215 
00216     if (dim == 1) {
00217       it_assert((m.cols() >= 1) && (m.rows() >= 1),
00218     "prod: number of columns should be at least 1");
00219       out.set_size(m.cols(), false);
00220 
00221       for (int i=0; i<m.cols(); i++)
00222   out(i) = prod(m.get_col(i));
00223     }
00224     else {
00225       it_assert((m.cols() >= 1) && (m.rows() >= 1),
00226     "prod: number of rows should be at least 1");
00227       out.set_size(m.rows(), false);
00228 
00229       for (int i=0; i<m.rows(); i++)
00230   out(i) = prod(m.get_row(i));
00231     }
00232     return out;
00233   }
00234 
00236   template<class T>
00237   Vec<T> cross(const Vec<T> &v1, const Vec<T> &v2)
00238   {
00239     it_assert((v1.size() == 3) && (v2.size() == 3),
00240         "cross: vectors should be of size 3");
00241 
00242     Vec<T> r(3);
00243 
00244     r(0) = v1(1) * v2(2) - v1(2) * v2(1);
00245     r(1) = v1(2) * v2(0) - v1(0) * v2(2);
00246     r(2) = v1(0) * v2(1) - v1(1) * v2(0);
00247 
00248     return r;
00249   }
00250 
00251 
00253   template<class T>
00254   Vec<T> zero_pad(const Vec<T> &v, int n)
00255   {
00256     it_assert(n >= v.size(), "zero_pad() cannot shrink the vector!");
00257     Vec<T> v2(n);
00258     v2.set_subvector(0, v.size()-1, v);
00259     if (n > v.size())
00260       v2.set_subvector(v.size(), n-1, T(0));
00261 
00262     return v2;
00263   }
00264 
00266   template<class T>
00267   Vec<T> zero_pad(const Vec<T> &v)
00268   {
00269     int n = pow2i(levels2bits(v.size()));
00270 
00271     return (n == v.size()) ? v : zero_pad(v, n);
00272   }
00273 
00275   template<class T>
00276   Mat<T> zero_pad(const Mat<T> &m, int rows, int cols)
00277   {
00278     it_assert((rows >= m.rows()) && (cols >= m.cols()),
00279         "zero_pad() cannot shrink the matrix!");
00280     Mat<T> m2(rows, cols);
00281     m2.set_submatrix(0,m.rows()-1,0,m.cols()-1, m);
00282     if (cols > m.cols()) // Zero
00283       m2.set_submatrix(0,m.rows()-1, m.cols(),cols-1, T(0));
00284     if (rows > m.rows()) // Zero
00285       m2.set_submatrix(m.rows(), rows-1, 0, cols-1, T(0));
00286 
00287     return m2;
00288   }
00289 
00290 
00293   template<class T>
00294   T index_zero_pad(const Vec<T> &v, const int index)
00295   {
00296     if (index >= 0 && index < v.size())
00297       return v(index);
00298     else
00299       return T(0);
00300   }
00301 
00302 
00304   template<class T>
00305   void transpose(const Mat<T> &m, Mat<T> &out) { out = m.T(); }
00306 
00308   template<class T>
00309   Mat<T> transpose(const Mat<T> &m) { return m.T(); }
00310 
00311 
00314   template<class T>
00315   void hermitian_transpose(const Mat<T> &m, Mat<T> &out) { out = m.H(); }
00316 
00318   template<class T>
00319   Mat<T> hermitian_transpose(const Mat<T> &m) { return m.H(); }
00320 
00321 
00322 
00332   template<class Num_T>
00333   bool is_hermitian(const Mat<Num_T>& X) {
00334 
00335     if (X == X.H() )
00336       return true;
00337     else
00338       return false;
00339   }
00340 
00350   template<class Num_T>
00351   bool is_unitary(const Mat<Num_T>& X) {
00352 
00353     if ( inv(X) == X.H() )
00354       return true;
00355     else
00356       return false;
00357   }
00358 
00359 
00368   template<class T>
00369   Vec<T> repmat(const Vec<T> &v, int n)
00370   {
00371     it_assert(n > 0, "repmat(): Wrong repetition parameter");
00372     int data_length = v.length();
00373     it_assert(data_length > 0, "repmat(): Input vector can not be empty");
00374     Vec<T> assembly(data_length * n);
00375     for (int j = 0; j < n; ++j) {
00376       assembly.set_subvector(j * data_length, v);
00377     }
00378     return assembly;
00379   }
00380 
00381 
00391   template<class T>
00392   Mat<T> repmat(const Mat<T> &data, int m, int n)
00393   {
00394     it_assert((m > 0) && (n > 0), "repmat(): Wrong repetition parameters");
00395     int data_rows = data.rows();
00396     int data_cols = data.cols();
00397     it_assert((data_rows > 0) && (data_cols > 0), "repmat(): Input matrix can "
00398         "not be empty");
00399     Mat<T> assembly(data_rows*m, data_cols*n);
00400     for (int i = 0; i < m; ++i) {
00401       for (int j = 0; j < n; ++j) {
00402         assembly.set_submatrix(i*data_rows, j*data_cols, data);
00403       }
00404     }
00405     return assembly;
00406   }
00407 
00419   template<class T> inline
00420   Mat<T> repmat(const Vec<T> &v, int m, int n, bool transpose = false)
00421   {
00422     return repmat((transpose ? v.T() : Mat<T>(v)), m, n);
00423   }
00424 
00425 
00437   template<class Num_T>
00438   Mat<Num_T> kron(const Mat<Num_T>& X, const Mat<Num_T>& Y)
00439   {
00440     Mat<Num_T> result(X.rows() * Y.rows(), X.cols() * Y.cols());
00441 
00442     for (int i = 0; i < X.rows(); i++)
00443       for (int j = 0; j < X.cols(); j++)
00444   result.set_submatrix(i * Y.rows(), j * Y.cols(), X(i, j) * Y);
00445 
00446     return result;
00447   }
00448 
00449 
00462   cmat sqrtm(const cmat& A);
00463 
00476   cmat sqrtm(const mat& A);
00477 
00479 
00480 
00481 
00482   // -------------------- Diagonal matrix functions -------------------------
00483 
00486 
00494   template<class T>
00495   Mat<T> diag(const Vec<T> &v, const int K = 0)
00496   {
00497     Mat<T> m(v.size() + std::abs(K), v.size() + std::abs(K));
00498     m = T(0);
00499     if (K>0)
00500       for (int i=v.size()-1; i>=0; i--)
00501   m(i,i+K) = v(i);
00502     else
00503       for (int i=v.size()-1; i>=0; i--)
00504   m(i-K,i) = v(i);
00505 
00506     return m;
00507   }
00508 
00516   template<class T>
00517   void diag(const Vec<T> &v, Mat<T> &m)
00518   {
00519     m.set_size(v.size(), v.size(), false);
00520     m = T(0);
00521     for (int i=v.size()-1; i>=0; i--)
00522       m(i,i) = v(i);
00523   }
00524 
00531   template<class T>
00532   Vec<T> diag(const Mat<T> &m)
00533   {
00534     Vec<T> t(std::min(m.rows(), m.cols()));
00535 
00536     for (int i=0; i<t.size(); i++)
00537       t(i) = m(i,i);
00538 
00539     return t;
00540   }
00541 
00542   //
00552   template<class T>
00553   Mat<T> bidiag(const Vec<T> &main, const Vec<T> &sup)
00554   {
00555     it_assert(main.size() == sup.size()+1, "bidiag()");
00556 
00557     int n=main.size();
00558     Mat<T> m(n, n);
00559     m = T(0);
00560     for (int i=0; i<n-1; i++) {
00561       m(i,i) = main(i);
00562       m(i,i+1) = sup(i);
00563     }
00564     m(n-1,n-1) = main(n-1);
00565 
00566     return m;
00567   }
00568 
00578   template<class T>
00579   void bidiag(const Vec<T> &main, const Vec<T> &sup, Mat<T> &m)
00580   {
00581     it_assert(main.size() == sup.size()+1, "bidiag()");
00582 
00583     int n=main.size();
00584     m.set_size(n, n);
00585     m = T(0);
00586     for (int i=0; i<n-1; i++) {
00587       m(i,i) = main(i);
00588       m(i,i+1) = sup(i);
00589     }
00590     m(n-1,n-1) = main(n-1);
00591   }
00592 
00601   template<class T>
00602   void bidiag(const Mat<T> &m, Vec<T> &main, Vec<T> &sup)
00603   {
00604     it_assert(m.rows() == m.cols(), "bidiag(): Matrix must be square!");
00605 
00606     int n=m.cols();
00607     main.set_size(n);
00608     sup.set_size(n-1);
00609     for (int i=0; i<n-1; i++) {
00610       main(i) = m(i,i);
00611       sup(i) = m(i,i+1);
00612     }
00613     main(n-1) = m(n-1,n-1);
00614   }
00615 
00625   template<class T>
00626   Mat<T> tridiag(const Vec<T> &main, const Vec<T> &sup, const Vec<T> &sub)
00627   {
00628     it_assert(main.size()==sup.size()+1 && main.size()==sub.size()+1, "bidiag()");
00629 
00630     int n=main.size();
00631     Mat<T> m(n, n);
00632     m = T(0);
00633     for (int i=0; i<n-1; i++) {
00634       m(i,i) = main(i);
00635       m(i,i+1) = sup(i);
00636       m(i+1,i) = sub(i);
00637     }
00638     m(n-1,n-1) = main(n-1);
00639 
00640     return m;
00641   }
00642 
00652   template<class T>
00653   void tridiag(const Vec<T> &main, const Vec<T> &sup, const Vec<T> &sub, Mat<T> &m)
00654   {
00655     it_assert(main.size()==sup.size()+1 && main.size()==sub.size()+1, "bidiag()");
00656 
00657     int n=main.size();
00658     m.set_size(n, n);
00659     m = T(0);
00660     for (int i=0; i<n-1; i++) {
00661       m(i,i) = main(i);
00662       m(i,i+1) = sup(i);
00663       m(i+1,i) = sub(i);
00664     }
00665     m(n-1,n-1) = main(n-1);
00666   }
00667 
00676   template<class T>
00677   void tridiag(const Mat<T> &m, Vec<T> &main, Vec<T> &sup, Vec<T> &sub)
00678   {
00679     it_assert(m.rows() == m.cols(), "tridiag(): Matrix must be square!");
00680 
00681     int n=m.cols();
00682     main.set_size(n);
00683     sup.set_size(n-1);
00684     sub.set_size(n-1);
00685     for (int i=0; i<n-1; i++) {
00686       main(i) = m(i,i);
00687       sup(i) = m(i,i+1);
00688       sub(i) = m(i+1,i);
00689     }
00690     main(n-1) = m(n-1,n-1);
00691   }
00692 
00693 
00697   template<class T>
00698   T trace(const Mat<T> &m)
00699   {
00700     return sum(diag(m));
00701   }
00702 
00704 
00705 
00706   // ----------------- reshaping vectors and matrices ------------------------
00707 
00710 
00712   template<class T>
00713   Vec<T> reverse(const Vec<T> &in)
00714   {
00715     int i, s=in.length();
00716 
00717     Vec<T> out(s);
00718     for (i=0;i<s;i++)
00719       out[i]=in[s-1-i];
00720     return out;
00721   }
00722 
00724   template<class T>
00725   Vec<T> rvectorize(const Mat<T> &m)
00726   {
00727     int i, j, n=0, r=m.rows(), c=m.cols();
00728     Vec<T> v(r * c);
00729 
00730     for (i=0; i<r; i++)
00731       for (j=0; j<c; j++)
00732   v(n++) = m(i,j);
00733 
00734     return v;
00735   }
00736 
00738   template<class T>
00739   Vec<T> cvectorize(const Mat<T> &m)
00740   {
00741     int i, j, n=0, r=m.rows(), c=m.cols();
00742     Vec<T> v(r * c);
00743 
00744     for (j=0; j<c; j++)
00745       for (i=0; i<r; i++)
00746   v(n++) = m(i,j);
00747 
00748     return v;
00749   }
00750 
00757   template<class T>
00758   Mat<T> reshape(const Mat<T> &m, int rows, int cols)
00759   {
00760     it_assert_debug(m.rows()*m.cols() == rows*cols, "Mat<T>::reshape: Sizes must match");
00761     Mat<T> temp(rows, cols);
00762     int i, j, ii=0, jj=0;
00763     for (j=0; j<m.cols(); j++) {
00764       for (i=0; i<m.rows(); i++) {
00765   temp(ii++,jj) = m(i,j);
00766   if (ii == rows) {
00767     jj++; ii=0;
00768   }
00769       }
00770     }
00771     return temp;
00772   }
00773 
00780   template<class T>
00781   Mat<T> reshape(const Vec<T> &v, int rows, int cols)
00782   {
00783     it_assert_debug(v.size() == rows*cols, "Mat<T>::reshape: Sizes must match");
00784     Mat<T> temp(rows, cols);
00785     int i, j, ii=0;
00786     for (j=0; j<cols; j++) {
00787       for (i=0; i<rows; i++) {
00788   temp(i,j) = v(ii++);
00789       }
00790     }
00791     return temp;
00792   }
00793 
00795 
00796 
00798   bool all(const bvec &testvec);
00800   bool any(const bvec &testvec);
00801 
00803 
00804   // ----------------------------------------------------------------------
00805   // Instantiations
00806   // ----------------------------------------------------------------------
00807 
00808 #ifdef HAVE_EXTERN_TEMPLATE
00809 
00810   extern template int length(const vec &v);
00811   extern template int length(const cvec &v);
00812   extern template int length(const svec &v);
00813   extern template int length(const ivec &v);
00814   extern template int length(const bvec &v);
00815 
00816   extern template double sum(const vec &v);
00817   extern template std::complex<double> sum(const cvec &v);
00818   extern template short sum(const svec &v);
00819   extern template int sum(const ivec &v);
00820   extern template bin sum(const bvec &v);
00821 
00822   extern template double sum_sqr(const vec &v);
00823   extern template std::complex<double> sum_sqr(const cvec &v);
00824   extern template short sum_sqr(const svec &v);
00825   extern template int sum_sqr(const ivec &v);
00826   extern template bin sum_sqr(const bvec &v);
00827 
00828   extern template vec cumsum(const vec &v);
00829   extern template cvec cumsum(const cvec &v);
00830   extern template svec cumsum(const svec &v);
00831   extern template ivec cumsum(const ivec &v);
00832   extern template bvec cumsum(const bvec &v);
00833 
00834   extern template double prod(const vec &v);
00835   extern template std::complex<double> prod(const cvec &v);
00836   extern template short prod(const svec &v);
00837   extern template int prod(const ivec &v);
00838   extern template bin prod(const bvec &v);
00839 
00840   extern template vec cross(const vec &v1, const vec &v2);
00841   extern template cvec cross(const cvec &v1, const cvec &v2);
00842   extern template ivec cross(const ivec &v1, const ivec &v2);
00843   extern template svec cross(const svec &v1, const svec &v2);
00844   extern template bvec cross(const bvec &v1, const bvec &v2);
00845 
00846   extern template vec reverse(const vec &in);
00847   extern template cvec reverse(const cvec &in);
00848   extern template svec reverse(const svec &in);
00849   extern template ivec reverse(const ivec &in);
00850   extern template bvec reverse(const bvec &in);
00851 
00852   extern template vec zero_pad(const vec &v, int n);
00853   extern template cvec zero_pad(const cvec &v, int n);
00854   extern template ivec zero_pad(const ivec &v, int n);
00855   extern template svec zero_pad(const svec &v, int n);
00856   extern template bvec zero_pad(const bvec &v, int n);
00857 
00858   extern template vec zero_pad(const vec &v);
00859   extern template cvec zero_pad(const cvec &v);
00860   extern template ivec zero_pad(const ivec &v);
00861   extern template svec zero_pad(const svec &v);
00862   extern template bvec zero_pad(const bvec &v);
00863 
00864   extern template mat zero_pad(const mat &, int, int);
00865   extern template cmat zero_pad(const cmat &, int, int);
00866   extern template imat zero_pad(const imat &, int, int);
00867   extern template smat zero_pad(const smat &, int, int);
00868   extern template bmat zero_pad(const bmat &, int, int);
00869 
00870   extern template vec sum(const mat &m, int dim);
00871   extern template cvec sum(const cmat &m, int dim);
00872   extern template svec sum(const smat &m, int dim);
00873   extern template ivec sum(const imat &m, int dim);
00874   extern template bvec sum(const bmat &m, int dim);
00875 
00876   extern template double sumsum(const mat &X);
00877   extern template std::complex<double> sumsum(const cmat &X);
00878   extern template short sumsum(const smat &X);
00879   extern template int sumsum(const imat &X);
00880   extern template bin sumsum(const bmat &X);
00881 
00882   extern template vec sum_sqr(const mat & m, int dim);
00883   extern template cvec sum_sqr(const cmat &m, int dim);
00884   extern template svec sum_sqr(const smat &m, int dim);
00885   extern template ivec sum_sqr(const imat &m, int dim);
00886   extern template bvec sum_sqr(const bmat &m, int dim);
00887 
00888   extern template mat cumsum(const mat &m, int dim);
00889   extern template cmat cumsum(const cmat &m, int dim);
00890   extern template smat cumsum(const smat &m, int dim);
00891   extern template imat cumsum(const imat &m, int dim);
00892   extern template bmat cumsum(const bmat &m, int dim);
00893 
00894   extern template vec prod(const mat &m, int dim);
00895   extern template cvec prod(const cmat &v, int dim);
00896   extern template svec prod(const smat &m, int dim);
00897   extern template ivec prod(const imat &m, int dim);
00898   extern template bvec prod(const bmat &m, int dim);
00899 
00900   extern template vec diag(const mat &in);
00901   extern template cvec diag(const cmat &in);
00902   extern template void diag(const vec &in, mat &m);
00903   extern template void diag(const cvec &in, cmat &m);
00904   extern template mat diag(const vec &v, const int K);
00905   extern template cmat diag(const cvec &v, const int K);
00906 
00907   extern template mat bidiag(const vec &, const vec &);
00908   extern template cmat bidiag(const cvec &, const cvec &);
00909   extern template void bidiag(const vec &, const vec &, mat &);
00910   extern template void bidiag(const cvec &, const cvec &, cmat &);
00911   extern template void bidiag(const mat &, vec &, vec &);
00912   extern template void bidiag(const cmat &, cvec &, cvec &);
00913 
00914   extern template mat tridiag(const vec &main, const vec &, const vec &);
00915   extern template cmat tridiag(const cvec &main, const cvec &, const cvec &);
00916   extern template void tridiag(const vec &main, const vec &, const vec &, mat &);
00917   extern template void tridiag(const cvec &main, const cvec &, const cvec &, cmat &);
00918   extern template void tridiag(const mat &m, vec &, vec &, vec &);
00919   extern template void tridiag(const cmat &m, cvec &, cvec &, cvec &);
00920 
00921   extern template double trace(const mat &in);
00922   extern template std::complex<double> trace(const cmat &in);
00923   extern template short trace(const smat &in);
00924   extern template int trace(const imat &in);
00925   extern template bin trace(const bmat &in);
00926 
00927   extern template void transpose(const mat &m, mat &out);
00928   extern template void transpose(const cmat &m, cmat &out);
00929   extern template void transpose(const smat &m, smat &out);
00930   extern template void transpose(const imat &m, imat &out);
00931   extern template void transpose(const bmat &m, bmat &out);
00932 
00933   extern template mat transpose(const mat &m);
00934   extern template cmat transpose(const cmat &m);
00935   extern template smat transpose(const smat &m);
00936   extern template imat transpose(const imat &m);
00937   extern template bmat transpose(const bmat &m);
00938 
00939   extern template void hermitian_transpose(const mat &m, mat &out);
00940   extern template void hermitian_transpose(const cmat &m, cmat &out);
00941   extern template void hermitian_transpose(const smat &m, smat &out);
00942   extern template void hermitian_transpose(const imat &m, imat &out);
00943   extern template void hermitian_transpose(const bmat &m, bmat &out);
00944 
00945   extern template mat hermitian_transpose(const mat &m);
00946   extern template cmat hermitian_transpose(const cmat &m);
00947   extern template smat hermitian_transpose(const smat &m);
00948   extern template imat hermitian_transpose(const imat &m);
00949   extern template bmat hermitian_transpose(const bmat &m);
00950 
00951   extern template bool is_hermitian(const mat &X);
00952   extern template bool is_hermitian(const cmat &X);
00953 
00954   extern template bool is_unitary(const mat &X);
00955   extern template bool is_unitary(const cmat &X);
00956 
00957   extern template vec rvectorize(const mat &m);
00958   extern template cvec rvectorize(const cmat &m);
00959   extern template ivec rvectorize(const imat &m);
00960   extern template svec rvectorize(const smat &m);
00961   extern template bvec rvectorize(const bmat &m);
00962 
00963   extern template vec cvectorize(const mat &m);
00964   extern template cvec cvectorize(const cmat &m);
00965   extern template ivec cvectorize(const imat &m);
00966   extern template svec cvectorize(const smat &m);
00967   extern template bvec cvectorize(const bmat &m);
00968 
00969   extern template mat reshape(const mat &m, int rows, int cols);
00970   extern template cmat reshape(const cmat &m, int rows, int cols);
00971   extern template imat reshape(const imat &m, int rows, int cols);
00972   extern template smat reshape(const smat &m, int rows, int cols);
00973   extern template bmat reshape(const bmat &m, int rows, int cols);
00974 
00975   extern template mat reshape(const vec &m, int rows, int cols);
00976   extern template cmat reshape(const cvec &m, int rows, int cols);
00977   extern template imat reshape(const ivec &m, int rows, int cols);
00978   extern template smat reshape(const svec &m, int rows, int cols);
00979   extern template bmat reshape(const bvec &m, int rows, int cols);
00980 
00981   extern template mat kron(const mat &X, const mat &Y);
00982   extern template cmat kron(const cmat &X, const cmat &Y);
00983   extern template imat kron(const imat &X, const imat &Y);
00984   extern template smat kron(const smat &X, const smat &Y);
00985   extern template bmat kron(const bmat &X, const bmat &Y);
00986 
00987   extern template vec repmat(const vec &v, int n);
00988   extern template cvec repmat(const cvec &v, int n);
00989   extern template ivec repmat(const ivec &v, int n);
00990   extern template svec repmat(const svec &v, int n);
00991   extern template bvec repmat(const bvec &v, int n);
00992 
00993   extern template mat repmat(const vec &v, int m, int n, bool transpose);
00994   extern template cmat repmat(const cvec &v, int m, int n, bool transpose);
00995   extern template imat repmat(const ivec &v, int m, int n, bool transpose);
00996   extern template smat repmat(const svec &v, int m, int n, bool transpose);
00997   extern template bmat repmat(const bvec &v, int m, int n, bool transpose);
00998 
00999   extern template mat repmat(const mat &data, int m, int n);
01000   extern template cmat repmat(const cmat &data, int m, int n);
01001   extern template imat repmat(const imat &data, int m, int n);
01002   extern template smat repmat(const smat &data, int m, int n);
01003   extern template bmat repmat(const bmat &data, int m, int n);
01004 
01005 #endif // HAVE_EXTERN_TEMPLATE
01006 
01008 
01009 } // namespace itpp
01010 
01011 #endif // #ifndef MATFUNC_H
SourceForge Logo

Generated on Sun Sep 14 18:54:51 2008 for IT++ by Doxygen 1.5.6