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