Mesa 3.0.0__py3-none-any.whl → 3.0.0a0__py3-none-any.whl

mesa/examples/advanced/sugarscape_g1mt/tests.py

@@ -1,69 +0,0 @@
-import numpy as np
-from scipy import stats
-
-from .agents import Trader
-from .model import SugarscapeG1mt, flatten
-
-
-def check_slope(y, increasing):
-    x = range(len(y))
-    slope, intercept, _, p_value, _ = stats.linregress(x, y)
-    result = (slope > 0) if increasing else (slope < 0)
-    # p_value for significance.
-    assert result and p_value < 0.05, (slope, p_value)
-
-
-def test_decreasing_price_variance():
-    # The variance of the average trade price should decrease over time (figure IV-3)
-    # See Growing Artificial Societies p. 109.
-    model = SugarscapeG1mt(42)
-    model.datacollector._new_model_reporter(
-        "price_variance",
-        lambda m: np.var(
-            flatten([a.prices for a in m.agents_by_type[Trader].values()])
-        ),
-    )
-    model.run_model(step_count=50)
-
-    df_model = model.datacollector.get_model_vars_dataframe()
-
-    check_slope(df_model.price_variance, increasing=False)
-
-
-def test_carrying_capacity():
-    def calculate_carrying_capacities(enable_trade):
-        carrying_capacities = []
-        visions = range(1, 10)
-        for vision_max in visions:
-            model = SugarscapeG1mt(vision_max=vision_max, enable_trade=enable_trade)
-            model.run_model(step_count=50)
-            carrying_capacities.append(len(model.agents_by_type[Trader]))
-        return carrying_capacities
-
-    # Carrying capacity should increase over mean vision (figure IV-6).
-    # See Growing Artificial Societies p. 112.
-    carrying_capacities_with_trade = calculate_carrying_capacities(True)
-    check_slope(
-        carrying_capacities_with_trade,
-        increasing=True,
-    )
-    # Carrying capacity should be higher when trade is enabled (figure IV-6).
-    carrying_capacities_no_trade = calculate_carrying_capacities(False)
-    check_slope(
-        carrying_capacities_no_trade,
-        increasing=True,
-    )
-
-    t_statistic, p_value = stats.ttest_rel(
-        carrying_capacities_with_trade, carrying_capacities_no_trade
-    )
-    # t_statistic > 0 means carrying_capacities_with_trade has larger values
-    # than carrying_capacities_no_trade.
-    # p_value for significance.
-    assert t_statistic > 0 and p_value < 0.05
-
-
-# TODO:
-# 1. Reproduce figure IV-12 that the log of average price should decrease over average agent age
-# 2. Reproduce figure IV-13 that the gini coefficient on trade should decrease over mean vision, and should be higher with trade
-# 3. a stricter test would be to ensure the amount of variance of the trade price matches figure IV-3

mesa/examples/advanced/wolf_sheep/Readme.md

