CA and PP testing

Author: StormKoper

docs/prompts.md

@@ -545,6 +545,122 @@ In the run function, check whether the entries in the cell_params arrays align w
 ### output
 Made large changes to multiple functions. See git commit for details.
 
+## CA and PP tests
+Now that the MVP functionality is fulfilled, we need to test it. For this, we create numerous tests for both the CA class and the PP class, testing if incorrect arguments raise the correct errors, if any functions raise unwanted errors, but mostly if the update functions work as intended.
+
+### prompt
+Add tests for the CA and PP class to the test_ca.py file. Check whether incorrect arguments do not raise errors and if any functions do raise errors. Also, test whether run picks up on cell_params array that do not align by grid. For this, manually change some cell_params array entries before running the simulation. Check whether all errors are informative, in the sense that a user would know how to avoid it next time.
+
+Lastly, check whether trivial simulations result in the correct outcome. For example, if both the predator and prey death rates are 1 and the birth rates are below 1, then the grid should go extinct. Also, if the birth rate of the prey and predators are 1 and the death rate of the predators to be 0 we expect the prey to go extinct an the predators to occupy a large number of cells.
+
+Create any additional tests if they are unique, meaning it is not tested already, and well-defined, meaning we know the intended behavior and we know how to compare it to the true behavior.
+
+### output
+def test_initialization_and_grid_filling():
+    rows, cols = 10, 10
+    densities = (0.2, 0.1)
+    ca = CA(rows, cols, densities, neighborhood="moore", params={}, cell_params={}, seed=42)
+    assert ca.grid.shape == (rows, cols)
+    assert ca.n_species == len(densities)
+    total_cells = rows * cols
+    # expected counts use the same rounding as CA.__init__
+    expected_counts = [int(round(total_cells * d)) for d in densities]
+    # verify actual counts equal expected
+    for i, exp in enumerate(expected_counts, start=1):
+        assert int(np.count_nonzero(ca.grid == i)) == exp
+
+
+def test_invalid_parameters_raise():
+    # invalid rows/cols
+    with pytest.raises(AssertionError):
+        CA(0, 5, (0.1,), "moore", {}, {}, seed=1)
+    with pytest.raises(AssertionError):
+        CA(5, -1, (0.1,), "moore", {}, {}, seed=1)
+    # densities must be non-empty tuple
+    with pytest.raises(AssertionError):
+        CA(5, 5, (), "moore", {}, {}, seed=1)
+    # densities sum > 1
+    with pytest.raises(AssertionError):
+        CA(5, 5, (0.8, 0.8), "moore", {}, {}, seed=1)
+    # invalid neighborhood
+    with pytest.raises(AssertionError):
+        CA(5, 5, (0.1,), "invalid", {}, {}, seed=1)
+
+    # PP: params must be a dict or None
+    with pytest.raises(TypeError):
+        PP(rows=5, cols=5, densities=(0.2, 0.1), neighborhood="moore", params="bad", cell_params=None, seed=1)
+
+
+def test_neighborhood_counting():
+    # set up a small grid with a single prey in the center and check neighbor counts
+    ca = CA(3, 3, (0.0,), neighborhood="moore", params={}, cell_params={}, seed=1)
+    ca.grid[:] = 0
+    ca.grid[1, 1] = 1
+    counts = ca.count_neighbors()
+    # counts is a tuple with one array (state 1)
+    neigh = counts[0]
+    # all 8 neighbors of center should have count 1
+    expected_positions = [(0, 0), (0, 1), (0, 2), (1, 0), (1, 2), (2, 0), (2, 1), (2, 2)]
+    for r in range(3):
+        for c in range(3):
+            if (r, c) in expected_positions:
+                assert neigh[r, c] == 1
+            else:
+                # center has 0 neighbors of same state
+                assert neigh[r, c] == 0
+
+
+def test_run_detects_cell_params_shape_and_nonnan_mismatch():
+    # create a PP and enable evolution for a parameter
+    pp = PP(rows=5, cols=5, densities=(0.2, 0.1), neighborhood="moore", params=None, cell_params=None, seed=2)
+    pp.evolve("prey_death", sd=0.01, min=0.0, max=1.0)
+
+    # wrong shape should raise informative ValueError during run()
+    pp.cell_params["prey_death"] = np.zeros((1, 1))
+    with pytest.raises(ValueError) as excinfo:
+        pp.run(1)
+    assert "shape equal to grid" in str(excinfo.value)
+
+    # now create a same-shaped array but with non-NaN positions that don't match prey positions
+    arr = np.zeros(pp.grid.shape, dtype=float)  # filled with non-NaN everywhere
+    pp.cell_params["prey_death"] = arr
+    with pytest.raises(ValueError) as excinfo2:
+        pp.run(1)
+    assert "non-NaN entries must match positions" in str(excinfo2.value)
+
+
+def test_extinction_when_death_one():
+    # when both death rates are 1 all individuals should die in one step
+    params = {
+        "prey_death": 1.0,
+        "predator_death": 1.0,
+        "prey_birth": 0.0,
+        "predator_birth": 0.0,
+    }
+    pp = PP(rows=10, cols=10, densities=(0.2, 0.1), neighborhood="moore", params=params, cell_params=None, seed=3)
+    pp.run(1)
+    # no prey or predators should remain
+    assert np.count_nonzero(pp.grid != 0) == 0
+
+
+def test_predators_dominate_with_high_birth_and_zero_predator_death():
+    params = {
+        "prey_death": 0.0,
+        "predator_death": 0.0,
+        "prey_birth": 1.0,
+        "predator_birth": 1.0,
+    }
+    pp = PP(rows=10, cols=10, densities=(0.1, 0.05), neighborhood="moore", params=params, cell_params=None, seed=4)
+    # run longer to allow predators to consume prey; expect prey extinction
+    pp.run(200)
+    after_prey = int(np.count_nonzero(pp.grid == 1))
+    after_pred = int(np.count_nonzero(pp.grid == 2))
+    # after sufficient time, prey should go extinct and predators remain
+    assert after_prey == 0
+    assert after_pred > 0
+
+### changes
+Revealed and fixed error in the PP class' update functions where no parameter key was passed to the _process_reproduction function, resulting in an error.
 
 ### Mean Field class
 

