# Reference Manual

This chapter contains the documentation of the modules in the package, mostly automatically generated from the documentation strings in the module and of the functions exported by each module. The order of the sections in this chapter follows the order of the previous chapters. The first section on the function in the solver module corresponds with chapter 3, on a blackbox solver. The section headings correspond to the earlier chapter headings.

## a blackbox solver for isolated solutions

The two most essential modules to solve polynomial systems are the `solver` module, which exports the blackbox solver, and the `solutions` module, to parse the computed solutions.

### functions in the module solver

The documentation strings of the functions exported by the module `solver` of the package phcpy are listed below.

The main functionality of PHCpack is its blackbox solver and the wide variety of start systems and homotopies. The blackbox solver is exported by the function solve. An important task of the solver is the mixed-volume computation, available in the function mixed_volume. For start systems based on the degrees of the polynomials, we have the plain total degree, m-homogeneous Bezout numbers, and general linear-product start systems.

solver.dobldobl_deflate(system, solutions, maxitr=3, maxdef=3, tolerr=1e-08, tolres=1e-08, tolrnk=1e-06)

  The deflation method augments the given system with derivatives to restore the quadratic convergence of Newton’s method at isolated singular solutions, in double double precision. The numerical parameters are

  maxitr: the maximum number of iterations per root,

  maxdef: the maximum number of deflations per root,

  tolerr: tolerance on the forward error on each root,

  tolres: tolerance on the backward error on each root,

  tolrnk: tolerance on the numerical rank of the Jacobian matrices.

  After application of deflation, the new approximations are returned.

solver.dobldobl_linear_reduction(pols, diagonalize=True)

  Applies row reduction in double double precision on the coefficient matrix of the polynomials in the list pols. As the monomials are sorted in the total degee order, the total degree of the system may decrease as a result. If diagonalize, then the coefficient matrix will be made diagonal. On return is the list of reduced polynomials.

solver.dobldobl_multiplicity(system, solution, order=5, tol=1e-08, verbose=False)

  Computes the multiplicity structure in double double precision of an isolated solution (in the string solution) of a polynomial system (in the list system). The other parameters are

  order: the maximum order of differentiation,

  tol: tolerance on the numerical rank,

  verbose: if extra output is needed.

  On return is the computed multiplicity.

solver.dobldobl_random_coefficient_system(verbose=True)

  Runs the polyhedral homotopies and returns a random coefficient system based on the contents of the cell container, in double double precision arithmetic. For this to work, the function mixed_volume() must be called first.

solver.dobldobl_random_system(neq, nvr, nbrmon, deg, cff)

  Returns a random polynomial system with coefficients in double double precision, based on the following:

  neq: number of equations,

  nvr: number of variables,

  nbrmon: maximum number of monomials per equation,

  > if 0, then the generated polynomials are dense,

  deg: upper bound on the degree of the monomials,

  cff: type of coefficients, must be 0, 1, or 2,

  > if 0, then random complex numbers on the unit circle,

  > if 1, then coefficients are one (or integer multiples of one),

  > if 2, then coefficients are floats in [-1,+1].

solver.dobldobl_scale_solutions(nvar, sols, cffs)

  Scales the solutions in the list sols using the coefficients in cffs, using double double precision arithmetic. The number of variables is given in the parameter nvar. If the sols are the solutions of the polynomials in the output of dobldobl_scale_system(pols), then the solutions on return will be solutions of the original polynomials in the list pols.

solver.dobldobl_scale_system(pols)

  Applies equation and variable scaling in double double precision to the polynomials in the list pols. On return is the list of scaled polynomials and the scaling coefficients.

solver.dobldobl_solve(pols, verbose=True, tasks=0, dictionary_output=False, verbose_level=0)

  Calls the blackbox solver to compute all isolated solutions in double double precision. On input in pols is a list of strings. By default, the solver will print to screen the computed root counts. To make the solver silent, set the flag verbose to False. The number of tasks for multithreading is given by tasks. The default zero value for tasks indicates no multithreading. If dictionary_output, then on return is a list of dictionaries, else the returned list is a list of strings. If verbose_level is larger than 0, then the names of the procedures called in the running of the blackbox solver will be listed. The solving happens in double double precision arithmetic.

solver.dobldobl_usolve(pol, mxi, eps)

  Applies the method of Durand-Kerner (aka Weierstrass) to the polynomial in the string pol, in double double precision The maximum number of iterations is in mxi, the requirement on the accuracy in eps.

solver.is_square(pols)

  Given in the list pols are string representations of Laurent polynomials. A system is square if it has as many unknowns as equations. Returns True if the system is square, False otherwise.

solver.linear_product_root_count(pols, verbose=True)

  Given in pols a list of string representations of polynomials, returns a linear-product root count based on a supporting set structure of the polynomials in pols. This root count is an upper bound for the number of isolated solutions.

solver.linear_reduce(pols, diagonalize=True, precision='d')

  Applies row reduction to the coefficient matrix of the polynomials in the list pols. As the monomials are sorted by total degree, the Bezout bound may decrease as a result of this row reduction. By default, if diagonalize, the coefficient matrix will be made diagonal. The default precision is double precision. Other available precisions are double double (‘dd’) and quad double (‘qd’).

solver.m_homogeneous_bezout_number(pols)

  Given in pols a list of string representations of polynomials, in as many variables as the elements in the list, this function applies a heuristic to generate a partition of the set of unknowns to exploit the product structure of the system. On return are the m-homogeneous Bezout number and the partition of the set of unknowns. If the partition equals the entire set of unknowns, then the 1-homogeneous Bezout number equals the total degree of the system.

solver.m_homogeneous_start_system(pols, partition, checkin=True)

  For an m-homogeneous Bezout number of a polynomial system defined by a partition of the set of unknowns, one can define a linear-product system that has exactly as many regular solutions as the Bezount number. This linear-product system can then be used as start system in a homotopy to compute all isolated solutions of any polynomial system with the same m-homogeneous structure. This function returns a linear-product start system with random coefficients and its solutions for the given polynomials in pols and the partition. If checkin, then the list pols is tested to see if pols defines a square polynomial system. If the input system is not square, then an error message is printed and None is returned.

solver.m_partition_bezout_number(pols, partition)

  There are as many m-homogeneous Bezout numbers as there are partitions of the set of unknowns of a polynomial system. Given in pols the string representations of a polynomial system in as many variables as equations, and a string representation of a partition of the set of unknowns, this function returns the m-homogeneous Bezout number corresponding to the given partition.

solver.mixed_volume(pols, stable=False, checkin=True)

  Given in pols a list of string representations of polynomials, this function returns the mixed volume of the system. This is an interface to Algorithm 846: MixedVol of ACM TOMS, developed by Tangan Gao, T.Y. Li, Mengnien Wu, and Li Xing. If the option stable is set to True, then on return is a tuple containing the mixed volume and the stable mixed volume. The mixed volume counts the solutions with all their coordinates nonzero, the stable mixed volume counts all affine roots. Note that the stable mixed volume does not apply to systems with negative exponents. Incorrectly parsed strings will result in a negative value on return. If checkin, then the system is test for being square and if then the system is not square, then an error message is printed and -1 is returned.

solver.mixed_volume_by_demics(pols, stable=False, checkin=True)

  Given in pols a list of string representations of polynomials, DEMiCs is called to compute the mixed volume of the Newton polytopes spanned by the supports of the polynomials in the system. DEMiCs applies dynamic enumeration to compute all mixed cells, was developed by Tomohiko Mizutani, Akiko Takeda, and Masakazu Kojima. If the option stable is set to True, then on return is a tuple containing the mixed volume and the stable mixed volume. The mixed volume counts the solutions with all their coordinates nonzero, the stable mixed volume counts all affine roots. Note that the stable mixed volume does not apply to systems with negative exponents. If checkin, then the system will be checked for being square and if then the system is not square, an error message is printed and -1 is returned.

solver.multprec_usolve(pol, mxi, eps, decimals)

  Applies the method of Durand-Kerner (aka Weierstrass) to the polynomial in the string pol, in arbitrary multiprecision, the number of decimal places in the precision is in decimals. The maximum number of iterations is in mxi, the requirement on the accuracy in eps.

solver.names_of_variables(pols)

  Returns a list of strings with the names of all variables that occur in the list of polynomials (given as strings) in pols.

solver.newton_laurent_step(system, solutions, precision='d', decimals=100)

  Applies one Newton step to the solutions of the Laurent system. For each solution, prints its last line of diagnostics. Four levels of precision are supported:

  d: standard double precision (1.1e-15 or 2^(-53)),

  dd: double double precision (4.9e-32 or 2^(-104)),

  qd: quad double precision (1.2e-63 or 2^(-209)).

  mp: arbitrary precision, where the number of decimal places in the working precision is determined by decimals.

solver.newton_step(system, solutions, precision='d', decimals=100)

  Applies one Newton step to the solutions of the system. For each solution, prints its last line of diagnostics. Four levels of precision are supported:

  d: standard double precision (1.1e-15 or 2^(-53)),

  dd: double double precision (4.9e-32 or 2^(-104)),

  qd: quad double precision (1.2e-63 or 2^(-209)).

  mp: arbitrary precision, where the number of decimal places in the working precision is determined by decimals.

solver.newton_steps(system, solutions, accuracy=8, maxsteps=4, maxprec=256)

  Runs a sequence of variable precision Newton steps to approximate solutions accurate up to a specified number of decimal places. In addition to the system and solutions, there are three parameters:

  accuracy: number of decimal places wanted to be accurate,

  maxsteps: maximum number of Newton steps,

  maxprec: maximum number of decimal places in the precision used to estimate the condition numbers.

solver.number_of_symbols(pols)

  Returns the number of symbols used as variables in the polynomials in the list pols. This function helps to determine whether a system is square (that is: has as many equations as unknowns) or not.

solver.permute_dobldobl_system(pols)

  Permutes the equations in the list of polynomials in pols with coefficients in double double precision, along the permutation used in the mixed volume computation.

solver.permute_quaddobl_system(pols)

  Permutes the equations in the list of polynomials in pols with coefficients in quad double precision, along the permutation used in the mixed volume computation.

solver.permute_standard_system(pols)

  Permutes the equations in the list of polynomials in pols with coefficients in standard double precision, along the permutation used in the mixed volume computation.

solver.quaddobl_deflate(system, solutions, maxitr=3, maxdef=3, tolerr=1e-08, tolres=1e-08, tolrnk=1e-06)

  The deflation method augments the given system with derivatives to restore the quadratic convergence of Newton’s method at isolated singular solutions, in quad double precision. The numerical parameters are

  maxitr: the maximum number of iterations per root,

  maxdef: the maximum number of deflations per root,

  tolerr: tolerance on the forward error on each root,

  tolres: tolerance on the backward error on each root,

  tolrnk: tolerance on the numerical rank of the Jacobian matrices.

  After application of deflation, the new approximations are returned.

solver.quaddobl_linear_reduction(pols, diagonalize=True)

  Applies row reduction in quad double precision on the coefficient matrix of the polynomials in the list pols. As the monomials are sorted in the total degee order, the total degree of the system may decrease as a result. If diagonalize, then the coefficient matrix will be made diagonal. On return is the list of reduced polynomials.

solver.quaddobl_multiplicity(system, solution, order=5, tol=1e-08, verbose=False)

  Computes the multiplicity structure in quad double precision of an isolated solution (in the string solution) of a polynomial system (in the list system). The other parameters are

  order: the maximum order of differentiation,

  tol: tolerance on the numerical rank,

  verbose: if extra output is needed.

  On return is the computed multiplicity.

solver.quaddobl_random_coefficient_system(verbose=True)

  Runs the polyhedral homotopies and returns a random coefficient system based on the contents of the cell container, in quad double precision arithmetic. For this to work, the function mixed_volume() must be called first.

solver.quaddobl_random_system(neq, nvr, nbrmon, deg, cff)

  Returns a random polynomial system with coefficients in quad double precision, based on the following:

  neq: number of equations,

  nvr: number of variables,

  nbrmon: maximum number of monomials per equation,

  > if 0, then the generated polynomials are dense,

  deg: upper bound on the degree of the monomials,

  cff: type of coefficients, must be 0, 1, or 2,

  > if 0, then random complex numbers on the unit circle,

  > if 1, then coefficients are one (or integer multiples of one),

  > if 2, then coefficients are floats in [-1,+1].

solver.quaddobl_scale_solutions(nvar, sols, cffs)

  Scales the solutions in the list sols using the coefficients in cffs, using quad double precision arithmetic. The number of variables is given in the parameter nvar. If the sols are the solution of the polynomials in the output of quaddobl_scale_system(pols), then the solutions on return will be solutions of the original polynomials in the list pols.

solver.quaddobl_scale_system(pols)

  Applies equation and variable scaling in quad double precision to the polynomials in the list pols. On return is the list of scaled polynomials and the scaling coefficients.

solver.quaddobl_solve(pols, verbose=True, tasks=0, dictionary_output=False, verbose_level=0)

  Calls the blackbox solver to compute all isolated solutions in quad double precision. On input in pols is a list of strings. By default, the solver will print to screen the computed root counts. To make the solver silent, set the flag verbose to False. The number of tasks for multithreading is given by tasks. The zero value for tasks indicates no multithreading. If dictionary_output, then on return is a list of dictionaries, else the returned list is a list of strings. If verbose_level is larger than 0, then the names of the procedures called in the running of the blackbox solver will be listed. The solving happens in quad double precision arithmetic.

solver.quaddobl_usolve(pol, mxi, eps)

  Applies the method of Durand-Kerner (aka Weierstrass) to the polynomial in the string pol, in quad double precision The maximum number of iterations is in mxi, the requirement on the accuracy in eps.

solver.random_coefficient_system(verbose=True, precision='d')

  Runs the polyhedral homotopies and returns a random coefficient system based on the contents of the cell container. For this to work, the function mixed_volume() must be called first. Three levels of precision are supported:

  d: standard double precision (1.1e-15 or 2^(-53)),

  dd: double double precision (4.9e-32 or 2^(-104)),

  qd: quad double precision (1.2e-63 or 2^(-209)).

solver.random_linear_product_system(pols, tosolve=True, checkin=True)

  Given in pols a list of string representations of polynomials, returns a random linear-product system based on a supporting set structure and its solutions as well (if tosolve). If checkin, then the list pols is tested to see if pols defines a square polynomial system. If the input system is not square, then an error message is printed and None is returned.

solver.random_system(neq, nvr, nbrmon, deg, cff, precision='d')

  Generates a random polynomial system based on the following:

  neq: number of equations,

  nvr: number of variables,

  nbrmon: maximum number of monomials per equation,

  > if 0, then the generated polynomials are dense,

  deg: upper bound on the degree of the monomials,

  cff: type of coefficients, must be 0, 1, or 2,

  > if 0, then random complex numbers on the unit circle,

  > if 1, then coefficients are one (or integer multiples of one),

  > if 2, then coefficients are floats in [-1,+1],

  precision: the precision of the coefficients,

  > if ‘d’, the precision of the coefficients is double,

  > if ‘dd’, the precision of the coefficients is double double,

  > if ‘qd’, the precision of the coefficients is quad double.

solver.random_trinomials()

  Returns a system of two trinomials equations for testing. A trinomial consists of three monomials in two variables. Exponents are uniform between 0 and 5 and coefficients are on the complex unit circle.

solver.real_random_trinomials(sys)

  On input in sys are two random trinonials with complex coefficients, in the format what random_trinomials() returns. On return is a list of two real random trinomials with the same monomial structure but with random real coefficients in [-1,+1].

solver.solve(pols, verbose=True, tasks=0, mvfocus=0, precision='d', checkin=True, dictionary_output=False, verbose_level=0)

  Calls the blackbox solver to compute all isolated solutions. To compute all solutions, also all positive dimensional solution sets, with a numerical irreducible decomposition, use solve in phcpy.factor. On input in pols is a list of strings. By default, the solver will print to screen the computed root counts. To make the solver silent, set the flag verbose to False. The number of tasks for multithreading is given by tasks. The default zero value for tasks indicates no multithreading. If the mvfocus option is set to one, then only mixed volumes and polyhedral homotopies will be applied in the solver, and no degree bounds will be computed, as is already the case when the input system is genuinely Laurent and has negative exponents. Three levels of precision are supported:

  d: standard double precision (1.1e-15 or 2^(-53)),

  dd: double double precision (4.9e-32 or 2^(-104)),

  qd: quad double precision (1.2e-63 or 2^(-209)).

  If checkin (by default), the input pols is checked for being square. If dictionary_output, then on return is a list of dictionaries, else the returned list is a list of strings. If verbose_level is larger than 0, then the names of the procedures called in the running of the blackbox solver will be listed.

solver.solve_checkin(pols, msg)

  Checks whether the system defined by the list of strings in pols is square. If so, True is returned. Otherwise, the error message in the string msg is printed to help the user.

solver.standard_condition_report(infilename, outfilename, maxit=4, tolres=1e-08, tolerr=1e-08, tolsing=1e-08, verbose=True)

  Computes a condition report for the system and the solutions on the file with name infile, in double precision. This report is intended for huge solution lists and the solutions are not exported into the Python session.

solver.standard_deflate(system, solutions, maxitr=3, maxdef=3, tolerr=1e-08, tolres=1e-08, tolrnk=1e-06)

  The deflation method augments the given system with derivatives to restore the quadratic convergence of Newton’s method at isolated singular solutions, in standard double precision. The numerical parameters are

  maxitr: the maximum number of iterations per root,

  maxdef: the maximum number of deflations per root,

  tolerr: tolerance on the forward error on each root,

  tolres: tolerance on the backward error on each root,

  tolrnk: tolerance on the numerical rank of the Jacobian matrices.

  After application of deflation, the new approximations are returned.

solver.standard_linear_reduction(pols, diagonalize=True)

  Applies row reduction in standard double precision on the coefficient matrix of the polynomials in the list pols. As the monomials are sorted in the total degee order, the total degree of the system may decrease as a result. If diagonalize, then the coefficient matrix will be made diagonal. On return is the list of reduced polynomials.

solver.standard_multiplicity(system, solution, order=5, tol=1e-08, verbose=False)

  Computes the multiplicity structure in standard double precision of an isolated solution (in the string solution) of a polynomial system (in the list system). The other parameters are

  order: the maximum order of differentiation,

  tol: tolerance on the numerical rank,

  verbose: if extra output is needed.

  On return is the computed multiplicity.

solver.standard_nonlinear_reduction(pols, eqmax=100, spmax=100, rpmax=100, verbose=True)

  Applies nonlinear reduction in standard double precision on the polynomials in the list pols. In addition to pols, three integers are part of the input: eqmax is the maximum number of equal degree replacements, spmax is the maximum number of computed S-polynomials, rpmax is the maximum number of computed R-polynomials. By default, verbose is True and the counts of equal degree replacements, computed S-polynomials and R-polynomials are written. On return is the list of reduced polynomials.

solver.standard_random_coefficient_system(verbose=True)

  Runs the polyhedral homotopies and returns a random coefficient system based on the contents of the cell container, in standard double precision arithmetic. For this to work, the function mixed_volume() must be called first.

solver.standard_random_system(neq, nvr, nbrmon, deg, cff)

  Returns a random polynomial system with coefficients in standard double precision, based on the following:

  neq: number of equations,

  nvr: number of variables,

  nbrmon: maximum number of monomials per equation,

  > if 0, then the generated polynomials are dense,

  deg: upper bound on the degree of the monomials,

  cff: type of coefficients, must be 0, 1, or 2,

  > if 0, then random complex numbers on the unit circle,

  > if 1, then coefficients are one (or integer multiples of one),

  > if 2, then coefficients are floats in [-1,+1].

solver.standard_scale_solutions(nvar, sols, cffs)

  Scales the solutions in the list sols using the coefficients in cffs, using standard double precision arithmetic. The number of variables is given in the parameter nvar. If the sols are the solutions of the polynomials in the output of standard_scale_system(pols), then the solutions on return will be solutions of the original polynomials in the list pols.

solver.standard_scale_system(pols)

  Applies equation and variable scaling in standard double precision to the polynomials in the list pols. On return is the list of scaled polynomials and the scaling coefficients.

solver.standard_solve(pols, verbose=True, tasks=0, mvfocus=0, dictionary_output=False, verbose_level=0)

  Calls the blackbox solver to compute all isolated solutions in standard double precision. On input in pols is a list of strings. By default, the solver will print to screen the computed root counts. To make the solver silent, set the flag verbose to False. The number of tasks for multithreading is given by tasks. The default zero value for tasks indicates no multithreading. If the mvfocus option is set to one, then only mixed volumes and polyhedral homotopies will be applied in the solver, and no degree bounds will be computed, as is already the case when the input system is genuinely Laurent and has negative exponents. If dictionary_output, then on return is a list of dictionaries, else the returned list is a list of strings. If verbose_level is larger than 0, then the names of the procedures called in the running of the blackbox solver will be listed. The solving happens in standard double precision arithmetic.

solver.standard_usolve(pol, mxi, eps)

  Applies the method of Durand-Kerner (aka Weierstrass) to the polynomial in the string pol, in standard double precision The maximum number of iterations is in mxi, the requirement on the accuracy in eps.

solver.test()

  Runs test_polyhedral_homotopy, test_solver and test_deflate.

solver.test_deflate()

  Applies the deflation method to a system used as example in the paper by T. Ojika on Modified deflation algorithm for the solution of singular problems. I. A system of nonlinear algebraic equations, which appeared in J. Math. Anal. Appl. 123, 199-221, 1987. The approximate solutions were computed via homotopy continuation. The function solve() deflates automatically.

solver.test_dobldobl_polyhedral_homotopy()

  Test polyhedral homotopy in double double precision on a small random polynomial system.

solver.test_mixed_volume()

  Runs a test on the mixed volume calculators.

solver.test_multiplicity(precision='d')

  Applies the deflation method to a system used as example in the paper by T. Ojika on Modified deflation algorithm for the solution of singular problems. I. A system of nonlinear algebraic equations, which appeared in J. Math. Anal. Appl. 123, 199-221, 1987. The parameter precision is either ‘d’, ‘dd’, or ‘qd’, respectively for double, double double, or quad double precision.

solver.test_newton()

  Tests Newton’s method on simple polynomial system, refining the square root of 2 with increasing precision.

solver.test_newton_laurent()

  Tests Newton’s method on simple Laurent system, refining the square root of 2 with increasing precision.

solver.test_nonlinear_reduce()

  Tests nonlinear reduction on a simple example.

solver.test_polyhedral_homotopy(precision='d')

  Test polyhedral homotopy on small random systems for standard double precision (d), double double precision (dd), or quad double precision (qd).

solver.test_quaddobl_polyhedral_homotopy()

  Test polyhedral homotopy in quad double precision on a small random polynomial system.

solver.test_reduce(precision='d')

  Tests the reduction of the coefficient matrix of a system.

solver.test_scale()

  Performs a basic test on variable scaling.

solver.test_solver()

  Generates a random trinomial system and solves it.

solver.test_standard_polyhedral_homotopy()

  Test on jumpstarting a polyhedral homotopy in standard precision.

solver.test_usolve()

  Does a simple sanity check on solving a univariate polynomial at various levels of precision.

solver.total_degree(pols)

  Given in pols a list of string representations of polynomials, returns the product of the degrees of the polynomials, the so-called total degree which bounds the number of isolated solutions of the polynomial system.

solver.total_degree_start_system(pols, checkin=True)

  Returns the system and solutions of the total degree start system for the polynomials represented by the strings in the list pols. If checkin, then the list pols is tested to see if pols defines a square polynomial system. If the input system is not square, then an error message is printed and None is returned.

solver.usolve(pol, mxi, eps, precision='d', decimals=100)

  Applies the method of Durand-Kerner (aka Weierstrass) to the polynomial in the string pol. The maximum number of iterations is in mxi, the requirement on the accuracy in eps. Four levels of precision are supported:

  d: standard double precision (1.1e-15 or 2^(-53)),

  dd: double double precision (4.9e-32 or 2^(-104)),

  qd: quad double precision (1.2e-63 or 2^(-209)).

  mp: arbitrary precision, where the number of decimal places in the working precision is determined by decimals.

### functions in the module solutions

The documentation strings of the functions exported by the module `solutions` are listed below. The script test() runs when typing python solutions.py at the command prompt.

The module solutions exports functions to convert a list of PHCpack solution strings into Python dictionaries. The module exports the definition of the class Solution, as an object-oriented representation of a solution.

class solutions.Solution(sol)

  Wraps the functions on solution strings.

  coordinates()

    Returns the values of the coordinates of the solution, as a tuple of variable names and corresponding values.

  diagnostics()

    Returns the numerical diagnostics.

  dictionary()

    Returns the dictionary format of the solution.

  multiplicity()

    Returns the multiplicity.

  numerals()

    Returns the numerical values of the coordinates.

  timevalue()

    Returns the value of the continuation parameter.

  variables()

    Returns the variable names of the coordinates.

solutions.condition_tables(sols)

  The input in sols is a list of PHCpack string solutions. A condition table is triplet of three frequency tables, computed from the diagnostics (err, rco, res) of each solution. The i-th entry in each frequency table counts the number of doubles x which floor(-log10(x)) mapped to the index i. Small numbers are mapped to the right of the table, large numbers are mapped to the left of the table.

solutions.coordinates(sol)

  Returns the coordinates of the solution in the PHCpack solution string sol, as a tuple of two lists: (names, values). The list names contains the strings of the variable names. The list values contains the complex values for the coordinates of the solution. The entries in the list names correspond to the entries in the list values.

solutions.diagnostics(sol)

  Extracts the diagnostics (err, rco, res) from the PHCpack string solution in sol and returns a triplet of three floats.

solutions.endmultiplicity(sol)

  Returns the value of t at the end and the multiplicity as (t,m) for the PHCpack solution string sol.

solutions.evaluate(pols, dsol)

  Evaluates a list of polynomials given as string in pols at the solution in dictionary format in dsol.

solutions.evaluate_polynomial(pol, dsol)

  Evaluates the polynomial pol at the solution dictionary dsol by string substitution.

solutions.filter_real(sols, tol, oper)

  Filters the real solutions in sols. The input parameters are

  1. sols is a list of solution strings in PHCpack format,

  2. tol is the tolerance on the absolute value of the imaginary parts of the coordinates of the solution.

  3. oper is either ‘select’ or ‘remove’

     if oper == ‘select’ then solutions that are considered real are selected and in the list on return,

     if oper == ‘remove’ then solutions that are considered real are in the list on return.

solutions.filter_regular(sols, tol, oper)

  Filters solutions in sols for the estimate of the inverse of the condition number. The input parameters are

  1. sols is a list of solution strings in PHCpack format,

  2. tol is the tolerance on the value for the estimate rco for the inverse of the condition number to decide whether a solution is singular (if rco < tol) or not.

  3. oper is either ‘select’ or ‘remove’

     if oper == ‘select’ then solutions with value rco > tol are selected and in the list on return,

     if oper == ‘remove’ then solutions with value rco <= tol are in the list on return.

solutions.filter_vanishing(sols, tol)

  Returns the list of solutions in sols that have a residual less than or equal to the given tolerance in tol.

solutions.filter_zero_coordinates(sols, varname, tol, oper)

  Filters the solutions in sols for variables that have a value less than the tolerance. The input parameters are

  1. sols is a list of solution strings in PHCpack format,

  2. varname is a string with the name of the variable,

  3. tol is the tolerance to decide whether a complex number equals zero or not, and

  4. oper is either ‘select’ or ‘remove’

     if oper == ‘select’ then solutions with value for the variable v that is less than tol are selected and in the list on return,

     if oper == ‘remove’ then solutions with value for the variable v that is less than tol are removed and not in the list on return.

solutions.formdictlist(sols, precision='d')

  Given in sols is a list of strings. Each string in sols represents a solution, in the PHCpack format. On return is the list of dictionaries. Each dictionary in the list of return stores each solution of the list sols in the dictionary format. By default, the precision of the coordinates is assumed to be double float (‘d’ on input). If the precision is not ‘d’, then the coordinates of the solution are returned as Python complex number string representations.

solutions.is_real(sol, tol)

  Returns True if the solution in sol is real with respect to the given tolerance tol: if the absolute value of the imaginary part of all coordinates are less than tol.

solutions.is_vanishing(sol, tol)

  Given in sol is a solution string and tol is the tolerance on the residual. Returns True if the residual of sol is less than or equal to tol. Returns False otherwise.

solutions.make_solution(names, values, err=0.0, rco=1.0, res=0.0, tval=0, multiplicity=1)

  Makes the string representation in PHCpack format with in names a list of strings for the variables names and in values a list of (complex) values for the coordinates. For example:

  s = make_solution([‘x’,’y’],[(1+2j), 3])

  returns the string s to represent the solution with coordinates (1+2j) and 3 for the variables x and y. The imaginary unit is the Python j instead of i. Other arguments for this function are

  1. err is the magnitude of an update, or the forward error,

  2. rco is the estimate for the inverse condition number,

  3. res is the value of the residual, or backward error,

  4. tval is the value for the continuation parameter t,

  5. multiplicity is the multiplicity of the solution.

  For those above arguments, default values are provided. Applying the function coordinates on the result of make_solution returns the tuple of arguments given on input to make_solution().

solutions.map_double(freqtab, nbr)

  On input in freqtab is a list of integer numbers and nbr is a double. The list freqtab represents a frequency table of magnitudes. The magnitude of the double nbr is mapped into the frequency table. The counter in freqtab that will be updated is at position floor(-log10(nbr))

solutions.numerals(dsol)

  Given the dictionary format of a solution dsol, returns the list of numeric values of the variables in the solution.

solutions.str2complex(scn)

  The string scn contains a complex number, the real and imaginary part separated by spaces. On return is the Python complex number.

solutions.string_complex(scn)

  The string scn contains a complex number, the real and imaginary part separated by spaces. On return is the string representation of a complex number, in Python format. The use of this function is for when the coordinates are calculated in higher precision.

solutions.string_coordinates(sol)

  Returns the coordinates of the solution in the PHCpack solution string sol, as a tuple of two lists: (names, values). For each name in names there is a value in values. The list names contains the strings of the variable names. The list values contains the values of the coordinates, represented as strings. This function is useful for when the coordinates are computed in higher precision.

solutions.strsol2dict(sol, precision='d')

  Converts the solution in the string sol into a dictionary format. By default, the precision of the coordinates is assumed to be double float (‘d’ on input). If the precision is not ‘d’, then the coordinates of the solution are returned as Python complex number string representations.

solutions.test_class()

  Tests the methods in the class Solution.

solutions.test_functions()

  Generates a random trinomial system, solves it, converts the solutions, and then sums the multiplicities.

solutions.variables(dsol)

  Given the dictionary format of a solution in dsol, returns the list of variables.

### the module polynomials

The module polynomials exports the definition of a class to represent systems of polynomials. The class `Polynomials` is intended as the starting point of the object-oriented interface to the solver.

The module polynomials exports the definition of the class Polynomials, as the object oriented interface to PHCpack.

class polynomials.Polynomials(pols)

  An instance of this class is a list of polynomials, which represents a polynomial system in several variables, with coefficients viewed by default as complex numbers.

  solve(verbose=True, nbtasks=0, mvfocus=0, dictionary_output=False, verbose_level=0)

    Applies the blackbox solver and returns a list of solutions. By default, verbose is True, and root counts are written. Multitasking is applied when the number of tasks in nbtasks is set to the number of tasks. To apply only mixed volumes and polyhedral homotopies, set the value for mvfocus to 1. If dictionary_output, then on return is a list of dictionaries, else the returned list is a list of strings. If verbose_level is larger than 0, then the names of the procedures called in the running of the blackbox solver will be listed. The solving happens in standard double precision arithmetic.

  variables()

    Returns the list of the variables in the polynomials.

polynomials.test()

  Tests the methods in the class Polynomials.

## path trackers and sweep homotopies

In the path tracking, we distinguish between paths defined by

1. homotopies with sufficiently random complex numbers, which then are free of singular solutions, except perhaps at the end; and

2. homotopies with real coefficients and real parameters, which most likely may contain singularities.

Functions to track solution paths defined by complex artificial parameter homotopies are exported by the module `trackers` while the module `sweepers` exports path trackers for real natural parameter homotopies. The module `tuning` helps to manage the tolerances of the function to track the solution paths in the `trackers` module. Access to polyhedral end games is provided by the `tropisms` module.

### functions in the module trackers

The documentation strings of the functions exported by the module `trackers` are listed below.

The module trackers offers functions to track paths starting at the known solutions of a start system and leading to the desired solutions of a target system. The path tracking functions in this module can track all solution paths in several levels of precision: standard double, double double, quad double, or arbitrary multiprecision arithmetic. For standard double, double double, and quad double arithmetic, multitasking is supported which could give a good speedup if sufficiently many cores are available on the processor. The tuning of the parameters for the predictor, corrector, and the settings of the tolerances is handled by the tuning module.

trackers.ade_double_double_track(target, start, sols, gamma=0, verbose=1)

  Does path tracking with algorithmic differentiation, in double double precision. On input are a target system, a start system with solutions. The target is a list of strings representing the polynomials of the target system (which has to be solved). The start is a list of strings representing the polynomials of the start system, with known solutions in sols. The sols is a list of strings representing start solutions. On return are the string representations of the solutions computed at the end of the paths. If gamma on input equals zero, then a random complex number is generated, otherwise the real and imaginary parts of gamma are used.

trackers.ade_double_track(target, start, sols, gamma=0, verbose=1)

  Does path tracking with algorithmic differentiation, in standard double precision. On input are a target system, a start system with solutions. The target is a list of strings representing the polynomials of the target system (which has to be solved). The start is a list of strings representing the polynomials of the start system, with known solutions in sols. The sols is a list of strings representing start solutions. On return are the string representations of the solutions computed at the end of the paths. If gamma on input equals zero, then a random complex number is generated, otherwise the real and imaginary parts of gamma are used.

trackers.ade_quad_double_track(target, start, sols, gamma=0, verbose=1)

  Does path tracking with algorithmic differentiation, in quad double precision. On input are a target system, a start system with solutions. The target is a list of strings representing the polynomials of the target system (which has to be solved). The start is a list of strings representing the polynomials of the start system, with known solutions in sols. The sols is a list of strings representing start solutions. On return are the string representations of the solutions computed at the end of the paths. If gamma on input equals zero, then a random complex number is generated, otherwise the real and imaginary parts of gamma are used.

trackers.ade_tuned_double_double_track(target, start, sols, pars, gamma=0, verbose=1)

  Does path tracking with algorithm differentiation, in double double precision, with tuned path parameters. On input are a target system, a start system with solutions. The target is a list of strings representing the polynomials of the target system (which has to be solved). The start is a list of strings representing the polynomials of the start system, with known solutions in sols. The sols is a list of strings representing start solutions. The pars is a tuple of 14 values for the path parameters. On return are the string representations of the solutions computed at the end of the paths. If gamma on input equals zero, then a random complex number is generated, otherwise the real and imaginary parts of gamma are used.

trackers.ade_tuned_double_track(target, start, sols, pars, gamma=0, verbose=1)

  Does path tracking with algorithm differentiation, in standard double precision, with tuned parameters in pars. On input are a target system, a start system with solutions. The target is a list of strings representing the polynomials of the target system (which has to be solved). The start is a list of strings representing the polynomials of the start system, with known solutions in sols. The sols is a list of strings representing start solutions. The pars is a tuple of 14 values for the path parameters. On return are the string representations of the solutions computed at the end of the paths. If gamma on input equals zero, then a random complex number is generated, otherwise the real and imaginary parts of gamma are used.

trackers.ade_tuned_quad_double_track(target, start, sols, pars, gamma=0, verbose=1)

  Does path tracking with algorithm differentiation, in quad double precision, with tuned path parameters. On input are a target system, a start system with solutions. The target is a list of strings representing the polynomials of the target system (which has to be solved). The start is a list of strings representing the polynomials of the start system, with known solutions in sols. The sols is a list of strings representing start solutions. The pars is a tuple of tuned values for the path parameters. On return are the string representations of the solutions computed at the end of the paths. If gamma on input equals zero, then a random complex number is generated, otherwise the real and imaginary parts of gamma are used.

trackers.cyclic3homotopy()

  Returns a triplet with the cyclic 3-roots system as first item, then in second place a random coefficient system, and the start solutions in the third item of the triplet.

trackers.double_double_crude_track(target, start, sols, gamma=0, verbose=True)

  A crude path tracker does not refine or postprocess the solutions at the end of the paths, computed in double double precision. The target is a list of strings representing the polynomials of the target system (which has to be solved). The start is a list of strings representing the polynomials of the start system, with known solutions in sols. The sols is a list of strings representing start solutions. By default, a random gamma constant is generated, otherwise gamma must be a nonzero complex constant. If verbose, then the solution vectors are written to screen. On return are the string representations of the solutions computed at the end of the paths.

trackers.double_double_track(target, start, sols, gamma=0, pwt=2, tasks=0)

  Does path tracking in double double precision. On input are a target system, a start system with solutions, optionally a (random) gamma constant and the number of tasks. The target is a list of strings representing the polynomials of the target system (which has to be solved). The start is a list of strings representing the polynomials of the start system with known solutions in sols. The sols is a list of strings representing start solutions. By default, a random gamma constant is generated, otherwise gamma must be a nonzero complex constant. The pwt is the power of t in the homotopy. Changing the default of pwt can only be done if a nonzero complex value for gamma is provided as well. The number of tasks in the multithreading is defined by tasks. The default zero value for tasks indicates no multithreading. On return are the string representations of the solutions computed at the end of the paths.

trackers.gpu_double_double_track(target, start, sols, gamma=0, verbose=1)

  GPU accelerated path tracking with algorithmic differentiation, in double double precision. On input are a target system, a start system with solutions. The target is a list of strings representing the polynomials of the target system (which has to be solved). The start is a list of strings representing the polynomials of the start system, with known solutions in sols. The sols is a list of strings representing start solutions. On return are the string representations of the solutions computed at the end of the paths. If gamma on input equals zero, then a random complex number is generated, otherwise the real and imaginary parts of gamma are used.

trackers.gpu_double_track(target, start, sols, gamma=0, verbose=1)

  GPU accelerated path tracking with algorithm differentiation, in standard double precision. On input are a target system, a start system with solutions. The target is a list of strings representing the polynomials of the target system (which has to be solved). The start is a list of strings representing the polynomials of the start system, with known solutions in sols. The sols is a list of strings representing start solutions. On return are the string representations of the solutions computed at the end of the paths. If gamma on input equals zero, then a random complex number is generated, otherwise the real and imaginary parts of gamma are used.

trackers.gpu_quad_double_track(target, start, sols, gamma=0, verbose=1)

  GPU accelerated path tracking with algorithmic differentiation, in quad double precision. On input are a target system, a start system with solutions. The target is a list of strings representing the polynomials of the target system (which has to be solved). The start is a list of strings representing the polynomials of the start system, with known solutions in sols. The sols is a list of strings representing start solutions. On return are the string representations of the solutions computed at the end of the paths. If gamma on input equals zero, then a random complex number is generated, otherwise the real and imaginary parts of gamma are used.

trackers.initialize_dobldobl_solution(nvar, sol)

  A double double precision path tracker with a generator is initialized with a start solution sol in a number of variables equal to the value of nvar.

trackers.initialize_dobldobl_tracker(target, start, fixedgamma=True, regamma=0.0, imgamma=0.0)

  Initializes a path tracker with a generator for a target and start system given in double double precision. If fixedgamma, then gamma will be a fixed default value, otherwise, a random complex constant for gamma is generated, but only if regamma and imgamma are both equal to 0.0. If not fixedgamma and moreover: regamma and imgamma are not both zero, then the complex number with real part in regamma and imaginary part in imgamma will be the gamma constant.

trackers.initialize_multprec_solution(nvar, sol)

  A multiprecision path tracker with a generator is initialized with a start solution sol in a number of variables equal to the value of nvar.

trackers.initialize_multprec_tracker(target, start, fixedgamma=True, decimals=100)

  Initializes a path tracker with a generator for a target and start system given in arbitrary multiprecision, with the number of decimal places in the working precision given by the value of decimals. If fixedgamma, then gamma will be a fixed default value, otherwise, a random complex constant for gamma is generated.

trackers.initialize_quaddobl_solution(nvar, sol)

  A quad double precision path tracker with a generator is initialized with a start solution sol in a number of variables equal to the value of nvar.

trackers.initialize_quaddobl_tracker(target, start, fixedgamma=True, regamma=0.0, imgamma=0.0)

  Initializes a path tracker with a generator for a target and start system given in quad double precision. If fixedgamma, then gamma will be a fixed default value, otherwise, a random complex constant for gamma is generated, but only if regamma and imgamma are both equal to 0.0. If not fixedgamma and moreover: regamma and imgamma are not both zero, then the complex number with real part in regamma and imaginary part in imgamma will be the gamma constant.

trackers.initialize_standard_solution(nvar, sol)

  A standard double precision path tracker with a generator is initialized with a start solution sol in a number of variables equal to the value of nvar.

trackers.initialize_standard_tracker(target, start, fixedgamma=True, regamma=0.0, imgamma=0.0)

  Initializes a path tracker with a generator for a target and start system given in standard double precision. If fixedgamma, then gamma will be a fixed default value, otherwise, a random complex constant for gamma is generated, but only if regamma and imgamma are both equal to 0.0. If not fixedgamma and moreover: regamma and imgamma are not both zero, then the complex number with real part in regamma and imaginary part in imgamma will be the gamma constant.

trackers.initialize_varbprec_solution(nvar, sol)

  A variable precision path tracker with a generator is initialized with a start solution sol in a number of variables equal to the value of nvar.

trackers.initialize_varbprec_tracker(target, start, fixedgamma=True)

  Initializes a path tracker in variable precision with a target and start system, given as lists of string representations of multivariate polynomials. If fixedgamma, then gamma will be a fixed default value, otherwise, a random complex constant for gamma is generated.

trackers.multiprecision_track(target, start, sols, gamma=0, pwt=2, decimals=80)

  Does path tracking with multiprecision. On input are a target system, a start system with solutions, and optionally a (random) gamma constant. The target is a list of strings representing the polynomials of the target system (which has to be solved). The start is a list of strings representing the polynomials of the start system with known solutions in sols. The sols is a list of strings representing start solutions. By default, a random gamma constant is generated, otherwise gamma must be a nonzero complex constant. The pwt is the power of t in the homotopy. Changing the default of pwt can only be done if a nonzero complex value for gamma is provided as well. The number of decimal places in the working precision is given by the value of decimals. On return are the string representations of the solutions computed at the end of the paths.

trackers.next_dobldobl_solution()

  Returns the next solution on a path tracked with double double precision arithmetic, provided the functions initialize_dobldobl_tracker() and initialize_dobldobl_solution() have been executed properly.

trackers.next_multprec_solution()

  Returns the next solution on a path tracked with arbitrary multiprecision arithmetic, provided the functions initialize_multprec_tracker() and initialize_multprec_solution() have been executed properly.

trackers.next_quaddobl_solution()

  Returns the next solution on a path tracked with quad double precision arithmetic, provided the functions initialize_quaddobl_tracker() and initialize_quaddobl_solution() have been executed properly.

trackers.next_standard_solution()

  Returns the next solution on a path tracked with standard double precision arithmetic, provided the functions initialize_standard_tracker() and initialize_standard_solution() have been executed properly.

trackers.next_varbprec_solution(wanted, maxprec, maxit, verbose)

  Returns the next solution on a path tracked with variable precision arithmetic, provided the functions initialize_varbprec_tracker() and initialize_varbprec_solution() have been executed properly. The four input parameters are

  1. wanted: the number of correct decimal places in the solution,

  2. maxprec: upper bound on the number of decimal places in the precision,

  3. maxit: maximum number of iterations, and

  4. verbose: flag to indicate if intermediate output is wanted.

trackers.quad_double_crude_track(target, start, sols, gamma=0, verbose=True)

  A crude path tracker does not refine or postprocess the solutions at the end of the paths, computed in quad double precision. The target is a list of strings representing the polynomials of the target system (which has to be solved). The start is a list of strings representing the polynomials of the start system, with known solutions in sols. The sols is a list of strings representing start solutions. By default, a random gamma constant is generated, otherwise gamma must be a nonzero complex constant. If verbose, then the solution vectors are written to screen. On return are the string representations of the solutions computed at the end of the paths.

trackers.quad_double_track(target, start, sols, gamma=0, pwt=2, tasks=0)

  Does path tracking with quad double precision. On input are a target system, a start system with solutions, optionally a (random) gamma constant and the number of tasks. The target is a list of strings representing the polynomials of the target system (which has to be solved). The start is a list of strings representing the polynomials of the start system with known solutions in sols. The sols is a list of strings representing start solutions. By default, a random gamma constant is generated, otherwise gamma must be a nonzero complex constant. The pwt is the power of t in the homotopy. Changing the default of pwt can only be done if a nonzero complex value for gamma is provided as well. The number of tasks in the multithreading is defined by tasks. The default zero value for tasks indicates no multithreading. On return are the string representations of the solutions computed at the end of the paths.

trackers.standard_double_crude_track(target, start, sols, gamma=0, verbose=True)

  A crude path tracker does not refine or postprocess the solutions at the end of the paths, computed in standard double precision. The target is a list of strings representing the polynomials of the target system (which has to be solved). The start is a list of strings representing the polynomials of the start system, with known solutions in sols. The sols is a list of strings representing start solutions. By default, a random gamma constant is generated, otherwise gamma must be a nonzero complex constant. If verbose, then the solution vectors are written to screen. On return are the string representations of the solutions computed at the end of the paths.

trackers.standard_double_track(target, start, sols, gamma=0, pwt=2, tasks=0)

  Does path tracking with standard double precision. On input are a target system, a start system with solutions, optionally: a (random) gamma constant and the number of tasks. The target is a list of strings representing the polynomials of the target system (which has to be solved). The start is a list of strings representing the polynomials of the start system, with known solutions in sols. The sols is a list of strings representing start solutions. By default, a random gamma constant is generated, otherwise gamma must be a nonzero complex constant. The pwt is the power of t in the homotopy. Changing the default of pwt can only be done if a nonzero complex value for gamma is provided as well. The number of tasks in the multithreading is defined by tasks. The default zero value for tasks indicates no multithreading. On return are the string representations of the solutions computed at the end of the paths.

trackers.test()

  Runs test_track(), test_next_track(), and test_monitored_track().

trackers.test_ade_double_double_track()

  Tests the path tracker on the cyclic 3-roots problem, in double double precision.

trackers.test_ade_double_track()

  Tests the path tracker on the cyclic 3-roots problem, in standard double precision.

trackers.test_ade_quad_double_track()

  Tests the path tracker on the cyclic 3-roots problem, in quad double precision.

trackers.test_crude_tracker(precision='d')

  Runs the crude path trackers. Values for precision are ‘d’, ‘dd’, or ‘qd’, respectively for double, double double, or quad double precision.

trackers.test_monitored_track()

  Often the number of paths to track can be huge and waiting on the outcome of track() without knowing how many paths that have been tracked so far can be annoying. This script illustrates how one can monitor the progress of the path tracking. We must use the same gamma constant with each call of track.

trackers.test_next_track(precision='d', decimals=80)

  Tests the step-by-step tracking of a solution path. Three levels of precision are supported: d : standard double precision (1.1e-15 or 2^(-53)), dd : double double precision (4.9e-32 or 2^(-104)), qd : quad double precision (1.2e-63 or 2^(-209)). mp : arbitrary multiprecision with as many decimal places in the working precision as the value set by decimals.

trackers.test_track(verbose=True, precision='d', decimals=80)

  Tests the path tracking on a small random system. Two random trinomials are generated and random constants are added to ensure there are no singular solutions so we can use this generated system as a start system. The target system has the same monomial structure as the start system, but with random real coefficients. Because all coefficients are random, the number of paths tracked equals the mixed volume of the system.

trackers.track(target, start, sols, precision='d', decimals=80, gamma=0, pwt=2, tasks=0)

  Runs the path trackers to track solutions in sols at the start system in start to the target system in the target list using the current settings of the numerical continuation parameters as tuned by the function tune_track_parameters() of the tuning module. Four levels of precision are supported:

  1. d: standard double precision (1.1e-15 or 2^(-53)),

  2. dd: double double precision (4.9e-32 or 2^(-104)),

  3. qd: quad double precision (1.2e-63 or 2^(-209)).

  4. mp: arbitrary multiprecision, with as many decimal places in the working precision as the value of decimals.

  The next to last parameter is optional. By default, a random complex number will be used for gamma, otherwise, gamma can be any nonzero complex number. The pwt is the power of t in the homotopy. Changing the default of pwt can only be done if a nonzero complex value for gamma is provided as well. The last parameter equals the number of tasks. By default, for tasks equal to 0 there is no multitasking. For positive values of tasks, the multitasking could give a speedup of up to the number of tasks, depending how may cores are available on the processor.

### functions in the module sweepers

The documentation strings of the functions exported by the module `sweepers` are listed below.

The module sweepers exports the definition of sweep homotopies and the tracking of solution paths defined by sweep homotopies. A sweep homotopy is a polynomial system where some of the variables are considered as parameters. Given solutions for some parameters and new values for the parameters, we can track the solution paths starting at the given solutions and ending at the new solutions for the new values of the parameters. The sweep is controlled by a convex linear combination between the list of start and target values for the parameters. We distinguish between a complex and a real sweep. In a complex sweep, with a randomly generated gamma we avoid singularities along the solution paths, in a complex convex combination between the start and target values for the parameters. This complex sweep is applicable only when the parameter space is convex. The algorithms applied in this module are described in the paper by Kathy Piret and Jan Verschelde: Sweeping Algebraic Curves for Singular Solutions. Journal of Computational and Applied Mathematics, volume 234, number 4, pages 1228-1237, 2010.

sweepers.complex_sweep_test(precision='d')

  Runs a complex sweep on two points on the unit circle. Although we start at two points with real coordinates and we end at two points that have nonzero imaginary parts, the sweep does not encounter a singularity because of the random complex gamma constant.

sweepers.dobldobl_complex_sweep(pols, sols, nvar, pars, start, target)

  For the polynomials in the list of strings pols and the solutions in sols for the values in the list start, a sweep through the parameter space will be performed in double double precision to the target values of the parameters in the list target. The number of variables in the polynomials and the solutions must be the same and be equal to the value of nvar. The list of symbols in pars contains the names of the variables in the polynomials pols that serve as parameters. The size of the lists pars, *start, and target must be same.

sweepers.dobldobl_real_sweep(pols, sols, par='s', start=0.0, target=1.0)

  A real sweep homotopy is a family of n equations in n+1 variables, where one of the variables is the artificial parameter s which moves from 0.0 to 1.0. The last equation can then be of the form

  (1 - s)*(lambda - L[0]) + s*(lambda - L[1]) = 0 so that,

  at s = 0, the natural parameter lambda has the value L[0], and

  at s = 1, the natural parameter lambda has the value L[1].

  Thus: as s moves from 0 to 1, lambda goes from L[0] to L[1]. All solutions in the list sols must have then the value L[0] for the variable lambda. The sweep stops when the target value for s is reached or when a singular solution is encountered. Computations happen in double double precision.

sweepers.quaddobl_complex_sweep(pols, sols, nvar, pars, start, target)

  For the polynomials in the list of strings p*ols* and the solutions in sols for the values in the list start, a sweep through the parameter space will be performed in quad double precision to the target values of the parameters in the list target. The number of variables in the polynomials and the solutions must be the same and be equal to the value of nvar. The list of symbols in pars contains the names of the variables in the polynomials pols that serve as parameters. The size of the lists pars, start, and target must be same.

sweepers.quaddobl_real_sweep(pols, sols, par='s', start=0.0, target=1.0)

  A real sweep homotopy is a family of n equations in n+1 variables, where one of the variables is the artificial parameter s which moves from 0.0 to 1.0. The last equation can then be of the form

  (1 - s)*(lambda - L[0]) + s*(lambda - L[1]) = 0 so that,

  at s = 0, the natural parameter lambda has the value L[0], and

  at s = 1, the natural parameter lambda has the value L[1].

  Thus: as s moves from 0 to 1, lambda goes from L[0] to L[1]. All solutions in the list sols must have then the value L[0] for the variable lambda. The sweep stops when the target value for s is reached or when a singular solution is encountered. Computations happen in quad double precision.

sweepers.real_sweep_test(precision='d')

  Runs a real sweep on two points on the unit circle: (1,0), (-1,0), moving the second coordinate from 0 to 2. The sweep will stop at the quadratic turning point: (0,1). We can also run the sweep starting at two complex points: (2*j, sqrt(5)) and (-2*j, sqrt(5)), moving the second coordinate from sqrt(5) to 0. This sweep will also stop at (0,1).

sweepers.standard_complex_sweep(pols, sols, nvar, pars, start, target)

  For the polynomials in the list of strings pols and the solutions in sols for the values in the list start, a sweep through the parameter space will be performed in standard double precision to the target values of the parameters in the list target. The number of variables in the polynomials and the solutions must be the same and be equal to the value of nvar. The list of symbols in pars contains the names of the variables in the polynomials pols that serve as parameters. The size of the lists pars, start, and target must be same.

sweepers.standard_real_sweep(pols, sols, par='s', start=0.0, target=1.0)

  A real sweep homotopy is a family of n equations in n+1 variables, where one of the variables is the artificial parameter s which moves from 0.0 to 1.0. The last equation can then be of the form

  (1 - s)*(lambda - L[0]) + s*(lambda - L[1]) = 0 so that,

  at s = 0, the natural parameter lambda has the value L[0], and

  at s = 1, the natural parameter lambda has the value L[1].

  Thus: as s moves from 0 to 1, lambda goes from L[0] to L[1].

  All solutions in the list sols must have then the value L[0] for the variable lambda. The sweep stops when the target value for s is reached or when a singular solution is encountered. Computations happend in standard double precision.

### functions in the module tuning

The documentation strings of the functions exported by the module `tuning` are listed below.

The module tuning provides functions to tune the tolerances and settings of the predictor and corrector parameters for the path trackers.

tuning.condition_level_get()

  Returns an integer that represents the difficulty level of the homotopy. The default level equals zero, higher values lead to smaller tolerances.

tuning.condition_level_set(lvl)

  Sets the parameter that represents the difficulty level of the homotopy to the value of lvl. The default level equals zero, higher values lead to smaller tolerances. On return is the failure code, which is zero if all went well.

tuning.corrector_abscorendgame_get()

  Returns the value of the tolerance on the absolute correction for the corrector during the end game.

tuning.corrector_abscoronpath_get()

  Returns the value of the tolerance on the absolute correction for the corrector along a path, before the end game.

tuning.corrector_abscoronpath_set(tol)

  Sets the tolerance on the absolute correction for the corrector along a path, before the start of the end game, to the value of tol. On return is the failure code, which equals zero if all went well.

tuning.corrector_absresendgame_get()

  Returns the value of the tolerance on the absolute residual for the corrector during the end game.

tuning.corrector_absresendgame_set(tol)

  Sets the tolerance on the absolute residal for the corrector during the end game, to the value of tol. On return is the failure code, which equals zero if all went well.

tuning.corrector_absresonpath_get()

  Returns the value of the tolerance on the absolute residual for the corrector along a path, before the end game.

tuning.corrector_absresonpath_set(tol)

  Sets the tolerance on the absolute residal for the corrector along a path, before the start of the end game, to the value of tol. On return is the failure code, which equals zero if all went well.

tuning.corrector_maxiterendgame_get()

  Returns the maximum number of iterations the corrector does along a path, during the end game. The default equals 3.

tuning.corrector_maxiterendgame_set(maxiter)

  Sets the maximum number of iterations the corrector does along a path, before the start of the end game, to the value of maxiter. On return is the failure code, which equals zero if all went well.

tuning.corrector_maxiteronpath_get()

  Returns the maximum number of iterations the corrector does along a path, before the start of the end game. The default equals 3.

tuning.corrector_maxiteronpath_set(maxiter)

  Sets the maximum number of iterations the corrector does along a path, before the start of the end game, to the value of maxiter. On return is the failure code, which equals zero if all went well.

tuning.corrector_relcorendgame_get()

  Returns the value of the tolerance on the relative correction for the corrector during the end game.

tuning.corrector_relcorendgame_set(tol)

  Sets the tolerance on the relative correction for the corrector during the end game, to the value of tol. On return is the failure code, which equals zero if all went well.

tuning.corrector_relcoronpath_get()

  Returns the value of the tolerance on the relative correction for the corrector along a path, before the end game.

tuning.corrector_relcoronpath_set(tol)

  Sets the tolerance on the relative correction for the corrector along a path, before the start of the end game, to the value of tol. On return is the failure code, which equals zero if all went well.

tuning.corrector_relresendgame_get()

  Returns the value of the tolerance on the relative residual for the corrector during the end game.

tuning.corrector_relresendgame_set(tol)

  Sets the tolerance on the relative residal for the corrector during the end game, to the value of tol. On return is the failure code, which equals zero if all went well.

tuning.corrector_relresonpath_get()

  Returns the value of the tolerance on the relative residual for the corrector along a path, before the end game.

tuning.corrector_relresonpath_set(tol)

  Sets the tolerance on the relative residal for the corrector along a path, before the start of the end game, to the value of tol. On return is the failure code, which equals zero if all went well.

tuning.default_path_parameters(precision)

  Given in precision 16, 32, or 64 for double, double double, or quad double precision respectively, returns a tuple with the default values for the path parameters.

tuning.distance_to_endgame_get()

  Returns the distance to start the end game. During the end game, the path tracker may apply tolerances that are more severe as the solution paths get more interesting near the end. The default value is 0.1.

tuning.distance_to_endgame_set(dst)

  Sets the distance to start the end game to the value of dst. During the end game, the path tracker may apply tolerances that are more severe as the solution paths get more interesting near the end. The default value is 0.1. On return is the failure code, which equals zero if all went well.

tuning.max_steps_get()

  Returns the maximum number of steps the path tracker will perform to reach the end of a solution path. For paths that diverge to infinity are often truncated beore reaching extreme values.

tuning.max_steps_set(mxs)

  Sets the maximum number of steps the path tracker will perform to reach the end of a solution path to mxs. For paths that diverge to infinity are often truncated beore reaching extreme values. On return is the failure code, which equals zero if all went well.

tuning.maxnum_reruns_get()

  Returns the value of the maximum number of path reruns. If path jumping is detected, then the clustered paths are retracked with more severe values of the tolerances. The default value equals one.

tuning.maxnum_reruns_set(mrr)

  Sets the value of the maximum number of path reruns to the value of mrr. If path jumping is detected, then the clustered paths are retracked with more severe values of the tolerances. The default value equals one. On return is the failure code, which is zero when all went well.

tuning.order_endgame_extrapolator_get()

  Returns the order of the extrapolator to estimate the winding number in a polyhedral end game. If the order is zero, then no polyhedral end game will be applied.

tuning.order_endgame_extrapolator_set(ord)

  Sets the order of the extrapolator to estimate the winding number in a polyhedral end game to the value of ord. If the order ord is zero, then no polyhedral end game will be applied. On return is the failure code, which equals zero if all went well.

tuning.predictor_expfacendgame_get()

  Returns the value of the expansion factor to increase the step size in case of a successful corrector stage, during the end game. The expansion factor determines the speed at which the predictor increases its step size when tracking an easier portion of the path.

tuning.predictor_expfacendgame_set(expfac)

  Sets the value of the expansion factor to increase the step size in case of a successful corrector stag, during the end game, to the value of expfac. On return is the failure code, which equals zero if all went well.

tuning.predictor_expfaconpath_get()

  Returns the value of the expansion factor to increase the step size in case of a successful corrector stage, along a path, before the end game. The expansion factor determines the speed at which the predictor increases its step size when tracking an easier portion of the path.

tuning.predictor_expfaconpath_set(expfac)

  Sets the value of the expansion factor to increase the step size in case of a successful corrector stag, along a path, before the end game, to the value of expfac. On return is the failure code, which equals zero if all went well.

tuning.predictor_exptrsendgame_get()

  Returns the value of the expansion threshold for the step size control, during the end game. The expansion threshold is the number of consecutive successful corrector stages that must be met before the step size is increased.

tuning.predictor_exptrsendgame_set(exptrs)

  Sets the value of the expansion threshold for the step size control, during the end game, to the value of exptrs. The expansion threshold is the number of consecutive successful corrector stages that must be met before the step size is increased. On return is the failure code, which equals zero if all went well.

tuning.predictor_exptrsonpath_get()

  Returns the value of the expansion threshold for the step size control, along a path, before the end game. The expansion threshold is the number of consecutive successful corrector stages that must be met before the step size is increased.

tuning.predictor_exptrsonpath_set(exptrs)

  Sets the value of the expansion threshold for the step size control, along a path, before the end game, to the value of exptrs. The expansion threshold is the number of consecutive successful corrector stages that must be met before the step size is increased. On return is the failure code, which equals zero if all went well.

tuning.predictor_maxstependgame_get()

  Returns the maximum value of the step size during the end game. The step size control will never increase the step size to a value above this maximum.

tuning.predictor_maxsteponpath_get()

  Returns the maximum value of the step size along a path, before the end game. The step size control will never increase the step size to a value above this maximum.

tuning.predictor_maxsteponpath_set(maxstep)

  Sets the maximum of the step size along a path before the end game to the value of maxstep. On return is the failure code, which equals zero if all went well.

tuning.predictor_maxtependgame_set(maxstep)

  Sets the maximum of the step size during the end game to the value of maxstep. On return is the failure code, which equals zero if all went well.

tuning.predictor_minstependgame_get()

  Returns the minimum value of the step size during the end game. If the step size control cuts the step size to a value below this minimum, then the path tracking is aborted.

tuning.predictor_minstependgame_set(minstep)

  Sets the minimum of the step size during the end game to the value of minstep. On return is the failure code, which equals zero if all went well.

tuning.predictor_minsteponpath_get()

  Returns the minimum value of the step size along a path, before the end game. If the step size control cuts the step size to a value below this minimum, then the path tracking is aborted.

tuning.predictor_minsteponpath_set(minstep)

  Sets the minimum of the step size along a path before the end game to the value of minstep. On return is the failure code, which equals zero if all went well.

tuning.predictor_redfacendgame_get()

  Returns the value of the reduction factor to cut the step size in case of a failed corrector stage, during the end game. The reduction factor determines the speed at which the predictor reduces its step size when tracking a more difficult portion of the path.

tuning.predictor_redfacendgame_set(redfac)

  Sets the value of the reduction factor to cut the step size in case of a failed corrector step during the end game, to the value of redfac. On return is the failure code, which equals zero if all went well.

tuning.predictor_redfaconpath_get()

  Returns the value of the reduction factor to cut the step size in case of a failed corrector stage, along a path, before the end game. The reduction factor determines the speed at which the predictor reduces its step size when tracking a more difficult portion of the path.

tuning.predictor_redfaconpath_set(redfac)

  Sets the value of the reduction factor to cut the step size in case of a failed corrector step, along a path, before the end game, to the value of redfac. On return is the failure code, which equals zero if all went well.

tuning.predictor_typeendgame_get()

  Returns an integer which represents the type of the predictor along a path, before the start of the end game. The integer on return takes values between 0 and 9, depending on the type for the solution x and for the continuation parameter t. The ten predictor types are

  0 : secant for x, real for t;

  1 : secant for x, complex for t;

  2 : secant for x, geometric for t;

  3 : tangent for x, real for t;

  4 : tangent for x, complex for t;

  5 : tangent for x, geometric for t;

  6 : Hermite for x, real for t;

  7 : quadratic for x, real for t;

  8 : cubic for x, real for t;

  9 : quartic for x, real for t.

tuning.predictor_typeendgame_set(predtype)

  Sets the type of the predictor during the end game to what the value of predtype represents. A valid integer value for predtype lies between 0 and 9, setting the type for the solution x and for the continuation parameter t. The ten predictor types are

  0 : secant for x, real for t;

  1 : secant for x, complex for t;

  2 : secant for x, geometric for t;

  3 : tangent for x, real for t;

  4 : tangent for x, complex for t;

  5 : tangent for x, geometric for t;

  6 : Hermite for x, real for t;

  7 : quadratic for x, real for t;

  8 : cubic for x, real for t;

  9 : quartic for x, real for t.

  On return is the failure code, which is zero when all went well.

tuning.predictor_typeonpath_get()

  Returns an integer which represents the type of the predictor along a path, before the start of the end game. The integer on return takes values between 0 and 9, depending on the type for the solution x and for the continuation parameter t. The ten predictor types are

  0 : secant for x, real for t;

  1 : secant for x, complex for t;

  2 : secant for x, geometric for t;

  3 : tangent for x, real for t;

  4 : tangent for x, complex for t;

  5 : tangent for x, geometric for t;

  6 : Hermite for x, real for t;

  7 : quadratic for x, real for t;

  8 : cubic for x, real for t;

  9 : quartic for x, real for t.

tuning.predictor_typeonpath_set(predtype)

  Sets the type of the predictor along a path, before the end game, to what the value of predtype represents. A valid integer value for predtype lies between 0 and 9, setting the type for the solution x and for the continuation parameter t. The ten predictor types are

  0 : secant for x, real for t;

  1 : secant for x, complex for t;

  2 : secant for x, geometric for t;

  3 : tangent for x, real for t;

  4 : tangent for x, complex for t;

  5 : tangent for x, geometric for t;

  6 : Hermite for x, real for t;

  7 : quadratic for x, real for t;

  8 : cubic for x, real for t;

  9 : quartic for x, real for t.

  On return is the failure code, which is zero when all went well.

tuning.set_path_parameter_value(idx)

  Given the index idx of a path parameter, prompts the user for a new value which will be returned.

tuning.test()

  Tests the tuning of the parameters.

tuning.tolerance_clustsolendgame_get()

  Returns the tolerance on the distance between two solutions to decide whether two solutions are clustered during the end game.

tuning.tolerance_clustsolendgame_set(tol)

  Sets the tolerance on the distance between two solutions to decide whether two solutions are clustered during the end game, to the value of tol. On return is the failure code which equals zero if all went well.

tuning.tolerance_clustsolonpath_get()

  Returns the tolerance on the distance between two solutions to decide whether two solutions are clustered along a path, before the end game.

tuning.tolerance_clustsolonpath_set(tol)

  Sets the tolerance on the distance between two solutions to decide whether two solutions are clustered along a path, before the end game, to the value of tol. On return is the failure code which equals zero if all went well.

tuning.tolerance_infsolendgame_get()

  Returns the tolerance threshold to decide whether a solution path diverges to infinity, during the end game.

tuning.tolerance_infsolendgame_set(tol)

  Sets the tolerance threshold to decice whether a solution path diverges to infinity, during the end game, to the value of tol. On return is the failure code which is zero if all went well.

tuning.tolerance_infsolonpath_get()

  Returns the tolerance threshold to decide whether a solution path diverges to infinity, before the start of the end game.

tuning.tolerance_infsolonpath_set(tol)

  Sets the tolerance threshold to decice whether a solution path diverges to infinity, during the end game, to the value of tol. On return is the failure code which is zero if all went well.

tuning.tolerance_rcondendgame_get()

  Returns the tolerance on the inverse condition number of the Jacobian matrix of a solution, during the end game, to decide whether a solution is singular or not.

tuning.tolerance_rcondendgame_set(tol)

  Sets the tolerance on the inverse condition number of the Jacobian matrix of a solution along a path, before the end game, to decide whether a solution is singular, to the value of tol. On return is the failure code, which equals zero if all went well.

tuning.tolerance_rcondonpath_get()

  Returns the tolerance on the inverse condition number of the Jacobian matrix of a solution along a path, before the end game, to decide whether a solution is singular.

tuning.tolerance_rcondonpath_set(tol)

  Sets the tolerance on the inverse condition number of the Jacobian matrix of a solution along a path, before the end game, to decide whether a solution is singular, to the value of tol. The failure code is returned, which is zero if all went well.

tuning.track_simultaneously_get()

  Returns the number of paths that are tracked simultaneously, for the same discretization of the interval of the continuation parameter. The default value equals one. Increasing this value avoids path crossing, also called path jumping. This jumping happens when the approximated points on one path transition to approximated points on another path.

tuning.track_simultaneously_set(nbr)

  Sets the number of paths that are tracked simultaneously, for the same discretization of the interval of the continuation parameter, to the value of nbr. The default value equals one. Increasing this value avoids path crossing, also called path jumping. This jumping happens when the approximated points on one path transition to approximated points on another path. On return in the failure code, which is zero if all went well.

tuning.tune_path_parameters(precision)

  Given in precision the value 16, 32, or 64 for double, double double, or quad double precision respectively, tunes the path parameters interactively, starting from the default path parameters.

tuning.tune_track_parameters(difficulty=0, digits=16, interactive=False, silent=True)

  Tunes the numerical continuation parameters for use during path tracking based on two parameters: the difficulty of the solution path (difficulty) and the number of decimal places (digits) for the accuracy of the approximations along a path. Increasing difficulty will decrease the step size and increase the number of steps along a path. Increasing digits will decrease the tolerances on the numerical approximations. If interactive is True, then the user can interactively adjust specific numerical continuation parameters. If silent is False, then the current values of the numerical continuation parameters are shown.

tuning.write_path_parameters(pars)

  Given in pars is a 14-tuple with the path parameters. The path parameters are written, for later interactive tuning.

### functions in the module tropisms

The module `tropisms` provides access to the numerically computed tropisms via a polyhedral end game. The functions exported by the module `tropisms` are listed below.

The module tropisms exports function to manage numerically computed tropisms in double, double double, or quad double precision.

tropisms.dobldobl_clear()

  Clears the tropisms stored in double double precision.

tropisms.dobldobl_dimension()

  Returns the dimension of the tropisms stored in double double precision.

tropisms.dobldobl_initialize(nbt, dim, wnd, dir, err)

  Initializes the direction vectors computed in double double precision, along with estimates for their winding numbers and errors. On entry are the following five parameters:

  nbt: the number of direction vectors;

  dim: the number of coordinates in each vector;

  wnd: a list of integer values for the winding numbers, as many as nbt;

  dir: a list of lists of double doubles with the coordinates of the directions, each inner list has dim double doubles and nbt vectors;

  err: a list of nbt double doubles.

tropisms.dobldobl_retrieve(nbt, dim)

  Given on input the number of tropisms in nbt and the dimension in dim, returns a tuple of three lists: the winding numbers, coordinates of the direction vectors, and the errrors; in double double precision.

tropisms.dobldobl_size()

  Returns the number of tropisms stored in double double precision.

tropisms.management_test()

  Tests the management of numerically computed tropisms.

tropisms.quaddobl_clear()

  Clears the tropisms stored in quad double precision.

tropisms.quaddobl_dimension()

  Returns the dimension of the tropisms stored in quad double precision.

tropisms.quaddobl_initialize(nbt, dim, wnd, dir, err)

  Initializes the direction vectors computed in quad double precision, along with estimates for their winding numbers and errors. On entry are the following five parameters:

  nbt: the number of direction vectors;

  dim: the number of coordinates in each vector;

  wnd: a list of integer values for the winding numbers, as many as nbt;

  dir: a list of lists of quad doubles with the coordinates of the directions, each inner list has dim quad doubles and nbt vectors;

  err: a list of nbt double doubles.

tropisms.quaddobl_retrieve(nbt, dim)

  Given on input the number of tropisms in nbt and the dimension in dim, returns a tuple of three lists: the winding numbers, coordinates of the direction vectors, and the errrors; in quad double precision.

tropisms.quaddobl_size()

  Returns the number of tropisms stored in quad double precision.

tropisms.retrieve_dobldobl_tropism(dim, idx)

  Returns the winding number, coordinates of the direction, and its error, stored in double double precision, of dimension dim, and index idx. The index must be in the range 1..dobldobl_size(). Observe that the index counter starts at one and not at zero.

tropisms.retrieve_quaddobl_tropism(dim, idx)

  Returns the winding number, coordinates of the direction, and its error, stored in quad double precision, of dimension dim, and index idx. The index must be in the range 1..quaddobl_size(). Observe that the index counter starts at one and not at zero.

tropisms.retrieve_standard_tropism(dim, idx)

  Returns the winding number, coordinates of the direction, and its error, stored in double precision, of dimension dim, and index idx. The index must be in the range 1..standard_size(). Observe that the index counter starts at one and not at zero.

tropisms.standard_clear()

  Clears the tropisms stored in standard double precision.

tropisms.standard_dimension()

  Returns the dimension of the tropisms stored in standard double precision.

tropisms.standard_initialize(nbt, dim, wnd, dir, err)

  Initializes the direction vectors computed in double precision, along with estimates for their winding numbers and errors. On entry are the following five parameters:

  nbt: the number of direction vectors;

  dim: the number of coordinates in each vector;

  wnd: a list of integer values for the winding numbers, as many as nbt;

  dir: a list of lists of doubles with the coordinates of the directions, each inner list has dim doubles and nbt vectors are given;

  err: a list of nbt doubles.

tropisms.standard_retrieve(nbt, dim)

  Given on input the number of tropisms in nbt and the dimension in dim, returns a tuple of three lists: the winding numbers, coordinates of the direction vectors, and the errrors; in standard double precision.

tropisms.standard_size()

  Returns the number of tropisms stored in standard double precision.

tropisms.store_dobldobl_tropism(dim, idx, wnd, dir, err)

  Stores the tropism, given in double double precision, with dim doubles as coordinates in the list dir, the error in err, and the winding number wnd, at position idx. The index idx must be in the range 1..dobldobl_size().

tropisms.store_quaddobl_tropism(dim, idx, wnd, dir, err)

  Stores the tropism, given in quad double precision, with dim doubles as coordinates in the list dir, the error in err, and the winding number wnd, at position idx. The index idx must be in the range 1..quaddobl_size().

tropisms.store_standard_tropism(dim, idx, wnd, dir, err)

  Stores the tropism, given in standard double precision, with dim doubles as coordinates in the list dir, the error in err, and the winding number wnd, at position idx. The index idx must be in the range 1..standard_size().

tropisms.test(precision='d')

  Tests the numerical computation of a tropism.

tropisms.test_dobldobl_store_load()

  Tests the storing and loading of numerically computed tropisms, in double double precision.

tropisms.test_quaddobl_store_load()

  Tests the storing and loading of numerically computed tropisms, in quad double precision.

tropisms.test_standard_store_load()

  Tests the storing and loading of numerically computed tropisms, in standard double precision.

## positive dimensional solution sets

Numerical representations of positive dimensional solution sets are called witness sets and are computed by the functions exported by the module sets. Cascades of homotopies compute generic points on each component of all dimensions. In a numerical irreducible decomposition, all equidimensional solution sets are factored into irreducible components.

### functions in the module sets

This module exports routines of PHCpack to manipulate positive dimensional solution sets of polynomial systems. The embed functions add slack variables and random hyperplanes. The number of slack variables equals the number of random hyperplanes, which in turn equals the dimension of the solution set. The drop functions remove the added slack variables from the polynomials and the coordinates of the solutions. Given a witness set and a point, a homotopy membership determines whether the point belongs to the solution set represented by the witness set.

sets.dobldobl_embed(nvar, topdim, pols)

  Given in pols a list of strings that represent polynomials in nvar variables, with coefficients in double double precision, this function returns an embedding of pols of dimension topdim. The topdim is the top dimension which equals the expected highest dimension of a component of the solution set of the system of polynomials.

sets.dobldobl_ismember(wsys, gpts, dim, point, evatol=1e-06, memtol=1e-06, verbose=True, tasks=0)

  Applies the homotopy membership test for a point to belong to a witness set of dimension dim, given by an embedding polynomial system in wsys, with corresponding generic points in gpts. The coordinates of the test point are given in the string point, which is the string representation of a solution in PHCpack format, with symbols of the variables before the values of the coordinates. By default, verbose is True. The number of threads is given in tasks. If tasks is zero, then no multithreading is applied in the homotopy membership test. Calculations happen in double double precision. The default values for the evaluation (evatol) and the membership (memtol) allow for singular values at the end points of the paths in the homotopy membership test. Returns a tuple of two booleans. The first boolean is True if the point satisfies the equations, otherwise it is False. The second boolean is True if the point belongs to the witness set, otherwise, the second boolean is False.

sets.dobldobl_ismember_filter(wsys, gpts, dim, points, rcotol=1e-06, evatol=1e-06, memtol=1e-06, verbose=True, tasks=0)

  Given in wsys and gpts is a witness set of dimension dim, where wsys is an embedded polynomial system, and in points a list of strings. The strings represent points as solutions in PHCpack format. The homotopy membership test is applied to each point in the list points. The list on return contains the points that do NOT belong to the witness set. Points that belong to the witness set are considered junk. By default, verbose is True. The number of threads is given in tasks. If tasks is zero, then no multithreading is applied in the homotopy membership test. Calculations happen in double double precision. The parameter rcotol is used to bypass the homotopy membership test, for points with their estimated inverse condition number larger than rcotol will be considered isolated and not in the witness set.

sets.dobldobl_laurent_embed(nvar, topdim, pols)

  Given in pols a list of strings that represent Laurent polynomials in nvar variables, with coefficients in double double precision, this function returns an embedding of pols of dimension topdim. The topdim is the top dimension which equals the expected highest dimension of a component of the solution set of the system of polynomials.

sets.dobldobl_laurent_ismember(wsys, gpts, dim, point, evatol=1e-06, memtol=1e-06, verbose=True, tasks=0)

  Applies the homotopy membership test for a point to belong to a witness set of dimension dim, given by an embedding polynomial Laurent system in wsys, with corresponding generic points in gpts. The coordinates of the test point are given in the string point, which is the string representation of a solution in PHCpack format, with symbols of the variables before the values of the coordinates. By default, verbose is True. The number of threads is given in tasks. If tasks is zero, then no multithreading is applied in the homotopy membership test. Calculations happen in double double precision. The default values for the evaluation (evatol) and the membership (memtol) allow for singular values at the end points of the paths in the homotopy membership test. Returns a tuple of two booleans. The first boolean is True if the point satisfies the equations, otherwise it is False. The second boolean is True if the point belongs to the witness set, otherwise, the second boolean is False.

sets.dobldobl_laurent_ismember_filter(wsys, gpts, dim, points, rcotol=1e-06, evatol=1e-06, memtol=1e-06, verbose=True, tasks=0)

  Given in wsys and gpts is a witness set of dimension dim, where wsys is an embedded Laurent polynomial system, and in points a list of strings. The strings represent points as solutions in PHCpack format. The homotopy membership test is applied to each point in the list points. The list on return contains the points that do NOT belong to the witness set. Points that belong to the witness set are considered junk. By default, verbose is True. The number of threads is given in tasks. If tasks is zero, then no multithreading is applied in the homotopy membership test. Calculations happen in double double precision. The parameter rcotol is used to bypass the homotopy membership test, for points with their estimated inverse condition number larger than rcotol will be considered isolated and not in the witness set.

sets.dobldobl_laurent_membertest(wsys, gpts, dim, point, evatol=1e-06, memtol=1e-06, verbose=True, tasks=0)

  Applies the homotopy membership test for a point to belong to a witness set of dimension dim, given by an embedding Laurent system in wsys, with corresponding generic points in gpts. The coordinates of the test point are given in the list point, as a list of doubles, with the real and imaginary part of each coordinate of the point. By default, verbose is True. The number of threads is given in tasks. If tasks is zero, then no multithreading is applied in the homotopy membership test. Calculations happen in double double precision. The default values for the evaluation (evatol) and the membership (memtol) allow for singular values at the end points of the paths in the homotopy membership test.

sets.dobldobl_membertest(wsys, gpts, dim, point, evatol=1e-06, memtol=1e-06, verbose=True, tasks=0)

  Applies the homotopy membership test for a point to belong to a witness set of dimension dim, given by an embedding polynomial system in wsys, with corresponding generic points in gpts. The coordinates of the test point are given in the list point, as a list of doubles, with the real and imaginary part of each coordinate of the point. By default, verbose is True. The number of threads is given in tasks. If tasks is zero, then no multithreading is applied in the homotopy membership test. Calculations happen in double double precision. The default values for the evaluation (evatol) and the membership (memtol) allow for singular values at the end points of the paths in the homotopy membership test.

sets.drop_coordinate_from_dobldobl_solutions(sols, nbvar, svar)

  Removes the variable with symbol in the string svar from the list sols of strings that represent solutions in nbvar variables, in double double precision.

sets.drop_coordinate_from_quaddobl_solutions(sols, nbvar, svar)

  Removes the variable with symbol in the string svar from the list sols of strings that represent solutions in nbvar variables, in quad double precision.

sets.drop_coordinate_from_standard_solutions(sols, nbvar, svar)

  Removes the variable with symbol in the string svar from the list sols of strings that represent solutions in nbvar variables, in standard double precision.

sets.drop_variable_from_dobldobl_laurent_polynomials(pols, svar)

  Removes the variable with symbol in the string svar from the list pols of strings that represent Laurent polynomials in several variables, with coefficients in double double precision. Note that the system in pols must be square.

sets.drop_variable_from_dobldobl_polynomials(pols, svar)

  Removes the variable with symbol in the string svar from the list pols of strings that represent polynomials in several variables, with coefficients in double double precision. Note that the system in pols must be square.

sets.drop_variable_from_quaddobl_laurent_polynomials(pols, svar)

  Removes the variable with symbol in the string svar from the list pols of strings that represent Laurent polynomials in several variables, with coefficients in quad double precision. Note that the system in pols must be square.

sets.drop_variable_from_quaddobl_polynomials(pols, svar)

  Removes the variable with symbol in the string svar from the list pols of strings that represent polynomials in several variables, with coefficients in quad double precision. Note that the system in pols must be square.

sets.drop_variable_from_standard_laurent_polynomials(pols, svar)

  Removes the variable with symbol in the string svar from the list pols of strings that represent Laurent polynomials in several variables, with coefficients in standard double precision. Note that the system in pols must be square.

sets.drop_variable_from_standard_polynomials(pols, svar)

  Removes the variable with symbol in the string svar from the list pols of strings that represent polynomials in several variables, with coefficients in standard double precision. Note that the system in pols must be square.

sets.embed(nvar, topdim, pols, precision='d')

  Given in pols a list of strings that represent polynomials in nvar variables, this function returns an embedding of pols of dimension topdim. The topdim is the top dimension which equals the expected highest dimension of a component of the solution set of the system of polynomials. The default precision of the coefficients is ‘d’, for standard double precision. For double double and quad double precision, set the value of precision to ‘dd’ or ‘qd’ respectively.

sets.is_member(wsys, gpts, dim, solpt, evatol=1e-06, memtol=1e-06, verbose=True, precision='d', tasks=0)

  This function wraps the membertest where the point is a solution, given in solpt. All other parameters have the same meaning as in the function membertest.

sets.is_signed(pol)

  Given in pol is the string representation of a polynomial. Returns True if the first nonspace character in the string pol is either ‘+’ or ‘-’. Returns False otherwise.

sets.is_slackvar(var)

  Given in var is a string with a variable name. Returns True if the variable name starts with ‘zz’, followed by a number. Returns False otherwise.

sets.ismember_filter(wsys, gpts, dim, points, rcotol=1e-06, evatol=1e-06, memtol=1e-06, verbose=True, precision='d', tasks=0)

  Filters points so the list on return contains only those points which do not belong to the witness set of dimension dim, given by an embedded polynomial system in wsys, with corresponding generic points in gpts. The list points is a list of strings. Each string is the symbolic string representation of a solution. By default, verbose is True, and the precision is double ‘d’. Other levels of precision are double double precision ‘dd’ and quad double precision ‘qd’. The number of threads is given in tasks. If tasks is zero, then no multithreading is applied in the homotopy membership test. The parameter rcotol is used to bypass the homotopy membership test, for points with their estimated inverse condition number larger than rcotol will be considered isolated and not in the witness set. The homotopy membership test has two tolerances: evatol and memtol. The evatol is the tolerance on the residual of the evaluation of the polynomial equations at the test point. If the residual of the evaluation is not less than evatol, then the point is not a member. Otherwise, the homotopy membership test is called and the memtol is used to compare the coordinates of the point with the newly computed generic points. If there is a match between the coordinates within the given tolerance memtol, then the points is a member and filtered out.

sets.laurent_embed(nvar, topdim, pols, precision='d')

  Given in pols a list of strings that represent Laurent polynomials in nvar variables, this function returns an embedding of pols of dimension topdim. The topdim is the top dimension which equals the expected highest dimension of a component of the solution set of the system of polynomials. The default precision of the coefficients is ‘d’, for standard double precision. For double double and quad double precision, set the value of precision to ‘dd’ or ‘qd’ respectively.

sets.laurent_ismember_filter(wsys, gpts, dim, points, rcotol=1e-06, evatol=1e-06, memtol=1e-06, verbose=True, precision='d', tasks=0)

  Filters points so the list on return contains only those points which do not belong to the witness set of dimension dim, given by an embedded Laurent polynomial system in wsys, with corresponding generic points in gpts. The list points is a list of strings. Each string is the symbolic string representation of a solution. By default, verbose is True, and the precision is double ‘d’. Other levels of precision are double double precision ‘dd’ and quad double precision ‘qd’. The number of threads is given in tasks. If tasks is zero, then no multithreading is applied in the homotopy membership test. The parameter rcotol is used to bypass the homotopy membership test, for points with their estimated inverse condition number larger than rcotol will be considered isolated and not in the witness set. The homotopy membership test has two tolerances: evatol and memtol. The evatol is the tolerance on the residual of the evaluation of the polynomial equations at the test point. If the residual of the evaluation is not less than evatol, then the point is not a member. Otherwise, the homotopy membership test is called and the memtol is used to compare the coordinates of the point with the newly computed generic points. If there is a match between the coordinates within the given tolerance memtol, then the point is a member and filtered out.

sets.laurent_membertest(wsys, gpts, dim, point, evatol=1e-06, memtol=1e-06, verbose=True, precision='d', tasks=0)

  Applies the homotopy membership test for a point to belong to a witness set of dimension dim, given by an embedding Laurent system in wsys, with corresponding generic points in gpts. The coordinates of the test point are given in the list point, as a list of doubles, with the real and imaginary part of each coordinate of the point. By default, verbose is True. The number of threads is given in tasks. If tasks is zero, then no multithreading is applied in the homotopy membership test. The default working precision is double ‘d’. Other levels of precision are double double precision ‘dd’ and quad double precision ‘qd’. There are two tolerances: evatol is the tolerance on the residual of the evaluation of the Laurent system at the test point. If the residual of the evaluation is not less than evatol, then the membertest returns False. Otherwise, the homotopy membership test is called and the memtol is used to compare the coordinates of the point with the newly computed generic points. If there is a match between the coordinates within the given tolerance memtol, then True is returned.

sets.membertest(wsys, gpts, dim, point, evatol=1e-06, memtol=1e-06, verbose=True, precision='d', tasks=0)

  Applies the homotopy membership test for a point to belong to a witness set of dimension dim, given by an embedding polynomial system in wsys, with corresponding generic points in gpts. The coordinates of the test point are given in the list point, as a list of doubles, with the real and imaginary part of each coordinate of the point. By default, verbose is True. The number of threads is given in tasks. If tasks is zero, then no multithreading is applied in the homotopy membership test. The default working precision is double ‘d’. Other levels of precision are double double precision ‘dd’ and quad double precision ‘qd’. There are two tolerances: evatol is the tolerance on the residual of the evaluation of the polynomial equations at the test point. If the residual of the evaluation is not less than evatol, then the membertest returns False. Otherwise, the homotopy membership test is called and the memtol is used to compare the coordinates of the point with the newly computed generic points. If there is a match between the coordinates within the given tolerance memtol, then True is returned.

sets.quaddobl_embed(nvar, topdim, pols)

  Given in pols a list of strings that represent polynomials in nvar variables, with coefficients in quad double precision, this function returns an embedding of pols of dimension topdim. The topdim is the top dimension which equals the expected highest dimension of a component of the solution set of the system of polynomials.

sets.quaddobl_ismember(wsys, gpts, dim, point, evatol=1e-06, memtol=1e-06, verbose=True, tasks=0)

  Applies the homotopy membership test for a point to belong to a witness set of dimension dim, given by an embedding polynomial system in wsys, with corresponding generic points in gpts. The coordinates of the test point are given in the string point, which is the string representation of a solution in PHCpack format, with symbols of the variables before the values of the coordinates. By default, verbose is True. The number of threads is given in tasks. If tasks is zero, then no multithreading is applied in the homotopy membership test. Calculations happen in quad double precision. The default values for the evaluation (evatol) and the membership (memtol) allow for singular values at the end points of the paths in the homotopy membership test. Returns a tuple of two booleans. The first boolean is True if the point satisfies the equations, otherwise it is False. The second boolean is True if the point belongs to the witness set, otherwise, the second boolean is False.

sets.quaddobl_ismember_filter(wsys, gpts, dim, points, rcotol=1e-06, evatol=1e-06, memtol=1e-06, verbose=True, tasks=0)

  Given in wsys and gpts is a witness set of dimension dim, where wsys is an embedded polynomial system, and in points a list of strings. The strings represent points as solutions in PHCpack format. The homotopy membership test is applied to each point in the list points. The list on return contains the points that do NOT belong to the witness set. Points that belong to the witness set are considered junk. By default, verbose is True. The number of threads is given in tasks. If tasks is zero, then no multithreading is applied in the homotopy membership test. Calculations happen in quad double precision. The parameter rcotol is used to bypass the homotopy membership test, for points with their estimated inverse condition number larger than rcotol will be considered isolated and not in the witness set.

sets.quaddobl_laurent_embed(nvar, topdim, pols)

  Given in pols a list of strings that represent Laurent polynomials in nvar variables, with coefficients in quad double precision, this function returns an embedding of pols of dimension topdim. The topdim is the top dimension which equals the expected highest dimension of a component of the solution set of the system of polynomials.

sets.quaddobl_laurent_ismember(wsys, gpts, dim, point, evatol=1e-06, memtol=1e-06, verbose=True, tasks=0)

  Applies the homotopy membership test for a point to belong to a witness set of dimension dim, given by an embedding polynomial Laurent system in wsys, with corresponding generic points in gpts. The coordinates of the test point are given in the string point, which is the string representation of a solution in PHCpack format, with symbols of the variables before the values of the coordinates. By default, verbose is True. The number of threads is given in tasks. If tasks is zero, then no multithreading is applied in the homotopy membership test. Calculations happen in quad double precision. The default values for the evaluation (evatol) and the membership (memtol) allow for singular values at the end points of the paths in the homotopy membership test. Returns a tuple of two booleans. The first boolean is True if the point satisfies the equations, otherwise it is False. The second boolean is True if the point belongs to the witness set, otherwise, the second boolean is False.

sets.quaddobl_laurent_ismember_filter(wsys, gpts, dim, points, rcotol=1e-06, evatol=1e-06, memtol=1e-06, verbose=True, tasks=0)

  Given in wsys and gpts is a witness set of dimension dim, where wsys is an embedded Laurent polynomial system, and in points a list of strings. The strings represent points as solutions in PHCpack format. The homotopy membership test is applied to each point in the list points. The list on return contains the points that do NOT belong to the witness set. Points that belong to the witness set are considered junk. By default, verbose is True. The number of threads is given in tasks. If tasks is zero, then no multithreading is applied in the homotopy membership test. Calculations happen in quad double precision. The parameter rcotol is used to bypass the homotopy membership test, for points with their estimated inverse condition number larger than rcotol will be considered isolated and not in the witness set.

sets.quaddobl_laurent_membertest(wsys, gpts, dim, point, evatol=1e-06, memtol=1e-06, verbose=True, tasks=0)

  Applies the homotopy membership test for a point to belong to a witness set of dimension dim, given by an embedding Laurent system in wsys, with corresponding generic points in gpts. The coordinates of the test point are given in the list point, as a list of doubles, with the real and imaginary part of each coordinate of the point. By default, verbose is True. The number of threads is given in tasks. If tasks is zero, then no multithreading is applied in the homotopy membership test. Calculations happen in quad double precision. The default values for the evaluation (evatol) and the membership (memtol) allow for singular values at the end points of the paths in the homotopy membership test.

sets.quaddobl_membertest(wsys, gpts, dim, point, evatol=1e-06, memtol=1e-06, verbose=True, tasks=0)

  Applies the homotopy membership test for a point to belong to a witness set of dimension dim, given by an embedding polynomial system in wsys, with corresponding generic points in gpts. The coordinates of the test point are given in the list point, as a list of doubles, with the real and imaginary part of each coordinate of the point. By default, verbose is True. The number of threads is given in tasks. If tasks is zero, then no multithreading is applied in the homotopy membership test. Calculations happen in quad double precision. The default values for the evaluation (evatol) and the membership (memtol) allow for singular values at the end points of the paths in the homotopy membership test.

sets.standard_embed(nvar, topdim, pols)

  Given in pols a list of strings representing polynomials in nvar variables, with coefficients in standard double precision, this function returns an embedding of pols of dimension topdim. The topdim is the top dimension which equals the expected highest dimension of a component of the solution set of the system of polynomials.

sets.standard_ismember(wsys, gpts, dim, point, evatol=1e-06, memtol=1e-06, verbose=True, tasks=0)

  Applies the homotopy membership test for a point to belong to a witness set of dimension dim, given by an embedding polynomial system in wsys, with corresponding generic points in gpts. The coordinates of the test point are given in the string point, which is the string representation of a solution in PHCpack format, with symbols of the variables before the values of the coordinates. By default, verbose is True. The number of threads is given in tasks. If tasks is zero, then no multithreading is applied in the homotopy membership test. Calculations happen in standard double precision. The default values for the evaluation (evatol) and the membership (memtol) allow for singular values at the end points of the paths in the homotopy membership test. Returns a tuple of two booleans. The first boolean is True if the point satisfies the equations, otherwise it is False. The second boolean is True if the point belongs to the witness set, otherwise, the second boolean is False.

sets.standard_ismember_filter(wsys, gpts, dim, points, rcotol=1e-06, evatol=1e-06, memtol=1e-06, verbose=True, tasks=0)

  Given in wsys and gpts is a witness set of dimension dim, where wsys is an embedded polynomial system, and in points a list of strings. The strings represent points as solutions in PHCpack format. The homotopy membership test is applied to each point in the list points. The list on return contains the points that do NOT belong to the witness set. Points that belong to the witness set are considered junk. By default, verbose is True. The number of threads is given in tasks. If tasks is zero, then no multithreading is applied in the homotopy membership test. Calculations happen in standard double precision. The parameter rcotol is used to bypass the homotopy membership test, for points with their estimated inverse condition number larger than rcotol will be considered isolated and not in the witness set.

sets.standard_laurent_embed(nvar, topdim, pols)

  Given in pols a list of strings representing Laurent polynomials in nvar variables, with coefficients in standard double precision, this function returns an embedding of pols of dimension topdim. The topdim is the top dimension which equals the expected highest dimension of a component of the solution set of the system of polynomials.

sets.standard_laurent_ismember(wsys, gpts, dim, point, evatol=1e-06, memtol=1e-06, verbose=True, tasks=0)

  Applies the homotopy membership test for a point to belong to a witness set of dimension dim, given by an embedding polynomial Laurent system in wsys, with corresponding generic points in gpts. The coordinates of the test point are given in the string point, which is the string representation of a solution in PHCpack format, with symbols of the variables before the values of the coordinates. By default, verbose is True. The number of threads is given in tasks. If tasks is zero, then no multithreading is applied in the homotopy membership test. Calculations happen in standard double precision. The default values for the evaluation (evatol) and the membership (memtol) allow for singular values at the end points of the paths in the homotopy membership test. Returns a tuple of two booleans. The first boolean is True if the point satisfies the equations, otherwise it is False. The second boolean is True if the point belongs to the witness set, otherwise, the second boolean is False.

sets.standard_laurent_ismember_filter(wsys, gpts, dim, points, rcotol=1e-06, evatol=1e-06, memtol=1e-06, verbose=True, tasks=0)

  Given in wsys and gpts is a witness set of dimension dim, where wsys is an embedded Laurent polynomial system, and in points a list of strings. The strings represent points as solutions in PHCpack format. The homotopy membership test is applied to each point in the list points. The list on return contains the points that do NOT belong to the witness set. Points that belong to the witness set are considered junk. By default, verbose is True. The number of threads is given in tasks. If tasks is zero, then no multithreading is applied in the homotopy membership test. Calculations happen in standard double precision. The parameter rcotol is used to bypass the homotopy membership test, for points with their estimated inverse condition number larger than rcotol will be considered isolated and not in the witness set.

sets.standard_laurent_membertest(wsys, gpts, dim, point, evatol=1e-06, memtol=1e-06, verbose=True, tasks=0)

  Applies the homotopy membership test for a point to belong to a witness set of dimension dim, given by an embedding Laurent system in wsys, with corresponding generic points in gpts. The coordinates of the test point are given in the list point, as a list of doubles, with the real and imaginary part of each coordinate of the point. By default, verbose is True. The number of threads is given in tasks. If tasks is zero, then no multithreading is applied in the homotopy membership test. Calculations happen in standard double precision. The default values for the evaluation (evatol) and the membership (memtol) allow for singular values at the end points of the paths in the homotopy membership test.

sets.standard_membertest(wsys, gpts, dim, point, evatol=1e-06, memtol=1e-06, verbose=True, tasks=0)

  Applies the homotopy membership test for a point to belong to a witness set of dimension dim, given by an embedding polynomial system in wsys, with corresponding generic points in gpts. The coordinates of the test point are given in the list point, as a list of doubles, with the real and imaginary part of each coordinate of the point. By default, verbose is True. The number of threads is given in tasks. If tasks is zero, then no multithreading is applied in the homotopy membership test. Calculations happen in standard double precision. The default values for the evaluation (evatol) and the membership (memtol) allow for singular values at the end points of the paths in the homotopy membership test.

sets.test()

  Runs a test on algebraic sets.

sets.test_member(prc='d')

  To test the membership, we take the twisted cubic.

sets.test_twisted_ismember(prc='d', laurent=True)

  To test the membertest wrapper, we take the twisted cubic again. The test point is given as a solution in PHCpack format.

sets.witness_set_of_hypersurface(nvar, hpol, precision='d')

  Given in hpol the string representation of a polynomial in nvar variables (ending with a semicolon), on return is an embedded system and its solutions which represents a witness set for hpol. The number of solutions on return should equal the degree of the polynomial in hpol. Three different precisions are supported, by default double (‘d’), or otherwise double double (‘dd’) or quad double (‘qd’).

sets.witness_set_of_laurent_hypersurface(nvar, hpol, precision='d')

  Given in hpol the string representation of a laurent polynomial in nvar variables (ending with a semicolon), on return is an embedded system and its solutions which represents a witness set for hpol. The number of solutions on return may differ from the actual degree of hpol if the polynomial represented by hpol has negative exponents. Three different precisions are supported, by default double (‘d’), or otherwise double double (‘dd’) or quad double (‘qd’).

### functions in the module cascades

A cascade homotopy removes one hyperplane from an embedded system, taking the solutions with nonzero slack variables to solutions on lower dimensional components of the solution set of the original system.

cascades.cascade_filter(dim, embpols, nonsols, tol, nbtasks=0, prc='d', verbose=True)

  Runs one step in the cascade homotopy defined by the embedding of polynomials in embpols, starting at the solutions in nonsols, removing the last hyperplane from embpols at dimension dim. The tolerance tol is used to split filter the solutions. By default, the precision prc is double (‘d’). Other valid values for prc are ‘dd’ (for double double) and ‘qd’ (for quad double). If verbose, then some output is written to screen.

cascades.cascade_step(dim, embsys, esols, precision='d', tasks=0)

  Given in embsys an embedded polynomial system and solutions with nonzero slack variables in esols, does one step in the homotopy cascade, with precision

  d: standard double precision (1.1e-15 or 2^(-53)),

  dd: double double precision (4.9e-32 or 2^(-104)),

  qd: quad double precision (1.2e-63 or 2^(-209)).

  The dimension of the solution set represented by embsys and esols is the value of dim. The number of tasks in multithreaded path tracking is given by tasks. The default zero value of tasks indicates no multithreading. The list on return contains witness points on lower dimensional solution components.

cascades.double_double_cascade_step(dim, embsys, esols, tasks=0)

  Given in embsys an embedded polynomial system and solutions with nonzero slack variables in esols, does one step in the homotopy cascade, with double double precision arithmetic. The dimension of the solution set represented by embsys and esols is the value of dim. The number of tasks in multithreaded path tracking is given by tasks. The default zero value of tasks indicates no multithreading. The list on return contains witness points on lower dimensional solution components.

cascades.double_double_laurent_cascade_step(dim, embsys, esols, tasks=0)

  Given in embsys an embedded Laurent polynomial system and solutions with nonzero slack variables in esols, does one step in the homotopy cascade, with double double precision arithmetic. The dimension of the solution set represented by embsys and esols is the value of dim. The number of tasks in multithreaded path tracking is given by tasks. The default zero value of tasks indicates no multithreading. The list on return contains witness points on lower dimensional solution components.

cascades.laurent_cascade_filter(dim, embpols, nonsols, tol, nbtasks=0, prc='d', verbose=True)

  Runs one step in the cascade homotopy defined by the embedding of Laurent polynomials in embpols, starting at the solutions in nonsols, removing the last hyperplane from embpols at dimension dim. The tolerance tol is used to split filter the solutions. By default, the precision prc is double (‘d’). Other valid values for prc are ‘dd’ (for double double) and ‘qd’ (for quad double). If verbose, then some output is written to screen.

cascades.laurent_cascade_step(dim, embsys, esols, precision='d', tasks=0)

  Given in embsys an embedded Laurent polynomial system and solutions with nonzero slack variables in esols, does one step in the homotopy cascade, with precision

  d: standard double precision (1.1e-15 or 2^(-53)),

  dd: double double precision (4.9e-32 or 2^(-104)),

  qd: quad double precision (1.2e-63 or 2^(-209)).

  The dimension of the solution set represented by embsys and esols is the value of dim. The number of tasks in multithreaded path tracking is given by tasks. The default zero value of tasks indicates no multithreading. The list on return contains witness points on lower dimensional solution components.

cascades.laurent_top_cascade(nvr, dim, pols, tol, nbtasks=0, prc='d', verbose=True)

  Constructs an embedding of the Laurent polynomials in pols, with the number of variables in pols equal to nvr, where dim is the top dimension of the solution set. Applies the blackbox solver to the embedded system. The tolerance tol is used to split the solution list in the list of generic points and the nonsolutions for use in the cascade. Returns a tuple with three items:

  1. the embedded system,

  2. the solutions with zero last coordinate w.r.t. tol,

  3. the solutions with nonzero last coordinate w.r.t. tol.

  The three parameters are

  1. nbtasks is the number of tasks, 0 if no multitasking;

  2. the working precision prc, ‘d’ for double, ‘dd’ for double double, or ‘qd’ for quad double;

  3. if verbose, then some output is written to screen.

cascades.quad_double_cascade_step(dim, embsys, esols, tasks=0)

  Given in embsys an embedded polynomial system and solutions with nonzero slack variables in esols, does one step in the homotopy cascade, with quad double precision arithmetic. The dimension of the solution set represented by embsys and esols is the value of dim. The number of tasks in multithreaded path tracking is given by tasks. The default zero value of tasks indicates no multithreading. The list on return contains witness points on lower dimensional solution components.

cascades.quad_double_laurent_cascade_step(dim, embsys, esols, tasks=0)

  Given in embsys an embedded Laurent polynomial system and solutions with nonzero slack variables in esols, does one step in the homotopy cascade, with quad double precision arithmetic. The dimension of the solution set represented by embsys and esols is the value of dim. The number of tasks in multithreaded path tracking is given by tasks. The default zero value of tasks indicates no multithreading. The list on return contains witness points on lower dimensional solution components.

cascades.run_cascade(nvr, dim, pols, islaurent=False, tol=1e-08, rcotol=1e-06, evatol=1e-06, memtol=1e-06, tasks=0, prc='d', verbose=True)

  Runs a cascade on the polynomials pols, in the number of variables equal to nvr, starting at the top dimension dim. If islaurent, then the polynomials in pols may have negative exponents. Returns a dictionary with as keys the dimensions and as values the tuples with the embedded systems and the corresponding generic points. Four tolerance parameters have default values on input: tol is used to decide which slack variables are zero, rcotol is the tolerance on the estimated inverse condition number, evatol is the tolerance on the residual to filter junk points, memtol is the tolerance for the homotopy membership test. The number of tasks is given by tasks (0 for no multitasking) and the default precision is double. Other supported values for prc are ‘dd’ for double double and ‘qd’ for quad double. If verbose, then a summary of the filtering is printed.

cascades.split_filter(sols, dim, tol, verbose=True)

  Given in sols is a list of solutions of dimension dim, which contain a variable with name ‘zz’ + str(dim), which is the name of the last slack variable. The tolerance tol is used to split the list of solution in two. On return is a tuple of two lists of solutions (possibly empty). The first list of solutions has the last slack variable equal to zero (with respect to the tolerance tol) and the last slack variable of each solution in the second list has a magnitude larger than *tol. If verbose, then the length of each solution list is printed.

cascades.standard_double_cascade_step(dim, embsys, esols, tasks=0)

  Given in embsys an embedded polynomial system and solutions with nonzero slack variables in esols, does one step in the homotopy cascade, with standard double precision arithmetic. The dimension of the solution set represented by embsys and esols is the value of dim. The number of tasks in multithreaded path tracking is given by tasks. The default zero value of tasks indicates no multithreading. The list on return contains witness points on lower dimensional solution components.

cascades.standard_double_laurent_cascade_step(dim, embsys, esols, tasks=0)

  Given in embsys an embedded Laurent polynomial system and solutions with nonzero slack variables in esols, does one step in the homotopy cascade, with standard double precision arithmetic. The dimension of the solution set represented by embsys and esols is the value of dim. The number of tasks in multithreaded path tracking is given by tasks. The default zero value of tasks indicates no multithreading. The list on return contains witness points on lower dimensional solution components.

cascades.test()

  Fixes a seed for the random number generators before running the test on the cascade homotopies.

cascades.test_cascade()

  Does one cascade step on simple example. In the top embedding we first find the 2-dimensional solution set x = 1. In the cascade step we compute the three witness points on the twisted cubic.

cascades.test_run_cascade()

  Runs the cascade on a list of polynomials.

cascades.top_cascade(nvr, dim, pols, tol, nbtasks=0, prc='d', verbose=True)

  Constructs an embedding of the polynomials in pols, with the number of variables in pols equal to nvr, where dim is the top dimension of the solution set. Applies the blackbox solver to the embedded system. The tolerance tol is used to split the solution list in the list of generic points and the nonsolutions for use in the cascade. Returns a tuple with three items:

  1. the embedded system,

  2. the solutions with zero last coordinate w.r.t. tol,

  3. the solutions with nonzero last coordinate w.r.t. tol.

  The three parameters are

  1. nbtasks is the number of tasks, 0 if no multitasking;

  2. the working precision prc, ‘d’ for double, ‘dd’ for double double, or ‘qd’ for quad double;

  3. if verbose, then some output is written to screen.

### functions in the module factor

Given a witness set representation of a pure dimensional solution set, the functions in this module separate the generic points in the witness set according to the irreducible components of the solution set.

factor.decompose(deco, islaurent=0, verbose=True, nbloops=20, precision='d')

  Given in deco is a dictionary with as keys the dimension and as value a tuple with an embedded (Laurent) polynomial system and its corresponding solutions as the second item in the tuple. Each item in the dictionary is decomposed into irreducible factors. If the embedded polynomial system is a Laurent system, then islaurent must equal one, the default is zero. The default precision is double ‘d’. Other valid values for precision are ‘dd’ for double double, or ‘qd’ for quad double. Returns the dictionary deco, but each tuple (except for dimension 0) is extended with the partition of the generic points with the linear trace difference to represented the irreducible decomposition.

factor.decomposition(deg, precision='d')

  Returns the decomposition as a list of labels of witness points on the components, computed in precision ‘d’, ‘dd’, or ‘qd’, respectively for double, double double, or quad double.

factor.dobldobl_decomposition(deg)

  Returns the decomposition as a list of labels of witness points on the components, computed in double double precision.

factor.dobldobl_laursys_solve(pols, topdim=- 1, filter=True, factor=True, tasks=0, verbose=True)

  Runs the cascades of homotopies on the Laurent polynomial system in pols in double double precision. The default top dimension topdim is the number of variables in pols minus one.

factor.dobldobl_monodromy_breakup(embsys, esols, dim, islaurent=0, verbose=True, nbloops=0)

  Applies the monodromy breakup algorithm in double double precision to factor the dim-dimensional algebraic set represented by the embedded system embsys and its solutions esols. If the embedded polynomial system is a Laurent system, then islaurent must equal one, the default is zero. If verbose is False, then no output is written. If nbloops equals zero, then the user is prompted to give the maximum number of loops.

factor.dobldobl_polysys_solve(pols, topdim=- 1, filter=True, factor=True, tasks=0, verbose=True)

  Runs the cascades of homotopies on the polynomial system in pols in double double precision. The default top dimension topdim is the number of variables in pols minus one.

factor.factor(dim, witsys, witsols, islaurent=0, verbose=True, nbloops=20, precision='d')

  Applies monodromy to factor an equidimensional algebraic set, given as a witness sets, with the embedded polynomials in witsys, and corresponding generic points in witsols. If the embedded polynomial system is a Laurent system, then islaurent must equal one, the default is zero. The dimension of the algebraic set is given in dim. The default precision is double ‘d’. Other valid values for precision are ‘dd’ for double double, or ‘qd’ for quad double.

factor.laursys_solve(pols, topdim=- 1, precision='d', filter=True, factor=True, tasks=0, verbose=True)

  Runs the cascades of homotopies on the Laurent polynomial system in pols in double, double double, or quad double precision. The default top dimension topdim is the number of variables in pols minus one.

factor.monodromy_breakup(embsys, esols, dim, islaurent=0, verbose=True, nbloops=0, prec='d')

  Applies the monodromy breakup algorithm to factor the dim-dimensional set represented by the embedded system embsys and its solutions esols. If the embedded polynomial system is a Laurent system, then islaurent must equal one, the default is zero. If verbose is False, then no output is written. If nbloops equals zero, then the user is prompted to give the maximum number of loops. Three different levels of precision are supported: double precision ‘d’ (for the value for prec) is the default, the two other precisions are double double precision ‘dd’ and quad double precision ‘qd’.

factor.polysys_solve(pols, topdim=- 1, precision='d', filter=True, factor=True, tasks=0, verbose=True)

  Runs the cascades of homotopies on the polynomial system in pols in double, double double, or quad double precision. The default top dimension topdim is the number of variables in pols minus one.

factor.quaddobl_decomposition(deg)

  Returns the decomposition as a list of labels of witness points on the components, computed in quad double precision.

factor.quaddobl_laursys_solve(pols, topdim=- 1, filter=True, factor=True, tasks=0, verbose=True)

  Runs the cascades of homotopies on the Laurent polynomial system in pols in quad double precision. The default top dimension topdim is the number of variables in pols minus one.

factor.quaddobl_monodromy_breakup(embsys, esols, dim, islaurent=0, verbose=True, nbloops=0)

  Applies the monodromy breakup algorithm in quad double precision to factor the dim-dimensional algebraic set represented by the embedded system embsys and its solutions esols. If the embedded polynomial system is a Laurent system, then islaurent must equal one, the default is zero. If verbose is False, then no output is written. If nbloops equals zero, then the user is prompted to give the maximum number of loops.

factor.quaddobl_polysys_solve(pols, topdim=- 1, filter=True, factor=True, tasks=0, verbose=True)

  Runs the cascades of homotopies on the polynomial system in pols in quad double precision. The default top dimension topdim is the number of variables in pols minus one.

factor.solve(nvr, dim, pols, islaurent=False, precision='d', tasks=0, nbloops=20, tol=1e-08, rcotol=1e-06, evatol=1e-06, memtol=1e-06, verbose=True)

  Computes a numerical irreducible decomposition for the polynomials in the list pols, where nvr is the number of variables in pols. The top dimension (the highest dimension of the solution set) is given in dim and could be by default set to nvr-1. If islaurent, then pols is considered a Laurent polynomial system and negative exponents may occur. The default precision is double ‘d’. Other valid values for precision are ‘dd’ for double double, or ‘qd’ for quad double. On return is a dictionary. The keys in the dictionary are dimensions. For each dimension, a tuple represents a witness set. For dimension zero, the solution list contains the isolated solutions. For each nonzero dimension, the generic points in the witness set are partitioned according to the irreducible factors of the solution set at that dimension.

factor.standard_decomposition(deg)

  Returns the decomposition as a list of labels of witness points on the components, computed in standard double precision.

factor.standard_laursys_solve(pols, topdim=- 1, filter=True, factor=True, tasks=0, verbose=True)

  Runs the cascades of homotopies on the Laurent polynomial system in pols in standard double precision. The default top dimension topdim is the number of variables in pols minus one.

factor.standard_monodromy_breakup(embsys, esols, dim, islaurent=0, verbose=True, nbloops=0)

  Applies the monodromy breakup algorithm in standard double precision to factor the dim-dimensional algebraic set represented by the embedded system embsys and its solutions esols. If the embedded polynomial system is a Laurent system, then islaurent must equal one, the default is zero. If verbose is False, then no output is written. If nbloops equals zero, then the user is prompted to give the maximum number of loops.

factor.standard_polysys_solve(pols, topdim=- 1, filter=True, factor=True, tasks=0, verbose=True)

  Runs the cascades of homotopies on the polynomial system in pols in standard double precision. The default top dimension topdim is the number of variables in pols minus one.

factor.test()

  Sets the seed for the random number generators to a fixed number and then runs a test.

factor.test_decompose()

  Runs a test on the decompose() function.

factor.test_factor()

  Simple test on the factor method.

factor.test_monodromy(prc='d')

  Runs a test on applying monodromy loops to factor a curve into irreducible components.

factor.test_polysys_solve()

  Runs a test on the standard_polysys_solve() function.

factor.test_solve()

  Runs a test on the solve() function.

factor.write_decomposition(deco)

  Given in deco is a dictionary where the keys are dimensions. For each dimension, there is a tuple with a witness set representation of the solution set at that dimension. The decomposition in deco is written.

### functions in the module diagonal

Given two witness sets for two pure dimensional solution sets, a diagonal homotopy computes a sets of witness sets for all components of the intersection of the two pure dimensional solution sets.

diagonal.diagonal_solver(dim, dm1, sys1, sols1, dm2, sys2, sols2, tasks=0, prc='d', verbose=True)

  Runs the diagonal homotopies to intersect two witness sets stored in (sys1, sols1) and (sys2, sols2), of respective dimensions dim1 and dim2. The ambient dimension equals dim. Multitasking is available, and is activated by the tasks parameter. The precision is set by the parameter prc, which takes the default value ‘d’ for standard double, ‘dd’ for double double, or ‘qd’ for quad double precision. Returns the last system in the cascade and its solutions.

diagonal.dobldobl_diagonal_cascade_solutions(dim1, dim2)

  Defines the start solutions in the cascade to start the diagonal homotopy to intersect a set of dimension dim1 with another set of dimension dim2, in double double precision. For this to work, dobldobl_diagonal_homotopy must have been executed successfully.

diagonal.dobldobl_diagonal_homotopy(dim1, sys1, esols1, dim2, sys2, esols2)

  Defines a diagonal homotopy to intersect the witness sets defined by (sys1, esols1) and (sys2, esols2), respectively of dimensions dim1 and dim2. The systems sys1 and sys2 are assumed to be square and with as many slack variables as the dimension of the solution sets. The data is stored in double double precision.

diagonal.dobldobl_diagonal_solver(dim, dm1, sys1, sols1, dm2, sys2, sols2, tasks=0, verbose=True)

  Runs the diagonal homotopies in double double precision to intersect two witness sets stored in (sys1, sols1) and (sys2, sols2), of respective dimensions dm1 and dm2. The ambient dimension equals dim. Multitasking is available, and is activated by the tasks parameter. Returns the last system in the cascade and its solutions. If verbose, then the solver runs in interactive mode, printing intermediate results to screen and prompting the user to continue.

diagonal.dobldobl_start_diagonal_cascade(gamma=0, tasks=0)

  Does the path tracking to start a diagonal cascade in double double precision. For this to work, the functions dobldobl_diagonal_homotopy and dobldobl_diagonal_cascade_solutions must be executed successfully. If gamma equals 0 on input, then a random gamma constant is generated, otherwise, the given complex gamma will be used in the homotopy. Multitasking is available, and activated by the tasks parameter. Returns the target (system and its corresponding) solutions.

diagonal.quaddobl_diagonal_cascade_solutions(dim1, dim2)

  Defines the start solutions in the cascade to start the diagonal homotopy to intersect a set of dimension dim1 with another set of dimension dim2, in quad double precision. For this to work, quaddobl_diagonal_homotopy must have been executed successfully.

diagonal.quaddobl_diagonal_homotopy(dim1, sys1, esols1, dim2, sys2, esols2)

  Defines a diagonal homotopy to intersect the witness sets defined by (sys1, esols1) and (sys2, esols2), respectively of dimensions dim1 and dim2. The systems sys1 and sys2 are assumed to be square and with as many slack variables as the dimension of the solution sets. The data is stored in quad double precision.

diagonal.quaddobl_diagonal_solver(dim, dm1, sys1, sols1, dm2, sys2, sols2, tasks=0, verbose=True)

  Runs the diagonal homotopies in quad double precision to intersect two witness sets stored in (sys1, sols1) and (sys2, sols2), of respective dimensions dm1 and dm2. The ambient dimension equals dim. Multitasking is available, and is activated by the tasks parameter. Returns the last system in the cascade and its solutions. If verbose, then the solver runs in interactive mode, printing intermediate results to screen and prompting the user to continue.

diagonal.quaddobl_start_diagonal_cascade(gamma=0, tasks=0)

  Does the path tracking to start a diagonal cascade in quad double precision. For this to work, the functions quaddobl_diagonal_homotopy and quaddobl_diagonal_cascade_solutions must be executed successfully. If gamma equals 0 on input, then a random gamma constant is generated, otherwise, the given complex gamma will be used in the homotopy. Multitasking is available, and is activated by the tasks parameter. Returns the target (system and its corresponding) solutions.

diagonal.standard_diagonal_cascade_solutions(dim1, dim2)

  Defines the start solutions in the cascade to start the diagonal homotopy to intersect a set of dimension dim1 with another set of dimension dim2, in standard double precision. For this to work, standard_diagonal_homotopy must have been executed successfully.

diagonal.standard_diagonal_homotopy(dim1, sys1, esols1, dim2, sys2, esols2)

  Defines a diagonal homotopy to intersect the witness sets defined by (sys1, esols1) and (sys2, esols2), respectively of dimensions dim1 and dim2. The systems sys1 and sys2 are assumed to be square and with as many slack variables as the dimension of the solution sets. The data is stored in standard double precision.

diagonal.standard_diagonal_solver(dim, dm1, sys1, sols1, dm2, sys2, sols2, tasks=0, verbose=True)

  Runs the diagonal homotopies in standard double precision to intersect two witness sets stored in (sys1, sols1) and (sys2, sols2), of respective dimensions dm1 and dm2. The ambient dimension equals dim. Multitasking is available, and is activated by the tasks parameter. Returns the last system in the cascade and its solutions. If verbose, then the solver runs in interactive mode, printing intermediate results to screen and prompting the user to continue.

diagonal.standard_start_diagonal_cascade(gamma=0, tasks=0)

  Does the path tracking to start a diagonal cascade in standard double precision. For this to work, the functions standard_diagonal_homotopy and standard_diagonal_cascade_solutions must be executed successfully. If gamma equals 0 on input, then a random gamma constant is generated, otherwise, the given complex gamma will be used in the homotopy. Multitasking is available, and activated by the tasks parameter. Returns the target (system and its corresponding) solutions.

diagonal.test()

  Runs a test on algebraic sets.

diagonal.test_diaghom(precision='d')

  Test on the diagonal homotopy.

diagonal.top_diagonal_dimension(kdm, dim1, dim2)

  Returns the number of slack variables at the top in the cascade of diagonal homotopies to intersect two sets of dimension dim1 and dim2, where dim1 >= dim2 and kdm is the dimension before the embedding. Typically, kdm is the number of equations in the first witness set minus dim1.

## some interesting families and examples

One of the motivations for phcpy was to perform regression tests on the blackbox solver.

### functions in the module examples

The documentation strings of the functions that return the polynomials of the example systems as strings of characters are listed below. The regression test is exported by the function test() of the module `examples`.

This module offers functions to returns the lists of polynomial strings of some well known examples. The test solves all systems and tests on the number of solutions. Running the test can take some time.

examples.binomials()

  A binomial system is a polynomial system where every equation has exactly two monomials with nonzero coefficient. A pure dimensional binomial system can be solved quickly. The example below has negative exponents.

examples.cyclic7()

  The cyclic 7-roots problem is a standard benchmark problem for polynomial system solvers. Reference: Backelin, J. and Froeberg, R.: How we proved that there are exactly 924 cyclic 7-roots, Proceedings of ISSAC-91, pp 103-111, ACM, New York, 1991.

examples.fbrfive4()

  Four-bar linkage through five points, 4-dimensional version. Reference: Charles W. Wampler: Isotropic coordinates, circularity and Bezout numbers: planar kinematics from a new perspective. Publication R&D-8188, General Motors Corporation, Research and Development Center. Proceedings of the 1996 ASME Design Engineering Technical Conference, Irvine, California August 18-22, 1996. CD-ROM edited by McCarthy, J.M., American society of mechanical engineers.

examples.game4two()

  Totally mixed Nash equilibria for 4 players with two pure strategies. See the paper by Andrew McLennan on The maximal generic number of pure Nash equilibria, Journal of Economic Theory, Vol 72, pages 408-410, 1997. Another reference is the paper by Richard D. McKelvey and Andrew McLennan: on The maximal number of regular totally mixed Nash equilibria, Journal of Economic Theory, Volume 72, pages 411-425, 1997. For more on equilibria, see David M. Kreps and Robert Wilson: Sequential Equibria, Econometrica, Vol 50, No 4, pages 863-894,1982.

examples.katsura6()

  A problem of magnetism in physics, see for examples the paper by S. Katsura, in New Trends in Magnetism, edited by M.D. Coutinho-Filho and S.M. Resende, World Scientific, 1990. It became part of the PoSSo test suite, Shigotoshi Katsura: “Users posing problems to PoSSo”, in the PoSSo Newsletter, no. 2, July 1994, edited by L. Gonzalez-Vega and T. Recio. See also the paper by W. Boege, R. Gebauer, and H. Kredel: Some examples for solving systems of algebraic equations by calculating Groebner bases, J. Symbolic Computation, 2:83-98, 1986. The system can be written for any dimension.

examples.noon3()

  A neural network modeled by an adaptive Lotka-Volterra system. See the paper by Karin Gatermann on Symbolic solution of polynomial equation systems with symmetry, Proceedings of ISSAC-90, pages 112-119, ACM New York, 1990. The system belongs to a family of problems of V.W. Noonburg: A neural network modeled by an adaptive Lotka-Volterra system, SIAM J. Appl. Math., Vol. 49, No. 6, 1779-1792, 1989.

examples.rps10()

  RPS Serial Chains for 10 positions on a circular hyperboloid. From the paper of Hai-Jun Su and J. Michael McCarthy: Kinematics Synthesis of RPS Serial Chains, In Proceedings of the ASME Design Engineering Technical Conferences (CDROM). Paper DETC03/DAC-48813. Chicago, IL, Sept.02-06, 2003.

examples.sevenbar()

  Returns the list of strings which represent Laurent polynomials for a special sevenbar mechanism that has isolated solutions and a cubic curve. A reference for the general case is the paper by Carlo Innocenti: Polynomial solution to the position analysis of the 7-line Assur kinematic chain with one quaternary link, in Mech. Mach. Theory, Vol. 30, No. 8, pages 1295-1303, 1995. The special case was introduced in the paper with title: Numerical decomposition of the solution sets of polynomial systems into irreducible components, SIAM J. Numer. Anal. 38(6):2022-2046, 2001, by Andrew Sommese, Jan Verschelde, and Charles Wampler.

examples.solve_binomials()

  Runs the test on solving the binomials example. Asserts that the number of solutions equals 20.

examples.solve_cyclic7()

  Runs the test on solving the cyclic 7-roots problem. Asserts that the number of solutions equals 924.

examples.solve_fbrfive4()

  Runs the test on solving a generic 4-bar problem. Asserts that the number of solutions equals 36.

examples.solve_game4two()

  Runs the test on solving the Nash equilibrium problem. Asserts that the number of solutions equals 9.

examples.solve_katsura6()

  Runs the test on solving the katsura6 problem. Asserts that the number of solutions equals 64.

examples.solve_noon3()

  Test on solving the noon3 system. Asserts that the number of solutions equals 21.

examples.solve_rps10()

  Test on solving a mechanical design problem. Asserts that the number of solutions equals 1024.

examples.solve_sevenbar()

  Test on solving a special 7-bar problem. Asserts that the number of isolated solutions equals 6 and that there are three generic points at a curve.

examples.solve_stewgou40()

  Test on solving a fully reall Stewart-Gough platform. Asserts that the number of solutions equals 40.

examples.solve_sysd1()

  Runs the test on solving the benchmark problem D1. Asserts that the number of solutions equals 48.

examples.solve_tangents()

  Test on solving the tangents to 4 spheres problem. Asserts that the number of solutions equals 6.

examples.stewgou40()

  Stewart-Gough platform with 40 real postures. From the paper of Peter Dietmaier: The Stewart-Gough platform of general geometry can have 40 real postures, pages 1-10, in Advances in Robot Kinematics: Analysis and Control, edited by Jadran Lenarcic and Manfred L. Husty, Kluwer Academic Publishers, Dordrecht, 1998.

examples.sysd1()

  A sparse system, know as benchmark D1 of the paper by H. Hong and V. Stahl: Safe Starting Regions by Fixed Points and Tightening, Computing 53(3-4): 322-335, 1995.

examples.tangents()

  Three lines tangent to four given spheres, each with multiplicity 4. Originally formulated as a polynomial system by Cassiano Durand. Thorsten Teobald came up with the positioning of the centers of the spheres, each with radius 0.5 at the vertices of a tethrahedron. See the paper by Frank Sottile: From Enumerative Geometry to Solving Systems of Polynomial Equations”. In “Computations in Algebraic Geometry with Macaulay 2”, edited by David Eisenbud, Daniel R. Grayson, Michael Stillman, and Bernd Sturmfels, Volume 8 of Algorithms and Computation in Mathematics, pages 101-129, Springer-Verlag, 2002. Another reference is the paper by Frank Sottile and Thorsten Theobald: Lines tangents to 2n - 2 spheres in R^n. Trans. Amer. Math. Soc. 354:4815-4829, 2002.

examples.test()

  Solves the systems and tests on their number of solutions.

### functions in the module families

The module families contains scripts to generate polynomial systems for any dimension.

families.adjacent_minors(rows, cols)

  Returns all adjacent 2-by-2 minors of a general matrix of dimensions rows by cols. This system originated in a paper on lattice walks and primary decomposition, written by P. Diaconis, D. Eisenbud, and B. Sturmfels, published by Birkhauser in 1998 in Mathematical Essays in Honor of Gian-Carlo Rota, edited by B. E. Sagan and R. P. Stanley, volume 161 of Progress in Mathematics, pages 173–193. See also the paper by S. Hosten and J. Shapiro on Primary decomposition of lattice basis ideals, published in 2000 in the Journal of Symbolic Computation, volume 29, pages 625-639.

families.chandra(dim, par=0.51234)

  Generates the equations of the Chandrasekhar H-equation for the given dimension dim and parameter par. The name of the problem stems from the 1960 Dover publication Radiative Transfer by S. Chandrasekhar. The problem was used as an illustration in the paper by C.T. Kelley on Solution of the Chandrasekhar H-equation by Newton’s method, published in J. Math. Phys. 21, pages 1625-1628, 1980. It featured in the paper by Jorge J. More on A collection of nonlinear model problems, published in volume 26 of the Lectures in Applied Mathematics, pages 723-762, AMS 1990 and in the paper by Laureano Gonzalez-Vega on Some examples on problem solving by using the symbolic viewpoint when dealing with polynomial systems of equations, published in Computer Algebra in Science and Engineering, pages 102-116, World Scientific, 1995.

families.cyclic(dim)

  Returns a list of string representing the polynomials of the cyclic n-roots system. This system entered the computer algebra literature in a technical report by J. Davenport on Looking at a set of equations, published in 1987 as Bath Computer Science Technical Report 87-06. Another technical report by J. Backelin in 1989 has the title Square multiples n give infinitely many cyclic n-roots, publised as Reports, Matematiska Institutionen 8, Stockholms universitet. Another interesting preprint is written by U. Haagerup, available at http://www.math.ku.dk/~haagerup, on cyclic p-roots of prime length p and related complex Hadamard matrices.

families.firsteqs(dim)

  Returns the list of equations defining the relations between the S[i,j] and the r[i,j] variables, for all i < j, for i from 1 to dim-1. Since the S[i,j] variables occur linearly, with these equations we can rewrite S[i,j] in terms of the corresponding r[i,j] variables. The elimination of the S[i,j] comes at the expense of high degrees in the r[i,j] variables of the remaining equations.

families.generic_nash_system(nbplayers)

  Returns a list of strings representing polynomials that define totally mixed Nash equilibria for a number of players equals to nbplayers with two pure strategies. The problem setup is generic in the sense that the utilities are uniformly generated positive floats in [0,1]. For n players, the n-homogeneous Bezout number provides a generically exact count on the number of equilibria, see the paper by Richard D. McKelvey and Andrew McLennan on the maximal number of regular totally mixed Nash equilibria, published in the Journal of Economic Theory, volume 72, pages 411-425, 1997.

families.indeterminate_matrix(rows, cols)

  Returns a list of lists with as many lists as the value of rows. Each rows has as many indeterminates as the value of cols. The lists of lists contains the data for a matrix of dimension rows by cols of variables.

families.katsura(dim)

  Returns the list of strings to represent the system of Katsura. The system originated in a paper by S. Katsura on Spin glass problem by the method of integral equation of the effective field, published in 1990 by World Scientific in the volume New Trends in Magnetism, edited by M. D. Coutinho-Filho and S. M. Resende, pages 110-121. The note by S. Katsura on Users posing problems to PoSSo appeared in 1994 in the second number of the PoSSo Newsletter, edited by L. Gonzalez-Vega and T. Recio.

families.katsura_variable(var, dim)

  Returns the variable U(var, dim) for use in the function katsura.

families.nash(nbplayers, player)

  Returns the string representation of one equation for a player to compute the totally mixed Nash equibria for nbplayers with two pure strategies, with random positive utilities.

families.nbodyeqs(dim, mas)

  The central configurations of the n-body problem can be defined via the Albouy-Chenciner equations, by A. Albouy and A. Chenciner: Le probleme des n corps et les distances mutuelles. Inv. Math. 131, 151-184, 1998; and the paper by M. Hampton and R. Moeckel on Finiteness of relative equilibria of the four-body problem. Inv. Math. 163, 289-312, 2006. Returns a list of strings, representing the central configurations for the n-body problem, where n = dim and with masses in the list mas. We require that len(mas) == dim.

families.noon(dim, parameter=1.1)

  Returns the list of strings to represent the system of Noonburg. The system originates in a paper by V. W. Noonburg on a neural network modeled by an adaptive Lotka-Volterra system, published in 1989 in volume 49 of SIAM Journal on Applied Mathematics, pages 1779-1792. It appeared also in a paper by K. Gatermann entitled Symbolic solution of polynomial equation systems with symmetry, published by ACM in 1990 in the proceedings of ISSAC-90, pages 112-119.

families.pieri_problem(mdim, pdim, real=True)

  Returns a system that expresses the intersection of pdim-planes with mdim*pdim general mdim-planes in (mdim+pdim)-space. When real is True, the generated mdim-planes are osculating a rational normal curve and all solutions are expected to be real. If real is False, then random complex planes are generated. For reality of solutions of polynomial systems, see the book by Frank Sottile: Real Solutions to Equations from Geometry, volume 57 of University Lecture Series, AMS, 2011.

families.poleqs(dim, masses)

  Returns the list of polynomial equations for the central configurations, for as many masses as the dimension dim.

families.recpol(nbplayers, player, ind, acc)

  Recursive generation of one polynomial, called by the function nash below.

families.strvar(name, i, j)

  Returns the string representation for the variable with the given name and indices i and j, i != j. Swaps the values for i and j if i > j.

families.test()

  Writes particular instances of the systems in the families.

## numerical Schubert calculus

The module schubert exports Pieri homotopies and Littlewood-Richardson homotopies to solve Schubert problems.

### functions in the module schubert

PHCpack offers numerical Schubert calculus, exported here.

schubert.cheater(mdim, pdim, qdeg, start, startsols)

  Generates a random Pieri problem of dimensions (mdim, pdim, qdeg) and solves it with a Cheater’s homotopy, starting from the Pieri system in start, at the solutions in startsols.

schubert.dobldobl_littlewood_richardson_homotopies(ndim, kdim, brackets, verbose=True, vrfcnd=False, minrep=True, tosqr=False, outputfilename='')

  In n-dimensional space we consider k-dimensional planes, subject to intersection conditions represented by brackets. The parameters ndim and kdim give values for n and k respectively. The parameter brackets is a list of brackets. A bracket is a list of as many natural numbers (in the range 1..*ndim*) as kdim. The Littlewood-Richardson homotopies compute k-planes that meet the flags at spaces of dimensions prescribed by the brackets, in double double precision. Four options are passed as Booleans:

  verbose: for adding extra output during computations,

  vrfcnd: for extra diagnostic verification of Schubert conditions,

  minrep: for a minimial representation of the problem formulation,

  tosqr: to square the overdetermined systems.

  On return is a 4-tuple. The first item of the tuple is the formal root count, sharp for general flags, then as second item the coordinates of the flags. The coordinates of the flags are stored row wise in a list of real and imaginary parts. The third and fourth item of the tuple on return are respectively the polynomial system that has been solved and its solutions. The length of the list of solution should match the root count.

schubert.littlewood_richardson_homotopies(ndim, kdim, brackets, verbose=True, vrfcnd=False, minrep=True, tosqr=False, precision='d', outputfilename='')

  In n-dimensional space we consider k-dimensional planes, subject to intersection conditions represented by brackets. The parameters ndim and kdim give values for n and k respectively. The parameter brackets is a list of brackets. A bracket is a list of as many natural numbers (in the range 1..*ndim*) as kdim. The Littlewood-Richardson homotopies compute k-planes that meet the flags at spaces of dimensions prescribed by the brackets. Four options are passed as Booleans:

  verbose: for adding extra output during computations,

  vrfcnd: for extra diagnostic verification of Schubert conditions,

  minrep: for a minimial representation of the problem formulation,

  tosqr: to square the overdetermined systems.

  On return is a 4-tuple. The first item of the tuple is the formal root count, sharp for general flags, then as second item the coordinates of the flags. The coordinates of the flags are stored row wise in a list of real and imaginary parts. The third and fourth item of the tuple on return are respectively the polynomial system that has been solved and its solutions. The length of the list of solution should match the root count.

schubert.main()

  Tests the Pieri homotopies and the Littlewood-Richardson homotopies.

schubert.make_pieri_system(mdim, pdim, qdeg, planes, is_real=False)

  Makes the polynomial system defined by the mdim-planes in the list planes.

schubert.osculating_input(mdim, pdim, qdeg, start, startsols)

  Generates real mdim-planes osculating a rational normal curve and solves this Pieri problem using the system in start, with corresponding solutions in startsols.

schubert.pieri_root_count(mdim, pdim, qdeg, verbose=True)

  Computes the number of pdim-plane producing maps of degree qdeg that meet mdim-planes at mdim*pdim + qdeg*(mdim+pdim) points.

schubert.planes_to_string(planes)

  Returns one long string with all numbers in planes, a list of lists of rows. The numbers are the real and imaginary parts, separated by space.

schubert.points_to_string(pts)

  Returns one long string with all numbers in pts, as sequences of real and imaginary parts, every number is separated by one space.

schubert.prompt_for_dimensions()

  Returns the triplet (m,p,q), where m is the dimension of the input planes, p is the dimension of the output planes, and q is the degree of the maps.

schubert.quaddobl_littlewood_richardson_homotopies(ndim, kdim, brackets, verbose=True, vrfcnd=False, minrep=True, tosqr=False, outputfilename='')

  In n-dimensional space we consider k-dimensional planes, subject to intersection conditions represented by brackets. The parameters ndim and kdim give values for n and k respectively. The parameter brackets is a list of brackets. A bracket is a list of as many natural numbers (in the range 1..ndim) as kdim. The Littlewood-Richardson homotopies compute k-planes that meet the flags at spaces of dimensions prescribed by the brackets, in quad double precision. Four options are passed as Booleans:

  verbose: for adding extra output during computations,

  vrfcnd: for extra diagnostic verification of Schubert conditions,

  minrep: for a minimial representation of the problem formulation,

  tosqr: to square the overdetermined systems.

  On return is a 4-tuple. The first item of the tuple is the formal root count, sharp for general flags, then as second item the coordinates of the flags. The coordinates of the flags are stored row wise in a list of real and imaginary parts. The third and fourth item of the tuple on return are respectively the polynomial system that has been solved and its solutions. The length of the list of solution should match the root count.

schubert.random_complex_matrices(nbr, nbrows, nbcols)

  Returns a list of matrix of length nbr, all of dimension nbrows by nbcols.

schubert.random_complex_matrix(nbrows, nbcols)

  Returns a random nbrows-by-nbcols matrix with randomly generated complex coefficients on the unit circle, as a list of rows.

schubert.real_osculating_planes(mdim, pdim, qdeg)

  Returns m*p + qdeg*(m+p) real m-planes osculating a rational normal curves.

schubert.resolve_schubert_conditions(ndim, kdim, brackets, verbose=True)

  In n-dimensional space we consider k-dimensional planes, subject to intersection conditions represented by brackets. The brackets is a list of brackets. A bracket is a list of as many natural numbers (in the range 1..*ndim*) as kdim. On return is the formal root count, which is sharp for general flags. and the coordinates of the flags, stored row wise in a list of real and imaginary parts.

schubert.run_pieri_homotopies(mdim, pdim, qdeg, planes, *pts, **opt)

  Computes the number of pdim-plane producing maps of degree qdeg that meet mdim-planes at mdim*pdim + qdeq*(mdim+pdim) points. For qdeg = 0, there are no interpolation points in pts.

schubert.standard_littlewood_richardson_homotopies(ndim, kdim, brackets, verbose=True, vrfcnd=False, minrep=True, tosqr=False, outputfilename='')

  In n-dimensional space we consider k-dimensional planes, subject to intersection conditions represented by brackets. The parameters ndim and kdim give values for n and k respectively. The parameter brackets is a list of brackets. A bracket is a list of as many natural numbers (in the range 1..*ndim*) as kdim. The Littlewood-Richardson homotopies compute k-planes that meet the flags at spaces of dimensions prescribed by the brackets, in standard double precision. Four options are passed as Booleans:

  verbose: for adding extra output during computations,

  vrfcnd: for extra diagnostic verification of Schubert conditions,

  minrep: for a minimial representation of the problem formulation,

  tosqr: to square the overdetermined systems.

  On return is a 4-tuple. The first item of the tuple is the formal root count, sharp for general flags, then as second item the coordinates of the flags. The coordinates of the flags are stored row wise in a list of real and imaginary parts. The third and fourth item of the tuple on return are respectively the polynomial system that has been solved and its solutions. The length of the list of solution should match the root count.

schubert.test_lrhom(prc='d')

  Performs a test on the Littlewood-Richardson homotopies.

schubert.test_pieri()

  Does a test on the Pieri homotopies.

schubert.verify(pols, sols)

  Verifies whether the solutions in sols satisfy the polynomials of the system in pols.

## Newton polytopes, monomial maps, and power series

The Newton polytope of a polynomial is spanned by the exponents of monomials which occur with nonzero coefficient in the polynomial.

### functions in the module polytopes

Given a polynomial, its support is the set of exponents of monomials which occur with nonzero coefficient. The convex hull of the support of a polynomial is the Newton polytope of the polynomial. For a polynomial system, the mixed volume of the Newton polytopes of the polynomials in the systems gives a generically sharp upper bound on the number of isolated solutions (not in coordinate planes) of the polynomial system.

This module exports routines of PHCpack to work with Newton polytopes.

polytopes.check_mixture(mixture, points)

  The sum of the integers in the list mixture equal the dimension of each point in points. Returns True if the mixture type passes the test, otherwise, prints an error message and returns False.

polytopes.convex_hull(dim, points, checkin=True, checkout=True)

  Returns the list of facets of the convex hull of the points, given in points. The dimension of the ambient space is in dim. If checkin (by default), the type of the input is checked. If checkout (by default), the output is checked.

polytopes.convex_hull_checkin(dim, points)

  Checks whether the input arguments satisfy the requirements: points is a list of tuples that each contain as many integer numbers as the value of dim. Returns True if the requirements are satisfied, returns False otherwise.

polytopes.convex_hull_checkout(dim, points, facets, verbose=True)

  Checks whether for each facet in the list of facets, the facet is supported on the points defined by the computed inner normal and the minimal value. Returns True if the check passes, returns False otherwise.

polytopes.edges_in_facets(facets)

  Given the the list of facets, returns the list of tuples of indices to the point that span the edges of the facets.

polytopes.initial_form(pols, normal)

  Returns the initial form of the polynomials in pols with respect to the inner normal with coordinates in normal.

polytopes.initial_support(points, normal)

  Returns the list of elements in points that make the minimal inner product with the given normal(, as the second element in a tuple. The first element is the value of that minimal inner product. Every tuple in *points must have the same length as normal.

polytopes.integer_mixed_cell(dim, nbr, idx, verbose=True)

  Given are three integers and one boolean, respectively:

  dim: the number of coordinates in the inner normal,

  nbr: the number of distinct supports,

  idx: the index to the cell (starts at one, instead of at zero), and

  verbose: the verbose flag.

  Returns the extracted data for the mixed cell with index idx. If verbose, the data is written to screen.

polytopes.integer_mixed_cells(mixture, points, verbose=True)

  Given a tuple of lifted support sets in points, computes all mixed cells in the regular subdivision defined by the integer lifting values given as the last coordinate of every point in the lifted supports. If verbose, then output is written to screen. Returns the mixed volume as the sum of the volumes of the cells.

polytopes.mixed_volume(mixture, points, checkin=True)

  Returns the mixed volume of the list of lists in points. Both mixture and points have the same length. The list mixture counts the number of times each support in points should be counted. For example, to compute the volume of a three dimensional polytope, the mixture is [3]. In general, the mixture determines the powers of the unknowns in the Minkowski polynomial of which the computed mixed volume is its coefficient. If checkin, then the mixture will be tested to match the length of each point in points. Examples: >>> q1 = [(1, 1), (1, 0), (0, 1), (0, 0)] >>> q2 = [(2, 2), (1, 0), (0, 1)] >>> mv([1, 1], [q1, q2]) 4 >>> mv([2], [q1]) 2

polytopes.planar_convex_hull(points, checkin=True, checkout=True)

  The convex hull of a point configuration in the plane consists of an ordered list of vertex points, ordered such that any two consecutive points span an edge, with the list of corresponding inner normals. If checkin (by default), the type of the input is checked. If checkout (by default), the output is checked.

polytopes.planar_hull_checkout(vertices, normals, verbose=True)

  Given a list of vertices and a list of normals as output of a convex hull algorithm in the plane, this function checks whether the initial support of every normal consists of exactly two points that appear with consecutive indices (modulo the length of the list) in the list of vertices. Return True if the checks pass, False otherwise.

polytopes.random_points(dim, nbr, low, upp)

  Generates a list of random integer points. Returns a list of nbr points of dimension dim, with integer coordinates in the range from low to upp.

polytopes.support(nvr, pol)

  The support of a multivariate polynomial is a set of exponents of the monomials that appear with nonzero coefficient. Given in nvr the number of variables and in pol a string representation of a polynomial in nvr variables, returns the support of the polynomial as a list of tuples.

polytopes.support_sets(pols, **nbvar)

  Returns the support sets of all polynomials in the list pols. The nbvar is the number of variables in the system. if nbvar is omitted, then the system is assumed to be square.

polytopes.test_convex_hull(dim=3, nbr=10, size=9)

  Generates a random point configuration in 3-space by default (although also dim = 4 works) and then computes its convex hull. By default, 10 points are generated, while in general, the number of points in the configurations equals nbr. The range of the coordinates in the point is defined by the value of size, from -size to size.

polytopes.test_integer_mixed_volume()

  Tests mixed volume computation via integer valued lifting functions.

polytopes.test_mixed_volume()

  Runs some simple tests on mixed volume computation.

polytopes.test_planar_hull(nbr=7, size=9)

  Generates a random point configuration in the plane and then computes its convex hull. By default, the number of points equals 7, in general it is the value of the parameter nbr. The range of the coordinates in the point is defined by the value of size, from -size to size.

polytopes.vertices_in_facets(facets)

  Given the list of facets, returns the list of indices to the vertices, to the points that span the facets.

### functions in the module maps

A binomial system is a system where every equation has exactly two monomials with nonzero coefficient. The solution set of a binomial system is a set of monomial maps.

This module allows to work with monomial maps, defined by binomial systems.

maps.is_binomial_system(silent=True)

  Returns True if the system stored in the Laurent systems container is a binomial system, returns False otherwise. if not silent, then the number of terms in each Laurent polynomial is written to screen.

maps.monomial_map_solutions(nbvar, with_degree=True)

  Returns the list of lists of strings, each list of strings representing a monomial map stored in the container. The number of variables equals nbvar.

maps.monomial_map_strings(dim, ind, nbvar)

  Returns the list of strings representing the components of the monomial map of dimension dim, with index ind, and where the number of variables equals nbvar.

maps.solve_binomials(nbvar, pols, silent=True, puretopdim=False)

  If the system given in pols as a list of strings in as many variables as the value of nbvar is a binomial system (that is: it has exactly two monomials with a nonzero coefficient in every equation), then this function will return monomial maps to represent the solution sets. By default, silent is True and no additional output is written. If only the expected pure top dimensional solution sets are of interest, then switch the default puretopdim to True for faster results. The expected top dimension equals the number of variables minus the number of equations.

maps.store_laurent_system(nbvar, pols)

  Given in pols a list of string representing Laurent polynomials into the systems container. The number of variables equals nbvar.

maps.test()

  Solves a binomial system which has the x-axis, the yz-plane, and the twisted cubic as solution components. The yz-plane is a solution set of the unexpected dimension 2.

maps.write_monomial_map(dim, ind, nbvar)

  Write the monomial map of dimension dim and of index ind, with number of variables equal to nbvar.

maps.write_monomial_maps(nbvar)

  Writes the maps stored in the container. The number of variables is given in nbvar.

### functions in the module series

Newton’s method over the field of truncated power series computes series expansions for solution curves.

The module series exports functions to compute power series solutions with Newton’s method in double, double double, or quad double precision.

series.apollonius(precision='d')

  Test on computing the power series at a double solution for the problem of Apolonius. The parameter t is the fourth variable, whence we call Newton’s method with idx equal to four.

series.checkin_newton_power_series(nbsym, lser, idx)

  Given in nbsym the number of symbols in the polynomial system, in lser the list of leading terms in the series and in idx the index of the parameter, returns True if nbsym = len(lser) if idx == 0, or otherwise if nbsym = len(lser) + 1 if idx != 0. An error message is written and False is returned if the above conditions are not satisfied.

series.dobldobl_newton_power_series(pols, lser, idx=1, maxdeg=4, nbr=4, checkin=True, verbose=True)

  Computes series in double double precision for the polynomials in pols, where the leading terms are given in the list lser. On entry are the following five parameters:

  pols: a list of string representations of polynomials,

  lser: a list of polynomials in the series parameter (e.g.: t), for use as start terms in Newton’s method,

  idx: index of the series parameter, by default equals 1,

  maxdeg: maximal degree of the series,

  nbr: number of steps with Newton’s method,

  checkin: checks whether the number of symbols in pols matches the length of the list lser if idx == 0, or is one less than the length of the list lser if idx != 0. If the conditions are not satisfied, then an error message is printed and lser is returned.

  verbose: whether to write intermediate output to screen or not.

  On return is a list of lists of strings. Each lists of strings represents the series solution for the variables in the list pols.

series.dobldobl_newton_series(pols, sols, idx=1, maxdeg=4, nbr=4, verbose=True)

  Computes series in double double precision for the polynomials in pols, where the leading coefficients are the solutions in sols. On entry are the following five parameters:

  pols: a list of string representations of polynomials,

  sols: a list of solutions of the polynomials in pols,

  idx: index of the series parameter, by default equals 1,

  maxdeg: maximal degree of the series,

  nbr: number of steps with Newton’s method,

  verbose: whether to write intermediate output to screen or not.

  On return is a list of lists of strings. Each lists of strings represents the series solution for the variables in the list pols.

series.dobldobl_pade_approximants(pols, sols, idx=1, numdeg=2, dendeg=2, nbr=4, verbose=True)

  Computes Pade approximants based on the series in double double precision for the polynomials in pols, where the leading coefficients of the series are the solutions in sols. On entry are the following seven parameters:

  pols: a list of string representations of polynomials,

  sols: a list of solutions of the polynomials in pols,

  idx: index of the series parameter, by default equals 1,

  numdeg: the degree of the numerator,

  dendeg: the degree of the denominator,

  nbr: number of steps with Newton’s method,

  verbose: whether to write intermediate output to screen or not.

  On return is a list of lists of strings. Each lists of strings represents the series solution for the variables in the list pols.

series.example4pade(prc='d')

  The function f(z) = ((1 + 1/2*z)/(1 + 2*z))^(1/2) is a solution x(s) of (1-s)*(x^2 - 1) + s*(3*x^2 - 3/2) = 0

series.make_fractions(pols)

  Given a list of string representations for the numerator and denominator polynomials in its even and odd numbered indices, returns a list of string representations for the fractions.

series.quaddobl_newton_power_series(pols, lser, idx=1, maxdeg=4, nbr=4, checkin=True, verbose=True)

  Computes series in quad double precision for the polynomials in pols, where the leading terms are given in the list lser. On entry are the following five parameters:

  pols: a list of string representations of polynomials,

  lser: a list of polynomials in the series parameter (e.g.: t), for use as start terms in Newton’s method,

  idx: index of the series parameter, by default equals 1,

  maxdeg: maximal degree of the series,

  nbr: number of steps with Newton’s method,

  checkin: checks whether the number of symbols in pols matches the length of the list lser if idx == 0, or is one less than the length of the list lser if idx != 0. If the conditions are not satisfied, then an error message is printed and lser is returned.

  verbose: whether to write intermediate output to screen or not.

  On return is a list of lists of strings. Each lists of strings represents the series solution for the variables in the list pols.

series.quaddobl_newton_series(pols, sols, idx=1, maxdeg=4, nbr=4, verbose=True)

  Computes series in quad double precision for the polynomials in pols, where the leading coefficients are the solutions in sols. On entry are the following five parameters:

  pols: a list of string representations of polynomials,

  sols: a list of solutions of the polynomials in pols,

  idx: index of the series parameter, by default equals 1,

  maxdeg: maximal degree of the series,

  nbr: number of steps with Newton’s method,

  verbose: whether to write intermediate output to screen or not.

  On return is a list of lists of strings. Each lists of strings represents the series solution for the variables in the list pols.

series.quaddobl_pade_approximants(pols, sols, idx=1, numdeg=2, dendeg=2, nbr=4, verbose=True)

  Computes Pade approximants based on the series in quad double precision for the polynomials in pols, where the leading coefficients of the series are the solutions in sols. On entry are the following seven parameters:

  pols: a list of string representations of polynomials,

  sols: a list of solutions of the polynomials in pols,

  idx: index of the series parameter, by default equals 1,

  numdeg: the degree of the numerator,

  dendeg: the degree of the denominator,

  nbr: number of steps with Newton’s method,

  verbose: whether to write intermediate output to screen or not.

  On return is a list of lists of strings. Each lists of strings represents the series solution for the variables in the list pols.

series.rational_forms(pols)

  Given a list of lists of string representations for the numerators and denominators, returns the proper rational representations for the Pade approximants.

series.replace_symbol(pol, idx)

  In the polynomial pol, replaces the first symbol by the symbol at place idx.

series.standard_newton_power_series(pols, lser, idx=1, maxdeg=4, nbr=4, checkin=True, verbose=True)

  Computes series in standard double precision for the polynomials in pols, where the leading terms are given in the list lser. On entry are the following five parameters:

  pols: a list of string representations of polynomials,

  lser: a list of polynomials in the series parameter (e.g.: t), for use as start terms in Newton’s method,

  idx: index of the series parameter, by default equals 1,

  maxdeg: maximal degree of the series,

  nbr: number of steps with Newton’s method,

  checkin: checks whether the number of symbols in pols matches the length of the list lser if idx == 0, or is one less than the length of the list lser if idx != 0. If the conditions are not satisfied, then an error message is printed and lser is returned.

  verbose: whether to write intermediate output to screen or not.

  On return is a list of lists of strings. Each lists of strings represents the series solution for the variables in the list pols.

series.standard_newton_series(pols, sols, idx=1, maxdeg=4, nbr=4, verbose=True)

  Computes series in standard double precision for the polynomials in pols, where the leading coefficients are the solutions in sols. On entry are the following five parameters:

  pols: a list of string representations of polynomials,

  sols: a list of solutions of the polynomials in pols,

  idx: index of the series parameter, by default equals 1,

  maxdeg: maximal degree of the series,

  nbr: number of steps with Newton’s method,

  verbose: whether to write intermediate output to screen or not.

  On return is a list of lists of strings. Each lists of strings represents the series solution for the variables in the list pols.

series.standard_pade_approximants(pols, sols, idx=1, numdeg=2, dendeg=2, nbr=4, verbose=True)

  Computes Pade approximants based on the series in standard double precision for the polynomials in pols, where the leading coefficients of the series are the solutions in sols. On entry are the following seven parameters:

  pols: a list of string representations of polynomials,

  sols: a list of solutions of the polynomials in pols,

  idx: index of the series parameter, by default equals 1,

  numdeg: the degree of the numerator,

  dendeg: the degree of the denominator,

  nbr: number of steps with Newton’s method,

  verbose: whether to write intermediate output to screen or not.

  On return is a list of lists of strings. Each lists of strings represents the series solution for the variables in the list pols.

series.substitute_symbol(pols, idx)

  Given in pols is a list of polynomials, replaces the first symbol by the symbol at place idx.

series.test(precision='d')

  Tests the application of Newton’s method to compute power series solutions of a polynomial system.

series.viviani(prc='d')

  Returns the system which stores the Viviani curve, with some solutions intersected with a plane, in double (‘d’), double double (‘dd’), or quad double(‘qd’) precision.

series.viviani2(precision='d')

  Computes the power series expansion for the Viviani curve, from a natural paramter perspective. The default precision is double (‘d’). Other precisions are double double (‘dd’) and quad double (‘qd’).

### functions in the module curves

Power series are input to Padé approximants, which provide accurate predictors to approximate algebraic curves.

The module curves exports functions to approximate algebraic space curves with rational expressions, in particular Pade approximants.

curves.dobldobl_closest_pole()

  Returns a tuple with the real and imaginary part of the closest pole used in the predictor in double double precision. The result is only meaningful is the real part is positive. The double coefficients are the high parts of the double doubles.

curves.dobldobl_estimated_distance()

  Returns the current estimated distance to the closest solution computed by the tracker in double double precision.

curves.dobldobl_get_solution(verbose=False)

  Returns the current solution on the path, in double double precision, which starts at the solution set with dobldobl_set_solution(). If verbose, then extra output is written.

curves.dobldobl_hessian_step()

  Returns the current Hessian step in the tracker in double double precision.

curves.dobldobl_next_loop(hom, idx, sols, verbose=False)

  Runs the series-Pade tracker step by step in double double precision. On input is a natural parameter homotopy with solutions. The hom is a list of strings representing the polynomials of the natural parameter homotopy. The idx is the index of the variable in hom which is the continuation parameter. The sols is a list of strings representing start solutions. The start solutions do not contain the value of the continuation parameter, which is assumed to be equal to zero. The function is interactive, prompting the user each time before performing the next predictor-corrector step. If verbose, then extra output is written. On return are the string representations of the solutions computed at the end of the paths.

curves.dobldobl_next_track(target, start, sols, verbose=False, homogeneous=False)

  Runs the series-Pade tracker step by step in double double precision, for an artificial-parameter homotopy. On input are a target system and a start system with solutions. The target is a list of strings representing the polynomials of the target system (which has to be solved). The start is a list of strings representing the polynomials of the start system, with known solutions in sols. The sols is a list of strings representing start solutions. The function is interactive, prompting the user each time before performing the next predictor-corrector step. If verbose, then extra output is written. If homogeneous, then path tracking happens in projective space, otherwise the original affine coordinates are used. On return are the string representations of the solutions computed at the end of the paths.

curves.dobldobl_pade_coefficients(idx)

  Returns a tuple of lists with the coefficients of the Pade approximants computed by the predictor in double double precision. The double coefficients are the high parts of the double doubles. The first list in the tuple holds the coefficients of the numerator, the second list in the tuple holds the denominator coefficients. On entry in idx is the index of a variable.

curves.dobldobl_pade_vector(dim)

  Returns the list of all coefficients over all dim variables, computed by the predictor in double double precision. The double coefficients are the high parts of the double doubles.

curves.dobldobl_pole_radius()

  Returns the smallest pole radius, used in the predictor in double double precision. The double on return is the high part of a double double.

curves.dobldobl_pole_step()

  Returns the current pole step in the tracker in double double precision.

curves.dobldobl_poles(dim)

  Returns a list of lists of all poles of the vector of length dim, computed by the predictor in double double precision. The doubles in the poles are the high parts of the double doubles.

curves.dobldobl_predict_correct(verbose=False)

  Performs one predictor and one corrector step on the set homotopy and the set solution, in double double precision. If verbose, then extra output is written.

curves.dobldobl_series_coefficients(dim)

  Returns a list of lists with the coefficients of the series computed by the predictor in double double precision. The double coefficients are the high parts of the double doubles. On entry in dim is the number of variables.

curves.dobldobl_series_step()

  Returns the current series step in the tracker in double double precision.

curves.dobldobl_set_homotopy(target, start, verbose=False, homogeneous=False)

  Initializes the homotopy with the target and start system for a step-by-step run of the series-Pade tracker, in double double precision. If verbose, then extra output is written. If homogeneous, then path tracking happens in projective space, otherwise the original affine coordinates are used. Returns the failure code of the homotopy initializer.

curves.dobldobl_set_parameter_homotopy(hom, idx, verbose=False)

  Initializes the homotopy with the polynomials in hom for a step-by-step run of the series-Pade tracker, in double double precision. The value idx gives the index of the continuation parameter and is the index of one of the variables in the homotopy hom. If verbose, then extra output is written. Returns the failure code of the homotopy initializer.

curves.dobldobl_set_solution(nvar, sol, verbose=False)

  Sets the start solution in sol for the step-by-step run of the series-Pade tracker, in double double precision. If verbose, then extra output is written. The number of variables is in nvar.

curves.dobldobl_step_size()

  Returns the current step size in the tracker in double double precision.

curves.dobldobl_t_value()

  Returns the current t value in the tracker in double double precision.

curves.dobldobl_track(target, start, sols, filename='', verbose=False, mhom=0, partition=None)

  Wraps the tracker for Pade continuation in double double precision. On input are a target system, a start system with solutions, optionally: a string filename and the verbose flag. The target is a list of strings representing the polynomials of the target system (which has to be solved). The start is a list of strings representing the polynomials of the start system, with known solutions in sols. The sols is a list of strings representing start solutions. By default mhom is zero and tracking happens in the original coordinates, if mhom equals one, then 1-homogeneous coordinates are used, and if mhom is two or higher, then multi-homogenization applies and partition contains the index representation of the partition of the set of variables. This index representation is a list of as many indices as the number of variables, defining which set of the partition each variables belongs to. On return are the string representations of the solutions computed at the end of the paths.

curves.get_corrector_residual_tolerance()

  Returns the current tolerance on the corrector residual. The corrector stops if the residual of the current approximation drops below this tolerance.

curves.get_curvature_beta_factor()

  Returns the current multiplication factor of the curvature bound. This curvature bound gives an upper bound on a safe step size. The step size is set by multiplication of the curvature bound with the beta factor.

curves.get_degree_of_denominator()

  Returns the current value of the degree of the denominator of the Pade approximant, evaluated to predict the next solution on a path.

curves.get_degree_of_numerator()

  Returns the current value of the degree of the numerator of the Pade approximant, evaluated to predict the next solution on a path.

curves.get_gamma_constant()

  Returns the current value of the gamma constant in the homotopy. A random value for gamma will guarantee the absence of singular solutions along a path, as unlucky choices belong to an algebraic set. A tuple of two floats is returned, respectively with the real and imaginary parts of the complex value for the gamma constant.

curves.get_homotopy_continuation_parameter(idx)

  Returns the current value of the homotopy continuation parameter with index idx, where idx is an integer in range(1, 13).

curves.get_maximum_corrector_steps()

  Returns the current value of the maximum number of corrector steps executed after the predictor stage.

curves.get_maximum_step_size()

  Returns the current value of the maximum step size. The step size is the increment to the continuation parameter.

curves.get_maximum_steps_on_path()

  Returns the current value of the maximum number of steps on a path. The path trackers abandons the tracking of a path once the number of steps reaches this maximum number.

curves.get_minimum_step_size()

  Returns the current value of the minimum step size. The path tracking will stop if the step size is larger than the minimum step size and if the predictor residual is larger than the value for alpha, the tolerance on the predictor residual.

curves.get_pole_radius_beta_factor()

  Returns the current multiplication factor of the smallest pole radius. The smallest radius of the poles of the Pade approximant gives an upper bound on a safe step size. The step size is set by multiplication of the smallest pole radius with the beta factor.

curves.get_predictor_residual_alpha()

  Returns the current tolerance on the residual of the predictor. This alpha parameter controls the accuracy of the tracking. As long as the residual of the evaluated predicted solution is larger than alpha, the step size is cut in half.

curves.get_series_beta_factor()

  Returns the current multiplication factor of the step size set by the power series approximation for the algebraic curve.

curves.get_zero_series_coefficient_tolerance()

  Returns the current tolerance on the series coefficient to be zero. A coefficient in a power series will be considered as zero if its absolute value drops below this tolerance.

curves.quaddobl_closest_pole()

  Returns a tuple with the real and imaginary part of the closest pole used in the predictor in quad double precision. The result is only meaningful is the real part is positive. The double coefficients are the highest parts of the quad doubles.

curves.quaddobl_estimated_distance()

  Returns the current estimated distance to the closest solution computed by the tracker in quad double precision.

curves.quaddobl_get_solution(verbose=False)

  Returns the current solution on the path, in quad double precision, which starts at the solution set with quaddobl_set_solution(). If verbose, then extra output is written.

curves.quaddobl_hessian_step()

  Returns the current Hessian step in the tracker in quad double precision.

curves.quaddobl_next_loop(hom, idx, sols, verbose=False)

  Runs the series-Pade tracker step by step in quad double precision. On input is a natural parameter homotopy with solutions. The hom is a list of strings representing the polynomials of the natural parameter homotopy. The idx is the index of the variable in hom which is the continuation parameter. The sols is a list of strings representing start solutions. The start solutions do not contain the value of the continuation parameter, which is assumed to be equal to zero. The function is interactive, prompting the user each time before performing the next predictor-corrector step. If verbose, then extra output is written. On return are the string representations of the solutions computed at the end of the paths.

curves.quaddobl_next_track(target, start, sols, verbose=False, homogeneous=False)

  Runs the series-Pade tracker step by step in quad double precision, for an artificial-parameter homotopy. On input are a target system and a start system with solutions. The target is a list of strings representing the polynomials of the target system (which has to be solved). The start is a list of strings representing the polynomials of the start system, with known solutions in sols. The sols is a list of strings representing start solutions. The function is interactive, prompting the user each time before performing the next predictor-corrector step. If verbose, then extra output is written. If homogeneous, then path tracking happens in projective space, otherwise the original affine coordinates are used. On return are the string representations of the solutions computed at the end of the paths.

curves.quaddobl_pade_coefficients(idx)

  Returns a tuple of lists with the coefficients of the Pade approximants computed by the predictor in quad double precision. The double coefficients are the highest parts of the quad doubles. The first list in the tuple holds the coefficients of the numerator, the second list in the tuple holds the denominator coefficients. On entry in idx is the index of a variable.

curves.quaddobl_pade_vector(dim)

  Returns the list of all coefficients over all dim variables, computed by the predictor in quad double precision. The double coefficients are the highest parts of the quad doubles.

curves.quaddobl_pole_radius()

  Returns the smallest pole radius, used in the predictor in quad double precision. The double on return is the highest part of a quad double.

curves.quaddobl_pole_step()

  Returns the current pole step in the tracker in quad double precision.

curves.quaddobl_poles(dim)

  Returns a list of lists of all poles of the vector of length dim, computed by the predictor in quad double precision. The doubles in the poles are the highest parts of the quad doubles.

curves.quaddobl_predict_correct(verbose=False)

  Performs one predictor and one corrector step on the set homotopy and the set solution, in quad double precision. If verbose, then extra output is written.

curves.quaddobl_series_coefficients(dim)

  Returns a list of lists with the coefficients of the series computed by the predictor in quad double precision. The double coefficients are the highest parts of the quad doubles. On entry in dim is the number of variables.

curves.quaddobl_series_step()

  Returns the current series step in the tracker in quad double precision.

curves.quaddobl_set_homotopy(target, start, verbose=False, homogeneous=False)

  Initializes the homotopy with the target and start system for a step-by-step run of the series-Pade tracker, in quad double precision. If verbose, then extra output is written. If homogeneous, then path tracking happens in projective space, otherwise the original affine coordinates are used. Returns the failure code of the homotopy initializer.

curves.quaddobl_set_parameter_homotopy(hom, idx, verbose=False)

  Initializes the homotopy with the polynomials in hom for a step-by-step run of the series-Pade tracker, in quad double precision. The value idx gives the index of the continuation parameter and is the index of one of the variables in the homotopy hom. If verbose, then extra output is written. Returns the failure code of the homotopy initializer.

curves.quaddobl_set_solution(nvar, sol, verbose=False)

  Sets the start solution in sol for the step-by-step run of the series-Pade tracker, in quad double precision. If verbose, then extra output is written. The number of variables is in nvar.

curves.quaddobl_step_size()

  Returns the current step size in the tracker in quad double precision.

curves.quaddobl_t_value()

  Returns the current t value in the tracker in quad double precision.

curves.quaddobl_track(target, start, sols, filename='', verbose=False, mhom=0, partition=None)

  Wraps the tracker for Pade continuation in quad double precision. On input are a target system, a start system with solutions, optionally: a string filename and the verbose flag. The target is a list of strings representing the polynomials of the target system (which has to be solved). The start is a list of strings representing the polynomials of the start system, with known solutions in sols. The sols is a list of strings representing start solutions. By default mhom is zero and tracking happens in the original coordinates, if mhom equals one, then 1-homogeneous coordinates are used, and if mhom is two or higher, then multi-homogenization applies and partition contains the index representation of the partition of the set of variables. This index representation is a list of as many indices as the number of variables, defining which set of the partition each variables belongs to. On return are the string representations of the solutions computed at the end of the paths.

curves.set_homotopy_continuation_gamma(regamma=0, imgamma=0)

  Sets the value of the homotopy continuation gamma constant to the complex number with real part in regamma and the imaginary part in imgamma. If both regamma and imgamma are zero, then the user is prompted to provide values for regamma and imgamma.

curves.set_homotopy_continuation_parameter(idx, val)

  Sets the value of the homotopy continuation parameter with index idx, where idx is in an integer in range(2, 13), to the value val.

curves.standard_closest_pole()

  Returns a tuple with the real and imaginary part of the closest pole used in the predictor in standard double precision. The result is only meaningful is the real part is positive.

curves.standard_estimated_distance()

  Returns the current estimated distance to the closest solution computed by the tracker in double precision.

curves.standard_get_solution(verbose=False)

  Returns the current solution on the path, in double precision, which starts at the solution set with standard_set_solution(). If verbose, then extra output is written.

curves.standard_hessian_step()

  Returns the current Hessian step in the tracker in double precision.

curves.standard_next_loop(hom, idx, sols, verbose=False)

  Runs the series-Pade tracker step by step in double precision. On input is a natural parameter homotopy with solutions. The hom is a list of strings representing the polynomials of the natural parameter homotopy. The idx is the index of the variable in hom which is the continuation parameter. The sols is a list of strings representing start solutions. The start solutions do not contain the value of the continuation parameter, which is assumed to be equal to zero. The function is interactive, prompting the user each time before performing the next predictor-corrector step. If verbose, then extra output is written. On return are the string representations of the solutions computed at the end of the paths.

curves.standard_next_track(target, start, sols, verbose=False, homogeneous=False)

  Runs the series-Pade tracker step by step in double precision, for an artificial-parameter homotopy. On input are a target system and a start system with solutions. The target is a list of strings representing the polynomials of the target system (which has to be solved). The start is a list of strings representing the polynomials of the start system, with known solutions in sols. The sols is a list of strings representing start solutions. The function is interactive, prompting the user each time before performing the next predictor-corrector step. If verbose, then extra output is written. If homogeneous, then path tracking happens in projective space, otherwise the original affine coordinates are used. On return are the string representations of the solutions computed at the end of the paths.

curves.standard_pade_coefficients(idx)

  Returns a tuple of lists with the coefficients of the Pade approximants computed by the predictor in standard double precision. The first list in the tuple holds the coefficients of the numerator, the second list in the tuple holds the denominator coefficients. On entry in idx is the index of a variable.

curves.standard_pade_vector(dim)

  Returns the list of all coefficients over all dim variables, computed by the predictor in standard double precision.

curves.standard_pole_radius()

  Returns the smallest pole radius, used in the predictor in standard double precision.

curves.standard_pole_step()

  Returns the current pole step in the tracker in double precision.

curves.standard_poles(dim)

  Returns a list of lists of all poles of the vector of length dim, computed by the predictor in standard double precision.

curves.standard_predict_correct(verbose=False)

  Performs one predictor and one corrector step on the set homotopy and the set solution, in standard double precision. If verbose, then extra output is written.

curves.standard_series_coefficients(dim)

  Returns a list of lists with the coefficients of the series computed by the predictor in standard double precision. On entry in dim is the number of variables.

curves.standard_series_step()

  Returns the current series step in the tracker in double precision.

curves.standard_set_homotopy(target, start, verbose=False, homogeneous=False)

  Initializes the homotopy with the target and start system for a step-by-step run of the series-Pade tracker, in double precision. If verbose, then extra output is written. If homogeneous, then path tracking happens in projective space, otherwise the original affine coordinates are used. Returns the failure code of the homotopy initializer.

curves.standard_set_parameter_homotopy(hom, idx, verbose=False)

  Initializes the homotopy with the polynomials in hom for a step-by-step run of the series-Pade tracker, in double precision. The value idx gives the index of the continuation parameter and is the index of one of the variables in the homotopy hom. If verbose, then extra output is written. Returns the failure code of the homotopy initializer.

curves.standard_set_solution(nvar, sol, verbose=False)

  Sets the start solution in sol for the step-by-step run of the series-Pade tracker, in standard double precision. If verbose, then extra output is written. The number of variables is in nvar.

curves.standard_step_size()

  Returns the current step size in the tracker in double precision.

curves.standard_t_value()

  Returns the current t value in the tracker in double precision.

curves.standard_track(target, start, sols, filename='', verbose=False, mhom=0, partition=None)

  Wraps the tracker for Pade continuation in standard double precision. On input are a target system, a start system with solutions, optionally: a string filename and the verbose flag. The target is a list of strings representing the polynomials of the target system (which has to be solved). The start is a list of strings representing the polynomials of the start system, with known solutions in sols. The sols is a list of strings representing start solutions. By default mhom is zero and tracking happens in the original coordinates, if mhom equals one, then 1-homogeneous coordinates are used, and if mhom is two or higher, then multi-homogenization applies and partition contains the index representation of the partition of the set of variables. This index representation is a list of as many indices as the number of variables, defining which set of the partition each variables belongs to. On return are the string representations of the solutions computed at the end of the paths.

curves.symbolic_pade_approximant(cff)

  Given in cff are the coefficients of numerator and denominator of a Pade approximant, given as a tuple of two lists. On return is the string representation of the Pade approximant, using ‘t’ as the variable.

curves.symbolic_pade_vector(cff)

  Given in cff are the coefficients of numerator and denominator of a Pade vector, given as a list of tuples of two lists each. On return is the string representation of the Pade approximant, using ‘t’ as the variable.

curves.test_hyperbola(precision='d')

  Tests the step-by-step Pade tracker on a hyperbola, by default in double precision (when precision equals ‘d’). Other supported precisions are double double (‘dd’) and quad double (‘qd’).

curves.test_next_track(precision='d')

  Tunes the parameters and runs the step-by-step tracker. The precision is either double (‘d’), double double (‘dd’), or quad double (‘qd’).

curves.test_simple_track(precision='d')

  Tunes the parameters and runs a simple test on the trackers. The precision is either double (‘d’), double double (‘dd’), or quad double (‘qd’).

curves.test_twohom(precision='d')

  Test on a 2-homogeneous homotopy.

curves.tune_homotopy_continuation_parameters()

  The interactive loop prompts the user to tune the parameters.

curves.write_homotopy_continuation_parameters()

  Writes the values of the homotopy continuation parameters.

## a graphical user interface

With Tkinter we can develop a graphical user interface. The module exports some possible development for a GUI to solve polynomial systems and to process solutions.

### functions in the module dashboard

This module prototypes a graphical user interface to phcpy.

class dashboard.CoordinatePlot(wdw, dim, sols, idx)

  Shows the distribution of one coordinate of a list of solutions in the complex plane.

  plot()

    Plots a coordinate of the list of solutions.

class dashboard.Scroller(wdw, sols)

  Scrolls through a solution list.

  next()

    Increases the cursor by one if possible.

  previous()

    Decreases the cursor by one if possible.

  show()

    Shows the solution at position self.cursor in the message widget and updates the entry widget.

class dashboard.SolveButton(wdw, pols=[])

  Simple input/output text widget and button graphical user interface to a solver.

  solve()

    Takes the data from the input text widget, places the data into a list of polynomials, calls the blackbox solver and displays the solutions in the output text widget.

dashboard.launchsolver(pols=[])

  Instantiates a Tk object and launches the event loop.

dashboard.plotcoordinate(sols, idx)

  Instantiates CoordinatePlot with a Tk object and launches the main event loop.

dashboard.pols2str(pols)

  Returns the input string to put into the text input widget for the string representations of polynomials in pols.

dashboard.scrollsols(sols)

  Instantiates the window and launches the GUI to scroll through the solutions in the lis sols.

dashboard.str2pols(strp)

  Returns the list of string representations of the polynomials in the string strp.

dashboard.testcoordinateplot()

  Solves the cyclic 5-roots problem, prompts the user for an index of a coordinate, and launches the plotcoordinate function.

dashboard.testscroller()

  Solves the cyclic 5-roots problems and launches the scroller.

dashboard.testsolvebutton()

  Solves the cyclic 5-roots problem and launches the solve button.

dashboard.windowsize(sols, idx)

  Returns the minimal and maximal value of the real and imaginary parts of the coordinate with index idx of the list of solutions in sols, as a tuple of 4 values: (realmin, realmax, imagmin, imagmax).

## the module phcpy.phcpy2c3

Almost all computations in phcpy are done with compiled code, provided in one object.

### functions in the module interface

Polynomial systems and solutions are passed through as strings. The coefficients of the polynomials and coordinates of the solutions are evaluated in standard double, double double, quad double precision, or arbitrary multiprecision.

This module provides the data interface to PHCpack. The user gives as input string representations of polynomials or solutions to the interface functions which store the data.

interface.load_dobldobl_laurent_system()

  Returns the Laurent polynomials stored in the system container with double double complex coefficients.

interface.load_dobldobl_solutions()

  Returns the list of solutions stored in the container for complex double double solutions.

interface.load_dobldobl_system()

  Returns the polynomials stored in the system container with double double complex coefficients.

interface.load_multprec_laurent_system()

  Returns the Laurent polynomials stored in the system container with multiprecision complex coefficients.

interface.load_multprec_solutions()

  Returns the list of solutions stored in the container for complex multiprecision solutions.

interface.load_multprec_system()

  Returns the polynomials stored in the system container with arbitrary multiprecision complex coefficients.

interface.load_quaddobl_laurent_system()

  Returns the Laurent polynomials stored in the system container with quad double complex coefficients.

interface.load_quaddobl_solutions()

  Returns the list of solutions stored in the container for complex quad double solutions.

interface.load_quaddobl_system()

  Returns the polynomials stored in the system container with quad double complex coefficients.

interface.load_standard_laurent_system()

  Returns the Laurent polynomials stored in the system container for standard double precision arithmetic.

interface.load_standard_solutions()

  Returns the list of solutions stored in the container for solutions with standard double precision.

interface.load_standard_system()

  Returns the polynomials stored in the system container for standard double precision arithmetic.

interface.load_standard_tableau(verbose=False)

  Returns the tableau form of the system stored in the container for double precision coefficients.

interface.read_dobldobl_solutions(filename)

  Returns the list of solutions stored on file with the given file name. The solutions are parsed in double double precision.

interface.read_dobldobl_system(filename)

  Opens the filename for reading a polynomial system with coefficients in double double precision. Returns the list of polynomials in the system or None if something went wrong.

interface.read_dobldobl_system_and_solutions(filename)

  Opens the filename for reading a polynomial system with coefficients in double double precision, and its corresponding list of solutions. Returns None if the reading went wrong, or otherwise returns a tuple with first the list of polynomials and second the list of solutions.

interface.read_quaddobl_solutions(filename)

  Returns the list of solutions stored on file with the given file name. The solutions are parsed in quad double precision.

interface.read_quaddobl_system(filename)

  Opens the filename for reading a polynomial system with coefficients in quad double precision. Returns the list of polynomials in the system or None if something went wrong.

interface.read_quaddobl_system_and_solutions(filename)

  Opens the filename for reading a polynomial system with coefficients in quad double precision, and its corresponding list of solutions. Returns None if the reading went wrong, or otherwise returns a tuple with first the list of polynomials and second the list of solutions.

interface.read_standard_solutions(filename)

  Returns the list of solutions stored on file with the given file name. The solutions are parsed in standard double precision.

interface.read_standard_system(filename)

  Opens the filename for reading a polynomial system with coefficients in standard double precision. Returns the list of polynomials in the system or None if something went wrong.

interface.read_standard_system_and_solutions(filename)

  Opens the filename for reading a polynomial system with coefficients in standard double precision, and its corresponding list of solutions. Returns None if the reading went wrong, or otherwise returns a tuple with first the list of polynomials and second the list of solutions.

interface.store_dobldobl_laurent_system(polsys, **nbvar)

  Stores the Laurent polynomials represented by the list of strings in polsys into the container for systems with coefficients in double double precision. If nbvar is omitted, then the system is assumed to be square. Otherwise, suppose the number of variables equals 2 and pols is the list of polynomials, then store_dobldobl_laurent_system(pols, nbvar=2) stores the polynomials in pols in the dobldobl Laurent systems container.

interface.store_dobldobl_laurent_witness_set(nbvar, dim, pols, sols)

  Given in nbar is the total number of variables in the list of Laurent polynomials in pols and its list of solutions in sols. The coefficients in the Laurent polynomials and the coordinates of the solutions will be parsed and stored in double double precision. The parameter dim equals the number of slack variables used in the embedding of pols and sols. This dim also equals the dimension of the solution set represented by the witness set given by the lists pols and sols. The symbols for the slack variables are swapped to the end of the symbol table in both the Laurent polynomials and the solutions.

interface.store_dobldobl_solutions(nvar, sols)

  Stores the solutions in the list sols, represented as strings in PHCpack format into the solution container for processing with complex double double arithmetic. The number nvar equals the number of variables.

interface.store_dobldobl_system(polsys, **nbvar)

  Stores the polynomials represented by the list of strings in polsys into the systems container for double double arithmetic. The number of variables is an optional argument given in nbvar. If nbvar is omitted, then the system is assumed to be square. Otherwise, suppose the number of variables equals 2 and pols is the list of polynomials, then the call store_dobldobl_system(pols, nbvar=2) will store the polynomials in pols in the dobldobl systems container.

interface.store_dobldobl_witness_set(nbvar, dim, pols, sols)

  Given in nbar is the total number of variables in the list of polynomials in pols and its list of solutions in sols. The coefficients in the polynomials and the coordinates of the solutions will be parsed and stored in double double precision. The parameter dim equals the number of slack variables used in the embedding of pols and sols. This dim also equals the dimension of the solution set represented by the witness set given by the lists pols and sols. The symbols for the slack variables are swapped to the end of the symbol table in both the polynomials and the solutions.

interface.store_multprec_laurent_system(polsys, decimals, **nbvar)

  Stores the Laurent polynomials represented by the list of strings in polsys into the container for systems with coefficients in multiprecision. The parameter decimals equals the number of decimal places in the working precision for the parsing of the strings in polsys. If nbvar is omitted, then the system is assumed to be square. Otherwise, suppose the number of variables equals 2 and pols is the list of polynomials, then store_multprec_laurent_system(pols, nbvar=2) stores the polynomials in pols in the multprec Laurent systems container.

interface.store_multprec_solutions(nvar, sols)

  Stores the solutions in the list sols, represented as strings in PHCpack format into the solution container for processing with complex multiprecision arithmetic. The number nvar equals the number of variables.

interface.store_multprec_system(polsys, decimals, **nbvar)

  Stores the polynomials represented by the list of strings in polsys into the systems container for multiprecision arithmetic. The parameter decimals equals the number of decimal places in the working precision for the parsing of the strings in polsys. The number of variables is an optional argument given in nbvar. If nbvar is omitted, then the system is assumed to be square. Otherwise, suppose the number of variables equals 2 and pols is the list of polynomials, then the call store_multprec_system(pols, nbvar=2) will store the polynomials in pols in the multiprecision systems container.

interface.store_quaddobl_laurent_system(polsys, **nbvar)

  Stores the Laurent polynomials represented by the list of strings in polsys into the container for systems with coefficients in quad double precision. If nbvar is omitted, then the system is assumed to be square. Otherwise, suppose the number of variables equals 2 and pols is the list of polynomials, then store_quaddobl_laurent_system(pols, nbvar=2) stores the polynomials in pols in the quaddobl Laurent systems container.

interface.store_quaddobl_laurent_witness_set(nbvar, dim, pols, sols)

  Given in nbar is the total number of variables in the list of Laurent polynomials in pols and its list of solutions in sols. The coefficients in the Laurent polynomials and the coordinates of the solutions will be parsed and stored in quad double precision. The parameter dim equals the number of slack variables used in the embedding of pols and sols. This dim also equals the dimension of the solution set represented by the witness set given by the lists pols and sols. The symbols for the slack variables are swapped to the end of the symbol table in both the Laurent polynomials and the solutions.

interface.store_quaddobl_solutions(nvar, sols)

  Stores the solutions in the list sols, represented as strings in PHCpack format into the solution container for processing with complex quad double arithmetic. The number nvar equals the number of variables.

interface.store_quaddobl_system(polsys, **nbvar)

  Stores the polynomials represented by the list of strings in polsys into the systems container for quad double arithmetic. The number of variables is an optional argument given in nbvar. If nbvar is omitted, then the system is assumed to be square. Otherwise, suppose the number of variables equals 2 and pols is the list of polynomials, then the call store_quaddobl_system(pols, nbvar=2) will store the polynomials in pols in the quaddobl systems container.

interface.store_quaddobl_witness_set(nbvar, dim, pols, sols)

  Given in nbar is the total number of variables in the list of polynomials in pols and its list of solutions in sols. The coefficients in the polynomials and the coordinates of the solutions will be parsed and stored in quad double precision. The parameter dim equals the number of slack variables used in the embedding of pols and sols. This dim also equals the dimension of the solution set represented by the witness set given by the lists pols and sols. The symbols for the slack variables are swapped to the end of the symbol table in both the polynomials and the solutions.

interface.store_standard_laurent_system(polsys, **nbvar)

  Stores the Laurent polynomials represented by the list of strings in polsys into the container for systems with coefficients in standard double precision. If nbvar is omitted, then the system is assumed to be square. Otherwise, suppose the number of variables equals 2 and pols is the list of polynomials, then store_standard_laurent_system(pols, nbvar=2) stores the polynomials in pols in the standard Laurent systems container.

interface.store_standard_laurent_witness_set(nbvar, dim, pols, sols)

  Given in nbar is the total number of variables in the list of Laurent polynomials in pols and its list of solutions in sols. The coefficients in the Laurent polynomials and the coordinates of the solutions will be parsed and stored in standard double precision. The parameter dim equals the number of slack variables used in the embedding of pols and sols. This dim also equals the dimension of the solution set represented by the witness set given by the lists pols and sols. The symbols for the slack variables are swapped to the end of the symbol table in both the Laurent polynomials and the solutions.

interface.store_standard_solutions(nvar, sols)

  Stores the solutions in the list sols, represented as strings in PHCpack format into the container for solutions with standard double precision. The number nvar equals the number of variables.

interface.store_standard_system(polsys, **nbvar)

  Stores the polynomials represented by the list of strings in polsys into the container for systems with coefficients in standard double precision. The number of variables is an optional argument given in nbvar. If nbvar is omitted, then the system is assumed to be square. Otherwise, suppose the number of variables equals 2 and pols is the list of polynomials, then the call store_standard_system(pols, nbvar=2) will store the polynomials in pols in the standard systems container.

interface.store_standard_tableau(poltab, verbose=False)

  Stores the polynomial system given in the list of lists poltab in the container for systems with coefficients in standard double precision. Every polynomial in the system is represented by a list of tuples. A monomial is represented by a 2-tuple:

  1. the coefficient of the monomial is a complex number,

  2. the exponent are a tuple of natural numbers.

  For example, the system x^2 - y = 0, x^3 - z = 0 is represented as [[((1+0j), (2, 0, 0)), ((-1+0j), (0, 1, 0))], [((1+0j), (3, 0, 0)), ((-1+0j), (0, 0, 1))]].

interface.store_standard_witness_set(nbvar, dim, pols, sols)

  Given in nbar is the total number of variables in the list of polynomials in pols and its list of solutions in sols. The coefficients in the polynomials and the coordinates of the solutions will be parsed and stored in standard double precision. The parameter dim equals the number of slack variables used in the embedding of pols and sols. This dim also equals the dimension of the solution set represented by the witness set given by the lists pols and sols. The symbols for the slack variables are swapped to the end of the symbol table in both the polynomials and the solutions.

interface.test(prc='d', laurent=False)

  Tests the storing of a witness set for the twisted cubic. The embedding induces the order x, y, zz1, z on the variables. After storing the witness set, the order is x, y, z, zz1, in both the system and solutions. The default precision prc is double ‘d’. Other supported precisions are double double ‘dd’ and quad double ‘qd’.

interface.test_tableau()

  Tests on storing and loading of a tableau.

### functions in the module phcpy2c3

The module `phcpy2c3` wraps the C functions in the C interface to PHCpack. The C interface to PHCpack was developed in the application of message passing (MPI) to run the path trackers on distributed memory multiprocessing computers. All functions documented below have their counterpart in C that are therefore then also directly accessible from C programs.

phcpy2c3.py2c_PHCpack_version_string()

  Returns the version string of PHCpack. The version string is 40 characters long.

phcpy2c3.py2c_ade_manypaths_d()

  Tracks many solution paths with algorithmic differentation in double precision on the data in the systems and solutions container. The start and target systems must have been defined and the standard solutions container holds valid solutions. On entry is the verbose flag, which equals zero if no output is wanted, or 1 if extra information should be written to screen. On return is the failure code, which equals zero if all went well.

phcpy2c3.py2c_ade_manypaths_d_pars()

  Tracks many solution paths with algorithmic differentation in double precision on the data in the systems and solutions container. The start and target systems must have been defined and the standard solutions container holds valid solutions. On entry is the verbose flag, which equals zero if no output is wanted, or 1 if extra information should be written to screen. Other input parameters are the real and imaginary parts of the gamma constant. Then, the 14 values of the path parameters has to be provided. On return is the failure code, which equals zero if all went well.

phcpy2c3.py2c_ade_newton_d()

  Runs Newton’s method with algorithmic differentation in double precision on the data in the systems and solutions container. The standard systems container must contain a valid polynomial system and the standard solutions container must hold a valid solution. On entry is the verbose flag, which equals zero if no output is wanted, or 1 if extra information should be written to screen. On return is the failure code, which equals zero if all went well.

phcpy2c3.py2c_ade_onepath_d()

  Tracks one solution path with algorithmic differentation in double precision on the data in the systems and solutions container. The start and target systems must have been defined and the standard solutions container must holds valid solution. On entry is the verbose flag, which equals zero if no output is wanted, or 1 if extra information should be written to screen. On return is the failure code, which equals zero if all went well.

phcpy2c3.py2c_autotune_continuation_parameters()

  Tunes the values of the continuation parameters. On input are two integers: 1) the difficulty level of the solution paths; and 2) the number of decimal places in the precision.

phcpy2c3.py2c_celcon_append_lifted_point()

  Appends a lifted point to the cells container. There are three input parameters: 1) the dimension of the point; 2) the index of the support to where to append to; and 3) the string representation of the lifted point. Returns the failure code, which equals zero when all went well.

phcpy2c3.py2c_celcon_clear_container()

  Deallocates the data in the cell container.

phcpy2c3.py2c_celcon_copy_into_dobldobl_systems_container()

  The random coefficient system in double double precision is copied from the cell container to the container for systems with coefficients in double double precision.

phcpy2c3.py2c_celcon_copy_into_quaddobl_systems_container()

  The random coefficient system in quad double precision is copied from the cell container to the container for systems with coefficients in quad double precision.

phcpy2c3.py2c_celcon_copy_into_standard_systems_container()

  The random coefficient system in standard double precision is copied from the cell container to the container for systems with coefficients in standard double precision.

phcpy2c3.py2c_celcon_copy_target_dobldobl_solution_to_container()

  Copies the i-th target solution corresponding to the k-th mixed cell to the container for solutions in double double precision. There are two input parameters for this function: 1) k, the index to the mixed cell; 2) i, the index to the i-th solution path defined by the cell. On return is the failure code, which equals zero when all went well.

phcpy2c3.py2c_celcon_copy_target_quaddobl_solution_to_container()

  Copies the i-th target solution corresponding to the k-th mixed cell to the container for solutions in quad double precision. There are two input parameters for this function: 1) k, the index to the mixed cell; 2) i, the index to the i-th solution path defined by the cell. On return is the failure code, which equals zero when all went well.

phcpy2c3.py2c_celcon_copy_target_standard_solution_to_container()

  Copies the i-th target solution corresponding to the k-th mixed cell to the container for solutions in standard double precision. There are two input parameters for this function: 1) k, the index to the mixed cell; 2) i, the index to the i-th solution path defined by the cell. On return is the failure code, which equals zero when all went well.

phcpy2c3.py2c_celcon_dobldobl_polyhedral_homotopy()

  Based on the lifting and the random coefficient system, the polyhedral homotopy to solve the random coefficient system in double double precision is constructed. This function also initializes the internal data structures to store the solutions of start and target systems. The lifted supports and the random coefficient system are defined. On return is the failure code, which equals zero if all went well.

phcpy2c3.py2c_celcon_dobldobl_random_coefficient_system()

  Based on the lifted supports stored in the container, a random coefficient system with coefficients in double double precision is stored in the cell container.

phcpy2c3.py2c_celcon_initialize_supports()

  Initializes the cell container with the number of distinct supports, this number is given as the one input parameter. On return is the failure code, which equals zero if all went well.

phcpy2c3.py2c_celcon_is_stable()

  returns 1 if stable mixed cells were stored, 0 otherwise

phcpy2c3.py2c_celcon_mixed_volume_of_supports()

  Returns the mixed volume of the supports stored in the cell container.

phcpy2c3.py2c_celcon_number_of_cells()

  returns the number of cells in the cell container

phcpy2c3.py2c_celcon_number_of_original_cells()

  returns the number of original cells in the cell container

phcpy2c3.py2c_celcon_number_of_stable_cells()

  returns the number of stable cells in the cell container

phcpy2c3.py2c_celcon_permute_dobldobl_system()

  Permutes the systems in the container for polynomial and Laurent systems with double double coefficients corresponding to the permutation used to compute the mixed-cell configuration. On return is the failure code, which equals zero if all went well.

phcpy2c3.py2c_celcon_permute_quaddobl_system()

  Permutes the systems in the container for polynomial and Laurent systems with quad double coefficients corresponding to the permutation used to compute the mixed-cell configuration. On return is the failure code, which equals zero if all went well.

phcpy2c3.py2c_celcon_permute_standard_system()

  Permutes the systems in the container for polynomial and Laurent systems with standard double coefficients corresponding to the permutation used to compute the mixed-cell configuration. On return is the failure code, which equals zero if all went well.

phcpy2c3.py2c_celcon_quaddobl_polyhedral_homotopy()

  Based on the lifting and the random coefficient system, the polyhedral homotopy to solve the random coefficient system in quad double precision is constructed. This function also initializes the internal data structures to store the solutions of start and target systems. The lifted supports and the random coefficient system are defined. On return is the failure code, which equals zero if all went well.

phcpy2c3.py2c_celcon_quaddobl_random_coefficient_system()

  Based on the lifted supports stored in the container, a random coefficient system with coefficients in quad double precision is stored in the cell container.

phcpy2c3.py2c_celcon_retrieve_lifted_point()

  Returns a string representation of a lifted point. On input are three integer numbers: 1) the number of coordinates in the lifted point; 2) the index to the support set; and 3) the index to the point in that support set.

phcpy2c3.py2c_celcon_set_type_of_mixture()

  Defines the type of mixture of the support sets. On input are two parameters, an integer and a string: 1) the integer equals the number of distinct supports; 2) the string is a string representation of a Python list of integers, there are as many integers as the value of the first parameter. Each integer is a positive number, equal to the number of occurrences of each support set.

phcpy2c3.py2c_celcon_solve_dobldobl_start_system()

  Solves the start system corresponding to the k-th mixed cell, using double double precision arithmetic. The precondition for this function is that the creation of the polyhedral homotopy in double double precision ended well. On return is the number of solution found, which must equal the mixed volume of the k-th mixed cell.

phcpy2c3.py2c_celcon_solve_quaddobl_start_system()

  Solves the start system corresponding to the k-th mixed cell, using quad double precision arithmetic. The precondition for this function is that the creation of the polyhedral homotopy in quad double precision ended well. On return is the number of solution found, which must equal the mixed volume of the k-th mixed cell.

phcpy2c3.py2c_celcon_solve_stable_dobldobl_start_system()

  Solves the start system corresponding to the k-th stable mixed cell, using double double precision arithmetic. The precondition for this function is that the creation of the polyhedral homotopy in double double precision ended well. On return is the number of solution found, which must equal the mixed volume of the k-th stable mixed cell.

phcpy2c3.py2c_celcon_solve_stable_quaddobl_start_system()

  Solves the start system corresponding to the k-th stable mixed cell, using quad double precision arithmetic. The precondition for this function is that the creation of the polyhedral homotopy in quad double precision ended well. On return is the number of solution found, which must equal the mixed volume of the k-th stable mixed cell.

phcpy2c3.py2c_celcon_solve_stable_standard_start_system()

  Solves the start system corresponding to the k-th stable mixed cell, using standard double precision arithmetic. The precondition for this function is that the creation of the polyhedral homotopy in standard double precision ended well. On return is the number of solution found, which must equal the mixed volume of the k-th stable mixed cell.

phcpy2c3.py2c_celcon_solve_standard_start_system()

  Solves the start system corresponding to the k-th mixed cell, using standard double precision arithmetic. The precondition for this function is that the creation of the polyhedral homotopy in standard double precision ended well. On return is the number of solution found, which must equal the mixed volume of the k-th mixed cell.

phcpy2c3.py2c_celcon_standard_polyhedral_homotopy()

  Based on the lifting and the random coefficient system, the polyhedral homotopy to solve the random coefficient system in standard double precision is constructed. This function also initializes the internal data structures to store the solutions of start and target systems. The lifted supports and the random coefficient system are defined. On return is the failure code, which equals zero if all went well.

phcpy2c3.py2c_celcon_standard_random_coefficient_system()

  Based on the lifted supports stored in the container, a random coefficient system with coefficients in standard double precision is stored in the cell container.

phcpy2c3.py2c_celcon_track_dobldobl_solution_path()

  Tracks a solution path starting at the i-th solution of the k-th cell, using double double precision arithmetic. The precondition for this function is that the start system defined by the k-th mixed cell is solved in double double precision. There are three input parameters: 1) k, the index to a mixed cell in the cell container; 2) i, the index to a solution path defined by that mixed cell; 3) otp, the level for intermediate output during path tracking. A target solution corresponding to the k-th cell is added on return.

phcpy2c3.py2c_celcon_track_quaddobl_solution_path()

  Tracks a solution path starting at the i-th solution of the k-th cell, using quad double precision arithmetic. The precondition for this function is that the start system defined by the k-th mixed cell is solved in quad double precision. There are three input parameters: 1) k, the index to a mixed cell in the cell container; 2) i, the index to a solution path defined by that mixed cell; 3) otp, the level for intermediate output during path tracking. A target solution corresponding to the k-th cell is added on return.

phcpy2c3.py2c_celcon_track_standard_solution_path()

  Tracks a solution path starting at the i-th solution of the k-th cell, using standard double precision arithmetic. The precondition for this function is that the start system defined by the k-th mixed cell is solved in standard double precision. There are three input parameters: 1) k, the index to a mixed cell in the cell container; 2) i, the index to a solution path defined by that mixed cell; 3) otp, the level for intermediate output during path tracking. A target solution corresponding to the k-th cell is added on return.

phcpy2c3.py2c_celcon_type_of_mixture()

  Returns the string representation of the type of mixture of the support sets. This string is the string representation of a Python list of integers.

phcpy2c3.py2c_clear_dobldobl_Laurent_data()

  Deallocates data used to solve Laurent systems by homotopy continuation in double double precision.

phcpy2c3.py2c_clear_dobldobl_homotopy()

  Deallocation of the homotopy stored in double double precision. On return is the failure code, which equals zero if all is well.

phcpy2c3.py2c_clear_dobldobl_operations_data()

  Deallocates the data used by solve_by_dobldobl_homotopy_continuation.

phcpy2c3.py2c_clear_dobldobl_tracker()

  Deallocates data used in the double double precision tracker with a generator.

phcpy2c3.py2c_clear_dobldobl_witsols()

  Clears the witness solutions in double double precision.

phcpy2c3.py2c_clear_multprec_homotopy()

  Deallocation of the homotopy stored in arbitrary multiprecision. On return is the failure code, which equals zero if all is well.

phcpy2c3.py2c_clear_multprec_tracker()

  Deallocates data used in the arbitrary multiprecision tracker with a generator.

phcpy2c3.py2c_clear_quaddobl_Laurent_data()

  Deallocates data used to solve Laurent systems by homotopy continuation in quad double precision.

phcpy2c3.py2c_clear_quaddobl_homotopy()

  Deallocation of the homotopy stored in quad double precision. On return is the failure code, which equals zero if all is well.

phcpy2c3.py2c_clear_quaddobl_operations_data()

  Deallocates the data used by solve_by_quaddobl_homotopy_continuation.

phcpy2c3.py2c_clear_quaddobl_tracker()

  Deallocates data used in the quad double precision tracker with a generator.

phcpy2c3.py2c_clear_quaddobl_witsols()

  Clears the witness solutions in quad double precision.

phcpy2c3.py2c_clear_standard_Laurent_data()

  Deallocates data used to solve Laurent systems by homotopy continuation in standard double precision.

phcpy2c3.py2c_clear_standard_homotopy()

  Deallocation of the homotopy stored in standard double precision. On return is the failure code, which equals zero if all is well.

phcpy2c3.py2c_clear_standard_operations_data()

  Deallocates the data used by solve_by_standard_homotopy_continuation.

phcpy2c3.py2c_clear_standard_tracker()

  Deallocates data used in the standard double precision tracker with a generator.

phcpy2c3.py2c_clear_standard_witsols()

  Clears the witness solutions in standard double precision.

phcpy2c3.py2c_clear_varbprec_tracker()

  Deallocates data used in the variable precision tracker with a generator.

phcpy2c3.py2c_copy_dobldobl_Laurent_container_to_start_system()

  Copies the Laurent system in double double precision from the container to the start system.

phcpy2c3.py2c_copy_dobldobl_Laurent_container_to_target_system()

  Copies the Laurent system in double double precision from the container to the target system.

phcpy2c3.py2c_copy_dobldobl_Laurent_start_system_to_container()

  Copies the start Laurent system in double double precision to the systems container for Laurent systems.

phcpy2c3.py2c_copy_dobldobl_Laurent_target_system_to_container()

  Copies the target Laurent system in double double precision to the systems container for Laurent systems.

phcpy2c3.py2c_copy_dobldobl_container_to_start_solutions()

  Copies the solutions in double double precision from the container to the start solutions in double double precision.

phcpy2c3.py2c_copy_dobldobl_container_to_start_system()

  Copies the system in the container for systems with coefficients in double double precision to the start system.

phcpy2c3.py2c_copy_dobldobl_container_to_target_solutions()

  Copies the solutions in double double precision from the container to the target solutions in double double precision.

phcpy2c3.py2c_copy_dobldobl_container_to_target_system()

  Copies the system in the container for systems with coefficients in double double precision to the target system.

phcpy2c3.py2c_copy_dobldobl_laursys_witset()

  There is one integer parameter dim on input, which represents the dimension of the witness set. Copies the witness set representation for a solution set of dimension dim into the Laurent systems and solutions container, in double double precision. REQUIRED : 1) py2c_dobldobl_laursys_solve was executed successfully, and 2) dim is in the range 0..topdim.

phcpy2c3.py2c_copy_dobldobl_polysys_witset()

  There is one integer parameter dim on input, which represents the dimension of the witness set. Copies the witness set representation for a solution set of dimension dim into the systems and solutions container, in double double precision. REQUIRED : 1) py2c_dobldobl_polysys_solve was executed successfully, and 2) dim is in the range 0..topdim.

phcpy2c3.py2c_copy_dobldobl_start_solutions_to_container()

  Copies the start solutions in double double precision to the container for solutions in double double precision.

phcpy2c3.py2c_copy_dobldobl_start_system_to_container()

  Copies the start system to the container for systems with coefficients in double double precision.

phcpy2c3.py2c_copy_dobldobl_target_solutions_to_container()

  Copies the target solutions in double double precision to the container for solutions in double double precision.

phcpy2c3.py2c_copy_dobldobl_target_system_to_container()

  Copies the target system to the container for systems with coefficients in double double precision.

phcpy2c3.py2c_copy_multprec_container_to_start_solutions()

  Copies the solutions in arbitrary multiprecision from the container to the start solutions in arbitrary multiprecision.

phcpy2c3.py2c_copy_multprec_container_to_start_system()

  Copies the system in the container for systems with coefficients in arbitrary multiprecision to the start system.

phcpy2c3.py2c_copy_multprec_container_to_target_solutions()

  Copies the solutions in arbitrary multiprecision from the container to the target solutions in arbitrary multiprecision.

phcpy2c3.py2c_copy_multprec_container_to_target_system()

  Copies the system in the container for systems with coefficients in arbitrary multiprecision to the target system.

phcpy2c3.py2c_copy_multprec_start_solutions_to_container()

  Copies the start solutions in arbitrary multiprecision to the container for solutions in arbitrary multiprecision.

phcpy2c3.py2c_copy_multprec_start_system_to_container()

  Copies the start system to the container for systems with coefficients in arbitrary multiprecision.

phcpy2c3.py2c_copy_multprec_target_solutions_to_container()

  Copies the target solutions in arbitrary multiprecision to the container for solutions in arbitrary multiprecision.

phcpy2c3.py2c_copy_multprec_target_system_to_container()

  copies multiprecision target system to container

phcpy2c3.py2c_copy_quaddobl_Laurent_container_to_start_system()

  Copies the Laurent system in quad double precision from the container to the start system.

phcpy2c3.py2c_copy_quaddobl_Laurent_container_to_target_system()

  Copies the Laurent system in quad double precision from the container to the target system.

phcpy2c3.py2c_copy_quaddobl_Laurent_start_system_to_container()

  Copies the start Laurent system in quad double precision to the systems container for Laurent systems.

phcpy2c3.py2c_copy_quaddobl_Laurent_target_system_to_container()

  Copies the target Laurent system in quad double precision to the systems container for Laurent systems.

phcpy2c3.py2c_copy_quaddobl_container_to_start_solutions()

  Copies the solutions in quad double precision from the container to the start solutions in quad double precision.

phcpy2c3.py2c_copy_quaddobl_container_to_start_system()

  Copies the system in the container for systems with coefficients in quad double precision to the start system.

phcpy2c3.py2c_copy_quaddobl_container_to_target_solutions()

  Copies the solutions in quad double precision from the container to the target solutions in quad double precision.

phcpy2c3.py2c_copy_quaddobl_container_to_target_system()

  Copies the system in the container for systems with coefficients in quad double precision to the target system.

phcpy2c3.py2c_copy_quaddobl_laursys_witset()

  There is one integer parameter dim on input, which represents the dimension of the witness set. Copies the witness set representation for a solution set of dimension dim into the Laurent systems and solutions container, in quad double precision. REQUIRED : 1) py2c_quaddobl_laursys_solve was executed successfully, and 2) dim is in the range 0..topdim.

phcpy2c3.py2c_copy_quaddobl_polysys_witset()

  There is one integer parameter dim on input, which represents the dimension of the witness set. Copies the witness set representation for a solution set of dimension dim into the systems and solutions container, in quad double precision. REQUIRED : 1) py2c_quaddobl_polysys_solve was executed successfully, and 2) dim is in the range 0..topdim.

phcpy2c3.py2c_copy_quaddobl_start_solutions_to_container()

  Copies the start solutions in quad double precision to the container for solutions in quad double precision.

phcpy2c3.py2c_copy_quaddobl_start_system_to_container()

  Copies the start system to the container for systems with coefficients in quad double precision.

phcpy2c3.py2c_copy_quaddobl_target_solutions_to_container()

  Copies the target solutions in quad double precision to the container for solutions in quad double precision.

phcpy2c3.py2c_copy_quaddobl_target_system_to_container()

  Copies the target system to the container for systems with coefficients in quad double precision.

phcpy2c3.py2c_copy_standard_Laurent_container_to_start_system()

  Copies the Laurent system in standard double precision from the container to the start system.

phcpy2c3.py2c_copy_standard_Laurent_container_to_target_system()

  Copies the Laurent system in standard double precision from the container to the target system.

phcpy2c3.py2c_copy_standard_Laurent_start_system_to_container()

  Copies the start Laurent system in standard double precision to the systems container for Laurent systems.

phcpy2c3.py2c_copy_standard_Laurent_target_system_to_container()

  Copies the target Laurent system in standard double precision to the systems container for Laurent systems.

phcpy2c3.py2c_copy_standard_container_to_start_solutions()

  Copies the solutions in standard double precision from the container to the start solutions in standard double precision.

phcpy2c3.py2c_copy_standard_container_to_start_system()

  Copies the system in the container for systems with coefficients in standard double precision to the start system.

phcpy2c3.py2c_copy_standard_container_to_target_solutions()

  Copies the solutions in standard double precision from the container to the target solutions in standard double precision.

phcpy2c3.py2c_copy_standard_container_to_target_system()

  Copies the system in the container for systems with coefficients in standard double precision to the target system.

phcpy2c3.py2c_copy_standard_laursys_witset()

  There is one integer parameter dim on input, which represents the dimension of the witness set. Copies the witness set representation for a solution set of dimension dim into the Laurent systems and solutions container, in standard double precision. REQUIRED : 1) py2c_standard_laursys_solve was executed successfully, and 2) dim is in the range 0..topdim.

phcpy2c3.py2c_copy_standard_polysys_witset()

  There is one integer parameter dim on input, which represents the dimension of the witness set. Copies the witness set representation for a solution set of dimension dim into the systems and solutions container, in standard double precision. REQUIRED : 1) py2c_standard_polysys_solve was executed successfully, and 2) dim is in the range 0..topdim.

phcpy2c3.py2c_copy_standard_target_solutions_to_container()

  Copies the target solutions in standard double precision to the container for solutions in standard double precision.

phcpy2c3.py2c_copy_standard_target_system_to_container()

  Copies the target system to the container for systems with coefficients in standard double precision.

phcpy2c3.py2c_copy_start_solutions_to_container()

  Copies the start solutions in standard double precision to the container for solutions in standard double precision.

phcpy2c3.py2c_copy_start_system_to_container()

  Copies the start system to the container for systems with coefficients in standard double precision.

phcpy2c3.py2c_corecount()

  Returns the number of cores available for multithreading.

phcpy2c3.py2c_create_dobldobl_homotopy()

  Initializes the data for a homotopy in double double precision. The failure code is returned, which is zero when all goes well.

phcpy2c3.py2c_create_dobldobl_homotopy_with_gamma()

  Initializes the data for a homotopy in double double precision. On input are two doubles and one positive integer: (1) the real and imaginary part of the gamma constant; (2) the power of t in the homotopy. The failure code is returned, which is zero when all goes well.

phcpy2c3.py2c_create_multprec_homotopy()

  Initializes the data for a homotopy in arbitrary multiprecision. The failure code is returned, which is zero when all goes well.

phcpy2c3.py2c_create_multprec_homotopy_with_gamma()

  Initializes the data for a homotopy in arbitrary multiprecision. On input are two doubles and one positive integer: (1) the real and imaginary part of the gamma constant; (2) the power of t in the homotopy. The failure code is returned, which is zero when all goes well.

phcpy2c3.py2c_create_quaddobl_homotopy()

  Initializes the data for a homotopy in quad double precision. The failure code is returned, which is zero when all goes well.

phcpy2c3.py2c_create_quaddobl_homotopy_with_gamma()

  Initializes the data for a homotopy in quad double precision. On input are two doubles and one positive integer: (1) the real and imaginary part of the gamma constant; (2) the power of t in the homotopy. The failure code is returned, which is zero when all goes well.

phcpy2c3.py2c_create_standard_homotopy()

  Initializes the data for a homotopy in standard double precision. The failure code is returned, which is zero when all goes well.

phcpy2c3.py2c_create_standard_homotopy_with_gamma()

  Initializes the data for a homotopy in standard double precision. On input are two doubles and one positive integer: (1) the real and imaginary part of the gamma constant; (2) the power of t in the homotopy. The failure code is returned, which is zero when all goes well.

phcpy2c3.py2c_define_output_file()

  Prompts the user to define the output file. On return is the failure code, which is zero if all went well.

phcpy2c3.py2c_determine_output_during_continuation()

  Interactive procedure to determine the level of output during the path tracking.

phcpy2c3.py2c_diagonal_symbols_doubler()

  Doubles the number of symbols in the symbol table to enable the writing of the target system to string properly when starting the cascade of a diagonal homotopy in extrinsic coordinates. On input are three integers, n, d, nc, and one string s. On input are n, the ambient dimension = #variables before the embedding, d is the number of slack variables, or the dimension of the first set, and in s (nc characters) are the symbols for the first witness set. This function takes the symbols in s and combines those symbols with those in the current symbol table for the second witness set stored in the standard systems container. On return, the symbol table contains then all symbols to write the top system in the cascade to start the diagonal homotopy.

phcpy2c3.py2c_dobldobl_Laurent_cascade_homotopy()

  Creates a homotopy in double double precision using the stored Laurent systems to go one level down the cascade, removing one slice. On return is the failure code, which equals zero if all went well.

phcpy2c3.py2c_dobldobl_Newton_Laurent_step()

  Applies one Newton step in double double precision to the Laurent system in the standard Laurent systems container and to the solutions in the container. On return is the failure code, which equals zero if all went well.

phcpy2c3.py2c_dobldobl_Newton_power_series()

  Given in the systems container a polynomial system with coefficients in standard double precision, and in the dobldobl systems pool the leading terms of the power series, this function runs Newton’s method to compute power series solutions of the system in the container, in double double precision. There are four integers on input: 1) the index of the series parameter; 2) the maximal degree of the series; 3) the number of Newton steps to be done on each solution; 4) a 0/1-flag to indicate whether additional diagnostic output needs to be written to screen. On return is the failure code, which equals zero if all went well.

phcpy2c3.py2c_dobldobl_Newton_series()

  Given in the systems container a polynomial system with coefficients in standard double precision, and in the solutions container the leading coefficients of the power series, this function runs Newton’s method to compute power series solutions of the system in the container, in double double precision. There are four integers on input: 1) the index of the series parameter; 2) the maximal degree of the series; 3) the number of Newton steps to be done on each solution; 4) a 0/1-flag to indicate whether additional diagnostic output needs to be written to screen. On return is the failure code, which equals zero if all went well.

phcpy2c3.py2c_dobldobl_Newton_step()

  Applies one Newton step in double double precision to the system in the standard systems container and to the solutions in the container. On return is the failure code, which equals zero if all went well.

phcpy2c3.py2c_dobldobl_Pade_approximant()

  Given in the systems container a polynomial system with coefficients in double double precision, and in the solutions container the leading coefficients of the power series, this function runs Newton’s method to compute power series solutions of the system in the container, in double double precision, followed by the construction of the Pade approximants, for each solution. There are five integers on input: 1) the index of the series parameter; 2) the degree of the numerator of the Pade approximant; 3) the degree of the denominator of the Pade approximant; 4) the number of Newton steps to be done on each solution; 5) a 0/1-flag to indicate whether additional diagnostic output needs to be written to screen. The Pade approximants are stored in the dobldobl systems pool, numerators in the odd indexed entries and denominators in the entries with even index in each system. On return is the failure code, which equals zero if all went well.

phcpy2c3.py2c_dobldobl_cascade_homotopy()

  Creates a homotopy in double double precision using the stored systems to go one level down the cascade, removing one slice. On return is the failure code, which equals zero if all went well.

phcpy2c3.py2c_dobldobl_collapse_diagonal()

  Eliminates the extrinsic diagonal for the system and solutions in the containers for double doubles. On input are two integers: 1) k, the current number of slack variables in the embedding; 2) d, the number of slack variables to add to the final embedding. The system in the container has its diagonal eliminated and is embedded with k+d slack variables. The solutions corresponding to this system are in the solutions container. On return is the failure code, which equals zero if all went well.

phcpy2c3.py2c_dobldobl_crude_tracker()

  A crude tracker appends the end point of a path directly to the solutions container, without refinement or postprocessing. Tracking happens in double double precision. On entry is the verbose parameter which is 1 or 0. If 1, then the solution vectors are written to screen, otherwise the crude tracker stays mute. On return is the failure code, which is zero when all went well. The requirement is that the target system, start system, and start solutions in double double precision have been initialized in the containers.

phcpy2c3.py2c_dobldobl_deflate()

  Applies deflation in double double precision to the system and the solutions stored in the containers. There are five input parameters, two integers and three doubles: (1) maxitr : the maximum number of iterations per root, (2) maxdef : the maximum number of deflations per root, (3) tolerr : tolerance on the forward error on each root, (4) tolres : tolerance on the backward error on each root, (5) tolres : tolerance on the numerical rank of the Jacobian matrices. On return is the failure code, which equals zero if all went well.

phcpy2c3.py2c_dobldobl_diagonal_cascade_solutions()

  Makes the start solutions to start the cascade homotopy to intersect two solution sets of dimensions a and b, where a >= b, in double double precision. The dimensions a and b are given as input parameters. The systems stored as target and start system in the container define the witness sets for these two solution sets. On return is the failure code, which equals zero when all went well.

phcpy2c3.py2c_dobldobl_diagonal_homotopy()

  Creates a diagonal homotopy to intersect two solution sets of dimensions a and b respectively, where a >= b. The two input parameters are values for a and b. The systems stored as target and start system in the container, in double double precision, define the witness sets for these two solution sets.

phcpy2c3.py2c_dobldobl_laursys_solve()

  Runs the cascades of homotopies on the Laurent polynomial system in the dobldobl systems container. Runs in double double precision. On input are five integers : 1) nbtasks equals the number of tasks for multitasking, 2) topdim is the top dimension to start the homotopy cascades, 3) filter is a 0 or 1 flag to filter the witness supersets, 4) factor is a 0 or 1 flag to factor the witness sets, 5) verbose is a flag for intermediate output.

phcpy2c3.py2c_dobldobl_multiplicity_structure()

  Computes the multiplicity structure in double double precision. Required is the presence of a polynomial system in the dobldobl systems container and a solution in the dobldobl solutions container. The input parameters are two integers and one double: order : the maximum differentiation order, verbose : 1 for verbose, 0 for silent, and tol : tolerance on the numerical rank. On return is a tuple: the multiplicity and the values of the Hilbert function.

phcpy2c3.py2c_dobldobl_polysys_solve()

  Runs the cascades of homotopies on the polynomial system in the dobldobl systems container. Runs in double double precision. On input are five integers : 1) nbtasks equals the number of tasks for multitasking, 2) topdim is the top dimension to start the homotopy cascades, 3) filter is a 0 or 1 flag to filter the witness supersets, 4) factor is a 0 or 1 flag to factor the witness sets, 5) verbose is a flag for intermediate output.

phcpy2c3.py2c_dobldobl_witset_of_Laurent_hypersurface()

  Given in the string p of nc characters a polynomial in nv variables, terminated by a semicolon, the systems and solutions container in double double precision on return contain a witness set for the hypersurface defined by the Laurent polynomial in p. On entry are two integers and one string, in the following order: 1) nv, the number of variables of the polynomials; 2) nc, the number of characters in the string p; 3) p, string representation of a Laurent polynomial in several variables, terminates with a semicolon. On return is the failure code, which equals zero if all went well.

phcpy2c3.py2c_dobldobl_witset_of_hypersurface()

  Given in the string p of nc characters a polynomial in nv variables, terminated by a semicolon, the systems and solutions container in double double precision on return contain a witness set for the hypersurface defined by the ordinary polynomial in p. On entry are two integers and one string, in the following order: 1) nv, the number of variables of the polynomials; 2) nc, the number of characters in the string p; 3) p, string representation of an ordinary polynomial in several variables, terminates with a semicolon. On return is the failure code, which equals zero if all went well.

phcpy2c3.py2c_embed_dobldobl_Laurent_system()

  Replaces the Laurent system with coefficients in double double precision in the container with its embedding of dimension d. The dimension d is given as an integer parameter on input. On return is the failure code, which equals zero if all went well.

phcpy2c3.py2c_embed_dobldobl_system()

  Replaces the system with coefficients in double double precision in the container with its embedding of dimension d. The dimension d is given as an integer parameter on input. On return is the failure code, which equals zero if all went well.

phcpy2c3.py2c_embed_quaddobl_Laurent_system()

  Replaces the Laurent system with coefficients in quad double precision in the container with its embedding of dimension d. The dimension d is given as an integer parameter on input. On return is the failure code, which equals zero if all went well.

phcpy2c3.py2c_embed_quaddobl_system()

  Replaces the system with coefficients in quad double precision in the container with its embedding of dimension d. The dimension d is given as an integer parameter on input. On return is the failure code, which equals zero if all went well.

phcpy2c3.py2c_embed_standard_Laurent_system()

  Replaces the Laurent system with coefficients in standard double precision in the container with its embedding of dimension d. The dimension d is given as an integer parameter on input. On return is the failure code, which equals zero if all went well.

phcpy2c3.py2c_embed_standard_system()

  Replaces the system with coefficients in standard double precision in the container with its embedding of dimension d. The dimension d is given as an integer parameter on input. On return is the failure code, which equals zero if all went well.

phcpy2c3.py2c_embed_system()

  Replaces the system in the container with its embedding of dimension d. The dimension d is given as the first integer parameter on input. The second integer parameter indicates the precision, either 0, 1, or 2, respectively for double, double double, or quad double precision. On return is the failure code, which equals zero if all went well.

phcpy2c3.py2c_extrinsic_top_diagonal_dimension()

  Returns the dimension of the start and target system to start the extrinsic cascade to intersect two witness sets, respectively of dimensions a and b, with ambient dimensions respectively equal to n1 and n2. There are four integers as parameters on input: n1, n2, a and b.

phcpy2c3.py2c_factor_define_output_file_with_string()

  Defines the output file for the factorization. On input are an integer and a string: 1) the integer equals the number of characters in the string; and 2) the string contains the name of a file. On return is the failure code, which equals zero if all went well.

phcpy2c3.py2c_factor_dobldobl_assign_labels()

  Assigns labels, replacing the multiplicity field of each solution in double double precision stored in the container. On entry are two integers: 1) n, the number of coordinates of the solutions; 2) nbsols, the number of solutions in the container. On return is the failure code, which equals zero if all went well.

phcpy2c3.py2c_factor_dobldobl_trace_grid_diagnostics()

  Returns a tuple of two doubles with the diagnostics on the trace grid computed in double double precision. The first double is the largest error of the samples. The second double is the smallest distance between two samples.

phcpy2c3.py2c_factor_dobldobl_trace_sum_difference()

  Returns the difference between the actual sum at the samples defined by the labels to the generic points in the factor, and the trace sum, computed in double double precision. On entry are three integer numbers and one string: 1) d, the number of points in the witness set; 2) k, the dimension of the solution set; 3) nc, the number of characters in the string; 4) ws, the string representing the labels of the witness set.

phcpy2c3.py2c_factor_dobldobl_track_paths()

  Tracks as many paths as defined by witness set, in double double precision. On input is an integer, which must be 1 if the witness set is defined by a Laurent polynomial system. On return is the failure code, which is zero when all went well.

phcpy2c3.py2c_factor_initialize_dobldobl_Laurent_sampler()

  Initializes the sampling machine with a witness set, defined by a Laurent polynomial system in double double precision. The embedded system is taken from the Laurent systems container and the generic points from the solutions container. On entry is the dimension or the number of hyperplanes to slide the positive dimensional solution set.

phcpy2c3.py2c_factor_initialize_dobldobl_monodromy()

  Initializes the internal data structures for n loops, to factor a k-dimensional solution component of degree d, in double double precision. There are three integers on input, in the following order: 1) n, the number of loops; 2) d, the degree of the solution set; 3) k, the dimensional of the solution set. On return is the failure code, which equals zero when all went well.

phcpy2c3.py2c_factor_initialize_dobldobl_sampler()

  Initializes the sampling machine with a witness set, defined by an ordinary polynomial system in double double precision. The embedded system is taken from the polynomial systems container and the generic points from the solutions container. On entry is the dimension or the number of hyperplanes to slide the positive dimensional solution set.

phcpy2c3.py2c_factor_initialize_quaddobl_Laurent_sampler()

  Initializes the sampling machine with a witness set, defined by a Laurent polynomial system in quad double precision. The embedded system is taken from the Laurent systems container and the generic points from the solutions container. On entry is the dimension or the number of hyperplanes to slide the positive dimensional solution set.

phcpy2c3.py2c_factor_initialize_quaddobl_monodromy()

  Initializes the internal data structures for n loops, to factor a k-dimensional solution component of degree d, in quad double precision. There are three integers on input, in the following order: 1) n, the number of loops; 2) d, the degree of the solution set; 3) k, the dimensional of the solution set. On return is the failure code, which equals zero when all went well.

phcpy2c3.py2c_factor_initialize_quaddobl_sampler()

  Initializes the sampling machine with a witness set, defined by an ordinary polynomial system in quad double precision. The embedded system is taken from the polynomial systems container and the generic points from the solutions container. On entry is the dimension or the number of hyperplanes to slide the positive dimensional solution set.

phcpy2c3.py2c_factor_initialize_standard_Laurent_sampler()

  Initializes the sampling machine with a witness set, defined by a Laurent polynomial system in standard double precision. The embedded system is taken from the Laurent systems container and the generic points from the solutions container. On entry is the dimension or the number of hyperplanes to slide the positive dimensional solution set.

phcpy2c3.py2c_factor_initialize_standard_monodromy()

  Initializes the internal data structures for n loops, to factor a k-dimensional solution component of degree d, in standard double precision. There are three integers on input, in the following order: 1) n, the number of loops; 2) d, the degree of the solution set; 3) k, the dimensional of the solution set. On return is the failure code, which equals zero when all went well.

phcpy2c3.py2c_factor_initialize_standard_sampler()

  Initializes the sampling machine with a witness set, defined by an ordinary polynomial system in standard double precision. The embedded system is taken from the polynomial systems container and the generic points from the solutions container. On entry is the dimension or the number of hyperplanes to slide the positive dimensional solution set.

phcpy2c3.py2c_factor_new_dobldobl_slices()

  Generates k random slides in n-space, in double double precision. The k and the n are the two input parameters. On return is the failure code, which is zero when all went well.

phcpy2c3.py2c_factor_new_quaddobl_slices()

  Generates k random slides in n-space, in quad double precision. The k and the n are the two input parameters. On return is the failure code, which is zero when all went well.

phcpy2c3.py2c_factor_new_standard_slices()

  Generates k random slides in n-space, in standard double precision. The k and the n are the two input parameters. On return is the failure code, which is zero when all went well.

phcpy2c3.py2c_factor_number_of_dobldobl_components()

  Returns the number of irreducible factors in the current double double precision decomposition of the witness set.

phcpy2c3.py2c_factor_number_of_quaddobl_components()

  Returns the number of irreducible factors in the current quad double precision decomposition of the witness set.

phcpy2c3.py2c_factor_number_of_standard_components()

  Returns the number of irreducible factors in the current standard double precision decomposition of the witness set.

phcpy2c3.py2c_factor_permutation_after_dobldobl_loop()

  For a set of degree d, computes the permutation using the solutions most recently stored, after a loop in double double precision. The number d is the input parameter of this function. On return is the string representation of the permutation.

phcpy2c3.py2c_factor_permutation_after_quaddobl_loop()

  For a set of degree d, computes the permutation using the solutions most recently stored, after a loop in quad double precision. The number d is the input parameter of this function. On return is the string representation of the permutation.

phcpy2c3.py2c_factor_permutation_after_standard_loop()

  For a set of degree d, computes the permutation using the solutions most recently stored, after a loop in standard double precision. The number d is the input parameter of this function. On return is the string representation of the permutation.

phcpy2c3.py2c_factor_quaddobl_assign_labels()

  Assigns labels, replacing the multiplicity field of each solution in quad double precision stored in the container. On entry are two integers: 1) n, the number of coordinates of the solutions; 2) nbsols, the number of solutions in the container. On return is the failure code, which equals zero if all went well.

phcpy2c3.py2c_factor_quaddobl_trace_grid_diagnostics()

  Returns a tuple of two doubles with the diagnostics on the trace grid computed in quad double precision. The first double is the largest error of the samples. The second double is the smallest distance between two samples.

phcpy2c3.py2c_factor_quaddobl_trace_sum_difference()

  Returns the difference between the actual sum at the samples defined by the labels to the generic points in the factor, and the trace sum, computed in quad double precision. On entry are three integer numbers and one string: 1) d, the number of points in the witness set; 2) k, the dimension of the solution set; 3) nc, the number of characters in the string; 4) ws, the string representing the labels of the witness set.

phcpy2c3.py2c_factor_quaddobl_track_paths()

  Tracks as many paths as defined by witness set, in quad double precision. On input is an integer, which must be 1 if the witness set is defined by a Laurent polynomial system. On return is the failure code, which is zero when all went well.

phcpy2c3.py2c_factor_restore_dobldobl_solutions()

  Restores the first initialized solutions, in double double precision, from sampler to the container.

phcpy2c3.py2c_factor_restore_quaddobl_solutions()

  Restores the first initialized solutions, in quad double precision, from sampler to the container.

phcpy2c3.py2c_factor_restore_standard_solutions()

  Restores the first initialized solutions, in standard double precision, from sampler to the container.

phcpy2c3.py2c_factor_set_dobldobl_to_mute()

  Sets the state of monodromy permutations in double double precision to silent.

phcpy2c3.py2c_factor_set_dobldobl_to_verbose()

  Sets the state of monodromy permutations in double double precision to verbose.

phcpy2c3.py2c_factor_set_dobldobl_trace_slice()

  Assigns the constant coefficient of the first slice, in double double precision. On entry is a flag to indicate if it was the first time or not. On return is the failure code, which is zero if all went well.

phcpy2c3.py2c_factor_set_quaddobl_to_mute()

  Sets the state of monodromy permutations in quad double precision to silent.

phcpy2c3.py2c_factor_set_quaddobl_to_verbose()

  Sets the state of monodromy permutations in quad double precision to verbose.

phcpy2c3.py2c_factor_set_quaddobl_trace_slice()

  Assigns the constant coefficient of the first slice, in quad double precision. On entry is a flag to indicate if it was the first time or not. On return is the failure code, which is zero if all went well.

phcpy2c3.py2c_factor_set_standard_to_mute()

  Sets the state of monodromy permutations in standard double precision to silent.

phcpy2c3.py2c_factor_set_standard_to_verbose()

  Sets the state of monodromy permutations in standard double precision to verbose.

phcpy2c3.py2c_factor_set_standard_trace_slice()

  Assigns the constant coefficient of the first slice, in standard double precision. On entry is a flag to indicate if it was the first time or not. On return is the failure code, which is zero if all went well.

phcpy2c3.py2c_factor_standard_assign_labels()

  Assigns labels, replacing the multiplicity field of each solution in standard double precision stored in the container. On entry are two integers: 1) n, the number of coordinates of the solutions; 2) nbsols, the number of solutions in the container. On return is the failure code, which equals zero if all went well.

phcpy2c3.py2c_factor_standard_trace_grid_diagnostics()

  Returns a tuple of two doubles with the diagnostics on the trace grid computed in standard double precision. The first double is the largest error of the samples. The second double is the smallest distance between two samples.

phcpy2c3.py2c_factor_standard_trace_sum_difference()

  Returns the difference between the actual sum at the samples defined by the labels to the generic points in the factor, and the trace sum, computed in standard double precision. On entry are three integer numbers and one string: 1) d, the number of points in the witness set; 2) k, the dimension of the solution set; 3) nc, the number of characters in the string; 4) ws, the string representing the labels of the witness set.

phcpy2c3.py2c_factor_standard_track_paths()

  Tracks as many paths as defined by witness set, in standard double precision. On input is an integer, which must be 1 if the witness set is defined by a Laurent polynomial system. On return is the failure code, which is zero when all went well.

phcpy2c3.py2c_factor_store_dobldobl_gammas()

  Stores the gamma constants in double double precision for the sampler in the monodromy loops. Generates as many random complex constants as the value on input. On return is the failure code, which is zero if all went well.

phcpy2c3.py2c_factor_store_dobldobl_solutions()

  Stores the solutions in the container, in double double precision, to the data for monodromy loops.

phcpy2c3.py2c_factor_store_quaddobl_gammas()

  Stores the gamma constants in quad double precision for the sampler in the monodromy loops. Generates as many random complex constants as the value on input. On return is the failure code, which is zero if all went well.

phcpy2c3.py2c_factor_store_quaddobl_solutions()

  Stores the solutions in the container, in quad double precision, to the data for monodromy loops.

phcpy2c3.py2c_factor_store_standard_gammas()

  Stores the gamma constants in standard double precision for the sampler in the monodromy loops. Generates as many random complex constants as the value on input. On return is the failure code, which is zero if all went well.

phcpy2c3.py2c_factor_store_standard_solutions()

  Stores the solutions in the container, in standard double precision, to the data for monodromy loops.

phcpy2c3.py2c_factor_swap_dobldobl_slices()

  Swaps the current slices with new slices and takes new solutions as start to turn back, in double double precision. On return is the failure code, which is zero when all went well.

phcpy2c3.py2c_factor_swap_quaddobl_slices()

  Swaps the current slices with new slices and takes new solutions as start to turn back, in quad double precision. On return is the failure code, which is zero when all went well.

phcpy2c3.py2c_factor_swap_standard_slices()

  Swaps the current slices with new slices and takes new solutions as start to turn back, in standard double precision. On return is the failure code, which is zero when all went well.

phcpy2c3.py2c_factor_update_dobldobl_decomposition()

  Updates the decomposition with the given permutation of d elements, computed in double double precision. On entry are two integers and one string: 1) d, the number of elements in the permutation; 2) nc, the number of characters in the string; 3) p, the string representation of the permutation. Returns one if the current decomposition is certified, otherwise returns zero.

phcpy2c3.py2c_factor_update_quaddobl_decomposition()

  Updates the decomposition with the given permutation of d elements, computed in quad double precision. On entry are two integers and one string: 1) d, the number of elements in the permutation; 2) nc, the number of characters in the string; 3) p, the string representation of the permutation. Returns one if the current decomposition is certified, otherwise returns zero.

phcpy2c3.py2c_factor_update_standard_decomposition()

  Updates the decomposition with the given permutation of d elements, computed in standard double precision. On entry are two integers and one string: 1) d, the number of elements in the permutation; 2) nc, the number of characters in the string; 3) p, the string representation of the permutation. Returns one if the current decomposition is certified, otherwise returns zero.

phcpy2c3.py2c_factor_witness_points_of_dobldobl_component()

  Returns a string which represents an irreducible component, computed in double double precision. On entry are two integers: 1) the sum of the degrees of all components; 2) the index of the component.

phcpy2c3.py2c_factor_witness_points_of_quaddobl_component()

  Returns a string which represents an irreducible component, computed in quad double precision. On entry are two integers: 1) the sum of the degrees of all components; 2) the index of the component.

phcpy2c3.py2c_factor_witness_points_of_standard_component()

  Returns a string which represents an irreducible component, computed in standard double precision. On entry are two integers: 1) the sum of the degrees of all components; 2) the index of the component.

phcpy2c3.py2c_get_default_path_parameters()

  Given the working precision (16, 32, or 64), returns the default values of the path parameters, for the path trackers with algorithmic differentiation.

phcpy2c3.py2c_get_gamma_constant()

  Returns the gamma constant used by the solve functions. Two integer parameters are expected on input: (1) for the precision, 1, 2, or 4, respectively for double, double double, or quad double precision; and (2) the verbose level. The function returns a tuple of two doubles, for the real and imaginary part of the gamma constant.

phcpy2c3.py2c_get_seed()

  Returns the current value of the seed. Using this value in py2c_set_seed will ensure that the results of previous runs can be reproduced.

phcpy2c3.py2c_get_value_of_continuation_parameter()

  Returns the value of a continuation parameter. On input is the index of this continuation parameter, an integer ranging from 1 to 34. On return is a double with the value of the corresponding parameter.

phcpy2c3.py2c_giftwrap_clear_3d_facets()

  Deallocates list of facets of convex hull stored in 3-space.

phcpy2c3.py2c_giftwrap_clear_4d_facets()

  Deallocates list of facets of convex hull stored in 4-space.

phcpy2c3.py2c_giftwrap_clear_support_string()

  Deallocates the string representation of the support set that was stored internally by the call py2c_giftwrap_support_size.

phcpy2c3.py2c_giftwrap_convex_hull()

  Applies the giftwrapping algorithm to a point configuration. On input are an integer and a string: 1) the number of points in the list; 2) the string representation of a Python list of tuples. When the function returns, the internal data structures to store the convex hull are defined. On return is the failure code, which equals zero if all went well.

phcpy2c3.py2c_giftwrap_initial_form()

  Replaces the system in the Laurent systems container by its initial form. There are three input parameters: 1) the dimension, number of coordinates in the inner normal; 2) the number of characters in the string representation for the normal; 3) the string representation of the inner normal. On return is the failure code, which equals zero if all went well.

phcpy2c3.py2c_giftwrap_number_of_facets()

  Returns the number of facets of the given dimension. On input is an integer, the dimension of the facet.

phcpy2c3.py2c_giftwrap_planar()

  Applies the giftwrapping algorithm to a planar point configuration. On input are an integer and a string: 1) the number of points in the list; 2) the string representation of a Python list of tuples. On return is the string representation of the vertex points, sorted so that each two consecutive points define an edge.

phcpy2c3.py2c_giftwrap_retrieve_facet()

  Returns the string representation of a facet. On input are two integer numbers: 1) the dimension of the facet; 2) the index of the facet.

phcpy2c3.py2c_giftwrap_support_size()

  Returns the number of characters in the string representation of the support of the k-th Laurent polynomial in the container, k is given on input.

phcpy2c3.py2c_giftwrap_support_string()

  Returns the string representation of the support of a Laurent polynomial.

phcpy2c3.py2c_initialize_dobldobl_homotopy()

  Initializes the homotopy to track a path with a generator, using double double precision arithmetic. There is one integer number on input to be considered as a boolean, as an indicator whether a fixed gamma constant will be used. Before calling this routine the target and start system must be copied over from the dobldobl systems container. The two other input parameters are two doubles: the real and imaginary part of the gamma constant. If the integer parameter equals zero and if the two input doubles are not both zero, then the input gamma constant will be used, otherwise, if the two input doubles are zero and the first integer parameter is zero as well, then a random gamma constant will be generated.

phcpy2c3.py2c_initialize_dobldobl_solution()

  Initializes the path tracker with a generator with a solution from the dobldobl solutions container. The index to the solution is given as an integer input parameter. The counting of the indices starts at one, so the first solution has index one.

phcpy2c3.py2c_initialize_multprec_homotopy()

  Initializes the homotopy to track a path with a generator, using arbitrary multiprecision arithmetic. There is are two integer numbers on input: 1) one to be considered as a boolean, as an indicator whether a fixed gamma constant will be used; and 2) the number of decimal places in the working precision. Before calling this routine the target and start system must be copied over from the multprec systems container.

phcpy2c3.py2c_initialize_multprec_solution()

  Initializes the path tracker with a generator with a solution from the multprec solutions container. The index to the solution is given as an integer input parameter. The counting of the indices starts at one, so the first solution has index one.

phcpy2c3.py2c_initialize_quaddobl_homotopy()

  Initializes the homotopy to track a path with a generator, using quad double precision arithmetic. There is one integer number on input to be considered as a boolean, as an indicator whether a fixed gamma constant will be used. Before calling this routine the target and start system must be copied over from the quaddobl systems container. The two other input parameters are two doubles: the real and imaginary part of the gamma constant. If the integer parameter equals zero and if the two input doubles are not both zero, then the input gamma constant will be used, otherwise, if the two input doubles are zero and the first integer parameter is zero as well, then a random gamma constant will be generated.

phcpy2c3.py2c_initialize_quaddobl_solution()

  Initializes the path tracker with a generator with a solution from the quaddobl solutions container. The index to the solution is given as an integer input parameter. The counting of the indices starts at one, so the first solution has index one.

phcpy2c3.py2c_initialize_standard_homotopy()

  Initializes the homotopy to track a path with a generator, using standard double precision arithmetic. There is one integer number on input to be considered as a boolean, as an indicator whether a fixed gamma constant will be used. Before calling this routine the target and start system must be copied over from the standard systems container. The two other input parameters are two doubles: the real and imaginary part of the gamma constant. If the integer parameter equals zero and if the two input doubles are not both zero, then the input gamma constant will be used, otherwise, if the two input doubles are zero and the first integer parameter is zero as well, then a random gamma constant will be generated.

phcpy2c3.py2c_initialize_standard_solution()

  Initializes the path tracker with a generator with a solution from the standard solutions container. The index to the solution is given as an integer input parameter. The counting of the indices starts at one, so the first solution has index one.

phcpy2c3.py2c_initialize_varbprec_homotopy()

  Initializes the variable precision homotopy with the target and start system stored in the strings. On entry are three integers and two strings, in the following order: 1) fixed_gamma is a flag: if 1, then a fixed value for the gamma constant is used, if 0, a random value for gamma will be generated; 2) nc_target, the number of characters in the string target; 3) target, the string representation of the target system; 4) nc_start, the number of characters in the string start; 5) start, the string representation of the start system. On return is the failure code, which equals zero if all went well.

phcpy2c3.py2c_initialize_varbprec_solution()

  Uses the string representation of a solution to initialize the variable precision path tracker with. There are three input parameters, two integers and one string: 1) nv, the number of variables in the solution; 2) nc, the number of characters in the string sol; 3) sol, the string representation of a solution. On return is the failure code, which equals zero if all went well.

phcpy2c3.py2c_intcelcon_append_lifted_point()

  Appends a lifted point to the cells container. There are three input parameters: 1) the dimension of the point; 2) the index of the support to where to append to; and 3) the string representation of the lifted point. Returns the failure code, which equals zero when all went well.

phcpy2c3.py2c_intcelcon_clear_mixed_cell_configuration()

  Deallocates the data in the integer cell container.

phcpy2c3.py2c_intcelcon_get_inner_normal()

  Given on input the dimension of the lifted points and the index of the mixed cell of interest, returns the string representation of the inner normal of the mixed cell.

phcpy2c3.py2c_intcelcon_get_lifted_point()

  Returns the string representation of the coordinates of a lifted point.

phcpy2c3.py2c_intcelcon_get_point_in_cell()

  Returns the string representation of the n coordinates of the k-th point from the j-th list of the i-th cell. On input are the four integers: n, i, j, k, respectively the length of the lifted vectors in the supports, the index to a cell in the container, the index to a support of the i-th cell, and the index to a point in the j-th support of the i-th cell.

phcpy2c3.py2c_intcelcon_initialize_supports()

  Initializes the supports with an integer valued lifting.

phcpy2c3.py2c_intcelcon_length_of_supports()

  Returns a list of lengths of each support.

phcpy2c3.py2c_intcelcon_make_subdivision()

  Computes the cells in the regular subdivision induced by an integer valued lifting function.

phcpy2c3.py2c_intcelcon_mixed_volume()

  Returns the mixed volume of a mixed cell.

phcpy2c3.py2c_intcelcon_number_of_cells()

  Returns the number of cells in the mixed subdivision by integer lifting.

phcpy2c3.py2c_intcelcon_number_of_points_in_cell()

  Given are two integer numbers: the index to a cell (starting the count at one) and the number of different supports. On return is the string representation of the number of points which span each component of the mixed cell.

phcpy2c3.py2c_intcelcon_read_mixed_cell_configuration()

  Reads a mixed-cell configuration

phcpy2c3.py2c_intcelcon_set_type_of_mixture()

  Defines the type of mixture of the tuple of supports.

phcpy2c3.py2c_intcelcon_type_of_mixture()

  Returns the type of mixture for the integer cells container.

phcpy2c3.py2c_intcelcon_write_mixed_cell_configuration()

  Writes the mixed-cell configuration to screen.

phcpy2c3.py2c_linear_reduce_dobldobl_system()

  Applies linear reduction on the coefficient matrix of the system in the container for double double precision. There is one integer parameter: whether to diagonalize or not.

phcpy2c3.py2c_linear_reduce_quaddobl_system()

  Applies linear reduction on the coefficient matrix of the system in the container for quad double precision. There is one integer parameter: whether to diagonalize or not.

phcpy2c3.py2c_linear_reduce_standard_system()

  Applies linear reduction on the coefficient matrix of the system in the container for standard double precision. There is one integer parameter: whether to diagonalize or not.

phcpy2c3.py2c_mapcon_clear_maps()

  Deallocates the maps stored in the container. Returns the failure code, which equals zero if all went well.

phcpy2c3.py2c_mapcon_coefficients_of_map()

  Returns the coefficients of a monomial map stored in the container. On entry are three parameters: 1) the dimension of the map; 2) the index of the map in all maps of that dimension; 3) the number of variables. On return is a Python list of complex doubles.

phcpy2c3.py2c_mapcon_degree_of_map()

  Given the dimension and index of a map, given as two integers as input parameters, returns the degree of that map.

phcpy2c3.py2c_mapcon_exponents_of_map()

  Returns the exponents of a monomial map stored in the container. On entry are three parameters: 1) the dimension of the map; 2) the index of the map in all maps of that dimension; 3) the number of variables. On return is a Python list of integers.

phcpy2c3.py2c_mapcon_number_of_maps()

  Returns the number of maps in the container.

phcpy2c3.py2c_mapcon_solve_system()

  Solves the binomial system stored in the Laurent systems container. There is one input argument, either one or zero. If one, then only the pure top dimensional solutions are computed. If zero, then all solution sets are computed. Returns the failure code, which equals zero if all went well.

phcpy2c3.py2c_mapcon_top_dimension()

  Returns the top dimension of the maps in the container.

phcpy2c3.py2c_mapcon_write_maps()

  Writes the maps stored in the container to screen. Returns the failure code, which equals zero if all went well.

phcpy2c3.py2c_mixed_volume()

  Computes the mixed volume, and the stable mixed volume as well if the input parameter equals 1. On return is the mixed volume, or a tuple with the mixed volume and the stable mixed volume.

phcpy2c3.py2c_mixed_volume_by_demics()

  Calls DEMiCs to compute the mixed volume of the system in the standard systems container. If the standard systems container is empty, then the system in the standard Laurent systems container is taken as input. The integer in mv on return equals the mixed volume. The regular mixed-cell configuration is in the cells container. The above is for the case if the input parameter equals 0. If the input parameter equals 1, then on return is a tuple, which contains the mixed volume and the stable mixed volume.

phcpy2c3.py2c_multprec_Newton_Laurent_step()

  Applies one Newton step in arbitrary multiprecision to the Laurent system in the multprec Laurent systems container and to the solutions in the container. On input is an integer: the number of decimal places in the precision. On return is the failure code, which equals zero if all went well.

phcpy2c3.py2c_multprec_Newton_step()

  Applies one Newton step in arbitrary multiprecision to the system in the multprec systems container and to the solutions in the container. On input is an integer, the number of decimal places in the precision. On return is the failure code, which equals zero if all went well.

phcpy2c3.py2c_next_dobldobl_solution()

  Computes the next point on the solution path with double double precision for the given index. This index is given as an input parameter. The index to the solution path starts its count at one. The point itself is stored in the dobldobl solutions container. The functions py2c_initialized_dobldobl_tracker and py2c_initialize_dobldobl_solution must have been executed earlier. The failcode is returned, which equals zero if all is well.

phcpy2c3.py2c_next_multprec_solution()

  Computes the next point on the solution path with arbitrary multiprecision for the given index. This index is given as an input parameter. The index to the solution path starts its count at one. The point itself is stored in the multprec solutions container. The functions py2c_initialized_multprec_tracker and py2c_initialize_multprec_solution must have been executed earlier. The failcode is returned, which equals zero if all is well.

phcpy2c3.py2c_next_quaddobl_solution()

  Computes the next point on the solution path with quad double precision for the given index. This index is given as an input parameter. The index to the solution path starts its count at one. The point itself is stored in the quaddobl solutions container. The functions py2c_initialized_quaddobl_tracker and py2c_initialize_quaddobl_solution must have been executed earlier. The failcode is returned, which equals zero if all is well.

phcpy2c3.py2c_next_standard_solution()

  Computes the next point on the solution path with standard double precision for the given index. This index is given as an input parameter. The index to the solution path starts its count at one. The point itself is stored in the standard solutions container. The functions py2c_initialized_standard_tracker and py2c_initialize_standard_solution must have been executed earlier. The failcode is returned, which equals zero if all is well.

phcpy2c3.py2c_next_varbprec_solution()

  Computes the next point on a solution path in variable precision. There are four integer input parameters: 1) the number of correct decimal places in the solution; 2) an upper bound on the number of decimal places in the precision; 3) the maximum number of Newton iterations; 4) a flag zero or one to indicate the verbose level. On return is a tuple: 0) the failure code, which equals zero if all went well; and 1) the string representation of the next solution on the path.

phcpy2c3.py2c_nonlinear_reduce_standard_system()

  Applies nonlinear reduction on the system in the container for standard double precision. Three integer numbers are expected on input: (1) the maximum number of equal degree replacements, (2) the maximum number of computed S-polynomials, (3) the maximum number of computed R-polynomials. The system in the standard container is replace by the reduced system. Three numbers are returned: (1) the number of equal degree replacements, (2) the number of computed S-polynomials, (3) the number of computed R-polynomials.

phcpy2c3.py2c_numbtrop_dobldobl_clear()

  Deallocates the stored numerically computed tropisms, computed in double double precision.

phcpy2c3.py2c_numbtrop_dobldobl_dimension()

  Returns the dimension of the tropisms, stored in double double precision, in the numerical tropisms container.

phcpy2c3.py2c_numbtrop_dobldobl_initialize()

  Initializes the numerical tropisms container, in double double precision. The input parameters are nbt : number of tropisms; dim : length_of_each tropism; wnd : winding numbers, as many as nbt; dir : 2*nbt*dim doubles with the coordinates of the tropisms; err : errors on the tropisms, as many doubles as the value of 2*nbt. The numbers in wnd, dir, and err must be given in one string, as the string representation of a list of doubles. On return is the the failure code, which equals zero if all went well.

phcpy2c3.py2c_numbtrop_dobldobl_retrieve()

  Retrieves all tropisms stored in double double precision. The input parameters are two integers: nbt : number of tropisms; dim : length_of_each tropism. On return are wnd : winding numbers, as many as nbt; dir : 2*nbt*dim doubles with the coordinates of the tropisms; err : errors on the tropisms, as many doubles as the value of 2*nbt. All numbers are returns in one string, as the string representation of a list of doubles. The failure code, which equals zero if all went well.

phcpy2c3.py2c_numbtrop_dobldobl_retrieve_tropism()

  Returns one tropism, stored in double double precision. The input parameters are two integers: dim : the length of the tropism vector; idx : the index of the tropism, indexing starts at one, and ends at nbt, what is returned by numbtrop_dobldobl_size. The first parameter on return is an integer: wnd : estimated winding number; The other output parameters are of type double: dir : coordinates of the tropisms, as many as 2*dim; err : the error on the tropism, two doubles. All 2*dim+2 doubles are returned in one string, the string representation of a list of doubles.

phcpy2c3.py2c_numbtrop_dobldobl_size()

  Returns the number of tropisms, stored in double double precision, in the numerical tropisms container.

phcpy2c3.py2c_numbtrop_quaddobl_clear()

  Deallocates the stored numerically computed tropisms, computed in quad double precision.

phcpy2c3.py2c_numbtrop_quaddobl_dimension()

  Returns the dimension of the tropisms, stored in quad double precision, in the numerical tropisms container.

phcpy2c3.py2c_numbtrop_quaddobl_initialize()

  Initializes the numerical tropisms container, in quad double precision. The input parameters are nbt : number of tropisms; dim : length_of_each tropism; wnd : winding numbers, as many as nbt; dir : 4*nbt*dim doubles with the coordinates of the tropisms; err : errors on the tropisms, as many doubles as the value of 4*nbt. The numbers in wnd, dir, and err must be given in one string, as the string representation of a list of doubles. On return is the the failure code, which equals zero if all went well.

phcpy2c3.py2c_numbtrop_quaddobl_retrieve()

  Retrieves all tropisms stored in quad double precision. The input parameters are two integers: nbt : number of tropisms; dim : length_of_each tropism. On return are wnd : winding numbers, as many as nbt; dir : 4*nbt*dim doubles with the coordinates of the tropisms; err : errors on the tropisms, as many doubles as the value of 4*nbt. All numbers are returns in one string, as the string representation of a list of doubles. The failure code, which equals zero if all went well.

phcpy2c3.py2c_numbtrop_quaddobl_retrieve_tropism()

  Returns one tropism, stored in quad double precision. The input parameters are two integers: dim : the length of the tropism vector; idx : the index of the tropism, indexing starts at one, and ends at nbt, what is returned by numbtrop_quaddobl_size. The first parameter on return is an integer: wnd : estimated winding number; The other output parameters are of type double: dir : coordinates of the tropisms, as many as 4*dim; err : the error on the tropism, four doubles. All 4*dim+4 doubles are returned in one string, the string representation of a list of doubles.

phcpy2c3.py2c_numbtrop_quaddobl_size()

  Returns the number of tropisms, stored in quad double precision, in the numerical tropisms container.

phcpy2c3.py2c_numbtrop_standard_clear()

  Deallocates the stored numerically computed tropisms, computed in standard double precision.

phcpy2c3.py2c_numbtrop_standard_dimension()

  Returns the dimension of the tropisms, stored in standard double precision, in the numerical tropisms container.

phcpy2c3.py2c_numbtrop_standard_initialize()

  Initializes the numerical tropisms container, in standard double precision. The input parameters are nbt : number of tropisms; dim : length_of_each tropism; wnd : winding numbers, as many as nbt; dir : nbt*dim doubles with the coordinates of the tropisms; err : errors on the tropisms, as many doubles as the value of nbt. The numbers in wnd, dir, and err must be given in one string, as the string representation of a list of doubles. On return is the failure code, which equals zero if all went well.

phcpy2c3.py2c_numbtrop_standard_retrieve()

  Retrieves all tropisms stored in standard double precision. The input parameters are two integers: nbt : number of tropisms; dim : length_of_each tropism. On return are wnd : winding numbers, as many as nbt; dir : nbt*dim doubles with the coordinates of the tropisms; err : errors on the tropisms, as many doubles as the value of nbt. All numbers are returns in one string, as the string representation of a list of doubles. The failure code, which equals zero if all went well.

phcpy2c3.py2c_numbtrop_standard_retrieve_tropism()

  Returns one tropism, stored in standard double precision. The input parameters are two integers: dim : the length of the tropism vector; idx : the index of the tropism, indexing starts at one, and ends at nbt, what is returned by numbtrop_standard_size. The first parameter on return is an integer: wnd : estimated winding number; The other output parameters are of type double: dir : coordinates of the tropisms, as many as dim; err : the error on the tropism. All dim+1 doubles are returned in one string, the string representation of a list of doubles.

phcpy2c3.py2c_numbtrop_standard_size()

  Returns the number of tropisms, stored in standard double precision, in the numerical tropisms container.

phcpy2c3.py2c_numbtrop_store_dobldobl_tropism()

  Stores a tropism given in double double precision. The first three input parameters are integers: dim : the length of the tropism vector; idx : the index of the tropism, indexing starts at one, and ends at nbt, what is returned by dobldobl_size; wnd : estimated winding number; The other input parameters are of type double: dir : coordinates of the tropisms, as many as 2*dim; err : the error on the tropism, two doubles. All 2*dim+2 doubles are given in one string, the string representatin of a list of doubles.

phcpy2c3.py2c_numbtrop_store_quaddobl_tropism()

  Stores a tropism given in quad double precision. The first three input parameters are integers: dim : the length of the tropism vector; idx : the index of the tropism, indexing starts at one, and ends at nbt, what is returned by quaddobl_size; The other input parameters are of type double: wnd : estimated winding number; dir : coordinates of the tropisms, as many as 4*dim; err : the error on the tropism, four double All 4*dim+4 doubles are given in one string, the string representatin of a list of doubles.

phcpy2c3.py2c_numbtrop_store_standard_tropism()

  Stores a tropism given in standard double precision. The first three input parmeters are integers: dim : the length of the tropism vector; idx : the index of the tropism, indexing starts at one, and ends at nbt, what is returned by standard_size; wnd : estimated winding number; The other input parameters are of type double: dir : coordinates of the tropisms, as many as dim; err : the error on the tropism. All dim+1 doubles are given in one string, the string representation of a list of doubles.

phcpy2c3.py2c_padcon_clear_dobldobl_data()

  Deallocates data for the series-Pade tracker in double double precision.

phcpy2c3.py2c_padcon_clear_parameters()

  Deallocates the allocated space for the parameters.

phcpy2c3.py2c_padcon_clear_quaddobl_data()

  Deallocates data for the series-Pade tracker in quad double precision.

phcpy2c3.py2c_padcon_clear_standard_data()

  Deallocates data for the series-Pade tracker in double precision.

phcpy2c3.py2c_padcon_dobldobl_closest_pole()

  Returns the complex number representation of the closest pole, computed by the predictor in double double precision. The returned numbers are the high parts of the double doubles. Results are meaningful only if the real part >= 0.0.

phcpy2c3.py2c_padcon_dobldobl_denominator_coefficient()

  Returns a tuple: the real and imaginary parts of the coefficient of the denominator of the Pade approximant, at the component with leadidx at position idx, computed by the predictor in double double precision. The doubles are the highest parts of the double doubles. The integers leadidx and idx are two input parameters, the third input integer is the verbose flag.

phcpy2c3.py2c_padcon_dobldobl_estimated_distance()

  Returns the estimated distance to the closest solution by the path tracker which runs in double double precision.

phcpy2c3.py2c_padcon_dobldobl_hessian_step()

  Returns the current Hessian step size of the path tracker which runs in double double precision.

phcpy2c3.py2c_padcon_dobldobl_initialize_homotopy()

  For the defined target and start system, initializes the homotopy in double double precision, for the step-by-step Pade continuation. On entry is one parameter, the verbose flag which is zero or one. If the verbose flag is 1, then extra output will be written.

phcpy2c3.py2c_padcon_dobldobl_initialize_parameter_homotopy()

  On entry are two integers: 1) the index for the continuation parameter in the natural homotopy and 2) the verbose flag. With the system, defined as target system, and the index for the continuation parameter, initializes the homotopy in double double precision for the step-by-step Pade continuation. If the verbose flag is 1, then extra output will be written.

phcpy2c3.py2c_padcon_dobldobl_numerator_coefficient()

  Returns a tuple: the real and imaginary parts of the coefficient of the numerator of the Pade approximant, at the component with leadidx at position idx, computed by the predictor in double double precision. The doubles are the highest parts of the double doubles. The integers leadidx and idx are two input parameters, the third input integer is the verbose flag.

phcpy2c3.py2c_padcon_dobldobl_pole()

  Returns a tuple: the real and imaginary parts of the pole Pade approximant with leadidx at position poleidx, computed by the predictor in double double precision. The integers leadidx and poleidx are two input parameters, the third input integer is the verbose flag. The returned doubles are the highest parts of the double doubles.

phcpy2c3.py2c_padcon_dobldobl_pole_radius()

  Returns the smallest pole radius computed by the predictor in double double precision. The returned number is the high part of the double double number.

phcpy2c3.py2c_padcon_dobldobl_pole_step()

  Returns the current pole step size of the path tracker which runs in double double precision.

phcpy2c3.py2c_padcon_dobldobl_predict_correct()

  Executes one predict-correct step on the current solution and the defined homotopy in double double precision. On entry is one integer, the verbose flag which is zero or one. On return is the failure code of the predict-correct step: if zero, then the required accuracies were met, otherwise, either the predict or the correct step failed. If the verbose flag is 1, then extra output will be written.

phcpy2c3.py2c_padcon_dobldobl_series_coefficient()

  Returns a tuple: the real and imaginary parts of the series coefficient of component with leadidx at position idx, of the series computed by the predictor in double double precision. The doubles are the highest parts of the double doubles. The integers leadidx and idx are two input parameters, the third input integer is the verbose flag.

phcpy2c3.py2c_padcon_dobldobl_series_step()

  Returns the current series step size of the path tracker which runs in double double precision.

phcpy2c3.py2c_padcon_dobldobl_step_size()

  Returns the current step size of the path tracker which runs in double double precision.

phcpy2c3.py2c_padcon_dobldobl_t_value()

  Returns the current t value of the path tracker which runs in double double precision.

phcpy2c3.py2c_padcon_dobldobl_track()

  For the defined target, start system, and start solutions, launches the Pade continuation in double double precision. Seven input parameters are expected: 1) the number of characters in the name of the output file; 2) a string which defines the name of the output file, if the string is empty, then no file is created; 3) a flag to indicate whether the output file is the defined output file (value 1 of the flag), or whether the file is local (value 0); 4) an integer for the verbose flag, if zero, then no extra information is written to file or screen; 5) an integer for the homogenization, if zero, tracking happens in affine space, if one, then tracking happens in 1-projective space, if m, for m > 1, then multihomogenization is applied; 6) an integer for the number of variables, 0 if the fifth parameter m is zero or one; 7) a string with the index representation for the partition of the set of variables, if the fifth parameter m is larger than one.

phcpy2c3.py2c_padcon_get_dobldobl_solution()

  On entry are two integer parameters: 1) the index of the position of the solution and 2) the verbose flag, which is zero or one. Retrieves the current solution and places it at the given position in the solutions container in double double precision. If the verbose flag is 1, then extra output will be written.

phcpy2c3.py2c_padcon_get_homotopy_continuation_parameter()

  Returns the value of the k-th continuation parameter, if k ranges between 1 and 13. The integer k is given on entry.

phcpy2c3.py2c_padcon_get_quaddobl_solution()

  On entry are two integer parameters: 1) the index of the position of the solution and 2) the verbose flag, which is zero or one. Retrieves the current solution and places it at the given position in the solutions container in quad double precision. If the verbose flag is 1, then extra output will be written.

phcpy2c3.py2c_padcon_get_standard_solution()

  On entry are two integer parameters: 1) the index of the position of the solution and 2) the verbose flag, which is zero or one. Retrieves the current solution and places it at the given position in the solutions container in standard double precision. If the verbose flag is 1, then extra output will be written.

phcpy2c3.py2c_padcon_initialize_dobldobl_solution()

  Takes the solution with a given index in the solutions container in double double precision and initializes the series-Pade tracker. On entry are two integers: 1) the index of the position of the solution in the container and 2) the verbose flag, which is zero or one. If the verbose flag is 1, then extra output will be written.

phcpy2c3.py2c_padcon_initialize_quaddobl_solution()

  Takes the solution with a given index in the solutions container in quad double precision and initializes the series-Pade tracker. On entry are two integers: 1) the index of the position of the solution in the container and 2) the verbose flag, which is zero or one. If the verbose flag is 1, then extra output will be written.

phcpy2c3.py2c_padcon_initialize_standard_solution()

  Takes the solution with a given index in the solutions container in standard double precision and initializes the series-Pade tracker. On entry are two integers: 1) the index of the position of the solution in the container and 2) the verbose flag, which is zero or one. If the verbose flag is 1, then extra output will be written.

phcpy2c3.py2c_padcon_quaddobl_closest_pole()

  Returns the complex number representation of the closest pole, computed by the predictor in quad double precision. The returned numbers are the highest parts of the quad doubles. Results are meaningful only if the real part >= 0.0.

phcpy2c3.py2c_padcon_quaddobl_denominator_coefficient()

  Returns a tuple: the real and imaginary parts of the series coefficient of the denominator of the Pade approximant, at the component with leadidx at position idx, computed by the predictor in quad double precision. The doubles are the highest parts of the quad doubles. The integers leadidx and idx are two input parameters, the third input integer is the verbose flag.

phcpy2c3.py2c_padcon_quaddobl_estimated_distance()

  Returns the estimated distance to the closest solution by the path tracker which runs in quad double precision.

phcpy2c3.py2c_padcon_quaddobl_hessian_step()

  Returns the current Hessian step size of the path tracker which runs in quad double precision.

phcpy2c3.py2c_padcon_quaddobl_initialize_homotopy()

  For the defined target and start system, initializes the homotopy in quad double precision, for the step-by-step Pade continuation. On entry is one parameter, the verbose flag which is zero or one. If the verbose flag is 1, then extra output will be written.

phcpy2c3.py2c_padcon_quaddobl_initialize_parameter_homotopy()

  On entry are two integers: 1) the index for the continuation parameter in the natural homotopy and 2) the verbose flag. With the system, defined as target system, and the index for the continuation parameter, initializes the homotopy in quad double precision for the step-by-step Pade continuation. If the verbose flag is 1, then extra output will be written.

phcpy2c3.py2c_padcon_quaddobl_numerator_coefficient()

  Returns a tuple: the real and imaginary parts of the series coefficient of the numerator of the Pade approximant, at the component with leadidx at position idx, computed by the predictor in quad double precision. The doubles are the highest parts of the quad doubles. The integers leadidx and idx are two input parameters, the third input integer is the verbose flag.

phcpy2c3.py2c_padcon_quaddobl_pole()

  Returns a tuple: the real and imaginary parts of the pole Pade approximant with leadidx at position poleidx, computed by the predictor in quad double precision. The integers leadidx and poleidx are two input parameters, the third input integer is the verbose flag. The returned doubles are the highest parts of the quad doubles.

phcpy2c3.py2c_padcon_quaddobl_pole_radius()

  Returns the smallest pole radius computed by the predictor in quad double precision. The returned number is the highest part of the quad double number.

phcpy2c3.py2c_padcon_quaddobl_pole_step()

  Returns the current pole step size of the path tracker which runs in quad double precision.

phcpy2c3.py2c_padcon_quaddobl_predict_correct()

  Executes one predict-correct step on the current solution and the defined homotopy in quad double precision. On entry is one integer, the verbose flag which is zero or one. On return is the failure code of the predict-correct step: if zero, then the required accuracies were met, otherwise, either the predict or the correct step failed. If the verbose flag is 1, then extra output will be written.

phcpy2c3.py2c_padcon_quaddobl_series_coefficient()

  Returns a tuple: the real and imaginary parts of the series coefficient of component with leadidx at position idx, of the series computed by the predictor in quad double precision. The doubles are the highest parts of the quad doubles. The integers leadidx and idx are two input parameters, the third input integer is the verbose flag.

phcpy2c3.py2c_padcon_quaddobl_series_step()

  Returns the current series step size of the path tracker which runs in quad double precision.

phcpy2c3.py2c_padcon_quaddobl_step_size()

  Returns the current step size of the path tracker which runs in quad double precision.

phcpy2c3.py2c_padcon_quaddobl_t_value()

  Returns the current t value of the path tracker which runs in quad double precision.

phcpy2c3.py2c_padcon_quaddobl_track()

  For the defined target, start system, and start solutions, launches the Pade continuation in quad double precision. Seven input parameters are expected: 1) the number of characters in the name of the output file; 2) a string which defines the name of the output file, if the string is empty, then no file is created; 3) a flag to indicate whether the output file is the defined output file (value 1 of the flag), or whether the file is local (value 0); 4) an integer for the verbose flag, if zero, then no extra information is written to file or screen; 5) an integer for the homogenization, if zero, tracking happens in affine space, if one, then tracking happens in 1-projective space, if m, for m > 1, then multihomogenization is applied; 6) an integer for the number of variables, 0 if the fifth parameter m is zero or one; 7) a string with the index representation for the partition of the set of variables, if the fifth parameter m is larger than one.

phcpy2c3.py2c_padcon_set_default_parameters()

  Sets the default values of the homotopy continuation parameters.

phcpy2c3.py2c_padcon_set_homotopy_continuation_gamma()

  The gamma constant is the first homotopy continuation parameter. The gamma is a complex number and it should be given as two doubles, as its real and imaginary part respectively.

phcpy2c3.py2c_padcon_set_homotopy_continuation_parameter()

  Sets the value of the k-th continuation parameter to the given value. The first parameter k is an integer number between 2 and 13. The second parameter is the value of the k-th parameter, parsed as a floating point number.

phcpy2c3.py2c_padcon_standard_closest_pole()

  Returns the complex number representation of the closest pole, computed by the predictor in standard double precision. Results are meaningful only if the real part >= 0.0.

phcpy2c3.py2c_padcon_standard_denominator_coefficient()

  Returns a tuple: the real and imaginary parts of the coefficient of the denominator of the Pade approximant, at the component with leadidx at position idx, computed by the predictor in double precision. The integers leadidx and idx are two input parameters, the third input integer is the verbose flag.

phcpy2c3.py2c_padcon_standard_estimated_distance()

  Returns the estimated distance to the closest solution by the path tracker which runs in standard double precision.

phcpy2c3.py2c_padcon_standard_hessian_step()

  Returns the current Hessian step size of the path tracker which runs in standard double precision.

phcpy2c3.py2c_padcon_standard_initialize_homotopy()

  For the defined target and start system, initializes the homotopy in standard double precision, for the step-by-step Pade continuation. On entry is one parameter, the verbose flag which is zero or one. If the verbose flag is 1, then extra output will be written.

phcpy2c3.py2c_padcon_standard_initialize_parameter_homotopy()

  On entry are two integers: 1) the index for the continuation parameter in the natural homotopy and 2) the verbose flag. With the system, defined as target system, and the index for the continuation parameter, initializes the homotopy in standard double precision for the step-by-step Pade continuation. If the verbose flag is 1, then extra output will be written.

phcpy2c3.py2c_padcon_standard_numerator_coefficient()

  Returns a tuple: the real and imaginary parts of the coefficient of the numerator of the Pade approximant, at the component with leadidx at position idx, computed by the predictor in double precision. The integers leadidx and idx are two input parameters, the third input integer is the verbose flag.

phcpy2c3.py2c_padcon_standard_pole()

  Returns a tuple: the real and imaginary parts of the pole Pade approximant with leadidx at position poleidx, computed by the predictor in double precision. The integers leadidx and poleidx are two input parameters, the third input integer is the verbose flag.

phcpy2c3.py2c_padcon_standard_pole_radius()

  Returns the smallest pole radius computed by the predictor in standard double precision.

phcpy2c3.py2c_padcon_standard_pole_step()

  Returns the current pole step size of the path tracker which runs in standard double precision.

phcpy2c3.py2c_padcon_standard_predict_correct()

  Executes one predict-correct step on the current solution and the defined homotopy in standard double precision. On entry is one integer, the verbose flag which is zero or one. On return is the failure code of the predict-correct step: if zero, then the required accuracies were met, otherwise, either the predict or the correct step failed. If the verbose flag is 1, then extra output will be written.

phcpy2c3.py2c_padcon_standard_series_coefficient()

  Returns a tuple: the real and imaginary parts of the series coefficient of component with leadidx at position idx, of the series computed by the predictor in double precision. The integers leadidx and idx are two input parameters, the third input integer is the verbose flag.

phcpy2c3.py2c_padcon_standard_series_step()

  Returns the current series step size of the path tracker which runs in standard double precision.

phcpy2c3.py2c_padcon_standard_step_size()

  Returns the current step size of the path tracker which runs in standard double precision.

phcpy2c3.py2c_padcon_standard_t_value()

  Returns the current t value of the path tracker which runs in standard double precision.

phcpy2c3.py2c_padcon_standard_track()

  For the defined target, start system, and start solutions, launches the Pade continuation in standard double precision. Seven input parameters are expected: 1) the number of characters in the name of the output file; 2) a string which defines the name of the output file, if the string is empty, then no file is created; 3) a flag to indicate whether the output file is the defined output file (value 1 of the flag), or whether the file is local (value 0); 4) an integer for the verbose flag, if zero, then no extra information is written to file or screen; 5) an integer for the homogenization, if zero, tracking happens in affine space, if one, then tracking happens in 1-projective space, if m, for m > 1, then multihomogenization is applied; 6) an integer for the number of variables, 0 if the fifth parameter m is zero or one; 7) a string with the index representation for the partition of the set of variables, if the fifth parameter m is larger than one.

phcpy2c3.py2c_product_clear_set_structure()

  Deallocates the set structure.

phcpy2c3.py2c_product_is_set_structure_supporting()

  Checks whether the stored set structure is supporting for the system in the standard systems container. Returns an integer which represents true (1) or false (0).

phcpy2c3.py2c_product_linear_product_root_count()

  Returns the linear-product root count, computed from the supporting set structure.

phcpy2c3.py2c_product_m_homogeneous_Bezout_number()

  For the system in the standard systems container, a heuristic partition of the set of variables may lead to a Bezout number that is smaller than the total degree. On return is the m-homogeneous Bezout number for the string representation of the partition that is returned as the second argument in the tuple.

phcpy2c3.py2c_product_m_homogeneous_start_system()

  Given a partition of the set of variables, constructs an m-homogeneous Bezout number for the system in the standard systems container. On input are two arguments: 1) the number of characters in the string (second argument); and 2) the string representation for a partition of the variables. On return is the m-homogeneous Bezout number.

phcpy2c3.py2c_product_m_partition_Bezout_number()

  Given a partition of the set of variables, computes the m-homogeneous Bezout number for the system in the standard systems container. On input are two arguments: 1) the number of characters in the string (second argument); and 2) the string representation for a partition of the variables. On return is the m-homogeneous Bezout number.

phcpy2c3.py2c_product_parse_set_structure()

  Parses a given string into a set structure. On input are two parameters, one integer and one string: 1) the number of characters in the given string; and 2) the characters in the string. On return is the failure code, if zero, then the string has been parsed into a valid set structure.

phcpy2c3.py2c_product_random_linear_product_system()

  Builds a random linear-product system based on the stored set structure. On return is the failure code, which equals zero if all went well.

phcpy2c3.py2c_product_set_structure_string()

  Returns the string representation of the set structure.

phcpy2c3.py2c_product_solve_linear_product_system()

  Computes all solutions to the linear-product system and stores the solutions in the container for solutions in standard double precision. On return is the failure code, which equals zero if all went well.

phcpy2c3.py2c_product_supporting_set_structure()

  Builds a supporting set structure for the system stored in the container with coefficients in standard double precision.

phcpy2c3.py2c_product_write_set_structure()

  Writes the supporting set structure to screen.

phcpy2c3.py2c_quaddobl_Laurent_cascade_homotopy()

  Creates a homotopy in quad double precision using the stored Laurent systems to go one level down the cascade, removing one slice. On return is the failure code, which equals zero if all went well.

phcpy2c3.py2c_quaddobl_Newton_Laurent_step()

  Applies one Newton step in quad double precision to the Laurent system in the standard Laurent systems container and to the solutions in the container. On return is the failure code, which equals zero if all went well.

phcpy2c3.py2c_quaddobl_Newton_power_series()

  Given in the systems container a polynomial system with coefficients in standard double precision, and in the quaddobl systems pool the leading terms of the power series, this function runs Newton’s method to compute power series solutions of the system in the container, in quad double precision. There are four integers on input: 1) the index of the series parameter; 2) the maximal degree of the series; 3) the number of Newton steps to be done on each solution; 4) a 0/1-flag to indicate whether additional diagnostic output needs to be written to screen. On return is the failure code, which equals zero if all went well.

phcpy2c3.py2c_quaddobl_Newton_series()

  Given in the systems container a polynomial system with coefficients in standard double precision, and in the solutions container the leading coefficients of the power series, this function runs Newton’s method to compute power series solutions of the system in the container, in quad double precision. There are four integers on input: 1) the index of the series parameter; 2) the maximal degree of the series; 3) the number of Newton steps to be done on each solution; 4) a 0/1-flag to indicate whether additional diagnostic output needs to be written to screen. On return is the failure code, which equals zero if all went well.

phcpy2c3.py2c_quaddobl_Newton_step()

  Applies one Newton step in quad double precision to the system in the standard systems container and to the solutions in the container. On return is the failure code, which equals zero if all went well.

phcpy2c3.py2c_quaddobl_Pade_approximant()

  Given in the systems container a polynomial system with coefficients in quad double precision, and in the solutions container the leading coefficients of the power series, this function runs Newton’s method to compute power series solutions of the system in the container, in quad double precision, followed by the construction of the Pade approximants, for each solution. There are five integers on input: 1) the index of the series parameter; 2) the degree of the numerator of the Pade approximant; 3) the degree of the denominator of the Pade approximant; 4) the number of Newton steps to be done on each solution; 5) a 0/1-flag to indicate whether additional diagnostic output needs to be written to screen. The Pade approximants are stored in the quaddobl systems pool, numerators in the odd indexed entries and denominators in the entries with even index in each system. On return is the failure code, which equals zero if all went well.

phcpy2c3.py2c_quaddobl_cascade_homotopy()

  Creates a homotopy in quad double precision using the stored systems to go one level down the cascade, removing one slice. On return is the failure code, which equals zero if all went well.

phcpy2c3.py2c_quaddobl_collapse_diagonal()

  Eliminates the extrinsic diagonal for the system and solutions in the containers for quad doubles. On input are two integers: 1) k, the current number of slack variables in the embedding; 2) d, the number of slack variables to add to the final embedding. The system in the container has its diagonal eliminated and is embedded with k+d slack variables. The solutions corresponding to this system are in the solutions container. On return is the failure code, which equals zero if all went well.

phcpy2c3.py2c_quaddobl_crude_tracker()

  A crude tracker appends the end point of a path directly to the solutions container, without refinement or postprocessing. Tracking happens in quad double precision. On entry is the verbose parameter which is 1 or 0. If 1, then the solution vectors are written to screen, otherwise the crude tracker stays mute. On return is the failure code, which is zero when all went well. The requirement is that the target system, start system, and start solutions in quad double precision have been initialized in the containers.

phcpy2c3.py2c_quaddobl_deflate()

  Applies deflation in quad double precision to the system and the solutions stored in the containers. There are five input parameters, two integers and three doubles: (1) maxitr : the maximum number of iterations per root, (2) maxdef : the maximum number of deflations per root, (3) tolerr : tolerance on the forward error on each root, (4) tolres : tolerance on the backward error on each root, (5) tolres : tolerance on the numerical rank of the Jacobian matrices. On return is the failure code, which equals zero if all went well.

phcpy2c3.py2c_quaddobl_diagonal_cascade_solutions()

  Makes the start solutions to start the cascade homotopy to intersect two solution sets of dimensions a and b, where a >= b, in quad double precision. The dimensions a and b are given as input parameters. The systems stored as target and start system in the container define the witness sets for these two solution sets. On return is the failure code, which equals zero when all went well.

phcpy2c3.py2c_quaddobl_diagonal_homotopy()

  Creates a diagonal homotopy to intersect two solution sets of dimensions a and b respectively, where a >= b. The two input parameters are values for a and b. The systems stored as target and start system in the container, in quad double precision, define the witness sets for these two solution sets.

phcpy2c3.py2c_quaddobl_laursys_solve()

  Runs the cascades of homotopies on the Laurent polynomial system in the quaddobl systems container. Runs in quad double precision. On input are five integers : 1) nbtasks equals the number of tasks for multitasking, 2) topdim is the top dimension to start the homotopy cascades, 3) filter is a 0 or 1 flag to filter the witness supersets, 4) factor is a 0 or 1 flag to factor the witness sets, 5) verbose is a flag for intermediate output.

phcpy2c3.py2c_quaddobl_multiplicity_structure()

  Computes the multiplicity structure in quad double precision. Required is the presence of a polynomial system in the quaddobl systems container and a solution in the quaddobl solutions container. The input parameters are two integers and one double: order : the maximum differentiation order, verbose : 1 for verbose, 0 for silent, and tol : tolerance on the numerical rank. On return is a tuple: the multiplicity and the values of the Hilbert function.

phcpy2c3.py2c_quaddobl_polysys_solve()

  Runs the cascades of homotopies on the polynomial system in the quaddobl systems container. Runs in quad double precision. On input are five integers : 1) nbtasks equals the number of tasks for multitasking, 2) topdim is the top dimension to start the homotopy cascades, 3) filter is a 0 or 1 flag to filter the witness supersets, 4) factor is a 0 or 1 flag to factor the witness sets, 5) verbose is a flag for intermediate output.

phcpy2c3.py2c_quaddobl_witset_of_Laurent_hypersurface()

  Given in the string p of nc characters a polynomial in nv variables, terminated by a semicolon, the systems and solutions container in quad double precision on return contain a witness set for the hypersurface defined by the Laurent polynomial in p. On entry are two integers and one string, in the following order: 1) nv, the number of variables of the polynomials; 2) nc, the number of characters in the string p; 3) p, string representation of a Laurent polynomial in several variables, terminates with a semicolon. On return is the failure code, which equals zero if all went well.

phcpy2c3.py2c_quaddobl_witset_of_hypersurface()

  Given in the string p of nc characters a polynomial in nv variables, terminated by a semicolon, the systems and solutions container in quad double precision on return contain a witness set for the hypersurface defined by the ordinary polynomial in p. On entry are two integers and one string, in the following order: 1) nv, the number of variables of the polynomials; 2) nc, the number of characters in the string p; 3) p, string representation of an ordinary polynomial in several variables, terminates with a semicolon. On return is the failure code, which equals zero if all went well.

phcpy2c3.py2c_read_dobldobl_start_Laurent_system()

  Prompts the user for a file name and reads the start system from file, in double double precision. If available on file, also its solutions will be read and stored.

phcpy2c3.py2c_read_dobldobl_start_system()

  Prompts the user to enter a start system that will be parsed in double double precision. The failure code is returned, which is zero if all went well.

phcpy2c3.py2c_read_dobldobl_start_system_from_file()

  The two input arguments are a number and a string: 1) The number equals the number of characters in the string. 2) The string given on input is the name of a file which contains a start system to be parsed in double double precision. The failure code is returned, which is zero if all went well.

phcpy2c3.py2c_read_dobldobl_target_Laurent_system()

  Prompts the user for a file name and reads the target system from file, in double double precision. If available on file, also its solutions will be read and stored.

phcpy2c3.py2c_read_dobldobl_target_system()

  Prompts the user to enter a target system that will be parsed in double double precision. The failure code is returned, which is zero if all went well.

phcpy2c3.py2c_read_dobldobl_target_system_from_file()

  The two input arguments are a number and a string: 1) The number equals the number of characters in the string. 2) The string given on input is the name of a file which contains a target system to be parsed in double double precision. The failure code is returned, which is zero if all went well.

phcpy2c3.py2c_read_quaddobl_start_Laurent_system()

  Prompts the user for a file name and reads the start system from file, in quad double precision. If available on file, also its solutions will be read and stored.

phcpy2c3.py2c_read_quaddobl_start_system()

  Prompts the user to enter a start system that will be parsed in quad double precision. The failure code is returned, which is zero if all went well.

phcpy2c3.py2c_read_quaddobl_start_system_from_file()

  The two input arguments are a number and a string: 1) The number equals the number of characters in the string. 2) The string given on input is the name of a file which contains a start system to be parsed in quad double precision. The failure code is returned, which is zero if all went well.

phcpy2c3.py2c_read_quaddobl_target_Laurent_system()

  Prompts the user for a file name and reads the target system from file, in quad double precision. If available on file, also its solutions will be read and stored.

phcpy2c3.py2c_read_quaddobl_target_system()

  Prompts the user to enter a target system that will be parsed in quad double precision. The failure code is returned, which is zero if all went well.

phcpy2c3.py2c_read_quaddobl_target_system_from_file()

  The two input arguments are a number and a string: 1) The number equals the number of characters in the string. 2) The string given on input is the name of a file which contains a target system to be parsed in quad double precision. The failure code is returned, which is zero if all went well.

phcpy2c3.py2c_read_standard_start_Laurent_system()

  Prompts the user for a file name and reads the start system from file, in standard double precision. If available on file, also its solutions will be read and stored.

phcpy2c3.py2c_read_standard_start_system()

  Prompts the user to enter a start system that will be parsed in standard double precision. The failure code is returned, which is zero if all went well.

phcpy2c3.py2c_read_standard_start_system_from_file()

  The two input arguments are a number and a string: 1) The number equals the number of characters in the string. 2) The string given on input is the name of a file which contains a start system to be parsed in standard double precision. The failure code is returned, which is zero if all went well.

phcpy2c3.py2c_read_standard_target_Laurent_system()

  Prompts the user for a file name and reads the target system from file, in standard double precision. If available on file, also its solutions will be read and stored.

phcpy2c3.py2c_read_standard_target_system()

  Prompts the user to enter a target system that will be parsed in standard double precision. The failure code is returned, which is zero if all went well.

phcpy2c3.py2c_read_standard_target_system_from_file()

  The two input arguments are a number and a string: 1) The number equals the number of characters in the string. 2) The string given on input is the name of a file which contains a target system to be parsed in standard double precision. The failure code is returned, which is zero if all went well.

phcpy2c3.py2c_scale_dobldobl_solutions()

  Replaces the solutions in the dobldobl solutions container with the scaled solutions, scaled with double double precision arithmetic, using the given scaling coefficients. On entry are two parameters: an integer and a string. The integer contains the number of elements in the list of scaling coefficients (doubles) stored in the string. The format of the string is the Python string representation of a list of doubles, i.e.: starting with [ and ending with ].

phcpy2c3.py2c_scale_dobldobl_system()

  Applies scaling to the system in the dobldobl systems container, with double double precision arithmetic. The system in the dobldobl systems container is replaced by the scaled system. On entry is one integer, which should be either 0, 1, or 2: 0 for only scaling of the equations, 1 variable scaling without variability reduction, 2 variable scaling with variability reduction. On return is a tuple with the scaling coefficients (if mode > 0) and the estimated inverse condition number of the scaling problem.

phcpy2c3.py2c_scale_quaddobl_solutions()

  Replaces the solutions in the quaddobl solutions container with the scaled solutions, scaled with quad double precision arithmetic, using the given scaling coefficients. On entry are two parameters: an integer and a string. The integer contains the number of elements in the list of scaling coefficients (doubles) stored in the string. The format of the string is the Python string representation of a list of doubles, i.e.: starting with [ and ending with ].

phcpy2c3.py2c_scale_quaddobl_system()

  Applies scaling to the system in the quaddobl systems container, with quad double precision arithmetic. The system in the quaddobl systems container is replaced by the scaled system. On entry is one integer, which should be either 0, 1, or 2: 0 for only scaling of the equations, 1 variable scaling without variability reduction, 2 variable scaling with variability reduction. On return is a tuple with the scaling coefficients (if mode > 0) and the estimated inverse condition number of the scaling problem.

phcpy2c3.py2c_scale_standard_solutions()

  Replaces the solutions in the standard solutions container with the scaled solutions, scaled with standard double precision arithmetic, using the given scaling coefficients. On entry are two parameters: an integer and a string. The integer contains the number of elements in the list of scaling coefficients (doubles) stored in the string. The format of the string is the Python string representation of a list of doubles, i.e.: starting with [ and ending with ].

phcpy2c3.py2c_scale_standard_system()

  Applies scaling to the system in the standard systems container, with standard double precision arithmetic. The system in the standard systems container is replaced by the scaled system. On entry is one integer, which should be either 0, 1, or 2: 0 for only scaling of the equations, 1 variable scaling without variability reduction, 2 variable scaling with variability reduction. On return is a tuple with the scaling coefficients (if mode > 0) and the estimated inverse condition number of the scaling problem.

phcpy2c3.py2c_scan_for_symbols()

  Given on input are two arguments: a number and a string. The string holds the string representation of a polynomial system, where each polynomial is terminated by a semi colon. The first argument on input is the number of characters in the string. On return is the number of symbols used as variables in the system. This function helps to determine whether a system is square or not.

phcpy2c3.py2c_schubert_dobldobl_littlewood_richardson_homotopies()

  Runs the Littlewood-Richardson homotopies to resolve a number of general Schubert intersection conditions on k-planes in n-space, in double double precision. The polynomial system that was solved is in the container for systems with coefficients in double double precision and the corresponding solutions are in the dobldobl solutions container. On entry are seven integers and two strings, in the following order: 1) n, the ambient dimension, where the k-planes live; 2) k, the dimension of the solution planes; 3) c,the number of intersection conditions; 4) nc, the number of characters in the string brackets; 5) brackets is a string representation of c brackets, where the numbers in each bracket are separated by spaces; 6) the flag verbose: if 0, then no intermediate output is written, if 1, then the resolution is dispayed on screen; 7) the flag verify: if 0, then no diagnostic verification is done, if 1, then diagnostic verification is written to file; 8) the flag minrep: if 0, then all minors are used in the system, if 1, then a minimal representation of the problem is used; 9) the flag tosquare: if 0, then Gauss-Newton path trackers run, if 1, then the overdetermined systems are squared; 10) nbchar, the number of characters in the string filename; 11) filename is the name of the output file. The function returns a tuple of an integer and a string: 0) r is the formal root count as the number of k-planes for conditions imposed by the brackets for general flags; 1) flags, a string with the coefficients of the general flags.

phcpy2c3.py2c_schubert_localization_poset()

  Returns the string representation of the localization poset for the Pieri root count for m, p, and q. The input parameters are the integer values for m, p, and q: 1) m, the dimension of the input planes; 2) p, the dimension of the output planes; 3) q, the degree of the curves that produce p-planes.

phcpy2c3.py2c_schubert_osculating_planes()

  Returns the string representation of n real m-planes in d-space osculating a rational normal curve at the n points in s, where n = m*p + q*(m+p) and d = m+p. On entry are four integers and one string: 1) m, the dimension of the input planes; 2) p, the dimension of the output planes; 3) q, the degree of the solution maps; 4) nc, the number of characters in the string pts; and 5) pts, the string with m*p + q*(m+p) interpolation points.

phcpy2c3.py2c_schubert_pieri_count()

  Returns the number of p-plane producing curves of degree q that meet m*p + q*(m+p) given general m-planes. On input are three integer numbers: 1) m, the dimension of the input planes; 2) p, the dimension of the output planes; and 3) q, the degree of the curve that produces p-planes. The dimension of the ambient space of this Pieri problem is m+p.

phcpy2c3.py2c_schubert_pieri_homotopies()

  Runs the Pieri homotopies for (m,p,q) dimensions on generic input data. On return the systems container for systems with coefficients in standard double precision contains the polynomial system solved and in the solutions in standard double precision are in the solutions container. On entry are four integers and two strings: 1) m, the dimension of the input planes; 2) p, the dimension of the output planes; 3) q, the degree of the solution maps; 4) nc, the number of characters in the string A; 5) A, the string with m*p + q*(m+p) random complex input m-planes, where the real and imaginary parts are separated by a space; 6) pts, the string with m*p + q*(m+p) random complex interpolation points, only needed if q > 0. The function returns the combinatorial Pieri root count, which should equal the number of solutions in the container.

phcpy2c3.py2c_schubert_pieri_system()

  Fills the container of systems with coefficients in standard double precision with a polynomial system that expresses the intersection conditions of a general Pieri problem. On input are five integers and one string: 1) m, the dimension of the input planes; 2) p, the dimension of the output planes; 3) q, the degree of the solution maps; 4) nc, the number of characters in the string A; 5) A, m*p + q*(m+p) random complex input m-planes, where the real and imaginary parts are separated by a space; 6) a flag is_real: if == 1, then the coefficients of A are real, if == 0, then the coefficients of A are complex. Returns the failure code, which equals zero if all went well.

phcpy2c3.py2c_schubert_quaddobl_littlewood_richardson_homotopies()

  Runs the Littlewood-Richardson homotopies to resolve a number of general Schubert intersection conditions on k-planes in n-space, in quad double precision. The polynomial system that was solved is in the container for systems with coefficients in quad double precision and the corresponding solutions are in the quaddobl solutions container. On entry are seven integers and two strings, in the following order: 1) n, the ambient dimension, where the k-planes live; 2) k, the dimension of the solution planes; 3) c,the number of intersection conditions; 4) nc, the number of characters in the string brackets; 5) brackets is a string representation of c brackets, where the numbers in each bracket are separated by spaces; 6) the flag verbose: if 0, then no intermediate output is written, if 1, then the resolution is dispayed on screen; 7) the flag verify: if 0, then no diagnostic verification is done, if 1, then diagnostic verification is written to file; 8) the flag minrep: if 0, then all minors are used in the system, if 1, then a minimal representation of the problem is used; 9) the flag tosquare: if 0, then Gauss-Newton path trackers run, if 1, then the overdetermined systems are squared; 10) nbchar, the number of characters in the string filename; 11) filename is the name of the output file. The function returns a tuple of an integer and a string: 0) r is the formal root count as the number of k-planes for conditions imposed by the brackets for general flags; 1) flags, a string with the coefficients of the general flags.

phcpy2c3.py2c_schubert_resolve_conditions()

  Resolves a general Schubert intersection condition in n-space for k-planes subject to conditions defined by brackers. On return is the root count, the number of k-planes that satisfy the intersection conditions imposed by the brackets for general flags. On entry are five integers and one string: 1) n, the ambient dimension, where the k-planes live; 2) k, the dimension of the solution planes; 3) c, the number of intersection conditions; 4) nc, the number of characters in the string brackets; 5) brackets is a string representation of c brackets, where the numbers in each bracket are separated by spaces; 6) the flag verbose: when 0, no intermediate output is written, when 1, then the resolution is dispayed on screen.

phcpy2c3.py2c_schubert_standard_littlewood_richardson_homotopies()

  Runs the Littlewood-Richardson homotopies to resolve a number of general Schubert intersection conditions on k-planes in n-space, in standard double precision. The polynomial system that was solved is in the container for systems with coefficients in standard double precision and the corresponding solutions are in the standard solutions container. On entry are seven integers and two strings, in the following order: 1) n, the ambient dimension, where the k-planes live; 2) k, the dimension of the solution planes; 3) c,the number of intersection conditions; 4) nc, the number of characters in the string brackets; 5) brackets is a string representation of c brackets, where the numbers in each bracket are separated by spaces; 6) the flag verbose: if 0, then no intermediate output is written, if 1, then the resolution is dispayed on screen; 7) the flag verify: if 0, then no diagnostic verification is done, if 1, then diagnostic verification is written to file; 8) the flag minrep: if 0, then all minors are used in the system, if 1, then a minimal representation of the problem is used; 9) the flag tosquare: if 0, then Gauss-Newton path trackers run, if 1, then the overdetermined systems are squared; 10) nbchar, the number of characters in the string filename; 11) filename is the name of the output file. The function returns a tuple of an integer and a string: 0) r is the formal root count as the number of k-planes for conditions imposed by the brackets for general flags; 1) flags, a string with the coefficients of the general flags.

phcpy2c3.py2c_set_gamma_constant()

  Stores the gamma constant for later retrieval. Four parameters are expected on input, two doubles and two integers. The two doubles are the real and imaginary parts of the gamma. The two integers are the precision, 1, 2, or 4, respectively for double, double double, or quad double; and the verbose level.

phcpy2c3.py2c_set_seed()

  Takes the value of the integer given on input and sets the seed for the random number generators. This fixing of the seed enables reproducible runs.

phcpy2c3.py2c_set_value_of_continuation_parameter()

  Sets the value of a continuation parameter. On input is the index of this continuation parameter, an integer ranging from 1 to 34; and the new value for the continuation parameter. On return is a double with the value of the corresponding parameter.

phcpy2c3.py2c_show_continuation_parameters()

  Shows the current values of the continuation parameters.

phcpy2c3.py2c_solcon_append_dobldobl_solution_string()

  Appends a solution in double double precision to the list of solutions already stored in the container. There are three input parameters: 1) the number of variables; 2) the number of characters in the string; 3) the string representing the solution to append to the list. Returns the failure code, which equals zero if all went well.

phcpy2c3.py2c_solcon_append_multprec_solution_string()

  Appends a solution in arbitrary multiprecision to the list of solutions already stored in the container. There are three input parameters: 1) the number of variables; 2) the number of characters in the string; 3) the string representing the solution to append to the list. Returns the failure code, which equals zero if all went well.

phcpy2c3.py2c_solcon_append_quaddobl_solution_string()

  Appends a solution in quad double precision to the list of solutions already stored in the container. There are three input parameters: 1) the number of variables; 2) the number of characters in the string; 3) the string representing the solution to append to the list. Returns the failure code, which equals zero if all went well.

phcpy2c3.py2c_solcon_append_standard_solution_string()

  Appends a solution in standard double precision to the list of solutions already stored in the container. There are three input parameters: 1) the number of variables; 2) the number of characters in the string; 3) the string representing the solution to append to the list. Returns the failure code, which equals zero if all went well.

phcpy2c3.py2c_solcon_clear_dobldobl_solutions()

  Deallocates the container for solutions in double double precision. Returns the failure code, which equals zero when all went well.

phcpy2c3.py2c_solcon_clear_multprec_solutions()

  Deallocates the container for solutions in arbitrary multiprecision. Returns the failure code, which equals zero when all went well.

phcpy2c3.py2c_solcon_clear_quaddobl_solutions()

  Deallocates the container for solutions in quad double precision. Returns the failure code, which equals zero when all went well.

phcpy2c3.py2c_solcon_clear_standard_solutions()

  Deallocates the container for solutions in standard double precision. Returns the failure code, which equals zero when all went well.

phcpy2c3.py2c_solcon_dobldobl_drop_coordinate_by_index()

  Replaces the solutions in the double double precision container with the same solutions that have their k-th coordinate dropped. There is one input parameter: the index k of the coordinate. On return is the failure code, which equals zero if all went well.

phcpy2c3.py2c_solcon_dobldobl_drop_coordinate_by_name()

  Replaces the solutions in the double double precision container with the same solutions that have their coordinate dropped corresponding to the name in the string s of nc characters long. There are two input parameters, an integer and a string: 1) nc, the number of characters in the string with the name; 2) s, the string with the name of the variable. On return is the failure code, which equals zero if all went well.

phcpy2c3.py2c_solcon_dobldobl_one_affinization()

  Divides every coordinate by the last coordinate of every solution in the container for solutions in double double precision.

phcpy2c3.py2c_solcon_dobldobl_one_homogenization()

  Add one extra coordinate one to every solution in the container for solutions in double double precision.

phcpy2c3.py2c_solcon_length_current_dobldobl_solution_string()

  Returns the number of characters in the string representation of the current double double solution in the container, at the place indicated by the value of the cursor. If this value equals zero, then there is no current solution, and then the length on return equals zero.

phcpy2c3.py2c_solcon_length_current_multprec_solution_string()

  Returns the number of characters in the string representation of the current arbitrary multiprecision solution in the container, at the place indicated by the value of the cursor. If this value equals zero, then there is no current solution, and then the length on return equals zero.

phcpy2c3.py2c_solcon_length_current_quaddobl_solution_string()

  Returns the number of characters in the string representation of the current quad double solution in the container, at the place indicated by the value of the cursor. If this value equals zero, then there is no current solution, and then the length on return equals zero.

phcpy2c3.py2c_solcon_length_current_standard_solution_string()

  Returns the number of characters in the string representation of the current standard double solution in the container, at the place indicated by the value of the cursor. If this value equals zero, then there is no current solution, and then the length on return equals zero.

phcpy2c3.py2c_solcon_length_dobldobl_solution_string()

  On input is the index k to a solution in double double precision, stored in the container. On return is the length of the string representation for that k-th solution in the container.

phcpy2c3.py2c_solcon_length_multprec_solution_string()

  On input is the index k to a solution in arbitrary multiprecision, stored in the container. On return is the length of the string representation for that k-th solution in the container.

phcpy2c3.py2c_solcon_length_quaddobl_solution_string()

  On input is the index k to a solution in quad double precision, stored in the container. On return is the length of the string representation for that k-th solution in the container.

phcpy2c3.py2c_solcon_length_standard_solution_string()

  On input is the index k to a solution in standard double precision, stored in the container. On return is the length of the string representation for that k-th solution in the container.

phcpy2c3.py2c_solcon_move_current_dobldobl_to_next()

  Moves the pointer to the current solution in double double precision to the next solution and returns the value of the cursor. If cursor on return is zero, then either the pointer was null or there is no next solution.

phcpy2c3.py2c_solcon_move_current_multprec_to_next()

  Moves the pointer to the current solution in arbitrary multiprecision to the next solution and returns the value of the cursor. If cursor on return is zero, then either the pointer was null or there is no next solution.

phcpy2c3.py2c_solcon_move_current_quaddobl_to_next()

  Moves the pointer to the current solution in quad double precision to the next solution and returns the value of the cursor. If cursor on return is zero, then either the pointer was null or there is no next solution.

phcpy2c3.py2c_solcon_move_current_standard_to_next()

  Moves the pointer to the current solution in standard double precision to the next solution and returns the value of the cursor. If cursor on return is zero, then either the pointer was null or there is no next solution.

phcpy2c3.py2c_solcon_number_of_dobldobl_solutions()

  Returns the number of solutions in double double precision, as stored in the container.

phcpy2c3.py2c_solcon_number_of_multprec_solutions()

  Returns the number of solutions in arbitrary multiprecision, as stored in the container.

phcpy2c3.py2c_solcon_number_of_quaddobl_solutions()

  Returns the number of solutions in quad double precision, as stored in the container.

phcpy2c3.py2c_solcon_number_of_standard_solutions()

  Returns the number of solutions in standard double precision, as stored in the container.

phcpy2c3.py2c_solcon_open_solution_input_file()

  Prompts the user for the name of the input file for the solutions and opens the input file. All subsequent reading happens from this input. Returns the failure code, which equals zero when all went well.

phcpy2c3.py2c_solcon_quaddobl_drop_coordinate_by_index()

  Replaces the solutions in the quad double precision container with the same solutions that have their k-th coordinate dropped. There is one input parameter: the index k of the coordinate. On return is the failure code, which equals zero if all went well.

phcpy2c3.py2c_solcon_quaddobl_drop_coordinate_by_name()

  Replaces the solutions in the quad double precision container with the same solutions that have their coordinate dropped corresponding to the name in the string s of nc characters long. There are two input parameters, an integer and a string: 1) nc, the number of characters in the string with the name; 2) s, the string with the name of the variable. On return is the failure code, which equals zero if all went well.

phcpy2c3.py2c_solcon_quaddobl_one_affinization()

  Divides every coordinate by the last coordinate of every solution in the container for solutions in quad double precision.

phcpy2c3.py2c_solcon_quaddobl_one_homogenization()

  Add one extra coordinate one to every solution in the container for solutions in double double precision.

phcpy2c3.py2c_solcon_read_dobldobl_solutions()

  Interactive function to read the solutions into the container, in double double precision. Returns the failure code, which is zero when all went well.

phcpy2c3.py2c_solcon_read_dobldobl_solutions_from_file()

  The two input arguments are a number and a string: 1) The number equals the number of characters in the string. 2) The string given on input is the name of a file which contains a solution list to be parsed in double double precision. Solutions are read from file and stored in the container for double double precision solutions. The failure code is returned, which is zero if all went well.

phcpy2c3.py2c_solcon_read_multprec_solutions()

  Interactive function to read the solutions into the container, in arbitrary multiprecision. Returns the failure code, which is zero when all went well.

phcpy2c3.py2c_solcon_read_quaddobl_solutions()

  Interactive function to read the solutions into the container, in quad double precision. Returns the failure code, which is zero when all went well.

phcpy2c3.py2c_solcon_read_quaddobl_solutions_from_file()

  The two input arguments are a number and a string: 1) The number equals the number of characters in the string. 2) The string given on input is the name of a file which contains a solution list to be parsed in quad double precision. Solutions are read from file and stored in the container for quad double precision solutions. The failure code is returned, which is zero if all went well.

phcpy2c3.py2c_solcon_read_standard_solutions()

  Interactive function to read the solutions into the container, in standard double precision. Returns the failure code, which is zero when all went well.

phcpy2c3.py2c_solcon_read_standard_solutions_from_file()

  The two input arguments are a number and a string: 1) The number equals the number of characters in the string. 2) The string given on input is the name of a file which contains a solution list to be parsed in standard double precision. Solutions are read from file and stored in the container for double precision solutions. The failure code is returned, which is zero if all went well.

phcpy2c3.py2c_solcon_retrieve_next_dobldobl_initialize()

  Resets the pointer to the current dobldobl solution in the container to the first solution in the list. On return is the failure code, which equals zero if all went well.

phcpy2c3.py2c_solcon_retrieve_next_multprec_initialize()

  Resets the pointer to the current multprec solution in the container to the first solution in the list. On return is the failure code, which equals zero if all went well.

phcpy2c3.py2c_solcon_retrieve_next_quaddobl_initialize()

  Resets the pointer to the current quaddobl solution in the container to the first solution in the list. On return is the failure code, which equals zero if all went well.

phcpy2c3.py2c_solcon_retrieve_next_standard_initialize()

  Resets the pointer to the current standard solution in the container to the first solution in the list. On return is the failure code, which equals zero if all went well.

phcpy2c3.py2c_solcon_standard_drop_coordinate_by_index()

  Replaces the solutions in the standard double precision container with the same solutions that have their k-th coordinate dropped. There is one input parameter: the index k of the coordinate. On return is the failure code, which equals zero if all went well.

phcpy2c3.py2c_solcon_standard_drop_coordinate_by_name()

  Replaces the solutions in the standard double precision container with the same solutions that have their coordinate dropped corresponding to the name in the string s of nc characters long. There are two input parameters, an integer and a string: 1) nc, the number of characters in the string with the name; 2) s, the string with the name of the variable. On return is the failure code, which equals zero if all went well.

phcpy2c3.py2c_solcon_standard_one_affinization()

  Divides every coordinate by the last coordinate of every solution in the container for solutions in standard double precision.

phcpy2c3.py2c_solcon_standard_one_homogenization()

  Add one extra coordinate one to every solution in the container for solutions in standard double precision.

phcpy2c3.py2c_solcon_write_current_dobldobl_solution_string()

  Writes the current double double solution in the solution container to the string s of n+1 characters. The last character is the end of string symbol. The value of n is given as the one input parameter to this function. On return is the string that contains the string representation of the current solution in standard double precision in the container.

phcpy2c3.py2c_solcon_write_current_multprec_solution_string()

  Writes the current arbitrary multiprecision solution in the solution container to the string s of n+1 characters. The last character is the end of string symbol. The value of n is given as the one input parameter to this function. On return is the string that contains the string representation of the current solution in standard double precision in the container.

phcpy2c3.py2c_solcon_write_current_quaddobl_solution_string()

  Writes the current quad double solution in the solution container to the string s of n+1 characters. The last character is the end of string symbol. The value of n is given as the one input parameter to this function. On return is the string that contains the string representation of the current solution in standard double precision in the container.

phcpy2c3.py2c_solcon_write_current_standard_solution_string()

  Writes the current standard double solution in the solution container to the string s of n+1 characters. The last character is the end of string symbol. The value of n is given as the one input parameter to this function. On return is the string that contains the string representation of the current solution in standard double precision in the container.

phcpy2c3.py2c_solcon_write_dobldobl_solution_string()

  Returns the string representation for the k-th solution stored in double double precision in the container. On input are two integers: 1) the index to the solution; and 2) the number of characters in the string representation for that solution.

phcpy2c3.py2c_solcon_write_dobldobl_solutions()

  Writes the solutions in double double precision to screen. Returns the failure code, which equals zero when all went well.

phcpy2c3.py2c_solcon_write_multprec_solution_string()

  Returns the string representation for the k-th solution stored in arbitrary multiprecision in the container. On input are two integers: 1) the index to the solution; and 2) the number of characters in the string representation for that solution.

phcpy2c3.py2c_solcon_write_multprec_solutions()

  Writes the solutions in arbitrary multiprecision to screen. Returns the failure code, which equals zero when all went well.

phcpy2c3.py2c_solcon_write_quaddobl_solution_string()

  Returns the string representation for the k-th solution stored in quad double precision in the container. On input are two integers: 1) the index to the solution; and 2) the number of characters in the string representation for that solution.

phcpy2c3.py2c_solcon_write_quaddobl_solutions()

  Writes the solutions in quad double precision to screen. Returns the failure code, which equals zero when all went well.

phcpy2c3.py2c_solcon_write_standard_solution_string()

  Returns the string representation for the k-th solution stored in standard double precision in the container. On input are two integers: 1) the index to the solution; and 2) the number of characters in the string representation for that solution.

phcpy2c3.py2c_solcon_write_standard_solutions()

  Writes the solutions in standard double precision to screen. Returns the failure code, which equals zero when all went well.

phcpy2c3.py2c_solve_by_dobldobl_Laurent_homotopy_continuation()

  Tracks the paths defined by the homotopy in double double precision to solve a Laurent system stored in the systems container, starting at the solutions of a stored Laurent start system. On input is one integer: the number of tasks for path tracking. If that input number is zero, then no multitasking is applied. On return is the failure code, which is zero when all went well.

phcpy2c3.py2c_solve_by_dobldobl_homotopy_continuation()

  Tracks the paths defined by the homotopy in double double precision. On input is one integer: the number of tasks for path tracking. If that input number is zero, then no multitasking is applied. On return is the failure code, which is zero when all went well.

phcpy2c3.py2c_solve_by_multprec_homotopy_continuation()

  Tracks the paths defined by the homotopy in arbitrary multiprecision. On input is one integer: the number of decimal places in the precision. On return is the failure code, which is zero when all went well.

phcpy2c3.py2c_solve_by_quaddobl_Laurent_homotopy_continuation()

  Tracks the paths defined by the homotopy in quad double precision to solve a Laurent system stored in the systems container, starting at the solutions of a stored Laurent start system. On input is one integer: the number of tasks for path tracking. If that input number is zero, then no multitasking is applied. On return is the failure code, which is zero when all went well.

phcpy2c3.py2c_solve_by_quaddobl_homotopy_continuation()

  Tracks the paths defined by the homotopy in quad double precision. On input is one integer: the number of tasks for path tracking. If that input number is zero, then no multitasking is applied. On return is the failure code, which is zero when all went well.

phcpy2c3.py2c_solve_by_standard_Laurent_homotopy_continuation()

  Tracks the paths defined by the homotopy in standard double precision to solve a Laurent system stored in the systems container, starting at the solutions of a stored Laurent start system. On input is one integer: the number of tasks for path tracking. If that input number is zero, then no multitasking is applied. On return is the failure code, which is zero when all went well.

phcpy2c3.py2c_solve_by_standard_homotopy_continuation()

  Tracks the paths defined by the homotopy in standard double precision. On input is one integer: the number of tasks for path tracking. If that input number is zero, then no multitasking is applied. On return is the failure code, which is zero when all went well.

phcpy2c3.py2c_solve_dobldobl_Laurent_system()

  Calls the blackbox solver on the system stored in the container for Laurent systems with coefficients in double double precision. Three integers are expected on input: 1) a boolean flag silent: if 1, then no intermediate output about the root counts is printed, if 0, then the solver is verbose; 2) the number of tasks: if 0, then no multitasking is applied, otherwise as many tasks as the number will run; and 3) the verbose level. On return, the container for solutions in double double precision contains the solutions to the system in the double double Laurent systems container.

phcpy2c3.py2c_solve_dobldobl_system()

  Calls the blackbox solver on the system stored in the container for systems with coefficients in double double precision. Three integers are expected on input: 1) a boolean flag if silent: if 1, then no intermediate output about the root counts is printed, if 0, then the solver is verbose; 2) the number of tasks. If that number is zero, then no multitasking is applied; and 3) the verbose level. On return, the container for solutions in double double precision contains the solutions to the system in the dobldobl systems container.

phcpy2c3.py2c_solve_quaddobl_Laurent_system()

  Calls the blackbox solver on the system stored in the container for Laurent systems with coefficients in quad double precision. Three integers are expected on input: 1) a boolean flag silent: if 1, then no intermediate output about the root counts is printed, if 0, then the solver is verbose; 2) the number of tasks: if 0, then no multitasking is applied, otherwise as many tasks as the number will run; and 3) the verbose level. On return, the container for solutions in quad double precision contains the solutions to the system in the quad double Laurent systems container.

phcpy2c3.py2c_solve_quaddobl_system()

  Calls the blackbox solver on the system stored in the container for systems with coefficients in quad double precision. Threee integers are expected on input: 1) a boolean flag if silent: if 1, then no intermediate output about the root counts is printed, if 0, then the solver is verbose; 2) the number of tasks. If that number is zero, then no multitasking is applied; and 3) the verbose level. On return, the container for solutions in quad double precision contains the solutions to the system in the quaddobl systems container.

phcpy2c3.py2c_solve_standard_Laurent_system()

  Calls the blackbox solver on the system stored in the container for Laurent systems with coefficients in standard double precision. Four integers are expected on input: 1) a boolean flag silent: if 1, then no intermediate output about the root counts is printed, if 0, then the solver is verbose; 2) the number of tasks: if 0, then no multitasking is applied, otherwise as many tasks as the number will run; 3) a flag to focus on mixed volumes and polyhedral homotopies, if 1, the no degree bounds will be computed, as when the system is genuinely Laurent with negative exponents; and 4) the verbose level. On return, the container for solutions in standard double precision contains the solutions to the system in the standard Laurent systems container.

phcpy2c3.py2c_solve_standard_system()

  Calls the blackbox solver on the system stored in the container for systems with coefficients in standard double precision. Four integers are expected on input: 1) a boolean flag if silent: if 1, then no intermediate output about the root counts is printed, if 0, then the solver is verbose; 2) the number of tasks. If that number is zero, then no multitasking is applied; 3) a flag to focus on mixed volumes and polyhedral homotopies, if 1, then no degree bounds will be computed; and 4) the verbose level. On return, the container for solutions in standard double precision contains the solutions to the system in the standard systems container.

phcpy2c3.py2c_standard_Laurent_cascade_homotopy()

  Creates a homotopy in standard double precision using the stored Laurent systems to go one level down the cascade, removing one slice. On return is the failure code, which equals zero if all went well.

phcpy2c3.py2c_standard_Newton_Laurent_step()

  Applies one Newton step in standard double precision to the Laurent system in the standard Laurent systems container and to the solutions in the container. On return is the failure code, which equals zero if all went well.

phcpy2c3.py2c_standard_Newton_power_series()

  Given in the systems container a polynomial system with coefficients in standard double precision, and in the standard systems pool the leading terms of the power series, this function runs Newton’s method to compute power series solutions of the system in the container, in standard double precision. There are four integers on input: 1) the index of the series parameter; 2) the maximal degree of the series; 3) the number of Newton steps to be done on each solution; 4) a 0/1-flag to indicate whether additional diagnostic output needs to be written to screen. On return is the failure code, which equals zero if all went well.

phcpy2c3.py2c_standard_Newton_series()

  Given in the systems container a polynomial system with coefficients in standard double precision, and in the solutions container the leading coefficients of the power series, this function runs Newton’s method to compute power series solutions of the system in the container, in standard double precision. There are four integers on input: 1) the index of the series parameter; 2) the maximal degree of the series; 3) the number of Newton steps to be done on each solution; 4) a 0/1-flag to indicate whether additional diagnostic output needs to be written to screen. On return is the failure code, which equals zero if all went well.

phcpy2c3.py2c_standard_Newton_step()

  Applies one Newton step in standard double precision to the system in the standard systems container and to the solutions in the container. On return is the failure code, which equals zero if all went well.

phcpy2c3.py2c_standard_Pade_approximant()

  Given in the systems container a polynomial system with coefficients in standard double precision, and in the solutions container the leading coefficients of the power series, this function runs Newton’s method to compute power series solutions of the system in the container, in standard double precision, followed by the construction of the Pade approximants, for each solution. There are five integers on input: 1) the index of the series parameter; 2) the degree of the numerator of the Pade approximant; 3) the degree of the denominator of the Pade approximant; 4) the number of Newton steps to be done on each solution; 5) a 0/1-flag to indicate whether additional diagnostic output needs to be written to screen. The Pade approximants are stored in the standard systems pool, numerators in the odd indexed entries and denominators in the entries with even index in each system. On return is the failure code, which equals zero if all went well.

phcpy2c3.py2c_standard_cascade_homotopy()

  Creates a homotopy in standard double precision using the stored systems to go one level down the cascade, removing one slice. On return is the failure code, which equals zero if all went well.

phcpy2c3.py2c_standard_collapse_diagonal()

  Eliminates the extrinsic diagonal for the system and solutions in the containers for standard doubles. On input are two integers: 1) k, the current number of slack variables in the embedding; 2) d, the number of slack variables to add to the final embedding. The system in the container has its diagonal eliminated and is embedded with k+d slack variables. The solutions corresponding to this system are in the solutions container. On return is the failure code, which equals zero if all went well.

phcpy2c3.py2c_standard_condition_report()

  For the system and solutions in the containers in double precision, computes a condition report. On input are the following: 1) maximum number of Newton iterations per solution; 2) tolerance on the residual; 3) tolerance on the forward error; 4) tolerance on the inverse condition number for singularities; 5) a string with the name of the output file, this string may be empty if no output to file is needed; 6) a verbose flag, either 1 or 0. On return are the counts of number of solutions that are regular, singular, real, complex, clustered, or failures; along with the frequency tables for the forward errors, residuals and estimates for the inverse condition numbers.

phcpy2c3.py2c_standard_crude_tracker()

  A crude tracker appends the end point of a path directly to the solutions container, without refinement or postprocessing. Tracking happens in standard double precision. On entry is the verbose parameter which is 1 or 0. If 1, then the solution vectors are written to screen, otherwise the crude tracker stays mute. On return is the failure code, which is zero when all went well. The requirement is that the target system, start system, and start solutions in standard double precision have been initialized in the containers.

phcpy2c3.py2c_standard_deflate()

  Applies deflation in standard double precision to the system and the solutions stored in the containers. There are five input parameters, two integers and three doubles: (1) maxitr : the maximum number of iterations per root, (2) maxdef : the maximum number of deflations per root, (3) tolerr : tolerance on the forward error on each root, (4) tolres : tolerance on the backward error on each root, (5) tolres : tolerance on the numerical rank of the Jacobian matrices. On return is the failure code, which equals zero if all went well.

phcpy2c3.py2c_standard_diagonal_cascade_solutions()

  Makes the start solutions to start the cascade homotopy to intersect two solution sets of dimensions a and b, where a >= b, in standard double precision. The dimensions a and b are given as input parameters. The systems stored as target and start system in the container define the witness sets for these two solution sets. On return is the failure code, which equals zero when all went well.

phcpy2c3.py2c_standard_diagonal_homotopy()

  Creates a diagonal homotopy to intersect two solution sets of dimensions a and b respectively, where a >= b. The two input parameters are values for a and b. The systems stored as target and start system in the container, in standard double precision, define the witness sets for these two solution sets.

phcpy2c3.py2c_standard_laursys_solve()

  Runs the cascades of homotopies on the Laurent polynomial system in the standard systems container. Runs in standard double precision. On input are five integers : 1) nbtasks equals the number of tasks for multitasking, 2) topdim is the top dimension to start the homotopy cascades, 3) filter is a 0 or 1 flag to filter the witness supersets, 4) factor is a 0 or 1 flag to factor the witness sets, 5) verbose is a flag for intermediate output.

phcpy2c3.py2c_standard_multiplicity_structure()

  Computes the multiplicity structure in standard double precision. Required is the presence of a polynomial system in the standard systems container and a solution in the standard solutions container. The input parameters are two integers and one double: order : the maximum differentiation order, verbose : 1 for verbose, 0 for silent, and tol : tolerance on the numerical rank. On return is a tuple: the multiplicity and the values of the Hilbert function.

phcpy2c3.py2c_standard_polysys_solve()

  Runs the cascades of homotopies on the polynomial system in the standard systems container. Runs in standard double precision. On input are five integers : 1) nbtasks equals the number of tasks for multitasking, 2) topdim is the top dimension to start the homotopy cascades, 3) filter is a 0 or 1 flag to filter the witness supersets, 4) factor is a 0 or 1 flag to factor the witness sets, 5) verbose is a flag for intermediate output.

phcpy2c3.py2c_standard_witset_of_Laurent_hypersurface()

  Given in the string p of nc characters a polynomial in nv variables, terminated by a semicolon, the systems and solutions container in standard double precision on return contain a witness set for the hypersurface defined by the Laurent polynomial in p. On entry are two integers and one string, in the following order: 1) nv, the number of variables of the polynomials; 2) nc, the number of characters in the string p; 3) p, string representation of a Laurent polynomial in several variables, terminates with a semicolon. On return is the failure code, which equals zero if all went well.

phcpy2c3.py2c_standard_witset_of_hypersurface()

  Given in the string p of nc characters a polynomial in nv variables, terminated by a semicolon, the systems and solutions container in standard double precision on return contain a witness set for the hypersurface defined by the ordinary polynomial in p. On entry are two integers and one string, in the following order: 1) nv, the number of variables of the polynomials; 2) nc, the number of characters in the string p; 3) p, string representation of an ordinary polynomial in several variables, terminates with a semicolon. On return is the failure code, which equals zero if all went well.

phcpy2c3.py2c_swap_symbols_for_dobldobl_Laurent_witness_set()

  Permutes the slack variables in the Laurent system with double double precision coefficients and its corresponding solutions in the containers so the slack variables appear at the end. On input are two integers: the total number of variables; and the number of slack variables, or the dimension of the set. This permutation is necessary to consider the system and solutions stored in containers as a witness set.

phcpy2c3.py2c_swap_symbols_for_dobldobl_witness_set()

  Permutes the slack variables in the polynomial system with double double precision coefficients and its corresponding solutions in the containers so the slack variables appear at the end. On input are two integers: the total number of variables; and the number of slack variables, or the dimension of the set. This permutation is necessary to consider the system and solutions stored in containers as a witness set.

phcpy2c3.py2c_swap_symbols_for_quaddobl_Laurent_witness_set()

  Permutes the slack variables in the Laurent system with quad double precision coefficients and its corresponding solutions in the containers so the slack variables appear at the end. On input are two integers: the total number of variables; and the number of slack variables, or the dimension of the set. This permutation is necessary to consider the system and solutions stored in containers as a witness set.

phcpy2c3.py2c_swap_symbols_for_quaddobl_witness_set()

  Permutes the slack variables in the polynomial system with quad double precision coefficients and its corresponding solutions in the containers so the slack variables appear at the end. On input are two integers: the total number of variables; and the number of slack variables, or the dimension of the set. This permutation is necessary to consider the system and solutions stored in containers as a witness set.

phcpy2c3.py2c_swap_symbols_for_standard_Laurent_witness_set()

  Permutes the slack variables in the Laurent system with standard double precision coefficients and its corresponding solutions in the containers so the slack variables appear at the end. On input are two integers: the total number of variables; and the number of slack variables, or the dimension of the set. This permutation is necessary to consider the system and solutions stored in containers as a witness set.

phcpy2c3.py2c_swap_symbols_for_standard_witness_set()

  Permutes the slack variables in the polynomial system with standard double precision coefficients and its corresponding solutions in the containers so the slack variables appear at the end. On input are two integers: the total number of variables; and the number of slack variables, or the dimension of the set. This permutation is necessary to consider the system and solutions stored in containers as a witness set.

phcpy2c3.py2c_sweep_clear_definitions()

  Clears the definitions in the sweep homotopy.

phcpy2c3.py2c_sweep_define_parameters_numerically()

  Defines the indices to the variables that serve as parameters numerically, that is: via integer indices. On entry are three integer numbers and a string. The string is a string representation of a Python list of integers, The three integers are the number of equations, the number of variables, and the number of parameters. The number of variables m includes the number of parameters. Then there should be as many as m indices in the list of integers to define which of the variables are parameters.

phcpy2c3.py2c_sweep_define_parameters_symbolically()

  Defines the indices to the variables that serve as parameters symbolically, that is, as names of variables. For this to work, the symbol table must be initialized. On entry are four integer numbers and a string. The four integers are the number of equations, the number of variables, the number of parameters (the number of variables m includes the number of parameters), and the number of characters in the string. The string contains the names of the parameters, separated by one comma. For this to work, the symbol table must be initialized, e.g.: via the reading of a polynomial system.

phcpy2c3.py2c_sweep_dobldobl_complex_run()

  Starts the trackers in a complex convex parameter homotopy, in double double precision, where the indices to the parameters, start and target values are already defined. Moreover, the containers of systems and solutions in double double precision have been initialized with a parametric systems and start solutions. The first input parameter is 0, 1, or 2, for respectively a randomly generated gamma (0), or no gamma (1), or a user given gamma with real and imaginary parts given in 2 pointers to doubles.

phcpy2c3.py2c_sweep_dobldobl_real_run()

  There are no input arguments to this routine. Starts a sweep with a natural parameter in a family of n equations in n+1 variables, where the last variable is the artificial parameter s that moves the one natural parameter from a start to target value. The last equation is of the form (1-s)*(A - v[0]) + s*(A - v[1]), where A is the natural parameter, going from the start value v[0] to the target value v[1]. This family must be stored in the systems container in double double precision and the corresponding start solutions in the dobldobl solutions container, where every solution has the value v[0] for the A variable. The sweep stops when s reaches the value v[1], or when a singularity is encountered on the path.

phcpy2c3.py2c_sweep_get_dobldobl_start()

  Gets the start values for the parameters in double double precision, giving on input the number n of doubles that need to be returned. On return will be n doubles, for the consecutive real and imaginary parts for the start values of all parameters, stored in the string representation of a Python list of doubles.

phcpy2c3.py2c_sweep_get_dobldobl_target()

  Gets the target values for the parameters in double double precision, giving on input the number n of doubles that need to be returned. On return will be n doubles, for the consecutive real and imaginary parts for the target values of all parameters, stored in the string representation of a Python list of doubles.

phcpy2c3.py2c_sweep_get_indices_numerically()

  Returns the indices of the variables that are parameters, as the string representation of a Python list of integers.

phcpy2c3.py2c_sweep_get_indices_symbolically()

  Returns a string with the names of the parameters, each separated by one space.

phcpy2c3.py2c_sweep_get_number_of_equations()

  Returns the number of equations in the sweep homotopy.

phcpy2c3.py2c_sweep_get_number_of_parameters()

  Returns the number of parameters in the sweep homotopy.

phcpy2c3.py2c_sweep_get_number_of_variables()

  Returns the number of variables in the sweep homotopy.

phcpy2c3.py2c_sweep_get_quaddobl_start()

  Gets the start values for the parameters in quad double precision, giving on input the number n of doubles that need to be returned. On return will be n doubles, for the consecutive real and imaginary parts for the start values of all parameters, stored in the string representation of a Python list of doubles.

phcpy2c3.py2c_sweep_get_quaddobl_target()

  Returns the target values for the parameters in quad double precision, giving on input the number n of doubles that need to be returned. On return will be n doubles, for the consecutive real and imaginary parts for the target values of all parameters, stored in the string representation of a Python list of doubles.

phcpy2c3.py2c_sweep_get_standard_start()

  Gets the start values for the parameters in standard double precision, giving on input the number n of doubles that need to be returned. On return will be n doubles, for the consecutive real and imaginary parts for the start values of all parameters, stored in the string representation of a Python list of doubles.

phcpy2c3.py2c_sweep_get_standard_target()

  Gets the target values for the parameters in standard double precision, giving on input the number n of doubles that need to be returned. On return will be n doubles, for the consecutive real and imaginary parts for the target values of all parameters, stored in the string representation of a Python list of doubles.

phcpy2c3.py2c_sweep_quaddobl_complex_run()

  Starts the trackers in a complex convex parameter homotopy, in quad double precision, where the indices to the parameters, start and target values are already defined. Moreover, the containers of systems and solutions in quad double precision have been initialized with a parametric systems and start solutions. The first input parameter is 0, 1, or 2, for respectively a randomly generated gamma (0), or no gamma (1), or a user given gamma with real and imaginary parts given in 2 pointers to doubles.

phcpy2c3.py2c_sweep_quaddobl_real_run()

  There are no input arguments to this routine. Starts a sweep with a natural parameter in a family of n equations in n+1 variables, where the last variable is the artificial parameter s that moves the one natural parameter from a start to target value. The last equation is of the form (1-s)*(A - v[0]) + s*(A - v[1]), where A is the natural parameter, going from the start value v[0] to the target value v[1]. This family must be stored in the systems container in quad double precision and the corresponding start solutions in the quaddobl solutions container, where every solution has the value v[0] for the A variable. The sweep stops when s reaches the value v[1], or when a singularity is encountered on the path.

phcpy2c3.py2c_sweep_set_dobldobl_start()

  Sets the start values for the m parameters in double double precision, giving on input an integer m and 4*m doubles, with the consecutive real and imaginary parts for the start values of all m parameters.

phcpy2c3.py2c_sweep_set_dobldobl_target()

  Sets the target values for the m parameters in double double precision, giving on input an integer m and 4*m doubles, with the consecutive real and imaginary parts for the target values of all m parameters.

phcpy2c3.py2c_sweep_set_quaddobl_start()

  Sets the start values for the m parameters in quad double precision, giving on input an integer m and 8*m doubles, with the consecutive real and imaginary parts for the start values of all m parameters.

phcpy2c3.py2c_sweep_set_quaddobl_target()

  Sets the target values for the m parameters in quad double precision, giving on input an integer m and 8*m doubles, with the consecutive real and imaginary parts for the target values of all m parameters.

phcpy2c3.py2c_sweep_set_standard_start()

  Sets the start values for the m parameters in standard double precision, giving on input an integer m and 2*m doubles, with the consecutive real and imaginary parts for the start values of all m parameters. The doubles are given in a string representation of a Python list of doubles.

phcpy2c3.py2c_sweep_set_standard_target()

  Sets the target values for the m parameters in standard double precision, giving on input an integer m and 2*m doubles, with the consecutive real and imaginary parts for the target values of all m parameters.

phcpy2c3.py2c_sweep_standard_complex_run()

  Starts the trackers in a complex convex parameter homotopy, in standard double precision, where the indices to the parameters, start and target values are already defined. Moreover, the containers of systems and solutions in standard double precision have been initialized with a parametric systems and start solutions. The first input parameter is 0, 1, or 2, for respectively a randomly generated gamma (0), or no gamma (1), or a user given gamma with real and imaginary parts given in 2 pointers to doubles.

phcpy2c3.py2c_sweep_standard_real_run()

  There are no input arguments to this routine. Starts a sweep with a natural parameter in a family of n equations in n+1 variables, where the last variable is the artificial parameter s that moves the one natural parameter from a start to target value. The last equation is of the form (1-s)*(A - v[0]) + s*(A - v[1]), where A is the natural parameter, going from the start value v[0] to the target value v[1]. This family must be stored in the systems container in standard double precision and the corresponding start solutions in the standard solutions container, where every solution has the value v[0] for the A variable. The sweep stops when s reaches the value v[1], or when a singularity is encountered on the path.

phcpy2c3.py2c_syscon_add_symbol()

  Adds a symbol to the table, with name given in the string, where the number of characters in the name equals the first integer argument. The second input parameter is the string. This symbol represents the last variable added in the homogeneous coordinate transformation.

phcpy2c3.py2c_syscon_clear_dobldobl_Laurent_system()

  Deallocates the container for Laurent polynomial systems with coefficients in double double precision.

phcpy2c3.py2c_syscon_clear_dobldobl_system()

  Deallocates the container for polynomial systems with coefficients in double double precision.

phcpy2c3.py2c_syscon_clear_multprec_Laurent_system()

  Deallocates the container for Laurent polynomial systems with coefficients in arbitrary multiprecision.

phcpy2c3.py2c_syscon_clear_multprec_system()

  Deallocates the container for polynomial systems with coefficients in arbitrary multiprecision.

phcpy2c3.py2c_syscon_clear_quaddobl_Laurent_system()

  Deallocates the container for Laurent polynomial systems with coefficients in quad double precision.

phcpy2c3.py2c_syscon_clear_quaddobl_system()

  Deallocates the container for polynomial systems with coefficients in quad double precision.

phcpy2c3.py2c_syscon_clear_standard_Laurent_system()

  Deallocates the container for Laurent polynomial systems with coefficients in standard double precision.

phcpy2c3.py2c_syscon_clear_standard_system()

  Deallocates the container for polynomial systems with coefficients in standard double precision.

phcpy2c3.py2c_syscon_clear_symbol_table()

  Clears the symbol table.

phcpy2c3.py2c_syscon_degree_of_dobldobl_polynomial()

  Returns the degree of the k-th polynomial in the container for polynomials with coefficients in double double precision. The index k of the polynomial is the one input argument.

phcpy2c3.py2c_syscon_degree_of_multprec_polynomial()

  Returns the degree of the k-th polynomial in the container for polynomials with coefficients in arbitrary multiprecision. The index k of the polynomial is the one input argument.

phcpy2c3.py2c_syscon_degree_of_quaddobl_polynomial()

  Returns the degree of the k-th polynomial in the container for polynomials with coefficients in quad double precision. The index k of the polynomial is the one input argument.

phcpy2c3.py2c_syscon_degree_of_standard_polynomial()

  Returns the degree of the k-th polynomial in the container for polynomials with coefficients in standard double precision. The index k of the polynomial is the one input argument.

phcpy2c3.py2c_syscon_dobldobl_Laurent_drop_variable_by_index()

  Replaces the Laurent system in the double double precision container with the same Laurent system that has its k-th variable dropped. The index k of the variable is given as an input parameter. On return is the failure code, which equals zero if all went well.

phcpy2c3.py2c_syscon_dobldobl_Laurent_drop_variable_by_name()

  Replaces the Laurent system in the double double precision container with the same Laurent system that have that variable dropped corresponding to the name in the string s of nc characters long. The function has two input parameters, an integer and a string: 1) nc, the number of characters in the string with the name; 2) s, a string that holds the name of the variable. On return is the failure code, which equals zero if all went well.

phcpy2c3.py2c_syscon_dobldobl_drop_variable_by_index()

  Replaces the system in the double double precision container with the same system that has its k-th variable dropped. The index k of the variable is given as an input parameter. On return is the failure code, which equals zero if all went well.

phcpy2c3.py2c_syscon_dobldobl_drop_variable_by_name()

  Replaces the system in the double double precision container with the same system that have that variable dropped corresponding to the name in the string s of nc characters long. The function has two input parameters, an integer and a string: 1) nc, the number of characters in the string with the name; 2) s, a string that holds the name of the variable. On return is the failure code, which equals zero if all went well.

phcpy2c3.py2c_syscon_dobldobl_one_affinization()

  Replaces the system in the double double precision container by its transformation to affine coordinates, substituting the value of the last coordinate by one and removing the last equation.

phcpy2c3.py2c_syscon_dobldobl_one_homogenization()

  Replaces the system in the double double precision container with its transformation in 1-homogeneous coordinates. There is one integer on input. If 0, then a random linear equation is added, otherwise, the linear equation z0 - 1 = 0 is added, where z0 is the extra homogeneous coordinate.

phcpy2c3.py2c_syscon_dobldobl_random_system()

  Places in the systems container a random polynomial system with coefficients in double double precision. There are five integers as input parameters: 1) n, the number of polynomials and variables; 2) m, the number of monomials per equation; 3) d, the largest degree of each monomial; 4) c, the type of coefficient: 0 if on the complex unit circle, 1, if all coefficients are one, 2, if all coefficients are random floats in [-1,+1]; 5) neq, the number of polynomials in the system.

phcpy2c3.py2c_syscon_initialize_number_of_dobldobl_Laurentials()

  Initializes the container for Laurent polynomials with coefficients in double double precision. The input argument is an integer, the number of polynomials in the container. The failure code is returned, which equals zero if all went well.

phcpy2c3.py2c_syscon_initialize_number_of_dobldobl_polynomials()

  Initializes the container for polynomials with coefficients in double double precision. The input argument is an integer, the number of polynomials in the container. The failure code is returned, which equals zero if all went well.

phcpy2c3.py2c_syscon_initialize_number_of_multprec_Laurentials()

  Initializes the container for Laurent polynomials with coefficients in arbitrary multiprecision. The input argument is an integer, the number of polynomials in the container. The failure code is returned, which equals zero if all went well.

phcpy2c3.py2c_syscon_initialize_number_of_multprec_polynomials()

  Initializes the container for polynomials with coefficients in arbitrary multiprecision. The input argument is an integer, the number of polynomials in the container. The failure code is returned, which equals zero if all went well.

phcpy2c3.py2c_syscon_initialize_number_of_quaddobl_Laurentials()

  Initializes the container for Laurent polynomials with coefficients in quad double precision. The input argument is an integer, the number of polynomials in the container. The failure code is returned, which equals zero if all went well.

phcpy2c3.py2c_syscon_initialize_number_of_quaddobl_polynomials()

  Initializes the container for polynomials with coefficients in quad double precision. The input argument is an integer, the number of polynomials in the container. The failure code is returned, which equals zero if all went well.

phcpy2c3.py2c_syscon_initialize_number_of_standard_Laurentials()

  Initializes the container for Laurent polynomials with coefficients in standard double precision. The input argument is an integer, the number of polynomials in the container. The failure code is returned, which equals zero if all went well.

phcpy2c3.py2c_syscon_initialize_number_of_standard_polynomials()

  Initializes the container for polynomials with coefficients in standard double precision. The input argument is an integer, the number of polynomials in the container. The failure code is returned, which equals zero if all went well.

phcpy2c3.py2c_syscon_load_dobldobl_Laurential()

  Returns the k-th polynomial in the Laurent systems container with double double complex coefficients as a string. The value for k is in the one integer parameter of this function.

phcpy2c3.py2c_syscon_load_dobldobl_polynomial()

  Returns the k-th polynomial in the systems container with double double complex coefficients as a string. The value for k is in the one integer parameter of this function.

phcpy2c3.py2c_syscon_load_multprec_Laurential()

  Returns the k-th polynomial in the Laurent systems container with arbitrary multiprecision complex coefficients as a string. The value for k is in the one integer parameter of this function.

phcpy2c3.py2c_syscon_load_multprec_polynomial()

  Returns the k-th polynomial in the systems container with arbitrary multiprecision complex coefficients as a string. The value for k is in the one integer parameter of this function.

phcpy2c3.py2c_syscon_load_quaddobl_Laurential()

  Returns the k-th polynomial in the Laurent systems container with quad double complex coefficients as a string. The value for k is in the one integer parameter of this function.

phcpy2c3.py2c_syscon_load_quaddobl_polynomial()

  Returns the k-th polynomial in the systems container with quad double complex coefficients as a string. The value for k is in the one integer parameter of this function.

phcpy2c3.py2c_syscon_load_standard_Laurential()

  Returns the k-th polynomial in the Laurent systems container with standard double complex coefficients as a string. The value for k is in the one integer parameter of this function.

phcpy2c3.py2c_syscon_load_standard_polynomial()

  Returns the k-th polynomial in the systems container with standard double complex coefficients as a string. The value for k is in the one integer parameter of this function.

phcpy2c3.py2c_syscon_number_of_Laurent_terms()

  Returns the number of terms in the k-th Laurent polynomial stored in the container for Laurent polynomials systems with coefficients in standard double precision. The input parameter k is the index of the polynomial k.

phcpy2c3.py2c_syscon_number_of_dobldobl_Laurentials()

  Returns the number of Laurent polynomials with coefficients in double double precision as stored in the systems container.

phcpy2c3.py2c_syscon_number_of_dobldobl_polynomials()

  Returns the number of polynomials with coefficients in double double precision as stored in the systems container.

phcpy2c3.py2c_syscon_number_of_multprec_Laurentials()

  Returns the number of Laurent polynomials with coefficients in arbitrary multiprecision as stored in the systems container.

phcpy2c3.py2c_syscon_number_of_multprec_polynomials()

  Returns the number of polynomials with coefficients in arbitrary multiprecision as stored in the systems container.

phcpy2c3.py2c_syscon_number_of_quaddobl_Laurentials()

  Returns the number of Laurent polynomials with coefficients in quad double precision as stored in the systems container.

phcpy2c3.py2c_syscon_number_of_quaddobl_polynomials()

  Returns the number of polynomials with coefficients in quad double precision as stored in the systems container.

phcpy2c3.py2c_syscon_number_of_standard_Laurentials()

  Returns the number of Laurent polynomials with coefficients in standard double precision as stored in the systems container.

phcpy2c3.py2c_syscon_number_of_standard_polynomials()

  Returns the number of polynomials with coefficients in standard double precision as stored in the systems container.

phcpy2c3.py2c_syscon_number_of_symbols()

  Returns the number of symbols in the symbol table.

phcpy2c3.py2c_syscon_number_of_terms()

  Returns the number of terms in the k-th polynomial stored in the container for systems with coefficients in standard double precision. The input parameter k is the index of the polynomial k.

phcpy2c3.py2c_syscon_quaddobl_Laurent_drop_variable_by_index()

  Replaces the Laurent system in the quad double precision container with the same Laurent system that has its k-th variable dropped. The index k of the variable is given as an input parameter. On return is the failure code, which equals zero if all went well.

phcpy2c3.py2c_syscon_quaddobl_Laurent_drop_variable_by_name()

  Replaces the Laurent system in the quad double precision container with the same Laurent system that have that variable dropped corresponding to the name in the string s of nc characters long. The function has two input parameters, an integer and a string: 1) nc, the number of characters in the string with the name; 2) s, a string that holds the name of the variable. On return is the failure code, which equals zero if all went well.

phcpy2c3.py2c_syscon_quaddobl_drop_variable_by_index()

  Replaces the system in the quad double precision container with the same system that has its k-th variable dropped. The index k of the variable is given as an input parameter. On return is the failure code, which equals zero if all went well.

phcpy2c3.py2c_syscon_quaddobl_drop_variable_by_name()

  Replaces the system in the quad double precision container with the same system that have that variable dropped corresponding to the name in the string s of nc characters long. The function has two input parameters, an integer and a string: 1) nc, the number of characters in the string with the name; 2) s, a string that holds the name of the variable. On return is the failure code, which equals zero if all went well.

phcpy2c3.py2c_syscon_quaddobl_one_affinization()

  Replaces the system in the quad double precision container by its transformation to affine coordinates, substituting the value of the last coordinate by one and removing the last equation.

phcpy2c3.py2c_syscon_quaddobl_one_homogenization()

  Replaces the system in the quad double precision container with its transformation in 1-homogeneous coordinates. There is one integer on input. If 0, then a random linear equation is added, otherwise, the linear equation z0 - 1 = 0 is added, where z0 is the extra homogeneous coordinate.

phcpy2c3.py2c_syscon_quaddobl_random_system()

  Places in the systems container a random polynomial system with coefficients in quad double precision. There are five integers as input parameters: 1) n, the number of polynomials and variables; 2) m, the number of monomials per equation; 3) d, the largest degree of each monomial; 4) c, the type of coefficient: 0 if on the complex unit circle, 1, if all coefficients are one, 2, if all coefficients are random floats in [-1,+1]; 5) neq, the number of polynomials in the system.

phcpy2c3.py2c_syscon_random_system()

  Places in the systems container a random polynomial system with coefficients in standard double precision. There are five integers as input parameters: 1) n, the number of polynomials and variables; 2) m, the number of monomials per equation; 3) d, the largest degree of each monomial; 4) c, the type of coefficient: 0 if on the complex unit circle, 1, if all coefficients are one, 2, if all coefficients are random floats in [-1,+1]; 5) neq, the number of polynomials in the system.

phcpy2c3.py2c_syscon_read_dobldobl_Laurent_system()

  Interactive procedure to read a Laurent polynomial system with coefficients in double double precision. The system will be placed in the dobldobl Laurent systems container. The failure code is returned, which equals zero if all went well.

phcpy2c3.py2c_syscon_read_dobldobl_system()

  Interactive procedure to read a polynomial system with coefficients in double double precision. The system will be placed in the dobldobl systems container. The failure code is returned, which equals zero if all went well.

phcpy2c3.py2c_syscon_read_multprec_Laurent_system()

  Interactive procedure to read a Laurent polynomial system with coefficients in arbitrary multiprecision. The one input parameter is an integer, the number of decimal places in the working precision. The system will be placed in the multprec Laurent systems container. The failure code is returned, which equals zero if all went well.

phcpy2c3.py2c_syscon_read_multprec_system()

  Interactive procedure to read a polynomial system with coefficients in arbitrary multiprecision. The one input parameter is an integer, the number of decimal places in the working precision. The system will be placed in the multprec systems container. The failure code is returned, which equals zero if all went well.

phcpy2c3.py2c_syscon_read_quaddobl_Laurent_system()

  Interactive procedure to read a Laurent polynomial system with coefficients in quad double precision. The system will be placed in the quaddobl Laurent systems container. The failure code is returned, which equals zero if all went well.

phcpy2c3.py2c_syscon_read_quaddobl_system()

  Interactive procedure to read a polynomial system with coefficients in quad double precision. The system will be placed in the quaddobl systems container. The failure code is returned, which equals zero if all went well.

phcpy2c3.py2c_syscon_read_standard_Laurent_system()

  Interactive procedure to read a Laurent polynomial system with coefficients in standard double precision. The system will be placed in the standard Laurent systems container. The failure code is returned, which equals zero if all went well.

phcpy2c3.py2c_syscon_read_standard_system()

  Interactive procedure to read a polynomial system with coefficients in standard double precision. The system will be placed in the standard systems container. The failure code is returned, which equals zero if all went well.

phcpy2c3.py2c_syscon_remove_symbol_name()

  Removes a symbol, given by name, from the symbol table. On input are two arguments: 1) an integer, as the number of characters in the name; 2) a string of characters with the name of the symbol. The failure code is returned, which equals zero when all went well.

phcpy2c3.py2c_syscon_retrieve_term()

  Retrieves one term of a polynomial with coefficients in standard double precision, that is stored in the systems container. On return is the failure code, which equals zero if all went well.

phcpy2c3.py2c_syscon_standard_Laurent_drop_variable_by_index()

  Replaces the Laurent system in the standard double precision container with the same Laurent system that has its k-th variable dropped. The index k of the variable is given as an input parameter. On return is the failure code, which equals zero if all went well.

phcpy2c3.py2c_syscon_standard_Laurent_drop_variable_by_name()

  Replaces the Laurent system in the standard double precision container with the same Laurent system that have that variable dropped corresponding to the name in the string s of nc characters long. The function has two input parameters, an integer and a string: 1) nc, the number of characters in the string with the name; 2) s, a string that holds the name of the variable. On return is the failure code, which equals zero if all went well.

phcpy2c3.py2c_syscon_standard_drop_variable_by_index()

  Replaces the system in the standard double precision container with the same system that has its k-th variable dropped. The index k of the variable is given as an input parameter. On return is the failure code, which equals zero if all went well.

phcpy2c3.py2c_syscon_standard_drop_variable_by_name()

  Replaces the system in the standard double precision container with the same system that have that variable dropped corresponding to the name in the string s of nc characters long. The function has two input parameters, an integer and a string: 1) nc, the number of characters in the string with the name; 2) s, a string that holds the name of the variable. On return is the failure code, which equals zero if all went well.

phcpy2c3.py2c_syscon_standard_one_affinization()

  Replaces the system in the standard double precision container by its transformation to affine coordinates, substituting the value of the last coordinate by one and removing the last equation.

phcpy2c3.py2c_syscon_standard_one_homogenization()

  Replaces the system in the standard double precision container with its transformation in 1-homogeneous coordinates. There is one integer on input. If 0, then a random linear equation is added, otherwise, the linear equation z0 - 1 = 0 is added, where z0 is the extra homogeneous coordinate.

phcpy2c3.py2c_syscon_store_dobldobl_Laurential()

  Defines the k-th polynomial in the systems container for Laurent polynomials with coefficients in double double precision. As a precondition for this function, the container must be initialized for sufficiently many polynomials, in any case >= k. There are four input parameters, three integers and one string: 1) nc, the number of characters in the string p; 2) n, the number of variables in the multivariate polynomial; 3) k, the index of the polynomial in the system; 4) p, a valid string representation for a polynomial. On return is the failure code, which equals zero when all went well.

phcpy2c3.py2c_syscon_store_dobldobl_polynomial()

  Defines the k-th polynomial in the systems container for polynomials with coefficients in double double precision. As a precondition for this function, the container must be initialized for sufficiently many polynomials, in any case >= k. There are four input parameters, three integers and one string: 1) nc, the number of characters in the string p; 2) n, the number of variables in the multivariate polynomial; 3) k, the index of the polynomial in the system; 4) p, a valid string representation for a polynomial. On return is the failure code, which equals zero when all went well.

phcpy2c3.py2c_syscon_store_multprec_Laurential()

  Defines the k-th polynomial in the systems container for Laurent polynomials with coefficients in arbitrary multiprecision. As a precondition for this function, the container must be initialized for sufficiently many polynomials, in any case >= k. There are five input parameters, four integers and one string: 1) nc, the number of characters in the string p; 2) n, the number of variables in the multivariate polynomial; 3) k, the index of the polynomial in the system; 4) dp, the number of decimal places to parse the coefficients; 5) p, a valid string representation for a polynomial. On return is the failure code, which equals zero when all went well.

phcpy2c3.py2c_syscon_store_multprec_polynomial()

  Defines the k-th polynomial in the systems container for polynomials with coefficients in arbitrary multiprecision. As a precondition for this function, the container must be initialized for sufficiently many polynomials, in any case >= k. There are five input parameters, four integers and one string: 1) nc, the number of characters in the string p; 2) n, the number of variables in the multivariate polynomial; 3) k, the index of the polynomial in the system; 4) dp, the number of decimal places to parse the coefficients; 5) p, a valid string representation for a polynomial. On return is the failure code, which equals zero when all went well.

phcpy2c3.py2c_syscon_store_quaddobl_Laurential()

  Defines the k-th polynomial in the systems container for Laurent polynomials with coefficients in quad double precision. As a precondition for this function, the container must be initialized for sufficiently many polynomials, in any case >= k. There are four input parameters, three integers and one string: 1) nc, the number of characters in the string p; 2) n, the number of variables in the multivariate polynomial; 3) k, the index of the polynomial in the system; 4) p, a valid string representation for a polynomial. On return is the failure code, which equals zero when all went well.

phcpy2c3.py2c_syscon_store_quaddobl_polynomial()

  Defines the k-th polynomial in the systems container for polynomials with coefficients in quad double precision. As a precondition for this function, the container must be initialized for sufficiently many polynomials, in any case >= k. There are four input parameters, three integers and one string: 1) nc, the number of characters in the string p; 2) n, the number of variables in the multivariate polynomial; 3) k, the index of the polynomial in the system; 4) p, a valid string representation for a polynomial. On return is the failure code, which equals zero when all went well.

phcpy2c3.py2c_syscon_store_standard_Laurential()

  Defines the k-th polynomial in the systems container for Laurent polynomials with coefficients in standard double precision. As a precondition for this function, the container must be initialized for sufficiently many polynomials, in any case >= k. There are four input parameters, three integers and one string: 1) nc, the number of characters in the string p; 2) n, the number of variables in the multivariate polynomial; 3) k, the index of the polynomial in the system; 4) p, a valid string representation for a polynomial. On return is the failure code, which equals zero when all went well.

phcpy2c3.py2c_syscon_store_standard_polynomial()

  Defines the k-th polynomial in the systems container for polynomials with coefficients in standard double precision. As a precondition for this function, the container must be initialized for sufficiently many polynomials, in any case >= k. There are four input parameters, three integers and one string: 1) nc, the number of characters in the string p; 2) n, the number of variables in the multivariate polynomial; 3) k, the index of the polynomial in the system; 4) p, a valid string representation for a polynomial. On return is the failure code, which equals zero when all went well.

phcpy2c3.py2c_syscon_string_of_symbols()

  Returns a string that contains the symbols in the symbol table. The symbols are separate from each other by one space.

phcpy2c3.py2c_syscon_total_degree()

  Returns in d the total degree of the system with coefficients in standard double precision, as stored in the container.

phcpy2c3.py2c_syscon_write_dobldobl_Laurent_system()

  Writes the Laurent polynomial system with double double precision coefficients that is stored in the container.

phcpy2c3.py2c_syscon_write_dobldobl_system()

  Writes the polynomial system with double double precision coefficients that is stored in the container.

phcpy2c3.py2c_syscon_write_multprec_Laurent_system()

  Writes the Laurent polynomial system with arbitrary multiprecision coefficients that is stored in the container.

phcpy2c3.py2c_syscon_write_multprec_system()

  Writes the polynomial system with arbitrary multiprecision coefficients that is stored in the container.

phcpy2c3.py2c_syscon_write_quaddobl_Laurent_system()

  Writes the Laurent polynomial system with quad double precision coefficients that is stored in the container.

phcpy2c3.py2c_syscon_write_quaddobl_system()

  Writes the polynomial system with quad double precision coefficients that is stored in the container.

phcpy2c3.py2c_syscon_write_standard_Laurent_system()

  Writes the Laurent polynomial system with standard double precision coefficients that is stored in the container.

phcpy2c3.py2c_syscon_write_standard_system()

  Writes the polynomial system with standard double precision coefficients that is stored in the container.

phcpy2c3.py2c_syscon_write_symbols()

  Writes the symbols in the symbol table to screen. Returns the failure code, which equals zero if all went well.

phcpy2c3.py2c_syspool_copy_to_dobldobl_container()

  Copies the k-th system in the pool for systems in double double precision to the dobldobl systems container. The value for k is given as an integer input parameter. On return is the failure code, which equals zero if all went well.

phcpy2c3.py2c_syspool_copy_to_quaddobl_container()

  Copies the k-th system in the pool for systems in quad double precision to the quaddobl systems container. The value for k is given as an integer input parameter. On return is the failure code, which equals zero if all went well.

phcpy2c3.py2c_syspool_copy_to_standard_container()

  Copies the k-th system in the pool for systems in standard double precision to the standard systems container. The value for k is given as an integer input parameter. On return is the failure code, which equals zero if all went well.

phcpy2c3.py2c_syspool_dobldobl_clear()

  Clears the pool for systems in double double precision.

phcpy2c3.py2c_syspool_dobldobl_create()

  Defines the k-th system in the dobldobl system pool, using the system in the dobldobl container.

phcpy2c3.py2c_syspool_dobldobl_init()

  Initializes the pool for systems in double double precision.

phcpy2c3.py2c_syspool_dobldobl_size()

  Returns the size of the pool for systems in double double precision.

phcpy2c3.py2c_syspool_quaddobl_clear()

  Clears the pool for systems in quad double precision.

phcpy2c3.py2c_syspool_quaddobl_create()

  Defines the k-th system in the quaddobl system pool, using the system in the quaddobl container.

phcpy2c3.py2c_syspool_quaddobl_init()

  Initializes the pool for systems in quad double precision.

phcpy2c3.py2c_syspool_quaddobl_size()

  Returns the size of the pool for systems in quad double precision.

phcpy2c3.py2c_syspool_standard_clear()

  Clears the pool for systems in standard double precision.

phcpy2c3.py2c_syspool_standard_create()

  Defines the k-th system in the standard system pool, using the system in the standard container.

phcpy2c3.py2c_syspool_standard_init()

  Initializes the pool for systems in standard double precision.

phcpy2c3.py2c_syspool_standard_size()

  Returns the size of the pool for systems in standard double precision.

phcpy2c3.py2c_tabform_load_standard_tableau()

  Returns a 5-tuple with the tableau form of the system with standard double precision coefficients in the container. On input is the verbose flag, as an integer. The five items in the returned tuple are 1) the number of equations as an integer, 2) the number of equations as an integer, 3) the number of terms in each polynomial, given as a string, the string representation of a list of integers, 4) the coefficients of all terms, given as a string, the string representation of a list of doubles, each pair of consecutive doubles represents a complex coefficient, 5) the exponents of all terms, given as a string, the string representation of a list of integers.

phcpy2c3.py2c_tabform_store_standard_tableau()

  On input is the tableau form of a polynomial system, given by 1) the number of equations as an integer, 2) the number of equations as an integer, 3) the number of characters in the 4-th string input, 4) the number of terms in each polynomial, given as a string, the string representation of a list of integers, 5) the number of characters in the 6-th string input, 6) the coefficients of all terms, given as a string, the string representation of a list of doubles, each pair of consecutive doubles represents a complex coefficient, 7) the number of characters in the 7-th string input, 8) the exponents of all terms, given as a string, the string representation of a list of integers. The tableau form is parsed and the container for systems with standard double precision coefficients is initialized.

phcpy2c3.py2c_tune_continuation_parameters()

  Interactive procedure to tune the continuation parameters.

phcpy2c3.py2c_usolve_dobldobl()

  Applies the method of Weierstrass to compute all roots of a polynomial in one variable with double double precision arithmetic. On input are two numbers: 1) the maximum number of iterations in the method of Weierstrass; and 2) the epsilon requirement on the accuracy of the roots. Before calling this function, the polynomial should be stored in the dobldobl systems container. After the call of this function, the dobldobl solutions container contains the roots of the polynomial. On return is the number of iterations done by the solver.

phcpy2c3.py2c_usolve_multprec()

  Applies the method of Weierstrass to compute all roots of a polynomial in one variable with arbitrary multiprecision arithmetic. On input are three numbers: 1) the number of decimal places in the working precision; 2) the maximum number of iterations in the method of Weierstrass; and 3) the epsilon requirement on the accuracy of the roots. Before calling this function, the polynomial should be stored in the multprec systems container. After the call of this function, the multprec solutions container contains the roots of the polynomial. On return is the number of iterations done by the solver.

phcpy2c3.py2c_usolve_quaddobl()

  Applies the method of Weierstrass to compute all roots of a polynomial in one variable with quad double precision arithmetic. On input are two numbers: 1) the maximum number of iterations in the method of Weierstrass; and 2) the epsilon requirement on the accuracy of the roots. Before calling this function, the polynomial should be stored in the quaddobl systems container. After the call of this function, the quaddobl solutions container contains the roots of the polynomial. On return is the number of iterations done by the solver.

phcpy2c3.py2c_usolve_standard()

  Applies the method of Weierstrass to compute all roots of a polynomial in one variable with standard double precision arithmetic. On input are two numbers: 1) the maximum number of iterations in the method of Weierstrass; and 2) the epsilon requirement on the accuracy of the roots. Before calling this function, the polynomial should be stored in the standard systems container. After the call of this function, the standard solutions container contains the roots of the polynomial. On return is the number of iterations done by the solver.

phcpy2c3.py2c_varbprec_Newton_Laurent_steps()

  Applies Newton’s method in variable precision. There are six input parameters: 1) the dimension: the number of variables and equations; 2) the accuracy, expressed as the correct number of decimal places; 3) the maximum number of iterations in Newton’s method; 4) an upper bound on the number of decimal places in the precision; 5) a string, with the representation of the polynomials in the system. On return is the failure code, which equals zero if all went well.

phcpy2c3.py2c_witset_dobldobl_Laurent_ismember()

  Runs the homotopy membership test for a point to belong to a witness set defined by a Laurent polynomial system in double double precision, where the test point is given as a string in PHCpack format. The containers in double double precision must contain the embedded Laurent system and the corresponding generic points. On entry are seven parameters. The first four are integers: 1) vrb, an integer flag (0 or 1) for the verbosity of the test, 2) nvr, the ambient dimension, number of coordinates of the point, 3) dim, the dimension of the witness set, 4) nbc, the number of characters in the string representing the point, the test point is represented as a solution string in symbolic format, including the symbols for the variables, before the coordinates; the next two parameters are two doubles: 5) restol, tolerance on the residual for the valuation of the point, 6) homtol, tolerance on the homotopy membership test for the point; and the last parameter is a string: 7) tpt, the string representation of a solution which contains the coordinates of the test point in symbolic format. On return are three 0/1 integers, to be interpreted as booleans: 1) fail, the failure code of the procedure, 2) onsys, 0 if the evaluation test failed, 1 if success, 3) onset, 0 if not a member of the witness set, 1 if a member.

phcpy2c3.py2c_witset_dobldobl_Laurent_membertest()

  Executes the homotopy membership test for a point to belong to a witness set defined by a Laurent polynomial system in double double precision. The containers in double double precision must contain the embedded Laurent system and its corresponding solutions for the witness set of a positive dimensional solution set. On entry are the seven parameters, the first four are integers: 1) vrb, an integer flag (0 or 1) for the verbosity of the test, 2) nvr, the ambient dimension, number of coordinates of the point, 3) dim, the dimension of the witness set, 4) nbc, the number of characters in the string representing the point; the next two parameters are two doubles: 5) restol, tolerance on the residual for the valuation of the point, 6) homtol, tolerance on the homotopy membership test for the point; and the last parameter is a string: 7) tpt, the string representation of the point as a list with as many as 4*nvr doubles for the real and imaginary parts of the double double precision coordinates of the test point. On return are three 0/1 integers, to be interpreted as booleans: 1) fail, the failure code of the procedure, 2) onsys, 0 if the evaluation test failed, 1 if success, 3) onset, 0 if not a member of the witness set, 1 if a member.

phcpy2c3.py2c_witset_dobldobl_ismember()

  Runs the homotopy membership test for a point to belong to a witness set defined by an ordinary polynomial system in double double precision, where the test point is given as a string in PHCpack format. The containers in double double precision must contain the embedded system and the corresponding generic points. On entry are seven parameters. The first four are integers: 1) vrb, an integer flag (0 or 1) for the verbosity of the test, 2) nvr, the ambient dimension, number of coordinates of the point, 3) dim, the dimension of the witness set, 4) nbc, the number of characters in the string representing the point, the test point is represented as a solution string in symbolic format, including the symbols for the variables, before the coordinates; the next two parameters are two doubles: 5) restol, tolerance on the residual for the valuation of the point, 6) homtol, tolerance on the homotopy membership test for the point; and the last parameter is a string: 7) tpt, the string representation of a solution which contains the coordinates of the test point in symbolic format. On return are three 0/1 integers, to be interpreted as booleans: 1) fail, the failure code of the procedure, 2) onsys, 0 if the evaluation test failed, 1 if success, 3) onset, 0 if not a member of the witness set, 1 if a member.

phcpy2c3.py2c_witset_dobldobl_membertest()
  Executes the homotopy membership test for a point to belong to

    a witness set defined by an ordinary polynomial system

  in double double precision.

    The containers in double double precision must contain the embedded polynomial system and its corresponding solutions for the witness set of a positive dimensional solution set. On entry are the seven parameters, the first four are integers: 1) vrb, an integer flag (0 or 1) for the verbosity of the test, 2) nvr, the ambient dimension, number of coordinates of the point, 3) dim, the dimension of the witness set, 4) nbc, the number of characters in the string representing the point; the next two parameters are two doubles: 5) restol, tolerance on the residual for the valuation of the point, 6) homtol, tolerance on the homotopy membership test for the point; and the last parameter is a string: 7) tpt, the string representation of the point as a list with as many as 4*nvr doubles for the real and imaginary parts of the double double precision coordinates of the test point. On return are three 0/1 integers, to be interpreted as booleans: 1) fail, the failure code of the procedure, 2) onsys, 0 if the evaluation test failed, 1 if success, 3) onset, 0 if not a member of the witness set, 1 if a member.

phcpy2c3.py2c_witset_quaddobl_Laurent_ismember()

  Runs the homotopy membership test for a point to belong to a witness set defined by a Laurent polynomial system in quad double precision, where the test point is given as a string in PHCpack format. The containers in quad double precision must contain the embedded Laurent system and the corresponding generic points. On entry are seven parameters. The first four are integers: 1) vrb, an integer flag (0 or 1) for the verbosity of the test, 2) nvr, the ambient dimension, number of coordinates of the point, 3) dim, the dimension of the witness set, 4) nbc, the number of characters in the string representing the point, the test point is represented as a solution string in symbolic format, including the symbols for the variables, before the coordinates; the next two parameters are two doubles: 5) restol, tolerance on the residual for the valuation of the point, 6) homtol, tolerance on the homotopy membership test for the point; and the last parameter is a string: 7) tpt, the string representation of a solution which contains the coordinates of the test point in symbolic format. On return are three 0/1 integers, to be interpreted as booleans: 1) fail, the failure code of the procedure, 2) onsys, 0 if the evaluation test failed, 1 if success, 3) onset, 0 if not a member of the witness set, 1 if a member.

phcpy2c3.py2c_witset_quaddobl_Laurent_membertest()

  Executes the homotopy membership test for a point to belong to a witness set defined by a Laurent polynomial system in quad double precision. The containers in quad double precision must contain the embedded Laurent system and its corresponding solutions for the witness set of a positive dimensional solution set. On entry are the seven parameters, the first four are integers: 1) vrb, an integer flag (0 or 1) for the verbosity of the test, 2) nvr, the ambient dimension, number of coordinates of the point, 3) dim, the dimension of the witness set, 4) nbc, the number of characters in the string representing the point; the next two parameters are two doubles: 5) restol, tolerance on the residual for the valuation of the point, 6) homtol, tolerance on the homotopy membership test for the point; and the last parameter is a string: 7) tpt, the string representation of the point as a list with as many as 8*nvr doubles for the real and imaginary parts of the quad double precision coordinates of the test point. On return are three 0/1 integers, to be interpreted as booleans: 1) fail, the failure code of the procedure, 2) onsys, 0 if the evaluation test failed, 1 if success, 3) onset, 0 if not a member of the witness set, 1 if a member.

phcpy2c3.py2c_witset_quaddobl_ismember()

  Runs the homotopy membership test for a point to belong to a witness set defined by an ordinary polynomial system in quad double precision, where the test point is given as a string in PHCpack format. The containers in quad double precision must contain the embedded system and the corresponding generic points. On entry are seven parameters. The first four are integers: 1) vrb, an integer flag (0 or 1) for the verbosity of the test, 2) nvr, the ambient dimension, number of coordinates of the point, 3) dim, the dimension of the witness set, 4) nbc, the number of characters in the string representing the point, the test point is represented as a solution string in symbolic format, including the symbols for the variables, before the coordinates; the next two parameters are two doubles: 5) restol, tolerance on the residual for the valuation of the point, 6) homtol, tolerance on the homotopy membership test for the point; and the last parameter is a string: 7) tpt, the string representation of a solution which contains the coordinates of the test point in symbolic format. On return are three 0/1 integers, to be interpreted as booleans: 1) fail, the failure code of the procedure, 2) onsys, 0 if the evaluation test failed, 1 if success, 3) onset, 0 if not a member of the witness set, 1 if a member.

phcpy2c3.py2c_witset_quaddobl_membertest()

  Executes the homotopy membership test for a point to belong to a witness set defined by an ordinary polynomial system in quad double precision. The containers in quad double precision must contain the embedded polynomial system and its corresponding solutions for the witness set of a positive dimensional solution set. On entry are the seven parameters, the first four are integers: 1) vrb, an integer flag (0 or 1) for the verbosity of the test, 2) nvr, the ambient dimension, number of coordinates of the point, 3) dim, the dimension of the witness set, 4) nbc, the number of characters in the string representing the point; the next two parameters are two doubles: 5) restol, tolerance on the residual for the valuation of the point, 6) homtol, tolerance on the homotopy membership test for the point; and the last parameter is a string: 7) tpt, the string representation of the point as a list with as many as 8*nvr doubles for the real and imaginary parts of the quad double precision coordinates of the test point. On return are three 0/1 integers, to be interpreted as booleans: 1) fail, the failure code of the procedure, 2) onsys, 0 if the evaluation test failed, 1 if success, 3) onset, 0 if not a member of the witness set, 1 if a member.

phcpy2c3.py2c_witset_standard_Laurent_ismember()

  Runs the homotopy membership test for a point to belong to a witness set defined by a Laurent polynomial system in standard double precision, where the test point is given as a string in PHCpack format. The containers in standard double precision must contain the embedded Laurent system and the corresponding generic points. On entry are seven parameters. The first four are integers: 1) vrb, an integer flag (0 or 1) for the verbosity of the test, 2) nvr, the ambient dimension, number of coordinates of the point, 3) dim, the dimension of the witness set, 4) nbc, the number of characters in the string representing the point, the test point is represented as a solution string in symbolic format, including the symbols for the variables, before the coordinates; the next two parameters are two doubles: 5) restol, tolerance on the residual for the valuation of the point, 6) homtol, tolerance on the homotopy membership test for the point; and the last parameter is a string: 7) tpt, the string representation of a solution which contains the coordinates of the test point in symbolic format. On return are three 0/1 integers, to be interpreted as booleans: 1) fail, the failure code of the procedure, 2) onsys, 0 if the evaluation test failed, 1 if success, 3) onset, 0 if not a member of the witness set, 1 if a member.

phcpy2c3.py2c_witset_standard_Laurent_membertest()

  Executes the homotopy membership test for a point to belong to a witness set defined by a Laurent polynomial system in standard double precision. The containers in standard double precision must contain the embedded Laurent system and its corresponding solutions for the witness set of a positive dimensional solution set. On entry are the seven parameters, the first four are integers: 1) vrb, an integer flag (0 or 1) for the verbosity of the test, 2) nvr, the ambient dimension, number of coordinates of the point, 3) dim, the dimension of the witness set, 4) nbc, the number of characters in the string representing the point; the next two parameters are two doubles: 5) restol, tolerance on the residual for the valuation of the point, 6) homtol, tolerance on the homotopy membership test for the point; and the last parameter is a string: 7) tpt, the string representation of the point as a list with as many as 2*nvr doubles for the real and imaginary parts of the standard double precision coordinates of the test point. On return are three 0/1 integers, to be interpreted as booleans: 1) fail, the failure code of the procedure, 2) onsys, 0 if the evaluation test failed, 1 if success, 3) onset, 0 if not a member of the witness set, 1 if a member.

phcpy2c3.py2c_witset_standard_ismember()

  Runs the homotopy membership test for a point to belong to a witness set defined by an ordinary polynomial system in standard double precision, where the test point is given as a string in PHCpack format. The containers in standard double precision must contain the embedded system and the corresponding generic points. On entry are seven parameters. The first four are integers: 1) vrb, an integer flag (0 or 1) for the verbosity of the test, 2) nvr, the ambient dimension, number of coordinates of the point, 3) dim, the dimension of the witness set, 4) nbc, the number of characters in the string representing the point, the test point is represented as a solution string in symbolic format, including the symbols for the variables, before the coordinates; the next two parameters are two doubles: 5) restol, tolerance on the residual for the valuation of the point, 6) homtol, tolerance on the homotopy membership test for the point; and the last parameter is a string: 7) tpt, the string representation of a solution which contains the coordinates of the test point in symbolic format. On return are three 0/1 integers, to be interpreted as booleans: 1) fail, the failure code of the procedure, 2) onsys, 0 if the evaluation test failed, 1 if success, 3) onset, 0 if not a member of the witness set, 1 if a member.

phcpy2c3.py2c_witset_standard_membertest()

  Executes the homotopy membership test for a point to belong to a witness set defined by an ordinary polynomial system in standard double precision. The containers in standard double precision must contain the embedded polynomial system and its corresponding solutions for the witness set of a positive dimensional solution set. On entry are the seven parameters, the first four are integers: 1) vrb, an integer flag (0 or 1) for the verbosity of the test, 2) nvr, the ambient dimension, number of coordinates of the point, 3) dim, the dimension of the witness set, 4) nbc, the number of characters in the string representing the point; the next two parameters are two doubles: 5) restol, tolerance on the residual for the valuation of the point, 6) homtol, tolerance on the homotopy membership test for the point; and the last parameter is a string: 7) tpt, the string representation of the point as a list with as many as 2*nvr doubles for the real and imaginary parts of the standard double precision coordinates of the test point. On return are three 0/1 integers, to be interpreted as booleans: 1) fail, the failure code of the procedure, 2) onsys, 0 if the evaluation test failed, 1 if success, 3) onset, 0 if not a member of the witness set, 1 if a member.

phcpy2c3.py2c_write_dobldobl_start_Laurent_system()

  Writes the start Laurent system in double double precision.

phcpy2c3.py2c_write_dobldobl_start_system()

  Writes the start system as stored in double double precision to screen or to the defined output file.

phcpy2c3.py2c_write_dobldobl_target_Laurent_system()

  Writes the target Laurent system in double double precision.

phcpy2c3.py2c_write_dobldobl_target_system()

  Writes the target system as stored in double double precision to screen or to the defined output file.

phcpy2c3.py2c_write_quaddobl_start_Laurent_system()

  Writes the start Laurent system in quad double precision.

phcpy2c3.py2c_write_quaddobl_start_system()

  Writes the start system as stored in quad double precision to screen or to the defined output file.

phcpy2c3.py2c_write_quaddobl_target_Laurent_system()

  Writes the target Laurent system in quad double precision.

phcpy2c3.py2c_write_quaddobl_target_system()

  Writes the target system as stored in quad double precision to screen or to the defined output file.

phcpy2c3.py2c_write_standard_start_Laurent_system()

  Writes the start Laurent system in standard double precision.

phcpy2c3.py2c_write_standard_start_system()

  Writes the start system as stored in standard double precision to screen or to the defined output file.

phcpy2c3.py2c_write_standard_target_Laurent_system()

  Writes the target Laurent system in standard double precision.

phcpy2c3.py2c_write_standard_target_system()

  Writes the target system as stored in standard double precision to screen or to the defined output file.

phcpy2c3.py2c_write_start_solutions()

  Writes the start solutions in standard double precision either to the screen (standard output) or to the defined output file. On return is the failure code, which is zero if all is well.