ODE

All Implemented Interfaces:: Discrete, CLOProvider

Direct Known Subclasses:: PDE, RungeKutta, SDE

public class ODE extends Model implements Discrete

Common base class for all differential equations models. Provides the basic Euler method for the numerical integration of systems of ordinary differential equations.

Note: Currently differential equation models are restricted to discrete strategy sets.

Author:: Christoph Hauert

Nested Class Summary

Nested Classes

Modifier and Type

Class

Description

static interface

ODE.HasDE

Methods that every Module must implement, which advertises numerical solutions based on differential equations.

static interface

ODE.HasODE

Additional methods that must be implemented by Modules that advertise numerical solutions based on ordinary differential equations.

static enum

ODE.InitType

Types of initial configurations.
Field Summary

Fields

Modifier and Type

Field

Description

(package private) double

accuracy

Desired accuracy to determine whether numerical integration has converged or a population has become monomorphic.

final CLOption

cloAdjustedDynamics

Command line option to activate adjusted replicator dynamics (if possible) in ODE models.

final CLOption

cloDEAccuracy

Command line option to set the desired accuracy of ODE calculations as criteria for convergence and whether population is monomorphic.

final CLOption

cloDEdt

Command line option to set the time increment dt in DE models.

final CLOption

cloInit

Command line option to set the initial configuration in ODE/SDE models.

final CLOption

cloTimeReversed

Command line option to set the number of generations between reports for EvoLudo.modelNext().

(package private) int[]

dependents

Array containing the indices of the dependent trait in each species.

(package private) double[]

dstate

Pointer to temporarily store a reference to the current state yt.

(package private) double

dt

Discretization of time increment for continuous time models.

(package private) double

dtTaken

The size of step taken by integrator.

(package private) double

dtTry

The attempted size of next step to take.

(package private) double[]

dyt

The frequency/density increments of the ODE between the current state yt and the previous state yout.

(package private) boolean

forward

The flag is true if the numerical integration moves forward in time.

(package private) double[]

ft

The current fitness of all traits in the ODE.

(package private) int[]

idxSpecies

Array containing indices that delimit individual species in the ODE state variables.

protected ODE.InitType[]

initType

Type of initial configuration for each species.

(package private) double[]

invFitRange

Array containing the inverse of the fitness range: 1.0/(maxFitness - minFitness) for each species.

(package private) boolean

isAdjustedDynamics

true if the adjusted replicator dynamics should be applied.

protected boolean

monoStop

Set to true to requests that the numerical integration stops once the population reaches a monomorphic state.

(package private) Mutation.Discrete[]

mutation

Array containing the mutation rates/probabilities for each species.

(package private) String[]

names

The names of the traits (dynamical variables) in the ODE.

(package private) int

nDim

Total number of traits (dynamical variables) in the ODE.

(package private) double[]

rates

Array containing the update rates for each species.

(package private) double[]

staticfit

For Modules with static fitness, e.g.

(package private) double[]

y0

The initial frequencies/densities of the ODE.

(package private) double[]

yout

The previous frequencies/densities of the ODE.

(package private) double[]

yt

The current frequencies/densities of the ODE.

Fields inherited from class Model
cloSamples, cloTimeRelax, cloTimeStep, cloTimeStop, connect, converged, engine, fixData, isMultispecies, isRelaxing, logger, mode, nSamples, nSpecies, nStatisticsFailed, nStatisticsSamples, rng, species, statisticsSampleNew, time, timeRelax, timeStep, timeStop, type
Constructor Summary

Constructors

Constructor

Description

ODE(EvoLudo engine)

Constructs a new model for the numerical integration of the system of ordinary differential equations representing the dynamics specified by the Module module using the EvoLudo pacemaker engine to control the numerical evaluations.
Method Summary

Modifier and Type

Method

Description

boolean

check()

Check consistency of parameters and adjust if necessary (and possible).

protected boolean

checkConvergence(double dist2)

Helper method to check whether the squared distance dist2 qualifies to signal convergence.

void

collectCLO(CLOParser parser)

All providers of command line options must implement this method to collect their options.

protected double

deStep(double step)

Attempts a numerical integration step of size step.

(package private) void

encodeFitness(StringBuilder plist)

Encodes the fitness of the model in the form of a plist string.

void

encodeState(StringBuilder plist)

Encode the state of the model in a plist inspired XML string.

(package private) void

encodeStrategies(StringBuilder plist)

Encodes state of the model in the form of a plist string.

double

getAccuracy()

Gets the numerical accuracy for determining convergence.

protected void

getDerivatives(double t, double[] state, double[] fitness, double[] change)

Calculate the rates of change for all species in state at time given the fitness fitness and returned in change.

double

getDt()

Gets the discretization of time increments in continuous time models.

<T> void

getFitnessData(int id, T[] colors, ColorMap.Gradient1D<T> colorMap)

Translates fitness data into colors using ColorMap colorMap.

void

getFitnessHistogramData(int id, double[][] bins)

Generates a histogram of fitness data and returns the result in the provided array bins.

void

getInitialTraits(double[] init)

Collect and return initial trait values for all species.

void

getInitialTraits(int id, double[] init)

Return initial trait values for species with ID id.

double

getMaxFitness(int id)

Calculates and returns the absolute fitness maximum.

double

getMaxScore(int id)

Returns the maximum score that individuals of species with ID id can achieve in this model.

boolean

getMeanFitness(double[] mean)

Gets the mean fitness values for traits in all species.

boolean

getMeanFitness(int id, double[] mean)

Gets the mean fitness values for species with ID id.

boolean

getMeanTraits(double[] mean)

Collect and return mean trait values for all species.

boolean

getMeanTraits(int id, double[] mean)

Return mean trait values for species with ID id.

double

getMinFitness(int id)

Calculates and returns the absolute fitness minimum.

double

getMinScore(int id)

Returns the minimum score that individuals of species with ID id can achieve in this model.

double

getMonoScore(int id, int idx)

Calculate and return the payoff/score of individuals in monomorphic populations with trait/strategy idx but also deals with payoff accounting (averaged versus accumulated).

int

getNMean()

Return the number of mean values for this model including all species (for traits or fitness).

int

getNMean(int id)

Return the number of mean trait values for species with ID id.

String

getStatus()

Returns status message from model.

<T> void

getTraitData(int id, T[] colors, ColorMap<T> colorMap)

Unused interface method.

void

init()

Milestone: Initialize this model

private void

init(boolean doRandom)

Helper method to set the intital state of the model.

boolean

