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 
00497   template<class T>
00498   Mat<T> diag(const Vec<T> &v, const int K = 0)
00499   {
00500     Mat<T> m(v.size() + std::abs(K), v.size() + std::abs(K));
00501     m = T(0);
00502     if (K>0)
00503       for (int i=v.size()-1; i>=0; i--)
00504         m(i,i+K) = v(i);
00505     else
00506       for (int i=v.size()-1; i>=0; i--)
00507         m(i-K,i) = v(i);
00508 
00509     return m;
00510   }
00511 
00521   template<class T>
00522   void diag(const Vec<T> &v, Mat<T> &m)
00523   {
00524     m.set_size(v.size(), v.size(), false);
00525     m = T(0);
00526     for (int i=v.size()-1; i>=0; i--)
00527       m(i,i) = v(i);
00528   }
00529 
00537   template<class T>
00538   Vec<T> diag(const Mat<T> &m)
00539   {
00540     Vec<T> t(std::min(m.rows(), m.cols()));
00541 
00542     for (int i=0; i<t.size(); i++)
00543       t(i) = m(i,i);
00544 
00545     return t;
00546   }
00547 
00557   template<class T>
00558   Mat<T> bidiag(const Vec<T> &main, const Vec<T> &sup)
00559   {
00560     it_assert(main.size() == sup.size()+1, "bidiag()");
00561 
00562     int n=main.size();
00563     Mat<T> m(n, n);
00564     m = T(0);
00565     for (int i=0; i<n-1; i++) {
00566       m(i,i) = main(i);
00567       m(i,i+1) = sup(i);
00568     }
00569     m(n-1,n-1) = main(n-1);
00570 
00571     return m;
00572   }
00573 
00583   template<class T>
00584   void bidiag(const Vec<T> &main, const Vec<T> &sup, Mat<T> &m)
00585   {
00586     it_assert(main.size() == sup.size()+1, "bidiag()");
00587 
00588     int n=main.size();
00589     m.set_size(n, n);
00590     m = T(0);
00591     for (int i=0; i<n-1; i++) {
00592       m(i,i) = main(i);
00593       m(i,i+1) = sup(i);
00594     }
00595     m(n-1,n-1) = main(n-1);
00596   }
00597 
00606   template<class T>
00607   void bidiag(const Mat<T> &m, Vec<T> &main, Vec<T> &sup)
00608   {
00609     it_assert(m.rows() == m.cols(), "bidiag(): Matrix must be square!");
00610 
00611     int n=m.cols();
00612     main.set_size(n);
00613     sup.set_size(n-1);
00614     for (int i=0; i<n-1; i++) {
00615       main(i) = m(i,i);
00616       sup(i) = m(i,i+1);
00617     }
00618     main(n-1) = m(n-1,n-1);
00619   }
00620 
00630   template<class T>
00631   Mat<T> tridiag(const Vec<T> &main, const Vec<T> &sup, const Vec<T> &sub)
00632   {
00633     it_assert(main.size()==sup.size()+1 && main.size()==sub.size()+1, "bidiag()");
00634 
00635     int n=main.size();
00636     Mat<T> m(n, n);
00637     m = T(0);
00638     for (int i=0; i<n-1; i++) {
00639       m(i,i) = main(i);
00640       m(i,i+1) = sup(i);
00641       m(i+1,i) = sub(i);
00642     }
00643     m(n-1,n-1) = main(n-1);
00644 
00645     return m;
00646   }
00647 
00657   template<class T>
00658   void tridiag(const Vec<T> &main, const Vec<T> &sup, const Vec<T> &sub, Mat<T> &m)
00659   {
00660     it_assert(main.size()==sup.size()+1 && main.size()==sub.size()+1, "bidiag()");
00661 
00662     int n=main.size();
00663     m.set_size(n, n);
00664     m = T(0);
00665     for (int i=0; i<n-1; i++) {
00666       m(i,i) = main(i);
00667       m(i,i+1) = sup(i);
00668       m(i+1,i) = sub(i);
00669     }
00670     m(n-1,n-1) = main(n-1);
00671   }
00672 
00681   template<class T>
00682   void tridiag(const Mat<T> &m, Vec<T> &main, Vec<T> &sup, Vec<T> &sub)
00683   {
00684     it_assert(m.rows() == m.cols(), "tridiag(): Matrix must be square!");
00685 
00686     int n=m.cols();
00687     main.set_size(n);
00688     sup.set_size(n-1);
00689     sub.set_size(n-1);
00690     for (int i=0; i<n-1; i++) {
00691       main(i) = m(i,i);
00692       sup(i) = m(i,i+1);
00693       sub(i) = m(i+1,i);
00694     }
00695     main(n-1) = m(n-1,n-1);
00696   }
00697 
00698 
00702   template<class T>
00703   T trace(const Mat<T> &m)
00704   {
00705     return sum(diag(m));
00706   }
00707 
00709 
00710 
00711   // ----------------- reshaping vectors and matrices ------------------------
00712 
00715 
00717   template<class T>
00718   Vec<T> reverse(const Vec<T> &in)
00719   {
00720     int i, s=in.length();
00721 
00722     Vec<T> out(s);
00723     for (i=0;i<s;i++)
00724       out[i]=in[s-1-i];
00725     return out;
00726   }
00727 
00729   template<class T>
00730   Vec<T> rvectorize(const Mat<T> &m)
00731   {
00732     int i, j, n=0, r=m.rows(), c=m.cols();
00733     Vec<T> v(r * c);
00734 
00735     for (i=0; i<r; i++)
00736       for (j=0; j<c; j++)
00737         v(n++) = m(i,j);
00738 
00739     return v;
00740   }
00741 
00743   template<class T>
00744   Vec<T> cvectorize(const Mat<T> &m)
00745   {
00746     int i, j, n=0, r=m.rows(), c=m.cols();
00747     Vec<T> v(r * c);
00748 
00749     for (j=0; j<c; j++)
00750       for (i=0; i<r; i++)
00751         v(n++) = m(i,j);
00752 
00753     return v;
00754   }
00755 
00762   template<class T>
00763   Mat<T> reshape(const Mat<T> &m, int rows, int cols)
00764   {
00765     it_assert_debug(m.rows()*m.cols() == rows*cols, "Mat<T>::reshape: Sizes must match");
00766     Mat<T> temp(rows, cols);
00767     int i, j, ii=0, jj=0;
00768     for (j=0; j<m.cols(); j++) {
00769       for (i=0; i<m.rows(); i++) {
00770         temp(ii++,jj) = m(i,j);
00771         if (ii == rows) {
00772           jj++; ii=0;
00773         }
00774       }
00775     }
00776     return temp;
00777   }
00778 
00785   template<class T>
00786   Mat<T> reshape(const Vec<T> &v, int rows, int cols)
00787   {
00788     it_assert_debug(v.size() == rows*cols, "Mat<T>::reshape: Sizes must match");
00789     Mat<T> temp(rows, cols);
00790     int i, j, ii=0;
00791     for (j=0; j<cols; j++) {
00792       for (i=0; i<rows; i++) {
00793         temp(i,j) = v(ii++);
00794       }
00795     }
00796     return temp;
00797   }
00798 
00800 
00801 
00803   bool all(const bvec &testvec);
00805   bool any(const bvec &testvec);
00806 
00808 
00809   // ----------------------------------------------------------------------
00810   // Instantiations
00811   // ----------------------------------------------------------------------
00812 
00813 #ifdef HAVE_EXTERN_TEMPLATE
00814 
00815   extern template int length(const vec &v);
00816   extern template int length(const cvec &v);
00817   extern template int length(const svec &v);
00818   extern template int length(const ivec &v);
00819   extern template int length(const bvec &v);
00820 
00821   extern template double sum(const vec &v);
00822   extern template std::complex<double> sum(const cvec &v);
00823   extern template short sum(const svec &v);
00824   extern template int sum(const ivec &v);
00825   extern template bin sum(const bvec &v);
00826 
00827   extern template double sum_sqr(const vec &v);
00828   extern template std::complex<double> sum_sqr(const cvec &v);
00829   extern template short sum_sqr(const svec &v);
00830   extern template int sum_sqr(const ivec &v);
00831   extern template bin sum_sqr(const bvec &v);
00832 
00833   extern template vec cumsum(const vec &v);
00834   extern template cvec cumsum(const cvec &v);
00835   extern template svec cumsum(const svec &v);
00836   extern template ivec cumsum(const ivec &v);
00837   extern template bvec cumsum(const bvec &v);
00838 
00839   extern template double prod(const vec &v);
00840   extern template std::complex<double> prod(const cvec &v);
00841   extern template short prod(const svec &v);
00842   extern template int prod(const ivec &v);
00843   extern template bin prod(const bvec &v);
00844 
00845   extern template vec cross(const vec &v1, const vec &v2);
00846   extern template cvec cross(const cvec &v1, const cvec &v2);
00847   extern template ivec cross(const ivec &v1, const ivec &v2);
00848   extern template svec cross(const svec &v1, const svec &v2);
00849   extern template bvec cross(const bvec &v1, const bvec &v2);
00850 
00851   extern template vec reverse(const vec &in);
00852   extern template cvec reverse(const cvec &in);
00853   extern template svec reverse(const svec &in);
00854   extern template ivec reverse(const ivec &in);
00855   extern template bvec reverse(const bvec &in);
00856 
00857   extern template vec zero_pad(const vec &v, int n);
00858   extern template cvec zero_pad(const cvec &v, int n);
00859   extern template ivec zero_pad(const ivec &v, int n);
00860   extern template svec zero_pad(const svec &v, int n);
00861   extern template bvec zero_pad(const bvec &v, int n);
00862 
00863   extern template vec zero_pad(const vec &v);
00864   extern template cvec zero_pad(const cvec &v);
00865   extern template ivec zero_pad(const ivec &v);
00866   extern template svec zero_pad(const svec &v);
00867   extern template bvec zero_pad(const bvec &v);
00868 
00869   extern template mat zero_pad(const mat &, int, int);
00870   extern template cmat zero_pad(const cmat &, int, int);
00871   extern template imat zero_pad(const imat &, int, int);
00872   extern template smat zero_pad(const smat &, int, int);
00873   extern template bmat zero_pad(const bmat &, int, int);
00874 
00875   extern template vec sum(const mat &m, int dim);
00876   extern template cvec sum(const cmat &m, int dim);
00877   extern template svec sum(const smat &m, int dim);
00878   extern template ivec sum(const imat &m, int dim);
00879   extern template bvec sum(const bmat &m, int dim);
00880 
00881   extern template double sumsum(const mat &X);
00882   extern template std::complex<double> sumsum(const cmat &X);
00883   extern template short sumsum(const smat &X);
00884   extern template int sumsum(const imat &X);
00885   extern template bin sumsum(const bmat &X);
00886 
00887   extern template vec sum_sqr(const mat & m, int dim);
00888   extern template cvec sum_sqr(const cmat &m, int dim);
00889   extern template svec sum_sqr(const smat &m, int dim);
00890   extern template ivec sum_sqr(const imat &m, int dim);
00891   extern template bvec sum_sqr(const bmat &m, int dim);
00892 
00893   extern template mat cumsum(const mat &m, int dim);
00894   extern template cmat cumsum(const cmat &m, int dim);
00895   extern template smat cumsum(const smat &m, int dim);
00896   extern template imat cumsum(const imat &m, int dim);
00897   extern template bmat cumsum(const bmat &m, int dim);
00898 
00899   extern template vec prod(const mat &m, int dim);
00900   extern template cvec prod(const cmat &v, int dim);
00901   extern template svec prod(const smat &m, int dim);
00902   extern template ivec prod(const imat &m, int dim);
00903   extern template bvec prod(const bmat &m, int dim);
00904 
00905   extern template vec diag(const mat &in);
00906   extern template cvec diag(const cmat &in);
00907   extern template void diag(const vec &in, mat &m);
00908   extern template void diag(const cvec &in, cmat &m);
00909   extern template mat diag(const vec &v, const int K);
00910   extern template cmat diag(const cvec &v, const int K);
00911 
00912   extern template mat bidiag(const vec &, const vec &);
00913   extern template cmat bidiag(const cvec &, const cvec &);
00914   extern template void bidiag(const vec &, const vec &, mat &);
00915   extern template void bidiag(const cvec &, const cvec &, cmat &);
00916   extern template void bidiag(const mat &, vec &, vec &);
00917   extern template void bidiag(const cmat &, cvec &, cvec &);
00918 
00919   extern template mat tridiag(const vec &main, const vec &, const vec &);
00920   extern template cmat tridiag(const cvec &main, const cvec &, const cvec &);
00921   extern template void tridiag(const vec &main, const vec &, const vec &, mat &);
00922   extern template void tridiag(const cvec &main, const cvec &, const cvec &, cmat &);
00923   extern template void tridiag(const mat &m, vec &, vec &, vec &);
00924   extern template void tridiag(const cmat &m, cvec &, cvec &, cvec &);
00925 
00926   extern template double trace(const mat &in);
00927   extern template std::complex<double> trace(const cmat &in);
00928   extern template short trace(const smat &in);
00929   extern template int trace(const imat &in);
00930   extern template bin trace(const bmat &in);
00931 
00932   extern template void transpose(const mat &m, mat &out);
00933   extern template void transpose(const cmat &m, cmat &out);
00934   extern template void transpose(const smat &m, smat &out);
00935   extern template void transpose(const imat &m, imat &out);
00936   extern template void transpose(const bmat &m, bmat &out);
00937 
00938   extern template mat transpose(const mat &m);
00939   extern template cmat transpose(const cmat &m);
00940   extern template smat transpose(const smat &m);
00941   extern template imat transpose(const imat &m);
00942   extern template bmat transpose(const bmat &m);
00943 
00944   extern template void hermitian_transpose(const mat &m, mat &out);
00945   extern template void hermitian_transpose(const cmat &m, cmat &out);
00946   extern template void hermitian_transpose(const smat &m, smat &out);
00947   extern template void hermitian_transpose(const imat &m, imat &out);
00948   extern template void hermitian_transpose(const bmat &m, bmat &out);
00949 
00950   extern template mat hermitian_transpose(const mat &m);
00951   extern template cmat hermitian_transpose(const cmat &m);
00952   extern template smat hermitian_transpose(const smat &m);
00953   extern template imat hermitian_transpose(const imat &m);
00954   extern template bmat hermitian_transpose(const bmat &m);
00955 
00956   extern template bool is_hermitian(const mat &X);
00957   extern template bool is_hermitian(const cmat &X);
00958 
00959   extern template bool is_unitary(const mat &X);
00960   extern template bool is_unitary(const cmat &X);
00961 
00962   extern template vec rvectorize(const mat &m);
00963   extern template cvec rvectorize(const cmat &m);
00964   extern template ivec rvectorize(const imat &m);
00965   extern template svec rvectorize(const smat &m);
00966   extern template bvec rvectorize(const bmat &m);
00967 
00968   extern template vec cvectorize(const mat &m);
00969   extern template cvec cvectorize(const cmat &m);
00970   extern template ivec cvectorize(const imat &m);
00971   extern template svec cvectorize(const smat &m);
00972   extern template bvec cvectorize(const bmat &m);
00973 
00974   extern template mat reshape(const mat &m, int rows, int cols);
00975   extern template cmat reshape(const cmat &m, int rows, int cols);
00976   extern template imat reshape(const imat &m, int rows, int cols);
00977   extern template smat reshape(const smat &m, int rows, int cols);
00978   extern template bmat reshape(const bmat &m, int rows, int cols);
00979 
00980   extern template mat reshape(const vec &m, int rows, int cols);
00981   extern template cmat reshape(const cvec &m, int rows, int cols);
00982   extern template imat reshape(const ivec &m, int rows, int cols);
00983   extern template smat reshape(const svec &m, int rows, int cols);
00984   extern template bmat reshape(const bvec &m, int rows, int cols);
00985 
00986   extern template mat kron(const mat &X, const mat &Y);
00987   extern template cmat kron(const cmat &X, const cmat &Y);
00988   extern template imat kron(const imat &X, const imat &Y);
00989   extern template smat kron(const smat &X, const smat &Y);
00990   extern template bmat kron(const bmat &X, const bmat &Y);
00991 
00992   extern template vec repmat(const vec &v, int n);
00993   extern template cvec repmat(const cvec &v, int n);
00994   extern template ivec repmat(const ivec &v, int n);
00995   extern template svec repmat(const svec &v, int n);
00996   extern template bvec repmat(const bvec &v, int n);
00997 
00998   extern template mat repmat(const vec &v, int m, int n, bool transpose);
00999   extern template cmat repmat(const cvec &v, int m, int n, bool transpose);
01000   extern template imat repmat(const ivec &v, int m, int n, bool transpose);
01001   extern template smat repmat(const svec &v, int m, int n, bool transpose);
01002   extern template bmat repmat(const bvec &v, int m, int n, bool transpose);
01003 
01004   extern template mat repmat(const mat &data, int m, int n);
01005   extern template cmat repmat(const cmat &data, int m, int n);
01006   extern template imat repmat(const imat &data, int m, int n);
01007   extern template smat repmat(const smat &data, int m, int n);
01008   extern template bmat repmat(const bmat &data, int m, int n);
01009 
01010 #endif // HAVE_EXTERN_TEMPLATE
01011 
01013 
01014 } // namespace itpp
01015 
01016 #endif // #ifndef MATFUNC_H
SourceForge Logo

Generated on Sat May 3 16:10:41 2008 for IT++ by Doxygen 1.5.5