Fn_misc

Functions

template<typename eT >
Mat< eT > linspace (const eT start, const eT end, const u32 num, const u32 dim=0)
 Generate a vector with 'num' elements. The values of the elements linearly increase from 'start' upto (and including) 'end'.
mat linspace (const double start, const double end, const u32 num, const u32 dim=0)
template<typename T , typename T1 >
Mat< T > real (const Base< std::complex< T >, T1 > &X)
template<typename T , typename T1 >
Cube< T > real (const BaseCube< std::complex< T >, T1 > &X)
template<typename T , typename T1 >
Mat< T > imag (const Base< std::complex< T >, T1 > &X)
template<typename T , typename T1 >
Cube< T > imag (const BaseCube< std::complex< T >, T1 > &X)
template<typename eT >
eT log_add (eT log_a, eT log_b)
template<typename eT >
eT trunc_log (const eT x)
template<typename eT >
eT trunc_exp (const eT x)
template<typename T1 >
const Op< T1, op_loglog (const Base< typename T1::elem_type, T1 > &A)
template<typename T1 >
const OpCube< T1, op_loglog (const BaseCube< typename T1::elem_type, T1 > &A)
template<typename T1 >
const Op< T1, op_trunc_logtrunc_log (const Base< typename T1::elem_type, T1 > &A)
template<typename T1 >
const OpCube< T1, op_trunc_logtrunc_log (const BaseCube< typename T1::elem_type, T1 > &A)
template<typename T1 >
const Op< T1, op_log10log10 (const Base< typename T1::elem_type, T1 > &A)
template<typename T1 >
const OpCube< T1, op_log10log10 (const BaseCube< typename T1::elem_type, T1 > &A)
template<typename T1 >
const Op< T1, op_expexp (const Base< typename T1::elem_type, T1 > &A)
template<typename T1 >
const OpCube< T1, op_expexp (const BaseCube< typename T1::elem_type, T1 > &A)
template<typename T1 >
const Op< T1, op_trunc_exptrunc_exp (const Base< typename T1::elem_type, T1 > &A)
template<typename T1 >
const OpCube< T1, op_trunc_exptrunc_exp (const BaseCube< typename T1::elem_type, T1 > &A)
template<typename T1 >
Mat< typename T1::pod_type > abs (const Base< typename T1::elem_type, T1 > &X)
template<typename T1 >
Cube< typename T1::pod_type > abs (const BaseCube< typename T1::elem_type, T1 > &X)
template<typename T1 >
Mat< typename T1::pod_type > fabs (const Base< typename T1::elem_type, T1 > &A)
template<typename T1 >
Cube< typename T1::pod_type > fabs (const BaseCube< typename T1::elem_type, T1 > &A)
template<typename T1 >
const Op< T1, op_squaresquare (const Base< typename T1::elem_type, T1 > &A)
template<typename T1 >
const OpCube< T1, op_squaresquare (const BaseCube< typename T1::elem_type, T1 > &A)
template<typename T1 >
const Op< T1, op_sqrtsqrt (const Base< typename T1::elem_type, T1 > &A)
template<typename T1 >
const OpCube< T1, op_sqrtsqrt (const BaseCube< typename T1::elem_type, T1 > &A)
template<typename T1 >
const Op< T1, op_powpow (const Base< typename T1::elem_type, T1 > &A, const typename T1::elem_type exponent)
template<typename T1 >
const OpCube< T1, op_powpow (const BaseCube< typename T1::elem_type, T1 > &A, const typename T1::elem_type exponent)
template<typename T1 >
const Op< T1, op_powpow (const Base< typename T1::elem_type, T1 > &A, const typename T1::elem_type::value_type exponent)
template<typename T1 >
const OpCube< T1, op_powpow (const BaseCube< typename T1::elem_type, T1 > &A, const typename T1::elem_type::value_type exponent)
template<typename T1 >
const Op< T1, op_pow_s32pow (const Base< typename T1::elem_type, T1 > &A, const s32 exponent)
template<typename T1 >
const OpCube< T1, op_pow_s32pow (const BaseCube< typename T1::elem_type, T1 > &A, const s32 exponent)
template<typename T , typename T1 >
const Op< T1, op_conjconj (const Base< std::complex< T >, T1 > &A)
template<typename T , typename T1 >
const OpCube< T1, op_conjconj (const BaseCube< std::complex< T >, T1 > &A)
template<typename T1 >
const T1 & conj (const Op< T1, op_conj > &A)
template<typename T1 >
const T1 & conj (const OpCube< T1, op_conj > &A)
template<typename T1 >
const Op< T1, op_htransconj (const Op< T1, op_trans > &A)
 the conjugate of the transpose of a complex matrix is the same as the hermitian transpose