isDensity()

Return whether this DE model tracks frequencies or densities.

boolean

isMonomorphic()

Check if population is monomorphic.

private boolean

isMonomorphic(int start, int stop, int dep, int vac)

Helper method to check if the species with trait indices start through stop is monomorphic.

boolean

isTimeReversed()

Checks if time is reversed.

void

load()

Milestone: Load this model and allocate resources (if applicable).

boolean

next()

Advance model by one step.

protected void

normalizeState(double[] state)

Convenience method to normalize state in frequency based models.

boolean

parse(String arg)

Parse initializer string arg.

boolean

permitsTimeReversal()

Checks if time reversal is permitted.

void

reset()

Milestone: Reset this model

(package private) boolean

restoreFitness(Plist plist)

Restores the fitness encoded in plist.

boolean

restoreState(Plist plist)

Restore the state encoded in the plist inspired map of key, value-pairs.

(package private) boolean

restoreStrategies(Plist plist)

Restores the state encoded in plist.

void

setAccuracy(double acc)

Sets the desired accuracy for determining convergence.

void

setAdjustedDynamics(boolean adjusted)

Sets whether adjusted dynamics is requested.

void

setDt(double deltat)

Sets the discretization of time increments in continuous time models.

boolean

setInitialTraits(double[] init)

Set initial traits in one or all species.

boolean

setInitialTraits(int id, double[] init)

Set initial trait values for species with ID id.

void

setTimeReversed(boolean reversed)

Request time reversal if reversed==true.

void

unload()

Milestone: Unload this model and free resources (if applicable).

void

update()

Update this model.

protected double

updateBest(Module mod, double[] state, double[] fitness, int nGroup, int index, double[] change)

Implementation of player update PlayerUpdate.Type.BEST.

protected double

updateBestResponse(Module mod, double[] state, double[] fitness, int nGroup, int index, double[] change)

Implementation of the player update PlayerUpdate.Type.BEST_RESPONSE.

protected double

updateEcology(Module mod, double[] state, double[] fitness, int nGroup, int index, double[] change)

