added type constrains for expression evaluation

Author: wildart

src/api/expressions.jl

@@ -3,11 +3,14 @@ Julia expression wrapper
 """
 struct Expression
     expr::Expr
-    syms::Vector{Symbol}
+    syms::Dict{Symbol,Int}
+end
+function Expression(ex::Expr)
+    syms = Dict( s=>i for (i,s) in pairs(sort!(symbols(ex))) )
+    Expression(ex, syms)
 end
-Expression(ex::Expr) = Expression(ex, sort!(symbols(ex)))
 show(io::IO, e::Expression) = infix(io, e.expr)
-(e::Expression)(val) = evaluate(val, e.expr, e.syms)
+(e::Expression)(vals::T...) where {T} = evaluate(e.expr, e.syms, vals...)
 
 function symbols(ex::Expr)
     syms = Symbol[]
@@ -18,6 +21,11 @@ function symbols(ex::Expr)
     unique!(syms)
 end
 
+function compile(ex::Expr, params::Vector{Symbol})
+    tprm = Expr(:tuple, params...)
+    Expr(:->, tprm, ex)
+end
+
 height(ex) = isa(ex, Expr) ? maximum( height(e) for e in ex.args )+1 : 0
 nodes(ex) = !isa(ex, Expr) ? 1 : length(ex.args) > 0 ? sum( nodes(e) for e in ex.args ) : 0
 length(ex) = nodes(ex)
@@ -79,15 +87,18 @@ isdiv(ex) = ex in [/, div, pdiv, aq]
 isexpr(ex) = isa(ex, Expr)
 issym(ex) = isa(ex, Symbol)
 
-function evaluate(val, ex::Expr, psyms::Vector{Symbol})
+function evaluate(ex::Expr, psyms::Dict{Symbol,Int}, vals::T...)::T where {T}
     exprm = ex.args
-    exvals = (isexpr(nex) || issym(nex) ? evaluate(val, nex, psyms) : nex for nex in exprm[2:end])
+    exvals = (isexpr(nex) || issym(nex) ? evaluate(nex, psyms, vals...) : nex for nex in exprm[2:end])
     exprm[1](exvals...)
 end
 
-function evaluate(val, ex::Symbol, psyms::Vector{Symbol})
-    pidx = findfirst(isequal(ex), psyms)
-    val[pidx]
+function evaluate(ex::Symbol, psyms::Dict{Symbol,Int}, vals::T...)::T where {T}
+    pidx = get(psyms, ex, 0)
+    if pidx == 0
+        @error "Undefined symbol: $ex"
+    end
+    return T(vals[pidx])
 end
 
 
@@ -114,9 +125,9 @@ function simplifybinary!(root)
         root = 1
     elseif (fn == (*) || isdiv(fn)) &&  (iszeronum(op1) || iszeronum(op2)) # look for 0: x*0 = 0*x = 0
         root = 0
-    elseif (fn == (+) || fn == (-)) && iszeronum(op2) # look for 0: x ± 0 = 0
+    elseif (fn == (+) || fn == (-)) && iszeronum(op2) # look for 0: x ± 0 = x
         root = op1
-    elseif fn == (+) && iszeronum(op1) # look for 0: 0 ± x = 0
+    elseif fn == (+) && iszeronum(op1) # look for 0: 0 + x = x
         root = op2
     elseif (fn == (*) || isdiv(fn)) && isonenum(op2) # x*1 = x || x/1 = x
         root = op1

test/gp.jl

@@ -82,23 +82,27 @@
     ys = fitfun.(rg)
     function fitobj(expr)
         ex = Evolutionary.Expression(expr)
-        sum(v->isnan(v) ? 1.0 : v, abs2.(ys - ex.(rg)) )/length(rg)
+        #ex = Evolutionary.Expression(expr, Dict(:x=>1))
+        yy = ex.(rg)
+        sum(v->isnan(v) ? 1.0 : v, abs2.(ys .- yy) )/length(rg)
     end
 
     Random.seed!(rng, 42)
     res = Evolutionary.optimize(fitobj,
         TreeGP(25, Terminal[:x, randn], Function[+,-,*,Evolutionary.aq],
             mindepth=1,
             maxdepth=3,
-            simplify = simplify!,
+            simplify = Evolutionary.simplify!,
             optimizer = GA(
                 selection = tournament(3),
-                mutationRate = 0.2,
+                mutationRate = 0.1,
                 crossoverRate = 0.9,
+                ε = 0.1
             ),
         ),
-        Evolutionary.Options(show_trace=false, rng=rng, iterations=50)
+        Evolutionary.Options(show_trace=true, rng=rng, iterations=50)
     )
     @test minimum(res) < 1.1
 
 end
+