|
||||||||||
PREV NEXT | FRAMES NO FRAMES |
Packages that use Point | |
---|---|
edu.princeton.plot | Contains classes for 2D plotting of polygons, scatters, line plots, etc. |
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.polygon | Contains classes and methods used for storing
and manipulating the polygons that define
payoff sets - Includes a convex hull routine,
and the class GameExtremePoint ,
which defines an equilibrium extreme point of V*
and how it is generated. |
Uses of Point in edu.princeton.plot |
---|
Methods in edu.princeton.plot with type parameters of type Point | ||
---|---|---|
static
|
Point.roundPointList(java.util.List<T> list,
int digits)
Rounds the list of points list to digits many digits |
Methods in edu.princeton.plot that return Point | |
---|---|
Point |
Point.add(double d)
|
Point |
Point.add(int d)
|
Point |
Point.add(Point p)
|
static Point |
Point.affineCombo(Point p1,
double alpha1,
Point p2)
|
Point |
Point.clone()
Returns a deep-copy of this Point |
Point |
Point.deepCopy()
Deprecated. |
Point |
Point.divide(double m)
|
Point |
Point.divide(int m)
|
Point |
Point.getClockwiseNormal()
|
Point |
Point.getCounterClockwiseNormal()
|
static Point |
Point.getNaN()
|
static Point |
Point.linearCombo(Point p1,
double a1,
Point p2,
double a2)
|
Point |
Point.minus(Point p)
Deprecated. |
Point |
Point.multiply(double m)
|
Point |
Point.multiply(int m)
|
Point |
Point.negate()
|
Point |
Point.normalize()
|
Point |
Point.plus(Point p)
Deprecated. |
Point |
Point.rotate(double theta)
Interpreting this point as a direction vector, rotates the vector by angle theta , |
Point |
Point.subtract(double d)
|
Point |
Point.subtract(int d)
|
Point |
Point.subtract(Point p)
|
Methods in edu.princeton.plot with parameters of type Point | |
---|---|
Point |
Point.add(Point p)
|
static Point |
Point.affineCombo(Point p1,
double alpha1,
Point p2)
|
static double |
Point.angleRadians(Point a,
Point b,
Point c)
Returns the angle formed by the points a , b
and c , with b the vertex |
static double |
Point.angleRadiansAbs(Point a,
Point b,
Point c)
Returns the angle formed by the points a , b
and c , with b the vertex, normalized to [0, Pi] |
double |
Point.dot(Point p)
Deprecated. |
static double |
Point.dot(Point p1,
Point p2)
Returns the dot product of p1 and p2 . |
double |
Point.euclidDistance(Point p)
|
static double |
Point.euclidDistance(Point p1,
Point p2)
The Euclidean-distance between points p1 and p2 ; |
static double |
Point.interpXonY(Point p1,
Point p2,
double y)
Taking points p1 , p2 as two points defining
a line, calculates the value of x such that the point
(x ,y ) lies on the same line |
static double |
Point.interpYonX(Point p1,
Point p2,
double x)
Taking points p1 , p2 as two points defining
a line, calculates the value of y such that the point
(x ,y ) lies on the same line |
boolean |
Point.isCloseTo(Point point,
double err)
Check if this point is within err
of the point point |
static Point |
Point.linearCombo(Point p1,
double a1,
Point p2,
double a2)
|
Point |
Point.minus(Point p)
Deprecated. |
double |
Point.multiply(Point p)
Returns the dot product of this and p . |
Point |
Point.plus(Point p)
Deprecated. |
Point |
Point.subtract(Point p)
|
double |
Point.supDistance(Point p)
|
static double |
Point.supDistance(Point p1,
Point p2)
The sup-distance between points p1 and p2 ; |
Uses of Point in edu.princeton.repeatedgames.rgsolve |
---|
Fields in edu.princeton.repeatedgames.rgsolve declared as Point | |
---|---|
Point[][] |
RGIter.intersections
intersections[a] saves the intersections
at action a=(a1*m2+a2) during this iteration. |
Point |
RGIter.punishment
punishment vector u at the *start* of this iteration |
Point |
RGSolution.punishment_star
The equilibrium threat point, (or threat point where algo stopped) |
private Point |
RGSolve.RecursiveActionLoop.u
the threat point |
Point[] |
RGSolution.W0
the initial feasible set containing V* used at start of algorithm |
Methods in edu.princeton.repeatedgames.rgsolve that return Point | |
---|---|
static Point |
RGSolve.getPunishment(GameExtremePoint[] W,
Point curPunishment)
Gets the current threat point given payoff set W and old threat point curPunishment |
static Point[] |
InnerApproximation.shrinkSet(Point[] W,
double scale)
"Shrinks" the set W by contracting each vertex v towards
the point q, i.e. |
Methods in edu.princeton.repeatedgames.rgsolve with parameters of type Point | |
---|---|
GameExtremePoint[] |
RGSolve.AbreuSannikovOperator(GameExtremePoint[] W,
Point u,
RGIter rg_iter)
This applies the Abreu-Sannikov (or APS) operator to a set. |
boolean |
RGSolve.g_a_enforceable(int a1,
int a2,
Point u,
int player)
|
private java.util.List<GameExtremePoint> |
RGSolve.generateSupportedPayoffs(int startAct,
int endAct,
GameExtremePoint[] W,
Point u,
RGIter rg_iter,
int xmin_n,
int xmin_s,
int ymin_e,
int ymin_w,
int xmax_n,
int xmax_s,
int ymax_e,
int ymax_w,
double minXVal,
double maxXVal,
double minYVal,
double maxYVal)
A helper method within the Abreu-Sannikov (or APS) operator for calculating potential extreme points supported by actions in the range startAct to endAct . |
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 Point |
RGSolve.getPunishment(GameExtremePoint[] W,
Point curPunishment)
Gets the current threat point given payoff set W and old threat point curPunishment |
static Point[] |
InnerApproximation.shrinkSet(Point[] W,
double scale)
"Shrinks" the set W by contracting each vertex v towards
the point q, i.e. |
RGSolution |
RGSolve.solveGame(Point[] W_initial,
Point punishment)
Solves the game held in this solver object, using an initial guess of V*, W_initial |
RGSolution |
RGSolve.solveGame(Point[] W_initial,
Point punishment)
Solves the game held in this solver object, using an initial guess of V*, W_initial |
Constructors in edu.princeton.repeatedgames.rgsolve with parameters of type Point | |
---|---|
RGIter(int iter,
boolean keepActions,
int numActions,
GameExtremePoint[] W,
Point punishment,
int numDrop_start,
BitSetFixed usableActions)
Constructor: see field information |
|
RGSolution.RGSolutionUserRule(AlgoParameters.ALGO_TYPE algo_type,
Point[] W0,
GameExtremePoint[] V_star,
Point punishment_star,
int[] BR1,
int[] BR2,
int iters,
long time_ms,
boolean converged,
double error,
java.util.ArrayList<RGIter> iterList,
int genPtsCount,
boolean keptActions,
AlgoParameters params,
boolean fromInnerApproximation,
GameCodeData gmcode)
Straightforward constructor; same as for GameCodeData ,
but it stores a GameCodeData object rather than a game. |
|
RGSolution.RGSolutionUserRule(AlgoParameters.ALGO_TYPE algo_type,
Point[] W0,
GameExtremePoint[] V_star,
Point punishment_star,
int[] BR1,
int[] BR2,
int iters,
long time_ms,
boolean converged,
double error,
java.util.ArrayList<RGIter> iterList,
int genPtsCount,
boolean keptActions,
AlgoParameters params,
boolean fromInnerApproximation,
GameCodeData gmcode)
Straightforward constructor; same as for GameCodeData ,
but it stores a GameCodeData object rather than a 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 |
|
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.RecursiveActionLoop(int startAct,
int endAct,
GameExtremePoint[] W,
Point u,
RGIter rg_iter,
int xmin_n,
int xmin_s,
int ymin_e,
int ymin_w,
int xmax_n,
int xmax_s,
int ymax_e,
int ymax_w,
double minXVal,
double maxXVal,
double minYVal,
double maxYVal)
A helper method within the Abreu-Sannikov (or APS) operator for calculating potential extreme points supported by actions in the range startAct to endAct . |
Uses of Point in edu.princeton.repeatedgames.rgsolve.components |
---|
Fields in edu.princeton.repeatedgames.rgsolve.components declared as Point | |
---|---|
(package private) Point[] |
SolutionGraph.payoffHull
|
Uses of Point in edu.princeton.repeatedgames.rgsolve.games |
---|
Methods in edu.princeton.repeatedgames.rgsolve.games that return Point | |
---|---|
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 Point[] |
StageGameMethods.getPointArray(Game game)
Returns an array of points representing the feasible payoffs in this game. |
Point |
Game.payoff(int a1,
int a2)
The stage game payoff vector as a Point |
Uses of Point in edu.princeton.repeatedgames.rgsolve.polygon |
---|
Subclasses of Point in edu.princeton.repeatedgames.rgsolve.polygon | |
---|---|
class |
GameExtremePoint
This class extends the Point class. |
Methods in edu.princeton.repeatedgames.rgsolve.polygon with type parameters of type Point | ||
---|---|---|
static
|
PolygonMethods.getArea(T[] pts)
Returns the area represented by the polygon pts |
|
static
|
PolygonMethods.getListArea(java.util.ArrayList<T> pts)
|
|
static
|
RobustConvexHull.monotoneChain(java.util.List<T> points,
java.lang.Class<T> cls)
Computes the convex hull non-robustly (but quickly) |
|
static
|
RobustConvexHull.monotoneChain(T[] points,
java.lang.Class<T> cls)
Computes the convex hull non-robustly (but quickly) |
|
static
|
RobustConvexHull.monotoneChainRobust(java.util.List<T> points,
java.lang.Class<T> cls)
Computes the convex hull robustly |
|
static
|
RobustConvexHull.monotoneChainRobust(java.util.List<T> points,
java.lang.Class<T> cls,
boolean smoothHull,
double ccwTol,
double angleTol)
Computes the convex hull. |
|
static
|
RobustConvexHull.monotoneChainRobust(T[] points,
java.lang.Class<T> cls)
Computes the convex hull robustly |
|
static
|
RobustConvexHull.monotoneChainRobust(T[] points,
java.lang.Class<T> cls,
boolean smoothHull,
double ccwTol,
double angleTol)
Computes the convex hull |
Methods in edu.princeton.repeatedgames.rgsolve.polygon that return Point | ||
---|---|---|
Point |
GameExtremePoint.getPoint()
"Upcasts" this GameExtremePoint and returns
an instance of Point with the same coordinates. |
|
static
|
RobustConvexHull.monotoneChain(T[] points,
java.lang.Class<T> cls)
Computes the convex hull non-robustly (but quickly) |
|
static
|
RobustConvexHull.monotoneChainRobust(T[] points,
java.lang.Class<T> cls)
Computes the convex hull robustly |
|
static
|
RobustConvexHull.monotoneChainRobust(T[] points,
java.lang.Class<T> cls,
boolean smoothHull,
double ccwTol,
double angleTol)
Computes the convex hull |
Methods in edu.princeton.repeatedgames.rgsolve.polygon with parameters of type Point | ||
---|---|---|
static double |
RobustConvexHull.AppOrient2D(Point A,
Point B,
Point C)
Non-robust signed area calculation |
|
int |
RobustConvexHull.PointComparator.compare(Point p1,
Point p2)
|
|
static double |
RobustConvexHull.Filter(Point A,
Point B,
Point C,
int filterType)
Robust signed area calucation |
|
static
|
PolygonMethods.getArea(T[] pts)
Returns the area represented by the polygon pts |
|
(package private) static double |
RobustConvexHull.getDetRobust(Point A,
Point B,
Point C)
|
|
static double |
PolygonMethods.getPolygonVertexDistance(Point[] polygon1,
Point[] polygon2,
boolean useSupDistance)
gets distance between sorted convex polygons in terms of corresponding vertices. |
|
static double |
PolygonMethods.getPolygonVertexDistance(Point[] polygon1,
Point[] polygon2,
boolean useSupDistance)
gets distance between sorted convex polygons in terms of corresponding vertices. |
|
static double[] |
PolygonMethods.getRelativeAreaDifferences(Point[][] W1,
Point[][] W2)
|
|
static double[] |
PolygonMethods.getRelativeAreaDifferences(Point[][] W1,
Point[][] W2)
|
|
double |
RobustConvexHull.SignedAreaFunc.getSignedArea(Point A,
Point B,
Point C)
|
|
static
|
RobustConvexHull.monotoneChain(T[] points,
java.lang.Class<T> cls)
Computes the convex hull non-robustly (but quickly) |
|
static
|
RobustConvexHull.monotoneChainRobust(T[] points,
java.lang.Class<T> cls)
Computes the convex hull robustly |
|
static
|
RobustConvexHull.monotoneChainRobust(T[] points,
java.lang.Class<T> cls,
boolean smoothHull,
double ccwTol,
double angleTol)
Computes the convex hull |
|
private static boolean |
RobustConvexHull.TripleIsRobust(Point A,
Point B,
Point C,
double ccwTol,
double angleTol)
Robustness check on the adjacent triple (A,B,C) on the hull |
|
static double |
RobustConvexHull.Verified1(Point A,
Point B,
Point C)
|
|
||||||||||
PREV NEXT | FRAMES NO FRAMES |