Data Structures | Macros | Typedefs | Enumerations | Functions | Variables
coeffs.h File Reference

Coefficient rings, fields and other domains suitable for Singular polynomials. More...

#include <misc/auxiliary.h>
#include <omalloc/omalloc.h>
#include <misc/sirandom.h>
#include <reporter/reporter.h>
#include <reporter/s_buff.h>
#include <factory/factory.h>
#include <coeffs/si_gmp.h>
#include <coeffs/Enumerator.h>
#include <coeffs/numstats.h>

Go to the source code of this file.

Data Structures

struct  GFInfo
 Creation data needed for finite fields. More...
 
struct  LongComplexInfo
 
struct  coeffs
 

Macros

#define FREE_RNUMBER(x)   omFreeBin((void *)x, rnumber_bin)
 
#define ALLOC_RNUMBER()   (number)omAllocBin(rnumber_bin)
 
#define ALLOC0_RNUMBER()   (number)omAlloc0Bin(rnumber_bin)
 
#define n_New(n, r)   nNew(n)
 
#define n_Test(a, r)   n_DBTest(a, __FILE__, __LINE__, r)
 BOOLEAN n_Test(number a, const coeffs r) More...
 

Typedefs

typedef number(* numberfunc) (number a, number b, const coeffs r)
 
typedef number(* nMapFunc) (number a, const coeffs src, const coeffs dst)
 maps "a", which lives in src, into dst More...
 
typedef IEnumerator< number > ICoeffsEnumerator
 Abstract interface for an enumerator of number coefficients for an object, e.g. a polynomial. More...
 
typedef void(* nCoeffsEnumeratorFunc) (ICoeffsEnumerator &numberCollectionEnumerator, number &output, const coeffs r)
 goes over coeffs given by the ICoeffsEnumerator and changes them. Additionally returns a number; More...
 

Enumerations

enum  n_coeffType {
  n_unknown =0, n_Zp, n_Q, n_R,
  n_GF, n_long_R, n_algExt, n_transExt,
  n_long_C, n_Z, n_Zn, n_Znm,
  n_Z2m, n_CF
}
 
enum  n_coeffRep {
  n_rep_unknown =0, n_rep_int, n_rep_gap_rat, n_rep_gap_gmp,
  n_rep_poly, n_rep_rat_fct, n_rep_gmp, n_rep_float,
  n_rep_gmp_float, n_rep_gmp_complex, n_rep_gf
}
 

Functions

static FORCE_INLINE n_coeffType getCoeffType (const coeffs r)
 Returns the type of coeffs domain. More...
 
coeffs nInitChar (n_coeffType t, void *parameter)
 one-time initialisations for new coeffs in case of an error return NULL More...
 
static FORCE_INLINE coeffs nCopyCoeff (const coeffs r)
 "copy" coeffs, i.e. increment ref More...
 
void nKillChar (coeffs r)
 undo all initialisations More...
 
static FORCE_INLINE void nSetChar (const coeffs r)
 initialisations after each ring change More...
 
void nNew (number *a)
 
static FORCE_INLINE int n_GetChar (const coeffs r)
 Return the characteristic of the coeff. domain. More...
 
static FORCE_INLINE number n_Copy (number n, const coeffs r)
 return a copy of 'n' More...
 
static FORCE_INLINE void n_Delete (number *p, const coeffs r)
 delete 'p' More...
 
static FORCE_INLINE BOOLEAN n_Equal (number a, number b, const coeffs r)
 TRUE iff 'a' and 'b' represent the same number; they may have different representations. More...
 
static FORCE_INLINE BOOLEAN n_IsZero (number n, const coeffs r)
 TRUE iff 'n' represents the zero element. More...
 
static FORCE_INLINE BOOLEAN n_IsOne (number n, const coeffs r)
 TRUE iff 'n' represents the one element. More...
 
static FORCE_INLINE BOOLEAN n_IsMOne (number n, const coeffs r)
 TRUE iff 'n' represents the additive inverse of the one element, i.e. -1. More...
 
static FORCE_INLINE BOOLEAN n_GreaterZero (number n, const coeffs r)
 ordered fields: TRUE iff 'n' is positive; in Z/pZ: TRUE iff 0 < m <= roundedBelow(p/2), where m is the long representing n in C: TRUE iff (Im(n) != 0 and Im(n) >= 0) or (Im(n) == 0 and Re(n) >= 0) in K(a)/<p(a)>: TRUE iff (n != 0 and (LC(n) > 0 or deg(n) > 0)) in K(t_1, ..., t_n): TRUE iff (LC(numerator(n) is a constant and > 0) or (LC(numerator(n) is not a constant) in Z/2^kZ: TRUE iff 0 < n <= 2^(k-1) in Z/mZ: TRUE iff the internal mpz is greater than zero in Z: TRUE iff n > 0 More...
 
static FORCE_INLINE BOOLEAN n_Greater (number a, number b, const coeffs r)
 ordered fields: TRUE iff 'a' is larger than 'b'; in Z/pZ: TRUE iff la > lb, where la and lb are the long's representing More...
 
static FORCE_INLINE BOOLEAN n_IsUnit (number n, const coeffs r)
 TRUE iff n has a multiplicative inverse in the given coeff field/ring r. More...
 
static FORCE_INLINE coeffs n_CoeffRingQuot1 (number c, const coeffs r)
 
static FORCE_INLINE int n_DivComp (number a, number b, const coeffs r)
 
static FORCE_INLINE number n_GetUnit (number n, const coeffs r)
 in Z: 1 in Z/kZ (where k is not a prime): largest divisor of n (taken in Z) that is co-prime with k in Z/2^kZ: largest odd divisor of n (taken in Z) other cases: not implemented More...
 
static FORCE_INLINE number n_Init (long i, const coeffs r)
 a number representing i in the given coeff field/ring r More...
 
static FORCE_INLINE number n_InitMPZ (mpz_t n, const coeffs r)
 conversion of a GMP integer to number More...
 
static FORCE_INLINE long n_Int (number &n, const coeffs r)
 conversion of n to an int; 0 if not possible in Z/pZ: the representing int lying in (-p/2 .. p/2] More...
 
static FORCE_INLINE void n_MPZ (mpz_t result, number &n, const coeffs r)
 conversion of n to a GMP integer; 0 if not possible More...
 
static FORCE_INLINE number n_InpNeg (number n, const coeffs r)
 in-place negation of n MUST BE USED: n = n_InpNeg(n) (no copy is returned) More...
 
static FORCE_INLINE number n_Invers (number a, const coeffs r)
 return the multiplicative inverse of 'a'; raise an error if 'a' is not invertible More...
 
static FORCE_INLINE int n_Size (number n, const coeffs r)
 return a non-negative measure for the complexity of n; return 0 only when n represents zero; (used for pivot strategies in matrix computations with entries from r) More...
 
static FORCE_INLINE void n_Normalize (number &n, const coeffs r)
 inplace-normalization of n; produces some canonical representation of n; More...
 
static FORCE_INLINE void n_WriteLong (number &n, const coeffs r)
 write to the output buffer of the currently used reporter More...
 
static FORCE_INLINE void n_WriteShort (number &n, const coeffs r)
 write to the output buffer of the currently used reporter in a shortest possible way, e.g. in K(a): a2 instead of a^2 More...
 
static FORCE_INLINE void n_Write (number &n, const coeffs r, const BOOLEAN bShortOut=TRUE)
 
static FORCE_INLINE const char * n_Read (const char *s, number *a, const coeffs r)
 !!! Recommendation: This method is too cryptic to be part of the user- !!! interface. As defined here, it is merely a helper !!! method for parsing number input strings. More...
 
static FORCE_INLINE number n_GetDenom (number &n, const coeffs r)
 return the denominator of n (if elements of r are by nature not fractional, result is 1) More...
 
static FORCE_INLINE number n_GetNumerator (number &n, const coeffs r)
 return the numerator of n (if elements of r are by nature not fractional, result is n) More...
 
static FORCE_INLINE number n_Div (number a, number b, const coeffs r)
 return the quotient of 'a' and 'b', i.e., a/b; raises an error if 'b' is not invertible in r exception in Z: raises an error if 'a' is not divisible by 'b' More...
 
static FORCE_INLINE number n_ExactDiv (number a, number b, const coeffs r)
 assume that there is a canonical subring in cf and we know that division is possible for these a and b in the subring, n_ExactDiv performs it, may skip additional tests. Can always be substituted by n_Div at the cost of larger computing time. More...
 
static FORCE_INLINE number n_IntMod (number a, number b, const coeffs r)
 for r a field, return n_Init(0,r) otherwise: n_Div(a,b,r)*b+n_IntMod(a,b,r)==a More...
 
static FORCE_INLINE void n_Power (number a, int b, number *res, const coeffs r)
 fill res with the power a^b More...
 
static FORCE_INLINE number n_Mult (number a, number b, const coeffs r)
 return the product of 'a' and 'b', i.e., a*b More...
 
static FORCE_INLINE void n_InpMult (number &a, number b, const coeffs r)
 multiplication of 'a' and 'b'; replacement of 'a' by the product a*b More...
 
static FORCE_INLINE void n_InpAdd (number &a, number b, const coeffs r)
 addition of 'a' and 'b'; replacement of 'a' by the sum a+b More...
 
static FORCE_INLINE number n_Add (number a, number b, const coeffs r)
 return the sum of 'a' and 'b', i.e., a+b More...
 
static FORCE_INLINE number n_Sub (number a, number b, const coeffs r)
 return the difference of 'a' and 'b', i.e., a-b More...
 
static FORCE_INLINE number n_Gcd (number a, number b, const coeffs r)
 in Z: return the gcd of 'a' and 'b' in Z/nZ, Z/2^kZ: computed as in the case Z in Z/pZ, C, R: not implemented in Q: return the gcd of the numerators of 'a' and 'b' in K(a)/<p(a)>: not implemented in K(t_1, ..., t_n): not implemented More...
 
static FORCE_INLINE number n_SubringGcd (number a, number b, const coeffs r)
 
static FORCE_INLINE number n_ExtGcd (number a, number b, number *s, number *t, const coeffs r)
 beware that ExtGCD is only relevant for a few chosen coeff. domains and may perform something unexpected in some cases... More...
 
static FORCE_INLINE number n_XExtGcd (number a, number b, number *s, number *t, number *u, number *v, const coeffs r)
 
static FORCE_INLINE number n_EucNorm (number a, const coeffs r)
 
static FORCE_INLINE number n_Ann (number a, const coeffs r)
 if r is a ring with zero divisors, return an annihilator!=0 of b otherwise return NULL More...
 
static FORCE_INLINE number n_QuotRem (number a, number b, number *q, const coeffs r)
 
static FORCE_INLINE number n_Lcm (number a, number b, const coeffs r)
 in Z: return the lcm of 'a' and 'b' in Z/nZ, Z/2^kZ: computed as in the case Z in Z/pZ, C, R: not implemented in K(a)/<p(a)>: not implemented in K(t_1, ..., t_n): not implemented More...
 
static FORCE_INLINE number n_NormalizeHelper (number a, number b, const coeffs r)
 assume that r is a quotient field (otherwise, return 1) for arguments (a1/a2,b1/b2) return (lcm(a1,b2)/1) More...
 
static FORCE_INLINE nMapFunc n_SetMap (const coeffs src, const coeffs dst)
 set the mapping function pointers for translating numbers from src to dst More...
 
static FORCE_INLINE BOOLEAN n_DBTest (number n, const char *filename, const int linenumber, const coeffs r)
 test whether n is a correct number; only used if LDEBUG is defined More...
 
static FORCE_INLINE void n_CoeffWrite (const coeffs r, BOOLEAN details=TRUE)
 output the coeff description More...
 
static FORCE_INLINE BOOLEAN nCoeff_is_Ring_2toM (const coeffs r)
 
static FORCE_INLINE BOOLEAN nCoeff_is_Ring_ModN (const coeffs r)
 
static FORCE_INLINE BOOLEAN nCoeff_is_Ring_PtoM (const coeffs r)
 
static FORCE_INLINE BOOLEAN nCoeff_is_Ring_Z (const coeffs r)
 
static FORCE_INLINE BOOLEAN nCoeff_is_Ring (const coeffs r)
 
static FORCE_INLINE BOOLEAN nCoeff_is_Domain (const coeffs r)
 returns TRUE, if r is a field or r has no zero divisors (i.e is a domain) More...
 
static FORCE_INLINE BOOLEAN n_DivBy (number a, number b, const coeffs r)
 test whether 'a' is divisible 'b'; for r encoding a field: TRUE iff 'b' does not represent zero in Z: TRUE iff 'b' divides 'a' (with remainder = zero) in Z/nZ: TRUE iff (a = 0 and b divides n in Z) or (a != 0 and b/gcd(a, b) is co-prime with n, i.e. a unit in Z/nZ) in Z/2^kZ: TRUE iff ((a = 0 mod 2^k) and (b = 0 or b is a power of 2)) or ((a, b <> 0) and (b/gcd(a, b) is odd)) More...
 
static FORCE_INLINE number n_ChineseRemainderSym (number *a, number *b, int rl, BOOLEAN sym, CFArray &inv_cache, const coeffs r)
 
static FORCE_INLINE number n_Farey (number a, number b, const coeffs r)
 
static FORCE_INLINE int n_ParDeg (number n, const coeffs r)
 
static FORCE_INLINE int n_NumberOfParameters (const coeffs r)
 Returns the number of parameters. More...
 
static FORCE_INLINE char const ** n_ParameterNames (const coeffs r)
 Returns a (const!) pointer to (const char*) names of parameters. More...
 
static FORCE_INLINE number n_Param (const int iParameter, const coeffs r)
 return the (iParameter^th) parameter as a NEW number NOTE: parameter numbering: 1..n_NumberOfParameters(...) More...
 
static FORCE_INLINE number n_RePart (number i, const coeffs cf)
 
static FORCE_INLINE number n_ImPart (number i, const coeffs cf)
 
static FORCE_INLINE BOOLEAN nCoeff_has_Units (const coeffs r)
 returns TRUE, if r is not a field and r has non-trivial units More...
 
static FORCE_INLINE BOOLEAN nCoeff_is_Zp (const coeffs r)
 
static FORCE_INLINE BOOLEAN nCoeff_is_Zp (const coeffs r, int p)
 
static FORCE_INLINE BOOLEAN nCoeff_is_Q (const coeffs r)
 
static FORCE_INLINE BOOLEAN nCoeff_is_Q_or_BI (const coeffs r)
 
static FORCE_INLINE BOOLEAN nCoeff_is_numeric (const coeffs r)
 
static FORCE_INLINE BOOLEAN nCoeff_is_R (const coeffs r)
 
static FORCE_INLINE BOOLEAN nCoeff_is_GF (const coeffs r)
 
static FORCE_INLINE BOOLEAN nCoeff_is_GF (const coeffs r, int q)
 
static FORCE_INLINE BOOLEAN nCoeff_is_Extension (const coeffs r)
 
static FORCE_INLINE BOOLEAN nCoeff_is_Zp_a (const coeffs r)
 
static FORCE_INLINE BOOLEAN nCoeff_is_Zp_a (const coeffs r, int p)
 
static FORCE_INLINE BOOLEAN nCoeff_is_Q_a (const coeffs r)
 
static FORCE_INLINE BOOLEAN nCoeff_is_long_R (const coeffs r)
 
static FORCE_INLINE BOOLEAN nCoeff_is_long_C (const coeffs r)
 
static FORCE_INLINE BOOLEAN nCoeff_is_CF (const coeffs r)
 
static FORCE_INLINE BOOLEAN nCoeff_has_simple_inverse (const coeffs r)
 TRUE, if the computation of the inverse is fast, i.e. prefer leading coeff. 1 over content. More...
 
static FORCE_INLINE BOOLEAN nCoeff_has_simple_Alloc (const coeffs r)
 TRUE if n_Delete/n_New are empty operations. More...
 
static FORCE_INLINE BOOLEAN nCoeff_is_algExt (const coeffs r)
 TRUE iff r represents an algebraic extension field. More...
 
static FORCE_INLINE BOOLEAN nCoeff_is_Q_algext (const coeffs r)
 is it an alg. ext. of Q? More...
 
static FORCE_INLINE BOOLEAN nCoeff_is_transExt (const coeffs r)
 TRUE iff r represents a transcendental extension field. More...
 
static FORCE_INLINE void n_ClearContent (ICoeffsEnumerator &numberCollectionEnumerator, number &c, const coeffs r)
 Computes the content and (inplace) divides it out on a collection of numbers number c is the content (i.e. the GCD of all the coeffs, which we divide out inplace) NOTE: it assumes all coefficient numbers to be integer!!! NOTE/TODO: see also the description by Hans TODO: rename into n_ClearIntegerContent. More...
 
static FORCE_INLINE void n_ClearDenominators (ICoeffsEnumerator &numberCollectionEnumerator, number &d, const coeffs r)
 (inplace) Clears denominators on a collection of numbers number d is the LCM of all the coefficient denominators (i.e. the number with which all the number coeffs. were multiplied) NOTE/TODO: see also the description by Hans More...
 
static FORCE_INLINE void n_ClearContent (ICoeffsEnumerator &numberCollectionEnumerator, const coeffs r)
 
static FORCE_INLINE void n_ClearDenominators (ICoeffsEnumerator &numberCollectionEnumerator, const coeffs r)
 
void n_Print (number &a, const coeffs r)
 print a number (BEWARE of string buffers!) mostly for debugging More...
 
static FORCE_INLINE char * nCoeffString (const coeffs cf)
 TODO: make it a virtual method of coeffs, together with: Decompose & Compose, rParameter & rPar. More...
 
static FORCE_INLINE char * nCoeffName (const coeffs cf)
 
static FORCE_INLINE number n_Random (siRandProc p, number p1, number p2, const coeffs cf)
 
static FORCE_INLINE void n_WriteFd (number a, FILE *f, const coeffs r)
 io via ssi: More...
 
static FORCE_INLINE number n_ReadFd (s_buff f, const coeffs r)
 io via ssi: More...
 
number n_convFactoryNSingN (const CanonicalForm n, const coeffs r)
 
CanonicalForm n_convSingNFactoryN (number n, BOOLEAN setChar, const coeffs r)
 
static FORCE_INLINE void number2mpz (number n, coeffs c, mpz_t m)
 
static FORCE_INLINE number mpz2number (mpz_t m, coeffs c)
 

Variables

unsigned short fftable []
 
omBin rnumber_bin
 

Detailed Description

Coefficient rings, fields and other domains suitable for Singular polynomials.

The main interface for Singular coefficients: coeffs is the main handler for Singular numbers

Definition in file coeffs.h.


Data Structure Documentation

struct GFInfo

Creation data needed for finite fields.

Definition at line 91 of file coeffs.h.

Data Fields
int GFChar
int GFDegree
const char * GFPar_name
struct LongComplexInfo

Definition at line 98 of file coeffs.h.

Data Fields
short float_len additional char-flags, rInit
short float_len2 additional char-flags, rInit
const char * par_name parameter name

Macro Definition Documentation

#define ALLOC0_RNUMBER ( )    (number)omAlloc0Bin(rnumber_bin)

Definition at line 87 of file coeffs.h.

#define ALLOC_RNUMBER ( )    (number)omAllocBin(rnumber_bin)

Definition at line 86 of file coeffs.h.

#define FREE_RNUMBER (   x)    omFreeBin((void *)x, rnumber_bin)

Definition at line 85 of file coeffs.h.

#define n_New (   n,
  r 
)    nNew(n)

Definition at line 441 of file coeffs.h.

#define n_Test (   a,
  r 
)    n_DBTest(a, __FILE__, __LINE__, r)

