Add train/test data support to simple-regression problem

src/propeller/problems/simple_regression.cljc

@@ -32,31 +32,43 @@
         0
         1))
 
+(defn train-and-test-data
+  [target-function]
+  (let [train-inputs (range -10 11)
+        test-inputs (concat (range -20 -10) (range 11 21))]
+    {:train {:inputs  train-inputs
+             :outputs (map target-function train-inputs)}
+     :test  {:inputs  test-inputs
+             :outputs (map target-function test-inputs)}}))
+
 (defn error-function
   "Finds the behaviors and errors of an individual. The error is the absolute
   deviation between the target output value and the program's selected behavior,
   or 1000000 if no behavior is produced. The behavior is here defined as the
   final top item on the INTEGER stack."
-  [argmap individual]
-  (let [program (genome/plushy->push (:plushy individual) argmap)
-        inputs (range -10 11)
-        correct-outputs (map target-function inputs)
-        outputs (map (fn [input]
-                       (state/peek-stack
-                         (interpreter/interpret-program
-                           program
-                           (assoc state/empty-state :input {:in1 input})
-                           (:step-limit argmap))
-                         :integer))
-                     inputs)
-        errors (map (fn [correct-output output]
-                      (if (= output :no-stack-item)
-                        1000000
-                        (math/abs (- correct-output output))))
-                    correct-outputs
-                    outputs)]
-    (assoc individual
-      :behaviors outputs
-      :errors errors
-      :total-error #?(:clj (apply +' errors)
-                      :cljs (apply + errors)))))
+  ([argmap individual]
+   (error-function argmap individual :train))
+  ([argmap individual subset]
+   (let [program (genome/plushy->push (:plushy individual) argmap)
+         data (get (train-and-test-data target-function) subset)
+         inputs (:inputs data)
+         correct-outputs (:outputs data)
+         outputs (map (fn [input]
+                        (state/peek-stack
+                          (interpreter/interpret-program
+                            program
+                            (assoc state/empty-state :input {:in1 input})
+                            (:step-limit argmap))
+                          :integer))
+                      inputs)
+         errors (map (fn [correct-output output]
+                       (if (= output :no-stack-item)
+                         1000000
+                         (math/abs (- correct-output output))))
+                     correct-outputs
+                     outputs)]
+     (assoc individual
+       :behaviors outputs
+       :errors errors
+       :total-error #?(:clj  (apply +' errors)
+                       :cljs (apply + errors))))))