Implementation of the player updates for modules with populations of variable size (density based or with vacant 'space', i.e.

protected double

updateImitate(Module mod, double[] state, double[] fitness, int nGroup, int index, double[] change)

Implementation of the player update PlayerUpdate.Type.IMITATE.

protected double

updateImitateBetter(Module mod, double[] state, double[] fitness, int nGroup, int index, double[] change)

Implementation of the player update PlayerUpdate.Type.IMITATE_BETTER.

protected double

updateProportional(Module mod, double[] state, double[] fitness, int nGroup, int index, double[] change)

Implementation of the player update PlayerUpdate.Type.PROPORTIONAL.

private double

updateReplicate(Module mod, double[] state, double[] fitness, int nGroup, int index, double[] change, double noise)

Helper method to calculate the rate of change for the standard replicator dynamics with different amounts of noise arising from the microscopic update rule.

protected double

updateThermal(Module mod, double[] state, double[] fitness, int nGroup, int index, double[] change)

Implementation of the player update PlayerUpdate.Type.THERMAL.

Methods inherited from class Model
debugStep, getCounter, getFitnessNameAt, getFixationData, getLogger, getMeanFitnessAt, getMeanName, getMeanNames, getMeanTraitAt, getMode, getNextHalt, getNSamples, getNSpecies, getNStatisticsFailed, getNStatisticsSamples, getScoreNameAt, getSpecies, getTime, getTimeRelax, getTimeStep, getTimeStop, getTraitNameAt, getType, hasConverged, initStatisticsFailed, initStatisticsSample, isConnected, isContinuous, isDE, isIBS, isODE, isPDE, isRelaxing, isSDE, isType, permitsDebugStep, permitsMode, permitsSampleStatistics, permitsUpdateStatistics, readStatisticsSample, relax, requestMode, resetStatisticsSample, setMode, setNSamples, setTimeRelax, setTimeStep, setTimeStop, useScheduling

Methods inherited from class Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Methods inherited from interface CLOProvider
adjustCLO

Field Details
- dt
  
  double dt
  
  Discretization of time increment for continuous time models. This is the attempted size of next step to take.
  Important: always positive regardless of direction of integration.
  See Also:
  
  dtTaken
  
  forward
  
  cloDEdt
  
  setDt(double)
- dtTry
  
  double dtTry
  
  The attempted size of next step to take. In ODE this is always equal to dt but for more sophisticated integrators, RungeKutta for example, the attempted step size may get adjusted.
  Important: always positive regardless of direction of integration.
  See Also:
  
  next()
  
  deStep(double)
- dtTaken
  
  double dtTaken
  
  The size of step taken by integrator. This can be less than the step size attempted, dtTaken ≤ dtTry.
  Important: always positive regardless of direction of integration.
  See Also:
  
  deStep(double)
- forward
  
  boolean forward
  
  The flag is true if the numerical integration moves forward in time.
  See Also:
  
  setTimeReversed(boolean)
- nDim
  
  int nDim
  
  Total number of traits (dynamical variables) in the ODE.
- y0
  
  double[] y0
  
  The initial frequencies/densities of the ODE. In multi-species modules the initial states of each species are concatenated into this single array. The initial frequencies/densities of the first species are stored in yt[0] through yt[n1] where n1 denotes the number of traits in the first species. The initial frequencies/densities of the second species are stored in yt[n1+1] through yt[n1+n2] where n2 denotes the number of traits in the second species, etc.
- yt
  
  double[] yt
  
  The current frequencies/densities of the ODE. In multi-species modules the current states of each species are concatenated into this single array. The current frequencies/densities of the first species are stored in yt[0] through yt[n1] where n1 denotes the number of traits in the first species. The current frequencies/densities of the second species are stored in yt[n1+1] through yt[n1+n2] where n2 denotes the number of traits in the second species, etc.
- ft
  
  double[] ft
  
  The current fitness of all traits in the ODE. In multi-species modules the current fitness of each species are concatenated into this single array. The current fitness of the first species are stored in ft[0] through ft[n1] where n1 denotes the number of traits in the first species. The current fitness of the second species are stored in ft[n1+1] through ft[n1+n2] where n2 denotes the number of traits in the second species, etc.
- dyt
  
  double[] dyt
  
  The frequency/density increments of the ODE between the current state yt and the previous state yout. In multi-species modules the increments of each species are concatenated into this single array. The increments in the first species are stored in dyt[0] through dyt[n1] where n1 denotes the number of traits in the first species. The increments in the second species are stored in dyt[n1+1] through dyt[n1+n2] where n2 denotes the number of traits in the second species, etc.
- yout
  
  double[] yout
  
  The previous frequencies/densities of the ODE. In multi-species modules the previous states of each species are concatenated into this single array. The previous frequencies/densities of the first species are stored in yout[0] through yout[n1] where n1 denotes the number of traits in the first species. The current frequencies/densities of the second species are stored in yout[n1+1] through yout[n1+n2] where n2 denotes the number of traits in the second species, etc.
- dstate
  
  double[] dstate
  
  Pointer to temporarily store a reference to the current state yt. This affects only multi-species modules because fitness calculations for the derivatives may need access to the state of the other populations. To allow this getMeanTraits(int, double[]) uses dstate while the derivative calculations are in progress (dstate != null). Otherwise yt is used.
- staticfit
  
  double[] staticfit
  
  For Modules with static fitness, e.g. the original Moran process Moran, this array stores the fitness of all types for efficiency reasons. In multi-species modules the static fitness of each species are concatenated into this single array. The fitness of the first species are stored in staticfit[0] through staticfit[n1] where n1 denotes the number of traits in the first species. The static fitness of the second species are stored in staticfit[n1+1] through staticfit[n1+n2] where n2 denotes the number of traits in the second species, etc. If only some species have static fitness only those are stored here. All other entries in the array are unused but the size remains unchanged and is always the same as e.g. yt or null if no species has static fitness.
- initType
  
  protected ODE.InitType[] initType
  
  Type of initial configuration for each species.
  See Also:
  
  cloInit
- idxSpecies
  
  int[] idxSpecies
  
  Array containing indices that delimit individual species in the ODE state variables. In a module with N species the array has N+1 entries. For example, for a single species module with n1 traits idxSpecies = int[] { 0, n1 } holds, whereas for a two species module with n1 and n2 traits, respectively, idxSpecies = int[] { 0, n1, n1+n2 } holds, and for three species idxSpecies = int[] { 0, n1, n1+n2, n1+n2+n3 } etc. In other words, the first entry is always zero and the last always contains the total number of dynamical variables in this ODE, idxSpecies[N]==nDim. This means that, e.g. the frequencies/densities referring to species i are stored in yt[idxSpecies[i]] through yt[idxSpecies[i+1]].
  See Also:
  
  nDim
- rates
  
  double[] rates
  
  Array containing the update rates for each species. Determines the relative update rate between species, Only relevant in multi-species modules.
  See Also:
  
  Module.getSpeciesUpdateRate()
- mutation
  
  Mutation.Discrete[] mutation
  
  Array containing the mutation rates/probabilities for each species.
  See Also:
  
  Module.getMutation()
- dependents
  
  int[] dependents
  
  Array containing the indices of the dependent trait in each species. Dependent traits make only sense in replicator type model with frequencies, i.e. normalized states. The dependent trait is the one that gets derived from the changes in all others in order to maintain normalization.
  See Also:
  
  Module.getDependent()
- invFitRange
  
  double[] invFitRange
  
  Array containing the inverse of the fitness range: 1.0/(maxFitness - minFitness) for each species. This is used to normalize imitation rules of players.
  See Also:
  
  PlayerUpdate.Type.IMITATE
- names
  
  String[] names
  
  The names of the traits (dynamical variables) in the ODE. In multi-species modules all names are concatenated into this single array. The names of the first species are stored in names[0] through names[n1] where n1 denotes the number of traits in the first species. The names of the second species are stored in names[n1+1] through names[n1+n2] where n2 denotes the number of traits in the second species, etc.
- monoStop
  
  protected boolean monoStop
  
  Set to true to requests that the numerical integration stops once the population reaches a monomorphic state.
  See Also:
  
  Discrete.cloMonoStop
  
  Discrete.getMonoStop()
  
  isMonomorphic()
  
  checkConvergence(double)
  
  setAccuracy(double)
- isAdjustedDynamics
  
  boolean isAdjustedDynamics
  
  true if the adjusted replicator dynamics should be applied. Compared to the standard replicator equation nothing changes in terms of trajectories, location of fixed points or their stability. However, the speed of evolutionary changes depend inversely proportional on the overall fitness of the population(s) such that changes happen rapidly in a population with low fitness but slowly in populations with high fitness. The adjusted replicator dynamics requires that all payoffs are positive.
  See Also:
  
  setAdjustedDynamics(boolean)
  
  cloAdjustedDynamics
- accuracy
  
  double accuracy
  
  Desired accuracy to determine whether numerical integration has converged or a population has become monomorphic.
  See Also:
  
  cloDEAccuracy
  
  setAccuracy(double)
  
  Model.hasConverged()
  
  isMonomorphic()
- cloDEdt
  
  public final CLOption cloDEdt
  
  Command line option to set the time increment dt in DE models. If the requested dt turns out to be too big, e.g. due to diffusion in PDE, it is reduced appropriately. For RungeKutta this represents the initial step.
  See Also:
  
  dt
  
  setDt(double)
- cloInit
  
  public final CLOption cloInit
  
  Command line option to set the initial configuration in ODE/SDE models.
  Note: PDE models use their own set of initial configurations.
  See Also:
  
  ODE.InitType
  
  PDE.InitType
- cloAdjustedDynamics
  
  public final CLOption cloAdjustedDynamics
  
  Command line option to activate adjusted replicator dynamics (if possible) in ODE models.
  See Also:
  
  isAdjustedDynamics
  
  setAdjustedDynamics(boolean)
- cloDEAccuracy
  
  public final CLOption cloDEAccuracy
  
  Command line option to set the desired accuracy of ODE calculations as criteria for convergence and whether population is monomorphic.
  See Also:
  
  accuracy
  
  setAccuracy(double)
  
  Model.hasConverged()
  
  isMonomorphic()
- cloTimeReversed
  
  public final CLOption cloTimeReversed
  
  Command line option to set the number of generations between reports for EvoLudo.modelNext().
Constructor Details
- ODE
  
  public ODE(EvoLudo engine)
  
  Constructs a new model for the numerical integration of the system of ordinary differential equations representing the dynamics specified by the Module module using the EvoLudo pacemaker engine to control the numerical evaluations. The integrator implements Euler's method (fixed step size).
  
  Parameters:
  
  engine - the pacemaker for running the model
Method Details
- load
  
  public void load()
  
  Description copied from class: Model
  
  Milestone: Load this model and allocate resources (if applicable).
  Overrides:
  
  load in class Model
  
  See Also:
  
  MilestoneListener.modelLoaded()
- unload
  
  public void unload()
  
  Description copied from class: Model
  
  Milestone: Unload this model and free resources (if applicable).
  Overrides:
  
  unload in class Model
  
  See Also:
  
  MilestoneListener.modelUnloaded()
- check
  
  public boolean check()
  
  Description copied from class: Model
  
  Check consistency of parameters and adjust if necessary (and possible). All issues and modifications should be reported through logger. Some parameters can be adjusted while the model remains active or even while running, whereas others require a reset. An example of the former category is in general simple adjustments of payoffs, while an example of the latter category is a change of the population structure.
  Overrides:
  
  check in class Model
  
  Returns:
  
  true if reset required
  
  See Also:
  
  Logger
- reset
  
  public void reset()
  
  Description copied from class: Model
  
  Milestone: Reset this model
  Overrides:
  
  reset in class Model
  
  See Also:
  
  MilestoneListener.modelDidReset()
- init
  
  public void init()
  
  Description copied from class: Model
  
  Milestone: Initialize this model
  Overrides:
  
  init in class Model
  
  See Also:
  
  MilestoneListener.modelDidInit()
- setDt
  
  public void setDt(double deltat)
  
  Sets the discretization of time increments in continuous time models.
  Note: Some models may need to adjust, i.e. reduce, deltat (see PDE.checkDt()) or choose a variable step size in which case deltat is ignored (see RungeKutta.getAutoDt()).
  
  Parameters:
  
  deltat - the time increments in continuous time models.
- getDt
  
  public double getDt()
  
  Gets the discretization of time increments in continuous time models.
  Note: This may be different from dt set through setDt(double) if the model required adjustments.
  
  Returns:
  
  the time increment in continuous time models.
- isDensity
  
  public boolean isDensity()
  
  Return whether this DE model tracks frequencies or densities. Returns false (i.e. frequency based model) by default.
  
  Returns:
  
  true if state refers to densities.
- setInitialTraits
  
  public boolean setInitialTraits(double[] init)
  
  Description copied from class: Model
  
  Set initial traits in one or all species.
  NOTE: this is a convenience method for multi-species modules to set inital states efficiently for interactions with GUI.
  
  Overrides:
  
  setInitialTraits in class Model
  
  Parameters:
  
  init - the array with the initial trait values
  
  Returns:
  
  true if initial traits successfully set
- getInitialTraits
  
  public void getInitialTraits(double[] init)
  
  Description copied from class: Model
  
  Collect and return initial trait values for all species.
  NOTE: this is a convenience method for multi-species modules to retrieve states efficiently for further processing or visualization.
  
  Specified by:
  
  getInitialTraits in class Model
  
  Parameters:
  
  init - the array for storing the initial trait values
- setInitialTraits
  
  public boolean setInitialTraits(int id, double[] init)
  
  Description copied from class: Model
  
  Set initial trait values for species with ID id.
  
  Overrides:
  
  setInitialTraits in class Model
  
  Parameters:
  
  id - the species identifier
  
  init - the array with the initial trait values
  
  Returns:
  
  true if initial traits successfully set
- getInitialTraits
  
  public void getInitialTraits(int id, double[] init)
  
  Description copied from class: Model
  
  Return initial trait values for species with ID id.
  
  Specified by:
  
  getInitialTraits in class Model
  
  Parameters:
  
  id - the species identifier
  
  init - the array for storing the initial trait values
- getMonoScore
  
  public double getMonoScore(int id, int idx)
  
  Description copied from interface: Discrete
  
  Calculate and return the payoff/score of individuals in monomorphic populations with trait/strategy idx but also deals with payoff accounting (averaged versus accumulated).
  Specified by:
  
  getMonoScore in interface Discrete
  
  Parameters:
  
  id - the id of the population for multi-species models
  
  idx - trait/strategy
  
  Returns:
  
  payoff/score in monomorphic population with trait/strategy idx. Returns NaN if scores ill defined
  
  See Also:
  
  Discrete.getMonoGameScore(int)
- getNMean
  
  public int getNMean()
  
  Description copied from class: Model
  
  Return the number of mean values for this model including all species (for traits or fitness). By default this returns the number of traits in the module. Models that report a different number of mean traits must override this method
  
  Specified by:
  
  getNMean in class Model
  
  Returns:
  
  the number of mean values for all species
- getNMean
  
  public int getNMean(int id)
  
  Description copied from class: Model
  
  Return the number of mean trait values for species with ID id.
  
  Specified by:
  
  getNMean in class Model
  
  Parameters:
  
  id - the species identifier
  
  Returns:
  
  the number of mean values for species id
- getMeanTraits
  
  public boolean getMeanTraits(int id, double[] mean)
  
  Description copied from class: Model
  
  Return mean trait values for species with ID id.
  
  Specified by:
  
  getMeanTraits in class Model
  
  Parameters:
  
  id - the species identifier
  
  mean - the array for storing the mean trait values
  
  Returns:
  
  true if this and the previous data point should be connected, i.e. no reset had been requested in the mean time.
- getMeanTraits
  
  public boolean getMeanTraits(double[] mean)
  
  Description copied from class: Model
  
  Collect and return mean trait values for all species.
  NOTE: this is a convenience method for multi-species modules to retrieve states efficiently for further processing or visualization.
  
  Specified by:
  
  getMeanTraits in class Model
  
  Parameters:
  
  mean - the array for storing the mean trait values
  
  Returns:
  
  true if this and previous data point should be connected, i.e. no reset had been requested in the mean time.
- getTraitData
  
  public <T> void getTraitData(int id, T[] colors, ColorMap<T> colorMap)
  
  Unused interface method.
  
  Specified by:
  
  getTraitData in class Model
  
  Type Parameters:
  
  T - color data type. Color for PopGraph2D and PopGraph2D as well as MeshLambertMaterial for PopGraph3D
  
  Parameters:
  
  id - the species identifier
  
  colors - the array for storing the colors for individuals
  
  colorMap - the map for translating individual traits into colors
- getMinScore
  
  public double getMinScore(int id)
  
  Description copied from class: Model
  
  Returns the minimum score that individuals of species with ID id can achieve in this model. Takes into account potential adjustments due to population structure and payoff accounting.
  Specified by:
  
  getMinScore in class Model
  
  Parameters:
  
  id - the id of the population for multi-species models
  
  Returns:
  
  the minimum score
  
  See Also:
  
  Module.getMinGameScore()
- getMaxScore
  
  public double getMaxScore(int id)
  
  Description copied from class: Model
  
  Returns the maximum score that individuals of species with ID id can achieve in this model. Takes into account potential adjustments due to population structure and payoff accounting.
  Specified by:
  
  getMaxScore in class Model
  
  Parameters:
  
  id - the id of the population for multi-species models
  
  Returns:
  
  the maximum score
  
  See Also:
  
  Module.getMaxGameScore()
- getMinFitness
  
  public double getMinFitness(int id)
  
  Description copied from class: Model
  Calculates and returns the absolute fitness minimum. This is important to
  
  determine probabilities or rates for adopting the strategy of another player,
  optimize fitness based picking of individuals, and
  scaling graphical output.
  Specified by:
  
  getMinFitness in class Model
  
  Parameters:
  
  id - the id of the population for multi-species models
  
  Returns:
  
  the minimum fitness
  
  See Also:
  
  Model.getMinScore(int id)
- getMaxFitness
  
  public double getMaxFitness(int id)
  
  Description copied from class: Model
  Calculates and returns the absolute fitness maximum. This is important to
  
  determine probabilities or rates for adopting the strategy of another player,
  optimize fitness based picking of individuals, and
  scaling graphical output.
  Specified by:
  
  getMaxFitness in class Model
  
  Parameters:
  
  id - the id of the population for multi-species models
  
  Returns:
  
  the maximum fitness
  
  See Also:
  
  Model.getMaxScore(int id)
- getMeanFitness
  
  public boolean getMeanFitness(int id, double[] mean)
  
  Description copied from class: Model
  
  Gets the mean fitness values for species with ID id. The result is stored and returned in mean. Used by GUI to visualize local dynamics at idx.
  
  Specified by:
  
  getMeanFitness in class Model
  
  Parameters:
  
  id - the species identifier
  
  mean - the array for storing the mean fitness values
  
  Returns:
  
  true if this and the previous data point should be connected, i.e. no reset had been requested in the mean time.
- getMeanFitness
  
  public boolean getMeanFitness(double[] mean)
  
  Description copied from class: Model
  
  Gets the mean fitness values for traits in all species. The result is stored and returned in mean. Used by GUI to visualize the current the state of the model.
  Note: this is a convenience method for multi-species modules to retrieve states efficiently for further processing or visualization.
  
  Specified by:
  
  getMeanFitness in class Model
  
  Parameters:
  
  mean - the array for storing the mean fitness values
  
  Returns:
  
  true if this and the previous data point should be connected, i.e. no reset had been requested in the mean time.
- getFitnessData
  
  public <T> void getFitnessData(int id, T[] colors, ColorMap.Gradient1D<T> colorMap)
  
  Description copied from class: Model
  
  Translates fitness data into colors using ColorMap colorMap. Used by GUI to visualize current state of model.
  
  Specified by:
  
  getFitnessData in class Model
  
  Type Parameters:
  
  T - color data type. Color for PopGraph2D and PopGraph2D as well as MeshLambertMaterial for PopGraph3D
  
  Parameters:
  
  id - the species identifier
  
  colors - the array for storing color values
  
  colorMap - the map to use for translating traits to colors
- getFitnessHistogramData
  
  public void getFitnessHistogramData(int id, double[][] bins)
  
  Description copied from class: Model
  
  Generates a histogram of fitness data and returns the result in the provided array bins. For Discrete modules a fitness histogram is returned for each trait separately. For Continuous modules there is, in general, only a single fitness dimension.
  
  Specified by:
  
  getFitnessHistogramData in class Model
  
  Parameters:
  
  id - the species identifier
  
  bins - the array for storing histogram. For Discrete modules this is always one dimensional
- next
  
  public boolean next()
  Advance model by one step. The details of what happens during one step depends on the models Type as well as its Mode.
  Implementation Notes:
  Before:
  
  yt current state
  ft current fitness
  dyt current derivatives fitness
  dtTry size of time step attempting to make
  After:
  
  yt next state
  ft next fitness
  dyt next derivatives
  yout contains previous state (i.e. yt when entering method)
  stepTaken the time between yt and yout
  Specified by:
  
  next in class Model
  
  Returns:
  
  true if next() can be called again. Typically false is returned if the model requires attention, such as the following conditions:
  
  the model has converged
  the model turned monomorphic (stops only if requested)
  a statistics sample is available
  a preset time has been reached
  
  See Also:
  
  ChangeListener.modelChanged(ChangeListener.PendingAction)
  
  Discrete.setMonoStop(boolean)
- checkConvergence
  
  protected boolean checkConvergence(double dist2)
  Helper method to check whether the squared distance dist2 qualifies to signal convergence.
  Implementation Notes:
  
  ODE's can converge even with non-zero mutation rates
  step size may keep decreasing without ever reaching the accuracy threshold (or reach step). This scenario requires an emergency brake (otherwise the browser becomes completely unresponsive - nasty!). Emergency brake triggered if stepTaken is so small that more than 1/(accuracy * stepTaken) updates are required to complete dt.
  stepTaken < 0 may hold but irrelevant because only the squared value is used.
  Parameters:
  
  dist2 - the squared distance between the current and previous states (y[t+dt]-y[t])².
  
  Returns:
  
  true if convergence criteria passed
- isMonomorphic
  
  public boolean isMonomorphic()
  
  Check if population is monomorphic. Note, in multi-species modules all species need to be monomorphic.
  
  Returns:
  
  true if criteria for monomorphic state passed
- isMonomorphic
  
  private boolean isMonomorphic(int start, int stop, int dep, int vac)
  
  Helper method to check if the species with trait indices start through stop is monomorphic. The species may have dependent trait dep and allow for vacant sites (with index vac).
  
  Parameters:
  
  start - the start index of the species
  
  stop - the stop index of the species
  
  dep - the index of the dependent trait
  
  vac - the index of the vacant trait
  
  Returns:
  
  true if the species is monomorphic
- deStep
  
  protected double deStep(double step)
  
  Attempts a numerical integration step of size step. The baseline are steps of fixed size following Euler's method.
  
  Parameters:
  
  step - the time step to attempt
  
  Returns:
  
  squared distance between this state and previous one, (yt-yout)².
- normalizeState
  
  protected void normalizeState(double[] state)
  
  Convenience method to normalize state in frequency based models. For density models nothing needs to be done.
  
  Parameters:
  
  state - the array that needs to be normalized if appropriate
- getDerivatives
  
  protected void getDerivatives(double t, double[] state, double[] fitness, double[] change)
  
  Calculate the rates of change for all species in state at time given the fitness fitness and returned in change. For replicator models the dynamics depends on the selected type of player updating, see PlayerUpdate.Type, while for modules with variable population sizes (density based or with vaccant 'space' (reproductive opportunities)) the fitness denotes the rate of reproduction moderated by the available 'space'.
  IMPORTANT: parallel processing for PDE's in JRE requires this method to be thread safe.
  Note: adding synchronized to this method would seem to make sense but this results in a deadlock for multiple threads in PDE's and JRE. However, apparently not needed as javascript and java yield the exact same results (after 15k generations!)
  Parameters:
  
  t - the time at which to calculate the derivative
  
  state - the array of frequencies/densities denoting the state population
  
  fitness - the array of fitness values of types in population
  
  change - the array to return the rate of change of each type in the population
  
  See Also:
  
  updateBest(Module, double[], double[], int, int, double[])
  
  updateBestResponse(Module, double[], double[], int, int, double[])
  
  updateEcology(Module, double[], double[], int, int, double[])
  
  updateImitate(Module, double[], double[], int, int, double[])
  
  updateThermal(Module, double[], double[], int, int, double[])
- updateEcology
  
  protected double updateEcology(Module mod, double[] state, double[] fitness, int nGroup, int index, double[] change)
  
  Implementation of the player updates for modules with populations of variable size (density based or with vacant 'space', i.e. reproductive opportunities). In models with varying reproductive opportunities the rate of reproduction is given by the product of the individual's fitness moderated by the available 'space'. This results in the dynamical equation given by $\dot{x} = x_{i} (z \cdot f_{i} - d)$ where $z$ denotes vacant space, $f_{i}$ the fitness of type $i$ and $d$ is the death rate. This works nicely for replicator type equations but may not fit more general dynamical equations.
  
  Parameters:
  
  mod - the module representing the current species
  
  state - array of frequencies/densities denoting the state population
  
  fitness - array of fitness values of types in population
  
  nGroup - the interaction group size
  
  index - the index of the module mod in multi-species modules
  
  change - array to return the rate of change of each type in the population
  
  Returns:
  
  the total change (should be zero in theory)
- updateThermal
  
  protected double updateThermal(Module mod, double[] state, double[] fitness, int nGroup, int index, double[] change)
  
  Implementation of the player update PlayerUpdate.Type.THERMAL. This calculates the rates of change for each type in species mod for the popular choice for 'pairwise comparisons' where the focal player $i$ and one of its neighbours $j$ are randomly chosen. The focal player $i$ adopts the strategy of player $j$ with a probability $p_{i \to j} = \frac{1}{1 + \exp [w (f_{i} - f_{j})]},$ where $w \geq 0$ denotes the selection strength and $f_{i}, f_{j}$ the payoffs of individuals $i$ and $j$ , respectively. The resulting dynamics for the frequencies of the different strategic types is then given by $\begin{aligned} {\dot{x}}_{i} = & \sum_{j = 1}^{n} x_{i} x_{j} (\frac{1}{1 + \exp [w (f_{i} - f_{j})]} - \frac{1}{1 + \exp [w (f_{j} - f_{i})]}) \\ = & x_{i} \sum_{j = 1}^{n} \tanh [w (f_{i} - f_{j}) / 2] . \end{aligned}$
  Parameters:
  
  mod - the module representing the current species
  
  state - array of frequencies/densities denoting the state population
  
  fitness - array of fitness values of types in population
  
  nGroup - the interaction group size
  
  index - the index of the module mod in multi-species modules
  
  change - array to return the rate of change of each type in the population
  
  Returns:
  
  the total change (should be zero in theory)
  
  See Also:
  
  Sigmund, K., Hauert, C., Traulsen, A. & De Silva, H. (2011) Social control and the social contract: the emergence of sanctioning systems for collective action, Dyn. Games & Appl. 1, 149-171
- updateBest
  
  protected double updateBest(Module mod, double[] state, double[] fitness, int nGroup, int index, double[] change)
  
  Implementation of player update PlayerUpdate.Type.BEST. This calculates the rate of change individuals adopt the strategy of better performing individuals with certainty (and never those of worse performing individuals). This calculates the rates of change for each type in species mod for the popular choice for 'pairwise comparisons' where the focal player $i$ and one of its neighbours $j$ are randomly chosen. The focal player $i$ adopts the strategy of player $j$ if $f_{j} > f_{i}$ but never adopts those of a player $j$ with $f_{j} < f_{i}$ , where $f_{i}, f_{j}$ denote the fitness of players $i$ and $j$ , respectively. In case of a tie $f_{j} = f_{i}$ the individual sticks to its strategy. More specifically, the probability to adopt the strategy of $j$ is given by $p_{i \to j} = θ (f_{j} - f_{i}),$ where $θ (x)$ denotes the Heaviside step function with $θ (x) = 0$ for $x < 0$ , $θ (x) = 1$ for $x > 0$ . In principle $θ (0) = 1 / 2$ but assuming that players need at least a marginal incentive to switch strategies we set $θ (0) = 0$ . In most cases this choice is inconsequential. The resulting dynamics for the frequencies of the different strategic types is then given by $\begin{aligned} {\dot{x}}_{i} = & \sum_{j = 1}^{n} x_{i} x_{j} θ [f_{j} - f_{i})] . \end{aligned}$
  Note:In the limit of vanishing noise the updates updateThermal(Module, double[], double[], int, int, double[]) and updateImitate(Module, double[], double[], int, int, double[]) recover the PlayerUpdate.Type.BEST updating type as well.
  
  Parameters:
  
  mod - the module representing the current species
  
  state - array of frequencies/densities denoting the state population
  
  fitness - array of fitness values of types in population
  
  nGroup - the interaction group size
  
  index - the index of the module mod in multi-species modules
  
  change - array to return the rate of change of each type in the population
  
  Returns:
  
  the total change (should be zero in theory)