BOOLEAN n_Test(number a, const coeffs r)

Definition at line 923 of file coeffs.h.

Typedef Documentation

typedef IEnumerator<number> ICoeffsEnumerator

Abstract interface for an enumerator of number coefficients for an object, e.g. a polynomial.

Definition at line 77 of file coeffs.h.

typedef void(* nCoeffsEnumeratorFunc) (ICoeffsEnumerator &numberCollectionEnumerator, number &output, const coeffs r)

goes over coeffs given by the ICoeffsEnumerator and changes them. Additionally returns a number;

Definition at line 81 of file coeffs.h.

typedef number(* nMapFunc) (number a, const coeffs src, const coeffs dst)

maps "a", which lives in src, into dst

Definition at line 72 of file coeffs.h.

typedef number(* numberfunc) (number a, number b, const coeffs r)

Definition at line 69 of file coeffs.h.

Enumeration Type Documentation

enum n_coeffRep
Enumerator
n_rep_unknown 
n_rep_int 

(int), see modulop.h

n_rep_gap_rat 

(number), see longrat.h

n_rep_gap_gmp 

(), see rinteger.h, new impl.

n_rep_poly 

(poly), see algext.h

n_rep_rat_fct 

(fraction), see transext.h

n_rep_gmp 

(mpz_ptr), see rmodulon,h

n_rep_float 

(float), see shortfl.h

n_rep_gmp_float 

(gmp_float), see

n_rep_gmp_complex 

(gmp_complex), see gnumpc.h

n_rep_gf 

(int), see ffields.h

Definition at line 106 of file coeffs.h.

107 {
108  n_rep_unknown=0,
109  n_rep_int, /**< (int), see modulop.h */
110  n_rep_gap_rat, /**< (number), see longrat.h */
111  n_rep_gap_gmp, /**< (), see rinteger.h, new impl. */
112  n_rep_poly, /**< (poly), see algext.h */
113  n_rep_rat_fct, /**< (fraction), see transext.h */
114  n_rep_gmp, /**< (mpz_ptr), see rmodulon,h */
115  n_rep_float, /**< (float), see shortfl.h */
116  n_rep_gmp_float, /**< (gmp_float), see */
117  n_rep_gmp_complex,/**< (gmp_complex), see gnumpc.h */
118  n_rep_gf /**< (int), see ffields.h */
119 };
(), see rinteger.h, new impl.
Definition: coeffs.h:111
(fraction), see transext.h
Definition: coeffs.h:113
(poly), see algext.h
Definition: coeffs.h:112
(gmp_complex), see gnumpc.h
Definition: coeffs.h:117
(mpz_ptr), see rmodulon,h
Definition: coeffs.h:114
(number), see longrat.h
Definition: coeffs.h:110
(gmp_float), see
Definition: coeffs.h:116
(int), see modulop.h
Definition: coeffs.h:109
(int), see ffields.h
Definition: coeffs.h:118
(float), see shortfl.h
Definition: coeffs.h:115
Enumerator
n_unknown 
n_Zp 

{p < 2^31}

n_Q 

rational (GMP) numbers

n_R 

single prescision (6,6) real numbers

n_GF 

{p^n < 2^16}

n_long_R 

real floating point (GMP) numbers

n_algExt 

used for all algebraic extensions, i.e., the top-most extension in an extension tower is algebraic

n_transExt 

used for all transcendental extensions, i.e., the top-most extension in an extension tower is transcendental

n_long_C 

complex floating point (GMP) numbers

n_Z 

only used if HAVE_RINGS is defined: ?

n_Zn 

only used if HAVE_RINGS is defined: ?

n_Znm 

only used if HAVE_RINGS is defined: ?

n_Z2m 

only used if HAVE_RINGS is defined: ?

n_CF 

?

Definition at line 27 of file coeffs.h.

28 {
29  n_unknown=0,
30  n_Zp, /**< \F{p < 2^31} */
31  n_Q, /**< rational (GMP) numbers */
32  n_R, /**< single prescision (6,6) real numbers */
33  n_GF, /**< \GF{p^n < 2^16} */
34  n_long_R, /**< real floating point (GMP) numbers */
35  n_algExt, /**< used for all algebraic extensions, i.e.,
36  the top-most extension in an extension tower
37  is algebraic */
38  n_transExt, /**< used for all transcendental extensions, i.e.,
39  the top-most extension in an extension tower
40  is transcendental */
41  n_long_C, /**< complex floating point (GMP) numbers */
42  n_Z, /**< only used if HAVE_RINGS is defined: ? */
43  n_Zn, /**< only used if HAVE_RINGS is defined: ? */
44  n_Znm, /**< only used if HAVE_RINGS is defined: ? */
45  n_Z2m, /**< only used if HAVE_RINGS is defined: ? */
46  n_CF /**< ? */
47 };
only used if HAVE_RINGS is defined: ?
Definition: coeffs.h:43
?
Definition: coeffs.h:46
only used if HAVE_RINGS is defined: ?
Definition: coeffs.h:45
used for all transcendental extensions, i.e., the top-most extension in an extension tower is transce...
Definition: coeffs.h:38
rational (GMP) numbers
Definition: coeffs.h:31
{p < 2^31}
Definition: coeffs.h:30
real floating point (GMP) numbers
Definition: coeffs.h:34
single prescision (6,6) real numbers
Definition: coeffs.h:32
only used if HAVE_RINGS is defined: ?
Definition: coeffs.h:44
complex floating point (GMP) numbers
Definition: coeffs.h:41
only used if HAVE_RINGS is defined: ?
Definition: coeffs.h:42
{p^n < 2^16}
Definition: coeffs.h:33
used for all algebraic extensions, i.e., the top-most extension in an extension tower is algebraic ...
Definition: coeffs.h:35

Function Documentation

static FORCE_INLINE n_coeffType getCoeffType ( const coeffs  r)
static

Returns the type of coeffs domain.

Definition at line 422 of file coeffs.h.

423 { assume(r != NULL); return r->type; }
#define assume(x)
Definition: mod2.h:405
#define NULL
Definition: omList.c:10
static FORCE_INLINE number mpz2number ( mpz_t  m,
coeffs  c 
)
static

Definition at line 992 of file coeffs.h.

992 { return n_InitMPZ(m, c); }
static FORCE_INLINE number n_InitMPZ(mpz_t n, const coeffs r)
conversion of a GMP integer to number
Definition: coeffs.h:543
int m
Definition: cfEzgcd.cc:119
static FORCE_INLINE number n_Add ( number  a,
number  b,
const coeffs  r 
)
static

return the sum of 'a' and 'b', i.e., a+b

Definition at line 655 of file coeffs.h.

656 { STATISTIC(n_Add); assume(r != NULL); assume(r->cfAdd!=NULL); const number sum = r->cfAdd(a, b, r);
657 
658 #ifdef HAVE_NUMSTATS
659  // avoid double counting
660  if( r->cfIsZero(sum,r) ) STATISTIC(n_CancelOut);
661 #endif
662 
663  return sum;
664 }
#define STATISTIC(f)
Definition: numstats.h:16
const poly a
Definition: syzextra.cc:212
#define assume(x)
Definition: mod2.h:405
static FORCE_INLINE number n_Add(number a, number b, const coeffs r)
return the sum of &#39;a&#39; and &#39;b&#39;, i.e., a+b
Definition: coeffs.h:655
#define NULL
Definition: omList.c:10
const poly b
Definition: syzextra.cc:213
static FORCE_INLINE number n_Ann ( number  a,
const coeffs  r 
)
static

if r is a ring with zero divisors, return an annihilator!=0 of b otherwise return NULL

Definition at line 700 of file coeffs.h.

701 { STATISTIC(n_Ann); assume(r != NULL); return r->cfAnn (a,r); }
#define STATISTIC(f)
Definition: numstats.h:16
const poly a
Definition: syzextra.cc:212
static FORCE_INLINE number n_Ann(number a, const coeffs r)
if r is a ring with zero divisors, return an annihilator!=0 of b otherwise return NULL ...
Definition: coeffs.h:700
#define assume(x)
Definition: mod2.h:405
#define NULL
Definition: omList.c:10
static FORCE_INLINE number n_ChineseRemainderSym ( number *  a,
number *  b,
int  rl,
BOOLEAN  sym,
CFArray inv_cache,
const coeffs  r 
)
static

Definition at line 782 of file coeffs.h.

783 { STATISTIC(n_ChineseRemainderSym); assume(r != NULL); assume(r->cfChineseRemainder != NULL); return r->cfChineseRemainder(a,b,rl,sym,inv_cache,r); }
#define STATISTIC(f)
Definition: numstats.h:16
const poly a
Definition: syzextra.cc:212
#define assume(x)
Definition: mod2.h:405
static FORCE_INLINE number n_ChineseRemainderSym(number *a, number *b, int rl, BOOLEAN sym, CFArray &inv_cache, const coeffs r)
Definition: coeffs.h:782
#define NULL
Definition: omList.c:10
const poly b
Definition: syzextra.cc:213
static FORCE_INLINE void n_ClearContent ( ICoeffsEnumerator numberCollectionEnumerator,
number &  c,
const coeffs  r 
)
static

Computes the content and (inplace) divides it out on a collection of numbers number c is the content (i.e. the GCD of all the coeffs, which we divide out inplace) NOTE: it assumes all coefficient numbers to be integer!!! NOTE/TODO: see also the description by Hans TODO: rename into n_ClearIntegerContent.

Definition at line 932 of file coeffs.h.

