operator_minus.hpp
Go to the documentation of this file.00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
00022
00023 template<typename T1>
00024 arma_inline
00025 const eOp<T1, eop_neg>
00026 operator-
00027 (const Base<typename T1::elem_type,T1>& X)
00028 {
00029 arma_extra_debug_sigprint();
00030
00031 return eOp<T1,eop_neg>(X.get_ref());
00032 }
00033
00034
00035
00036
00037 template<typename T1>
00038 arma_inline
00039 const T1&
00040 operator-
00041 (const eOp<T1, eop_neg>& X)
00042 {
00043 arma_extra_debug_sigprint();
00044
00045 return X.m;
00046 }
00047
00048
00049
00050
00051 template<typename T1>
00052 arma_inline
00053 const eOp<T1, eop_scalar_minus_post>
00054 operator-
00055 (
00056 const Base<typename T1::elem_type,T1>& X,
00057 const typename T1::elem_type k
00058 )
00059 {
00060 arma_extra_debug_sigprint();
00061
00062 return eOp<T1, eop_scalar_minus_post>(X.get_ref(), k);
00063 }
00064
00065
00066
00067
00068 template<typename T1>
00069 arma_inline
00070 const eOp<T1, eop_scalar_minus_pre>
00071 operator-
00072 (
00073 const typename T1::elem_type k,
00074 const Base<typename T1::elem_type,T1>& X
00075 )
00076 {
00077 arma_extra_debug_sigprint();
00078
00079 return eOp<T1, eop_scalar_minus_pre>(X.get_ref(), k);
00080 }
00081
00082
00083
00084
00085 template<typename T1>
00086 arma_inline
00087 Mat<typename std::complex<typename T1::pod_type> >
00088 operator-
00089 (
00090 const Base<typename T1::pod_type, T1>& X,
00091 const std::complex<typename T1::pod_type>& k
00092 )
00093 {
00094 arma_extra_debug_sigprint();
00095
00096 typedef typename std::complex<typename T1::pod_type> eT;
00097 typedef typename T1::pod_type T;
00098
00099 const Proxy<T1> A(X.get_ref());
00100
00101 Mat<eT> out(A.n_rows, A.n_cols);
00102
00103 const u32 n_elem = A.n_elem;
00104 eT* out_mem = out.memptr();
00105
00106 for(u32 i=0; i<n_elem; ++i)
00107 {
00108 out_mem[i] = A[i] - k;
00109 }
00110
00111 return out;
00112 }
00113
00114
00115
00116
00117 template<typename T1>
00118 arma_inline
00119 Mat<typename std::complex<typename T1::pod_type> >
00120 operator-
00121 (
00122 const std::complex<typename T1::pod_type>& k,
00123 const Base<typename T1::pod_type, T1>& X
00124 )
00125 {
00126 arma_extra_debug_sigprint();
00127
00128 typedef typename std::complex<typename T1::pod_type> eT;
00129 typedef typename T1::pod_type T;
00130
00131 const Proxy<T1> A(X.get_ref());
00132
00133 Mat<eT> out(A.n_rows, A.n_cols);
00134
00135 const u32 n_elem = A.n_elem;
00136 eT* out_mem = out.memptr();
00137
00138 for(u32 i=0; i<n_elem; ++i)
00139 {
00140 out_mem[i] = k - A[i];
00141 }
00142
00143 return out;
00144 }
00145
00146
00147
00148
00149 template<typename T1, typename T2>
00150 arma_inline
00151 const eGlue<T1, T2, eglue_minus>
00152 operator-
00153 (
00154 const Base<typename T1::elem_type,T1>& X,
00155 const Base<typename T1::elem_type,T2>& Y
00156 )
00157 {
00158 arma_extra_debug_sigprint();
00159
00160 return eGlue<T1, T2, eglue_minus>(X.get_ref(), Y.get_ref());
00161 }
00162
00163
00164
00165
00166 template<typename T1, typename T2>
00167 arma_inline
00168 Mat<typename promote_type<typename T1::elem_type, typename T2::elem_type>::result>
00169 operator-
00170 (
00171 const Base< typename force_different_type<typename T1::elem_type, typename T2::elem_type>::T1_result, T1>& X,
00172 const Base< typename force_different_type<typename T1::elem_type, typename T2::elem_type>::T2_result, T2>& Y
00173 )
00174 {
00175 arma_extra_debug_sigprint();
00176
00177 typedef typename T1::elem_type eT1;
00178 typedef typename T2::elem_type eT2;
00179
00180 typedef typename promote_type<eT1,eT2>::result out_eT;
00181
00182 promote_type<eT1,eT2>::check();
00183
00184 const Proxy<T1> A(X.get_ref());
00185 const Proxy<T2> B(Y.get_ref());
00186
00187 arma_debug_assert_same_size(A, B, "matrix subtraction");
00188
00189 Mat<out_eT> out(A.n_rows, A.n_cols);
00190
00191 out_eT* out_mem = out.memptr();
00192 const u32 n_elem = out.n_elem;
00193
00194 for(u32 i=0; i<n_elem; ++i)
00195 {
00196 out_mem[i] = upgrade_val<eT1,eT2>::apply(A[i]) - upgrade_val<eT1,eT2>::apply(B[i]);
00197 }
00198
00199 return out;
00200 }
00201
00202
00203
00204