Re: [Boost-users] Two questions on boost::function

Subject: Re: [Boost-users] Two questions on boost::function
From: OvermindDL1 (overminddl1_at_[hidden])
Date: 2009-11-28 21:39:44

On Sat, Nov 28, 2009 at 6:15 AM, CR Koudella <ckoudell_at_[hidden]> wrote:
>
> Hi,
>
> thank you very much for your help.
>
> What you suggest works fine, thanks. I have 'studied' the boost lambda
> library a bit and get the
> feeling as it says in the intro to the doc that it is especially meant to
> write small lambda expressions
> for use with the STL. I am not actually that interested in this use and am
> having a bit of time trying
> to get it to do some other things.
>
> Imagine I want to do the following operation [h * (f - g)^2](x), where the x
> is 'const std::vector<double> &',
> all functions return double and h(x) = k1 and g(x) = k2, where k1, k2 =
> const. f is some non-trivial function. I can make this work according to the
> method you indicate. I am not entirely sure what the optimal is to build the
> lambda
> expressions for the constant functions h and g, see below. It seems that I
> need to drive this step through
> boost::function, otherwise the code won't compile.
>
> Â Â Â  // some function f given...
>
> Â Â Â  // constant h functor
> Â Â Â  const double dh = 4.0;
> Â Â Â  bll::constant_type<double>::type lh(bll::constant(dh));
> Â Â Â  boost::function<double (const std::vector<double> & vecArg)> bfoh;
> Â Â Â  bfoh = lh;
>
> Â Â Â  // constant g functor
> Â Â Â  const double dg = 0.5;
> Â Â Â  bll::constant_type<double>::type lg(bll::constant(dg));
> Â Â Â  boost::function<double (const std::vector<double> & vecArg)> bfog;
> Â Â Â  bfog = lg;
>
> Â Â Â  // construct h * (f - g)^2
> Â Â Â  // f - g
> Â Â Â  boost::function<double (const std::vector<double> & vecArg)> bfoDF;
> Â Â Â  bfoDF = bll::bind(f, bll::_1) - bll::bind(bfog, bll::_1);
>
> Â Â Â  // (f - g)^2
> Â Â Â  boost::function<double (const std::vector<double> & vecArg)> bfoSF;
> Â Â Â  bfoSF = bll::bind(bfoDF, bll::_1) * bll::bind(bfoDF, bll::_1);
>
> Â Â Â  // h * (f -g)^2
> Â Â Â  boost::function<double (const std::vector<double> & vecArg)> bfoWRF;
> Â Â Â  bfoWRF = bll::bind(bfoh, bll::_1) * bll::bind(bfoSF, bll::_1);
>
> Other than this, the repetitive use of bll::bind at every stage and
> generally speaking,
> the wordiness of the script makes me wonder whether this is the right thing
> to use
> or if I am using it as I should. I mean h*(f-g)^2 is a pretty simple
> operation. Any
> comments on how to improve the above? In particular on how to build the
> constant
> functors h and g?
>
> Another question I have is, would it be possible to combine functors with
> different
> return types in the same way? Imagine j(x) is now a function that takes in
> an
> std::vector<double> and returns an std::vector<double>. Then can it be
> scaled
> with a function that takes in an std::vector<double>, but returns a double?
>
> BTW, a propos extracting the underlying functor out of a boost::function,
> yes it
> isn't ideal, but you might just need to acess the underlying interface at
> some
> point.

For note, that is all easier with Boost.Phoenix, which supersedes
Boost.Lambda, has all of its functionality and a great deal more.