Hi Andrew,
just my thoughts on this chat.
Andrew Durward schrieb:
The central concept is that for any expression (a # b) where # is {+, -, *},
the result can be expressed as (x + y) where x is the floating-point
How about transform the expression a+b to sum_approx(a,b)+sum_diff(a,b)
instead to fusion::cons > ?
The advantage of this approach is that you still get an ast where childs
are held in terminal (instead in cons).
approximation of (a # b), and y is an error term whose value can also be
computed as a floating-point value.
In toying with proto, I've been able to transform simple expressions
successfully but I can't seem to figure out how to define a grammar that
will handle arbitrary combinations of {+, -, *} recursively. Here's what
I've got so far:
struct sum_approx{/* */};
struct sum_error{/* */};
struct diff_approx{/* */};
struct diff_error{/* */};
struct prod_approx{/* */};
struct prod_error{/* */};
struct Transform :
proto::or_<
proto::when<
proto::plus< proto::terminal< _ >, proto::terminal< _ > >
, fusion::cons<
proto::_make_function(
sum_approx()
, proto::_left
, proto::_right
)
I dont see the meaning behind this step. If you use
proto::_make_function you create a child in the ast, but you put this
child in a fusion::cons.
, fusion::cons<
proto::_make_function(
sum_error()
, proto::_left
, proto::_right
)
>
>()
>
// ... similar substitutions for minus and multiplies
>
{};
So the expression (a + b) yields the sequence:
sum_approx(a,b)
sum_error(a,b)
Here's where I'm stuck. In the case of the expression (a + b)*(c - d), the
addition and subtraction should be replaced by the appropriate sequences
before the multiplication gets expanded to yield the final sequence:
prod_approx( sum_approx(a,b), diff_approx(c,d) )
prod_error( sum_approx(a,b), diff_approx(c,d) )
prod_approx( sum_approx(a,b), diff_error(c,d) )
prod_error( sum_approx(a,b), diff_error(c,d) )
prod_approx( sum_error(a,b), diff_approx(c,d) )
prod_error( sum_error(a,b), diff_approx(c,d) )
prod_approx( sum_error(a,b), diff_error(c,d) )
prod_error( sum_error(a,b), diff_error(c,d) )
Are you sure that you want to get a sequence of expression instead an
ast. In case you really want to get a sequence you can use
proto::tag::comma to separate your child.
Obviously I need a recursive transform here but I'm not sure how to pass it
the sequences generated by both the left and right subtrees.
Cheers,
Kim
Here is a toy project.
Hth.
# include
# include
# include
# include
# include
# define PRECISION_MAKE_tag(name) \
struct name \
{ \
friend std::ostream& operator<< (std::ostream& s, name const&) \
{ \
return s<< #name; \
} \
};
# define PRECISION_MAKE_terminal(name) \
proto::terminal< tag::name >::type const name = {{}}
namespace proto = boost::proto;
namespace tag{
PRECISION_MAKE_tag(a);
PRECISION_MAKE_tag(b);
PRECISION_MAKE_tag(c);
PRECISION_MAKE_tag(d);
PRECISION_MAKE_tag(sum_approx);
PRECISION_MAKE_tag(sum_error);
PRECISION_MAKE_tag(diff_approx);
PRECISION_MAKE_tag(diff_error);
}
namespace mpl = boost::mpl;
namespace fusion = boost::fusion;
using proto::_;
struct transform
{
BOOST_PROTO_CALLABLE()
template<typename Sig>
struct result;
template
struct result
: proto::result_of::make_expr<
proto::tag::plus
, typename proto::result_of::make_expr<
proto::tag::function ,tag::sum_approx, A0, A1
>::type
, typename proto::result_of::make_expr<
proto::tag::function ,tag::sum_error, A0, A1
>::type
>
{};
template
struct result
: proto::result_of::make_expr<
proto::tag::minus, A0, A1
>
{};
template
typename result::type
operator()(proto::tag::plus const ,A0 const& a0,A1 const& a1) const
{
return proto::make_exprproto::tag::plus(
proto::make_exprproto::tag::function(
tag::sum_approx()
, boost::ref(a0)
, boost::ref(a1))
,proto::make_exprproto::tag::function(
tag::sum_error()
, boost::ref(a0)
, boost::ref(a1))
);
//return proto::make_exprproto::tag::plus(boost::ref(a0), boost::ref(a1));
};
template
typename result::type
operator()(proto::tag::minus const ,A0 const& a0, A1 const& a1) const
{
return proto::make_exprproto::tag::minus(boost::ref(a0), boost::ref(a1));
};
};
struct Transform
: proto::or_<
proto::when<
proto::plus< proto::terminal< _ >, proto::terminal< _ > >
, transform(
proto::tag::plus()
, proto::_value(proto::_left)
, proto::_value(proto::_right)
)
>
,proto::when<
proto::minus< proto::terminal< _ >, proto::terminal< _ > >
, transform(
proto::tag::minus()
, proto::_value(proto::_left)
, proto::_value(proto::_right)
)
>
, proto::otherwise >
>
{};
PRECISION_MAKE_terminal(a);
PRECISION_MAKE_terminal(b);
PRECISION_MAKE_terminal(c);
PRECISION_MAKE_terminal(d);
# undef PRECISION_MAKE_tag
# undef PRECISION_MAKE_terminal
int main()
{
proto::display_expr(a+b);
BOOST_AUTO(expr, Transform()( (a+b)*(c-d) ) );
proto::display_expr(expr);
return boost::exit_success;
}
