From 4c44cc1002bd920f5bfd7d87f57bb1ff5d29a442 Mon Sep 17 00:00:00 2001
From: Richard Feistenauer <richard.feistenauer@gmx.de>
Date: Fri, 15 Feb 2019 20:02:57 +0100
Subject: [PATCH] removed coordinate string from cells dict

---
 scripts/performance_test                     | Bin 3861 -> 3861 bytes
 src/cellular_automaton/ca_cell.py            |  15 +++++++--------
 src/cellular_automaton/ca_display.py         |   8 ++++----
 src/cellular_automaton/ca_factory.py         |  15 +++++----------
 src/cellular_automaton/cellular_automaton.py |  18 +++++++++---------
 test/test_cell.py                            |   6 +++---
 test/test_factory.py                         |  13 +++++++------
 7 files changed, 35 insertions(+), 40 deletions(-)

diff --git a/scripts/performance_test b/scripts/performance_test
index beb96144bae1485f75148feb175c524f84f597e9..693a4512387b7da97b90b31ef17ff3a1fe4922ce 100644
GIT binary patch
delta 1314
zcmZvcYe*DP6vv%?%<jzYI%BM>l`b>8J$xj-BU_rGm#-i~LxMsqvYQb;rdY}c(kH{9
z+)itexs_sNpyrZ@uMcHGRP;hCGAb%j>q}v^X++JmyQMRIIrHat&pG#=d*&Xu)opDk
zrAiaaKa@9w^T;n;HLL=4ET;|4`O~@8vmDB+@6wuTf4SbX3I^fWQuA<^@6FM};~XkH
z8^Iq-{m4}bdg#_!$bSe*u{hfAH_9Q6`}|Ww%S*U|F)j~I&LPjSgtT&RsyqAUdk)!$
z?0d4tKa1%?LqbAgHG)R`{4q%G0~xAi=CC#$U0?8=Lw+$S1;S>`QaA@C#i|8NOjDv4
ztw2b5wR7@zxVEN8)tPv-_#V?&FgwVLrO5Y|`@n>Xq54~=(&N0}Ipmx5w#HY2MeS6u
zCiN2NBysY7@CNR~L$wWF%}1Dqp$6M5Kl@@Lc~rUk?!go_BxzU$E7G{BWjAWR?0NEu
zL$)TnYTHK8Xyez(*bpz393d7lwNf-M@M34#erNH#sxz!RvPRD)^C&a_`dID;sL-;M
zoLv;zHFxK*<Dij8F~0rywG?>#ABN#ERKG1h@9j77_(vNP+0J%Yg|iB_7mvfu?K?f~
z>*35lc?W0dMcv^8lhI!}6u48E!5Jlt)iJ5)($Wu8vpx=u;3amiW=QOoP2Me;4^->e
z)ZH!jw%;|)a45#+wLQ>DajZN}<^zv(EbXhxsXLIK!lNTwDhslotpQBWC}Famp@J^~
zy@nc3awZh%9bqyy#6toR3AglVFl<-=6{<*>F)RcJ!G-O+T6>6?Y~)Z-Ks}K|3#X3v
zTfYqQC?Mb+A<#WdY1WO?A`A#9CP(P#p0XUhVT3~g0XYUn2@e}`A&Lm2ssc|!AjLZn
z3}7S@VSzE-yz7GJ)aug&kAgyaP7g>6R2ZWvcHo<*w^YR=zkp^V53fRTax6Fn#-PDu
zru{X~fwYOC%95MALv-T!S@EO2@W3YEO>1dq|3r7)xwjk&h(FN^c-`bk^VcMfhoGnu
pmiU_&FP&d9f0u#+?4bj6@A(s#$=hPr147#3qzRY)gWyt9(r<<i@nHY}

delta 1329
zcmZvcc}Ns-6vrKRo!!~PnKh4!l$q_Y?Q+u%D&zOVjA$eJqo4!ABw2qMl{(dySXt7A
z6{)Z7vXFu@x{E?mmh$MZpo_{5h{7W)iZHvdsNcAwTRYAlZ@zry9lyu>z40aZ5=vL{
z4d=hV-cb;PNkEiskRXF$xga>3C@ecww2td|ib&q26yJ>c*0NSf!ytwk?y?;>2qp76
z5Lr;3WuLY1BPx`QVPRnoy{xCN9z#NXU?nq3==CS->nrZv^nQkujHrdrn6a+FS=td1
zuQoL&{^+D7B121r`oN^{5k>J=a@|JrV?^T4){bd%w)YpP@o_qIGDFkn7^#&xrBK8_
zy<G5}Ye-#f!Q@Q#=5G6BKklbr)raeIg16x!@2^U4bXR^yWLDwiL+M!%tMh7Dg>IOT
zaVQS&O!<I_D&W4(u7!+V<VVzP=*oU1VA4FbHNOLcQ!i;)rryUlRiFNSYwj1C@zbg+
zWyPS67(F$F`LWV>9PRd<i<%d#$D6y{>-n$smLX`xns4JVIX0kc-J;EqA0hFf>?mc|
zPam0+vx~)K>yvG|>|A)*4`bMo@G6q!24OPCvn9Ry7ffU&zPfTxmFY&1EoDcsIgWRG
z>&C!=puEjWLf@4Ng#3h`tf++!gP3x0|I3oQ@4FEx{d_o~Doq)fT^Z`X7c|5N)*Gbg
zz;b*=B%<Jnp<<d6C&6qcmg__Cz#s{42HQ@w6(wV`@BG%h>9GhHqo{@BjUxZx+Ty{6
zadn8q4=uJ`E{05Fsx5^1F^uH~LZi_I4d$qDITBjTNs!7R8$EH)LwW_2aBjh~)?Xv1
z_%Trhv~aR;a${D)!DI?m0Upz1!CUk8;`YOj5K#rV&7u|-m}kNe&c+w2J0P2AIoS*r
zE(xM66QV7Zn`&Nk(tF)2=qAEFQ!M0L;`zH*pEb_E6OKthz!3{pMr?YHNMK0Mq0|~J
zs5%G*tH|4@>@NP}h{9y~%_U`MJ78;?5EwukQh!rzN;LgZaR&7RT(+jVLY?S}52I(M
j(;clGT`|4!!9+tNYt@CK*CMcG-AeXyD{BoB<aGW8=MM}z

diff --git a/src/cellular_automaton/ca_cell.py b/src/cellular_automaton/ca_cell.py
index d463527..a28cfd3 100644
--- a/src/cellular_automaton/ca_cell.py
+++ b/src/cellular_automaton/ca_cell.py
@@ -3,22 +3,21 @@ from typing import Type
 
 
 class Cell:
-    def __init__(self, state_class: Type[CellState], coordinate):
-        self.coordinate = coordinate
+    def __init__(self, state_class: Type[CellState]):
         self.state = state_class()
         self.neighbours = []
 
     @staticmethod
     def evolve_if_ready(cell, rule, iteration):
-        if cell[0].is_active(iteration):
-            new_state = rule(cell[0].get_state_of_last_iteration(iteration),
-                             [n.get_state_of_last_iteration(iteration) for n in cell[1]])
+        if cell.state.is_active(iteration):
+            new_state = rule(cell.state.get_state_of_last_iteration(iteration),
+                             [n.get_state_of_last_iteration(iteration) for n in cell.neighbours])
             Cell.set_new_state_and_activate(cell, new_state, iteration)
 
     @staticmethod
     def set_new_state_and_activate(cell, new_state: CellState, iteration):
-        changed = cell[0].set_state_of_iteration(new_state, iteration)
+        changed = cell.state.set_state_of_iteration(new_state, iteration)
         if changed:
-            cell[0].set_active_for_next_iteration(iteration)
-            for n in cell[1]:
+            cell.state.set_active_for_next_iteration(iteration)
+            for n in cell.neighbours:
                 n.set_active_for_next_iteration(iteration)
diff --git a/src/cellular_automaton/ca_display.py b/src/cellular_automaton/ca_display.py
index ecd8b21..e832890 100644
--- a/src/cellular_automaton/ca_display.py
+++ b/src/cellular_automaton/ca_display.py
@@ -29,10 +29,10 @@ class DisplayFor2D:
         pygame.display.update(update_rects)
 
     def _cell_redraw_rectangles(self):
-        for cell in self._cellular_automaton.cells:
+        for coordinate, cell in self._cellular_automaton.cells.items():
             if cell.state.is_set_for_redraw():
                 cell_color = cell.state.get_state_draw_color(self._cellular_automaton.evolution_iteration_index)
-                cell_pos = _calculate_cell_position(self._display_info.cell_size, cell)
+                cell_pos = _calculate_cell_position(self._display_info.cell_size, coordinate)
                 surface_pos = list(map(operator.add, cell_pos, self._display_info.grid_pos))
                 yield self._display_info.screen.fill(cell_color, (surface_pos, self._display_info.cell_size))
                 cell.state.was_redrawn()
@@ -97,5 +97,5 @@ class PyGameFor2D:
         print("SIZE: " + "{0:.4f}".format(size / (1024 * 1024)) + "MB")
 
 
-def _calculate_cell_position(cell_size, cell):
-    return list(map(operator.mul, cell_size, cell.coordinate))
+def _calculate_cell_position(cell_size, coordinate):
+    return list(map(operator.mul, cell_size, coordinate))
diff --git a/src/cellular_automaton/ca_factory.py b/src/cellular_automaton/ca_factory.py
index e8a65a1..bd811ed 100644
--- a/src/cellular_automaton/ca_factory.py
+++ b/src/cellular_automaton/ca_factory.py
@@ -12,23 +12,18 @@ class CAFactory:
 
         cells = CAFactory._make_cells(dimension, state_class)
         CAFactory._apply_neighbourhood_to_cells(cells, neighborhood, dimension)
-        return tuple(cells.values())
+        return cells
 
     @staticmethod
     def _make_cells(dimension, state_class):
         cells = {}
         for c in itertools.product(*[range(d) for d in dimension]):
-            coordinate_string = _join_coordinate(c)
-            cells[coordinate_string] = Cell(state_class, c)
+            cells[tuple(c)] = Cell(state_class)
         return cells
 
     @staticmethod
     def _apply_neighbourhood_to_cells(cells, neighborhood, dimension):
-        for cell in cells.values():
-            n_coordinates = neighborhood.calculate_cell_neighbor_coordinates(cell.coordinate, dimension)
-            cell.neighbours = [cells[_join_coordinate(coordinate)].state for coordinate in n_coordinates]
-
-
-def _join_coordinate(coordinate):
-    return '-'.join(str(x) for x in coordinate)
+        for coordinate, cell in cells.items():
+            n_coordinates = neighborhood.calculate_cell_neighbor_coordinates(coordinate, dimension)
+            cell.neighbours = [cells[tuple(nc)].state for nc in n_coordinates]
 
diff --git a/src/cellular_automaton/cellular_automaton.py b/src/cellular_automaton/cellular_automaton.py
index 39c7061..d745eaa 100644
--- a/src/cellular_automaton/cellular_automaton.py
+++ b/src/cellular_automaton/cellular_automaton.py
@@ -25,7 +25,7 @@ class CellularAutomatonProcessor:
         self._ca.evolution_iteration_index += 1
         i = self._ca.evolution_iteration_index
         r = self._ca.evolution_rule.evolve_cell
-        list(map(lambda c: Cell.evolve_if_ready((c.state, c.neighbours), r, i), self._ca.cells))
+        list(map(lambda c: Cell.evolve_if_ready((c.state, c.neighbours), r, i), tuple(self._ca.cells.items())))
         # print(sum(1 for c in self._ca.cells if c.state.is_set_for_redraw()))
 
 
@@ -33,25 +33,25 @@ class CellularAutomatonMultiProcessor(CellularAutomatonProcessor):
     def __init__(self, cellular_automaton, process_count: int = 2):
         if process_count < 1:
             raise ValueError
+
         super().__init__(cellular_automaton)
-        self.ca = cellular_automaton
-        cells = {i: (c.state, c.neighbours) for i, c in enumerate(self.ca.cells)}
-        self.evolve_range = range(len(self.ca.cells))
+
+        self.evolve_range = range(len(self._ca.cells))
         self.evolution_iteration_index = multiprocessing.RawValue(c_int, -1)
 
         self.pool = multiprocessing.Pool(processes=process_count,
                                          initializer=_init_process,
-                                         initargs=(cells,
-                                                   self.ca.evolution_rule,
+                                         initargs=(tuple(self._ca.cells.values()),
+                                                   self._ca.evolution_rule,
                                                    self.evolution_iteration_index))
         self._evolve_method = self.pool.map
 
-        for cell in self.ca.cells:
+        for cell in self._ca.cells.values():
             del cell.neighbours
 
     def evolve(self):
-        self.ca.evolution_iteration_index += 1
-        self.evolution_iteration_index.value = self.ca.evolution_iteration_index
+        self._ca.evolution_iteration_index += 1
+        self.evolution_iteration_index.value = self._ca.evolution_iteration_index
         self.pool.map(_process_routine, self.evolve_range)
 
 
diff --git a/test/test_cell.py b/test/test_cell.py
index f10bf40..ee946cb 100644
--- a/test/test_cell.py
+++ b/test/test_cell.py
@@ -12,14 +12,14 @@ class TestState(CellState):
 
 class TestCellState(unittest.TestCase):
     def setUp(self):
-        self.cell = [TestState(), []]
+        self.cell = Cell(TestState)
         self.neighbours = [TestState() for x in range(5)]
         for neighbour in self.neighbours:
             neighbour.set_state_of_iteration((0, ), 0)
-        self.cell[1] = self.neighbours
+        self.cell.neighbours = self.neighbours
 
     def cell_and_neighbours_active(self, iteration):
-        self.neighbours.append(self.cell[0])
+        self.neighbours.append(self.cell.state)
         all_active = True
         for state in self.neighbours:
             if not state.is_active(iteration):
diff --git a/test/test_factory.py b/test/test_factory.py
index df5fd8e..231eeca 100644
--- a/test/test_factory.py
+++ b/test/test_factory.py
@@ -28,31 +28,32 @@ class TestCAFactory(unittest.TestCase):
         with mock.patch.object(CAFactory, '_make_cells', return_value={1: True}):
             with mock.patch.object(CAFactory, '_apply_neighbourhood_to_cells'):
                 cells = CAFactory.make_cellular_automaton([10], Neighborhood, CellState)
-                self.assertEqual(cells, (True, ))
+                self.assertEqual(tuple(cells.values()), (True, ))
 
     def test_1dimension_coordinates(self):
         fac = TestFac()
         c = fac.make_cells([3], CellState)
-        self.assertEqual(list(c.keys()), ['0', '1', '2'])
+        self.assertEqual(list(c.keys()), [(0,), (1,), (2,)])
 
     def test_2dimension_coordinates(self):
         fac = TestFac()
         c = fac.make_cells([2, 2], CellState)
-        self.assertEqual(list(c.keys()), ['0-0', '0-1', '1-0', '1-1'])
+        self.assertEqual(list(c.keys()), [(0, 0), (0, 1), (1, 0), (1, 1)])
 
     def test_3dimension_coordinates(self):
         fac = TestFac()
         c = fac.make_cells([2, 2, 2], CellState)
-        self.assertEqual(list(c.keys()), ['0-0-0', '0-0-1', '0-1-0', '0-1-1', '1-0-0', '1-0-1', '1-1-0', '1-1-1'])
+        self.assertEqual(list(c.keys()), [(0, 0, 0), (0, 0, 1), (0, 1, 0), (0, 1, 1),
+                                          (1, 0, 0), (1, 0, 1), (1, 1, 0), (1, 1, 1)])
 
     def test_apply_neighbourhood(self):
         fac = TestFac()
         cells = fac.make_cells([3, 3], CellState)
         fac.apply_neighbourhood(cells, MooreNeighborhood(EdgeRule.IGNORE_EDGE_CELLS), [3, 3])
 
-        neighbours = self.__create_neighbour_list_of_cell('1-1', cells)
+        neighbours = self.__create_neighbour_list_of_cell((1, 1), cells)
 
-        self.assertEqual(set(neighbours), set(cells['1-1'].neighbours))
+        self.assertEqual(set(neighbours), set(cells[(1, 1)].neighbours))
 
     @staticmethod
     def __create_neighbour_list_of_cell(cell_id, cells):