Function Documentation

template<typename eT >
Mat<eT> linspace ( const eT  start,
const eT  end,
const u32  num,
const u32  dim = 0 
) [inline]

Generate a vector with 'num' elements. The values of the elements linearly increase from 'start' upto (and including) 'end'.

Definition at line 26 of file fn_misc.hpp.

References Mat< eT >::set_size().

00027   {
00028   arma_extra_debug_sigprint();
00029   
00030   arma_debug_check( (num < 2), "linspace(): num must be >= 2");
00031   
00032   Mat<eT> x;
00033   
00034   if(dim == 0)
00035     {
00036     x.set_size(num,1);  // column vector
00037     }
00038   else
00039     {
00040     x.set_size(1,num);  // row vector
00041     }
00042   
00043   
00044   const eT delta = (end-start)/(num-1);
00045   
00046   x[0] = start;
00047   
00048   for(u32 i=1; i<num; ++i)
00049     {
00050     x[i] = x[i-1] + delta;
00051     }
00052   
00053   return x; 
00054   }

mat linspace ( const double  start,
const double  end,
const u32  num,
const u32  dim = 0 
) [inline]

Definition at line 60 of file fn_misc.hpp.

00061   {
00062   arma_extra_debug_sigprint();
00063   return linspace<double>(start, end, num, dim);
00064   }

template<typename T , typename T1 >
Mat<T> real ( const Base< std::complex< T >, T1 > &  X  )  [inline]

Definition at line 74 of file fn_misc.hpp.

References Mat< eT >::memptr(), and Mat< eT >::n_elem.

Referenced by real(), and auxlib::svd().

00075   {
00076   arma_extra_debug_sigprint();
00077   
00078   typedef std::complex<T> eT;
00079 
00080   const unwrap<T1> A_tmp(X.get_ref());
00081   const Mat<eT>& A = A_tmp.M;
00082   
00083   Mat<T> out(A.n_rows, A.n_cols);
00084   
00085   const eT* A_mem = A.mem;
00086   T* out_mem = out.memptr();
00087   
00088   for(u32 i=0; i<out.n_elem; ++i)
00089     {
00090     out_mem[i] = std::real(A_mem[i]);
00091     }
00092   
00093   return out;
00094   }

template<typename T , typename T1 >
Cube<T> real ( const BaseCube< std::complex< T >, T1 > &  X  )  [inline]

Definition at line 101 of file fn_misc.hpp.

References Cube< eT >::memptr(), Cube< eT >::n_elem, and real().

00102   {
00103   arma_extra_debug_sigprint();
00104   
00105   typedef std::complex<T> eT;
00106 
00107   const unwrap_cube<T1> A_tmp(X.get_ref());
00108   const Cube<eT>& A   = A_tmp.M;
00109   
00110   Cube<T> out(A.n_rows, A.n_cols, A.n_slices);
00111   
00112   const eT* A_mem = A.mem;
00113   T* out_mem = out.memptr();
00114   
00115   for(u32 i=0; i<out.n_elem; ++i)
00116     {
00117     out_mem[i] = std::real(A_mem[i]);
00118     }
00119   
00120   return out;
00121   }

template<typename T , typename T1 >
Mat<T> imag ( const Base< std::complex< T >, T1 > &  X  )  [inline]

Definition at line 131 of file fn_misc.hpp.

References Mat< eT >::memptr(), and Mat< eT >::n_elem.

Referenced by imag().

00132   {
00133   arma_extra_debug_sigprint();
00134   
00135   typedef std::complex<T> eT;
00136 
00137   const unwrap<T1> A_tmp(X.get_ref());
00138   const Mat<eT>& A = A_tmp.M;
00139   
00140   Mat<T> out(A.n_rows, A.n_cols);
00141   
00142   const eT* A_mem = A.mem;
00143   T* out_mem = out.memptr();
00144   
00145   for(u32 i=0; i<out.n_elem; ++i)
00146     {
00147     out_mem[i] = std::imag(A_mem[i]);
00148     }
00149   
00150   return out;
00151   }

