Mercurial > repos > icfp2013

annotate src/bv.tp @ 59:3c8d8fdd32a1 default tip

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
mike's changes to solver
author bill
date Sun, 11 Aug 2013 15:24:22 -0700
parents 27ee5051b1ec
children
Ignore whitespace changes - Everywhere: Within whitespace: At end of lines:
rev   line source
28
6384e577842d Add code for filtering a program set based on the operators used
Mike Pavone <pavone@retrodev.com>
parents: 27
diff changeset
1 {
6384e577842d Add code for filtering a program set based on the operators used
Mike Pavone <pavone@retrodev.com>
parents: 27
diff changeset
2 #{
6384e577842d Add code for filtering a program set based on the operators used
Mike Pavone <pavone@retrodev.com>
parents: 27
diff changeset
3 program <- {
6384e577842d Add code for filtering a program set based on the operators used
Mike Pavone <pavone@retrodev.com>
parents: 27
diff changeset
4 _input <- 0u64
6384e577842d Add code for filtering a program set based on the operators used
Mike Pavone <pavone@retrodev.com>
parents: 27
diff changeset
5 _acc <- 0u64
6384e577842d Add code for filtering a program set based on the operators used
Mike Pavone <pavone@retrodev.com>
parents: 27
diff changeset
6 _val <- 0u64
33
b00904b36aca More solver work
Mike Pavone <pavone@retrodev.com>
parents: 28
diff changeset
7
28
6384e577842d Add code for filtering a program set based on the operators used
Mike Pavone <pavone@retrodev.com>
parents: 27
diff changeset
8 _zero <- #{
6384e577842d Add code for filtering a program set based on the operators used
Mike Pavone <pavone@retrodev.com>
parents: 27
diff changeset
9 string <- { "0" }
6384e577842d Add code for filtering a program set based on the operators used
Mike Pavone <pavone@retrodev.com>
parents: 27
diff changeset
10 eval <- { 0u64 }
6384e577842d Add code for filtering a program set based on the operators used
Mike Pavone <pavone@retrodev.com>
parents: 27
diff changeset
11 operators <- { 0 }
6384e577842d Add code for filtering a program set based on the operators used
Mike Pavone <pavone@retrodev.com>
parents: 27
diff changeset
12 isTfold? <- { false }
6384e577842d Add code for filtering a program set based on the operators used
Mike Pavone <pavone@retrodev.com>
parents: 27
diff changeset
13 isTerminal? <- { true }
33
b00904b36aca More solver work
Mike Pavone <pavone@retrodev.com>
parents: 28
diff changeset
14 constant? <- { true }
3
dfc5f00c94bc Initial evaluator implementation. fold is currently missing but other ops are present and seem to work
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
15 }
33
b00904b36aca More solver work
Mike Pavone <pavone@retrodev.com>
parents: 28
diff changeset
16 _accInputNode <- _zero
b00904b36aca More solver work
Mike Pavone <pavone@retrodev.com>
parents: 28
diff changeset
17 _foldInputNode <- _zero
3
dfc5f00c94bc Initial evaluator implementation. fold is currently missing but other ops are present and seem to work
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
18
28
6384e577842d Add code for filtering a program set based on the operators used
Mike Pavone <pavone@retrodev.com>
parents: 27
diff changeset
19 _one <- #{
6384e577842d Add code for filtering a program set based on the operators used
Mike Pavone <pavone@retrodev.com>
parents: 27
diff changeset
20 string <- { "1" }
6384e577842d Add code for filtering a program set based on the operators used
Mike Pavone <pavone@retrodev.com>
parents: 27
diff changeset
21 eval <- { 1u64 }
6384e577842d Add code for filtering a program set based on the operators used
Mike Pavone <pavone@retrodev.com>
parents: 27
diff changeset
22 operators <- { 0 }
6384e577842d Add code for filtering a program set based on the operators used
Mike Pavone <pavone@retrodev.com>
parents: 27
diff changeset
23 isTfold? <- { false }
6384e577842d Add code for filtering a program set based on the operators used
Mike Pavone <pavone@retrodev.com>
parents: 27
diff changeset
24 isTerminal? <- { true }
33
b00904b36aca More solver work
Mike Pavone <pavone@retrodev.com>
parents: 28
diff changeset
25 constant? <- { true }
3
dfc5f00c94bc Initial evaluator implementation. fold is currently missing but other ops are present and seem to work
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
26 }
dfc5f00c94bc Initial evaluator implementation. fold is currently missing but other ops are present and seem to work
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
27
28
6384e577842d Add code for filtering a program set based on the operators used
Mike Pavone <pavone@retrodev.com>
parents: 27
diff changeset
28 _inputNode <- #{
6384e577842d Add code for filtering a program set based on the operators used
Mike Pavone <pavone@retrodev.com>
parents: 27
diff changeset
29 string <- { "input" }
6384e577842d Add code for filtering a program set based on the operators used
Mike Pavone <pavone@retrodev.com>
parents: 27
diff changeset
30 eval <- { _input }
6384e577842d Add code for filtering a program set based on the operators used
Mike Pavone <pavone@retrodev.com>
parents: 27
diff changeset
31 operators <- { 0 }
6384e577842d Add code for filtering a program set based on the operators used
Mike Pavone <pavone@retrodev.com>
parents: 27
diff changeset
32 isTfold? <- { false }
6384e577842d Add code for filtering a program set based on the operators used
Mike Pavone <pavone@retrodev.com>
parents: 27
diff changeset
33 isTerminal? <- { true }
33
b00904b36aca More solver work
Mike Pavone <pavone@retrodev.com>
parents: 28
diff changeset
34 constant? <- { false }
28
6384e577842d Add code for filtering a program set based on the operators used
Mike Pavone <pavone@retrodev.com>
parents: 27
diff changeset
35 }
6384e577842d Add code for filtering a program set based on the operators used
Mike Pavone <pavone@retrodev.com>
parents: 27
diff changeset
36 _accNode <- #{
6384e577842d Add code for filtering a program set based on the operators used
Mike Pavone <pavone@retrodev.com>
parents: 27
diff changeset
37 string <- { "acc" }
6384e577842d Add code for filtering a program set based on the operators used
Mike Pavone <pavone@retrodev.com>
parents: 27
diff changeset
38 eval <- { _acc }
6384e577842d Add code for filtering a program set based on the operators used
Mike Pavone <pavone@retrodev.com>
parents: 27
diff changeset
39 operators <- { 0 }
6384e577842d Add code for filtering a program set based on the operators used
Mike Pavone <pavone@retrodev.com>
parents: 27
diff changeset
40 isTfold? <- { false }
6384e577842d Add code for filtering a program set based on the operators used
Mike Pavone <pavone@retrodev.com>
parents: 27
diff changeset
41 isTerminal? <- { true }
33
b00904b36aca More solver work
Mike Pavone <pavone@retrodev.com>
parents: 28
diff changeset
42 constant? <- { _accInputNode constant? }
28
6384e577842d Add code for filtering a program set based on the operators used
Mike Pavone <pavone@retrodev.com>
parents: 27
diff changeset
43 }
6384e577842d Add code for filtering a program set based on the operators used
Mike Pavone <pavone@retrodev.com>
parents: 27
diff changeset
44 _valNode <- #{
6384e577842d Add code for filtering a program set based on the operators used
Mike Pavone <pavone@retrodev.com>
parents: 27
diff changeset
45 string <- { "val" }
6384e577842d Add code for filtering a program set based on the operators used
Mike Pavone <pavone@retrodev.com>
parents: 27
diff changeset
46 eval <- { _val }
6384e577842d Add code for filtering a program set based on the operators used
Mike Pavone <pavone@retrodev.com>
parents: 27
diff changeset
47 operators <- { 0 }
6384e577842d Add code for filtering a program set based on the operators used
Mike Pavone <pavone@retrodev.com>
parents: 27
diff changeset
48 isTfold? <- { false }
6384e577842d Add code for filtering a program set based on the operators used
Mike Pavone <pavone@retrodev.com>
parents: 27
diff changeset
49 isTerminal? <- { true }
33
b00904b36aca More solver work
Mike Pavone <pavone@retrodev.com>
parents: 28
diff changeset
50 constant? <- { _foldInputNode constant? }
28
6384e577842d Add code for filtering a program set based on the operators used
Mike Pavone <pavone@retrodev.com>
parents: 27
diff changeset
51 }
6384e577842d Add code for filtering a program set based on the operators used
Mike Pavone <pavone@retrodev.com>
parents: 27
diff changeset
52 _opPlus <- 1
6384e577842d Add code for filtering a program set based on the operators used
Mike Pavone <pavone@retrodev.com>
parents: 27
diff changeset
53 _opAnd <- 2
6384e577842d Add code for filtering a program set based on the operators used
Mike Pavone <pavone@retrodev.com>
parents: 27
diff changeset
54 _opOr <- 4
6384e577842d Add code for filtering a program set based on the operators used
Mike Pavone <pavone@retrodev.com>
parents: 27
diff changeset
55 _opXor <- 8
6384e577842d Add code for filtering a program set based on the operators used
Mike Pavone <pavone@retrodev.com>
parents: 27
diff changeset
56 _opNot <- 0x10
6384e577842d Add code for filtering a program set based on the operators used
Mike Pavone <pavone@retrodev.com>
parents: 27
diff changeset
57 _opShl1 <- 0x20
6384e577842d Add code for filtering a program set based on the operators used
Mike Pavone <pavone@retrodev.com>
parents: 27
diff changeset
58 _opShr1 <- 0x40
6384e577842d Add code for filtering a program set based on the operators used
Mike Pavone <pavone@retrodev.com>
parents: 27
diff changeset
59 _opShr4 <- 0x80
6384e577842d Add code for filtering a program set based on the operators used
Mike Pavone <pavone@retrodev.com>
parents: 27
diff changeset
60 _opShr16 <- 0x100
6384e577842d Add code for filtering a program set based on the operators used
Mike Pavone <pavone@retrodev.com>
parents: 27
diff changeset
61 _opIf0 <- 0x200
6384e577842d Add code for filtering a program set based on the operators used
Mike Pavone <pavone@retrodev.com>
parents: 27
diff changeset
62 _opFold <- 0x400
6384e577842d Add code for filtering a program set based on the operators used
Mike Pavone <pavone@retrodev.com>
parents: 27
diff changeset
63 _opTfold <- 0x800
6384e577842d Add code for filtering a program set based on the operators used
Mike Pavone <pavone@retrodev.com>
parents: 27
diff changeset
64 _maskRemoveFold <- 0x3FF
56
f864792a1b17 Improve prefiltering in program generator. Make solver use similar logic to driver when run standalone.
Mike Pavone <pavone@retrodev.com>
parents: 43
diff changeset
65 _opPlusMask <- 1 xor 0xFFF
f864792a1b17 Improve prefiltering in program generator. Make solver use similar logic to driver when run standalone.
Mike Pavone <pavone@retrodev.com>
parents: 43
diff changeset
66 _opAndMask <- 2 xor 0xFFF
f864792a1b17 Improve prefiltering in program generator. Make solver use similar logic to driver when run standalone.
Mike Pavone <pavone@retrodev.com>
parents: 43
diff changeset
67 _opOrMask <- 4 xor 0xFFF
f864792a1b17 Improve prefiltering in program generator. Make solver use similar logic to driver when run standalone.
Mike Pavone <pavone@retrodev.com>
parents: 43
diff changeset
68 _opXorMask <- 8 xor 0xFFF
f864792a1b17 Improve prefiltering in program generator. Make solver use similar logic to driver when run standalone.
Mike Pavone <pavone@retrodev.com>
parents: 43
diff changeset
69 _opNotMask <- 0x10 xor 0xFFF
f864792a1b17 Improve prefiltering in program generator. Make solver use similar logic to driver when run standalone.
Mike Pavone <pavone@retrodev.com>
parents: 43
diff changeset
70 _opShl1Mask <- 0x20 xor 0xFFF
f864792a1b17 Improve prefiltering in program generator. Make solver use similar logic to driver when run standalone.
Mike Pavone <pavone@retrodev.com>
parents: 43
diff changeset
71 _opShr1Mask <- 0x40 xor 0xFFF
f864792a1b17 Improve prefiltering in program generator. Make solver use similar logic to driver when run standalone.
Mike Pavone <pavone@retrodev.com>
parents: 43
diff changeset
72 _opShr4Mask <- 0x80 xor 0xFFF
f864792a1b17 Improve prefiltering in program generator. Make solver use similar logic to driver when run standalone.
Mike Pavone <pavone@retrodev.com>
parents: 43
diff changeset
73 _opShr16Mask <- 0x100 xor 0xFFF
f864792a1b17 Improve prefiltering in program generator. Make solver use similar logic to driver when run standalone.
Mike Pavone <pavone@retrodev.com>
parents: 43
diff changeset
74 _opIf0Mask <- 0x200 xor 0xFFF
f864792a1b17 Improve prefiltering in program generator. Make solver use similar logic to driver when run standalone.
Mike Pavone <pavone@retrodev.com>
parents: 43
diff changeset
75
28
6384e577842d Add code for filtering a program set based on the operators used
Mike Pavone <pavone@retrodev.com>
parents: 27
diff changeset
76 _names <- dict linear
6384e577842d Add code for filtering a program set based on the operators used
Mike Pavone <pavone@retrodev.com>
parents: 27
diff changeset
77 _names set: "plus" _opPlus
6384e577842d Add code for filtering a program set based on the operators used
Mike Pavone <pavone@retrodev.com>
parents: 27
diff changeset
78 _names set: "and" _opAnd
6384e577842d Add code for filtering a program set based on the operators used
Mike Pavone <pavone@retrodev.com>
parents: 27
diff changeset
79 _names set: "xor" _opXor
6384e577842d Add code for filtering a program set based on the operators used
Mike Pavone <pavone@retrodev.com>
parents: 27
diff changeset
80 _names set: "or" _opOr
6384e577842d Add code for filtering a program set based on the operators used
Mike Pavone <pavone@retrodev.com>
parents: 27
diff changeset
81 _names set: "not" _opNot
6384e577842d Add code for filtering a program set based on the operators used
Mike Pavone <pavone@retrodev.com>
parents: 27
diff changeset
82 _names set: "shl1" _opShl1
6384e577842d Add code for filtering a program set based on the operators used
Mike Pavone <pavone@retrodev.com>
parents: 27
diff changeset
83 _names set: "shr1" _opShr1
6384e577842d Add code for filtering a program set based on the operators used
Mike Pavone <pavone@retrodev.com>
parents: 27
diff changeset
84 _names set: "shr4" _opShr4
6384e577842d Add code for filtering a program set based on the operators used
Mike Pavone <pavone@retrodev.com>
parents: 27
diff changeset
85 _names set: "shr16" _opShr16
6384e577842d Add code for filtering a program set based on the operators used
Mike Pavone <pavone@retrodev.com>
parents: 27
diff changeset
86 _names set: "if0" _opIf0
6384e577842d Add code for filtering a program set based on the operators used
Mike Pavone <pavone@retrodev.com>
parents: 27
diff changeset
87 _names set: "fold" _opFold
6384e577842d Add code for filtering a program set based on the operators used
Mike Pavone <pavone@retrodev.com>
parents: 27
diff changeset
88 _names set: "tfold" _opTfold
6384e577842d Add code for filtering a program set based on the operators used
Mike Pavone <pavone@retrodev.com>
parents: 27
diff changeset
89 _memo <- #[]
6384e577842d Add code for filtering a program set based on the operators used
Mike Pavone <pavone@retrodev.com>
parents: 27
diff changeset
90 _memoFoldBody <- #[]
6384e577842d Add code for filtering a program set based on the operators used
Mike Pavone <pavone@retrodev.com>
parents: 27
diff changeset
91 _memoFoldParam <- #[]
6384e577842d Add code for filtering a program set based on the operators used
Mike Pavone <pavone@retrodev.com>
parents: 27
diff changeset
92 #{
6384e577842d Add code for filtering a program set based on the operators used
Mike Pavone <pavone@retrodev.com>
parents: 27
diff changeset
93 plus <- :left right {
6384e577842d Add code for filtering a program set based on the operators used
Mike Pavone <pavone@retrodev.com>
parents: 27
diff changeset
94 #{
6384e577842d Add code for filtering a program set based on the operators used
Mike Pavone <pavone@retrodev.com>
parents: 27
diff changeset
95 string <- { "(plus " . (string: left) . " " . (string: right) . ")" }
6384e577842d Add code for filtering a program set based on the operators used
Mike Pavone <pavone@retrodev.com>
parents: 27
diff changeset
96 eval <- { (eval: left) + (eval: right)}
6384e577842d Add code for filtering a program set based on the operators used
Mike Pavone <pavone@retrodev.com>
parents: 27
diff changeset
97 operators <- { _opPlus or (left operators) or (right operators)}
6384e577842d Add code for filtering a program set based on the operators used
Mike Pavone <pavone@retrodev.com>
parents: 27
diff changeset
98 isTfold? <- { false }
6384e577842d Add code for filtering a program set based on the operators used
Mike Pavone <pavone@retrodev.com>
parents: 27
diff changeset
99 isTerminal? <- { false }
33
b00904b36aca More solver work
Mike Pavone <pavone@retrodev.com>
parents: 28
diff changeset
100 constant? <- { (left constant?) && (right constant?) }
28
6384e577842d Add code for filtering a program set based on the operators used
Mike Pavone <pavone@retrodev.com>
parents: 27
diff changeset
101 }
3
dfc5f00c94bc Initial evaluator implementation. fold is currently missing but other ops are present and seem to work
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
102 }
28
6384e577842d Add code for filtering a program set based on the operators used
Mike Pavone <pavone@retrodev.com>
parents: 27
diff changeset
103 zero <- {
6384e577842d Add code for filtering a program set based on the operators used
Mike Pavone <pavone@retrodev.com>
parents: 27
diff changeset
104 _zero
6384e577842d Add code for filtering a program set based on the operators used
Mike Pavone <pavone@retrodev.com>
parents: 27
diff changeset
105 }
3
dfc5f00c94bc Initial evaluator implementation. fold is currently missing but other ops are present and seem to work
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
106
28
6384e577842d Add code for filtering a program set based on the operators used
Mike Pavone <pavone@retrodev.com>
parents: 27
diff changeset
107 one <- {
6384e577842d Add code for filtering a program set based on the operators used
Mike Pavone <pavone@retrodev.com>
parents: 27
diff changeset
108 _one
3
dfc5f00c94bc Initial evaluator implementation. fold is currently missing but other ops are present and seem to work
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
109 }
dfc5f00c94bc Initial evaluator implementation. fold is currently missing but other ops are present and seem to work
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
110
28
6384e577842d Add code for filtering a program set based on the operators used
Mike Pavone <pavone@retrodev.com>
parents: 27
diff changeset
111 opAnd <- :left right {
6384e577842d Add code for filtering a program set based on the operators used
Mike Pavone <pavone@retrodev.com>
parents: 27
diff changeset
112 #{
6384e577842d Add code for filtering a program set based on the operators used
Mike Pavone <pavone@retrodev.com>
parents: 27
diff changeset
113 string <- { "(and " . (string: left) . " " . (string: right) . ")" }
6384e577842d Add code for filtering a program set based on the operators used
Mike Pavone <pavone@retrodev.com>
parents: 27
diff changeset
114 eval <- { (eval: left) and (eval: right)}
6384e577842d Add code for filtering a program set based on the operators used
Mike Pavone <pavone@retrodev.com>
parents: 27
diff changeset
115 operators <- { _opAnd or (left operators) or (right operators)}
6384e577842d Add code for filtering a program set based on the operators used
Mike Pavone <pavone@retrodev.com>
parents: 27
diff changeset
116 isTfold? <- { false }
6384e577842d Add code for filtering a program set based on the operators used
Mike Pavone <pavone@retrodev.com>
parents: 27
diff changeset
117 isTerminal? <- { false }
33
b00904b36aca More solver work
Mike Pavone <pavone@retrodev.com>
parents: 28
diff changeset
118 constant? <- {
b00904b36aca More solver work
Mike Pavone <pavone@retrodev.com>
parents: 28
diff changeset
119 if: (left constant?) {
b00904b36aca More solver work
Mike Pavone <pavone@retrodev.com>
parents: 28
diff changeset
120 if: (right constant?) {
b00904b36aca More solver work
Mike Pavone <pavone@retrodev.com>
parents: 28
diff changeset
121 true
b00904b36aca More solver work
Mike Pavone <pavone@retrodev.com>
parents: 28
diff changeset
122 } else: {
b00904b36aca More solver work
Mike Pavone <pavone@retrodev.com>
parents: 28
diff changeset
123 if: (string: left) = "0" {
b00904b36aca More solver work
Mike Pavone <pavone@retrodev.com>
parents: 28
diff changeset
124 true
b00904b36aca More solver work
Mike Pavone <pavone@retrodev.com>
parents: 28
diff changeset
125 } else: {
b00904b36aca More solver work
Mike Pavone <pavone@retrodev.com>
parents: 28
diff changeset
126 false
b00904b36aca More solver work
Mike Pavone <pavone@retrodev.com>
parents: 28
diff changeset
127 }
b00904b36aca More solver work
Mike Pavone <pavone@retrodev.com>
parents: 28
diff changeset
128 }
b00904b36aca More solver work
Mike Pavone <pavone@retrodev.com>
parents: 28
diff changeset
129 } else: {
b00904b36aca More solver work
Mike Pavone <pavone@retrodev.com>
parents: 28
diff changeset
130 if: (right constant?) {
b00904b36aca More solver work
Mike Pavone <pavone@retrodev.com>
parents: 28
diff changeset
131 if: (string: right) = "0" {
b00904b36aca More solver work
Mike Pavone <pavone@retrodev.com>
parents: 28
diff changeset
132 true
b00904b36aca More solver work
Mike Pavone <pavone@retrodev.com>
parents: 28
diff changeset
133 } else: {
b00904b36aca More solver work
Mike Pavone <pavone@retrodev.com>
parents: 28
diff changeset
134 false
b00904b36aca More solver work
Mike Pavone <pavone@retrodev.com>
parents: 28
diff changeset
135 }
b00904b36aca More solver work
Mike Pavone <pavone@retrodev.com>
parents: 28
diff changeset
136 } else: {
b00904b36aca More solver work
Mike Pavone <pavone@retrodev.com>
parents: 28
diff changeset
137 false
b00904b36aca More solver work
Mike Pavone <pavone@retrodev.com>
parents: 28
diff changeset
138 }
b00904b36aca More solver work
Mike Pavone <pavone@retrodev.com>
parents: 28
diff changeset
139 }
b00904b36aca More solver work
Mike Pavone <pavone@retrodev.com>
parents: 28
diff changeset
140 }
28
6384e577842d Add code for filtering a program set based on the operators used
Mike Pavone <pavone@retrodev.com>
parents: 27
diff changeset
141 }
6384e577842d Add code for filtering a program set based on the operators used
Mike Pavone <pavone@retrodev.com>
parents: 27
diff changeset
142 }
6384e577842d Add code for filtering a program set based on the operators used
Mike Pavone <pavone@retrodev.com>
parents: 27
diff changeset
143
6384e577842d Add code for filtering a program set based on the operators used
Mike Pavone <pavone@retrodev.com>
parents: 27
diff changeset
144 opOr <- :left right {
6384e577842d Add code for filtering a program set based on the operators used
Mike Pavone <pavone@retrodev.com>
parents: 27
diff changeset
145 #{
6384e577842d Add code for filtering a program set based on the operators used
Mike Pavone <pavone@retrodev.com>
parents: 27
diff changeset
146 string <- { "(or " . (string: left) . " " . (string: right) . ")" }
6384e577842d Add code for filtering a program set based on the operators used
Mike Pavone <pavone@retrodev.com>
parents: 27
diff changeset
147 eval <- { (eval: left) or (eval: right)}
6384e577842d Add code for filtering a program set based on the operators used
Mike Pavone <pavone@retrodev.com>
parents: 27
diff changeset
148 operators <- { _opOr or (left operators) or (right operators)}
6384e577842d Add code for filtering a program set based on the operators used
Mike Pavone <pavone@retrodev.com>
parents: 27
diff changeset
149 isTfold? <- { false }
6384e577842d Add code for filtering a program set based on the operators used
Mike Pavone <pavone@retrodev.com>
parents: 27
diff changeset
150 isTerminal? <- { false }
33
b00904b36aca More solver work
Mike Pavone <pavone@retrodev.com>
parents: 28
diff changeset
151 constant? <- { (left constant?) && (right constant?) }
28
6384e577842d Add code for filtering a program set based on the operators used
Mike Pavone <pavone@retrodev.com>
parents: 27
diff changeset
152 }
3
dfc5f00c94bc Initial evaluator implementation. fold is currently missing but other ops are present and seem to work
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
153 }
28
6384e577842d Add code for filtering a program set based on the operators used
Mike Pavone <pavone@retrodev.com>
parents: 27
diff changeset
154
6384e577842d Add code for filtering a program set based on the operators used
Mike Pavone <pavone@retrodev.com>
parents: 27
diff changeset
155 opXor <- :left right {
6384e577842d Add code for filtering a program set based on the operators used
Mike Pavone <pavone@retrodev.com>
parents: 27
diff changeset
156 #{
6384e577842d Add code for filtering a program set based on the operators used
Mike Pavone <pavone@retrodev.com>
parents: 27
diff changeset
157 string <- { "(xor " . (string: left) . " " . (string: right) . ")" }
6384e577842d Add code for filtering a program set based on the operators used
Mike Pavone <pavone@retrodev.com>
parents: 27
diff changeset
158 eval <- { (eval: left) xor (eval: right)}
6384e577842d Add code for filtering a program set based on the operators used
Mike Pavone <pavone@retrodev.com>
parents: 27
diff changeset
159 operators <- { _opXor or (left operators) or (right operators)}
6384e577842d Add code for filtering a program set based on the operators used
Mike Pavone <pavone@retrodev.com>
parents: 27
diff changeset
160 isTfold? <- { false }
6384e577842d Add code for filtering a program set based on the operators used
Mike Pavone <pavone@retrodev.com>
parents: 27
diff changeset
161 isTerminal? <- { false }
33
b00904b36aca More solver work
Mike Pavone <pavone@retrodev.com>
parents: 28
diff changeset
162 constant? <- {
b00904b36aca More solver work
Mike Pavone <pavone@retrodev.com>
parents: 28
diff changeset
163 if: (left constant?) && (right constant?) {
b00904b36aca More solver work
Mike Pavone <pavone@retrodev.com>
parents: 28
diff changeset
164 true
b00904b36aca More solver work
Mike Pavone <pavone@retrodev.com>
parents: 28
diff changeset
165 } else: {
b00904b36aca More solver work
Mike Pavone <pavone@retrodev.com>
parents: 28
diff changeset
166 (string: left) = (string: right)
b00904b36aca More solver work
Mike Pavone <pavone@retrodev.com>
parents: 28
diff changeset
167 }
b00904b36aca More solver work
Mike Pavone <pavone@retrodev.com>
parents: 28
diff changeset
168 }
28
6384e577842d Add code for filtering a program set based on the operators used
Mike Pavone <pavone@retrodev.com>
parents: 27
diff changeset
169 }
6384e577842d Add code for filtering a program set based on the operators used
Mike Pavone <pavone@retrodev.com>
parents: 27
diff changeset
170 }
6384e577842d Add code for filtering a program set based on the operators used
Mike Pavone <pavone@retrodev.com>
parents: 27
diff changeset
171
6384e577842d Add code for filtering a program set based on the operators used
Mike Pavone <pavone@retrodev.com>
parents: 27
diff changeset
172 opNot <- :exp {
6384e577842d Add code for filtering a program set based on the operators used
Mike Pavone <pavone@retrodev.com>
parents: 27
diff changeset
173 #{
6384e577842d Add code for filtering a program set based on the operators used
Mike Pavone <pavone@retrodev.com>
parents: 27
diff changeset
174 string <- { "(not " . (string: exp) . ")" }
6384e577842d Add code for filtering a program set based on the operators used
Mike Pavone <pavone@retrodev.com>
parents: 27
diff changeset
175 eval <- { (eval: exp) xor -1u64 }
6384e577842d Add code for filtering a program set based on the operators used
Mike Pavone <pavone@retrodev.com>
parents: 27
diff changeset
176 operators <- { _opNot or (exp operators)}
6384e577842d Add code for filtering a program set based on the operators used
Mike Pavone <pavone@retrodev.com>
parents: 27
diff changeset
177 isTfold? <- { false }
6384e577842d Add code for filtering a program set based on the operators used
Mike Pavone <pavone@retrodev.com>
parents: 27
diff changeset
178 isTerminal? <- { false }
33
b00904b36aca More solver work
Mike Pavone <pavone@retrodev.com>
parents: 28
diff changeset
179 constant? <- { exp constant? }
28
6384e577842d Add code for filtering a program set based on the operators used
Mike Pavone <pavone@retrodev.com>
parents: 27
diff changeset
180 }
6384e577842d Add code for filtering a program set based on the operators used
Mike Pavone <pavone@retrodev.com>
parents: 27
diff changeset
181 }
3
dfc5f00c94bc Initial evaluator implementation. fold is currently missing but other ops are present and seem to work
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
182
28
6384e577842d Add code for filtering a program set based on the operators used
Mike Pavone <pavone@retrodev.com>
parents: 27
diff changeset
183 shl1 <- :exp {
6384e577842d Add code for filtering a program set based on the operators used
Mike Pavone <pavone@retrodev.com>
parents: 27
diff changeset
184 #{
6384e577842d Add code for filtering a program set based on the operators used
Mike Pavone <pavone@retrodev.com>
parents: 27
diff changeset
185 string <- { "(shl1 " . (string: exp) . ")" }
6384e577842d Add code for filtering a program set based on the operators used
Mike Pavone <pavone@retrodev.com>
parents: 27
diff changeset
186 eval <- { lshift: (eval: exp) by: 1u64 }
6384e577842d Add code for filtering a program set based on the operators used
Mike Pavone <pavone@retrodev.com>
parents: 27
diff changeset
187 operators <- { _opShl1 or (exp operators)}
6384e577842d Add code for filtering a program set based on the operators used
Mike Pavone <pavone@retrodev.com>
parents: 27
diff changeset
188 isTfold? <- { false }
6384e577842d Add code for filtering a program set based on the operators used
Mike Pavone <pavone@retrodev.com>
parents: 27
diff changeset
189 isTerminal? <- { false }
33
b00904b36aca More solver work
Mike Pavone <pavone@retrodev.com>
parents: 28
diff changeset
190 constant? <- { exp constant? }
28
6384e577842d Add code for filtering a program set based on the operators used
Mike Pavone <pavone@retrodev.com>
parents: 27
diff changeset
191 }
6384e577842d Add code for filtering a program set based on the operators used
Mike Pavone <pavone@retrodev.com>
parents: 27
diff changeset
192 }
6384e577842d Add code for filtering a program set based on the operators used
Mike Pavone <pavone@retrodev.com>
parents: 27
diff changeset
193
6384e577842d Add code for filtering a program set based on the operators used
Mike Pavone <pavone@retrodev.com>
parents: 27
diff changeset
194 shr1 <- :exp {
6384e577842d Add code for filtering a program set based on the operators used
Mike Pavone <pavone@retrodev.com>
parents: 27
diff changeset
195 #{
6384e577842d Add code for filtering a program set based on the operators used
Mike Pavone <pavone@retrodev.com>
parents: 27
diff changeset
196 string <- { "(shr1 " . (string: exp) . ")" }
6384e577842d Add code for filtering a program set based on the operators used
Mike Pavone <pavone@retrodev.com>
parents: 27
diff changeset
197 eval <- { rshift: (eval: exp) by: 1u64 }
6384e577842d Add code for filtering a program set based on the operators used
Mike Pavone <pavone@retrodev.com>
parents: 27
diff changeset
198 operators <- { _opShr1 or (exp operators)}
6384e577842d Add code for filtering a program set based on the operators used
Mike Pavone <pavone@retrodev.com>
parents: 27
diff changeset
199 isTfold? <- { false }
6384e577842d Add code for filtering a program set based on the operators used
Mike Pavone <pavone@retrodev.com>
parents: 27
diff changeset
200 isTerminal? <- { false }
33
b00904b36aca More solver work
Mike Pavone <pavone@retrodev.com>
parents: 28
diff changeset
201 constant? <- { exp constant? }
28
6384e577842d Add code for filtering a program set based on the operators used
Mike Pavone <pavone@retrodev.com>
parents: 27
diff changeset
202 }
3
dfc5f00c94bc Initial evaluator implementation. fold is currently missing but other ops are present and seem to work
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
203 }
28
6384e577842d Add code for filtering a program set based on the operators used
Mike Pavone <pavone@retrodev.com>
parents: 27
diff changeset
204
6384e577842d Add code for filtering a program set based on the operators used
Mike Pavone <pavone@retrodev.com>
parents: 27
diff changeset
205 shr4 <- :exp {
6384e577842d Add code for filtering a program set based on the operators used
Mike Pavone <pavone@retrodev.com>
parents: 27
diff changeset
206 #{
6384e577842d Add code for filtering a program set based on the operators used
Mike Pavone <pavone@retrodev.com>
parents: 27
diff changeset
207 string <- { "(shr4 " . (string: exp) . ")" }
6384e577842d Add code for filtering a program set based on the operators used
Mike Pavone <pavone@retrodev.com>
parents: 27
diff changeset
208 eval <- { rshift: (eval: exp) by: 4u64 }
6384e577842d Add code for filtering a program set based on the operators used
Mike Pavone <pavone@retrodev.com>
parents: 27
diff changeset
209 operators <- { _opShr4 or (exp operators)}
6384e577842d Add code for filtering a program set based on the operators used
Mike Pavone <pavone@retrodev.com>
parents: 27
diff changeset
210 isTfold? <- { false }
6384e577842d Add code for filtering a program set based on the operators used
Mike Pavone <pavone@retrodev.com>
parents: 27
diff changeset
211 isTerminal? <- { false }
33
b00904b36aca More solver work
Mike Pavone <pavone@retrodev.com>
parents: 28
diff changeset
212 constant? <- { exp constant? }
28
6384e577842d Add code for filtering a program set based on the operators used
Mike Pavone <pavone@retrodev.com>
parents: 27
diff changeset
213 }
6384e577842d Add code for filtering a program set based on the operators used
Mike Pavone <pavone@retrodev.com>
parents: 27
diff changeset
214 }
6384e577842d Add code for filtering a program set based on the operators used
Mike Pavone <pavone@retrodev.com>
parents: 27
diff changeset
215
6384e577842d Add code for filtering a program set based on the operators used
Mike Pavone <pavone@retrodev.com>
parents: 27
diff changeset
216 shr16 <- :exp {
6384e577842d Add code for filtering a program set based on the operators used
Mike Pavone <pavone@retrodev.com>
parents: 27
diff changeset
217 #{
6384e577842d Add code for filtering a program set based on the operators used
Mike Pavone <pavone@retrodev.com>
parents: 27
diff changeset
218 string <- { "(shr16 " . (string: exp) . ")" }
6384e577842d Add code for filtering a program set based on the operators used
Mike Pavone <pavone@retrodev.com>
parents: 27
diff changeset
219 eval <- { rshift: (eval: exp) by: 16u64 }
6384e577842d Add code for filtering a program set based on the operators used
Mike Pavone <pavone@retrodev.com>
parents: 27
diff changeset
220 operators <- { _opShr16 or (exp operators)}
6384e577842d Add code for filtering a program set based on the operators used
Mike Pavone <pavone@retrodev.com>
parents: 27
diff changeset
221 isTfold? <- { false }
6384e577842d Add code for filtering a program set based on the operators used
Mike Pavone <pavone@retrodev.com>
parents: 27
diff changeset
222 isTerminal? <- { false }
33
b00904b36aca More solver work
Mike Pavone <pavone@retrodev.com>
parents: 28
diff changeset
223 constant? <- { exp constant? }
28
6384e577842d Add code for filtering a program set based on the operators used
Mike Pavone <pavone@retrodev.com>
parents: 27
diff changeset
224 }
6384e577842d Add code for filtering a program set based on the operators used
Mike Pavone <pavone@retrodev.com>
parents: 27
diff changeset
225 }
6384e577842d Add code for filtering a program set based on the operators used
Mike Pavone <pavone@retrodev.com>
parents: 27
diff changeset
226
6384e577842d Add code for filtering a program set based on the operators used
Mike Pavone <pavone@retrodev.com>
parents: 27
diff changeset
227 input <- { _inputNode }
6384e577842d Add code for filtering a program set based on the operators used
Mike Pavone <pavone@retrodev.com>
parents: 27
diff changeset
228 acc <- { _accNode }
6384e577842d Add code for filtering a program set based on the operators used
Mike Pavone <pavone@retrodev.com>
parents: 27
diff changeset
229 val <- { _valNode }
3
dfc5f00c94bc Initial evaluator implementation. fold is currently missing but other ops are present and seem to work
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
230
28
6384e577842d Add code for filtering a program set based on the operators used
Mike Pavone <pavone@retrodev.com>
parents: 27
diff changeset
231 if0:then:else <- :exp ifzero :ifnotzero {
6384e577842d Add code for filtering a program set based on the operators used
Mike Pavone <pavone@retrodev.com>
parents: 27
diff changeset
232 #{
6384e577842d Add code for filtering a program set based on the operators used
Mike Pavone <pavone@retrodev.com>
parents: 27
diff changeset
233 string <- { "(if0 " . (string: exp) . " " . (string: ifzero) . " " . (string: ifnotzero) . ")" }
6384e577842d Add code for filtering a program set based on the operators used
Mike Pavone <pavone@retrodev.com>
parents: 27
diff changeset
234 eval <- {
6384e577842d Add code for filtering a program set based on the operators used
Mike Pavone <pavone@retrodev.com>
parents: 27
diff changeset
235 if: (eval: exp) = 0u64 {
6384e577842d Add code for filtering a program set based on the operators used
Mike Pavone <pavone@retrodev.com>
parents: 27
diff changeset
236 eval: ifzero
6384e577842d Add code for filtering a program set based on the operators used
Mike Pavone <pavone@retrodev.com>
parents: 27
diff changeset
237 } else: {
6384e577842d Add code for filtering a program set based on the operators used
Mike Pavone <pavone@retrodev.com>
parents: 27
diff changeset
238 eval: ifnotzero
6384e577842d Add code for filtering a program set based on the operators used
Mike Pavone <pavone@retrodev.com>
parents: 27
diff changeset
239 }
6384e577842d Add code for filtering a program set based on the operators used
Mike Pavone <pavone@retrodev.com>
parents: 27
diff changeset
240 }
6384e577842d Add code for filtering a program set based on the operators used
Mike Pavone <pavone@retrodev.com>
parents: 27
diff changeset
241 operators <- { _opIf0 or (exp operators) or (ifzero operators) or (ifnotzero operators)}
6384e577842d Add code for filtering a program set based on the operators used
Mike Pavone <pavone@retrodev.com>
parents: 27
diff changeset
242 isTfold? <- { false }
6384e577842d Add code for filtering a program set based on the operators used
Mike Pavone <pavone@retrodev.com>
parents: 27
diff changeset
243 isTerminal? <- { false }
33
b00904b36aca More solver work
Mike Pavone <pavone@retrodev.com>
parents: 28
diff changeset
244 constant? <- { (exp constant?) && (ifzero constant?) && (ifnotzero constant?) }
28
6384e577842d Add code for filtering a program set based on the operators used
Mike Pavone <pavone@retrodev.com>
parents: 27
diff changeset
245 }
3
dfc5f00c94bc Initial evaluator implementation. fold is currently missing but other ops are present and seem to work
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
246 }
dfc5f00c94bc Initial evaluator implementation. fold is currently missing but other ops are present and seem to work
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
247
28
6384e577842d Add code for filtering a program set based on the operators used
Mike Pavone <pavone@retrodev.com>
parents: 27
diff changeset
248 fold:with:startingAt <- :toFold :fun :startAcc {
6384e577842d Add code for filtering a program set based on the operators used
Mike Pavone <pavone@retrodev.com>
parents: 27
diff changeset
249 #{
6384e577842d Add code for filtering a program set based on the operators used
Mike Pavone <pavone@retrodev.com>
parents: 27
diff changeset
250 string <- {
6384e577842d Add code for filtering a program set based on the operators used
Mike Pavone <pavone@retrodev.com>
parents: 27
diff changeset
251 "(fold " . (string: toFold) . " " . (string: startAcc) . " (lambda (val acc) " . (string: fun) . "))"
6384e577842d Add code for filtering a program set based on the operators used
Mike Pavone <pavone@retrodev.com>
parents: 27
diff changeset
252 }
6384e577842d Add code for filtering a program set based on the operators used
Mike Pavone <pavone@retrodev.com>
parents: 27
diff changeset
253 eval <- {
6384e577842d Add code for filtering a program set based on the operators used
Mike Pavone <pavone@retrodev.com>
parents: 27
diff changeset
254 _acc <- (eval: startAcc)
6384e577842d Add code for filtering a program set based on the operators used
Mike Pavone <pavone@retrodev.com>
parents: 27
diff changeset
255 source <- (eval: toFold)
6384e577842d Add code for filtering a program set based on the operators used
Mike Pavone <pavone@retrodev.com>
parents: 27
diff changeset
256 //parser doesn''t currently like vertical whitespace in arays so
6384e577842d Add code for filtering a program set based on the operators used
Mike Pavone <pavone@retrodev.com>
parents: 27
diff changeset
257 //this needs to be on a single line until that bug is fixed
6384e577842d Add code for filtering a program set based on the operators used
Mike Pavone <pavone@retrodev.com>
parents: 27
diff changeset
258 vals <- #[source and 255u64 (rshift: source by: 8u64) and 255u64 (rshift: source by: 16u64) and 255u64 (rshift: source by: 24u64) and 255u64 (rshift: source by: 32u64) and 255u64 (rshift: source by: 40u64) and 255u64 (rshift: source by: 48u64) and 255u64 (rshift: source by: 56u64) and 255u64]
6384e577842d Add code for filtering a program set based on the operators used
Mike Pavone <pavone@retrodev.com>
parents: 27
diff changeset
259 foreach: vals :idx cur {
6384e577842d Add code for filtering a program set based on the operators used
Mike Pavone <pavone@retrodev.com>
parents: 27
diff changeset
260 _val <- cur
6384e577842d Add code for filtering a program set based on the operators used
Mike Pavone <pavone@retrodev.com>
parents: 27
diff changeset
261 _acc <- (eval: fun)
6384e577842d Add code for filtering a program set based on the operators used
Mike Pavone <pavone@retrodev.com>
parents: 27
diff changeset
262 }
6384e577842d Add code for filtering a program set based on the operators used
Mike Pavone <pavone@retrodev.com>
parents: 27
diff changeset
263 _acc
6384e577842d Add code for filtering a program set based on the operators used
Mike Pavone <pavone@retrodev.com>
parents: 27
diff changeset
264 }
6384e577842d Add code for filtering a program set based on the operators used
Mike Pavone <pavone@retrodev.com>
parents: 27
diff changeset
265 operators <- { _opFold or (toFold operators) or (fun operators) or (startAcc operators) }
6384e577842d Add code for filtering a program set based on the operators used
Mike Pavone <pavone@retrodev.com>
parents: 27
diff changeset
266 isTfold? <- {
6384e577842d Add code for filtering a program set based on the operators used
Mike Pavone <pavone@retrodev.com>
parents: 27
diff changeset
267 (toFold isTerminal?) && (startAcc isTerminal?) && (toFold string) = "input" && (startAcc string) = "0"
6384e577842d Add code for filtering a program set based on the operators used
Mike Pavone <pavone@retrodev.com>
parents: 27
diff changeset
268 }
6384e577842d Add code for filtering a program set based on the operators used
Mike Pavone <pavone@retrodev.com>
parents: 27
diff changeset
269 isTerminal? <- { false }
33
b00904b36aca More solver work
Mike Pavone <pavone@retrodev.com>
parents: 28
diff changeset
270 constant? <- {
b00904b36aca More solver work
Mike Pavone <pavone@retrodev.com>
parents: 28
diff changeset
271 _accInputNode <- startAcc
b00904b36aca More solver work
Mike Pavone <pavone@retrodev.com>
parents: 28
diff changeset
272 _foldInputNode <- toFold
b00904b36aca More solver work
Mike Pavone <pavone@retrodev.com>
parents: 28
diff changeset
273 fun constant?
b00904b36aca More solver work
Mike Pavone <pavone@retrodev.com>
parents: 28
diff changeset
274 }
28
6384e577842d Add code for filtering a program set based on the operators used
Mike Pavone <pavone@retrodev.com>
parents: 27
diff changeset
275 }
3
dfc5f00c94bc Initial evaluator implementation. fold is currently missing but other ops are present and seem to work
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
276 }
28
6384e577842d Add code for filtering a program set based on the operators used
Mike Pavone <pavone@retrodev.com>
parents: 27
diff changeset
277
6384e577842d Add code for filtering a program set based on the operators used
Mike Pavone <pavone@retrodev.com>
parents: 27
diff changeset
278 run <- :in {
6384e577842d Add code for filtering a program set based on the operators used
Mike Pavone <pavone@retrodev.com>
parents: 27
diff changeset
279 _input <- in
6384e577842d Add code for filtering a program set based on the operators used
Mike Pavone <pavone@retrodev.com>
parents: 27
diff changeset
280 eval: root
6384e577842d Add code for filtering a program set based on the operators used
Mike Pavone <pavone@retrodev.com>
parents: 27
diff changeset
281 }
6384e577842d Add code for filtering a program set based on the operators used
Mike Pavone <pavone@retrodev.com>
parents: 27
diff changeset
282
6384e577842d Add code for filtering a program set based on the operators used
Mike Pavone <pavone@retrodev.com>
parents: 27
diff changeset
283 root <- _zero
6384e577842d Add code for filtering a program set based on the operators used
Mike Pavone <pavone@retrodev.com>
parents: 27
diff changeset
284
6384e577842d Add code for filtering a program set based on the operators used
Mike Pavone <pavone@retrodev.com>
parents: 27
diff changeset
285 string <- {
6384e577842d Add code for filtering a program set based on the operators used
Mike Pavone <pavone@retrodev.com>
parents: 27
diff changeset
286 "(lambda (input) " . (string: root) . ")"
6384e577842d Add code for filtering a program set based on the operators used
Mike Pavone <pavone@retrodev.com>
parents: 27
diff changeset
287 }
6384e577842d Add code for filtering a program set based on the operators used
Mike Pavone <pavone@retrodev.com>
parents: 27
diff changeset
288
6384e577842d Add code for filtering a program set based on the operators used
Mike Pavone <pavone@retrodev.com>
parents: 27
diff changeset
289 gentestprog <- {
6384e577842d Add code for filtering a program set based on the operators used
Mike Pavone <pavone@retrodev.com>
parents: 27
diff changeset
290 root <- if0: (opAnd: input one) then: (
6384e577842d Add code for filtering a program set based on the operators used
Mike Pavone <pavone@retrodev.com>
parents: 27
diff changeset
291 plus: (opOr: input (shl1: one))
6384e577842d Add code for filtering a program set based on the operators used
Mike Pavone <pavone@retrodev.com>
parents: 27
diff changeset
292 ) else: (
6384e577842d Add code for filtering a program set based on the operators used
Mike Pavone <pavone@retrodev.com>
parents: 27
diff changeset
293 opXor: input (shr16: input)
6384e577842d Add code for filtering a program set based on the operators used
Mike Pavone <pavone@retrodev.com>
parents: 27
diff changeset
294 )
6384e577842d Add code for filtering a program set based on the operators used
Mike Pavone <pavone@retrodev.com>
parents: 27
diff changeset
295 self
6384e577842d Add code for filtering a program set based on the operators used
Mike Pavone <pavone@retrodev.com>
parents: 27
diff changeset
296 }
6384e577842d Add code for filtering a program set based on the operators used
Mike Pavone <pavone@retrodev.com>
parents: 27
diff changeset
297
6384e577842d Add code for filtering a program set based on the operators used
Mike Pavone <pavone@retrodev.com>
parents: 27
diff changeset
298 exampleprog <- {
6384e577842d Add code for filtering a program set based on the operators used
Mike Pavone <pavone@retrodev.com>
parents: 27
diff changeset
299 root <- fold: input with: (opOr: val acc) startingAt: zero
6384e577842d Add code for filtering a program set based on the operators used
Mike Pavone <pavone@retrodev.com>
parents: 27
diff changeset
300 self
6384e577842d Add code for filtering a program set based on the operators used
Mike Pavone <pavone@retrodev.com>
parents: 27
diff changeset
301 }
3
dfc5f00c94bc Initial evaluator implementation. fold is currently missing but other ops are present and seem to work
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
302
28
6384e577842d Add code for filtering a program set based on the operators used
Mike Pavone <pavone@retrodev.com>
parents: 27
diff changeset
303 allOfSize:inFold? <- :n :infold? {
56
f864792a1b17 Improve prefiltering in program generator. Make solver use similar logic to driver when run standalone.
Mike Pavone <pavone@retrodev.com>
parents: 43
diff changeset
304 memoAdjust <- 1
28
6384e577842d Add code for filtering a program set based on the operators used
Mike Pavone <pavone@retrodev.com>
parents: 27
diff changeset
305 memo <- if: infold? = 2 {
6384e577842d Add code for filtering a program set based on the operators used
Mike Pavone <pavone@retrodev.com>
parents: 27
diff changeset
306 _memoFoldBody
6384e577842d Add code for filtering a program set based on the operators used
Mike Pavone <pavone@retrodev.com>
parents: 27
diff changeset
307 } else: {
6384e577842d Add code for filtering a program set based on the operators used
Mike Pavone <pavone@retrodev.com>
parents: 27
diff changeset
308 if: infold? = 1 && n > 4 {
56
f864792a1b17 Improve prefiltering in program generator. Make solver use similar logic to driver when run standalone.
Mike Pavone <pavone@retrodev.com>
parents: 43
diff changeset
309 memoAdjust <- 5
28
6384e577842d Add code for filtering a program set based on the operators used
Mike Pavone <pavone@retrodev.com>
parents: 27
diff changeset
310 _memoFoldParam
6384e577842d Add code for filtering a program set based on the operators used
Mike Pavone <pavone@retrodev.com>
parents: 27
diff changeset
311 } else: {
6384e577842d Add code for filtering a program set based on the operators used
Mike Pavone <pavone@retrodev.com>
parents: 27
diff changeset
312 _memo
6384e577842d Add code for filtering a program set based on the operators used
Mike Pavone <pavone@retrodev.com>
parents: 27
diff changeset
313 }
6384e577842d Add code for filtering a program set based on the operators used
Mike Pavone <pavone@retrodev.com>
parents: 27
diff changeset
314 }
56
f864792a1b17 Improve prefiltering in program generator. Make solver use similar logic to driver when run standalone.
Mike Pavone <pavone@retrodev.com>
parents: 43
diff changeset
315 if: n - memoAdjust < (memo length) {
f864792a1b17 Improve prefiltering in program generator. Make solver use similar logic to driver when run standalone.
Mike Pavone <pavone@retrodev.com>
parents: 43
diff changeset
316 memo get: (n - memoAdjust)
28
6384e577842d Add code for filtering a program set based on the operators used
Mike Pavone <pavone@retrodev.com>
parents: 27
diff changeset
317 } else: {
6384e577842d Add code for filtering a program set based on the operators used
Mike Pavone <pavone@retrodev.com>
parents: 27
diff changeset
318 if: n = 1 {
6384e577842d Add code for filtering a program set based on the operators used
Mike Pavone <pavone@retrodev.com>
parents: 27
diff changeset
319 res <- #[one zero input]
6384e577842d Add code for filtering a program set based on the operators used
Mike Pavone <pavone@retrodev.com>
parents: 27
diff changeset
320 if: infold? = 2 {
6384e577842d Add code for filtering a program set based on the operators used
Mike Pavone <pavone@retrodev.com>
parents: 27
diff changeset
321 res append: acc
6384e577842d Add code for filtering a program set based on the operators used
Mike Pavone <pavone@retrodev.com>
parents: 27
diff changeset
322 res append: val
6384e577842d Add code for filtering a program set based on the operators used
Mike Pavone <pavone@retrodev.com>
parents: 27
diff changeset
323 }
6384e577842d Add code for filtering a program set based on the operators used
Mike Pavone <pavone@retrodev.com>
parents: 27
diff changeset
324 print: "Saving at memo index: " . (string: (memo length)) . "\n"
6384e577842d Add code for filtering a program set based on the operators used
Mike Pavone <pavone@retrodev.com>
parents: 27
diff changeset
325 memo append: res
6384e577842d Add code for filtering a program set based on the operators used
Mike Pavone <pavone@retrodev.com>
parents: 27
diff changeset
326 res
3
dfc5f00c94bc Initial evaluator implementation. fold is currently missing but other ops are present and seem to work
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
327 } else: {
28
6384e577842d Add code for filtering a program set based on the operators used
Mike Pavone <pavone@retrodev.com>
parents: 27
diff changeset
328 res <- #[]
6384e577842d Add code for filtering a program set based on the operators used
Mike Pavone <pavone@retrodev.com>
parents: 27
diff changeset
329 foreach: (allOfSize: n - 1 inFold?: infold?) :idx exp {
6384e577842d Add code for filtering a program set based on the operators used
Mike Pavone <pavone@retrodev.com>
parents: 27
diff changeset
330 res append: (opNot: exp)
6384e577842d Add code for filtering a program set based on the operators used
Mike Pavone <pavone@retrodev.com>
parents: 27
diff changeset
331 res append: (shl1: exp)
6384e577842d Add code for filtering a program set based on the operators used
Mike Pavone <pavone@retrodev.com>
parents: 27
diff changeset
332 res append: (shr1: exp)
6384e577842d Add code for filtering a program set based on the operators used
Mike Pavone <pavone@retrodev.com>
parents: 27
diff changeset
333 res append: (shr4: exp)
6384e577842d Add code for filtering a program set based on the operators used
Mike Pavone <pavone@retrodev.com>
parents: 27
diff changeset
334 res append: (shr16: exp)
6384e577842d Add code for filtering a program set based on the operators used
Mike Pavone <pavone@retrodev.com>
parents: 27
diff changeset
335 }
6384e577842d Add code for filtering a program set based on the operators used
Mike Pavone <pavone@retrodev.com>
parents: 27
diff changeset
336 if: n > 2 {
6384e577842d Add code for filtering a program set based on the operators used
Mike Pavone <pavone@retrodev.com>
parents: 27
diff changeset
337 numLeft <- 1
6384e577842d Add code for filtering a program set based on the operators used
Mike Pavone <pavone@retrodev.com>
parents: 27
diff changeset
338 argTotal <- n - 1
6384e577842d Add code for filtering a program set based on the operators used
Mike Pavone <pavone@retrodev.com>
parents: 27
diff changeset
339 while: { numLeft < argTotal } do: {
6384e577842d Add code for filtering a program set based on the operators used
Mike Pavone <pavone@retrodev.com>
parents: 27
diff changeset
340 numRight <- argTotal - numLeft
6384e577842d Add code for filtering a program set based on the operators used
Mike Pavone <pavone@retrodev.com>
parents: 27
diff changeset
341 choicesRight <- (allOfSize: numRight inFold?: infold?)
6384e577842d Add code for filtering a program set based on the operators used
Mike Pavone <pavone@retrodev.com>
parents: 27
diff changeset
342 foreach: (allOfSize: numLeft inFold?: infold?) :idx leftExp {
6384e577842d Add code for filtering a program set based on the operators used
Mike Pavone <pavone@retrodev.com>
parents: 27
diff changeset
343 foreach: choicesRight :idx rightExp {
6384e577842d Add code for filtering a program set based on the operators used
Mike Pavone <pavone@retrodev.com>
parents: 27
diff changeset
344 res append: (opAnd: leftExp rightExp)
6384e577842d Add code for filtering a program set based on the operators used
Mike Pavone <pavone@retrodev.com>
parents: 27
diff changeset
345 res append: (opOr: leftExp rightExp)
6384e577842d Add code for filtering a program set based on the operators used
Mike Pavone <pavone@retrodev.com>
parents: 27
diff changeset
346 res append: (opXor: leftExp rightExp)
6384e577842d Add code for filtering a program set based on the operators used
Mike Pavone <pavone@retrodev.com>
parents: 27
diff changeset
347 res append: (plus: leftExp rightExp)
6384e577842d Add code for filtering a program set based on the operators used
Mike Pavone <pavone@retrodev.com>
parents: 27
diff changeset
348 }
6384e577842d Add code for filtering a program set based on the operators used
Mike Pavone <pavone@retrodev.com>
parents: 27
diff changeset
349 }
6384e577842d Add code for filtering a program set based on the operators used
Mike Pavone <pavone@retrodev.com>
parents: 27
diff changeset
350 numLeft <- numLeft + 1
6384e577842d Add code for filtering a program set based on the operators used
Mike Pavone <pavone@retrodev.com>
parents: 27
diff changeset
351 }
6384e577842d Add code for filtering a program set based on the operators used
Mike Pavone <pavone@retrodev.com>
parents: 27
diff changeset
352 if: n > 3 {
6384e577842d Add code for filtering a program set based on the operators used
Mike Pavone <pavone@retrodev.com>
parents: 27
diff changeset
353 numLeft <- 1
6384e577842d Add code for filtering a program set based on the operators used
Mike Pavone <pavone@retrodev.com>
parents: 27
diff changeset
354 limitLeft <- n - 2
6384e577842d Add code for filtering a program set based on the operators used
Mike Pavone <pavone@retrodev.com>
parents: 27
diff changeset
355 while: { numLeft < limitLeft } do: {
6384e577842d Add code for filtering a program set based on the operators used
Mike Pavone <pavone@retrodev.com>
parents: 27
diff changeset
356 numMid <- 1
6384e577842d Add code for filtering a program set based on the operators used
Mike Pavone <pavone@retrodev.com>
parents: 27
diff changeset
357 limitMid <- n - (1 + numLeft)
6384e577842d Add code for filtering a program set based on the operators used
Mike Pavone <pavone@retrodev.com>
parents: 27
diff changeset
358 while: { numMid < limitMid } do: {
6384e577842d Add code for filtering a program set based on the operators used
Mike Pavone <pavone@retrodev.com>
parents: 27
diff changeset
359 numRight <- n - (1 + numLeft + numMid)
6384e577842d Add code for filtering a program set based on the operators used
Mike Pavone <pavone@retrodev.com>
parents: 27
diff changeset
360 choicesRight <- (allOfSize: numRight inFold?: infold?)
6384e577842d Add code for filtering a program set based on the operators used
Mike Pavone <pavone@retrodev.com>
parents: 27
diff changeset
361 choicesMid <- (allOfSize: numMid inFold?: infold?)
6384e577842d Add code for filtering a program set based on the operators used
Mike Pavone <pavone@retrodev.com>
parents: 27
diff changeset
362 foreach: (allOfSize: numLeft inFold?: infold?) :idx leftExp {
6384e577842d Add code for filtering a program set based on the operators used
Mike Pavone <pavone@retrodev.com>
parents: 27
diff changeset
363 foreach: choicesMid :idx midExp {
6384e577842d Add code for filtering a program set based on the operators used
Mike Pavone <pavone@retrodev.com>
parents: 27
diff changeset
364 foreach: choicesRight :idx rightExp {
6384e577842d Add code for filtering a program set based on the operators used
Mike Pavone <pavone@retrodev.com>
parents: 27
diff changeset
365 res append: (if0: leftExp then: midExp else: rightExp)
6384e577842d Add code for filtering a program set based on the operators used
Mike Pavone <pavone@retrodev.com>
parents: 27
diff changeset
366 }
6384e577842d Add code for filtering a program set based on the operators used
Mike Pavone <pavone@retrodev.com>
parents: 27
diff changeset
367 }
6384e577842d Add code for filtering a program set based on the operators used
Mike Pavone <pavone@retrodev.com>
parents: 27
diff changeset
368 }
6384e577842d Add code for filtering a program set based on the operators used
Mike Pavone <pavone@retrodev.com>
parents: 27
diff changeset
369 numMid <- numMid + 1
6384e577842d Add code for filtering a program set based on the operators used
Mike Pavone <pavone@retrodev.com>
parents: 27
diff changeset
370 }
6384e577842d Add code for filtering a program set based on the operators used
Mike Pavone <pavone@retrodev.com>
parents: 27
diff changeset
371 numLeft <- numLeft + 1
6384e577842d Add code for filtering a program set based on the operators used
Mike Pavone <pavone@retrodev.com>
parents: 27
diff changeset
372 }
6384e577842d Add code for filtering a program set based on the operators used
Mike Pavone <pavone@retrodev.com>
parents: 27
diff changeset
373 if: n > 4 && infold? = 0 {
6384e577842d Add code for filtering a program set based on the operators used
Mike Pavone <pavone@retrodev.com>
parents: 27
diff changeset
374 numSeq <- 1
6384e577842d Add code for filtering a program set based on the operators used
Mike Pavone <pavone@retrodev.com>
parents: 27
diff changeset
375 limitSeq <- n - 3
6384e577842d Add code for filtering a program set based on the operators used
Mike Pavone <pavone@retrodev.com>
parents: 27
diff changeset
376 while: { numSeq < limitSeq } do: {
6384e577842d Add code for filtering a program set based on the operators used
Mike Pavone <pavone@retrodev.com>
parents: 27
diff changeset
377 numFun <- 1
6384e577842d Add code for filtering a program set based on the operators used
Mike Pavone <pavone@retrodev.com>
parents: 27
diff changeset
378 limitFun <- n - (2 + numSeq)
6384e577842d Add code for filtering a program set based on the operators used
Mike Pavone <pavone@retrodev.com>
parents: 27
diff changeset
379 while: { numFun < limitFun } do: {
6384e577842d Add code for filtering a program set based on the operators used
Mike Pavone <pavone@retrodev.com>
parents: 27
diff changeset
380 numStart <- n - (2 + numSeq + numFun)
6384e577842d Add code for filtering a program set based on the operators used
Mike Pavone <pavone@retrodev.com>
parents: 27
diff changeset
381 choicesStart <- (allOfSize: numStart inFold?: 1)
6384e577842d Add code for filtering a program set based on the operators used
Mike Pavone <pavone@retrodev.com>
parents: 27
diff changeset
382 choicesFun <- (allOfSize: numFun inFold?: 2)
6384e577842d Add code for filtering a program set based on the operators used
Mike Pavone <pavone@retrodev.com>
parents: 27
diff changeset
383 foreach: (allOfSize: numSeq inFold?: 1) :idx seqExp {
6384e577842d Add code for filtering a program set based on the operators used
Mike Pavone <pavone@retrodev.com>
parents: 27
diff changeset
384 foreach: choicesFun :idx funExp {
6384e577842d Add code for filtering a program set based on the operators used
Mike Pavone <pavone@retrodev.com>
parents: 27
diff changeset
385 foreach: choicesStart :idx startExp {
6384e577842d Add code for filtering a program set based on the operators used
Mike Pavone <pavone@retrodev.com>
parents: 27
diff changeset
386 res append: (fold: seqExp with: funExp startingAt: startExp)
6384e577842d Add code for filtering a program set based on the operators used
Mike Pavone <pavone@retrodev.com>
parents: 27
diff changeset
387 }
6384e577842d Add code for filtering a program set based on the operators used
Mike Pavone <pavone@retrodev.com>
parents: 27
diff changeset
388 }
6384e577842d Add code for filtering a program set based on the operators used
Mike Pavone <pavone@retrodev.com>
parents: 27
diff changeset
389 }
6384e577842d Add code for filtering a program set based on the operators used
Mike Pavone <pavone@retrodev.com>
parents: 27
diff changeset
390 numFun <- numFun + 1
6384e577842d Add code for filtering a program set based on the operators used
Mike Pavone <pavone@retrodev.com>
parents: 27
diff changeset
391 }
6384e577842d Add code for filtering a program set based on the operators used
Mike Pavone <pavone@retrodev.com>
parents: 27
diff changeset
392 numSeq <- numSeq + 1
6384e577842d Add code for filtering a program set based on the operators used
Mike Pavone <pavone@retrodev.com>
parents: 27
diff changeset
393 }
6384e577842d Add code for filtering a program set based on the operators used
Mike Pavone <pavone@retrodev.com>
parents: 27
diff changeset
394 }
6384e577842d Add code for filtering a program set based on the operators used
Mike Pavone <pavone@retrodev.com>
parents: 27
diff changeset
395 }
6384e577842d Add code for filtering a program set based on the operators used
Mike Pavone <pavone@retrodev.com>
parents: 27
diff changeset
396 }
6384e577842d Add code for filtering a program set based on the operators used
Mike Pavone <pavone@retrodev.com>
parents: 27
diff changeset
397 print: "Saving " . (string: n) . " at memo index: " . (string: (memo length)) . "\n"
6384e577842d Add code for filtering a program set based on the operators used
Mike Pavone <pavone@retrodev.com>
parents: 27
diff changeset
398 memo append: res
6384e577842d Add code for filtering a program set based on the operators used
Mike Pavone <pavone@retrodev.com>
parents: 27
diff changeset
399 res
3
dfc5f00c94bc Initial evaluator implementation. fold is currently missing but other ops are present and seem to work
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
400 }
dfc5f00c94bc Initial evaluator implementation. fold is currently missing but other ops are present and seem to work
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
401 }
dfc5f00c94bc Initial evaluator implementation. fold is currently missing but other ops are present and seem to work
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
402 }
dfc5f00c94bc Initial evaluator implementation. fold is currently missing but other ops are present and seem to work
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
403
28
6384e577842d Add code for filtering a program set based on the operators used
Mike Pavone <pavone@retrodev.com>
parents: 27
diff changeset
404 allOfSize <- :n {
6384e577842d Add code for filtering a program set based on the operators used
Mike Pavone <pavone@retrodev.com>
parents: 27
diff changeset
405 allOfSize: (n - 1) inFold?: 0
27
655d5b19333d Add memoization support to program generator
Mike Pavone <pavone@retrodev.com>
parents: 9
diff changeset
406 }
28
6384e577842d Add code for filtering a program set based on the operators used
Mike Pavone <pavone@retrodev.com>
parents: 27
diff changeset
407
56
f864792a1b17 Improve prefiltering in program generator. Make solver use similar logic to driver when run standalone.
Mike Pavone <pavone@retrodev.com>
parents: 43
diff changeset
408 allOfSize:inFold?:withOps:needOps <- :n :infold? :ops :needed {
f864792a1b17 Improve prefiltering in program generator. Make solver use similar logic to driver when run standalone.
Mike Pavone <pavone@retrodev.com>
parents: 43
diff changeset
409 if: n <= 7 {
f864792a1b17 Improve prefiltering in program generator. Make solver use similar logic to driver when run standalone.
Mike Pavone <pavone@retrodev.com>
parents: 43
diff changeset
410 unfiltered <- allOfSize: n inFold?: infold?
f864792a1b17 Improve prefiltering in program generator. Make solver use similar logic to driver when run standalone.
Mike Pavone <pavone@retrodev.com>
parents: 43
diff changeset
411 if: (needed) > 0 {
f864792a1b17 Improve prefiltering in program generator. Make solver use similar logic to driver when run standalone.
Mike Pavone <pavone@retrodev.com>
parents: 43
diff changeset
412 _filterTrees: unfiltered needed
f864792a1b17 Improve prefiltering in program generator. Make solver use similar logic to driver when run standalone.
Mike Pavone <pavone@retrodev.com>
parents: 43
diff changeset
413 } else: {
f864792a1b17 Improve prefiltering in program generator. Make solver use similar logic to driver when run standalone.
Mike Pavone <pavone@retrodev.com>
parents: 43
diff changeset
414 unfiltered
43
96b2fcb746bf Add support for generating programs with only a certain set of operators to allow work with slightly larger problem sizes
Mike Pavone <pavone@retrodev.com>
parents: 33
diff changeset
415 }
96b2fcb746bf Add support for generating programs with only a certain set of operators to allow work with slightly larger problem sizes
Mike Pavone <pavone@retrodev.com>
parents: 33
diff changeset
416 } else: {
96b2fcb746bf Add support for generating programs with only a certain set of operators to allow work with slightly larger problem sizes
Mike Pavone <pavone@retrodev.com>
parents: 33
diff changeset
417 res <- #[]
96b2fcb746bf Add support for generating programs with only a certain set of operators to allow work with slightly larger problem sizes
Mike Pavone <pavone@retrodev.com>
parents: 33
diff changeset
418 origops <- ops
96b2fcb746bf Add support for generating programs with only a certain set of operators to allow work with slightly larger problem sizes
Mike Pavone <pavone@retrodev.com>
parents: 33
diff changeset
419 if: (ops and _opTfold) > 0 {
96b2fcb746bf Add support for generating programs with only a certain set of operators to allow work with slightly larger problem sizes
Mike Pavone <pavone@retrodev.com>
parents: 33
diff changeset
420 ops <- ops and _maskRemoveFold
56
f864792a1b17 Improve prefiltering in program generator. Make solver use similar logic to driver when run standalone.
Mike Pavone <pavone@retrodev.com>
parents: 43
diff changeset
421 } else: {
f864792a1b17 Improve prefiltering in program generator. Make solver use similar logic to driver when run standalone.
Mike Pavone <pavone@retrodev.com>
parents: 43
diff changeset
422 if: (ops and _opNot) > 0 {
f864792a1b17 Improve prefiltering in program generator. Make solver use similar logic to driver when run standalone.
Mike Pavone <pavone@retrodev.com>
parents: 43
diff changeset
423 foreach: (allOfSize: n - 1 inFold?: infold? withOps: ops needOps: (needed and _opNotMask)) :idx exp {
43
96b2fcb746bf Add support for generating programs with only a certain set of operators to allow work with slightly larger problem sizes
Mike Pavone <pavone@retrodev.com>
parents: 33
diff changeset
424 res append: (opNot: exp)
96b2fcb746bf Add support for generating programs with only a certain set of operators to allow work with slightly larger problem sizes
Mike Pavone <pavone@retrodev.com>
parents: 33
diff changeset
425 }
56
f864792a1b17 Improve prefiltering in program generator. Make solver use similar logic to driver when run standalone.
Mike Pavone <pavone@retrodev.com>
parents: 43
diff changeset
426 }
f864792a1b17 Improve prefiltering in program generator. Make solver use similar logic to driver when run standalone.
Mike Pavone <pavone@retrodev.com>
parents: 43
diff changeset
427 if: (ops and _opShl1) > 0 {
f864792a1b17 Improve prefiltering in program generator. Make solver use similar logic to driver when run standalone.
Mike Pavone <pavone@retrodev.com>
parents: 43
diff changeset
428 foreach: (allOfSize: n - 1 inFold?: infold? withOps: ops needOps: (needed and _opShl1Mask)) :idx exp {
43
96b2fcb746bf Add support for generating programs with only a certain set of operators to allow work with slightly larger problem sizes
Mike Pavone <pavone@retrodev.com>
parents: 33
diff changeset
429 res append: (shl1: exp)
96b2fcb746bf Add support for generating programs with only a certain set of operators to allow work with slightly larger problem sizes
Mike Pavone <pavone@retrodev.com>
parents: 33
diff changeset
430 }
56
f864792a1b17 Improve prefiltering in program generator. Make solver use similar logic to driver when run standalone.
Mike Pavone <pavone@retrodev.com>
parents: 43
diff changeset
431 }
f864792a1b17 Improve prefiltering in program generator. Make solver use similar logic to driver when run standalone.
Mike Pavone <pavone@retrodev.com>
parents: 43
diff changeset
432 if: (ops and _opShr1) > 0 {
f864792a1b17 Improve prefiltering in program generator. Make solver use similar logic to driver when run standalone.
Mike Pavone <pavone@retrodev.com>
parents: 43
diff changeset
433 foreach: (allOfSize: n - 1 inFold?: infold? withOps: ops needOps: (needed and _opShr1Mask)) :idx exp {
43
96b2fcb746bf Add support for generating programs with only a certain set of operators to allow work with slightly larger problem sizes
Mike Pavone <pavone@retrodev.com>
parents: 33
diff changeset
434 res append: (shr1: exp)
96b2fcb746bf Add support for generating programs with only a certain set of operators to allow work with slightly larger problem sizes
Mike Pavone <pavone@retrodev.com>
parents: 33
diff changeset
435 }
56
f864792a1b17 Improve prefiltering in program generator. Make solver use similar logic to driver when run standalone.
Mike Pavone <pavone@retrodev.com>
parents: 43
diff changeset
436 }
f864792a1b17 Improve prefiltering in program generator. Make solver use similar logic to driver when run standalone.
Mike Pavone <pavone@retrodev.com>
parents: 43
diff changeset
437 if: (ops and _opShr4) > 0 {
f864792a1b17 Improve prefiltering in program generator. Make solver use similar logic to driver when run standalone.
Mike Pavone <pavone@retrodev.com>
parents: 43
diff changeset
438 foreach: (allOfSize: n - 1 inFold?: infold? withOps: ops needOps: (needed and _opShr4Mask)) :idx exp {
43
96b2fcb746bf Add support for generating programs with only a certain set of operators to allow work with slightly larger problem sizes
Mike Pavone <pavone@retrodev.com>
parents: 33
diff changeset
439 res append: (shr4: exp)
96b2fcb746bf Add support for generating programs with only a certain set of operators to allow work with slightly larger problem sizes
Mike Pavone <pavone@retrodev.com>
parents: 33
diff changeset
440 }
56
f864792a1b17 Improve prefiltering in program generator. Make solver use similar logic to driver when run standalone.
Mike Pavone <pavone@retrodev.com>
parents: 43
diff changeset
441 }
f864792a1b17 Improve prefiltering in program generator. Make solver use similar logic to driver when run standalone.
Mike Pavone <pavone@retrodev.com>
parents: 43
diff changeset
442 if: (ops and _opShr16) > 0 {
f864792a1b17 Improve prefiltering in program generator. Make solver use similar logic to driver when run standalone.
Mike Pavone <pavone@retrodev.com>
parents: 43
diff changeset
443 foreach: (allOfSize: n - 1 inFold?: infold? withOps: ops needOps: (needed and _opShr16Mask)) :idx exp {
43
96b2fcb746bf Add support for generating programs with only a certain set of operators to allow work with slightly larger problem sizes
Mike Pavone <pavone@retrodev.com>
parents: 33
diff changeset
444 res append: (shr16: exp)
96b2fcb746bf Add support for generating programs with only a certain set of operators to allow work with slightly larger problem sizes
Mike Pavone <pavone@retrodev.com>
parents: 33
diff changeset
445 }
96b2fcb746bf Add support for generating programs with only a certain set of operators to allow work with slightly larger problem sizes
Mike Pavone <pavone@retrodev.com>
parents: 33
diff changeset
446 }
96b2fcb746bf Add support for generating programs with only a certain set of operators to allow work with slightly larger problem sizes
Mike Pavone <pavone@retrodev.com>
parents: 33
diff changeset
447 numLeft <- 1
96b2fcb746bf Add support for generating programs with only a certain set of operators to allow work with slightly larger problem sizes
Mike Pavone <pavone@retrodev.com>
parents: 33
diff changeset
448 argTotal <- n - 1
96b2fcb746bf Add support for generating programs with only a certain set of operators to allow work with slightly larger problem sizes
Mike Pavone <pavone@retrodev.com>
parents: 33
diff changeset
449 if: (ops and (_opAnd or _opOr or _opXor or _opPlus)) > 0 {
96b2fcb746bf Add support for generating programs with only a certain set of operators to allow work with slightly larger problem sizes
Mike Pavone <pavone@retrodev.com>
parents: 33
diff changeset
450 while: { numLeft < argTotal } do: {
96b2fcb746bf Add support for generating programs with only a certain set of operators to allow work with slightly larger problem sizes
Mike Pavone <pavone@retrodev.com>
parents: 33
diff changeset
451 numRight <- argTotal - numLeft
56
f864792a1b17 Improve prefiltering in program generator. Make solver use similar logic to driver when run standalone.
Mike Pavone <pavone@retrodev.com>
parents: 43
diff changeset
452 choicesRight <- (allOfSize: numRight inFold?: infold? withOps: ops needOps: 0)
f864792a1b17 Improve prefiltering in program generator. Make solver use similar logic to driver when run standalone.
Mike Pavone <pavone@retrodev.com>
parents: 43
diff changeset
453 foreach: (allOfSize: numLeft inFold?: infold? withOps: ops needOps: 0) :idx leftExp {
f864792a1b17 Improve prefiltering in program generator. Make solver use similar logic to driver when run standalone.
Mike Pavone <pavone@retrodev.com>
parents: 43
diff changeset
454 if: (ops and _opAnd) > 0 {
f864792a1b17 Improve prefiltering in program generator. Make solver use similar logic to driver when run standalone.
Mike Pavone <pavone@retrodev.com>
parents: 43
diff changeset
455 foreach: choicesRight :idx rightExp {
f864792a1b17 Improve prefiltering in program generator. Make solver use similar logic to driver when run standalone.
Mike Pavone <pavone@retrodev.com>
parents: 43
diff changeset
456 newop <- (opAnd: leftExp rightExp)
f864792a1b17 Improve prefiltering in program generator. Make solver use similar logic to driver when run standalone.
Mike Pavone <pavone@retrodev.com>
parents: 43
diff changeset
457 if: needed = 0 || (((newop operators) and needed) xor needed) = 0 {
f864792a1b17 Improve prefiltering in program generator. Make solver use similar logic to driver when run standalone.
Mike Pavone <pavone@retrodev.com>
parents: 43
diff changeset
458 res append: newop
f864792a1b17 Improve prefiltering in program generator. Make solver use similar logic to driver when run standalone.
Mike Pavone <pavone@retrodev.com>
parents: 43
diff changeset
459 }
43
96b2fcb746bf Add support for generating programs with only a certain set of operators to allow work with slightly larger problem sizes
Mike Pavone <pavone@retrodev.com>
parents: 33
diff changeset
460 }
56
f864792a1b17 Improve prefiltering in program generator. Make solver use similar logic to driver when run standalone.
Mike Pavone <pavone@retrodev.com>
parents: 43
diff changeset
461 }
f864792a1b17 Improve prefiltering in program generator. Make solver use similar logic to driver when run standalone.
Mike Pavone <pavone@retrodev.com>
parents: 43
diff changeset
462 if: (ops and _opOr) > 0 {
f864792a1b17 Improve prefiltering in program generator. Make solver use similar logic to driver when run standalone.
Mike Pavone <pavone@retrodev.com>
parents: 43
diff changeset
463 foreach: choicesRight :idx rightExp {
f864792a1b17 Improve prefiltering in program generator. Make solver use similar logic to driver when run standalone.
Mike Pavone <pavone@retrodev.com>
parents: 43
diff changeset
464 newop <- (opOr: leftExp rightExp)
f864792a1b17 Improve prefiltering in program generator. Make solver use similar logic to driver when run standalone.
Mike Pavone <pavone@retrodev.com>
parents: 43
diff changeset
465 if: needed = 0 || (((newop operators) and needed) xor needed) = 0 {
f864792a1b17 Improve prefiltering in program generator. Make solver use similar logic to driver when run standalone.
Mike Pavone <pavone@retrodev.com>
parents: 43
diff changeset
466 res append: newop
f864792a1b17 Improve prefiltering in program generator. Make solver use similar logic to driver when run standalone.
Mike Pavone <pavone@retrodev.com>
parents: 43
diff changeset
467 }
43
96b2fcb746bf Add support for generating programs with only a certain set of operators to allow work with slightly larger problem sizes
Mike Pavone <pavone@retrodev.com>
parents: 33
diff changeset
468 }
56
f864792a1b17 Improve prefiltering in program generator. Make solver use similar logic to driver when run standalone.
Mike Pavone <pavone@retrodev.com>
parents: 43
diff changeset
469 }
f864792a1b17 Improve prefiltering in program generator. Make solver use similar logic to driver when run standalone.
Mike Pavone <pavone@retrodev.com>
parents: 43
diff changeset
470 if: (ops and _opXor) > 0 {
f864792a1b17 Improve prefiltering in program generator. Make solver use similar logic to driver when run standalone.
Mike Pavone <pavone@retrodev.com>
parents: 43
diff changeset
471 foreach: choicesRight :idx rightExp {
f864792a1b17 Improve prefiltering in program generator. Make solver use similar logic to driver when run standalone.
Mike Pavone <pavone@retrodev.com>
parents: 43
diff changeset
472 newop <- (opXor: leftExp rightExp)
f864792a1b17 Improve prefiltering in program generator. Make solver use similar logic to driver when run standalone.
Mike Pavone <pavone@retrodev.com>
parents: 43
diff changeset
473 if: needed = 0 || (((newop operators) and needed) xor needed) = 0 {
f864792a1b17 Improve prefiltering in program generator. Make solver use similar logic to driver when run standalone.
Mike Pavone <pavone@retrodev.com>
parents: 43
diff changeset
474 res append: newop
f864792a1b17 Improve prefiltering in program generator. Make solver use similar logic to driver when run standalone.
Mike Pavone <pavone@retrodev.com>
parents: 43
diff changeset
475 }
43
96b2fcb746bf Add support for generating programs with only a certain set of operators to allow work with slightly larger problem sizes
Mike Pavone <pavone@retrodev.com>
parents: 33
diff changeset
476 }
56
f864792a1b17 Improve prefiltering in program generator. Make solver use similar logic to driver when run standalone.
Mike Pavone <pavone@retrodev.com>
parents: 43
diff changeset
477 }
f864792a1b17 Improve prefiltering in program generator. Make solver use similar logic to driver when run standalone.
Mike Pavone <pavone@retrodev.com>
parents: 43
diff changeset
478 if: (ops and _opPlus) > 0 {
f864792a1b17 Improve prefiltering in program generator. Make solver use similar logic to driver when run standalone.
Mike Pavone <pavone@retrodev.com>
parents: 43
diff changeset
479 foreach: choicesRight :idx rightExp {
f864792a1b17 Improve prefiltering in program generator. Make solver use similar logic to driver when run standalone.
Mike Pavone <pavone@retrodev.com>
parents: 43
diff changeset
480 newop <- (plus: leftExp rightExp)
f864792a1b17 Improve prefiltering in program generator. Make solver use similar logic to driver when run standalone.
Mike Pavone <pavone@retrodev.com>
parents: 43
diff changeset
481 if: needed = 0 || (((newop operators) and needed) xor needed) = 0 {
f864792a1b17 Improve prefiltering in program generator. Make solver use similar logic to driver when run standalone.
Mike Pavone <pavone@retrodev.com>
parents: 43
diff changeset
482 res append: newop
f864792a1b17 Improve prefiltering in program generator. Make solver use similar logic to driver when run standalone.
Mike Pavone <pavone@retrodev.com>
parents: 43
diff changeset
483 }
43
96b2fcb746bf Add support for generating programs with only a certain set of operators to allow work with slightly larger problem sizes
Mike Pavone <pavone@retrodev.com>
parents: 33
diff changeset
484 }
96b2fcb746bf Add support for generating programs with only a certain set of operators to allow work with slightly larger problem sizes
Mike Pavone <pavone@retrodev.com>
parents: 33
diff changeset
485 }
96b2fcb746bf Add support for generating programs with only a certain set of operators to allow work with slightly larger problem sizes
Mike Pavone <pavone@retrodev.com>
parents: 33
diff changeset
486 }
96b2fcb746bf Add support for generating programs with only a certain set of operators to allow work with slightly larger problem sizes
Mike Pavone <pavone@retrodev.com>
parents: 33
diff changeset
487 numLeft <- numLeft + 1
96b2fcb746bf Add support for generating programs with only a certain set of operators to allow work with slightly larger problem sizes
Mike Pavone <pavone@retrodev.com>
parents: 33
diff changeset
488 }
96b2fcb746bf Add support for generating programs with only a certain set of operators to allow work with slightly larger problem sizes
Mike Pavone <pavone@retrodev.com>
parents: 33
diff changeset
489 }
56
f864792a1b17 Improve prefiltering in program generator. Make solver use similar logic to driver when run standalone.
Mike Pavone <pavone@retrodev.com>
parents: 43
diff changeset
490 numLeft <- 1
f864792a1b17 Improve prefiltering in program generator. Make solver use similar logic to driver when run standalone.
Mike Pavone <pavone@retrodev.com>
parents: 43
diff changeset
491 limitLeft <- n - 2
f864792a1b17 Improve prefiltering in program generator. Make solver use similar logic to driver when run standalone.
Mike Pavone <pavone@retrodev.com>
parents: 43
diff changeset
492 if: (ops and _opIf0) > 0 {
f864792a1b17 Improve prefiltering in program generator. Make solver use similar logic to driver when run standalone.
Mike Pavone <pavone@retrodev.com>
parents: 43
diff changeset
493 while: { numLeft < limitLeft } do: {
f864792a1b17 Improve prefiltering in program generator. Make solver use similar logic to driver when run standalone.
Mike Pavone <pavone@retrodev.com>
parents: 43
diff changeset
494 numMid <- 1
f864792a1b17 Improve prefiltering in program generator. Make solver use similar logic to driver when run standalone.
Mike Pavone <pavone@retrodev.com>
parents: 43
diff changeset
495 limitMid <- n - (1 + numLeft)
f864792a1b17 Improve prefiltering in program generator. Make solver use similar logic to driver when run standalone.
Mike Pavone <pavone@retrodev.com>
parents: 43
diff changeset
496 while: { numMid < limitMid } do: {
f864792a1b17 Improve prefiltering in program generator. Make solver use similar logic to driver when run standalone.
Mike Pavone <pavone@retrodev.com>
parents: 43
diff changeset
497 numRight <- n - (1 + numLeft + numMid)
f864792a1b17 Improve prefiltering in program generator. Make solver use similar logic to driver when run standalone.
Mike Pavone <pavone@retrodev.com>
parents: 43
diff changeset
498 choicesRight <- (allOfSize: numRight inFold?: infold? withOps: ops needOps: 0)
f864792a1b17 Improve prefiltering in program generator. Make solver use similar logic to driver when run standalone.
Mike Pavone <pavone@retrodev.com>
parents: 43
diff changeset
499 choicesMid <- (allOfSize: numMid inFold?: infold? withOps: ops needOps: 0)
f864792a1b17 Improve prefiltering in program generator. Make solver use similar logic to driver when run standalone.
Mike Pavone <pavone@retrodev.com>
parents: 43
diff changeset
500 foreach: (allOfSize: numLeft inFold?: infold? withOps: ops needOps: 0) :idx leftExp {
f864792a1b17 Improve prefiltering in program generator. Make solver use similar logic to driver when run standalone.
Mike Pavone <pavone@retrodev.com>
parents: 43
diff changeset
501 foreach: choicesMid :idx midExp {
f864792a1b17 Improve prefiltering in program generator. Make solver use similar logic to driver when run standalone.
Mike Pavone <pavone@retrodev.com>
parents: 43
diff changeset
502 foreach: choicesRight :idx rightExp {
f864792a1b17 Improve prefiltering in program generator. Make solver use similar logic to driver when run standalone.
Mike Pavone <pavone@retrodev.com>
parents: 43
diff changeset
503 newop <- (if0: leftExp then: midExp else: rightExp)
f864792a1b17 Improve prefiltering in program generator. Make solver use similar logic to driver when run standalone.
Mike Pavone <pavone@retrodev.com>
parents: 43
diff changeset
504 if: needed = 0 || (((newop operators) and needed) xor needed) = 0 {
f864792a1b17 Improve prefiltering in program generator. Make solver use similar logic to driver when run standalone.
Mike Pavone <pavone@retrodev.com>
parents: 43
diff changeset
505 res append: newop
43
96b2fcb746bf Add support for generating programs with only a certain set of operators to allow work with slightly larger problem sizes
Mike Pavone <pavone@retrodev.com>
parents: 33
diff changeset
506 }
96b2fcb746bf Add support for generating programs with only a certain set of operators to allow work with slightly larger problem sizes
Mike Pavone <pavone@retrodev.com>
parents: 33
diff changeset
507 }
96b2fcb746bf Add support for generating programs with only a certain set of operators to allow work with slightly larger problem sizes
Mike Pavone <pavone@retrodev.com>
parents: 33
diff changeset
508 }
96b2fcb746bf Add support for generating programs with only a certain set of operators to allow work with slightly larger problem sizes
Mike Pavone <pavone@retrodev.com>
parents: 33
diff changeset
509 }
56
f864792a1b17 Improve prefiltering in program generator. Make solver use similar logic to driver when run standalone.
Mike Pavone <pavone@retrodev.com>
parents: 43
diff changeset
510 numMid <- numMid + 1
43
96b2fcb746bf Add support for generating programs with only a certain set of operators to allow work with slightly larger problem sizes
Mike Pavone <pavone@retrodev.com>
parents: 33
diff changeset
511 }
56
f864792a1b17 Improve prefiltering in program generator. Make solver use similar logic to driver when run standalone.
Mike Pavone <pavone@retrodev.com>
parents: 43
diff changeset
512 numLeft <- numLeft + 1
43
96b2fcb746bf Add support for generating programs with only a certain set of operators to allow work with slightly larger problem sizes
Mike Pavone <pavone@retrodev.com>
parents: 33
diff changeset
513 }
56
f864792a1b17 Improve prefiltering in program generator. Make solver use similar logic to driver when run standalone.
Mike Pavone <pavone@retrodev.com>
parents: 43
diff changeset
514 }
f864792a1b17 Improve prefiltering in program generator. Make solver use similar logic to driver when run standalone.
Mike Pavone <pavone@retrodev.com>
parents: 43
diff changeset
515 }
f864792a1b17 Improve prefiltering in program generator. Make solver use similar logic to driver when run standalone.
Mike Pavone <pavone@retrodev.com>
parents: 43
diff changeset
516 if: infold? = 0 && (origops and (_opFold or _opTfold)) > 0 {
f864792a1b17 Improve prefiltering in program generator. Make solver use similar logic to driver when run standalone.
Mike Pavone <pavone@retrodev.com>
parents: 43
diff changeset
517 numSeq <- 1
f864792a1b17 Improve prefiltering in program generator. Make solver use similar logic to driver when run standalone.
Mike Pavone <pavone@retrodev.com>
parents: 43
diff changeset
518 limitSeq <- n - 3
f864792a1b17 Improve prefiltering in program generator. Make solver use similar logic to driver when run standalone.
Mike Pavone <pavone@retrodev.com>
parents: 43
diff changeset
519 oldlen <- res length
f864792a1b17 Improve prefiltering in program generator. Make solver use similar logic to driver when run standalone.
Mike Pavone <pavone@retrodev.com>
parents: 43
diff changeset
520 while: { numSeq < limitSeq } do: {
f864792a1b17 Improve prefiltering in program generator. Make solver use similar logic to driver when run standalone.
Mike Pavone <pavone@retrodev.com>
parents: 43
diff changeset
521 numFun <- 1
f864792a1b17 Improve prefiltering in program generator. Make solver use similar logic to driver when run standalone.
Mike Pavone <pavone@retrodev.com>
parents: 43
diff changeset
522 limitFun <- n - (2 + numSeq)
f864792a1b17 Improve prefiltering in program generator. Make solver use similar logic to driver when run standalone.
Mike Pavone <pavone@retrodev.com>
parents: 43
diff changeset
523 while: { numFun < limitFun } do: {
f864792a1b17 Improve prefiltering in program generator. Make solver use similar logic to driver when run standalone.
Mike Pavone <pavone@retrodev.com>
parents: 43
diff changeset
524 numStart <- n - (2 + numSeq + numFun)
f864792a1b17 Improve prefiltering in program generator. Make solver use similar logic to driver when run standalone.
Mike Pavone <pavone@retrodev.com>
parents: 43
diff changeset
525 choicesStart <- false
f864792a1b17 Improve prefiltering in program generator. Make solver use similar logic to driver when run standalone.
Mike Pavone <pavone@retrodev.com>
parents: 43
diff changeset
526 choicesToFold <- false
f864792a1b17 Improve prefiltering in program generator. Make solver use similar logic to driver when run standalone.
Mike Pavone <pavone@retrodev.com>
parents: 43
diff changeset
527 choicesFun <- false
f864792a1b17 Improve prefiltering in program generator. Make solver use similar logic to driver when run standalone.
Mike Pavone <pavone@retrodev.com>
parents: 43
diff changeset
528 if: (origops and _opTfold) > 0 {
f864792a1b17 Improve prefiltering in program generator. Make solver use similar logic to driver when run standalone.
Mike Pavone <pavone@retrodev.com>
parents: 43
diff changeset
529 choicesStart <- #[zero]
f864792a1b17 Improve prefiltering in program generator. Make solver use similar logic to driver when run standalone.
Mike Pavone <pavone@retrodev.com>
parents: 43
diff changeset
530 choicesToFold <- #[input]
f864792a1b17 Improve prefiltering in program generator. Make solver use similar logic to driver when run standalone.
Mike Pavone <pavone@retrodev.com>
parents: 43
diff changeset
531 choicesFun <- (allOfSize: numFun inFold?: 2 withOps: ops needOps: (needed and _maskRemoveFold))
f864792a1b17 Improve prefiltering in program generator. Make solver use similar logic to driver when run standalone.
Mike Pavone <pavone@retrodev.com>
parents: 43
diff changeset
532 } else: {
f864792a1b17 Improve prefiltering in program generator. Make solver use similar logic to driver when run standalone.
Mike Pavone <pavone@retrodev.com>
parents: 43
diff changeset
533 choicesStart <- (allOfSize: numStart inFold?: 1 withOps: ops needOps: 0)
f864792a1b17 Improve prefiltering in program generator. Make solver use similar logic to driver when run standalone.
Mike Pavone <pavone@retrodev.com>
parents: 43
diff changeset
534 choicesToFold <- (allOfSize: numSeq inFold?: 1 withOps: ops needOps: 0)
f864792a1b17 Improve prefiltering in program generator. Make solver use similar logic to driver when run standalone.
Mike Pavone <pavone@retrodev.com>
parents: 43
diff changeset
535 choicesFun <- (allOfSize: numFun inFold?: 2 withOps: ops needOps: 0)
f864792a1b17 Improve prefiltering in program generator. Make solver use similar logic to driver when run standalone.
Mike Pavone <pavone@retrodev.com>
parents: 43
diff changeset
536 }
f864792a1b17 Improve prefiltering in program generator. Make solver use similar logic to driver when run standalone.
Mike Pavone <pavone@retrodev.com>
parents: 43
diff changeset
537 foreach: choicesToFold :idx seqExp {
f864792a1b17 Improve prefiltering in program generator. Make solver use similar logic to driver when run standalone.
Mike Pavone <pavone@retrodev.com>
parents: 43
diff changeset
538 foreach: choicesFun :idx funExp {
f864792a1b17 Improve prefiltering in program generator. Make solver use similar logic to driver when run standalone.
Mike Pavone <pavone@retrodev.com>
parents: 43
diff changeset
539 foreach: choicesStart :idx startExp {
f864792a1b17 Improve prefiltering in program generator. Make solver use similar logic to driver when run standalone.
Mike Pavone <pavone@retrodev.com>
parents: 43
diff changeset
540 if: (origops and _opFold) > 0 {
f864792a1b17 Improve prefiltering in program generator. Make solver use similar logic to driver when run standalone.
Mike Pavone <pavone@retrodev.com>
parents: 43
diff changeset
541 newop <- fold: seqExp with: funExp startingAt: startExp
f864792a1b17 Improve prefiltering in program generator. Make solver use similar logic to driver when run standalone.
Mike Pavone <pavone@retrodev.com>
parents: 43
diff changeset
542 if: needed = 0 || (((newop operators) and needed) xor needed) = 0 {
f864792a1b17 Improve prefiltering in program generator. Make solver use similar logic to driver when run standalone.
Mike Pavone <pavone@retrodev.com>
parents: 43
diff changeset
543 res append: newop
f864792a1b17 Improve prefiltering in program generator. Make solver use similar logic to driver when run standalone.
Mike Pavone <pavone@retrodev.com>
parents: 43
diff changeset
544 }
f864792a1b17 Improve prefiltering in program generator. Make solver use similar logic to driver when run standalone.
Mike Pavone <pavone@retrodev.com>
parents: 43
diff changeset
545 } else: {
f864792a1b17 Improve prefiltering in program generator. Make solver use similar logic to driver when run standalone.
Mike Pavone <pavone@retrodev.com>
parents: 43
diff changeset
546 mtf <- fold: seqExp with: funExp startingAt: startExp
f864792a1b17 Improve prefiltering in program generator. Make solver use similar logic to driver when run standalone.
Mike Pavone <pavone@retrodev.com>
parents: 43
diff changeset
547 if: (mtf isTfold?) {
f864792a1b17 Improve prefiltering in program generator. Make solver use similar logic to driver when run standalone.
Mike Pavone <pavone@retrodev.com>
parents: 43
diff changeset
548 res append: mtf
43
96b2fcb746bf Add support for generating programs with only a certain set of operators to allow work with slightly larger problem sizes
Mike Pavone <pavone@retrodev.com>
parents: 33
diff changeset
549 }
96b2fcb746bf Add support for generating programs with only a certain set of operators to allow work with slightly larger problem sizes
Mike Pavone <pavone@retrodev.com>
parents: 33
diff changeset
550 }
96b2fcb746bf Add support for generating programs with only a certain set of operators to allow work with slightly larger problem sizes
Mike Pavone <pavone@retrodev.com>
parents: 33
diff changeset
551 }
96b2fcb746bf Add support for generating programs with only a certain set of operators to allow work with slightly larger problem sizes
Mike Pavone <pavone@retrodev.com>
parents: 33
diff changeset
552 }
96b2fcb746bf Add support for generating programs with only a certain set of operators to allow work with slightly larger problem sizes
Mike Pavone <pavone@retrodev.com>
parents: 33
diff changeset
553 }
56
f864792a1b17 Improve prefiltering in program generator. Make solver use similar logic to driver when run standalone.
Mike Pavone <pavone@retrodev.com>
parents: 43
diff changeset
554 numFun <- numFun + 1
43
96b2fcb746bf Add support for generating programs with only a certain set of operators to allow work with slightly larger problem sizes
Mike Pavone <pavone@retrodev.com>
parents: 33
diff changeset
555 }
56
f864792a1b17 Improve prefiltering in program generator. Make solver use similar logic to driver when run standalone.
Mike Pavone <pavone@retrodev.com>
parents: 43
diff changeset
556 numSeq <- numSeq + 1
43
96b2fcb746bf Add support for generating programs with only a certain set of operators to allow work with slightly larger problem sizes
Mike Pavone <pavone@retrodev.com>
parents: 33
diff changeset
557 }
96b2fcb746bf Add support for generating programs with only a certain set of operators to allow work with slightly larger problem sizes
Mike Pavone <pavone@retrodev.com>
parents: 33
diff changeset
558 }
96b2fcb746bf Add support for generating programs with only a certain set of operators to allow work with slightly larger problem sizes
Mike Pavone <pavone@retrodev.com>
parents: 33
diff changeset
559 res
96b2fcb746bf Add support for generating programs with only a certain set of operators to allow work with slightly larger problem sizes
Mike Pavone <pavone@retrodev.com>
parents: 33
diff changeset
560 }
96b2fcb746bf Add support for generating programs with only a certain set of operators to allow work with slightly larger problem sizes
Mike Pavone <pavone@retrodev.com>
parents: 33
diff changeset
561 }
96b2fcb746bf Add support for generating programs with only a certain set of operators to allow work with slightly larger problem sizes
Mike Pavone <pavone@retrodev.com>
parents: 33
diff changeset
562
96b2fcb746bf Add support for generating programs with only a certain set of operators to allow work with slightly larger problem sizes
Mike Pavone <pavone@retrodev.com>
parents: 33
diff changeset
563 allOfSize:withOps <- :size strops {
96b2fcb746bf Add support for generating programs with only a certain set of operators to allow work with slightly larger problem sizes
Mike Pavone <pavone@retrodev.com>
parents: 33
diff changeset
564 ops <- strops fold: 0 with: :acc el {
96b2fcb746bf Add support for generating programs with only a certain set of operators to allow work with slightly larger problem sizes
Mike Pavone <pavone@retrodev.com>
parents: 33
diff changeset
565 acc or (_names get: el withDefault: 0)
96b2fcb746bf Add support for generating programs with only a certain set of operators to allow work with slightly larger problem sizes
Mike Pavone <pavone@retrodev.com>
parents: 33
diff changeset
566 }
56
f864792a1b17 Improve prefiltering in program generator. Make solver use similar logic to driver when run standalone.
Mike Pavone <pavone@retrodev.com>
parents: 43
diff changeset
567 allOfSize: (size - 1) inFold?: 0 withOps: ops needOps: ops
43
96b2fcb746bf Add support for generating programs with only a certain set of operators to allow work with slightly larger problem sizes
Mike Pavone <pavone@retrodev.com>
parents: 33
diff changeset
568 }
96b2fcb746bf Add support for generating programs with only a certain set of operators to allow work with slightly larger problem sizes
Mike Pavone <pavone@retrodev.com>
parents: 33
diff changeset
569
53
0f8adc187d29 allWithMaxSize seems to work, will clean next commit
William Morgan <bill@mrgn.org>
parents: 43
diff changeset
570 allWithMaxSize <- :size {
0f8adc187d29 allWithMaxSize seems to work, will clean next commit
William Morgan <bill@mrgn.org>
parents: 43
diff changeset
571 res <- #[]
0f8adc187d29 allWithMaxSize seems to work, will clean next commit
William Morgan <bill@mrgn.org>
parents: 43
diff changeset
572 n <- 3
0f8adc187d29 allWithMaxSize seems to work, will clean next commit
William Morgan <bill@mrgn.org>
parents: 43
diff changeset
573 while: {n <= size} do: {
0f8adc187d29 allWithMaxSize seems to work, will clean next commit
William Morgan <bill@mrgn.org>
parents: 43
diff changeset
574 foreach: (allOfSize: n) :idx el{
0f8adc187d29 allWithMaxSize seems to work, will clean next commit
William Morgan <bill@mrgn.org>
parents: 43
diff changeset
575 res append: el
0f8adc187d29 allWithMaxSize seems to work, will clean next commit
William Morgan <bill@mrgn.org>
parents: 43
diff changeset
576 }
0f8adc187d29 allWithMaxSize seems to work, will clean next commit
William Morgan <bill@mrgn.org>
parents: 43
diff changeset
577 n <- n + 1
0f8adc187d29 allWithMaxSize seems to work, will clean next commit
William Morgan <bill@mrgn.org>
parents: 43
diff changeset
578 }
0f8adc187d29 allWithMaxSize seems to work, will clean next commit
William Morgan <bill@mrgn.org>
parents: 43
diff changeset
579 res
0f8adc187d29 allWithMaxSize seems to work, will clean next commit
William Morgan <bill@mrgn.org>
parents: 43
diff changeset
580 }
0f8adc187d29 allWithMaxSize seems to work, will clean next commit
William Morgan <bill@mrgn.org>
parents: 43
diff changeset
581
28
6384e577842d Add code for filtering a program set based on the operators used
Mike Pavone <pavone@retrodev.com>
parents: 27
diff changeset
582 filterTrees <- :trees strops {
6384e577842d Add code for filtering a program set based on the operators used
Mike Pavone <pavone@retrodev.com>
parents: 27
diff changeset
583 ops <- strops fold: 0 with: :acc el {
6384e577842d Add code for filtering a program set based on the operators used
Mike Pavone <pavone@retrodev.com>
parents: 27
diff changeset
584 acc or (_names get: el withDefault: 0)
6384e577842d Add code for filtering a program set based on the operators used
Mike Pavone <pavone@retrodev.com>
parents: 27
diff changeset
585 }
56
f864792a1b17 Improve prefiltering in program generator. Make solver use similar logic to driver when run standalone.
Mike Pavone <pavone@retrodev.com>
parents: 43
diff changeset
586 _filterTrees: trees ops
f864792a1b17 Improve prefiltering in program generator. Make solver use similar logic to driver when run standalone.
Mike Pavone <pavone@retrodev.com>
parents: 43
diff changeset
587 }
f864792a1b17 Improve prefiltering in program generator. Make solver use similar logic to driver when run standalone.
Mike Pavone <pavone@retrodev.com>
parents: 43
diff changeset
588 _filterTrees <- :trees ops {
f864792a1b17 Improve prefiltering in program generator. Make solver use similar logic to driver when run standalone.
Mike Pavone <pavone@retrodev.com>
parents: 43
diff changeset
589 filtered <- #[]
28
6384e577842d Add code for filtering a program set based on the operators used
Mike Pavone <pavone@retrodev.com>
parents: 27
diff changeset
590 if: (ops and _opTfold) > 0 {
6384e577842d Add code for filtering a program set based on the operators used
Mike Pavone <pavone@retrodev.com>
parents: 27
diff changeset
591 foreach: trees :idx tree {
6384e577842d Add code for filtering a program set based on the operators used
Mike Pavone <pavone@retrodev.com>
parents: 27
diff changeset
592 if: (tree isTfold?) {
6384e577842d Add code for filtering a program set based on the operators used
Mike Pavone <pavone@retrodev.com>
parents: 27
diff changeset
593 if: (tree operators) and _maskRemoveFold = ops and _maskRemoveFold {
6384e577842d Add code for filtering a program set based on the operators used
Mike Pavone <pavone@retrodev.com>
parents: 27
diff changeset
594 filtered append: tree
9
0ccebdbc3e80 Add support for generating programs that contain fold. Make the desired program size a command line argument.
Mike Pavone <pavone@retrodev.com>
parents: 8
diff changeset
595 }
0ccebdbc3e80 Add support for generating programs that contain fold. Make the desired program size a command line argument.
Mike Pavone <pavone@retrodev.com>
parents: 8
diff changeset
596 }
8
3f0172ceab81 Add support for generating programs with if0, thus allowing us to generate all programs up to size 5.
Mike Pavone <pavone@retrodev.com>
parents: 7
diff changeset
597 }
28
6384e577842d Add code for filtering a program set based on the operators used
Mike Pavone <pavone@retrodev.com>
parents: 27
diff changeset
598 } else: {
6384e577842d Add code for filtering a program set based on the operators used
Mike Pavone <pavone@retrodev.com>
parents: 27
diff changeset
599 foreach: trees :idx tree {
6384e577842d Add code for filtering a program set based on the operators used
Mike Pavone <pavone@retrodev.com>
parents: 27
diff changeset
600 if: (tree operators) = ops {
6384e577842d Add code for filtering a program set based on the operators used
Mike Pavone <pavone@retrodev.com>
parents: 27
diff changeset
601 filtered append: tree
6384e577842d Add code for filtering a program set based on the operators used
Mike Pavone <pavone@retrodev.com>
parents: 27
diff changeset
602 }
6384e577842d Add code for filtering a program set based on the operators used
Mike Pavone <pavone@retrodev.com>
parents: 27
diff changeset
603 }
7
301f16245955 Add support for generating all programs up to size 3 inclusive
Mike Pavone <pavone@retrodev.com>
parents: 5
diff changeset
604 }
28
6384e577842d Add code for filtering a program set based on the operators used
Mike Pavone <pavone@retrodev.com>
parents: 27
diff changeset
605 filtered
7
301f16245955 Add support for generating all programs up to size 3 inclusive
Mike Pavone <pavone@retrodev.com>
parents: 5
diff changeset
606 }
301f16245955 Add support for generating all programs up to size 3 inclusive
Mike Pavone <pavone@retrodev.com>
parents: 5
diff changeset
607 }
28
6384e577842d Add code for filtering a program set based on the operators used
Mike Pavone <pavone@retrodev.com>
parents: 27
diff changeset
608 }
7
301f16245955 Add support for generating all programs up to size 3 inclusive
Mike Pavone <pavone@retrodev.com>
parents: 5
diff changeset
609
28
6384e577842d Add code for filtering a program set based on the operators used
Mike Pavone <pavone@retrodev.com>
parents: 27
diff changeset
610 test <- :prog {
6384e577842d Add code for filtering a program set based on the operators used
Mike Pavone <pavone@retrodev.com>
parents: 27
diff changeset
611 print: (string: prog) . "\n"
6384e577842d Add code for filtering a program set based on the operators used
Mike Pavone <pavone@retrodev.com>
parents: 27
diff changeset
612 print: "Operators: " . (hex: ((prog root) operators)) . "\n"
6384e577842d Add code for filtering a program set based on the operators used
Mike Pavone <pavone@retrodev.com>
parents: 27
diff changeset
613 if: ((prog root) isTfold?) {
6384e577842d Add code for filtering a program set based on the operators used
Mike Pavone <pavone@retrodev.com>
parents: 27
diff changeset
614 print: "TFold!\n"
6384e577842d Add code for filtering a program set based on the operators used
Mike Pavone <pavone@retrodev.com>
parents: 27
diff changeset
615 }
6384e577842d Add code for filtering a program set based on the operators used
Mike Pavone <pavone@retrodev.com>
parents: 27
diff changeset
616 //parser doesn''t currently like vertical whitespace in arays so
6384e577842d Add code for filtering a program set based on the operators used
Mike Pavone <pavone@retrodev.com>
parents: 27
diff changeset
617 //this needs to be on a single line until that bug is fixed
43
96b2fcb746bf Add support for generating programs with only a certain set of operators to allow work with slightly larger problem sizes
Mike Pavone <pavone@retrodev.com>
parents: 33
diff changeset
618 vals <- #[0u64 1u64 2u64 3u64 0x30001u64 0x50015u64 (lshift: 0x11223344u64 by: 32u64) or 0x55667788u64]
28
6384e577842d Add code for filtering a program set based on the operators used
Mike Pavone <pavone@retrodev.com>
parents: 27
diff changeset
619 foreach: vals :idx val {
6384e577842d Add code for filtering a program set based on the operators used
Mike Pavone <pavone@retrodev.com>
parents: 27
diff changeset
620 print: "p(0x" . (hex: val) . ") = 0x" . (hex: (prog run: val)) . "\n"
7
301f16245955 Add support for generating all programs up to size 3 inclusive
Mike Pavone <pavone@retrodev.com>
parents: 5
diff changeset
621 }
3
dfc5f00c94bc Initial evaluator implementation. fold is currently missing but other ops are present and seem to work
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
622 }
28
6384e577842d Add code for filtering a program set based on the operators used
Mike Pavone <pavone@retrodev.com>
parents: 27
diff changeset
623
54
42930b0904b1 clean out test
William Morgan <bill@mrgn.org>
parents: 53
diff changeset
624 main <- :args {
28
6384e577842d Add code for filtering a program set based on the operators used
Mike Pavone <pavone@retrodev.com>
parents: 27
diff changeset
625 //test: (program gentestprog)
6384e577842d Add code for filtering a program set based on the operators used
Mike Pavone <pavone@retrodev.com>
parents: 27
diff changeset
626 //test: (program exampleprog)
6384e577842d Add code for filtering a program set based on the operators used
Mike Pavone <pavone@retrodev.com>
parents: 27
diff changeset
627 size <- 3
6384e577842d Add code for filtering a program set based on the operators used
Mike Pavone <pavone@retrodev.com>
parents: 27
diff changeset
628 if: (args length) > 1 {
6384e577842d Add code for filtering a program set based on the operators used
Mike Pavone <pavone@retrodev.com>
parents: 27
diff changeset
629 size <- int32: (args get: 1)
6384e577842d Add code for filtering a program set based on the operators used
Mike Pavone <pavone@retrodev.com>
parents: 27
diff changeset
630 }
6384e577842d Add code for filtering a program set based on the operators used
Mike Pavone <pavone@retrodev.com>
parents: 27
diff changeset
631 if: size >= 2 {
6384e577842d Add code for filtering a program set based on the operators used
Mike Pavone <pavone@retrodev.com>
parents: 27
diff changeset
632 prog <- program
43
96b2fcb746bf Add support for generating programs with only a certain set of operators to allow work with slightly larger problem sizes
Mike Pavone <pavone@retrodev.com>
parents: 33
diff changeset
633 ops <- #[]
28
6384e577842d Add code for filtering a program set based on the operators used
Mike Pavone <pavone@retrodev.com>
parents: 27
diff changeset
634 if: (args length) > 2 {
6384e577842d Add code for filtering a program set based on the operators used
Mike Pavone <pavone@retrodev.com>
parents: 27
diff changeset
635 ops <- (args get: 2) splitOn: ","
43
96b2fcb746bf Add support for generating programs with only a certain set of operators to allow work with slightly larger problem sizes
Mike Pavone <pavone@retrodev.com>
parents: 33
diff changeset
636 }
96b2fcb746bf Add support for generating programs with only a certain set of operators to allow work with slightly larger problem sizes
Mike Pavone <pavone@retrodev.com>
parents: 33
diff changeset
637 trees <- #[]
96b2fcb746bf Add support for generating programs with only a certain set of operators to allow work with slightly larger problem sizes
Mike Pavone <pavone@retrodev.com>
parents: 33
diff changeset
638 if: (ops length) > 0 {
96b2fcb746bf Add support for generating programs with only a certain set of operators to allow work with slightly larger problem sizes
Mike Pavone <pavone@retrodev.com>
parents: 33
diff changeset
639 if: size < 9 {
96b2fcb746bf Add support for generating programs with only a certain set of operators to allow work with slightly larger problem sizes
Mike Pavone <pavone@retrodev.com>
parents: 33
diff changeset
640 trees <- (prog allOfSize: size)
96b2fcb746bf Add support for generating programs with only a certain set of operators to allow work with slightly larger problem sizes
Mike Pavone <pavone@retrodev.com>
parents: 33
diff changeset
641 trees <- prog filterTrees: trees ops
96b2fcb746bf Add support for generating programs with only a certain set of operators to allow work with slightly larger problem sizes
Mike Pavone <pavone@retrodev.com>
parents: 33
diff changeset
642 } else: {
96b2fcb746bf Add support for generating programs with only a certain set of operators to allow work with slightly larger problem sizes
Mike Pavone <pavone@retrodev.com>
parents: 33
diff changeset
643 trees <- (prog allOfSize: size withOps: ops)
96b2fcb746bf Add support for generating programs with only a certain set of operators to allow work with slightly larger problem sizes
Mike Pavone <pavone@retrodev.com>
parents: 33
diff changeset
644 }
96b2fcb746bf Add support for generating programs with only a certain set of operators to allow work with slightly larger problem sizes
Mike Pavone <pavone@retrodev.com>
parents: 33
diff changeset
645 } else: {
96b2fcb746bf Add support for generating programs with only a certain set of operators to allow work with slightly larger problem sizes
Mike Pavone <pavone@retrodev.com>
parents: 33
diff changeset
646 trees <- (prog allOfSize: size)
28
6384e577842d Add code for filtering a program set based on the operators used
Mike Pavone <pavone@retrodev.com>
parents: 27
diff changeset
647 }
6384e577842d Add code for filtering a program set based on the operators used
Mike Pavone <pavone@retrodev.com>
parents: 27
diff changeset
648 foreach: trees :idx tree {
53
0f8adc187d29 allWithMaxSize seems to work, will clean next commit
William Morgan <bill@mrgn.org>
parents: 43
diff changeset
649 prog root!: tree
28
6384e577842d Add code for filtering a program set based on the operators used
Mike Pavone <pavone@retrodev.com>
parents: 27
diff changeset
650 test: prog
6384e577842d Add code for filtering a program set based on the operators used
Mike Pavone <pavone@retrodev.com>
parents: 27
diff changeset
651 }
6384e577842d Add code for filtering a program set based on the operators used
Mike Pavone <pavone@retrodev.com>
parents: 27
diff changeset
652 }
6384e577842d Add code for filtering a program set based on the operators used
Mike Pavone <pavone@retrodev.com>
parents: 27
diff changeset
653 0
6384e577842d Add code for filtering a program set based on the operators used
Mike Pavone <pavone@retrodev.com>
parents: 27
diff changeset
654 }
3
dfc5f00c94bc Initial evaluator implementation. fold is currently missing but other ops are present and seem to work
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
655 }
dfc5f00c94bc Initial evaluator implementation. fold is currently missing but other ops are present and seem to work
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
656 }
53
0f8adc187d29 allWithMaxSize seems to work, will clean next commit
William Morgan <bill@mrgn.org>
parents: 43
diff changeset
657