|
||||||||||
PREV NEXT | FRAMES NO FRAMES |
Packages that use Game | |
---|---|
edu.princeton.repeatedgames.rgsolve | Contains the core classes of the rgsolve package,
including the solver class RGSolve ,
the solver settings AlgoParameters ,
and data structures like RGSolution
for storing game solutions and algorithm information. |
edu.princeton.repeatedgames.rgsolve.components | WARNING: These classes are undocumented - Contains classes defining the components used in the rgsolve GUI. |
edu.princeton.repeatedgames.rgsolve.games | Contains the Game class which defines
a repeated game, and classes for constructing,
manipulating and analyzing games. |
edu.princeton.repeatedgames.rgsolve.games.specialgames | Contains special predefined subclasses of Game
for some games of interest, including Oligopoly models and
examples from the Abreu-Sannikov 2013 paper. |
edu.princeton.repeatedgames.rgsolve.games.staticmethods | |
edu.princeton.repeatedgames.rgsolve.utilities | A grab-bag of utility classes used by rgsolve, including some I/O classes. |
edu.princeton.repeatedgames.rgsolve.utilities.gamecompiler | A subpackage used in dynamically defining, compiling and loading games from user-written source code from within the rgsolve GUI. |
Uses of Game in edu.princeton.repeatedgames.rgsolve |
---|
Fields in edu.princeton.repeatedgames.rgsolve declared as Game | |
---|---|
private Game |
RGSolve.game
The repeated game associated with this instance of the solver |
Game |
RGSolution.game
the game associated with this solution |
Methods in edu.princeton.repeatedgames.rgsolve that return Game | |
---|---|
Game |
RGSolve.getGame()
Returns the value of the field called 'game'. |
Methods in edu.princeton.repeatedgames.rgsolve with parameters of type Game | |
---|---|
private static java.lang.String |
RGSolveMathematica.getEquationSystem(Game game,
GameExtremePoint[] V_star,
int[] BR1,
int[] BR2,
RGSolveMathematica.SOFTWARE software)
Returns the command for the the software in software 's
algebraic solver to find the exact solution to the system of equations
defining V*, a system derived from the extreme points (and how they are generated)
stored in V_star |
static RGSolution |
InnerApproximation.getInnerApproximationSolution(Game game,
AlgoParameters params,
Point[] W0,
double scale)
This method returns the inner approximation solution implied by the set W0 . |
static java.lang.String |
RGSolveMathematica.getLatexCommand(Game game,
GameExtremePoint[] V_star)
Returns the LaTeX code for the system of equations defining V*, a system derived from the extreme points (and how they are generated) stored in V_star |
static java.lang.String |
RGSolveMathematica.getLatexCommand(Game game,
GameExtremePoint[] V_star,
int[] BR1,
int[] BR2)
Returns the LaTeX code for the system of equations defining V*, a system derived from the extreme points (and how they are generated) stored in V_star |
static java.lang.String |
RGSolveMathematica.getMathematicaCommand(Game game,
GameExtremePoint[] V_star)
Returns the Mathematica command for the Mathematica algebraic solver to find the exact solution to the system of equations defining V*, a system derived from the extreme points (and how they are generated) stored in V_star |
static java.lang.String |
RGSolveMathematica.getMathematicaCommand(Game game,
GameExtremePoint[] V_star,
int[] BR1,
int[] BR2)
Returns the Mathematica command for the Mathematica algebraic solver to find the exact solution to the system of equations defining V*, a system derived from the extreme points (and how they are generated) stored in V_star |
static java.lang.String |
RGSolveMathematica.getMatlabCommand(Game game,
GameExtremePoint[] V_star)
Returns the Matlab command for the Matlab algebraic solver to find the exact solution to the system of equations defining V*, a system derived from the extreme points (and how they are generated) stored in V_star |
static java.lang.String |
RGSolveMathematica.getMatlabCommand(Game game,
GameExtremePoint[] V_star,
int[] BR1,
int[] BR2)
Returns the Matlab command for the Matlab algebraic solver to find the exact solution to the system of equations defining V*, a system derived from the extreme points (and how they are generated) stored in V_star |
private void |
RGSolve.initializeObject(Game game,
AlgoParameters params,
RGSolveProgressUpdater progressUpdater)
Initializes all rgsolve-object data |
static RGSolution |
RGSolve.staticSolveGame(Game game)
Solves the game statically (no RGSolve object) using rgsolve default parameters, and which prints status updates to the console |
static RGSolution |
RGSolve.staticSolveGame(Game game,
AlgoParameters params)
Solves the game statically (no RGSolve object) and which prints status updates to the console |
Constructors in edu.princeton.repeatedgames.rgsolve with parameters of type Game | |
---|---|
RGSolution(AlgoParameters.ALGO_TYPE algo_type,
Point[] W0,
GameExtremePoint[] V_star,
Point punishment_star,
Game game,
int[] BR1,
int[] BR2,
int iters,
long time_ms,
boolean converged,
double error,
java.util.ArrayList<RGIter> iterList,
int genPtsCount,
boolean keptActions,
boolean fromInnerApproximation,
AlgoParameters params)
Default constructor for initializing fields of data structure |
|
RGSolve(Game game)
Constructor using rgsolve default parameters, and which prints status updates to the console |
|
RGSolve(Game game,
AlgoParameters params)
Constructor using user-passed-in parameters params ,
and which prints status updates to the console |
|
RGSolve(Game game,
AlgoParameters params,
RGSolveProgressUpdater progressUpdater)
Constructor using user-passed-in parameters params ,
and which prints status updates to progressUpdater |
Uses of Game in edu.princeton.repeatedgames.rgsolve.components |
---|
Fields in edu.princeton.repeatedgames.rgsolve.components declared as Game | |
---|---|
Game |
GameComponents_new.currentGame
|
(package private) Game |
SolutionGraph.game
|
(package private) Game |
GameScrollPane.game
|
(package private) Game |
StageGamePayoffGraph.gm
|
Methods in edu.princeton.repeatedgames.rgsolve.components that return Game | |
---|---|
Game |
GameComponents_new.getGame()
|
Methods in edu.princeton.repeatedgames.rgsolve.components with parameters of type Game | |
---|---|
void |
GameComponents_new.setGame(Game game)
|
Constructors in edu.princeton.repeatedgames.rgsolve.components with parameters of type Game | |
---|---|
GameComponents_new(Game game)
|
|
GameScrollPane(Game game,
int minRow,
int maxRow,
int minCol,
int maxCol,
GameComponents_new gComps,
GameScrollPane.TYPE type)
|
|
StageGamePayoffGraph(Game gm)
|
Uses of Game in edu.princeton.repeatedgames.rgsolve.games |
---|
Subclasses of Game in edu.princeton.repeatedgames.rgsolve.games | |
---|---|
class |
BimatrixGame
This class extends Game and stores a
repeated game where the stage game payoffs are
stored as 2D arrays |
Methods in edu.princeton.repeatedgames.rgsolve.games that return Game | |
---|---|
static Game |
GameFactory.getArmsRace(int m1,
int m2)
|
static Game |
GameFactory.getGrabTheDollar(int m1)
|
static Game |
GameFactory.getUniformGame(int m1,
int m2)
A game with payoffs drawn i.i.d. |
Methods in edu.princeton.repeatedgames.rgsolve.games with parameters of type Game | |
---|---|
static java.util.ArrayList<GameExtremePoint> |
StageGameMethods.getFeasibleSetHull(Game gm,
AlgoParameters params,
boolean doMultiThread)
Computes and returns the convex hull of the set of feasible stage payoffs in the game gm . |
static Fraction[][][] |
StageGameMethods.getFractionalPayoffs(Game game)
Converts game payoffs into Fractions (from reals/doubles) |
static Point |
StageGameMethods.getMinimumPayoffs(Game game)
Returns the minimum feasible payoffs to each player as a Point of the game game |
static Point |
StageGameMethods.getMinMax(Game game)
Returns the minmax payoffs as a Point of the game game |
static double[][][] |
StageGameMethods.getPayoffArray(Game game)
Returns a double[][][] representation
of the stage payoffs, with [i-1][a1][a2] denoting the
payoff to player i in {1,2} given action (a1,a2) |
static Point[] |
StageGameMethods.getPointArray(Game game)
Returns an array of points representing the feasible payoffs in this game. |
static int[] |
StageGameMethods.getStaticBestResponse(Game gm,
int player,
boolean doMulti)
Returns the static best response vector for player i, where BR[a] is the best response of i to action a by player j = (-i) Note: there could be multiple BRs, but we only care about BRs for defection payoffs and therefore choose a unique BR. |
private static void |
StageGameMethods.getStaticBestResponseFrom(Game gm,
int start,
int end,
int player,
int[] BR)
Helper method that calculates the best responses for player player in the game game in response
to actions start through end of the
other player, and stores them in the array BR /
Note: there could be multiple BRs, but we only care about BRs
for defection payoffs and therefore choose a unique BR. |
static boolean[][] |
StageGameMethods.getUsableActions(Game game)
Converts the BitSet of usable actions in
the game game to a boolean[][]
representation |
static void |
StageGameMethods.showLatexTable(java.lang.String gameName,
Game gm)
Shows a JFrame with the game in LaTeX table format |
static BimatrixGame |
StageGameMethods.toBimatrixGame(Game gm)
This method converts any subclass of Game
into a BimatrixGame , storing payoffs as
double[][] arrays. |
static BimatrixGame |
StageGameMethods.toBimatrixGame(Game gm,
int m1,
int m2)
Converts the game gm to an m1 x m2
dimension BimatrixGame , truncating or padding gm
as necessary. |
static java.lang.String |
StageGameMethods.toLatexTable(Game gm,
int numDigits)
Returns the stage game as a normal-form table in LaTeX format |
Uses of Game in edu.princeton.repeatedgames.rgsolve.games.specialgames |
---|
Subclasses of Game in edu.princeton.repeatedgames.rgsolve.games.specialgames | |
---|---|
class |
AbreuSannikovExample1
This game is the example on page 10 of Abreu-Sannikov 2013 |
class |
AbreuSannikovExample2
This game is the example in figure 8 of Abreu-Sannikov 2013 |
class |
ArmsRace
An "Arms Race", where action profile (a1, a2) yields military expenditures Xi = max(i) * ai/(mi-1). |
class |
BattleOfTheSexes
The classic Battle of the Sexes |
class |
BertrandImperfectSubs
A Bertrand game with goods that are imperfect substitutes. |
class |
BertrandPerfectSubs
A Bertrand Game with the demand function for player i Q(pi, pj) = A - B * pi [if pi < pj] Q(pi, pj) = 0 [if pi > pj] Q(pi, pj) = (A - B * pi)/2 [if pi = pj] Constant marginal costs are c1 and c2 Maximum price is A/B |
class |
CournotGame
A Cournot Game, where P(Q) = Max{ A - B * Q, 0 } Minimum output is zero, maximum output for player i in {1,2} is the maximum between A/B and *PROF* / ci ,
where *PROF* is the monopolist profit. |
class |
GrabTheDollar
This stage game is itself a dynamic game. |
class |
HawkDove
The classic Hawk-Dove Game |
class |
PrisonersDilemma
The classic Prisoner's Dilemma |
class |
RandomNormalGame
Creates a game where payoffs are distributed bivariate normal |
Uses of Game in edu.princeton.repeatedgames.rgsolve.games.staticmethods |
---|
Methods in edu.princeton.repeatedgames.rgsolve.games.staticmethods with parameters of type Game | |
---|---|
static double[][] |
FictitiousPlay.doFictitiousPlay(Game game)
|
static double[][] |
FictitiousPlay.doFictitiousPlay(Game game,
double[] edf1_0,
double[] edf2_0,
int numPlays,
double logit_coeff,
boolean showOutput)
|
static java.util.ArrayList<int[]> |
StaticGameMethods.getPSNE(Game gm,
boolean showOutput)
Calculates all Pure-Strategy Nash Equilibria of a game |
static java.util.ArrayList<java.lang.Integer>[][] |
StaticGameMethods.getStaticBestResponses(Game gm,
boolean showOutput)
Calculates *all* best responses for player player
Method is not multi-threaded. |
static java.util.ArrayList<java.lang.Integer>[] |
StaticGameMethods.getStaticBestResponses(Game gm,
StaticGameMethods.PLAYER play)
Calculates *all* best responses for player player
Method is not multi-threaded. |
static BitSetFixed[] |
StaticGameMethods.getStrictDomStrats(Game game,
boolean showOutput)
Iterated elimination of strictly dominated strategies |
Uses of Game in edu.princeton.repeatedgames.rgsolve.utilities |
---|
Fields in edu.princeton.repeatedgames.rgsolve.utilities declared as Game | |
---|---|
Game |
RGSolveIO.OpenGameReturnObject.game
The Game |
Methods in edu.princeton.repeatedgames.rgsolve.utilities with parameters of type Game | |
---|---|
static java.lang.String |
RGSolveIO.writeGameFile(Game gm,
java.lang.String file_title)
This methods and saves game files as - .rgm (serialized games). |
Constructors in edu.princeton.repeatedgames.rgsolve.utilities with parameters of type Game | |
---|---|
RGSolveIO.OpenGameReturnObject(java.lang.String fileTitle,
Game game,
java.lang.String extension,
java.lang.String filePath)
Constructor |
Uses of Game in edu.princeton.repeatedgames.rgsolve.utilities.gamecompiler |
---|
Subclasses of Game in edu.princeton.repeatedgames.rgsolve.utilities.gamecompiler | |
---|---|
class |
TempGameHolder
An abstract class defining a temporary game held in memory. |
|
||||||||||
PREV NEXT | FRAMES NO FRAMES |