36 #ifndef VIGRA_FUNCTOREXPRESSION_HXX 37 #define VIGRA_FUNCTOREXPRESSION_HXX 328 #if !defined(NO_PARTIAL_TEMPLATE_SPECIALIZATION) 331 #include "numerictraits.hxx" 332 #include "mathutil.hxx" 333 #include "functortraits.hxx" 349 template <
class Operation>
350 struct ResultTraits0;
352 template <
class Operation,
class T1>
358 template <
class Operation,
class T1,
class T2>
361 typedef typename PromoteTraits<T1, T2>::Promote Res;
364 template <
class Operation,
class T1,
class T2,
class T3>
367 typedef typename PromoteTraits<T1, T2>::Promote P1;
368 typedef typename PromoteTraits<P1, T3>::Promote Res;
371 template <
class EXPR>
374 UnaryFunctor(EXPR
const & e)
379 typename ResultTraits0<EXPR>::Res
386 typename ResultTraits1<EXPR, T1>::Res
387 operator()(T1
const & v)
const 392 template <
class T1,
class T2>
393 typename ResultTraits2<EXPR, T1, T2>::Res
394 operator()(T1
const & v1, T2
const & v2)
const 396 return expr_(v1, v2);
399 template <
class T1,
class T2,
class T3>
400 typename ResultTraits3<EXPR, T1, T2, T3>::Res
401 operator()(T1
const & v1, T2
const & v2, T3
const & v3)
const 403 return expr_(v1, v2, v3);
410 UnaryFunctor & operator=(UnaryFunctor
const &);
413 template <
class Expr>
414 struct ResultTraits0<UnaryFunctor<Expr> >
416 typedef typename ResultTraits0<Expr>::Res Res;
419 template <
class Expr,
class T1>
420 struct ResultTraits1<UnaryFunctor<Expr>, T1>
422 typedef typename ResultTraits1<Expr, T1>::Res Res;
425 template <
class Expr,
class T1,
class T2>
426 struct ResultTraits2<UnaryFunctor<Expr>, T1, T2>
428 typedef typename ResultTraits2<Expr, T1, T2>::Res Res;
431 template <
class Expr,
class T1,
class T2,
class T3>
432 struct ResultTraits3<UnaryFunctor<Expr>, T1, T2, T3>
434 typedef typename ResultTraits3<Expr, T1, T2, T3>::Res Res;
443 struct ArgumentFunctor1;
444 struct ArgumentFunctor2;
445 struct ArgumentFunctor3;
448 struct UnaryFunctor<ArgumentFunctor1>
454 T1
const & operator()(T1
const & v1)
const 459 template <
class T1,
class T2>
460 T1
const & operator()(T1
const & v1, T2
const &)
const 465 template <
class T1,
class T2,
class T3>
466 T1
const & operator()(T1
const & v1, T2
const &, T3
const &)
const 472 UnaryFunctor & operator=(UnaryFunctor
const &);
475 typedef UnaryFunctor<ArgumentFunctor1> Identity;
478 struct ResultTraits0<UnaryFunctor<ArgumentFunctor1> >
480 typedef ErrorType Res;
484 struct ResultTraits1<UnaryFunctor<ArgumentFunctor1>, T1>
489 template <
class T1,
class T2>
490 struct ResultTraits2<UnaryFunctor<ArgumentFunctor1>, T1, T2>
495 template <
class T1,
class T2,
class T3>
496 struct ResultTraits3<UnaryFunctor<ArgumentFunctor1>, T1, T2, T3>
504 UnaryFunctor<ArgumentFunctor1>
507 return UnaryFunctor<ArgumentFunctor1>();
513 struct UnaryFunctor<ArgumentFunctor2>
518 template <
class T1,
class T2>
519 T2
const & operator()(T1
const &, T2
const & v2)
const 524 template <
class T1,
class T2,
class T3>
525 T2
const & operator()(T1
const &, T2
const & v2, T3
const &)
const 531 UnaryFunctor & operator=(UnaryFunctor
const &);
535 struct ResultTraits0<UnaryFunctor<ArgumentFunctor2> >
537 typedef ErrorType Res;
541 struct ResultTraits1<UnaryFunctor<ArgumentFunctor2>, T1>
543 typedef ErrorType Res;
546 template <
class T1,
class T2>
547 struct ResultTraits2<UnaryFunctor<ArgumentFunctor2>, T1, T2>
552 template <
class T1,
class T2,
class T3>
553 struct ResultTraits3<UnaryFunctor<ArgumentFunctor2>, T1, T2, T3>
561 UnaryFunctor<ArgumentFunctor2>
564 return UnaryFunctor<ArgumentFunctor2>();
570 struct UnaryFunctor<ArgumentFunctor3>
575 template <
class T1,
class T2,
class T3>
576 T3
const & operator()(T1
const &, T2
const &, T3
const & v3)
const 582 UnaryFunctor & operator=(UnaryFunctor
const &);
586 struct ResultTraits0<UnaryFunctor<ArgumentFunctor3> >
588 typedef ErrorType Res;
592 struct ResultTraits1<UnaryFunctor<ArgumentFunctor3>, T1>
594 typedef ErrorType Res;
597 template <
class T1,
class T2>
598 struct ResultTraits2<UnaryFunctor<ArgumentFunctor3>, T1, T2>
600 typedef ErrorType Res;
603 template <
class T1,
class T2,
class T3>
604 struct ResultTraits3<UnaryFunctor<ArgumentFunctor3>, T1, T2, T3>
612 UnaryFunctor<ArgumentFunctor3>
615 return UnaryFunctor<ArgumentFunctor3>();
625 struct ParameterFunctor
627 ParameterFunctor(T v)
631 T
const & operator()()
const 637 T
const & operator()(U1
const &)
const 642 template <
class U1,
class U2>
643 T
const & operator()(U1
const &, U2
const &)
const 648 template <
class U1,
class U2,
class U3>
649 T
const & operator()(U1
const &, U2
const &, U3
const &)
const 658 ParameterFunctor & operator=(ParameterFunctor
const &);
662 struct ResultTraits0<ParameterFunctor<T> >
667 template <
class T,
class T1>
668 struct ResultTraits1<ParameterFunctor<T>, T1>
673 template <
class T,
class T1,
class T2>
674 struct ResultTraits2<ParameterFunctor<T>, T1, T2>
679 template <
class T,
class T1,
class T2,
class T3>
680 struct ResultTraits3<ParameterFunctor<T>, T1, T2, T3>
686 inline UnaryFunctor<ParameterFunctor<T> >
689 ParameterFunctor<T> fv(v);
690 return UnaryFunctor<ParameterFunctor<T> >(fv);
700 template <
class EXPR>
704 UnaryAnalyser(EXPR
const & e)
708 void operator()()
const 714 void operator()(T1
const & v)
const 719 template <
class T1,
class T2>
720 void operator()(T1
const & v1, T2
const & v2)
const 725 template <
class T1,
class T2,
class T3>
726 void operator()(T1
const & v1, T2
const & v2, T3
const & v3)
const 735 UnaryAnalyser & operator=(UnaryAnalyser
const &);
748 struct UnaryFunctor<VarFunctor<T> >;
752 #define MAKE_ASSIGNMENT_FUNCTOR(name, op) \ 753 template <class V, class EXPR> \ 754 struct AssignmentFunctor_##name \ 756 AssignmentFunctor_##name(UnaryFunctor<VarFunctor<V> > v, \ 757 UnaryFunctor<EXPR> const & e) \ 758 : value_(v.value_), expr_(e) \ 761 V & operator()() const \ 763 const_cast<V &>(value_) op expr_(); \ 764 return const_cast<V &>(value_); \ 767 template <class T1> \ 768 V & operator()(T1 const & v1) const \ 770 const_cast<V &>(value_) op expr_(v1); \ 771 return const_cast<V &>(value_); \ 774 template <class T1, class T2> \ 775 V & operator()(T1 const & v1, T2 const & v2) const \ 777 const_cast<V &>(value_) op expr_(v1, v2); \ 778 return const_cast<V &>(value_); \ 781 template <class T1, class T2, class T3> \ 782 V & operator()(T1 const & v1, T2 const & v2, T3 const & v3) const \ 784 const_cast<V &>(value_) op expr_(v1, v2, v3); \ 785 return const_cast<V &>(value_); \ 790 UnaryFunctor<EXPR> expr_; \ 792 AssignmentFunctor_##name & operator=(AssignmentFunctor_##name const &);\ 797 MAKE_ASSIGNMENT_FUNCTOR(assign, =)
798 MAKE_ASSIGNMENT_FUNCTOR(
add, +=)
799 MAKE_ASSIGNMENT_FUNCTOR(subtract, -=)
800 MAKE_ASSIGNMENT_FUNCTOR(multiply, *=)
801 MAKE_ASSIGNMENT_FUNCTOR(divide, /=)
803 #undef MAKE_ASSIGNMENT_FUNCTOR 812 struct UnaryFunctor<VarFunctor<T> >
820 template <
class EXPR>
821 UnaryAnalyser< AssignmentFunctor_assign<T, UnaryFunctor<EXPR> > >
822 operator=(UnaryFunctor<EXPR>
const & e)
824 AssignmentFunctor_assign<T, UnaryFunctor<EXPR> > va(*
this, e);
825 return UnaryAnalyser< AssignmentFunctor_assign<T, UnaryFunctor<EXPR> > >(va);
828 template <
class EXPR>
829 UnaryAnalyser< AssignmentFunctor_add<T, UnaryFunctor<EXPR> > >
832 AssignmentFunctor_add<T, UnaryFunctor<EXPR> > va(*
this, e);
833 return UnaryAnalyser< AssignmentFunctor_add<T, UnaryFunctor<EXPR> > >(va);
836 template <
class EXPR>
837 UnaryAnalyser< AssignmentFunctor_subtract<T, UnaryFunctor<EXPR> > >
840 AssignmentFunctor_subtract<T, UnaryFunctor<EXPR> > va(*
this, e);
841 return UnaryAnalyser< AssignmentFunctor_subtract<T, UnaryFunctor<EXPR> > >(va);
844 template <
class EXPR>
845 UnaryAnalyser< AssignmentFunctor_multiply<T, UnaryFunctor<EXPR> > >
848 AssignmentFunctor_multiply<T, UnaryFunctor<EXPR> > va(*
this, e);
849 return UnaryAnalyser< AssignmentFunctor_multiply<T, UnaryFunctor<EXPR> > >(va);
852 template <
class EXPR>
853 UnaryAnalyser< AssignmentFunctor_divide<T, UnaryFunctor<EXPR> > >
856 AssignmentFunctor_divide<T, UnaryFunctor<EXPR> > va(*
this, e);
857 return UnaryAnalyser< AssignmentFunctor_divide<T, UnaryFunctor<EXPR> > >(va);
860 T
const & operator()()
const 866 T
const & operator()(U1
const &)
const 871 template <
class U1,
class U2>
872 T
const & operator()(U1
const &, U2
const &)
const 877 template <
class U1,
class U2,
class U3>
878 T
const & operator()(U1
const &, U2
const &, U3
const &)
const 886 UnaryFunctor & operator=(UnaryFunctor
const &);
890 struct ResultTraits0<UnaryFunctor<VarFunctor<T> > >
895 template <
class T,
class T1>
896 struct ResultTraits1<UnaryFunctor<VarFunctor<T> >, T1>
901 template <
class T,
class T1,
class T2>
902 struct ResultTraits2<UnaryFunctor<VarFunctor<T> >, T1, T2>
907 template <
class T,
class T1,
class T2,
class T3>
908 struct ResultTraits3<UnaryFunctor<VarFunctor<T> >, T1, T2, T3>
914 inline UnaryFunctor<VarFunctor<T> >
917 return UnaryFunctor<VarFunctor<T> >(v);
926 template <
class EXPR1,
class EXPR2>
931 IfThenFunctor(EXPR1
const & e1, EXPR2
const & e2)
932 : expr1_(e1), expr2_(e2)
935 void operator()()
const 937 if( expr1_() ) expr2_();
941 void operator()(T
const & v1)
const 943 if( expr1_(v1) ) expr2_(v1);
946 template <
class T1,
class T2>
947 void operator()(T1
const & v1, T2
const & v2)
const 949 if( expr1_(v1, v2) ) expr2_(v1, v2);
952 template <
class T1,
class T2,
class T3>
953 void operator()(T1
const & v1, T2
const & v2, T3
const & v3)
const 955 if( expr1_(v1, v2, v3) ) expr2_(v1, v2, v3);
964 IfThenFunctor & operator=(IfThenFunctor
const &);
967 template <
class EXPR1,
class EXPR2>
968 UnaryAnalyser<IfThenFunctor<UnaryFunctor<EXPR1>,
969 UnaryAnalyser<EXPR2> > >
970 ifThen(UnaryFunctor<EXPR1>
const & e1,
971 UnaryAnalyser<EXPR2>
const & e2)
973 IfThenFunctor<UnaryFunctor<EXPR1>,
974 UnaryAnalyser<EXPR2> > p(e1, e2);
975 return UnaryAnalyser<IfThenFunctor<UnaryFunctor<EXPR1>,
976 UnaryAnalyser<EXPR2> > >(p);
985 template <
class EXPR1,
class EXPR2,
class EXPR3>
986 struct IfThenElseFunctor;
988 template <
class EXPR1,
class EXPR2,
class EXPR3>
989 struct ResultTraits0<IfThenElseFunctor<EXPR1, EXPR2, EXPR3> >
991 typedef typename ResultTraits0<EXPR2>::Res R2;
992 typedef typename ResultTraits0<EXPR3>::Res R3;
993 typedef typename PromoteTraits<R2, R3>::Promote Res;
996 template <
class EXPR1,
class EXPR2,
class EXPR3,
class T1>
997 struct ResultTraits1<IfThenElseFunctor<EXPR1, EXPR2, EXPR3>, T1>
999 typedef typename ResultTraits1<EXPR2, T1>::Res R2;
1000 typedef typename ResultTraits1<EXPR3, T1>::Res R3;
1001 typedef typename PromoteTraits<R2, R3>::Promote Res;
1004 template <
class EXPR1,
class EXPR2,
class EXPR3,
class T1,
class T2>
1005 struct ResultTraits2<IfThenElseFunctor<EXPR1, EXPR2, EXPR3>, T1, T2>
1007 typedef typename ResultTraits2<EXPR2, T1, T2>::Res R2;
1008 typedef typename ResultTraits2<EXPR3, T1, T2>::Res R3;
1009 typedef typename PromoteTraits<R2, R3>::Promote Res;
1012 template <
class EXPR1,
class EXPR2,
class EXPR3,
class T1,
class T2,
class T3>
1013 struct ResultTraits3<IfThenElseFunctor<EXPR1, EXPR2, EXPR3>, T1, T2, T3>
1015 typedef typename ResultTraits3<EXPR2, T1, T2, T3>::Res R2;
1016 typedef typename ResultTraits3<EXPR3, T1, T2, T3>::Res R3;
1017 typedef typename PromoteTraits<R2, R3>::Promote Res;
1020 template <
class EXPR1,
class EXPR2,
class EXPR3>
1021 struct IfThenElseFunctor
1023 IfThenElseFunctor(EXPR1
const & e1, EXPR2
const & e2, EXPR3
const & e3)
1024 : expr1_(e1), expr2_(e2), expr3_(e3)
1027 typename ResultTraits0<IfThenElseFunctor>::Res
1032 return typename ResultTraits0<IfThenElseFunctor>::Res(expr2_());
1036 return typename ResultTraits0<IfThenElseFunctor>::Res(expr3_());
1041 typename ResultTraits1<IfThenElseFunctor, T>::Res
1042 operator()(T
const & v1)
const 1046 return typename ResultTraits1<IfThenElseFunctor, T>::Res(expr2_(v1));
1050 return typename ResultTraits1<IfThenElseFunctor, T>::Res(expr3_(v1));
1054 template <
class T1,
class T2>
1055 typename ResultTraits2<IfThenElseFunctor, T1, T2>::Res
1056 operator()(T1
const & v1, T2
const & v2)
const 1060 return typename ResultTraits2<IfThenElseFunctor, T1, T2>::Res(expr2_(v1, v2));
1064 return typename ResultTraits2<IfThenElseFunctor, T1, T2>::Res(expr3_(v1, v2));
1068 template <
class T1,
class T2,
class T3>
1069 typename ResultTraits3<IfThenElseFunctor, T1, T2, T3>::Res
1070 operator()(T1
const & v1, T2
const & v2, T3
const & v3)
const 1072 if(expr1_(v1, v2, v3))
1074 return typename ResultTraits3<IfThenElseFunctor, T1, T2, T3>::Res(expr2_(v1, v2, v3));
1078 return typename ResultTraits3<IfThenElseFunctor, T1, T2, T3>::Res(expr3_(v1, v2, v3));
1088 IfThenElseFunctor & operator=(IfThenElseFunctor
const &);
1091 template <
class EXPR1,
class EXPR2,
class EXPR3>
1092 UnaryFunctor<IfThenElseFunctor<UnaryFunctor<EXPR1>,
1093 UnaryFunctor<EXPR2>,
1094 UnaryFunctor<EXPR3> > >
1095 ifThenElse(UnaryFunctor<EXPR1>
const & e1,
1096 UnaryFunctor<EXPR2>
const & e2,
1097 UnaryFunctor<EXPR3>
const & e3)
1099 IfThenElseFunctor<UnaryFunctor<EXPR1>,
1100 UnaryFunctor<EXPR2>,
1101 UnaryFunctor<EXPR3> > p(e1, e2, e3);
1102 return UnaryFunctor<IfThenElseFunctor<UnaryFunctor<EXPR1>,
1103 UnaryFunctor<EXPR2>,
1104 UnaryFunctor<EXPR3> > >(p);
1113 #define MAKE_FUNCTOR_UNARY_FUNCTION(function, namespc, traitsClass, traitsValue) \ 1114 using ::namespc::function; \ 1115 template <class EXPR> \ 1116 struct Functor_##function; \ 1118 template <class EXPR> \ 1119 struct ResultTraits0<Functor_##function<EXPR> > \ 1121 typedef typename ResultTraits0<EXPR>::Res R1; \ 1122 typedef typename traitsClass<R1>::traitsValue Res; \ 1125 template <class EXPR, class T1> \ 1126 struct ResultTraits1<Functor_##function<EXPR>, T1> \ 1128 typedef typename ResultTraits1<EXPR, T1>::Res R1; \ 1129 typedef typename traitsClass<R1>::traitsValue Res; \ 1132 template <class EXPR, class T1, class T2> \ 1133 struct ResultTraits2<Functor_##function<EXPR>, T1, T2> \ 1135 typedef typename ResultTraits2<EXPR, T1, T2>::Res R1; \ 1136 typedef typename traitsClass<R1>::traitsValue Res; \ 1139 template <class EXPR, class T1, class T2, class T3> \ 1140 struct ResultTraits3<Functor_##function<EXPR>, T1, T2, T3> \ 1142 typedef typename ResultTraits3<EXPR, T1, T2, T3>::Res R1; \ 1143 typedef typename traitsClass<R1>::traitsValue Res; \ 1146 template <class EXPR> \ 1147 struct Functor_##function \ 1149 Functor_##function(EXPR const & e) \ 1153 typename ResultTraits0<Functor_##function>::Res \ 1154 operator()() const \ 1156 return function(expr_()); \ 1159 template <class T> \ 1160 typename ResultTraits1<Functor_##function, T>::Res \ 1161 operator()(T const & v1) const \ 1163 return function(expr_(v1)); \ 1166 template <class T1, class T2> \ 1167 typename ResultTraits2<Functor_##function, T1, T2>::Res \ 1168 operator()(T1 const & v1, T2 const & v2) const \ 1170 return function(expr_(v1, v2)); \ 1173 template <class T1, class T2, class T3> \ 1174 typename ResultTraits3<Functor_##function, T1, T2, T3>::Res \ 1175 operator()(T1 const & v1, T2 const & v2, T3 const & v3) const \ 1177 return function(expr_(v1, v2, v3)); \ 1185 Functor_##function & operator=(Functor_##function const &); \ 1188 template <class EXPR> \ 1189 inline UnaryFunctor<Functor_##function<UnaryFunctor<EXPR> > > \ 1190 function(UnaryFunctor<EXPR> const & e) \ 1192 Functor_##function<UnaryFunctor<EXPR> > p(e); \ 1193 return UnaryFunctor<Functor_##function<UnaryFunctor<EXPR> > >(p); \ 1198 MAKE_FUNCTOR_UNARY_FUNCTION(
sq,
vigra, NumericTraits, RealPromote)
1199 MAKE_FUNCTOR_UNARY_FUNCTION(
sqrt,
std, NumericTraits, RealPromote)
1200 MAKE_FUNCTOR_UNARY_FUNCTION(
exp,
std, NumericTraits, RealPromote)
1201 MAKE_FUNCTOR_UNARY_FUNCTION(
log,
std, NumericTraits, RealPromote)
1202 MAKE_FUNCTOR_UNARY_FUNCTION(
log10,
std, NumericTraits, RealPromote)
1203 MAKE_FUNCTOR_UNARY_FUNCTION(
sin,
std, NumericTraits, RealPromote)
1204 MAKE_FUNCTOR_UNARY_FUNCTION(
asin,
std, NumericTraits, RealPromote)
1205 MAKE_FUNCTOR_UNARY_FUNCTION(
cos,
std, NumericTraits, RealPromote)
1206 MAKE_FUNCTOR_UNARY_FUNCTION(
acos,
std, NumericTraits, RealPromote)
1207 MAKE_FUNCTOR_UNARY_FUNCTION(
tan,
std, NumericTraits, RealPromote)
1208 MAKE_FUNCTOR_UNARY_FUNCTION(
atan,
std, NumericTraits, RealPromote)
1209 MAKE_FUNCTOR_UNARY_FUNCTION(
floor,
std, NumericTraits, RealPromote)
1210 MAKE_FUNCTOR_UNARY_FUNCTION(
ceil,
std, NumericTraits, RealPromote)
1211 MAKE_FUNCTOR_UNARY_FUNCTION(
abs,
vigra, NumericTraits, RealPromote)
1212 MAKE_FUNCTOR_UNARY_FUNCTION(
norm,
vigra, NormTraits, NormType)
1213 MAKE_FUNCTOR_UNARY_FUNCTION(
squaredNorm,
vigra, NormTraits, SquaredNormType)
1215 #undef MAKE_FUNCTOR_UNARY_FUNCTION 1223 #define MAKE_FUNCTOR_UNARY_OPERATOR(name, op) \ 1224 template <class EXPR> \ 1225 struct Functor_##name; \ 1227 template <class EXPR> \ 1228 struct ResultTraits0<Functor_##name<EXPR> > \ 1230 typedef typename ResultTraits0<EXPR>::Res Res; \ 1233 template <class EXPR, class T1> \ 1234 struct ResultTraits1<Functor_##name<EXPR>, T1> \ 1236 typedef typename ResultTraits1<EXPR, T1>::Res Res; \ 1239 template <class EXPR, class T1, class T2> \ 1240 struct ResultTraits2<Functor_##name<EXPR>, T1, T2> \ 1242 typedef typename ResultTraits2<EXPR, T1, T2>::Res Res; \ 1245 template <class EXPR, class T1, class T2, class T3> \ 1246 struct ResultTraits3<Functor_##name<EXPR>, T1, T2, T3> \ 1248 typedef typename ResultTraits3<EXPR, T1, T2, T3>::Res Res; \ 1251 template <class EXPR> \ 1252 struct Functor_##name \ 1254 Functor_##name(EXPR const & e) \ 1258 typename ResultTraits0<Functor_##name>::Res \ 1259 operator()() const \ 1261 return op expr_(); \ 1264 template <class T> \ 1265 typename ResultTraits1<Functor_##name, T>::Res \ 1266 operator()(T const & v1) const \ 1268 return op expr_(v1); \ 1271 template <class T1, class T2> \ 1272 typename ResultTraits2<Functor_##name, T1, T2>::Res \ 1273 operator()(T1 const & v1, T2 const & v2) const \ 1275 return op expr_(v1, v2); \ 1278 template <class T1, class T2, class T3> \ 1279 typename ResultTraits3<Functor_##name, T1, T2, T3>::Res \ 1280 operator()(T1 const & v1, T2 const & v2, T3 const & v3) const \ 1282 return op expr_(v1, v2, v3); \ 1289 Functor_##name & operator=(Functor_##name const &);\ 1292 template <class EXPR> \ 1293 inline UnaryFunctor<Functor_##name<UnaryFunctor<EXPR> > > \ 1294 operator op(UnaryFunctor<EXPR> const & e) \ 1296 Functor_##name<UnaryFunctor<EXPR> > p(e); \ 1297 return UnaryFunctor<Functor_##name<UnaryFunctor<EXPR> > >(p); \ 1303 MAKE_FUNCTOR_UNARY_OPERATOR(minus, -)
1304 MAKE_FUNCTOR_UNARY_OPERATOR(negate, !)
1305 MAKE_FUNCTOR_UNARY_OPERATOR(bitNegate, ~)
1307 #undef MAKE_FUNCTOR_UNARY_OPERATOR 1315 #define MAKE_FUNCTOR_BINARY_FUNCTION(function) \ 1316 using std::function; \ 1317 template <class EXPR1, class EXPR2> \ 1318 struct Functor_##function; \ 1320 template <class EXPR1, class EXPR2> \ 1321 struct ResultTraits0<Functor_##function<EXPR1, EXPR2> > \ 1323 typedef typename ResultTraits0<EXPR1>::Res R1; \ 1324 typedef typename ResultTraits0<EXPR2>::Res R2; \ 1325 typedef typename PromoteTraits<R1, R2>::Promote R3; \ 1326 typedef typename NumericTraits<R3>::RealPromote Res; \ 1329 template <class EXPR1, class EXPR2, class T1> \ 1330 struct ResultTraits1<Functor_##function<EXPR1, EXPR2>, T1> \ 1332 typedef typename ResultTraits1<EXPR1, T1>::Res R1; \ 1333 typedef typename ResultTraits1<EXPR2, T1>::Res R2; \ 1334 typedef typename PromoteTraits<R1, R2>::Promote R3; \ 1335 typedef typename NumericTraits<R3>::RealPromote Res; \ 1338 template <class EXPR1, class EXPR2, class T1, class T2> \ 1339 struct ResultTraits2<Functor_##function<EXPR1, EXPR2>, T1, T2> \ 1341 typedef typename ResultTraits2<EXPR1, T1, T2>::Res R1; \ 1342 typedef typename ResultTraits2<EXPR2, T1, T2>::Res R2; \ 1343 typedef typename PromoteTraits<R1, R2>::Promote R3; \ 1344 typedef typename NumericTraits<R3>::RealPromote Res; \ 1347 template <class EXPR1, class EXPR2, class T1, class T2, class T3> \ 1348 struct ResultTraits3<Functor_##function<EXPR1, EXPR2>, T1, T2, T3> \ 1350 typedef typename ResultTraits3<EXPR1, T1, T2, T3>::Res R1; \ 1351 typedef typename ResultTraits3<EXPR2, T1, T2, T3>::Res R2; \ 1352 typedef typename PromoteTraits<R1, R2>::Promote R3; \ 1353 typedef typename NumericTraits<R3>::RealPromote Res; \ 1356 template <class EXPR1, class EXPR2> \ 1357 struct Functor_##function \ 1359 Functor_##function(EXPR1 const & e1, EXPR2 const & e2) \ 1360 : expr1_(e1), expr2_(e2) \ 1363 typename ResultTraits0<Functor_##function>::Res \ 1364 operator()() const \ 1366 return function(expr1_(), expr2_()); \ 1369 template <class T> \ 1370 typename ResultTraits1<Functor_##function, T>::Res \ 1371 operator()(T const & v1) const \ 1373 return function(expr1_(v1), expr2_(v1)); \ 1376 template <class T1, class T2> \ 1377 typename ResultTraits2<Functor_##function, T1, T2>::Res \ 1378 operator()(T1 const & v1, T2 const & v2) const \ 1380 return function(expr1_(v1, v2), expr2_(v1, v2)); \ 1383 template <class T1, class T2, class T3> \ 1384 typename ResultTraits3<Functor_##function, T1, T2, T3>::Res \ 1385 operator()(T1 const & v1, T2 const & v2, T3 const & v3) const \ 1387 return function(expr1_(v1, v2, v3), expr2_(v1, v2, v3)); \ 1395 Functor_##function & operator=(Functor_##function const &); \ 1398 template <class EXPR1, class EXPR2> \ 1399 inline UnaryFunctor<Functor_##function<UnaryFunctor<EXPR1>, UnaryFunctor<EXPR2> > > \ 1400 function(UnaryFunctor<EXPR1> const & e1, UnaryFunctor<EXPR2> const & e2) \ 1402 Functor_##function<UnaryFunctor<EXPR1>, UnaryFunctor<EXPR2> > p(e1, e2); \ 1403 return UnaryFunctor<Functor_##function<UnaryFunctor<EXPR1>, \ 1404 UnaryFunctor<EXPR2> > >(p); \ 1409 MAKE_FUNCTOR_BINARY_FUNCTION(pow)
1410 MAKE_FUNCTOR_BINARY_FUNCTION(
atan2)
1411 MAKE_FUNCTOR_BINARY_FUNCTION(fmod)
1413 #undef MAKE_FUNCTOR_BINARY_FUNCTION 1417 #define MAKE_FUNCTOR_MINMAX(name, op) \ 1418 template <class EXPR1, class EXPR2> \ 1419 struct Functor_##name; \ 1421 template <class EXPR1, class EXPR2> \ 1422 struct ResultTraits0<Functor_##name<EXPR1, EXPR2> > \ 1424 typedef typename ResultTraits0<EXPR1>::Res R1; \ 1425 typedef typename ResultTraits0<EXPR2>::Res R2; \ 1426 typedef typename PromoteTraits<R1, R2>::Promote Res; \ 1429 template <class EXPR1, class EXPR2, class T1> \ 1430 struct ResultTraits1<Functor_##name<EXPR1, EXPR2>, T1> \ 1432 typedef typename ResultTraits1<EXPR1, T1>::Res R1; \ 1433 typedef typename ResultTraits1<EXPR2, T1>::Res R2; \ 1434 typedef typename PromoteTraits<R1, R2>::Promote Res; \ 1437 template <class EXPR1, class EXPR2, class T1, class T2> \ 1438 struct ResultTraits2<Functor_##name<EXPR1, EXPR2>, T1, T2> \ 1440 typedef typename ResultTraits2<EXPR1, T1, T2>::Res R1; \ 1441 typedef typename ResultTraits2<EXPR2, T1, T2>::Res R2; \ 1442 typedef typename PromoteTraits<R1, R2>::Promote Res; \ 1445 template <class EXPR1, class EXPR2, class T1, class T2, class T3> \ 1446 struct ResultTraits3<Functor_##name<EXPR1, EXPR2>, T1, T2, T3> \ 1448 typedef typename ResultTraits3<EXPR1, T1, T2, T3>::Res R1; \ 1449 typedef typename ResultTraits3<EXPR2, T1, T2, T3>::Res R2; \ 1450 typedef typename PromoteTraits<R1, R2>::Promote Res; \ 1453 template <class EXPR1, class EXPR2> \ 1454 struct Functor_##name \ 1456 Functor_##name(EXPR1 const & e1, EXPR2 const & e2) \ 1457 : expr1_(e1), expr2_(e2) \ 1460 typename ResultTraits0<Functor_##name>::Res \ 1461 operator()() const \ 1464 ResultTraits0<Functor_##name<EXPR1, EXPR2> >::R1 r1(expr1_()); \ 1466 ResultTraits0<Functor_##name<EXPR1, EXPR2> >::R2 r2(expr2_()); \ 1467 return (r1 op r2) ? r1 : r2; \ 1470 template <class T> \ 1471 typename ResultTraits1<Functor_##name, T>::Res \ 1472 operator()(T const & v1) const \ 1475 ResultTraits1<Functor_##name<EXPR1, EXPR2>, T>::R1 r1(expr1_(v1)); \ 1477 ResultTraits1<Functor_##name<EXPR1, EXPR2>, T>::R2 r2(expr2_(v1)); \ 1478 return (r1 op r2) ? r1 : r2; \ 1481 template <class T1, class T2> \ 1482 typename ResultTraits2<Functor_##name, T1, T2>::Res \ 1483 operator()(T1 const & v1, T2 const & v2) const \ 1486 ResultTraits2<Functor_##name<EXPR1, EXPR2>, T1, T2>::R1 r1(expr1_(v1, v2)); \ 1488 ResultTraits2<Functor_##name<EXPR1, EXPR2>, T1, T2>::R2 r2(expr2_(v1, v2)); \ 1489 return (r1 op r2) ? r1 : r2; \ 1492 template <class T1, class T2, class T3> \ 1493 typename ResultTraits3<Functor_##name, T1, T2, T3>::Res \ 1494 operator()(T1 const & v1, T2 const & v2, T3 const & v3) const \ 1497 ResultTraits3<Functor_##name<EXPR1, EXPR2>, T1, T2, T3>::R1 r1(expr1_(v1, v2, v3)); \ 1499 ResultTraits3<Functor_##name<EXPR1, EXPR2>, T1, T2, T3>::R2 r2(expr2_(v1, v2, v3)); \ 1500 return (r1 op r2) ? r1 : r2; \ 1508 Functor_##name & operator=(Functor_##name const &); \ 1511 template <class EXPR1, class EXPR2> \ 1512 inline UnaryFunctor<Functor_##name<UnaryFunctor<EXPR1>, UnaryFunctor<EXPR2> > > \ 1513 name(UnaryFunctor<EXPR1> const & e1, UnaryFunctor<EXPR2> const & e2) \ 1515 Functor_##name<UnaryFunctor<EXPR1>, UnaryFunctor<EXPR2> > p(e1, e2); \ 1516 return UnaryFunctor<Functor_##name<UnaryFunctor<EXPR1>, \ 1517 UnaryFunctor<EXPR2> > >(p); \ 1520 MAKE_FUNCTOR_MINMAX(min, <)
1521 MAKE_FUNCTOR_MINMAX(max, >)
1523 #undef MAKE_FUNCTOR_MINMAX 1531 #define MAKE_FUNCTOR_BINARY_OPERATOR(name, op) \ 1532 template <class EXPR1, class EXPR2> \ 1533 struct Functor_##name; \ 1535 template <class EXPR1, class EXPR2> \ 1536 struct ResultTraits0<Functor_##name<EXPR1, EXPR2> > \ 1538 typedef typename ResultTraits0<EXPR1>::Res R1; \ 1539 typedef typename ResultTraits0<EXPR2>::Res R2; \ 1540 typedef typename PromoteTraits<R1, R2>::Promote Res; \ 1543 template <class EXPR1, class EXPR2, class T1> \ 1544 struct ResultTraits1<Functor_##name<EXPR1, EXPR2>, T1> \ 1546 typedef typename ResultTraits1<EXPR1, T1>::Res R1; \ 1547 typedef typename ResultTraits1<EXPR2, T1>::Res R2; \ 1548 typedef typename PromoteTraits<R1, R2>::Promote Res; \ 1551 template <class EXPR1, class EXPR2, class T1, class T2> \ 1552 struct ResultTraits2<Functor_##name<EXPR1, EXPR2>, T1, T2> \ 1554 typedef typename ResultTraits2<EXPR1, T1, T2>::Res R1; \ 1555 typedef typename ResultTraits2<EXPR2, T1, T2>::Res R2; \ 1556 typedef typename PromoteTraits<R1, R2>::Promote Res; \ 1559 template <class EXPR1, class EXPR2, class T1, class T2, class T3> \ 1560 struct ResultTraits3<Functor_##name<EXPR1, EXPR2>, T1, T2, T3> \ 1562 typedef typename ResultTraits3<EXPR1, T1, T2, T3>::Res R1; \ 1563 typedef typename ResultTraits3<EXPR2, T1, T2, T3>::Res R2; \ 1564 typedef typename PromoteTraits<R1, R2>::Promote Res; \ 1567 template <class EXPR1, class EXPR2> \ 1568 struct Functor_##name \ 1570 Functor_##name(EXPR1 const & e1, EXPR2 const & e2) \ 1571 : expr1_(e1), expr2_(e2) \ 1574 typename ResultTraits0<Functor_##name>::Res \ 1575 operator()() const \ 1577 return expr1_() op expr2_(); \ 1580 template <class T> \ 1581 typename ResultTraits1<Functor_##name, T>::Res \ 1582 operator()(T const & v1) const \ 1584 return expr1_(v1) op expr2_(v1); \ 1587 template <class T1, class T2> \ 1588 typename ResultTraits2<Functor_##name, T1, T2>::Res \ 1589 operator()(T1 const & v1, T2 const & v2) const \ 1591 return expr1_(v1, v2) op expr2_(v1, v2); \ 1594 template <class T1, class T2, class T3> \ 1595 typename ResultTraits3<Functor_##name, T1, T2, T3>::Res \ 1596 operator()(T1 const & v1, T2 const & v2, T3 const & v3) const \ 1598 return expr1_(v1, v2, v3) op expr2_(v1, v2, v3); \ 1606 Functor_##name & operator=(Functor_##name const &); \ 1609 template <class EXPR1, class EXPR2> \ 1610 inline UnaryFunctor<Functor_##name<UnaryFunctor<EXPR1>, UnaryFunctor<EXPR2> > > \ 1611 operator op(UnaryFunctor<EXPR1> const & e1, UnaryFunctor<EXPR2> const & e2) \ 1613 Functor_##name<UnaryFunctor<EXPR1>, UnaryFunctor<EXPR2> > p(e1, e2); \ 1614 return UnaryFunctor<Functor_##name<UnaryFunctor<EXPR1>, \ 1615 UnaryFunctor<EXPR2> > >(p); \ 1620 MAKE_FUNCTOR_BINARY_OPERATOR(add, +)
1621 MAKE_FUNCTOR_BINARY_OPERATOR(subtract, -)
1622 MAKE_FUNCTOR_BINARY_OPERATOR(multiply, *)
1623 MAKE_FUNCTOR_BINARY_OPERATOR(divide, /)
1624 MAKE_FUNCTOR_BINARY_OPERATOR(modulo, %)
1625 MAKE_FUNCTOR_BINARY_OPERATOR(bitAnd, &)
1626 MAKE_FUNCTOR_BINARY_OPERATOR(bitOr, |)
1627 MAKE_FUNCTOR_BINARY_OPERATOR(bitXor, ^)
1629 #undef MAKE_FUNCTOR_BINARY_OPERATOR 1633 #define MAKE_FUNCTOR_BINARY_OPERATOR_BOOL(name, op) \ 1634 template <class EXPR1, class EXPR2> \ 1635 struct Functor_##name; \ 1637 template <class EXPR1, class EXPR2> \ 1638 struct ResultTraits0<Functor_##name<EXPR1, EXPR2> > \ 1643 template <class EXPR1, class EXPR2, class T1> \ 1644 struct ResultTraits1<Functor_##name<EXPR1, EXPR2>, T1> \ 1649 template <class EXPR1, class EXPR2, class T1, class T2> \ 1650 struct ResultTraits2<Functor_##name<EXPR1, EXPR2>, T1, T2> \ 1655 template <class EXPR1, class EXPR2, class T1, class T2, class T3> \ 1656 struct ResultTraits3<Functor_##name<EXPR1, EXPR2>, T1, T2, T3> \ 1661 template <class EXPR1, class EXPR2> \ 1662 struct Functor_##name \ 1664 Functor_##name(EXPR1 const & e1, EXPR2 const & e2) \ 1665 : expr1_(e1), expr2_(e2) \ 1668 bool operator()() const \ 1670 return expr1_() op expr2_(); \ 1673 template <class T> \ 1674 bool operator()(T const & v1) const \ 1676 return expr1_(v1) op expr2_(v1); \ 1679 template <class T1, class T2> \ 1680 bool operator()(T1 const & v1, T2 const & v2) const \ 1682 return expr1_(v1, v2) op expr2_(v1, v2); \ 1685 template <class T1, class T2, class T3> \ 1686 bool operator()(T1 const & v1, T2 const & v2, T3 const & v3) const \ 1688 return expr1_(v1, v2, v3) op expr2_(v1, v2, v3); \ 1696 Functor_##name & operator=(Functor_##name const &); \ 1699 template <class EXPR1, class EXPR2> \ 1700 inline UnaryFunctor<Functor_##name<UnaryFunctor<EXPR1>, UnaryFunctor<EXPR2> > > \ 1701 operator op(UnaryFunctor<EXPR1> const & e1, UnaryFunctor<EXPR2> const & e2) \ 1703 Functor_##name<UnaryFunctor<EXPR1>, UnaryFunctor<EXPR2> > p(e1, e2); \ 1704 return UnaryFunctor<Functor_##name<UnaryFunctor<EXPR1>, \ 1705 UnaryFunctor<EXPR2> > >(p); \ 1710 MAKE_FUNCTOR_BINARY_OPERATOR_BOOL(equals, ==)
1711 MAKE_FUNCTOR_BINARY_OPERATOR_BOOL(differs, !=)
1712 MAKE_FUNCTOR_BINARY_OPERATOR_BOOL(less, <)
1713 MAKE_FUNCTOR_BINARY_OPERATOR_BOOL(lessEqual, <=)
1714 MAKE_FUNCTOR_BINARY_OPERATOR_BOOL(greater, >)
1715 MAKE_FUNCTOR_BINARY_OPERATOR_BOOL(greaterEqual, >=)
1716 MAKE_FUNCTOR_BINARY_OPERATOR_BOOL(and, &&)
1717 MAKE_FUNCTOR_BINARY_OPERATOR_BOOL(or, ||)
1719 #undef MAKE_FUNCTOR_BINARY_OPERATOR_BOOL 1727 template <
class EXPR,
class RES,
class ARG>
1728 struct UnaryFctPtrFunctor
1730 UnaryFctPtrFunctor(EXPR
const & e, RES (*fct)(ARG))
1734 RES operator()()
const 1740 RES operator()(T
const & v1)
const 1742 return f_(expr_(v1));
1745 template <
class T1,
class T2>
1746 RES operator()(T1
const & v1, T2
const & v2)
const 1748 return f_(expr_(v1, v2));
1751 template <
class T1,
class T2,
class T3>
1752 RES operator()(T1
const & v1, T2
const & v2, T3
const & v3)
const 1754 return f_(expr_(v1, v2, v3));
1762 UnaryFctPtrFunctor & operator=(UnaryFctPtrFunctor
const &);
1765 template <
class EXPR,
class RES,
class ARG>
1766 struct ResultTraits0<UnaryFctPtrFunctor<EXPR, RES, ARG> >
1771 template <
class EXPR,
class RES,
class ARG,
class T1>
1772 struct ResultTraits1<UnaryFctPtrFunctor<EXPR, RES, ARG>, T1>
1777 template <
class EXPR,
class RES,
class ARG,
class T1,
class T2>
1778 struct ResultTraits2<UnaryFctPtrFunctor<EXPR, RES, ARG>, T1, T2>
1783 template <
class EXPR,
class RES,
class ARG,
class T1,
class T2,
class T3>
1784 struct ResultTraits3<UnaryFctPtrFunctor<EXPR, RES, ARG>, T1, T2, T3>
1789 template <
class EXPR,
class RES,
class ARG>
1790 inline UnaryFunctor<UnaryFctPtrFunctor<UnaryFunctor<EXPR>, RES, ARG> >
1791 applyFct(RES (*f)(ARG), UnaryFunctor<EXPR>
const & e)
1793 UnaryFctPtrFunctor<UnaryFunctor<EXPR>, RES, ARG> p(e, f);
1794 return UnaryFunctor<UnaryFctPtrFunctor<UnaryFunctor<EXPR>, RES, ARG> >(p);
1803 template <
class EXPR1,
class EXPR2,
class RES,
class ARG1,
class ARG2>
1804 struct BinaryFctPtrFunctor
1806 BinaryFctPtrFunctor(EXPR1
const & e1, EXPR2
const & e2,
1807 RES (*f)(ARG1, ARG2))
1808 : expr1_(e1), expr2_(e2), f_(f)
1811 RES operator()()
const 1813 return f_(expr1_(), expr2_());
1817 RES operator()(T
const & v1)
const 1819 return f_(expr1_(v1), expr2_(v1));
1822 template <
class T1,
class T2>
1823 RES operator()(T1
const & v1, T2
const & v2)
const 1825 return f_(expr1_(v1, v2), expr2_(v1, v2));
1828 template <
class T1,
class T2,
class T3>
1829 RES operator()(T1
const & v1, T2
const & v2, T3
const & v3)
const 1831 return f_(expr1_(v1, v2, v3), expr2_(v1, v2, v3));
1838 RES (*f_)(ARG1, ARG2);
1841 BinaryFctPtrFunctor & operator=(BinaryFctPtrFunctor
const &);
1844 template <
class EXPR1,
class EXPR2,
class RES,
class ARG1,
class ARG2>
1845 struct ResultTraits0<BinaryFctPtrFunctor<EXPR1, EXPR2, RES, ARG1, ARG2> >
1850 template <
class EXPR1,
class EXPR2,
class RES,
class ARG1,
class ARG2,
1852 struct ResultTraits1<BinaryFctPtrFunctor<EXPR1, EXPR2, RES, ARG1, ARG2>, T1>
1857 template <
class EXPR1,
class EXPR2,
class RES,
class ARG1,
class ARG2,
1859 struct ResultTraits2<BinaryFctPtrFunctor<EXPR1, EXPR2, RES, ARG1, ARG2>, T1, T2>
1864 template <
class EXPR1,
class EXPR2,
class RES,
class ARG1,
class ARG2,
1865 class T1,
class T2,
class T3>
1866 struct ResultTraits3<BinaryFctPtrFunctor<EXPR1, EXPR2, RES, ARG1, ARG2>, T1, T2, T3>
1871 template <
class EXPR1,
class EXPR2,
class RES,
class ARG1,
class ARG2>
1872 inline UnaryFunctor<BinaryFctPtrFunctor<UnaryFunctor<EXPR1>,
1873 UnaryFunctor<EXPR2>,
1875 applyFct(RES (*f)(ARG1, ARG2), UnaryFunctor<EXPR1>
const & e1,
1876 UnaryFunctor<EXPR2>
const & e2)
1878 BinaryFctPtrFunctor<UnaryFunctor<EXPR1>,
1879 UnaryFunctor<EXPR2>,
1880 RES, ARG1, ARG2> p(e1, e2, f);
1881 return UnaryFunctor<BinaryFctPtrFunctor<UnaryFunctor<EXPR1>,
1882 UnaryFunctor<EXPR2>,
1883 RES, ARG1, ARG2> >(p);
1892 template <
class EXPR1,
class EXPR2>
1895 CommaFunctor(EXPR1
const & e1, EXPR2
const & e2)
1896 : expr1_(e1), expr2_(e2)
1899 typename ResultTraits0<EXPR2>::Res
1907 typename ResultTraits1<EXPR2, T>::Res
1908 operator()(T
const & v1)
const 1914 template <
class T1,
class T2>
1915 typename ResultTraits2<EXPR2, T1, T2>::Res
1916 operator()(T1
const & v1, T2
const & v2)
const 1919 return expr2_(v1, v2);
1922 template <
class T1,
class T2,
class T3>
1923 typename ResultTraits3<EXPR2, T1, T2, T3>::Res
1924 operator()(T1
const & v1, T2
const & v2, T3
const & v3)
const 1927 return expr2_(v1, v2, v3);
1936 CommaFunctor & operator=(CommaFunctor
const &);
1939 template <
class Expr1,
class Expr2>
1940 struct ResultTraits0<CommaFunctor<Expr1, Expr2> >
1942 typedef typename ResultTraits0<Expr2>::Res Res;
1945 template <
class Expr1,
class Expr2,
class T1>
1946 struct ResultTraits1<CommaFunctor<Expr1, Expr2>, T1>
1948 typedef typename ResultTraits1<Expr2, T1>::Res Res;
1951 template <
class Expr1,
class Expr2,
class T1,
class T2>
1952 struct ResultTraits2<CommaFunctor<Expr1, Expr2>, T1, T2>
1954 typedef typename ResultTraits2<Expr2, T1, T2>::Res Res;
1957 template <
class Expr1,
class Expr2,
class T1,
class T2,
class T3>
1958 struct ResultTraits3<CommaFunctor<Expr1, Expr2>, T1, T2, T3>
1960 typedef typename ResultTraits3<Expr2, T1, T2, T3>::Res Res;
1963 template <
class EXPR1,
class EXPR2>
1964 inline UnaryFunctor<CommaFunctor<UnaryAnalyser<EXPR1>,
1965 UnaryFunctor<EXPR2> > >
1966 operator,(UnaryAnalyser<EXPR1>
const & e1,
1967 UnaryFunctor<EXPR2>
const & e2)
1969 CommaFunctor<UnaryAnalyser<EXPR1>,
1970 UnaryFunctor<EXPR2> > p(e1, e2);
1971 return UnaryFunctor<CommaFunctor<UnaryAnalyser<EXPR1>,
1972 UnaryFunctor<EXPR2> > >(p);
1977 template <
class EXPR1,
class EXPR2>
1978 struct CommaAnalyser
1980 CommaAnalyser(EXPR1
const & e1, EXPR2
const & e2)
1981 : expr1_(e1), expr2_(e2)
1984 void operator()()
const 1991 void operator()(T
const & v1)
const 1997 template <
class T1,
class T2>
1998 void operator()(T1
const & v1, T2
const & v2)
const 2004 template <
class T1,
class T2,
class T3>
2005 void operator()(T1
const & v1, T2
const & v2, T3
const & v3)
const 2017 CommaAnalyser & operator=(CommaAnalyser
const &);
2020 template <
class EXPR1,
class EXPR2>
2021 inline UnaryAnalyser<CommaAnalyser<UnaryAnalyser<EXPR1>,
2022 UnaryAnalyser<EXPR2> > >
2023 operator,(UnaryAnalyser<EXPR1>
const & e1,
2024 UnaryAnalyser<EXPR2>
const & e2)
2026 CommaAnalyser<UnaryAnalyser<EXPR1>,
2027 UnaryAnalyser<EXPR2> > p(e1, e2);
2028 return UnaryAnalyser<CommaAnalyser<UnaryAnalyser<EXPR1>,
2029 UnaryAnalyser<EXPR2> > >(p);
2034 #if defined(__GNUC__) && __GNUC__ < 3 2035 using functor::Arg1;
2036 using functor::Arg2;
2037 using functor::Arg3;
2038 using functor::Param;
2042 class FunctorTraits<functor::UnaryFunctor<T> >
2043 :
public FunctorTraitsBase<functor::UnaryFunctor<T> >
2046 typedef VigraTrueType isInitializer;
2047 typedef VigraTrueType isUnaryFunctor;
2048 typedef VigraTrueType isBinaryFunctor;
2049 typedef VigraTrueType isTernaryFunctor;
2053 class FunctorTraits<functor::UnaryAnalyser<T> >
2054 :
public FunctorTraitsBase<functor::UnaryAnalyser<T> >
2057 typedef VigraTrueType isUnaryAnalyser;
2058 typedef VigraTrueType isBinaryAnalyser;
2059 typedef VigraTrueType isTernaryAnalyser;
linalg::TemporaryMatrix< T > acos(MultiArrayView< 2, T, C > const &v)
FixedPoint16< 2, OverflowHandling > atan2(FixedPoint16< IntBits, OverflowHandling > y, FixedPoint16< IntBits, OverflowHandling > x)
Arctangent. Accuracy better than 1/3 degree (9 significant bits).
Definition: fixedpoint.hxx:1654
linalg::TemporaryMatrix< T > sin(MultiArrayView< 2, T, C > const &v)
linalg::TemporaryMatrix< T > exp(MultiArrayView< 2, T, C > const &v)
Definition: array_vector.hxx:954
FFTWComplex< R >::SquaredNormType squaredNorm(const FFTWComplex< R > &a)
squared norm (= squared magnitude)
Definition: fftw3.hxx:1044
linalg::TemporaryMatrix< T > asin(MultiArrayView< 2, T, C > const &v)
void add(FixedPoint< IntBits1, FracBits1 > l, FixedPoint< IntBits2, FracBits2 > r, FixedPoint< IntBits3, FracBits3 > &result)
addition with enforced result type.
Definition: fixedpoint.hxx:561
Definition: accessor.hxx:43
FFTWComplex< R > & operator-=(FFTWComplex< R > &a, const FFTWComplex< R > &b)
subtract-assignment
Definition: fftw3.hxx:867
FFTWComplex< R >::NormType norm(const FFTWComplex< R > &a)
norm (= magnitude)
Definition: fftw3.hxx:1037
FFTWComplex< R > & operator+=(FFTWComplex< R > &a, const FFTWComplex< R > &b)
add-assignment
Definition: fftw3.hxx:859
NumericTraits< T >::Promote sq(T t)
The square function.
Definition: mathutil.hxx:365
linalg::TemporaryMatrix< T > log10(MultiArrayView< 2, T, C > const &v)
FFTWComplex< R > & operator*=(FFTWComplex< R > &a, const FFTWComplex< R > &b)
multiply-assignment
Definition: fftw3.hxx:875
linalg::TemporaryMatrix< T > log(MultiArrayView< 2, T, C > const &v)
FFTWComplex< R >::NormType abs(const FFTWComplex< R > &a)
absolute value (= magnitude)
Definition: fftw3.hxx:1002
linalg::TemporaryMatrix< T > atan(MultiArrayView< 2, T, C > const &v)
linalg::TemporaryMatrix< T > tan(MultiArrayView< 2, T, C > const &v)
FFTWComplex< R > & operator/=(FFTWComplex< R > &a, const FFTWComplex< R > &b)
divide-assignment
Definition: fftw3.hxx:884
int ceil(FixedPoint< IntBits, FracBits > v)
rounding up.
Definition: fixedpoint.hxx:675
linalg::TemporaryMatrix< T > cos(MultiArrayView< 2, T, C > const &v)
int floor(FixedPoint< IntBits, FracBits > v)
rounding down.
Definition: fixedpoint.hxx:667
SquareRootTraits< FixedPoint< IntBits, FracBits > >::SquareRootResult sqrt(FixedPoint< IntBits, FracBits > v)
square root.
Definition: fixedpoint.hxx:616