Multivariate polynomials and polynomial systems over rings in PHCv2.3.22

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.

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

--------------------------------------------------------------------------------
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_polynomial_functions      : evaluation of polynomials
generic_laur_poly_functions       : evaluation of Laurent polynomials
generic_polynomial_systems        : systems of polynomials
generic_laur_poly_systems         : systems of Laurent polynomials
generic_poly_system_functions     : evaluation of systems of polynomials
generic_laur_system_functions     : evaluation of Laurent polynomial systems
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
--------------------------------------------------------------------------------
standard_complex_polynomials      : polynomials over standard complex numbers
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_laur_polys       : Laurent polynomials with standard complex
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_functions   : generic_polynomial_functions instantiated
standard_floating_poly_functions  : polynomial functions for standard floats
standard_complex_laur_functions   : generic_laur_poly_functions instantiated
standard_complex_poly_systems     : generic_polynomial_systems instantiated
standard_floating_poly_systems    : systems with real coefficients
standard_complex_poly_systems_io  : input/output for complex polynomial systems
standard_tableau_formats          : simple tableau format for polynomials
standard_complex_laur_systems     : generic_laur_poly_systems instantiated
standard_complex_poly_sysfun      : generic_poly_system_function instantiated
standard_floating_poly_sysfun     : systems of real polynomial functions
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
standard_to_multprec_convertors   : convert from standard to multiprecision
multprec_to_standard_convertors   : convert from multiprecision to standard
multprec_complex_polynomials      : polynomials over multiprec complex numbers
multprec_floating_polynomials     : polynomials with multiprec real coefficients
multprec_complex_to_real_poly     : type conversions for complex/real poly
multprec_complex_laur_polys       : 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_functions   : evaluating multprec complex polynomials
multprec_floating_poly_functions  : evaluating multprec floating polynomials
multprec_complex_poly_systems     : systems of multiprec complex polynomials
multprec_floating_poly_systems    : systems of multiprec floating polynomials
multprec_complex_poly_systems_io  : simple output of multprec systems
multprec_complex_poly_sysfun      : evaluating multprec complex poly systems
multprec_floating_poly_sysfun     : evaluating multprec floating poly systems
multprec_complex_jaco_matrices    : Jacobi matrices for multiprecision complex
multprec_floating_jaco_matrices   : Jacobi matrices for multiprecision real
multprec_complex_laur_systems     : multiprecision Laurent systems
exponent_vectors                  : management of exponents of a system
standard_evaluator_packages       : create package to evaluate systems
matrix_indeterminates             : manipulate symbols for xij
--------------------------------------------------------------------------------
ts_poly                           : test on polynomials and polynomial systems
ts_rpol                           : test polynomials with real coefficients
ts_randpoly                       : test on random polynomial generation
ts_tabform                        : test on tableau format
ts_jaco                           : test on Jacobian matrices
ts_evaline                        : calls the evaluator package
ts_parse                          : test on poly-string conversions
ts_subs                           : test on substitution of variables
--------------------------------------------------------------------------------
Three different representations of polynomials are implemented:
as a list of terms, a nested Horner scheme with fixed coefficients
and with parametric coefficients.
The latter provides an efficient way to evaluate coefficient homotopies.

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.
The package generic_polynomial_functions is used to evaluate polynomials.
In version one of PHC both the ring operations and evaluation routines
were united in one large package.  The current organization has the benefit
of separating evaluation from the definitions of vectors and matrices.
The evaluation by means of a function is also supported.

Since functions need separate data structures, separate packages are used,
instead of working with child units that could also have been used to create
a different view on the same data structure.

Also the polynomial systems have been implemented separately.

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.

Since the different ways to evaluate polynomials use different orders of
computation, the results may differ when mixed-precision arithmetic is used.

The Laurent polynomials only differ from the usual polynomials by the
type definition of the exponents and require the instantiation of a field
for evaluation.