933 { STATISTIC(n_ClearContent); assume(r != NULL); r->cfClearContent(numberCollectionEnumerator, c, r); }
#define STATISTIC(f)
Definition: numstats.h:16
static FORCE_INLINE void n_ClearContent(ICoeffsEnumerator &numberCollectionEnumerator, number &c, const coeffs r)
Computes the content and (inplace) divides it out on a collection of numbers number c is the content ...
Definition: coeffs.h:932
#define assume(x)
Definition: mod2.h:405
#define NULL
Definition: omList.c:10
static FORCE_INLINE void n_ClearContent ( ICoeffsEnumerator numberCollectionEnumerator,
const coeffs  r 
)
static

Definition at line 948 of file coeffs.h.

949 { STATISTIC(n_ClearContent); number c; n_ClearContent(numberCollectionEnumerator, c, r); n_Delete(&c, r); }
#define STATISTIC(f)
Definition: numstats.h:16
static FORCE_INLINE void n_ClearContent(ICoeffsEnumerator &numberCollectionEnumerator, number &c, const coeffs r)
Computes the content and (inplace) divides it out on a collection of numbers number c is the content ...
Definition: coeffs.h:932
static FORCE_INLINE void n_Delete(number *p, const coeffs r)
delete &#39;p&#39;
Definition: coeffs.h:456
static FORCE_INLINE void n_ClearDenominators ( ICoeffsEnumerator numberCollectionEnumerator,
number &  d,
const coeffs  r 
)
static

(inplace) Clears denominators on a collection of numbers number d is the LCM of all the coefficient denominators (i.e. the number with which all the number coeffs. were multiplied) NOTE/TODO: see also the description by Hans

Definition at line 939 of file coeffs.h.

940 { STATISTIC(n_ClearDenominators); assume(r != NULL); r->cfClearDenominators(numberCollectionEnumerator, d, r); }
#define STATISTIC(f)
Definition: numstats.h:16
#define assume(x)
Definition: mod2.h:405
#define NULL
Definition: omList.c:10
static FORCE_INLINE void n_ClearDenominators(ICoeffsEnumerator &numberCollectionEnumerator, number &d, const coeffs r)
(inplace) Clears denominators on a collection of numbers number d is the LCM of all the coefficient d...
Definition: coeffs.h:939
static FORCE_INLINE void n_ClearDenominators ( ICoeffsEnumerator numberCollectionEnumerator,
const coeffs  r 
)
static

Definition at line 951 of file coeffs.h.

952 { STATISTIC(n_ClearDenominators); assume(r != NULL); number d; n_ClearDenominators(numberCollectionEnumerator, d, r); n_Delete(&d, r); }
#define STATISTIC(f)
Definition: numstats.h:16
#define assume(x)
Definition: mod2.h:405
#define NULL
Definition: omList.c:10
static FORCE_INLINE void n_Delete(number *p, const coeffs r)
delete &#39;p&#39;
Definition: coeffs.h:456
static FORCE_INLINE void n_ClearDenominators(ICoeffsEnumerator &numberCollectionEnumerator, number &d, const coeffs r)
(inplace) Clears denominators on a collection of numbers number d is the LCM of all the coefficient d...
Definition: coeffs.h:939
static FORCE_INLINE coeffs n_CoeffRingQuot1 ( number  c,
const coeffs  r 
)
static

Definition at line 519 of file coeffs.h.

520 { STATISTIC(n_CoeffRingQuot1); assume(r != NULL); assume(r->cfQuot1 != NULL); return r->cfQuot1(c, r); }
#define STATISTIC(f)
Definition: numstats.h:16
#define assume(x)
Definition: mod2.h:405
#define NULL
Definition: omList.c:10
static FORCE_INLINE coeffs n_CoeffRingQuot1(number c, const coeffs r)
Definition: coeffs.h:519
static FORCE_INLINE void n_CoeffWrite ( const coeffs  r,
BOOLEAN  details = TRUE 
)
static

output the coeff description

Definition at line 737 of file coeffs.h.

738 { STATISTIC(n_CoeffWrite); assume(r != NULL); assume(r->cfCoeffWrite != NULL); r->cfCoeffWrite(r, details); }
#define STATISTIC(f)
Definition: numstats.h:16
#define assume(x)
Definition: mod2.h:405
static FORCE_INLINE void n_CoeffWrite(const coeffs r, BOOLEAN details=TRUE)
output the coeff description
Definition: coeffs.h:737
#define NULL
Definition: omList.c:10
number n_convFactoryNSingN ( const CanonicalForm  n,
const coeffs  r 
)

Definition at line 560 of file numbers.cc.

562 { STATISTIC(n_convFactoryNSingN); assume(r != NULL); assume(r->convFactoryNSingN != NULL); return r->convFactoryNSingN(n, r); }
#define STATISTIC(f)
Definition: numstats.h:16
number n_convFactoryNSingN(const CanonicalForm n, const coeffs r)
Definition: numbers.cc:560
#define assume(x)
Definition: mod2.h:405
#define NULL
Definition: omList.c:10
CanonicalForm n_convSingNFactoryN ( number  n,
BOOLEAN  setChar,
const coeffs  r 
)

Definition at line 565 of file numbers.cc.

567 { STATISTIC(n_convSingNFactoryN); assume(r != NULL); assume(r->convSingNFactoryN != NULL); return r->convSingNFactoryN(n, setChar, r); }
#define STATISTIC(f)
Definition: numstats.h:16
#define assume(x)
Definition: mod2.h:405
#define NULL
Definition: omList.c:10
CanonicalForm n_convSingNFactoryN(number n, BOOLEAN setChar, const coeffs r)
Definition: numbers.cc:565
static FORCE_INLINE number n_Copy ( number  n,
const coeffs  r 
)
static

return a copy of 'n'

Definition at line 452 of file coeffs.h.

453 { STATISTIC(n_Copy); assume(r != NULL); assume(r->cfCopy!=NULL); return r->cfCopy(n, r); }
#define STATISTIC(f)
Definition: numstats.h:16
#define assume(x)
Definition: mod2.h:405
#define NULL
Definition: omList.c:10
static FORCE_INLINE number n_Copy(number n, const coeffs r)
return a copy of &#39;n&#39;
Definition: coeffs.h:452
static FORCE_INLINE BOOLEAN n_DBTest ( number  n,
const char *  filename,
const int  linenumber,
const coeffs  r 
)
static

test whether n is a correct number; only used if LDEBUG is defined

Definition at line 726 of file coeffs.h.

727 { STATISTIC(n_Test); assume(r != NULL); assume(r->cfDBTest != NULL); return r->cfDBTest(n, filename, linenumber, r); }
#define STATISTIC(f)
Definition: numstats.h:16
#define assume(x)
Definition: mod2.h:405
#define n_Test(a, r)
BOOLEAN n_Test(number a, const coeffs r)
Definition: coeffs.h:923
#define NULL
Definition: omList.c:10
static FORCE_INLINE void n_Delete ( number *  p,
const coeffs  r 
)
static

delete 'p'

Definition at line 456 of file coeffs.h.

457 { STATISTIC(n_Delete); assume(r != NULL); assume(r->cfDelete!= NULL); r->cfDelete(p, r); }
#define STATISTIC(f)
Definition: numstats.h:16
return P p
Definition: myNF.cc:203
#define assume(x)
Definition: mod2.h:405
#define NULL
Definition: omList.c:10
static FORCE_INLINE void n_Delete(number *p, const coeffs r)
delete &#39;p&#39;
Definition: coeffs.h:456
static FORCE_INLINE number n_Div ( number  a,
number  b,
const coeffs  r 
)
static

return the quotient of 'a' and 'b', i.e., a/b; raises an error if 'b' is not invertible in r exception in Z: raises an error if 'a' is not divisible by 'b'

Definition at line 615 of file coeffs.h.

616 { STATISTIC(n_Div); assume(r != NULL); assume(r->cfDiv!=NULL); return r->cfDiv(a,b,r); }
#define STATISTIC(f)
Definition: numstats.h:16
const poly a
Definition: syzextra.cc:212
#define assume(x)
Definition: mod2.h:405
#define NULL
Definition: omList.c:10
static FORCE_INLINE number n_Div(number a, number b, const coeffs r)
return the quotient of &#39;a&#39; and &#39;b&#39;, i.e., a/b; raises an error if &#39;b&#39; is not invertible in r exceptio...
Definition: coeffs.h:615
const poly b
Definition: syzextra.cc:213
static FORCE_INLINE BOOLEAN n_DivBy ( number  a,
number  b,
const coeffs  r 
)
static

test whether 'a' is divisible 'b'; for r encoding a field: TRUE iff 'b' does not represent zero in Z: TRUE iff 'b' divides 'a' (with remainder = zero) in Z/nZ: TRUE iff (a = 0 and b divides n in Z) or (a != 0 and b/gcd(a, b) is co-prime with n, i.e. a unit in Z/nZ) in Z/2^kZ: TRUE iff ((a = 0 mod 2^k) and (b = 0 or b is a power of 2)) or ((a, b <> 0) and (b/gcd(a, b) is odd))

Definition at line 771 of file coeffs.h.

772 { STATISTIC(n_DivBy); assume(r != NULL);
773 #ifdef HAVE_RINGS
774  if( nCoeff_is_Ring(r) )
775  {
776  assume(r->cfDivBy!=NULL); return r->cfDivBy(a,b,r);
777  }
778 #endif
779  return !n_IsZero(b, r);
780 }
#define STATISTIC(f)
Definition: numstats.h:16
const poly a
Definition: syzextra.cc:212
static FORCE_INLINE BOOLEAN nCoeff_is_Ring(const coeffs r)
Definition: coeffs.h:753
#define assume(x)
Definition: mod2.h:405
static FORCE_INLINE BOOLEAN n_DivBy(number a, number b, const coeffs r)
test whether &#39;a&#39; is divisible &#39;b&#39;; for r encoding a field: TRUE iff &#39;b&#39; does not represent zero in Z:...
Definition: coeffs.h:771
static FORCE_INLINE BOOLEAN n_IsZero(number n, const coeffs r)
TRUE iff &#39;n&#39; represents the zero element.
Definition: coeffs.h:465
#define NULL
Definition: omList.c:10
const poly b
Definition: syzextra.cc:213
static FORCE_INLINE int n_DivComp ( number  a,
number  b,
const coeffs  r 
)
static

Definition at line 523 of file coeffs.h.

524 { STATISTIC(n_DivComp); assume(r != NULL); assume(r->cfDivComp!=NULL); return r->cfDivComp (a,b,r); }
#define STATISTIC(f)
Definition: numstats.h:16
const poly a
Definition: syzextra.cc:212
#define assume(x)
Definition: mod2.h:405
static FORCE_INLINE int n_DivComp(number a, number b, const coeffs r)
Definition: coeffs.h:523
#define NULL
Definition: omList.c:10
const poly b
Definition: syzextra.cc:213
static FORCE_INLINE BOOLEAN n_Equal ( number  a,
number  b,
const coeffs  r 
)
static

TRUE iff 'a' and 'b' represent the same number; they may have different representations.

Definition at line 461 of file coeffs.h.

462 { STATISTIC(n_Equal); assume(r != NULL); assume(r->cfEqual!=NULL); return r->cfEqual(a, b, r); }
#define STATISTIC(f)
Definition: numstats.h:16
const poly a
Definition: syzextra.cc:212
#define assume(x)
Definition: mod2.h:405
#define NULL
Definition: omList.c:10
static FORCE_INLINE BOOLEAN n_Equal(number a, number b, const coeffs r)
TRUE iff &#39;a&#39; and &#39;b&#39; represent the same number; they may have different representations.
Definition: coeffs.h:461
const poly b
Definition: syzextra.cc:213
static FORCE_INLINE number n_EucNorm ( number  a,
const coeffs  r 
)
static

Definition at line 696 of file coeffs.h.

697 { STATISTIC(n_EucNorm); assume(r != NULL); assume(r->cfEucNorm!=NULL); return r->cfEucNorm (a,r); }
#define STATISTIC(f)
Definition: numstats.h:16
static FORCE_INLINE number n_EucNorm(number a, const coeffs r)
Definition: coeffs.h:696
const poly a
Definition: syzextra.cc:212
#define assume(x)
Definition: mod2.h:405
#define NULL
Definition: omList.c:10
static FORCE_INLINE number n_ExactDiv ( number  a,
number  b,
const coeffs  r 
)
static

assume that there is a canonical subring in cf and we know that division is possible for these a and b in the subring, n_ExactDiv performs it, may skip additional tests. Can always be substituted by n_Div at the cost of larger computing time.

Definition at line 622 of file coeffs.h.

623 { STATISTIC(n_ExactDiv); assume(r != NULL); assume(r->cfExactDiv!=NULL); return r->cfExactDiv(a,b,r); }
#define STATISTIC(f)
Definition: numstats.h:16
const poly a
Definition: syzextra.cc:212
#define assume(x)
Definition: mod2.h:405
#define NULL
Definition: omList.c:10
static FORCE_INLINE number n_ExactDiv(number a, number b, const coeffs r)
assume that there is a canonical subring in cf and we know that division is possible for these a and ...
Definition: coeffs.h:622
const poly b
Definition: syzextra.cc:213
static FORCE_INLINE number n_ExtGcd ( number  a,
number  b,
number *  s,
number *  t,
const coeffs  r 
)
static

beware that ExtGCD is only relevant for a few chosen coeff. domains and may perform something unexpected in some cases...

Definition at line 692 of file coeffs.h.

693 { STATISTIC(n_ExtGcd); assume(r != NULL); assume(r->cfExtGcd!=NULL); return r->cfExtGcd (a,b,s,t,r); }
#define STATISTIC(f)
Definition: numstats.h:16
const CanonicalForm int s
Definition: facAbsFact.cc:55
const poly a
Definition: syzextra.cc:212
#define assume(x)
Definition: mod2.h:405
static FORCE_INLINE number n_ExtGcd(number a, number b, number *s, number *t, const coeffs r)
beware that ExtGCD is only relevant for a few chosen coeff. domains and may perform something unexpec...
Definition: coeffs.h:692
#define NULL
Definition: omList.c:10
const poly b
Definition: syzextra.cc:213
static FORCE_INLINE number n_Farey ( number  a,
number  b,
const coeffs  r 
)
static

Definition at line 785 of file coeffs.h.

786 { STATISTIC(n_Farey); assume(r != NULL); assume(r->cfFarey != NULL); return r->cfFarey(a,b,r); }
#define STATISTIC(f)
Definition: numstats.h:16
const poly a
Definition: syzextra.cc:212
#define assume(x)
Definition: mod2.h:405
static FORCE_INLINE number n_Farey(number a, number b, const coeffs r)
Definition: coeffs.h:785
#define NULL
Definition: omList.c:10
const poly b
Definition: syzextra.cc:213
static FORCE_INLINE number n_Gcd ( number  a,
number  b,
const coeffs  r 
)
static

