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 &);
473 typedef UnaryFunctor<ArgumentFunctor1> Identity;
476 struct ResultTraits0<UnaryFunctor<ArgumentFunctor1> >
478 typedef ErrorType Res;
482 struct ResultTraits1<UnaryFunctor<ArgumentFunctor1>, T1>
487 template <
class T1,
class T2>
488 struct ResultTraits2<UnaryFunctor<ArgumentFunctor1>, T1, T2>
493 template <
class T1,
class T2,
class T3>
494 struct ResultTraits3<UnaryFunctor<ArgumentFunctor1>, T1, T2, T3>
502 UnaryFunctor<ArgumentFunctor1>
505 return UnaryFunctor<ArgumentFunctor1>();
511 struct UnaryFunctor<ArgumentFunctor2>
516 template <
class T1,
class T2>
517 T2
const & operator()(T1
const &, T2
const & v2)
const
522 template <
class T1,
class T2,
class T3>
523 T2
const & operator()(T1
const &, T2
const & v2, T3
const &)
const
529 UnaryFunctor & operator=(UnaryFunctor
const &);
533 struct ResultTraits0<UnaryFunctor<ArgumentFunctor2> >
535 typedef ErrorType Res;
539 struct ResultTraits1<UnaryFunctor<ArgumentFunctor2>, T1>
541 typedef ErrorType Res;
544 template <
class T1,
class T2>
545 struct ResultTraits2<UnaryFunctor<ArgumentFunctor2>, T1, T2>
550 template <
class T1,
class T2,
class T3>
551 struct ResultTraits3<UnaryFunctor<ArgumentFunctor2>, T1, T2, T3>
559 UnaryFunctor<ArgumentFunctor2>
562 return UnaryFunctor<ArgumentFunctor2>();
568 struct UnaryFunctor<ArgumentFunctor3>
573 template <
class T1,
class T2,
class T3>
574 T3
const & operator()(T1
const &, T2
const &, T3
const & v3)
const
580 UnaryFunctor & operator=(UnaryFunctor
const &);
584 struct ResultTraits0<UnaryFunctor<ArgumentFunctor3> >
586 typedef ErrorType Res;
590 struct ResultTraits1<UnaryFunctor<ArgumentFunctor3>, T1>
592 typedef ErrorType Res;
595 template <
class T1,
class T2>
596 struct ResultTraits2<UnaryFunctor<ArgumentFunctor3>, T1, T2>
598 typedef ErrorType Res;
601 template <
class T1,
class T2,
class T3>
602 struct ResultTraits3<UnaryFunctor<ArgumentFunctor3>, T1, T2, T3>
610 UnaryFunctor<ArgumentFunctor3>
613 return UnaryFunctor<ArgumentFunctor3>();
623 struct ParameterFunctor
625 ParameterFunctor(T v)
629 T
const & operator()()
const
635 T
const & operator()(U1
const &)
const
640 template <
class U1,
class U2>
641 T
const & operator()(U1
const &, U2
const &)
const
646 template <
class U1,
class U2,
class U3>
647 T
const & operator()(U1
const &, U2
const &, U3
const &)
const
656 ParameterFunctor & operator=(ParameterFunctor
const &);
660 struct ResultTraits0<ParameterFunctor<T> >
665 template <
class T,
class T1>
666 struct ResultTraits1<ParameterFunctor<T>, T1>
671 template <
class T,
class T1,
class T2>
672 struct ResultTraits2<ParameterFunctor<T>, T1, T2>
677 template <
class T,
class T1,
class T2,
class T3>
678 struct ResultTraits3<ParameterFunctor<T>, T1, T2, T3>
684 inline UnaryFunctor<ParameterFunctor<T> >
687 ParameterFunctor<T> fv(v);
688 return UnaryFunctor<ParameterFunctor<T> >(fv);
698 template <
class EXPR>
702 UnaryAnalyser(EXPR
const & e)
706 void operator()()
const
712 void operator()(T1
const & v)
const
717 template <
class T1,
class T2>
718 void operator()(T1
const & v1, T2
const & v2)
const
723 template <
class T1,
class T2,
class T3>
724 void operator()(T1
const & v1, T2
const & v2, T3
const & v3)
const
733 UnaryAnalyser & operator=(UnaryAnalyser
const &);
746 struct UnaryFunctor<VarFunctor<T> >;
750 #define MAKE_ASSIGNMENT_FUNCTOR(name, op) \
751 template <class V, class EXPR> \
752 struct AssignmentFunctor_##name \
754 AssignmentFunctor_##name(UnaryFunctor<VarFunctor<V> > v, \
755 UnaryFunctor<EXPR> const & e) \
756 : value_(v.value_), expr_(e) \
759 V & operator()() const \
761 const_cast<V &>(value_) op expr_(); \
762 return const_cast<V &>(value_); \
765 template <class T1> \
766 V & operator()(T1 const & v1) const \
768 const_cast<V &>(value_) op expr_(v1); \
769 return const_cast<V &>(value_); \
772 template <class T1, class T2> \
773 V & operator()(T1 const & v1, T2 const & v2) const \
775 const_cast<V &>(value_) op expr_(v1, v2); \
776 return const_cast<V &>(value_); \
779 template <class T1, class T2, class T3> \
780 V & operator()(T1 const & v1, T2 const & v2, T3 const & v3) const \
782 const_cast<V &>(value_) op expr_(v1, v2, v3); \
783 return const_cast<V &>(value_); \
788 UnaryFunctor<EXPR> expr_; \
790 AssignmentFunctor_##name & operator=(AssignmentFunctor_##name const &);\
795 MAKE_ASSIGNMENT_FUNCTOR(assign, =)
796 MAKE_ASSIGNMENT_FUNCTOR(
add, +=)
797 MAKE_ASSIGNMENT_FUNCTOR(subtract, -=)
798 MAKE_ASSIGNMENT_FUNCTOR(multiply, *=)
799 MAKE_ASSIGNMENT_FUNCTOR(divide, /=)
801 #undef MAKE_ASSIGNMENT_FUNCTOR
810 struct UnaryFunctor<VarFunctor<T> >
818 template <
class EXPR>
819 UnaryAnalyser< AssignmentFunctor_assign<T, UnaryFunctor<EXPR> > >
820 operator=(UnaryFunctor<EXPR>
const & e)
822 AssignmentFunctor_assign<T, UnaryFunctor<EXPR> > va(*
this, e);
823 return UnaryAnalyser< AssignmentFunctor_assign<T, UnaryFunctor<EXPR> > >(va);
826 template <
class EXPR>
827 UnaryAnalyser< AssignmentFunctor_add<T, UnaryFunctor<EXPR> > >
830 AssignmentFunctor_add<T, UnaryFunctor<EXPR> > va(*
this, e);
831 return UnaryAnalyser< AssignmentFunctor_add<T, UnaryFunctor<EXPR> > >(va);
834 template <
class EXPR>
835 UnaryAnalyser< AssignmentFunctor_subtract<T, UnaryFunctor<EXPR> > >
838 AssignmentFunctor_subtract<T, UnaryFunctor<EXPR> > va(*
this, e);
839 return UnaryAnalyser< AssignmentFunctor_subtract<T, UnaryFunctor<EXPR> > >(va);
842 template <
class EXPR>
843 UnaryAnalyser< AssignmentFunctor_multiply<T, UnaryFunctor<EXPR> > >
846 AssignmentFunctor_multiply<T, UnaryFunctor<EXPR> > va(*
this, e);
847 return UnaryAnalyser< AssignmentFunctor_multiply<T, UnaryFunctor<EXPR> > >(va);
850 template <
class EXPR>
851 UnaryAnalyser< AssignmentFunctor_divide<T, UnaryFunctor<EXPR> > >
854 AssignmentFunctor_divide<T, UnaryFunctor<EXPR> > va(*
this, e);
855 return UnaryAnalyser< AssignmentFunctor_divide<T, UnaryFunctor<EXPR> > >(va);
858 T
const & operator()()
const
864 T
const & operator()(U1
const &)
const
869 template <
class U1,
class U2>
870 T
const & operator()(U1
const &, U2
const &)
const
875 template <
class U1,
class U2,
class U3>
876 T
const & operator()(U1
const &, U2
const &, U3
const &)
const
884 UnaryFunctor & operator=(UnaryFunctor
const &);
888 struct ResultTraits0<UnaryFunctor<VarFunctor<T> > >
893 template <
class T,
class T1>
894 struct ResultTraits1<UnaryFunctor<VarFunctor<T> >, T1>
899 template <
class T,
class T1,
class T2>
900 struct ResultTraits2<UnaryFunctor<VarFunctor<T> >, T1, T2>
905 template <
class T,
class T1,
class T2,
class T3>
906 struct ResultTraits3<UnaryFunctor<VarFunctor<T> >, T1, T2, T3>
912 inline UnaryFunctor<VarFunctor<T> >
915 return UnaryFunctor<VarFunctor<T> >(v);
924 template <
class EXPR1,
class EXPR2>
929 IfThenFunctor(EXPR1
const & e1, EXPR2
const & e2)
930 : expr1_(e1), expr2_(e2)
933 void operator()()
const
935 if( expr1_() ) expr2_();
939 void operator()(T
const & v1)
const
941 if( expr1_(v1) ) expr2_(v1);
944 template <
class T1,
class T2>
945 void operator()(T1
const & v1, T2
const & v2)
const
947 if( expr1_(v1, v2) ) expr2_(v1, v2);
950 template <
class T1,
class T2,
class T3>
951 void operator()(T1
const & v1, T2
const & v2, T3
const & v3)
const
953 if( expr1_(v1, v2, v3) ) expr2_(v1, v2, v3);
962 IfThenFunctor & operator=(IfThenFunctor
const &);
965 template <
class EXPR1,
class EXPR2>
966 UnaryAnalyser<IfThenFunctor<UnaryFunctor<EXPR1>,
967 UnaryAnalyser<EXPR2> > >
968 ifThen(UnaryFunctor<EXPR1>
const & e1,
969 UnaryAnalyser<EXPR2>
const & e2)
971 IfThenFunctor<UnaryFunctor<EXPR1>,
972 UnaryAnalyser<EXPR2> > p(e1, e2);
973 return UnaryAnalyser<IfThenFunctor<UnaryFunctor<EXPR1>,
974 UnaryAnalyser<EXPR2> > >(p);
983 template <
class EXPR1,
class EXPR2,
class EXPR3>
984 struct IfThenElseFunctor;
986 template <
class EXPR1,
class EXPR2,
class EXPR3>
987 struct ResultTraits0<IfThenElseFunctor<EXPR1, EXPR2, EXPR3> >
989 typedef typename ResultTraits0<EXPR2>::Res R2;
990 typedef typename ResultTraits0<EXPR3>::Res R3;
991 typedef typename PromoteTraits<R2, R3>::Promote Res;
994 template <
class EXPR1,
class EXPR2,
class EXPR3,
class T1>
995 struct ResultTraits1<IfThenElseFunctor<EXPR1, EXPR2, EXPR3>, T1>
997 typedef typename ResultTraits1<EXPR2, T1>::Res R2;
998 typedef typename ResultTraits1<EXPR3, T1>::Res R3;
999 typedef typename PromoteTraits<R2, R3>::Promote Res;
1002 template <
class EXPR1,
class EXPR2,
class EXPR3,
class T1,
class T2>
1003 struct ResultTraits2<IfThenElseFunctor<EXPR1, EXPR2, EXPR3>, T1, T2>
1005 typedef typename ResultTraits2<EXPR2, T1, T2>::Res R2;
1006 typedef typename ResultTraits2<EXPR3, T1, T2>::Res R3;
1007 typedef typename PromoteTraits<R2, R3>::Promote Res;
1010 template <
class EXPR1,
class EXPR2,
class EXPR3,
class T1,
class T2,
class T3>
1011 struct ResultTraits3<IfThenElseFunctor<EXPR1, EXPR2, EXPR3>, T1, T2, T3>
1013 typedef typename ResultTraits3<EXPR2, T1, T2, T3>::Res R2;
1014 typedef typename ResultTraits3<EXPR3, T1, T2, T3>::Res R3;
1015 typedef typename PromoteTraits<R2, R3>::Promote Res;
1018 template <
class EXPR1,
class EXPR2,
class EXPR3>
1019 struct IfThenElseFunctor
1021 IfThenElseFunctor(EXPR1
const & e1, EXPR2
const & e2, EXPR3
const & e3)
1022 : expr1_(e1), expr2_(e2), expr3_(e3)
1025 typename ResultTraits0<IfThenElseFunctor>::Res
1030 return typename ResultTraits0<IfThenElseFunctor>::Res(expr2_());
1034 return typename ResultTraits0<IfThenElseFunctor>::Res(expr3_());
1039 typename ResultTraits1<IfThenElseFunctor, T>::Res
1040 operator()(T
const & v1)
const
1044 return typename ResultTraits1<IfThenElseFunctor, T>::Res(expr2_(v1));
1048 return typename ResultTraits1<IfThenElseFunctor, T>::Res(expr3_(v1));
1052 template <
class T1,
class T2>
1053 typename ResultTraits2<IfThenElseFunctor, T1, T2>::Res
1054 operator()(T1
const & v1, T2
const & v2)
const
1058 return typename ResultTraits2<IfThenElseFunctor, T1, T2>::Res(expr2_(v1, v2));
1062 return typename ResultTraits2<IfThenElseFunctor, T1, T2>::Res(expr3_(v1, v2));
1066 template <
class T1,
class T2,
class T3>
1067 typename ResultTraits3<IfThenElseFunctor, T1, T2, T3>::Res
1068 operator()(T1
const & v1, T2
const & v2, T3
const & v3)
const
1070 if(expr1_(v1, v2, v3))
1072 return typename ResultTraits3<IfThenElseFunctor, T1, T2, T3>::Res(expr2_(v1, v2, v3));
1076 return typename ResultTraits3<IfThenElseFunctor, T1, T2, T3>::Res(expr3_(v1, v2, v3));
1086 IfThenElseFunctor & operator=(IfThenElseFunctor
const &);
1089 template <
class EXPR1,
class EXPR2,
class EXPR3>
1090 UnaryFunctor<IfThenElseFunctor<UnaryFunctor<EXPR1>,
1091 UnaryFunctor<EXPR2>,
1092 UnaryFunctor<EXPR3> > >
1093 ifThenElse(UnaryFunctor<EXPR1>
const & e1,
1094 UnaryFunctor<EXPR2>
const & e2,
1095 UnaryFunctor<EXPR3>
const & e3)
1097 IfThenElseFunctor<UnaryFunctor<EXPR1>,
1098 UnaryFunctor<EXPR2>,
1099 UnaryFunctor<EXPR3> > p(e1, e2, e3);
1100 return UnaryFunctor<IfThenElseFunctor<UnaryFunctor<EXPR1>,
1101 UnaryFunctor<EXPR2>,
1102 UnaryFunctor<EXPR3> > >(p);
1111 #define MAKE_FUNCTOR_UNARY_FUNCTION(function, namespc, traitsClass, traitsValue) \
1112 using ::namespc::function; \
1113 template <class EXPR> \
1114 struct Functor_##function; \
1116 template <class EXPR> \
1117 struct ResultTraits0<Functor_##function<EXPR> > \
1119 typedef typename ResultTraits0<EXPR>::Res R1; \
1120 typedef typename traitsClass<R1>::traitsValue Res; \
1123 template <class EXPR, class T1> \
1124 struct ResultTraits1<Functor_##function<EXPR>, T1> \
1126 typedef typename ResultTraits1<EXPR, T1>::Res R1; \
1127 typedef typename traitsClass<R1>::traitsValue Res; \
1130 template <class EXPR, class T1, class T2> \
1131 struct ResultTraits2<Functor_##function<EXPR>, T1, T2> \
1133 typedef typename ResultTraits2<EXPR, T1, T2>::Res R1; \
1134 typedef typename traitsClass<R1>::traitsValue Res; \
1137 template <class EXPR, class T1, class T2, class T3> \
1138 struct ResultTraits3<Functor_##function<EXPR>, T1, T2, T3> \
1140 typedef typename ResultTraits3<EXPR, T1, T2, T3>::Res R1; \
1141 typedef typename traitsClass<R1>::traitsValue Res; \
1144 template <class EXPR> \
1145 struct Functor_##function \
1147 Functor_##function(EXPR const & e) \
1151 typename ResultTraits0<Functor_##function>::Res \
1152 operator()() const \
1154 return function(expr_()); \
1157 template <class T> \
1158 typename ResultTraits1<Functor_##function, T>::Res \
1159 operator()(T const & v1) const \
1161 return function(expr_(v1)); \
1164 template <class T1, class T2> \
1165 typename ResultTraits2<Functor_##function, T1, T2>::Res \
1166 operator()(T1 const & v1, T2 const & v2) const \
1168 return function(expr_(v1, v2)); \
1171 template <class T1, class T2, class T3> \
1172 typename ResultTraits3<Functor_##function, T1, T2, T3>::Res \
1173 operator()(T1 const & v1, T2 const & v2, T3 const & v3) const \
1175 return function(expr_(v1, v2, v3)); \
1183 Functor_##function & operator=(Functor_##function const &); \
1186 template <class EXPR> \
1187 inline UnaryFunctor<Functor_##function<UnaryFunctor<EXPR> > > \
1188 function(UnaryFunctor<EXPR> const & e) \
1190 Functor_##function<UnaryFunctor<EXPR> > p(e); \
1191 return UnaryFunctor<Functor_##function<UnaryFunctor<EXPR> > >(p); \
1196 MAKE_FUNCTOR_UNARY_FUNCTION(
sq, vigra, NumericTraits, RealPromote)
1197 MAKE_FUNCTOR_UNARY_FUNCTION(
sqrt, std, NumericTraits, RealPromote)
1198 MAKE_FUNCTOR_UNARY_FUNCTION(
exp, std, NumericTraits, RealPromote)
1199 MAKE_FUNCTOR_UNARY_FUNCTION(
log, std, NumericTraits, RealPromote)
1200 MAKE_FUNCTOR_UNARY_FUNCTION(
log10, std, NumericTraits, RealPromote)
1201 MAKE_FUNCTOR_UNARY_FUNCTION(
sin, std, NumericTraits, RealPromote)
1202 MAKE_FUNCTOR_UNARY_FUNCTION(
asin, std, NumericTraits, RealPromote)
1203 MAKE_FUNCTOR_UNARY_FUNCTION(
cos, std, NumericTraits, RealPromote)
1204 MAKE_FUNCTOR_UNARY_FUNCTION(
acos, std, NumericTraits, RealPromote)
1205 MAKE_FUNCTOR_UNARY_FUNCTION(
tan, std, NumericTraits, RealPromote)
1206 MAKE_FUNCTOR_UNARY_FUNCTION(
atan, std, NumericTraits, RealPromote)
1207 MAKE_FUNCTOR_UNARY_FUNCTION(
floor, std, NumericTraits, RealPromote)
1208 MAKE_FUNCTOR_UNARY_FUNCTION(
ceil, std, NumericTraits, RealPromote)
1209 MAKE_FUNCTOR_UNARY_FUNCTION(
abs, vigra, NumericTraits, RealPromote)
1210 MAKE_FUNCTOR_UNARY_FUNCTION(
norm, vigra, NormTraits, NormType)
1211 MAKE_FUNCTOR_UNARY_FUNCTION(
squaredNorm, vigra, NormTraits, SquaredNormType)
1213 #undef MAKE_FUNCTOR_UNARY_FUNCTION
1221 #define MAKE_FUNCTOR_UNARY_OPERATOR(name, op) \
1222 template <class EXPR> \
1223 struct Functor_##name; \
1225 template <class EXPR> \
1226 struct ResultTraits0<Functor_##name<EXPR> > \
1228 typedef typename ResultTraits0<EXPR>::Res Res; \
1231 template <class EXPR, class T1> \
1232 struct ResultTraits1<Functor_##name<EXPR>, T1> \
1234 typedef typename ResultTraits1<EXPR, T1>::Res Res; \
1237 template <class EXPR, class T1, class T2> \
1238 struct ResultTraits2<Functor_##name<EXPR>, T1, T2> \
1240 typedef typename ResultTraits2<EXPR, T1, T2>::Res Res; \
1243 template <class EXPR, class T1, class T2, class T3> \
1244 struct ResultTraits3<Functor_##name<EXPR>, T1, T2, T3> \
1246 typedef typename ResultTraits3<EXPR, T1, T2, T3>::Res Res; \
1249 template <class EXPR> \
1250 struct Functor_##name \
1252 Functor_##name(EXPR const & e) \
1256 typename ResultTraits0<Functor_##name>::Res \
1257 operator()() const \
1259 return op expr_(); \
1262 template <class T> \
1263 typename ResultTraits1<Functor_##name, T>::Res \
1264 operator()(T const & v1) const \
1266 return op expr_(v1); \
1269 template <class T1, class T2> \
1270 typename ResultTraits2<Functor_##name, T1, T2>::Res \
1271 operator()(T1 const & v1, T2 const & v2) const \
1273 return op expr_(v1, v2); \
1276 template <class T1, class T2, class T3> \
1277 typename ResultTraits3<Functor_##name, T1, T2, T3>::Res \
1278 operator()(T1 const & v1, T2 const & v2, T3 const & v3) const \
1280 return op expr_(v1, v2, v3); \
1287 Functor_##name & operator=(Functor_##name const &);\
1290 template <class EXPR> \
1291 inline UnaryFunctor<Functor_##name<UnaryFunctor<EXPR> > > \
1292 operator op(UnaryFunctor<EXPR> const & e) \
1294 Functor_##name<UnaryFunctor<EXPR> > p(e); \
1295 return UnaryFunctor<Functor_##name<UnaryFunctor<EXPR> > >(p); \
1301 MAKE_FUNCTOR_UNARY_OPERATOR(minus, -)
1302 MAKE_FUNCTOR_UNARY_OPERATOR(negate, !)
1303 MAKE_FUNCTOR_UNARY_OPERATOR(bitNegate, ~)
1305 #undef MAKE_FUNCTOR_UNARY_OPERATOR
1313 #define MAKE_FUNCTOR_BINARY_FUNCTION(function) \
1314 using std::function; \
1315 template <class EXPR1, class EXPR2> \
1316 struct Functor_##function; \
1318 template <class EXPR1, class EXPR2> \
1319 struct ResultTraits0<Functor_##function<EXPR1, EXPR2> > \
1321 typedef typename ResultTraits0<EXPR1>::Res R1; \
1322 typedef typename ResultTraits0<EXPR2>::Res R2; \
1323 typedef typename PromoteTraits<R1, R2>::Promote R3; \
1324 typedef typename NumericTraits<R3>::RealPromote Res; \
1327 template <class EXPR1, class EXPR2, class T1> \
1328 struct ResultTraits1<Functor_##function<EXPR1, EXPR2>, T1> \
1330 typedef typename ResultTraits1<EXPR1, T1>::Res R1; \
1331 typedef typename ResultTraits1<EXPR2, T1>::Res R2; \
1332 typedef typename PromoteTraits<R1, R2>::Promote R3; \
1333 typedef typename NumericTraits<R3>::RealPromote Res; \
1336 template <class EXPR1, class EXPR2, class T1, class T2> \
1337 struct ResultTraits2<Functor_##function<EXPR1, EXPR2>, T1, T2> \
1339 typedef typename ResultTraits2<EXPR1, T1, T2>::Res R1; \
1340 typedef typename ResultTraits2<EXPR2, T1, T2>::Res R2; \
1341 typedef typename PromoteTraits<R1, R2>::Promote R3; \
1342 typedef typename NumericTraits<R3>::RealPromote Res; \
1345 template <class EXPR1, class EXPR2, class T1, class T2, class T3> \
1346 struct ResultTraits3<Functor_##function<EXPR1, EXPR2>, T1, T2, T3> \
1348 typedef typename ResultTraits3<EXPR1, T1, T2, T3>::Res R1; \
1349 typedef typename ResultTraits3<EXPR2, T1, T2, T3>::Res R2; \
1350 typedef typename PromoteTraits<R1, R2>::Promote R3; \
1351 typedef typename NumericTraits<R3>::RealPromote Res; \
1354 template <class EXPR1, class EXPR2> \
1355 struct Functor_##function \
1357 Functor_##function(EXPR1 const & e1, EXPR2 const & e2) \
1358 : expr1_(e1), expr2_(e2) \
1361 typename ResultTraits0<Functor_##function>::Res \
1362 operator()() const \
1364 return function(expr1_(), expr2_()); \
1367 template <class T> \
1368 typename ResultTraits1<Functor_##function, T>::Res \
1369 operator()(T const & v1) const \
1371 return function(expr1_(v1), expr2_(v1)); \
1374 template <class T1, class T2> \
1375 typename ResultTraits2<Functor_##function, T1, T2>::Res \
1376 operator()(T1 const & v1, T2 const & v2) const \
1378 return function(expr1_(v1, v2), expr2_(v1, v2)); \
1381 template <class T1, class T2, class T3> \
1382 typename ResultTraits3<Functor_##function, T1, T2, T3>::Res \
1383 operator()(T1 const & v1, T2 const & v2, T3 const & v3) const \
1385 return function(expr1_(v1, v2, v3), expr2_(v1, v2, v3)); \
1393 Functor_##function & operator=(Functor_##function const &); \
1396 template <class EXPR1, class EXPR2> \
1397 inline UnaryFunctor<Functor_##function<UnaryFunctor<EXPR1>, UnaryFunctor<EXPR2> > > \
1398 function(UnaryFunctor<EXPR1> const & e1, UnaryFunctor<EXPR2> const & e2) \
1400 Functor_##function<UnaryFunctor<EXPR1>, UnaryFunctor<EXPR2> > p(e1, e2); \
1401 return UnaryFunctor<Functor_##function<UnaryFunctor<EXPR1>, \
1402 UnaryFunctor<EXPR2> > >(p); \
1407 MAKE_FUNCTOR_BINARY_FUNCTION(pow)
1408 MAKE_FUNCTOR_BINARY_FUNCTION(
atan2)
1409 MAKE_FUNCTOR_BINARY_FUNCTION(fmod)
1411 #undef MAKE_FUNCTOR_BINARY_FUNCTION
1415 #define MAKE_FUNCTOR_MINMAX(name, op) \
1416 template <class EXPR1, class EXPR2> \
1417 struct Functor_##name; \
1419 template <class EXPR1, class EXPR2> \
1420 struct ResultTraits0<Functor_##name<EXPR1, EXPR2> > \
1422 typedef typename ResultTraits0<EXPR1>::Res R1; \
1423 typedef typename ResultTraits0<EXPR2>::Res R2; \
1424 typedef typename PromoteTraits<R1, R2>::Promote Res; \
1427 template <class EXPR1, class EXPR2, class T1> \
1428 struct ResultTraits1<Functor_##name<EXPR1, EXPR2>, T1> \
1430 typedef typename ResultTraits1<EXPR1, T1>::Res R1; \
1431 typedef typename ResultTraits1<EXPR2, T1>::Res R2; \
1432 typedef typename PromoteTraits<R1, R2>::Promote Res; \
1435 template <class EXPR1, class EXPR2, class T1, class T2> \
1436 struct ResultTraits2<Functor_##name<EXPR1, EXPR2>, T1, T2> \
1438 typedef typename ResultTraits2<EXPR1, T1, T2>::Res R1; \
1439 typedef typename ResultTraits2<EXPR2, T1, T2>::Res R2; \
1440 typedef typename PromoteTraits<R1, R2>::Promote Res; \
1443 template <class EXPR1, class EXPR2, class T1, class T2, class T3> \
1444 struct ResultTraits3<Functor_##name<EXPR1, EXPR2>, T1, T2, T3> \
1446 typedef typename ResultTraits3<EXPR1, T1, T2, T3>::Res R1; \
1447 typedef typename ResultTraits3<EXPR2, T1, T2, T3>::Res R2; \
1448 typedef typename PromoteTraits<R1, R2>::Promote Res; \
1451 template <class EXPR1, class EXPR2> \
1452 struct Functor_##name \
1454 Functor_##name(EXPR1 const & e1, EXPR2 const & e2) \
1455 : expr1_(e1), expr2_(e2) \
1458 typename ResultTraits0<Functor_##name>::Res \
1459 operator()() const \
1462 ResultTraits0<Functor_##name<EXPR1, EXPR2> >::R1 r1(expr1_()); \
1464 ResultTraits0<Functor_##name<EXPR1, EXPR2> >::R2 r2(expr2_()); \
1465 return (r1 op r2) ? r1 : r2; \
1468 template <class T> \
1469 typename ResultTraits1<Functor_##name, T>::Res \
1470 operator()(T const & v1) const \
1473 ResultTraits1<Functor_##name<EXPR1, EXPR2>, T>::R1 r1(expr1_(v1)); \
1475 ResultTraits1<Functor_##name<EXPR1, EXPR2>, T>::R2 r2(expr2_(v1)); \
1476 return (r1 op r2) ? r1 : r2; \
1479 template <class T1, class T2> \
1480 typename ResultTraits2<Functor_##name, T1, T2>::Res \
1481 operator()(T1 const & v1, T2 const & v2) const \
1484 ResultTraits2<Functor_##name<EXPR1, EXPR2>, T1, T2>::R1 r1(expr1_(v1, v2)); \
1486 ResultTraits2<Functor_##name<EXPR1, EXPR2>, T1, T2>::R2 r2(expr2_(v1, v2)); \
1487 return (r1 op r2) ? r1 : r2; \
1490 template <class T1, class T2, class T3> \
1491 typename ResultTraits3<Functor_##name, T1, T2, T3>::Res \
1492 operator()(T1 const & v1, T2 const & v2, T3 const & v3) const \
1495 ResultTraits3<Functor_##name<EXPR1, EXPR2>, T1, T2, T3>::R1 r1(expr1_(v1, v2, v3)); \
1497 ResultTraits3<Functor_##name<EXPR1, EXPR2>, T1, T2, T3>::R2 r2(expr2_(v1, v2, v3)); \
1498 return (r1 op r2) ? r1 : r2; \
1506 Functor_##name & operator=(Functor_##name const &); \
1509 template <class EXPR1, class EXPR2> \
1510 inline UnaryFunctor<Functor_##name<UnaryFunctor<EXPR1>, UnaryFunctor<EXPR2> > > \
1511 name(UnaryFunctor<EXPR1> const & e1, UnaryFunctor<EXPR2> const & e2) \
1513 Functor_##name<UnaryFunctor<EXPR1>, UnaryFunctor<EXPR2> > p(e1, e2); \
1514 return UnaryFunctor<Functor_##name<UnaryFunctor<EXPR1>, \
1515 UnaryFunctor<EXPR2> > >(p); \
1518 MAKE_FUNCTOR_MINMAX(
min, <)
1519 MAKE_FUNCTOR_MINMAX(
max, >)
1521 #undef MAKE_FUNCTOR_MINMAX
1529 #define MAKE_FUNCTOR_BINARY_OPERATOR(name, op) \
1530 template <class EXPR1, class EXPR2> \
1531 struct Functor_##name; \
1533 template <class EXPR1, class EXPR2> \
1534 struct ResultTraits0<Functor_##name<EXPR1, EXPR2> > \
1536 typedef typename ResultTraits0<EXPR1>::Res R1; \
1537 typedef typename ResultTraits0<EXPR2>::Res R2; \
1538 typedef typename PromoteTraits<R1, R2>::Promote Res; \
1541 template <class EXPR1, class EXPR2, class T1> \
1542 struct ResultTraits1<Functor_##name<EXPR1, EXPR2>, T1> \
1544 typedef typename ResultTraits1<EXPR1, T1>::Res R1; \
1545 typedef typename ResultTraits1<EXPR2, T1>::Res R2; \
1546 typedef typename PromoteTraits<R1, R2>::Promote Res; \
1549 template <class EXPR1, class EXPR2, class T1, class T2> \
1550 struct ResultTraits2<Functor_##name<EXPR1, EXPR2>, T1, T2> \
1552 typedef typename ResultTraits2<EXPR1, T1, T2>::Res R1; \
1553 typedef typename ResultTraits2<EXPR2, T1, T2>::Res R2; \
1554 typedef typename PromoteTraits<R1, R2>::Promote Res; \
1557 template <class EXPR1, class EXPR2, class T1, class T2, class T3> \
1558 struct ResultTraits3<Functor_##name<EXPR1, EXPR2>, T1, T2, T3> \
1560 typedef typename ResultTraits3<EXPR1, T1, T2, T3>::Res R1; \
1561 typedef typename ResultTraits3<EXPR2, T1, T2, T3>::Res R2; \
1562 typedef typename PromoteTraits<R1, R2>::Promote Res; \
1565 template <class EXPR1, class EXPR2> \
1566 struct Functor_##name \
1568 Functor_##name(EXPR1 const & e1, EXPR2 const & e2) \
1569 : expr1_(e1), expr2_(e2) \
1572 typename ResultTraits0<Functor_##name>::Res \
1573 operator()() const \
1575 return expr1_() op expr2_(); \
1578 template <class T> \
1579 typename ResultTraits1<Functor_##name, T>::Res \
1580 operator()(T const & v1) const \
1582 return expr1_(v1) op expr2_(v1); \
1585 template <class T1, class T2> \
1586 typename ResultTraits2<Functor_##name, T1, T2>::Res \
1587 operator()(T1 const & v1, T2 const & v2) const \
1589 return expr1_(v1, v2) op expr2_(v1, v2); \
1592 template <class T1, class T2, class T3> \
1593 typename ResultTraits3<Functor_##name, T1, T2, T3>::Res \
1594 operator()(T1 const & v1, T2 const & v2, T3 const & v3) const \
1596 return expr1_(v1, v2, v3) op expr2_(v1, v2, v3); \
1604 Functor_##name & operator=(Functor_##name const &); \
1607 template <class EXPR1, class EXPR2> \
1608 inline UnaryFunctor<Functor_##name<UnaryFunctor<EXPR1>, UnaryFunctor<EXPR2> > > \
1609 operator op(UnaryFunctor<EXPR1> const & e1, UnaryFunctor<EXPR2> const & e2) \
1611 Functor_##name<UnaryFunctor<EXPR1>, UnaryFunctor<EXPR2> > p(e1, e2); \
1612 return UnaryFunctor<Functor_##name<UnaryFunctor<EXPR1>, \
1613 UnaryFunctor<EXPR2> > >(p); \
1618 MAKE_FUNCTOR_BINARY_OPERATOR(add, +)
1619 MAKE_FUNCTOR_BINARY_OPERATOR(subtract, -)
1620 MAKE_FUNCTOR_BINARY_OPERATOR(multiply, *)
1621 MAKE_FUNCTOR_BINARY_OPERATOR(divide, /)
1622 MAKE_FUNCTOR_BINARY_OPERATOR(modulo, %)
1623 MAKE_FUNCTOR_BINARY_OPERATOR(bitAnd, &)
1624 MAKE_FUNCTOR_BINARY_OPERATOR(bitOr, |)
1625 MAKE_FUNCTOR_BINARY_OPERATOR(bitXor, ^)
1627 #undef MAKE_FUNCTOR_BINARY_OPERATOR
1631 #define MAKE_FUNCTOR_BINARY_OPERATOR_BOOL(name, op) \
1632 template <class EXPR1, class EXPR2> \
1633 struct Functor_##name; \
1635 template <class EXPR1, class EXPR2> \
1636 struct ResultTraits0<Functor_##name<EXPR1, EXPR2> > \
1641 template <class EXPR1, class EXPR2, class T1> \
1642 struct ResultTraits1<Functor_##name<EXPR1, EXPR2>, T1> \
1647 template <class EXPR1, class EXPR2, class T1, class T2> \
1648 struct ResultTraits2<Functor_##name<EXPR1, EXPR2>, T1, T2> \
1653 template <class EXPR1, class EXPR2, class T1, class T2, class T3> \
1654 struct ResultTraits3<Functor_##name<EXPR1, EXPR2>, T1, T2, T3> \
1659 template <class EXPR1, class EXPR2> \
1660 struct Functor_##name \
1662 Functor_##name(EXPR1 const & e1, EXPR2 const & e2) \
1663 : expr1_(e1), expr2_(e2) \
1666 bool operator()() const \
1668 return expr1_() op expr2_(); \
1671 template <class T> \
1672 bool operator()(T const & v1) const \
1674 return expr1_(v1) op expr2_(v1); \
1677 template <class T1, class T2> \
1678 bool operator()(T1 const & v1, T2 const & v2) const \
1680 return expr1_(v1, v2) op expr2_(v1, v2); \
1683 template <class T1, class T2, class T3> \
1684 bool operator()(T1 const & v1, T2 const & v2, T3 const & v3) const \
1686 return expr1_(v1, v2, v3) op expr2_(v1, v2, v3); \
1694 Functor_##name & operator=(Functor_##name const &); \
1697 template <class EXPR1, class EXPR2> \
1698 inline UnaryFunctor<Functor_##name<UnaryFunctor<EXPR1>, UnaryFunctor<EXPR2> > > \
1699 operator op(UnaryFunctor<EXPR1> const & e1, UnaryFunctor<EXPR2> const & e2) \
1701 Functor_##name<UnaryFunctor<EXPR1>, UnaryFunctor<EXPR2> > p(e1, e2); \
1702 return UnaryFunctor<Functor_##name<UnaryFunctor<EXPR1>, \
1703 UnaryFunctor<EXPR2> > >(p); \
1708 MAKE_FUNCTOR_BINARY_OPERATOR_BOOL(equals, ==)
1709 MAKE_FUNCTOR_BINARY_OPERATOR_BOOL(differs, !=)
1710 MAKE_FUNCTOR_BINARY_OPERATOR_BOOL(less, <)
1711 MAKE_FUNCTOR_BINARY_OPERATOR_BOOL(lessEqual, <=)
1712 MAKE_FUNCTOR_BINARY_OPERATOR_BOOL(greater, >)
1713 MAKE_FUNCTOR_BINARY_OPERATOR_BOOL(greaterEqual, >=)
1714 MAKE_FUNCTOR_BINARY_OPERATOR_BOOL(and, &&)
1715 MAKE_FUNCTOR_BINARY_OPERATOR_BOOL(or, ||)
1717 #undef MAKE_FUNCTOR_BINARY_OPERATOR_BOOL
1725 template <
class EXPR,
class RES,
class ARG>
1726 struct UnaryFctPtrFunctor
1728 UnaryFctPtrFunctor(EXPR
const & e, RES (*fct)(ARG))
1732 RES operator()()
const
1738 RES operator()(T
const & v1)
const
1740 return f_(expr_(v1));
1743 template <
class T1,
class T2>
1744 RES operator()(T1
const & v1, T2
const & v2)
const
1746 return f_(expr_(v1, v2));
1749 template <
class T1,
class T2,
class T3>
1750 RES operator()(T1
const & v1, T2
const & v2, T3
const & v3)
const
1752 return f_(expr_(v1, v2, v3));
1760 UnaryFctPtrFunctor & operator=(UnaryFctPtrFunctor
const &);
1763 template <
class EXPR,
class RES,
class ARG>
1764 struct ResultTraits0<UnaryFctPtrFunctor<EXPR, RES, ARG> >
1769 template <
class EXPR,
class RES,
class ARG,
class T1>
1770 struct ResultTraits1<UnaryFctPtrFunctor<EXPR, RES, ARG>, T1>
1775 template <
class EXPR,
class RES,
class ARG,
class T1,
class T2>
1776 struct ResultTraits2<UnaryFctPtrFunctor<EXPR, RES, ARG>, T1, T2>
1781 template <
class EXPR,
class RES,
class ARG,
class T1,
class T2,
class T3>
1782 struct ResultTraits3<UnaryFctPtrFunctor<EXPR, RES, ARG>, T1, T2, T3>
1787 template <
class EXPR,
class RES,
class ARG>
1788 inline UnaryFunctor<UnaryFctPtrFunctor<UnaryFunctor<EXPR>, RES, ARG> >
1789 applyFct(RES (*f)(ARG), UnaryFunctor<EXPR>
const & e)
1791 UnaryFctPtrFunctor<UnaryFunctor<EXPR>, RES, ARG> p(e, f);
1792 return UnaryFunctor<UnaryFctPtrFunctor<UnaryFunctor<EXPR>, RES, ARG> >(p);
1801 template <
class EXPR1,
class EXPR2,
class RES,
class ARG1,
class ARG2>
1802 struct BinaryFctPtrFunctor
1804 BinaryFctPtrFunctor(EXPR1
const & e1, EXPR2
const & e2,
1805 RES (*f)(ARG1, ARG2))
1806 : expr1_(e1), expr2_(e2), f_(f)
1809 RES operator()()
const
1811 return f_(expr1_(), expr2_());
1815 RES operator()(T
const & v1)
const
1817 return f_(expr1_(v1), expr2_(v1));
1820 template <
class T1,
class T2>
1821 RES operator()(T1
const & v1, T2
const & v2)
const
1823 return f_(expr1_(v1, v2), expr2_(v1, v2));
1826 template <
class T1,
class T2,
class T3>
1827 RES operator()(T1
const & v1, T2
const & v2, T3
const & v3)
const
1829 return f_(expr1_(v1, v2, v3), expr2_(v1, v2, v3));
1836 RES (*f_)(ARG1, ARG2);
1839 BinaryFctPtrFunctor & operator=(BinaryFctPtrFunctor
const &);
1842 template <
class EXPR1,
class EXPR2,
class RES,
class ARG1,
class ARG2>
1843 struct ResultTraits0<BinaryFctPtrFunctor<EXPR1, EXPR2, RES, ARG1, ARG2> >
1848 template <
class EXPR1,
class EXPR2,
class RES,
class ARG1,
class ARG2,
1850 struct ResultTraits1<BinaryFctPtrFunctor<EXPR1, EXPR2, RES, ARG1, ARG2>, T1>
1855 template <
class EXPR1,
class EXPR2,
class RES,
class ARG1,
class ARG2,
1857 struct ResultTraits2<BinaryFctPtrFunctor<EXPR1, EXPR2, RES, ARG1, ARG2>, T1, T2>
1862 template <
class EXPR1,
class EXPR2,
class RES,
class ARG1,
class ARG2,
1863 class T1,
class T2,
class T3>
1864 struct ResultTraits3<BinaryFctPtrFunctor<EXPR1, EXPR2, RES, ARG1, ARG2>, T1, T2, T3>
1869 template <
class EXPR1,
class EXPR2,
class RES,
class ARG1,
class ARG2>
1870 inline UnaryFunctor<BinaryFctPtrFunctor<UnaryFunctor<EXPR1>,
1871 UnaryFunctor<EXPR2>,
1873 applyFct(RES (*f)(ARG1, ARG2), UnaryFunctor<EXPR1>
const & e1,
1874 UnaryFunctor<EXPR2>
const & e2)
1876 BinaryFctPtrFunctor<UnaryFunctor<EXPR1>,
1877 UnaryFunctor<EXPR2>,
1878 RES, ARG1, ARG2> p(e1, e2, f);
1879 return UnaryFunctor<BinaryFctPtrFunctor<UnaryFunctor<EXPR1>,
1880 UnaryFunctor<EXPR2>,
1881 RES, ARG1, ARG2> >(p);
1890 template <
class EXPR1,
class EXPR2>
1893 CommaFunctor(EXPR1
const & e1, EXPR2
const & e2)
1894 : expr1_(e1), expr2_(e2)
1897 typename ResultTraits0<EXPR2>::Res
1905 typename ResultTraits1<EXPR2, T>::Res
1906 operator()(T
const & v1)
const
1912 template <
class T1,
class T2>
1913 typename ResultTraits2<EXPR2, T1, T2>::Res
1914 operator()(T1
const & v1, T2
const & v2)
const
1917 return expr2_(v1, v2);
1920 template <
class T1,
class T2,
class T3>
1921 typename ResultTraits3<EXPR2, T1, T2, T3>::Res
1922 operator()(T1
const & v1, T2
const & v2, T3
const & v3)
const
1925 return expr2_(v1, v2, v3);
1934 CommaFunctor & operator=(CommaFunctor
const &);
1937 template <
class Expr1,
class Expr2>
1938 struct ResultTraits0<CommaFunctor<Expr1, Expr2> >
1940 typedef typename ResultTraits0<Expr2>::Res Res;
1943 template <
class Expr1,
class Expr2,
class T1>
1944 struct ResultTraits1<CommaFunctor<Expr1, Expr2>, T1>
1946 typedef typename ResultTraits1<Expr2, T1>::Res Res;
1949 template <
class Expr1,
class Expr2,
class T1,
class T2>
1950 struct ResultTraits2<CommaFunctor<Expr1, Expr2>, T1, T2>
1952 typedef typename ResultTraits2<Expr2, T1, T2>::Res Res;
1955 template <
class Expr1,
class Expr2,
class T1,
class T2,
class T3>
1956 struct ResultTraits3<CommaFunctor<Expr1, Expr2>, T1, T2, T3>
1958 typedef typename ResultTraits3<Expr2, T1, T2, T3>::Res Res;
1961 template <
class EXPR1,
class EXPR2>
1962 inline UnaryFunctor<CommaFunctor<UnaryAnalyser<EXPR1>,
1963 UnaryFunctor<EXPR2> > >
1964 operator,(UnaryAnalyser<EXPR1>
const & e1,
1965 UnaryFunctor<EXPR2>
const & e2)
1967 CommaFunctor<UnaryAnalyser<EXPR1>,
1968 UnaryFunctor<EXPR2> > p(e1, e2);
1969 return UnaryFunctor<CommaFunctor<UnaryAnalyser<EXPR1>,
1970 UnaryFunctor<EXPR2> > >(p);
1975 template <
class EXPR1,
class EXPR2>
1976 struct CommaAnalyser
1978 CommaAnalyser(EXPR1
const & e1, EXPR2
const & e2)
1979 : expr1_(e1), expr2_(e2)
1982 void operator()()
const
1989 void operator()(T
const & v1)
const
1995 template <
class T1,
class T2>
1996 void operator()(T1
const & v1, T2
const & v2)
const
2002 template <
class T1,
class T2,
class T3>
2003 void operator()(T1
const & v1, T2
const & v2, T3
const & v3)
const
2015 CommaAnalyser & operator=(CommaAnalyser
const &);
2018 template <
class EXPR1,
class EXPR2>
2019 inline UnaryAnalyser<CommaAnalyser<UnaryAnalyser<EXPR1>,
2020 UnaryAnalyser<EXPR2> > >
2021 operator,(UnaryAnalyser<EXPR1>
const & e1,
2022 UnaryAnalyser<EXPR2>
const & e2)
2024 CommaAnalyser<UnaryAnalyser<EXPR1>,
2025 UnaryAnalyser<EXPR2> > p(e1, e2);
2026 return UnaryAnalyser<CommaAnalyser<UnaryAnalyser<EXPR1>,
2027 UnaryAnalyser<EXPR2> > >(p);
2032 #if defined(__GNUC__) && __GNUC__ < 3
2033 using functor::Arg1;
2034 using functor::Arg2;
2035 using functor::Arg3;
2036 using functor::Param;
2040 class FunctorTraits<functor::UnaryFunctor<T> >
2041 :
public FunctorTraitsBase<functor::UnaryFunctor<T> >
2044 typedef VigraTrueType isInitializer;
2045 typedef VigraTrueType isUnaryFunctor;
2046 typedef VigraTrueType isBinaryFunctor;
2047 typedef VigraTrueType isTernaryFunctor;
2051 class FunctorTraits<functor::UnaryAnalyser<T> >
2052 :
public FunctorTraitsBase<functor::UnaryAnalyser<T> >
2055 typedef VigraTrueType isUnaryAnalyser;
2056 typedef VigraTrueType isBinaryAnalyser;
2057 typedef VigraTrueType isTernaryAnalyser;