def __init__(self):
super().__init__()
self.ui = Ui_simulationDialog()
self.ui.setupUi(self)
self.sim = Simulator()
self.ui.armyOfLightSpinner.setValue(self.sim.get_light_army_size())
self.ui.armyOfDarknessSpinner.setValue(self.sim.get_dark_army_size())
self.ui.setArmySizeButton.clicked.connect(self.set_army_size)
self.ui.runButton.clicked.connect(self.run_simulation)
self.ui.quitButton.clicked.connect(self.quit_button)
self.show()
def setUp(self) -> None:
self.w = Wheel()
bb = BinBuilder(self.w)
bb.buildBins()
self.t = Table()
self.p = Passenger57(self.t, self.w)
self.g = Game(self.t, self.w)
self.sim = Simulator(self.p, self.g)
class SimulationForm(QDialog):
def __init__(self):
super().__init__()
self.ui = Ui_simulationDialog()
self.ui.setupUi(self)
self.sim = Simulator()
self.ui.armyOfLightSpinner.setValue(self.sim.get_light_army_size())
self.ui.armyOfDarknessSpinner.setValue(self.sim.get_dark_army_size())
self.ui.setArmySizeButton.clicked.connect(self.set_army_size)
self.ui.runButton.clicked.connect(self.run_simulation)
self.ui.quitButton.clicked.connect(self.quit_button)
self.show()
def disp_victor(self, victor):
self.ui.victoryResultsLabel.setText(victor)
def run_simulation(self):
self.sim.run_simulation()
self.ui.armyOfLightSpinner.setValue(self.sim.get_light_army_size())
self.ui.armyOfDarknessSpinner.setValue(self.sim.get_dark_army_size())
self.disp_victor(self.sim.get_victor())
def quit_button(self):
sys.exit(app.exec_())
def set_army_size(self):
self.sim.dark_army.generate_army("Dark",
self.ui.armyOfDarknessSpinner.value())
self.sim.light_army.generate_army("Light",
self.ui.armyOfLightSpinner.value())
if __name__ == '__main__':
ast = [0,1,2,3,4]
atrans = [[0.5,0.5,0,0,0],[0.5,0,0.5,0,0],[0,0.5,0,0.5,0],[0,0,0.5,0,0.5],[0,0,0,0,1]]
aLamda = 1
aReward = [-1,-1,-1,-1,0]
aPro = Problem(ast, atrans, aLamda, aReward)
aDP = DP(aPro)
print('DP result:')
print(aDP.runDP(1000))
print('---------------------------------------------')
aSim = Simulator(aPro, 4)
Historys = aSim.batchSimulate(0, 100)
aEsti = Estimator(aPro, Historys)
print('TD result a=N:')
print(aEsti.TD(Historys))
print('---------------------------------------------')
alpha = 0.05
print('TD result a='+str(alpha))
print(aEsti.TDalpha(Historys,alpha))
print(aEsti.TDalphaLast(Historys, alpha))
print(aEsti.TDalphaNstep(Historys, 0, 200))
print('---------------------------------------------')
import json
num = 1
path = "./astablishment_space/SinglePendulum/astablishment_space" + str(num)
os.chdir(path)
input_space = np.load("input_space.npy")
with open('param.json', 'r') as json_file:
json_data = json.load(json_file)
axes_param_list = [
list(param_dict.values()) for param_dict in json_data["axes"]
]
print(axes_param_list)
axes = [Axis(*param) for param in axes_param_list]
print(axes)
model = SinglePendulum(0, 0, **json_data["model_param"])
t_s = TopologicalSpace(*axes)
t_s.show_concentration_img(axes[0], axes[1], input_space)
simulator = Simulator(t_s, input_space, model)
simulator.model.state = (-simulator.model.state[0] - 0.1,
simulator.model.state[1])
df = simulator.do()
simulator.t_s.show_concentration_img_with_tragectory(simulator.t_s.axes[0],
simulator.t_s.axes[1],
simulator.input_space,
df["theta"],
df["theta_dot"])
def testDefaultMutableList(self):
sim1 = Simulator(self.p, self.g)
sim2 = Simulator(self.p, self.g)
sim1.maximums.append(1)
self.assertEqual(len(sim2.maximums), 0)
from src.Simulator import Simulator
if __name__ == "__main__":
simulator = Simulator('Fuzzy Traffic System')
simulator.start()
class UI:
def __init__(self, initial, final, level, pivot):
self.simulator = Simulator(initial, final, level, pivot)
self.background = Window(*(0, 0), *os.get_terminal_size(),
*os.get_terminal_size(), '01 ')
def render_background_with_form(self, form):
x = self.background.x + (self.background.width - form.width) // 2
y = self.background.y + (self.background.height - form.height) // 2
form.set_x_y(x, y)
for i in range(100000):
self.background.render_window(form)
time.sleep(0.3)
self.background.push_new_line_on_window()
def one_game(self, form):
tick = 0.3
form.set_string('Enter size:', *(1, 1))
time.sleep(tick)
size = form.get_and_set_string_from_input(2, 1)
data = self.simulator.get_data(int(size))
initial = self.simulator.get_initial(data)
form.set_string(initial, *(3, 1))
time.sleep(tick)
form.set_string('Enter string:', *(4 + 2, 1))
time.sleep(tick)
user_input = form.get_and_set_string_from_input(5 + 2, 1)
form.set_string('Result:', *(6 + 2, 1))
time.sleep(tick)
result = self.simulator.validate_input(user_input, data)
if result['status'] == 'SUCCESS':
i = 7
form.set_string('SUCCESS', *(7 + 2, 1))
time.sleep(tick)
else:
for i, message in enumerate(result['messages'], start=7 + 2):
result = ''
if message[0] == 'incompatible':
result = f'#{message[1]}, expected {message[3]} but was {message[2]}'
else:
result = f'Incorrect size'
form.set_string(result, *(i, 1))
time.sleep(tick)
form.set_string('pause', *(i + 1 + 2, 1))
time.sleep(tick)
user_input = form.get_and_set_string_from_input(i + 2 + 2, 1)
form.clean()
def run(self):
width, height = os.get_terminal_size()
form = Form(width // 2, height // 2)
thread = threading.Thread(target=self.render_background_with_form,
args=([form]))
thread.start()
while True:
self.one_game(form)
def __init__(self, initial, final, level, pivot):
self.simulator = Simulator(initial, final, level, pivot)
self.background = Window(*(0, 0), *os.get_terminal_size(),
*os.get_terminal_size(), '01 ')
def test_simulator_turn():
sim = Simulator()
assert sim.turn(sim.dark_army, sim.light_army) is False
def test_simulator_has_armies():
sim = Simulator()
assert len(sim.dark_army.unit) > 0
assert len(sim.light_army.unit) > 0
def test_simulator_run_simulation():
sim = Simulator()
sim.dark_army.generate_army("Dark", 5)
sim.light_army.generate_army("Light", 5)
sim.run_simulation()
assert sim.victory is True