Steven: beautifully simple code on your previous post. &nbsp;I just fear that MPL is beyond the reach of mortals such as myself because I could never come up with that solution.<div><br></div><div>If people are in the mood for this kind of stuff, let me post on a set of questions coming up in my libraries:<br>
</div><div>1) QUESTION 1: MANAGING DERIVATIVES FOR FUNCTIONS</div><div>* I am doing a lot of work with functions that may have an associated derivative analytically or numerically determined.<br></div><div>* This is the tip of the iceberg in associating a bunch of information with a mathematical function that all needs to be bundled.</div>
<div>* I have been creating functors like the following:</div><div>template &lt;class ParamType&gt;</div><div>struct square{</div><div>&nbsp;&nbsp;typedef double result_type; //For adaptors</div><div>&nbsp;&nbsp;double operator()(double x, const ParamType&amp; params ) { return x*x;}</div>
<div>&nbsp;&nbsp;double gradient(double x,&nbsp;const ParamType&amp; params&nbsp;){return 2 * x;}</div><div>&nbsp;&nbsp;boost::function&lt;double (double,const ParamType&amp; params)&gt;&nbsp;&nbsp;gradient(){return boost::bind(&amp;square::gradient, *this, _1, _2)}; //I forget the exact notation for bind with member functions, but the idea is that it would return a boost::function.</div>
<div>}; //Analytical derivative</div><div><br></div><div>But I would also love the ability to use finitedifference or autodifferentiation algorithms for more complicated examples. &nbsp;Perhaps something like:</div><div><br></div>
<div>struct square : finite_differences&lt;int Order&gt;{<br></div><div>&nbsp;&nbsp;&nbsp;&nbsp;double operator()(double x, const ParamType&amp; params ) { return x*x;}</div><div>}; //Analytical derivative</div><div><br></div><div>* Ideally here, finite_differences&lt;int Order&gt; would be able to generate the derivative using order taylor series approx and the operator() to evaluate the function. &nbsp;Even here I am not sure the best way to organize it.</div>
<div><br></div><div>2) QUESTION 2: ADAPTATION AND USE LIKE BOOST::FUNCTION</div><div>Now, lets say that there was something similar to boost::function but which had the &quot;derivative&quot; concept to call.gradient(...) to evaluate grad, or return a functor which is the gradient as another function.. &nbsp;Lets call it math_function for now. &nbsp;The behavior is things like the following:</div>
<div>using lambda::_1;</div><div>using lambda::_2;</div><div>math_function&lt;double (double)&gt; mysquare(_1 * _1); //This will generate a math_function with the finite differences as its derivative.<br></div><div>assert(mysquare(1) == 1);</div>
<div>math_function&lt;double (double)&gt; mysquaregrad = mysquare.gradient(); //Gets the derivative, which was generated through finite differences. &nbsp;This could then be used to get the .gradient again for example.<br></div>
<div>assert(mysquare.gradient(.1) == mysquaregrad(.1));</div><div><br></div><div>math_function&lt;double (double, int)&gt; myfunc(_1 + _2);</div><div>math_function&lt;double (double)&gt; myboundfunc = bind(my_func, _1, 3);</div>
<div>assert(myboundfunc.gradient(1.0) == 4.0);</div><div><br></div><div>//And then to create one with an analytical derivative</div><div>math_function&lt;double (double)&gt; mysquare(_1 * _1, 2 * _1);</div><div>assert(mysquare.gradient(1.0) == 2.0); //evaluated through the analytical derivative.<br>
</div><div><div>boost::function&lt;double (double)&gt; myboostsquare = mysquare.as_function(); //would be nice for interoperability... or something similar.</div><div><br></div></div><div>//Then we can create a class such as polynomial which subclasses math_function</div>
<div>polynomial_function&lt;3&gt; mypoly({{2, 3, 5}}); //Creates a third order polynomial. &nbsp;The operator() uses fancy algorithms for polynomial evaluation.</div><div>math_function&lt;double (double)&gt; mypoly2 = mypoly; //Can adapt to a math_function for use in generic algorithms.</div>
<div>math_function&lt;double (double)&gt; mypolygrad1 = mypoly.gradient();</div><div>polynomial_function&lt;2&gt; mypolygrad2 = mypoly.gradient(); //Maybe this is getting too fancy...</div><div><br></div><div>3) QUESTION 3: WHY DO I WANT ALL THIS STUFF?</div>
<div>For the same reason that boost::function is so useful for functional programming. I am going to have a million permutations on this kind of pattern, am writing very generic algorithms, and would prefer not to have to write a superclass for every permutation of parameters. &nbsp;I want to be able to freely bind to it, easily use lambdas, and eventually want to add a bunch of other traits such as # of derivatives, range/domain, continuity, hessians, etc. that can be uniformly managed.</div>
<div><br></div><div>4) QUESTION 4: AM I INSANE?</div><div>Is this at all possible or has something similar been done? &nbsp;It seems to me that it might be, but I am likely not be capable of doing it. &nbsp;Is piggybacking boost::function in some smart way here the best approach? &nbsp;Even if we can&#39;t subclass directly, can we copy the source code and intelligently add in a few extra functions, etc.?</div>