From b0a8fb05a404dbf143c2d60ab54d30f7c117a019 Mon Sep 17 00:00:00 2001
From: Richard Feistenauer <richard.feistenauer@gmx.de>
Date: Sat, 9 Feb 2019 19:06:18 +0100
Subject: [PATCH] fixed tests and refactored cellstate

---
 performance.txt                              |   5 ++-
 scripts/main_ui.py                           |   2 +-
 scripts/performance_test                     | Bin 3861 -> 3861 bytes
 src/cellular_automaton/ca_cell.py            |  38 +++++++------------
 src/cellular_automaton/ca_cell_state.py      |  21 +++++-----
 src/cellular_automaton/ca_display.py         |   8 ++--
 src/cellular_automaton/ca_factory.py         |   4 +-
 src/cellular_automaton/cellular_automaton.py |   7 ++--
 test/test_cell.py                            |  15 ++++----
 9 files changed, 46 insertions(+), 54 deletions(-)

diff --git a/performance.txt b/performance.txt
index c9fec8b..7726429 100644
--- a/performance.txt
+++ b/performance.txt
@@ -14,4 +14,7 @@ TOTAL TIME: 0.1792s 	# probably wrong calculated (asizeof was in there)
 SIZE: 20.2575MB			# Factory instead of grid
 
 TOTAL TIME: 0.1152s		# dict instead of list for cells
-SIZE: 20.2575MB			# process size 53 / 75,8
\ No newline at end of file
+SIZE: 20.2575MB			# process size 53 / 75,8
+
+TOTAL TIME: 0.1135s		# evolve is static
+SIZE: 20.2575MB			# process size 50.8 / 76 (no more cell objects in processes)
\ No newline at end of file
diff --git a/scripts/main_ui.py b/scripts/main_ui.py
index a01e5cc..8b7f345 100644
--- a/scripts/main_ui.py
+++ b/scripts/main_ui.py
@@ -48,7 +48,7 @@ if __name__ == "__main__":
     freeze_support()
 
     random.seed(1000)
-    # best is 400/400 with 0,2 ca speed and 0,09 redraw
+    # best single is 400/400 with 0,2 ca speed and 0,09 redraw / multi is 300/300 with 0.083
     neighborhood = MooreNeighborhood(EdgeRule.FIRST_AND_LAST_CELL_OF_DIMENSION_ARE_NEIGHBORS)
     ca = make_cellular_automaton(dimension=[100, 100], neighborhood=neighborhood, rule=TestRule(), state_class=MyState)
     ca_window = PyGameFor2D(window_size=[1000, 800], cellular_automaton=ca)