template<typename T , typename T1 >
Cube<T> imag ( const BaseCube< std::complex< T >, T1 > &  X  )  [inline]

Definition at line 158 of file fn_misc.hpp.

References imag(), Cube< eT >::memptr(), and Cube< eT >::n_elem.

00159   {
00160   arma_extra_debug_sigprint();
00161   
00162   typedef std::complex<T> eT;
00163 
00164   const unwrap_cube<T1> A_tmp(X.get_ref());
00165   const Cube<eT>& A   = A_tmp.M;
00166   
00167   Cube<T> out(A.n_rows, A.n_cols, A.n_slices);
00168   
00169   const eT* A_mem = A.mem;
00170   T* out_mem = out.memptr();
00171   
00172   for(u32 i=0; i<out.n_elem; ++i)
00173     {
00174     out_mem[i] = std::imag(A_mem[i]);
00175     }
00176   
00177   return out;
00178   }

template<typename eT >
eT log_add ( eT  log_a,
eT  log_b 
) [inline]

Definition at line 188 of file fn_misc.hpp.

References arma_isfinite(), exp(), and log().

00189   {
00190   if(log_a < log_b)
00191     {
00192     std::swap(log_a, log_b);
00193     }
00194   
00195   const eT negdelta = log_b - log_a;
00196   
00197   if( (negdelta < Math<eT>::log_min()) || (arma_isfinite(negdelta) == false) )
00198     {
00199     return log_a;
00200     }
00201   else
00202     {
00203     #if defined(ARMA_HAVE_LOG1P)
00204       return (log_a + log1p(std::exp(negdelta)));
00205     #else
00206       return (log_a + std::log(1.0 + std::exp(negdelta)));
00207     #endif
00208     }
00209   }

template<typename eT >
eT trunc_log ( const eT  x  )  [inline]

Definition at line 216 of file fn_misc.hpp.

References log(), Math< eT >::log_max(), and Math< eT >::log_min().

Referenced by op_trunc_log::apply().

00217   {
00218   if(std::numeric_limits<eT>::is_iec559)
00219     {
00220     if(x == std::numeric_limits<eT>::infinity())
00221       {
00222       return Math<eT>::log_max();
00223       }
00224     if(x <= 0)
00225       {
00226       return Math<eT>::log_min();
00227       }
00228     else
00229       {
00230       return std::log(x);
00231       }
00232     }
00233   else
00234     {
00235     return std::log(x);
00236     }
00237   }

template<typename eT >
eT trunc_exp ( const eT  x  )  [inline]

Definition at line 244 of file fn_misc.hpp.

References exp(), and max().

Referenced by op_trunc_exp::apply().

00245   {
00246   if(std::numeric_limits<eT>::is_iec559 && (x >= Math<eT>::log_max() ))
00247     {
00248     return std::numeric_limits<eT>::max();
00249     }
00250   else
00251     {
00252     return std::exp(x);
00253     }
00254   }

template<typename T1 >
const Op<T1, op_log> log ( const Base< typename T1::elem_type, T1 > &  A  )  [inline]

Definition at line 264 of file fn_misc.hpp.

References Base< elem_type, derived >::get_ref().

Referenced by op_log::apply(), log_add(), Math< eT >::log_max(), Math< eT >::log_min(), and trunc_log().

00265   {
00266   arma_extra_debug_sigprint();
00267   
00268   return Op<T1, op_log>(A.get_ref());
00269   }

template<typename T1 >
const OpCube<T1, op_log> log ( const BaseCube< typename T1::elem_type, T1 > &  A  )  [inline]

Definition at line 276 of file fn_misc.hpp.

References BaseCube< elem_type, derived >::get_ref().

00277   {
00278   arma_extra_debug_sigprint();
00279   
00280   return OpCube<T1, op_log>(A.get_ref());
00281   }

template<typename T1 >
const Op<T1, op_trunc_log> trunc_log ( const Base< typename T1::elem_type, T1 > &  A  )  [inline]

Definition at line 291 of file fn_misc.hpp.

References Base< elem_type, derived >::get_ref().

00292   {
00293   arma_extra_debug_sigprint();
00294   
00295   return Op<T1, op_trunc_log>(A.get_ref());
00296   }

template<typename T1 >
const OpCube<T1, op_trunc_log> trunc_log ( const BaseCube< typename T1::elem_type, T1 > &  A  )  [inline]

