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

Generated on Fri May 1 11:09:16 2009 for IT++ by Doxygen 1.5.8