Uses of Class
utilities.ModelError

Packages that use ModelError
connectionRules   
learningRules   
models   
mutationRules   
utilities   
 

Uses of ModelError in connectionRules
 

Methods in connectionRules that throw ModelError
 void NeighborReinforce.newGeneration(Individual i)
          Prepares the individual for a new round of play.
 void NeighborReinforce.processPayoff(Individual i)
          This function is run after the payoffs are updated for all individuals.
 

Uses of ModelError in learningRules
 

Methods in learningRules that throw ModelError
 void StratReinforce.newGeneration(Individual i)
          Prepares the individual for a new generation.
 void StratReinforce.processPayoff(Individual i)
          Processes the payoff by adding the payoff to the weight of the strategy choosen on this round
 void SmoothReinforcement.newGeneration(Individual i)
          Prepares the individual for a new generation.
 void SmoothReinforcement.processPayoff(Individual i)
          Processes the payoff by adding the payoff to the weight of the strategy choosen on this round
 void SmoothReinforcement.processPayoff(Individual i, int d)
          Processes the payoff by adding the payoff to the weight of the strategy choosen on this round.
 void SmoothPayoffLearning.newGeneration(Individual i)
          This does nothing since there is no discounting or anything.
 void SmoothPayoffLearning.processPayoff(Individual i)
          This processes the payoff by updating the agents beliefs about each payoff based on the information received this round.
 void SmoothBGLearning.newGeneration(Individual i)
          This does nothing since there is no discounting or anything.
 void SmoothBGLearning.processPayoff(Individual i)
          This processes a payoff for an individual.
 void PayoffLearning.newGeneration(Individual i)
          This does nothing since there is no discounting or anything.
 void PayoffLearning.processPayoff(Individual i)
          This processes the payoff by updating the agents beliefs about each payoff based on the information received this round.
 void MyopicBRLearning.newGeneration(Individual i)
          This does nothing since there is no discounting or anything.
 void MyopicBRLearning.processPayoff(Individual i)
          Processing a payoff does nothing, since there are no beliefs to be updated.
 void LearningRule.newGeneration(Individual i)
          A function that resets the learning rule for a new generation
 void LearningRule.processPayoff(Individual i)
          Process the payoffs once they have played the game fully
 void ImitateBestLearning.newGeneration(Individual i)
          This does nothing since there is no discounting or anything.
 void ImitateBestLearning.processPayoff(Individual i)
          Processing a payoff does nothing, since there are no beliefs to be updated.
 void HybridLearning.newGeneration(Individual i)
          The new generation method implements the averaging.
 void HybridLearning.processPayoff(Individual i)
          Updates beliefs based on the payoffs of neighbors.
 void BgLearning.newGeneration(Individual i)
          This does nothing since there is no discounting or anything.
 void BgLearning.processPayoff(Individual i)
          This processes a payoff for an individual.
 

Constructors in learningRules that throw ModelError
SmoothPayoffLearning(Game g, double gam)
           
PayoffLearning(Game g)
           
 

Uses of ModelError in models
 

Methods in models that throw ModelError
 void StandardModel.createPlayersHigh(Individual[] inds, int s)
          Forms a new network of specified size; expects random to be set.
 void StandardModel.createPlayersHigh(Individual[] inds, int s, ConnectionRule c, LearningRule l, double m, double z)
          Forms a new network of specified size; expects random to be set.
 void StandardModel.createPlayersHigh(Individual[] inds, int s, ConnectionRule c, LearningRule l, Game g, double m, double z)
          Forms a new network of specified size; expects random to be set.
 void StandardModel.playGen()
          Plays a generation and then resets.
 int StandardModel.detectConvergence(int sow)
          Checks to see if individuals have converged.
 void SingleDPL.playGen()
          Resets then plays a generation.
 void SingleDPL.run(com.martiansoftware.jsap.JSAPResult config)
           
 void SingleBGM.run(com.martiansoftware.jsap.JSAPResult config)
          Runs the model
 void SimpleCondorcetModel.resetPlayers(int s, double e)
          Resets the players beliefs
 int SimpleCondorcetModel.detectState()
          Detects if the individuals are in one of three states, unanimity on the truth (strategy 0), majority on the truth or none
 int SimpleCondorcetModel.countTruth()
          Returns the count of individuals who believe the truth (strategy 0).
 int SimpleCondorcetModel.runmodel(double mr, boolean tr, int g, int v)
          Runs the model.
 void SignalingGame.run()
           
 void RandomNetworkModel.playGen()
          Resets then plays a generation.
 int RandomNetworkModel.detectConvergence(int optimal)
          Checks to see if the population has converged either to the correct state or the bad state.
 void PayoffLearningModel.playGen()
          Resets then plays a generation.
 int PayoffLearningModel.detectConvergence(int optimal)
          Checks to see if the population has converged either to the correct state or the bad state.
 void HybridModel.createPlayersHigh(Individual[] inds, int s)
          Forms a new network of specified size; expects random to be set.
 void HybridModel.createPlayersHigh(Individual[] inds, int s, ConnectionRule c, LearningRule l, double m, double z)
          Forms a new network of specified size; expects random to be set.
 void HybridModel.createPlayersHigh(Individual[] inds, int s, ConnectionRule c, LearningRule l, Game g, double m, double z)
          Forms a new network of specified size; expects random to be set.
 void HybridModel.playGen()
          Resets then plays a generation.
 int HybridModel.detectConvergence(int sow)
          Checks to see if the population has converged either to the correct state or the bad state.
 void BiasedNetworkModel.playGen()
          Resets then plays a generation.
 int BiasedNetworkModel.detectConvergence(int optimal)
          Checks to see if the population has converged either to the correct state or the bad state.
 void BgModel.createPlayersHigh(Individual[] inds, int s)
          Forms a new network of specified size; expects random to be set.
 void BgModel.createPlayersHigh(Individual[] inds, int s, ConnectionRule c, LearningRule l, double m, double z)
          Forms a new network of specified size; expects random to be set.
 void BgModel.createPlayersHigh(Individual[] inds, int s, ConnectionRule c, LearningRule l, Game g, double m, double z)
          Forms a new network of specified size; expects random to be set.
 void BgModel.playGen()
          Resets then plays a generation.
 int BgModel.detectConvergence(int sow)
          Checks to see if the population has converged either to the correct state or the bad state.
 

