Glue_div

Classes

class  glue_div
 Class which implements the immediate element-wise division of two or more matrices. More...

Functions

template<typename T1 , typename T2 >
static void glue_div::apply (Mat< typename T1::elem_type > &out, const Glue< T1, T2, glue_div > &X)
template<typename T1 >
static void glue_div::apply_inplace (Mat< typename T1::elem_type > &out, const T1 &X)
template<typename eT1 , typename eT2 >
static void glue_div::apply_mixed (Mat< typename promote_type< eT1, eT2 >::result > &out, const Mat< eT1 > &X, const Mat< eT2 > &Y)
 element-wise division with different element types
template<typename eT >
static void glue_div::apply (Mat< eT > &out, const Mat< eT > &A, const Mat< eT > &B)
template<typename eT >
static void glue_div::apply (Mat< eT > &out, const Mat< eT > &A, const Mat< eT > &B, const Mat< eT > &C)
template<typename eT >
static void glue_div::apply (Mat< eT > &out, const Glue< Mat< eT >, Mat< eT >, glue_div > &X)
template<typename eT >
static void glue_div::apply (Mat< eT > &out, const Glue< Glue< Mat< eT >, Mat< eT >, glue_div >, Mat< eT >, glue_div > &X)

Function Documentation

template<typename T1 , typename T2 >
void glue_div::apply ( Mat< typename T1::elem_type > &  out,
const Glue< T1, T2, glue_div > &  X 
) [inline, static, inherited]

Definition at line 24 of file glue_div_meat.hpp.

References Glue< T1, T2, glue_type >::A, apply_inplace(), Glue< T1, T2, glue_type >::B, and Mat< eT >::set_size().

Referenced by apply(), and apply_mixed().

00025   {
00026   arma_extra_debug_sigprint();
00027 
00028   typedef typename T1::elem_type eT;
00029 
00030   const u32 N_mat = 1 + depth_lhs< glue_div, Glue<T1,T2,glue_div> >::num;
00031   arma_extra_debug_print( arma_boost::format("N_mat = %d") % N_mat );
00032 
00033   if(N_mat == 2)
00034     {
00035     if(is_Mat<T1>::value == false)
00036       {
00037       out = X.A;
00038       glue_div::apply_inplace(out, X.B);
00039       }
00040     else
00041       {
00042       const unwrap<T1> tmp1(X.A);
00043       const unwrap<T2> tmp2(X.B);
00044       
00045       glue_div::apply(out, tmp1.M, tmp2.M);
00046       }
00047     }
00048   else
00049     {
00050     const Mat<eT>* ptrs[N_mat];
00051     bool            del[N_mat];
00052 
00053     mat_ptrs<glue_div, Glue<T1,T2,glue_div> >::get_ptrs(ptrs, del, X);
00054     //mat_ptrs_outcheck<glue_div, Glue<T1,T2,glue_div> >::get_ptrs(ptrs, del, X, &out);
00055 
00056     for(u32 i=0; i<N_mat; ++i)  arma_extra_debug_print( arma_boost::format("ptrs[%d] = %x") % i % ptrs[i] );
00057     for(u32 i=0; i<N_mat; ++i)  arma_extra_debug_print( arma_boost::format(" del[%d] = %d") % i %  del[i] );
00058 
00059     const Mat<eT>& tmp_mat = *(ptrs[0]);
00060 
00061     for(u32 i=1; i<N_mat; ++i)
00062       {
00063       arma_debug_assert_same_size(tmp_mat, *(ptrs[i]), "element-wise matrix division");
00064       }
00065   
00066     
00067     const u32 n_rows = ptrs[0]->n_rows;
00068     const u32 n_cols = ptrs[0]->n_cols;
00069 
00070     // no aliasing problem
00071     out.set_size(n_rows,n_cols);
00072     
00073     const u32 n_elem = ptrs[0]->n_elem;
00074     
00075     for(u32 j=0; j<n_elem; ++j)
00076       {
00077       eT acc = ptrs[0]->mem[j];
00078       
00079       for(u32 i=1; i<N_mat; ++i)
00080         {
00081         acc /= ptrs[i]->mem[j];
00082         }
00083       
00084       out[j] = acc;
00085       }
00086     
00087     
00088     for(u32 i=0; i<N_mat; ++i)
00089       {
00090       if(del[i] == true)
00091         {
00092         arma_extra_debug_print( arma_boost::format("delete ptrs[%d]") % i );
00093         delete ptrs[i];
00094         }
00095       }
00096 
00097     }
00098   }

template<typename T1 >
void glue_div::apply_inplace ( Mat< typename T1::elem_type > &  out,
const T1 &  X 
) [inline, static, inherited]

Definition at line 105 of file glue_div_meat.hpp.

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

