36 #ifndef VIGRA_FUNCTOREXPRESSION_HXX
37 #define VIGRA_FUNCTOREXPRESSION_HXX
326 #if !defined(NO_PARTIAL_TEMPLATE_SPECIALIZATION)
329 #include "numerictraits.hxx"
330 #include "mathutil.hxx"
331 #include "functortraits.hxx"
347 template <
class Operation>
348 struct ResultTraits0;
350 template <
class Operation,
class T1>
356 template <
class Operation,
class T1,
class T2>
359 typedef typename PromoteTraits<T1, T2>::Promote Res;
362 template <
class Operation,
class T1,
class T2,
class T3>
365 typedef typename PromoteTraits<T1, T2>::Promote P1;
366 typedef typename PromoteTraits<P1, T3>::Promote Res;
369 template <
class EXPR>
372 UnaryFunctor(EXPR
const & e)
377 typename ResultTraits0<EXPR>::Res
384 typename ResultTraits1<EXPR, T1>::Res
385 operator()(T1
const & v)
const
390 template <
class T1,
class T2>
391 typename ResultTraits2<EXPR, T1, T2>::Res
392 operator()(T1
const & v1, T2
const & v2)
const
394 return expr_(v1, v2);
397 template <
class T1,
class T2,
class T3>
398 typename ResultTraits3<EXPR, T1, T2, T3>::Res
399 operator()(T1
const & v1, T2
const & v2, T3
const & v3)
const
401 return expr_(v1, v2, v3);
408 UnaryFunctor & operator=(UnaryFunctor
const &);
411 template <
class Expr>
412 struct ResultTraits0<UnaryFunctor<Expr> >
414 typedef typename ResultTraits0<Expr>::Res Res;
417 template <
class Expr,
class T1>
418 struct ResultTraits1<UnaryFunctor<Expr>, T1>
420 typedef typename ResultTraits1<Expr, T1>::Res Res;
423 template <
class Expr,
class T1,
class T2>
424 struct ResultTraits2<UnaryFunctor<Expr>, T1, T2>
426 typedef typename ResultTraits2<Expr, T1, T2>::Res Res;
429 template <
class Expr,
class T1,
class T2,
class T3>
430 struct ResultTraits3<UnaryFunctor<Expr>, T1, T2, T3>
432 typedef typename ResultTraits3<Expr, T1, T2, T3>::Res Res;
441 struct ArgumentFunctor1;
442 struct ArgumentFunctor2;
443 struct ArgumentFunctor3;
446 struct UnaryFunctor<ArgumentFunctor1>
452 T1
const & operator()(T1
const & v1)
const
457 template <
class T1,
class T2>
458 T1
const & operator()(T1
const & v1, T2
const &)
const
463 template <
class T1,
class T2,
class T3>
464 T1
const & operator()(T1
const & v1, T2
const &, T3
const &)
const
470 UnaryFunctor & operator=(UnaryFunctor
const &);
474 struct ResultTraits0<UnaryFunctor<ArgumentFunctor1> >
476 typedef ErrorType Res;
480 struct ResultTraits1<UnaryFunctor<ArgumentFunctor1>, T1>
485 template <
class T1,
class T2>
486 struct ResultTraits2<UnaryFunctor<ArgumentFunctor1>, T1, T2>
491 template <
class T1,
class T2,
class T3>
492 struct ResultTraits3<UnaryFunctor<ArgumentFunctor1>, T1, T2, T3>
500 UnaryFunctor<ArgumentFunctor1>
503 return UnaryFunctor<ArgumentFunctor1>();
509 struct UnaryFunctor<ArgumentFunctor2>
514 template <
class T1,
class T2>
515 T2
const & operator()(T1
const &, T2
const & v2)
const
520 template <
class T1,
class T2,
class T3>
521 T2
const & operator()(T1
const &, T2
const & v2, T3
const &)
const
527 UnaryFunctor & operator=(UnaryFunctor
const &);
531 struct ResultTraits0<UnaryFunctor<ArgumentFunctor2> >
533 typedef ErrorType Res;
537 struct ResultTraits1<UnaryFunctor<ArgumentFunctor2>, T1>
539 typedef ErrorType Res;
542 template <
class T1,
class T2>
543 struct ResultTraits2<UnaryFunctor<ArgumentFunctor2>, T1, T2>
548 template <
class T1,
class T2,
class T3>
549 struct ResultTraits3<UnaryFunctor<ArgumentFunctor2>, T1, T2, T3>
557 UnaryFunctor<ArgumentFunctor2>
560 return UnaryFunctor<ArgumentFunctor2>();
566 struct UnaryFunctor<ArgumentFunctor3>
571 template <
class T1,
class T2,
class T3>
572 T3
const & operator()(T1
const &, T2
const &, T3
const & v3)
const
578 UnaryFunctor & operator=(UnaryFunctor
const &);
582 struct ResultTraits0<UnaryFunctor<ArgumentFunctor3> >
584 typedef ErrorType Res;
588 struct ResultTraits1<UnaryFunctor<ArgumentFunctor3>, T1>
590 typedef ErrorType Res;
593 template <
class T1,
class T2>
594 struct ResultTraits2<UnaryFunctor<ArgumentFunctor3>, T1, T2>
596 typedef ErrorType Res;
599 template <
class T1,
class T2,
class T3>
600 struct ResultTraits3<UnaryFunctor<ArgumentFunctor3>, T1, T2, T3>
608 UnaryFunctor<ArgumentFunctor3>
611 return UnaryFunctor<ArgumentFunctor3>();
621 struct ParameterFunctor
623 ParameterFunctor(T v)
627 T
const & operator()()
const
633 T
const & operator()(U1
const &)
const
638 template <
class U1,
class U2>
639 T
const & operator()(U1
const &, U2
const &)
const
644 template <
class U1,
class U2,
class U3>
645 T
const & operator()(U1
const &, U2
const &, U3
const &)
const
654 ParameterFunctor & operator=(ParameterFunctor
const &);
658 struct ResultTraits0<ParameterFunctor<T> >
663 template <
class T,
class T1>
664 struct ResultTraits1<ParameterFunctor<T>, T1>
669 template <
class T,
class T1,
class T2>
670 struct ResultTraits2<ParameterFunctor<T>, T1, T2>
675 template <
class T,
class T1,
class T2,
class T3>
676 struct ResultTraits3<ParameterFunctor<T>, T1, T2, T3>
682 inline UnaryFunctor<ParameterFunctor<T> >
685 ParameterFunctor<T> fv(v);
686 return UnaryFunctor<ParameterFunctor<T> >(fv);
696 template <
class EXPR>
700 UnaryAnalyser(EXPR
const & e)
704 void operator()()
const
710 void operator()(T1
const & v)
const
715 template <
class T1,
class T2>
716 void operator()(T1
const & v1, T2
const & v2)
const
721 template <
class T1,
class T2,
class T3>
722 void operator()(T1
const & v1, T2
const & v2, T3
const & v3)
const
731 UnaryAnalyser & operator=(UnaryAnalyser
const &);
744 struct UnaryFunctor<VarFunctor<T> >;
748 #define MAKE_ASSIGNMENT_FUNCTOR(name, op) \
749 template <class V, class EXPR> \
750 struct AssignmentFunctor_##name \
752 AssignmentFunctor_##name(UnaryFunctor<VarFunctor<V> > v, \
753 UnaryFunctor<EXPR> const & e) \
754 : value_(v.value_), expr_(e) \
757 V & operator()() const \
759 const_cast<V &>(value_) op expr_(); \
760 return const_cast<V &>(value_); \
763 template <class T1> \
764 V & operator()(T1 const & v1) const \
766 const_cast<V &>(value_) op expr_(v1); \
767 return const_cast<V &>(value_); \
770 template <class T1, class T2> \
771 V & operator()(T1 const & v1, T2 const & v2) const \
773 const_cast<V &>(value_) op expr_(v1, v2); \
774 return const_cast<V &>(value_); \
777 template <class T1, class T2, class T3> \
778 V & operator()(T1 const & v1, T2 const & v2, T3 const & v3) const \
780 const_cast<V &>(value_) op expr_(v1, v2, v3); \
781 return const_cast<V &>(value_); \
786 UnaryFunctor<EXPR> expr_; \
788 AssignmentFunctor_##name & operator=(AssignmentFunctor_##name const &);\
793 MAKE_ASSIGNMENT_FUNCTOR(assign, =)
794 MAKE_ASSIGNMENT_FUNCTOR(
add, +=)
795 MAKE_ASSIGNMENT_FUNCTOR(subtract, -=)
796 MAKE_ASSIGNMENT_FUNCTOR(multiply, *=)
797 MAKE_ASSIGNMENT_FUNCTOR(divide, /=)
799 #undef MAKE_ASSIGNMENT_FUNCTOR
808 struct UnaryFunctor<VarFunctor<T> >
816 template <
class EXPR>
817 UnaryAnalyser< AssignmentFunctor_assign<T, UnaryFunctor<EXPR> > >
818 operator=(UnaryFunctor<EXPR>
const & e)
820 AssignmentFunctor_assign<T, UnaryFunctor<EXPR> > va(*
this, e);
821 return UnaryAnalyser< AssignmentFunctor_assign<T, UnaryFunctor<EXPR> > >(va);
824 template <
class EXPR>
825 UnaryAnalyser< AssignmentFunctor_add<T, UnaryFunctor<EXPR> > >
828 AssignmentFunctor_add<T, UnaryFunctor<EXPR> > va(*
this, e);
829 return UnaryAnalyser< AssignmentFunctor_add<T, UnaryFunctor<EXPR> > >(va);
832 template <
class EXPR>
833 UnaryAnalyser< AssignmentFunctor_subtract<T, UnaryFunctor<EXPR> > >
836 AssignmentFunctor_subtract<T, UnaryFunctor<EXPR> > va(*
this, e);
837 return UnaryAnalyser< AssignmentFunctor_subtract<T, UnaryFunctor<EXPR> > >(va);
840 template <
class EXPR>
841 UnaryAnalyser< AssignmentFunctor_multiply<T, UnaryFunctor<EXPR> > >
844 AssignmentFunctor_multiply<T, UnaryFunctor<EXPR> > va(*
this, e);
845 return UnaryAnalyser< AssignmentFunctor_multiply<T, UnaryFunctor<EXPR> > >(va);
848 template <
class EXPR>
849 UnaryAnalyser< AssignmentFunctor_divide<T, UnaryFunctor<EXPR> > >
852 AssignmentFunctor_divide<T, UnaryFunctor<EXPR> > va(*
this, e);
853 return UnaryAnalyser< AssignmentFunctor_divide<T, UnaryFunctor<EXPR> > >(va);
856 T
const & operator()()
const
862 T
const & operator()(U1
const &)
const
867 template <
class U1,
class U2>
868 T
const & operator()(U1
const &, U2
const &)
const
873 template <
class U1,
class U2,
class U3>
874 T
const & operator()(U1
const &, U2
const &, U3
const &)
const
882 UnaryFunctor & operator=(UnaryFunctor
const &);
886 struct ResultTraits0<UnaryFunctor<VarFunctor<T> > >
891 template <
class T,
class T1>
892 struct ResultTraits1<UnaryFunctor<VarFunctor<T> >, T1>
897 template <
class T,
class T1,
class T2>
898 struct ResultTraits2<UnaryFunctor<VarFunctor<T> >, T1, T2>
903 template <
class T,
class T1,
class T2,
class T3>
904 struct ResultTraits3<UnaryFunctor<VarFunctor<T> >, T1, T2, T3>
910 inline UnaryFunctor<VarFunctor<T> >
913 return UnaryFunctor<VarFunctor<T> >(v);
922 template <
class EXPR1,
class EXPR2>
927 IfThenFunctor(EXPR1
const & e1, EXPR2
const & e2)
928 : expr1_(e1), expr2_(e2)
931 void operator()()
const
933 if( expr1_() ) expr2_();
937 void operator()(T
const & v1)
const
939 if( expr1_(v1) ) expr2_(v1);
942 template <
class T1,
class T2>
943 void operator()(T1
const & v1, T2
const & v2)
const
945 if( expr1_(v1, v2) ) expr2_(v1, v2);
948 template <
class T1,
class T2,
class T3>
949 void operator()(T1
const & v1, T2
const & v2, T3
const & v3)
const
951 if( expr1_(v1, v2, v3) ) expr2_(v1, v2, v3);
960 IfThenFunctor & operator=(IfThenFunctor
const &);
963 template <
class EXPR1,
class EXPR2>
964 UnaryAnalyser<IfThenFunctor<UnaryFunctor<EXPR1>,
965 UnaryAnalyser<EXPR2> > >
966 ifThen(UnaryFunctor<EXPR1>
const & e1,
967 UnaryAnalyser<EXPR2>
const & e2)
969 IfThenFunctor<UnaryFunctor<EXPR1>,
970 UnaryAnalyser<EXPR2> > p(e1, e2);
971 return UnaryAnalyser<IfThenFunctor<UnaryFunctor<EXPR1>,
972 UnaryAnalyser<EXPR2> > >(p);
981 template <
class EXPR1,
class EXPR2,
class EXPR3>
982 struct IfThenElseFunctor;
984 template <
class EXPR1,
class EXPR2,
class EXPR3>
985 struct ResultTraits0<IfThenElseFunctor<EXPR1, EXPR2, EXPR3> >
987 typedef typename ResultTraits0<EXPR2>::Res R2;
988 typedef typename ResultTraits0<EXPR3>::Res R3;
989 typedef typename PromoteTraits<R2, R3>::Promote Res;
992 template <
class EXPR1,
class EXPR2,
class EXPR3,
class T1>
993 struct ResultTraits1<IfThenElseFunctor<EXPR1, EXPR2, EXPR3>, T1>
995 typedef typename ResultTraits1<EXPR2, T1>::Res R2;
996 typedef typename ResultTraits1<EXPR3, T1>::Res R3;
997 typedef typename PromoteTraits<R2, R3>::Promote Res;
1000 template <
class EXPR1,
class EXPR2,
class EXPR3,
class T1,
class T2>
1001 struct ResultTraits2<IfThenElseFunctor<EXPR1, EXPR2, EXPR3>, T1, T2>
1003 typedef typename ResultTraits2<EXPR2, T1, T2>::Res R2;
1004 typedef typename ResultTraits2<EXPR3, T1, T2>::Res R3;
1005 typedef typename PromoteTraits<R2, R3>::Promote Res;
1008 template <
class EXPR1,
class EXPR2,
class EXPR3,
class T1,
class T2,
class T3>
1009 struct ResultTraits3<IfThenElseFunctor<EXPR1, EXPR2, EXPR3>, T1, T2, T3>
1011 typedef typename ResultTraits3<EXPR2, T1, T2, T3>::Res R2;
1012 typedef typename ResultTraits3<EXPR3, T1, T2, T3>::Res R3;
1013 typedef typename PromoteTraits<R2, R3>::Promote Res;
1016 template <
class EXPR1,
class EXPR2,
class EXPR3>
1017 struct IfThenElseFunctor
1019 IfThenElseFunctor(EXPR1
const & e1, EXPR2
const & e2, EXPR3
const & e3)
1020 : expr1_(e1), expr2_(e2), expr3_(e3)
1023 typename ResultTraits0<IfThenElseFunctor>::Res
1028 return typename ResultTraits0<IfThenElseFunctor>::Res(expr2_());
1032 return typename ResultTraits0<IfThenElseFunctor>::Res(expr3_());
1037 typename ResultTraits1<IfThenElseFunctor, T>::Res
1038 operator()(T
const & v1)
const
1042 return typename ResultTraits1<IfThenElseFunctor, T>::Res(expr2_(v1));
1046 return typename ResultTraits1<IfThenElseFunctor, T>::Res(expr3_(v1));
1050 template <
class T1,
class T2>
1051 typename ResultTraits2<IfThenElseFunctor, T1, T2>::Res
1052 operator()(T1
const & v1, T2
const & v2)
const
1056 return typename ResultTraits2<IfThenElseFunctor, T1, T2>::Res(expr2_(v1, v2));
1060 return typename ResultTraits2<IfThenElseFunctor, T1, T2>::Res(expr3_(v1, v2));
1064 template <
class T1,
class T2,
class T3>
1065 typename ResultTraits3<IfThenElseFunctor, T1, T2, T3>::Res
1066 operator()(T1
const & v1, T2
const & v2, T3
const & v3)
const
1068 if(expr1_(v1, v2, v3))
1070 return typename ResultTraits3<IfThenElseFunctor, T1, T2, T3>::Res(expr2_(v1, v2, v3));
1074 return typename ResultTraits3<IfThenElseFunctor, T1, T2, T3>::Res(expr3_(v1, v2, v3));
1084 IfThenElseFunctor & operator=(IfThenElseFunctor
const &);
1087 template <
class EXPR1,
class EXPR2,
class EXPR3>
1088 UnaryFunctor<IfThenElseFunctor<UnaryFunctor<EXPR1>,
1089 UnaryFunctor<EXPR2>,
1090 UnaryFunctor<EXPR3> > >
1091 ifThenElse(UnaryFunctor<EXPR1>
const & e1,
1092 UnaryFunctor<EXPR2>
const & e2,
1093 UnaryFunctor<EXPR3>
const & e3)
1095 IfThenElseFunctor<UnaryFunctor<EXPR1>,
1096 UnaryFunctor<EXPR2>,
1097 UnaryFunctor<EXPR3> > p(e1, e2, e3);
1098 return UnaryFunctor<IfThenElseFunctor<UnaryFunctor<EXPR1>,
1099 UnaryFunctor<EXPR2>,
1100 UnaryFunctor<EXPR3> > >(p);
1109 #define MAKE_FUNCTOR_UNARY_FUNCTION(function, namespc, traitsClass, traitsValue) \
1110 using ::namespc::function; \
1111 template <class EXPR> \
1112 struct Functor_##function; \
1114 template <class EXPR> \
1115 struct ResultTraits0<Functor_##function<EXPR> > \
1117 typedef typename ResultTraits0<EXPR>::Res R1; \
1118 typedef typename traitsClass<R1>::traitsValue Res; \
1121 template <class EXPR, class T1> \
1122 struct ResultTraits1<Functor_##function<EXPR>, T1> \
1124 typedef typename ResultTraits1<EXPR, T1>::Res R1; \
1125 typedef typename traitsClass<R1>::traitsValue Res; \
1128 template <class EXPR, class T1, class T2> \
1129 struct ResultTraits2<Functor_##function<EXPR>, T1, T2> \
1131 typedef typename ResultTraits2<EXPR, T1, T2>::Res R1; \
1132 typedef typename traitsClass<R1>::traitsValue Res; \
1135 template <class EXPR, class T1, class T2, class T3> \
1136 struct ResultTraits3<Functor_##function<EXPR>, T1, T2, T3> \
1138 typedef typename ResultTraits3<EXPR, T1, T2, T3>::Res R1; \
1139 typedef typename traitsClass<R1>::traitsValue Res; \
1142 template <class EXPR> \
1143 struct Functor_##function \
1145 Functor_##function(EXPR const & e) \
1149 typename ResultTraits0<Functor_##function>::Res \
1150 operator()() const \
1152 return function(expr_()); \
1155 template <class T> \
1156 typename ResultTraits1<Functor_##function, T>::Res \
1157 operator()(T const & v1) const \
1159 return function(expr_(v1)); \
1162 template <class T1, class T2> \
1163 typename ResultTraits2<Functor_##function, T1, T2>::Res \
1164 operator()(T1 const & v1, T2 const & v2) const \
1166 return function(expr_(v1, v2)); \
1169 template <class T1, class T2, class T3> \
1170 typename ResultTraits3<Functor_##function, T1, T2, T3>::Res \
1171 operator()(T1 const & v1, T2 const & v2, T3 const & v3) const \
1173 return function(expr_(v1, v2, v3)); \
1181 Functor_##function & operator=(Functor_##function const &); \
1184 template <class EXPR> \
1185 inline UnaryFunctor<Functor_##function<UnaryFunctor<EXPR> > > \
1186 function(UnaryFunctor<EXPR> const & e) \
1188 Functor_##function<UnaryFunctor<EXPR> > p(e); \
1189 return UnaryFunctor<Functor_##function<UnaryFunctor<EXPR> > >(p); \
1194 MAKE_FUNCTOR_UNARY_FUNCTION(
sq, vigra, NumericTraits, RealPromote)
1195 MAKE_FUNCTOR_UNARY_FUNCTION(
sqrt, std, NumericTraits, RealPromote)
1196 MAKE_FUNCTOR_UNARY_FUNCTION(
exp, std, NumericTraits, RealPromote)
1197 MAKE_FUNCTOR_UNARY_FUNCTION(
log, std, NumericTraits, RealPromote)
1198 MAKE_FUNCTOR_UNARY_FUNCTION(
log10, std, NumericTraits, RealPromote)
1199 MAKE_FUNCTOR_UNARY_FUNCTION(
sin, std, NumericTraits, RealPromote)
1200 MAKE_FUNCTOR_UNARY_FUNCTION(
asin, std, NumericTraits, RealPromote)
1201 MAKE_FUNCTOR_UNARY_FUNCTION(
cos, std, NumericTraits, RealPromote)
1202 MAKE_FUNCTOR_UNARY_FUNCTION(
acos, std, NumericTraits, RealPromote)
1203 MAKE_FUNCTOR_UNARY_FUNCTION(
tan, std, NumericTraits, RealPromote)
1204 MAKE_FUNCTOR_UNARY_FUNCTION(
atan, std, NumericTraits, RealPromote)
1205 MAKE_FUNCTOR_UNARY_FUNCTION(
floor, std, NumericTraits, RealPromote)
1206 MAKE_FUNCTOR_UNARY_FUNCTION(
ceil, std, NumericTraits, RealPromote)
1207 MAKE_FUNCTOR_UNARY_FUNCTION(
abs, vigra, NumericTraits, RealPromote)
1208 MAKE_FUNCTOR_UNARY_FUNCTION(
norm, vigra, NormTraits, NormType)
1209 MAKE_FUNCTOR_UNARY_FUNCTION(
squaredNorm, vigra, NormTraits, SquaredNormType)
1211 #undef MAKE_FUNCTOR_UNARY_FUNCTION
1219 #define MAKE_FUNCTOR_UNARY_OPERATOR(name, op) \
1220 template <class EXPR> \
1221 struct Functor_##name; \
1223 template <class EXPR> \
1224 struct ResultTraits0<Functor_##name<EXPR> > \
1226 typedef typename ResultTraits0<EXPR>::Res Res; \
1229 template <class EXPR, class T1> \
1230 struct ResultTraits1<Functor_##name<EXPR>, T1> \
1232 typedef typename ResultTraits1<EXPR, T1>::Res Res; \
1235 template <class EXPR, class T1, class T2> \
1236 struct ResultTraits2<Functor_##name<EXPR>, T1, T2> \
1238 typedef typename ResultTraits2<EXPR, T1, T2>::Res Res; \
1241 template <class EXPR, class T1, class T2, class T3> \
1242 struct ResultTraits3<Functor_##name<EXPR>, T1, T2, T3> \
1244 typedef typename ResultTraits3<EXPR, T1, T2, T3>::Res Res; \
1247 template <class EXPR> \
1248 struct Functor_##name \
1250 Functor_##name(EXPR const & e) \
1254 typename ResultTraits0<Functor_##name>::Res \
1255 operator()() const \
1257 return op expr_(); \
1260 template <class T> \
1261 typename ResultTraits1<Functor_##name, T>::Res \
1262 operator()(T const & v1) const \
1264 return op expr_(v1); \
1267 template <class T1, class T2> \
1268 typename ResultTraits2<Functor_##name, T1, T2>::Res \
1269 operator()(T1 const & v1, T2 const & v2) const \
1271 return op expr_(v1, v2); \
1274 template <class T1, class T2, class T3> \
1275 typename ResultTraits3<Functor_##name, T1, T2, T3>::Res \
1276 operator()(T1 const & v1, T2 const & v2, T3 const & v3) const \
1278 return op expr_(v1, v2, v3); \
1285 Functor_##name & operator=(Functor_##name const &);\
1288 template <class EXPR> \
1289 inline UnaryFunctor<Functor_##name<UnaryFunctor<EXPR> > > \
1290 operator op(UnaryFunctor<EXPR> const & e) \
1292 Functor_##name<UnaryFunctor<EXPR> > p(e); \
1293 return UnaryFunctor<Functor_##name<UnaryFunctor<EXPR> > >(p); \
1299 MAKE_FUNCTOR_UNARY_OPERATOR(minus, -)
1300 MAKE_FUNCTOR_UNARY_OPERATOR(negate, !)
1301 MAKE_FUNCTOR_UNARY_OPERATOR(bitNegate, ~)
1303 #undef MAKE_FUNCTOR_UNARY_OPERATOR
1311 #define MAKE_FUNCTOR_BINARY_FUNCTION(function) \
1312 using std::function; \
1313 template <class EXPR1, class EXPR2> \
1314 struct Functor_##function; \
1316 template <class EXPR1, class EXPR2> \
1317 struct ResultTraits0<Functor_##function<EXPR1, EXPR2> > \
1319 typedef typename ResultTraits0<EXPR1>::Res R1; \
1320 typedef typename ResultTraits0<EXPR2>::Res R2; \
1321 typedef typename PromoteTraits<R1, R2>::Promote R3; \
1322 typedef typename NumericTraits<R3>::RealPromote Res; \
1325 template <class EXPR1, class EXPR2, class T1> \
1326 struct ResultTraits1<Functor_##function<EXPR1, EXPR2>, T1> \
1328 typedef typename ResultTraits1<EXPR1, T1>::Res R1; \
1329 typedef typename ResultTraits1<EXPR2, T1>::Res R2; \
1330 typedef typename PromoteTraits<R1, R2>::Promote R3; \
1331 typedef typename NumericTraits<R3>::RealPromote Res; \
1334 template <class EXPR1, class EXPR2, class T1, class T2> \
1335 struct ResultTraits2<Functor_##function<EXPR1, EXPR2>, T1, T2> \
1337 typedef typename ResultTraits2<EXPR1, T1, T2>::Res R1; \
1338 typedef typename ResultTraits2<EXPR2, T1, T2>::Res R2; \
1339 typedef typename PromoteTraits<R1, R2>::Promote R3; \
1340 typedef typename NumericTraits<R3>::RealPromote Res; \
1343 template <class EXPR1, class EXPR2, class T1, class T2, class T3> \
1344 struct ResultTraits3<Functor_##function<EXPR1, EXPR2>, T1, T2, T3> \
1346 typedef typename ResultTraits3<EXPR1, T1, T2, T3>::Res R1; \
1347 typedef typename ResultTraits3<EXPR2, T1, T2, T3>::Res R2; \
1348 typedef typename PromoteTraits<R1, R2>::Promote R3; \
1349 typedef typename NumericTraits<R3>::RealPromote Res; \
1352 template <class EXPR1, class EXPR2> \
1353 struct Functor_##function \
1355 Functor_##function(EXPR1 const & e1, EXPR2 const & e2) \
1356 : expr1_(e1), expr2_(e2) \
1359 typename ResultTraits0<Functor_##function>::Res \
1360 operator()() const \
1362 return function(expr1_(), expr2_()); \
1365 template <class T> \
1366 typename ResultTraits1<Functor_##function, T>::Res \
1367 operator()(T const & v1) const \
1369 return function(expr1_(v1), expr2_(v1)); \
1372 template <class T1, class T2> \
1373 typename ResultTraits2<Functor_##function, T1, T2>::Res \
1374 operator()(T1 const & v1, T2 const & v2) const \
1376 return function(expr1_(v1, v2), expr2_(v1, v2)); \
1379 template <class T1, class T2, class T3> \
1380 typename ResultTraits3<Functor_##function, T1, T2, T3>::Res \
1381 operator()(T1 const & v1, T2 const & v2, T3 const & v3) const \
1383 return function(expr1_(v1, v2, v3), expr2_(v1, v2, v3)); \
1391 Functor_##function & operator=(Functor_##function const &); \
1394 template <class EXPR1, class EXPR2> \
1395 inline UnaryFunctor<Functor_##function<UnaryFunctor<EXPR1>, UnaryFunctor<EXPR2> > > \
1396 function(UnaryFunctor<EXPR1> const & e1, UnaryFunctor<EXPR2> const & e2) \
1398 Functor_##function<UnaryFunctor<EXPR1>, UnaryFunctor<EXPR2> > p(e1, e2); \
1399 return UnaryFunctor<Functor_##function<UnaryFunctor<EXPR1>, \
1400 UnaryFunctor<EXPR2> > >(p); \
1405 MAKE_FUNCTOR_BINARY_FUNCTION(
pow)
1406 MAKE_FUNCTOR_BINARY_FUNCTION(
atan2)
1407 MAKE_FUNCTOR_BINARY_FUNCTION(fmod)
1409 #undef MAKE_FUNCTOR_BINARY_FUNCTION
1413 #define MAKE_FUNCTOR_MINMAX(name, op) \
1414 template <class EXPR1, class EXPR2> \
1415 struct Functor_##name; \
1417 template <class EXPR1, class EXPR2> \
1418 struct ResultTraits0<Functor_##name<EXPR1, EXPR2> > \
1420 typedef typename ResultTraits0<EXPR1>::Res R1; \
1421 typedef typename ResultTraits0<EXPR2>::Res R2; \
1422 typedef typename PromoteTraits<R1, R2>::Promote Res; \
1425 template <class EXPR1, class EXPR2, class T1> \
1426 struct ResultTraits1<Functor_##name<EXPR1, EXPR2>, T1> \
1428 typedef typename ResultTraits1<EXPR1, T1>::Res R1; \
1429 typedef typename ResultTraits1<EXPR2, T1>::Res R2; \
1430 typedef typename PromoteTraits<R1, R2>::Promote Res; \
1433 template <class EXPR1, class EXPR2, class T1, class T2> \
1434 struct ResultTraits2<Functor_##name<EXPR1, EXPR2>, T1, T2> \
1436 typedef typename ResultTraits2<EXPR1, T1, T2>::Res R1; \
1437 typedef typename ResultTraits2<EXPR2, T1, T2>::Res R2; \
1438 typedef typename PromoteTraits<R1, R2>::Promote Res; \
1441 template <class EXPR1, class EXPR2, class T1, class T2, class T3> \
1442 struct ResultTraits3<Functor_##name<EXPR1, EXPR2>, T1, T2, T3> \
1444 typedef typename ResultTraits3<EXPR1, T1, T2, T3>::Res R1; \
1445 typedef typename ResultTraits3<EXPR2, T1, T2, T3>::Res R2; \
1446 typedef typename PromoteTraits<R1, R2>::Promote Res; \
1449 template <class EXPR1, class EXPR2> \
1450 struct Functor_##name \
1452 Functor_##name(EXPR1 const & e1, EXPR2 const & e2) \
1453 : expr1_(e1), expr2_(e2) \
1456 typename ResultTraits0<Functor_##name>::Res \
1457 operator()() const \
1460 ResultTraits0<Functor_##name<EXPR1, EXPR2> >::R1 r1(expr1_()); \
1462 ResultTraits0<Functor_##name<EXPR1, EXPR2> >::R2 r2(expr2_()); \
1463 return (r1 op r2) ? r1 : r2; \
1466 template <class T> \
1467 typename ResultTraits1<Functor_##name, T>::Res \
1468 operator()(T const & v1) const \
1471 ResultTraits1<Functor_##name<EXPR1, EXPR2>, T>::R1 r1(expr1_(v1)); \
1473 ResultTraits1<Functor_##name<EXPR1, EXPR2>, T>::R2 r2(expr2_(v1)); \
1474 return (r1 op r2) ? r1 : r2; \
1477 template <class T1, class T2> \
1478 typename ResultTraits2<Functor_##name, T1, T2>::Res \
1479 operator()(T1 const & v1, T2 const & v2) const \
1482 ResultTraits2<Functor_##name<EXPR1, EXPR2>, T1, T2>::R1 r1(expr1_(v1, v2)); \
1484 ResultTraits2<Functor_##name<EXPR1, EXPR2>, T1, T2>::R2 r2(expr2_(v1, v2)); \
1485 return (r1 op r2) ? r1 : r2; \
1488 template <class T1, class T2, class T3> \
1489 typename ResultTraits3<Functor_##name, T1, T2, T3>::Res \
1490 operator()(T1 const & v1, T2 const & v2, T3 const & v3) const \
1493 ResultTraits3<Functor_##name<EXPR1, EXPR2>, T1, T2, T3>::R1 r1(expr1_(v1, v2, v3)); \
1495 ResultTraits3<Functor_##name<EXPR1, EXPR2>, T1, T2, T3>::R2 r2(expr2_(v1, v2, v3)); \
1496 return (r1 op r2) ? r1 : r2; \
1504 Functor_##name & operator=(Functor_##name const &); \
1507 template <class EXPR1, class EXPR2> \
1508 inline UnaryFunctor<Functor_##name<UnaryFunctor<EXPR1>, UnaryFunctor<EXPR2> > > \
1509 name(UnaryFunctor<EXPR1> const & e1, UnaryFunctor<EXPR2> const & e2) \
1511 Functor_##name<UnaryFunctor<EXPR1>, UnaryFunctor<EXPR2> > p(e1, e2); \
1512 return UnaryFunctor<Functor_##name<UnaryFunctor<EXPR1>, \
1513 UnaryFunctor<EXPR2> > >(p); \
1516 MAKE_FUNCTOR_MINMAX(min, <)
1517 MAKE_FUNCTOR_MINMAX(max, >)
1519 #undef MAKE_FUNCTOR_MINMAX
1527 #define MAKE_FUNCTOR_BINARY_OPERATOR(name, op) \
1528 template <class EXPR1, class EXPR2> \
1529 struct Functor_##name; \
1531 template <class EXPR1, class EXPR2> \
1532 struct ResultTraits0<Functor_##name<EXPR1, EXPR2> > \
1534 typedef typename ResultTraits0<EXPR1>::Res R1; \
1535 typedef typename ResultTraits0<EXPR2>::Res R2; \
1536 typedef typename PromoteTraits<R1, R2>::Promote Res; \
1539 template <class EXPR1, class EXPR2, class T1> \
1540 struct ResultTraits1<Functor_##name<EXPR1, EXPR2>, T1> \
1542 typedef typename ResultTraits1<EXPR1, T1>::Res R1; \
1543 typedef typename ResultTraits1<EXPR2, T1>::Res R2; \
1544 typedef typename PromoteTraits<R1, R2>::Promote Res; \
1547 template <class EXPR1, class EXPR2, class T1, class T2> \
1548 struct ResultTraits2<Functor_##name<EXPR1, EXPR2>, T1, T2> \
1550 typedef typename ResultTraits2<EXPR1, T1, T2>::Res R1; \
1551 typedef typename ResultTraits2<EXPR2, T1, T2>::Res R2; \
1552 typedef typename PromoteTraits<R1, R2>::Promote Res; \
1555 template <class EXPR1, class EXPR2, class T1, class T2, class T3> \
1556 struct ResultTraits3<Functor_##name<EXPR1, EXPR2>, T1, T2, T3> \
1558 typedef typename ResultTraits3<EXPR1, T1, T2, T3>::Res R1; \
1559 typedef typename ResultTraits3<EXPR2, T1, T2, T3>::Res R2; \
1560 typedef typename PromoteTraits<R1, R2>::Promote Res; \
1563 template <class EXPR1, class EXPR2> \
1564 struct Functor_##name \
1566 Functor_##name(EXPR1 const & e1, EXPR2 const & e2) \
1567 : expr1_(e1), expr2_(e2) \
1570 typename ResultTraits0<Functor_##name>::Res \
1571 operator()() const \
1573 return expr1_() op expr2_(); \
1576 template <class T> \
1577 typename ResultTraits1<Functor_##name, T>::Res \
1578 operator()(T const & v1) const \
1580 return expr1_(v1) op expr2_(v1); \
1583 template <class T1, class T2> \
1584 typename ResultTraits2<Functor_##name, T1, T2>::Res \
1585 operator()(T1 const & v1, T2 const & v2) const \
1587 return expr1_(v1, v2) op expr2_(v1, v2); \
1590 template <class T1, class T2, class T3> \
1591 typename ResultTraits3<Functor_##name, T1, T2, T3>::Res \
1592 operator()(T1 const & v1, T2 const & v2, T3 const & v3) const \
1594 return expr1_(v1, v2, v3) op expr2_(v1, v2, v3); \
1602 Functor_##name & operator=(Functor_##name const &); \
1605 template <class EXPR1, class EXPR2> \
1606 inline UnaryFunctor<Functor_##name<UnaryFunctor<EXPR1>, UnaryFunctor<EXPR2> > > \
1607 operator op(UnaryFunctor<EXPR1> const & e1, UnaryFunctor<EXPR2> const & e2) \
1609 Functor_##name<UnaryFunctor<EXPR1>, UnaryFunctor<EXPR2> > p(e1, e2); \
1610 return UnaryFunctor<Functor_##name<UnaryFunctor<EXPR1>, \
1611 UnaryFunctor<EXPR2> > >(p); \
1616 MAKE_FUNCTOR_BINARY_OPERATOR(add, +)
1617 MAKE_FUNCTOR_BINARY_OPERATOR(subtract, -)
1618 MAKE_FUNCTOR_BINARY_OPERATOR(multiply, *)
1619 MAKE_FUNCTOR_BINARY_OPERATOR(divide, /)
1620 MAKE_FUNCTOR_BINARY_OPERATOR(modulo, %)
1621 MAKE_FUNCTOR_BINARY_OPERATOR(bitAnd, &)
1622 MAKE_FUNCTOR_BINARY_OPERATOR(bitOr, |)
1623 MAKE_FUNCTOR_BINARY_OPERATOR(bitXor, ^)
1625 #undef MAKE_FUNCTOR_BINARY_OPERATOR
1629 #define MAKE_FUNCTOR_BINARY_OPERATOR_BOOL(name, op) \
1630 template <class EXPR1, class EXPR2> \
1631 struct Functor_##name; \
1633 template <class EXPR1, class EXPR2> \
1634 struct ResultTraits0<Functor_##name<EXPR1, EXPR2> > \
1639 template <class EXPR1, class EXPR2, class T1> \
1640 struct ResultTraits1<Functor_##name<EXPR1, EXPR2>, T1> \
1645 template <class EXPR1, class EXPR2, class T1, class T2> \
1646 struct ResultTraits2<Functor_##name<EXPR1, EXPR2>, T1, T2> \
1651 template <class EXPR1, class EXPR2, class T1, class T2, class T3> \
1652 struct ResultTraits3<Functor_##name<EXPR1, EXPR2>, T1, T2, T3> \
1657 template <class EXPR1, class EXPR2> \
1658 struct Functor_##name \
1660 Functor_##name(EXPR1 const & e1, EXPR2 const & e2) \
1661 : expr1_(e1), expr2_(e2) \
1664 bool operator()() const \
1666 return expr1_() op expr2_(); \
1669 template <class T> \
1670 bool operator()(T const & v1) const \
1672 return expr1_(v1) op expr2_(v1); \
1675 template <class T1, class T2> \
1676 bool operator()(T1 const & v1, T2 const & v2) const \
1678 return expr1_(v1, v2) op expr2_(v1, v2); \
1681 template <class T1, class T2, class T3> \
1682 bool operator()(T1 const & v1, T2 const & v2, T3 const & v3) const \
1684 return expr1_(v1, v2, v3) op expr2_(v1, v2, v3); \
1692 Functor_##name & operator=(Functor_##name const &); \
1695 template <class EXPR1, class EXPR2> \
1696 inline UnaryFunctor<Functor_##name<UnaryFunctor<EXPR1>, UnaryFunctor<EXPR2> > > \
1697 operator op(UnaryFunctor<EXPR1> const & e1, UnaryFunctor<EXPR2> const & e2) \
1699 Functor_##name<UnaryFunctor<EXPR1>, UnaryFunctor<EXPR2> > p(e1, e2); \
1700 return UnaryFunctor<Functor_##name<UnaryFunctor<EXPR1>, \
1701 UnaryFunctor<EXPR2> > >(p); \
1706 MAKE_FUNCTOR_BINARY_OPERATOR_BOOL(equals, ==)
1707 MAKE_FUNCTOR_BINARY_OPERATOR_BOOL(differs, !=)
1708 MAKE_FUNCTOR_BINARY_OPERATOR_BOOL(less, <)
1709 MAKE_FUNCTOR_BINARY_OPERATOR_BOOL(lessEqual, <=)
1710 MAKE_FUNCTOR_BINARY_OPERATOR_BOOL(greater, >)
1711 MAKE_FUNCTOR_BINARY_OPERATOR_BOOL(greaterEqual, >=)
1712 MAKE_FUNCTOR_BINARY_OPERATOR_BOOL(and, &&)
1713 MAKE_FUNCTOR_BINARY_OPERATOR_BOOL(or, ||)
1715 #undef MAKE_FUNCTOR_BINARY_OPERATOR_BOOL
1723 template <
class EXPR,
class RES,
class ARG>
1724 struct UnaryFctPtrFunctor
1726 UnaryFctPtrFunctor(EXPR
const & e, RES (*fct)(ARG))
1730 RES operator()()
const
1736 RES operator()(T
const & v1)
const
1738 return f_(expr_(v1));
1741 template <
class T1,
class T2>
1742 RES operator()(T1
const & v1, T2
const & v2)
const
1744 return f_(expr_(v1, v2));
1747 template <
class T1,
class T2,
class T3>
1748 RES operator()(T1
const & v1, T2
const & v2, T3
const & v3)
const
1750 return f_(expr_(v1, v2, v3));
1758 UnaryFctPtrFunctor & operator=(UnaryFctPtrFunctor
const &);
1761 template <
class EXPR,
class RES,
class ARG>
1762 struct ResultTraits0<UnaryFctPtrFunctor<EXPR, RES, ARG> >
1767 template <
class EXPR,
class RES,
class ARG,
class T1>
1768 struct ResultTraits1<UnaryFctPtrFunctor<EXPR, RES, ARG>, T1>
1773 template <
class EXPR,
class RES,
class ARG,
class T1,
class T2>
1774 struct ResultTraits2<UnaryFctPtrFunctor<EXPR, RES, ARG>, T1, T2>
1779 template <
class EXPR,
class RES,
class ARG,
class T1,
class T2,
class T3>
1780 struct ResultTraits3<UnaryFctPtrFunctor<EXPR, RES, ARG>, T1, T2, T3>
1785 template <
class EXPR,
class RES,
class ARG>
1786 inline UnaryFunctor<UnaryFctPtrFunctor<UnaryFunctor<EXPR>, RES, ARG> >
1787 applyFct(RES (*f)(ARG), UnaryFunctor<EXPR>
const & e)
1789 UnaryFctPtrFunctor<UnaryFunctor<EXPR>, RES, ARG> p(e, f);
1790 return UnaryFunctor<UnaryFctPtrFunctor<UnaryFunctor<EXPR>, RES, ARG> >(p);
1799 template <
class EXPR1,
class EXPR2,
class RES,
class ARG1,
class ARG2>
1800 struct BinaryFctPtrFunctor
1802 BinaryFctPtrFunctor(EXPR1
const & e1, EXPR2
const & e2,
1803 RES (*f)(ARG1, ARG2))
1804 : expr1_(e1), expr2_(e2), f_(f)
1807 RES operator()()
const
1809 return f_(expr1_(), expr2_());
1813 RES operator()(T
const & v1)
const
1815 return f_(expr1_(v1), expr2_(v1));
1818 template <
class T1,
class T2>
1819 RES operator()(T1
const & v1, T2
const & v2)
const
1821 return f_(expr1_(v1, v2), expr2_(v1, v2));
1824 template <
class T1,
class T2,
class T3>
1825 RES operator()(T1
const & v1, T2
const & v2, T3
const & v3)
const
1827 return f_(expr1_(v1, v2, v3), expr2_(v1, v2, v3));
1834 RES (*f_)(ARG1, ARG2);
1837 BinaryFctPtrFunctor & operator=(BinaryFctPtrFunctor
const &);
1840 template <
class EXPR1,
class EXPR2,
class RES,
class ARG1,
class ARG2>
1841 struct ResultTraits0<BinaryFctPtrFunctor<EXPR1, EXPR2, RES, ARG1, ARG2> >
1846 template <
class EXPR1,
class EXPR2,
class RES,
class ARG1,
class ARG2,
1848 struct ResultTraits1<BinaryFctPtrFunctor<EXPR1, EXPR2, RES, ARG1, ARG2>, T1>
1853 template <
class EXPR1,
class EXPR2,
class RES,
class ARG1,
class ARG2,
1855 struct ResultTraits2<BinaryFctPtrFunctor<EXPR1, EXPR2, RES, ARG1, ARG2>, T1, T2>
1860 template <
class EXPR1,
class EXPR2,
class RES,
class ARG1,
class ARG2,
1861 class T1,
class T2,
class T3>
1862 struct ResultTraits3<BinaryFctPtrFunctor<EXPR1, EXPR2, RES, ARG1, ARG2>, T1, T2, T3>
1867 template <
class EXPR1,
class EXPR2,
class RES,
class ARG1,
class ARG2>
1868 inline UnaryFunctor<BinaryFctPtrFunctor<UnaryFunctor<EXPR1>,
1869 UnaryFunctor<EXPR2>,
1871 applyFct(RES (*f)(ARG1, ARG2), UnaryFunctor<EXPR1>
const & e1,
1872 UnaryFunctor<EXPR2>
const & e2)
1874 BinaryFctPtrFunctor<UnaryFunctor<EXPR1>,
1875 UnaryFunctor<EXPR2>,
1876 RES, ARG1, ARG2> p(e1, e2, f);
1877 return UnaryFunctor<BinaryFctPtrFunctor<UnaryFunctor<EXPR1>,
1878 UnaryFunctor<EXPR2>,
1879 RES, ARG1, ARG2> >(p);
1888 template <
class EXPR1,
class EXPR2>
1891 CommaFunctor(EXPR1
const & e1, EXPR2
const & e2)
1892 : expr1_(e1), expr2_(e2)
1895 typename ResultTraits0<EXPR2>::Res
1903 typename ResultTraits1<EXPR2, T>::Res
1904 operator()(T
const & v1)
const
1910 template <
class T1,
class T2>
1911 typename ResultTraits2<EXPR2, T1, T2>::Res
1912 operator()(T1
const & v1, T2
const & v2)
const
1915 return expr2_(v1, v2);
1918 template <
class T1,
class T2,
class T3>
1919 typename ResultTraits3<EXPR2, T1, T2, T3>::Res
1920 operator()(T1
const & v1, T2
const & v2, T3
const & v3)
const
1923 return expr2_(v1, v2, v3);
1932 CommaFunctor & operator=(CommaFunctor
const &);
1935 template <
class Expr1,
class Expr2>
1936 struct ResultTraits0<CommaFunctor<Expr1, Expr2> >
1938 typedef typename ResultTraits0<Expr2>::Res Res;
1941 template <
class Expr1,
class Expr2,
class T1>
1942 struct ResultTraits1<CommaFunctor<Expr1, Expr2>, T1>
1944 typedef typename ResultTraits1<Expr2, T1>::Res Res;
1947 template <
class Expr1,
class Expr2,
class T1,
class T2>
1948 struct ResultTraits2<CommaFunctor<Expr1, Expr2>, T1, T2>
1950 typedef typename ResultTraits2<Expr2, T1, T2>::Res Res;
1953 template <
class Expr1,
class Expr2,
class T1,
class T2,
class T3>
1954 struct ResultTraits3<CommaFunctor<Expr1, Expr2>, T1, T2, T3>
1956 typedef typename ResultTraits3<Expr2, T1, T2, T3>::Res Res;
1959 template <
class EXPR1,
class EXPR2>
1960 inline UnaryFunctor<CommaFunctor<UnaryAnalyser<EXPR1>,
1961 UnaryFunctor<EXPR2> > >
1962 operator,(UnaryAnalyser<EXPR1>
const & e1,
1963 UnaryFunctor<EXPR2>
const & e2)
1965 CommaFunctor<UnaryAnalyser<EXPR1>,
1966 UnaryFunctor<EXPR2> > p(e1, e2);
1967 return UnaryFunctor<CommaFunctor<UnaryAnalyser<EXPR1>,
1968 UnaryFunctor<EXPR2> > >(p);
1973 template <
class EXPR1,
class EXPR2>
1974 struct CommaAnalyser
1976 CommaAnalyser(EXPR1
const & e1, EXPR2
const & e2)
1977 : expr1_(e1), expr2_(e2)
1980 void operator()()
const
1987 void operator()(T
const & v1)
const
1993 template <
class T1,
class T2>
1994 void operator()(T1
const & v1, T2
const & v2)
const
2000 template <
class T1,
class T2,
class T3>
2001 void operator()(T1
const & v1, T2
const & v2, T3
const & v3)
const
2013 CommaAnalyser & operator=(CommaAnalyser
const &);
2016 template <
class EXPR1,
class EXPR2>
2017 inline UnaryAnalyser<CommaAnalyser<UnaryAnalyser<EXPR1>,
2018 UnaryAnalyser<EXPR2> > >
2019 operator,(UnaryAnalyser<EXPR1>
const & e1,
2020 UnaryAnalyser<EXPR2>
const & e2)
2022 CommaAnalyser<UnaryAnalyser<EXPR1>,
2023 UnaryAnalyser<EXPR2> > p(e1, e2);
2024 return UnaryAnalyser<CommaAnalyser<UnaryAnalyser<EXPR1>,
2025 UnaryAnalyser<EXPR2> > >(p);
2030 #if defined(__GNUC__) && __GNUC__ < 3
2031 using functor::Arg1;
2032 using functor::Arg2;
2033 using functor::Arg3;
2034 using functor::Param;
2038 class FunctorTraits<functor::UnaryFunctor<T> >
2039 :
public FunctorTraitsBase<functor::UnaryFunctor<T> >
2042 typedef VigraTrueType isInitializer;
2043 typedef VigraTrueType isUnaryFunctor;
2044 typedef VigraTrueType isBinaryFunctor;
2045 typedef VigraTrueType isTernaryFunctor;
2049 class FunctorTraits<functor::UnaryAnalyser<T> >
2050 :
public FunctorTraitsBase<functor::UnaryAnalyser<T> >
2053 typedef VigraTrueType isUnaryAnalyser;
2054 typedef VigraTrueType isBinaryAnalyser;
2055 typedef VigraTrueType isTernaryAnalyser;