Create SymEngine.Basic from julia Expr about symengine.jl

[mforets]

For the record, now SymEngine exports the convert methods:

julia> expr = convert(Basic, "2x + y")
2*x + y

julia> expr = convert(Basic, :(2x+y))
2*x + y

[isuruf]

I'm not sure this is the best way, but here goes.

syms = [:x, :y, :z]
ex = :(x * y  - x * z)

using SymEngine
symengine_syms = map(symbols, syms)

d = Dict(zip(syms, symengine_syms))

function Basic(s::Symbol, d::Dict{Symbol,SymEngine.Basic})
   if haskey(d, s)
       get(d, s, 0)
   else
       s
   end
end

function Basic(ex::Expr, d::Dict{Symbol,SymEngine.Basic})
   s = copy(ex)
   for i in 1:length(s.args)
       s.args[i] = Basic(s.args[i], d)
   end
   eval(s)
end

Basic(ex, d)

[jverzani]

This is reminiscent of the @vars macro. Something like this may also be of interest:

using SymEngine

ss = [:x, :y, :z]
ex = :(x * y + x * z)


function evaluate_expression(ex, vars)
    q=Expr(:block)
    for s in ss
        push!(q.args, Expr(:(=), s, Expr(:call, :(SymEngine._symbol), Expr(:quote, s))))
    end
    push!(q.args, Expr(:tuple, vars...))
    eval(Main, q)

    eval(ex)
end

evaluate_expression(ex, ss)

This uses SymEngine to generate a Basic expression from the expression and the variables which seems a bit more direct.

[isuruf]

With the latest SymEngine master, you can even do,

function basic_parse(s::String)
    a = Basic()
    ccall((:basic_parse, :libsymengine), Void, (Ptr{Basic}, Ptr{Int8}), &a, s)
    return a
end

basic_parse(string(ex))

[sglyon]

@isuruf that's exactly what I was looking for! Thank you for that.