Hi Eric,
On Jan 11, 9:33 pm, Eric Niebler wrote:
See attached.
Thank you very much for the example, it definitely works and does even
more that I was expecting to achieve in this example. However, just in
order to make it more understandable (to me) at the beginning I want
to go even simpler that what you did.
I understand that proto is ideal for recursive expression (grammars?)
but I just want to define a fixed/rigid grammar that only accepts a
rigid expression of the type of 4. + 5.*i. Besides that I don't want
proto to evaluate things for me, I want to be able to "see" the
expression structure and contained values from a single place.
In other words I want a glorified (simulated) constructor.
std::complex<double> z = 5. + 6.*i;
I guess the "grammar" is simply (correct me if I am wrong):
struct i_tag{};
struct complex_cartesian_grammar
: proto::plus<
proto::terminal<double>,
proto::multiplies >
>
{};
yes, it is a very stupid rigid expression. (It just should accept a
certain expression.). For this, I striped down your version, to the
point it didn't compile but I think the intention of the code is
there.
The complete code is attached below. In my opinion...
what it has:
1) defines abstract symbol "i"
2) defines the only allowed expression in the syntax.
3) defines the domain (I don't know what this does)
what it lacks:
4) be able to compile
5) proper conversion of the expression tree to extract the relevant
data.
6) expression matches verification??
for the future:
7) allow a few more allowable expressions compatible with the
constructor of std::complex<double>, just of the types 4.+5.*i, 4.,
5.*i and that's it.
Sorry to using your powerful library for such an unpowerful
application, I am just trying to learn.
The current code gives naturally this error:
error: conversion from ‘const
boost::proto::exprns_::expr’ to non-
scalar type ‘std::complex<double>’ requested
The code follows // Thank you // Alfredo
#include <complex>
#include
namespace proto=boost::proto;
namespace pretty{
struct i_tag{};
struct complex_cartesian_grammar
: proto::plus<
proto::terminal<double>,
proto::multiplies >
>
{};
template< typename Expr >
struct complex_cartesian_expr;
struct complex_cartesian_domain :
proto::domain<
proto::pod_generator< complex_cartesian_expr >,
complex_cartesian_grammar
>
{};
template<typename Expr>
struct complex_cartesian_expr
{
BOOST_PROTO_EXTENDS(
Expr,
complex_cartesian_expr,
complex_cartesian_domain
)
template<typename T>
operator std::complex<T>() const{
return std::complex<double>(proto::child_c<0>(*this),
proto::child_c<0>(*this));
}
};
proto::terminal::type const i = {{}};
}
int main(){
using namespace pretty;
std::complex<double> z = 5. + 6.*i;
std::cout << z << std::endl;
return 0;
}