- updateImitate
  
  protected double updateImitate(Module mod, double[] state, double[] fitness, int nGroup, int index, double[] change)
  
  Implementation of the player update PlayerUpdate.Type.IMITATE. This calculates the rates of change for each type in species mod for the popular choice for 'pairwise comparisons' where the focal player $i$ and one of its neighbours $j$ are randomly chosen. The focal player $i$ adopts the strategy of $j$ with a probability proportional to the payoff difference $f_{j} - f_{i}$ : $p_{i \to j} = 1 / 2 (1 + (f_{j} - f_{i}) / (f_{j} + f_{i})),$ where $f_{i}, f_{j}$ denote the fitness of players $i$ and $j$ , respectively. The resulting dynamics for the frequencies of the different strategic types is then given by the standard replicator equation $\begin{aligned} {\dot{x}}_{i} = & x_{i} (f_{i} - \bar{f}) \end{aligned}$ where $\bar{f}$ denotes the the average population payoff.
  Note: in multi-species models all rates of change are scaled by the maximum fitness difference for all species to preserve their relative time scales.
  
  Parameters:
  
  mod - the module representing the current species
  
  state - array of frequencies/densities denoting the state population
  
  fitness - array of fitness values of types in population
  
  nGroup - the interaction group size
  
  index - the index of the module mod in multi-species modules
  
  change - array to return the rate of change of each type in the population
  
  Returns:
  
  the total change (should be zero in theory)
