This is Bertini.info, produced by Macaulay2, version 1.22

Bertini -- software for numerical algebraic geometry
****************************************************

Description
===========

Interfaces the functionality of the software Bertini to solve polynomial
systems and perform calculations in numerical algebraic geometry. The software
is available at http://bertini.nd.edu/. Bertini is under ongoing development by
D. Bates, J. Hauenstein, A. Sommese, and C. Wampler.

The user may place the executable program bertini in the execution path.
Alternatively, the path to the executable needs to be specified, for instance,

+-----------------------------------------------------------------------------+
|i1 : needsPackage("Bertini",                                                 |
|                                                                             |
|o1 = Bertini                                                                 |
|                                                                             |
|o1 : Package                                                                 |
|-----------------------------------------------------------------------------|
|Configuration=>{"BERTINIexecutable"=>"/folder/subfolder/bertini"})           |
+-----------------------------------------------------------------------------+

Below is a simple example using the most popular function, a basic
zero-dimensional solve with no special options.

+-----------------------------------------------------------------+
|i2 : R = CC[x,y]                                                 |
|                                                                 |
|o2 = R                                                           |
|                                                                 |
|o2 : PolynomialRing                                              |
+-----------------------------------------------------------------+
|i3 : F = {x^2-1,y^2-2}                                           |
|                                                                 |
|       2       2                                                 |
|o3 = {x  - 1, y  - 2}                                            |
|                                                                 |
|o3 : List                                                        |
+-----------------------------------------------------------------+
|i4 : solns = bertiniZeroDimSolve(F)                              |
|                                                                 |
|o4 = {{1, 1.41421}, {1, -1.41421}, {-1, 1.41421}, {-1, -1.41421}}|
|                                                                 |
|o4 : List                                                        |
+-----------------------------------------------------------------+

