Package org.evoludo.simulator.modules

Class EcoPGG

Object
Module
Discrete
EcoPGG
All Implemented Interfaces:
Runnable, IBS.HasIBS, IBS.HasIBS.DGroups, IBS.HasIBS.DPairs, MilestoneListener, Model.HasDE, Model.HasDE.DGroups, Model.HasDE.EM, Model.HasDE.ODE, Model.HasDE.PDE, Model.HasDE.PDEADV, Model.HasDE.PDERD, Model.HasDE.RK5, Model.HasDE.SDE, Features, Features.Groups, Features.Pairs, Features.Payoffs, HasHistogram, HasHistogram.Degree, HasHistogram.Fitness, HasHistogram.StatisticsStationary, HasMean, HasMean.Fitness, HasMean.Traits, HasPhase2D, HasPop2D, HasPop2D.Fitness, HasPop2D.Traits, HasPop3D, HasPop3D.Fitness, HasPop3D.Traits, HasS3, CLOProvider
public class EcoPGG extends Discrete implements Features.Payoffs, IBS.HasIBS.DGroups, Model.HasDE.DGroups, Model.HasDE.EM, Model.HasDE.RK5, Model.HasDE.SDE, Model.HasDE.PDERD, Model.HasDE.PDEADV, HasPop2D.Traits, HasPop3D.Traits, HasMean.Traits, HasS3, HasPhase2D, HasPop2D.Fitness, HasPop3D.Fitness, HasMean.Fitness, HasHistogram.Fitness, HasHistogram.Degree, HasHistogram.StatisticsStationary
Cooperation in ecological public goods interactions.
Author:
Christoph Hauert

  • Field Details

    • DEFECT

      public static final int DEFECT
      The trait (and index) value of defectors.
      See Also:

    • COOPERATE

      public static final int COOPERATE
      The trait (and index) value of cooperators.
      See Also:

    • interest

      double interest
      The multiplication factor of the public good.

    • cost

      double cost
      The cost of cooperation or the individual contribution to the public good.

    • payLoneCoop

      double payLoneCoop
      The payoff to lone cooperators.

    • payLoneDefect

      double payLoneDefect
      The payoff to lone defectors.

    • map

      EcoPGG.EcoPGGMap map
      The map for translating the model data into 2D phase plane representation.

    • cloInterest

      public final CLOption cloInterest
      Command line option to set the multiplication factor for public good interactions.

    • cloCost

      public final CLOption cloCost
      Command line option to set the cost of cooperation, i.e. contributions to the public good.

    • cloLoneCooperator

      public final CLOption cloLoneCooperator
      Command line option to set the payoff to cooperators that failed to find any interaction partners.

    • cloLoneDefector

      public final CLOption cloLoneDefector
      Command line option to set the payoff to defectors that failed to find any interaction partners.

  • Constructor Details

    • EcoPGG

      public EcoPGG(EvoLudo engine)
      Create a new instance of the module for ecological public goods games.
      Parameters:
      engine - the manager of modules and pacemaker for running the model

  • Method Details

    • load

      public void load()
      Description copied from class: Module
      Load new module and perform basic initializations.
      Overrides:
      load in class Discrete
      See Also:

    • getKey

      public String getKey()
      Description copied from class: Module
      Returns identifier of the active module. For example, 2x2 games in TBT return "2x2". This corresponds to the argument for the --module option to load a particular module. The default is to use the class name.
      Overrides:
      getKey in class Module
      Returns:
      the identifying key of this module

    • getAuthors

      public String getAuthors()
      Description copied from class: Module
      Returns a string with information about the authors of the module.
      Overrides:
      getAuthors in class Module
      Returns:
      the names of the authors

    • getTitle

      public String getTitle()
      Description copied from interface: Features
      Returns title of active module, e.g. 2x2 games in TBT returns "2x2 Games".
      Specified by:
      getTitle in interface Features
      Returns:
      the title of active module

    • getMinPayoff

      public double getMinPayoff()
      Description copied from interface: Features.Payoffs
      Calculates and returns the minimum payoff/score of an individual. This value is important for converting payoffs/scores into probabilities, for scaling graphical output and some optimizations.
      Specified by:
      getMinPayoff in interface Features.Payoffs
      Returns:
      the minimum payoff/score
      See Also:

    • getMaxPayoff

      public double getMaxPayoff()
      Description copied from interface: Features.Payoffs
      Calculates and returns the maximum payoff/score of an individual. This value is important for converting payoffs/scores into probabilities, for scaling graphical output and some optimizations.
      Specified by:
      getMaxPayoff in interface Features.Payoffs
      Returns:
      the maximum payoff/score
      See Also:

    • getMonoPayoff

      public double getMonoPayoff(int type)
      Description copied from class: Discrete
      Calculate and return the payoff/score of individuals in monomorphic populations with trait type.

      Note: Optional implementation. Returns Double#NaN if not defined or not implemented.

      Overrides:
      getMonoPayoff in class Discrete
      Parameters:
      type - the index of the trait
      Returns:
      payoff/score in monomorphic population with trait type

    • getDependent

      public int getDependent()
      Description copied from interface: Model.HasDE
      For replicator dynamics the frequencies of all traits must sum up to one. Hence, for nTraits traits there are only nTraits-1 degrees of freedom. The index returned by getDependent() marks the one rate of change that is derived from all the others.

      Notes:

      • Dependent traits are used by models where the frequencies of all types must sum up to one.
      • Density modules do not have dependent traits and getDependent() should return -1.
      • Currently differential equations implementations are only provided for Discrete modules.
      Specified by:
      getDependent in interface Model.HasDE
      Returns:
      the index of the dependent trait (or -1 if there is none)

    • mixedScores

      public void mixedScores(int[] traitCount, int n, double[] traitScore)
      Calculate the average payoff/score in a finite population with the number of each trait provided in count for interaction groups of size n. The payoffs/scores for each of the nTraits traits must be stored and returned in the array traitScores.

      Notes:

      For payoff calculations:
      • each trait sees one less of its own type in its environment
      • the size of the environment is nPopulation-1
      • the fact that the payoff of each trait does not depend on its own type simplifies things
      If explicit calculations of the well-mixed scores are not available, interactions with everyone in well-mixed populations should be checked for and excluded with a warning in IBS.check() (see IBSMCPopulation for an example).

      Important:

      Must be overridden and implemented in subclasses that define game interactions in well-mixed populations where individuals interact with everyone else. Computationally it is not feasible to cover this scenario with IBS.HasIBS.DPairs.pairScores(int, int[], double[]) or IBS.HasIBS.DGroups.groupScores(int[], double[]), respectively.

      Proper sampling in finite populations (c.f. CDL): \begin{align*} f_L =& \sigma\\ f_D =& \frac{\binom z{N-1}}{\binom{M-1}{N-1}}\sigma+r\frac x{M-z-1}\\ & \left(1-\frac 1{N(M-z)} \left( M-(z-N+1)\frac{\binom z{N-1}}{\binom{M-1}{N-1}}\right)\right) c\\ f_C =& f_d-F(z)c\\ F(z) =& 1-\frac rN\frac{M-N}{M-z-1}+\frac{\binom z{N-1}}{\binom{M-1}{N-1}}\\ & \left(\frac rN \frac{z+1}{M-z-1}+r\frac{M-z-2}{M-z-1}-1\right) \end{align*}

      Specified by:
      mixedScores in interface IBS.HasIBS.DGroups
      Parameters:
      traitCount - number of individuals for each trait
      n - interaction group size
      traitScore - array for returning the payoffs/scores of each trait

    • avgScores

      public void avgScores(double[] dens, int n, double[] avgscores)
      Description copied from interface: Model.HasDE.DGroups
      Calculate the average payoff for the frequency of traits specified in the array state for interactions in groups of size n. The average payoffs for each of the nTraits traits must be stored and returned in the array scores.
      Specified by:
      avgScores in interface Model.HasDE.DGroups
      Parameters:
      dens - the frequency/density of each trait
      n - the size of interaction groups
      avgscores - the array for storing the average payoffs/scores of each trait

    • pairScores

      public double pairScores(int me, int[] traitCount, double[] traitScore)
      Description copied from interface: IBS.HasIBS.DPairs
      Calculate and return total (accumulated) payoff/score for pairwise interactions of the focal individual with trait me against opponents with different traits. The respective numbers of each of the nTraits opponent traits are provided in the array tCount. The payoffs/scores for each of the nTraits opponent traits must be stored and returned in the array tScore.

      Important: must be overridden and implemented in subclasses that define game interactions between pairs of individuals (nGroup=2, pairwise=true), otherwise see IBS.HasIBS.DGroups.groupScores(int[], double[]).

      Specified by:
      pairScores in interface IBS.HasIBS.DPairs
      Parameters:
      me - the trait index of the focal individual
      traitCount - number of opponents with each trait
      traitScore - array for returning the scores of each opponent trait
      Returns:
      score of focal individual me accumulated over all interactions

    • groupScores

      public void groupScores(int[] traitCount, double[] traitScore)
      Description copied from interface: IBS.HasIBS.DGroups
      Calculate the payoff/score for interactions in groups consisting of traits with respective numbers given in the array traitCount. The interaction group size is given by the sum over traitCount[i] for i=0,1,...,nTraits. The payoffs/scores for each of the nTraits traits must be stored and returned in the array traitScore.

      Important: must be overridden and implemented in subclasses that define game interactions among groups of individuals (for groups with sizes nGroup>2, otherwise see IBS.HasIBS.DPairs.pairScores(int, int[], double[])).

      Specified by:
      groupScores in interface IBS.HasIBS.DGroups
      Parameters:
      traitCount - group composition given by the number of individuals with each trait
      traitScore - array for returning the payoffs/scores of each trait

    • setCostCoop

      public void setCostCoop(double aValue)
      Set the cost of cooperation.
      Parameters:
      aValue - the cost of cooperation

    • getCostCoop

      public double getCostCoop()
      Get the cost of cooperation.
      Returns:
      the cost of cooperation

    • setInterest

      public void setInterest(double aValue)
      Set the multiplication factor of the linear public goods game.
      Parameters:
      aValue - the new multiplication factor

    • getInterest

      public double getInterest()
      Get the multiplication factor of the linear public goods game.
      Returns:
      the multiplication factor

    • setPayLoneCoop

      public void setPayLoneCoop(double aValue)
      Set the payoff to lone cooperators. Defaults to loner payoff.
      Parameters:
      aValue - the payoff to lone cooperators.

    • getPayLoneCoop

      public double getPayLoneCoop()
      Get the payoff to lone cooperators.
      Returns:
      the payoff to lone cooperators.

    • setPayLoneDefect

      public void setPayLoneDefect(double aValue)
      Set the payoff to lone defectors. Defaults to loner payoff.
      Parameters:
      aValue - the payoff to lone defectors.

    • getPayLoneDefect

      public double getPayLoneDefect()
      Get the payoff to lone defectors.
      Returns:
      the payoff to lone defectors.

    • getPhase2DMap

      public HasPhase2D.Data2Phase getPhase2DMap()
      Description copied from interface: HasPhase2D
      Get the map that transforms the data of the module to a 2D phase plane (projection).
      Specified by:
      getPhase2DMap in interface HasPhase2D
      Returns:
      the map

    • collectCLO

      public void collectCLO(CLOParser parser)
      Description copied from interface: CLOProvider
      All providers of command line options must implement this method to collect their options.

      Each command line option is (uniquely) identified by it's name (see CLOption.getName()), which corresponds to the long version of the option. If an attempt is made to add an option with a name that already exists, the parser issues a warning and ignores the option. Thus, in general, implementing subclasses should first register their options and call super.collectCLO(CLOParser) at the end such that subclasses are able to override command line options specified in a parental class.

      Override this method in subclasses to add further command line options. Subclasses must make sure that they include a call to super.

      Specified by:
      collectCLO in interface CLOProvider
      Overrides:
      collectCLO in class Discrete
      Parameters:
      parser - the reference to parser that manages command line options
      See Also: