Uses of Class
edu.princeton.plot.Point

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
<T extends Point>
void
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
<T extends Point>
double
PolygonMethods.getArea(T[] pts)
          Returns the area represented by the polygon pts
static
<T extends Point>
double
PolygonMethods.getListArea(java.util.ArrayList<T> pts)
           
static
<T extends Point>
java.util.List<T>
RobustConvexHull.monotoneChain(java.util.List<T> points, java.lang.Class<T> cls)
          Computes the convex hull non-robustly (but quickly)
static
<T extends Point>
T[]
RobustConvexHull.monotoneChain(T[] points, java.lang.Class<T> cls)
          Computes the convex hull non-robustly (but quickly)
static
<T extends Point>
java.util.List<T>
RobustConvexHull.monotoneChainRobust(java.util.List<T> points, java.lang.Class<T> cls)
          Computes the convex hull robustly
static
<T extends Point>
java.util.List<T>
RobustConvexHull.monotoneChainRobust(java.util.List<T> points, java.lang.Class<T> cls, boolean smoothHull, double ccwTol, double angleTol)
          Computes the convex hull.
static
<T extends Point>
T[]
RobustConvexHull.monotoneChainRobust(T[] points, java.lang.Class<T> cls)
          Computes the convex hull robustly
static
<T extends Point>
T[]
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
<T extends Point>
T[]
RobustConvexHull.monotoneChain(T[] points, java.lang.Class<T> cls)
          Computes the convex hull non-robustly (but quickly)
static
<T extends Point>
T[]
RobustConvexHull.monotoneChainRobust(T[] points, java.lang.Class<T> cls)
          Computes the convex hull robustly
static
<T extends Point>
T[]
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
<T extends Point>
double
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
<T extends Point>
T[]
RobustConvexHull.monotoneChain(T[] points, java.lang.Class<T> cls)
          Computes the convex hull non-robustly (but quickly)
static
<T extends Point>
T[]
RobustConvexHull.monotoneChainRobust(T[] points, java.lang.Class<T> cls)
          Computes the convex hull robustly
static
<T extends Point>
T[]
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)