Definition at line 303 of file fn_misc.hpp.

References BaseCube< elem_type, derived >::get_ref().

00304   {
00305   arma_extra_debug_sigprint();
00306   
00307   return OpCube<T1, op_trunc_log>(A.get_ref());
00308   }

template<typename T1 >
const Op<T1, op_log10> log10 ( const Base< typename T1::elem_type, T1 > &  A  )  [inline]

Definition at line 318 of file fn_misc.hpp.

References Base< elem_type, derived >::get_ref().

Referenced by op_log10::apply(), and op_eps::direct_eps().

00319   {
00320   arma_extra_debug_sigprint();
00321   
00322   return Op<T1, op_log10>(A.get_ref());
00323   }

template<typename T1 >
const OpCube<T1, op_log10> log10 ( const BaseCube< typename T1::elem_type, T1 > &  A  )  [inline]

Definition at line 330 of file fn_misc.hpp.

References BaseCube< elem_type, derived >::get_ref().

00331   {
00332   arma_extra_debug_sigprint();
00333   
00334   return OpCube<T1, op_log10>(A.get_ref());
00335   }

template<typename T1 >
const Op<T1, op_exp> exp ( const Base< typename T1::elem_type, T1 > &  A  )  [inline]

Definition at line 345 of file fn_misc.hpp.

References Base< elem_type, derived >::get_ref().

Referenced by op_exp::apply(), log_add(), and trunc_exp().

00346   {
00347   arma_extra_debug_sigprint();
00348   
00349   return Op<T1, op_exp>(A.get_ref());
00350   }

template<typename T1 >
const OpCube<T1, op_exp> exp ( const BaseCube< typename T1::elem_type, T1 > &  A  )  [inline]

Definition at line 357 of file fn_misc.hpp.

References BaseCube< elem_type, derived >::get_ref().

00358   {
00359   arma_extra_debug_sigprint();
00360   
00361   return OpCube<T1, op_exp>(A.get_ref());
00362   }

template<typename T1 >
const Op<T1, op_trunc_exp> trunc_exp ( const Base< typename T1::elem_type, T1 > &  A  )  [inline]

Definition at line 372 of file fn_misc.hpp.

References Base< elem_type, derived >::get_ref().

00373   {
00374   arma_extra_debug_sigprint();
00375   
00376   return Op<T1, op_trunc_exp>(A.get_ref());
00377   }

template<typename T1 >
const OpCube<T1, op_trunc_exp> trunc_exp ( const BaseCube< typename T1::elem_type, T1 > &  A  )  [inline]

Definition at line 384 of file fn_misc.hpp.

References BaseCube< elem_type, derived >::get_ref().

00385   {
00386   arma_extra_debug_sigprint();
00387   
00388   return OpCube<T1, op_trunc_exp>(A.get_ref());
00389   }

template<typename T1 >
Mat<typename T1::pod_type> abs ( const Base< typename T1::elem_type, T1 > &  X  )  [inline]

Definition at line 399 of file fn_misc.hpp.

References Base< elem_type, derived >::get_ref(), Mat< eT >::mem, Mat< eT >::memptr(), Mat< eT >::n_cols, Mat< eT >::n_elem, and Mat< eT >::n_rows.

Referenced by abs(), op_min::apply(), op_median::apply(), op_max::apply(), arma_qsort_helper< std::complex< T > >::ascend_compare(), arma_qsort_helper< std::complex< T > >::descend_compare(), op_median::direct_cx_median_index(), op_eps::direct_eps(), op_max::direct_max(), op_min::direct_min(), fabs(), and norm().

00400   {
00401   arma_extra_debug_sigprint();
00402   
00403   const unwrap<T1> A_tmp(X.get_ref());
00404 
00405   // if T1 is a complex matrix,
00406   // pod_type is the underlying type used by std::complex;
00407   // otherwise pod_type is the same as elem_type
00408   
00409   typedef typename T1::elem_type  in_eT;
00410   typedef typename T1::pod_type  out_eT;
00411 
00412   const Mat<in_eT>& A = A_tmp.M;
00413   
00414   Mat<out_eT> out(A.n_rows, A.n_cols);
00415   
00416   const in_eT* A_mem   = A.mem;
00417   out_eT*      out_mem = out.memptr();
00418   
00419   for(u32 i=0; i<out.n_elem; ++i)
00420     {
00421     out_mem[i] = std::abs(A_mem[i]);
00422     }
00423   
00424   return out;
00425   }

