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)
379 typename ResultTraits0<EXPR>::Res
386 typename ResultTraits1<EXPR, T1>::Res
387 operator()(T1
const & v)
const
392 template <
class T1,
class T2>
393 typename ResultTraits2<EXPR, T1, T2>::Res
394 operator()(T1
const & v1, T2
const & v2)
const
396 return expr_(v1, v2);
399 template <
class T1,
class T2,
class T3>
400 typename ResultTraits3<EXPR, T1, T2, T3>::Res
401 operator()(T1
const & v1, T2
const & v2, T3
const & v3)
const
403 return expr_(v1, v2, v3);
410 UnaryFunctor & operator=(UnaryFunctor
const &);
414struct ResultTraits0<UnaryFunctor<Expr> >
416 typedef typename ResultTraits0<Expr>::Res Res;
419template <
class Expr,
class T1>
420struct ResultTraits1<UnaryFunctor<Expr>, T1>
422 typedef typename ResultTraits1<Expr, T1>::Res Res;
425template <
class Expr,
class T1,
class T2>
426struct ResultTraits2<UnaryFunctor<Expr>, T1, T2>
428 typedef typename ResultTraits2<Expr, T1, T2>::Res Res;
431template <
class Expr,
class T1,
class T2,
class T3>
432struct ResultTraits3<UnaryFunctor<Expr>, T1, T2, T3>
434 typedef typename ResultTraits3<Expr, T1, T2, T3>::Res Res;
443struct ArgumentFunctor1;
444struct ArgumentFunctor2;
445struct ArgumentFunctor3;
448struct UnaryFunctor<ArgumentFunctor1>
454 T1
const & operator()(T1
const & v1)
const
459 template <
class T1,
class T2>
460 T1
const & operator()(T1
const & v1, T2
const &)
const
465 template <
class T1,
class T2,
class T3>
466 T1
const & operator()(T1
const & v1, T2
const &, T3
const &)
const
472 UnaryFunctor & operator=(UnaryFunctor
const &);
475typedef UnaryFunctor<ArgumentFunctor1> Identity;
478struct ResultTraits0<UnaryFunctor<ArgumentFunctor1> >
480 typedef ErrorType Res;
484struct ResultTraits1<UnaryFunctor<ArgumentFunctor1>, T1>
489template <
class T1,
class T2>
490struct ResultTraits2<UnaryFunctor<ArgumentFunctor1>, T1, T2>
495template <
class T1,
class T2,
class T3>
496struct ResultTraits3<UnaryFunctor<ArgumentFunctor1>, T1, T2, T3>
504UnaryFunctor<ArgumentFunctor1>
507 return UnaryFunctor<ArgumentFunctor1>();
513struct UnaryFunctor<ArgumentFunctor2>
518 template <
class T1,
class T2>
519 T2
const & operator()(T1
const &, T2
const & v2)
const
524 template <
class T1,
class T2,
class T3>
525 T2
const & operator()(T1
const &, T2
const & v2, T3
const &)
const
531 UnaryFunctor & operator=(UnaryFunctor
const &);
535struct ResultTraits0<UnaryFunctor<ArgumentFunctor2> >
537 typedef ErrorType Res;
541struct ResultTraits1<UnaryFunctor<ArgumentFunctor2>, T1>
543 typedef ErrorType Res;
546template <
class T1,
class T2>
547struct ResultTraits2<UnaryFunctor<ArgumentFunctor2>, T1, T2>
552template <
class T1,
class T2,
class T3>
553struct ResultTraits3<UnaryFunctor<ArgumentFunctor2>, T1, T2, T3>
561UnaryFunctor<ArgumentFunctor2>
564 return UnaryFunctor<ArgumentFunctor2>();
570struct UnaryFunctor<ArgumentFunctor3>
575 template <
class T1,
class T2,
class T3>
576 T3
const & operator()(T1
const &, T2
const &, T3
const & v3)
const
582 UnaryFunctor & operator=(UnaryFunctor
const &);
586struct ResultTraits0<UnaryFunctor<ArgumentFunctor3> >
588 typedef ErrorType Res;
592struct ResultTraits1<UnaryFunctor<ArgumentFunctor3>, T1>
594 typedef ErrorType Res;
597template <
class T1,
class T2>
598struct ResultTraits2<UnaryFunctor<ArgumentFunctor3>, T1, T2>
600 typedef ErrorType Res;
603template <
class T1,
class T2,
class T3>
604struct ResultTraits3<UnaryFunctor<ArgumentFunctor3>, T1, T2, T3>
612UnaryFunctor<ArgumentFunctor3>
615 return UnaryFunctor<ArgumentFunctor3>();
625struct ParameterFunctor
627 ParameterFunctor(T v)
631 T
const & operator()()
const
637 T
const & operator()(U1
const &)
const
642 template <
class U1,
class U2>
643 T
const & operator()(U1
const &, U2
const &)
const
648 template <
class U1,
class U2,
class U3>
649 T
const & operator()(U1
const &, U2
const &, U3
const &)
const
658 ParameterFunctor & operator=(ParameterFunctor
const &);
662struct ResultTraits0<ParameterFunctor<T> >
667template <
class T,
class T1>
668struct ResultTraits1<ParameterFunctor<T>, T1>
673template <
class T,
class T1,
class T2>
674struct ResultTraits2<ParameterFunctor<T>, T1, T2>
679template <
class T,
class T1,
class T2,
class T3>
680struct ResultTraits3<ParameterFunctor<T>, T1, T2, T3>
686inline UnaryFunctor<ParameterFunctor<T> >
689 ParameterFunctor<T> fv(v);
690 return UnaryFunctor<ParameterFunctor<T> >(fv);
704 UnaryAnalyser(EXPR
const & e)
708 void operator()()
const
714 void operator()(T1
const & v)
const
719 template <
class T1,
class T2>
720 void operator()(T1
const & v1, T2
const & v2)
const
725 template <
class T1,
class T2,
class T3>
726 void operator()(T1
const & v1, T2
const & v2, T3
const & v3)
const
735 UnaryAnalyser & operator=(UnaryAnalyser
const &);
748struct UnaryFunctor<VarFunctor<T> >;
752#define MAKE_ASSIGNMENT_FUNCTOR(name, op) \
753 template <class V, class EXPR> \
754 struct AssignmentFunctor_##name \
756 AssignmentFunctor_##name(UnaryFunctor<VarFunctor<V> > v, \
757 UnaryFunctor<EXPR> const & e) \
758 : value_(v.value_), expr_(e) \
761 V & operator()() const \
763 const_cast<V &>(value_) op expr_(); \
764 return const_cast<V &>(value_); \
767 template <class T1> \
768 V & operator()(T1 const & v1) const \
770 const_cast<V &>(value_) op expr_(v1); \
771 return const_cast<V &>(value_); \
774 template <class T1, class T2> \
775 V & operator()(T1 const & v1, T2 const & v2) const \
777 const_cast<V &>(value_) op expr_(v1, v2); \
778 return const_cast<V &>(value_); \
781 template <class T1, class T2, class T3> \
782 V & operator()(T1 const & v1, T2 const & v2, T3 const & v3) const \
784 const_cast<V &>(value_) op expr_(v1, v2, v3); \
785 return const_cast<V &>(value_); \
790 UnaryFunctor<EXPR> expr_; \
792 AssignmentFunctor_##name & operator=(AssignmentFunctor_##name const &);\
797MAKE_ASSIGNMENT_FUNCTOR(assign, =)
798MAKE_ASSIGNMENT_FUNCTOR(
add, +=)
799MAKE_ASSIGNMENT_FUNCTOR(subtract, -=)
800MAKE_ASSIGNMENT_FUNCTOR(multiply, *=)
801MAKE_ASSIGNMENT_FUNCTOR(divide, /=)
803#undef MAKE_ASSIGNMENT_FUNCTOR
812struct UnaryFunctor<VarFunctor<T> >
820 template <
class EXPR>
821 UnaryAnalyser< AssignmentFunctor_assign<T, UnaryFunctor<EXPR> > >
822 operator=(UnaryFunctor<EXPR>
const & e)
824 AssignmentFunctor_assign<T, UnaryFunctor<EXPR> > va(*
this, e);
825 return UnaryAnalyser< AssignmentFunctor_assign<T, UnaryFunctor<EXPR> > >(va);
828 template <
class EXPR>
829 UnaryAnalyser< AssignmentFunctor_add<T, UnaryFunctor<EXPR> > >
832 AssignmentFunctor_add<T, UnaryFunctor<EXPR> > va(*
this, e);
833 return UnaryAnalyser< AssignmentFunctor_add<T, UnaryFunctor<EXPR> > >(va);
836 template <
class EXPR>
837 UnaryAnalyser< AssignmentFunctor_subtract<T, UnaryFunctor<EXPR> > >
840 AssignmentFunctor_subtract<T, UnaryFunctor<EXPR> > va(*
this, e);
841 return UnaryAnalyser< AssignmentFunctor_subtract<T, UnaryFunctor<EXPR> > >(va);
844 template <
class EXPR>
845 UnaryAnalyser< AssignmentFunctor_multiply<T, UnaryFunctor<EXPR> > >
848 AssignmentFunctor_multiply<T, UnaryFunctor<EXPR> > va(*
this, e);
849 return UnaryAnalyser< AssignmentFunctor_multiply<T, UnaryFunctor<EXPR> > >(va);
852 template <
class EXPR>
853 UnaryAnalyser< AssignmentFunctor_divide<T, UnaryFunctor<EXPR> > >
856 AssignmentFunctor_divide<T, UnaryFunctor<EXPR> > va(*
this, e);
857 return UnaryAnalyser< AssignmentFunctor_divide<T, UnaryFunctor<EXPR> > >(va);
860 T
const & operator()()
const
866 T
const & operator()(U1
const &)
const
871 template <
class U1,
class U2>
872 T
const & operator()(U1
const &, U2
const &)
const
877 template <
class U1,
class U2,
class U3>
878 T
const & operator()(U1
const &, U2
const &, U3
const &)
const
886 UnaryFunctor & operator=(UnaryFunctor
const &);
890struct ResultTraits0<UnaryFunctor<VarFunctor<T> > >
895template <
class T,
class T1>
896struct ResultTraits1<UnaryFunctor<VarFunctor<T> >, T1>
901template <
class T,
class T1,
class T2>
902struct ResultTraits2<UnaryFunctor<VarFunctor<T> >, T1, T2>
907template <
class T,
class T1,
class T2,
class T3>
908struct ResultTraits3<UnaryFunctor<VarFunctor<T> >, T1, T2, T3>
914inline UnaryFunctor<VarFunctor<T> >
917 return UnaryFunctor<VarFunctor<T> >(v);
926template <
class EXPR1,
class EXPR2>
931 IfThenFunctor(EXPR1
const & e1, EXPR2
const & e2)
932 : expr1_(e1), expr2_(e2)
935 void operator()()
const
937 if( expr1_() ) expr2_();
941 void operator()(T
const & v1)
const
943 if( expr1_(v1) ) expr2_(v1);
946 template <
class T1,
class T2>
947 void operator()(T1
const & v1, T2
const & v2)
const
949 if( expr1_(v1, v2) ) expr2_(v1, v2);
952 template <
class T1,
class T2,
class T3>
953 void operator()(T1
const & v1, T2
const & v2, T3
const & v3)
const
955 if( expr1_(v1, v2, v3) ) expr2_(v1, v2, v3);
964 IfThenFunctor & operator=(IfThenFunctor
const &);
967template <
class EXPR1,
class EXPR2>
968UnaryAnalyser<IfThenFunctor<UnaryFunctor<EXPR1>,
969 UnaryAnalyser<EXPR2> > >
970ifThen(UnaryFunctor<EXPR1>
const & e1,
971 UnaryAnalyser<EXPR2>
const & e2)
973 IfThenFunctor<UnaryFunctor<EXPR1>,
974 UnaryAnalyser<EXPR2> > p(e1, e2);
975 return UnaryAnalyser<IfThenFunctor<UnaryFunctor<EXPR1>,
976 UnaryAnalyser<EXPR2> > >(p);
985template <
class EXPR1,
class EXPR2,
class EXPR3>
986struct IfThenElseFunctor;
988template <
class EXPR1,
class EXPR2,
class EXPR3>
989struct ResultTraits0<IfThenElseFunctor<EXPR1, EXPR2, EXPR3> >
991 typedef typename ResultTraits0<EXPR2>::Res R2;
992 typedef typename ResultTraits0<EXPR3>::Res R3;
993 typedef typename PromoteTraits<R2, R3>::Promote Res;
996template <
class EXPR1,
class EXPR2,
class EXPR3,
class T1>
997struct ResultTraits1<IfThenElseFunctor<EXPR1, EXPR2, EXPR3>, T1>
999 typedef typename ResultTraits1<EXPR2, T1>::Res R2;
1000 typedef typename ResultTraits1<EXPR3, T1>::Res R3;
1001 typedef typename PromoteTraits<R2, R3>::Promote Res;
1004template <
class EXPR1,
class EXPR2,
class EXPR3,
class T1,
class T2>
1005struct ResultTraits2<IfThenElseFunctor<EXPR1, EXPR2, EXPR3>, T1, T2>
1007 typedef typename ResultTraits2<EXPR2, T1, T2>::Res R2;
1008 typedef typename ResultTraits2<EXPR3, T1, T2>::Res R3;
1009 typedef typename PromoteTraits<R2, R3>::Promote Res;
1012template <
class EXPR1,
class EXPR2,
class EXPR3,
class T1,
class T2,
class T3>
1013struct ResultTraits3<IfThenElseFunctor<EXPR1, EXPR2, EXPR3>, T1, T2, T3>
1015 typedef typename ResultTraits3<EXPR2, T1, T2, T3>::Res R2;
1016 typedef typename ResultTraits3<EXPR3, T1, T2, T3>::Res R3;
1017 typedef typename PromoteTraits<R2, R3>::Promote Res;
1020template <
class EXPR1,
class EXPR2,
class EXPR3>
1021struct IfThenElseFunctor
1023 IfThenElseFunctor(EXPR1
const & e1, EXPR2
const & e2, EXPR3
const & e3)
1024 : expr1_(e1), expr2_(e2), expr3_(e3)
1027 typename ResultTraits0<IfThenElseFunctor>::Res
1032 return typename ResultTraits0<IfThenElseFunctor>::Res(expr2_());
1036 return typename ResultTraits0<IfThenElseFunctor>::Res(expr3_());
1041 typename ResultTraits1<IfThenElseFunctor, T>::Res
1042 operator()(T
const & v1)
const
1046 return typename ResultTraits1<IfThenElseFunctor, T>::Res(expr2_(v1));
1050 return typename ResultTraits1<IfThenElseFunctor, T>::Res(expr3_(v1));
1054 template <
class T1,
class T2>
1055 typename ResultTraits2<IfThenElseFunctor, T1, T2>::Res
1056 operator()(T1
const & v1, T2
const & v2)
const
1060 return typename ResultTraits2<IfThenElseFunctor, T1, T2>::Res(expr2_(v1, v2));
1064 return typename ResultTraits2<IfThenElseFunctor, T1, T2>::Res(expr3_(v1, v2));
1068 template <
class T1,
class T2,
class T3>
1069 typename ResultTraits3<IfThenElseFunctor, T1, T2, T3>::Res
1070 operator()(T1
const & v1, T2
const & v2, T3
const & v3)
const
1072 if(expr1_(v1, v2, v3))
1074 return typename ResultTraits3<IfThenElseFunctor, T1, T2, T3>::Res(expr2_(v1, v2, v3));
1078 return typename ResultTraits3<IfThenElseFunctor, T1, T2, T3>::Res(expr3_(v1, v2, v3));
1088 IfThenElseFunctor & operator=(IfThenElseFunctor
const &);
1091template <
class EXPR1,
class EXPR2,
class EXPR3>
1092UnaryFunctor<IfThenElseFunctor<UnaryFunctor<EXPR1>,
1093 UnaryFunctor<EXPR2>,
1094 UnaryFunctor<EXPR3> > >
1095ifThenElse(UnaryFunctor<EXPR1>
const & e1,
1096 UnaryFunctor<EXPR2>
const & e2,
1097 UnaryFunctor<EXPR3>
const & e3)
1099 IfThenElseFunctor<UnaryFunctor<EXPR1>,
1100 UnaryFunctor<EXPR2>,
1101 UnaryFunctor<EXPR3> > p(e1, e2, e3);
1102 return UnaryFunctor<IfThenElseFunctor<UnaryFunctor<EXPR1>,
1103 UnaryFunctor<EXPR2>,
1104 UnaryFunctor<EXPR3> > >(p);
1113#define MAKE_FUNCTOR_UNARY_FUNCTION(function, namespc, traitsClass, traitsValue) \
1114 using ::namespc::function; \
1115 template <class EXPR> \
1116 struct Functor_##function; \
1118 template <class EXPR> \
1119 struct ResultTraits0<Functor_##function<EXPR> > \
1121 typedef typename ResultTraits0<EXPR>::Res R1; \
1122 typedef typename traitsClass<R1>::traitsValue Res; \
1125 template <class EXPR, class T1> \
1126 struct ResultTraits1<Functor_##function<EXPR>, T1> \
1128 typedef typename ResultTraits1<EXPR, T1>::Res R1; \
1129 typedef typename traitsClass<R1>::traitsValue Res; \
1132 template <class EXPR, class T1, class T2> \
1133 struct ResultTraits2<Functor_##function<EXPR>, T1, T2> \
1135 typedef typename ResultTraits2<EXPR, T1, T2>::Res R1; \
1136 typedef typename traitsClass<R1>::traitsValue Res; \
1139 template <class EXPR, class T1, class T2, class T3> \
1140 struct ResultTraits3<Functor_##function<EXPR>, T1, T2, T3> \
1142 typedef typename ResultTraits3<EXPR, T1, T2, T3>::Res R1; \
1143 typedef typename traitsClass<R1>::traitsValue Res; \
1146 template <class EXPR> \
1147 struct Functor_##function \
1149 Functor_##function(EXPR const & e) \
1153 typename ResultTraits0<Functor_##function>::Res \
1154 operator()() const \
1156 return function(expr_()); \
1159 template <class T> \
1160 typename ResultTraits1<Functor_##function, T>::Res \
1161 operator()(T const & v1) const \
1163 return function(expr_(v1)); \
1166 template <class T1, class T2> \
1167 typename ResultTraits2<Functor_##function, T1, T2>::Res \
1168 operator()(T1 const & v1, T2 const & v2) const \
1170 return function(expr_(v1, v2)); \
1173 template <class T1, class T2, class T3> \
1174 typename ResultTraits3<Functor_##function, T1, T2, T3>::Res \
1175 operator()(T1 const & v1, T2 const & v2, T3 const & v3) const \
1177 return function(expr_(v1, v2, v3)); \
1185 Functor_##function & operator=(Functor_##function const &); \
1188 template <class EXPR> \
1189 inline UnaryFunctor<Functor_##function<UnaryFunctor<EXPR> > > \
1190 function(UnaryFunctor<EXPR> const & e) \
1192 Functor_##function<UnaryFunctor<EXPR> > p(e); \
1193 return UnaryFunctor<Functor_##function<UnaryFunctor<EXPR> > >(p); \
1198MAKE_FUNCTOR_UNARY_FUNCTION(sq,
vigra, NumericTraits, RealPromote)
1199MAKE_FUNCTOR_UNARY_FUNCTION(sqrt, std, NumericTraits, RealPromote)
1200MAKE_FUNCTOR_UNARY_FUNCTION(exp, std, NumericTraits, RealPromote)
1201MAKE_FUNCTOR_UNARY_FUNCTION(log, std, NumericTraits, RealPromote)
1202MAKE_FUNCTOR_UNARY_FUNCTION(log10, std, NumericTraits, RealPromote)
1203MAKE_FUNCTOR_UNARY_FUNCTION(sin, std, NumericTraits, RealPromote)
1204MAKE_FUNCTOR_UNARY_FUNCTION(asin, std, NumericTraits, RealPromote)
1205MAKE_FUNCTOR_UNARY_FUNCTION(cos, std, NumericTraits, RealPromote)
1206MAKE_FUNCTOR_UNARY_FUNCTION(acos, std, NumericTraits, RealPromote)
1207MAKE_FUNCTOR_UNARY_FUNCTION(tan, std, NumericTraits, RealPromote)
1208MAKE_FUNCTOR_UNARY_FUNCTION(atan, std, NumericTraits, RealPromote)
1209MAKE_FUNCTOR_UNARY_FUNCTION(floor, std, NumericTraits, RealPromote)
1210MAKE_FUNCTOR_UNARY_FUNCTION(ceil, std, NumericTraits, RealPromote)
1211MAKE_FUNCTOR_UNARY_FUNCTION(abs,
vigra, NumericTraits, RealPromote)
1212MAKE_FUNCTOR_UNARY_FUNCTION(
norm,
vigra, NormTraits, NormType)
1213MAKE_FUNCTOR_UNARY_FUNCTION(
squaredNorm,
vigra, NormTraits, SquaredNormType)
1215#undef MAKE_FUNCTOR_UNARY_FUNCTION
1223#define MAKE_FUNCTOR_UNARY_OPERATOR(name, op) \
1224 template <class EXPR> \
1225 struct Functor_##name; \
1227 template <class EXPR> \
1228 struct ResultTraits0<Functor_##name<EXPR> > \
1230 typedef typename ResultTraits0<EXPR>::Res Res; \
1233 template <class EXPR, class T1> \
1234 struct ResultTraits1<Functor_##name<EXPR>, T1> \
1236 typedef typename ResultTraits1<EXPR, T1>::Res Res; \
1239 template <class EXPR, class T1, class T2> \
1240 struct ResultTraits2<Functor_##name<EXPR>, T1, T2> \
1242 typedef typename ResultTraits2<EXPR, T1, T2>::Res Res; \
1245 template <class EXPR, class T1, class T2, class T3> \
1246 struct ResultTraits3<Functor_##name<EXPR>, T1, T2, T3> \
1248 typedef typename ResultTraits3<EXPR, T1, T2, T3>::Res Res; \
1251 template <class EXPR> \
1252 struct Functor_##name \
1254 Functor_##name(EXPR const & e) \
1258 typename ResultTraits0<Functor_##name>::Res \
1259 operator()() const \
1261 return op expr_(); \
1264 template <class T> \
1265 typename ResultTraits1<Functor_##name, T>::Res \
1266 operator()(T const & v1) const \
1268 return op expr_(v1); \
1271 template <class T1, class T2> \
1272 typename ResultTraits2<Functor_##name, T1, T2>::Res \
1273 operator()(T1 const & v1, T2 const & v2) const \
1275 return op expr_(v1, v2); \
1278 template <class T1, class T2, class T3> \
1279 typename ResultTraits3<Functor_##name, T1, T2, T3>::Res \
1280 operator()(T1 const & v1, T2 const & v2, T3 const & v3) const \
1282 return op expr_(v1, v2, v3); \
1289 Functor_##name & operator=(Functor_##name const &);\
1292 template <class EXPR> \
1293 inline UnaryFunctor<Functor_##name<UnaryFunctor<EXPR> > > \
1294 operator op(UnaryFunctor<EXPR> const & e) \
1296 Functor_##name<UnaryFunctor<EXPR> > p(e); \
1297 return UnaryFunctor<Functor_##name<UnaryFunctor<EXPR> > >(p); \
1303MAKE_FUNCTOR_UNARY_OPERATOR(minus, -)
1304MAKE_FUNCTOR_UNARY_OPERATOR(negate, !)
1305MAKE_FUNCTOR_UNARY_OPERATOR(bitNegate, ~)
1307#undef MAKE_FUNCTOR_UNARY_OPERATOR
1315#define MAKE_FUNCTOR_BINARY_FUNCTION(function) \
1316 using std::function; \
1317 template <class EXPR1, class EXPR2> \
1318 struct Functor_##function; \
1320 template <class EXPR1, class EXPR2> \
1321 struct ResultTraits0<Functor_##function<EXPR1, EXPR2> > \
1323 typedef typename ResultTraits0<EXPR1>::Res R1; \
1324 typedef typename ResultTraits0<EXPR2>::Res R2; \
1325 typedef typename PromoteTraits<R1, R2>::Promote R3; \
1326 typedef typename NumericTraits<R3>::RealPromote Res; \
1329 template <class EXPR1, class EXPR2, class T1> \
1330 struct ResultTraits1<Functor_##function<EXPR1, EXPR2>, T1> \
1332 typedef typename ResultTraits1<EXPR1, T1>::Res R1; \
1333 typedef typename ResultTraits1<EXPR2, T1>::Res R2; \
1334 typedef typename PromoteTraits<R1, R2>::Promote R3; \
1335 typedef typename NumericTraits<R3>::RealPromote Res; \
1338 template <class EXPR1, class EXPR2, class T1, class T2> \
1339 struct ResultTraits2<Functor_##function<EXPR1, EXPR2>, T1, T2> \
1341 typedef typename ResultTraits2<EXPR1, T1, T2>::Res R1; \
1342 typedef typename ResultTraits2<EXPR2, T1, T2>::Res R2; \
1343 typedef typename PromoteTraits<R1, R2>::Promote R3; \
1344 typedef typename NumericTraits<R3>::RealPromote Res; \
1347 template <class EXPR1, class EXPR2, class T1, class T2, class T3> \
1348 struct ResultTraits3<Functor_##function<EXPR1, EXPR2>, T1, T2, T3> \
1350 typedef typename ResultTraits3<EXPR1, T1, T2, T3>::Res R1; \
1351 typedef typename ResultTraits3<EXPR2, T1, T2, T3>::Res R2; \
1352 typedef typename PromoteTraits<R1, R2>::Promote R3; \
1353 typedef typename NumericTraits<R3>::RealPromote Res; \
1356 template <class EXPR1, class EXPR2> \
1357 struct Functor_##function \
1359 Functor_##function(EXPR1 const & e1, EXPR2 const & e2) \
1360 : expr1_(e1), expr2_(e2) \
1363 typename ResultTraits0<Functor_##function>::Res \
1364 operator()() const \
1366 return function(expr1_(), expr2_()); \
1369 template <class T> \
1370 typename ResultTraits1<Functor_##function, T>::Res \
1371 operator()(T const & v1) const \
1373 return function(expr1_(v1), expr2_(v1)); \
1376 template <class T1, class T2> \
1377 typename ResultTraits2<Functor_##function, T1, T2>::Res \
1378 operator()(T1 const & v1, T2 const & v2) const \
1380 return function(expr1_(v1, v2), expr2_(v1, v2)); \
1383 template <class T1, class T2, class T3> \
1384 typename ResultTraits3<Functor_##function, T1, T2, T3>::Res \
1385 operator()(T1 const & v1, T2 const & v2, T3 const & v3) const \
1387 return function(expr1_(v1, v2, v3), expr2_(v1, v2, v3)); \
1395 Functor_##function & operator=(Functor_##function const &); \
1398 template <class EXPR1, class EXPR2> \
1399 inline UnaryFunctor<Functor_##function<UnaryFunctor<EXPR1>, UnaryFunctor<EXPR2> > > \
1400 function(UnaryFunctor<EXPR1> const & e1, UnaryFunctor<EXPR2> const & e2) \
1402 Functor_##function<UnaryFunctor<EXPR1>, UnaryFunctor<EXPR2> > p(e1, e2); \
1403 return UnaryFunctor<Functor_##function<UnaryFunctor<EXPR1>, \
1404 UnaryFunctor<EXPR2> > >(p); \
1409MAKE_FUNCTOR_BINARY_FUNCTION(pow)
1410MAKE_FUNCTOR_BINARY_FUNCTION(atan2)
1411MAKE_FUNCTOR_BINARY_FUNCTION(fmod)
1413#undef MAKE_FUNCTOR_BINARY_FUNCTION
1417#define MAKE_FUNCTOR_MINMAX(name, op) \
1418 template <class EXPR1, class EXPR2> \
1419 struct Functor_##name; \
1421 template <class EXPR1, class EXPR2> \
1422 struct ResultTraits0<Functor_##name<EXPR1, EXPR2> > \
1424 typedef typename ResultTraits0<EXPR1>::Res R1; \
1425 typedef typename ResultTraits0<EXPR2>::Res R2; \
1426 typedef typename PromoteTraits<R1, R2>::Promote Res; \
1429 template <class EXPR1, class EXPR2, class T1> \
1430 struct ResultTraits1<Functor_##name<EXPR1, EXPR2>, T1> \
1432 typedef typename ResultTraits1<EXPR1, T1>::Res R1; \
1433 typedef typename ResultTraits1<EXPR2, T1>::Res R2; \
1434 typedef typename PromoteTraits<R1, R2>::Promote Res; \
1437 template <class EXPR1, class EXPR2, class T1, class T2> \
1438 struct ResultTraits2<Functor_##name<EXPR1, EXPR2>, T1, T2> \
1440 typedef typename ResultTraits2<EXPR1, T1, T2>::Res R1; \
1441 typedef typename ResultTraits2<EXPR2, T1, T2>::Res R2; \
1442 typedef typename PromoteTraits<R1, R2>::Promote Res; \
1445 template <class EXPR1, class EXPR2, class T1, class T2, class T3> \
1446 struct ResultTraits3<Functor_##name<EXPR1, EXPR2>, T1, T2, T3> \
1448 typedef typename ResultTraits3<EXPR1, T1, T2, T3>::Res R1; \
1449 typedef typename ResultTraits3<EXPR2, T1, T2, T3>::Res R2; \
1450 typedef typename PromoteTraits<R1, R2>::Promote Res; \
1453 template <class EXPR1, class EXPR2> \
1454 struct Functor_##name \
1456 Functor_##name(EXPR1 const & e1, EXPR2 const & e2) \
1457 : expr1_(e1), expr2_(e2) \
1460 typename ResultTraits0<Functor_##name>::Res \
1461 operator()() const \
1464 ResultTraits0<Functor_##name<EXPR1, EXPR2> >::R1 r1(expr1_()); \
1466 ResultTraits0<Functor_##name<EXPR1, EXPR2> >::R2 r2(expr2_()); \
1467 return (r1 op r2) ? r1 : r2; \
1470 template <class T> \
1471 typename ResultTraits1<Functor_##name, T>::Res \
1472 operator()(T const & v1) const \
1475 ResultTraits1<Functor_##name<EXPR1, EXPR2>, T>::R1 r1(expr1_(v1)); \
1477 ResultTraits1<Functor_##name<EXPR1, EXPR2>, T>::R2 r2(expr2_(v1)); \
1478 return (r1 op r2) ? r1 : r2; \
1481 template <class T1, class T2> \
1482 typename ResultTraits2<Functor_##name, T1, T2>::Res \
1483 operator()(T1 const & v1, T2 const & v2) const \
1486 ResultTraits2<Functor_##name<EXPR1, EXPR2>, T1, T2>::R1 r1(expr1_(v1, v2)); \
1488 ResultTraits2<Functor_##name<EXPR1, EXPR2>, T1, T2>::R2 r2(expr2_(v1, v2)); \
1489 return (r1 op r2) ? r1 : r2; \
1492 template <class T1, class T2, class T3> \
1493 typename ResultTraits3<Functor_##name, T1, T2, T3>::Res \
1494 operator()(T1 const & v1, T2 const & v2, T3 const & v3) const \
1497 ResultTraits3<Functor_##name<EXPR1, EXPR2>, T1, T2, T3>::R1 r1(expr1_(v1, v2, v3)); \
1499 ResultTraits3<Functor_##name<EXPR1, EXPR2>, T1, T2, T3>::R2 r2(expr2_(v1, v2, v3)); \
1500 return (r1 op r2) ? r1 : r2; \
1508 Functor_##name & operator=(Functor_##name const &); \
1511 template <class EXPR1, class EXPR2> \
1512 inline UnaryFunctor<Functor_##name<UnaryFunctor<EXPR1>, UnaryFunctor<EXPR2> > > \
1513 name(UnaryFunctor<EXPR1> const & e1, UnaryFunctor<EXPR2> const & e2) \
1515 Functor_##name<UnaryFunctor<EXPR1>, UnaryFunctor<EXPR2> > p(e1, e2); \
1516 return UnaryFunctor<Functor_##name<UnaryFunctor<EXPR1>, \
1517 UnaryFunctor<EXPR2> > >(p); \
1520MAKE_FUNCTOR_MINMAX(min, <)
1521MAKE_FUNCTOR_MINMAX(max, >)
1523#undef MAKE_FUNCTOR_MINMAX
1531#define MAKE_FUNCTOR_BINARY_OPERATOR(name, op) \
1532 template <class EXPR1, class EXPR2> \
1533 struct Functor_##name; \
1535 template <class EXPR1, class EXPR2> \
1536 struct ResultTraits0<Functor_##name<EXPR1, EXPR2> > \
1538 typedef typename ResultTraits0<EXPR1>::Res R1; \
1539 typedef typename ResultTraits0<EXPR2>::Res R2; \
1540 typedef typename PromoteTraits<R1, R2>::Promote Res; \
1543 template <class EXPR1, class EXPR2, class T1> \
1544 struct ResultTraits1<Functor_##name<EXPR1, EXPR2>, T1> \
1546 typedef typename ResultTraits1<EXPR1, T1>::Res R1; \
1547 typedef typename ResultTraits1<EXPR2, T1>::Res R2; \
1548 typedef typename PromoteTraits<R1, R2>::Promote Res; \
1551 template <class EXPR1, class EXPR2, class T1, class T2> \
1552 struct ResultTraits2<Functor_##name<EXPR1, EXPR2>, T1, T2> \
1554 typedef typename ResultTraits2<EXPR1, T1, T2>::Res R1; \
1555 typedef typename ResultTraits2<EXPR2, T1, T2>::Res R2; \
1556 typedef typename PromoteTraits<R1, R2>::Promote Res; \
1559 template <class EXPR1, class EXPR2, class T1, class T2, class T3> \
1560 struct ResultTraits3<Functor_##name<EXPR1, EXPR2>, T1, T2, T3> \
1562 typedef typename ResultTraits3<EXPR1, T1, T2, T3>::Res R1; \
1563 typedef typename ResultTraits3<EXPR2, T1, T2, T3>::Res R2; \
1564 typedef typename PromoteTraits<R1, R2>::Promote Res; \
1567 template <class EXPR1, class EXPR2> \
1568 struct Functor_##name \
1570 Functor_##name(EXPR1 const & e1, EXPR2 const & e2) \
1571 : expr1_(e1), expr2_(e2) \
1574 typename ResultTraits0<Functor_##name>::Res \
1575 operator()() const \
1577 return expr1_() op expr2_(); \
1580 template <class T> \
1581 typename ResultTraits1<Functor_##name, T>::Res \
1582 operator()(T const & v1) const \
1584 return expr1_(v1) op expr2_(v1); \
1587 template <class T1, class T2> \
1588 typename ResultTraits2<Functor_##name, T1, T2>::Res \
1589 operator()(T1 const & v1, T2 const & v2) const \
1591 return expr1_(v1, v2) op expr2_(v1, v2); \
1594 template <class T1, class T2, class T3> \
1595 typename ResultTraits3<Functor_##name, T1, T2, T3>::Res \
1596 operator()(T1 const & v1, T2 const & v2, T3 const & v3) const \
1598 return expr1_(v1, v2, v3) op expr2_(v1, v2, v3); \
1606 Functor_##name & operator=(Functor_##name const &); \
1609 template <class EXPR1, class EXPR2> \
1610 inline UnaryFunctor<Functor_##name<UnaryFunctor<EXPR1>, UnaryFunctor<EXPR2> > > \
1611 operator op(UnaryFunctor<EXPR1> const & e1, UnaryFunctor<EXPR2> const & e2) \
1613 Functor_##name<UnaryFunctor<EXPR1>, UnaryFunctor<EXPR2> > p(e1, e2); \
1614 return UnaryFunctor<Functor_##name<UnaryFunctor<EXPR1>, \
1615 UnaryFunctor<EXPR2> > >(p); \
1620MAKE_FUNCTOR_BINARY_OPERATOR(
add, +)
1621MAKE_FUNCTOR_BINARY_OPERATOR(subtract, -)
1622MAKE_FUNCTOR_BINARY_OPERATOR(multiply, *)
1623MAKE_FUNCTOR_BINARY_OPERATOR(divide, /)
1624MAKE_FUNCTOR_BINARY_OPERATOR(modulo, %)
1625MAKE_FUNCTOR_BINARY_OPERATOR(bitAnd, &)
1626MAKE_FUNCTOR_BINARY_OPERATOR(bitOr, |)
1627MAKE_FUNCTOR_BINARY_OPERATOR(bitXor, ^)
1629#undef MAKE_FUNCTOR_BINARY_OPERATOR
1633#define MAKE_FUNCTOR_BINARY_OPERATOR_BOOL(name, op) \
1634 template <class EXPR1, class EXPR2> \
1635 struct Functor_##name; \
1637 template <class EXPR1, class EXPR2> \
1638 struct ResultTraits0<Functor_##name<EXPR1, EXPR2> > \
1643 template <class EXPR1, class EXPR2, class T1> \
1644 struct ResultTraits1<Functor_##name<EXPR1, EXPR2>, T1> \
1649 template <class EXPR1, class EXPR2, class T1, class T2> \
1650 struct ResultTraits2<Functor_##name<EXPR1, EXPR2>, T1, T2> \
1655 template <class EXPR1, class EXPR2, class T1, class T2, class T3> \
1656 struct ResultTraits3<Functor_##name<EXPR1, EXPR2>, T1, T2, T3> \
1661 template <class EXPR1, class EXPR2> \
1662 struct Functor_##name \
1664 Functor_##name(EXPR1 const & e1, EXPR2 const & e2) \
1665 : expr1_(e1), expr2_(e2) \
1668 bool operator()() const \
1670 return expr1_() op expr2_(); \
1673 template <class T> \
1674 bool operator()(T const & v1) const \
1676 return expr1_(v1) op expr2_(v1); \
1679 template <class T1, class T2> \
1680 bool operator()(T1 const & v1, T2 const & v2) const \
1682 return expr1_(v1, v2) op expr2_(v1, v2); \
1685 template <class T1, class T2, class T3> \
1686 bool operator()(T1 const & v1, T2 const & v2, T3 const & v3) const \
1688 return expr1_(v1, v2, v3) op expr2_(v1, v2, v3); \
1696 Functor_##name & operator=(Functor_##name const &); \
1699 template <class EXPR1, class EXPR2> \
1700 inline UnaryFunctor<Functor_##name<UnaryFunctor<EXPR1>, UnaryFunctor<EXPR2> > > \
1701 operator op(UnaryFunctor<EXPR1> const & e1, UnaryFunctor<EXPR2> const & e2) \
1703 Functor_##name<UnaryFunctor<EXPR1>, UnaryFunctor<EXPR2> > p(e1, e2); \
1704 return UnaryFunctor<Functor_##name<UnaryFunctor<EXPR1>, \
1705 UnaryFunctor<EXPR2> > >(p); \
1711#pragma GCC diagnostic push
1712#pragma GCC diagnostic ignored "-Wsign-compare"
1715MAKE_FUNCTOR_BINARY_OPERATOR_BOOL(equals, ==)
1716MAKE_FUNCTOR_BINARY_OPERATOR_BOOL(differs, !=)
1717MAKE_FUNCTOR_BINARY_OPERATOR_BOOL(less, <)
1718MAKE_FUNCTOR_BINARY_OPERATOR_BOOL(lessEqual, <=)
1719MAKE_FUNCTOR_BINARY_OPERATOR_BOOL(greater, >)
1720MAKE_FUNCTOR_BINARY_OPERATOR_BOOL(greaterEqual, >=)
1721MAKE_FUNCTOR_BINARY_OPERATOR_BOOL(and, &&)
1722MAKE_FUNCTOR_BINARY_OPERATOR_BOOL(or, ||)
1725#pragma GCC diagnostic pop
1728#undef MAKE_FUNCTOR_BINARY_OPERATOR_BOOL
1736template <
class EXPR,
class RES,
class ARG>
1737struct UnaryFctPtrFunctor
1739 UnaryFctPtrFunctor(EXPR
const & e, RES (*fct)(ARG))
1743 RES operator()()
const
1749 RES operator()(T
const & v1)
const
1751 return f_(expr_(v1));
1754 template <
class T1,
class T2>
1755 RES operator()(T1
const & v1, T2
const & v2)
const
1757 return f_(expr_(v1, v2));
1760 template <
class T1,
class T2,
class T3>
1761 RES operator()(T1
const & v1, T2
const & v2, T3
const & v3)
const
1763 return f_(expr_(v1, v2, v3));
1771 UnaryFctPtrFunctor & operator=(UnaryFctPtrFunctor
const &);
1774template <
class EXPR,
class RES,
class ARG>
1775struct ResultTraits0<UnaryFctPtrFunctor<EXPR, RES, ARG> >
1780template <
class EXPR,
class RES,
class ARG,
class T1>
1781struct ResultTraits1<UnaryFctPtrFunctor<EXPR, RES, ARG>, T1>
1786template <
class EXPR,
class RES,
class ARG,
class T1,
class T2>
1787struct ResultTraits2<UnaryFctPtrFunctor<EXPR, RES, ARG>, T1, T2>
1792template <
class EXPR,
class RES,
class ARG,
class T1,
class T2,
class T3>
1793struct ResultTraits3<UnaryFctPtrFunctor<EXPR, RES, ARG>, T1, T2, T3>
1798template <
class EXPR,
class RES,
class ARG>
1799inline UnaryFunctor<UnaryFctPtrFunctor<UnaryFunctor<EXPR>, RES, ARG> >
1800applyFct(RES (*f)(ARG), UnaryFunctor<EXPR>
const & e)
1802 UnaryFctPtrFunctor<UnaryFunctor<EXPR>, RES, ARG> p(e, f);
1803 return UnaryFunctor<UnaryFctPtrFunctor<UnaryFunctor<EXPR>, RES, ARG> >(p);
1812template <
class EXPR1,
class EXPR2,
class RES,
class ARG1,
class ARG2>
1813struct BinaryFctPtrFunctor
1815 BinaryFctPtrFunctor(EXPR1
const & e1, EXPR2
const & e2,
1816 RES (*f)(ARG1, ARG2))
1817 : expr1_(e1), expr2_(e2), f_(f)
1820 RES operator()()
const
1822 return f_(expr1_(), expr2_());
1826 RES operator()(T
const & v1)
const
1828 return f_(expr1_(v1), expr2_(v1));
1831 template <
class T1,
class T2>
1832 RES operator()(T1
const & v1, T2
const & v2)
const
1834 return f_(expr1_(v1, v2), expr2_(v1, v2));
1837 template <
class T1,
class T2,
class T3>
1838 RES operator()(T1
const & v1, T2
const & v2, T3
const & v3)
const
1840 return f_(expr1_(v1, v2, v3), expr2_(v1, v2, v3));
1847 RES (*f_)(ARG1, ARG2);
1850 BinaryFctPtrFunctor & operator=(BinaryFctPtrFunctor
const &);
1853template <
class EXPR1,
class EXPR2,
class RES,
class ARG1,
class ARG2>
1854struct ResultTraits0<BinaryFctPtrFunctor<EXPR1, EXPR2, RES, ARG1, ARG2> >
1859template <
class EXPR1,
class EXPR2,
class RES,
class ARG1,
class ARG2,
1861struct ResultTraits1<BinaryFctPtrFunctor<EXPR1, EXPR2, RES, ARG1, ARG2>, T1>
1866template <
class EXPR1,
class EXPR2,
class RES,
class ARG1,
class ARG2,
1868struct ResultTraits2<BinaryFctPtrFunctor<EXPR1, EXPR2, RES, ARG1, ARG2>, T1, T2>
1873template <
class EXPR1,
class EXPR2,
class RES,
class ARG1,
class ARG2,
1874 class T1,
class T2,
class T3>
1875struct ResultTraits3<BinaryFctPtrFunctor<EXPR1, EXPR2, RES, ARG1, ARG2>, T1, T2, T3>
1880template <
class EXPR1,
class EXPR2,
class RES,
class ARG1,
class ARG2>
1881inline UnaryFunctor<BinaryFctPtrFunctor<UnaryFunctor<EXPR1>,
1882 UnaryFunctor<EXPR2>,
1884applyFct(RES (*f)(ARG1, ARG2), UnaryFunctor<EXPR1>
const & e1,
1885 UnaryFunctor<EXPR2>
const & e2)
1887 BinaryFctPtrFunctor<UnaryFunctor<EXPR1>,
1888 UnaryFunctor<EXPR2>,
1889 RES, ARG1, ARG2> p(e1, e2, f);
1890 return UnaryFunctor<BinaryFctPtrFunctor<UnaryFunctor<EXPR1>,
1891 UnaryFunctor<EXPR2>,
1892 RES, ARG1, ARG2> >(p);
1901template <
class EXPR1,
class EXPR2>
1904 CommaFunctor(EXPR1
const & e1, EXPR2
const & e2)
1905 : expr1_(e1), expr2_(e2)
1908 typename ResultTraits0<EXPR2>::Res
1916 typename ResultTraits1<EXPR2, T>::Res
1917 operator()(T
const & v1)
const
1923 template <
class T1,
class T2>
1924 typename ResultTraits2<EXPR2, T1, T2>::Res
1925 operator()(T1
const & v1, T2
const & v2)
const
1928 return expr2_(v1, v2);
1931 template <
class T1,
class T2,
class T3>
1932 typename ResultTraits3<EXPR2, T1, T2, T3>::Res
1933 operator()(T1
const & v1, T2
const & v2, T3
const & v3)
const
1936 return expr2_(v1, v2, v3);
1945 CommaFunctor & operator=(CommaFunctor
const &);
1948template <
class Expr1,
class Expr2>
1949struct ResultTraits0<CommaFunctor<Expr1, Expr2> >
1951 typedef typename ResultTraits0<Expr2>::Res Res;
1954template <
class Expr1,
class Expr2,
class T1>
1955struct ResultTraits1<CommaFunctor<Expr1, Expr2>, T1>
1957 typedef typename ResultTraits1<Expr2, T1>::Res Res;
1960template <
class Expr1,
class Expr2,
class T1,
class T2>
1961struct ResultTraits2<CommaFunctor<Expr1, Expr2>, T1, T2>
1963 typedef typename ResultTraits2<Expr2, T1, T2>::Res Res;
1966template <
class Expr1,
class Expr2,
class T1,
class T2,
class T3>
1967struct ResultTraits3<CommaFunctor<Expr1, Expr2>, T1, T2, T3>
1969 typedef typename ResultTraits3<Expr2, T1, T2, T3>::Res Res;
1972template <
class EXPR1,
class EXPR2>
1973inline UnaryFunctor<CommaFunctor<UnaryAnalyser<EXPR1>,
1974 UnaryFunctor<EXPR2> > >
1975operator,(UnaryAnalyser<EXPR1>
const & e1,
1976 UnaryFunctor<EXPR2>
const & e2)
1978 CommaFunctor<UnaryAnalyser<EXPR1>,
1979 UnaryFunctor<EXPR2> > p(e1, e2);
1980 return UnaryFunctor<CommaFunctor<UnaryAnalyser<EXPR1>,
1981 UnaryFunctor<EXPR2> > >(p);
1986template <
class EXPR1,
class EXPR2>
1989 CommaAnalyser(EXPR1
const & e1, EXPR2
const & e2)
1990 : expr1_(e1), expr2_(e2)
1993 void operator()()
const
2000 void operator()(T
const & v1)
const
2006 template <
class T1,
class T2>
2007 void operator()(T1
const & v1, T2
const & v2)
const
2013 template <
class T1,
class T2,
class T3>
2014 void operator()(T1
const & v1, T2
const & v2, T3
const & v3)
const
2026 CommaAnalyser & operator=(CommaAnalyser
const &);
2029template <
class EXPR1,
class EXPR2>
2030inline UnaryAnalyser<CommaAnalyser<UnaryAnalyser<EXPR1>,
2031 UnaryAnalyser<EXPR2> > >
2032operator,(UnaryAnalyser<EXPR1>
const & e1,
2033 UnaryAnalyser<EXPR2>
const & e2)
2035 CommaAnalyser<UnaryAnalyser<EXPR1>,
2036 UnaryAnalyser<EXPR2> > p(e1, e2);
2037 return UnaryAnalyser<CommaAnalyser<UnaryAnalyser<EXPR1>,
2038 UnaryAnalyser<EXPR2> > >(p);
2043#if defined(__GNUC__) && __GNUC__ < 3
2047using functor::Param;
2051class FunctorTraits<functor::UnaryFunctor<T> >
2052:
public FunctorTraitsBase<functor::UnaryFunctor<T> >
2055 typedef VigraTrueType isInitializer;
2056 typedef VigraTrueType isUnaryFunctor;
2057 typedef VigraTrueType isBinaryFunctor;
2058 typedef VigraTrueType isTernaryFunctor;
2062class FunctorTraits<functor::UnaryAnalyser<T> >
2063:
public FunctorTraitsBase<functor::UnaryAnalyser<T> >
2066 typedef VigraTrueType isUnaryAnalyser;
2067 typedef VigraTrueType isBinaryAnalyser;
2068 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