Refactored Till PopMember

julia/PopMember.jl

@@ -0,0 +1,10 @@
+# Define a member of population by equation, score, and age
+mutable struct PopMember
+    tree::Node
+    score::Float32
+    birth::Integer
+
+    PopMember(t::Node) = new(t, scoreFunc(t), getTime())
+    PopMember(t::Node, score::Float32) = new(t, score, getTime())
+
+end

julia/complexityChecks.jl

@@ -0,0 +1,42 @@
+# Check if any binary operator are overly complex
+function flagBinOperatorComplexity(tree::Node, op::Int)::Bool
+    if tree.degree == 0
+        return false
+    elseif tree.degree == 1
+        return flagBinOperatorComplexity(tree.l, op)
+    else
+        if tree.op == op
+            overly_complex = (
+                    ((bin_constraints[op][1] > -1) &&
+                     (countNodes(tree.l) > bin_constraints[op][1]))
+                      ||
+                    ((bin_constraints[op][2] > -1) &&
+                     (countNodes(tree.r) > bin_constraints[op][2]))
+                )
+            if overly_complex
+                return true
+            end
+        end
+        return (flagBinOperatorComplexity(tree.l, op) || flagBinOperatorComplexity(tree.r, op))
+    end
+end
+
+# Check if any unary operators are overly complex
+function flagUnaOperatorComplexity(tree::Node, op::Int)::Bool
+    if tree.degree == 0
+        return false
+    elseif tree.degree == 1
+        if tree.op == op
+            overly_complex = (
+                      (una_constraints[op] > -1) &&
+                      (countNodes(tree.l) > una_constraints[op])
+                )
+            if overly_complex
+                return true
+            end
+        end
+        return flagUnaOperatorComplexity(tree.l, op)
+    else
+        return (flagUnaOperatorComplexity(tree.l, op) || flagUnaOperatorComplexity(tree.r, op))
+    end
+end

julia/simplification.jl

@@ -0,0 +1,106 @@
+# Simplify tree
+function combineOperators(tree::Node)::Node
+    # NOTE: (const (+*-) const) already accounted for. Call simplifyTree before.
+    # ((const + var) + const) => (const + var)
+    # ((const * var) * const) => (const * var)
+    # ((const - var) - const) => (const - var)
+    # (want to add anything commutative!)
+    # TODO - need to combine plus/sub if they are both there.
+    if tree.degree == 0
+        return tree
+    elseif tree.degree == 1
+        tree.l = combineOperators(tree.l)
+    elseif tree.degree == 2
+        tree.l = combineOperators(tree.l)
+        tree.r = combineOperators(tree.r)
+    end
+
+    top_level_constant = tree.degree == 2 && (tree.l.constant || tree.r.constant)
+    if tree.degree == 2 && (binops[tree.op] === mult || binops[tree.op] === plus) && top_level_constant
+        op = tree.op
+        # Put the constant in r. Need to assume var in left for simplification assumption.
+        if tree.l.constant
+            tmp = tree.r
+            tree.r = tree.l
+            tree.l = tmp
+        end
+        topconstant = tree.r.val
+        # Simplify down first
+        below = tree.l
+        if below.degree == 2 && below.op == op
+            if below.l.constant
+                tree = below
+                tree.l.val = binops[op](tree.l.val, topconstant)
+            elseif below.r.constant
+                tree = below
+                tree.r.val = binops[op](tree.r.val, topconstant)
+            end
+        end
+    end
+
+    if tree.degree == 2 && binops[tree.op] === sub && top_level_constant
+        # Currently just simplifies subtraction. (can't assume both plus and sub are operators)
+        # Not commutative, so use different op.
+        if tree.l.constant
+            if tree.r.degree == 2 && binops[tree.r.op] === sub
+                if tree.r.l.constant
+                    #(const - (const - var)) => (var - const)
+                    l = tree.l
+                    r = tree.r
+                    simplified_const = -(l.val - r.l.val) #neg(sub(l.val, r.l.val))
+                    tree.l = tree.r.r
+                    tree.r = l
+                    tree.r.val = simplified_const
+                elseif tree.r.r.constant
+                    #(const - (var - const)) => (const - var)
+                    l = tree.l
+                    r = tree.r
+                    simplified_const = l.val + r.r.val #plus(l.val, r.r.val)
+                    tree.r = tree.r.l
+                    tree.l.val = simplified_const
+                end
+            end
+        else #tree.r.constant is true
+            if tree.l.degree == 2 && binops[tree.l.op] === sub
+                if tree.l.l.constant
+                    #((const - var) - const) => (const - var)
+                    l = tree.l
+                    r = tree.r
+                    simplified_const = l.l.val - r.val#sub(l.l.val, r.val)
+                    tree.r = tree.l.r
+                    tree.l = r
+                    tree.l.val = simplified_const
+                elseif tree.l.r.constant
+                    #((var - const) - const) => (var - const)
+                    l = tree.l
+                    r = tree.r
+                    simplified_const = r.val + l.r.val #plus(r.val, l.r.val)
+                    tree.l = tree.l.l
+                    tree.r.val = simplified_const
+                end
+            end
+        end
+    end
+    return tree
+end
+
+# Simplify tree
+function simplifyTree(tree::Node)::Node
+    if tree.degree == 1
+        tree.l = simplifyTree(tree.l)
+        if tree.l.degree == 0 && tree.l.constant
+            return Node(unaops[tree.op](tree.l.val))
+        end
+    elseif tree.degree == 2
+        tree.l = simplifyTree(tree.l)
+        tree.r = simplifyTree(tree.r)
+        constantsBelow = (
+             tree.l.degree == 0 && tree.l.constant &&
+             tree.r.degree == 0 && tree.r.constant
+        )
+        if constantsBelow
+            return Node(binops[tree.op](tree.l.val, tree.r.val))
+        end
+    end
+    return tree
+end

