Glue_cube_schur

Classes

class  glue_cube_schur
 Class which implements the immediate Schur product (element-wise multiplication) of two or more cubes. More...

Functions

template<typename T1 , typename T2 >
static void glue_cube_schur::apply (Cube< typename T1::elem_type > &out, const GlueCube< T1, T2, glue_cube_schur > &X)
template<typename T1 >
static void glue_cube_schur::apply_inplace (Cube< typename T1::elem_type > &out, const T1 &X)
template<typename eT1 , typename eT2 >
static void glue_cube_schur::apply_mixed (Cube< typename promote_type< eT1, eT2 >::result > &out, const Cube< eT1 > &X, const Cube< eT2 > &Y)
 cube schur product with different element types
template<typename eT >
static void glue_cube_schur::apply (Cube< eT > &out, const Cube< eT > &A, const Cube< eT > &B)
template<typename eT >
static void glue_cube_schur::apply (Cube< eT > &out, const Cube< eT > &A, const Cube< eT > &B, const Cube< eT > &C)
template<typename eT >
static void glue_cube_schur::apply (Cube< eT > &out, const GlueCube< Cube< eT >, Cube< eT >, glue_cube_schur > &X)
template<typename eT >
static void glue_cube_schur::apply (Cube< eT > &out, const GlueCube< GlueCube< Cube< eT >, Cube< eT >, glue_cube_schur >, Cube< eT >, glue_cube_schur > &X)
template<typename T1 , typename T2 >
static void glue_cube_schur::apply_inplace (Cube< typename T1::elem_type > &out, const GlueCube< T1, T2, glue_cube_schur > &X)

Function Documentation

template<typename T1 , typename T2 >
void glue_cube_schur::apply ( Cube< typename T1::elem_type > &  out,
const GlueCube< T1, T2, glue_cube_schur > &  X 
) [inline, static, inherited]

Definition at line 24 of file glue_cube_schur_meat.hpp.

References GlueCube< T1, T2, glue_type >::A, GlueCube< T1, T2, glue_type >::B, and Cube< 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_cube = 1 + depth_lhs_cube< glue_cube_schur, GlueCube<T1,T2,glue_cube_schur> >::num;
00031   arma_extra_debug_print( arma_boost::format("N_cube = %d") % N_cube );
00032 
00033   if(N_cube == 2)
00034     {
00035     const unwrap_cube<T1> tmp1(X.A);
00036     const unwrap_cube<T2> tmp2(X.B);
00037     
00038     glue_cube_schur::apply(out, tmp1.M, tmp2.M);
00039     }
00040   else
00041     {
00042     const Cube<eT>* ptrs[N_cube];
00043     bool             del[N_cube];
00044 
00045     cube_ptrs<glue_cube_schur, GlueCube<T1,T2,glue_cube_schur> >::get_ptrs(ptrs, del, X);
00046 
00047     for(u32 i=0; i<N_cube; ++i)  arma_extra_debug_print( arma_boost::format("ptrs[%d] = %x") % i % ptrs[i] );
00048     for(u32 i=0; i<N_cube; ++i)  arma_extra_debug_print( arma_boost::format(" del[%d] = %d") % i %  del[i] );
00049 
00050     const Cube<eT>& tmp_cube = *(ptrs[0]);
00051 
00052     for(u32 i=1; i<N_cube; ++i)
00053       {
00054       arma_debug_assert_same_size(tmp_cube, *(ptrs[i]), "cube schur product");
00055       }
00056   
00057     
00058     const u32 n_rows   = ptrs[0]->n_rows;
00059     const u32 n_cols   = ptrs[0]->n_cols;
00060     const u32 n_slices = ptrs[0]->n_slices;
00061 
00062     // no aliasing problem
00063     out.set_size(n_rows, n_cols, n_slices);
00064     
00065     const u32 n_elem = ptrs[0]->n_elem;
00066     
00067     for(u32 j=0; j<n_elem; ++j)
00068       {
00069       eT acc = ptrs[0]->mem[j];
00070       
00071       for(u32 i=1; i<N_cube; ++i)
00072         {
00073         acc *= ptrs[i]->mem[j];
00074         }
00075       
00076       out[j] = acc;
00077       }
00078     
00079     
00080     for(u32 i=0; i<N_cube; ++i)
00081       {
00082       if(del[i] == true)
00083         {
00084         arma_extra_debug_print( arma_boost::format("delete ptrs[%d]") % i );
00085         delete ptrs[i];
00086         }
00087       }
00088 
00089     }
00090   }

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

Definition at line 97 of file glue_cube_schur_meat.hpp.

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

