Glue_cube_minus

Classes

class  glue_cube_minus
 Class which implements the immediate subtraction of cubes. More...

Functions

template<typename T1 , typename T2 >
static void glue_cube_minus::apply (Cube< typename T1::elem_type > &out, const GlueCube< T1, T2, glue_cube_minus > &X)
 Immediate out = A-B-...-Z (operands obtained from Glue).
template<typename T1 >
static void glue_cube_minus::apply_inplace (Cube< typename T1::elem_type > &out, const T1 &X)
 Immediate out -= B.
template<typename eT1 , typename eT2 >
static void glue_cube_minus::apply_mixed (Cube< typename promote_type< eT1, eT2 >::result > &out, const Cube< eT1 > &X, const Cube< eT2 > &Y)
 cube subtraction with different element types
template<typename eT >
static void glue_cube_minus::apply (Cube< eT > &out, const Cube< eT > &A, const Cube< eT > &B)
 Immediate out = A-B.
template<typename eT >
static void glue_cube_minus::apply (Cube< eT > &out, const Cube< eT > &A, const Cube< eT > &B, const Cube< eT > &C)
 Immediate out = A-B-C.
template<typename eT >
static void glue_cube_minus::apply (Cube< eT > &out, const GlueCube< Cube< eT >, Cube< eT >, glue_cube_minus > &X)
 Immediate out = A-B (operands obtained from Glue).
template<typename eT >
static void glue_cube_minus::apply (Cube< eT > &out, const GlueCube< GlueCube< Cube< eT >, Cube< eT >, glue_cube_minus >, Cube< eT >, glue_cube_minus > &X)
 Immediate out = A-B-C (operands obtained from Glue).
template<typename T1 , typename T2 >
static void glue_cube_minus::apply_inplace (Cube< typename T1::elem_type > &out, const GlueCube< T1, T2, glue_cube_minus > &X)

Function Documentation

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

Immediate out = A-B-...-Z (operands obtained from Glue).

Definition at line 25 of file glue_cube_minus_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().

00026   {
00027   arma_extra_debug_sigprint();
00028   
00029   typedef typename T1::elem_type eT;
00030   
00031   const u32 N_cube = 1 + depth_lhs_cube< glue_cube_minus, GlueCube<T1,T2,glue_cube_minus> >::num;
00032   arma_extra_debug_print( arma_boost::format("N_cube = %d") % N_cube );
00033 
00034 
00035   if(N_cube == 2)
00036     {
00037     const unwrap_cube<T1> tmp1(X.A);
00038     const unwrap_cube<T2> tmp2(X.B);
00039     
00040     glue_cube_minus::apply(out, tmp1.M, tmp2.M);
00041     }
00042   else
00043     {
00044     const Cube<eT>* ptrs[N_cube];
00045     bool             del[N_cube];
00046 
00047     cube_ptrs<glue_cube_minus, GlueCube<T1,T2,glue_cube_minus> >::get_ptrs(ptrs, del, X);
00048 
00049     for(u32 i=0; i<N_cube; ++i)  arma_extra_debug_print( arma_boost::format("ptrs[%d] = %x")  % i % ptrs[i] );
00050     for(u32 i=0; i<N_cube; ++i)  arma_extra_debug_print( arma_boost::format(" del[%d] = %d")  % i %  del[i] );
00051 
00052     const Cube<eT>& tmp_cube = *(ptrs[0]);
00053     
00054     for(u32 i=1; i<N_cube; ++i)
00055       {
00056       arma_debug_assert_same_size(tmp_cube, *(ptrs[i]), "cube subtraction");
00057       }
00058   
00059     const u32 n_rows   = ptrs[0]->n_rows;
00060     const u32 n_cols   = ptrs[0]->n_cols;
00061     const u32 n_slices = ptrs[0]->n_slices;
00062     
00063     // no aliasing problem
00064     out.set_size(n_rows, n_cols, n_slices);
00065     
00066     const u32 n_elem = ptrs[0]->n_elem;
00067     
00068     for(u32 j=0; j<n_elem; ++j)
00069       {
00070       eT acc = ptrs[0]->mem[j];
00071       
00072       for(u32 i=1; i<N_cube; ++i)
00073         {
00074         acc -= ptrs[i]->mem[j];
00075         }
00076       
00077       out[j] = acc;
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_minus::apply_inplace ( Cube< typename T1::elem_type > &  out,
const T1 &  X 
) [inline, static, inherited]

Immediate out -= B.

Definition at line 98 of file glue_cube_minus_meat.hpp.

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

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

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

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

cube subtraction with different element types

Definition at line 127 of file glue_cube_minus_meat.hpp.

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

Referenced by operator-().

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

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

Immediate out = A-B.

Definition at line 156 of file glue_cube_minus_meat.hpp.

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

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

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

Immediate out = A-B-C.

Definition at line 185 of file glue_cube_minus_meat.hpp.

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

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

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

Immediate out = A-B (operands obtained from Glue).

Definition at line 220 of file glue_cube_minus_meat.hpp.

References apply().

00221   {
00222   glue_cube_minus::apply(out, X.A, X.B);
00223   }

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

Immediate out = A-B-C (operands obtained from Glue).

Definition at line 231 of file glue_cube_minus_meat.hpp.

References apply().

00232   {
00233   glue_cube_minus::apply(out, X.A.A, X.A.B, X.B);
00234   }

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

Definition at line 241 of file glue_cube_minus_meat.hpp.

00242   {
00243   arma_extra_debug_sigprint();
00244   
00245   out = out - X;
00246   }