julia/sr.jl

@@ -23,167 +23,12 @@ include("eval.jl")
 
 include("randomMutations.jl")
 
+include("simplification.jl")
 
-# Simplify tree
-function combineOperators(tree::Node)::Node
-    # NOTE: (const (+*-) const) already accounted for. Call simplifyTree before.
-    # ((const + var) + const) => (const + var)
-    # ((const * var) * const) => (const * var)
-    # ((const - var) - const) => (const - var)
-    # (want to add anything commutative!)
-    # TODO - need to combine plus/sub if they are both there.
-    if tree.degree == 0
-        return tree
-    elseif tree.degree == 1
-        tree.l = combineOperators(tree.l)
-    elseif tree.degree == 2
-        tree.l = combineOperators(tree.l)
-        tree.r = combineOperators(tree.r)
-    end
+include("PopMember.jl")
 
-    top_level_constant = tree.degree == 2 && (tree.l.constant || tree.r.constant)
-    if tree.degree == 2 && (binops[tree.op] === mult || binops[tree.op] === plus) && top_level_constant
-        op = tree.op
-        # Put the constant in r. Need to assume var in left for simplification assumption.
-        if tree.l.constant
-            tmp = tree.r
-            tree.r = tree.l
-            tree.l = tmp
-        end
-        topconstant = tree.r.val
-        # Simplify down first
-        below = tree.l
-        if below.degree == 2 && below.op == op
-            if below.l.constant
-                tree = below
-                tree.l.val = binops[op](tree.l.val, topconstant)
-            elseif below.r.constant
-                tree = below
-                tree.r.val = binops[op](tree.r.val, topconstant)
-            end
-        end
-    end
+include("complexityChecks.jl")
 