Constructors in models that throw ModelError
SingleDPL(com.martiansoftware.jsap.JSAPResult config)
           
SingleBGM(com.martiansoftware.jsap.JSAPResult config)
           
RandomNetworkModel(Individual[] i, Game g, LearningRule l, double m, double p)
           
PayoffLearningModel(Individual[] i, Game g, ConnectionRule c, LearningRule l, double m)
           
BiasedNetworkModel(Individual[] i, Game g, LearningRule l, double m, double min, double max)
           
 

Uses of ModelError in mutationRules
 

Methods in mutationRules that throw ModelError
 void NoMutate.setMutationRate(double m, int s)
          Does nothing
 void NoMutate.mutate(Individual i)
          Does nothing
 void MutationRule.mutate(Individual i)
           
 void MutationRule.setMutationRate(double m, int s)
           
 void MutateStrategy.mutate(Individual i)
          This function mutates based on the mutation matrix already established by the constructor.
 void MutateStrategy.setMutationRate(double m, int s)
          Sets the mutation rate (equivalent to the constructor)
 void MutateStrategy.setMutationRate(double[][] m)
          Same as constructor
 void MutateBeliefs.mutate(Individual i)
          Mutates weights, beliefs, and alpha/beta values.
 void MutateBeliefs.setMutationRate(double m, int s)
          Sets the mutation rate
 

Constructors in mutationRules that throw ModelError
MutateStrategy(double[][] m)
          The constructor which takes a mutation matrix
MutateStrategy(double m, int s)
          Sets the mutation matrix as uniform based on m
MutateBeliefs(double m)
          Constructor which accepts rate and strategy number.
 

Uses of ModelError in utilities
 

Methods in utilities that throw ModelError
 void Individual.setBeliefs(double[] b)
          A function to set the Bayesian beliefs for one domain.
 void Individual.setBeliefs(double[][] b)
          A function to set the Bayesian beliefs for multi-domain situations.
 void Individual.setBeliefs(double[] b, int d)
          A function to set the Bayesian beliefs for one domain in mutli-domain learning situations.
 void Individual.setConstraint(double c)
          Sets a constraint that initializations can be constrained by.
 void Individual.setConstraint(double[] c)
          Sets a constraint that initializations can be constrained by.
 void Individual.setConstraint(int d, double c)
          Sets a constraint that initializations can be constrained by.
 void Individual.setStratWeights(double[] s)
          Sets the strategy weights to a specific value.
 void Individual.setStratWeights(double[][] s)
          Sets the strategy weights to a specific value.
 void Individual.setStratWeights(int p, double s)
          Sets the strategy weight for a particular strategy to a specific value.
 void Individual.setStratWeights(int d, int p, double s)
          Sets the strategy weight for a particular strategy to a specific value.
 void Individual.addStratWeight(int p, double w)
          Adds a specified weight to a particular strategy.
 void Individual.addStratWeight(int d, int p, double w)
          Adds a specified weight to a particular strategy.
 void Individual.setDiscount(double d)
          Sets a discount value
 void Individual.setMutation(double m)
          Calls the mutationRule set function.
 void Individual.mutate()
          Calls the mutationRules mutate function.
 void Individual.setStrat(int s)
          Sets the current strategy of a user
 int Individual.chooseStrat()
          Uses the learning rule to choose a strategy
 int Individual.getStrat()
          Returns the current strategy, if its not set chooses one.
 void Individual.reset()
          Resets for a new generation.
 void Individual.playGame()
          Plays the game with each neighbor.
 void Individual.update()
          Updates after play is complete.
 void Individual.initStart(int s)
          The initializes the individual for single domain models by giving them random beliefs and randomizing the weights The random beliefs are constrained by the zeroconstraint.
 void Individual.initStart(int d, int s)
          The initializes the individual for multi domain models by giving them random beliefs and randomizes the the wieghts The random beliefs are constrained by the zeroconstraint.
static java.util.HashSet GraphIO.readJobsFile(java.lang.String fn)
          A function to read jobs files.
static int[][] GraphIO.stringMatrix(java.lang.String s)
          A function to turn a string representing an adjacency matrix into an integer matrix.
 void Game.setMatrix(int[][] m)
          Sets the payoff matrix.
 void Game.setMatrix(int[][] m, int bp)
          Sets the payoff matrix.
 void BeliefAnimation.newFrame()
           
 

Constructors in utilities that throw ModelError
Game(int[][] m, boolean so)
          Returns a game object.
Game(int[][] m, boolean so, MersenneTwister r)
          Returns a game object.
Game(int[][] m, boolean so, MersenneTwister r, boolean st)
          Returns a game object