-----Original Message-----
From: boost-users-bounces@lists.boost.org [mailto:boost-users-bounces@lists.boost.org] On Behalf Of Eric Niebler
Sent: 07 March 2009 02:32
To: boost-users@lists.boost.org
Subject: Re: [Boost-users] proto: analytical-only math functions

Hicham Mouline wrote:

>

> Step1 is to have a derivative metafunction which computers the nth

> derivative of a function at compile time.

>

> In order to do that, I need a mathematical language to write my

> functions.

>

> so I have constants, variables, basic_functions and user-defined

> functions that are terminals of my language

>

> f(x) = log(x);

>

> g(x) = derivative(1, f, x);

>

> g(x) will be 1/x;

>

> I should manage to run derivative purely in compile time.

You won't be able to do it this way with exactly this syntax. The object

"f" will not carry the compile-time information that derivative() would

need to do its job. You might need something like this:

   BOOST_PROTO_AUTO( _f, f(x) = log(x) );

   BOOST_PROTO_AUTO( _g, g(x) = derivative(1, _f, x) );

Hmm. That is a bit unfortunate. I don’t like very much how this syntax looks like.

I thought I could store the expression tree inside the f objects themselves…

that is I thought the operator= or the ctor of the function_tag could be run entirely at compile-time?

But I realize it might not be possible:

The ideal syntax would be:

function<2> f(x,y) = x*y + x – y;  

// f object defined in c++ terms and at the same assigned to the expression tree

// all at compile time

// The above can’t be correct c++ right?  Both construction and call to operator=

// how about the following?

const function<2> f(x, y, x*y + x – y);  // this might be ok, only constructor called

//can this be ran entirely at compile time?

Or, you could do it all in one big expression, like:

   let( f(x) = log(x) )[ g(x) = derivative(1, f, x) ];

or something. And if I'm right in assuming that the first parameter of

derivative is which derivative to take, you'll need to make that

information available at compile-time as well, so:

   let( f(x) = log(x) )[ g(x) = derivative<1>(f, x) ];

Yes, I didn’t think the derivative function/metafunction through. These are the valid expressions:

derivative<1>(f, x)   // first order derivative of f wrt to x

derivative<1>(f, y)   // first order derivative of f wrt to y

derivative<2>(f, x)   // second order derivative of f wrt to x

derivative<2>(f, y)   // second order derivative of f wrt to y

derivative<2>(f, x, y)   // second order cross derivative of f wrt to x and y

in general, a n-dim function of n variables x1…xn, you can define all these valid expression

derivative<1>(f, x1)…. derivative<1>(f, xn)

derivative<2>(f, x1)…. derivative<2>(f, xn) derivative<2>(f, x1, x2)… all combinations of 2 vars

derivative<3>(f, x1)…. )…. derivative<3>(f, xn) derivative<3>(f, x1, x2) derivative<3>(f, x1, x3)… derivative<3>(f, x1, x2, x3)… all comb. of 3 vars

…

derivative<n>(f, x1)…. You get the idea

For now, I am still focusing on constants.

Thanks very much,