-    if tree.degree == 2 && binops[tree.op] === sub && top_level_constant
-        # Currently just simplifies subtraction. (can't assume both plus and sub are operators)
-        # Not commutative, so use different op.
-        if tree.l.constant
-            if tree.r.degree == 2 && binops[tree.r.op] === sub
-                if tree.r.l.constant
-                    #(const - (const - var)) => (var - const)
-                    l = tree.l
-                    r = tree.r
-                    simplified_const = -(l.val - r.l.val) #neg(sub(l.val, r.l.val))
-                    tree.l = tree.r.r
-                    tree.r = l
-                    tree.r.val = simplified_const
-                elseif tree.r.r.constant
-                    #(const - (var - const)) => (const - var)
-                    l = tree.l
-                    r = tree.r
-                    simplified_const = l.val + r.r.val #plus(l.val, r.r.val)
-                    tree.r = tree.r.l
-                    tree.l.val = simplified_const
-                end
-            end
-        else #tree.r.constant is true
-            if tree.l.degree == 2 && binops[tree.l.op] === sub
-                if tree.l.l.constant
-                    #((const - var) - const) => (const - var)
-                    l = tree.l
-                    r = tree.r
-                    simplified_const = l.l.val - r.val#sub(l.l.val, r.val)
-                    tree.r = tree.l.r
-                    tree.l = r
-                    tree.l.val = simplified_const
-                elseif tree.l.r.constant
-                    #((var - const) - const) => (var - const)
-                    l = tree.l
-                    r = tree.r
-                    simplified_const = r.val + l.r.val #plus(r.val, l.r.val)
-                    tree.l = tree.l.l
-                    tree.r.val = simplified_const
-                end
-            end
-        end
-    end
-    return tree
-end
-
-# Simplify tree
-function simplifyTree(tree::Node)::Node
-    if tree.degree == 1
-        tree.l = simplifyTree(tree.l)
-        if tree.l.degree == 0 && tree.l.constant
-            return Node(unaops[tree.op](tree.l.val))
-        end
-    elseif tree.degree == 2
-        tree.l = simplifyTree(tree.l)
-        tree.r = simplifyTree(tree.r)
-        constantsBelow = (
-             tree.l.degree == 0 && tree.l.constant &&
-             tree.r.degree == 0 && tree.r.constant
-        )
-        if constantsBelow
-            return Node(binops[tree.op](tree.l.val, tree.r.val))
-        end
-    end
-    return tree
-end
-
-# Define a member of population by equation, score, and age
-mutable struct PopMember
-    tree::Node
-    score::Float32
-    birth::Integer
-
-    PopMember(t::Node) = new(t, scoreFunc(t), getTime())
-    PopMember(t::Node, score::Float32) = new(t, score, getTime())
-
-end
-
-# Check if any binary operator are overly complex
-function flagBinOperatorComplexity(tree::Node, op::Int)::Bool
-    if tree.degree == 0
-        return false
-    elseif tree.degree == 1
-        return flagBinOperatorComplexity(tree.l, op)
-    else
-        if tree.op == op
-            overly_complex = (
-                    ((bin_constraints[op][1] > -1) &&
-                     (countNodes(tree.l) > bin_constraints[op][1]))
-                      ||
-                    ((bin_constraints[op][2] > -1) &&
-                     (countNodes(tree.r) > bin_constraints[op][2]))
-                )
-            if overly_complex
-                return true
-            end
-        end
-        return (flagBinOperatorComplexity(tree.l, op) || flagBinOperatorComplexity(tree.r, op))
-    end
-end
-
-# Check if any unary operators are overly complex
-function flagUnaOperatorComplexity(tree::Node, op::Int)::Bool
-    if tree.degree == 0
-        return false
-    elseif tree.degree == 1
-        if tree.op == op
-            overly_complex = (
-                      (una_constraints[op] > -1) &&
-                      (countNodes(tree.l) > una_constraints[op])
-                )
-            if overly_complex
-                return true
-            end
-        end
-        return flagUnaOperatorComplexity(tree.l, op)
-    else
-        return (flagUnaOperatorComplexity(tree.l, op) || flagUnaOperatorComplexity(tree.r, op))
-    end
-end
 
 # Go through one simulated annealing mutation cycle
 #  exp(-delta/T) defines probability of accepting a change