Authors
=======

  * Elizabeth Gross (see http://math.sjsu.edu/~egross )
    <elizabeth.gross@sjsu.edu>
  * Jose Israel Rodriguez (see https://www.math.wisc.edu/~jose/ )
    <Jose@math.wisc.edu>
  * Dan Bates (see http://www.math.colostate.edu/~bates )
    <bates@math.colostate.edu>
  * Anton Leykin (see http://www.math.gatech.edu/~leykin )
    <leykin@math.gatech.edu>

Version
=======

This documentation describes version 2.1.2.3 of Bertini.

Source code
===========

The source code from which this documentation is derived is in the file
Bertini.m2 (see common/share/Macaulay2/Bertini.m2 ). The auxiliary files
accompanying it are in the directory Bertini/ (see
common/share/Macaulay2/Bertini/ ).

Exports
=======

  * Types
      * B'Section -- a mutable hash table that gives
        information about a hyperplane used to slice a numerical variety.
  * Functions and commands
      * bertiniComponentMemberTest -- a main
        method to test whether points lie on a given variety
      * bertiniParameterHomotopy -- a main
        method to perform a parameter homotopy in Bertini
      * bertiniPosDimSolve -- a main method that is
        used to produce witness sets
      * bertiniRefineSols -- sharpen solutions to a
        prescribed number of digits
      * bertiniSample -- a main method to sample points
        from an irreducible component of a variety
      * bertiniTrackHomotopy -- a main method to
        track using a user-defined homotopy
      * bertiniUserHomotopy -- a main method to
        track a user-defined homotopy
      * bertiniZeroDimSolve -- a main method to
        solve a zero-dimensional system of equations
      * importIncidenceMatrix -- Imports an
        incidence matrix file after running makeMembershipFile.
      * importMainDataFile -- This function imports
        points from the main data file form a Bertini run.
      * importParameterFile -- Imports parameters
        from a Bertini parameter file.
      * importSolutionsFile -- Imports coordinates
        from a Bertini solution file.
      * makeB'InputFile -- write a Bertini input file
        in a directory
      * makeB'Section -- makeB'Section creates a hash
        table that represents a hyperplane.
      * makeB'Slice -- makeB'Slice creates a hash table
        that represents a linear slice.
      * moveB'File -- Move or copy files.
      * NumberToB'String -- Translates a number to a
        string that Bertini can read.
      * radicalList -- A support function that removes
        multiplicities of numbers in a list up to a tolerance.
      * subPoint -- This function evaluates a polynomial or
        matrix at a point.
      * valueBM2 -- This function makes a number in CC from a
        string.
      * writeStartFile -- Writes the list of list of
        coordinates to a file that Bertini can read.
  * Methods
      * "bertiniComponentMemberTest(List,NumericalVariety)" -- see
        bertiniComponentMemberTest, -- a main
        method to test whether points lie on a given variety
      * "bertiniParameterHomotopy(List,List,List)" -- see
        bertiniParameterHomotopy, -- a main method to
        perform a parameter homotopy in Bertini
      * "bertiniPosDimSolve(Ideal)" -- see bertiniPosDimSolve,
        -- a main method that is used to produce witness
        sets
      * "bertiniPosDimSolve(List)" -- see bertiniPosDimSolve,
        -- a main method that is used to produce witness
        sets
      * "bertiniRefineSols(ZZ,List,List)" -- see bertiniRefineSols,
        -- sharpen solutions to a prescribed number of
        digits
      * "bertiniSample(ZZ,WitnessSet)" -- see bertiniSample,
        -- a main method to sample points from an irreducible
        component of a variety
      * "bertiniTrackHomotopy(RingElement,List,List)" -- see
        bertiniTrackHomotopy, -- a main method to track
        using a user-defined homotopy
      * "bertiniUserHomotopy(Thing,List,List,List)" -- see
        bertiniUserHomotopy, -- a main method to track a
        user-defined homotopy
      * "bertiniZeroDimSolve(Ideal)" -- see bertiniZeroDimSolve,
        -- a main method to solve a zero-dimensional
        system of equations
      * "bertiniZeroDimSolve(List)" -- see bertiniZeroDimSolve,
        -- a main method to solve a zero-dimensional
        system of equations
      * "importIncidenceMatrix(String)" -- see importIncidenceMatrix,
        -- Imports an incidence matrix file after
        running makeMembershipFile.
      * "importMainDataFile(String)" -- see importMainDataFile,
        -- This function imports points from the main data
        file form a Bertini run.
      * "importParameterFile(String)" -- see importParameterFile,
        -- Imports parameters from a Bertini parameter
        file.
      * "importSolutionsFile(String)" -- see importSolutionsFile,
        -- Imports coordinates from a Bertini solution
        file.
      * "makeB'InputFile(String)" -- see makeB'InputFile,
        -- write a Bertini input file in a directory
      * "makeB'Section(List)" -- see makeB'Section, --
        makeB'Section creates a hash table that represents a hyperplane.
      * "makeB'Slice(Thing,List)" -- see makeB'Slice, --
        makeB'Slice creates a hash table that represents a linear slice.
      * "moveB'File(String,String,String)" -- see moveB'File,
        -- Move or copy files.
      * "NumberToB'String(Thing)" -- see NumberToB'String,
        -- Translates a number to a string that Bertini can
        read.
      * "radicalList(List)" -- see radicalList, -- A support
        function that removes multiplicities of numbers in a list up to a
        tolerance.
      * "radicalList(List,Number)" -- see radicalList, -- A
        support function that removes multiplicities of numbers in a list up to
        a tolerance.
      * "subPoint(Thing,List,Thing)" -- see subPoint, -- This
        function evaluates a polynomial or matrix at a point.
      * "valueBM2(String)" -- see valueBM2, -- This function
        makes a number in CC from a string.
      * "writeStartFile(String,List)" -- see writeStartFile,
        -- Writes the list of list of coordinates to a file
        that Bertini can read.
  * Symbols
      * B'Constants -- an option to designate the constants
        for a Bertini Input file
      * "CoeffBound" -- see Bertini input configuration,
        -- a configuration option for a Bertini input file
      * "CondNumThreshold" -- see Bertini input configuration,
        -- a configuration option for a Bertini input file
      * "DegreeBound" -- see Bertini input configuration,
        -- a configuration option for a Bertini input file
      * "EndGameNum" -- see Bertini input configuration,
        -- a configuration option for a Bertini input file
      * "FinalTol" -- see Bertini input configuration,
        -- a configuration option for a Bertini input file
      * "ImagThreshold" -- see Bertini input configuration,
        -- a configuration option for a Bertini input file
      * "MaxCycleNum" -- see Bertini input configuration,
        -- a configuration option for a Bertini input file
      * "MaxNewtonIts" -- see Bertini input configuration,
        -- a configuration option for a Bertini input file
      * "MaxNorm" -- see Bertini input configuration,
        -- a configuration option for a Bertini input file
      * "MaxNumberSteps" -- see Bertini input configuration,
        -- a configuration option for a Bertini input file
      * "MaxStepSize" -- see Bertini input configuration,
        -- a configuration option for a Bertini input file
      * "MinStepSizeBeforeEG" -- see Bertini input configuration,
        -- a configuration option for a Bertini input file
      * "MinStepSizeDuringEG" -- see Bertini input configuration,
        -- a configuration option for a Bertini input file
      * "MPType" -- see Bertini input configuration,
        -- a configuration option for a Bertini input file
      * "ODEPredictor" -- see Bertini input configuration,
        -- a configuration option for a Bertini input file
      * "OutputLevel" -- see Bertini input configuration,
        -- a configuration option for a Bertini input file
      * "PRECISION" -- see Bertini input configuration,
        -- a configuration option for a Bertini input file
      * "RandomSeed" -- see Bertini input configuration,
        -- a configuration option for a Bertini input file
      * "RegenStartLevel" -- see Bertini input configuration,
        -- a configuration option for a Bertini input file
      * "ScreenOut" -- see Bertini input configuration,
        -- a configuration option for a Bertini input file
      * "SecurityLevel" -- see Bertini input configuration,
        -- a configuration option for a Bertini input file
      * "SingValZeroTol" -- see Bertini input configuration,
        -- a configuration option for a Bertini input file
      * "StepsForIncrease" -- see Bertini input configuration,
        -- a configuration option for a Bertini input file
      * "TrackTolBeforeEG" -- see Bertini input configuration,
        -- a configuration option for a Bertini input file
      * "TrackTolDuringEG" -- see Bertini input configuration,
        -- a configuration option for a Bertini input file
      * "RandomComplex" -- see Bertini input file declarations_colon_ random numbers,
        --
        an option which designates symbols/strings/variables that will be set
        to be a random real number or random complex number
      * "RandomReal" -- see Bertini input file declarations_colon_ random numbers,
        -- an
        option which designates symbols/strings/variables that will be set to
        be a random real number or random complex number
      * CopyB'File -- an optional argument to specify
        whether make a copy of the file.
      * IsProjective -- optional argument to specify
        whether to use homogeneous coordinates
      * "NameB'Slice" -- see makeB'Slice, -- makeB'Slice
        creates a hash table that represents a linear slice.
      * TopDirectory -- Option to change directory for
        file storage.
      * UseRegeneration -- an option specifying when to
        use regeneration
      * "AffVariableGroup" -- see Variable groups, -- an
        option to group variables and use multihomogeneous homotopies
      * "HomVariableGroup" -- see Variable groups, -- an
        option to group variables and use multihomogeneous homotopies
  * Other things
      * storeBM2Files (missing documentation)

For the programmer
==================

The object Bertini, is a package (Macaulay2Doc).

B'Constants -- an option to designate the constants for a Bertini Input file
****************************************************************************

Description
===========

This option should be set to a list of options X=>v with X denoting the
constant as an indeterminant and v as it's value.

+-----------------------------------------------------+
|i1 : R=QQ[z,a,b,c]                                   |
|                                                     |
|o1 = R                                               |
|                                                     |
|o1 : PolynomialRing                                  |
+-----------------------------------------------------+
|i2 : makeB'InputFile(storeBM2Files,                  |
|              BertiniInputConfiguration=>{MPType=>2},|
|              AffVariableGroup=>{{z}},               |
|               B'Constants=>{a=>2,b=>3+2*ii,c=>3/2}, |
|                B'Polynomials=>{a*z^2+b*z+c});       |
+-----------------------------------------------------+

Functions with optional argument named B'Constants :
====================================================

  * "bertiniParameterHomotopy(...,B'Constants=>...)"
  * "bertiniZeroDimSolve(...,B'Constants=>...)"
  * "makeB'InputFile(...,B'Constants=>...)"
  * bertiniUserHomotopy(...,B'Constants=>...) (missing documentation)

For the programmer
==================

The object B'Constants, is a symbol (Macaulay2Doc).

B'Section -- a mutable hash table that gives information about a hyperplane used to slice a numerical variety.
**************************************************************************************************************

Description
===========

B'Section is a type of mutable hash table. It can be created using
makeB'Section.

For the programmer
==================

The object B'Section, is a type (Macaulay2Doc),
with ancestor classes MutableHashTable (Macaulay2Doc), <
HashTable (Macaulay2Doc) < Thing (Macaulay2Doc).

B'Slice -- a mutable hash table that gives information about a linear space used to slice a numerical variety.
**************************************************************************************************************

Description
===========

B'Slice is a type of mutable hash table. It can be created using makeB'Slice.

For the programmer
==================

The object B'Slice, is a type (Macaulay2Doc), with
ancestor classes MutableHashTable (Macaulay2Doc), <
HashTable (Macaulay2Doc) < Thing (Macaulay2Doc).

Bertini input configuration -- a configuration option for a Bertini input file
******************************************************************************

Refer to Appendix E of SIAM Bertini book for full details and list of options.

MPType: Type of precision (0=double, 1=fixed higher, 2=adaptive).

PRECISION: Precision, in bits, when used MPType=1. Precision is capitalized
here to not conflict with Precision.

ODEPredictor: Choice of predictor method (9 choices).

TrackTolBeforeEG: Before endgame zone, Newton error must be less than this for
success.

TrackTolDuringEG: Same as previous, but during endgame.

FinalTol: Path is deemed successful if final two endpoint approximations agree
to FinalTol.

MaxNorm: If SecurityLevel=0, path is truncated if two consecutive endpoint
approximations exceed this value.

MinStepSizeBeforeEG: Path is truncated if stepsize drops below this level
before endgame.

MinStepSizeDuringEG: Same as previous, but during endgame.

ImagThreshold: Endpoint deemed real if infinity norm is smaller than this.

CoeffBound: Useful only if MPType=2, bound on sum of coefficients of each
polynomial.

DegreeBound: Useful only if MPType=2, bound on degree of each polynomial.

CondNumThreshold: Endpoint is deemed singular if multiple paths lead to it or
condition number exceeds this.

RandomSeed: Useful to repeat runs with the same random numbers.

SingValZeroTol: Singular value is considered 0 if less than this value, when
using fixed precision.

EndGameNum: Choice of endgame (1=power series, 2=Cauchy, 3=trackback Cauchy).

UseRegeneration: 1 to use regeneration for a zero-dimensional run.

SecurityLevel: 1 to avoid truncation of possibly-infinite paths.

ScreenOut: Level of output to the screen.

OutputLevel: Level of output to files.

StepsForIncrease: Number of consecutive Newton corrector successes before
increase of stepsize.

MaxNewtonIts: Newton corrector step deemed failed if no convergence prior to
this number of iterations.

MaxStepSize: Largest stepsize allowed.

MaxNumberSteps: Max number of steps for entire path.  Path failure if number of
steps exceeds this.

MaxCycleNum: Max cycle number considered during endgame.

RegenStartLevel: Level at which regeneration begins.

There are two recommended ways of using the optional arguments based on
zero-dim solving and pos-dim solving.

(1) Specify individual parameters in a function call:

+-----------------------------------------------------------------------------+
|i1 : CC[x,y]; F = {x^2-1,y^2-1};                                             |
+-----------------------------------------------------------------------------+
|i3 : bertiniZeroDimSolve(F,BertiniInputConfiguration=>{RandomSeed=>0,        |
|                                                                             |
|o3 = {{1, 1}, {1, -1}, {-1, 1}, {-1, -1}}                                    |
|                                                                             |
|o3 : List                                                                    |
|-----------------------------------------------------------------------------|
|TrackTolBeforeEG=>1e-6,FinalTol=>1e-100})                                    |
+-----------------------------------------------------------------------------+

(2) Store your frequently used favorites in an OptionTable and pass it as the
last argument in each function call:

+-----------------------------------------------------------------------------+
|i4 : opts = new OptionTable from {BertiniInputConfiguration=>{               |
|                                                                             |
|o4 = OptionTable{BertiniInputConfiguration => {RandomSeed => 0               |
|                                                                             |
|o4 : OptionTable                                                             |
|-----------------------------------------------------------------------------|
|RandomSeed=>0,TrackTolBeforeEG=>1e-6,FinalTol=>1e-100}}                      |
|                                                                             |
|, TrackTolBeforeEG => .000001, FinalTol => 1e-100}}                          |
+-----------------------------------------------------------------------------+
|i5 : G = {x^2+y^2-1};                                                        |
+-----------------------------------------------------------------------------+
|i6 : bertiniPosDimSolve(G,opts)                                              |
|                                                                             |
|o6 = a numerical variety with components in                                  |
|     dim 1:  (dim=1,deg=2)                                                   |
|                                                                             |
|o6 : NumericalVariety                                                        |
+-----------------------------------------------------------------------------+

Bertini input file declarations: random numbers -- an option which designates symbols/strings/variables that will be set to be a random real number or random complex number
****************************************************************************************************************************************************************************

This option should be set to a list of symbols, strings, or variables. Elements
of this list will be fixed to random real/complex numbers when Bertini is
called.

+-----------------------------------------------------------------------------+
|i1 : R=QQ[x,y,c1,c2]                                                         |
|                                                                             |
|o1 = R                                                                       |
|                                                                             |
|o1 : PolynomialRing                                                          |
+-----------------------------------------------------------------------------+
|i2 : makeB'InputFile(storeBM2Files,                                          |
|              AffVariableGroup=>{{x,y}},                                     |
|              RandomReal=>{c1,c2},--c1=.1212, c2=.4132 may be written to the |
|              B'Polynomials=>{x-c1,y-c2});                                   |
|-----------------------------------------------------------------------------|
|input file.                                                                  |
+-----------------------------------------------------------------------------+
+-----------------------------------------------------------------------------+
|i3 : R=QQ[x,y,c1,c2]                                                         |
|                                                                             |
|o3 = R                                                                       |
|                                                                             |
|o3 : PolynomialRing                                                          |
+-----------------------------------------------------------------------------+
|i4 : makeB'InputFile(storeBM2Files,                                          |
|              AffVariableGroup=>{{x,y}},                                     |
|              RandomComplex=>{c1,c2},--c1=.1212+ii*.1344, c2=.4132-ii*.2144  |
|              B'Polynomials=>{x-c1,y-c2});                                   |
|-----------------------------------------------------------------------------|
|are written to the input file.                                               |
+-----------------------------------------------------------------------------+

AFTER Bertini is run, the random values are stored in a file named
"random_values".

bertiniComponentMemberTest -- a main method to test whether points lie on a given variety
*****************************************************************************************

Synopsis
========

  * Usage:
        L = bertiniComponentMemberTest (pts, NV)
  * Inputs:
      * pts, a list (Macaulay2Doc), a list of points to test
      * NV, a numerical variety (NAGtypes), a numerical
        variety to test if points lie on a given irreducible component
  * Optional inputs (Macaulay2Doc),:
      * BertiniInputConfiguration (missing documentation) => ..., default value
        {}, null
      * IsProjective, => ..., default value -1, optional
        argument to specify whether to use homogeneous coordinates
      * Verbose,
        => ..., default value false, Option to silence additional output
  * Outputs:
      * L, a list (Macaulay2Doc), entries are lists of witness sets
        containing the test point

Description
===========

This method checks whether the test points pts lie on NV using Bertini by (1)
writing the witness set information of NV and the test points to temporary
files, (2) invokes Bertini's solver with option TRACKTYPE => 3, (3) stores
output of Bertini in temporary file, (4) parses and outputs the solutions.

+-----------------------------------------------+
|i1 : R = CC[x,y,z];                            |
+-----------------------------------------------+
|i2 : F = {(y^2+x^2+z^2-1)*x,(y^2+x^2+z^2-1)*y};|
+-----------------------------------------------+
|i3 : NV = bertiniPosDimSolve(F)                |
|                                               |
|o3 = NV                                        |
|                                               |
|o3 : NumericalVariety                          |
+-----------------------------------------------+
|i4 : pts = {{0,0,0}} --z-axis                  |
|                                               |
|o4 = {{0, 0, 0}}                               |
|                                               |
|o4 : List                                      |
+-----------------------------------------------+
|i5 : bertiniComponentMemberTest(pts, NV)       |
|                                               |
|o5 = {{(dim=1,deg=1)}}                         |
|                                               |
|o5 : List                                      |
+-----------------------------------------------+

In the current implementation, at most one witness set is listed for each test
point although the point may lie on more than one component.

Ways to use bertiniComponentMemberTest :
========================================

  * "bertiniComponentMemberTest(List,NumericalVariety)"

For the programmer
==================

The object bertiniComponentMemberTest, is a
method function with options (Macaulay2Doc).

bertiniParameterHomotopy -- a main method to perform a parameter homotopy in Bertini
************************************************************************************

Synopsis
========

  * Usage:
        S = bertiniParameterHomotopy(F,P,T)
  * Inputs:
      * F, a list (Macaulay2Doc), a list of polynomials
      * P, a list (Macaulay2Doc), a list of parameter
        indeterminants
      * T, a list (Macaulay2Doc), a list of lists of target
        parameter values
  * Optional inputs (Macaulay2Doc),:
      * AffVariableGroup, => ..., default value {}, an
        option to group variables and use multihomogeneous homotopies
      * B'Constants, => ..., default value {}, an option to
        designate the constants for a Bertini Input file
      * B'Functions (missing documentation) => ..., default value {}, null
      * BertiniInputConfiguration (missing documentation) => ..., default value
        {}, null
      * HomVariableGroup, => ..., default value {}, an
        option to group variables and use multihomogeneous homotopies
      * M2Precision (missing documentation) => ..., default value 53, null
      * OutputStyle (missing documentation) => ..., default value "OutPoints",
        null
      * RandomComplex,
        => ..., default value {}, an option which designates
        symbols/strings/variables that will be set to be a random real number
        or random complex number
      * RandomReal, =>
        ..., default value {}, an option which designates
        symbols/strings/variables that will be set to be a random real number
        or random complex number
      * TopDirectory, => ..., default value
        "/var/folders/p7/xwnp7z5d3gj2rvmpgtm68nnh0000gn/T/M2-21575-0/0", Option
        to change directory for file storage.
      * Verbose,
        => ..., default value false, Option to silence additional output
  * Outputs:
      * S, a list (Macaulay2Doc), a list whose entries are lists of
        solutions for each target system

Description
===========

This method numerically solves several polynomial systems from a parameterized
family at once.  The list F is a system of polynomials in ring variables and
the parameters listed in P.  The list T is the set of parameter values for
which solutions to F are desired.  Both stages of Bertini's parameter homotopy
method are called with bertiniParameterHomotopy. First, Bertini assigns a
random complex number to each parameter and solves the resulting system, then,
after this initial phase, Bertini computes solutions for every given choice of
parameters using a number of paths equal to the exact root count in the first
stage.

+-----------------------------------------------------------------------------+
|i1 : R=CC[u1,u2,u3,x,y];                                                     |
+-----------------------------------------------------------------------------+
|i2 : f1=u1*(y-1)+u2*(y-2)+u3*(y-3); --parameters are u1, u2, and u3          |
+-----------------------------------------------------------------------------+
|i3 : f2=(x-11)*(x-12)*(x-13)-u1;                                             |
+-----------------------------------------------------------------------------+
|i4 : paramValues0={1,0,0};                                                   |
+-----------------------------------------------------------------------------+
|i5 : paramValues1={0,1+2*ii,0};                                              |
+-----------------------------------------------------------------------------+
|i6 : bPH=bertiniParameterHomotopy( {f1,f2}, {u1,u2,u3},{paramValues0 ,paramVa|
|                                                                             |
|o6 = {{{11.3376+.56228*ii, 1}, {13.3247, 1}, {11.3376-.56228*ii, 1}}, {{12,  |
|     ------------------------------------------------------------------------|
|     2}, {13, 2}, {11, 2}}}                                                  |
|                                                                             |
|o6 : List                                                                    |
|-----------------------------------------------------------------------------|
|lues1 })                                                                     |
+-----------------------------------------------------------------------------+
|i7 : bPH_0--the solutions to the system with parameters set equal to         |
|                                                                             |
|o7 = {{11.3376+.56228*ii, 1}, {13.3247, 1}, {11.3376-.56228*ii, 1}}          |
|                                                                             |
|o7 : List                                                                    |
|-----------------------------------------------------------------------------|
|paramValues0                                                                 |
+-----------------------------------------------------------------------------+
+-----------------------------------------------------------------------------+
|i8 : R=CC[x,y,z,u1,u2]                                                       |
|                                                                             |
|o8 = R                                                                       |
|                                                                             |
|o8 : PolynomialRing                                                          |
+-----------------------------------------------------------------------------+
|i9 : f1=x^2+y^2-z^2                                                          |
|                                                                             |
|      2    2    2                                                            |
|o9 = x  + y  - z                                                             |
|                                                                             |
|o9 : R                                                                       |
+-----------------------------------------------------------------------------+
|i10 : f2=u1*x+u2*y                                                           |
|                                                                             |
|o10 = x*u1 + y*u2                                                            |
|                                                                             |
|o10 : R                                                                      |
+-----------------------------------------------------------------------------+
|i11 : finalParameters0={0,1}                                                 |
|                                                                             |
|o11 = {0, 1}                                                                 |
|                                                                             |
|o11 : List                                                                   |
+-----------------------------------------------------------------------------+
|i12 : finalParameters1={1,0}                                                 |
|                                                                             |
|o12 = {1, 0}                                                                 |
|                                                                             |
|o12 : List                                                                   |
+-----------------------------------------------------------------------------+
|i13 : bPH=bertiniParameterHomotopy( {f1,f2}, {u1,u2},{finalParameters0 ,final|
|                                                                             |
|o13 = {{{1, -2.30252e-16+1.70802e-16*ii, -1}, {1,                            |
|      -----------------------------------------------------------------------|
|      -5.73444e-16+3.53557e-16*ii, 1}}, {{-2.9577e-16-1.70683e-16*ii, 1, 1}, |
|      -----------------------------------------------------------------------|
|      {-2.1372e-17-6.80607e-17*ii, 1, -1}}}                                  |
|                                                                             |
|o13 : List                                                                   |
|-----------------------------------------------------------------------------|
|Parameters1 },HomVariableGroup=>{x,y,z})                                     |
+-----------------------------------------------------------------------------+
|i14 : bPH_0--The two solutions for finalParameters0                          |
|                                                                             |
|o14 = {{1, -2.30252e-16+1.70802e-16*ii, -1}, {1, -5.73444e-16+3.53557e-16*ii,|
|      -----------------------------------------------------------------------|
|      1}}                                                                    |
|                                                                             |
|o14 : List                                                                   |
+-----------------------------------------------------------------------------+
+-----------------------------------------------------------------------------+
|i15 : finParamValues={{1},{2}}                                               |
|                                                                             |
|o15 = {{1}, {2}}                                                             |
|                                                                             |
|o15 : List                                                                   |
+-----------------------------------------------------------------------------+
|i16 : bPH1=bertiniParameterHomotopy( {"x^2-u1"},                             |
|                                                                             |
|o16 = {{{1}, {-1}}, {{1.41421}, {-1.41421}}}                                 |
|                                                                             |
|o16 : List                                                                   |
|-----------------------------------------------------------------------------|
|{u1},finParamValues,AffVariableGroup=>{x})                                   |
+-----------------------------------------------------------------------------+
|i17 : bPH2=bertiniParameterHomotopy( {"x^2-u1"},                             |
|                                                                             |
|o17 = {{{1}, {-1}}, {{1.41421}, {-1.41421}}}                                 |
|                                                                             |
|o17 : List                                                                   |
|-----------------------------------------------------------------------------|
|{u1},finParamValues,AffVariableGroup=>{x},OutputStyle=>"OutSolutions")       |
+-----------------------------------------------------------------------------+
|i18 : class bPH1_0_0                                                         |
|                                                                             |
|o18 = Point                                                                  |
|                                                                             |
|o18 : Type                                                                   |
+-----------------------------------------------------------------------------+
|i19 : class bPH2_0_0                                                         |
|                                                                             |
|o19 = List                                                                   |
|                                                                             |
|o19 : Type                                                                   |
+-----------------------------------------------------------------------------+
+-----------------------------------------------------------------------------+
|i20 : dir1 := temporaryFileName(); -- build a directory to store temporary   |
|-----------------------------------------------------------------------------|
|data                                                                         |
+-----------------------------------------------------------------------------+
|i21 : makeDirectory dir1;                                                    |
+-----------------------------------------------------------------------------+
|i22 : bPH5=bertiniParameterHomotopy( {"x^2-u1"},                             |
|-----------------------------------------------------------------------------|
|{u1},{{1},{2}},AffVariableGroup=>{x},OutputStyle=>"OutNone",TopDirectory=>   |
|-----------------------------------------------------------------------------|
|dir1)                                                                        |
+-----------------------------------------------------------------------------+
|i23 : B0=importSolutionsFile(dir1,NameSolutionsFile=>"ph_jade_0")            |
|                                                                             |
|o23 = {{1}, {-1}}                                                            |
|                                                                             |
|o23 : List                                                                   |
+-----------------------------------------------------------------------------+
|i24 : B1=importSolutionsFile(dir1,NameSolutionsFile=>"ph_jade_1")            |
|                                                                             |
|o24 = {{1.41421}, {-1.41421}}                                                |
|                                                                             |
|o24 : List                                                                   |
+-----------------------------------------------------------------------------+

Ways to use bertiniParameterHomotopy :
======================================

  * "bertiniParameterHomotopy(List,List,List)"

For the programmer
==================

The object bertiniParameterHomotopy, is a
method function with options (Macaulay2Doc).

bertiniPosDimSolve -- a main method that is used to produce witness sets
************************************************************************

Synopsis
========

  * Usage:
        V = bertiniPosDimSolve I
        V = bertiniPosDimSolve F
  * Inputs:
      * F, a list (Macaulay2Doc), a list of ring elements defining
        a variety
  * Optional inputs (Macaulay2Doc),:
      * BertiniInputConfiguration (missing documentation) => ..., default value
        {}, null
      * IsProjective, => ..., default value -1, optional
        argument to specify whether to use homogeneous coordinates
      * Verbose,
        => ..., default value false, Option to silence additional output
  * Outputs:
      * V, a numerical variety (NAGtypes), a numerical
        irreducible decomposition of the variety defined by F

Description
===========

The method bertiniPosDimSolve calls  Bertini to find a numerical irreducible
decomposition of the zero-set of F.  The decomposition is returned as the
NumericalVariety (NAGtypes), NV.  Witness sets of NV contain
approximations to solutions of the system F=0. Bertini (1) writes the system to
temporary files, (2) invokes Bertini's solver with TrackType => 1, (3) Bertini
uses a cascade homotopy to find witness supersets in each dimension, (4)
removes extra points using a membership test or local dimension test, (5)
deflates singular witness points, and finally (6) decomposes using a
combination of monodromy and a linear trace test

+-----------------------------------------------------------------------------+
|i1 : R = QQ[x,y,z]                                                           |
|                                                                             |
|o1 = R                                                                       |
|                                                                             |
|o1 : PolynomialRing                                                          |
+-----------------------------------------------------------------------------+
|i2 : F = {(y^2+x^2+z^2-1)*x,(y^2+x^2+z^2-1)*y}                               |
|                                                                             |
|       3      2      2       2     3      2                                  |
|o2 = {x  + x*y  + x*z  - x, x y + y  + y*z  - y}                             |
|                                                                             |
|o2 : List                                                                    |
+-----------------------------------------------------------------------------+
|i3 : S = bertiniPosDimSolve F                                                |
|                                                                             |
|o3 = S                                                                       |
|                                                                             |
|o3 : NumericalVariety                                                        |
+-----------------------------------------------------------------------------+
|i4 : S#1_0#Points -- 1_0 chooses the first witness set in dimension 1        |
|                                                                             |
|o4 = {{-1.10806e-63-6.72876e-63*ii, 7.72046e-63-5.95645e-64*ii, .397346      |
|                                                                             |
|o4 : VerticalList                                                            |
|-----------------------------------------------------------------------------|
|+.0700853*ii}}                                                               |
+-----------------------------------------------------------------------------+

Each WitnessSet (NAGtypes), is accessed by dimension and then
list position.

+-----------------------------------------------------------------------------+
|i5 : S#1 --first specify dimension                                           |
|                                                                             |
|o5 = {(dim=1,deg=1)}                                                         |
|                                                                             |
|o5 : List                                                                    |
+-----------------------------------------------------------------------------+
|i6 : peek oo_0 --then list position                                          |
|                                                                             |
|o6 = WitnessSet{cache => CacheTable{...3...}                                 |
|                Equations => {-3} | x3+xy2+xz2-x |                           |
|                             {-3} | x2y+y3+yz2-y |                           |
|                Points => {{-1.10806e-63-6.72876e-63*ii, 7.72046e-63-        |
|                Slice => | -1.51179-2.7846ii -.654837-3.31013ii 4.905        |
|-----------------------------------------------------------------------------|
|                                     }                                       |
|                                                                             |
|                                                                             |
|5.95645e-64*ii, .397346+.0700853*ii}}                                        |
|-1.2379ii -2.03574+.148105ii |                                               |
+-----------------------------------------------------------------------------+

In the example, we find two components, one component has dimension 1 and
degree 1 and the other has dimension 2 and degree 2.  We get the same results
using symbolic methods.

+--------------------------------------------+
|i7 : PD=primaryDecomposition( ideal F)      |
|                                            |
|             2    2    2                    |
|o7 = {ideal(x  + y  + z  - 1), ideal (y, x)}|
|                                            |
|o7 : List                                   |
+--------------------------------------------+
|i8 : dim PD_0                               |
|                                            |
|o8 = 2                                      |
+--------------------------------------------+
|i9 : degree PD_0                            |
|                                            |
|o9 = 2                                      |
+--------------------------------------------+
|i10 : dim PD_1                              |
|                                            |
|o10 = 1                                     |
+--------------------------------------------+
|i11 : degree PD_1                           |
|                                            |
|o11 = 1                                     |
+--------------------------------------------+

Ways to use bertiniPosDimSolve :
================================

  * "bertiniPosDimSolve(Ideal)"
  * "bertiniPosDimSolve(List)"

For the programmer
==================

The object bertiniPosDimSolve, is a method function with options (Macaulay2Doc).

bertiniRefineSols -- sharpen solutions to a prescribed number of digits
***********************************************************************

Synopsis
========

  * Usage:
        S = bertiniRefineSols(d, F, l)
  * Inputs:
      * d, an integer (Macaulay2Doc), an integer specifying the
        number of digits of precision
      * F, a list (Macaulay2Doc), a list of polynomials (system
        need not be square)
      * l, a list (Macaulay2Doc), a list of points to be sharpened
  * Optional inputs (Macaulay2Doc),:
      * BertiniInputConfiguration (missing documentation) => ..., default value
        {}, null
      * IsProjective, => ..., default value -1, optional
        argument to specify whether to use homogeneous coordinates
      * Verbose,
        => ..., default value false, Option to silence additional output
  * Outputs:
      * S, a list (Macaulay2Doc), a list of solutions of type Point

Description
===========

This method takes the list l of solutions of F and sharpens them to d digits
using the sharpening module of Bertini.

+-----------------------------------------------------------------------------+
|i1 : R = CC[x,y];                                                            |
+-----------------------------------------------------------------------------+
|i2 : F = {x^2-2,y^2-2};                                                      |
+-----------------------------------------------------------------------------+
|i3 : sols = bertiniZeroDimSolve (F)                                          |
|                                                                             |
|o3 = {{1.41421, 1.41421}, {1.41421, -1.41421}, {-1.41421, 1.41421},          |
|     ------------------------------------------------------------------------|
|     {-1.41421, -1.41421}}                                                   |
|                                                                             |
|o3 : List                                                                    |
+-----------------------------------------------------------------------------+
|i4 : S = bertiniRefineSols (100, F, sols)                                    |
|                                                                             |
|o4 = {[RF], [RF], [RF], [RF]}                                                |
|                                                                             |
|o4 : List                                                                    |
+-----------------------------------------------------------------------------+
|i5 : coords = coordinates S_0                                                |
|                                                                             |
|o5 = {-1.41421, -1.41421}                                                    |
|                                                                             |
|o5 : List                                                                    |
+-----------------------------------------------------------------------------+
|i6 : coords_0                                                                |
|                                                                             |
|o6 = -1.41421-1.11022e-16*ii                                                 |
|                                                                             |
|o6 : CC (of precision 333)                                                   |
+-----------------------------------------------------------------------------+

See bertiniRefineSols, will only refine non-singular
solutions and does not currently work for homogeneous systems.

Ways to use bertiniRefineSols :
===============================

  * "bertiniRefineSols(ZZ,List,List)"

For the programmer
==================

The object bertiniRefineSols, is a method function with options (Macaulay2Doc).

bertiniSample -- a main method to sample points from an irreducible component of a variety
******************************************************************************************

Synopsis
========

  * Usage:
        V = bertiniSample (n, W)
  * Inputs:
      * n, an integer (Macaulay2Doc), an integer specifying the
        number of desired sample points
      * W, a witness set (NAGtypes), a witness set for an
        irreducible component
  * Optional inputs (Macaulay2Doc),:
      * BertiniInputConfiguration (missing documentation) => ..., default value
        {}, null
      * IsProjective, => ..., default value -1, optional
        argument to specify whether to use homogeneous coordinates
      * Verbose,
        => ..., default value false, Option to silence additional output
  * Outputs:
      * L, a list (Macaulay2Doc), a list of sample points

Description
===========

Samples points from an irreducible component of a variety using Bertini.  The
irreducible component needs to be in its numerical form as a WitnessSet (NAGtypes).
The method bertiniPosDimSolve,
can be used to generate a witness set for the component.
Bertini (1) writes the witness set to a temporary file, (2) invokes Bertini's
solver with option TrackType => 2, and (3 moves the hyperplanes defined in the
WitnessSet (NAGtypes), W within the space until the desired
points are sampled, (4) stores the output of Bertini in a temporary file, and
finally (5) parses and outputs the solutions.

+-----------------------------------------------------------------------------+
|i1 : R = CC[x,y,z]                                                           |
|                                                                             |
|o1 = R                                                                       |
|                                                                             |
|o1 : PolynomialRing                                                          |
+-----------------------------------------------------------------------------+
|i2 : F = { (y^2+x^2+z^2-1)*x, (y^2+x^2+z^2-1)*y }                            |
|                                                                             |
|       3      2      2       2     3      2                                  |
|o2 = {x  + x*y  + x*z  - x, x y + y  + y*z  - y}                             |
|                                                                             |
|o2 : List                                                                    |
+-----------------------------------------------------------------------------+
|i3 : NV = bertiniPosDimSolve(F)                                              |
|                                                                             |
|o3 = NV                                                                      |
|                                                                             |
|o3 : NumericalVariety                                                        |
+-----------------------------------------------------------------------------+
|i4 : W = NV#1_0 --z-axis                                                     |
|                                                                             |
|o4 = W                                                                       |
|                                                                             |
|o4 : WitnessSet                                                              |
+-----------------------------------------------------------------------------+
|i5 : bertiniSample(4, W)                                                     |
|                                                                             |
|o5 = {{0, 2.58729e-271+2.77047e-271*ii, .504375-.170678*ii},                 |
|     ------------------------------------------------------------------------|
|     {2.4161e-318+4.1731e-318*ii, -2.4161e-318-4.1731e-318*ii,               |
|     ------------------------------------------------------------------------|
|     .491246-.001592*ii}, {1.60477e-272+1.72248e-272*ii,                     |
|     ------------------------------------------------------------------------|
|     -4.3062e-273+4.01191e-273*ii, .500412-.168743*ii},                      |
|     ------------------------------------------------------------------------|
|     {1.51709e-317+1.55709e-317*ii, 2.27564e-318+2.33564e-318*ii,            |
|     ------------------------------------------------------------------------|
|     .611325-.011571*ii}}                                                    |
|                                                                             |
|o5 : List                                                                    |
+-----------------------------------------------------------------------------+

Ways to use bertiniSample :
===========================

  * "bertiniSample(ZZ,WitnessSet)"

For the programmer
==================

The object bertiniSample, is a method function with options (Macaulay2Doc).

bertiniTrackHomotopy -- a main method to track using a user-defined homotopy
****************************************************************************

Synopsis
========

  * Usage:
        S0=bertiniTrackHomotopy(t, H, S1)
  * Inputs:
      * t, a ring element (Macaulay2Doc), a path variable
      * H, a list (Macaulay2Doc), a list polynomials that define
        the homotopy with respect to the path variable
      * S1, a list (Macaulay2Doc), a list of solutions to the start
        system
  * Optional inputs (Macaulay2Doc),:
      * BertiniInputConfiguration (missing documentation) => ..., default value
        {}, null
      * IsProjective, => ..., default value -1, optional
        argument to specify whether to use homogeneous coordinates
      * Verbose,
        => ..., default value false, Option to silence additional output
  * Outputs:
      * S0, a list (Macaulay2Doc), a list of solutions to the
        target system

Description
===========

This method calls Bertini to track a user-defined homotopy.  The user needs to
specify the homotopy H, the path variable t, and a list of start solutions S1.
Bertini (1) writes the homotopy and start solutions to temporary files, (2)
invokes Bertini's solver with configuration keyword UserHomotopy => 1 in the
affine case and UserHomotopy => 2 in the projective situation, (3) stores the
output of Bertini in a temporary file, and (4) parses a machine readable file
to output a list of solutions.

+-------------------------------------------------------------------+
|i1 : R = CC[x,t]; -- include the path variable in the ring         |
+-------------------------------------------------------------------+
|i2 : H = { (x^2-1)*t + (x^2-2)*(1-t)};                             |
+-------------------------------------------------------------------+
|i3 : sol1 = point {{1}};                                           |
+-------------------------------------------------------------------+
|i4 : sol2 = point {{-1}};                                          |
+-------------------------------------------------------------------+
|i5 : S1= { sol1, sol2  };--solutions to H when t=1                 |
+-------------------------------------------------------------------+
|i6 : S0 = bertiniTrackHomotopy (t, H, S1) --solutions to H when t=0|
|                                                                   |
|o6 = {{-1.41421}, {1.41421}}                                       |
|                                                                   |
|o6 : List                                                          |
+-------------------------------------------------------------------+
|i7 : peek S0_0                                                     |
|                                                                   |
|o7 = Point{ConditionNumber => 1           }                        |
|           Coordinates => {-1.41421}                               |
|           CycleNumber => 1                                        |
|           FunctionResidual => 4.44089e-16                         |
|           LastT => .0015625                                       |
|           MaximumPrecision => 52                                  |
|           Multiplicity => 1                                       |
|           NewtonResidual => 0                                     |
|           SolutionNumber => -1                                    |
|           SolutionStatus => Regular                               |
+-------------------------------------------------------------------+

In the previous example, we solved $x^2-2$ by moving from $x^2-1$ with a linear
homotopy. Bertini tracks homotopies starting at $t=1$ and ending at $t=0$.
Final solutions are of the type Point.

+-----------------------------------------------------------------------------+
|i8 : R=CC[x,y,t]; -- include the path variable in the ring                   |
+-----------------------------------------------------------------------------+
|i9 : f1=(x^2-y^2);                                                           |
+-----------------------------------------------------------------------------+
|i10 : f2=(2*x^2-3*x*y+5*y^2);                                                |
+-----------------------------------------------------------------------------+
|i11 : H = { f1*t + f2*(1-t)}; --H is a list of polynomials in x,y,t          |
+-----------------------------------------------------------------------------+
|i12 : sol1=    point{{1,1}}--{{x,y}} coordinates                             |
|                                                                             |
|o12 = sol1                                                                   |
|                                                                             |
|o12 : Point                                                                  |
+-----------------------------------------------------------------------------+
|i13 : sol2=    point{{ -1,1}}                                                |
|                                                                             |
|o13 = sol2                                                                   |
|                                                                             |
|o13 : Point                                                                  |
+-----------------------------------------------------------------------------+
|i14 : S1={sol1,sol2}--solutions to H when t=1                                |
|                                                                             |
|o14 = {sol1, sol2}                                                           |
|                                                                             |
|o14 : List                                                                   |
+-----------------------------------------------------------------------------+
|i15 : S0=bertiniTrackHomotopy(t, H, S1, IsProjective=>1) --solutions to H whe|
|                                                                             |
|o15 = {{-.947782-.710437*ii, .11122-.740833*ii}, {-.847231+1.44261*ii,       |
|      -----------------------------------------------------------------------|
|      .549043+.904502*ii}}                                                   |
|                                                                             |
|o15 : List                                                                   |
|-----------------------------------------------------------------------------|
|n t=0                                                                        |
+-----------------------------------------------------------------------------+

Variables must begin with a letter (lowercase or capital) and can only contain
letters, numbers, underscores, and square brackets.

Ways to use bertiniTrackHomotopy :
==================================

  * "bertiniTrackHomotopy(RingElement,List,List)"

For the programmer
==================

The object bertiniTrackHomotopy, is a method function with options (Macaulay2Doc).

bertiniTrackHomotopy(...,Verbose=>...) -- Option to silence additional output
*****************************************************************************

Synopsis
========

  * Usage:
        bertiniTrackHomotopyVerbose(...,Verbose=>Boolean)
        bertiniUserHomotopyVerbose(...,Verbose=>Boolean)
        bertiniPosDimSolve(...,Verbose=>Boolean)
        bertiniRefineSols(...,Verbose=>Boolean)
        bertiniSample(...,Verbose=>Boolean)
        bertiniZeroDimSolve(...,Verbose=>Boolean)
        bertiniParameterHomotopy(...,Verbose=>Boolean)
        makeB'InputFile(...,Verbose=>Boolean)
        makeMembershipFile(...,Verbose=>Boolean)
        b'PHGaloisGroup(...,Verbose=>Boolean)
        b'PHMonodromyCollect(...,Verbose=>Boolean)
        importIncidenceMatrix(...,Verbose=>Boolean)
        importMainDataFile(...,Verbose=>Boolean)
        importSliceFile(...,Verbose=>Boolean)
        importSolutionsFile(...,Verbose=>Boolean)
        runBertini(...,Verbose=>Boolean)

Description
===========

Use Verbose=>false to silence additional output.

Further information
===================

  * Default value: false (Macaulay2Doc),
  * Function: bertiniTrackHomotopy, -- a main
    method to track using a user-defined homotopy
  * Option key: Verbose (Macaulay2Doc), -- request verbose
    feedback

Functions with optional argument named Verbose :
================================================

  * "bertiniComponentMemberTest(...,Verbose=>...)"
  * "bertiniParameterHomotopy(...,Verbose=>...)"
  * "bertiniPosDimSolve(...,Verbose=>...)"
  * "bertiniRefineSols(...,Verbose=>...)"
  * "bertiniSample(...,Verbose=>...)"
  * bertiniTrackHomotopy(...,Verbose=>...)
    -- Option to
    silence additional output
  * "bertiniUserHomotopy(...,Verbose=>...)"
  * "bertiniZeroDimSolve(...,Verbose=>...)"
  * "importIncidenceMatrix(...,Verbose=>...)"
  * "importMainDataFile(...,Verbose=>...)"
  * "importSolutionsFile(...,Verbose=>...)"
  * "makeB'InputFile(...,Verbose=>...)"
  * "makeMembershipFile(...,Verbose=>...)"
  * "makeSampleSolutionsFile(...,Verbose=>...)"
  * "runBertini(...,Verbose=>...)"
  * "check(...,Verbose=>...)" -- see check (Macaulay2Doc), --
    perform tests of a package
  * "checkDegrees(...,Verbose=>...)" -- see checkDegrees (Isomorphism),
    -- compares the degrees of generators of two
    modules
  * "copyDirectory(...,Verbose=>...)" -- see
    copyDirectory(String,String) (Macaulay2Doc),
  * "copyFile(...,Verbose=>...)" -- see copyFile(String,String) (Macaulay2Doc),
  * "findProgram(...,Verbose=>...)" -- see findProgram (Macaulay2Doc),
    -- load external program
  * "installPackage(...,Verbose=>...)" -- see installPackage (Macaulay2Doc),
    -- load and install a package and its
    documentation
  * "isIsomorphic(...,Verbose=>...)" -- see isIsomorphic (Isomorphism),
    -- Probabilistic test for isomorphism of modules
  * "moveFile(...,Verbose=>...)" -- see moveFile(String,String) (Macaulay2Doc),
  * "runProgram(...,Verbose=>...)" -- see runProgram (Macaulay2Doc),
    -- run an external program
  * "symlinkDirectory(...,Verbose=>...)" -- see
    symlinkDirectory(String,String) (Macaulay2Doc),
    -- make symbolic links
    for all files in a directory tree

bertiniUserHomotopy -- a main method to track a user-defined homotopy
*********************************************************************

Synopsis
========

  * Usage:
        S0=bertiniUserHomotopy(t, P, H, S1)
  * Inputs:
      * t, a ring element (Macaulay2Doc), a path variable
      * P, a list (Macaulay2Doc), a list of options that set the
        parameters
      * H, a list (Macaulay2Doc), a list of polynomials that define
        the homotopy
      * S1, a list (Macaulay2Doc), a list of solutions to the start
        system
  * Optional inputs (Macaulay2Doc),:
      * AffVariableGroup, => ..., default value {}, an
        option to group variables and use multihomogeneous homotopies
      * B'Constants (missing documentation) => ..., default value {}, null
      * B'Functions (missing documentation) => ..., default value {}, null
      * BertiniInputConfiguration (missing documentation) => ..., default value
        {}, null
      * HomVariableGroup (missing documentation) => ..., default value {}, null
      * M2Precision (missing documentation) => ..., default value 53, null
      * OutputStyle (missing documentation) => ..., default value "OutPoints",
        null
      * RandomComplex (missing documentation) => ..., default value {}, null
      * RandomReal (missing documentation) => ..., default value {}, null
      * TopDirectory, => ..., default value
        "/var/folders/p7/xwnp7z5d3gj2rvmpgtm68nnh0000gn/T/M2-21575-0/0", Option
        to change directory for file storage.
      * Verbose,
        => ..., default value false, Option to silence additional output
  * Outputs:
      * S0, a list (Macaulay2Doc), a list of solutions to the
        target system

Description
===========

This method calls Bertini to track a user-defined homotopy.  The user needs to
specify the homotopy H, the path variable t, and a list of start solutions S1.
Bertini (1) writes the homotopy and start solutions to temporary files, (2)
invokes Bertini's solver with configuration keyword UserHomotopy => 2, (3)
stores the output of Bertini in a temporary file, and (4) parses a machine
readable file to output a list of solutions.

+-------------------------------------------------------------------------+
|i1 : R = CC[x,a,t]; -- include the path variable in the ring             |
+-------------------------------------------------------------------------+
|i2 : H = { (x^2-1)*a + (x^2-2)*(1-a)};                                   |
+-------------------------------------------------------------------------+
|i3 : sol1 = point {{1}};                                                 |
+-------------------------------------------------------------------------+
|i4 : sol2 = point {{-1}};                                                |
+-------------------------------------------------------------------------+
|i5 : S1= { sol1, sol2  };--solutions to H when t=1                       |
+-------------------------------------------------------------------------+
|i6 : S0 = bertiniUserHomotopy (t,{a=>t}, H, S1) --solutions to H when t=0|
|                                                                         |
|o6 = {{1.41421}, {-1.41421}}                                             |
|                                                                         |
|o6 : List                                                                |
+-------------------------------------------------------------------------+
|i7 : peek S0_0                                                           |
|                                                                         |
|o7 = Point{AccuracyEst => 5.92958e-13        }                           |
|           AccuracyEstInternal => 2.00447e-13                            |
|           ConditionNumber => 5.80657                                    |
|           Coordinates => {1.41421}                                      |
|           CycleNumber => 1                                              |
|           FinalTValue => .0015625                                       |
|           FunctionResidual => 5.55112e-17                               |
|           MaxPrecisionUtilized => 52                                    |
|           Multiplicity => 1                                             |
|           NewtonResidual => 1.64398e-16                                 |
|           PathNumber => 0                                               |
|           PathsWithSameEndpoint => {}                                   |
|           PrecisionIncreased => 0                                       |
|           SolutionNumber => 1                                           |
+-------------------------------------------------------------------------+
+-----------------------------------------------------------------------------+
|i8 : R=CC[x,y,t,a]; -- include the path variable in the ring                 |
+-----------------------------------------------------------------------------+
|i9 : f1=(x^2-y^2);                                                           |
+-----------------------------------------------------------------------------+
|i10 : f2=(2*x^2-3*x*y+5*y^2);                                                |
+-----------------------------------------------------------------------------+
|i11 : H = { f1*a + f2*(1-a)}; --H is a list of polynomials in x,y,t          |
+-----------------------------------------------------------------------------+
|i12 : sol1=    point{{1,1}}--{{x,y}} coordinates                             |
|                                                                             |
|o12 = sol1                                                                   |
|                                                                             |
|o12 : Point                                                                  |
+-----------------------------------------------------------------------------+
|i13 : sol2=    point{{ -1,1}}                                                |
|                                                                             |
|o13 = sol2                                                                   |
|                                                                             |
|o13 : Point                                                                  |
+-----------------------------------------------------------------------------+
|i14 : S1={sol1,sol2}--solutions to H when t=1                                |
|                                                                             |
|o14 = {sol1, sol2}                                                           |
|                                                                             |
|o14 : List                                                                   |
+-----------------------------------------------------------------------------+
|i15 : S0=bertiniUserHomotopy(t,{a=>t}, H, S1, HomVariableGroup=>{x,y})       |
|                                                                             |
|o15 = {{1, .3+.556776*ii}, {1, .3-.556776*ii}}                               |
|                                                                             |
|o15 : List                                                                   |
|-----------------------------------------------------------------------------|
|--solutions to H when t=0                                                    |
+-----------------------------------------------------------------------------+

Ways to use bertiniUserHomotopy :
=================================

  * "bertiniUserHomotopy(Thing,List,List,List)"

For the programmer
==================

The object bertiniUserHomotopy, is a method function with options (Macaulay2Doc).

bertiniZeroDimSolve -- a main method to solve a zero-dimensional system of equations
************************************************************************************

Synopsis
========

  * Usage:
        S = bertiniZeroDimSolve F
        S = bertiniZeroDimSolve I
        S = bertiniZeroDimSolve(I, UseRegeneration=>1)
  * Inputs:
      * F, a list (Macaulay2Doc), a list of ring elements (system
        need not be square)
      * I, an ideal (Macaulay2Doc), an ideal defining a variety
  * Optional inputs (Macaulay2Doc),:
      * AffVariableGroup, => ..., default value {}, an
        option to group variables and use multihomogeneous homotopies
      * B'Constants, => ..., default value {}, an option to
        designate the constants for a Bertini Input file
      * B'Functions (missing documentation) => ..., default value {}, null
      * BertiniInputConfiguration (missing documentation) => ..., default value
        {}, null
      * HomVariableGroup, => ..., default value {}, an
        option to group variables and use multihomogeneous homotopies
      * IsProjective (missing documentation) => ..., default value -1, null
      * M2Precision (missing documentation) => ..., default value 53, null
      * NameMainDataFile (missing documentation) => ..., default value
        "main_data", null
      * NameSolutionsFile (missing documentation) => ..., default value
        "raw_solutions", null
      * OutputStyle (missing documentation) => ..., default value "OutPoints",
        null
      * RandomComplex,
        => ..., default value {}, an option which designates
        symbols/strings/variables that will be set to be a random real number
        or random complex number
      * RandomReal, =>
        ..., default value {}, an option which designates
        symbols/strings/variables that will be set to be a random real number
        or random complex number
      * TopDirectory, => ..., default value
        "/var/folders/p7/xwnp7z5d3gj2rvmpgtm68nnh0000gn/T/M2-21575-0/0", Option
        to change directory for file storage.
      * UseRegeneration (missing documentation) => ..., default value -1, null
      * Verbose,
        => ..., default value false, Option to silence additional output
  * Outputs:
      * S, a list (Macaulay2Doc), a list of points that are
        contained in the variety of F

Description
===========

This method finds isolated solutions to the system F via numerical polynomial
homotopy continuation by (1) building a Bertini input file from the system F,
(2) calling Bertini on this input file, (3) returning solutions from a machine
readable file that is an output from Bertini.

+-----------------------------------------------------------------+
|i1 : R = CC[x,y];                                                |
+-----------------------------------------------------------------+
|i2 : F = {x^2-1,y^2-2};                                          |
+-----------------------------------------------------------------+
|i3 : S = bertiniZeroDimSolve F                                   |
|                                                                 |
|o3 = {{1, 1.41421}, {1, -1.41421}, {-1, 1.41421}, {-1, -1.41421}}|
|                                                                 |
|o3 : List                                                        |
+-----------------------------------------------------------------+

Each solution is of type Point (NAGtypes).  Additional
information about the solution can be accessed by using peek (Macaulay2Doc).

+----------------------------------------------+
|i4 : peek S_0                                 |
|                                              |
|o4 = Point{AccuracyEst => 3.4703e-13         }|
|           AccuracyEstInternal => 5.71549e-14 |
|           ConditionNumber => 2.40039         |
|           Coordinates => {1, 1.41421}        |
|           CycleNumber => 1                   |
|           FinalTValue => .000390625          |
|           FunctionResidual => 7.85046e-17    |
|           MaxPrecisionUtilized => 52         |
|           Multiplicity => 1                  |
|           NewtonResidual => 2.48129e-18      |
|           PathNumber => 0                    |
|           PathsWithSameEndpoint => {}        |
|           PrecisionIncreased => 0            |
|           SolutionNumber => 0                |
+----------------------------------------------+

Bertini uses a multihomogeneous homotopy as a default, but regeneration can be
deployed with the option UseRegeneration=>1 .

+--------------------------------------------------+
|i5 : R = CC[x];                                   |
+--------------------------------------------------+
|i6 : F = {x^2*(x-1)};                             |
+--------------------------------------------------+
|i7 : S = bertiniZeroDimSolve F                    |
|                                                  |
|o7 = {{1}, {4.30297e-15+1.81764e-15*ii}}          |
|                                                  |
|o7 : List                                         |
+--------------------------------------------------+
|i8 : B = bertiniZeroDimSolve(F,UseRegeneration=>1)|
|                                                  |
|o8 = {{1}}                                        |
|                                                  |
|o8 : List                                         |
+--------------------------------------------------+

Variables must begin with a letter (lowercase or capital) and can only contain
letters, numbers, underscores, and square brackets. Regeneration in
bertiniZeroDimSolve only finds nonsingular isolated points.

Ways to use bertiniZeroDimSolve :
=================================

  * "bertiniZeroDimSolve(Ideal)"
  * "bertiniZeroDimSolve(List)"

For the programmer
==================

The object bertiniZeroDimSolve, is a method function with options (Macaulay2Doc).

CopyB'File -- an optional argument to specify whether make a copy of the file.
******************************************************************************

Description
===========

When set to true, a file is copy of the file is made rather than just moved.
The default in moveB'File is set to false.

Functions with optional argument named CopyB'File :
===================================================

  * "moveB'File(...,CopyB'File=>...)"

For the programmer
==================

The object CopyB'File, is a symbol (Macaulay2Doc).

importIncidenceMatrix -- Imports an incidence matrix file after running makeMembershipFile.
*******************************************************************************************

Synopsis
========

  * Usage:
        importIncidenceMatrix(s)
  * Inputs:
      * s, a string (Macaulay2Doc), The directory where the file
        is stored.
  * Optional inputs (Macaulay2Doc),:
      * NameIncidenceMatrixFile (missing documentation) => ..., default value
        "incidence_matrix", null
      * StorageFolder (missing documentation) => ..., default value null, null
      * Verbose,
        => ..., default value false, Option to silence additional output

Description
===========

After running makeMembershipFile Bertini produces an incidence_matrix file. The
incidence_matrix says which points belong to which components. Our incidence
matrix is flattened to a list. The number of elements in theIM is equal to the
number of points in the solutions file. Each element of theIM is a list of
sequences of 2 elements (codim,component Number). Note that we follow the
Bertini convention and switch from (dimension,component number) indexing to
(codimension,component number) indexing.

If the NameIncidenceMatrixFile option is set when we want to import files with
a different name.

+-----------------------------------------------------------------------------+
|i1 : makeB'InputFile(storeBM2Files,                                          |
|         BertiniInputConfiguration=>{{TrackType,1}},                         |
|-----------------------------------------------------------------------------|
|AffVariableGroup=>{x,y,z},                                                   |
|-----------------------------------------------------------------------------|
|B'Polynomials=>{"z*((x+y+z)^3-1)","z*(y^2-3+z)"}    );                       |
+-----------------------------------------------------------------------------+
|i2 : runBertini(storeBM2Files)                                               |
+-----------------------------------------------------------------------------+
|i3 : makeSampleSolutionsFile(storeBM2Files,2,SpecifyComponent=>{1,0})        |
+-----------------------------------------------------------------------------+
|i4 : makeMembershipFile(storeBM2Files,NameSolutionsFile=>"sample_solutions_  |
|-----------------------------------------------------------------------------|
|file")                                                                       |
+-----------------------------------------------------------------------------+
|i5 : theIM=importIncidenceMatrix(storeBM2Files)                              |
|                                                                             |
|o5 = {{(2, 0)}, {(2, 0)}}                                                    |
|                                                                             |
|o5 : List                                                                    |
+-----------------------------------------------------------------------------+

Ways to use importIncidenceMatrix :
===================================

  * "importIncidenceMatrix(String)"

For the programmer
==================

The object importIncidenceMatrix, is a
method function with options (Macaulay2Doc).

importMainDataFile -- This function imports points from the main data file form a Bertini run.
**********************************************************************************************

Synopsis
========

  * Usage:
        importMainDataFile(theDir)
  * Inputs:
      * theDir, a string (Macaulay2Doc), The directory where the
        main_data file is located.
  * Optional inputs (Macaulay2Doc),:
      * M2Precision (missing documentation) => ..., default value 53, null
      * NameMainDataFile (missing documentation) => ..., default value
        "main_data", null
      * SpecifyDim (missing documentation) => ..., default value false, null
      * Verbose,
        => ..., default value false, Option to silence additional output

Description
===========

This function does not import a list of coordinates. Instead it imports points
from a main_data file. These points contain coordinates, condition numbers, and
etc. The information the points contain depend on if regeneration was used and
if a TrackType 0 or 1 was used. When TrackType 1 is used, UNCLASSIFIED points
will have component number -1.

+-----------------------------------------------------------------------------+
|i1 : makeB'InputFile(storeBM2Files,                                          |
|       AffVariableGroup=>{x,y,z},                                            |
|       BertiniInputConfiguration=>{{TrackType,1}},                           |
|       B'Polynomials=>{"(x^2+y^2+z^2-1)*y"});                                |
+-----------------------------------------------------------------------------+
|i2 : runBertini(storeBM2Files)                                               |
+-----------------------------------------------------------------------------+
|i3 : thePoints=importMainDataFile(storeBM2Files)                             |
|                                                                             |
|o3 = {{.149461+.159961*ii, 9.736e-17-5.4656e-18*ii, -.391748-.945759*ii},    |
|     ------------------------------------------------------------------------|
|     {-.857123-.070152*ii, .980754-.23564*ii, -.20747-.824096*ii},           |
|     ------------------------------------------------------------------------|
|     {1.17109-.073108*ii, -.792826+.647494*ii, -.613818-.975805*ii}}         |
|                                                                             |
|o3 : List                                                                    |
+-----------------------------------------------------------------------------+
|i4 : witnessPointsDim1= importMainDataFile(storeBM2Files,SpecifyDim=>1)--We  |
|1                                                                            |
|1                                                                            |
|1                                                                            |
|                                                                             |
|o4 = {}                                                                      |
|                                                                             |
|o4 : List                                                                    |
|-----------------------------------------------------------------------------|
|can choose which dimension we import points from. There are no witness points|
|-----------------------------------------------------------------------------|
|in dimension 1.                                                              |
+-----------------------------------------------------------------------------+
|i5 : sortMainDataComponents(thePoints)                                       |
|                                                                             |
|o5 = {{{.149461+.159961*ii, 9.736e-17-5.4656e-18*ii, -.391748-.945759*ii}},  |
|     ------------------------------------------------------------------------|
|     {{-.857123-.070152*ii, .980754-.23564*ii, -.20747-.824096*ii},          |
|     ------------------------------------------------------------------------|
|     {1.17109-.073108*ii, -.792826+.647494*ii, -.613818-.975805*ii}}}        |
|                                                                             |
|o5 : List                                                                    |
+-----------------------------------------------------------------------------+

Ways to use importMainDataFile :
================================

  * "importMainDataFile(String)"

For the programmer
==================

The object importMainDataFile, is a method function with options (Macaulay2Doc).

importParameterFile -- Imports parameters from a Bertini parameter file.
************************************************************************

Synopsis
========

  * Usage:
        importParameterFile(s)
  * Inputs:
      * s, a string (Macaulay2Doc), The directory where the file
        is stored.
  * Optional inputs (Macaulay2Doc),:
      * M2Precision (missing documentation) => ..., default value 53, null
      * NameParameterFile (missing documentation) => ..., default value
        "final_parameters", null
      * StorageFolder (missing documentation) => ..., default value null, null

Description
===========

After Bertini does a parameter homotopy many files are created. This function
imports the parameters from  the "final_parameters" file as the default.

+-----------------------------------------------------------------------------+
|i1 : writeParameterFile(storeBM2Files,{1,2},NameParameterFile=>"final_       |
|-----------------------------------------------------------------------------|
|parameters");                                                                |
+-----------------------------------------------------------------------------+
|i2 : importParameterFile(storeBM2Files)                                      |
|                                                                             |
|o2 = {1, 2}                                                                  |
|                                                                             |
|o2 : List                                                                    |
+-----------------------------------------------------------------------------+

Ways to use importParameterFile :
=================================

  * "importParameterFile(String)"

For the programmer
==================

The object importParameterFile, is a method function with options (Macaulay2Doc).

importSolutionsFile -- Imports coordinates from a Bertini solution file.
************************************************************************

Synopsis
========

  * Usage:
        importSolutionsFile(s)
  * Inputs:
      * s, a string (Macaulay2Doc), The directory where the file
        is stored.
  * Optional inputs (Macaulay2Doc),:
      * M2Precision (missing documentation) => ..., default value 53, null
      * NameSolutionsFile (missing documentation) => ..., default value
        "raw_solutions", null
      * OrderPaths (missing documentation) => ..., default value false, null
      * StorageFolder (missing documentation) => ..., default value null, null
      * Verbose,
        => ..., default value false, Option to silence additional output

Description
===========

After Bertini does a run many files are created. This function imports the
coordinates of solutions from the simple "raw_solutions" file. By using the
option NameSolutionsFile=>"real_finite_solutions" we would import solutions
from real finite solutions. Other common file names are
"nonsingular_solutions", "finite_solutions", "infinite_solutions", and
"singular_solutions".

If the NameSolutionsFile option is set to 0 then "nonsingular_solutions" is
imported, is set to 1 then "real_finite_solutions" is imported, is set to 2
then "infinite_solutions" is imported, is set to 3 then "finite_solutions" is
imported, is set to 4 then "start" is imported, is set to 5 then
"raw_solutions" is imported.

+-----------------------------------------------------------------------------+
|i1 : R=QQ[x,y]                                                               |
|                                                                             |
|o1 = R                                                                       |
|                                                                             |
|o1 : PolynomialRing                                                          |
+-----------------------------------------------------------------------------+
|i2 : makeB'InputFile(storeBM2Files,                                          |
|         AffVariableGroup=>{{x,y}},                                          |
|         B'Polynomials=>{x^2-1,y^3-1});                                      |
+-----------------------------------------------------------------------------+
|i3 : runBertini(storeBM2Files)                                               |
+-----------------------------------------------------------------------------+
|i4 : importSolutionsFile(storeBM2Files)                                      |
|                                                                             |
|o4 = {{1, 1}, {1, -.5+.866025*ii}, {1, -.5-.866025*ii}, {-1, 1}, {-1,        |
|     ------------------------------------------------------------------------|
|     -.5+.866025*ii}, {-1, -.5-.866025*ii}}                                  |
|                                                                             |
|o4 : List                                                                    |
+-----------------------------------------------------------------------------+
|i5 : importSolutionsFile(storeBM2Files,NameSolutionsFile=>"real_finite_      |
|                                                                             |
|o5 = {{1, 1}, {-1, 1}}                                                       |
|                                                                             |
|o5 : List                                                                    |
|-----------------------------------------------------------------------------|
|solutions")                                                                  |
+-----------------------------------------------------------------------------+
|i6 : importSolutionsFile(storeBM2Files,NameSolutionsFile=>0)                 |
|                                                                             |
|o6 = {{1, 1}, {1, -.5+.866025*ii}, {1, -.5-.866025*ii}, {-1, 1}, {-1,        |
|     ------------------------------------------------------------------------|
|     -.5+.866025*ii}, {-1, -.5-.866025*ii}}                                  |
|                                                                             |
|o6 : List                                                                    |
+-----------------------------------------------------------------------------+

Ways to use importSolutionsFile :
=================================

  * "importSolutionsFile(String)"

For the programmer
==================

The object importSolutionsFile, is a method function with options (Macaulay2Doc).

IsProjective -- optional argument to specify whether to use homogeneous coordinates
***********************************************************************************

Description
===========

When set to 1, this option indicates that the input system is homogenized and
the output should be given in projective space.

+---------------------------------------------------+
|i1 : R = CC[x,y,z];                                |
+---------------------------------------------------+
|i2 : f = {(x^2+y^2-z^2)*(z-x),(x^2+y^2-z^2)*(z+y)};|
+---------------------------------------------------+
|i3 : bertiniPosDimSolve(f,IsProjective=>1);        |
+---------------------------------------------------+

Functions with optional argument named IsProjective :
=====================================================

  * bertiniZeroDimSolve(...,IsProjective=>...) (missing documentation)
  * "bertiniComponentMemberTest(...,IsProjective=>...)"
  * "bertiniPosDimSolve(...,IsProjective=>...)"
  * "bertiniRefineSols(...,IsProjective=>...)"
  * "bertiniSample(...,IsProjective=>...)"
  * "bertiniTrackHomotopy(...,IsProjective=>...)"

For the programmer
==================

The object IsProjective, is a symbol (Macaulay2Doc).

makeB'InputFile -- write a Bertini input file in a directory
************************************************************

Synopsis
========

  * Usage:
        makeB'InputFile(s)
  * Inputs:
      * s, a string (Macaulay2Doc), a directory where the input
        file will be written
  * Optional inputs (Macaulay2Doc),:
      * AffVariableGroup, => ..., default value {}, an
        option to group variables and use multihomogeneous homotopies
      * B'Constants, => ..., default value {}, an option to
        designate the constants for a Bertini Input file
      * B'Functions (missing documentation) => ..., default value {}, null
      * B'Polynomials (missing documentation) => ..., default value {}, null
      * BertiniInputConfiguration (missing documentation) => ..., default value
        {}, null
      * HomVariableGroup, => ..., default value {}, an
        option to group variables and use multihomogeneous homotopies
      * NameB'InputFile (missing documentation) => ..., default value "input",
        null
      * NamePolynomials (missing documentation) => ..., default value {}, null
      * ParameterGroup (missing documentation) => ..., default value {}, null
      * PathVariable (missing documentation) => ..., default value {}, null
      * RandomComplex,
        => ..., default value {}, an option which designates
        symbols/strings/variables that will be set to be a random real number
        or random complex number
      * RandomReal, =>
        ..., default value {}, an option which designates
        symbols/strings/variables that will be set to be a random real number
        or random complex number
      * SetParameterGroup (missing documentation) => ..., default value {},
        null
      * StorageFolder (missing documentation) => ..., default value null, null
      * VariableList (missing documentation) => ..., default value {}, null
      * Verbose,
        => ..., default value false, Option to silence additional output

Description
===========

This function writes a Bertini input file. The user can specify CONFIGS for the
file using the BertiniInputConfiguration option. The user should specify
variable groups with the AffVariableGroup (affine variable group) option or
HomVariableGroup (homogeneous variable group) option. The user should specify
the polynomial system they want to solve with the  B'Polynomials option or
B'Functions option. If B'Polynomials is not used then the user should use the
NamePolynomials option.

+-----------------------------------------------------------+
|i1 : R=QQ[x1,x2,y]                                         |
|                                                           |
|o1 = R                                                     |
|                                                           |
|o1 : PolynomialRing                                        |
+-----------------------------------------------------------+
|i2 : theDir = temporaryFileName();                         |
+-----------------------------------------------------------+
|i3 : makeDirectory theDir                                  |
+-----------------------------------------------------------+
|i4 : makeB'InputFile(theDir,                               |
|             BertiniInputConfiguration=>{MPType=>2},       |
|         AffVariableGroup=>{{x1,x2},{y}},                  |
|             B'Polynomials=>{y*(x1+x2+1)^2+1,x1-x2+1,y-2});|
+-----------------------------------------------------------+
+----------------------------------------------------+
|i5 : R=QQ[x1,x2,y,X]                                |
|                                                    |
|o5 = R                                              |
|                                                    |
|o5 : PolynomialRing                                 |
+----------------------------------------------------+
|i6 : makeB'InputFile(theDir,                        |
|             BertiniInputConfiguration=>{MPType=>2},|
|         AffVariableGroup=>{{x1,x2},{y}},           |
|             NamePolynomials=>{f1,f2,f3},           |
|             B'Functions=>{                         |
|            {X,x1+x2+1},                            |
|            {f1,y*X^2+1},                           |
|            {f2,x1-x2+1},                           |
|            {f3,y-2}});                             |
+----------------------------------------------------+
+----------------------------------------------------+
|i7 : R=QQ[x1,x2,y,X]                                |
|                                                    |
|o7 = R                                              |
|                                                    |
|o7 : PolynomialRing                                 |
+----------------------------------------------------+
|i8 : makeB'InputFile(theDir,                        |
|              BertiniInputConfiguration=>{MPype=>2},|
|          AffVariableGroup=>{{x1,x2},{y}},          |
|               B'Polynomials=>{y*X^2+1,x1-x2+1,y-2},|
|                B'Functions=>{                      |
|                   {X,x1+x2+1}});                   |
+----------------------------------------------------+

Variables must begin with a letter (lowercase or capital) and can only contain
letters, numbers, underscores, and square brackets. "jade" should not be used
in any expression. "I" can only be used to represent the complex number
sqrt(-1).

Ways to use makeB'InputFile :
=============================

  * "makeB'InputFile(String)"

For the programmer
==================

The object makeB'InputFile, is a method function with options (Macaulay2Doc).

makeB'Section -- makeB'Section creates a hash table that represents a hyperplane.
*********************************************************************************

Synopsis
========

  * Usage:
        makeB'Section(l)
  * Inputs:
      * l, a list (Macaulay2Doc), A list of variables.
  * Optional inputs (Macaulay2Doc),:
      * B'Homogenization => ..., default value 1
      * B'NumberCoefficients => ..., default value {}
      * ContainsPoint => ..., default value {}
      * NameB'Section => ..., default value null
      * RandomCoefficientGenerator => ..., default value -*Function*-

Description
===========

makeB'Section allows for easy creation of equations that define hyperplanes.
The default creates a hash table with two keys: B'NumberCoefficients and
B'SectionString. The first key is a list of numbers in CC that are
coefficients, and the second key is a string representing the linear
polynomial. The option RandomCoefficientGenerator can be set to a function to
generate random numbers for the coefficients.

To get affine linear equations include 1 in the input list.

To have an affine linear equation that contains a particular point we set the
ContainsPoint option to a list of coordinates or a point. To get an homogeneous
equation that contains a projective point we have to set the ContainsPoint
option as well as the B'Homogenization option.

+-----------------------------------------------------------------------------+
|i1 : s=makeB'Section({x,y,z})                                                |
|                                                                             |
|o1 = B'Section{...2...}                                                      |
|                                                                             |
|o1 : B'Section                                                               |
+-----------------------------------------------------------------------------+
|i2 : class s                                                                 |
|                                                                             |
|o2 = B'Section                                                               |
|                                                                             |
|o2 : Type                                                                    |
+-----------------------------------------------------------------------------+
|i3 : randomRealCoefficientGenerator=()->random(RR)                           |
|                                                                             |
|o3 = randomRealCoefficientGenerator                                          |
|                                                                             |
|o3 : FunctionClosure                                                         |
+-----------------------------------------------------------------------------+
|i4 : sReal=makeB'Section({x,y,z},RandomCoefficientGenerator=>                |
|                                                                             |
|o4 = B'Section{...2...}                                                      |
|                                                                             |
|o4 : B'Section                                                               |
|-----------------------------------------------------------------------------|
|randomRealCoefficientGenerator)                                              |
+-----------------------------------------------------------------------------+
|i5 : sReal#B'NumberCoefficients                                              |
|                                                                             |
|o5 = {.0741835, .808694, .362835}                                            |
|                                                                             |
|o5 : List                                                                    |
+-----------------------------------------------------------------------------+
|i6 : randomRationalCoefficientGenerator=()->random(QQ)                       |
|                                                                             |
|o6 = randomRationalCoefficientGenerator                                      |
|                                                                             |
|o6 : FunctionClosure                                                         |
+-----------------------------------------------------------------------------+
|i7 : sRational=makeB'Section({x,y,z},RandomCoefficientGenerator=>            |
|                                                                             |
|o7 = B'Section{...2...}                                                      |
|                                                                             |
|o7 : B'Section                                                               |
|-----------------------------------------------------------------------------|
|randomRationalCoefficientGenerator)                                          |
+-----------------------------------------------------------------------------+
|i8 : sRational#B'NumberCoefficients                                          |
|                                                                             |
|       7  1   7                                                              |
|o8 = {--, -, --}                                                             |
|      10  2  10                                                              |
|                                                                             |
|o8 : List                                                                    |
+-----------------------------------------------------------------------------+
+-------------------------------------------+
|i9 : affineSection=makeB'Section({x,y,z,1})|
|                                           |
|o9 = B'Section{...2...}                    |
|                                           |
|o9 : B'Section                             |
+-------------------------------------------+
+-----------------------------------------------------------------------------+
|i10 : X={x,y,z}                                                              |
|                                                                             |
|o10 = {x, y, z}                                                              |
|                                                                             |
|o10 : List                                                                   |
+-----------------------------------------------------------------------------+
|i11 : P={1,2,3}                                                              |
|                                                                             |
|o11 = {1, 2, 3}                                                              |
|                                                                             |
|o11 : List                                                                   |
+-----------------------------------------------------------------------------+
|i12 : affineContainingPoint=makeB'Section({x,y,z},ContainsPoint=>P)          |
|                                                                             |
|o12 = B'Section{...3...}                                                     |
|                                                                             |
|o12 : B'Section                                                              |
+-----------------------------------------------------------------------------+
|i13 : r= affineContainingPoint#B'SectionString                               |
|                                                                             |
|o13 = (1.18921+.849539*ii)*(x-(1)*(1))+(-.542371+.307137*ii)*(y-(1)*(2))+(   |
|      1.36945+.015633*ii)*(z-(1)*(3))                                        |
+-----------------------------------------------------------------------------+
|i14 : print r                                                                |
|(1.18921+.849539*ii)*(x-(1)*(1))+(-.542371+.307137*ii)*(y-(1)*(2))+(1.36945  |
|-----------------------------------------------------------------------------|
|+.015633*ii)*(z-(1)*(3))                                                     |
+-----------------------------------------------------------------------------+
+-----------------------------------------------------------------------------+
|i15 : rHomogeSection= makeB'Section({x,y,z},ContainsPoint=>P,B'Homogenization|
|                                                                             |
|o15 = B'Section{...3...}                                                     |
|                                                                             |
|o15 : B'Section                                                              |
|-----------------------------------------------------------------------------|
|=>"x+y+z")                                                                   |
+-----------------------------------------------------------------------------+
|i16 : peek rHomogeSection                                                    |
|                                                                             |
|o16 = B'Section{B'Homogenization => x+y+z                                    |
|                B'NumberCoefficients => {.534614-.175945*ii, .426704         |
|                B'SectionString => (.534614-.175945*ii)*(x-(x+y+z)*(         |
|      -----------------------------------------------------------------------|
|                                                                             |
|      -.97539*ii, -.478803+.0416008*ii}                                      |
|      1))+(.426704-.97539*ii)*(y-(x+y+z)*(2))+(-.478803+.0416008*ii)*(z-(x+y+|
|      -----------------------------------------------------------------------|
|             }                                                               |
|                                                                             |
|      z)*(3))                                                                |
+-----------------------------------------------------------------------------+
|i17 : print rHomogeSection#B'SectionString                                   |
|(.534614-.175945*ii)*(x-(x+y+z)*(1))+(.426704-.97539*ii)*(y-(x+y+z)*(2       |
|-----------------------------------------------------------------------------|
|))+(-.478803+.0416008*ii)*(z-(x+y+z)*(3))                                    |
+-----------------------------------------------------------------------------+
+--------------------------------------------+
|i18 : f="y^3-x*y+1"                         |
|                                            |
|o18 = y^3-x*y+1                             |
+--------------------------------------------+
|i19 : s1=makeB'Section({x,y,1})             |
|                                            |
|o19 = B'Section{...2...}                    |
|                                            |
|o19 : B'Section                             |
+--------------------------------------------+
|i20 : makeB'InputFile(storeBM2Files,        |
|        AffVariableGroup=>{x,y},            |
|        B'Polynomials=>{f,s1});             |
+--------------------------------------------+
|i21 : runBertini(storeBM2Files)             |
+--------------------------------------------+
|i22 : #importSolutionsFile(storeBM2Files)==3|
|                                            |
|o22 = true                                  |
+--------------------------------------------+