diff --git a/scripts/performance_test b/scripts/performance_test
index 112495e103f620ce1aa9a7d2fc78540540b2e869..6b88c5966074883b6715e97601db6b7bcdfcfdcf 100644
GIT binary patch
literal 3861
zcmbtXZEO@p7{1!?RuHSHUlb0MmeTfUY(#_2UPy^z0-*+okepe!d(-XKz1?GWuOGPt
zj1nQl$PW$1q>08DgqSGBf{6hW60PD#6oaA#epFO?AsS*6jaL(V-`m@{ot?WvVt;Js
z_MUm3XWn_=cjo3=%d?w$*2cEkgxaw_BSmB*Wh$|C$>e&)QDPe{RWV|{)Y7Puuw%WW
z&VXg+|8+gw(e+@=(EDP}03}LXH?>G|H1lI96q>4$W!=;rS#GV&l)(#H0T1o^()xzU
zp=%Nwq>q$S{92!dCoP9jYef!P0^ix{;xpF(I#nyn#B>Nn72m8ir&iFKnMp}o^~>y7
z{qAohrqXx|%&Hhxbcd4>CNP;<l!3L75qB*<6;&y}x_9(@NpolaAf;(d(7%9T#Qz}i
z0+|wnC^nI8Wr%QV*wg<0%XM#^l(d;mW811CrwePS!AR8xl>|If`WKZJ$%?u&rBecm
zwqsFV%w54DN%L6JbYW0Hz%YU9C{QcwwrmZXB+f0vbDs~=Bm_xd7BC*OURbJsdp90<
zHS&4qZ<2N?e7vgc=tQ(g-~|lhEF_wr^O7_8T<xbnK?Ke<m;JRN6or(@ZvWqPkw_Vi
zo}`vaY#XX0mb5GbN<<%qJQTBCFu_dE!Jbc5L4<AMaPeik;tkSJAa}xs=({o1E3qs`
zi{v`&wKs!_U~#yK<&Vsv^P9t;ZJCv{9V?%i{&pOq?J4YKcz?+Xc;L?(MIyQ0Qd0>i
zUuY_BcS+<Tlxr~ZutklytPzt?1=2NUQ#Ga%!$=tlm6eoZCE&GL<P|oc#h8!_$&h6X
z5qU&*^aQcFsGU6W@x>R%ewMVkCmLSsyO>+kR86<-P_Q87Y8*Z$ta!>G5*IyTCPwcr
z(948Tw8|Cb#J2BR*;043Gpbd^FC6>&f*U}bLhr`MJ@DWp1UyRQwzL|vpgf@@Ieyk-
z_B}drxamtDKgNMJ1^ER$;~z%;IvE6H#U3?PPNr?^AFmwl`5P)E-d?w3&m&kN1zU7U
zP)5KPWLWb1^X$8H$Lo*%IxT7D7i-U4X{s#b+1m{7&ocqf_%ZWoBl_|4yXk&{Z>YJj
z?g#u-xdxTx=NIsdzmWHSey??EH6ISX@H^HCT^5XqfMJ~Ifi4evb{oPONo!R1>pjPi
zGaTd;FpRShH^0x>uO52p-I=bawyyc<-hr3a6!sCfpDqpZ3wY$e7f|j|cpu{Z{BAct
zD`|;0+cv-B)>gJ`R|asQ?9%SOlx{d3x*1LoxJksrxzD<3N5}|K`C1d0Q27B=UV&Vl
z-Fb=@C7C2<yd`Y)hg($3Fo^2t7Es2?&J=;yeS`4EmN=X4_8#=w;K5=ClYl8@Ag<d=
zpMg@~KsIdX`27*+YW=!FXbA%t5B$^If1yyCXKybo&po;G?Cw=7Vp!_4e&!6`ujncy
z{B!H$()sr$qHKU28}>FtZ^OqTcyO8S#(CVUjB&|>-;VHxAl!|L?*Pf4=ov`i5N(5p
z)-%~X_7OVp2Bnskzy8d>G~b;|*b%n0TTy&Laj(8z=8Z&HjM+u<rmYB3V^*rrN_EhR
zfak4r_^sqFn>X#GbWrNhNqx|XfajgG2sJ9_b51cJ>l6omAwcqBIpJozJ08Az;`oL)
zu1K0UnD3tFhT^nDD}&bD%fn?!^9H=NWr8)<KH~ZioY#Df3n5R_`-6%ChEt@?i1)X*
zvz8Noe)Zz0w(ry@t3S95Et#8;U0&MafMP3-LwS!vH5KtFV0g(Tr6mnwq8zpbw>P*{
za0+?@CN~d;mz$@Dn`Fef;qvYXZov(fS18hC%E=c6^z{^pY|#@*gFK02cwel`AE=yG
YtLx86nm1s}&9%$iZ&L3ohUx755B2m|Pyhe`

literal 3861
zcmbtXTWl0n7%rCHZK=quV(D@zwX|I;HP(<iqZ9}V7`zn0Y%-bdo*qWd&MaqUd$GpG
z*hH+vKBzASMTtg@M(_dSLx}+s0whLjFu`*15-%*&rb$&~YsCM|?3|r5vn3?<;q-Lo
zoB#X%bN*YW>+{oF+Sf!nOhnB{CrKiOBy~0NKq9eDwbaOFBdU_fR%&3X#?8pqK5M6;
zXMVM`Hnpsd5Un#}?W9PJX*v!k`ch}|^76)t6-CoEOHt|zQl;>K&V~gK#u`g^3@(!S
zrvHO{It$)tQ?Sx}*wxRrp)=r{>m7V*5};!xih^_tQO4r=s-$Y;)jiwJNO<t{%2|JH
z%#%6Gf}7y0**&Ue2{eHZIL#EJ0bfwB<BNyo^?$23ow{^c!lf^+ovd9vDfQE0zy1J*
z8@|d6mn#$zq?$-E)ozsAhgCmM?JFDjUgAC!vy&?EGjSJOJZJicF;yyRbazst2pCPv
zpt;B{N_e>7$7oU6AK*$wZUPU66I^2iC5mP$MvsnSf*Vil8J+)9<pl{(ZTPP3WO*u=
z<p9RDtYuyGUT?$XN26ceJzvH{Pw#po^vj5x<KP1rZZjKbUYpMG{Vier)S8pORoAkR
zNpJt(c@a+%OG{8AicAx-Ba$!-0x6>PKpY06Js^UMo`yRgD})m^ktLk(@dMLeJowBd
z3A>wqNRWAOA=&^7^#YcbeL}3eK>h_MVaeeHmiJ^nIk&#;;Z&uJ3l3KuL*sDTF2f5P
z?@ieN9_*({j+0zxM3ZqyUnnY0b&1<2WEU8v$DkypV5B3eLbygu8jVB|AxWZAMNL{p
z93JaA9<c(nm<417>NZF>QhF6jiz5@t5UVrvHdwF|aT5~m7~g*WLh}*k(^zqvX;F|M
z*%<gUZp4xVNpO1XqZz(rr?(JZr)ppsD|ASOE4pXj+#_#oSS{ld_vP)FxYH)HKcS15
z*(z9s3ku*F1#`)faXZ5ocqCoivah2sJPIMOmcF+9F57;3*0U+V<)v%dI+Gf)nlwEW
zM^L(BA^UGlH^ZnGMMdWVmKd`gOhqjI^5bek@T}qSiC5llFOqR%L;Gj%ReL<EW^$J>
zrQXm8;JN)CX1`Pc0!20Z^r%1+fAaos9@<eYXL57BUCy~Iy39`#z-MV##M({98{rLm
zcg?v{n=j*w!^b}VHnA!j;qP#~;D#U1?X#St3z#0S{lUhAFP9z|m+-r|qkh%!v|Y+=
z{X>8s%g2z@Ui$$&x1Y^8uYKNR{wybp*8k4xVXgm60vK+SX`n0pnt3Vuvh_{#`AKGT
zh2LfX!)<2I&8u_%!A(c!Jqn3Xa;5R@fgw42kL>#Ca=-lmp4n$<MnkZqo7*xGU8g1z
zNRQQpjIK~!)F1>!EzN)kkD=X31dltPf+wbw<5EUoMzC*ZBv)f{UvbP#0%Dq}b`nMf
z3KU{O#qSD3RqN6SqJn^IB>@-gAM9@WMeB`O_ngk1vF?moVPZsgc`c{z06Vk+7W~u4
zefO?7KO*xDtJrq&o5L`bun6(yP7K)HxbRyTe6Anv%m}C5Vd1otnH5qjq-i58c=*Gn
z%5CRBfxDT>waoZ)eb+oQSKvmtYd16Ua=+F9UKA4MXUqr58<yhq(X`un(-N0b$fOkc
zr3CPzlqRnfd)T~TB~IBsDq(lSmDq!KnO}(u<9Ja?U7%$snV3@vM4f8Ee+UqKES=b8
zJ2&oh)CxJ%S}UMl1SZHsU+*m%YJq{--OvKRG~OZHjVNttKpO96F|8Z=wV2}$&smr7
zEaZ5dpD}<D80k`m_jcRR<xdZ9+`mx9&mG#2%UYr52_K}F%`9=JYO0n+MU9(>Uk#sV
z{#C;6CWl7%6~~B_OJ=4dNN04cEI75{T20y9<J~_<*xhit>tIB>>x>jS>a|4o_(<Vy
z`suCyD{x<B;&D_G`LaoxNLrbsfV!SU;m5Rif}ls(9-il_@@~h?w%%X_1Tf9b{{fI9
BV37a-

diff --git a/src/cellular_automaton/ca_cell.py b/src/cellular_automaton/ca_cell.py
index b072e14..d463527 100644
--- a/src/cellular_automaton/ca_cell.py
+++ b/src/cellular_automaton/ca_cell.py
@@ -4,33 +4,21 @@ from typing import Type
 
 class Cell:
     def __init__(self, state_class: Type[CellState], coordinate):
-        self._coordinate = coordinate
+        self.coordinate = coordinate
         self.state = state_class()
         self.neighbours = []
 
-    def set_neighbours(self, neighbours):
-        self.neighbours = 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]])
+            Cell.set_new_state_and_activate(cell, new_state, iteration)
 
-    def get_state(self):
-        return self.state
-
-    def get_coordinate(self):
-        return self._coordinate
-
-    def evolve_if_ready(self, rule, iteration):
-        if self.state.is_active(iteration):
-            new_state = rule(self.state.get_state_of_last_iteration(iteration), self.get_neighbour_states(iteration))
-            self.set_new_state_and_activate(new_state, iteration)
-
-    def get_neighbour_states(self, index):
-        return [n.get_state_of_last_iteration(index) for n in self.neighbours]
-
-    def set_new_state_and_activate(self, new_state: CellState, iteration):
-        changed = self.state.set_state_of_iteration(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)
         if changed:
-            self._set_active_for_next_iteration(iteration)
-
-    def _set_active_for_next_iteration(self, iteration):
-        self.state.set_active_for_next_iteration(iteration)
-        for n in self.neighbours:
-            n.set_active_for_next_iteration(iteration)
+            cell[0].set_active_for_next_iteration(iteration)
+            for n in cell[1]:
+                n.set_active_for_next_iteration(iteration)
diff --git a/src/cellular_automaton/ca_cell_state.py b/src/cellular_automaton/ca_cell_state.py
index 706a928..cc48640 100644
--- a/src/cellular_automaton/ca_cell_state.py
+++ b/src/cellular_automaton/ca_cell_state.py
@@ -17,16 +17,6 @@ class CellState:
         else:
             self._dirty = RawValue(c_bool, False)
 
-    def get_state_of_iteration(self, iteration):
-        """ Will return the state for the iteration modulo number of saved states.
-        :param iteration:   Uses the iteration index, to differ between concurrent states.
-        :return The state for this iteration.
-        """
-        return self._state_slots[self.__calculate_slot(iteration)]
-
-    def __calculate_slot(self, iteration):
-        return iteration % self.__class__._state_save_slot_count
-
     def is_active(self, iteration):
         return self._active[self.__calculate_slot(iteration)]
 
@@ -42,6 +32,13 @@ class CellState:
     def get_state_of_last_iteration(self, current_iteration_index):
         return self.get_state_of_iteration(current_iteration_index - 1)
 
+    def get_state_of_iteration(self, iteration):
+        """ Will return the state for the iteration modulo number of saved states.
+        :param iteration:   Uses the iteration index, to differ between concurrent states.
+        :return The state for this iteration.
+        """
+        return self._state_slots[self.__calculate_slot(iteration)]
+
     def set_state_of_iteration(self, new_state, iteration):
         """ Will set the new state for the iteration modulo number of saved states.
         :param new_state:  The new state to set.
@@ -66,3 +63,7 @@ class CellState:
 
     def get_state_draw_color(self, iteration):
         raise NotImplementedError
+
+    @classmethod
+    def __calculate_slot(cls, iteration):
+        return iteration % cls._state_save_slot_count
diff --git a/src/cellular_automaton/ca_display.py b/src/cellular_automaton/ca_display.py
index 84d01cb..f642002 100644
--- a/src/cellular_automaton/ca_display.py
+++ b/src/cellular_automaton/ca_display.py
@@ -92,13 +92,13 @@ class PyGameFor2D:
 
 def _cell_redraw_rectangles(cells, evolution_index, display_info):
     for cell in cells:
-        if cell.get_state().is_set_for_redraw():
-            cell_color = cell.get_state().get_state_draw_color(evolution_index)
+        if cell.state.is_set_for_redraw():
+            cell_color = cell.state.get_state_draw_color(evolution_index)
             cell_pos = _calculate_cell_position(display_info.cell_size, cell)
             surface_pos = list(map(operator.add, cell_pos, display_info.grid_pos))
             yield display_info.screen.fill(cell_color, (surface_pos, display_info.cell_size))
-            cell.get_state().was_redrawn()
+            cell.state.was_redrawn()
 
 
 def _calculate_cell_position(cell_size, cell):
-    return list(map(operator.mul, cell_size, cell.get_coordinate()))
+    return list(map(operator.mul, cell_size, cell.coordinate))
diff --git a/src/cellular_automaton/ca_factory.py b/src/cellular_automaton/ca_factory.py
index d70723d..de998f2 100644
--- a/src/cellular_automaton/ca_factory.py
+++ b/src/cellular_automaton/ca_factory.py
@@ -25,9 +25,9 @@ class CAFactory:
     @staticmethod
     def _apply_neighbourhood_to_cells(cells, neighborhood, dimension):
         for cell in cells.values():
-            n_coordinates = neighborhood.calculate_cell_neighbor_coordinates(cell.get_coordinate(),
+            n_coordinates = neighborhood.calculate_cell_neighbor_coordinates(cell.coordinate,
                                                                              dimension)
-            cell.set_neighbours([cells[_join_coordinate(coordinate)].get_state() for coordinate in n_coordinates])
+            cell.neighbours = [cells[_join_coordinate(coordinate)].state for coordinate in n_coordinates]
 
 
 def _join_coordinate(coordinate):
diff --git a/src/cellular_automaton/cellular_automaton.py b/src/cellular_automaton/cellular_automaton.py
index f7bf9c7..c258fdd 100644
--- a/src/cellular_automaton/cellular_automaton.py
+++ b/src/cellular_automaton/cellular_automaton.py
@@ -1,6 +1,7 @@
 import multiprocessing
 
 from cellular_automaton.ca_rule import Rule
+from cellular_automaton.ca_cell import Cell
 
 
 class CellularAutomaton:
@@ -14,7 +15,7 @@ class CellularAutomaton:
 class CellularAutomatonProcessor:
     def __init__(self, cellular_automaton, process_count: int = 1):
         self.ca = cellular_automaton
-        cells = {i: self.ca.cells[i] for i in range(len(self.ca.cells))}
+        cells = {i: (c.state, c.neighbours) for i, c in enumerate(self.ca.cells)}
         self.evolve_range = range(len(self.ca.cells))
         self.pool = multiprocessing.Pool(processes=process_count,
                                          initializer=_init_process,
@@ -22,7 +23,7 @@ class CellularAutomatonProcessor:
                                                    self.ca.evolution_rule,
                                                    self.ca.evolution_iteration_index))
         for cell in self.ca.cells:
-            cell.set_neighbours(None)
+            del cell.neighbours
 
     def evolve_x_times(self, x):
         for x in range(x):
@@ -46,5 +47,5 @@ def _init_process(cells, rule, index):
 
 
 def _process_routine(i):
-    global_cells[i].evolve_if_ready(global_rule.evolve_cell, global_iteration.value)
+    Cell.evolve_if_ready(global_cells[i], global_rule.evolve_cell, global_iteration.value)
 
diff --git a/test/test_cell.py b/test/test_cell.py
index 17ca8ac..f10bf40 100644
--- a/test/test_cell.py
+++ b/test/test_cell.py
@@ -1,26 +1,25 @@
 import sys
 sys.path.append('../src')
 
-import cellular_automaton.ca_cell_state as cas
-import cellular_automaton.ca_cell as cac
+from cellular_automaton import *
 import unittest
 
 
-class TestState(cas.CellState):
+class TestState(CellState):
     def __init__(self):
         super().__init__()
 
 
 class TestCellState(unittest.TestCase):
     def setUp(self):
-        self.cell = cac.Cell(TestState, [])
+        self.cell = [TestState(), []]
         self.neighbours = [TestState() for x in range(5)]
         for neighbour in self.neighbours:
             neighbour.set_state_of_iteration((0, ), 0)
-        self.cell.set_neighbours(self.neighbours)
+        self.cell[1] = self.neighbours
 
     def cell_and_neighbours_active(self, iteration):
-        self.neighbours.append(self.cell.get_state())
+        self.neighbours.append(self.cell[0])
         all_active = True
         for state in self.neighbours:
             if not state.is_active(iteration):
@@ -28,12 +27,12 @@ class TestCellState(unittest.TestCase):
         return all_active
 
     def test_evolve_activation(self):
-        self.cell.evolve_if_ready((lambda a, b: (1,)), 0)
+        Cell.evolve_if_ready(self.cell, (lambda a, b: (1,)), 0)
         all_active = self.cell_and_neighbours_active(1)
         self.assertTrue(all_active)
 
     def test_evolve_activation_on_no_change(self):
-        self.cell.evolve_if_ready((lambda a, b: (0,)), 0)
+        Cell.evolve_if_ready(self.cell, (lambda a, b: (0,)), 0)
         all_active = self.cell_and_neighbours_active(1)
         self.assertFalse(all_active)