- updateImitateBetter
  
  protected double updateImitateBetter(Module mod, double[] state, double[] fitness, int nGroup, int index, double[] change)
  
  Implementation of the player update PlayerUpdate.Type.IMITATE_BETTER. This calculates the rates of change for each type in species mod for the popular choice for 'pairwise comparisons' where the focal player $i$ and one of its neighbours $j$ are randomly chosen. The focal player $i$ adopts the strategy of a better performing player $j$ with a probability proportional to the payoff difference $f_{j} - f_{i}$ : $\begin{aligned} {\dot{x}}_{i} = & \sum_{j = 1}^{n} x_{i} x_{j} (f_{i} - f_{j})_{+} = \sum_{j = 1}^{n} x_{i} x_{j} (f_{i} - f_{j}) - \sum_{j = 1}^{n} x_{i} x_{j} (f_{i} - f_{j})_{-} \\ = & \sum_{j = 1}^{n} x_{i} x_{j} (f_{i} - f_{j}) / 2 = x_{i} (f_{i} - \bar{f}) / 2. \end{aligned}$ Incidentally and somewhat surprisingly this update also reduces to the standard replicator dynamics albeit with a constant rescaling of time such that the rate of change are half of the standard replicator equation obtained from PlayerUpdate.Type#IMITATE.
  Note: in multi-species models all rates of change are scaled by the maximum fitness difference for all species to preserve their relative time scales.
  
  Parameters:
  
  mod - the module representing the current species
  
  state - array of frequencies/densities denoting the state population
  
  fitness - array of fitness values of types in population
  
  nGroup - the interaction group size
  
  index - the index of the module mod in multi-species modules
  
  change - array to return the rate of change of each type in the population
  
  Returns:
  
  the total change (should be zero in theory)