Ways to use makeB'Section :
===========================

  * "makeB'Section(List)"

For the programmer
==================

The object makeB'Section, is a method function with options (Macaulay2Doc).

makeB'Slice -- makeB'Slice creates a hash table that represents a linear slice.
*******************************************************************************

Synopsis
========

  * Usage:
        makeB'Slice(sliceType,variableGroups)
  * Inputs:
      * sliceType, a list (Macaulay2Doc), A list of integers or
        integer.
      * variableGroups, a list (Macaulay2Doc), A list of list of
        variables or list of variables.
  * Optional inputs (Macaulay2Doc),:
      * B'Homogenization, => ..., default value {},
        makeB'Section creates a hash table that represents a hyperplane.
      * B'NumberCoefficients => ..., default value {}
      * ContainsMultiProjectivePoint => ..., default value {}
      * ContainsPoint => ..., default value {}
      * NameB'Slice => ..., default value null
      * RandomCoefficientGenerator => ..., default value -*Function*-

Description
===========

makeB'Slice allows for easy creation of equations that define linear spaces,
i.e. slices. The default creates a hash table with two keys:
B'NumberCoefficients and B'SectionString. When we have a multiprojective
variety we can different types of slices. To make a slice we need to specify
the type of slice we want followed by variable groups.

+-----------------------------------------------------------------------------+
|i1 : sliceType={1,1}                                                         |
|                                                                             |
|o1 = {1, 1}                                                                  |
|                                                                             |
|o1 : List                                                                    |
+-----------------------------------------------------------------------------+
|i2 : variableGroups={{x0,x1},{y0,y1,y2}}                                     |
|                                                                             |
|o2 = {{x0, x1}, {y0, y1, y2}}                                                |
|                                                                             |
|o2 : List                                                                    |
+-----------------------------------------------------------------------------+
|i3 : xySlice=makeB'Slice(sliceType,variableGroups)                           |
|                                                                             |
|o3 = B'Slice{...4...}                                                        |
|                                                                             |
|o3 : B'Slice                                                                 |
+-----------------------------------------------------------------------------+
|i4 : peek xySlice                                                            |
|                                                                             |
|o4 = B'Slice{B'NumberCoefficients => {{1.49144+.713846*ii, -.840113+1.1986*  |
|             B'SectionString => {(1.49144+.713846*ii)*(x0)+(-.840113+1.1986  |
|             ListB'Sections => {B'Section{...2...}, B'Section{...2...}}      |
|             NameB'Slice => null                                             |
|-----------------------------------------------------------------------------|
|ii}, {.014842+1.23548*ii, -.214468+.911293*ii, -.486176+.400577*ii}}         |
|*ii)*(x1), (.014842+1.23548*ii)*(y0)+(-.214468+.911293*ii)*(y1)+(-.486176    |
|-----------------------------------------------------------------------------|
|                  }                                                          |
|+.400577*ii)*(y2)}                                                           |
+-----------------------------------------------------------------------------+
|i5 : for i in  xySlice#B'SectionString do print i                            |
|(1.49144+.713846*ii)*(x0)+(-.840113+1.1986*ii)*(x1)                          |
|(.014842+1.23548*ii)*(y0)+(-.214468+.911293*ii)*(y1)+(-.486176+.400577*ii)*( |
|-----------------------------------------------------------------------------|
|y2)                                                                          |
+-----------------------------------------------------------------------------+
+-----------------------------------------------------------------------------+
|i6 : aSlice=makeB'Slice(3,{x,y,z,1},NameB'Slice=>"f");                       |
+-----------------------------------------------------------------------------+
|i7 : aSlice#NameB'Slice                                                      |
|                                                                             |
|o7 = {f0, f1, f2}                                                            |
|                                                                             |
|o7 : List                                                                    |
+-----------------------------------------------------------------------------+
|i8 : makeB'InputFile(storeBM2Files,AffVariableGroup=>{x,y,z},B'Functions=>{  |
|-----------------------------------------------------------------------------|
|aSlice},NamePolynomials=>{"f0","f1","f2"});                                  |
+-----------------------------------------------------------------------------+
+---------------------------------------------------------+
|i9 : f1="x0*y0+x1*y0+x2*y2"                              |
|                                                         |
|o9 = x0*y0+x1*y0+x2*y2                                   |
+---------------------------------------------------------+
|i10 : f2="x0*y0^2+x1*y1*y2+x2*y0*y2"                     |
|                                                         |
|o10 = x0*y0^2+x1*y1*y2+x2*y0*y2                          |
+---------------------------------------------------------+
|i11 : variableGroups={{x0,x1,x2},{y0,y1,y2}}             |
|                                                         |
|o11 = {{x0, x1, x2}, {y0, y1, y2}}                       |
|                                                         |
|o11 : List                                               |
+---------------------------------------------------------+
|i12 : xxSlice=makeB'Slice({2,0},variableGroups)          |
|                                                         |
|o12 = B'Slice{...4...}                                   |
|                                                         |
|o12 : B'Slice                                            |
+---------------------------------------------------------+
|i13 : xySlice=makeB'Slice({1,1},variableGroups)          |
|                                                         |
|o13 = B'Slice{...4...}                                   |
|                                                         |
|o13 : B'Slice                                            |
+---------------------------------------------------------+
|i14 : yySlice=makeB'Slice({0,2},variableGroups)          |
|                                                         |
|o14 = B'Slice{...4...}                                   |
|                                                         |
|o14 : B'Slice                                            |
+---------------------------------------------------------+
|i15 : makeB'InputFile(storeBM2Files,                     |
|          HomVariableGroup=>variableGroups,              |
|          B'Polynomials=>{f1,f2}|xxSlice#ListB'Sections);|
+---------------------------------------------------------+
|i16 : runBertini(storeBM2Files)                          |
+---------------------------------------------------------+
|i17 : xxDegree=#importSolutionsFile(storeBM2Files)       |
|                                                         |
|o17 = 2                                                  |
+---------------------------------------------------------+
|i18 : makeB'InputFile(storeBM2Files,                     |
|          HomVariableGroup=>variableGroups,              |
|          B'Polynomials=>{f1,f2}|xySlice#ListB'Sections);|
+---------------------------------------------------------+
|i19 : runBertini(storeBM2Files)                          |
+---------------------------------------------------------+
|i20 : xyDegree=#importSolutionsFile(storeBM2Files)       |
|                                                         |
|o20 = 3                                                  |
+---------------------------------------------------------+
|i21 : makeB'InputFile(storeBM2Files,                     |
|          HomVariableGroup=>variableGroups,              |
|          B'Polynomials=>{f1,f2}|yySlice#ListB'Sections);|
+---------------------------------------------------------+
|i22 : runBertini(storeBM2Files)                          |
+---------------------------------------------------------+
|i23 : yyDegree=#importSolutionsFile(storeBM2Files)       |
|                                                         |
|o23 = 1                                                  |
+---------------------------------------------------------+