Referenced by apply(), and Mat< eT >::operator/=().

00106   {
00107   arma_extra_debug_sigprint();
00108   
00109   typedef typename T1::elem_type eT;
00110   
00111   const unwrap<T1>   tmp(X);
00112   const Mat<eT>& B = tmp.M;
00113   
00114   arma_debug_assert_same_size(out, B, "element-wise matrix division");
00115   
00116   const u32 n_elem = out.n_elem;
00117   
00118         eT* out_mem = out.memptr();
00119   const eT* B_mem   = B.mem;
00120   
00121   for(u32 i=0; i<n_elem; ++i)
00122     {
00123     out_mem[i] /= B_mem[i];
00124     }
00125   
00126   }

template<typename eT1 , typename eT2 >
void glue_div::apply_mixed ( Mat< typename promote_type< eT1, eT2 >::result > &  out,
const Mat< eT1 > &  X,
const Mat< eT2 > &  Y 
) [inline, static, inherited]

element-wise division with different element types

Definition at line 134 of file glue_div_meat.hpp.

References apply(), and Mat< eT >::mem.

Referenced by operator/().

00135   {
00136   arma_extra_debug_sigprint();
00137   
00138   typedef typename promote_type<eT1,eT2>::result out_eT;
00139   
00140   arma_debug_assert_same_size(X,Y, "element-wise matrix division");
00141   
00142   //out.set_size(X.n_rows, X.n_cols);
00143   out.copy_size(X);
00144   
00145         out_eT* out_mem = out.memptr();
00146   const eT1*    X_mem   = X.mem;
00147   const eT2*    Y_mem   = Y.mem;
00148   
00149   const u32 n_elem = out.n_elem;
00150   
00151   for(u32 i=0; i<n_elem; ++i)
00152     {
00153     out_mem[i] = upgrade_val<eT1,eT2>::apply(X_mem[i]) / upgrade_val<eT1,eT2>::apply(Y_mem[i]);
00154     }
00155   }

template<typename eT >
void glue_div::apply ( Mat< eT > &  out,
const Mat< eT > &  A,
const Mat< eT > &  B 
) [inline, static, inherited]

Definition at line 162 of file glue_div_meat.hpp.

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

00163   {
00164   arma_extra_debug_sigprint();
00165   
00166   arma_debug_assert_same_size(A, B, "element-wise matrix division");
00167     
00168   // no aliasing problem
00169   //out.set_size(A.n_rows, A.n_cols);
00170   out.copy_size(A);
00171     
00172   const u32 n_elem = A.n_elem;
00173 
00174         eT* out_mem = out.memptr();
00175   const eT* A_mem   = A.mem;
00176   const eT* B_mem   = B.mem;
00177     
00178   for(u32 i=0; i<n_elem; ++i)
00179     {
00180     out_mem[i] = A_mem[i] / B_mem[i];
00181     }
00182   
00183   }

template<typename eT >
void glue_div::apply ( Mat< eT > &  out,
const Mat< eT > &  A,
const Mat< eT > &  B,
const Mat< eT > &  C 
) [inline, static, inherited]

Definition at line 190 of file glue_div_meat.hpp.

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

00191   {
00192   arma_extra_debug_sigprint();
00193   
00194   arma_debug_assert_same_size(A, B, "element-wise matrix division");
00195   arma_debug_assert_same_size(B, C, "element-wise matrix division");
00196   
00197   // no aliasing problem
00198   //out.set_size(A.n_rows, A.n_cols);
00199   out.copy_size(A);
00200   
00201   const u32 n_elem = A.n_elem;
00202   
00203         eT* out_mem = out.memptr();
00204   const eT* A_mem   = A.mem;
00205   const eT* B_mem   = B.mem;
00206   const eT* C_mem   = C.mem;
00207   
00208   for(u32 i=0; i<n_elem; ++i)
00209     {
00210     out_mem[i] = A_mem[i] / B_mem[i] / C_mem[i];
00211     }
00212   
00213   }

template<typename eT >
void glue_div::apply ( Mat< eT > &  out,
const Glue< Mat< eT >, Mat< eT >, glue_div > &  X 
) [inline, static, inherited]

Definition at line 222 of file glue_div_meat.hpp.

References apply().

00223   {
00224   glue_div::apply(out, X.A, X.B);
00225   }

template<typename eT >
void glue_div::apply ( Mat< eT > &  out,
const Glue< Glue< Mat< eT >, Mat< eT >, glue_div >, Mat< eT >, glue_div > &  X 
) [inline, static, inherited]

Definition at line 232 of file glue_div_meat.hpp.

References apply().

00233   {
00234   glue_div::apply(out, X.A.A, X.A.B, X.B);
00235   }