template<typename T1 >
Cube<typename T1::pod_type> abs ( const BaseCube< typename T1::elem_type, T1 > &  X  )  [inline]

Definition at line 432 of file fn_misc.hpp.

References abs(), BaseCube< elem_type, derived >::get_ref(), Cube< eT >::mem, Cube< eT >::memptr(), Cube< eT >::n_cols, Cube< eT >::n_elem, Cube< eT >::n_rows, and Cube< eT >::n_slices.

00433   {
00434   arma_extra_debug_sigprint();
00435   
00436   const unwrap_cube<T1> A_tmp(X.get_ref());
00437 
00438   // if T1 is a complex matrix,
00439   // pod_type is the underlying type used by std::complex;
00440   // otherwise pod_type is the same as elem_type
00441   
00442   typedef typename T1::elem_type  in_eT;
00443   typedef typename T1::pod_type  out_eT;
00444 
00445   const Cube<in_eT>& A = A_tmp.M;
00446   
00447   Cube<out_eT> out(A.n_rows, A.n_cols, A.n_slices);
00448   
00449   const in_eT* A_mem   = A.mem;
00450   out_eT*      out_mem = out.memptr();
00451   
00452   for(u32 i=0; i<out.n_elem; ++i)
00453     {
00454     out_mem[i] = std::abs(A_mem[i]);
00455     }
00456   
00457   return out;
00458   }

template<typename T1 >
Mat<typename T1::pod_type> fabs ( const Base< typename T1::elem_type, T1 > &  A  )  [inline]

Definition at line 468 of file fn_misc.hpp.

References abs().

00469   {
00470   arma_extra_debug_sigprint();
00471   
00472   return abs(A);
00473   }

template<typename T1 >
Cube<typename T1::pod_type> fabs ( const BaseCube< typename T1::elem_type, T1 > &  A  )  [inline]

Definition at line 480 of file fn_misc.hpp.

References abs().

00481   {
00482   arma_extra_debug_sigprint();
00483   
00484   return abs(A);
00485   }

template<typename T1 >
const Op<T1, op_square> square ( const Base< typename T1::elem_type, T1 > &  A  )  [inline]

Definition at line 495 of file fn_misc.hpp.

References Base< elem_type, derived >::get_ref().

00496   {
00497   arma_extra_debug_sigprint();
00498   
00499   return Op<T1, op_square>(A.get_ref());
00500   }

template<typename T1 >
const OpCube<T1, op_square> square ( const BaseCube< typename T1::elem_type, T1 > &  A  )  [inline]

Definition at line 507 of file fn_misc.hpp.

References BaseCube< elem_type, derived >::get_ref().

00508   {
00509   arma_extra_debug_sigprint();
00510   
00511   return OpCube<T1, op_square>(A.get_ref());
00512   }

template<typename T1 >
const Op<T1, op_sqrt> sqrt ( const Base< typename T1::elem_type, T1 > &  A  )  [inline]

Definition at line 522 of file fn_misc.hpp.

References Base< elem_type, derived >::get_ref().

Referenced by accu(), op_stddev::apply(), op_sqrt::apply(), op_norm_dot::apply(), norm(), running_stat_vec< eT >::stddev(), running_stat< eT >::stddev(), and stddev().

00523   {
00524   arma_extra_debug_sigprint();
00525   
00526   return Op<T1, op_sqrt>(A.get_ref());
00527   }

template<typename T1 >
const OpCube<T1, op_sqrt> sqrt ( const BaseCube< typename T1::elem_type, T1 > &  A  )  [inline]

Definition at line 534 of file fn_misc.hpp.

References BaseCube< elem_type, derived >::get_ref().

00535   {
00536   arma_extra_debug_sigprint();
00537   
00538   return OpCube<T1, op_sqrt>(A.get_ref());
00539   }

template<typename T1 >
const Op<T1, op_pow> pow ( const Base< typename T1::elem_type, T1 > &  A,
const typename T1::elem_type  exponent 
) [inline]

Definition at line 548 of file fn_misc.hpp.

References Base< elem_type, derived >::get_ref().

Referenced by op_pow::apply(), op_eps::direct_eps(), op_pow_s32::internal_pow(), op_pow::internal_pow(), and norm().

