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"
349template <
class Operation>
352template <
class Operation,
class T1>
358template <
class Operation,
class T1,
class T2>
361 typedef typename PromoteTraits<T1, T2>::Promote Res;
364template <
class Operation,
class T1,
class T2,
class T3>
367 typedef typename PromoteTraits<T1, T2>::Promote P1;
368 typedef typename PromoteTraits<P1, T3>::Promote Res;
374 UnaryFunctor(EXPR
const & e)
378 UnaryFunctor(UnaryFunctor
const &) =
default;
379 UnaryFunctor & operator=(UnaryFunctor
const &) =
delete;
380 UnaryFunctor(UnaryFunctor &&) =
default;
381 UnaryFunctor & operator=(UnaryFunctor &&) =
default;
383 typename ResultTraits0<EXPR>::Res
390 typename ResultTraits1<EXPR, T1>::Res
391 operator()(T1
const & v)
const
396 template <
class T1,
class T2>
397 typename ResultTraits2<EXPR, T1, T2>::Res
398 operator()(T1
const & v1, T2
const & v2)
const
400 return expr_(v1, v2);
403 template <
class T1,
class T2,
class T3>
404 typename ResultTraits3<EXPR, T1, T2, T3>::Res
405 operator()(T1
const & v1, T2
const & v2, T3
const & v3)
const
407 return expr_(v1, v2, v3);
415struct ResultTraits0<UnaryFunctor<Expr> >
417 typedef typename ResultTraits0<Expr>::Res Res;
420template <
class Expr,
class T1>
421struct ResultTraits1<UnaryFunctor<Expr>, T1>
423 typedef typename ResultTraits1<Expr, T1>::Res Res;
426template <
class Expr,
class T1,
class T2>
427struct ResultTraits2<UnaryFunctor<Expr>, T1, T2>
429 typedef typename ResultTraits2<Expr, T1, T2>::Res Res;
432template <
class Expr,
class T1,
class T2,
class T3>
433struct ResultTraits3<UnaryFunctor<Expr>, T1, T2, T3>
435 typedef typename ResultTraits3<Expr, T1, T2, T3>::Res Res;
444struct ArgumentFunctor1;
445struct ArgumentFunctor2;
446struct ArgumentFunctor3;
449struct UnaryFunctor<ArgumentFunctor1>
451 UnaryFunctor() =
default;
453 UnaryFunctor(UnaryFunctor
const &) =
default;
454 UnaryFunctor & operator=(UnaryFunctor
const &) =
delete;
455 UnaryFunctor(UnaryFunctor &&) =
default;
456 UnaryFunctor & operator=(UnaryFunctor &&) =
default;
459 T1
const & operator()(T1
const & v1)
const
464 template <
class T1,
class T2>
465 T1
const & operator()(T1
const & v1, T2
const &)
const
470 template <
class T1,
class T2,
class T3>
471 T1
const & operator()(T1
const & v1, T2
const &, T3
const &)
const
477typedef UnaryFunctor<ArgumentFunctor1> Identity;
480struct ResultTraits0<UnaryFunctor<ArgumentFunctor1> >
482 typedef ErrorType Res;
486struct ResultTraits1<UnaryFunctor<ArgumentFunctor1>, T1>
491template <
class T1,
class T2>
492struct ResultTraits2<UnaryFunctor<ArgumentFunctor1>, T1, T2>
497template <
class T1,
class T2,
class T3>
498struct ResultTraits3<UnaryFunctor<ArgumentFunctor1>, T1, T2, T3>
506UnaryFunctor<ArgumentFunctor1>
509 return UnaryFunctor<ArgumentFunctor1>();
515struct UnaryFunctor<ArgumentFunctor2>
517 UnaryFunctor() =
default;
519 UnaryFunctor(UnaryFunctor
const &) =
default;
520 UnaryFunctor & operator=(UnaryFunctor
const &) =
delete;
521 UnaryFunctor(UnaryFunctor &&) =
default;
522 UnaryFunctor & operator=(UnaryFunctor &&) =
default;
524 template <
class T1,
class T2>
525 T2
const & operator()(T1
const &, T2
const & v2)
const
530 template <
class T1,
class T2,
class T3>
531 T2
const & operator()(T1
const &, T2
const & v2, T3
const &)
const
538struct ResultTraits0<UnaryFunctor<ArgumentFunctor2> >
540 typedef ErrorType Res;
544struct ResultTraits1<UnaryFunctor<ArgumentFunctor2>, T1>
546 typedef ErrorType Res;
549template <
class T1,
class T2>
550struct ResultTraits2<UnaryFunctor<ArgumentFunctor2>, T1, T2>
555template <
class T1,
class T2,
class T3>
556struct ResultTraits3<UnaryFunctor<ArgumentFunctor2>, T1, T2, T3>
564UnaryFunctor<ArgumentFunctor2>
567 return UnaryFunctor<ArgumentFunctor2>();
573struct UnaryFunctor<ArgumentFunctor3>
575 UnaryFunctor() =
default;
577 UnaryFunctor(UnaryFunctor
const &) =
default;
578 UnaryFunctor & operator=(UnaryFunctor
const &) =
delete;
579 UnaryFunctor(UnaryFunctor &&) =
default;
580 UnaryFunctor & operator=(UnaryFunctor &&) =
default;
582 template <
class T1,
class T2,
class T3>
583 T3
const & operator()(T1
const &, T2
const &, T3
const & v3)
const
590struct ResultTraits0<UnaryFunctor<ArgumentFunctor3> >
592 typedef ErrorType Res;
596struct ResultTraits1<UnaryFunctor<ArgumentFunctor3>, T1>
598 typedef ErrorType Res;
601template <
class T1,
class T2>
602struct ResultTraits2<UnaryFunctor<ArgumentFunctor3>, T1, T2>
604 typedef ErrorType Res;
607template <
class T1,
class T2,
class T3>
608struct ResultTraits3<UnaryFunctor<ArgumentFunctor3>, T1, T2, T3>
616UnaryFunctor<ArgumentFunctor3>
619 return UnaryFunctor<ArgumentFunctor3>();
629struct ParameterFunctor
631 ParameterFunctor(T v)
635 ParameterFunctor(ParameterFunctor
const &) =
default;
636 ParameterFunctor & operator=(ParameterFunctor
const &) =
delete;
637 ParameterFunctor(ParameterFunctor &&) =
default;
638 ParameterFunctor & operator=(ParameterFunctor &&) =
default;
640 T
const & operator()()
const
646 T
const & operator()(U1
const &)
const
651 template <
class U1,
class U2>
652 T
const & operator()(U1
const &, U2
const &)
const
657 template <
class U1,
class U2,
class U3>
658 T
const & operator()(U1
const &, U2
const &, U3
const &)
const
668struct ResultTraits0<ParameterFunctor<T> >
673template <
class T,
class T1>
674struct ResultTraits1<ParameterFunctor<T>, T1>
679template <
class T,
class T1,
class T2>
680struct ResultTraits2<ParameterFunctor<T>, T1, T2>
685template <
class T,
class T1,
class T2,
class T3>
686struct ResultTraits3<ParameterFunctor<T>, T1, T2, T3>
692inline UnaryFunctor<ParameterFunctor<T> >
695 ParameterFunctor<T> fv(v);
696 return UnaryFunctor<ParameterFunctor<T> >(fv);
710 UnaryAnalyser(EXPR
const & e)
714 UnaryAnalyser(UnaryAnalyser
const &) =
default;
715 UnaryAnalyser & operator=(UnaryAnalyser
const &) =
delete;
716 UnaryAnalyser(UnaryAnalyser &&) =
default;
717 UnaryAnalyser & operator=(UnaryAnalyser &&) =
default;
719 void operator()()
const
725 void operator()(T1
const & v)
const
730 template <
class T1,
class T2>
731 void operator()(T1
const & v1, T2
const & v2)
const
736 template <
class T1,
class T2,
class T3>
737 void operator()(T1
const & v1, T2
const & v2, T3
const & v3)
const
756struct UnaryFunctor<VarFunctor<T> >;
760#define MAKE_ASSIGNMENT_FUNCTOR(name, op) \
761 template <class V, class EXPR> \
762 struct AssignmentFunctor_##name \
764 AssignmentFunctor_##name(UnaryFunctor<VarFunctor<V> > v, \
765 UnaryFunctor<EXPR> const & e) \
766 : value_(v.value_), expr_(e) \
769 AssignmentFunctor_##name(AssignmentFunctor_##name const &) = default;\
770 AssignmentFunctor_##name & operator=(AssignmentFunctor_##name const &) = delete;\
771 AssignmentFunctor_##name(AssignmentFunctor_##name &&) = default;\
772 AssignmentFunctor_##name & operator=(AssignmentFunctor_##name &&) = default;\
774 V & operator()() const \
776 const_cast<V &>(value_) op expr_(); \
777 return const_cast<V &>(value_); \
780 template <class T1> \
781 V & operator()(T1 const & v1) const \
783 const_cast<V &>(value_) op expr_(v1); \
784 return const_cast<V &>(value_); \
787 template <class T1, class T2> \
788 V & operator()(T1 const & v1, T2 const & v2) const \
790 const_cast<V &>(value_) op expr_(v1, v2); \
791 return const_cast<V &>(value_); \
794 template <class T1, class T2, class T3> \
795 V & operator()(T1 const & v1, T2 const & v2, T3 const & v3) const \
797 const_cast<V &>(value_) op expr_(v1, v2, v3); \
798 return const_cast<V &>(value_); \
803 UnaryFunctor<EXPR> expr_; \
808MAKE_ASSIGNMENT_FUNCTOR(assign, =)
809MAKE_ASSIGNMENT_FUNCTOR(
add, +=)
810MAKE_ASSIGNMENT_FUNCTOR(subtract, -=)
811MAKE_ASSIGNMENT_FUNCTOR(multiply, *=)
812MAKE_ASSIGNMENT_FUNCTOR(divide, /=)
814#undef MAKE_ASSIGNMENT_FUNCTOR
823struct UnaryFunctor<VarFunctor<T> >
831 UnaryFunctor(UnaryFunctor
const &) =
default;
832 UnaryFunctor & operator=(UnaryFunctor
const &) =
delete;
833 UnaryFunctor(UnaryFunctor &&) =
default;
834 UnaryFunctor & operator=(UnaryFunctor &&) =
default;
836 template <
class EXPR>
837 UnaryAnalyser< AssignmentFunctor_assign<T, UnaryFunctor<EXPR> > >
838 operator=(UnaryFunctor<EXPR>
const & e)
840 AssignmentFunctor_assign<T, UnaryFunctor<EXPR> > va(*
this, e);
841 return UnaryAnalyser< AssignmentFunctor_assign<T, UnaryFunctor<EXPR> > >(va);
844 template <
class EXPR>
845 UnaryAnalyser< AssignmentFunctor_add<T, UnaryFunctor<EXPR> > >
848 AssignmentFunctor_add<T, UnaryFunctor<EXPR> > va(*
this, e);
849 return UnaryAnalyser< AssignmentFunctor_add<T, UnaryFunctor<EXPR> > >(va);
852 template <
class EXPR>
853 UnaryAnalyser< AssignmentFunctor_subtract<T, UnaryFunctor<EXPR> > >
856 AssignmentFunctor_subtract<T, UnaryFunctor<EXPR> > va(*
this, e);
857 return UnaryAnalyser< AssignmentFunctor_subtract<T, UnaryFunctor<EXPR> > >(va);
860 template <
class EXPR>
861 UnaryAnalyser< AssignmentFunctor_multiply<T, UnaryFunctor<EXPR> > >
864 AssignmentFunctor_multiply<T, UnaryFunctor<EXPR> > va(*
this, e);
865 return UnaryAnalyser< AssignmentFunctor_multiply<T, UnaryFunctor<EXPR> > >(va);
868 template <
class EXPR>
869 UnaryAnalyser< AssignmentFunctor_divide<T, UnaryFunctor<EXPR> > >
872 AssignmentFunctor_divide<T, UnaryFunctor<EXPR> > va(*
this, e);
873 return UnaryAnalyser< AssignmentFunctor_divide<T, UnaryFunctor<EXPR> > >(va);
876 T
const & operator()()
const
882 T
const & operator()(U1
const &)
const
887 template <
class U1,
class U2>
888 T
const & operator()(U1
const &, U2
const &)
const
893 template <
class U1,
class U2,
class U3>
894 T
const & operator()(U1
const &, U2
const &, U3
const &)
const
903struct ResultTraits0<UnaryFunctor<VarFunctor<T> > >
908template <
class T,
class T1>
909struct ResultTraits1<UnaryFunctor<VarFunctor<T> >, T1>
914template <
class T,
class T1,
class T2>
915struct ResultTraits2<UnaryFunctor<VarFunctor<T> >, T1, T2>
920template <
class T,
class T1,
class T2,
class T3>
921struct ResultTraits3<UnaryFunctor<VarFunctor<T> >, T1, T2, T3>
927inline UnaryFunctor<VarFunctor<T> >
930 return UnaryFunctor<VarFunctor<T> >(v);
939template <
class EXPR1,
class EXPR2>
944 IfThenFunctor(EXPR1
const & e1, EXPR2
const & e2)
945 : expr1_(e1), expr2_(e2)
948 IfThenFunctor(IfThenFunctor
const &) =
default;
949 IfThenFunctor & operator=(IfThenFunctor
const &) =
delete;
950 IfThenFunctor(IfThenFunctor &&) =
default;
951 IfThenFunctor & operator=(IfThenFunctor &&) =
default;
953 void operator()()
const
955 if( expr1_() ) expr2_();
959 void operator()(T
const & v1)
const
961 if( expr1_(v1) ) expr2_(v1);
964 template <
class T1,
class T2>
965 void operator()(T1
const & v1, T2
const & v2)
const
967 if( expr1_(v1, v2) ) expr2_(v1, v2);
970 template <
class T1,
class T2,
class T3>
971 void operator()(T1
const & v1, T2
const & v2, T3
const & v3)
const
973 if( expr1_(v1, v2, v3) ) expr2_(v1, v2, v3);
982template <
class EXPR1,
class EXPR2>
983UnaryAnalyser<IfThenFunctor<UnaryFunctor<EXPR1>,
984 UnaryAnalyser<EXPR2> > >
985ifThen(UnaryFunctor<EXPR1>
const & e1,
986 UnaryAnalyser<EXPR2>
const & e2)
988 IfThenFunctor<UnaryFunctor<EXPR1>,
989 UnaryAnalyser<EXPR2> > p(e1, e2);
990 return UnaryAnalyser<IfThenFunctor<UnaryFunctor<EXPR1>,
991 UnaryAnalyser<EXPR2> > >(p);
1000template <
class EXPR1,
class EXPR2,
class EXPR3>
1001struct IfThenElseFunctor;
1003template <
class EXPR1,
class EXPR2,
class EXPR3>
1004struct ResultTraits0<IfThenElseFunctor<EXPR1, EXPR2, EXPR3> >
1006 typedef typename ResultTraits0<EXPR2>::Res R2;
1007 typedef typename ResultTraits0<EXPR3>::Res R3;
1008 typedef typename PromoteTraits<R2, R3>::Promote Res;
1011template <
class EXPR1,
class EXPR2,
class EXPR3,
class T1>
1012struct ResultTraits1<IfThenElseFunctor<EXPR1, EXPR2, EXPR3>, T1>
1014 typedef typename ResultTraits1<EXPR2, T1>::Res R2;
1015 typedef typename ResultTraits1<EXPR3, T1>::Res R3;
1016 typedef typename PromoteTraits<R2, R3>::Promote Res;
1019template <
class EXPR1,
class EXPR2,
class EXPR3,
class T1,
class T2>
1020struct ResultTraits2<IfThenElseFunctor<EXPR1, EXPR2, EXPR3>, T1, T2>
1022 typedef typename ResultTraits2<EXPR2, T1, T2>::Res R2;
1023 typedef typename ResultTraits2<EXPR3, T1, T2>::Res R3;
1024 typedef typename PromoteTraits<R2, R3>::Promote Res;
1027template <
class EXPR1,
class EXPR2,
class EXPR3,
class T1,
class T2,
class T3>
1028struct ResultTraits3<IfThenElseFunctor<EXPR1, EXPR2, EXPR3>, T1, T2, T3>
1030 typedef typename ResultTraits3<EXPR2, T1, T2, T3>::Res R2;
1031 typedef typename ResultTraits3<EXPR3, T1, T2, T3>::Res R3;
1032 typedef typename PromoteTraits<R2, R3>::Promote Res;
1035template <
class EXPR1,
class EXPR2,
class EXPR3>
1036struct IfThenElseFunctor
1038 IfThenElseFunctor(EXPR1
const & e1, EXPR2
const & e2, EXPR3
const & e3)
1039 : expr1_(e1), expr2_(e2), expr3_(e3)
1042 IfThenElseFunctor(IfThenElseFunctor
const &) =
default;
1043 IfThenElseFunctor & operator=(IfThenElseFunctor
const &) =
delete;
1044 IfThenElseFunctor(IfThenElseFunctor &&) =
default;
1045 IfThenElseFunctor & operator=(IfThenElseFunctor &&) =
default;
1047 typename ResultTraits0<IfThenElseFunctor>::Res
1052 return typename ResultTraits0<IfThenElseFunctor>::Res(expr2_());
1056 return typename ResultTraits0<IfThenElseFunctor>::Res(expr3_());
1061 typename ResultTraits1<IfThenElseFunctor, T>::Res
1062 operator()(T
const & v1)
const
1066 return typename ResultTraits1<IfThenElseFunctor, T>::Res(expr2_(v1));
1070 return typename ResultTraits1<IfThenElseFunctor, T>::Res(expr3_(v1));
1074 template <
class T1,
class T2>
1075 typename ResultTraits2<IfThenElseFunctor, T1, T2>::Res
1076 operator()(T1
const & v1, T2
const & v2)
const
1080 return typename ResultTraits2<IfThenElseFunctor, T1, T2>::Res(expr2_(v1, v2));
1084 return typename ResultTraits2<IfThenElseFunctor, T1, T2>::Res(expr3_(v1, v2));
1088 template <
class T1,
class T2,
class T3>
1089 typename ResultTraits3<IfThenElseFunctor, T1, T2, T3>::Res
1090 operator()(T1
const & v1, T2
const & v2, T3
const & v3)
const
1092 if(expr1_(v1, v2, v3))
1094 return typename ResultTraits3<IfThenElseFunctor, T1, T2, T3>::Res(expr2_(v1, v2, v3));
1098 return typename ResultTraits3<IfThenElseFunctor, T1, T2, T3>::Res(expr3_(v1, v2, v3));
1109template <
class EXPR1,
class EXPR2,
class EXPR3>
1110UnaryFunctor<IfThenElseFunctor<UnaryFunctor<EXPR1>,
1111 UnaryFunctor<EXPR2>,
1112 UnaryFunctor<EXPR3> > >
1113ifThenElse(UnaryFunctor<EXPR1>
const & e1,
1114 UnaryFunctor<EXPR2>
const & e2,
1115 UnaryFunctor<EXPR3>
const & e3)
1117 IfThenElseFunctor<UnaryFunctor<EXPR1>,
1118 UnaryFunctor<EXPR2>,
1119 UnaryFunctor<EXPR3> > p(e1, e2, e3);
1120 return UnaryFunctor<IfThenElseFunctor<UnaryFunctor<EXPR1>,
1121 UnaryFunctor<EXPR2>,
1122 UnaryFunctor<EXPR3> > >(p);
1131#define MAKE_FUNCTOR_UNARY_FUNCTION(function, namespc, traitsClass, traitsValue) \
1132 using ::namespc::function; \
1133 template <class EXPR> \
1134 struct Functor_##function; \
1136 template <class EXPR> \
1137 struct ResultTraits0<Functor_##function<EXPR> > \
1139 typedef typename ResultTraits0<EXPR>::Res R1; \
1140 typedef typename traitsClass<R1>::traitsValue Res; \
1143 template <class EXPR, class T1> \
1144 struct ResultTraits1<Functor_##function<EXPR>, T1> \
1146 typedef typename ResultTraits1<EXPR, T1>::Res R1; \
1147 typedef typename traitsClass<R1>::traitsValue Res; \
1150 template <class EXPR, class T1, class T2> \
1151 struct ResultTraits2<Functor_##function<EXPR>, T1, T2> \
1153 typedef typename ResultTraits2<EXPR, T1, T2>::Res R1; \
1154 typedef typename traitsClass<R1>::traitsValue Res; \
1157 template <class EXPR, class T1, class T2, class T3> \
1158 struct ResultTraits3<Functor_##function<EXPR>, T1, T2, T3> \
1160 typedef typename ResultTraits3<EXPR, T1, T2, T3>::Res R1; \
1161 typedef typename traitsClass<R1>::traitsValue Res; \
1164 template <class EXPR> \
1165 struct Functor_##function \
1167 Functor_##function(EXPR const & e) \
1171 Functor_##function(Functor_##function const &) = default; \
1172 Functor_##function & operator=(Functor_##function const &) = delete; \
1173 Functor_##function(Functor_##function &&) = default; \
1174 Functor_##function & operator=(Functor_##function &&) = default; \
1176 typename ResultTraits0<Functor_##function>::Res \
1177 operator()() const \
1179 return function(expr_()); \
1182 template <class T> \
1183 typename ResultTraits1<Functor_##function, T>::Res \
1184 operator()(T const & v1) const \
1186 return function(expr_(v1)); \
1189 template <class T1, class T2> \
1190 typename ResultTraits2<Functor_##function, T1, T2>::Res \
1191 operator()(T1 const & v1, T2 const & v2) const \
1193 return function(expr_(v1, v2)); \
1196 template <class T1, class T2, class T3> \
1197 typename ResultTraits3<Functor_##function, T1, T2, T3>::Res \
1198 operator()(T1 const & v1, T2 const & v2, T3 const & v3) const \
1200 return function(expr_(v1, v2, v3)); \
1208 template <class EXPR> \
1209 inline UnaryFunctor<Functor_##function<UnaryFunctor<EXPR> > > \
1210 function(UnaryFunctor<EXPR> const & e) \
1212 Functor_##function<UnaryFunctor<EXPR> > p(e); \
1213 return UnaryFunctor<Functor_##function<UnaryFunctor<EXPR> > >(p); \
1218MAKE_FUNCTOR_UNARY_FUNCTION(sq,
vigra, NumericTraits, RealPromote)
1219MAKE_FUNCTOR_UNARY_FUNCTION(sqrt, std, NumericTraits, RealPromote)
1220MAKE_FUNCTOR_UNARY_FUNCTION(exp, std, NumericTraits, RealPromote)
1221MAKE_FUNCTOR_UNARY_FUNCTION(log, std, NumericTraits, RealPromote)
1222MAKE_FUNCTOR_UNARY_FUNCTION(log10, std, NumericTraits, RealPromote)
1223MAKE_FUNCTOR_UNARY_FUNCTION(sin, std, NumericTraits, RealPromote)
1224MAKE_FUNCTOR_UNARY_FUNCTION(asin, std, NumericTraits, RealPromote)
1225MAKE_FUNCTOR_UNARY_FUNCTION(cos, std, NumericTraits, RealPromote)
1226MAKE_FUNCTOR_UNARY_FUNCTION(acos, std, NumericTraits, RealPromote)
1227MAKE_FUNCTOR_UNARY_FUNCTION(tan, std, NumericTraits, RealPromote)
1228MAKE_FUNCTOR_UNARY_FUNCTION(atan, std, NumericTraits, RealPromote)
1229MAKE_FUNCTOR_UNARY_FUNCTION(floor, std, NumericTraits, RealPromote)
1230MAKE_FUNCTOR_UNARY_FUNCTION(ceil, std, NumericTraits, RealPromote)
1231MAKE_FUNCTOR_UNARY_FUNCTION(abs,
vigra, NumericTraits, RealPromote)
1232MAKE_FUNCTOR_UNARY_FUNCTION(
norm,
vigra, NormTraits, NormType)
1233MAKE_FUNCTOR_UNARY_FUNCTION(
squaredNorm,
vigra, NormTraits, SquaredNormType)
1235#undef MAKE_FUNCTOR_UNARY_FUNCTION
1243#define MAKE_FUNCTOR_UNARY_OPERATOR(name, op) \
1244 template <class EXPR> \
1245 struct Functor_##name; \
1247 template <class EXPR> \
1248 struct ResultTraits0<Functor_##name<EXPR> > \
1250 typedef typename ResultTraits0<EXPR>::Res Res; \
1253 template <class EXPR, class T1> \
1254 struct ResultTraits1<Functor_##name<EXPR>, T1> \
1256 typedef typename ResultTraits1<EXPR, T1>::Res Res; \
1259 template <class EXPR, class T1, class T2> \
1260 struct ResultTraits2<Functor_##name<EXPR>, T1, T2> \
1262 typedef typename ResultTraits2<EXPR, T1, T2>::Res Res; \
1265 template <class EXPR, class T1, class T2, class T3> \
1266 struct ResultTraits3<Functor_##name<EXPR>, T1, T2, T3> \
1268 typedef typename ResultTraits3<EXPR, T1, T2, T3>::Res Res; \
1271 template <class EXPR> \
1272 struct Functor_##name \
1274 Functor_##name(EXPR const & e) \
1278 Functor_##name(Functor_##name const &) = default; \
1279 Functor_##name & operator=(Functor_##name const &) = delete; \
1280 Functor_##name(Functor_##name &&) = default; \
1281 Functor_##name & operator=(Functor_##name &&) = default; \
1283 typename ResultTraits0<Functor_##name>::Res \
1284 operator()() const \
1286 return op expr_(); \
1289 template <class T> \
1290 typename ResultTraits1<Functor_##name, T>::Res \
1291 operator()(T const & v1) const \
1293 return op expr_(v1); \
1296 template <class T1, class T2> \
1297 typename ResultTraits2<Functor_##name, T1, T2>::Res \
1298 operator()(T1 const & v1, T2 const & v2) const \
1300 return op expr_(v1, v2); \
1303 template <class T1, class T2, class T3> \
1304 typename ResultTraits3<Functor_##name, T1, T2, T3>::Res \
1305 operator()(T1 const & v1, T2 const & v2, T3 const & v3) const \
1307 return op expr_(v1, v2, v3); \
1314 template <class EXPR> \
1315 inline UnaryFunctor<Functor_##name<UnaryFunctor<EXPR> > > \
1316 operator op(UnaryFunctor<EXPR> const & e) \
1318 Functor_##name<UnaryFunctor<EXPR> > p(e); \
1319 return UnaryFunctor<Functor_##name<UnaryFunctor<EXPR> > >(p); \
1325MAKE_FUNCTOR_UNARY_OPERATOR(minus, -)
1326MAKE_FUNCTOR_UNARY_OPERATOR(negate, !)
1327MAKE_FUNCTOR_UNARY_OPERATOR(bitNegate, ~)
1329#undef MAKE_FUNCTOR_UNARY_OPERATOR
1337#define MAKE_FUNCTOR_BINARY_FUNCTION(function) \
1338 using std::function; \
1339 template <class EXPR1, class EXPR2> \
1340 struct Functor_##function; \
1342 template <class EXPR1, class EXPR2> \
1343 struct ResultTraits0<Functor_##function<EXPR1, EXPR2> > \
1345 typedef typename ResultTraits0<EXPR1>::Res R1; \
1346 typedef typename ResultTraits0<EXPR2>::Res R2; \
1347 typedef typename PromoteTraits<R1, R2>::Promote R3; \
1348 typedef typename NumericTraits<R3>::RealPromote Res; \
1351 template <class EXPR1, class EXPR2, class T1> \
1352 struct ResultTraits1<Functor_##function<EXPR1, EXPR2>, T1> \
1354 typedef typename ResultTraits1<EXPR1, T1>::Res R1; \
1355 typedef typename ResultTraits1<EXPR2, T1>::Res R2; \
1356 typedef typename PromoteTraits<R1, R2>::Promote R3; \
1357 typedef typename NumericTraits<R3>::RealPromote Res; \
1360 template <class EXPR1, class EXPR2, class T1, class T2> \
1361 struct ResultTraits2<Functor_##function<EXPR1, EXPR2>, T1, T2> \
1363 typedef typename ResultTraits2<EXPR1, T1, T2>::Res R1; \
1364 typedef typename ResultTraits2<EXPR2, T1, T2>::Res R2; \
1365 typedef typename PromoteTraits<R1, R2>::Promote R3; \
1366 typedef typename NumericTraits<R3>::RealPromote Res; \
1369 template <class EXPR1, class EXPR2, class T1, class T2, class T3> \
1370 struct ResultTraits3<Functor_##function<EXPR1, EXPR2>, T1, T2, T3> \
1372 typedef typename ResultTraits3<EXPR1, T1, T2, T3>::Res R1; \
1373 typedef typename ResultTraits3<EXPR2, T1, T2, T3>::Res R2; \
1374 typedef typename PromoteTraits<R1, R2>::Promote R3; \
1375 typedef typename NumericTraits<R3>::RealPromote Res; \
1378 template <class EXPR1, class EXPR2> \
1379 struct Functor_##function \
1381 Functor_##function(EXPR1 const & e1, EXPR2 const & e2) \
1382 : expr1_(e1), expr2_(e2) \
1385 Functor_##function(Functor_##function const &) = default; \
1386 Functor_##function & operator=(Functor_##function const &) = delete; \
1387 Functor_##function(Functor_##function &&) = default; \
1388 Functor_##function & operator=(Functor_##function &&) = default; \
1390 typename ResultTraits0<Functor_##function>::Res \
1391 operator()() const \
1393 return function(expr1_(), expr2_()); \
1396 template <class T> \
1397 typename ResultTraits1<Functor_##function, T>::Res \
1398 operator()(T const & v1) const \
1400 return function(expr1_(v1), expr2_(v1)); \
1403 template <class T1, class T2> \
1404 typename ResultTraits2<Functor_##function, T1, T2>::Res \
1405 operator()(T1 const & v1, T2 const & v2) const \
1407 return function(expr1_(v1, v2), expr2_(v1, v2)); \
1410 template <class T1, class T2, class T3> \
1411 typename ResultTraits3<Functor_##function, T1, T2, T3>::Res \
1412 operator()(T1 const & v1, T2 const & v2, T3 const & v3) const \
1414 return function(expr1_(v1, v2, v3), expr2_(v1, v2, v3)); \
1423 template <class EXPR1, class EXPR2> \
1424 inline UnaryFunctor<Functor_##function<UnaryFunctor<EXPR1>, UnaryFunctor<EXPR2> > > \
1425 function(UnaryFunctor<EXPR1> const & e1, UnaryFunctor<EXPR2> const & e2) \
1427 Functor_##function<UnaryFunctor<EXPR1>, UnaryFunctor<EXPR2> > p(e1, e2); \
1428 return UnaryFunctor<Functor_##function<UnaryFunctor<EXPR1>, \
1429 UnaryFunctor<EXPR2> > >(p); \
1434MAKE_FUNCTOR_BINARY_FUNCTION(pow)
1435MAKE_FUNCTOR_BINARY_FUNCTION(atan2)
1436MAKE_FUNCTOR_BINARY_FUNCTION(fmod)
1438#undef MAKE_FUNCTOR_BINARY_FUNCTION
1442#define MAKE_FUNCTOR_MINMAX(name, op) \
1443 template <class EXPR1, class EXPR2> \
1444 struct Functor_##name; \
1446 template <class EXPR1, class EXPR2> \
1447 struct ResultTraits0<Functor_##name<EXPR1, EXPR2> > \
1449 typedef typename ResultTraits0<EXPR1>::Res R1; \
1450 typedef typename ResultTraits0<EXPR2>::Res R2; \
1451 typedef typename PromoteTraits<R1, R2>::Promote Res; \
1454 template <class EXPR1, class EXPR2, class T1> \
1455 struct ResultTraits1<Functor_##name<EXPR1, EXPR2>, T1> \
1457 typedef typename ResultTraits1<EXPR1, T1>::Res R1; \
1458 typedef typename ResultTraits1<EXPR2, T1>::Res R2; \
1459 typedef typename PromoteTraits<R1, R2>::Promote Res; \
1462 template <class EXPR1, class EXPR2, class T1, class T2> \
1463 struct ResultTraits2<Functor_##name<EXPR1, EXPR2>, T1, T2> \
1465 typedef typename ResultTraits2<EXPR1, T1, T2>::Res R1; \
1466 typedef typename ResultTraits2<EXPR2, T1, T2>::Res R2; \
1467 typedef typename PromoteTraits<R1, R2>::Promote Res; \
1470 template <class EXPR1, class EXPR2, class T1, class T2, class T3> \
1471 struct ResultTraits3<Functor_##name<EXPR1, EXPR2>, T1, T2, T3> \
1473 typedef typename ResultTraits3<EXPR1, T1, T2, T3>::Res R1; \
1474 typedef typename ResultTraits3<EXPR2, T1, T2, T3>::Res R2; \
1475 typedef typename PromoteTraits<R1, R2>::Promote Res; \
1478 template <class EXPR1, class EXPR2> \
1479 struct Functor_##name \
1481 Functor_##name(EXPR1 const & e1, EXPR2 const & e2) \
1482 : expr1_(e1), expr2_(e2) \
1485 Functor_##name(Functor_##name const &) = default; \
1486 Functor_##name & operator=(Functor_##name const &) = delete; \
1487 Functor_##name(Functor_##name &&) = default; \
1488 Functor_##name & operator=(Functor_##name &&) = default; \
1490 typename ResultTraits0<Functor_##name>::Res \
1491 operator()() const \
1494 ResultTraits0<Functor_##name<EXPR1, EXPR2> >::R1 r1(expr1_()); \
1496 ResultTraits0<Functor_##name<EXPR1, EXPR2> >::R2 r2(expr2_()); \
1497 return (r1 op r2) ? r1 : r2; \
1500 template <class T> \
1501 typename ResultTraits1<Functor_##name, T>::Res \
1502 operator()(T const & v1) const \
1505 ResultTraits1<Functor_##name<EXPR1, EXPR2>, T>::R1 r1(expr1_(v1)); \
1507 ResultTraits1<Functor_##name<EXPR1, EXPR2>, T>::R2 r2(expr2_(v1)); \
1508 return (r1 op r2) ? r1 : r2; \
1511 template <class T1, class T2> \
1512 typename ResultTraits2<Functor_##name, T1, T2>::Res \
1513 operator()(T1 const & v1, T2 const & v2) const \
1516 ResultTraits2<Functor_##name<EXPR1, EXPR2>, T1, T2>::R1 r1(expr1_(v1, v2)); \
1518 ResultTraits2<Functor_##name<EXPR1, EXPR2>, T1, T2>::R2 r2(expr2_(v1, v2)); \
1519 return (r1 op r2) ? r1 : r2; \
1522 template <class T1, class T2, class T3> \
1523 typename ResultTraits3<Functor_##name, T1, T2, T3>::Res \
1524 operator()(T1 const & v1, T2 const & v2, T3 const & v3) const \
1527 ResultTraits3<Functor_##name<EXPR1, EXPR2>, T1, T2, T3>::R1 r1(expr1_(v1, v2, v3)); \
1529 ResultTraits3<Functor_##name<EXPR1, EXPR2>, T1, T2, T3>::R2 r2(expr2_(v1, v2, v3)); \
1530 return (r1 op r2) ? r1 : r2; \
1539 template <class EXPR1, class EXPR2> \
1540 inline UnaryFunctor<Functor_##name<UnaryFunctor<EXPR1>, UnaryFunctor<EXPR2> > > \
1541 name(UnaryFunctor<EXPR1> const & e1, UnaryFunctor<EXPR2> const & e2) \
1543 Functor_##name<UnaryFunctor<EXPR1>, UnaryFunctor<EXPR2> > p(e1, e2); \
1544 return UnaryFunctor<Functor_##name<UnaryFunctor<EXPR1>, \
1545 UnaryFunctor<EXPR2> > >(p); \
1548MAKE_FUNCTOR_MINMAX(min, <)
1549MAKE_FUNCTOR_MINMAX(max, >)
1551#undef MAKE_FUNCTOR_MINMAX
1559#define MAKE_FUNCTOR_BINARY_OPERATOR(name, op) \
1560 template <class EXPR1, class EXPR2> \
1561 struct Functor_##name; \
1563 template <class EXPR1, class EXPR2> \
1564 struct ResultTraits0<Functor_##name<EXPR1, EXPR2> > \
1566 typedef typename ResultTraits0<EXPR1>::Res R1; \
1567 typedef typename ResultTraits0<EXPR2>::Res R2; \
1568 typedef typename PromoteTraits<R1, R2>::Promote Res; \
1571 template <class EXPR1, class EXPR2, class T1> \
1572 struct ResultTraits1<Functor_##name<EXPR1, EXPR2>, T1> \
1574 typedef typename ResultTraits1<EXPR1, T1>::Res R1; \
1575 typedef typename ResultTraits1<EXPR2, T1>::Res R2; \
1576 typedef typename PromoteTraits<R1, R2>::Promote Res; \
1579 template <class EXPR1, class EXPR2, class T1, class T2> \
1580 struct ResultTraits2<Functor_##name<EXPR1, EXPR2>, T1, T2> \
1582 typedef typename ResultTraits2<EXPR1, T1, T2>::Res R1; \
1583 typedef typename ResultTraits2<EXPR2, T1, T2>::Res R2; \
1584 typedef typename PromoteTraits<R1, R2>::Promote Res; \
1587 template <class EXPR1, class EXPR2, class T1, class T2, class T3> \
1588 struct ResultTraits3<Functor_##name<EXPR1, EXPR2>, T1, T2, T3> \
1590 typedef typename ResultTraits3<EXPR1, T1, T2, T3>::Res R1; \
1591 typedef typename ResultTraits3<EXPR2, T1, T2, T3>::Res R2; \
1592 typedef typename PromoteTraits<R1, R2>::Promote Res; \
1595 template <class EXPR1, class EXPR2> \
1596 struct Functor_##name \
1598 Functor_##name(EXPR1 const & e1, EXPR2 const & e2) \
1599 : expr1_(e1), expr2_(e2) \
1602 Functor_##name(Functor_##name const &) = default; \
1603 Functor_##name & operator=(Functor_##name const &) = delete; \
1604 Functor_##name(Functor_##name &&) = default; \
1605 Functor_##name & operator=(Functor_##name &&) = default; \
1607 typename ResultTraits0<Functor_##name>::Res \
1608 operator()() const \
1610 return expr1_() op expr2_(); \
1613 template <class T> \
1614 typename ResultTraits1<Functor_##name, T>::Res \
1615 operator()(T const & v1) const \
1617 return expr1_(v1) op expr2_(v1); \
1620 template <class T1, class T2> \
1621 typename ResultTraits2<Functor_##name, T1, T2>::Res \
1622 operator()(T1 const & v1, T2 const & v2) const \
1624 return expr1_(v1, v2) op expr2_(v1, v2); \
1627 template <class T1, class T2, class T3> \
1628 typename ResultTraits3<Functor_##name, T1, T2, T3>::Res \
1629 operator()(T1 const & v1, T2 const & v2, T3 const & v3) const \
1631 return expr1_(v1, v2, v3) op expr2_(v1, v2, v3); \
1640 template <class EXPR1, class EXPR2> \
1641 inline UnaryFunctor<Functor_##name<UnaryFunctor<EXPR1>, UnaryFunctor<EXPR2> > > \
1642 operator op(UnaryFunctor<EXPR1> const & e1, UnaryFunctor<EXPR2> const & e2) \
1644 Functor_##name<UnaryFunctor<EXPR1>, UnaryFunctor<EXPR2> > p(e1, e2); \
1645 return UnaryFunctor<Functor_##name<UnaryFunctor<EXPR1>, \
1646 UnaryFunctor<EXPR2> > >(p); \
1651MAKE_FUNCTOR_BINARY_OPERATOR(
add, +)
1652MAKE_FUNCTOR_BINARY_OPERATOR(subtract, -)
1653MAKE_FUNCTOR_BINARY_OPERATOR(multiply, *)
1654MAKE_FUNCTOR_BINARY_OPERATOR(divide, /)
1655MAKE_FUNCTOR_BINARY_OPERATOR(modulo, %)
1656MAKE_FUNCTOR_BINARY_OPERATOR(bitAnd, &)
1657MAKE_FUNCTOR_BINARY_OPERATOR(bitOr, |)
1658MAKE_FUNCTOR_BINARY_OPERATOR(bitXor, ^)
1660#undef MAKE_FUNCTOR_BINARY_OPERATOR
1664#define MAKE_FUNCTOR_BINARY_OPERATOR_BOOL(name, op) \
1665 template <class EXPR1, class EXPR2> \
1666 struct Functor_##name; \
1668 template <class EXPR1, class EXPR2> \
1669 struct ResultTraits0<Functor_##name<EXPR1, EXPR2> > \
1674 template <class EXPR1, class EXPR2, class T1> \
1675 struct ResultTraits1<Functor_##name<EXPR1, EXPR2>, T1> \
1680 template <class EXPR1, class EXPR2, class T1, class T2> \
1681 struct ResultTraits2<Functor_##name<EXPR1, EXPR2>, T1, T2> \
1686 template <class EXPR1, class EXPR2, class T1, class T2, class T3> \
1687 struct ResultTraits3<Functor_##name<EXPR1, EXPR2>, T1, T2, T3> \
1692 template <class EXPR1, class EXPR2> \
1693 struct Functor_##name \
1695 Functor_##name(EXPR1 const & e1, EXPR2 const & e2) \
1696 : expr1_(e1), expr2_(e2) \
1700 Functor_##name(Functor_##name const &) = default; \
1701 Functor_##name & operator=(Functor_##name const &) = delete; \
1702 Functor_##name(Functor_##name &&) = default; \
1703 Functor_##name & operator=(Functor_##name &&) = delete; \
1704 bool operator()() const \
1706 return expr1_() op expr2_(); \
1709 template <class T> \
1710 bool operator()(T const & v1) const \
1712 return expr1_(v1) op expr2_(v1); \
1715 template <class T1, class T2> \
1716 bool operator()(T1 const & v1, T2 const & v2) const \
1718 return expr1_(v1, v2) op expr2_(v1, v2); \
1721 template <class T1, class T2, class T3> \
1722 bool operator()(T1 const & v1, T2 const & v2, T3 const & v3) const \
1724 return expr1_(v1, v2, v3) op expr2_(v1, v2, v3); \
1733 template <class EXPR1, class EXPR2> \
1734 inline UnaryFunctor<Functor_##name<UnaryFunctor<EXPR1>, UnaryFunctor<EXPR2> > > \
1735 operator op(UnaryFunctor<EXPR1> const & e1, UnaryFunctor<EXPR2> const & e2) \
1737 Functor_##name<UnaryFunctor<EXPR1>, UnaryFunctor<EXPR2> > p(e1, e2); \
1738 return UnaryFunctor<Functor_##name<UnaryFunctor<EXPR1>, \
1739 UnaryFunctor<EXPR2> > >(p); \
1745#pragma GCC diagnostic push
1746#pragma GCC diagnostic ignored "-Wsign-compare"
1749MAKE_FUNCTOR_BINARY_OPERATOR_BOOL(equals, ==)
1750MAKE_FUNCTOR_BINARY_OPERATOR_BOOL(differs, !=)
1751MAKE_FUNCTOR_BINARY_OPERATOR_BOOL(less, <)
1752MAKE_FUNCTOR_BINARY_OPERATOR_BOOL(lessEqual, <=)
1753MAKE_FUNCTOR_BINARY_OPERATOR_BOOL(greater, >)
1754MAKE_FUNCTOR_BINARY_OPERATOR_BOOL(greaterEqual, >=)
1755MAKE_FUNCTOR_BINARY_OPERATOR_BOOL(and, &&)
1756MAKE_FUNCTOR_BINARY_OPERATOR_BOOL(or, ||)
1759#pragma GCC diagnostic pop
1762#undef MAKE_FUNCTOR_BINARY_OPERATOR_BOOL
1770template <
class EXPR,
class RES,
class ARG>
1771struct UnaryFctPtrFunctor
1773 UnaryFctPtrFunctor(EXPR
const & e, RES (*fct)(ARG))
1777 UnaryFctPtrFunctor(UnaryFctPtrFunctor
const &) =
default;
1778 UnaryFctPtrFunctor & operator=(UnaryFctPtrFunctor
const &) =
delete;
1779 UnaryFctPtrFunctor(UnaryFctPtrFunctor &&) =
default;
1780 UnaryFctPtrFunctor & operator=(UnaryFctPtrFunctor &&) =
default;
1782 RES operator()()
const
1788 RES operator()(T
const & v1)
const
1790 return f_(expr_(v1));
1793 template <
class T1,
class T2>
1794 RES operator()(T1
const & v1, T2
const & v2)
const
1796 return f_(expr_(v1, v2));
1799 template <
class T1,
class T2,
class T3>
1800 RES operator()(T1
const & v1, T2
const & v2, T3
const & v3)
const
1802 return f_(expr_(v1, v2, v3));
1810template <
class EXPR,
class RES,
class ARG>
1811struct ResultTraits0<UnaryFctPtrFunctor<EXPR, RES, ARG> >
1816template <
class EXPR,
class RES,
class ARG,
class T1>
1817struct ResultTraits1<UnaryFctPtrFunctor<EXPR, RES, ARG>, T1>
1822template <
class EXPR,
class RES,
class ARG,
class T1,
class T2>
1823struct ResultTraits2<UnaryFctPtrFunctor<EXPR, RES, ARG>, T1, T2>
1828template <
class EXPR,
class RES,
class ARG,
class T1,
class T2,
class T3>
1829struct ResultTraits3<UnaryFctPtrFunctor<EXPR, RES, ARG>, T1, T2, T3>
1834template <
class EXPR,
class RES,
class ARG>
1835inline UnaryFunctor<UnaryFctPtrFunctor<UnaryFunctor<EXPR>, RES, ARG> >
1836applyFct(RES (*f)(ARG), UnaryFunctor<EXPR>
const & e)
1838 UnaryFctPtrFunctor<UnaryFunctor<EXPR>, RES, ARG> p(e, f);
1839 return UnaryFunctor<UnaryFctPtrFunctor<UnaryFunctor<EXPR>, RES, ARG> >(p);
1848template <
class EXPR1,
class EXPR2,
class RES,
class ARG1,
class ARG2>
1849struct BinaryFctPtrFunctor
1851 BinaryFctPtrFunctor(EXPR1
const & e1, EXPR2
const & e2,
1852 RES (*f)(ARG1, ARG2))
1853 : expr1_(e1), expr2_(e2), f_(f)
1856 BinaryFctPtrFunctor(BinaryFctPtrFunctor
const &) =
default;
1857 BinaryFctPtrFunctor & operator=(BinaryFctPtrFunctor
const &) =
delete;
1858 BinaryFctPtrFunctor(BinaryFctPtrFunctor &&) =
default;
1859 BinaryFctPtrFunctor & operator=(BinaryFctPtrFunctor &&) =
default;
1861 RES operator()()
const
1863 return f_(expr1_(), expr2_());
1867 RES operator()(T
const & v1)
const
1869 return f_(expr1_(v1), expr2_(v1));
1872 template <
class T1,
class T2>
1873 RES operator()(T1
const & v1, T2
const & v2)
const
1875 return f_(expr1_(v1, v2), expr2_(v1, v2));
1878 template <
class T1,
class T2,
class T3>
1879 RES operator()(T1
const & v1, T2
const & v2, T3
const & v3)
const
1881 return f_(expr1_(v1, v2, v3), expr2_(v1, v2, v3));
1888 RES (*f_)(ARG1, ARG2);
1891template <
class EXPR1,
class EXPR2,
class RES,
class ARG1,
class ARG2>
1892struct ResultTraits0<BinaryFctPtrFunctor<EXPR1, EXPR2, RES, ARG1, ARG2> >
1897template <
class EXPR1,
class EXPR2,
class RES,
class ARG1,
class ARG2,
1899struct ResultTraits1<BinaryFctPtrFunctor<EXPR1, EXPR2, RES, ARG1, ARG2>, T1>
1904template <
class EXPR1,
class EXPR2,
class RES,
class ARG1,
class ARG2,
1906struct ResultTraits2<BinaryFctPtrFunctor<EXPR1, EXPR2, RES, ARG1, ARG2>, T1, T2>
1911template <
class EXPR1,
class EXPR2,
class RES,
class ARG1,
class ARG2,
1912 class T1,
class T2,
class T3>
1913struct ResultTraits3<BinaryFctPtrFunctor<EXPR1, EXPR2, RES, ARG1, ARG2>, T1, T2, T3>
1918template <
class EXPR1,
class EXPR2,
class RES,
class ARG1,
class ARG2>
1919inline UnaryFunctor<BinaryFctPtrFunctor<UnaryFunctor<EXPR1>,
1920 UnaryFunctor<EXPR2>,
1922applyFct(RES (*f)(ARG1, ARG2), UnaryFunctor<EXPR1>
const & e1,
1923 UnaryFunctor<EXPR2>
const & e2)
1925 BinaryFctPtrFunctor<UnaryFunctor<EXPR1>,
1926 UnaryFunctor<EXPR2>,
1927 RES, ARG1, ARG2> p(e1, e2, f);
1928 return UnaryFunctor<BinaryFctPtrFunctor<UnaryFunctor<EXPR1>,
1929 UnaryFunctor<EXPR2>,
1930 RES, ARG1, ARG2> >(p);
1939template <
class EXPR1,
class EXPR2>
1942 CommaFunctor(EXPR1
const & e1, EXPR2
const & e2)
1943 : expr1_(e1), expr2_(e2)
1946 CommaFunctor(CommaFunctor
const &) =
default;
1947 CommaFunctor & operator=(CommaFunctor
const &) =
delete;
1948 CommaFunctor(CommaFunctor &&) =
default;
1949 CommaFunctor & operator=(CommaFunctor &&) =
default;
1951 typename ResultTraits0<EXPR2>::Res
1959 typename ResultTraits1<EXPR2, T>::Res
1960 operator()(T
const & v1)
const
1966 template <
class T1,
class T2>
1967 typename ResultTraits2<EXPR2, T1, T2>::Res
1968 operator()(T1
const & v1, T2
const & v2)
const
1971 return expr2_(v1, v2);
1974 template <
class T1,
class T2,
class T3>
1975 typename ResultTraits3<EXPR2, T1, T2, T3>::Res
1976 operator()(T1
const & v1, T2
const & v2, T3
const & v3)
const
1979 return expr2_(v1, v2, v3);
1988template <
class Expr1,
class Expr2>
1989struct ResultTraits0<CommaFunctor<Expr1, Expr2> >
1991 typedef typename ResultTraits0<Expr2>::Res Res;
1994template <
class Expr1,
class Expr2,
class T1>
1995struct ResultTraits1<CommaFunctor<Expr1, Expr2>, T1>
1997 typedef typename ResultTraits1<Expr2, T1>::Res Res;
2000template <
class Expr1,
class Expr2,
class T1,
class T2>
2001struct ResultTraits2<CommaFunctor<Expr1, Expr2>, T1, T2>
2003 typedef typename ResultTraits2<Expr2, T1, T2>::Res Res;
2006template <
class Expr1,
class Expr2,
class T1,
class T2,
class T3>
2007struct ResultTraits3<CommaFunctor<Expr1, Expr2>, T1, T2, T3>
2009 typedef typename ResultTraits3<Expr2, T1, T2, T3>::Res Res;
2012template <
class EXPR1,
class EXPR2>
2013inline UnaryFunctor<CommaFunctor<UnaryAnalyser<EXPR1>,
2014 UnaryFunctor<EXPR2> > >
2015operator,(UnaryAnalyser<EXPR1>
const & e1,
2016 UnaryFunctor<EXPR2>
const & e2)
2018 CommaFunctor<UnaryAnalyser<EXPR1>,
2019 UnaryFunctor<EXPR2> > p(e1, e2);
2020 return UnaryFunctor<CommaFunctor<UnaryAnalyser<EXPR1>,
2021 UnaryFunctor<EXPR2> > >(p);
2026template <
class EXPR1,
class EXPR2>
2029 CommaAnalyser(EXPR1
const & e1, EXPR2
const & e2)
2030 : expr1_(e1), expr2_(e2)
2033 CommaAnalyser(CommaAnalyser
const &) =
default;
2034 CommaAnalyser & operator=(CommaAnalyser
const &) =
delete;
2035 CommaAnalyser(CommaAnalyser &&) =
default;
2036 CommaAnalyser & operator=(CommaAnalyser &&) =
default;
2038 void operator()()
const
2045 void operator()(T
const & v1)
const
2051 template <
class T1,
class T2>
2052 void operator()(T1
const & v1, T2
const & v2)
const
2058 template <
class T1,
class T2,
class T3>
2059 void operator()(T1
const & v1, T2
const & v2, T3
const & v3)
const
2071template <
class EXPR1,
class EXPR2>
2072inline UnaryAnalyser<CommaAnalyser<UnaryAnalyser<EXPR1>,
2073 UnaryAnalyser<EXPR2> > >
2074operator,(UnaryAnalyser<EXPR1>
const & e1,
2075 UnaryAnalyser<EXPR2>
const & e2)
2077 CommaAnalyser<UnaryAnalyser<EXPR1>,
2078 UnaryAnalyser<EXPR2> > p(e1, e2);
2079 return UnaryAnalyser<CommaAnalyser<UnaryAnalyser<EXPR1>,
2080 UnaryAnalyser<EXPR2> > >(p);
2085#if defined(__GNUC__) && __GNUC__ < 3
2089using functor::Param;
2093class FunctorTraits<functor::UnaryFunctor<T> >
2094:
public FunctorTraitsBase<functor::UnaryFunctor<T> >
2097 typedef VigraTrueType isInitializer;
2098 typedef VigraTrueType isUnaryFunctor;
2099 typedef VigraTrueType isBinaryFunctor;
2100 typedef VigraTrueType isTernaryFunctor;
2104class FunctorTraits<functor::UnaryAnalyser<T> >
2105:
public FunctorTraitsBase<functor::UnaryAnalyser<T> >
2108 typedef VigraTrueType isUnaryAnalyser;
2109 typedef VigraTrueType isBinaryAnalyser;
2110 typedef VigraTrueType isTernaryAnalyser;
void add(FixedPoint< IntBits1, FracBits1 > l, FixedPoint< IntBits2, FracBits2 > r, FixedPoint< IntBits3, FracBits3 > &result)
addition with enforced result type.
Definition fixedpoint.hxx:561
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
FFTWComplex< R > & operator-=(FFTWComplex< R > &a, const FFTWComplex< R > &b)
subtract-assignment
Definition fftw3.hxx:867
FFTWComplex< R > & operator*=(FFTWComplex< R > &a, const FFTWComplex< R > &b)
multiply-assignment
Definition fftw3.hxx:875
FFTWComplex< R > & operator/=(FFTWComplex< R > &a, const FFTWComplex< R > &b)
divide-assignment
Definition fftw3.hxx:884
FFTWComplex< R >::SquaredNormType squaredNorm(const FFTWComplex< R > &a)
squared norm (= squared magnitude)
Definition fftw3.hxx:1044