Referenced by Cube< eT >::operator%=().

00098   {
00099   arma_extra_debug_sigprint();
00100   
00101   typedef typename T1::elem_type eT;
00102   
00103   const unwrap_cube<T1> tmp(X);
00104   const Cube<eT>& B   = tmp.M;
00105   
00106   arma_debug_assert_same_size(out, B, "cube schur product");
00107   
00108   const u32 n_elem = out.n_elem;
00109   
00110         eT* out_mem = out.memptr();
00111   const eT* B_mem   = B.mem;
00112   
00113   for(u32 i=0; i<n_elem; ++i)
00114     {
00115     out_mem[i] *= B_mem[i];
00116     }
00117   
00118   }

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

cube schur product with different element types

Definition at line 126 of file glue_cube_schur_meat.hpp.

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

Referenced by operator%().

00127   {
00128   arma_extra_debug_sigprint();
00129   
00130   typedef typename promote_type<eT1,eT2>::result out_eT;
00131   
00132   arma_debug_assert_same_size(X,Y, "cube schur product");  
00133   
00134   //out.set_size(X.n_rows, X.n_cols, X.n_slices);
00135   out.copy_size(X);
00136   
00137         out_eT* out_mem = out.memptr();
00138   const eT1*    X_mem   = X.mem;
00139   const eT2*    Y_mem   = Y.mem;
00140   
00141   const u32 n_elem = out.n_elem;
00142   
00143   for(u32 i=0; i<n_elem; ++i)
00144     {
00145     out_mem[i] = upgrade_val<eT1,eT2>::apply(X_mem[i]) * upgrade_val<eT1,eT2>::apply(Y_mem[i]);
00146     }
00147   }

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

Definition at line 154 of file glue_cube_schur_meat.hpp.

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

00155   {
00156   arma_extra_debug_sigprint();
00157   
00158   arma_debug_assert_same_size(A, B, "cube schur product");
00159     
00160   // no aliasing problem
00161   //out.set_size(A.n_rows, A.n_cols, A.n_slices);
00162   out.copy_size(A);
00163     
00164         eT* out_mem = out.memptr();
00165   const eT* A_mem   = A.mem;
00166   const eT* B_mem   = B.mem;
00167   
00168   const u32 n_elem  = A.n_elem;
00169     
00170   for(u32 i=0; i<n_elem; ++i)
00171     {
00172     out_mem[i] = A_mem[i] * B_mem[i];
00173     }
00174   
00175   }

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

Definition at line 182 of file glue_cube_schur_meat.hpp.

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

00183   {
00184   arma_extra_debug_sigprint();
00185   
00186   arma_debug_assert_same_size(A, B, "cube schur product");
00187   arma_debug_assert_same_size(A, C, "cube schur product");
00188   
00189   // no aliasing problem
00190   //out.set_size(A.n_rows, A.n_cols, A.n_slices);
00191   out.copy_size(A);
00192     
00193         eT* out_mem = out.memptr();
00194   const eT* A_mem   = A.mem;
00195   const eT* B_mem   = B.mem;
00196   const eT* C_mem   = C.mem;
00197   
00198   const u32 n_elem  = A.n_elem;
00199   
00200   for(u32 i=0; i<n_elem; ++i)
00201     {
00202     out_mem[i] = A_mem[i] * B_mem[i] * C_mem[i];
00203     }
00204   
00205   }

template<typename eT >
void glue_cube_schur::apply ( Cube< eT > &  out,
const GlueCube< Cube< eT >, Cube< eT >, glue_cube_schur > &  X 
) [inline, static, inherited]

Definition at line 216 of file glue_cube_schur_meat.hpp.

References apply().

00217   {
00218   glue_cube_schur::apply(out, X.A, X.B);
00219   }

template<typename eT >
void glue_cube_schur::apply ( Cube< eT > &  out,
const GlueCube< GlueCube< Cube< eT >, Cube< eT >, glue_cube_schur >, Cube< eT >, glue_cube_schur > &  X 
) [inline, static, inherited]

Definition at line 226 of file glue_cube_schur_meat.hpp.

References apply().

00227   {
00228   glue_cube_schur::apply(out, X.A.A, X.A.B, X.B);
00229   }

template<typename T1 , typename T2 >
void glue_cube_schur::apply_inplace ( Cube< typename T1::elem_type > &  out,
const GlueCube< T1, T2, glue_cube_schur > &  X 
) [inline, static, inherited]

Definition at line 236 of file glue_cube_schur_meat.hpp.

00237   {
00238   arma_extra_debug_sigprint();
00239   
00240   out = X % out;
00241   }