7. Add PCF analysis functonality for prey auto, predator auto and cross correlation. Also, integrate the snapshot method from the CA clas as an optional functionality of the analysis module. Add the folowing plots: 1. phase diagrams showing segregation, prey-clusterin, and predator clustering. Scatter plots tetsing if Hydra effect correlates with spatial segregation, and CA-style snapshots, neighbor histogram, and evolution trajectory.

8. Help me create a testing module for the analysis file. Use unittest.mock to create a mock model for testing.

# per-parameter evolve metadata and evolution state

# maps parameter name -> dict with keys 'sd','min','max','species'

self._evolve_info: Dict[str, Dict[str, float]] = {}

# when True, inheritance uses deterministic copy from parent (no mutation)

self._evolution_stopped: bool = False

# human-readable species names (useful for visualization). Default

# generates generic names based on n_species; subclasses may override.

self.species_names: Tuple[str, ...] = tuple(f"species{i+1}" for i in range(self._n_species))

def validate(self) -> None:

"""Validate core CA invariants.

if self.neighborhood not in ("neumann", "moore"):

raise ValueError("neighborhood must be 'neumann' or 'moore'")

expected_shape = (int(getattr(self, "_rows")), int(getattr(self, "_cols")))

if self.grid.shape != expected_shape:

raise ValueError(f"grid shape {self.grid.shape} does not match expected {expected_shape}")

# Ensure any array in cell_params matches grid shape

for k, v in (self.cell_params or {}).items():

if isinstance(v, np.ndarray) and v.shape != expected_shape:

raise ValueError(f"cell_params['{k}'] must have shape equal to grid")

def _infer_species_from_param_name(self, param_name: str) -> Optional[int]:

"""Infer species index (1-based) from a parameter name using `species_names`.

if not isinstance(param_name, str):

return None

for idx, name in enumerate(self.species_names or ()): # type: ignore

if isinstance(name, str) and param_name.startswith(f"{name}_"):

return idx + 1

return None

def evolve(self, param: str, species: Optional[int] = None, sd: float = 0.05, min_val: Optional[float] = None, max_val: Optional[float] = None) -> None:

"""Enable per-cell evolution for `param` on `species`.

if min_val is None:

min_val = 0.01

if max_val is None:

max_val = 0.99

if param not in self.params:

raise ValueError(f"Unknown parameter '{param}'")

if species is None:

species = self._infer_species_from_param_name(param)

if species is None:

raise ValueError("species must be provided or inferable from param name and species_names")

if not isinstance(species, int) or species <= 0 or species > self._n_species:

raise ValueError("species must be an integer between 1 and n_species")

arr = np.full(self.grid.shape, np.nan, dtype=float)

mask = (self.grid == int(species))

arr[mask] = float(self.params[param])

self.cell_params[param] = arr

self._evolve_info[param] = {"sd": float(sd), "min": float(min_val), "max": float(max_val), "species": int(species)}

# mark evolution as stopped; do not erase evolve metadata so

# deterministic inheritance can still use parent values

self._evolution_stopped = True

# set human-friendly species names for PP

self.species_names = ("prey", "predator")

# Remove PP-specific evolve wrapper; use CA.evolve with optional species

# expected non-NaN positions correspond to species stored in metadata

species = None

if isinstance(meta, dict) and "species" in meta:

species = int(meta.get("species"))

else:

# try to infer species from parameter name using species_names

species = self._infer_species_from_param_name(pname)

if species is None:

raise ValueError(f"cell_params['{pname}'] missing species metadata and could not infer from name")

for pname, meta in self._evolve_info.items():

# determine species from metadata or infer from name

species = None

if isinstance(meta, dict) and "species" in meta:

species = int(meta.get("species"))

else:

species = self._infer_species_from_param_name(pname)

if species is None:

# cannot determine species; skip clearing for safety

continue

arr = self.cell_params.get(pname)

if not (isinstance(arr, np.ndarray) and arr.shape == self.grid.shape):

continue

if species == 1:

arr[prey_death_mask] = np.nan

elif species == 2:

arr[pred_death_mask] = np.nan

# determine species this parameter belongs to via metadata or inference

species = None

if isinstance(meta, dict) and "species" in meta:

species = int(meta.get("species"))

species = self._infer_species_from_param_name(pname)

if species is None:

raise ValueError(f"_evolve_info contains unexpected key '{pname}' without species metadata and could not infer")

if new_state_val != species:

# If evolution has been stopped, inheritance is deterministic: copy

# parent values directly without Gaussian mutation so we can observe

# which parameter values survive.

if getattr(self, "_evolution_stopped", False):

mut = parent_vals.copy()

else:

mut = parent_vals + self.generator.normal(0.0, sd, size=parent_vals.shape)

mut = np.clip(mut, mn, mx)