Hello,
There are a few posts these days about generic libraries for math derivation
of math functions, analytically or numerically.
My objective is to start simple with analytical functions, and to expand the
result gradually.
I have used proto to define terminals :
1. 1D constants
2. 1D variables
3. 1D basic functions ( c++03 cmath + boost::math )
4. user-defined functions ( 0 or more dimensions )
HEADER
struct constant_tag {};
typedef proto::terminal< constant_tag >::type constant;
struct variable_tag {};
typedef proto::terminal< variable_tag >::type variable;
template < double (*basic_function_ptr)(double) >
struct basic_function_tag {
typedef double result_type;
result_type operator()(double d) const { return basic_function_ptr(d); }
};
proto::terminal< basic_function_tagstd::log >::type const log = {{}}; //
1 example, I have one of these for each function
template struct function_tag {};
template
struct function : proto::terminal< function_tag<1> >::type
{};
USER CODE
------------------
constant c;
variable x,y,z,t,u,v;
function<0> h;
function<1> f;
function<5> g;
My grammar will be very simple for a start. All I want to allow are
statements like:
1.variable = constant(proto terminal) or literal (actual number, does it
have to be proto terminal), for e.g.
x = 5;
2. function definition with the = operator. The LHS of the operator can one
of:
h =
h() =
f(x) =
g(x,y,z,t,u) =
// All arguments of f should be "variable"s only and they can't be repeated,
and they have to match the dimension
my LHS grammar looks like:
template
struct function_def_lhs_grammar
: proto::function< function_tag<dim>, proto::vararg< proto::terminal<
variable_tag > > >
{};
template <>
struct function_def_lhs_grammar<0>
: proto::or_<
proto::terminal< function_tag<0> >,
proto::function< function_tag<0>, proto::vararg< proto::terminal<
variable_tag > > >
{};
But vararg is not what I want at all:
I want to have 0 variables (nothing) for the 0-dim function in the
proto::function case,
And I want to have exactly dim variables in the dim>0 proto::function case.
Is it possible to "math-define" the function at the same time of the
function<> object definition (in c++ terms) and have the dimension deducted,
like:
function f(x,y,z) = x+y+z ;
The next step will be to worry about the RHS which is the much more
complicated bit,
regards,