Ways to use makeB'Slice :
=========================

  * "makeB'Slice(Thing,List)"

For the programmer
==================

The object makeB'Slice, is a method function with options (Macaulay2Doc).

moveB'File -- Move or copy files.
*********************************

Synopsis
========

  * Usage:
        moveB'File(s,f,n)
  * Inputs:
      * s, a string (Macaulay2Doc), A string giving a directory.
      * f, a string (Macaulay2Doc), A name of a file.
      * s, a string (Macaulay2Doc), A new name for the file.
  * Optional inputs (Macaulay2Doc),:
      * CopyB'File, => ..., default value false, an optional
        argument to specify whether make a copy of the file.
      * MoveToDirectory => ..., default value null
      * SubFolder => ..., default value null

Description
===========

This function takes the file f in the directory s and renames it to n.

+---------------------------------------------------------------------------+
|i1 : writeParameterFile(storeBM2Files,{2,3,5,7});                          |
+---------------------------------------------------------------------------+
|i2 : fileExists(storeBM2Files|"/final_parameters")                         |
|                                                                           |
|o2 = true                                                                  |
+---------------------------------------------------------------------------+
|i3 : moveB'File(storeBM2Files,"final_parameters","start_parameters")       |
+---------------------------------------------------------------------------+
|i4 : fileExists(storeBM2Files|"/final_parameters")                         |
|                                                                           |
|o4 = false                                                                 |
+---------------------------------------------------------------------------+
|i5 : fileExists(storeBM2Files|"/start_parameters")                         |
|                                                                           |
|o5 = true                                                                  |
+---------------------------------------------------------------------------+
|i6 : moveB'File(storeBM2Files,"start_parameters","backup",CopyB'File=>true)|
+---------------------------------------------------------------------------+
|i7 : fileExists(storeBM2Files|"/start_parameters")                         |
|                                                                           |
|o7 = true                                                                  |
+---------------------------------------------------------------------------+
|i8 : fileExists(storeBM2Files|"/backup")                                   |
|                                                                           |
|o8 = true                                                                  |
+---------------------------------------------------------------------------+

