AbstractPoint -- a type used to store a point in complex space

Description

The type Point inherited from AbstractPoint is used to store a solution to a polynomial system obtained by such functions as solveSystem, track. The following methods can be used to access a AbstractPoint:

coordinates -- get the coordinates (returns a list)
matrix -- get the coordinates (returns a matrix)
status -- get the type of solution (e.g., Regular)

Possible return values of status reflect the status with respect to a homotopy continuation procedure that obtained this point:

Regular -- the jacobian of the polynomial system is regular at the point
Singular -- the jacobian of the polynomial system is (near)singular at the point
Infinity -- the solution path is deemed divergent
MinStepFailure -- the tracker failed to stay above the minimal step increment threshold
NumericalRankFailure -- it is likely that in a sequence of deflations numerical rank did not give the correct rank
RefinementFailure -- a solution refinement function failed
Origin -- the solution path approaches the origin (impossible to give a relative error estimate)
IncreasePrecision -- the current precision is deemed inadequate for robust computation
DecreasePrecision -- the current precision is deemed excessive (more than the double of sufficient precision)
null -- the point has not been classified

Only coordinates are displayed (by net); other attributes of a Point p are stored in p.cache. Different algorithms attach different information describing the point. For example, solveSystem produces the following.

i1 : loadPackage "NumericalAlgebraicGeometry";

i2 : R = CC[x,y];

i3 : sols = solveSystem{x^2+y^2-3, x^3-y^3-7}

o3 = {{-1.7957-1.31322*ii, 1.7957-1.31322*ii}, {-.101284+.779159*ii,
     ------------------------------------------------------------------------
     -1.89699-.041601*ii}, {-1.7957+1.31322*ii, 1.7957+1.31322*ii},
     ------------------------------------------------------------------------
     {-.101284-.779159*ii, -1.89699+.041601*ii}, {1.89699+.041601*ii,
     ------------------------------------------------------------------------
     .101284-.779159*ii}, {1.89699-.041601*ii, .101284+.779159*ii}}

o3 : List

i4 : pt = first sols

o4 = pt

o4 : Point

i5 : peek pt

o5 = Point{cache => CacheTable{...5...}                          }
           Coordinates => {-1.7957-1.31322*ii, 1.7957-1.31322*ii}

i6 : coordinates pt

o6 = {-1.7957-1.31322*ii, 1.7957-1.31322*ii}

o6 : List

i7 : status pt

o7 = Regular

o7 : Symbol

The other keys that may be attached include

NumberOfSteps -- the number of steps in made by the continuation procedure
LastT -- the last value of the continuation parameter produced during tracking (equals 1 for a regular solution)
ErrorBoundEstimate -- an estimate of the distance from the approximation to the actual solution
MaxPrecision -- max precision used during the homotopy tracking
Multiplicity -- the multiplicity of an isolated solution
WindingNumber -- the winding number of a singular solution determined in the end-games
DeflationNumber -- number of first-order deflations in the regularization of a singular solution
Tracker -- reserved for developers

Basic service functions:

areEqual -- determine if solutions are equal
sortSolutions -- sort the list of solutions
isRealPoint -- determine whether a point is real
realPoints -- select real points
solutionsWithMultiplicity -- replaces clusters of approximately equal points by single points with multiplicity
norm(Thing,AbstractPoint) -- p-norm of the point
toAffineChart -- coordinates of a point in the projective space in an affine chart

Types of point:

Point

Methods that use a point:

coordinates(AbstractPoint)
matrix(AbstractPoint)
net(AbstractPoint)
status(AbstractPoint)
AbstractPoint == AbstractPoint -- see areEqual -- determine if solutions are equal
areEqual(AbstractPoint,AbstractPoint) -- see areEqual -- determine if solutions are equal
dualSpace(Matrix,AbstractPoint) -- see dualSpace -- construct a DualSpace
dualSpace(PolySpace,AbstractPoint) -- see dualSpace -- construct a DualSpace
evaluate(Matrix,AbstractPoint) -- see evaluate -- evaluate a polynomial system or matrix at a point
evaluateJacobian(PolySystem,AbstractPoint) -- see evaluate -- evaluate a polynomial system or matrix at a point
isGEQ(AbstractPoint,AbstractPoint) -- see isGEQ -- compare two points
isRealPoint(AbstractPoint) -- see isRealPoint -- determine whether a point is real
norm(Thing,AbstractPoint) -- p-norm of the point
point(AbstractPoint) -- see point -- construct a Point
project(AbstractPoint,ZZ) -- project a point
residual(System,AbstractPoint) -- see residual -- residual of a polynomial function at a point
evaluate(System,AbstractPoint) -- see System -- a system of functions
evaluate(System,AbstractPoint,AbstractPoint) -- see System -- a system of functions
evaluateJacobian(System,AbstractPoint) -- see System -- a system of functions
evaluateJacobian(System,AbstractPoint,AbstractPoint) -- see System -- a system of functions

For the programmer

The object AbstractPoint is a type, with ancestor classes HashTable < Thing.

The source of this document is in NAGtypes/doc-NAGtypes.m2:103:0.