Multivariate polynomials and polynomial systems over rings in PHCv2.4.90

New in release 2 is the availability of multiprecision numbers.
The data structures are entirely redefined using Ada 95 concepts.
The graded lexicographic order of monomials was inlined in release 2.3.
Polynomials and systems with real coefficients were added in v2.3.22.
New in release 2.3.26 is the i/o for genuine Laurent polynomials.
Polynomials with double and quad double coefficients are new in v2.3.55.
In v2.3.69, the algorithms to evaluate polynomials was moved to the new
Functions directory.  Code for phc -g was added in version 2.3.80.
Version 2.4.80 added polynomials in triple, penta, octo, and deca double
precision.  Support for hexa double precision was added in 2.3.87.

This library is organized in three parts:
1) generic packages: polynomials and systems
2) instantiations
3) utilities

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

-------------------------------------------------------------------------------
file name                         : short description
-------------------------------------------------------------------------------
generic_lists                     : lists of items
graded_lexicographic_order        : defines the order of monomials
generic_polynomials               : generic polynomials in several variables
generic_laurent_polynomials       : generic polynomials with integer exponents
generic_lists_of_terms            : generic list of terms in several variables
generic_polynomial_systems        : systems of polynomials
generic_laur_poly_systems         : systems of Laurent polynomials
generic_jacobian_matrices         : Jacobian matrices of polynomial systems
generic_laur_jaco_matrices        : Jacobian matrices of Laurent systems
symbol_table                      : management of table of symbols
symbol_table_io                   : input/output of symbols
parse_polynomial_exceptions       : defines exceptions for parsing polynomials
line_breaks                       : counts number of characters to break lines
write_factors                     : writing one pure power in a factor
-------------------------------------------------------------------------------
standard_complex_polynomials      : polynomials over standard complex numbers
standard_complex_poly_terms       : list of terms with standard complex coeffs
standard_complex_poly_terms_io    : list of terms written in tableau format
standard_floating_polynomials     : polynomials with real coefficients
standard_complex_to_real_poly     : type conversions between complex/real
standard_complex_polynomials_io   : input/output of complex polynomials
standard_random_polynomials       : generate sparse and dense polynomials
standard_complex_poly_strings     : string representations of polynomials
standard_complex_laurentials      : Laurent polynomials with standard complex
standard_complex_laurentials_io   : i/o for Laurent polynomials
standard_random_laurentials       : random Laurent polynomials
standard_complex_laur_strings     : string representations of Laurentials
standard_complex_poly_ring        : abstract_ring(standard complex poly)
standard_complex_poly_ring_io     : abstract_ring_io(standard complex poly)
standard_complex_poly_vectors     : generic_vectors(standard complex poly)
standard_complex_poly_vectors_io  : generic_vectors_io(standard complex poly)
standard_complex_poly_matrices    : generic_matrices(standard complex poly)
standard_complex_poly_matrices_io : generic_matrices_io(standard complex poly)
standard_complex_poly_systems     : generic_polynomial_systems instantiated
standard_complex_poly_systems_io  : input/output for complex polynomial systems
standard_floating_poly_systems    : systems with real coefficients
standard_floating_poly_systems_io : input/output for real polynomial systems
standard_tableau_formats          : simple tableau format for polynomials
dobldobl_tableau_formats          : poly tableau format for double doubles
quaddobl_tableau_formats          : poly tableau format for quad doubles
standard_complex_laur_systems     : generic_laur_poly_systems instantiated
standard_complex_laur_systems_io  : input/output for Laurent systems
standard_complex_jaco_matrices    : generic_jacobian_matrices instantiated
standard_floating_jaco_matrices   : Jacobi matrices with real coefficients
standard_complex_poly_randomizers : randomize coefficients of polynomials
standard_complex_laur_randomizers : randomize coefficients of polynomials
standard_complex_substitutors     : substitute equations into polynomials
standard_poly_laur_convertors     : convert polynomials to Laurent polynomials
standard_laur_poly_convertors     : convert Laurent polynomials to polynomials
dobldobl_poly_laur_convertors     : convert polynomials to Laurent for dobldobl
dobldobl_laur_poly_convertors     : convert Laurent polynomials for dobldobl
quaddobl_poly_laur_convertors     : convert polynomials to Laurent for quaddobl
quaddobl_laur_poly_convertors     : convert Laurent polynomials for quaddobl
multprec_laur_poly_convertors     : multiprecision "is_genuine_Laurent"
standard_to_multprec_convertors   : convert from standard to multiprecision
dobldobl_complex_poly_ring        : abstract_ring(dobldobl complex poly)
dobldobl_complex_poly_ring_io     : abstract_ring_io(dobldobl complex poly)
dobldobl_complex_poly_vectors     : generic_vectors(dobldobl complex poly)
dobldobl_complex_poly_vectors_io  : generic_vectors_io(dobldobl complex poly)
dobldobl_complex_poly_matrices    : generic_matrices(dobldobl complex poly)
dobldobl_complex_poly_matrices_io : generic_matrices_io(dobldobl complex poly)
double_double_polynomials         : polynomials with double double coefficients
double_double_poly_systems        : systems of double double polynomials
double_double_poly_systems_io     : i/o of double double polynomial systems
double_double_jaco_matrices       : Jacobian matrices of double doubles
dobldobl_complex_to_real_poly     : converting dd complex to real polynomials
dobldobl_complex_polynomials      : polynomials over complex double doubles
dobldobl_complex_polynomials_io   : basic output for dobldobl complex poly
dobldobl_complex_term_lists       : list of terms with dobldobl complex coeffs
dobldobl_complex_term_lists_io    : list of terms written in tableau format
dobldobl_random_polynomials       : random sparse or dense dd complex poly
dobldobl_complex_poly_randomizers : random polynomials with same support
dobldobl_complex_poly_strings     : string representations of dd complex poly
dobldobl_complex_poly_systems     : systems of double complex polynomials
dobldobl_complex_poly_systems_io  : basic output for dd complex poly systems
dobldobl_complex_jaco_matrices    : Jacobian matrices of double complex
dobldobl_complex_laurentials      : Laurent polynomials for dd complex
dobldobl_complex_laurentials_io   : basic output for dd complex Laurentials
dobldobl_complex_laur_strings     : string representations of dd Laurentials
dobldobl_complex_laur_systems     : double double Laurent systems
dobldobl_complex_laur_systems_io  : basic output for dd complex Laur systems
dobldobl_complex_laur_jacomats    : Jacobians of double double Laurent systems
dobldobl_complex_poly_randomizers : randomize coeffs of dobldobl polynomials
dobldobl_complex_laur_randomizers : randomize coeffs of dobldobl polynomials
dobldobl_polynomial_convertors    : standard poly <-> double double poly
quad_double_polynomials           : polynomials with quad double coefficients
quad_double_poly_systems          : quad double polynomial systems
quad_double_poly_systems_io       : i/o of quad double polynomial systems
quad_double_jaco_matrices         : Jacobian matrices of double doubles
quaddobl_complex_to_real_poly     : converting qd complex to real polynomials
quaddobl_complex_poly_ring        : abstract_ring(quaddobl complex poly)
quaddobl_complex_poly_ring_io     : abstract_ring_io(quaddobl complex poly)
quaddobl_complex_poly_vectors     : generic_vectors(quaddobl complex poly)
quaddobl_complex_poly_vectors_io  : generic_vectors_io(quaddobl complex poly)
quaddobl_complex_poly_matrices    : generic_matrices(quaddobl complex poly)
quaddobl_complex_poly_matrices_io : generic_matrices_io(quaddobl complex poly)
quaddobl_complex_polynomials      : polynomials over complex quad doubles
quaddobl_complex_polynomials_io   : basic output for qd complex polynomials
quaddobl_complex_term_lists       : list of terms with quaddobl complex coeffs
quaddobl_complex_term_lists_io    : list of terms written in tableau format
quaddobl_random_polynomials       : random sparse or dense qd complex poly
quaddobl_complex_poly_strings     : string representations of qd complex poly
quaddobl_complex_poly_systems     : systems of quad double complex polys
quaddobl_complex_poly_systems_io  : basic output for qd complex poly systems
quaddobl_complex_jaco_matrices    : Jacobian matrices of quad double complex
quaddobl_complex_laurentials      : Laurent polynomials for qd complex
quaddobl_complex_laurentials_io   : basic output for qd complex Laurentials
quaddobl_complex_laur_strings     : string representations of qd Laurentials
quaddobl_complex_laur_systems     : systems of quad double Laurent polynomials
quaddobl_complex_laur_systems_io  : basic output for qd complex laur systems
quaddobl_complex_laur_jacomats    : Jacobians of quad double Laurent systems
dobldobl_complex_poly_randomizers : randomize coeffs of quaddobl polynomials
dobldobl_complex_laur_randomizers : randomize coeffs of quaddobl polynomials
quaddobl_polynomial_convertors    : standard poly <-> quad double poly
multprec_to_standard_convertors   : convert from multiprecision to standard
multprec_complex_polynomials      : polynomials over multprec complex numbers
multprec_floating_polynomials     : polynomials with multprec real coefficients
multprec_random_polynomials       : random sparse or dense multiprec poly
multprec_complex_to_real_poly     : type conversions for complex/real poly
multprec_complex_laurentials      : Laurent polynomials over multprec complex
multprec_complex_poly_ring        : abstract_ring(multprec complex poly)
multprec_complex_poly_ring_io     : abstract_ring_io(multprec complex poly)
multprec_complex_poly_vectors     : generic_vectors(multprec complex poly)
multprec_complex_poly_vectors_io  : generic_vectors_io(multprec complex poly)
multprec_complex_poly_matrices    : generic_matrices(multprec complex poly)
multprec_complex_poly_matrices_io : generic_matrices_io(multprec complex poly)
multprec_complex_poly_systems     : systems of multiprec complex polynomials
multprec_complex_poly_systems_io  : simple output of multiprec complex systems
multprec_complex_term_lists       : list of terms with multprec complex coeffs
multprec_complex_term_lists_io    : list of terms written in tableau format
multprec_floating_poly_systems    : systems of multiprec floating polynomials
multprec_floating_poly_systems_io : simple output for multiprec real systems
multprec_complex_jaco_matrices    : Jacobi matrices for multiprecision complex
multprec_complex_laur_jacomats    : multprec complex Laurent Jacobi matrices
multprec_floating_jaco_matrices   : Jacobi matrices for multiprecision real
multprec_complex_laur_systems     : multiprecision Laurent systems
multprec_complex_laur_systems_io  : i/o for multiprecision Laurent systems
exponent_vectors                  : management of exponents of a system
matrix_indeterminates             : manipulate symbols for xij
standard_system_readers           : interactive reading from file
dobldobl_system_readers           : double double version of system readers
quaddobl_system_readers           : quad double version of system readers
multprec_system_readers           : multiprecision version of system readers
string_system_readers             : reading strings from file
standard_complex_laur_lists       : lists of standard complex Laurentials
-------------------------------------------------------------------------------
test_standard_polynomials         : tests double polynomials
test_standard_laurentials         : tests double Laurent polynomials
test_dobldobl_polynomials         : tests double double polynomials
test_quaddobl_polynomials         : tests quad double polynomials
test_multprec_polynomials         : tests multiprecision polynomials
-------------------------------------------------------------------------------
test_standard_random_systems      : tests random systems in double precision
test_dobldobl_random_systems      : tests random systems in dobldobl precision
test_quaddobl_random_systems      : tests random systems in quaddobl precision
test_multprec_random_systems      : tests random systems in multiprecision 
-------------------------------------------------------------------------------
triple_double_polynomials         : polynomials with triple double coeffs
triple_double_poly_systems        : poly systems with triple double coeffs
tripdobl_complex_polynomials      : polynomials with tripdobl complex coeffs
tripdobl_complex_polynomials_io   : i/o for tripdobl complex polynomials
tripdobl_complex_poly_strings     : string representations of td complex poly
tripdobl_complex_laurentials      : tripdobl complex Laurent polynomials
tripdobl_complex_laurentials_io   : i/o for tripdobl complex Laurentials
tripdobl_complex_poly_systems     : systems of tripdobl complex polynomials
tripdobl_complex_poly_systems_io  : i/o for tripdobl complex poly systems
tripdobl_complex_jaco_matrices    : Jacobian matrices for tripdobl complex
tripdobl_complex_laur_systems_io  : i/o for tripdobl complex Laurent systems
tripdobl_complex_laur_systems     : systems of tripdobl complex Laurentials
tripdobl_polynomial_convertors    : converting tripdobl with double/multprec
test_tripdobl_polynomials         : tests on tripdobl polynomials
ts_tdpol                          : main test on tripdobl polynomials
penta_double_polynomials          : polynomials with penta double coeffs
penta_double_poly_systems         : poly systems with penta double coeffs
pentdobl_complex_polynomials      : polynomials with pentdobl complex coeffs
pentdobl_complex_poly_strings     : string representations of pd complex poly
pentdobl_complex_polynomials_io   : i/o for pentdobl complex polynomials
pentdobl_complex_laurentials      : pentdobl complex Laurent polynomials
pentdobl_complex_lauentials_io    : i/o for pentdobl complex Laurentials
pentdobl_complex_laur_strings     : string representations of pd Laurentials
pentdobl_complex_poly_systems     : systems of pentdobl complex polynomials
pentdobl_complex_poly_systems_io  : i/o for pentdobl complex poly systems
pentdobl_complex_jaco_matrices    : Jacobian matrices for pentdobl complex
pentdobl_complex_laur_systems     : systems of pentdobl complex Laurentials
pentdobl_complex_laur_systems_io  : i/o for pentdobl complex Laurent systems
pentdobl_polynomial_convertors    : converting pentdobl with double/multprec
test_pentdobl_polynomials         : tests on pentdobl polynomials
ts_pdpol                          : main test on pentdobl polynomials
octo_double_polynomials           : polynomials with octo double coeffs
octo_double_poly_systems          : poly systems with octo double coeffs
octodobl_complex_polynomials      : polynomials with octodobl complex coeffs
octodobl_complex_polynomials_io   : i/o for octodobl complex polynomials
octodobl_complex_poly_strings     : string representations of od complex poly
octodobl_complex_laurentials      : octodobl complex Laurent polynomials
octodobl_complex_laurentials_io   : i/o for octodobl complex Laurentials
octodobl_complex_laur_strings     : string representations of od Laurentials
octodobl_complex_poly_systems     : systems of octodobl complex polynomials
octodobl_complex_poly_systems_io  : basic output for od complex poly systems
octodobl_complex_jaco_matrices    : Jacobian matrices for octodobl complex
octodobl_complex_laur_systems     : systems of octodobl complex Laurentials
octodobl_complex_laur_systems_io  : i/o for octodobl complex Laurent systems
octodobl_polynomial_convertors    : converting octodobl with double/multprec
test_octodobl_polynomials         : tests on octodobl polynomials
ts_odpol                          : main test on octodobl polynomials
deca_double_polynomials           : polynomials with deca double coeffs
deca_double_poly_systems          : poly systems with deca double coeffs
decadobl_complex_polynomials      : polynomials with decadobl complex coeffs
decadobl_complex_polynomials_io   : i/o for decadobl complex polynomials
decadobl_complex_poly_strings     : string representations of da complex poly
decadobl_complex_laurentials      : decadobl complex Laurent polynomials
decadobl_complex_laurentials_io   : i/o for decadobl complex Laurentials
decadobl_complex_laur_strings     : string representations of da Laurentials
decadobl_complex_poly_systems     : systems of decadobl complex polynomials
decadobl_complex_poly_systems_io  : basic output for da complex poly systems
decadobl_complex_jaco_matrices    : Jacobian matrices for decadobl complex
decadobl_complex_laur_systems     : systems of decadobl complex Laurentials
decadobl_complex_laur_systems_io  : i/o for decadobl complex Laurent systems
decadobl_polynomial_convertors    : converting decadobl with double/multprec
test_decadobl_polynomials         : tests on decadobl polynomials
ts_dapol                          : main test on decadobl polynomials
hexa_double_polynomials           : polynomials with hexa double coeffs
hexa_double_poly_systems          : poly systems with hexa double coeffs
hexadobl_complex_polynomials      : polynomials with hexadobl complex coeffs
hexadobl_complex_polynomials_io   : i/o for hexadobl complex polynomials
hexadobl_complex_poly_strings     : string representations of hd complex poly
hexadobl_complex_laurentials      : hexadobl complex Laurent polynomials
hexadobl_complex_laurentials_io   : i/o for hexadobl complex Laurentials
hexadobl_complex_laur_strings     : string representations of hd Laurentials
hexadobl_complex_poly_systems     : systems of hexadobl complex polynomials
hexadobl_complex_poly_systems_io  : basic output for da complex poly systems
hexadobl_complex_jaco_matrices    : Jacobian matrices for hexadobl complex
hexadobl_complex_laur_systems     : systems of hexadobl complex Laurentials
hexadobl_complex_laur_systems_io  : i/o for hexadobl complex Laurent systems
hexadobl_polynomial_convertors    : converting hexadobl with double/multprec
test_hexadobl_polynomials         : tests on hexadobl polynomials
ts_dapol                          : main test on decadobl polynomials
-------------------------------------------------------------------------------
tripdobl_complex_poly_randomizers : randomize coeffs of tripdobl polynomials
quaddobl_complex_poly_randomizers : randomize coeffs of quaddobl polynomials
pentdobl_complex_poly_randomizers : randomize coeffs of pentdobl polynomials
octodobl_complex_poly_randomizers : randomize coeffs of octodobl polynomials
decadobl_complex_poly_randomizers : randomize coeffs of decadobl polynomials
hexadobl_complex_poly_randomizers : randomize coeffs of hexadobl polynomials
-------------------------------------------------------------------------------
tripdobl_random_polynomials       : random polynomials in tripdobl precision
pentdobl_random_polynomials       : random polynomials in pentdobl precision
octodobl_random_polynomials       : random polynomials in octodobl precision
decadobl_random_polynomials       : random polynomials in decadobl precision
hexadobl_random_polynomials       : random polynomials in hexadobl precision
random_polynomial_systems         : interactive generation of random systems
test_tripdobl_random_systems      : tests random tripdobl polynomial systems
test_pentdobl_random_systems      : tests random pentdobl polynomial systems
test_octodobl_random_systems      : tests random octodobl polynomial systems
test_decadobl_random_systems      : tests random decadobl polynomial systems
test_hexadobl_random_systems      : tests random hexadobl polynomial systems
-------------------------------------------------------------------------------
generic_hessian_matrices          : basic computation of Hessian matrix
standard_complex_hessians         : Hessians in standard double precision
dobldobl_complex_hessians         : Hessians in double double precision
quaddobl_complex_hessians         : Hessians in quad double precision
ts_hessian                        : test on Hessian matrices
-------------------------------------------------------------------------------
test_parse_polynomials            : tests for parsing string to polynomials
-------------------------------------------------------------------------------
ts_poly                           : test on polynomials and polynomial systems
ts_rpol                           : test polynomials with real coefficients
ts_laurpoly                       : test on Laurent polynomials and systems
ts_laurlist                       : basic test on lists of Laurent polynomials
ts_randpoly                       : test on random polynomial generation
ts_tabform                        : test on tableau format
ts_jaco                           : test on Jacobian matrices
ts_parse                          : test on poly-string conversions
ts_subs                           : test on substitution of variables
ts_ddpol                          : test on double double polynomials
ts_qdpol                          : test on quad double polynomials
ts_termlist                       : tests on lists of terms
ts_rwspol                         : test on writing, for long polynomials
-------------------------------------------------------------------------------
parse_strings_to_polynomials      : to parse strings into a system and phc -g
symbol_table_order                : writes the symbol table, for phc -o
-------------------------------------------------------------------------------
The i/o-routines provide readable formats in symbolic form.

We can take advantage of the way vectors and matrices have been created:
a polynomial system is an instance of a polynomial vector and
a matrix with all partial derivatives is an instance of a polynomial matrix.

The package generic_polynomials allow to define polynomial rings.
Jacobian matrices are implemented by means of generics.  Their main usage
is towards evaluation.  Therefore, the type to represent a Jacobian matrix
is just a two-dimensional array of polynomials.  To perform algebraic
manipulations, one should convert to the matrix type of the package matrices
instantiated with the polynomial ring.

The Laurent polynomials differ substantially from the usual polynomials:
(1) by the type definition of the exponents, and 
(2) require the instantiation of a field for the evaluation.
