00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
00022
00023
00024
00025
00026 #ifndef MLN_VALUE_OPS_HH
00027 # define MLN_VALUE_OPS_HH
00028
00032
00033 # include <mln/trait/op/all.hh>
00034 # include <mln/value/builtin/all.hh>
00035 # include <mln/value/concept/all.hh>
00036 # include <mln/value/equiv.hh>
00037 # include <mln/trait/value_.hh>
00038 # include <mln/literal/zero.hh>
00039 # include <mln/literal/one.hh>
00040 # include <mln/literal/ops.hh>
00041 # include <mln/metal/ret.hh>
00042
00043
00045 # define mln_trait_value_sum_product(T, U) \
00046 typename mln::trait::value_< mln_trait_op_times(T,U) >::sum
00047
00048
00050 # define mln_sum_product(T, U) mln_trait_value_sum_product(T, U)
00051
00052
00053
00054
00055
00056
00057 namespace mln
00058 {
00059
00060 namespace trait
00061 {
00062
00063
00064
00065 template < template <class> class Name,
00066 typename V >
00067 struct set_unary_< Name, mln::value::Scalar, V >
00068 {
00069 typedef mln_trait_unary(Name, mln_value_equiv(V)) ret;
00070 };
00071
00072
00073
00074
00075 template < template <class, class> class Name,
00076 typename Vl, typename Vr >
00077 struct set_binary_< Name, mln::value::Scalar, Vl, mln::value::Scalar, Vr >
00078 {
00079 typedef mln_trait_binary(Name, mln_value_equiv(Vl), mln_value_equiv(Vr)) ret;
00080 };
00081
00082
00083
00084 template < template <class, class> class Name,
00085 typename Sl, typename Sr >
00086 struct set_binary_< Name,
00087 mln::value::Scalar, mln::value::scalar_<Sl>,
00088 mln::value::Scalar, mln::value::scalar_<Sr> >
00089 {
00090 typedef mln_trait_binary(Name, mln_value_equiv(Sl), mln_value_equiv(Sr)) ret;
00091 };
00092
00093
00094 template < template <class, class> class Name,
00095 typename S, typename L >
00096 struct set_binary_< Name,
00097 mln::value::Scalar, S,
00098 mln::Literal, L >
00099 {
00100 typedef mln_value_equiv(S) S_;
00101 typedef mln_trait_binary(Name, S_, S_) ret;
00102 };
00103
00104 template < template <class, class> class Name,
00105 typename L, typename S >
00106 struct set_binary_< Name,
00107 mln::Literal, L,
00108 mln::value::Scalar, S >
00109 {
00110 typedef mln_value_equiv(S) S_;
00111 typedef mln_trait_binary(Name, S_, S_) ret;
00112 };
00113
00114
00115
00116
00117 template < typename S, typename O >
00118 struct set_binary_< op::plus,
00119 mln::value::Scalar, mln::value::scalar_<S>,
00120 mln::Object, O >
00121 {
00122 typedef mln_trait_op_plus(O, mln::value::scalar_<S>) ret;
00123 };
00124
00125 template < typename S, typename O >
00126 struct set_binary_< op::times,
00127 mln::value::Scalar, mln::value::scalar_<S>,
00128 mln::Object, O >
00129 {
00130 typedef mln_trait_op_times(O, mln::value::scalar_<S>) ret;
00131 };
00132
00133 }
00134
00135
00136
00137
00138 template <typename Vl, typename Vr>
00139 mln_trait_op_plus(Vl, Vr)
00140 operator + (const value::Scalar<Vl>& lhs, const value::Scalar<Vr>& rhs);
00141
00142 template <typename Vl, typename Vr>
00143 mln_trait_op_minus(Vl, Vr)
00144 operator - (const value::Scalar<Vl>& lhs, const value::Scalar<Vr>& rhs);
00145
00146 template <typename Vl, typename Vr>
00147 mln_trait_op_times(Vl, Vr)
00148 operator * (const value::Scalar<Vl>& lhs, const value::Scalar<Vr>& rhs);
00149
00150 template <typename Vl, typename Vr>
00151 mln_trait_op_div(Vl, Vr)
00152 operator / (const value::Scalar<Vl>& lhs, const value::Scalar<Vr>& rhs);
00153
00154 template <typename Vl, typename Vr>
00155 mln_trait_op_mod(Vl, Vr)
00156 operator % (const value::Scalar<Vl>& lhs, const value::Scalar<Vr>& rhs);
00157
00158
00159
00160
00161
00162
00163 template <typename S, typename O>
00164 mln_trait_op_plus(O, value::scalar_<S>)
00165 operator + (const value::scalar_<S>& lhs, const Object<O>& rhs);
00166
00167 template <typename S, typename O>
00168 mln_trait_op_times(O, value::scalar_<S>)
00169 operator * (const value::scalar_<S>& lhs, const Object<O>& rhs);
00170
00171
00172
00173
00174 template <typename S>
00175 mln_trait_op_uminus(S)
00176 operator - (const value::scalar_<S>& rhs);
00177
00178
00179
00180
00181
00182
00183
00184
00185
00186
00187
00188
00189 template <typename Sl, typename Sr>
00190 mln_trait_op_plus(Sl, Sr)
00191 operator + (const value::scalar_<Sl>& lhs, const value::scalar_<Sr>& rhs);
00192
00193 template <typename Sl, typename Sr>
00194 mln_trait_op_minus(Sl, Sr)
00195 operator - (const value::scalar_<Sl>& lhs, const value::scalar_<Sr>& rhs);
00196
00197 template <typename Sl, typename Sr>
00198 mln_trait_op_times(Sl, Sr)
00199 operator * (const value::scalar_<Sl>& lhs, const value::scalar_<Sr>& rhs);
00200
00201 template <typename Sl, typename Sr>
00202 mln_trait_op_div(Sl, Sr)
00203 operator / (const value::scalar_<Sl>& lhs, const value::scalar_<Sr>& rhs);
00204
00205 template <typename Sl, typename Sr>
00206 mln_trait_op_mod(Sl, Sr)
00207 operator % (const value::scalar_<Sl>& lhs, const value::scalar_<Sr>& rhs);
00208
00209
00210
00211
00212 template <typename Sl, typename Sr>
00213 mln_trait_op_eq(Sl, Sr)
00214 operator == (const value::scalar_<Sl>& lhs, const value::scalar_<Sr>& rhs);
00215
00216 bool
00217 operator == (const value::scalar_<int>& lhs, const value::scalar_<unsigned>& rhs);
00218
00219 bool
00220 operator == (const value::scalar_<unsigned>& lhs, const value::scalar_<int>& rhs);
00221
00222 template <typename O, typename L>
00223 mln_trait_op_eq(O, O)
00224 operator==(const value::scalar_<O>& lhs, const Literal<L>& rhs);
00225
00226 template <typename L, typename O>
00227 mln_trait_op_eq(O, O)
00228 operator==(const Literal<L>& lhs, const value::scalar_<O>& rhs);
00229
00230
00231
00232
00233 template <typename Sl, typename Sr>
00234 mln_trait_op_less(Sl, Sr)
00235 operator < (const value::scalar_<Sl>& lhs, const value::scalar_<Sr>& rhs);
00236
00237 template <typename O, typename L>
00238 mln_trait_op_less(O, O)
00239 operator < (const value::scalar_<O>& lhs, const Literal<L>& rhs);
00240
00241 template <typename L, typename O>
00242 mln_trait_op_less(O, O)
00243 operator < (const Literal<L>& lhs, const value::scalar_<O>& rhs);
00244
00245
00246
00247 # ifndef MLN_INCLUDE_ONLY
00248
00249 template <typename Vl, typename Vr>
00250 inline
00251 mln_trait_op_plus(Vl, Vr)
00252 operator + (const value::Scalar<Vl>& lhs, const value::Scalar<Vr>& rhs)
00253 {
00254 typedef mln_trait_op_plus(Vl, Vr) R;
00255 return static_cast<R>(value::equiv(lhs)) + static_cast<R>(value::equiv(rhs));
00256 }
00257
00258 template <typename Vl, typename Vr>
00259 inline
00260 mln_trait_op_minus(Vl, Vr)
00261 operator - (const value::Scalar<Vl>& lhs, const value::Scalar<Vr>& rhs)
00262 {
00263 typedef mln_trait_op_minus(Vl, Vr) R;
00264 return static_cast<R>(value::equiv(lhs)) - static_cast<R>(value::equiv(rhs));
00265 }
00266
00267 template <typename Vl, typename Vr>
00268 inline
00269 mln_trait_op_times(Vl, Vr)
00270 operator * (const value::Scalar<Vl>& lhs, const value::Scalar<Vr>& rhs)
00271 {
00272 typedef mln_trait_op_times(Vl, Vr) R;
00273 return static_cast<R>(value::equiv(lhs)) * static_cast<R>(value::equiv(rhs));
00274 }
00275
00276 template <typename Vl, typename Vr>
00277 inline
00278 mln_trait_op_div(Vl, Vr)
00279 operator / (const value::Scalar<Vl>& lhs, const value::Scalar<Vr>& rhs)
00280 {
00281 typedef mln_trait_op_div(Vl, Vr) R;
00282 return static_cast<R>(value::equiv(lhs)) / static_cast<R>(value::equiv(rhs));
00283 }
00284
00285 template <typename Vl, typename Vr>
00286 inline
00287 mln_trait_op_mod(Vl, Vr)
00288 operator % (const value::Scalar<Vl>& lhs, const value::Scalar<Vr>& rhs)
00289 {
00290 return value::equiv(lhs) % value::equiv(rhs);
00291 }
00292
00293 template <typename S>
00294 inline
00295 mln_trait_op_uminus(S)
00296 operator - (const value::scalar_<S>& rhs)
00297 {
00298 typedef mln_trait_op_uminus(S) R;
00299 return static_cast<R>(- rhs.to_equiv());
00300 }
00301
00302 template <typename S, typename O>
00303 inline
00304 mln_trait_op_plus(O, value::scalar_<S>)
00305 operator + (const value::scalar_<S>& lhs, const Object<O>& rhs)
00306 {
00307 return exact(rhs) + lhs;
00308 }
00309
00310 template <typename S, typename O>
00311 inline
00312 mln_trait_op_times(O, value::scalar_<S>)
00313 operator * (const value::scalar_<S>& lhs, const Object<O>& rhs)
00314 {
00315 return exact(rhs) * lhs;
00316 }
00317
00318
00319
00320
00321
00322
00323 template <typename Sl, typename Sr>
00324 inline
00325 mln_trait_op_plus(Sl, Sr)
00326 operator + (const value::scalar_<Sl>& lhs, const value::scalar_<Sr>& rhs)
00327 {
00328 return value::equiv(lhs) + value::equiv(rhs);
00329 }
00330
00331 template <typename Sl, typename Sr>
00332 inline
00333 mln_trait_op_minus(Sl, Sr)
00334 operator - (const value::scalar_<Sl>& lhs, const value::scalar_<Sr>& rhs)
00335 {
00336 return value::equiv(lhs) - value::equiv(rhs);
00337 }
00338
00339 template <typename Sl, typename Sr>
00340 inline
00341 mln_trait_op_times(Sl, Sr)
00342 operator * (const value::scalar_<Sl>& lhs, const value::scalar_<Sr>& rhs)
00343 {
00344 return value::equiv(lhs) * value::equiv(rhs);
00345 }
00346
00347 template <typename Sl, typename Sr>
00348 inline
00349 mln_trait_op_div(Sl, Sr)
00350 operator / (const value::scalar_<Sl>& lhs, const value::scalar_<Sr>& rhs)
00351 {
00352 return value::equiv(lhs) / value::equiv(rhs);
00353 }
00354
00355 template <typename Sl, typename Sr>
00356 inline
00357 mln_trait_op_mod(Sl, Sr)
00358 operator % (const value::scalar_<Sl>& lhs, const value::scalar_<Sr>& rhs)
00359 {
00360 return value::equiv(lhs) % value::equiv(rhs);
00361 }
00362
00363
00364
00365
00366 template <typename Sl, typename Sr>
00367 inline
00368 mln_trait_op_eq(Sl, Sr)
00369 operator == (const value::scalar_<Sl>& lhs, const value::scalar_<Sr>& rhs)
00370 {
00371 return value::equiv(lhs) == value::equiv(rhs);
00372 }
00373
00374 inline
00375 bool
00376 operator == (const value::scalar_<int>& lhs, const value::scalar_<unsigned>& rhs)
00377 {
00378 return lhs.to_equiv() == int(rhs.to_equiv());
00379 }
00380
00381 inline
00382 bool
00383 operator == (const value::scalar_<unsigned>& lhs, const value::scalar_<int>& rhs)
00384 {
00385 return int(lhs.to_equiv()) == rhs.to_equiv();
00386 }
00387
00388 template <typename O, typename L>
00389 inline
00390 mln_trait_op_eq(O, O)
00391 operator==(const value::scalar_<O>& lhs, const Literal<L>& rhs)
00392 {
00393 return exact(lhs) == mln_value_equiv(O)(exact(rhs));
00394 }
00395
00396 template <typename L, typename O>
00397 inline
00398 mln_trait_op_eq(O, O)
00399 operator==(const Literal<L>& lhs, const value::scalar_<O>& rhs)
00400 {
00401 return mln_value_equiv(O)(exact(lhs)) == exact(rhs);
00402 }
00403
00404
00405
00406
00407 template <typename Sl, typename Sr>
00408 inline
00409 mln_trait_op_less(Sl, Sr)
00410 operator < (const value::scalar_<Sl>& lhs, const value::scalar_<Sr>& rhs)
00411 {
00412 return value::equiv(lhs) < value::equiv(rhs);
00413 }
00414
00415 template <typename O, typename L>
00416 inline
00417 mln_trait_op_less(O, O)
00418 operator < (const value::scalar_<O>& lhs, const Literal<L>& rhs)
00419 {
00420 return exact(lhs) < mln_value_equiv(O)(exact(rhs));
00421 }
00422
00423 template <typename L, typename O>
00424 inline
00425 mln_trait_op_less(O, O)
00426 operator < (const Literal<L>& lhs, const value::scalar_<O>& rhs)
00427 {
00428 return mln_value_equiv(O)(exact(lhs)) < exact(rhs);
00429 }
00430
00431 # endif // ! MLN_INCLUDE_ONLY
00432
00433 }
00434
00435
00436 #endif // ! MLN_VALUE_OPS_HH