Re: [Boost-users] [lambda][phoenix] make lambda/phoenix play well with std::complex, imag, real, abs, etc.

6 Jun 2010


      On 6/6/10 10:10 AM, alfC wrote:
...
On Jun 2, 2:01 pm, alfC  wrote:
...
Hi, I need some complex arithmetic in lambda expressions, for that I
implemented this to make some std::complex functions work with
Boost.Lambda.
...
2) it seem imposible to generalized to other template overloads of
imag<T>, real<T>  (i.e. something that can be used for std::complex<T>)
because the template parameter Arg doesn't have information about the
actual type. is it so?
I think I now appreciate what Joel DG. refers to when he says that
bind functions are monomorphic, and why they cannot do what I pointed
in 2).
The following is the Phoenix equivalent, i.e. the code that makes
std::complex play well with Phoenix, moreover it is truly polymorphic,
they work for all std::complex<T>  types, (in fact it should work for
any type that has the nested type ::value_type)
#ifndef BOOST_PHOENIX_COMPLEX_HPP
#define BOOST_PHOENIX_COMPLEX_HPP
#include
#include<complex>
namespace boost{
namespace phoenix{
#define BOOST_PHOENIX_UNARY_COMPLEX_TO_REAL( FunctionnamE ) \
  struct FunctionnamE##_eval{ \
      template  struct result{typedef
typename boost::mpl::at_c::type::value_type type;}; \
      template  static RT
eval(Env const&  env, Arg_ const&  arg_){ \
      	return FunctionnamE(arg_.eval(env)); \
      } \
  }; \
  template<typename Arg_>  actor::type>  \
  FunctionnamE(Arg_ const&  arg_){ \
      return compose(arg_); \
  }
//as listed in http://www.cplusplus.com/reference/std/complex/
BOOST_PHOENIX_UNARY_COMPLEX_TO_REAL( real )
BOOST_PHOENIX_UNARY_COMPLEX_TO_REAL( imag )
BOOST_PHOENIX_UNARY_COMPLEX_TO_REAL( abs )
BOOST_PHOENIX_UNARY_COMPLEX_TO_REAL( norm )
BOOST_PHOENIX_UNARY_COMPLEX_TO_REAL( arg ) //argument complex
function, do not confuse with arg_
#undef BOOST_PHOENIX_UNARY_COMPLEX_TO_REAL
#define BOOST_PHOENIX_UNARY_COMPLEX_TO_COMPLEX( FunctionnamE ) \
  struct FunctionnamE##_eval{ \
      template  struct result{typedef
typename boost::mpl::at_c::type type;}; \
      template  static RT
eval(Env const&  env, Arg_ const&  arg_){ \
      	return FunctionnamE(arg_.eval(env)); \
      } \
  }; \
  template<typename Arg_>  actor::type>  \
  FunctionnamE(Arg_ const&  arg_){ \
      return compose(arg_); \
  }
  BOOST_PHOENIX_UNARY_COMPLEX_TO_COMPLEX( conj  )
  //todo: polar
BOOST_PHOENIX_UNARY_COMPLEX_TO_COMPLEX( cos   )
  BOOST_PHOENIX_UNARY_COMPLEX_TO_COMPLEX( cosh  )
  BOOST_PHOENIX_UNARY_COMPLEX_TO_COMPLEX( exp   )
  BOOST_PHOENIX_UNARY_COMPLEX_TO_COMPLEX( log   )
  BOOST_PHOENIX_UNARY_COMPLEX_TO_COMPLEX( log10 )
  BOOST_PHOENIX_UNARY_COMPLEX_TO_COMPLEX( pow   )
  BOOST_PHOENIX_UNARY_COMPLEX_TO_COMPLEX( sin   )
  BOOST_PHOENIX_UNARY_COMPLEX_TO_COMPLEX( sinh  )
  BOOST_PHOENIX_UNARY_COMPLEX_TO_COMPLEX( sqrt  )
  BOOST_PHOENIX_UNARY_COMPLEX_TO_COMPLEX( tan   )
  BOOST_PHOENIX_UNARY_COMPLEX_TO_COMPLEX( tanh  )
#undef BOOST_PHOENIX_UNARY_COMPLEX_TO_COMPLEX
}}
#endif
Is there a reason why you are not using plain phoenix::function(s)
for this?

Regards,
-- 
Joel de Guzman
http://www.boostpro.com
http://spirit.sf.net