Mesa 3.1.1__tar.gz → 3.1.3__tar.gz

{mesa-3.1.1 → mesa-3.1.3}/.pre-commit-config.yaml

@@ -4,7 +4,7 @@ ci:
 repos:
 - repo: https://github.com/astral-sh/ruff-pre-commit
   # Ruff version.
-  rev: v0.8.1
+  rev: v0.8.6
   hooks:
     # Run the linter.
     - id: ruff
@@ -14,7 +14,7 @@ repos:
     - id: ruff-format
       types_or: [ python, pyi, jupyter ]
 -   repo: https://github.com/asottile/pyupgrade
-    rev: v3.19.0
+    rev: v3.19.1
     hooks:
     -   id: pyupgrade
         args: [--py311-plus]

{mesa-3.1.1 → mesa-3.1.3}/CONTRIBUTING.md

@@ -137,6 +137,8 @@ To create a new release, follow these steps:
 9. The [`release.yml`](https://github.com/projectmesa/mesa/blob/main/.github/workflows/release.yml) CI workflow should automatically create and upload the package to PyPI. Verify this on [PyPI.org](https://pypi.org/project/mesa/).
 10. Finally, after release, open a new PR to update the version number in [`mesa/__init__.py`](https://github.com/projectmesa/mesa/blob/main/mesa/__init__.py) for the next release (e.g., `"3.1.0.dev"`).
 
+A recorded video of this process is [available here](https://youtu.be/JE44jkegmns).
+
 ## Special Thanks
 
 A special thanks to the following projects who offered inspiration for this contributing file.

{mesa-3.1.1 → mesa-3.1.3}/HISTORY.md

@@ -1,6 +1,80 @@
 ---
 title: Release History
 ---
+# 3.1.3 (2025-01-11)
+## Highlights
+Mesa 3.1.3 introduces a major experimental reimplementation of Mesa's continuous space, providing an intuitive agent-centric API and significant performance improvements. The new implementation supports n-dimensional spaces and offers streamlined methods for agent movement and neighbor calculations.
+
+### New Continuous Space Features
+- Agent-centric movement API similar to cell spaces
+- Efficient neighbor calculations and position updates
+- Support for n-dimensional spaces
+- Improved memory management with dynamic array resizing
+
+Here's a quick look at the new API:
+
+```python
+# Create a 2D continuous space
+space = ContinuousSpace(
+    dimensions=[[0, 1], [0, 1]],
+    torus=True,
+    random=model.random
+)
+
+# Create and position an agent
+agent = ContinuousSpaceAgent(space, model)
+agent.position = [0.5, 0.5]
+
+# Move agent using vector arithmetic
+agent.position += [0.1, 0.1]
+
+# Get neighbors within radius
+neighbors, distances = agent.get_neighbors_in_radius(radius=0.2)
+
+# Find k nearest neighbors
+nearest, distances = agent.get_nearest_neighbors(k=5)
+```
+
+The new implementation particularly benefits models requiring frequent position updates and neighbor queries, such as flocking simulations or particle systems. See [#2584](https://github.com/projectmesa/mesa/pull/2584) for more details. We would love to get feedback on the new Continuous Space in [#2611](https://github.com/projectmesa/mesa/discussions/2611).
+
+Other improvements in this release include consistent visualization behavior across space types with the reimplementation of `draw_voronoi` [#2608](https://github.com/projectmesa/mesa/pull/2608), and a new render interval slider for controlling visualization update frequency in SolaraViz, which helps improve performance when working with complex visualizations [#2596](https://github.com/projectmesa/mesa/pull/2596). We've also fixed a bug affecting random number generation determinism when using `Model(seed=something)`, ensuring both `model.random` and `model.rng` now behave consistently when seeded with the same initial value [#2598](https://github.com/projectmesa/mesa/pull/2598).
+
+## What's Changed
+### 🧪 Experimental features
+* Reimplementation of Continuous Space by @quaquel in https://github.com/projectmesa/mesa/pull/2584
+### 🛠 Enhancements made
+* reimplementation of draw_voroinoi by @quaquel in https://github.com/projectmesa/mesa/pull/2608
+* Add render interval slider to control visualization update frequency by @HMNS19 in https://github.com/projectmesa/mesa/pull/2596
+### 🐛 Bugs fixed
+* Bugfix for non deterministic rng behavior by @quaquel in https://github.com/projectmesa/mesa/pull/2598
+### 🔍 Examples updated
+* Clarify ContinuousSpace.get_neighbors behavior with multiple agents at same position by @quaquel in https://github.com/projectmesa/mesa/pull/2599
+
+## New Contributors
+* @HMNS19 made their first contribution in https://github.com/projectmesa/mesa/pull/2596
+
+**Full Changelog**: https://github.com/projectmesa/mesa/compare/v3.1.2...v3.1.3
+
+# 3.1.2 (2025-01-04)
+## Highlights
+Mesa v3.1.2 is a patch release containing updates to our wolf-sheep, shelling and prisoner's dilemma example models and improving documentation in the tutorials and visualisation docstring. No functional changes to the core library were made.
+
+## What's Changed
+### 🔍 Examples updated
+* examples/wolf_sheep: Don't allow dumb moves by @EwoutH in https://github.com/projectmesa/mesa/pull/2503
+* Added homophily ratio in basic schelling example by @vbv-shm in https://github.com/projectmesa/mesa/pull/2520
+* examples: Update pd_grid analysis.ipynb to use new spaces by @quaquel in https://github.com/projectmesa/mesa/pull/2553
+### 📜 Documentation improvements
+* Corrected a few errors in Intro tutorial by @sanika-n in https://github.com/projectmesa/mesa/pull/2583
+* Small draw_space docstring fix by @quaquel in https://github.com/projectmesa/mesa/pull/2554
+* fix: model name in visualization tutorial by @Sahil-Chhoker in https://github.com/projectmesa/mesa/pull/2591
+
+## New Contributors
+* @vbv-shm made their first contribution in https://github.com/projectmesa/mesa/pull/2520
+* @sanika-n made their first contribution in https://github.com/projectmesa/mesa/pull/2583
+
+**Full Changelog**: https://github.com/projectmesa/mesa/compare/v3.1.1...v3.1.2
+
 # 3.1.1 (2024-12-14)
 ## Highlights
 Mesa 3.1.1 is a maintenance release that includes visualization improvements and documentation updates. The key enhancement is the addition of an interactive play interval control to the visualization interface, allowing users to dynamically adjust simulation speed between 1ms and 500ms through a slider in the Controls panel.

{mesa-3.1.1 → mesa-3.1.3}/PKG-INFO

@@ -1,11 +1,13 @@
-Metadata-Version: 2.3
+Metadata-Version: 2.4
 Name: Mesa
-Version: 3.1.1
+Version: 3.1.3
 Summary: Agent-based modeling (ABM) in Python
 Project-URL: homepage, https://github.com/projectmesa/mesa
 Project-URL: repository, https://github.com/projectmesa/mesa
 Author-email: Project Mesa Team <projectmesa@googlegroups.com>
 License: Apache 2.0
+License-File: LICENSE
+License-File: NOTICE
 Keywords: ABM,agent,based,model,modeling,multi-agent,simulation
 Classifier: Development Status :: 3 - Alpha
 Classifier: Intended Audience :: Science/Research
@@ -22,6 +24,7 @@ Classifier: Topic :: Scientific/Engineering :: Artificial Life
 Requires-Python: >=3.11
 Requires-Dist: numpy
 Requires-Dist: pandas
+Requires-Dist: scipy
 Requires-Dist: tqdm
 Provides-Extra: all
 Requires-Dist: ipython; extra == 'all'

{mesa-3.1.1 → mesa-3.1.3}/benchmarks/configurations.py

@@ -35,7 +35,7 @@ configurations = {
             "parameters": {
                 "height": 40,
                 "width": 40,
-                "homophily": 3,
+                "homophily": 0.4,
                 "radius": 1,
                 "density": 0.625,
             },
@@ -47,7 +47,7 @@ configurations = {
             "parameters": {
                 "height": 100,
                 "width": 100,
-                "homophily": 8,
+                "homophily": 1,
                 "radius": 2,
                 "density": 0.8,
             },
@@ -90,14 +90,19 @@ configurations = {
             "seeds": 25,
             "replications": 3,
             "steps": 20,
-            "parameters": {"population": 200, "width": 100, "height": 100, "vision": 5},
+            "parameters": {
+                "population_size": 200,
+                "width": 100,
+                "height": 100,
+                "vision": 5,
+            },
         },
         "large": {
             "seeds": 10,
             "replications": 3,
             "steps": 10,
             "parameters": {
-                "population": 400,
+                "population_size": 400,
                 "width": 150,
                 "height": 150,
                 "vision": 15,

{mesa-3.1.1 → mesa-3.1.3}/docs/apis/experimental.md

@@ -54,3 +54,15 @@ This namespace contains experimental features. These are under development, and
 .. automodule:: experimental.devs.simulator
    :members:
 ```
+
+## Continuous Space
+
+```{eval-rst}
+.. automodule:: experimental.continuous_space.continuous_space
+   :members:
+```
+
+```{eval-rst}
+.. automodule:: experimental.continuous_space.continuous_space_agents
+   :members:
+```

{mesa-3.1.1 → mesa-3.1.3}/docs/tutorials/intro_tutorial.ipynb

@@ -14,7 +14,7 @@
    "metadata": {},
    "source": [
     "**Important:** \n",
-    "- If you are just exploring Mesa and want the fastest way to execute the code we recommend executing this tutorial online in a Colab notebook. [![Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/projectmesa/mesa/blob/main/docs/tutorials/intro_tutorial.ipynb) or if you do not have a Google account you can use [![Binder](https://mybinder.org/badge_logo.svg)](https://mybinder.org/v2/gh/projectmesa/mesa/main?labpath=docs%2Ftutorials%2Fintro_tutorial.ipynb) (Thas can take 30 seconds to 5 minutes to load)\n",
+    "- If you are just exploring Mesa and want the fastest way to execute the code we recommend executing this tutorial online in a Colab notebook. [![Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/projectmesa/mesa/blob/main/docs/tutorials/intro_tutorial.ipynb) or if you do not have a Google account you can use [![Binder](https://mybinder.org/badge_logo.svg)](https://mybinder.org/v2/gh/projectmesa/mesa/main?labpath=docs%2Ftutorials%2Fintro_tutorial.ipynb) (This can take 30 seconds to 5 minutes to load)\n",
     "- If you have installed mesa and are running locally, please ensure that your Mesa version is greater than or equal to 3.0.0b1.\n",
     "\n",
     "## Tutorial Description\n",
@@ -68,7 +68,7 @@
     "\n",
     "Even as a starter-level model it yields results that are both interesting and unexpected. \n",
     "\n",
-    "Due to its simplicity and intrquiging results, we found ti to be a greater starter model. "
+    "Due to its simplicity and intriguing results, we found it to be the best starter model. "
    ]
   },
   {
@@ -104,7 +104,7 @@
     "```\n",
     "\n",
     "\n",
-    "**If running in Google Colab run the below cell to install Mesa.** (This will also work in a locally installed version of Jupyter.)"
+    "**If running in Google Colab run the below cell to install Mesa.** (This will also work in a locally installed version of Jupyter)."
    ]
   },
   {
@@ -226,7 +226,7 @@
     "\n",
     "**Background:** The model can be visualized as a list containing all the agents. The model creates, holds and manages all the agent objects, specifically in a dictionary. The model activates agents in discrete time steps.\n",
     "\n",
-    "**Model-specific information:** When a model is created the number of agents within the model is specified. The model then creates the agents and places them in an set of agents. \n",
+    "**Model-specific information:** When a model is created the number of agents within the model is specified. The model then creates the agents and places them in a set of agents. \n",
     "\n",
     "**Code implementation:** This is done by creating a new class (or object) that extends `mesa.Model` and calls `super().__init__()`, creating a subclass of the `Model` class from mesa. The new class is named `MoneyModel`.  The technical details about the model object can be found in [model module](https://github.com/projectmesa/mesa/blob/main/mesa/model.py) and the AgentSet in the [agent module](https://github.com/projectmesa/mesa/blob/d7a3834c99a3be809abe2edc8b83610f3d4438ba/mesa/agent.py#L86). A critical point is that you can use the `seed` kwarg (keyword argument) to set a seed which controls the random number generator of the model class allowing for the reproducibility of results. \n",
     "\n",
@@ -256,11 +256,11 @@
    "source": [
     "### Making the Agents `do`\n",
     "\n",
-    "With the basics of the Agent class and Model class created we can no activate the agents to `do` things\n",
+    "With the basics of the Agent class and Model class created we can now activate the agents to `do` things\n",
     "\n",
-    "**Background:** Mesa's `do` function calls agent functions the grow your ABM. A step is the smallest unit of time in the model, and is often referred to as a tick. The `do` function and Python functionality can be configured to activate agents in different orders. This can be important as the order in which agents are activated can impact the results of the model [Comer2014]. At each step of the model, one or more of the agents -- usually all of them -- are activated and take their own step, changing internally and/or interacting with one another or the environment.\n",
+    "**Background:** Mesa's `do` function calls agent functions to grow your ABM. A step is the smallest unit of time in the model, and is often referred to as a tick. The `do` function and Python functionality can be configured to activate agents in different orders. This can be important as the order in which agents are activated can impact the results of the model [Comer2014]. At each step of the model, one or more of the agents -- usually all of them -- are activated and take their own step, changing internally and/or interacting with one another or the environment.\n",
     "\n",
-    "**Model-specific information:** For this section we will randomly reorder the Agent activation order using  `mesa.Agent.shuffle_do` and have the agents `step` function print the agent unique id they are assigned during the agent creation process. \n",
+    "**Model-specific information:** For this section we will randomly reorder the Agent activation order using  `mesa.Agent.shuffle_do` and have the agents `step` function print the agent's unique id that they were assigned during the agent creation process. \n",
     "\n",
     "**Code implementation:** Using standard ABM convention we add a `step` function to the `MoneyModel` class which calls the `mesa.Agent.shuffle_do` function. We then pass into `shuffle_do` the parameter \"step\". This tells mesa to look for and execute the `step` function in our MoneyAgent class.  "
    ]
@@ -569,7 +569,7 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "This runs 100 instantiations of the model, and runs each for 10 steps. (notice that we set the histogram bins to be integers, since agents can only have whole numbers of wealth). This distribution looks a lot smoother. By running the model 100 times, we smooth out some of the 'noise' of randomness, and get to the model's overall expected behavior.\n",
+    "This runs 100 instantiations of the model, and runs each for 30 steps. (notice that we set the histogram bins to be integers, since agents can only have whole numbers of wealth). This distribution looks a lot smoother. By running the model 100 times, we smooth out some of the 'noise' of randomness, and get to the model's overall expected behavior.\n",
     "\n",
     "This outcome might be surprising. Despite the fact that all agents, on average, give and receive one unit of money every step, the model converges to a state where most agents have a small amount of money and a small number have a lot of money."
    ]
@@ -580,7 +580,7 @@
    "source": [
     "## Adding space\n",
     "\n",
-    "**Background:** Many ABMs have a spatial element, with agents moving around and interacting with nearby neighbors. Mesa has several types of [spaces](https://mesa.readthedocs.io/latest/apis/space.html) from different types of grids to networks to an in development [cell_space](https://mesa.readthedocs.io/latest/apis/experimental.html#module-experimental.cell_space.__init__). Mesa grids are divided into cells, and agents can only be on a particular cell, like pieces on a chess board. Continuous space, in contrast, allows agents to have any arbitrary position. (Think of grids vs continuous space like the difference between integers and decimals.)\n",
+    "**Background:** Many ABMs have a spatial element, with agents moving around and interacting with nearby neighbors. Mesa has several types of [spaces](https://mesa.readthedocs.io/latest/apis/space.html) from different types of grids to networks to an in development [cell_space](https://mesa.readthedocs.io/latest/apis/experimental.html#module-experimental.cell_space.__init__). Mesa grids are divided into cells, and agents can only be on a particular cell, like pieces on a chess board. Continuous space, in contrast, allows agents to have any arbitrary position. (Think of grids vs continuous space like the difference between integers and decimals).\n",
     "\n",
     "Both grids and continuous spaces are frequently [toroidal](https://en.wikipedia.org/wiki/Toroidal_graph), meaning that the edges wrap around, with cells on the right edge connected to those on the left edge, and the top to the bottom. This prevents some cells having fewer neighbors than others, or agents being able to go off the edge of the environment. You can envision a torous by thinking of donut.\n",
     "\n",
@@ -800,14 +800,14 @@
     "Since one of the main goals of agent-based modeling is generating data for analysis, Mesa provides a class which can handle data collection and storage for us and make it easier to analyze.\n",
     "\n",
     "The data collector stores three categories of data: \n",
-    " - Model-level variables : Model-level collection functions take a model object as an input. Such as a function that computes a dynamic of the whole model (in this case we will compute a measure of wealth inequality based on all agents wealth)\n",
+    " - Model-level variables : Model-level collection functions take a model object as an input. Such as a function that computes a dynamic of the whole model (in this case we will compute a measure of wealth inequality based on all agent's wealth)\n",
     " - Agent-level variables: Agent-level collection functions take an agent object as an input and is typically the state of an agent attributes, in this case wealth.\n",
     " - Tables (which are a catch-all for everything else). \n",
     "\n",
     "**Model-specific information:** We will collect two variables to show Mesa capabilities. At the model level, let's measure the model's [Gini Coefficient](https://en.wikipedia.org/wiki/Gini_coefficient), a measure of wealth inequality. At the agent level, we want to collect every agent's wealth at every step. \n",
     "\n",
     "**Code implementation:**\n",
-    "Let's add a DataCollector to the model with [`mesa.DataCollector`](https://github.com/projectmesa/mesa/blob/main/mesa/datacollection.py), and collect the agents wealth and the gini coefficient at each time step. "
+    "Let's add a DataCollector to the model with [`mesa.DataCollector`](https://github.com/projectmesa/mesa/blob/main/mesa/datacollection.py), and collect the agent's wealth and the gini coefficient at each time step. "
    ]
   },
   {
@@ -882,9 +882,9 @@
    "source": [
     "At every step of the model, the datacollector will collect and store the model-level current Gini coefficient, as well as each agent's wealth, associating each with the current step.\n",
     "\n",
-    "We run the model just as we did above. now is when an interactive session, especially via a notebook, comes in handy: the DataCollector can export the data its collected as a pandas* DataFrame, for easy interactive analysis. \n",
+    "We run the model just as we did above. Now is when an interactive session, especially via a notebook, comes in handy: the DataCollector can export the data it has collected as a pandas* DataFrame, for easy and interactive analysis. \n",
     "\n",
-    "*If you are new to Python, please be aware that pandas is already installed as a dependency of Mesa and that [pandas](https://pandas.pydata.org/docs/) is a \"fast, powerful, flexible and easy to use open source data analysis and manipulation tool\". pandas is great resource to help analyze the data collected in your models."
+    "*If you are new to Python, please be aware that pandas is already installed as a dependency of Mesa and that [pandas](https://pandas.pydata.org/docs/) is a \"fast, powerful, flexible and easy to use open source data analysis and manipulation tool\". Pandas is a great resource to help analyze the data collected in your models."
    ]
   },
   {
@@ -1051,7 +1051,7 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "You can also use pandas to export the data to a CSV (comma separated value), which can be opened by any common spreadsheet application or opened by pandas.\n",
+    "You can also use pandas to export the data to a CSV (comma separated value) file, which can be opened by any common spreadsheet application or opened by pandas.\n",
     "\n",
     "If you do not specify a file path, the file will be saved in the local directory. After you run the code below you will see two files appear (*model_data.csv* and *agent_data.csv*)"
    ]
@@ -1280,7 +1280,7 @@
     "\n",
     "**Model-specific implementation:** In this case we will give agents an attribute of enthnicity of Green, Blue or Mixed. Green and Blue agents only give money to their ethnicity while Mixed can give money to anyone.\n",
     "\n",
-    "**Code Implementation**: Using `groupby` we will execute the above logic in our code passing a list of grouped agents into our `give_money` function.  To ensure we can plot wealth by group we also need to add ethnicity to our datacollector. "
+    "**Code Implementation**: Using `groupby` we will execute the above logic in our code by passing a list of grouped agents into our `give_money` function.  To ensure we can plot wealth by group we also need to add ethnicity to our datacollector. "
    ]
   },
   {
@@ -1460,7 +1460,7 @@
     "  A dictionary containing all the parameters of the model class and desired values to use for the batch run as key-value pairs. Each value can either be fixed ( e.g. `{\"height\": 10, \"width\": 10}`) or an iterable (e.g. `{\"n\": range(10, 500, 10)}`). `batch_run` will then generate all possible parameter combinations based on this dictionary and run the model `iterations` times for each combination.\n",
     "* `number_processes`\n",
     "  If not specified, defaults to 1. Set it to `None` to use all the available processors.\n",
-    "  note: Multiprocessing does make debugging challenging. If your parameter sweeps are resulting in unexpected errors set `number_processes=1`.\n",
+    "  Note: Multiprocessing does make debugging challenging. If your parameter sweeps are resulting in unexpected errors set `number_processes=1`.\n",
     "* `iterations`\n",
     "  The number of iterations to run each parameter combination for. Optional. If not specified, defaults to 1.\n",
     "* `data_collection_period`\n",
@@ -1482,16 +1482,16 @@
     "1. the Gini coefficient value at each time step, and\n",
     "2. the individual agent's wealth development and steps without giving money.\n",
     "\n",
-    "**Important:** Since for the latter changes at each time step might be interesting, we set `data_collection_period=1`. By default, it only collects data at the end of each episode.\n",
+    "**Important:** Since for the latter, changes at each time step might be interesting, we set `data_collection_period=1`. By default, it only collects data at the end of each episode.\n",
     "\n",
-    "note: The total number of runs is 245 (= 49 different populations * 5 iterations per population). However, the resulting list of dictionaries will be of length 6186250 (= 250 average agents per population * 49 different populations * 5 iterations per population * 101 steps per iteration). "
+    "Note: The total number of runs is 245 (= 49 different populations * 5 iterations per population). However, the resulting list of dictionaries will be of length 6186250 (= 250 average agents per population * 49 different populations * 5 iterations per population * 101 steps per iteration). "
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "**note for Windows OS users:** If you are running this tutorial in Jupyter, make sure that you set `number_processes = 1` (single process). If `number_processes` is greater than 1, it is less straightforward to set up. For details on how to use multiprocessing on windows, see [multiprocessing's programming guidelines](https://docs.python.org/3/library/multiprocessing.html#multiprocessing-programming). "
+    "**Note for Windows OS users:** If you are running this tutorial in Jupyter, make sure that you set `number_processes = 1` (single process). If `number_processes` is greater than 1, it is less straightforward to set up. For details on how to use multiprocessing on windows, see [multiprocessing's programming guidelines](https://docs.python.org/3/library/multiprocessing.html#multiprocessing-programming). "
    ]
   },
   {
@@ -1541,7 +1541,7 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "First, we want to take a closer look at how the Gini coefficient at the end of each episode changes as we increase the size of the population. For this, we filter our results to only contain the data of one agent (the Gini coefficient will be the same for the entire population at any time) at the 100th step of each episode and then scatter-plot the values for the Gini coefficient over the the number of agents. notice there are five values for each population size since we set `iterations=5` when calling the batch run."
+    "First, we want to take a closer look at how the Gini coefficient at the end of each episode changes as we increase the size of the population. For this, we filter our results to only contain the data of one agent (the Gini coefficient will be the same for the entire population at any time) at the 100th step of each episode and then scatter-plot the values for the Gini coefficient over the the number of agents. Notice there are five values for each population size since we set `iterations=5` when calling the batch run."
    ]
   },
   {
@@ -1600,7 +1600,7 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "Second, we want to display the agent's wealth at each time step of one specific episode. To do this, we again filter our large data frame, this time with a fixed number of agents and only for a specific iteration of that population.\n",
+    "Secondly, we want to display the agent's wealth at each time step of one specific episode. To do this, we again filter our large data frame, this time with a fixed number of agents and only for a specific iteration of that population.\n",
     "To print the results, we convert the filtered data frame to a string specifying the desired columns to print. \n",
     "\n",
     "Pandas has built-in functions to convert to a lot of different data formats. For example, to display as a table in a Jupyter notebook, we can use the `to_html()` function which takes the same arguments as `to_string()` (see commented lines)."
@@ -1656,7 +1656,7 @@
     "### Analyzing model reporters: Comparing 5 scenarios\n",
     "Other insights might be gathered when we compare the Gini coefficient of different scenarios. For example, we can compare the Gini coefficient of a population with 25 agents to the Gini coefficient of a population with 400 agents. While doing this, we increase the number of iterations to 25 to get a better estimate of the Gini coefficient for each population size and get usable error estimations.\n",
     "\n",
-    "As we look varying the parameters to see the impact on model outcomes, it is critical to again point that users can set the random seed. Due to the often inherent randomness with ABMs the seed becomes crucial for: \n",
+    "As we look varying the parameters to see the impact on model outcomes, it is critical to again point out that users can set the random seed. Due to the often inherent randomness with ABMs the seed becomes crucial for: \n",
     "- **Reproducibility** - Being able to replicate the ABM results\n",
     "- **Sensitivity Analysis** - Identifying how sensitive/robust your model results are to random fluctuations\n",
     "\n",

{mesa-3.1.1 → mesa-3.1.3}/docs/tutorials/visualization_tutorial.ipynb

@@ -128,13 +128,13 @@
    "outputs": [],
    "source": [
     "# Create initial model instance\n",
-    "model1 = MoneyModel(n=50, width=10, height=10) #keyword arguments\n",
+    "money_model = MoneyModel(n=50, width=10, height=10) #keyword arguments\n",
     "\n",
     "SpaceGraph = make_space_component(agent_portrayal)\n",
     "GiniPlot = make_plot_component(\"Gini\")\n",
     "\n",
     "page = SolaraViz(\n",
-    "    model1,\n",
+    "    money_model,\n",
     "    components=[SpaceGraph, GiniPlot],\n",
     "    model_params=model_params,\n",
     "    name=\"Boltzmann Wealth Model\",\n",
@@ -207,13 +207,13 @@
    "outputs": [],
    "source": [
     "# Create initial model instance\n",
-    "model = MoneyModel(n=50, width=10, height=10)\n",
+    "money_model = MoneyModel(n=50, width=10, height=10)\n",
     "\n",
     "SpaceGraph = make_space_component(agent_portrayal)\n",
     "GiniPlot = make_plot_component(\"Gini\")\n",
     "\n",
     "page = SolaraViz(\n",
-    "    model1,\n",
+    "    money_model,\n",
     "    components=[SpaceGraph, GiniPlot],\n",
     "    model_params=model_params,\n",
     "    name=\"Boltzmann Wealth Model\",\n",
@@ -318,7 +318,7 @@
    "outputs": [],
    "source": [
     "# Create initial model instance\n",
-    "model = MoneyModel(n=50, width=10, height=10)\n",
+    "money_model = MoneyModel(n=50, width=10, height=10)\n",
     "\n",
     "SpaceGraph = make_space_component(agent_portrayal)\n",
     "GiniPlot = make_plot_component(\"Gini\")"
@@ -354,7 +354,7 @@
    ],
    "source": [
     "page = SolaraViz(\n",
-    "    model,\n",
+    "    money_model,\n",
     "    components=[SpaceGraph, GiniPlot, Histogram],\n",
     "    model_params=model_params,\n",
     "    name=\"Boltzmann Wealth Model\",\n",
@@ -399,7 +399,7 @@
     }
    ],
    "source": [
-    "Histogram(model)"
+    "Histogram(money_model)"
    ]
   },
   {

{mesa-3.1.1 → mesa-3.1.3}/mesa/__init__.py

@@ -22,7 +22,7 @@ __all__ = [
 ]
 
 __title__ = "mesa"
-__version__ = "3.1.1"
+__version__ = "3.1.3"
 __license__ = "Apache 2.0"
 _this_year = datetime.datetime.now(tz=datetime.UTC).date().year
 __copyright__ = f"Copyright {_this_year} Project Mesa Team"

mesa-3.1.3/mesa/examples/advanced/pd_grid/analysis.ipynb

@@ -0,0 +1,183 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Demographic Prisoner's Dilemma\n",
+    "\n",
+    "The Demographic Prisoner's Dilemma is a family of variants on the classic two-player [Prisoner's Dilemma](https://en.wikipedia.org/wiki/Prisoner's_dilemma), first developed by [Joshua Epstein](http://citeseerx.ist.psu.edu/viewdoc/download?doi=10.1.1.8.8629&rep=rep1&type=pdf). The model consists of agents, each with a strategy of either Cooperate or Defect. Each agent's payoff is based on its strategy and the strategies of its spatial neighbors. After each step of the model, the agents adopt the strategy of their neighbor with the highest total score. \n",
+    "\n",
+    "The specific variant presented here is adapted from the [Evolutionary Prisoner's Dilemma](http://ccl.northwestern.edu/netlogo/models/PDBasicEvolutionary) model included with NetLogo. Its payoff table is a slight variant of the traditional PD payoff table:\n",
+    "\n",
+    "<table>\n",
+    "    <tr><td></td><td>**Cooperate**</td><td>**Defect**</td></tr>\n",
+    "    <tr><td>**Cooperate**</td><td>1, 1</td><td>0, *D*</td></tr>\n",
+    "    <tr><td>**Defect**</td><td>*D*, 0</td><td>0, 0</td></tr>\n",
+    "</table>\n",
+    "\n",
+    "Where *D* is the defection bonus, generally set higher than 1. In these runs, the defection bonus is set to $D=1.6$.\n",
+    "\n",
+    "The Demographic Prisoner's Dilemma demonstrates how simple rules can lead to the emergence of widespread cooperation, despite the Defection strategy dominiating each individual interaction game. However, it is also interesting for another reason: it is known to be sensitive to the activation regime employed in it.\n",
+    "\n",
+    "Below, we demonstrate this by instantiating the same model (with the same random seed) three times, with three different activation regimes: \n",
+    "\n",
+    "* Sequential activation, where agents are activated in the order they were added to the model;\n",
+    "* Random activation, where they are activated in random order every step;\n",
+    "* Simultaneous activation, simulating them all being activated simultaneously.\n",
+    "\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "metadata": {},
+   "source": [
+    "import matplotlib.pyplot as plt\n",
+    "from model import PdGrid\n",
+    "\n",
+    "%matplotlib inline"
+   ],
+   "outputs": [],
+   "execution_count": null
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Helper functions"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "metadata": {},
+   "source": [
+    "from mesa.visualization.mpl_space_drawing import draw_space\n",
+    "\n",
+    "\n",
+    "def agent_portroyal(agent):\n",
+    "    return {\"color\": \"red\" if agent.move == \"D\" else \"blue\", \"marker\": \"s\", \"size\": 11}"
+   ],
+   "outputs": [],
+   "execution_count": null
+  },
+  {
+   "cell_type": "code",
+   "metadata": {},
+   "source": [
+    "def run_model(model):\n",
+    "    \"\"\"\n",
+    "    Run an experiment with a given model, and plot the results.\n",
+    "    \"\"\"\n",
+    "    fig = plt.figure(figsize=(12, 8))\n",
+    "\n",
+    "    ax1 = fig.add_subplot(231)\n",
+    "    ax2 = fig.add_subplot(232)\n",
+    "    ax3 = fig.add_subplot(233)\n",
+    "    ax4 = fig.add_subplot(212)\n",
+    "\n",
+    "    draw_space(model.grid, agent_portroyal, ax=ax1, draw_grid=False)\n",
+    "    model.run(10)\n",
+    "    draw_space(model.grid, agent_portroyal, ax=ax2, draw_grid=False)\n",
+    "    model.run(10)\n",
+    "    draw_space(model.grid, agent_portroyal, ax=ax3, draw_grid=False)\n",
+    "    model.datacollector.get_model_vars_dataframe().plot(ax=ax4)"
+   ],
+   "outputs": [],
+   "execution_count": null
+  },
+  {
+   "cell_type": "code",
+   "metadata": {},
+   "source": [
+    "# Set the random seed\n",
+    "seed = 21"
+   ],
+   "outputs": [],
+   "execution_count": null
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Sequential Activation"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "metadata": {},
+   "source": [
+    "pd_model = PdGrid(50, 50, \"Sequential\", seed=seed)\n",
+    "run_model(pd_model)"
+   ],
+   "outputs": [],
+   "execution_count": null
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Random Activation"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "metadata": {},
+   "source": [
+    "pd_model = PdGrid(50, 50, \"Random\", seed=seed)\n",
+    "run_model(pd_model)"
+   ],
+   "outputs": [],
+   "execution_count": null
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "collapsed": true,
+    "jupyter": {
+     "outputs_hidden": true
+    }
+   },
+   "source": [
+    "## Simultaneous Activation"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "metadata": {},
+   "source": [
+    "pd_model = PdGrid(50, 50, \"Simultaneous\", seed=seed)\n",
+    "run_model(pd_model)"
+   ],
+   "outputs": [],
+   "execution_count": null
+  },
+  {
+   "cell_type": "code",
+   "metadata": {},
+   "source": [],
+   "outputs": [],
+   "execution_count": null
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3 (ipykernel)",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.11.0"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 4
+}