- updateReplicate
  
  private double updateReplicate(Module mod, double[] state, double[] fitness, int nGroup, int index, double[] change, double noise)
  
  Helper method to calculate the rate of change for the standard replicator dynamics with different amounts of noise arising from the microscopic update rule. In the microscopic implementation of the replicator dynamics the noise arises from focal individuals $i$ that adopt the strategy of a neighbour $j$ with a probability proportional to the payoff difference $f_{j} - f_{i}$ , where $f_{i}, f_{j}$ refer to the respective payoffs of $i$ and $j$ . However, the noise is cut in half if the focal imitates only better performing neighbours, i.e. proportional to $(f_{j} - f_{i})_{+}$ .
  
  Parameters:
  
  mod - the module representing the current species
  
  state - array of frequencies/densities denoting the state population
  
  fitness - array of fitness values of types in population
  
  nGroup - the interaction group size
  
  index - the index of the module mod in multi-species modules
  
  change - array to return the rate of change of each type in the population
  
  noise - the noise arising from probabilistical updates
  
  Returns:
  
  the total change (should be zero in theory)
- updateProportional
  
  protected double updateProportional(Module mod, double[] state, double[] fitness, int nGroup, int index, double[] change)
  
  Implementation of the player update PlayerUpdate.Type.PROPORTIONAL. This calculates the rates of change for each type in species mod for a 'pairwise comparison' where the focal player $i$ and one of its neighbours $j$ are randomly chosen. The focal player $i$ adopts the strategy of a player $j$ with probability: $p_{i \to j} = f_{j} / (f_{i} + f_{j}),$ where $f_{i}, f_{j}$ refer to the respective payoffs of $i$ and $j$ . In the continuum limit this yields $\begin{aligned} {\dot{x}}_{i} = & x_{i} \sum_{j = 1}^{n} x_{j} \frac{f_{i} - f_{j}}{f_{i} + f_{j}} . \end{aligned}$
  
  Parameters:
  
  mod - the module representing the current species
  
  state - array of frequencies/densities denoting the state population
  
  fitness - array of fitness values of types in population
  
  nGroup - the interaction group size
  
  index - the index of the module mod in multi-species modules
  
  change - array to return the rate of change of each type in the population
  
  Returns:
  
  the total change (should be zero in theory)
