Return to READ_ME CVS log

Up to [local] / OpenXM_contrib / PHC / Ada / Math_Lib / Polynomials

Annotation of OpenXM_contrib/PHC/Ada/Math_Lib/Polynomials/READ_ME, Revision 1.1

1.1     ! maekawa     1: Multivariate polynomials and polynomial systems over rings/fields in PHCv2.
        !             2:
        !             3: New in this release is the availability of multi-precision numbers.
        !             4: The data structures are entirely redefined using Ada 95 concepts.
        !             5:
        !             6: This library is organized in three parts:
        !             7: 1) generic packages: polynomials and systems
        !             8: 2) instantiations
        !             9: 3) utilities
        !            10:
        !            11: --------------------------------------------------------------------------------
        !            12: file name                         : short description
        !            13: --------------------------------------------------------------------------------
        !            14: generic_lists                     : lists of items
        !            15: graded_lexicographic_order        : defines the order of monomials
        !            16: generic_polynomials               : generic polynomials in several variables
        !            17: generic_laurent_polynomials       : generic polynomials with integer exponents
        !            18: generic_polynomial_functions      : evaluation of polynomials
        !            19: generic_laur_poly_functions       : evaluation of Laurent polynomials
        !            20: generic_polynomial_systems        : systems of polynomials
        !            21: generic_laur_poly_systems         : systems of Laurent polynomials
        !            22: generic_poly_system_functions     : evaluation of systems of polynomials
        !            23: generic_laur_system_functions     : evaluation of Laurent polynomial systems
        !            24: generic_jacobian_matrices         : Jacobian matrices of polynomial systems
        !            25: generic_laur_jaco_matrices        : Jacobian matrices of Laurent systems
        !            26: symbol_table                      : management of table of symbols
        !            27: symbol_table_io                   : input/output of symbols
        !            28: --------------------------------------------------------------------------------
        !            29: standard_complex_polynomials      : polynomials over standard complex numbers
        !            30: standard_complex_polynomials_io   : input/output of complex polynomials
        !            31: standard_complex_laur_polys       : Laurent polynomials with standard complex
        !            32: standard_complex_poly_ring        : abstract_ring(standard complex poly)
        !            33: standard_complex_poly_ring_io     : abstract_ring_io(standard complex poly)
        !            34: standard_complex_poly_vectors     : generic_vectors(standard complex poly)
        !            35: standard_complex_poly_vectors_io  : generic_vectors_io(standard complex poly)
        !            36: standard_complex_poly_matrices    : generic_matrices(standard complex poly)
        !            37: standard_complex_poly_matrices_io : generic_matrices_io(standard complex poly)
        !            38: standard_complex_poly_functions   : generic_polynomial_functions instantiated
        !            39: standard_complex_laur_functions   : generic_laur_poly_functions instantiated
        !            40: standard_complex_poly_systems     : generic_polynomial_systems instantiated
        !            41: standard_complex_poly_systems_io  : input/output for complex polynomial systems
        !            42: standard_complex_laur_systems     : generic_laur_poly_systems instantiated
        !            43: standard_complex_poly_sysfun      : generic_poly_system_function instantiated
        !            44: standard_complex_jaco_matrices    : generic_jacobian_matrices instantiated
        !            45: standard_complex_poly_randomizers : randomize coefficients of polynomials
        !            46: standard_complex_laur_randomizers : randomize coefficients of polynomials
        !            47: standard_complex_substitutors     : substitute equations into polynomials
        !            48: standard_poly_laur_convertors     : convert polynomials to Laurent polynomials
        !            49: standard_laur_poly_convertors     : convert Laurent polynomials to polynomials
        !            50: multprec_complex_polynomials      : polynomials over multiprec complex numbers
        !            51: multprec_complex_laur_polys       : Laurent polynomials over multprec complex
        !            52: multprec_complex_poly_functions   : evaluating multprec complex polynomials
        !            53: multprec_complex_poly_systems     : systems of multiprec complex polynomials
        !            54: multprec_complex_poly_sysfun      : evaluating multprec complex poly systems
        !            55: multprec_complex_jaco_matrices    : Jacobian matrices of multiprec systems
        !            56: multprec_complex_laur_systems     : multi-precision Laurent systems
        !            57: exponent_vectors                  : management of exponents of a system
        !            58: standard_evaluator_packages       : create package to evaluate systems
        !            59: matrix_indeterminates             : manipulate symbols for xij
        !            60: --------------------------------------------------------------------------------
        !            61: ts_poly                           : test on polynomials and polynomial systems
        !            62: ts_jaco                           : test on Jacobian matrices
        !            63: ts_evaline                        : calls the evaluator package
        !            64: --------------------------------------------------------------------------------
        !            65: Three different representations of polynomials are implemented:
        !            66: as a list of terms, a nested Horner scheme with fixed coefficients
        !            67: and with parametric coefficients.
        !            68: The latter provides an efficient way to evaluate coefficient homotopies.
        !            69:
        !            70: The i/o-routines provide readable formats in symbolic form.
        !            71:
        !            72: We can take advantage of the way vectors and matrices have been created:
        !            73: a polynomial system is an instance of a polynomial vector and
        !            74: a matrix with all partial derivatives is an instance of a polynomial matrix.
        !            75:
        !            76: The package generic_polynomials allow to define polynomial rings.
        !            77: The package generic_polynomial_functions is used to evaluate polynomials.
        !            78: In version one of PHC both the ring operations and evaluation routines
        !            79: were united in one large package.  The current organization has the benefit
        !            80: of separating evaluation from the definitions of vectors and matrices.
        !            81: The evaluation by means of a function is also supported.
        !            82:
        !            83: Since functions need separate data structures, separate packages are used,
        !            84: instead of working with child units that could also have been used to create
        !            85: a different view on the same data structure.
        !            86:
        !            87: Also the polynomial systems have been implemented separately.
        !            88:
        !            89: Jacobian matrices are implemented by means of generics.  Their main usage
        !            90: is towards evaluation.  Therefore, the type to represent a Jacobian matrix
        !            91: is just a two-dimensional array of polynomials.  To perform algebraic
        !            92: manipulations, one should convert to the matrix type of the package matrices
        !            93: instantiated with the polynomial ring.
        !            94:
        !            95: Since the different ways to evaluate polynomials use different orders of
        !            96: computation, the results may differ when mixed-precision arithmetic is used.
        !            97:
        !            98: The Laurent polynomials only differ from the usual polynomials by the
        !            99: type definition of the exponents and require the instantiation of a field
        !           100: for evaluation.
        !           101:
        !           102: wc *adb counts 7032 lines of Ada code