in Z: return the gcd of 'a' and 'b' in Z/nZ, Z/2^kZ: computed as in the case Z in Z/pZ, C, R: not implemented in Q: return the gcd of the numerators of 'a' and 'b' in K(a)/<p(a)>: not implemented in K(t_1, ..., t_n): not implemented

Definition at line 685 of file coeffs.h.

686 { STATISTIC(n_Gcd); assume(r != NULL); assume(r->cfGcd!=NULL); return r->cfGcd(a,b,r); }
#define STATISTIC(f)
Definition: numstats.h:16
static FORCE_INLINE number n_Gcd(number a, number b, const coeffs r)
in Z: return the gcd of &#39;a&#39; and &#39;b&#39; in Z/nZ, Z/2^kZ: computed as in the case Z in Z/pZ...
Definition: coeffs.h:685
const poly a
Definition: syzextra.cc:212
#define assume(x)
Definition: mod2.h:405
#define NULL
Definition: omList.c:10
const poly b
Definition: syzextra.cc:213
static FORCE_INLINE int n_GetChar ( const coeffs  r)
static

Return the characteristic of the coeff. domain.

Definition at line 445 of file coeffs.h.

446 { STATISTIC(n_GetChar); assume(r != NULL); return r->ch; }
#define STATISTIC(f)
Definition: numstats.h:16
static FORCE_INLINE int n_GetChar(const coeffs r)
Return the characteristic of the coeff. domain.
Definition: coeffs.h:445
#define assume(x)
Definition: mod2.h:405
#define NULL
Definition: omList.c:10
static FORCE_INLINE number n_GetDenom ( number &  n,
const coeffs  r 
)
static

return the denominator of n (if elements of r are by nature not fractional, result is 1)

Definition at line 604 of file coeffs.h.

605 { STATISTIC(n_GetDenom); assume(r != NULL); assume(r->cfGetDenom!=NULL); return r->cfGetDenom(n, r); }
#define STATISTIC(f)
Definition: numstats.h:16
#define assume(x)
Definition: mod2.h:405
#define NULL
Definition: omList.c:10
static FORCE_INLINE number n_GetDenom(number &n, const coeffs r)
return the denominator of n (if elements of r are by nature not fractional, result is 1) ...
Definition: coeffs.h:604
static FORCE_INLINE number n_GetNumerator ( number &  n,
const coeffs  r 
)
static

return the numerator of n (if elements of r are by nature not fractional, result is n)

Definition at line 609 of file coeffs.h.

610 { STATISTIC(n_GetNumerator); assume(r != NULL); assume(r->cfGetNumerator!=NULL); return r->cfGetNumerator(n, r); }
#define STATISTIC(f)
Definition: numstats.h:16
static FORCE_INLINE number n_GetNumerator(number &n, const coeffs r)
return the numerator of n (if elements of r are by nature not fractional, result is n) ...
Definition: coeffs.h:609
#define assume(x)
Definition: mod2.h:405
#define NULL
Definition: omList.c:10
static FORCE_INLINE number n_GetUnit ( number  n,
const coeffs  r 
)
static

in Z: 1 in Z/kZ (where k is not a prime): largest divisor of n (taken in Z) that is co-prime with k in Z/2^kZ: largest odd divisor of n (taken in Z) other cases: not implemented

Definition at line 533 of file coeffs.h.

534 { STATISTIC(n_GetUnit); assume(r != NULL); assume(r->cfGetUnit!=NULL); return r->cfGetUnit(n,r); }
#define STATISTIC(f)
Definition: numstats.h:16
static FORCE_INLINE number n_GetUnit(number n, const coeffs r)
in Z: 1 in Z/kZ (where k is not a prime): largest divisor of n (taken in Z) that is co-prime with k i...
Definition: coeffs.h:533
#define assume(x)
Definition: mod2.h:405
#define NULL
Definition: omList.c:10
static FORCE_INLINE BOOLEAN n_Greater ( number  a,
number  b,
const coeffs  r 
)
static

ordered fields: TRUE iff 'a' is larger than 'b'; in Z/pZ: TRUE iff la > lb, where la and lb are the long's representing