- updateBestResponse
  
  protected double updateBestResponse(Module mod, double[] state, double[] fitness, int nGroup, int index, double[] change)
  
  Implementation of the player update PlayerUpdate.Type.BEST_RESPONSE. This calculates the rates of change for each type in species mod for the best-response dynamic where the focal player $i$ switches to the strategy $j$ that has the highest payoff given the current state of the population. Note, in contrast to other player updates, such as PlayerUpdate.Type.THERMAL or PlayerUpdate.Type.IMITATE the best-response is an innovative update rule, which means that strategic types that are currently not present in the population can get introduced. Consequently, homogeneous states may not be absorbing.
  Note: inactive strategies are excluded and do not qualify as a best response.
  IMPORTANT: needs to be thread safe (must supply memory for calculations and results)
  
  Parameters:
  
  mod - the module representing the current species
  
  state - array of frequencies/densities denoting the state population
  
  fitness - array of fitness values of types in population
  
  nGroup - the interaction group size
  
  index - the index of the module mod in multi-species modules
  
  change - array to return the rate of change of each type in the population
  
  Returns:
  
  the total change (should be zero in theory)
- update
  
  public void update()
  
  Description copied from class: Model
  
  Update this model. For example called after initialization and when parameters changed.
  Specified by:
  
  update in class Model
  
  See Also:
  
  ChangeListener.modelChanged(ChangeListener.PendingAction)
