Overview | Package | Class | Use | Tree | Deprecated | Index | Help
PREV NEXT | FRAMES NO FRAMES

## Uses of Class
edu.princeton.repeatedgames.rgsolve.games.Game

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
`(package private) Game` | `SolutionGraph.game`

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
`class` | `ScaledGame` This class scales the payoffs of a `Game` object linearly, according to the function newPayoff(player) = payoff(player) * slope[player] + offset[player]
`class` | `SymmetricBimatrixGame` A class for symmetric matrix games

Fields in edu.princeton.repeatedgames.rgsolve.games declared as Game
`Game` | `ScaledGame.game` The base game

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.List<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.getMaximumPayoffs(Game game)`
`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 ScaledGame` | `ScaledGame.getNormalizedGame(Game game, double min, double max)` Normalizes the range of payoffs to each player to the range `[min, max]`
`static ScaledGame` | `ScaledGame.getOffsetGame(Game game, double[] offset)` Offsets the payoffs to each player by the amount `offset[player]`
`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 {PLAYER_1, PLAYER_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).
`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

Constructors in edu.princeton.repeatedgames.rgsolve.games with parameters of type Game
`ScaledGame(Game game)`
`ScaledGame(Game game, double[] slope, double[] offset)`

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
`class` | `Sierpinski` A game forming the Sierpinski triangle
`class` | `SimpleCournot` "A simple Cournot game with demand P(Q) = max{0, A - B * Q}, and marginal costs c1 and c2, with quantity actions on [0, A/B] and discount delta

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.

Overview | Package | Class | Use | Tree | Deprecated | Index | Help
PREV NEXT | FRAMES NO FRAMES