The options MoveToDirectory and SubFolder give greater control for where to
move the file.

+-----------------------------------------------------------------------------+
|i9 : Dir1 = temporaryFileName();                                             |
+-----------------------------------------------------------------------------+
|i10 : makeDirectory Dir1                                                     |
+-----------------------------------------------------------------------------+
|i11 : writeParameterFile(storeBM2Files,{2,3,5,7});                           |
+-----------------------------------------------------------------------------+
|i12 : moveB'File(storeBM2Files,"final_parameters","start_parameters",        |
|-----------------------------------------------------------------------------|
|MoveToDirectory=>Dir1)                                                       |
+-----------------------------------------------------------------------------+
|i13 : fileExists(Dir1|"/start_parameters")                                   |
|                                                                             |
|o13 = true                                                                   |
+-----------------------------------------------------------------------------+
+-----------------------------------------------------------------------------+
|i14 : makeDirectory (storeBM2Files|"/Dir2")                                  |
+-----------------------------------------------------------------------------+
|i15 : writeParameterFile(storeBM2Files,{2,3,5,7});                           |
+-----------------------------------------------------------------------------+
|i16 : moveB'File(storeBM2Files,"final_parameters","start_parameters",        |
|-----------------------------------------------------------------------------|
|SubFolder=>"Dir2")                                                           |
+-----------------------------------------------------------------------------+
|i17 : fileExists(storeBM2Files|"/Dir2/start_parameters")                     |
|                                                                             |
|o17 = true                                                                   |
+-----------------------------------------------------------------------------+

