Next: Contents
GRÖBNER:
A Library for Computing Gröbner Bases
based on SACLIB
Manual for Version 2.0
Wolfgang Windsteiger Bruno Buchberger
RISC-Linz
--
Research Institute for Symbolic Computation
Johannes Kepler Universität Linz
A-4040 Linz, Austria
Tel: +43 (732) 2468-9921, Fax: +43 (732) 2468-9930
email:
--
September 3, 1998
© GRÖBNER Copyright 1994 by the RISC-Linz
Institute The GRÖBNER system source code and User's Guide are made available free of
charge by the RISC-Linz Institute. Persons or
institutions receiving it are pledged not to distribute it to others.
Instead, individuals wishing to acquire the system should obtain it by
ftp directly from the RISC-Linz Institute, informing the Institute of the
acquisition. Thereby the GRÖBNER Group will know who has the system and be able
to inform all users of any corrections or newer versions.
Users are kindly asked to cite their use of the system in any resulting
publications or in any application packages built upon GRÖBNER. Neither GRÖBNER nor
any part thereof may be incorporated in any commercial software product
without the consent of the authors. Users developing non-commercial
application packages are kindly asked to inform us.
Requests or proposals for changes or additions to the
system will be welcomed and given consideration. GRÖBNER is offered without
warranty of any kind, either expressed or implied. However reports of bugs or
problems are encouraged.
Abstract:
Almost every Computer Algebra System contains some implementation
of the Gröbner bases algorithm . The present implementation has the following specific features:
- The source code is distributed and publically available free of charge.
- The library is written in C.
- A simple but efficient mechanism of polymorphism is
implemented that enables the user to adjust the library to a wide
variety of coefficient domains, power product and polynomial representations, admissible
orderings, selection strategies for pairs etc.
Thus, GRÖBNER should be a useful tool
- for those who want to do research in Gröbner bases theory and applications
and, hence, need access to all details of the implementation
- and also for those who want to apply the algorithm as a black box,
possibly as a subalgorithm in a larger implementation, and need high
efficiency.
- Contents
- List of Figures
- List of Tables
- User's Guide
- Reference Manual
- DIVISION
- EMPTY
- GB_criteria( PS F)
- GB_crude( PS F)
- GB_reduce_all( PS F)
- GB_small_pair_set( PS F)
- GROEBNER_VERSION_NUMBER
- NOGB
- REST( Word w)
- SACLIB_MEMORY
- S_polynomial_lp( LP lp1, LP lp2)
- S_polynomial_poly( Poly p1, Poly p2)
- ZERODIVISION
- absolute_ff( FF ff)
- absolute_rn( RN rn)
- all_reduced( PS reducibles, PS reducers, PS basis, PaS pairs)
- applied( UF uf, Word l)
- applied_iter( UF uf, Word l)
- applied_rec( UF uf, Word l)
- basis_module_syz( PS gb)
- canceled_multiples_pl( PL pl)
- canceled_multiples_ps( PS ps)
- chain_criterion( Pa pa, PS basis, Pa pair)
- coefficient( Mon m)
- coefficient_domain
- cofactors_pc( PC pc)
- combine_dpl( DPL dpl1, DPL dpl2)
- combine_pc( PC pc1, PC pc2)
- combine_ppoly( PPoly p1, PPoly p2)
- combine_poly( Poly p1, Poly p2)
- complete_normal_form_poly( Poly p, PS ps)
- completely_reduced_lpl( PL pl)
- completely_reduced_lps( PS ps)
- completely_reduced_pl( PL pl)
- completely_reduced_ps( PS ps)
- component_wise( BF bf, Word l1, Word l2)
- component_wise_iter( BF bf, Word l1, Word l2)
- component_wise_rec( BF bf, Word l1, Word l2)
- contains_pa( Pa pa, PS ps)
- contains_pas( PaS pas, Pa pa)
- criteria( LP lp1, LP lp2, PS G, PaS B)
- denominator_rf( RF rf)
- denominator_rn( RN rn)
- difference_coef( Coef c1, Coef c2)
- difference_dpl( DPL p1, DPL p2)
- difference_ff( FF ff1, FF ff2)
- difference_mon( Mon m1, Mon m2)
- difference_pc( PC pc1, PC pc2)
- difference_ppoly( PPoly p1, PPoly p2)
- difference_poly( Poly p1, Poly p2)
- difference_rf( RF rf1, RF rf2)
- difference_rn( RN r1, RN r2)
- difference_syz( Syz s1, Syz s2)
- empty_pl
- empty_ps
- error_in_groebner_
- expanded( Word element, Word list, BP comp)
- expanded_iter( Word element, Word list, BP comp)
- expanded_rec( Word element, Word list, BP comp)
- explicit_chain_criterion( LP lp1, LP lp2, PS G, PaS B)
- extension_syz( Syz s, PS gb)
- extract_info4groebner(int argc, char *argv[])
- first_pair_pas( PaS p)
- first_polynomial_pa( Pa p)
- head_reduced_lp( LP lp, PS ps)
- head_reduced_poly( Poly p, PS ps)
- init_groebner_globals()
- initial_pairs( PS ps)
- initial_pairs_with_criteria( PS ps)
- initial_pairs_with_product_criterion( PS ps)
- initialized_dpl( DPL p, int pos, int total)
- initialized_pc( PPoly p, int pos, int total)
- initialized_ppoly( PPoly p, int pos, int total)
- initialized_pl( PL pl)
- initialized_poly( PPoly p, int pos, int total)
- initialized_ps( PS ps)
- insert_lpl( LP lp, PL pl)
- insert_lps( LP lp, PS ps)
- insert_ppoly_pl( PPoly p, PL pl)
- insert_ppoly_ps( PPoly p, PS ps)
- insert_pl( Poly p, PL pl)
- insert_ps( Poly p, PS ps)
- inter_reduced_ps( PS ps)
- inverse_coef( Coef c)
- inverse_ff( FF ff)
- inverse_rf( RF rf)
- inverse_rn( RN r)
- is_disjoint_el( EL el1, EL el2)
- is_disjoint_pp( PP pp1, PP pp2)
- is_empty_pas( PaS pas)
- is_empty_pl( PL pl)
- is_empty_ps( PS ps)
- is_equal_coef( Coef c1, Coef c2)
- is_equal_dpl( DPL p1, DPL p2)
- is_equal_el( EL el1, EL el2)
- is_equal_ff( FF ff1, FF ff2)
- is_equal_int( Int i1, Int i2)
- is_equal_lp( LP lp1, LP lp2)
- is_equal_pa( Pa pa1, Pa pa2)
- is_equal_pc( PC pc1, PC pc2)
- is_equal_poly( Poly p1, Poly p2)
- is_equal_pp( PP pp1, PP pp2)
- is_equal_ppoly( PPoly p1, PPoly p2)
- is_equal_rf( RF rf1, RF rf2)
- is_equal_rn( RN r1, RN r2)
- is_equal_syz( Syz s1, Syz s2)
- is_greater_mon( Mon m1, Mon m2)
- is_greater_mon_pair_order( Mon m1, Mon m2)
- is_greater_rn( RN r1, RN r2)
- is_labeled_lcm_greater( Pa p1, Pa p2)
- is_labeled_pa_greater( Pa p1, Pa p2)
- is_lcm_greater( Pa p1, Pa p2)
- is_leading_monomial_greater_dpl( DPL p1, DPL p2)
- is_leading_monomial_greater_lp( LP lp1, LP lp2)
- is_leading_monomial_greater_pc( PC pc1, PC pc2)
- is_leading_monomial_greater_poly( Poly p1, Poly p2)
- is_leading_monomial_greater_ppoly( PPoly p1, PPoly p2)
- is_leading_monomial_multiple_dpl( DPL p1, DPL p2)
- is_leading_monomial_multiple_lp( LP lp1, LP lp2)
- is_leading_monomial_multiple_pc( PC pc1, PC pc2)
- is_leading_monomial_multiple_poly( Poly p1, Poly p2)
- is_leading_monomial_multiple_ppoly( PPoly p1, PPoly p2)
- is_lexical_greater_el( EL el1, EL el2)
- is_lexical_greater_mon( Mon m1, Mon m2)
- is_lexical_greater_pp( PP pp1, PP pp2)
- is_matrix_greater_el( EL el1, EL el2)
- is_matrix_greater_mon( Mon m1, Mon m2)
- is_matrix_greater_pp( PP pp1, PP pp2)
- is_multiple_el( EL el1, EL el2)
- is_multiple_mon( Mon m1, Mon m2)
- is_multiple_pp( PP pp1, PP pp2)
- is_negative_coef( Coef c)
- is_negative_ff( FF ff)
- is_negative_int( Int i)
- is_negative_mon( Mon m)
- is_negative_rf( RF rf)
- is_negative_rn( RN r)
- is_one_coef( Coef c)
- is_one_el( EL el)
- is_one_ff( FF ff)
- is_one_int( Int i)
- is_one_pp( PP pp)
- is_one_rf( RF rf)
- is_one_rn( RN r)
- is_pa_greater( Pa p1, Pa p2)
- is_positive_coef( Coef c)
- is_positive_ff( FF ff)
- is_positive_rf( RF rf)
- is_positive_rn( RN r)
- is_total_degree_inverse_lexical_ greater_el( EL el1, EL el2)
- is_total_degree_inverse_lexical_ greater_mon( Mon m1, Mon m2)
- is_total_degree_inverse_lexical_ greater_pp( PP pp1, PP pp2)
- is_total_degree_lexical_greater_el( EL el1, EL el2)
- is_total_degree_lexical_greater_mon( Mon m1, Mon m2)
- is_total_degree_lexical_greater_pp( PP pp1, PP pp2)
- is_zero_coef( Coef c)
- is_zero_ff( FF ff)
- is_zero_int( Int i)
- is_zero_lp( LP lp)
- is_zero_mon( Mon m)
- is_zero_pc( PC pc)
- is_zero_poly( Poly p)
- is_zero_ppoly( PPoly p)
- is_zero_rf( RF rf)
- is_zero_rn( RN r)
- is_zero_syz( Syz s)
- label( LP lp)
- label_
- labeled_pl( PL pl)
- labeled_poly( Poly p)
- labeled_ps( PS ps)
- lcm_coef( Coef c1, Coef c2)
- lcm_denominator_rf( RF rf1, RF rf2)
- lcm_el( EL el1, EL el2)
- lcm_ff( FF ff1, FF ff2)
- lcm_mon( Mon m1, Mon m2)
- lcm_pp( PP pp1, PP pp2)
- lcm_rf( RF rf1, RF rf2)
- lcm_rn( RN r1, RN r2)
- leading_coefficient( Poly p)
- leading_coefficient_dpl( DPL dpl)
- leading_coefficient_lp( LP lp)
- leading_coefficient_pc( PC pc)
- leading_coefficient_ppoly( PPoly p)
- leading_monomial( Poly p)
- leading_monomial_dpl( DPL dpl)
- leading_monomial_lp( LP lp)
- leading_monomial_pc( PC pc)
- leading_monomial_ppoly( PPoly p)
- leading_power_product( Poly p)
- leading_power_product_dpl( DPL dpl)
- leading_power_product_lp( LP lp)
- leading_power_product_pc( PC pc)
- leading_power_product_ppoly( PPoly p)
- merged( Word l1, Word l2, BP comp, BF f, UP cancel)
- merged_disjunct( Word l1, Word l2, BP comp)
- merged_disjunct_iter( Word l1, Word l2, BP comp)
- merged_disjunct_rec( Word l1, Word l2, BP comp)
- merged_iter( Word l1, Word l2, BP comp, BF f, UP cancel)
- merged_rec( Word l1, Word l2, BP comp, BF f, UP cancel)
- modulus_
- negative_coef( Coef c)
- negative_dpl( DPL p)
- negative_ff( FF ff)
- negative_int( i)
- negative_mon( Mon m)
- negative_pc( PC pc)
- negative_poly( Poly p)
- negative_ppoly( PPoly p)
- negative_rf( RF rf)
- negative_rn( RN r)
- negative_syz( Syz s)
- new_pair( LP lp1, LP lp2)
- new_pairs( Poly p, PS ps)
- normal_form_algorithm
- normal_form_lp( LP lp, PS ps)
- normal_form_poly( Poly p, PS ps)
- normalized_dpl( DPL p)
- normalized_pc( PC pc)
- PL normalized_pl( PL pl)
- normalized_poly( Poly p)
- normalized_ppoly( PPoly p)
- normalized_ps( PS ps)
- normalized_rf( RF rf)
- normalizer_coef( Coef c)
- normalizer_ff( FF ff)
- normalizer_rf( RF rf)
- normalizer_rn( RN r)
- number_of_field_variables_
- numerator_rf( RF rf)
- numerator_rn( RN r)
- one_coef( Coef c)
- one_dpl( DPL p)
- one_el( EL el)
- one_ff( FF ff)
- one_int( Int i)
- one_mon( Mon m)
- one_ppoly( PPoly p)
- one_pp( PP pp)
- one_rf( RF rf)
- one_rn( RN r)
- order_matrix_
- pair_ordering
- pair_set( PS ps)
- pair_strategy
- partial_normal_form_poly( Poly p, PS ps)
- poly_extracted_pl( PL pl)
- poly_extracted_ps( PS ps)
- poly_structure
- polynomial_dpl( DPL p)
- polynomial_lp( LP lp)
- polynomial_pc( PC pc)
- polynomial_ppoly( PPoly p)
- polynomial_poly( Poly p)
- prepend_monomial( Mon m, Poly p)
- prepend_monomial_dpl( Mon m, DPL p)
- prepend_monomial_pc( Mon m, PC pc)
- prepend_monomial_ppoly( Mon m, PPoly p)
- product_coef( Coef c1, Coef c2)
- product_coef_dpl( Coef c, DPL p)
- product_coef_mon( Coef c, Mon m)
- product_coef_pc( Coef c, PC pc)
- product_coef_poly( Coef c, Poly p)
- product_coef_ppoly( Coef c, PPoly p)
- product_criterion( LP lp1, LP lp2)
- product_dpl( DPL p1, DPL p2)
- product_el( EL el1, EL el2)
- product_ff( FF ff1, FF ff2)
- product_mon( Mon m1, Mon m2)
- product_mon_dpl( Mon m, DPL p)
- product_mon_pc( Mon m, PC pc)
- product_mon_ppoly( Mon m, PPoly p)
- product_mon_poly( Mon m, Poly p)
- product_monic_mon( Mon m1, Mon m2)
- product_monic_mon_dpl( Mon m, DPL p)
- product_monic_mon_pc( Mon m, PC pc)
- product_monic_mon_ppoly( Mon m, PPoly p)
- product_monic_mon_poly( Mon m, Poly p)
- product_neg_monic_mon( Mon m1, Mon m2)
- product_neg_monic_mon_dpl( Mon m, DPL p)
- product_neg_monic_mon_pc( Mon m, PC pc)
- product_neg_monic_mon_ppoly( Mon m, PPoly p)
- product_neg_monic_mon_poly( Mon m, Poly p)
- product_ppoly( PPoly p1, PPoly p2)
- product_pp( PP pp1, PP pp2)
- product_rf( RF rf1, RF rf2)
- product_rn( RN r1, RN r2)
- pure_poly_representation
- quotient_coef( Coef c1, Coef c2)
- quotient_dpl( DPL p1, DPL p2)
- quotient_el( EL el1, EL el2)
- quotient_ff( FF ff1, FF ff2)
- quotient_monic_mon( Mon m1, Mon m2)
- quotient_ppoly( PPoly p1, PPoly p2)
- quotient_pp( PP pp1, PP pp2)
- quotient_rf( RF rf1, RF rf2)
- quotient_rn( RN r1, RN r2)
- rational_function( Word n, Word d)
- remaining_pairs_pas( PaS pas)
- remaining_polynomial( Poly p)
- remaining_polynomial_dpl( DPL p)
- remaining_polynomial_lp( LP lp)
- remaining_polynomial_pc( PC pc)
- remaining_polynomial_ppoly( PPoly p)
- singleton( Word w)
- split( Word element, Word list, BP rel)
- split_iter( Word element, Word list, BP rel)
- split_rec( Word element, Word list, BP rel)
- start_groebner()
- step( BF bf, Word o, Word l)
- step_iter( BF bf, Word o, Word l)
- step_rec( BF bf, Word o, Word l)
- sum_coef( Coef c1, Coef c2)
- sum_dpl( DPL p1, DPL p2)
- sum_ff( FF ff1, FF ff2)
- sum_mon( Mon m1, Mon m2)
- sum_pc( PC pc1, PC pc2)
- sum_ppoly( PPoly p1, PPoly p2)
- sum_poly( Poly p1, Poly p2)
- sum_rf( RF rf1, RF rf2)
- sum_rn( RN r1, RN r2)
- sum_syz( Syz s1, Syz s2)
- thinned_by_chain_criterion( PaS pair_set, PS basis, Pa pair)
- thinned( Word element, Word list, BP rel)
- thinned_iter( Word element, Word list, BP rel)
- thinned_pairs( PS ps, PaS pairs)
- thinned_rec( Word element, Word list, BP rel)
- triangle_criterion( Pa pa, LP lp, Pa pair)
- trivial_pair( )
- unlabeled_lp( LP lp)
- unlabeled_pl( PL pl)
- unlabeled_ps( PS ps)
- updated_pairs( PaS pairs, PS ps, LP lp)
- updated_pairs_with_product_criterion( PaS pairs, PS ps, LP lp)
- zero_coef( Coef c)
- zero_dpl( DPL p)
- zero_ff( FF ff)
- zero_pc( PC pc)
- zero_ppoly( PPoly p)
- zero_poly( Poly p)
- zero_rf( RF rf)
- zero_rn( RN r)
- zero_syz( Syz s)
- References
- Index
- About this document ...
Next: Contents
windsteiger wolfgang
Thu Sep 3 14:50:07 MDT 1998