def test_exec_do_times(self):
i = '_exec_do*times'
# 1
before = {
'_integer': [2],
'_exec': [get_instruction('_string_stack_depth')]
}
after = {
'_exec': [[
0, 1,
JustInTimeInstruction('_exec_do*range'),
[
JustInTimeInstruction('_integer_pop'),
get_instruction('_string_stack_depth')
]
]]
}
self.assertTrue(t_u.run_test(before, after, i))
# 2
before = {'_integer': [2], '_exec': [get_instruction('_integer_inc')]}
after = {
'_exec': [[
0, 1,
JustInTimeInstruction('_exec_do*range'),
[
JustInTimeInstruction('_integer_pop'),
get_instruction('_integer_inc')
]
]]
}
self.assertTrue(t_u.run_test(before, after, i))
def test_code_do_count(self):
i = '_code_do*count'
# 1
before = {
'_integer': [2],
'_code': [get_instruction('_string_stack_depth')]
}
after = {
'_exec': [[
0, 1,
JustInTimeInstruction('_code_from_exec'),
get_instruction('_string_stack_depth'),
JustInTimeInstruction('_code_do*range')
]]
}
self.assertTrue(t_u.run_test(before, after, i))
# 2
before = {'_integer': [2], '_code': [get_instruction('_integer_inc')]}
after = {
'_exec': [[
0, 1,
JustInTimeInstruction('_code_from_exec'),
get_instruction('_integer_inc'),
JustInTimeInstruction('_code_do*range')
]]
}
self.assertTrue(t_u.run_test(before, after, i))
def test_exec_do_range(self):
before = {
'_exec': [get_instruction('_integer_inc')],
'_integer': [3, 4]
}
after = {
'_exec': [[
4, 4,
JustInTimeInstruction('_exec_do*range'),
get_instruction('_integer_inc')
],
get_instruction('_integer_inc')],
'_integer': [3]
}
self.assertTrue(t_u.run_test(before, after, '_exec_do*range'))
def test_code_do_range(self):
before = {
'_code': [get_instruction('_integer_inc')],
'_integer': [1, 2, 3]
}
after = {
'_exec': [[
3, 3,
JustInTimeInstruction('_code_from_exec'),
get_instruction('_integer_inc'),
JustInTimeInstruction('_code_do*range')
],
get_instruction('_integer_inc')],
'_integer': [1, 2]
}
self.assertTrue(t_u.run_test(before, after, '_code_do*range'))
def run_test(before, after, instruction, print_test=False):
interpreter = interp.PushInterpreter()
interpreter.state.from_dict(before)
if not isinstance(instruction, Instruction):
instruction = get_instruction(instruction)
if print_test:
print(instruction.name)
print("BEFORE:")
interpreter.state.pretty_print()
if type(after) == dict:
interpreter.eval_atom(instruction)
if print_test:
print("AFTER:")
interpreter.state.pretty_print()
print()
return dict_matches_state(interpreter, after)
else:
try:
interpreter.eval_atom(instruction)
except Exception as e:
if print_test:
print("Raises error: ", type(e))
print()
return isinstance(e, after)
def test_exec_when(self):
i = '_exec_when'
# 1
before = {
'_boolean': [True],
'_exec': [get_instruction('_string_stack_depth')]
}
after = {'_exec': [get_instruction('_string_stack_depth')]}
self.assertTrue(t_u.run_test(before, after, i))
# 2
before = {
'_boolean': [False],
'_exec': [get_instruction('_string_stack_depth')]
}
after = {}
self.assertTrue(t_u.run_test(before, after, i))
# 3
before = {
'_boolean': [True],
'_exec': [get_instruction('_string_empty')]
}
after = {'_exec': [get_instruction('_string_empty')]}
self.assertTrue(t_u.run_test(before, after, i))
# 4
before = {
'_boolean': [False],
'_exec': [get_instruction('_string_empty')]
}
after = {}
self.assertTrue(t_u.run_test(before, after, i))
def test_exec_while(self):
i = '_exec_while'
# 1
before = {
'_integer': [5],
'_boolean': [True],
'_exec': [get_instruction('_integer_inc')]
}
after = {
'_integer': [5],
'_exec': [
get_instruction('_integer_inc'),
JustInTimeInstruction('_exec_while'),
get_instruction('_integer_inc')
]
}
self.assertTrue(t_u.run_test(before, after, i))
# 2
before = {
'_integer': [5],
'_boolean': [False],
'_exec': [get_instruction('_integer_inc')]
}
after = {'_integer': [5]}
self.assertTrue(t_u.run_test(before, after, i))
# 3
before = {
'_boolean': [True],
'_exec': [get_instruction('_string_stack_depth')]
}
after = {
'_exec': [
get_instruction('_string_stack_depth'),
JustInTimeInstruction('_exec_while'),
get_instruction('_string_stack_depth')
]
}
self.assertTrue(t_u.run_test(before, after, i))
# 4
before = {
'_boolean': [False],
'_exec': [get_instruction('_string_stack_depth')]
}
after = {}
self.assertTrue(t_u.run_test(before, after, i))
# Create the push interpreter
interpreter = PushInterpreter()
y_hat = interpreter.run(program, [inpt], ['_string'])[0]
if y_hat is None:
errors.append(1e5)
else:
# compare to target output
target_output = inpt[:-2] + inpt[:-2]
errors.append(
string_difference(y_hat, target_output) +
string_char_counts_difference(y_hat, target_output))
return errors
atom_generators = [
get_instruction("_string_length"),
get_instruction("_string_head"),
get_instruction("_string_concat"),
get_instruction("_string_stack_depth"),
get_instruction("_string_swap"),
get_instruction("_string_dup"),
get_instruction("_integer_add"),
get_instruction("_integer_sub"),
get_instruction("_integer_dup"),
get_instruction("_integer_swap"),
get_instruction("_integer_stack_depth"),
get_instruction("_integer_inc"), lambda: random.randint(0, 10),
lambda: random_str()
]
if __name__ == "__main__":
import numpy as np
from random import choice
import unittest
import pyshgp.gp.variation as v
import pyshgp.gp.population as p
from pyshgp.push.spawn import Spawner
from pyshgp.push.registered_instructions import get_instruction
atom_gens = [
lambda: np.random.random(),
lambda: np.random.randint(10),
lambda: choice('abcdefghijklmnopqrstuvwxyz \n!.'),
get_instruction('_integer_add'),
get_instruction('_float_add'),
get_instruction('_string_from_float'),
get_instruction('_string_from_integer'),
get_instruction('_string_concat'),
]
class TestPerturbCloseMutationMethods(unittest.TestCase):
def setUp(self):
self.R = Spawner(atom_gens)
self.i1 = p.Individual(self.R.random_plush_genome(15))
def test_produce(self):
pim = v.PerturbCloseMutation(rate=0.9)
child = pim.produce([self.i1], self.R)
def test_get_instruction_strd(self):
add_instr = ri.get_instruction('_integer_add')
self.assertIsInstance(add_instr, Instruction)