operator_cube_minus.hpp

Go to the documentation of this file.
00001 // Copyright (C) 2009 NICTA
00002 // 
00003 // Authors:
00004 // - Conrad Sanderson (conradsand at ieee dot org)
00005 // 
00006 // This file is part of the Armadillo C++ library.
00007 // It is provided without any warranty of fitness
00008 // for any purpose. You can redistribute this file
00009 // and/or modify it under the terms of the GNU
00010 // Lesser General Public License (LGPL) as published
00011 // by the Free Software Foundation, either version 3
00012 // of the License or (at your option) any later version.
00013 // (see http://www.opensource.org/licenses for more info)
00014 
00015 
00016 //! \addtogroup operator_cube_minus
00017 //! @{
00018 
00019 
00020 
00021 //! unary -
00022 template<typename T1>
00023 arma_inline
00024 const OpCube<T1, op_neg>
00025 operator-
00026 (const BaseCube<typename T1::elem_type,T1>& X)
00027   {
00028   arma_extra_debug_sigprint();
00029   
00030   return OpCube<T1,op_neg>(X.get_ref());
00031   }
00032 
00033 
00034 
00035 //! cancellation of two consecutive negations: -(-T1)
00036 template<typename T1>
00037 arma_inline
00038 const T1&
00039 operator-
00040 (const OpCube<T1, op_neg>& X)
00041   {
00042   arma_extra_debug_sigprint();
00043   
00044   return X.m;
00045   }
00046 
00047 
00048 
00049 //! Base - scalar
00050 template<typename T1>
00051 arma_inline
00052 const OpCube<T1, op_scalar_minus_post>
00053 operator-
00054 (const BaseCube<typename T1::elem_type,T1>& X, const typename T1::elem_type k)
00055   {
00056   arma_extra_debug_sigprint();
00057   
00058   return OpCube<T1, op_scalar_minus_post>(X.get_ref(), k);
00059   }
00060 
00061 
00062 
00063 //! scalar - Base
00064 template<typename T1>
00065 arma_inline
00066 const OpCube<T1, op_scalar_minus_pre>
00067 operator-
00068 (const typename T1::elem_type k, const BaseCube<typename T1::elem_type,T1>& X)
00069   {
00070   arma_extra_debug_sigprint();
00071   
00072   return OpCube<T1, op_scalar_minus_pre>(X.get_ref(), k);
00073   }
00074 
00075 
00076 
00077 //! Base - - Base = Base + Base
00078 template<typename T1, typename T2>
00079 arma_inline
00080 const GlueCube<T1, T2, glue_cube_plus>
00081 operator-
00082   (
00083   const BaseCube<typename T1::elem_type, T1                >& X,
00084   const BaseCube<typename T1::elem_type, OpCube<T2,op_neg> >& Y
00085   )
00086   {
00087   arma_extra_debug_sigprint();
00088   
00089   const T1& A = X.get_ref();
00090   const T2& B = (Y.get_ref()).m;
00091   
00092   return GlueCube<T1, T2, glue_cube_plus>(A,B);
00093   }
00094 
00095 
00096 
00097 //! Base - OpCube<T2,op_neg> = Base + T2
00098 template<typename T1, typename T2>
00099 arma_inline
00100 const GlueCube<T1, T2, glue_cube_plus>
00101 operator-
00102 (const BaseCube<typename T2::elem_type,T1>& X, const OpCube<T2, op_neg>& Y)
00103   {
00104   arma_extra_debug_sigprint();
00105   
00106   return GlueCube<T1, T2, glue_cube_plus>(X.get_ref(), Y.m);
00107   }
00108 
00109 
00110 
00111 //
00112 // subtraction of Base objects with different element types
00113 //
00114 
00115 
00116 
00117 //! Base - Base
00118 template<typename eT1, typename T1, typename eT2, typename T2>
00119 arma_inline
00120 Cube<typename promote_type<eT1,eT2>::result>
00121 operator-
00122 (const BaseCube<eT1,T1>& X, const BaseCube<eT2,T2>& Y)
00123   {
00124   arma_extra_debug_sigprint();
00125   
00126   promote_type<eT1,eT2>::check();
00127   
00128   const unwrap_cube<T1> tmp1(X.get_ref());
00129   const unwrap_cube<T2> tmp2(Y.get_ref());
00130   
00131   const Cube<eT1>& A = tmp1.M;
00132   const Cube<eT2>& B = tmp2.M;
00133   
00134   Cube< typename promote_type<eT1,eT2>::result > out;
00135   glue_cube_minus::apply_mixed(out, A, B);
00136   
00137   return out;
00138   }
00139 
00140 
00141 
00142 //
00143 // subtraction of Base objects with same element types
00144 //
00145 
00146 
00147 
00148 template<typename T1, typename T2>
00149 arma_inline
00150 const GlueCube<T1, T2, glue_cube_minus>
00151 operator-
00152 (const BaseCube<std::complex<double>,T1>& X, const BaseCube<std::complex<double>,T2>& Y)
00153   {
00154   arma_extra_debug_sigprint();
00155   
00156   return GlueCube<T1, T2, glue_cube_minus>(X.get_ref(), Y.get_ref());
00157   }
00158 
00159 
00160 
00161 template<typename T1, typename T2>
00162 arma_inline
00163 const GlueCube<T1, T2, glue_cube_minus>
00164 operator-
00165 (const BaseCube<std::complex<float>,T1>& X, const BaseCube<std::complex<float>,T2>& Y)
00166   {
00167   arma_extra_debug_sigprint();
00168   
00169   return GlueCube<T1, T2, glue_cube_minus>(X.get_ref(), Y.get_ref());
00170   }
00171 
00172 
00173 
00174 template<typename T1, typename T2>
00175 arma_inline
00176 const GlueCube<T1, T2, glue_cube_minus>
00177 operator-
00178 (const BaseCube<double,T1>& X, const BaseCube<double,T2>& Y)
00179   {
00180   arma_extra_debug_sigprint();
00181   
00182   return GlueCube<T1, T2, glue_cube_minus>(X.get_ref(), Y.get_ref());
00183   }
00184 
00185 
00186 
00187 template<typename T1, typename T2>
00188 arma_inline
00189 const GlueCube<T1, T2, glue_cube_minus>
00190 operator-
00191 (const BaseCube<float,T1>& X, const BaseCube<float,T2>& Y)
00192   {
00193   arma_extra_debug_sigprint();
00194   
00195   return GlueCube<T1, T2, glue_cube_minus>(X.get_ref(), Y.get_ref());
00196   }
00197 
00198 
00199 
00200 template<typename T1, typename T2>
00201 arma_inline
00202 const GlueCube<T1, T2, glue_cube_minus>
00203 operator-
00204 (const BaseCube<s32,T1>& X, const BaseCube<s32,T2>& Y)
00205   {
00206   arma_extra_debug_sigprint();
00207   
00208   return GlueCube<T1, T2, glue_cube_minus>(X.get_ref(), Y.get_ref());
00209   }
00210 
00211 
00212 
00213 template<typename T1, typename T2>
00214 arma_inline
00215 const GlueCube<T1, T2, glue_cube_minus>
00216 operator-
00217 (const BaseCube<u32,T1>& X, const BaseCube<u32,T2>& Y)
00218   {
00219   arma_extra_debug_sigprint();
00220   
00221   return GlueCube<T1, T2, glue_cube_minus>(X.get_ref(), Y.get_ref());
00222   }
00223 
00224 
00225 
00226 template<typename T1, typename T2>
00227 arma_inline
00228 const GlueCube<T1, T2, glue_cube_minus>
00229 operator-
00230 (const BaseCube<s16,T1>& X, const BaseCube<s16,T2>& Y)
00231   {
00232   arma_extra_debug_sigprint();
00233   
00234   return GlueCube<T1, T2, glue_cube_minus>(X.get_ref(), Y.get_ref());
00235   }
00236 
00237 
00238 
00239 template<typename T1, typename T2>
00240 arma_inline
00241 const GlueCube<T1, T2, glue_cube_minus>
00242 operator-
00243 (const BaseCube<u16,T1>& X, const BaseCube<u16,T2>& Y)
00244   {
00245   arma_extra_debug_sigprint();
00246   
00247   return GlueCube<T1, T2, glue_cube_minus>(X.get_ref(), Y.get_ref());
00248   }
00249 
00250 
00251 
00252 template<typename T1, typename T2>
00253 arma_inline
00254 const GlueCube<T1, T2, glue_cube_minus>
00255 operator-
00256 (const BaseCube<s8,T1>& X, const BaseCube<s8,T2>& Y)
00257   {
00258   arma_extra_debug_sigprint();
00259   
00260   return GlueCube<T1, T2, glue_cube_minus>(X.get_ref(), Y.get_ref());
00261   }
00262 
00263 
00264 
00265 template<typename T1, typename T2>
00266 arma_inline
00267 const GlueCube<T1, T2, glue_cube_minus>
00268 operator-
00269 (const BaseCube<u8,T1>& X, const BaseCube<u8,T2>& Y)
00270   {
00271   arma_extra_debug_sigprint();
00272   
00273   return GlueCube<T1, T2, glue_cube_minus>(X.get_ref(), Y.get_ref());
00274   }
00275 
00276 
00277 
00278 //! @}