in C: TRUE iff (Im(a) > Im(b)) in K(a)/<p(a)>: TRUE iff (a != 0 and (b == 0 or deg(a) > deg(b)) in K(t_1, ..., t_n): TRUE only if one or both numerator polynomials are zero or if their degrees are equal. In this case, TRUE if LC(numerator(a)) > LC(numerator(b)) in Z/2^kZ: TRUE if n_DivBy(a, b) in Z/mZ: TRUE iff the internal mpz's fulfill the relation '>' in Z: TRUE iff a > b

!!! Recommendation: remove implementations for unordered fields !!! and raise errors instead, in these cases

Definition at line 512 of file coeffs.h.

513 { STATISTIC(n_Greater); assume(r != NULL); assume(r->cfGreater!=NULL); return r->cfGreater(a,b,r); }
static FORCE_INLINE BOOLEAN n_Greater(number a, number b, const coeffs r)
ordered fields: TRUE iff &#39;a&#39; is larger than &#39;b&#39;; in Z/pZ: TRUE iff la > lb, where la and lb are the l...
Definition: coeffs.h:512
#define STATISTIC(f)
Definition: numstats.h:16
const poly a
Definition: syzextra.cc:212
#define assume(x)
Definition: mod2.h:405
#define NULL
Definition: omList.c:10
const poly b
Definition: syzextra.cc:213
static FORCE_INLINE BOOLEAN n_GreaterZero ( number  n,
const coeffs  r 
)
static

ordered fields: TRUE iff 'n' is positive; in Z/pZ: TRUE iff 0 < m <= roundedBelow(p/2), where m is the long representing n in C: TRUE iff (Im(n) != 0 and Im(n) >= 0) or (Im(n) == 0 and Re(n) >= 0) in K(a)/<p(a)>: TRUE iff (n != 0 and (LC(n) > 0 or deg(n) > 0)) in K(t_1, ..., t_n): TRUE iff (LC(numerator(n) is a constant and > 0) or (LC(numerator(n) is not a constant) in Z/2^kZ: TRUE iff 0 < n <= 2^(k-1) in Z/mZ: TRUE iff the internal mpz is greater than zero in Z: TRUE iff n > 0

!!! Recommendation: remove implementations for unordered fields !!! and raise errors instead, in these cases !!! Do not follow this recommendation: while writing polys, !!! between 2 monomials will be an additional + iff !n_GreaterZero(next coeff) Then change definition to include n_GreaterZero => printing does NOT start with -

Definition at line 495 of file coeffs.h.

496 { STATISTIC(n_GreaterZero); assume(r != NULL); assume(r->cfGreaterZero!=NULL); return r->cfGreaterZero(n,r); }
#define STATISTIC(f)
Definition: numstats.h:16
#define assume(x)
Definition: mod2.h:405
#define NULL
Definition: omList.c:10
static FORCE_INLINE BOOLEAN n_GreaterZero(number n, const coeffs r)
ordered fields: TRUE iff &#39;n&#39; is positive; in Z/pZ: TRUE iff 0 < m <= roundedBelow(p/2), where m is the long representing n in C: TRUE iff (Im(n) != 0 and Im(n) >= 0) or (Im(n) == 0 and Re(n) >= 0) in K(a)/<p(a)>: TRUE iff (n != 0 and (LC(n) > 0 or deg(n) > 0)) in K(t_1, ..., t_n): TRUE iff (LC(numerator(n) is a constant and > 0) or (LC(numerator(n) is not a constant) in Z/2^kZ: TRUE iff 0 < n <= 2^(k-1) in Z/mZ: TRUE iff the internal mpz is greater than zero in Z: TRUE iff n > 0
Definition: coeffs.h:495
static FORCE_INLINE number n_ImPart ( number  i,
const coeffs  cf 
)
static

Definition at line 811 of file coeffs.h.

812 { STATISTIC(n_ImPart); assume(cf != NULL); assume(cf->cfImPart!=NULL); return cf->cfImPart(i,cf); }
#define STATISTIC(f)
Definition: numstats.h:16
#define assume(x)
Definition: mod2.h:405
int i
Definition: cfEzgcd.cc:123
static FORCE_INLINE number n_ImPart(number i, const coeffs cf)
Definition: coeffs.h:811
#define NULL
Definition: omList.c:10
static FORCE_INLINE number n_Init ( long  i,
const coeffs  r 
)
static

a number representing i in the given coeff field/ring r

Definition at line 539 of file coeffs.h.

540 { STATISTIC(n_Init); assume(r != NULL); assume(r->cfInit!=NULL); return r->cfInit(i,r); }
#define STATISTIC(f)
Definition: numstats.h:16
static FORCE_INLINE number n_Init(long i, const coeffs r)
a number representing i in the given coeff field/ring r
Definition: coeffs.h:539
#define assume(x)
Definition: mod2.h:405
int i
Definition: cfEzgcd.cc:123
#define NULL
Definition: omList.c:10
static FORCE_INLINE number n_InitMPZ ( mpz_t  n,
const coeffs  r 
)
static

conversion of a GMP integer to number

Definition at line 543 of file coeffs.h.

544 { STATISTIC(n_InitMPZ); assume(r != NULL); assume(r->cfInitMPZ != NULL); return r->cfInitMPZ(n,r); }
#define STATISTIC(f)
Definition: numstats.h:16
#define assume(x)
Definition: mod2.h:405
static FORCE_INLINE number n_InitMPZ(mpz_t n, const coeffs r)
conversion of a GMP integer to number
Definition: coeffs.h:543
#define NULL
Definition: omList.c:10
static FORCE_INLINE void n_InpAdd ( number &  a,
number  b,
const coeffs  r 
)
static

addition of 'a' and 'b'; replacement of 'a' by the sum a+b

Definition at line 645 of file coeffs.h.

646 { STATISTIC(n_InpAdd); assume(r != NULL); assume(r->cfInpAdd!=NULL); r->cfInpAdd(a,b,r);
647 
648 #ifdef HAVE_NUMSTATS
649  // avoid double counting
650  if( r->cfIsZero(a,r) ) STATISTIC(n_CancelOut);
651 #endif
652 }
#define STATISTIC(f)
Definition: numstats.h:16
const poly a
Definition: syzextra.cc:212
static FORCE_INLINE void n_InpAdd(number &a, number b, const coeffs r)
addition of &#39;a&#39; and &#39;b&#39;; replacement of &#39;a&#39; by the sum a+b
Definition: coeffs.h:645
#define assume(x)
Definition: mod2.h:405
#define NULL
Definition: omList.c:10
const poly b
Definition: syzextra.cc:213
static FORCE_INLINE void n_InpMult ( number &  a,
number  b,
const coeffs  r 
)
static

multiplication of 'a' and 'b'; replacement of 'a' by the product a*b

Definition at line 640 of file coeffs.h.

641 { STATISTIC(n_InpMult); assume(r != NULL); assume(r->cfInpMult!=NULL); r->cfInpMult(a,b,r); }
#define STATISTIC(f)
Definition: numstats.h:16
const poly a
Definition: syzextra.cc:212
static FORCE_INLINE void n_InpMult(number &a, number b, const coeffs r)
multiplication of &#39;a&#39; and &#39;b&#39;; replacement of &#39;a&#39; by the product a*b
Definition: coeffs.h:640
#define assume(x)
Definition: mod2.h:405
#define NULL
Definition: omList.c:10
const poly b
Definition: syzextra.cc:213
static FORCE_INLINE number n_InpNeg ( number  n,
const coeffs  r 
)
static

in-place negation of n MUST BE USED: n = n_InpNeg(n) (no copy is returned)

Definition at line 558 of file coeffs.h.

559 { STATISTIC(n_InpNeg); assume(r != NULL); assume(r->cfInpNeg!=NULL); return r->cfInpNeg(n,r); }
#define STATISTIC(f)
Definition: numstats.h:16
#define assume(x)
Definition: mod2.h:405
static FORCE_INLINE number n_InpNeg(number n, const coeffs r)
in-place negation of n MUST BE USED: n = n_InpNeg(n) (no copy is returned)
Definition: coeffs.h:558
#define NULL
Definition: omList.c:10
static FORCE_INLINE long n_Int ( number &  n,
const coeffs  r 
)
static

conversion of n to an int; 0 if not possible in Z/pZ: the representing int lying in (-p/2 .. p/2]

Definition at line 548 of file coeffs.h.

549 { STATISTIC(n_Int); assume(r != NULL); assume(r->cfInt!=NULL); return r->cfInt(n,r); }
#define STATISTIC(f)
Definition: numstats.h:16
static FORCE_INLINE long n_Int(number &n, const coeffs r)
conversion of n to an int; 0 if not possible in Z/pZ: the representing int lying in (-p/2 ...
Definition: coeffs.h:548
#define assume(x)
Definition: mod2.h:405
#define NULL
Definition: omList.c:10
static FORCE_INLINE number n_IntMod ( number  a,
number  b,
const coeffs  r 
)
static

for r a field, return n_Init(0,r) otherwise: n_Div(a,b,r)*b+n_IntMod(a,b,r)==a

Definition at line 627 of file coeffs.h.

628 { STATISTIC(n_IntMod); assume(r != NULL); return r->cfIntMod(a,b,r); }
#define STATISTIC(f)
Definition: numstats.h:16
static FORCE_INLINE number n_IntMod(number a, number b, const coeffs r)
for r a field, return n_Init(0,r) otherwise: n_Div(a,b,r)*b+n_IntMod(a,b,r)==a
Definition: coeffs.h:627
const poly a
Definition: syzextra.cc:212
#define assume(x)
Definition: mod2.h:405
#define NULL
Definition: omList.c:10
const poly b
Definition: syzextra.cc:213
static FORCE_INLINE number n_Invers ( number  a,
const coeffs  r 
)
static

return the multiplicative inverse of 'a'; raise an error if 'a' is not invertible

!!! Recommendation: rename to 'n_Inverse'

Definition at line 565 of file coeffs.h.

566 { STATISTIC(n_Invers); assume(r != NULL); assume(r->cfInvers!=NULL); return r->cfInvers(a,r); }
#define STATISTIC(f)
Definition: numstats.h:16
const poly a
Definition: syzextra.cc:212
#define assume(x)
Definition: mod2.h:405
static FORCE_INLINE number n_Invers(number a, const coeffs r)
return the multiplicative inverse of &#39;a&#39;; raise an error if &#39;a&#39; is not invertible ...
Definition: coeffs.h:565
#define NULL
Definition: omList.c:10
static FORCE_INLINE BOOLEAN n_IsMOne ( number  n,
const coeffs  r 
)
static

TRUE iff 'n' represents the additive inverse of the one element, i.e. -1.

Definition at line 473 of file coeffs.h.

474 { STATISTIC(n_IsMOne); assume(r != NULL); assume(r->cfIsMOne!=NULL); return r->cfIsMOne(n,r); }
#define STATISTIC(f)
Definition: numstats.h:16
#define assume(x)
Definition: mod2.h:405
#define NULL
Definition: omList.c:10
static FORCE_INLINE BOOLEAN n_IsMOne(number n, const coeffs r)
TRUE iff &#39;n&#39; represents the additive inverse of the one element, i.e. -1.
Definition: coeffs.h:473
static FORCE_INLINE BOOLEAN n_IsOne ( number  n,
const coeffs  r 
)
static

TRUE iff 'n' represents the one element.

Definition at line 469 of file coeffs.h.

470 { STATISTIC(n_IsOne); assume(r != NULL); assume(r->cfIsOne!=NULL); return r->cfIsOne(n,r); }
#define STATISTIC(f)
Definition: numstats.h:16
static FORCE_INLINE BOOLEAN n_IsOne(number n, const coeffs r)
TRUE iff &#39;n&#39; represents the one element.
Definition: coeffs.h:469
#define assume(x)
Definition: mod2.h:405
#define NULL
Definition: omList.c:10
static FORCE_INLINE BOOLEAN n_IsUnit ( number  n,
const coeffs  r 
)
static

TRUE iff n has a multiplicative inverse in the given coeff field/ring r.

Definition at line 516 of file coeffs.h.

517 { STATISTIC(n_IsUnit); assume(r != NULL); assume(r->cfIsUnit!=NULL); return r->cfIsUnit(n,r); }
#define STATISTIC(f)
Definition: numstats.h:16
static FORCE_INLINE BOOLEAN n_IsUnit(number n, const coeffs r)
TRUE iff n has a multiplicative inverse in the given coeff field/ring r.
Definition: coeffs.h:516
#define assume(x)
Definition: mod2.h:405
#define NULL
Definition: omList.c:10
static FORCE_INLINE BOOLEAN n_IsZero ( number  n,
const coeffs  r 
)
static

TRUE iff 'n' represents the zero element.

Definition at line 465 of file coeffs.h.

466 { STATISTIC(n_IsZero); assume(r != NULL); assume(r->cfIsZero!=NULL); return r->cfIsZero(n,r); }
#define STATISTIC(f)
Definition: numstats.h:16
#define assume(x)
Definition: mod2.h:405
static FORCE_INLINE BOOLEAN n_IsZero(number n, const coeffs r)
TRUE iff &#39;n&#39; represents the zero element.
Definition: coeffs.h:465
#define NULL
Definition: omList.c:10
static FORCE_INLINE number n_Lcm ( number  a,
number  b,
const coeffs  r 
)
static

in Z: return the lcm of 'a' and 'b' in Z/nZ, Z/2^kZ: computed as in the case Z in Z/pZ, C, R: not implemented in K(a)/<p(a)>: not implemented in K(t_1, ..., t_n): not implemented

Definition at line 711 of file coeffs.h.

712 { STATISTIC(n_Lcm); assume(r != NULL); assume(r->cfLcm!=NULL); return r->cfLcm(a,b,r); }
#define STATISTIC(f)
Definition: numstats.h:16
const poly a
Definition: syzextra.cc:212
#define assume(x)
Definition: mod2.h:405
static FORCE_INLINE number n_Lcm(number a, number b, const coeffs r)
in Z: return the lcm of &#39;a&#39; and &#39;b&#39; in Z/nZ, Z/2^kZ: computed as in the case Z in Z/pZ...
Definition: coeffs.h:711
#define NULL
Definition: omList.c:10
const poly b
Definition: syzextra.cc:213
static FORCE_INLINE void n_MPZ ( mpz_t  result,
number &  n,
const coeffs  r 
)
static

conversion of n to a GMP integer; 0 if not possible

Definition at line 552 of file coeffs.h.

553 { STATISTIC(n_MPZ); assume(r != NULL); assume(r->cfMPZ!=NULL); r->cfMPZ(result, n, r); }
#define STATISTIC(f)
Definition: numstats.h:16
#define assume(x)
Definition: mod2.h:405
#define NULL
Definition: omList.c:10
static FORCE_INLINE void n_MPZ(mpz_t result, number &n, const coeffs r)
conversion of n to a GMP integer; 0 if not possible
Definition: coeffs.h:552
return result
Definition: facAbsBiFact.cc:76
static FORCE_INLINE number n_Mult ( number  a,
number  b,
const coeffs  r 
)
static

return the product of 'a' and 'b', i.e., a*b

Definition at line 635 of file coeffs.h.

636 { STATISTIC(n_Mult); assume(r != NULL); assume(r->cfMult!=NULL); return r->cfMult(a, b, r); }
#define STATISTIC(f)
Definition: numstats.h:16
const poly a
Definition: syzextra.cc:212
static FORCE_INLINE number n_Mult(number a, number b, const coeffs r)
return the product of &#39;a&#39; and &#39;b&#39;, i.e., a*b
Definition: coeffs.h:635
#define assume(x)
Definition: mod2.h:405
#define NULL
Definition: omList.c:10
const poly b
Definition: syzextra.cc:213
static FORCE_INLINE void n_Normalize ( number &  n,
const coeffs  r 
)
static

inplace-normalization of n; produces some canonical representation of n;

!!! Recommendation: remove this method from the user-interface, i.e., !!! this should be hidden

Definition at line 579 of file coeffs.h.

580 { STATISTIC(n_Normalize); assume(r != NULL); assume(r->cfNormalize!=NULL); r->cfNormalize(n,r); }
#define STATISTIC(f)
Definition: numstats.h:16
static FORCE_INLINE void n_Normalize(number &n, const coeffs r)
inplace-normalization of n; produces some canonical representation of n;
Definition: coeffs.h:579
#define assume(x)
Definition: mod2.h:405
#define NULL
Definition: omList.c:10
static FORCE_INLINE number n_NormalizeHelper ( number  a,
number  b,
const coeffs  r 
)
static

assume that r is a quotient field (otherwise, return 1) for arguments (a1/a2,b1/b2) return (lcm(a1,b2)/1)

Definition at line 716 of file coeffs.h.

717 { STATISTIC(n_NormalizeHelper); assume(r != NULL); assume(r->cfNormalizeHelper!=NULL); return r->cfNormalizeHelper(a,b,r); }
#define STATISTIC(f)
Definition: numstats.h:16
const poly a
Definition: syzextra.cc:212
static FORCE_INLINE number n_NormalizeHelper(number a, number b, const coeffs r)
assume that r is a quotient field (otherwise, return 1) for arguments (a1/a2,b1/b2) return (lcm(a1...
Definition: coeffs.h:716
#define assume(x)
Definition: mod2.h:405
#define NULL
Definition: omList.c:10
const poly b
Definition: syzextra.cc:213
static FORCE_INLINE int n_NumberOfParameters ( const coeffs  r)
static

Returns the number of parameters.

Definition at line 792 of file coeffs.h.

793 { STATISTIC(n_NumberOfParameters); assume(r != NULL); return r->iNumberOfParameters; }
#define STATISTIC(f)
Definition: numstats.h:16
static FORCE_INLINE int n_NumberOfParameters(const coeffs r)
Returns the number of parameters.
Definition: coeffs.h:792
#define assume(x)
Definition: mod2.h:405
#define NULL
Definition: omList.c:10
static FORCE_INLINE number n_Param ( const int  iParameter,
const coeffs  r 
)
static

return the (iParameter^th) parameter as a NEW number NOTE: parameter numbering: 1..n_NumberOfParameters(...)

Definition at line 801 of file coeffs.h.

802 { assume(r != NULL);
803  assume((iParameter >= 1) || (iParameter <= n_NumberOfParameters(r)));
804  assume(r->cfParameter != NULL);
805  STATISTIC(n_Param); return r->cfParameter(iParameter, r);
806 }
#define STATISTIC(f)
Definition: numstats.h:16
static FORCE_INLINE int n_NumberOfParameters(const coeffs r)
Returns the number of parameters.
Definition: coeffs.h:792
static FORCE_INLINE number n_Param(const int iParameter, const coeffs r)
return the (iParameter^th) parameter as a NEW number NOTE: parameter numbering: 1..n_NumberOfParameters(...)
Definition: coeffs.h:801
#define assume(x)
Definition: mod2.h:405
#define NULL
Definition: omList.c:10
static FORCE_INLINE char const* * n_ParameterNames ( const coeffs  r)
static

Returns a (const!) pointer to (const char*) names of parameters.

Definition at line 796 of file coeffs.h.

797 { STATISTIC(n_ParameterNames); assume(r != NULL); return r->pParameterNames; }
#define STATISTIC(f)
Definition: numstats.h:16
static FORCE_INLINE char const ** n_ParameterNames(const coeffs r)
Returns a (const!) pointer to (const char*) names of parameters.
Definition: coeffs.h:796
#define assume(x)
Definition: mod2.h:405
#define NULL
Definition: omList.c:10
static FORCE_INLINE int n_ParDeg ( number  n,
const coeffs  r 
)
static

Definition at line 788 of file coeffs.h.

789 { STATISTIC(n_ParDeg); assume(r != NULL); assume(r->cfParDeg != NULL); return r->cfParDeg(n,r); }
#define STATISTIC(f)
Definition: numstats.h:16
static FORCE_INLINE int n_ParDeg(number n, const coeffs r)
Definition: coeffs.h:788
#define assume(x)
Definition: mod2.h:405
#define NULL
Definition: omList.c:10
static FORCE_INLINE void n_Power ( number  a,
int  b,
number *  res,
const coeffs  r 
)
static

fill res with the power a^b

Definition at line 631 of file coeffs.h.

632 { STATISTIC(n_Power); assume(r != NULL); assume(r->cfPower!=NULL); r->cfPower(a,b,res,r); }
#define STATISTIC(f)
Definition: numstats.h:16
const poly a
Definition: syzextra.cc:212
poly res
Definition: myNF.cc:322
#define assume(x)
Definition: mod2.h:405
static FORCE_INLINE void n_Power(number a, int b, number *res, const coeffs r)
fill res with the power a^b
Definition: coeffs.h:631
#define NULL
Definition: omList.c:10
const poly b
Definition: syzextra.cc:213
void n_Print ( number &  a,
const coeffs  r 
)

print a number (BEWARE of string buffers!) mostly for debugging

Definition at line 549 of file numbers.cc.

551 {
552  assume(r != NULL);
553  n_Test(a,r);
554 
555  StringSetS("");
556  n_Write(a, r);
557  { char* s = StringEndS(); Print("%s", s); omFree(s); }
const CanonicalForm int s
Definition: facAbsFact.cc:55
const poly a
Definition: syzextra.cc:212
#define Print
Definition: emacs.cc:83
char * StringEndS()
Definition: reporter.cc:151
#define omFree(addr)
Definition: omAllocDecl.h:261
#define assume(x)
Definition: mod2.h:405
void StringSetS(const char *st)
Definition: reporter.cc:128
static FORCE_INLINE void n_Write(number &n, const coeffs r, const BOOLEAN bShortOut=TRUE)
Definition: coeffs.h:592
#define n_Test(a, r)
BOOLEAN n_Test(number a, const coeffs r)
Definition: coeffs.h:923
#define NULL
Definition: omList.c:10
static FORCE_INLINE number n_QuotRem ( number  a,
number  b,
number *  q,
const coeffs  r 
)
static

Definition at line 702 of file coeffs.h.

703 { STATISTIC(n_QuotRem); assume(r != NULL); assume(r->cfQuotRem!=NULL); return r->cfQuotRem (a,b,q,r); }
#define STATISTIC(f)
Definition: numstats.h:16
const poly a
Definition: syzextra.cc:212
#define assume(x)
Definition: mod2.h:405
static FORCE_INLINE number n_QuotRem(number a, number b, number *q, const coeffs r)
Definition: coeffs.h:702
#define NULL
Definition: omList.c:10
const poly b
Definition: syzextra.cc:213
static FORCE_INLINE number n_Random ( siRandProc  p,
number  p1,
number  p2,
const coeffs  cf 
)
static

Definition at line 970 of file coeffs.h.

971 { STATISTIC(n_Random); assume( cf != NULL ); assume( cf->cfRandom != NULL ); return cf->cfRandom(p, p1, p2, cf); }
#define STATISTIC(f)
Definition: numstats.h:16
return P p
Definition: myNF.cc:203
static FORCE_INLINE number n_Random(siRandProc p, number p1, number p2, const coeffs cf)
Definition: coeffs.h:970
#define assume(x)
Definition: mod2.h:405
#define NULL
Definition: omList.c:10
END_NAMESPACE const void * p2
Definition: syzextra.cc:202
static FORCE_INLINE const char* n_Read ( const char *  s,
number *  a,
const coeffs  r 
)
static

!!! Recommendation: This method is too cryptic to be part of the user- !!! interface. As defined here, it is merely a helper !!! method for parsing number input strings.

Definition at line 599 of file coeffs.h.

600 { STATISTIC(n_Read); assume(r != NULL); assume(r->cfRead!=NULL); return r->cfRead(s, a, r); }
#define STATISTIC(f)
Definition: numstats.h:16
const CanonicalForm int s
Definition: facAbsFact.cc:55
const poly a
Definition: syzextra.cc:212
static FORCE_INLINE const char * n_Read(const char *s, number *a, const coeffs r)
!!! Recommendation: This method is too cryptic to be part of the user- !!! interface. As defined here, it is merely a helper !!! method for parsing number input strings.
Definition: coeffs.h:599
#define assume(x)
Definition: mod2.h:405
#define NULL
Definition: omList.c:10
static FORCE_INLINE number n_ReadFd ( s_buff  f,
const coeffs  r 
)
static

io via ssi:

Definition at line 978 of file coeffs.h.

979 { STATISTIC(n_ReadFd); assume(r != NULL); assume(r->cfReadFd != NULL); return r->cfReadFd(f, r); }
#define STATISTIC(f)
Definition: numstats.h:16
f
Definition: cfModGcd.cc:4022
static FORCE_INLINE number n_ReadFd(s_buff f, const coeffs r)
io via ssi:
Definition: coeffs.h:978
#define assume(x)
Definition: mod2.h:405
#define NULL
Definition: omList.c:10
static FORCE_INLINE number n_RePart ( number  i,
const coeffs  cf 
)
static

Definition at line 808 of file coeffs.h.

809 { STATISTIC(n_RePart); assume(cf != NULL); assume(cf->cfRePart!=NULL); return cf->cfRePart(i,cf); }
#define STATISTIC(f)
Definition: numstats.h:16
#define assume(x)
Definition: mod2.h:405
int i
Definition: cfEzgcd.cc:123
#define NULL
Definition: omList.c:10
static FORCE_INLINE number n_RePart(number i, const coeffs cf)
Definition: coeffs.h:808
static FORCE_INLINE nMapFunc n_SetMap ( const coeffs  src,
const coeffs  dst 
)
static

set the mapping function pointers for translating numbers from src to dst

Definition at line 720 of file coeffs.h.

721 { STATISTIC(n_SetMap); assume(src != NULL && dst != NULL); assume(dst->cfSetMap!=NULL); return dst->cfSetMap(src,dst); }
#define STATISTIC(f)
Definition: numstats.h:16
#define assume(x)
Definition: mod2.h:405
static FORCE_INLINE nMapFunc n_SetMap(const coeffs src, const coeffs dst)
set the mapping function pointers for translating numbers from src to dst
Definition: coeffs.h:720
#define NULL
Definition: omList.c:10
static FORCE_INLINE int n_Size ( number  n,
const coeffs  r 
)
static

return a non-negative measure for the complexity of n; return 0 only when n represents zero; (used for pivot strategies in matrix computations with entries from r)

Definition at line 571 of file coeffs.h.

572 { STATISTIC(n_Size); assume(r != NULL); assume(r->cfSize!=NULL); return r->cfSize(n,r); }
#define STATISTIC(f)
Definition: numstats.h:16
#define assume(x)
Definition: mod2.h:405
#define NULL
Definition: omList.c:10
static FORCE_INLINE int n_Size(number n, const coeffs r)
return a non-negative measure for the complexity of n; return 0 only when n represents zero; (used fo...
Definition: coeffs.h:571
static FORCE_INLINE number n_Sub ( number  a,
number  b,
const coeffs  r 
)
static

return the difference of 'a' and 'b', i.e., a-b

Definition at line 668 of file coeffs.h.

669 { STATISTIC(n_Sub); assume(r != NULL); assume(r->cfSub!=NULL); const number d = r->cfSub(a, b, r);
670 
671 #ifdef HAVE_NUMSTATS
672  // avoid double counting
673  if( r->cfIsZero(d,r) ) STATISTIC(n_CancelOut);
674 #endif
675 
676  return d;
677 }
static FORCE_INLINE number n_Sub(number a, number b, const coeffs r)
return the difference of &#39;a&#39; and &#39;b&#39;, i.e., a-b
Definition: coeffs.h:668
#define STATISTIC(f)
Definition: numstats.h:16
const poly a
Definition: syzextra.cc:212
#define assume(x)
Definition: mod2.h:405
#define NULL
Definition: omList.c:10
const poly b
Definition: syzextra.cc:213
static FORCE_INLINE number n_SubringGcd ( number  a,
number  b,
const coeffs  r 
)
static

Definition at line 687 of file coeffs.h.

688 { STATISTIC(n_SubringGcd); assume(r != NULL); assume(r->cfSubringGcd!=NULL); return r->cfSubringGcd(a,b,r); }
#define STATISTIC(f)
Definition: numstats.h:16
const poly a
Definition: syzextra.cc:212
#define assume(x)
Definition: mod2.h:405
#define NULL
Definition: omList.c:10
static FORCE_INLINE number n_SubringGcd(number a, number b, const coeffs r)
Definition: coeffs.h:687
const poly b
Definition: syzextra.cc:213
static FORCE_INLINE void n_Write ( number &  n,
const coeffs  r,
const BOOLEAN  bShortOut = TRUE 
)
static

Definition at line 592 of file coeffs.h.

593 { STATISTIC(n_Write); if (bShortOut) n_WriteShort(n, r); else n_WriteLong(n, r); }
#define STATISTIC(f)
Definition: numstats.h:16
static FORCE_INLINE void n_Write(number &n, const coeffs r, const BOOLEAN bShortOut=TRUE)
Definition: coeffs.h:592
static FORCE_INLINE void n_WriteShort(number &n, const coeffs r)
write to the output buffer of the currently used reporter in a shortest possible way, e.g. in K(a): a2 instead of a^2
Definition: coeffs.h:589
static FORCE_INLINE void n_WriteLong(number &n, const coeffs r)
write to the output buffer of the currently used reporter
Definition: coeffs.h:584
static FORCE_INLINE void n_WriteFd ( number  a,
FILE *  f,
const coeffs  r 
)
static

io via ssi:

Definition at line 974 of file coeffs.h.

975 { STATISTIC(n_WriteFd); assume(r != NULL); assume(r->cfWriteFd != NULL); return r->cfWriteFd(a, f, r); }
#define STATISTIC(f)
Definition: numstats.h:16
const poly a
Definition: syzextra.cc:212
f
Definition: cfModGcd.cc:4022
#define assume(x)
Definition: mod2.h:405
static FORCE_INLINE void n_WriteFd(number a, FILE *f, const coeffs r)
io via ssi:
Definition: coeffs.h:974
#define NULL
Definition: omList.c:10
static FORCE_INLINE void n_WriteLong ( number &  n,
const coeffs  r 
)
static

write to the output buffer of the currently used reporter

Definition at line 584 of file coeffs.h.

585 { STATISTIC(n_WriteLong); assume(r != NULL); assume(r->cfWriteLong!=NULL); r->cfWriteLong(n,r); }
#define STATISTIC(f)
Definition: numstats.h:16
#define assume(x)
Definition: mod2.h:405
#define NULL
Definition: omList.c:10
static FORCE_INLINE void n_WriteLong(number &n, const coeffs r)
write to the output buffer of the currently used reporter
Definition: coeffs.h:584
static FORCE_INLINE void n_WriteShort ( number &  n,
const coeffs  r 
)
static

write to the output buffer of the currently used reporter in a shortest possible way, e.g. in K(a): a2 instead of a^2

Definition at line 589 of file coeffs.h.

590 { STATISTIC(n_WriteShort); assume(r != NULL); assume(r->cfWriteShort!=NULL); r->cfWriteShort(n,r); }
#define STATISTIC(f)
Definition: numstats.h:16
#define assume(x)
Definition: mod2.h:405
#define NULL
Definition: omList.c:10
static FORCE_INLINE void n_WriteShort(number &n, const coeffs r)
write to the output buffer of the currently used reporter in a shortest possible way, e.g. in K(a): a2 instead of a^2
Definition: coeffs.h:589
static FORCE_INLINE number n_XExtGcd ( number  a,
number  b,
number *  s,
number *  t,
number *  u,
number *  v,
const coeffs  r 
)
static

Definition at line 694 of file coeffs.h.

695 { STATISTIC(n_XExtGcd); assume(r != NULL); assume(r->cfXExtGcd!=NULL); return r->cfXExtGcd (a,b,s,t,u,v,r); }
#define STATISTIC(f)
Definition: numstats.h:16
const CanonicalForm int s
Definition: facAbsFact.cc:55
const poly a
Definition: syzextra.cc:212
static FORCE_INLINE number n_XExtGcd(number a, number b, number *s, number *t, number *u, number *v, const coeffs r)
Definition: coeffs.h:694
#define assume(x)
Definition: mod2.h:405
const Variable & v
< [in] a sqrfree bivariate poly
Definition: facBivar.h:37
#define NULL
Definition: omList.c:10
const poly b
Definition: syzextra.cc:213
static FORCE_INLINE BOOLEAN nCoeff_has_simple_Alloc ( const coeffs  r)
static

TRUE if n_Delete/n_New are empty operations.

Definition at line 907 of file coeffs.h.

908 { assume(r != NULL); return r->has_simple_Alloc; }
#define assume(x)
Definition: mod2.h:405
#define NULL
Definition: omList.c:10
static FORCE_INLINE BOOLEAN nCoeff_has_simple_inverse ( const coeffs  r)
static

TRUE, if the computation of the inverse is fast, i.e. prefer leading coeff. 1 over content.

Definition at line 903 of file coeffs.h.

904 { assume(r != NULL); return r->has_simple_Inverse; }
#define assume(x)
Definition: mod2.h:405
#define NULL
Definition: omList.c:10
static FORCE_INLINE BOOLEAN nCoeff_has_Units ( const coeffs  r)
static

returns TRUE, if r is not a field and r has non-trivial units

Definition at line 815 of file coeffs.h.

816 { assume(r != NULL); return ((getCoeffType(r)==n_Zn) || (getCoeffType(r)==n_Z2m) || (getCoeffType(r)==n_Znm)); }
only used if HAVE_RINGS is defined: ?
Definition: coeffs.h:43
only used if HAVE_RINGS is defined: ?
Definition: coeffs.h:45
only used if HAVE_RINGS is defined: ?
Definition: coeffs.h:44
#define assume(x)
Definition: mod2.h:405
static FORCE_INLINE n_coeffType getCoeffType(const coeffs r)
Returns the type of coeffs domain.
Definition: coeffs.h:422
#define NULL
Definition: omList.c:10
static FORCE_INLINE BOOLEAN nCoeff_is_algExt ( const coeffs  r)
static

TRUE iff r represents an algebraic extension field.

Definition at line 911 of file coeffs.h.

912 { assume(r != NULL); return (getCoeffType(r)==n_algExt); }
#define assume(x)
Definition: mod2.h:405
static FORCE_INLINE n_coeffType getCoeffType(const coeffs r)
Returns the type of coeffs domain.
Definition: coeffs.h:422
#define NULL
Definition: omList.c:10
used for all algebraic extensions, i.e., the top-most extension in an extension tower is algebraic ...
Definition: coeffs.h:35
static FORCE_INLINE BOOLEAN nCoeff_is_CF ( const coeffs  r)
static

Definition at line 898 of file coeffs.h.

899 { assume(r != NULL); return getCoeffType(r)==n_CF; }
?
Definition: coeffs.h:46
#define assume(x)
Definition: mod2.h:405
static FORCE_INLINE n_coeffType getCoeffType(const coeffs r)
Returns the type of coeffs domain.
Definition: coeffs.h:422
#define NULL
Definition: omList.c:10
static FORCE_INLINE BOOLEAN nCoeff_is_Domain ( const coeffs  r)
static

returns TRUE, if r is a field or r has no zero divisors (i.e is a domain)

Definition at line 757 of file coeffs.h.

758 {
759  assume(r != NULL);
760  return (r->is_domain);
761 }
#define assume(x)
Definition: mod2.h:405
#define NULL
Definition: omList.c:10
static FORCE_INLINE BOOLEAN nCoeff_is_Extension ( const coeffs  r)
static

Definition at line 844 of file coeffs.h.

845 {
846  assume(r != NULL);
847  return (getCoeffType(r)==n_algExt) || (getCoeffType(r)==n_transExt);
848 }
used for all transcendental extensions, i.e., the top-most extension in an extension tower is transce...
Definition: coeffs.h:38
#define assume(x)
Definition: mod2.h:405
static FORCE_INLINE n_coeffType getCoeffType(const coeffs r)
Returns the type of coeffs domain.
Definition: coeffs.h:422
#define NULL
Definition: omList.c:10
used for all algebraic extensions, i.e., the top-most extension in an extension tower is algebraic ...
Definition: coeffs.h:35
static FORCE_INLINE BOOLEAN nCoeff_is_GF ( const coeffs  r)
static

Definition at line 837 of file coeffs.h.

838 { assume(r != NULL); return getCoeffType(r)==n_GF; }
#define assume(x)
Definition: mod2.h:405
static FORCE_INLINE n_coeffType getCoeffType(const coeffs r)
Returns the type of coeffs domain.
Definition: coeffs.h:422
#define NULL
Definition: omList.c:10
{p^n < 2^16}
Definition: coeffs.h:33
static FORCE_INLINE BOOLEAN nCoeff_is_GF ( const coeffs  r,
int  q 
)
static

Definition at line 840 of file coeffs.h.

841 { assume(r != NULL); return (getCoeffType(r)==n_GF) && (r->ch == q); }
#define assume(x)
Definition: mod2.h:405
static FORCE_INLINE n_coeffType getCoeffType(const coeffs r)
Returns the type of coeffs domain.
Definition: coeffs.h:422
#define NULL
Definition: omList.c:10
{p^n < 2^16}
Definition: coeffs.h:33
static FORCE_INLINE BOOLEAN nCoeff_is_long_C ( const coeffs  r)
static

Definition at line 895 of file coeffs.h.

896 { assume(r != NULL); return getCoeffType(r)==n_long_C; }
#define assume(x)
Definition: mod2.h:405
complex floating point (GMP) numbers
Definition: coeffs.h:41
static FORCE_INLINE n_coeffType getCoeffType(const coeffs r)
Returns the type of coeffs domain.
Definition: coeffs.h:422
#define NULL
Definition: omList.c:10
static FORCE_INLINE BOOLEAN nCoeff_is_long_R ( const coeffs  r)
static

Definition at line 892 of file coeffs.h.

893 { assume(r != NULL); return getCoeffType(r)==n_long_R; }
real floating point (GMP) numbers
Definition: coeffs.h:34
#define assume(x)
Definition: mod2.h:405
static FORCE_INLINE n_coeffType getCoeffType(const coeffs r)
Returns the type of coeffs domain.
Definition: coeffs.h:422
#define NULL
Definition: omList.c:10
static FORCE_INLINE BOOLEAN nCoeff_is_numeric ( const coeffs  r)
static

Definition at line 830 of file coeffs.h.

831 { assume(r != NULL); return (getCoeffType(r)==n_R) || (getCoeffType(r)==n_long_R) || (getCoeffType(r)==n_long_C); }
real floating point (GMP) numbers
Definition: coeffs.h:34
single prescision (6,6) real numbers
Definition: coeffs.h:32
#define assume(x)
Definition: mod2.h:405
complex floating point (GMP) numbers
Definition: coeffs.h:41
static FORCE_INLINE n_coeffType getCoeffType(const coeffs r)
Returns the type of coeffs domain.
Definition: coeffs.h:422
#define NULL
Definition: omList.c:10
static FORCE_INLINE BOOLEAN nCoeff_is_Q ( const coeffs  r)
static

Definition at line 824 of file coeffs.h.

825 { assume(r != NULL); return getCoeffType(r)==n_Q && (r->is_field); }
rational (GMP) numbers
Definition: coeffs.h:31
#define assume(x)
Definition: mod2.h:405
static FORCE_INLINE n_coeffType getCoeffType(const coeffs r)
Returns the type of coeffs domain.
Definition: coeffs.h:422
#define NULL
Definition: omList.c:10
static FORCE_INLINE BOOLEAN nCoeff_is_Q_a ( const coeffs  r)
static

Definition at line 883 of file coeffs.h.

884 {
885  assume(r != NULL);
886  return ((n_GetChar(r) == 0) && nCoeff_is_Extension(r));
887 }
static FORCE_INLINE int n_GetChar(const coeffs r)
Return the characteristic of the coeff. domain.
Definition: coeffs.h:445
#define assume(x)
Definition: mod2.h:405
#define NULL
Definition: omList.c:10
static FORCE_INLINE BOOLEAN nCoeff_is_Extension(const coeffs r)
Definition: coeffs.h:844
static FORCE_INLINE BOOLEAN nCoeff_is_Q_algext ( const coeffs  r)
static

is it an alg. ext. of Q?

Definition at line 915 of file coeffs.h.

916 { assume(r != NULL); return ((n_GetChar(r) == 0) && nCoeff_is_algExt(r)); }
static FORCE_INLINE int n_GetChar(const coeffs r)
Return the characteristic of the coeff. domain.
Definition: coeffs.h:445
static FORCE_INLINE BOOLEAN nCoeff_is_algExt(const coeffs r)
TRUE iff r represents an algebraic extension field.
Definition: coeffs.h:911
#define assume(x)
Definition: mod2.h:405
#define NULL
Definition: omList.c:10
static FORCE_INLINE BOOLEAN nCoeff_is_Q_or_BI ( const coeffs  r)
static

Definition at line 827 of file coeffs.h.

828 { assume(r != NULL); return getCoeffType(r)==n_Q; }
rational (GMP) numbers
Definition: coeffs.h:31
#define assume(x)
Definition: mod2.h:405
static FORCE_INLINE n_coeffType getCoeffType(const coeffs r)
Returns the type of coeffs domain.
Definition: coeffs.h:422
#define NULL
Definition: omList.c:10
static FORCE_INLINE BOOLEAN nCoeff_is_R ( const coeffs  r)
static

Definition at line 834 of file coeffs.h.

835 { assume(r != NULL); return getCoeffType(r)==n_R; }
single prescision (6,6) real numbers
Definition: coeffs.h:32
#define assume(x)
Definition: mod2.h:405
static FORCE_INLINE n_coeffType getCoeffType(const coeffs r)
Returns the type of coeffs domain.
Definition: coeffs.h:422
#define NULL
Definition: omList.c:10
static FORCE_INLINE BOOLEAN nCoeff_is_Ring ( const coeffs  r)
static

Definition at line 753 of file coeffs.h.

754 { assume(r != NULL); return (r->is_field==0); }
#define assume(x)
Definition: mod2.h:405
#define NULL
Definition: omList.c:10
static FORCE_INLINE BOOLEAN nCoeff_is_Ring_2toM ( const coeffs  r)
static

Definition at line 741 of file coeffs.h.

742 { assume(r != NULL); return (getCoeffType(r)==n_Z2m); }
only used if HAVE_RINGS is defined: ?
Definition: coeffs.h:45
#define assume(x)
Definition: mod2.h:405
static FORCE_INLINE n_coeffType getCoeffType(const coeffs r)
Returns the type of coeffs domain.
Definition: coeffs.h:422
#define NULL
Definition: omList.c:10
static FORCE_INLINE BOOLEAN nCoeff_is_Ring_ModN ( const coeffs  r)
static

Definition at line 744 of file coeffs.h.

745 { assume(r != NULL); return (getCoeffType(r)==n_Zn); }
only used if HAVE_RINGS is defined: ?
Definition: coeffs.h:43
#define assume(x)
Definition: mod2.h:405
static FORCE_INLINE n_coeffType getCoeffType(const coeffs r)
Returns the type of coeffs domain.
Definition: coeffs.h:422
#define NULL
Definition: omList.c:10
static FORCE_INLINE BOOLEAN nCoeff_is_Ring_PtoM ( const coeffs  r)
static

Definition at line 747 of file coeffs.h.

748 { assume(r != NULL); return (getCoeffType(r)==n_Znm); }
only used if HAVE_RINGS is defined: ?
Definition: coeffs.h:44
#define assume(x)
Definition: mod2.h:405
static FORCE_INLINE n_coeffType getCoeffType(const coeffs r)
Returns the type of coeffs domain.
Definition: coeffs.h:422
#define NULL
Definition: omList.c:10
static FORCE_INLINE BOOLEAN nCoeff_is_Ring_Z ( const coeffs  r)
static

Definition at line 750 of file coeffs.h.

751 { assume(r != NULL); return (getCoeffType(r)==n_Z); }
#define assume(x)
Definition: mod2.h:405
only used if HAVE_RINGS is defined: ?
Definition: coeffs.h:42
static FORCE_INLINE n_coeffType getCoeffType(const coeffs r)
Returns the type of coeffs domain.
Definition: coeffs.h:422
#define NULL
Definition: omList.c:10
static FORCE_INLINE BOOLEAN nCoeff_is_transExt ( const coeffs  r)
static

TRUE iff r represents a transcendental extension field.

Definition at line 919 of file coeffs.h.

920 { assume(r != NULL); return (getCoeffType(r)==n_transExt); }
used for all transcendental extensions, i.e., the top-most extension in an extension tower is transce...
Definition: coeffs.h:38
#define assume(x)
Definition: mod2.h:405
static FORCE_INLINE n_coeffType getCoeffType(const coeffs r)
Returns the type of coeffs domain.
Definition: coeffs.h:422
#define NULL
Definition: omList.c:10
static FORCE_INLINE BOOLEAN nCoeff_is_Zp ( const coeffs  r)
static

Definition at line 818 of file coeffs.h.

819 { assume(r != NULL); return getCoeffType(r)==n_Zp; }
{p < 2^31}
Definition: coeffs.h:30
#define assume(x)
Definition: mod2.h:405
static FORCE_INLINE n_coeffType getCoeffType(const coeffs r)
Returns the type of coeffs domain.
Definition: coeffs.h:422
#define NULL
Definition: omList.c:10
static FORCE_INLINE BOOLEAN nCoeff_is_Zp ( const coeffs  r,
int  p 
)
static

Definition at line 821 of file coeffs.h.

822 { assume(r != NULL); return ((getCoeffType(r)==n_Zp) && (r->ch == p)); }
return P p
Definition: myNF.cc:203
{p < 2^31}
Definition: coeffs.h:30
#define assume(x)
Definition: mod2.h:405
static FORCE_INLINE n_coeffType getCoeffType(const coeffs r)
Returns the type of coeffs domain.
Definition: coeffs.h:422
#define NULL
Definition: omList.c:10
static FORCE_INLINE BOOLEAN nCoeff_is_Zp_a ( const coeffs  r)
static

Definition at line 857 of file coeffs.h.

858 {
859  assume(r != NULL);
860  return ((!nCoeff_is_Ring(r)) && (n_GetChar(r) != 0) && nCoeff_is_Extension(r));
861 }
static FORCE_INLINE int n_GetChar(const coeffs r)
Return the characteristic of the coeff. domain.
Definition: coeffs.h:445
static FORCE_INLINE BOOLEAN nCoeff_is_Ring(const coeffs r)
Definition: coeffs.h:753
#define assume(x)
Definition: mod2.h:405
#define NULL
Definition: omList.c:10
static FORCE_INLINE BOOLEAN nCoeff_is_Extension(const coeffs r)
Definition: coeffs.h:844
static FORCE_INLINE BOOLEAN nCoeff_is_Zp_a ( const coeffs  r,
int  p 
)
static

Definition at line 870 of file coeffs.h.

871 {
872  assume(r != NULL);
873  assume(p != 0);
874  return ((!nCoeff_is_Ring(r)) && (n_GetChar(r) == p) && nCoeff_is_Extension(r));
875 }
return P p
Definition: myNF.cc:203
static FORCE_INLINE int n_GetChar(const coeffs r)
Return the characteristic of the coeff. domain.
Definition: coeffs.h:445
static FORCE_INLINE BOOLEAN nCoeff_is_Ring(const coeffs r)
Definition: coeffs.h:753
#define assume(x)
Definition: mod2.h:405
#define NULL
Definition: omList.c:10
static FORCE_INLINE BOOLEAN nCoeff_is_Extension(const coeffs r)
Definition: coeffs.h:844
static FORCE_INLINE char* nCoeffName ( const coeffs  cf)
static

Definition at line 967 of file coeffs.h.

968 { STATISTIC(nCoeffName); assume( cf != NULL ); return cf->cfCoeffName(cf); }
#define STATISTIC(f)
Definition: numstats.h:16
#define assume(x)
Definition: mod2.h:405
static FORCE_INLINE char * nCoeffName(const coeffs cf)
Definition: coeffs.h:967
#define NULL
Definition: omList.c:10
static FORCE_INLINE char* nCoeffString ( const coeffs  cf)
static

TODO: make it a virtual method of coeffs, together with: Decompose & Compose, rParameter & rPar.

Definition at line 963 of file coeffs.h.

964 { STATISTIC(nCoeffString); assume( cf != NULL ); return cf->cfCoeffString(cf); }
#define STATISTIC(f)
Definition: numstats.h:16
#define assume(x)
Definition: mod2.h:405
#define NULL
Definition: omList.c:10
static FORCE_INLINE char * nCoeffString(const coeffs cf)
TODO: make it a virtual method of coeffs, together with: Decompose & Compose, rParameter & rPar...
Definition: coeffs.h:963
static FORCE_INLINE coeffs nCopyCoeff ( const coeffs  r)
static

"copy" coeffs, i.e. increment ref

Definition at line 430 of file coeffs.h.

431 { assume(r!=NULL); r->ref++; return r;}
const ring r
Definition: syzextra.cc:208
#define assume(x)
Definition: mod2.h:405
#define NULL
Definition: omList.c:10
coeffs nInitChar ( n_coeffType  t,
void *  parameter 
)

one-time initialisations for new coeffs in case of an error return NULL

Definition at line 327 of file numbers.cc.

329 {
330  n_Procs_s *n=cf_root;
331 
332  while((n!=NULL) && (n->nCoeffIsEqual!=NULL) && (!n->nCoeffIsEqual(n,t,parameter)))
333  n=n->next;
334 
335  if (n==NULL)
336  {
337  n=(n_Procs_s*)omAlloc0(sizeof(n_Procs_s));
338  n->next=cf_root;
339  n->ref=1;
340  n->type=t;
341 
342  // default entries (different from NULL) for some routines:
344  n->cfSize = ndSize;
347  n->cfImPart=ndReturn0;
348  n->cfDelete= ndDelete;
349  n->cfAnn = ndAnn;
350  n->cfCoeffString = ndCoeffString; // should alway be changed!
351  n->cfInpMult=ndInpMult;
352  n->cfInpAdd=ndInpAdd;
353  n->cfCopy = ndCopy;
354  n->cfIntMod=ndIntMod; /* dummy !! */
356  n->cfGcd = ndGcd;
357  n->cfNormalizeHelper = ndGcd; /* tricky, isn't it ?*/
358  n->cfLcm = ndGcd; /* tricky, isn't it ?*/
359  n->cfInitMPZ = ndInitMPZ;
360  n->cfMPZ = ndMPZ;
361  n->cfPower = ndPower;
363 
364  n->cfKillChar = ndKillChar; /* dummy */
365  n->cfSetChar = ndSetChar; /* dummy */
366  // temp. removed to catch all the coeffs which miss to implement this!
367 
369  n->cfFarey = ndFarey;
370  n->cfParDeg = ndParDeg;
371 
373 
376 
377  n->cfIsUnit = ndIsUnit;
378 #ifdef HAVE_RINGS
379  n->cfDivComp = ndDivComp;
380  n->cfDivBy = ndDivBy;
381  n->cfExtGcd = ndExtGcd;
382  //n->cfGetUnit = (nMapFunc)NULL;
383 #endif
384 
385 #ifdef LDEBUG
386  n->cfDBTest=ndDBTest;
387 #endif
388 
391 
392  BOOLEAN nOK=TRUE;
393  // init
394  if ((t<=nLastCoeffs) && (nInitCharTable[t]!=NULL))
395  nOK = (nInitCharTable[t])(n,parameter);
396  else
397  Werror("Sorry: the coeff type [%d] was not registered: it is missing in nInitCharTable", (int)t);
398  if (nOK)
399  {
400  omFreeSize(n,sizeof(*n));
401  return NULL;
402  }
403  cf_root=n;
404  // post init settings:
405  if (n->cfRePart==NULL) n->cfRePart=n->cfCopy;
406  if (n->cfExactDiv==NULL) n->cfExactDiv=n->cfDiv;
407  if (n->cfSubringGcd==NULL) n->cfSubringGcd=n->cfGcd;
408 
409 #ifdef HAVE_RINGS
410  if (n->cfGetUnit==NULL) n->cfGetUnit=n->cfCopy;
411 #endif
412 
413  if(n->cfWriteShort==NULL)
414  n->cfWriteShort = n->cfWriteLong;
415 
417  assume(n->cfSetChar!=NULL);
419  assume(n->cfMult!=NULL);
420  assume(n->cfSub!=NULL);
421  assume(n->cfAdd!=NULL);
422  assume(n->cfDiv!=NULL);
423  assume(n->cfIntMod!=NULL);
424  assume(n->cfExactDiv!=NULL);
425  assume(n->cfInit!=NULL);
426  assume(n->cfInitMPZ!=NULL);
427  assume(n->cfSize!=NULL);
428  assume(n->cfInt!=NULL);
429  assume(n->cfMPZ!=NULL);
430  //assume(n->n->cfDivComp!=NULL);
431  //assume(n->cfIsUnit!=NULL);
432  //assume(n->cfGetUnit!=NULL);
433  //assume(n->cfExtGcd!=NULL);
434  assume(n->cfInpNeg!=NULL);
435  assume(n->cfCopy!=NULL);
436 
437  assume(n->cfWriteLong!=NULL);
438  assume(n->cfWriteShort!=NULL);
439 
440  assume(n->iNumberOfParameters>= 0);
441 
442  assume( (n->iNumberOfParameters == 0 && n->pParameterNames == NULL) ||
443  (n->iNumberOfParameters > 0 && n->pParameterNames != NULL) );
444 
445  assume(n->cfParameter!=NULL);
446  assume(n->cfParDeg!=NULL);
447 
448  assume(n->cfRead!=NULL);
449  assume(n->cfNormalize!=NULL);
450  assume(n->cfGreater!=NULL);
451  //assume(n->cfDivBy!=NULL);
452  assume(n->cfEqual!=NULL);
453  assume(n->cfIsZero!=NULL);
454  assume(n->cfIsOne!=NULL);
455  assume(n->cfIsMOne!=NULL);
457  assume(n->cfGetDenom!=NULL);
459  assume(n->cfGcd!=NULL);
461  assume(n->cfDelete!=NULL);
462  assume(n->cfSetMap!=NULL);
463  assume(n->cfInpMult!=NULL);
464 // assume(n->cfInit_bigint!=NULL);
465  assume(n->cfCoeffWrite != NULL);
466 
467  assume(n->cfClearContent != NULL);
469 
470  assume(n->type==t);
471 
472 #ifndef SING_NDEBUG
473  if(n->cfKillChar==NULL) Warn("cfKillChar is NULL for coeff %d",t);
474  if(n->cfWriteLong==NULL) Warn("cfWrite is NULL for coeff %d",t);
475  if(n->cfWriteShort==NULL) Warn("cfWriteShort is NULL for coeff %d",t);
476  if(n->cfCoeffString==ndCoeffString) Warn("cfCoeffString is undefined for coeff %d",t);
477 #endif
478 
479  if( n->nNULL == NULL )
480  n->nNULL = n->cfInit(0, n); // may still remain NULL
481  }
482  else
483  {
484  n->ref++;
485  }
486  return n;
static BOOLEAN ndIsUnit(number a, const coeffs r)
Definition: numbers.cc:103
BOOLEAN(* cfDivBy)(number a, number b, const coeffs r)
Definition: coeffs.h:382
number(* cfCopy)(number a, const coeffs r)
return a copy of a
Definition: coeffs.h:198
number(* cfExtGcd)(number a, number b, number *s, number *t, const coeffs r)
Definition: coeffs.h:245
numberfunc cfIntMod
Definition: coeffs.h:174
int(* cfDivComp)(number a, number b, const coeffs r)
Definition: coeffs.h:378
static void ndPower(number a, int i, number *res, const coeffs r)
Definition: numbers.cc:72
static number ndParameter(const int, const coeffs r)
Definition: numbers.cc:125
number nNULL
the 0 as constant, NULL by default
Definition: coeffs.h:317
static void ndKillChar(coeffs)
Definition: numbers.cc:249
static BOOLEAN ndDBTest(number, const char *, const int, const coeffs)
Definition: numbers.cc:106
BOOLEAN(* cfDBTest)(number a, const char *f, const int l, const coeffs r)
Test: is "a" a correct number?
Definition: coeffs.h:416
void(* cfMPZ)(mpz_t result, number &n, const coeffs r)
Converts a non-negative number n into a GMP number, 0 if impossible.
Definition: coeffs.h:189
void(* cfSetChar)(const coeffs r)
Definition: coeffs.h:160
static BOOLEAN ndDivBy(number, number, const coeffs)
Definition: numbers.cc:255
char const ** pParameterNames
array containing the names of Parameters (default NULL)
Definition: coeffs.h:323
coeffs next
Definition: coeffs.h:124
static number ndCopy(number a, const coeffs)
Definition: numbers.cc:238
static n_coeffType nLastCoeffs
Definition: numbers.cc:293
static number ndChineseRemainder(number *, number *, int, BOOLEAN, CFArray &, const coeffs r)
Definition: numbers.cc:114
void(* cfDelete)(number *a, const coeffs r)
Definition: coeffs.h:269
static void ndNormalize(number &, const coeffs)
Definition: numbers.cc:146
BOOLEAN(*)(*)(*)(*) cfIsOne(number a, const coeffs r)
Definition: coeffs.h:228
#define omFreeSize(addr, size)
Definition: omAllocDecl.h:260
number(* cfSubringGcd)(number a, number b, const coeffs r)
Definition: coeffs.h:244
static number ndConvFactoryNSingN(const CanonicalForm, const coeffs)
[in, out] a bigint number >= 0
Definition: numbers.cc:267
numberfunc cfAdd
Definition: coeffs.h:174
BOOLEAN(* cfGreater)(number a, number b, const coeffs r)
Definition: coeffs.h:224
void(* cfNormalize)(number &a, const coeffs r)
Definition: coeffs.h:222
static char * ndCoeffString(const coeffs r)
Definition: numbers.cc:54
number(* cfRePart)(number a, const coeffs r)
Definition: coeffs.h:199
#define TRUE
Definition: auxiliary.h:144
static void ndDelete(number *d, const coeffs)
Definition: numbers.cc:52
static int ndDivComp(number, number, const coeffs)
Definition: numbers.cc:256
void(* cfCoeffWrite)(const coeffs r, BOOLEAN details)
output of coeff description via Print
Definition: coeffs.h:147
static char * ndCoeffName(const coeffs r)
Definition: numbers.cc:153
BOOLEAN(* cfIsUnit)(number a, const coeffs r)
Definition: coeffs.h:379
number(* cfGetUnit)(number a, const coeffs r)
Definition: coeffs.h:380
number(* cfFarey)(number p, number n, const coeffs)
rational reconstruction: "best" rational a/b with a/b = p mod n
Definition: coeffs.h:288
number(* cfInitMPZ)(mpz_t i, const coeffs r)
init with a GMP integer
Definition: coeffs.h:180
char *(* cfCoeffString)(const coeffs r)
string output of coeff description
Definition: coeffs.h:150
BOOLEAN(* nCoeffIsEqual)(const coeffs r, n_coeffType n, void *parameter)
Definition: coeffs.h:144
static number ndReturn0(number, const coeffs r)
Definition: numbers.cc:147
static void ndInpMult(number &a, number b, const coeffs r)
Definition: numbers.cc:59
number(* cfInit)(long i, const coeffs r)
init with an integer
Definition: coeffs.h:177
number(* cfNormalizeHelper)(number a, number b, const coeffs r)
Definition: coeffs.h:268
static number ndInitMPZ(mpz_t m, const coeffs r)
Definition: numbers.cc:280
static int ndParDeg(number n, const coeffs r)
Definition: numbers.cc:120
BOOLEAN(*)(*)(*)(*)(*)(*) cfGreaterZero(number a, const coeffs r)
Definition: coeffs.h:234
long(* cfInt)(number &n, const coeffs r)
convertion to long, 0 if impossible
Definition: coeffs.h:186
void(* cfInpMult)(number &a, number b, const coeffs r)
Inplace: a *= b.
Definition: coeffs.h:278
numberfunc cfSub
Definition: coeffs.h:174
static void ndClearContent(ICoeffsEnumerator &numberCollectionEnumerator, number &c, const coeffs r)
Definition: numbers.cc:155
static number ndGetDenom(number &, const coeffs r)
Definition: numbers.cc:150
number(* cfImPart)(number a, const coeffs r)
Definition: coeffs.h:200
#define assume(x)
Definition: mod2.h:405
number(* cfInpNeg)(number a, const coeffs r)
changes argument inline: a:= -a return -a! (no copy is returned) the result should be assigned to the...
Definition: coeffs.h:194
static int ndSize(number a, const coeffs r)
Definition: numbers.cc:152
int ref
Definition: coeffs.h:125
void(* cfPower)(number a, int i, number *result, const coeffs r)
Definition: coeffs.h:236
nCoeffsEnumeratorFunc cfClearContent
function pointer behind n_ClearContent
Definition: coeffs.h:306
n_Procs_s * cf_root
Definition: numbers.cc:47
numberfunc cfExactDiv
Definition: coeffs.h:174
static BOOLEAN ndCoeffIsEqual(const coeffs r, n_coeffType n, void *)
Definition: numbers.cc:286
n_coeffType type
Definition: coeffs.h:127
static CanonicalForm ndConvSingNFactoryN(number, BOOLEAN, const coeffs)
Definition: numbers.cc:260
numberfunc cfDiv
Definition: coeffs.h:174
const char *(* cfRead)(const char *s, number *a, const coeffs r)
Definition: coeffs.h:220
numberfunc cfMult
Definition: coeffs.h:174
static number ndGcd(number, number, const coeffs r)
Definition: numbers.cc:148
static number ndExtGcd(number, number, number *, number *, const coeffs r)
Definition: numbers.cc:257
static cfInitCharProc * nInitCharTable
Definition: numbers.cc:323
#define NULL
Definition: omList.c:10
void(* cfWriteLong)(number a, const coeffs r)
print a given number (long format)
Definition: coeffs.h:203
number(* cfGcd)(number a, number b, const coeffs r)
Definition: coeffs.h:243
static void ndSetChar(const coeffs)
Definition: numbers.cc:250
number(* cfLcm)(number a, number b, const coeffs r)
Definition: coeffs.h:267
static void ndInpAdd(number &a, number b, const coeffs r)
Definition: numbers.cc:65
number(* convFactoryNSingN)(const CanonicalForm n, const coeffs r)
conversion to CanonicalForm(factory) to number
Definition: coeffs.h:312
number(* cfChineseRemainder)(number *x, number *q, int rl, BOOLEAN sym, CFArray &inv_cache, const coeffs)
chinese remainder returns X with X mod q[i]=x[i], i=0..rl-1
Definition: coeffs.h:294
static number ndGetNumerator(number &a, const coeffs r)
Definition: numbers.cc:151
static number ndAnn(number, const coeffs)
Definition: numbers.cc:53
static number ndIntMod(number, number, const coeffs r)
Definition: numbers.cc:149
static number ndFarey(number, number, const coeffs r)
Definition: numbers.cc:109
static void ndClearDenominators(ICoeffsEnumerator &, number &d, const coeffs r)
Definition: numbers.cc:229
nMapFunc(* cfSetMap)(const coeffs src, const coeffs dst)
Definition: coeffs.h:272
char *(* cfCoeffName)(const coeffs r)
default name of cf, should substitue cfCoeffWrite, cfCoeffString
Definition: coeffs.h:153
int(* cfSize)(number n, const coeffs r)
how complicated, (0) => 0, or positive
Definition: coeffs.h:183
number(* cfAnn)(number a, const coeffs r)
Definition: coeffs.h:258
number(* cfParameter)(const int i, const coeffs r)
create i^th parameter or NULL if not possible
Definition: coeffs.h:300
BOOLEAN(*)(*)(*)(*)(*) cfIsMOne(number a, const coeffs r)
Definition: coeffs.h:229
CanonicalForm(* convSingNFactoryN)(number n, BOOLEAN setChar, const coeffs r)
Definition: coeffs.h:313
void(* cfKillChar)(coeffs r)
Definition: coeffs.h:158
int BOOLEAN
Definition: auxiliary.h:131
static void ndMPZ(mpz_t result, number &n, const coeffs r)
Converts a non-negative bigint number into a GMP number.
Definition: numbers.cc:275
void Werror(const char *fmt,...)
Definition: reporter.cc:199
void(* cfInpAdd)(number &a, number b, const coeffs r)
Inplace: a += b.
Definition: coeffs.h:281
number(* cfGetNumerator)(number &n, const coeffs r)
Definition: coeffs.h:238
void(* cfWriteShort)(number a, const coeffs r)
print a given number in a shorter way, if possible e.g. in K(a): a2 instead of a^2 ...
Definition: coeffs.h:207
#define omAlloc0(size)
Definition: omAllocDecl.h:211
int iNumberOfParameters
Number of Parameters in the coeffs (default 0)
Definition: coeffs.h:320
number(* cfGetDenom)(number &n, const coeffs r)
Definition: coeffs.h:237
BOOLEAN(*)(*)(*) cfIsZero(number a, const coeffs r)
Definition: coeffs.h:227
BOOLEAN(*)(*) cfEqual(number a, number b, const coeffs r)
tests
Definition: coeffs.h:226
nCoeffsEnumeratorFunc cfClearDenominators
function pointer behind n_ClearDenominators
Definition: coeffs.h:309
#define Warn
Definition: emacs.cc:80
int(* cfParDeg)(number x, const coeffs r)
degree for coeffcients: -1 for 0, 0 for "constants", ...
Definition: coeffs.h:297
void nKillChar ( coeffs  r)

undo all initialisations

Definition at line 488 of file numbers.cc.

490 {
492  if (r!=NULL)
493  {
494  r->ref--;
495  if (r->ref<=0)
496  {
497  n_Procs_s tmp;
498  n_Procs_s* n=&tmp;
499  tmp.next=cf_root;
500  while((n->next!=NULL) && (n->next!=r)) n=n->next;
501  if (n->next==r)
502  {
503  n->next=n->next->next;
504  if (cf_root==r) cf_root=n->next;
505  n_Delete(&(r->nNULL),r);
506  assume (r->cfKillChar!=NULL); r->cfKillChar(r); // STATISTIC(nKillChar);
507  omFreeSize((void *)r, sizeof(n_Procs_s));
508  r=NULL;
509  }
510  else
511  {
512  WarnS("cf_root list destroyed");
513  }
514  }
515  }
#define STATISTIC(f)
Definition: numstats.h:16
coeffs next
Definition: coeffs.h:124
#define omFreeSize(addr, size)
Definition: omAllocDecl.h:260
#define WarnS
Definition: emacs.cc:81
void nKillChar(coeffs r)
undo all initialisations
Definition: numbers.cc:488
#define assume(x)
Definition: mod2.h:405
n_Procs_s * cf_root
Definition: numbers.cc:47
#define NULL
Definition: omList.c:10
static FORCE_INLINE void n_Delete(number *p, const coeffs r)
delete &#39;p&#39;
Definition: coeffs.h:456
void nNew ( number *  a)

Definition at line 49 of file numbers.cc.

49 { *d=NULL; }
#define NULL
Definition: omList.c:10
static FORCE_INLINE void nSetChar ( const coeffs  r)
static

initialisations after each ring change

Definition at line 437 of file coeffs.h.

438 { STATISTIC(nSetChar); assume(r!=NULL); assume(r->cfSetChar != NULL); r->cfSetChar(r); }
#define STATISTIC(f)
Definition: numstats.h:16
static FORCE_INLINE void nSetChar(const coeffs r)
initialisations after each ring change
Definition: coeffs.h:437
#define assume(x)
Definition: mod2.h:405
#define NULL
Definition: omList.c:10
static FORCE_INLINE void number2mpz ( number  n,
coeffs  c,
mpz_t  m 
)
static

Definition at line 991 of file coeffs.h.

991 { n_MPZ(m, n, c); }
int m
Definition: cfEzgcd.cc:119
static FORCE_INLINE void n_MPZ(mpz_t result, number &n, const coeffs r)
conversion of n to a GMP integer; 0 if not possible
Definition: coeffs.h:552

Variable Documentation

unsigned short fftable[]

Definition at line 61 of file ffields.cc.

omBin rnumber_bin

Definition at line 23 of file longrat0.cc.