Next: DIVISION
Up: No Title
Previous: Variables
This part of the manual is dedicated to a description of each constituent of
GRÖBNER. The items are listed lexicographically, where uppercase letters come
before lowercase letters. The items are divided into several types, containing
- functions,
- predicates,
- virtual functions,
- virtual predicates,
- macros,
- constants, and
- global variables.
We particularly want to emphasize the subtle difference between functions and
macros taking arguments for further development of the system. Some
functions in GRÖBNER have the possibility to take a pointer to a
function as an argument. Be aware that you cannot pass the name of a
function, which is actually implemented as a macro taking arguments, on such
an occasion. This fact might be obvious for experienced C programmers, but it
might be worth mentioned explicitly for those not so familiar with
the C language, who should also be able to use and extend GRÖBNER.
- 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)
windsteiger wolfgang
Thu Sep 3 14:50:07 MDT 1998