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 #include <itpp/base/algebra/inv.h>
00038 
00039 
00040 namespace itpp
00041 {
00042 
00047 
00048 
00050 template<class T>
00051 int length(const Vec<T> &v) { return v.length(); }
00052 
00054 template<class T>
00055 int size(const Vec<T> &v) { return v.length(); }
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 
00098 
00100 template<class T>
00101 T sumsum(const Mat<T> &X)
00102 {
00103   const T * X_data = X._data();
00104   const int X_datasize = X._datasize();
00105   T acc = 0;
00106 
00107   for (int i = 0;i < X_datasize;i++)
00108     acc += X_data[i];
00109 
00110   return acc;
00111 }
00112 
00113 
00115 template<class T>
00116 T sum_sqr(const Vec<T> &v)
00117 {
00118   T M = 0;
00119 
00120   for (int i = 0; i < v.length(); i++)
00121     M += v[i] * v[i];
00122 
00123   return M;
00124 }
00125 
00133 template<class T>
00134 Vec<T> sum_sqr(const Mat<T> &m, int dim = 1)
00135 {
00136   it_assert((dim == 1) || (dim == 2), "sum_sqr: dimension need to be 1 or 2");
00137   Vec<T> out;
00138 
00139   if (dim == 1) {
00140     out.set_size(m.cols(), false);
00141 
00142     for (int i = 0; i < m.cols(); i++)
00143       out(i) = sum_sqr(m.get_col(i));
00144   }
00145   else {
00146     out.set_size(m.rows(), false);
00147 
00148     for (int i = 0; i < m.rows(); i++)
00149       out(i) = sum_sqr(m.get_row(i));
00150   }
00151 
00152   return out;
00153 }
00154 
00156 template<class T>
00157 Vec<T> cumsum(const Vec<T> &v)
00158 {
00159   Vec<T> out(v.size());
00160 
00161   out(0) = v(0);
00162   for (int i = 1; i < v.size(); i++)
00163     out(i) = out(i - 1) + v(i);
00164 
00165   return out;
00166 }
00167 
00175 template<class T>
00176 Mat<T> cumsum(const Mat<T> &m, int dim = 1)
00177 {
00178   it_assert((dim == 1) || (dim == 2), "cumsum: dimension need to be 1 or 2");
00179   Mat<T> out(m.rows(), m.cols());
00180 
00181   if (dim == 1) {
00182     for (int i = 0; i < m.cols(); i++)
00183       out.set_col(i, cumsum(m.get_col(i)));
00184   }
00185   else {
00186     for (int i = 0; i < m.rows(); i++)
00187       out.set_row(i, cumsum(m.get_row(i)));
00188   }
00189 
00190   return out;
00191 }
00192 
00194 template<class T>
00195 T prod(const Vec<T> &v)
00196 {
00197   it_assert(v.size() >= 1, "prod: size of vector should be at least 1");
00198   T out = v(0);
00199 
00200   for (int i = 1; i < v.size(); i++)
00201     out *= v(i);
00202 
00203   return out;
00204 }
00205 
00213 template<class T>
00214 Vec<T> prod(const Mat<T> &m, int dim = 1)
00215 {
00216   it_assert((dim == 1) || (dim == 2), "prod: dimension need to be 1 or 2");
00217   Vec<T> out(m.cols());
00218 
00219   if (dim == 1) {
00220     it_assert((m.cols() >= 1) && (m.rows() >= 1),
00221               "prod: number of columns should be at least 1");
00222     out.set_size(m.cols(), false);
00223 
00224     for (int i = 0; i < m.cols(); i++)
00225       out(i) = prod(m.get_col(i));
00226   }
00227   else {
00228     it_assert((m.cols() >= 1) && (m.rows() >= 1),
00229               "prod: number of rows should be at least 1");
00230     out.set_size(m.rows(), false);
00231 
00232     for (int i = 0; i < m.rows(); i++)
00233       out(i) = prod(m.get_row(i));
00234   }
00235   return out;
00236 }
00237 
00239 template<class T>
00240 Vec<T> cross(const Vec<T> &v1, const Vec<T> &v2)
00241 {
00242   it_assert((v1.size() == 3) && (v2.size() == 3),
00243             "cross: vectors should be of size 3");
00244 
00245   Vec<T> r(3);
00246 
00247   r(0) = v1(1) * v2(2) - v1(2) * v2(1);
00248   r(1) = v1(2) * v2(0) - v1(0) * v2(2);
00249   r(2) = v1(0) * v2(1) - v1(1) * v2(0);
00250 
00251   return r;
00252 }
00253 
00254 
00256 template<class T>
00257 Vec<T> zero_pad(const Vec<T> &v, int n)
00258 {
00259   it_assert(n >= v.size(), "zero_pad() cannot shrink the vector!");
00260   Vec<T> v2(n);
00261   v2.set_subvector(0, v.size() - 1, v);
00262   if (n > v.size())
00263     v2.set_subvector(v.size(), n - 1, T(0));
00264 
00265   return v2;
00266 }
00267 
00269 template<class T>
00270 Vec<T> zero_pad(const Vec<T> &v)
00271 {
00272   int n = pow2i(levels2bits(v.size()));
00273 
00274   return (n == v.size()) ? v : zero_pad(v, n);
00275 }
00276 
00278 template<class T>
00279 Mat<T> zero_pad(const Mat<T> &m, int rows, int cols)
00280 {
00281   it_assert((rows >= m.rows()) && (cols >= m.cols()),
00282             "zero_pad() cannot shrink the matrix!");
00283   Mat<T> m2(rows, cols);
00284   m2.set_submatrix(0, m.rows() - 1, 0, m.cols() - 1, m);
00285   if (cols > m.cols()) // Zero
00286     m2.set_submatrix(0, m.rows() - 1, m.cols(), cols - 1, T(0));
00287   if (rows > m.rows()) // Zero
00288     m2.set_submatrix(m.rows(), rows - 1, 0, cols - 1, T(0));
00289 
00290   return m2;
00291 }
00292 
00293 
00296 template<class T>
00297 T index_zero_pad(const Vec<T> &v, const int index)
00298 {
00299   if (index >= 0 && index < v.size())
00300     return v(index);
00301   else
00302     return T(0);
00303 }
00304 
00305 
00307 template<class T>
00308 void transpose(const Mat<T> &m, Mat<T> &out) { out = m.T(); }
00309 
00311 template<class T>
00312 Mat<T> transpose(const Mat<T> &m) { return m.T(); }
00313 
00314 
00317 template<class T>
00318 void hermitian_transpose(const Mat<T> &m, Mat<T> &out) { out = m.H(); }
00319 
00321 template<class T>
00322 Mat<T> hermitian_transpose(const Mat<T> &m) { return m.H(); }
00323 
00324 
00325 
00335 template<class Num_T>
00336 bool is_hermitian(const Mat<Num_T>& X)
00337 {
00338 
00339   if (X == X.H())
00340     return true;
00341   else
00342     return false;
00343 }
00344 
00354 template<class Num_T>
00355 bool is_unitary(const Mat<Num_T>& X)
00356 {
00357 
00358   if (inv(X) == X.H())
00359     return true;
00360   else
00361     return false;
00362 }
00363 
00364 
00373 template<class T>
00374 Vec<T> repmat(const Vec<T> &v, int n)
00375 {
00376   it_assert(n > 0, "repmat(): Wrong repetition parameter");
00377   int data_length = v.length();
00378   it_assert(data_length > 0, "repmat(): Input vector can not be empty");
00379   Vec<T> assembly(data_length * n);
00380   for (int j = 0; j < n; ++j) {
00381     assembly.set_subvector(j * data_length, v);
00382   }
00383   return assembly;
00384 }
00385 
00386 
00396 template<class T>
00397 Mat<T> repmat(const Mat<T> &data, int m, int n)
00398 {
00399   it_assert((m > 0) && (n > 0), "repmat(): Wrong repetition parameters");
00400   int data_rows = data.rows();
00401   int data_cols = data.cols();
00402   it_assert((data_rows > 0) && (data_cols > 0), "repmat(): Input matrix can "
00403             "not be empty");
00404   Mat<T> assembly(data_rows*m, data_cols*n);
00405   for (int i = 0; i < m; ++i) {
00406     for (int j = 0; j < n; ++j) {
00407       assembly.set_submatrix(i*data_rows, j*data_cols, data);
00408     }
00409   }
00410   return assembly;
00411 }
00412 
00424 template<class T> inline
00425 Mat<T> repmat(const Vec<T> &v, int m, int n, bool transpose = false)
00426 {
00427   return repmat((transpose ? v.T() : Mat<T>(v)), m, n);
00428 }
00429 
00430 
00442 template<class Num_T>
00443 Mat<Num_T> kron(const Mat<Num_T>& X, const Mat<Num_T>& Y)
00444 {
00445   Mat<Num_T> result(X.rows() * Y.rows(), X.cols() * Y.cols());
00446 
00447   for (int i = 0; i < X.rows(); i++)
00448     for (int j = 0; j < X.cols(); j++)
00449       result.set_submatrix(i * Y.rows(), j * Y.cols(), X(i, j) * Y);
00450 
00451   return result;
00452 }
00453 
00454 
00467 cmat sqrtm(const cmat& A);
00468 
00481 cmat sqrtm(const mat& A);
00482 
00484 
00485 
00486 
00487 // -------------------- Diagonal matrix functions -------------------------
00488 
00491 
00502 template<class T>
00503 Mat<T> diag(const Vec<T> &v, const int K = 0)
00504 {
00505   Mat<T> m(v.size() + std::abs(K), v.size() + std::abs(K));
00506   m = T(0);
00507   if (K > 0)
00508     for (int i = v.size() - 1; i >= 0; i--)
00509       m(i, i + K) = v(i);
00510   else
00511     for (int i = v.size() - 1; i >= 0; i--)
00512       m(i - K, i) = v(i);
00513 
00514   return m;
00515 }
00516 
00526 template<class T>
00527 void diag(const Vec<T> &v, Mat<T> &m)
00528 {
00529   m.set_size(v.size(), v.size(), false);
00530   m = T(0);
00531   for (int i = v.size() - 1; i >= 0; i--)
00532     m(i, i) = v(i);
00533 }
00534 
00542 template<class T>
00543 Vec<T> diag(const Mat<T> &m)
00544 {
00545   Vec<T> t(std::min(m.rows(), m.cols()));
00546 
00547   for (int i = 0; i < t.size(); i++)
00548     t(i) = m(i, i);
00549 
00550   return t;
00551 }
00552 
00562 template<class T>
00563 Mat<T> bidiag(const Vec<T> &main, const Vec<T> &sup)
00564 {
00565   it_assert(main.size() == sup.size() + 1, "bidiag()");
00566 
00567   int n = main.size();
00568   Mat<T> m(n, n);
00569   m = T(0);
00570   for (int i = 0; i < n - 1; i++) {
00571     m(i, i) = main(i);
00572     m(i, i + 1) = sup(i);
00573   }
00574   m(n - 1, n - 1) = main(n - 1);
00575 
00576   return m;
00577 }
00578 
00588 template<class T>
00589 void bidiag(const Vec<T> &main, const Vec<T> &sup, Mat<T> &m)
00590 {
00591   it_assert(main.size() == sup.size() + 1, "bidiag()");
00592 
00593   int n = main.size();
00594   m.set_size(n, n);
00595   m = T(0);
00596   for (int i = 0; i < n - 1; i++) {
00597     m(i, i) = main(i);
00598     m(i, i + 1) = sup(i);
00599   }
00600   m(n - 1, n - 1) = main(n - 1);
00601 }
00602 
00611 template<class T>
00612 void bidiag(const Mat<T> &m, Vec<T> &main, Vec<T> &sup)
00613 {
00614   it_assert(m.rows() == m.cols(), "bidiag(): Matrix must be square!");
00615 
00616   int n = m.cols();
00617   main.set_size(n);
00618   sup.set_size(n - 1);
00619   for (int i = 0; i < n - 1; i++) {
00620     main(i) = m(i, i);
00621     sup(i) = m(i, i + 1);
00622   }
00623   main(n - 1) = m(n - 1, n - 1);
00624 }
00625 
00635 template<class T>
00636 Mat<T> tridiag(const Vec<T> &main, const Vec<T> &sup, const Vec<T> &sub)
00637 {
00638   it_assert(main.size() == sup.size() + 1 && main.size() == sub.size() + 1, "bidiag()");
00639 
00640   int n = main.size();
00641   Mat<T> m(n, n);
00642   m = T(0);
00643   for (int i = 0; i < n - 1; i++) {
00644     m(i, i) = main(i);
00645     m(i, i + 1) = sup(i);
00646     m(i + 1, i) = sub(i);
00647   }
00648   m(n - 1, n - 1) = main(n - 1);
00649 
00650   return m;
00651 }
00652 
00662 template<class T>
00663 void tridiag(const Vec<T> &main, const Vec<T> &sup, const Vec<T> &sub, Mat<T> &m)
00664 {
00665   it_assert(main.size() == sup.size() + 1 && main.size() == sub.size() + 1, "bidiag()");
00666 
00667   int n = main.size();
00668   m.set_size(n, n);
00669   m = T(0);
00670   for (int i = 0; i < n - 1; i++) {
00671     m(i, i) = main(i);
00672     m(i, i + 1) = sup(i);
00673     m(i + 1, i) = sub(i);
00674   }
00675   m(n - 1, n - 1) = main(n - 1);
00676 }
00677 
00686 template<class T>
00687 void tridiag(const Mat<T> &m, Vec<T> &main, Vec<T> &sup, Vec<T> &sub)
00688 {
00689   it_assert(m.rows() == m.cols(), "tridiag(): Matrix must be square!");
00690 
00691   int n = m.cols();
00692   main.set_size(n);
00693   sup.set_size(n - 1);
00694   sub.set_size(n - 1);
00695   for (int i = 0; i < n - 1; i++) {
00696     main(i) = m(i, i);
00697     sup(i) = m(i, i + 1);
00698     sub(i) = m(i + 1, i);
00699   }
00700   main(n - 1) = m(n - 1, n - 1);
00701 }
00702 
00703 
00707 template<class T>
00708 T trace(const Mat<T> &m)
00709 {
00710   return sum(diag(m));
00711 }
00712 
00714 
00715 
00716 // ----------------- reshaping vectors and matrices ------------------------
00717 
00720 
00722 template<class T>
00723 Vec<T> reverse(const Vec<T> &in)
00724 {
00725   int i, s = in.length();
00726 
00727   Vec<T> out(s);
00728   for (i = 0;i < s;i++)
00729     out[i] = in[s-1-i];
00730   return out;
00731 }
00732 
00734 template<class T>
00735 Vec<T> rvectorize(const Mat<T> &m)
00736 {
00737   int i, j, n = 0, r = m.rows(), c = m.cols();
00738   Vec<T> v(r * c);
00739 
00740   for (i = 0; i < r; i++)
00741     for (j = 0; j < c; j++)
00742       v(n++) = m(i, j);
00743 
00744   return v;
00745 }
00746 
00748 template<class T>
00749 Vec<T> cvectorize(const Mat<T> &m)
00750 {
00751   int i, j, n = 0, r = m.rows(), c = m.cols();
00752   Vec<T> v(r * c);
00753 
00754   for (j = 0; j < c; j++)
00755     for (i = 0; i < r; i++)
00756       v(n++) = m(i, j);
00757 
00758   return v;
00759 }
00760 
00767 template<class T>
00768 Mat<T> reshape(const Mat<T> &m, int rows, int cols)
00769 {
00770   it_assert_debug(m.rows()*m.cols() == rows*cols, "Mat<T>::reshape: Sizes must match");
00771   Mat<T> temp(rows, cols);
00772   int i, j, ii = 0, jj = 0;
00773   for (j = 0; j < m.cols(); j++) {
00774     for (i = 0; i < m.rows(); i++) {
00775       temp(ii++, jj) = m(i, j);
00776       if (ii == rows) {
00777         jj++;
00778         ii = 0;
00779       }
00780     }
00781   }
00782   return temp;
00783 }
00784 
00791 template<class T>
00792 Mat<T> reshape(const Vec<T> &v, int rows, int cols)
00793 {
00794   it_assert_debug(v.size() == rows*cols, "Mat<T>::reshape: Sizes must match");
00795   Mat<T> temp(rows, cols);
00796   int i, j, ii = 0;
00797   for (j = 0; j < cols; j++) {
00798     for (i = 0; i < rows; i++) {
00799       temp(i, j) = v(ii++);
00800     }
00801   }
00802   return temp;
00803 }
00804 
00806 
00807 
00809 bool all(const bvec &testvec);
00811 bool any(const bvec &testvec);
00812 
00814 
00815 // ----------------------------------------------------------------------
00816 // Instantiations
00817 // ----------------------------------------------------------------------
00818 
00819 #ifdef HAVE_EXTERN_TEMPLATE
00820 
00821 extern template int length(const vec &v);
00822 extern template int length(const cvec &v);
00823 extern template int length(const svec &v);
00824 extern template int length(const ivec &v);
00825 extern template int length(const bvec &v);
00826 
00827 extern template double sum(const vec &v);
00828 extern template std::complex<double> sum(const cvec &v);
00829 extern template short sum(const svec &v);
00830 extern template int sum(const ivec &v);
00831 extern template bin sum(const bvec &v);
00832 
00833 extern template double sum_sqr(const vec &v);
00834 extern template std::complex<double> sum_sqr(const cvec &v);
00835 extern template short sum_sqr(const svec &v);
00836 extern template int sum_sqr(const ivec &v);
00837 extern template bin sum_sqr(const bvec &v);
00838 
00839 extern template vec cumsum(const vec &v);
00840 extern template cvec cumsum(const cvec &v);
00841 extern template svec cumsum(const svec &v);
00842 extern template ivec cumsum(const ivec &v);
00843 extern template bvec cumsum(const bvec &v);
00844 
00845 extern template double prod(const vec &v);
00846 extern template std::complex<double> prod(const cvec &v);
00847 extern template short prod(const svec &v);
00848 extern template int prod(const ivec &v);
00849 extern template bin prod(const bvec &v);
00850 
00851 extern template vec cross(const vec &v1, const vec &v2);
00852 extern template cvec cross(const cvec &v1, const cvec &v2);
00853 extern template ivec cross(const ivec &v1, const ivec &v2);
00854 extern template svec cross(const svec &v1, const svec &v2);
00855 extern template bvec cross(const bvec &v1, const bvec &v2);
00856 
00857 extern template vec reverse(const vec &in);
00858 extern template cvec reverse(const cvec &in);
00859 extern template svec reverse(const svec &in);
00860 extern template ivec reverse(const ivec &in);
00861 extern template bvec reverse(const bvec &in);
00862 
00863 extern template vec zero_pad(const vec &v, int n);
00864 extern template cvec zero_pad(const cvec &v, int n);
00865 extern template ivec zero_pad(const ivec &v, int n);
00866 extern template svec zero_pad(const svec &v, int n);
00867 extern template bvec zero_pad(const bvec &v, int n);
00868 
00869 extern template vec zero_pad(const vec &v);
00870 extern template cvec zero_pad(const cvec &v);
00871 extern template ivec zero_pad(const ivec &v);
00872 extern template svec zero_pad(const svec &v);
00873 extern template bvec zero_pad(const bvec &v);
00874 
00875 extern template mat zero_pad(const mat &, int, int);
00876 extern template cmat zero_pad(const cmat &, int, int);
00877 extern template imat zero_pad(const imat &, int, int);
00878 extern template smat zero_pad(const smat &, int, int);
00879 extern template bmat zero_pad(const bmat &, int, int);
00880 
00881 extern template vec sum(const mat &m, int dim);
00882 extern template cvec sum(const cmat &m, int dim);
00883 extern template svec sum(const smat &m, int dim);
00884 extern template ivec sum(const imat &m, int dim);
00885 extern template bvec sum(const bmat &m, int dim);
00886 
00887 extern template double sumsum(const mat &X);
00888 extern template std::complex<double> sumsum(const cmat &X);
00889 extern template short sumsum(const smat &X);
00890 extern template int sumsum(const imat &X);
00891 extern template bin sumsum(const bmat &X);
00892 
00893 extern template vec sum_sqr(const mat & m, int dim);
00894 extern template cvec sum_sqr(const cmat &m, int dim);
00895 extern template svec sum_sqr(const smat &m, int dim);
00896 extern template ivec sum_sqr(const imat &m, int dim);
00897 extern template bvec sum_sqr(const bmat &m, int dim);
00898 
00899 extern template mat cumsum(const mat &m, int dim);
00900 extern template cmat cumsum(const cmat &m, int dim);
00901 extern template smat cumsum(const smat &m, int dim);
00902 extern template imat cumsum(const imat &m, int dim);
00903 extern template bmat cumsum(const bmat &m, int dim);
00904 
00905 extern template vec prod(const mat &m, int dim);
00906 extern template cvec prod(const cmat &v, int dim);
00907 extern template svec prod(const smat &m, int dim);
00908 extern template ivec prod(const imat &m, int dim);
00909 extern template bvec prod(const bmat &m, int dim);
00910 
00911 extern template vec diag(const mat &in);
00912 extern template cvec diag(const cmat &in);
00913 extern template void diag(const vec &in, mat &m);
00914 extern template void diag(const cvec &in, cmat &m);
00915 extern template mat diag(const vec &v, const int K);
00916 extern template cmat diag(const cvec &v, const int K);
00917 
00918 extern template mat bidiag(const vec &, const vec &);
00919 extern template cmat bidiag(const cvec &, const cvec &);
00920 extern template void bidiag(const vec &, const vec &, mat &);
00921 extern template void bidiag(const cvec &, const cvec &, cmat &);
00922 extern template void bidiag(const mat &, vec &, vec &);
00923 extern template void bidiag(const cmat &, cvec &, cvec &);
00924 
00925 extern template mat tridiag(const vec &main, const vec &, const vec &);
00926 extern template cmat tridiag(const cvec &main, const cvec &, const cvec &);
00927 extern template void tridiag(const vec &main, const vec &, const vec &, mat &);
00928 extern template void tridiag(const cvec &main, const cvec &, const cvec &, cmat &);
00929 extern template void tridiag(const mat &m, vec &, vec &, vec &);
00930 extern template void tridiag(const cmat &m, cvec &, cvec &, cvec &);
00931 
00932 extern template double trace(const mat &in);
00933 extern template std::complex<double> trace(const cmat &in);
00934 extern template short trace(const smat &in);
00935 extern template int trace(const imat &in);
00936 extern template bin trace(const bmat &in);
00937 
00938 extern template void transpose(const mat &m, mat &out);
00939 extern template void transpose(const cmat &m, cmat &out);
00940 extern template void transpose(const smat &m, smat &out);
00941 extern template void transpose(const imat &m, imat &out);
00942 extern template void transpose(const bmat &m, bmat &out);
00943 
00944 extern template mat transpose(const mat &m);
00945 extern template cmat transpose(const cmat &m);
00946 extern template smat transpose(const smat &m);
00947 extern template imat transpose(const imat &m);
00948 extern template bmat transpose(const bmat &m);
00949 
00950 extern template void hermitian_transpose(const mat &m, mat &out);
00951 extern template void hermitian_transpose(const cmat &m, cmat &out);
00952 extern template void hermitian_transpose(const smat &m, smat &out);
00953 extern template void hermitian_transpose(const imat &m, imat &out);
00954 extern template void hermitian_transpose(const bmat &m, bmat &out);
00955 
00956 extern template mat hermitian_transpose(const mat &m);
00957 extern template cmat hermitian_transpose(const cmat &m);
00958 extern template smat hermitian_transpose(const smat &m);
00959 extern template imat hermitian_transpose(const imat &m);
00960 extern template bmat hermitian_transpose(const bmat &m);
00961 
00962 extern template bool is_hermitian(const mat &X);
00963 extern template bool is_hermitian(const cmat &X);
00964 
00965 extern template bool is_unitary(const mat &X);
00966 extern template bool is_unitary(const cmat &X);
00967 
00968 extern template vec rvectorize(const mat &m);
00969 extern template cvec rvectorize(const cmat &m);
00970 extern template ivec rvectorize(const imat &m);
00971 extern template svec rvectorize(const smat &m);
00972 extern template bvec rvectorize(const bmat &m);
00973 
00974 extern template vec cvectorize(const mat &m);
00975 extern template cvec cvectorize(const cmat &m);
00976 extern template ivec cvectorize(const imat &m);
00977 extern template svec cvectorize(const smat &m);
00978 extern template bvec cvectorize(const bmat &m);
00979 
00980 extern template mat reshape(const mat &m, int rows, int cols);
00981 extern template cmat reshape(const cmat &m, int rows, int cols);
00982 extern template imat reshape(const imat &m, int rows, int cols);
00983 extern template smat reshape(const smat &m, int rows, int cols);
00984 extern template bmat reshape(const bmat &m, int rows, int cols);
00985 
00986 extern template mat reshape(const vec &m, int rows, int cols);
00987 extern template cmat reshape(const cvec &m, int rows, int cols);
00988 extern template imat reshape(const ivec &m, int rows, int cols);
00989 extern template smat reshape(const svec &m, int rows, int cols);
00990 extern template bmat reshape(const bvec &m, int rows, int cols);
00991 
00992 extern template mat kron(const mat &X, const mat &Y);
00993 extern template cmat kron(const cmat &X, const cmat &Y);
00994 extern template imat kron(const imat &X, const imat &Y);
00995 extern template smat kron(const smat &X, const smat &Y);
00996 extern template bmat kron(const bmat &X, const bmat &Y);
00997 
00998 extern template vec repmat(const vec &v, int n);
00999 extern template cvec repmat(const cvec &v, int n);
01000 extern template ivec repmat(const ivec &v, int n);
01001 extern template svec repmat(const svec &v, int n);
01002 extern template bvec repmat(const bvec &v, int n);
01003 
01004 extern template mat repmat(const vec &v, int m, int n, bool transpose);
01005 extern template cmat repmat(const cvec &v, int m, int n, bool transpose);
01006 extern template imat repmat(const ivec &v, int m, int n, bool transpose);
01007 extern template smat repmat(const svec &v, int m, int n, bool transpose);
01008 extern template bmat repmat(const bvec &v, int m, int n, bool transpose);
01009 
01010 extern template mat repmat(const mat &data, int m, int n);
01011 extern template cmat repmat(const cmat &data, int m, int n);
01012 extern template imat repmat(const imat &data, int m, int n);
01013 extern template smat repmat(const smat &data, int m, int n);
01014 extern template bmat repmat(const bmat &data, int m, int n);
01015 
01016 #endif // HAVE_EXTERN_TEMPLATE
01017 
01019 
01020 } // namespace itpp
01021 
01022 #endif // #ifndef MATFUNC_H
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Defines
SourceForge Logo

Generated on Tue Feb 2 09:33:29 2010 for IT++ by Doxygen 1.6.2