Force all operators to be fast versions

TODO.md

@@ -78,6 +78,7 @@
 
 ## Algorithmic performance ideas:
 
+- [ ] Use package compiler and compile sr.jl into a standalone binary that can be used by pysr.
 - [ ] Idea: use gradient of equation with respect to each operator (perhaps simply add to each operator) to tell which part is the most "sensitive" to changes. Then, perhaps insert/delete/mutate on that part of the tree?
 - [ ] Start populations staggered; so that there is more frequent printing (and pops that start a bit later get hall of fame already)?
 - [ ] Consider adding mutation for constant<->variable

julia/operators.jl

@@ -1,15 +1,26 @@
 import SpecialFunctions: gamma, lgamma, erf, erfc, beta
 
+
+import Base.FastMath: sqrt_llvm_fast, neg_float_fast,
+    add_float_fast, sub_float_fast, mul_float_fast, div_float_fast, rem_float_fast,
+    eq_float_fast, ne_float_fast, lt_float_fast, le_float_fast,
+    sign_fast, abs_fast, log_fast, log2_fast, log10_fast, sqrt_fast
+
+# Implicitly defined:
+#binary: mod
+#unary: exp, abs, log1p, sin, cos, tan, sinh, cosh, tanh, asin, acos, atan, asinh, acosh, atanh, erf, erfc, gamma, relu, round, floor, ceil, round, sign.
+
+# Use some fast operators from https://github.com/JuliaLang/julia/blob/81597635c4ad1e8c2e1c5753fda4ec0e7397543f/base/fastmath.jl
 # Define allowed operators. Any julia operator can also be used.
-plus(x::Float32, y::Float32)::Float32 = x+y #Do not change the name of this operator.
-mult(x::Float32, y::Float32)::Float32 = x*y #Do not change the name of this operator.
-pow(x::Float32, y::Float32)::Float32 = sign(x)*abs(x)^y
-div(x::Float32, y::Float32)::Float32 = x/y
-logm(x::Float32)::Float32 = log(abs(x) + 1f-8)
-logm2(x::Float32)::Float32 = log2(abs(x) + 1f-8)
-logm10(x::Float32)::Float32 = log10(abs(x) + 1f-8)
-sqrtm(x::Float32)::Float32 = sqrt(abs(x))
-neg(x::Float32)::Float32 = -x
+plus(x::Float32, y::Float32)::Float32 = add_float_fast(x, y) #Do not change the name of this operator.
+mult(x::Float32, y::Float32)::Float32 = mul_float_fast(x, y) #Do not change the name of this operator.
+pow(x::Float32, y::Float32)::Float32 = sign_fast(x)*ccall(("powf",libm), Float32, (Float32,Float32), abs_fast(x), y)
+div(x::Float32, y::Float32)::Float32 = div_float_fast(x, y)
+logm(x::Float32)::Float32 = log_fast(abs_fast(x) + 1f-8)
+logm2(x::Float32)::Float32 = log2_fast(abs_fast(x) + 1f-8)
+logm10(x::Float32)::Float32 = log10_fast(abs_fast(x) + 1f-8)
+sqrtm(x::Float32)::Float32 = sqrt_fast(abs_fast(x))
+neg(x::Float32)::Float32 = sub_float_fast(x)
 
 function greater(x::Float32, y::Float32)::Float32
     if x > y

julia/sr.jl

@@ -282,10 +282,10 @@ function evalTreeArray(tree::Node, cX::Array{Float32, 2})::Union{Array{Float32,
             return nothing
         end
         op = unaops[tree.op]
-        @fastmath @inbounds @simd for i=1:clen
+        @inbounds @simd for i=1:clen
             cumulator[i] = op(cumulator[i])
         end
-        @inbounds @simd for i=1:clen
+        @inbounds for i=1:clen
             if isinf(cumulator[i]) || isnan(cumulator[i])
                 return nothing
             end
@@ -302,10 +302,10 @@ function evalTreeArray(tree::Node, cX::Array{Float32, 2})::Union{Array{Float32,
             return nothing
         end
 
-        @fastmath @inbounds @simd for i=1:clen
+        @inbounds @simd for i=1:clen
             cumulator[i] = op(cumulator[i], array2[i])
         end
-        @inbounds @simd for i=1:clen
+        @inbounds for i=1:clen
             if isinf(cumulator[i]) || isnan(cumulator[i])
                 return nothing
             end
@@ -1032,6 +1032,7 @@ function fullRun(niterations::Integer;
                         end
                         if shouldOptimizeConstants
                             #pass #(We already calculate full scores in the optimizer)
+                            #TODO - not correct. only randomly calculate!
                         else
                             tmp_pop = finalizeScores(tmp_pop)
                         end

pysr/sr.py

@@ -241,8 +241,8 @@ def pysr(X=None, y=None, weights=None,
             op_list[i] = function_name
 
     def_hyperparams += f"""include("{pkg_directory}/operators.jl")
-const binops = {'[' + ', '.join(binary_operators) + ']'}
-const unaops = {'[' + ', '.join(unary_operators) + ']'}
+const binops = @fastmath {'[' + ', '.join(binary_operators) + ']'}
+const unaops = @fastmath {'[' + ', '.join(unary_operators) + ']'}
 const ns=10;
 const parsimony = {parsimony:f}f0
 const alpha = {alpha:f}f0