@@ -1,57 +0,0 @@
-# Wolf-Sheep Predation Model
-
-## Summary
-
-A simple ecological model, consisting of three agent types: wolves, sheep, and grass. The wolves and the sheep wander around the grid at random. Wolves and sheep both expend energy moving around, and replenish it by eating. Sheep eat grass, and wolves eat sheep if they end up on the same grid cell.
-
-If wolves and sheep have enough energy, they reproduce, creating a new wolf or sheep (in this simplified model, only one parent is needed for reproduction). The grass on each cell regrows at a constant rate. If any wolves and sheep run out of energy, they die.
-
-The model is tests and demonstrates several Mesa concepts and features:
- - MultiGrid
- - Multiple agent types (wolves, sheep, grass)
- - Overlay arbitrary text (wolf's energy) on agent's shapes while drawing on CanvasGrid
- - Agents inheriting a behavior (random movement) from an abstract parent
- - Writing a model composed of multiple files.
- - Dynamically adding and removing agents from the schedule
-
-## Installation
-
-To install the dependencies use pip and the requirements.txt in this directory. e.g.
-
-```
-    # First, we clone the Mesa repo
-    $ git clone https://github.com/projectmesa/mesa.git
-    $ cd mesa
-    # Then we cd to the example directory
-    $ cd examples/wolf_sheep
-    $ pip install -r requirements.txt
-```
-
-## How to Run
-
-To run the model interactively, run ``mesa runserver`` in this directory. e.g.
-
-```
-    $ mesa runserver
-```
-
-Then open your browser to [http://127.0.0.1:8521/](http://127.0.0.1:8521/) and press Reset, then Run.
-
-## Files
-
-* ``wolf_sheep/random_walk.py``: This defines the ``RandomWalker`` agent, which implements the behavior of moving randomly across a grid, one cell at a time. Both the Wolf and Sheep agents will inherit from it.
-* ``wolf_sheep/test_random_walk.py``: Defines a simple model and a text-only visualization intended to make sure the RandomWalk class was working as expected. This doesn't actually model anything, but serves as an ad-hoc unit test. To run it, ``cd`` into the ``wolf_sheep`` directory and run ``python test_random_walk.py``. You'll see a series of ASCII grids, one per model step, with each cell showing a count of the number of agents in it.
-* ``wolf_sheep/agents.py``: Defines the Wolf, Sheep, and GrassPatch agent classes.
-* ``wolf_sheep/scheduler.py``: Defines a custom variant on the RandomActivationByType scheduler, where we can define filters for the `get_type_count` function.
-* ``wolf_sheep/model.py``: Defines the Wolf-Sheep Predation model itself
-* ``wolf_sheep/server.py``: Sets up the interactive visualization server
-* ``run.py``: Launches a model visualization server.
-
-## Further Reading
-
-This model is closely based on the NetLogo Wolf-Sheep Predation Model:
-
-Wilensky, U. (1997). NetLogo Wolf Sheep Predation model. http://ccl.northwestern.edu/netlogo/models/WolfSheepPredation. Center for Connected Learning and Computer-Based Modeling, Northwestern University, Evanston, IL.
-
-See also the [Lotka–Volterra equations
-](https://en.wikipedia.org/wiki/Lotka%E2%80%93Volterra_equations) for an example of a classic differential-equation model with similar dynamics.

mesa/examples/advanced/wolf_sheep/agents.py

@@ -1,102 +0,0 @@
-from mesa.experimental.cell_space import CellAgent, FixedAgent
-
-
-class Animal(CellAgent):
-    """The base animal class."""
-
-    def __init__(self, model, energy, p_reproduce, energy_from_food, cell):
-        """Initializes an animal.
-
-        Args:
-            model: a model instance
-            energy: starting amount of energy
-            p_reproduce: probability of sexless reproduction
-            energy_from_food: energy obtained from 1 unit of food
-            cell: the cell in which the animal starts
-        """
-        super().__init__(model)
-        self.energy = energy
-        self.p_reproduce = p_reproduce
-        self.energy_from_food = energy_from_food
-        self.cell = cell
-
-    def spawn_offspring(self):
-        """Create offspring."""
-        self.energy /= 2
-        self.__class__(
-            self.model,
-            self.energy,
-            self.p_reproduce,
-            self.energy_from_food,
-            self.cell,
-        )
-
-    def feed(self): ...
-
-    def step(self):
-        """One step of the agent."""
-        self.cell = self.cell.neighborhood.select_random_cell()
-        self.energy -= 1
-
-        self.feed()
-
-        if self.energy < 0:
-            self.remove()
-        elif self.random.random() < self.p_reproduce:
-            self.spawn_offspring()
-
-
-class Sheep(Animal):
-    """A sheep that walks around, reproduces (asexually) and gets eaten."""
-
-    def feed(self):
-        """If possible eat the food in the current location."""
-        # If there is grass available, eat it
-        if self.model.grass:
-            grass_patch = next(
-                obj for obj in self.cell.agents if isinstance(obj, GrassPatch)
-            )
-            if grass_patch.fully_grown:
-                self.energy += self.energy_from_food
-                grass_patch.fully_grown = False
-
-
-class Wolf(Animal):
-    """A wolf that walks around, reproduces (asexually) and eats sheep."""
-
-    def feed(self):
-        """If possible eat the food in the current location."""
-        sheep = [obj for obj in self.cell.agents if isinstance(obj, Sheep)]
-        if len(sheep) > 0:
-            sheep_to_eat = self.random.choice(sheep)
-            self.energy += self.energy_from_food
-
-            # Kill the sheep
-            sheep_to_eat.remove()
-
-
-class GrassPatch(FixedAgent):
-    """
-    A patch of grass that grows at a fixed rate and it is eaten by sheep
-    """
-
-    def __init__(self, model, fully_grown, countdown):
-        """
-        Creates a new patch of grass
-
-        Args:
-            grown: (boolean) Whether the patch of grass is fully grown or not
-            countdown: Time for the patch of grass to be fully grown again
-        """
-        super().__init__(model)
-        self.fully_grown = fully_grown
-        self.countdown = countdown
-
-    def step(self):
-        if not self.fully_grown:
-            if self.countdown <= 0:
-                # Set as fully grown
-                self.fully_grown = True
-                self.countdown = self.model.grass_regrowth_time
-            else:
-                self.countdown -= 1

mesa/examples/advanced/wolf_sheep/app.py

@@ -1,84 +0,0 @@
-from mesa.examples.advanced.wolf_sheep.agents import GrassPatch, Sheep, Wolf
-from mesa.examples.advanced.wolf_sheep.model import WolfSheep
-from mesa.visualization import (
-    Slider,
-    SolaraViz,
-    make_plot_component,
-    make_space_component,
-)
-
-
-def wolf_sheep_portrayal(agent):
-    if agent is None:
-        return
-
-    portrayal = {
-        "size": 25,
-    }
-
-    if isinstance(agent, Wolf):
-        portrayal["color"] = "tab:red"
-        portrayal["marker"] = "o"
-        portrayal["zorder"] = 2
-    elif isinstance(agent, Sheep):
-        portrayal["color"] = "tab:cyan"
-        portrayal["marker"] = "o"
-        portrayal["zorder"] = 2
-    elif isinstance(agent, GrassPatch):
-        if agent.fully_grown:
-            portrayal["color"] = "tab:green"
-        else:
-            portrayal["color"] = "tab:brown"
-        portrayal["marker"] = "s"
-        portrayal["size"] = 75
-
-    return portrayal
-
-
-model_params = {
-    # The following line is an example to showcase StaticText.
-    "grass": {
-        "type": "Select",
-        "value": True,
-        "values": [True, False],
-        "label": "grass regrowth enabled?",
-    },
-    "grass_regrowth_time": Slider("Grass Regrowth Time", 20, 1, 50),
-    "initial_sheep": Slider("Initial Sheep Population", 100, 10, 300),
-    "sheep_reproduce": Slider("Sheep Reproduction Rate", 0.04, 0.01, 1.0, 0.01),
-    "initial_wolves": Slider("Initial Wolf Population", 10, 5, 100),
-    "wolf_reproduce": Slider(
-        "Wolf Reproduction Rate",
-        0.05,
-        0.01,
-        1.0,
-        0.01,
-    ),
-    "wolf_gain_from_food": Slider("Wolf Gain From Food Rate", 20, 1, 50),
-    "sheep_gain_from_food": Slider("Sheep Gain From Food", 4, 1, 10),
-}
-
-
-def post_process(ax):
-    ax.set_aspect("equal")
-    ax.set_xticks([])
-    ax.set_yticks([])
-
-
-space_component = make_space_component(
-    wolf_sheep_portrayal, draw_grid=False, post_process=post_process
-)
-lineplot_component = make_plot_component(
-    {"Wolves": "tab:orange", "Sheep": "tab:cyan", "Grass": "tab:green"}
-)
-
-model = WolfSheep(grass=True)
-
-
-page = SolaraViz(
-    model,
-    components=[space_component, lineplot_component],
-    model_params=model_params,
-    name="Wolf Sheep",
-)
-page  # noqa

mesa/examples/advanced/wolf_sheep/model.py

@@ -1,137 +0,0 @@
-"""
-Wolf-Sheep Predation Model
-================================
-
-Replication of the model found in NetLogo:
-    Wilensky, U. (1997). NetLogo Wolf Sheep Predation model.
-    http://ccl.northwestern.edu/netlogo/models/WolfSheepPredation.
-    Center for Connected Learning and Computer-Based Modeling,
-    Northwestern University, Evanston, IL.
-"""
-
-import mesa
-from mesa.examples.advanced.wolf_sheep.agents import GrassPatch, Sheep, Wolf
-from mesa.experimental.cell_space import OrthogonalMooreGrid
-
-
-class WolfSheep(mesa.Model):
-    """
-    Wolf-Sheep Predation Model
-    """
-
-    height = 20
-    width = 20
-
-    initial_sheep = 100
-    initial_wolves = 50
-
-    sheep_reproduce = 0.04
-    wolf_reproduce = 0.05
-
-    wolf_gain_from_food = 20
-
-    grass = False
-    grass_regrowth_time = 30
-    sheep_gain_from_food = 4
-
-    description = (
-        "A model for simulating wolf and sheep (predator-prey) ecosystem modelling."
-    )
-
-    def __init__(
-        self,
-        width=20,
-        height=20,
-        initial_sheep=100,
-        initial_wolves=50,
-        sheep_reproduce=0.04,
-        wolf_reproduce=0.05,
-        wolf_gain_from_food=20,
-        grass=False,
-        grass_regrowth_time=30,
-        sheep_gain_from_food=4,
-        seed=None,
-    ):
-        """
-        Create a new Wolf-Sheep model with the given parameters.
-
-        Args:
-            initial_sheep: Number of sheep to start with
-            initial_wolves: Number of wolves to start with
-            sheep_reproduce: Probability of each sheep reproducing each step
-            wolf_reproduce: Probability of each wolf reproducing each step
-            wolf_gain_from_food: Energy a wolf gains from eating a sheep
-            grass: Whether to have the sheep eat grass for energy
-            grass_regrowth_time: How long it takes for a grass patch to regrow
-                                 once it is eaten
-            sheep_gain_from_food: Energy sheep gain from grass, if enabled.
-        """
-        super().__init__(seed=seed)
-        # Set parameters
-        self.width = width
-        self.height = height
-        self.initial_sheep = initial_sheep
-        self.initial_wolves = initial_wolves
-        self.grass = grass
-        self.grass_regrowth_time = grass_regrowth_time
-
-        self.grid = OrthogonalMooreGrid((self.width, self.height), torus=True)
-
-        collectors = {
-            "Wolves": lambda m: len(m.agents_by_type[Wolf]),
-            "Sheep": lambda m: len(m.agents_by_type[Sheep]),
-            "Grass": lambda m: len(
-                m.agents_by_type[GrassPatch].select(lambda a: a.fully_grown)
-            )
-            if m.grass
-            else -1,
-        }
-
-        self.datacollector = mesa.DataCollector(collectors)
-
-        # Create sheep:
-        for _ in range(self.initial_sheep):
-            x = self.random.randrange(self.width)
-            y = self.random.randrange(self.height)
-            energy = self.random.randrange(2 * self.sheep_gain_from_food)
-            Sheep(
-                self, energy, sheep_reproduce, sheep_gain_from_food, self.grid[(x, y)]
-            )
-
-        # Create wolves
-        for _ in range(self.initial_wolves):
-            x = self.random.randrange(self.width)
-            y = self.random.randrange(self.height)
-            energy = self.random.randrange(2 * self.wolf_gain_from_food)
-            Wolf(self, energy, wolf_reproduce, wolf_gain_from_food, self.grid[(x, y)])
-
-        # Create grass patches
-        if self.grass:
-            for cell in self.grid.all_cells:
-                fully_grown = self.random.choice([True, False])
-
-                if fully_grown:
-                    countdown = self.grass_regrowth_time
-                else:
-                    countdown = self.random.randrange(self.grass_regrowth_time)
-
-                patch = GrassPatch(self, fully_grown, countdown)
-                patch.cell = cell
-
-        self.running = True
-        self.datacollector.collect(self)
-
-    def step(self):
-        # This replicated the behavior of the old RandomActivationByType scheduler
-        # when using step(shuffle_types=True, shuffle_agents=True).
-        # Conceptually, it can be argued that this should be modelled differently.
-        self.random.shuffle(self.agent_types)
-        for agent_type in self.agent_types:
-            self.agents_by_type[agent_type].shuffle_do("step")
-
-        # collect data
-        self.datacollector.collect(self)
-
-    def run_model(self, step_count=200):
-        for _ in range(step_count):
-            self.step()

mesa/examples/basic/boid_flockers/Readme.md

@@ -1,22 +0,0 @@
-# Boids Flockers
-
-## Summary
-
-An implementation of Craig Reynolds's Boids flocker model. Agents (simulated birds) try to fly towards the average position of their neighbors and in the same direction as them, while maintaining a minimum distance. This produces flocking behavior.
-
-This model tests Mesa's continuous space feature, and uses numpy arrays to represent vectors.
-
-## How to Run
-
-* To launch the visualization interactively, run ``solara run app.py`` in this directory.It will automatically open a browser page.
-
-## Files
-
-* [model.py](model.py): Ccntains the Boid Model
-* [agents.py](agents.py): Contains the Boid agent
-* [app.py](app.py): Solara based Visualization code.
-
-## Further Reading
-
-The following link can be visited for more information on the boid flockers model:
-https://cs.stanford.edu/people/eroberts/courses/soco/projects/2008-09/modeling-natural-systems/boids.html

mesa/examples/basic/boid_flockers/agents.py

@@ -1,71 +0,0 @@
-import numpy as np
-
-from mesa import Agent
-
-
-class Boid(Agent):
-    """A Boid-style flocker agent.
-
-    The agent follows three behaviors to flock:
-        - Cohesion: steering towards neighboring agents.
-        - Separation: avoiding getting too close to any other agent.
-        - Alignment: try to fly in the same direction as the neighbors.
-
-    Boids have a vision that defines the radius in which they look for their
-    neighbors to flock with. Their speed (a scalar) and direction (a vector)
-    define their movement. Separation is their desired minimum distance from
-    any other Boid.
-    """
-
-    def __init__(
-        self,
-        model,
-        speed,
-        direction,
-        vision,
-        separation,
-        cohere=0.03,
-        separate=0.015,
-        match=0.05,
-    ):
-        """Create a new Boid flocker agent.
-
-        Args:
-            speed: Distance to move per step.
-            direction: numpy vector for the Boid's direction of movement.
-            vision: Radius to look around for nearby Boids.
-            separation: Minimum distance to maintain from other Boids.
-            cohere: the relative importance of matching neighbors' positions
-            separate: the relative importance of avoiding close neighbors
-            match: the relative importance of matching neighbors' headings
-        """
-        super().__init__(model)
-        self.speed = speed
-        self.direction = direction
-        self.vision = vision
-        self.separation = separation
-        self.cohere_factor = cohere
-        self.separate_factor = separate
-        self.match_factor = match
-        self.neighbors = None
-
-    def step(self):
-        """Get the Boid's neighbors, compute the new vector, and move accordingly."""
-        self.neighbors = self.model.space.get_neighbors(self.pos, self.vision, False)
-        n = 0
-        match_vector, separation_vector, cohere = np.zeros((3, 2))
-        for neighbor in self.neighbors:
-            n += 1
-            heading = self.model.space.get_heading(self.pos, neighbor.pos)
-            cohere += heading
-            if self.model.space.get_distance(self.pos, neighbor.pos) < self.separation:
-                separation_vector -= heading
-            match_vector += neighbor.direction
-        n = max(n, 1)
-        cohere = cohere * self.cohere_factor
-        separation_vector = separation_vector * self.separate_factor
-        match_vector = match_vector * self.match_factor
-        self.direction += (cohere + separation_vector + match_vector) / n
-        self.direction /= np.linalg.norm(self.direction)
-        new_pos = self.pos + self.direction * self.speed
-        self.model.space.move_agent(self, new_pos)

mesa/examples/basic/boid_flockers/app.py

@@ -1,58 +0,0 @@
-from mesa.examples.basic.boid_flockers.model import BoidFlockers
-from mesa.visualization import Slider, SolaraViz, make_space_component
-
-
-def boid_draw(agent):
-    if not agent.neighbors:  # Only for the first Frame
-        neighbors = len(agent.model.space.get_neighbors(agent.pos, agent.vision, False))
-    else:
-        neighbors = len(agent.neighbors)
-
-    if neighbors <= 1:
-        return {"color": "red", "size": 20}
-    elif neighbors >= 2:
-        return {"color": "green", "size": 20}
-
-
-model_params = {
-    "population": Slider(
-        label="Number of boids",
-        value=100,
-        min=10,
-        max=200,
-        step=10,
-    ),
-    "width": 100,
-    "height": 100,
-    "speed": Slider(
-        label="Speed of Boids",
-        value=5,
-        min=1,
-        max=20,
-        step=1,
-    ),
-    "vision": Slider(
-        label="Vision of Bird (radius)",
-        value=10,
-        min=1,
-        max=50,
-        step=1,
-    ),
-    "separation": Slider(
-        label="Minimum Separation",
-        value=2,
-        min=1,
-        max=20,
-        step=1,
-    ),
-}
-
-model = BoidFlockers()
-
-page = SolaraViz(
-    model,
-    [make_space_component(agent_portrayal=boid_draw, backend="matplotlib")],
-    model_params=model_params,
-    name="Boid Flocking Model",
-)
-page  # noqa

mesa/examples/basic/boid_flockers/model.py

@@ -1,69 +0,0 @@
-"""Flockers.
-=============================================================
-A Mesa implementation of Craig Reynolds's Boids flocker model.
-Uses numpy arrays to represent vectors.
-"""
-
-import numpy as np
-
-import mesa
-from mesa.examples.basic.boid_flockers.agents import Boid
-
-
-class BoidFlockers(mesa.Model):
-    """Flocker model class. Handles agent creation, placement and scheduling."""
-
-    def __init__(
-        self,
-        seed=None,
-        population=100,
-        width=100,
-        height=100,
-        vision=10,
-        speed=1,
-        separation=1,
-        cohere=0.03,
-        separate=0.015,
-        match=0.05,
-    ):
-        """Create a new Flockers model.
-
-        Args:
-            population: Number of Boids
-            width, height: Size of the space.
-            speed: How fast should the Boids move.
-            vision: How far around should each Boid look for its neighbors
-            separation: What's the minimum distance each Boid will attempt to
-                    keep from any other
-            cohere, separate, match: factors for the relative importance of
-                    the three drives.
-        """
-        super().__init__(seed=seed)
-        self.population = population
-        self.vision = vision
-        self.speed = speed
-        self.separation = separation
-
-        self.space = mesa.space.ContinuousSpace(width, height, True)
-        self.factors = {"cohere": cohere, "separate": separate, "match": match}
-        self.make_agents()
-
-    def make_agents(self):
-        """Create self.population agents, with random positions and starting headings."""
-        for _ in range(self.population):
-            x = self.random.random() * self.space.x_max
-            y = self.random.random() * self.space.y_max
-            pos = np.array((x, y))
-            direction = np.random.random(2) * 2 - 1
-            boid = Boid(
-                model=self,
-                speed=self.speed,
-                direction=direction,
-                vision=self.vision,
-                separation=self.separation,
-                **self.factors,
-            )
-            self.space.place_agent(boid, pos)
-
-    def step(self):
-        self.agents.shuffle_do("step")