models/CA.py

@@ -592,11 +592,11 @@ def _process_reproduction(sources, birth_param_key, birth_prob, target_state_req
 
 		# Prey reproduce into empty cells (target state 0 -> new state 1)
 		prey_sources = np.argwhere(grid_ref == 1)
-		_process_reproduction(prey_sources, self.params["prey_birth"], 0, 1)
+		_process_reproduction(prey_sources, "prey_birth", self.params["prey_birth"], 0, 1)
 
 		# Predators reproduce into prey cells (target state 1 -> new state 2)
 		pred_sources = np.argwhere(grid_ref == 2)
-		_process_reproduction(pred_sources, self.params["predator_birth"], 1, 2)
+		_process_reproduction(pred_sources, "predator_birth", self.params["predator_birth"], 1, 2)
 
 	def update_async(self) -> None:
 		"""Asynchronous (random-sequential) update.

tests/test_ca.py

@@ -2,20 +2,108 @@
 
 import pytest
 import numpy as np
-from models.CA import CA
+from models.CA import CA, PP
 
-# @pytest.fixture
-def ca_instance():
-    pass
 
-def test_initialization():
-    pass
+def test_initialization_and_grid_filling():
+    rows, cols = 10, 10
+    densities = (0.2, 0.1)
+    ca = CA(rows, cols, densities, neighborhood="moore", params={}, cell_params={}, seed=42)
+    assert ca.grid.shape == (rows, cols)
+    assert ca.n_species == len(densities)
+    total_cells = rows * cols
+    # expected counts use the same rounding as CA.__init__
+    expected_counts = [int(round(total_cells * d)) for d in densities]
+    # verify actual counts equal expected
+    for i, exp in enumerate(expected_counts, start=1):
+        assert int(np.count_nonzero(ca.grid == i)) == exp
 
-def test_invalid_parameters():
-    pass
 
-def test_grid_filling():
-    pass
+def test_invalid_parameters_raise():
+    # invalid rows/cols
+    with pytest.raises(AssertionError):
+        CA(0, 5, (0.1,), "moore", {}, {}, seed=1)
+    with pytest.raises(AssertionError):
+        CA(5, -1, (0.1,), "moore", {}, {}, seed=1)
+    # densities must be non-empty tuple
+    with pytest.raises(AssertionError):
+        CA(5, 5, (), "moore", {}, {}, seed=1)
+    # densities sum > 1
+    with pytest.raises(AssertionError):
+        CA(5, 5, (0.8, 0.8), "moore", {}, {}, seed=1)
+    # invalid neighborhood
+    with pytest.raises(AssertionError):
+        CA(5, 5, (0.1,), "invalid", {}, {}, seed=1)
 
-def test_neighborhood_types():
-    pass
+    # PP: params must be a dict or None
+    with pytest.raises(TypeError):
+        PP(rows=5, cols=5, densities=(0.2, 0.1), neighborhood="moore", params="bad", cell_params=None, seed=1)
+
+
+def test_neighborhood_counting():
+    # set up a small grid with a single prey in the center and check neighbor counts
+    ca = CA(3, 3, (0.0,), neighborhood="moore", params={}, cell_params={}, seed=1)
+    ca.grid[:] = 0
+    ca.grid[1, 1] = 1
+    counts = ca.count_neighbors()
+    # counts is a tuple with one array (state 1)
+    neigh = counts[0]
+    # all 8 neighbors of center should have count 1
+    expected_positions = [(0, 0), (0, 1), (0, 2), (1, 0), (1, 2), (2, 0), (2, 1), (2, 2)]
+    for r in range(3):
+        for c in range(3):
+            if (r, c) in expected_positions:
+                assert neigh[r, c] == 1
+            else:
+                # center has 0 neighbors of same state
+                assert neigh[r, c] == 0
+
+
+def test_run_detects_cell_params_shape_and_nonnan_mismatch():
+    # create a PP and enable evolution for a parameter
+    pp = PP(rows=5, cols=5, densities=(0.2, 0.1), neighborhood="moore", params=None, cell_params=None, seed=2)
+    pp.evolve("prey_death", sd=0.01, min=0.0, max=1.0)
+
+    # wrong shape should raise informative ValueError during run()
+    pp.cell_params["prey_death"] = np.zeros((1, 1))
+    with pytest.raises(ValueError) as excinfo:
+        pp.run(1)
+    assert "shape equal to grid" in str(excinfo.value)
+
+    # now create a same-shaped array but with non-NaN positions that don't match prey positions
+    arr = np.zeros(pp.grid.shape, dtype=float)  # filled with non-NaN everywhere
+    pp.cell_params["prey_death"] = arr
+    with pytest.raises(ValueError) as excinfo2:
+        pp.run(1)
+    assert "non-NaN entries must match positions" in str(excinfo2.value)
+
+
+def test_extinction_when_death_one():
+    # when both death rates are 1 all individuals should die in one step
+    params = {
+        "prey_death": 1.0,
+        "predator_death": 1.0,
+        "prey_birth": 0.0,
+        "predator_birth": 0.0,
+    }
+    pp = PP(rows=10, cols=10, densities=(0.2, 0.1), neighborhood="moore", params=params, cell_params=None, seed=3)
+    pp.run(1)
+    # no prey or predators should remain
+    assert np.count_nonzero(pp.grid != 0) == 0
+
+
+def test_predators_dominate_with_high_birth_and_zero_predator_death():
+    params = {
+        "prey_death": 0.0,
+        "predator_death": 0.0,
+        "prey_birth": 1.0,
+        "predator_birth": 1.0,
+    }
+    pp = PP(rows=10, cols=10, densities=(0.1, 0.05), neighborhood="moore", params=params, cell_params=None, seed=4)
+    # run longer to allow predators to consume prey; expect prey extinction
+    pp.run(200)
+    after_prey = int(np.count_nonzero(pp.grid == 1))
+    after_pred = int(np.count_nonzero(pp.grid == 2))
+    # after sufficient time, prey should go extinct and predators remain
+    assert after_prey == 0
+    assert after_pred > 0