00549   {
00550   arma_extra_debug_sigprint();
00551   
00552   return Op<T1, op_pow>(A.get_ref(), exponent);
00553   }

template<typename T1 >
const OpCube<T1, op_pow> pow ( const BaseCube< typename T1::elem_type, T1 > &  A,
const typename T1::elem_type  exponent 
) [inline]

Definition at line 560 of file fn_misc.hpp.

References BaseCube< elem_type, derived >::get_ref().

00561   {
00562   arma_extra_debug_sigprint();
00563   
00564   return OpCube<T1, op_pow>(A.get_ref(), exponent);
00565   }

template<typename T1 >
const Op<T1, op_pow> pow ( const Base< typename T1::elem_type, T1 > &  A,
const typename T1::elem_type::value_type  exponent 
) [inline]

Definition at line 574 of file fn_misc.hpp.

References Base< elem_type, derived >::get_ref().

00575   {
00576   arma_extra_debug_sigprint();
00577   
00578   return Op<T1, op_pow>(A.get_ref(), eT(exponent));
00579   }

template<typename T1 >
const OpCube<T1, op_pow> pow ( const BaseCube< typename T1::elem_type, T1 > &  A,
const typename T1::elem_type::value_type  exponent 
) [inline]

Definition at line 586 of file fn_misc.hpp.

References BaseCube< elem_type, derived >::get_ref().

00587   {
00588   arma_extra_debug_sigprint();
00589   
00590   return OpCube<T1, op_pow>(A.get_ref(), eT(exponent));
00591   }

template<typename T1 >
const Op<T1, op_pow_s32> pow ( const Base< typename T1::elem_type, T1 > &  A,
const s32  exponent 
) [inline]

Definition at line 603 of file fn_misc.hpp.

References Base< elem_type, derived >::get_ref().

00604   {
00605   arma_extra_debug_sigprint();
00606   
00607   if(exponent >= 0)
00608     {
00609     return Op<T1, op_pow_s32>(A.get_ref(), exponent, 0);
00610     }
00611   else
00612     {
00613     return Op<T1, op_pow_s32>(A.get_ref(), -exponent, 1);
00614     }
00615   }

template<typename T1 >
const OpCube<T1, op_pow_s32> pow ( const BaseCube< typename T1::elem_type, T1 > &  A,
const s32  exponent 
) [inline]

Definition at line 622 of file fn_misc.hpp.

References BaseCube< elem_type, derived >::get_ref().

00623   {
00624   arma_extra_debug_sigprint();
00625   
00626   if(exponent >= 0)
00627     {
00628     return OpCube<T1, op_pow_s32>(A.get_ref(), exponent, 0);
00629     }
00630   else
00631     {
00632     return OpCube<T1, op_pow_s32>(A.get_ref(), -exponent, 1);
00633     }
00634   }

template<typename T , typename T1 >
const Op<T1, op_conj> conj ( const Base< std::complex< T >, T1 > &  A  )  [inline]
template<typename T , typename T1 >
const OpCube<T1, op_conj> conj ( const BaseCube< std::complex< T >, T1 > &  A  )  [inline]

Definition at line 659 of file fn_misc.hpp.

00660   {
00661   arma_extra_debug_sigprint();
00662 
00663   return OpCube<T1, op_conj>(A.get_ref());
00664   }

template<typename T1 >
const T1& conj ( const Op< T1, op_conj > &  A  )  [inline]

Definition at line 671 of file fn_misc.hpp.

References Op< T1, op_type >::m.

00672   {
00673   arma_extra_debug_sigprint();
00674   
00675   return A.m;
00676   }

template<typename T1 >
const T1& conj ( const OpCube< T1, op_conj > &  A  )  [inline]

Definition at line 683 of file fn_misc.hpp.

References OpCube< T1, op_type >::m.

00684   {
00685   arma_extra_debug_sigprint();
00686   
00687   return A.m;
00688   }

template<typename T1 >
const Op<T1, op_htrans> conj ( const Op< T1, op_trans > &  A  )  [inline]

the conjugate of the transpose of a complex matrix is the same as the hermitian transpose

Definition at line 695 of file fn_misc.hpp.

References Op< T1, op_type >::m.

00696   {
00697   arma_extra_debug_sigprint();
00698   
00699   arma_type_check< is_complex<typename T1::elem_type>::value == false >::apply();
00700 
00701   return Op<T1, op_htrans>(A.m);
00702   }