signal file init

src/propeller/problems/regression/stock_regression.cljc

@@ -0,0 +1,92 @@
+(ns propeller.problems.regression.stock-regression
+  (:require [propeller.genome :as genome]
+            [propeller.push.interpreter :as interpreter]
+            [propeller.push.state :as state]
+            [propeller.tools.math :as math]
+            [propeller.gp :as gp]
+            #?(:cljs [cljs.reader :refer [read-string]])))
+
+(defn- target-function
+  "Target function: f(x) = x^3 + 2*x^2 + x + 3"
+  [x]
+  (+ (* x x x) (* 2 x x) x 3))
+
+(def train-and-test-data
+  "Training data: Inputs and outputs with -10 <= x < 11
+  Test data: Inputs and outputs of -20 <= x < -10 and 11 <= x < 21"
+  (let [train-inputs (range -10 11)
+        test-inputs (concat (range -20 -10) (range 11 21))]
+    {:train (map (fn [x] {:input1 (vector x) :output1 (vector (target-function x))}) train-inputs)
+     :test (map (fn [x] {:input1 (vector x) :output1 (vector (target-function x))}) test-inputs)}))
+
+(def instructions
+  "stack-specific instructions, input instructions, close, and constants"
+  (list :in1
+        :integer_add
+        :integer_subtract
+        :integer_mult
+        :integer_quot
+        :integer_eq
+        :exec_dup
+        :exec_if
+        'close
+        0
+        1
+        :buy
+        :sell
+        :hold
+        ))
+
+(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 data individual]
+   (let [program (genome/plushy->push (:plushy individual) argmap)
+         inputs (map (fn [x] (first (:input1 x))) data)
+         correct-outputs (map (fn [x] (first (:output1 x))) 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))))))
+
+(def integer-argmap
+  {:instructions             instructions
+   :error-function           error-function
+   :training-data            (:train train-and-test-data)
+   :testing-data             (:test train-and-test-data)
+   :max-generations          300
+   :population-size          1000
+   :max-initial-plushy-size  5
+   :step-limit               200
+   :parent-selection         :lexicase
+   :tournament-size          5
+   :umad-rate                0.1
+   :variation                {:umad 1.0 :crossover 0.0}
+   :elitism                  false})
+
+(defn -main
+  "Runs the top-level genetic programming function, giving it a map of 
+  arguments with defaults that can be overridden from the command line
+  or through a passed map."
+  [& args]
+  (gp/gp
+    (merge
+     integer-argmap
+     (apply hash-map (map #(if (string? %) (read-string %) %) args)))))

src/propeller/push/instructions/numeric.cljc

@@ -20,6 +20,36 @@
   (fn [stack state]
     (make-instruction state > [stack stack] :boolean)))
 
+;; Pushes :buy onto the SIGNAL stack if the first item is greater than the second
+;; item, and acts as a no-op otherwise.
+(def _gt_buy
+  "Pushes :buy onto the SIGNAL stack if the first item is greater
+  than the second item, and acts as a no-op otherwise"
+  ^{:stacks #{:signal}
+    :name "_gt_buy"}
+  (fn [stack state]
+    (make-instruction state #(if (> %1 %2) :buy nil) [stack stack] :signal)))
+
+;; Pushes :sell onto the SIGNAL stack if the first item is greater than the second
+;; item, and acts as a no-op otherwise.
+(def _gt_sell
+  "Pushes :sell onto the SIGNAL stack if the first item is greater
+  than the second item, and acts as a no-op otherwise"
+  ^{:stacks #{:signal}
+    :name "_gt_sell"}
+  (fn [stack state]
+    (make-instruction state #(if (> %1 %2) :sell nil) [stack stack] :signal)))
+
+;; Pushes :hold onto the SIGNAL stack if the first item is greater than the second
+;; item, and acts as a no-op otherwise.
+(def _gt_hold
+  "Pushes :hold onto the SIGNAL stack if the first item is greater
+  than the second item, and acts as a no-op otherwise"
+  ^{:stacks #{:signal}
+    :name "_gt_hold"}
+  (fn [stack state]
+    (make-instruction state #(if (> %1 %2) :hold nil) [stack stack] :signal)))
+
 ;; Pushes TRUE onto the BOOLEAN stack if the second item is greater than or
 ;; equal to the top item, and FALSE otherwise
 (def _gte
@@ -30,6 +60,36 @@
   (fn [stack state]
     (make-instruction state >= [stack stack] :boolean)))
 
+;; Pushes :buy onto the SIGNAL stack if the first item is greater than or equal to the second
+;; item, and acts as a no-op otherwise.
+(def _gte_buy
+  "Pushes :buy onto the SIGNAL stack if the first item is greater
+  than or equal to the second item, and acts as a no-op otherwise"
+  ^{:stacks #{:signal}
+    :name "_gte_buy"}
+  (fn [stack state]
+    (make-instruction state #(if (>= %1 %2) :buy nil) [stack stack] :signal)))
+
+;; Pushes :sell onto the SIGNAL stack if the first item is greater than or equal to the second
+;; item, and acts as a no-op otherwise.
+(def _gte_sell
+  "Pushes :sell onto the SIGNAL stack if the first item is greater
+  than or equal to the second item, and acts as a no-op otherwise"
+  ^{:stacks #{:signal}
+    :name "_gte_sell"}
+  (fn [stack state]
+    (make-instruction state #(if (>= %1 %2) :sell nil) [stack stack] :signal)))
+
+;; Pushes :hold onto the SIGNAL stack if the first item is greater than or equal to the second
+;; item, and acts as a no-op otherwise.
+(def _gte_hold
+  "Pushes :hold onto the SIGNAL stack if the first item is greater
+  than or equal to the second item, and acts as a no-op otherwise"
+  ^{:stacks #{:signal}
+    :name "_gte_hold"}
+  (fn [stack state]
+    (make-instruction state #(if (>= %1 %2) :hold nil) [stack stack] :signal)))
+
 ;; Pushes TRUE onto the BOOLEAN stack if the second item is less than the top
 ;; item, and FALSE otherwise
 (def _lt
@@ -40,6 +100,36 @@
   (fn [stack state]
     (make-instruction state < [stack stack] :boolean)))
 
+;; Pushes :buy onto the SIGNAL stack if the first item is less than the second
+;; item, and acts as a no-op otherwise.
+(def _lt_buy
+  "Pushes :buy onto the SIGNAL stack if the first item is less
+  than the second item, and acts as a no-op otherwise"
+  ^{:stacks #{:signal}
+    :name "_lt_buy"}
+  (fn [stack state]
+    (make-instruction state #(if (< %1 %2) :buy nil) [stack stack] :signal)))
+
+;; Pushes :sell onto the SIGNAL stack if the first item is less than the second
+;; item, and acts as a no-op otherwise.
+(def _lt_sell
+  "Pushes :sell onto the SIGNAL stack if the first item is less
+  than the second item, and acts as a no-op otherwise"
+  ^{:stacks #{:signal}
+    :name "_lt_sell"}
+  (fn [stack state]
+    (make-instruction state #(if (< %1 %2) :sell nil) [stack stack] :signal)))
+
+;; Pushes :hold onto the SIGNAL stack if the first item is less than the second
+;; item, and acts as a no-op otherwise.
+(def _lt_hold
+  "Pushes :hold onto the SIGNAL stack if the first item is less
+  than the second item, and acts as a no-op otherwise"
+  ^{:stacks #{:signal}
+    :name "_lt_hold"}
+  (fn [stack state]
+    (make-instruction state #(if (< %1 %2) :hold nil) [stack stack] :signal)))
+
 ;; Pushes TRUE onto the BOOLEAN stack if the second item is less than or equal
 ;; to the top item, and FALSE otherwise
 (def _lte
@@ -50,6 +140,36 @@
   (fn [stack state]
     (make-instruction state <= [stack stack] :boolean)))
 
+;; Pushes :buy onto the SIGNAL stack if the first item is less than or equal to the second
+;; item, and acts as a no-op otherwise.
+(def _lte_buy
+  "Pushes :buy onto the SIGNAL stack if the first item is less
+  than or equal to the second item, and acts as a no-op otherwise"
+  ^{:stacks #{:signal}
+    :name "_lte_buy"}
+  (fn [stack state]
+    (make-instruction state #(if (<= %1 %2) :buy nil) [stack stack] :signal)))
+
+;; Pushes :sell onto the SIGNAL stack if the first item is less than or equal to the second
+;; item, and acts as a no-op otherwise.
+(def _lte_sell
+  "Pushes :sell onto the SIGNAL stack if the first item is less
+  than or equal to the second item, and acts as a no-op otherwise"
+  ^{:stacks #{:signal}
+    :name "_lte_sell"}
+  (fn [stack state]
+    (make-instruction state #(if (<= %1 %2) :sell nil) [stack stack] :signal)))
+
+;; Pushes :hold onto the SIGNAL stack if the first item is less than or equal to the second
+;; item, and acts as a no-op otherwise.
+(def _lte_hold
+  "Pushes :hold onto the SIGNAL stack if the first item is less
+  than or equal to the second item, and acts as a no-op otherwise"
+  ^{:stacks #{:signal}
+    :name "_lte_hold"}
+  (fn [stack state]
+    (make-instruction state #(if (<= %1 %2) :hold nil) [stack stack] :signal)))
+
 ;; Pushes the sum of the top two items onto the same stack
 (def _add
   "Pushes the sum of the top two items onto the same stack"
@@ -173,11 +293,11 @@ Otherwise, acts as a NOOP"
   (fn [stack state]
     (make-instruction state dec [stack] stack)))
 
-;; 2 types x 16 functions = 32 instructions
 (generate-instructions
   [:float :integer]
   [_gt _gte _lt _lte _add _subtract _mult _quot _mod _max _min _inc _dec
-   _from_boolean _from_char _from_string])
+   _from_boolean _from_char _from_string _gt_buy _gt_sell _gt_hold _gte_buy
+   _gte_sell _gte_hold _lt_buy _lt_sell _lt_hold _lte_buy _lte_sell _lte_hold])
 
 ;; =============================================================================
 ;; FLOAT Instructions only

src/propeller/push/instructions/polymorphic.cljc

@@ -232,9 +232,9 @@
         (state/push-to-stack popped-state stack indexed-item))
       state)))
 
-;; 11 types x 13 functions = 143 instructions
+;; 12 types x 13 functions = 156 instructions
 (generate-instructions
   [:boolean :char :code :exec :float :integer :string
-   :vector_boolean :vector_float :vector_integer :vector_string]
+   :vector_boolean :vector_float :vector_integer :vector_string :signal]
   [_dup _dup_times _dup_items _empty _eq _flush _pop _rot _shove
    _stack_depth _swap _yank _yank_dup _deep_dup])

src/propeller/push/instructions/signal.cljc

@@ -0,0 +1,8 @@
+(ns propeller.push.instructions.signal
+  "SIGNAL instructions. Instructions pertaining only to trading signals
+   are located here."
+  (:require [propeller.tools.math :as math]
+           [propeller.push.instructions :refer [def-instruction
+                                                generate-instructions
+                                                make-instruction]]))
+

src/propeller/push/interpreter.cljc

@@ -11,6 +11,11 @@
         instruction (first (:exec state))
         literal-type (instructions/get-literal-type instruction)]     ; nil for non-literals
     (cond
+      ;;
+      ;; Catch the trading signal keywords before the other
+      ;; keyword checks.
+      (some #(= instruction %) '(:buy :sell :hold))
+      (state/push-to-stack popped-state :signal instruction)
       ;;
       ;; Recognize functional instruction or input instruction
       (keyword? instruction)

src/propeller/push/state.cljc

@@ -5,19 +5,21 @@
 
 ;; Empty push state - all available stacks are empty
 (defonce ^:no-doc empty-state {:boolean        '()
-                      :char           '()
+                               :char           '()
-                      :code           '()
+                               :code           '()
-                      :exec           '()
+                               :exec           '()
-                      :float          '()
+                               :float          '()
-                      :input          {}
+                               :input          {}
-                      :output         {}
+                               :output         {}
-                      :integer        '()
+                               :integer        '()
-                      :print          '("")
+                               :print          '("")
-                      :string         '()
+                               :string         '()
-                      :vector_boolean '()
+                               :vector_boolean '()
-                      :vector_float   '()
+                               :vector_float   '()
-                      :vector_integer '()
+                               :vector_integer '()
-                      :vector_string  '()})
+                               :vector_string  '()
+                               :signal         '() ;; stock trading signal (:buy, :sell, or :hold only), long only for now
+                               })
 
 ;; All stack types available in a Push state
 (defonce ^:no-doc stacks (set (keys empty-state)))