- getStatus
  
  public String getStatus()
  
  Description copied from class: Model
  
  Returns status message from model. Typically this is a string summarizing the current state of the simulation. For example, models with discrete strategy sets (such as 2x2 games, see TBT) return the average frequencies of each strategy type in the population(s), see IBSDPopulation. Similarly, models with continuous strategies (such as continuous snowdrift games, see CSD) return the mean, minimum and maximum trait value(s) in the population(s), see IBSMCPopulation. The status message is displayed along the bottom of the GUI.
  Note: if the model runs into difficulties, problems should be reported through the logging mechanism. Messages with severity Level.WARNING or higher are displayed in the status of the GUI and override status messages returned here.
  
  Specified by:
  
  getStatus in class Model
  
  Returns:
  
  status of active model
- permitsTimeReversal
  
  public boolean permitsTimeReversal()
  
  Checks if time reversal is permitted. By default returns false. Only few models are capable of time reversal.
  ODE and SDE models return true by default.
  Overrides:
  
  permitsTimeReversal in class Model
  
  Returns:
  
  true if time reversal permissible.
  
  See Also:
  
  Model.setTimeReversed(boolean)
- isTimeReversed
  
  public boolean isTimeReversed()
  
  Description copied from class: Model
  
  Checks if time is reversed. By default returns false. Only few models are capable of time reversal.
  Overrides:
  
  isTimeReversed in class Model
  
  Returns:
  
  true if time is reversed
  
  See Also:
  
  Model.setTimeReversed(boolean)
- setTimeReversed
  
  public void setTimeReversed(boolean reversed)
  
  Description copied from class: Model
  Request time reversal if reversed==true. The model may not be able to honour the request. However, some models allow to travel back in time. In general, this is only possible for ODE and SDE models and even for those it may not be feasible due to details of the dynamics, such as dissipative terms in the differential equations. For example, in
  
  invalid reference
  
  org.evoludo.simulator.modules.CG
  
  the ecological dynamics of the patch quality prevents time reversal, i.e. results are numerically unstable due to exponential amplification of deviations in dissipative systems.
  Overrides:
  
  setTimeReversed in class Model
  
  Parameters:
  
  reversed - the request whether time should be reversed.
  
  See Also:
  
  ODE.setTimeReversed
  
  SDE.setTimeReversed
- setAdjustedDynamics
  
  public void setAdjustedDynamics(boolean adjusted)
  
  Sets whether adjusted dynamics is requested. It may not be possible to honour the request, e.g. if payoffs can be negative.
  
  Parameters:
  
  adjusted - if true requests adjusted dynamics
- setAccuracy
  
  public void setAccuracy(double acc)
  
  Sets the desired accuracy for determining convergence. If y(t+dt)-y(t)<acc dt holds, where y(t+dt) denotes the new state and y(t) the previous state, the numerical integration is reported as having converged and stops.
  
  Parameters:
  
  acc - the numerical accuracy
- getAccuracy
  
  public double getAccuracy()
  
  Gets the numerical accuracy for determining convergence.
  
  Returns:
  
  the numerical accuracy
- init
  
  private void init(boolean doRandom)
  
  Helper method to set the intital state of the model. The method initializes the state vector yt and the initial state vector y0. If doRandom is true random initial frequencies are set for species with InitType.RANDOM.
  
  Parameters:
  
  doRandom - if true use random initial frequencies as requested
- parse
  
  public boolean parse(String arg)
  
  Parse initializer string arg. Determine type of initialization and process its arguments as appropriate.
  Note: Not possible to perform parsing in CLODelegate of cloInit because PDE model provide their own PDE.InitTypes.
  Parameters:
  
  arg - the arguments to parse
  
  Returns:
  
  true if parsing successful
  
  See Also:
  
  ODE.InitType
- 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 Model
  
  Parameters:
  
  parser - the reference to parser that manages command line options
  
  See Also:
  
  CLOParser.addCLO(CLOption)
- encodeState
  
  public void encodeState(StringBuilder plist)
  
  Description copied from class: Model
  
  Encode the state of the model in a plist inspired XML string. This allows to save the state and restore later with the exact same results as when continuing to run the model. This even allows to switch from JRE to GWT or back and obtain identical results!
  Specified by:
  
  encodeState in class Model
  
  Parameters:
  
  plist - the StringBuilder to write the encoded state to
  
  See Also:
  
  Plist
  
  XMLCoder
- restoreState
  
  public boolean restoreState(Plist plist)
  
  Description copied from class: Model
  
  Restore the state encoded in the plist inspired map of key, value-pairs.
  Specified by:
  
  restoreState in class Model
  
  Parameters:
  
  plist - the map of key, value-pairs
  
  Returns:
  
  true if successful
  
  See Also:
  
  Plist
  
  PlistReader
  
  PlistParser
- encodeStrategies
  
  void encodeStrategies(StringBuilder plist)
  
  Encodes state of the model in the form of a plist string.
  
  Parameters:
  
  plist - the string builder for the encoded state
- restoreStrategies
  
  boolean restoreStrategies(Plist plist)
  
  Restores the state encoded in plist.
  
  Parameters:
  
  plist - the encoded state
  
  Returns:
  
  true if successful
- encodeFitness
  
  void encodeFitness(StringBuilder plist)
  
  Encodes the fitness of the model in the form of a plist string.
  
  Parameters:
  
  plist - the string builder for the encoded state
- restoreFitness
  
  boolean restoreFitness(Plist plist)
  
  Restores the fitness encoded in plist.
  
  Parameters:
  
  plist - the encoded state
  
  Returns:
  
  true if successful

Class ODE

Nested Class Summary

Field Summary

Fields inherited from class Model

Constructor Summary

Method Summary

Methods inherited from class Model

Methods inherited from class Object

Methods inherited from interface CLOProvider

Field Details

dt

dtTry

dtTaken

forward

nDim

y0

yt

ft

dyt

yout

dstate

staticfit

initType

idxSpecies

rates

mutation

dependents

invFitRange

names

monoStop

isAdjustedDynamics

accuracy

cloDEdt

cloInit

cloAdjustedDynamics

cloDEAccuracy

cloTimeReversed

Constructor Details

ODE

Method Details

load

unload

check

reset

init

setDt

getDt

isDensity

setInitialTraits

getInitialTraits

setInitialTraits

getInitialTraits

getMonoScore

getNMean

getNMean

getMeanTraits

getMeanTraits

getTraitData

getMinScore

getMaxScore

getMinFitness

getMaxFitness

getMeanFitness

getMeanFitness

getFitnessData

getFitnessHistogramData

next

Implementation Notes:

checkConvergence

Implementation Notes:

isMonomorphic

isMonomorphic

deStep

normalizeState

getDerivatives

updateEcology

updateThermal

updateBest

updateImitate

updateImitateBetter