Ways to use moveB'File :
========================

  * "moveB'File(String,String,String)"

For the programmer
==================

The object moveB'File, is a method function with options (Macaulay2Doc).

NumberToB'String -- Translates a number to a string that Bertini can read.
**************************************************************************

Synopsis
========

  * Usage:
        NumberToB'String(n)
  * Inputs:
      * n, a thing (Macaulay2Doc), n is a number.
  * Optional inputs (Macaulay2Doc),:
      * M2Precision (missing documentation) => ..., default value 53, null

Description
===========

This function takes a number as an input then outputs a string to represent
this number to Bertini. The numbers are converted to floating point to
precision determined by the option M2Precision.

+--------------------------------------------------------------+
|i1 : NumberToB'String(2+5*ii)                                 |
|                                                              |
|o1 = .2e1 .5e1                                                |
+--------------------------------------------------------------+
|i2 : NumberToB'String(1/3,M2Precision=>16)                    |
|Warning: rational numbers will be converted to floating point.|
|                                                              |
|o2 = .33333333333333331e0 .0e0                                |
+--------------------------------------------------------------+
|i3 : NumberToB'String(1/3,M2Precision=>128)                   |
|Warning: rational numbers will be converted to floating point.|
|                                                              |
|o3 = .3333333333333333333333333333333333333338e0 .0e0         |
+--------------------------------------------------------------+

