Univariate solvers and algebraic curves in PHCpack version 2.4.90

The numerical treatment of plane algebraic curves needs the solution of
polynomial equations in one variable.  To solve univariate polynomials,
the method of Durand-Kerner (also called the method of Weierstrass) is
implemented.  Release 2.2 added blackbox solvers, double double and
quad double versions were provided in version 2.3.79.

For plane algebraic curves, no particular homotopy is needed and sampling
curves provides good development and testing cases for the predictors.
New in 2.3.79 is the introduction of higher-order extrapolators.

The addition of Newton's method to compute power series solutions
is entirely new in release 2.4.21.  The power series are the input
to the algorithms to compute rational, Pade approximants for the
solution paths in a polynomial homotopy.  Since version 2.4.61,
phc -u provides access to a robust path tracker, with a priori step
control and detection of the nearest singularity via the application
of the theorem of Fabry.

Run "gprbuild curves.gpr" to make all test programs.
On windows, type "gprbuild curves.gpr -Xos=windows"
at the PowerShell prompt.
The "gprclean curves.gpr" removes all files created by gprbuild.

-------------------------------------------------------------------------------
file name                         : short description
-------------------------------------------------------------------------------
standard_durand_kerner            : solves univariate polynomial equations
dobldobl_durand_kerner            : double double Durand-Kerner method
quaddobl_durand_kerner            : quad double Durand-Kerner method
multprec_durand_kerner            : multi-precision Durand-Kerner method
hybrid_durand_kerner              : hybrid standard/multi-precision version
ts_durker                         : test polynomial equation solver
black_box_univariate_solvers      : called by the black-box solver (phc -b)
-------------------------------------------------------------------------------
standard_extrapolators            : divided differences to extrapolate
dobldobl_extrapolators            : extrapolation with double doubles
quaddobl_extrapolators            : extrapolation with quad doubles
multprec_extrapolators            : extrapolation at any precision
sample_plane_curves               : tools to compute points on curves
ts_extrapol                       : test on extrapolation
ts_extrapts                       : points on skew line
-------------------------------------------------------------------------------
standard_newton_series            : Newton to compute series solutions
dobldobl_newton_series            : Newton on series in double double precision
quaddobl_newton_series            : Newton on series in quad double precision
standard_newton_matrix_series     : linearization in Newton on series matrices
dobldobl_newton_matrix_series     : linearized Newton with double doubles
tripdobl_newton_matrix_series     : linearized Newton with triple doubles
quaddobl_newton_matrix_series     : linearized Newton with quad doubles
pentdobl_newton_matrix_series     : linearized Newton with penta doubles
octodobl_newton_matrix_series     : linearized Newton with octo doubles
decadobl_newton_matrix_series     : linearized Newton with deca doubles
hexadobl_newton_matrix_series     : linearized Newton with hexa doubles
test_sd_newton_matrix_series      : test Newton for series with doubles
test_dd_newton_matrix_series      : test Newton for series with double doubles
test_td_newton_matrix_series      : test Newton for series with triple doubles
test_qd_newton_matrix_series      : test Newton for series with quad doubles
test_pd_newton_matrix_series      : test Newton for series with penta doubles
test_od_newton_matrix_series      : test Newton for series with octo doubles
test_da_newton_matrix_series      : test Newton for series with deca doubles
test_hd_newton_matrix_series      : test Newton for series with hexa doubles
ts_sernew                         : test on the Newton series packages
series_and_solutions              : making series from solution vectors
power_series_methods              : Newton's method on power series solutions
run_power_series_methods          : main programs to run Newton on series
test_series_solutions             : test series developments as solutions
ts_sersol                         : main test procedure on solution series
-------------------------------------------------------------------------------
standard_newton_convolution_steps : double Newton convolution steps
staggered_newton_convolutions     : Newton with staggered degrees
dobldobl_newton_convolution_steps : double double Newton convolution steps
tripdobl_newton_convolution_steps : triple double Newton convolution steps
quaddobl_newton_convolution_steps : quad double Newton convolution steps
pentdobl_newton_convolution_steps : penta double Newton convolution steps
octodobl_newton_convolution_steps : octo double Newton convolution steps
decadobl_newton_convolution_steps : deca double Newton convolution steps
hexadobl_newton_convolution_steps : hexa double Newton convolution steps
test_standard_newtconvsteps       : tests double Newton convolution steps
test_dobldobl_newtconvsteps       : tests dobldobl Newton convolution steps
test_tripdobl_newtconvsteps       : tests tripdobl Newton convolution steps
test_quaddobl_newtconvsteps       : tests quaddobl Newton convolution steps
test_pentdobl_newtconvsteps       : tests pentdobl Newton convolution steps
test_octodobl_newtconvsteps       : tests octodobl Newton convolution steps
test_decadobl_newtconvsteps       : tests decadobl Newton convolution steps
test_hexadobl_newtconvsteps       : tests hexadobl Newton convolution steps
ts_sernewcnv                      : test on Newton power series convolutions
-------------------------------------------------------------------------------
series_and_homotopies             : homotopies as systems with series coeffs
ts_serhom                         : test on series and homotopies
homotopy_series_readers           : reads a homotopy for power series
-------------------------------------------------------------------------------
standard_rational_approximations  : definition of a rational approximation
dobldobl_rational_approximations  : rational approximations with double doubles
tripdobl_rational_approximations  : rational approximations with triple doubles
quaddobl_rational_approximations  : rational approximations with quad doubles
pentdobl_rational_approximations  : rational approximations with penta doubles
octodobl_rational_approximations  : rational approximations with octo doubles
decadobl_rational_approximations  : rational approximations with deca doubles
homotopy_coefficient_scaling      : scale coefficients for homogenization
standard_pade_approximants        : Pade approximants in double precision
standard_pade_approximants_io     : output of double Pade approximants
dobldobl_pade_approximants        : Pade approximants with double doubles
dobldobl_pade_approximants_io     : output of double double Pade approximants
quaddobl_pade_approximants        : Pade approximants with quad doubles
quaddobl_pade_approximants_io     : output of quad double Pade approximants
homotopy_pade_approximants        : wraps series Newton and Pade creators
test_standard_pade_approximants   : test pade approximants with doubles
test_dobldobl_pade_approximants   : test pade approximants with double doubles
test_quaddobl_pade_approximants   : test pade approximants with quad doubles
ts_serpade                        : test rational approximations given series
test_rational_approximations      : test on rational approximations
ts_ratapp                         : calls the main test on rational approxs
------------------------------------------------------------------------------
standard_homotopy_convolutions_io : prompts for double homotopy convolutions
dobldobl_homotopy_convolutions_io : prompts for dobldobl homotopy convolutions
tripdobl_homotopy_convolutions_io : prompts for tripdobl homotopy convolutions
quaddobl_homotopy_convolutions_io : prompts for quaddobl homotopy convolutions
pentdobl_homotopy_convolutions_io : prompts for pentdobl homotopy convolutions
octodobl_homotopy_convolutions_io : prompts for octodobl homotopy convolutions
decadobl_homotopy_convolutions_io : prompts for decadobl homotopy convolutions
hexadobl_homotopy_convolutions_io : prompts for hexadobl homotopy convolutions
fabry_on_homotopy_helpers         : helpers for convergence radius packages
standard_fabry_on_homotopy        : convergence radius with doubles
dobldobl_fabry_on_homotopy        : convergence radius with double doubles
tripdobl_fabry_on_homotopy        : convergence radius with triple doubles
quaddobl_fabry_on_homotopy        : convergence radius with quad doubles
pentdobl_fabry_on_homotopy        : convergence radius with penta doubles
octodobl_fabry_on_homotopy        : convergence radius with octo doubles
decadobl_fabry_on_homotopy        : convergence radius with deca doubles
hexadobl_fabry_on_homotopy        : convergence radius with hexa doubles
ts_fabryhom                       : tests Newton-Fabry on a homotopy
-----------------------------------------------------------------------------
singular_values_of_hessians       : wraps SVD for the Hessian criterion
series_and_predictors             : apply power series to predict solutions
test_series_predictors            : procedure to help in the testing
ts_hesscrit                       : test development of the Hessian criterion
ts_hesspred                       : test step size based on nearest solution
ts_hesspcnv                       : test on Hessian criterion on convolutions
corrector_convolutions            : apply Newton's method at a point
ts_corcnv                         : tests corrector convolutions
ts_serpred                        : test on series predictor
test_pade_predictors              : procedure to help testing Pade predictors
jacobian_rabinowitsch_trick       : application of the Rabinowitsch trick
ts_jacrabin                       : test application of Rabinowitsch trick
ts_padepred                       : test the Pade predictors
three_way_minima                  : minima of three numbers
standard_predictor_convolutions   : double predictor convolution homotopies
dobldobl_predictor_convolutions   : dobldobl predictor convolution homotopies
quaddobl_predictor_convolutions   : quaddobl predictor convolution homotopies
test_predictor_convolutions       : checks start solutions
ts_padepcnv                       : Pade predictors for convolution circuits
ts_predstep                       : test setting of step size
predictor_corrector_loops         : feedback loops in predictor-corrector
predictor_corrector_trackers      : trackers run predictor-corrector loops
ts_pcscnv                         : test predictor-corrector-shift step
hyperplane_convolution_scaling    : scaling homogeneous convolution circuits
ts_scalecnv                       : test scaling of solutions
-------------------------------------------------------------------------------
homotopy_continuation_parameters    : parameters and tolerances
homotopy_continuation_parameters_io : output and tuning of arameters 
homotopy_newton_steps               : defines the correctors
standard_pade_trackers              : pade trackers in double precision
dobldobl_pade_trackers              : pade trackers in double double precision
quaddobl_pade_trackers              : pade trackers in quad double precision
series_and_trackers                 : power series predictor in path tracker
drivers_to_series_trackers          : helps to launch series trackers
series_path_trackers                : runs the series path trackers
ts_serpath                          : test on series path tracker
main_pade_trackers                  : main procedures for phc -u
-------------------------------------------------------------------------------
standard_seriespade_tracker         : provides a get_next() method tracker
dobldobl_seriespade_tracker         : a get_next() tracker with double doubles
quaddobl_seriespade_tracker         : a get_next() tracker with quad doubles
interactive_pade_trackers           : calls the step-by-step path trackers
ts_nxtpadsol                        : test on the get_next() trackers
-------------------------------------------------------------------------------
wrapped_pade_trackers               : wrapping of the trackers
ts_wrappade                         : test on the wrapping
-------------------------------------------------------------------------------
