Uses of Class
utilities.Individual

Packages that use Individual
connectionRules   
learningRules   
models   
mutationRules   
utilities   
 

Uses of Individual in connectionRules
 

Methods in connectionRules with parameters of type Individual
 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.
 int NeighborReinforce.pickStrat(Individual i)
          Choose a strategy for the individual based on the wieghts by the standard reinforcement method.
 java.util.HashSet ConnectNothing.formConnection(Individual i)
           
 java.util.HashSet ConnectionRule.formConnection(Individual i)
          The function to form connections
 

Uses of Individual in learningRules
 

Methods in learningRules with parameters of type Individual
 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
 int StratReinforce.pickStrat(Individual i)
          Chooses a strategy based on standard reinforcement method
 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.
 int SmoothReinforcement.pickStrat(Individual i)
          Picks a strategy based on a logisitic response rule similar to smoothed fictitious play this is for multi domain models
 int SmoothReinforcement.pickStrat(Individual i, int d)
          Picks a strategy based on a logisitic response rule similar to smoothed fictitious play this is for signaling games
 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.
 int SmoothPayoffLearning.pickStrat(Individual i)
          This function chooses a strategy for the player.
 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.
 int SmoothBGLearning.pickStrat(Individual i)
          This function chooses a strategy for the player.
 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.
 int PayoffLearning.pickStrat(Individual i)
          Chooses the strategy with the highest expected payoff.
 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.
 int MyopicBRLearning.pickStrat(Individual i)
          This function chooses a strategy which is a best response to the collective action of the players last round.
 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
 int LearningRule.pickStrat(Individual i)
          Pick a strategy to play in a new generation
 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.
 int ImitateBestLearning.pickStrat(Individual i)
          This function chooses the strategy which did best on the previous round.
 void HybridLearning.newGeneration(Individual i)
          The new generation method implements the averaging.
 int HybridLearning.pickStrat(Individual i)
          Chooses the strategy with the highest expectation
 void HybridLearning.processPayoff(Individual i)
          Updates beliefs based on the payoffs of neighbors.
 void CondorcetLearning.newGeneration(Individual i)
          There is no updating so this function does nothing
 int CondorcetLearning.pickStrat(Individual i)
          This function censuses individual in the neighborhood and adopts the strategy used by the majority last round.
 void CondorcetLearning.processPayoff(Individual i)
          All this does is update LastStrat.
 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.
 int BgLearning.pickStrat(Individual i)
          This function chooses a strategy for the player.
 

Uses of Individual in models
 

Methods in models that return Individual
 Individual[] StandardModel.getIndividuals()
          Returns the set of individuals for the model.
 Individual SingleDPL.getIndivids()
          Returns the value of indivis.
 Individual SingleBGM.getIndividual()
          Returns the set of individuals for the model.
 Individual[] SimpleCondorcetModel.getIndividuals()
          Returns the set of individuals for the model.
 Individual[] RandomNetworkModel.getIndivids()
          Returns the value of indivis.
 Individual[] PayoffLearningModel.getIndivids()
          Returns the value of indivis.
 Individual[] HybridModel.getIndividuals()
          Returns the set of individuals for the model.
 Individual[] BiasedNetworkModel.getIndivids()
          Returns the value of indivis.
 Individual[] BgModel.getIndividuals()
          Returns the set of individuals for the model.
 

Methods in models with parameters of type Individual
 void StandardModel.setIndividuals(Individual[] i)
          Sets the list of individuals for the model.
 void StandardModel.createPlayersLow(Individual[] inds)
          Forms a new network of specified size; doesn't expect much to be set.
 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 SingleDPL.setIndividual(Individual individs)
          Sets the value of indivis.
 void SingleBGM.setIndividual(Individual i)
          Sets the list of individuals for the model.
 void SimpleCondorcetModel.setIndividuals(Individual[] i)
          Sets the list of individuals for the model.
 void SimpleCondorcetModel.createPlayers(Individual[] is, MutationRule mr, LearningRule lr, ConnectionRule cr)
          Sets up the individuals
 void RandomNetworkModel.setIndivids(Individual[] individs)
          Sets the value of indivis.
 void PayoffLearningModel.setIndivids(Individual[] individs)
          Sets the value of indivis.
 void HybridModel.setIndividuals(Individual[] i)
          Sets the list of individuals for the model.
 void HybridModel.createPlayersLow(Individual[] inds)
          Forms a new network of specified size; doesn't expect much to be set.
 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 BiasedNetworkModel.setIndivids(Individual[] individs)
          Sets the value of indivis.
 void BgModel.setIndividuals(Individual[] i)
          Sets the list of individuals for the model.
 void BgModel.createPlayersLow(Individual[] inds)
          Forms a new network of specified size; doesn't expect much to be set.
 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.
 

Constructors in models with parameters of type Individual
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 Individual in mutationRules
 

Methods in mutationRules with parameters of type Individual
 void NoMutate.mutate(Individual i)
          Does nothing
 void MutationRule.mutate(Individual i)
           
 void MutateStrategy.mutate(Individual i)
          This function mutates based on the mutation matrix already established by the constructor.
 void MutateBeliefs.mutate(Individual i)
          Mutates weights, beliefs, and alpha/beta values.
 

Uses of Individual in utilities
 

Methods in utilities that return Individual
 Individual[] Individual.getNetwork()
          Returns the network (all other individuals in the model).
static Individual[] GraphIO.adjacencyMatrix(int[][] m)
          Turns an adjacency matrix into a collection of Individuals.
 

Methods in utilities with parameters of type Individual
 void Individual.setNetwork(Individual[] nw)
          Sets the network (all other individuals in the model).
 void Individual.addConnected(Individual i)
          Adds a neighbor to an individuals current neighbors.
 void BeliefAnimation.start(Individual ind, java.lang.String fn)
           
 

Constructors in utilities with parameters of type Individual
Individual(int i, int s, MersenneTwister r, Individual[] nw, ConnectionRule c, LearningRule l)
          Returns and individual object, but with more initialized.