Ways to use NumberToB'String :
==============================

  * "NumberToB'String(Thing)"

For the programmer
==================

The object NumberToB'String, is a method function with options (Macaulay2Doc).

radicalList -- A support function that removes multiplicities of numbers in a list up to a tolerance.
*****************************************************************************************************

Synopsis
========

  * Usage:
        radicalList(List,Number)
        radicalList(List)
  * Inputs:
      * L, a list (Macaulay2Doc), A list of complex or real
        numbers.
      * N, a number (Macaulay2Doc), A small real number.

Description
===========

This outputs a sublist of complex or real numbers that all have distinct norms
up to the tolerance N (default is 1e-10).

+-------------------------------------+
|i1 : radicalList({2.000,1.999})      |
|                                     |
|o1 = {2, 1.999}                      |
|                                     |
|o1 : List                            |
+-------------------------------------+
|i2 : radicalList({2.000,1.999},1e-10)|
|                                     |
|o2 = {2, 1.999}                      |
|                                     |
|o2 : List                            |
+-------------------------------------+
|i3 : radicalList({2.000,1.999},1e-2) |
|                                     |
|o3 = {2}                             |
|                                     |
|o3 : List                            |
+-------------------------------------+

Ways to use radicalList :
=========================

  * "radicalList(List)"
  * "radicalList(List,Number)"

For the programmer
==================

The object radicalList, is a method function with options (Macaulay2Doc).

storeBM2Files
*************

For the programmer
==================

The object storeBM2Files (missing documentation) is a string (Macaulay2Doc).

subPoint -- This function evaluates a polynomial or matrix at a point.
**********************************************************************

Synopsis
========

  * Usage:
        subPoint(f,v,p)
  * Inputs:
      * f, a thing (Macaulay2Doc), A polynomial or a matrix.
      * v, a list (Macaulay2Doc), List of variables that we will be
        evaluated at the point.
      * p, a thing (Macaulay2Doc), A point or a list of
        coordinates or a matrix.
  * Optional inputs (Macaulay2Doc),:
      * M2Precision (missing documentation) => ..., default value 53, null
      * SpecifyVariables (missing documentation) => ..., default value false,
        null
      * SubIntoCC (missing documentation) => ..., default value false, null

Description
===========

Evaluate f at a point.

+---------------------------------------------------------+
|i1 : R=CC[x,y,z]                                         |
|                                                         |
|o1 = R                                                   |
|                                                         |
|o1 : PolynomialRing                                      |
+---------------------------------------------------------+
|i2 : f=z*x+y                                             |
|                                                         |
|o2 = x*z + y                                             |
|                                                         |
|o2 : R                                                   |
+---------------------------------------------------------+
|i3 : subPoint(f,{x,y},{.1,.2})                           |
|                                                         |
|o3 = .1z + .2                                            |
|                                                         |
|o3 : R                                                   |
+---------------------------------------------------------+
|i4 : subPoint(f,{x,y,z},{.1,.2,.3},SpecifyVariables=>{y})|
|                                                         |
|o4 = x*z + .2                                            |
|                                                         |
|o4 : R                                                   |
+---------------------------------------------------------+
+-----------------------------------------------------------------------+
|i5 : R=CC_200[x,y,z]                                                   |
|                                                                       |
|o5 = R                                                                 |
|                                                                       |
|o5 : PolynomialRing                                                    |
+-----------------------------------------------------------------------+
|i6 : f=z*x+y                                                           |
|                                                                       |
|o6 = x*z + y                                                           |
|                                                                       |
|o6 : R                                                                 |
+-----------------------------------------------------------------------+
|i7 : subPoint(f,{x,y,z},{.1,.2,.3},SubIntoCC=>true)                    |
|                                                                       |
|o7 = .23                                                               |
|                                                                       |
|o7 : CC (of precision 53)                                              |
+-----------------------------------------------------------------------+
|i8 : subPoint(f,{x,y,z},{.1234567890123456789012345678901234567890p200,|
|             0,1},SubIntoCC=>true,M2Precision=>200)                    |
|                                                                       |
|o8 = .123456789012345678901234567890123456789                          |
|                                                                       |
|o8 : CC (of precision 200)                                             |
+-----------------------------------------------------------------------+

Caveat
======

When SubIntoCC is set to true then unset variables will be set to zero or
unexpected values.

Ways to use subPoint :
======================

  * "subPoint(Thing,List,Thing)"

For the programmer
==================

The object subPoint, is a method function with options (Macaulay2Doc).

TopDirectory -- Option to change directory for file storage.
************************************************************

Synopsis
========

  * Usage:
        bertiniParameterHomotopy(...,TopDirectory=>String)
        bertiniZeroDimSolve(...,TopDirectory=>String)
        bertiniUserHomotopy(...,TopDirectory=>String)

Description
===========

This option specifies a directory to store Bertini output files.

Functions with optional argument named TopDirectory :
=====================================================

  * "bertiniParameterHomotopy(...,TopDirectory=>...)"
  * "bertiniUserHomotopy(...,TopDirectory=>...)"
  * "bertiniZeroDimSolve(...,TopDirectory=>...)"

For the programmer
==================

The object TopDirectory, is a symbol (Macaulay2Doc).

UseRegeneration -- an option specifying when to use regeneration
****************************************************************

Synopsis
========

  * Usage:
        bertiniParameterHomotopy(...,TopDirectory=>String)
        bertiniZeroDimSolve(...,TopDirectory=>String)
        bertiniUserHomotopy(...,TopDirectory=>String)

Description
===========

This option is set to 1 to have Bertini use regeneration when solving a
polynomial system.

Functions with optional argument named UseRegeneration :
========================================================

  * bertiniZeroDimSolve(...,UseRegeneration=>...) (missing documentation)

For the programmer
==================

The object UseRegeneration, is a symbol (Macaulay2Doc).

valueBM2 -- This function makes a number in CC from a string.
*************************************************************

Synopsis
========

  * Usage:
        valueBM2(s)
  * Inputs:
      * s, a string (Macaulay2Doc), A string that gives a
        coordinate.
  * Optional inputs (Macaulay2Doc),:
      * M2Precision (missing documentation) => ..., default value 53, null

Description
===========

This function take a string representing a coordinate in a Bertini solutions
file or parameter file and makes a number in CC. We can adjust the precision
using the M2Precision option. Fractions should not be in the string s.

+-----------------------------------------------------------------------------+
|i1 : valueBM2("1.22e-2 4e-5")                                                |
|                                                                             |
|o1 = .0122+.00004*ii                                                         |
|                                                                             |
|o1 : CC (of precision 53)                                                    |
+-----------------------------------------------------------------------------+
|i2 : valueBM2("1.22 4e-5")                                                   |
|                                                                             |
|o2 = 1.22+.00004*ii                                                          |
|                                                                             |
|o2 : CC (of precision 53)                                                    |
+-----------------------------------------------------------------------------+
|i3 : valueBM2("1.22 4")                                                      |
|                                                                             |
|o3 = 1.22+4*ii                                                               |
|                                                                             |
|o3 : CC (of precision 53)                                                    |
+-----------------------------------------------------------------------------+
|i4 : valueBM2("1.22e+2 4 ")                                                  |
|                                                                             |
|o4 = 122+4*ii                                                                |
|                                                                             |
|o4 : CC (of precision 53)                                                    |
+-----------------------------------------------------------------------------+
|i5 : n1=valueBM2("1.11",M2Precision=>52)                                     |
|                                                                             |
|o5 = 1.11                                                                    |
|                                                                             |
|o5 : RR (of precision 52)                                                    |
+-----------------------------------------------------------------------------+
|i6 : n2=valueBM2("1.11",M2Precision=>300)                                    |
|                                                                             |
|o6 = 1.11                                                                    |
|                                                                             |
|o6 : RR (of precision 300)                                                   |
+-----------------------------------------------------------------------------+
|i7 : toExternalString n1                                                     |
|                                                                             |
|o7 = .11099999999999999p52e1                                                 |
+-----------------------------------------------------------------------------+
|i8 : toExternalString n2                                                     |
|                                                                             |
|o8 = .11100000000000000000000000000000000000000000000000000000000000000000000|
|     000000000000000000003p300e1                                             |
+-----------------------------------------------------------------------------+

Ways to use valueBM2 :
======================

  * "valueBM2(String)"

For the programmer
==================

The object valueBM2, is a method function with options (Macaulay2Doc).

Variable groups -- an option to group variables and use multihomogeneous homotopies
***********************************************************************************

Grouping the variables has Bertini solve zero dimensional systems using
multihomogeneous homotopies.

+-----------------------------------------------------------------+
|i1 : R = CC[x,y];                                                |
+-----------------------------------------------------------------+
|i2 : F1 = {x*y+1,2*x*y+3*x+4*y+5};                               |
+-----------------------------------------------------------------+
|i3 : bertiniZeroDimSolve(F1, AffVariableGroup=>{{x},{y}});       |
+-----------------------------------------------------------------+
|i4 : hR =CC[x0,x1,y0,y1]                                         |
|                                                                 |
|o4 = hR                                                          |
|                                                                 |
|o4 : PolynomialRing                                              |
+-----------------------------------------------------------------+
|i5 : F2 = {x1*y1+x0*y0,2*x1*y1+3*x1*y0+4*x0*y1+5*x0*y0};         |
+-----------------------------------------------------------------+
|i6 : bertiniZeroDimSolve(F2,HomVariableGroup=>{{x0,x1},{y0,y1}});|
+-----------------------------------------------------------------+

writeStartFile -- Writes the list of list of coordinates to a file that Bertini can read.
*****************************************************************************************

Synopsis
========

  * Usage:
        writeStartFile(s,v)
  * Inputs:
      * s, a string (Macaulay2Doc), The directory where the
        Bertini file will be written.
      * v, a list (Macaulay2Doc), A list of list numbers that will
        be written to the file.
  * Optional inputs (Macaulay2Doc),:
      * M2Precision (missing documentation) => ..., default value 53, null
      * NameStartFile (missing documentation) => ..., default value "start",
        null
      * StorageFolder (missing documentation) => ..., default value null, null

Description
===========

This function can be used to write "start" files and any other solution file
using the option NameStartFile=>"AnyNameYouWant".

+--------------------------------------------------------+
|i1 : coordinatesOfTwoPnts={{1,0},{3,4}}                 |
|                                                        |
|o1 = {{1, 0}, {3, 4}}                                   |
|                                                        |
|o1 : List                                               |
+--------------------------------------------------------+
|i2 : writeStartFile(storeBM2Files,coordinatesOfTwoPnts);|
+--------------------------------------------------------+

Ways to use writeStartFile :
============================

  * "writeStartFile(String,List)"

For the programmer
==================

The object writeStartFile, is a method function with options (Macaulay2Doc).