My Project  debian-1:4.1.1-p2+ds-4build1
coeffs.h
Go to the documentation of this file.
1 /*! \file coeffs/coeffs.h Coefficient rings, fields and other domains suitable for Singular polynomials
2 
3  The main interface for Singular coefficients: \ref coeffs is the main handler for Singular numbers
4 */
5 /****************************************
6 * Computer Algebra System SINGULAR *
7 ****************************************/
8 
9 #ifndef COEFFS_H
10 #define COEFFS_H
11 
12 #include "misc/auxiliary.h"
13 #include "omalloc/omalloc.h"
14 
15 #include "misc/sirandom.h"
16 /* for assume: */
17 #include "reporter/reporter.h"
18 #include "reporter/s_buff.h"
19 #include "factory/factory.h"
20 
21 #include "coeffs/si_gmp.h"
22 #include "coeffs/Enumerator.h"
23 #include "coeffs/numstats.h" // for STATISTIC(F) counting macro
24 
25 class CanonicalForm;
26 
27 enum n_coeffType
28 {
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_polyExt, /**< used to represent polys as coeffcients */
36  n_algExt, /**< used for all algebraic extensions, i.e.,
37  the top-most extension in an extension tower
38  is algebraic */
39  n_transExt, /**< used for all transcendental extensions, i.e.,
40  the top-most extension in an extension tower
41  is transcendental */
42  n_long_C, /**< complex floating point (GMP) numbers */
43  n_nTupel, /**< n-tupel of cf: ZZ/p1,... ZZ/pn, R, long_R */
44  n_Z, /**< only used if HAVE_RINGS is defined */
45  n_Zn, /**< only used if HAVE_RINGS is defined */
46  n_Znm, /**< only used if HAVE_RINGS is defined */
47  n_Z2m, /**< only used if HAVE_RINGS is defined */
48  n_CF /**< ? */
49 };
50 
51 extern const unsigned short fftable[];
52 
53 struct snumber;
54 typedef struct snumber * number;
55 
56 /* standard types */
57 struct ip_sring;
58 typedef struct ip_sring * ring;
59 typedef struct ip_sring const * const_ring;
60 
61 /// @class coeffs coeffs.h coeffs/coeffs.h
62 ///
63 /// The main handler for Singular numbers which are suitable for Singular polynomials.
64 ///
65 /// With it one may implement a ring, a field, a domain etc.
66 ///
67 struct n_Procs_s;
68 typedef struct n_Procs_s *coeffs;
69 typedef struct n_Procs_s const * const_coeffs;
70 
71 typedef number (*numberfunc)(number a, number b, const coeffs r);
72 
73 /// maps "a", which lives in src, into dst
74 typedef number (*nMapFunc)(number a, const coeffs src, const coeffs dst);
75 
76 
77 /// Abstract interface for an enumerator of number coefficients for an
78 /// object, e.g. a polynomial
80 
81 /// goes over coeffs given by the ICoeffsEnumerator and changes them.
82 /// Additionally returns a number;
83 typedef void (*nCoeffsEnumeratorFunc)(ICoeffsEnumerator& numberCollectionEnumerator, number& output, const coeffs r);
84 
85 extern omBin rnumber_bin;
86 
87 #define FREE_RNUMBER(x) omFreeBin((void *)x, rnumber_bin)
88 #define ALLOC_RNUMBER() (number)omAllocBin(rnumber_bin)
89 #define ALLOC0_RNUMBER() (number)omAlloc0Bin(rnumber_bin)
90 
91 
92 /// Creation data needed for finite fields
93 typedef struct
94 {
95  int GFChar;
96  int GFDegree;
97  const char* GFPar_name;
98 } GFInfo;
99 
100 typedef struct
101 {
102  short float_len; /**< additional char-flags, rInit */
103  short float_len2; /**< additional char-flags, rInit */
104  const char* par_name; /**< parameter name */
106 
107 
108 enum n_coeffRep
109 {
111  n_rep_int, /**< (int), see modulop.h */
112  n_rep_gap_rat, /**< (number), see longrat.h */
113  n_rep_gap_gmp, /**< (), see rinteger.h, new impl. */
114  n_rep_poly, /**< (poly), see algext.h */
115  n_rep_rat_fct, /**< (fraction), see transext.h */
116  n_rep_gmp, /**< (mpz_ptr), see rmodulon,h */
117  n_rep_float, /**< (float), see shortfl.h */
118  n_rep_gmp_float, /**< (gmp_float), see */
119  n_rep_gmp_complex,/**< (gmp_complex), see gnumpc.h */
120  n_rep_gf /**< (int), see ffields.h */
121 };
122 
123 struct n_Procs_s
124 {
125  // administration of coeffs:
127  int ref;
130  /// how many variables of factory are already used by this coeff
131  int factoryVarOffset;
132 
133  // general properties:
134  /// TRUE, if nNew/nDelete/nCopy are dummies
136  /// TRUE, if std should make polynomials monic (if nInvers is cheap)
137  /// if false, then a gcd routine is used for a content computation
139 
140  /// TRUE, if cf is a field
142  /// TRUE, if cf is a domain
144 
145  // tests for numbers.cc:
146  BOOLEAN (*nCoeffIsEqual)(const coeffs r, n_coeffType n, void * parameter);
147 
148  /// output of coeff description via Print
149  void (*cfCoeffWrite)(const coeffs r, BOOLEAN details);
150 
151  /// string output of coeff description
152  char* (*cfCoeffString)(const coeffs r);
153 
154  /// default name of cf, should substitue cfCoeffWrite, cfCoeffString
155  char* (*cfCoeffName)(const coeffs r);
156 
157  // ?
158  // initialisation:
159  //void (*cfInitChar)(coeffs r, int parameter); // do one-time initialisations
160  void (*cfKillChar)(coeffs r); // undo all initialisations
161  // or NULL
162  void (*cfSetChar)(const coeffs r); // initialisations after each ring change
163  // or NULL
164  // general stuff
165  // if the ring has a meaningful Euclidean structure, hopefully
166  // supported by cfQuotRem, then
167  // IntMod, Div should give the same result
168  // Div(a,b) = QuotRem(a,b, &IntMod(a,b))
169  // if the ring is not Euclidean or a field, then IntMod should return 0
170  // and Div the exact quotient. It is assumed that the function is
171  // ONLY called on Euclidean rings or in the case of an exact division.
172  //
173  // cfDiv does an exact division, but has to handle illegal input
174  // cfExactDiv does an exact division, but no error checking
175  // (I'm not sure I understant and even less that this makes sense)
177 
178  /// init with an integer
179  number (*cfInit)(long i,const coeffs r);
180 
181  /// init with a GMP integer
182  number (*cfInitMPZ)(mpz_t i, const coeffs r);
183 
184  /// how complicated, (0) => 0, or positive
185  int (*cfSize)(number n, const coeffs r);
186 
187  /// convertion to long, 0 if impossible
188  long (*cfInt)(number &n, const coeffs r);
189 
190  /// Converts a non-negative number n into a GMP number, 0 if impossible
191  void (*cfMPZ)(mpz_t result, number &n, const coeffs r);
192 
193  /// changes argument inline: a:= -a
194  /// return -a! (no copy is returned)
195  /// the result should be assigned to the original argument: e.g. a = n_InpNeg(a,r)
196  number (*cfInpNeg)(number a, const coeffs r);
197  /// return 1/a
198  number (*cfInvers)(number a, const coeffs r);
199  /// return a copy of a
200  number (*cfCopy)(number a, const coeffs r);
201  number (*cfRePart)(number a, const coeffs r);
202  number (*cfImPart)(number a, const coeffs r);
203 
204  /// print a given number (long format)
205  void (*cfWriteLong)(number a, const coeffs r);
206 
207  /// print a given number in a shorter way, if possible
208  /// e.g. in K(a): a2 instead of a^2
209  void (*cfWriteShort)(number a, const coeffs r);
210 
211  // it is legal, but not always useful to have cfRead(s, a, r)
212  // just return s again.
213  // Useful application (read constants which are not an projection
214  // from int/bigint:
215  // Let ring r = R,x,dp;
216  // where R is a coeffs having "special" "named" elements (ie.
217  // the primitive element in some algebraic extension).
218  // If there is no interpreter variable of the same name, it is
219  // difficult to create non-trivial elements in R.
220  // Hence one can use the string to allow creation of R-elts using the
221  // unbound name of the special element.
222  const char * (*cfRead)(const char * s, number * a, const coeffs r);
223 
224  void (*cfNormalize)(number &a, const coeffs r);
225 
226  BOOLEAN (*cfGreater)(number a,number b, const coeffs r),
227  /// tests
228  (*cfEqual)(number a,number b, const coeffs r),
229  (*cfIsZero)(number a, const coeffs r),
230  (*cfIsOne)(number a, const coeffs r),
231  // IsMOne is used for printing os polynomials:
232  // -1 is only printed for constant monomials
233  (*cfIsMOne)(number a, const coeffs r),
234  //GreaterZero is used for printing of polynomials:
235  // a "+" is only printed in front of a coefficient
236  // if the element is >0. It is assumed that any element
237  // failing this will start printing with a leading "-"
238  (*cfGreaterZero)(number a, const coeffs r);
239 
240  void (*cfPower)(number a, int i, number * result, const coeffs r);
241  number (*cfGetDenom)(number &n, const coeffs r);
242  number (*cfGetNumerator)(number &n, const coeffs r);
243  //CF: a Euclidean ring is a commutative, unitary ring with an Euclidean
244  // function f s.th. for all a,b in R, b ne 0, we can find q, r s.th.
245  // a = qb+r and either r=0 or f(r) < f(b)
246  // Note that neither q nor r nor f(r) are unique.
247  number (*cfGcd)(number a, number b, const coeffs r);
248  number (*cfSubringGcd)(number a, number b, const coeffs r);
249  number (*cfExtGcd)(number a, number b, number *s, number *t,const coeffs r);
250  //given a and b in a Euclidean setting, return s,t,u,v sth.
251  // sa + tb = gcd
252  // ua + vb = 0
253  // sv + tu = 1
254  // ie. the 2x2 matrix (s t | u v) is unimodular and maps (a,b) to (g, 0)
255  //CF: note, in general, this cannot be derived from ExtGcd due to
256  // zero divisors
257  number (*cfXExtGcd)(number a, number b, number *s, number *t, number *u, number *v, const coeffs r);
258  //in a Euclidean ring, return the Euclidean norm as a bigint (of type number)
259  number (*cfEucNorm)(number a, const coeffs r);
260  //in a principal ideal ring (with zero divisors): the annihilator
261  // NULL otherwise
262  number (*cfAnn)(number a, const coeffs r);
263  //find a "canonical representative of a modulo the units of r
264  //return NULL if a is already normalized
265  //otherwise, the factor.
266  //(for Z: make positive, for z/nZ make the gcd with n
267  //aparently it is GetUnit!
268  //in a Euclidean ring, return the quotient and compute the remainder
269  //rem can be NULL
270  number (*cfQuotRem)(number a, number b, number *rem, const coeffs r);
271  number (*cfLcm)(number a, number b, const coeffs r);
272  number (*cfNormalizeHelper)(number a, number b, const coeffs r);
273  void (*cfDelete)(number * a, const coeffs r);
274 
275  //CF: tries to find a canonical map from src -> dst
276  nMapFunc (*cfSetMap)(const coeffs src, const coeffs dst);
277 
278  void (*cfWriteFd)(number a, FILE *f, const coeffs r);
279  number (*cfReadFd)( s_buff f, const coeffs r);
280 
281  /// Inplace: a *= b
282  void (*cfInpMult)(number &a, number b, const coeffs r);
283 
284  /// Inplace: a += b
285  void (*cfInpAdd)(number &a, number b, const coeffs r);
286 
287  /// rational reconstruction: "best" rational a/b with a/b = p mod n
288  // or a = bp mod n
289  // CF: no idea what this would be in general
290  // it seems to be extended to operate coefficient wise in extensions.
291  // I presume then n in coeffs_BIGINT while p in coeffs
292  number (*cfFarey)(number p, number n, const coeffs);
293 
294  /// chinese remainder
295  /// returns X with X mod q[i]=x[i], i=0..rl-1
296  //CF: by the looks of it: q[i] in Z (coeffs_BIGINT)
297  // strange things happen in naChineseRemainder for example.
298  number (*cfChineseRemainder)(number *x, number *q,int rl, BOOLEAN sym,CFArray &inv_cache,const coeffs);
299 
300  /// degree for coeffcients: -1 for 0, 0 for "constants", ...
301  int (*cfParDeg)(number x,const coeffs r);
302 
303  /// create i^th parameter or NULL if not possible
304  number (*cfParameter)(const int i, const coeffs r);
305 
306  /// a function returning random elements
307  number (*cfRandom)(siRandProc p, number p1, number p2, const coeffs cf);
308 
309  /// function pointer behind n_ClearContent
311 
312  /// function pointer behind n_ClearDenominators
314 
315  /// conversion to CanonicalForm(factory) to number
316  number (*convFactoryNSingN)( const CanonicalForm n, const coeffs r);
317  CanonicalForm (*convSingNFactoryN)( number n, BOOLEAN setChar, const coeffs r );
318 
319  /// Number of Parameters in the coeffs (default 0)
321 
322  /// array containing the names of Parameters (default NULL)
323  char const ** pParameterNames;
324  // NOTE that it replaces the following:
325 // char* complex_parameter; //< the name of sqrt(-1) in n_long_C , i.e. 'i' or 'j' etc...?
326 // char * m_nfParameter; //< the name of parameter in n_GF
327 
328  /////////////////////////////////////////////
329  // the union stuff
330 
331  //-------------------------------------------
332 
333  /* for extension fields we need to be able to represent polynomials,
334  so here is the polynomial ring: */
335  ring extRing;
336 
337  //number minpoly; //< no longer needed: replaced by
338  // //< extRing->qideal->[0]
339 
340 
341  int ch; /* characteristic, set by the local *InitChar methods;
342  In field extensions or extensions towers, the
343  characteristic can be accessed from any of the
344  intermediate extension fields, i.e., in this case
345  it is redundant along the chain of field extensions;
346  CONTRARY to SINGULAR as it was, we do NO LONGER use
347  negative values for ch;
348  for rings, ch will also be set and is - per def -
349  the smallest number of 1's that sum up to zero;
350  however, in this case ch may not fit in an int,
351  thus ch may contain a faulty value */
352 
353  short float_len; /* additional char-flags, rInit */
354  short float_len2; /* additional char-flags, rInit */
355 
356 // BOOLEAN CanShortOut; //< if the elements can be printed in short format
357 // // this is set to FALSE if a parameter name has >2 chars
358 // BOOLEAN ShortOut; //< if the elements should print in short format
359 
360 // ---------------------------------------------------
361  // for n_GF
362 
363  int m_nfCharQ; ///< the number of elements: q
364  int m_nfM1; ///< representation of -1
365  int m_nfCharP; ///< the characteristic: p
366  int m_nfCharQ1; ///< q-1
367  unsigned short *m_nfPlus1Table;
368  int *m_nfMinPoly;
369 
370 // ---------------------------------------------------
371 // for Zp:
372  unsigned short *npInvTable;
373  unsigned short *npExpTable;
374  unsigned short *npLogTable;
375  // int npPrimeM; // NOTE: npPrimeM is deprecated, please use ch instead!
376  int npPminus1M; ///< characteristic - 1
377 //-------------------------------------------
378  int (*cfDivComp)(number a,number b,const coeffs r);
379  BOOLEAN (*cfIsUnit)(number a,const coeffs r);
380  number (*cfGetUnit)(number a,const coeffs r);
381  //CF: test if b divides a
382  BOOLEAN (*cfDivBy)(number a, number b, const coeffs r);
383  /* The following members are for representing the ring Z/n,
384  where n is not a prime. We distinguish four cases:
385  1.) n has at least two distinct prime factors. Then
386  modBase stores n, modExponent stores 1, modNumber
387  stores n, and mod2mMask is not used;
388  2.) n = p^k for some odd prime p and k > 1. Then
389  modBase stores p, modExponent stores k, modNumber
390  stores n, and mod2mMask is not used;
391  3.) n = 2^k for some k > 1; moreover, 2^k - 1 fits in
392  an unsigned long. Then modBase stores 2, modExponent
393  stores k, modNumber is not used, and mod2mMask stores
394  2^k - 1, i.e., the bit mask '111..1' of length k.
395  4.) n = 2^k for some k > 1; but 2^k - 1 does not fit in
396  an unsigned long. Then modBase stores 2, modExponent
397  stores k, modNumber stores n, and mod2mMask is not
398  used;
399  Cases 1.), 2.), and 4.) are covered by the implementation
400  in the files rmodulon.h and rmodulon.cc, whereas case 3.)
401  is implemented in the files rmodulo2m.h and rmodulo2m.cc. */
402  mpz_ptr modBase;
403  unsigned long modExponent;
404  mpz_ptr modNumber;
405  unsigned long mod2mMask;
406  //returns coeffs with updated ch, modNumber and modExp
407  coeffs (*cfQuot1)(number c, const coeffs r);
408 
409  /*CF: for blackbox rings, contains data needed to define the ring.
410  * contents depends on the actual example.*/
411  void * data;
412 #ifdef LDEBUG
413  // must be last entry:
414  /// Test: is "a" a correct number?
415  // DB as in debug, not data base.
416  BOOLEAN (*cfDBTest)(number a, const char *f, const int l, const coeffs r);
417 #endif
418 };
419 
420 // test properties and type
421 /// Returns the type of coeffs domain
423 { assume(r != NULL); return r->type; }
424 
425 /// one-time initialisations for new coeffs
426 /// in case of an error return NULL
427 coeffs nInitChar(n_coeffType t, void * parameter);
428 
429 /// "copy" coeffs, i.e. increment ref
430 static FORCE_INLINE coeffs nCopyCoeff(const coeffs r)
431 { assume(r!=NULL); r->ref++; return r;}
432 
433 /// undo all initialisations
434 void nKillChar(coeffs r);
435 
436 /// initialisations after each ring change
437 static FORCE_INLINE void nSetChar(const coeffs r)
438 { STATISTIC(nSetChar); assume(r!=NULL); assume(r->cfSetChar != NULL); r->cfSetChar(r); }
439 
440 void nNew(number * a);
441 #define n_New(n, r) nNew(n)
442 
443 
444 /// Return the characteristic of the coeff. domain.
445 static FORCE_INLINE int n_GetChar(const coeffs r)
446 { STATISTIC(n_GetChar); assume(r != NULL); return r->ch; }
447 
448 
449 // the access methods (part 2):
450 
451 /// return a copy of 'n'
452 static FORCE_INLINE number n_Copy(number n, const coeffs r)
453 { STATISTIC(n_Copy); assume(r != NULL); assume(r->cfCopy!=NULL); return r->cfCopy(n, r); }
454 
455 /// delete 'p'
456 static FORCE_INLINE void n_Delete(number* p, const coeffs r)
457 { STATISTIC(n_Delete); assume(r != NULL); assume(r->cfDelete!= NULL); r->cfDelete(p, r); }
458 
459 /// TRUE iff 'a' and 'b' represent the same number;
460 /// they may have different representations
461 static FORCE_INLINE BOOLEAN n_Equal(number a, number b, const coeffs r)
462 { STATISTIC(n_Equal); assume(r != NULL); assume(r->cfEqual!=NULL); return r->cfEqual(a, b, r); }
463 
464 /// TRUE iff 'n' represents the zero element
465 static FORCE_INLINE BOOLEAN n_IsZero(number n, const coeffs r)
466 { STATISTIC(n_IsZero); assume(r != NULL); assume(r->cfIsZero!=NULL); return r->cfIsZero(n,r); }
467 
468 /// TRUE iff 'n' represents the one element
469 static FORCE_INLINE BOOLEAN n_IsOne(number n, const coeffs r)
470 { STATISTIC(n_IsOne); assume(r != NULL); assume(r->cfIsOne!=NULL); return r->cfIsOne(n,r); }
471 
472 /// TRUE iff 'n' represents the additive inverse of the one element, i.e. -1
473 static FORCE_INLINE BOOLEAN n_IsMOne(number n, const coeffs r)
474 { STATISTIC(n_IsMOne); assume(r != NULL); assume(r->cfIsMOne!=NULL); return r->cfIsMOne(n,r); }
475 
476 /// ordered fields: TRUE iff 'n' is positive;
477 /// in Z/pZ: TRUE iff 0 < m <= roundedBelow(p/2), where m is the long
478 /// representing n
479 /// in C: TRUE iff (Im(n) != 0 and Im(n) >= 0) or
480 /// (Im(n) == 0 and Re(n) >= 0)
481 /// in K(a)/<p(a)>: TRUE iff (n != 0 and (LC(n) > 0 or deg(n) > 0))
482 /// in K(t_1, ..., t_n): TRUE iff (LC(numerator(n) is a constant and > 0)
483 /// or (LC(numerator(n) is not a constant)
484 /// in Z/2^kZ: TRUE iff 0 < n <= 2^(k-1)
485 /// in Z/mZ: TRUE iff the internal mpz is greater than zero
486 /// in Z: TRUE iff n > 0
487 ///
488 /// !!! Recommendation: remove implementations for unordered fields
489 /// !!! and raise errors instead, in these cases
490 /// !!! Do not follow this recommendation: while writing polys,
491 /// !!! between 2 monomials will be an additional + iff !n_GreaterZero(next coeff)
492 /// Then change definition to include n_GreaterZero => printing does NOT
493 /// start with -
494 ///
495 static FORCE_INLINE BOOLEAN n_GreaterZero(number n, const coeffs r)
496 { STATISTIC(n_GreaterZero); assume(r != NULL); assume(r->cfGreaterZero!=NULL); return r->cfGreaterZero(n,r); }
497 
498 /// ordered fields: TRUE iff 'a' is larger than 'b';
499 /// in Z/pZ: TRUE iff la > lb, where la and lb are the long's representing
500 // a and b, respectively
501 /// in C: TRUE iff (Im(a) > Im(b))
502 /// in K(a)/<p(a)>: TRUE iff (a != 0 and (b == 0 or deg(a) > deg(b))
503 /// in K(t_1, ..., t_n): TRUE only if one or both numerator polynomials are
504 /// zero or if their degrees are equal. In this case,
505 /// TRUE if LC(numerator(a)) > LC(numerator(b))
506 /// in Z/2^kZ: TRUE if n_DivBy(a, b)
507 /// in Z/mZ: TRUE iff the internal mpz's fulfill the relation '>'
508 /// in Z: TRUE iff a > b
509 ///
510 /// !!! Recommendation: remove implementations for unordered fields
511 /// !!! and raise errors instead, in these cases
512 static FORCE_INLINE BOOLEAN n_Greater(number a, number b, const coeffs r)
513 { STATISTIC(n_Greater); assume(r != NULL); assume(r->cfGreater!=NULL); return r->cfGreater(a,b,r); }
514 
515 /// TRUE iff n has a multiplicative inverse in the given coeff field/ring r
516 static FORCE_INLINE BOOLEAN n_IsUnit(number n, const coeffs r)
517 { STATISTIC(n_IsUnit); assume(r != NULL); assume(r->cfIsUnit!=NULL); return r->cfIsUnit(n,r); }
518 
519 static FORCE_INLINE coeffs n_CoeffRingQuot1(number c, const coeffs r)
520 { STATISTIC(n_CoeffRingQuot1); assume(r != NULL); assume(r->cfQuot1 != NULL); return r->cfQuot1(c, r); }
521 
522 #ifdef HAVE_RINGS
523 static FORCE_INLINE int n_DivComp(number a, number b, const coeffs r)
524 { STATISTIC(n_DivComp); assume(r != NULL); assume(r->cfDivComp!=NULL); return r->cfDivComp (a,b,r); }
525 
526 /// in Z: 1
527 /// in Z/kZ (where k is not a prime): largest divisor of n (taken in Z) that
528 /// is co-prime with k
529 /// in Z/2^kZ: largest odd divisor of n (taken in Z)
530 /// other cases: not implemented
531 // CF: shold imply that n/GetUnit(n) is normalized in Z/kZ
532 // it would make more sense to return the inverse...
533 static FORCE_INLINE number n_GetUnit(number n, const coeffs r)
534 { STATISTIC(n_GetUnit); assume(r != NULL); assume(r->cfGetUnit!=NULL); return r->cfGetUnit(n,r); }
535 
536 #endif
537 
538 /// a number representing i in the given coeff field/ring r
539 static FORCE_INLINE number n_Init(long i, const coeffs r)
540 { STATISTIC(n_Init); assume(r != NULL); assume(r->cfInit!=NULL); return r->cfInit(i,r); }
541 
542 /// conversion of a GMP integer to number
543 static FORCE_INLINE number n_InitMPZ(mpz_t n, const coeffs r)
544 { STATISTIC(n_InitMPZ); assume(r != NULL); assume(r->cfInitMPZ != NULL); return r->cfInitMPZ(n,r); }
545 
546 /// conversion of n to an int; 0 if not possible
547 /// in Z/pZ: the representing int lying in (-p/2 .. p/2]
548 static FORCE_INLINE long n_Int(number &n, const coeffs r)
549 { STATISTIC(n_Int); assume(r != NULL); assume(r->cfInt!=NULL); return r->cfInt(n,r); }
550 
551 /// conversion of n to a GMP integer; 0 if not possible
552 static FORCE_INLINE void n_MPZ(mpz_t result, number &n, const coeffs r)
553 { STATISTIC(n_MPZ); assume(r != NULL); assume(r->cfMPZ!=NULL); r->cfMPZ(result, n, r); }
554 
555 
556 /// in-place negation of n
557 /// MUST BE USED: n = n_InpNeg(n) (no copy is returned)
558 static FORCE_INLINE number n_InpNeg(number n, const coeffs r)
559 { STATISTIC(n_InpNeg); assume(r != NULL); assume(r->cfInpNeg!=NULL); return r->cfInpNeg(n,r); }
560 
561 /// return the multiplicative inverse of 'a';
562 /// raise an error if 'a' is not invertible
563 ///
564 /// !!! Recommendation: rename to 'n_Inverse'
565 static FORCE_INLINE number n_Invers(number a, const coeffs r)
566 { STATISTIC(n_Invers); assume(r != NULL); assume(r->cfInvers!=NULL); return r->cfInvers(a,r); }
567 
568 /// return a non-negative measure for the complexity of n;
569 /// return 0 only when n represents zero;
570 /// (used for pivot strategies in matrix computations with entries from r)
571 static FORCE_INLINE int n_Size(number n, const coeffs r)
572 { STATISTIC(n_Size); assume(r != NULL); assume(r->cfSize!=NULL); return r->cfSize(n,r); }
573 
574 /// inplace-normalization of n;
575 /// produces some canonical representation of n;
576 ///
577 /// !!! Recommendation: remove this method from the user-interface, i.e.,
578 /// !!! this should be hidden
579 static FORCE_INLINE void n_Normalize(number& n, const coeffs r)
580 { STATISTIC(n_Normalize); assume(r != NULL); assume(r->cfNormalize!=NULL); r->cfNormalize(n,r); }
581 
582 /// write to the output buffer of the currently used reporter
583 //CF: the "&" should be removed, as one wants to write constants as well
584 static FORCE_INLINE void n_WriteLong(number n, const coeffs r)
585 { STATISTIC(n_WriteLong); assume(r != NULL); assume(r->cfWriteLong!=NULL); r->cfWriteLong(n,r); }
586 
587 /// write to the output buffer of the currently used reporter
588 /// in a shortest possible way, e.g. in K(a): a2 instead of a^2
589 static FORCE_INLINE void n_WriteShort(number n, const coeffs r)
590 { STATISTIC(n_WriteShort); assume(r != NULL); assume(r->cfWriteShort!=NULL); r->cfWriteShort(n,r); }
591 
592 static FORCE_INLINE void n_Write(number n, const coeffs r, const BOOLEAN bShortOut = TRUE)
593 { STATISTIC(n_Write); if (bShortOut) n_WriteShort(n, r); else n_WriteLong(n, r); }
594 
595 
596 /// !!! Recommendation: This method is too cryptic to be part of the user-
597 /// !!! interface. As defined here, it is merely a helper
598 /// !!! method for parsing number input strings.
599 static FORCE_INLINE const char *n_Read(const char * s, number * a, const coeffs r)
600 { STATISTIC(n_Read); assume(r != NULL); assume(r->cfRead!=NULL); return r->cfRead(s, a, r); }
601 
602 /// return the denominator of n
603 /// (if elements of r are by nature not fractional, result is 1)
604 static FORCE_INLINE number n_GetDenom(number& n, const coeffs r)
605 { STATISTIC(n_GetDenom); assume(r != NULL); assume(r->cfGetDenom!=NULL); return r->cfGetDenom(n, r); }
606 
607 /// return the numerator of n
608 /// (if elements of r are by nature not fractional, result is n)
609 static FORCE_INLINE number n_GetNumerator(number& n, const coeffs r)
610 { STATISTIC(n_GetNumerator); assume(r != NULL); assume(r->cfGetNumerator!=NULL); return r->cfGetNumerator(n, r); }
611 
612 /// return the quotient of 'a' and 'b', i.e., a/b;
613 /// raises an error if 'b' is not invertible in r
614 /// exception in Z: raises an error if 'a' is not divisible by 'b'
615 /// always: n_Div(a,b,r)*b+n_IntMod(a,b,r)==a
616 static FORCE_INLINE number n_Div(number a, number b, const coeffs r)
617 { STATISTIC(n_Div); assume(r != NULL); assume(r->cfDiv!=NULL); return r->cfDiv(a,b,r); }
618 
619 /// assume that there is a canonical subring in cf and we know
620 /// that division is possible for these a and b in the subring,
621 /// n_ExactDiv performs it, may skip additional tests.
622 /// Can always be substituted by n_Div at the cost of larger computing time.
623 static FORCE_INLINE number n_ExactDiv(number a, number b, const coeffs r)
624 { STATISTIC(n_ExactDiv); assume(r != NULL); assume(r->cfExactDiv!=NULL); return r->cfExactDiv(a,b,r); }
625 
626 /// for r a field, return n_Init(0,r)
627 /// always: n_Div(a,b,r)*b+n_IntMod(a,b,r)==a
628 /// n_IntMod(a,b,r) >=0
629 static FORCE_INLINE number n_IntMod(number a, number b, const coeffs r)
630 { STATISTIC(n_IntMod); assume(r != NULL); return r->cfIntMod(a,b,r); }
631 
632 /// fill res with the power a^b
633 static FORCE_INLINE void n_Power(number a, int b, number *res, const coeffs r)
634 { STATISTIC(n_Power); assume(r != NULL); assume(r->cfPower!=NULL); r->cfPower(a,b,res,r); }
635 
636 /// return the product of 'a' and 'b', i.e., a*b
637 static FORCE_INLINE number n_Mult(number a, number b, const coeffs r)
638 { STATISTIC(n_Mult); assume(r != NULL); assume(r->cfMult!=NULL); return r->cfMult(a, b, r); }
639 
640 /// multiplication of 'a' and 'b';
641 /// replacement of 'a' by the product a*b
642 static FORCE_INLINE void n_InpMult(number &a, number b, const coeffs r)
643 { STATISTIC(n_InpMult); assume(r != NULL); assume(r->cfInpMult!=NULL); r->cfInpMult(a,b,r); }
644 
645 /// addition of 'a' and 'b';
646 /// replacement of 'a' by the sum a+b
647 static FORCE_INLINE void n_InpAdd(number &a, number b, const coeffs r)
648 { STATISTIC(n_InpAdd); assume(r != NULL); assume(r->cfInpAdd!=NULL); r->cfInpAdd(a,b,r);
649 
650 #ifdef HAVE_NUMSTATS
651  // avoid double counting
652  if( r->cfIsZero(a,r) ) STATISTIC(n_CancelOut);
653 #endif
654 }
655 
656 /// return the sum of 'a' and 'b', i.e., a+b
657 static FORCE_INLINE number n_Add(number a, number b, const coeffs r)
658 { STATISTIC(n_Add); assume(r != NULL); assume(r->cfAdd!=NULL); const number sum = r->cfAdd(a, b, r);
659 
660 #ifdef HAVE_NUMSTATS
661  // avoid double counting
662  if( r->cfIsZero(sum,r) ) STATISTIC(n_CancelOut);
663 #endif
664 
665  return sum;
666 }
667 
668 
669 /// return the difference of 'a' and 'b', i.e., a-b
670 static FORCE_INLINE number n_Sub(number a, number b, const coeffs r)
671 { STATISTIC(n_Sub); assume(r != NULL); assume(r->cfSub!=NULL); const number d = r->cfSub(a, b, r);
672 
673 #ifdef HAVE_NUMSTATS
674  // avoid double counting
675  if( r->cfIsZero(d,r) ) STATISTIC(n_CancelOut);
676 #endif
677 
678  return d;
679 }
680 
681 /// in Z: return the gcd of 'a' and 'b'
682 /// in Z/nZ, Z/2^kZ: computed as in the case Z
683 /// in Z/pZ, C, R: not implemented
684 /// in Q: return the gcd of the numerators of 'a' and 'b'
685 /// in K(a)/<p(a)>: not implemented
686 /// in K(t_1, ..., t_n): not implemented
687 static FORCE_INLINE number n_Gcd(number a, number b, const coeffs r)
688 { STATISTIC(n_Gcd); assume(r != NULL); assume(r->cfGcd!=NULL); return r->cfGcd(a,b,r); }
689 static FORCE_INLINE number n_SubringGcd(number a, number b, const coeffs r)
690 { STATISTIC(n_SubringGcd); assume(r != NULL); assume(r->cfSubringGcd!=NULL); return r->cfSubringGcd(a,b,r); }
691 
692 /// beware that ExtGCD is only relevant for a few chosen coeff. domains
693 /// and may perform something unexpected in some cases...
694 static FORCE_INLINE number n_ExtGcd(number a, number b, number *s, number *t, const coeffs r)
695 { STATISTIC(n_ExtGcd); assume(r != NULL); assume(r->cfExtGcd!=NULL); return r->cfExtGcd (a,b,s,t,r); }
696 static FORCE_INLINE number n_XExtGcd(number a, number b, number *s, number *t, number *u, number *v, const coeffs r)
697 { STATISTIC(n_XExtGcd); assume(r != NULL); assume(r->cfXExtGcd!=NULL); return r->cfXExtGcd (a,b,s,t,u,v,r); }
698 static FORCE_INLINE number n_EucNorm(number a, const coeffs r)
699 { STATISTIC(n_EucNorm); assume(r != NULL); assume(r->cfEucNorm!=NULL); return r->cfEucNorm (a,r); }
700 /// if r is a ring with zero divisors, return an annihilator!=0 of b
701 /// otherwise return NULL
702 static FORCE_INLINE number n_Ann(number a, const coeffs r)
703 { STATISTIC(n_Ann); assume(r != NULL); return r->cfAnn (a,r); }
704 static FORCE_INLINE number n_QuotRem(number a, number b, number *q, const coeffs r)
705 { STATISTIC(n_QuotRem); assume(r != NULL); assume(r->cfQuotRem!=NULL); return r->cfQuotRem (a,b,q,r); }
706 
707 
708 /// in Z: return the lcm of 'a' and 'b'
709 /// in Z/nZ, Z/2^kZ: computed as in the case Z
710 /// in Z/pZ, C, R: not implemented
711 /// in K(a)/<p(a)>: not implemented
712 /// in K(t_1, ..., t_n): not implemented
713 static FORCE_INLINE number n_Lcm(number a, number b, const coeffs r)
714 { STATISTIC(n_Lcm); assume(r != NULL); assume(r->cfLcm!=NULL); return r->cfLcm(a,b,r); }
715 
716 /// assume that r is a quotient field (otherwise, return 1)
717 /// for arguments (a1/a2,b1/b2) return (lcm(a1,b2)/1)
718 static FORCE_INLINE number n_NormalizeHelper(number a, number b, const coeffs r)
719 { STATISTIC(n_NormalizeHelper); assume(r != NULL); assume(r->cfNormalizeHelper!=NULL); return r->cfNormalizeHelper(a,b,r); }
720 
721 /// set the mapping function pointers for translating numbers from src to dst
722 static FORCE_INLINE nMapFunc n_SetMap(const coeffs src, const coeffs dst)
723 { STATISTIC(n_SetMap); assume(src != NULL && dst != NULL); assume(dst->cfSetMap!=NULL); return dst->cfSetMap(src,dst); }
724 
725 #ifdef LDEBUG
726 /// test whether n is a correct number;
727 /// only used if LDEBUG is defined
728 static FORCE_INLINE BOOLEAN n_DBTest(number n, const char *filename, const int linenumber, const coeffs r)
729 { STATISTIC(n_Test); assume(r != NULL); assume(r->cfDBTest != NULL); return r->cfDBTest(n, filename, linenumber, r); }
730 #else
731 // is it really necessary to define this function in any case?
732 /// test whether n is a correct number;
733 /// only used if LDEBUG is defined
734 static FORCE_INLINE BOOLEAN n_DBTest(number, const char*, const int, const coeffs)
735 { STATISTIC(n_Test); return TRUE; }
736 #endif
737 
738 /// BOOLEAN n_Test(number a, const coeffs r)
739 #define n_Test(a,r) n_DBTest(a, __FILE__, __LINE__, r)
740 
741 /// output the coeff description
742 static FORCE_INLINE void n_CoeffWrite(const coeffs r, BOOLEAN details = TRUE)
743 { STATISTIC(n_CoeffWrite); assume(r != NULL); assume(r->cfCoeffWrite != NULL); r->cfCoeffWrite(r, details); }
744 
745 // Tests:
746 #ifdef HAVE_RINGS
748 { assume(r != NULL); return (getCoeffType(r)==n_Z2m); }
749 
751 { assume(r != NULL); return (getCoeffType(r)==n_Zn); }
752 
754 { assume(r != NULL); return (getCoeffType(r)==n_Znm); }
755 
757 { assume(r != NULL); return (getCoeffType(r)==n_Z); }
758 
760 { assume(r != NULL); return (r->is_field==0); }
761 #else
762 #define nCoeff_is_Ring_2toM(A) 0
763 #define nCoeff_is_Ring_ModN(A) 0
764 #define nCoeff_is_Ring_PtoM(A) 0
765 #define nCoeff_is_Ring_Z(A) 0
766 #define nCoeff_is_Ring(A) 0
767 #endif
768 
769 /// returns TRUE, if r is a field or r has no zero divisors (i.e is a domain)
771 {
772  assume(r != NULL);
773  return (r->is_domain);
774 }
775 
776 /// test whether 'a' is divisible 'b';
777 /// for r encoding a field: TRUE iff 'b' does not represent zero
778 /// in Z: TRUE iff 'b' divides 'a' (with remainder = zero)
779 /// in Z/nZ: TRUE iff (a = 0 and b divides n in Z) or
780 /// (a != 0 and b/gcd(a, b) is co-prime with n, i.e.
781 /// a unit in Z/nZ)
782 /// in Z/2^kZ: TRUE iff ((a = 0 mod 2^k) and (b = 0 or b is a power of 2))
783 /// or ((a, b <> 0) and (b/gcd(a, b) is odd))
784 static FORCE_INLINE BOOLEAN n_DivBy(number a, number b, const coeffs r)
785 { STATISTIC(n_DivBy); assume(r != NULL);
786 #ifdef HAVE_RINGS
787  if( nCoeff_is_Ring(r) )
788  {
789  assume(r->cfDivBy!=NULL); return r->cfDivBy(a,b,r);
790  }
791 #endif
792  return !n_IsZero(b, r);
793 }
794 
795 static FORCE_INLINE number n_ChineseRemainderSym(number *a, number *b, int rl, BOOLEAN sym,CFArray &inv_cache,const coeffs r)
796 { STATISTIC(n_ChineseRemainderSym); assume(r != NULL); assume(r->cfChineseRemainder != NULL); return r->cfChineseRemainder(a,b,rl,sym,inv_cache,r); }
797 
798 static FORCE_INLINE number n_Farey(number a, number b, const coeffs r)
799 { STATISTIC(n_Farey); assume(r != NULL); assume(r->cfFarey != NULL); return r->cfFarey(a,b,r); }
800 
801 static FORCE_INLINE int n_ParDeg(number n, const coeffs r)
802 { STATISTIC(n_ParDeg); assume(r != NULL); assume(r->cfParDeg != NULL); return r->cfParDeg(n,r); }
803 
804 /// Returns the number of parameters
805 static FORCE_INLINE int n_NumberOfParameters(const coeffs r)
806 { STATISTIC(n_NumberOfParameters); assume(r != NULL); return r->iNumberOfParameters; }
807 
808 /// Returns a (const!) pointer to (const char*) names of parameters
809 static FORCE_INLINE char const * * n_ParameterNames(const coeffs r)
810 { STATISTIC(n_ParameterNames); assume(r != NULL); return r->pParameterNames; }
811 
812 /// return the (iParameter^th) parameter as a NEW number
813 /// NOTE: parameter numbering: 1..n_NumberOfParameters(...)
814 static FORCE_INLINE number n_Param(const int iParameter, const coeffs r)
815 { assume(r != NULL);
816  assume((iParameter >= 1) || (iParameter <= n_NumberOfParameters(r)));
817  assume(r->cfParameter != NULL);
818  STATISTIC(n_Param); return r->cfParameter(iParameter, r);
819 }
820 
821 static FORCE_INLINE number n_RePart(number i, const coeffs cf)
822 { STATISTIC(n_RePart); assume(cf != NULL); assume(cf->cfRePart!=NULL); return cf->cfRePart(i,cf); }
823 
824 static FORCE_INLINE number n_ImPart(number i, const coeffs cf)
825 { STATISTIC(n_ImPart); assume(cf != NULL); assume(cf->cfImPart!=NULL); return cf->cfImPart(i,cf); }
826 
827 /// returns TRUE, if r is not a field and r has non-trivial units
829 { assume(r != NULL); return ((getCoeffType(r)==n_Zn) || (getCoeffType(r)==n_Z2m) || (getCoeffType(r)==n_Znm)); }
830 
831 static FORCE_INLINE BOOLEAN nCoeff_is_Zp(const coeffs r)
832 { assume(r != NULL); return getCoeffType(r)==n_Zp; }
833 
834 static FORCE_INLINE BOOLEAN nCoeff_is_Zp(const coeffs r, int p)
835 { assume(r != NULL); return ((getCoeffType(r)==n_Zp) && (r->ch == p)); }
836 
837 static FORCE_INLINE BOOLEAN nCoeff_is_Q(const coeffs r)
838 { assume(r != NULL); return getCoeffType(r)==n_Q && (r->is_field); }
839 
840 static FORCE_INLINE BOOLEAN nCoeff_is_Z(const coeffs r)
841 { assume(r != NULL); return getCoeffType(r)==n_Z || ((getCoeffType(r)==n_Q) && (!r->is_field)); }
842 
844 { assume(r != NULL); return getCoeffType(r)==n_Q; }
845 
846 static FORCE_INLINE BOOLEAN nCoeff_is_numeric(const coeffs r) /* R, long R, long C */
847 { assume(r != NULL); return (getCoeffType(r)==n_R) || (getCoeffType(r)==n_long_R) || (getCoeffType(r)==n_long_C); }
848 // (r->ringtype == 0) && (r->ch == -1); ??
849 
850 static FORCE_INLINE BOOLEAN nCoeff_is_R(const coeffs r)
851 { assume(r != NULL); return getCoeffType(r)==n_R; }
852 
853 static FORCE_INLINE BOOLEAN nCoeff_is_GF(const coeffs r)
854 { assume(r != NULL); return getCoeffType(r)==n_GF; }
855 
856 static FORCE_INLINE BOOLEAN nCoeff_is_GF(const coeffs r, int q)
857 { assume(r != NULL); return (getCoeffType(r)==n_GF) && (r->ch == q); }
858 
859 /* TRUE iff r represents an algebraic or transcendental extension field */
861 {
862  assume(r != NULL);
863  return (getCoeffType(r)==n_algExt) || (getCoeffType(r)==n_transExt);
864 }
865 
866 /* DO NOT USE (only kept for compatibility reasons towards the SINGULAR
867  svn trunk);
868  intension: should be TRUE iff the given r is an extension field above
869  some Z/pZ;
870  actually: TRUE iff the given r is an extension tower of arbitrary
871  height above some field of characteristic p (may be Z/pZ or some
872  Galois field of characteristic p) */
874 {
875  assume(r != NULL);
876  return ((!nCoeff_is_Ring(r)) && (n_GetChar(r) != 0) && nCoeff_is_Extension(r));
877 }
878 
879 /* DO NOT USE (only kept for compatibility reasons towards the SINGULAR
880  svn trunk);
881  intension: should be TRUE iff the given r is an extension field above
882  Z/pZ (with p as provided);
883  actually: TRUE iff the given r is an extension tower of arbitrary
884  height above some field of characteristic p (may be Z/pZ or some
885  Galois field of characteristic p) */
886 static FORCE_INLINE BOOLEAN nCoeff_is_Zp_a(const coeffs r, int p)
887 {
888  assume(r != NULL);
889  assume(p != 0);
890  return ((!nCoeff_is_Ring(r)) && (n_GetChar(r) == p) && nCoeff_is_Extension(r));
891 }
892 
893 /* DO NOT USE (only kept for compatibility reasons towards the SINGULAR
894  svn trunk);
895  intension: should be TRUE iff the given r is an extension field
896  above Q;
897  actually: TRUE iff the given r is an extension tower of arbitrary
898  height above some field of characteristic 0 (may be Q, R, or C) */
900 {
901  assume(r != NULL);
902  return ((n_GetChar(r) == 0) && nCoeff_is_Extension(r));
903 }
904 
906 { assume(r != NULL); return getCoeffType(r)==n_long_R; }
907 
909 { assume(r != NULL); return getCoeffType(r)==n_long_C; }
910 
911 static FORCE_INLINE BOOLEAN nCoeff_is_CF(const coeffs r)
912 { assume(r != NULL); return getCoeffType(r)==n_CF; }
913 
914 /// TRUE, if the computation of the inverse is fast,
915 /// i.e. prefer leading coeff. 1 over content
917 { assume(r != NULL); return r->has_simple_Inverse; }
918 
919 /// TRUE if n_Delete/n_New are empty operations
921 { assume(r != NULL); return r->has_simple_Alloc; }
922 
923 /// TRUE iff r represents an algebraic extension field
925 { assume(r != NULL); return (getCoeffType(r)==n_algExt); }
926 
927 /// is it an alg. ext. of Q?
929 { assume(r != NULL); return ((n_GetChar(r) == 0) && nCoeff_is_algExt(r)); }
930 
931 /// TRUE iff r represents a transcendental extension field
933 { assume(r != NULL); return (getCoeffType(r)==n_transExt); }
934 
935 /// Computes the content and (inplace) divides it out on a collection
936 /// of numbers
937 /// number @em c is the content (i.e. the GCD of all the coeffs, which
938 /// we divide out inplace)
939 /// NOTE: it assumes all coefficient numbers to be integer!!!
940 /// NOTE/TODO: see also the description by Hans
941 /// TODO: rename into n_ClearIntegerContent
942 static FORCE_INLINE void n_ClearContent(ICoeffsEnumerator& numberCollectionEnumerator, number& c, const coeffs r)
943 { STATISTIC(n_ClearContent); assume(r != NULL); r->cfClearContent(numberCollectionEnumerator, c, r); }
944 
945 /// (inplace) Clears denominators on a collection of numbers
946 /// number @em d is the LCM of all the coefficient denominators (i.e. the number
947 /// with which all the number coeffs. were multiplied)
948 /// NOTE/TODO: see also the description by Hans
949 static FORCE_INLINE void n_ClearDenominators(ICoeffsEnumerator& numberCollectionEnumerator, number& d, const coeffs r)
950 { STATISTIC(n_ClearDenominators); assume(r != NULL); r->cfClearDenominators(numberCollectionEnumerator, d, r); }
951 
952 // convenience helpers (no number returned - but the input enumeration
953 // is to be changed
954 // TODO: do we need separate hooks for these as our existing code does
955 // *different things* there: compare p_Cleardenom (which calls
956 // *p_Content) and p_Cleardenom_n (which doesn't)!!!
957 
958 static FORCE_INLINE void n_ClearContent(ICoeffsEnumerator& numberCollectionEnumerator, const coeffs r)
959 { STATISTIC(n_ClearContent); number c; n_ClearContent(numberCollectionEnumerator, c, r); n_Delete(&c, r); }
960 
961 static FORCE_INLINE void n_ClearDenominators(ICoeffsEnumerator& numberCollectionEnumerator, const coeffs r)
962 { STATISTIC(n_ClearDenominators); assume(r != NULL); number d; n_ClearDenominators(numberCollectionEnumerator, d, r); n_Delete(&d, r); }
963 
964 
965 /// print a number (BEWARE of string buffers!)
966 /// mostly for debugging
967 void n_Print(number& a, const coeffs r);
968 
969 
970 
971 /// TODO: make it a virtual method of coeffs, together with:
972 /// Decompose & Compose, rParameter & rPar
973 static FORCE_INLINE char * nCoeffString(const coeffs cf)
974 { STATISTIC(nCoeffString); assume( cf != NULL ); return cf->cfCoeffString(cf); }
975 
976 
977 static FORCE_INLINE char * nCoeffName (const coeffs cf)
978 { STATISTIC(nCoeffName); assume( cf != NULL ); return cf->cfCoeffName(cf); }
979 
980 static FORCE_INLINE number n_Random(siRandProc p, number p1, number p2, const coeffs cf)
981 { STATISTIC(n_Random); assume( cf != NULL ); assume( cf->cfRandom != NULL ); return cf->cfRandom(p, p1, p2, cf); }
982 
983 /// io via ssi:
984 static FORCE_INLINE void n_WriteFd(number a, FILE *f, const coeffs r)
985 { STATISTIC(n_WriteFd); assume(r != NULL); assume(r->cfWriteFd != NULL); return r->cfWriteFd(a, f, r); }
986 
987 /// io via ssi:
988 static FORCE_INLINE number n_ReadFd( s_buff f, const coeffs r)
989 { STATISTIC(n_ReadFd); assume(r != NULL); assume(r->cfReadFd != NULL); return r->cfReadFd(f, r); }
990 
991 
992 // the following wrappers went to numbers.cc since they needed factory
993 // knowledge!
994 number n_convFactoryNSingN( const CanonicalForm n, const coeffs r);
995 
996 CanonicalForm n_convSingNFactoryN( number n, BOOLEAN setChar, const coeffs r );
997 
998 
999 // TODO: remove the following functions...
1000 // the following 2 inline functions are just convenience shortcuts for Frank's code:
1001 static FORCE_INLINE void number2mpz(number n, coeffs c, mpz_t m){ n_MPZ(m, n, c); }
1002 static FORCE_INLINE number mpz2number(mpz_t m, coeffs c){ return n_InitMPZ(m, c); }
1003 
1004 #endif
1005 
getCoeffType
static FORCE_INLINE n_coeffType getCoeffType(const coeffs r)
Returns the type of coeffs domain.
Definition: coeffs.h:421
n_IntMod
static FORCE_INLINE number n_IntMod(number a, number b, const coeffs r)
for r a field, return n_Init(0,r) always: n_Div(a,b,r)*b+n_IntMod(a,b,r)==a n_IntMod(a,...
Definition: coeffs.h:628
n_rep_gap_rat
(number), see longrat.h
Definition: coeffs.h:111
n_WriteLong
static FORCE_INLINE void n_WriteLong(number n, const coeffs r)
write to the output buffer of the currently used reporter
Definition: coeffs.h:583
n_Procs_s::cfInpMult
void(* cfInpMult)(number &a, number b, const coeffs r)
Inplace: a *= b.
Definition: coeffs.h:281
n_Procs_s::next
coeffs next
Definition: coeffs.h:125
n_Procs_s::convSingNFactoryN
CanonicalForm(* convSingNFactoryN)(number n, BOOLEAN setChar, const coeffs r)
Definition: coeffs.h:316
n_Procs_s::cfSize
int(* cfSize)(number n, const coeffs r)
how complicated, (0) => 0, or positive
Definition: coeffs.h:184
n_rep_gmp
(mpz_ptr), see rmodulon,h
Definition: coeffs.h:115
n_rep_unknown
Definition: coeffs.h:109
omalloc.h
n_Zn
only used if HAVE_RINGS is defined
Definition: coeffs.h:44
n_Procs_s::cfGcd
number(* cfGcd)(number a, number b, const coeffs r)
Definition: coeffs.h:246
n_Procs_s::cfDivComp
int(* cfDivComp)(number a, number b, const coeffs r)
Definition: coeffs.h:377
n_Random
static FORCE_INLINE number n_Random(siRandProc p, number p1, number p2, const coeffs cf)
Definition: coeffs.h:979
nCoeff_is_numeric
static FORCE_INLINE BOOLEAN nCoeff_is_numeric(const coeffs r)
Definition: coeffs.h:845
n_Procs_s::is_field
BOOLEAN is_field
TRUE, if cf is a field.
Definition: coeffs.h:140
n_Procs_s::cfInpNeg
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:195
n_Procs_s::m_nfPlus1Table
unsigned short * m_nfPlus1Table
Definition: coeffs.h:366
nCoeff_is_Zp
static FORCE_INLINE BOOLEAN nCoeff_is_Zp(const coeffs r)
Definition: coeffs.h:830
n_XExtGcd
static FORCE_INLINE number n_XExtGcd(number a, number b, number *s, number *t, number *u, number *v, const coeffs r)
Definition: coeffs.h:695
nSetChar
static FORCE_INLINE void nSetChar(const coeffs r)
initialisations after each ring change
Definition: coeffs.h:436
n_ParDeg
static FORCE_INLINE int n_ParDeg(number n, const coeffs r)
Definition: coeffs.h:800
n_Procs_s::cfGetDenom
number(* cfGetDenom)(number &n, const coeffs r)
Definition: coeffs.h:240
n_Procs_s::cfWriteFd
void(* cfWriteFd)(number a, FILE *f, const coeffs r)
Definition: coeffs.h:277
f
FILE * f
Definition: checklibs.c:9
n_Procs_s::iNumberOfParameters
int iNumberOfParameters
Number of Parameters in the coeffs (default 0)
Definition: coeffs.h:319
nCoeff_is_R
static FORCE_INLINE BOOLEAN nCoeff_is_R(const coeffs r)
Definition: coeffs.h:849
rnumber_bin
omBin rnumber_bin
Definition: longrat0.cc:19
n_Procs_s::modBase
mpz_ptr modBase
Definition: coeffs.h:401
n_ExactDiv
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
nCoeff_is_Z
static FORCE_INLINE BOOLEAN nCoeff_is_Z(const coeffs r)
Definition: coeffs.h:839
LongComplexInfo
Definition: coeffs.h:99
nCoeff_is_Ring_2toM
static FORCE_INLINE BOOLEAN nCoeff_is_Ring_2toM(const coeffs r)
Definition: coeffs.h:746
n_Procs_s::cfParDeg
int(* cfParDeg)(number x, const coeffs r)
degree for coeffcients: -1 for 0, 0 for "constants", ...
Definition: coeffs.h:300
x
Variable x
Definition: cfModGcd.cc:4023
n_Procs_s::modExponent
unsigned long modExponent
Definition: coeffs.h:402
s_buff.h
n_Procs_s::cfWriteShort
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:208
result
return result
Definition: facAbsBiFact.cc:76
n_InpMult
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
Definition: coeffs.h:641
n_GetChar
static FORCE_INLINE int n_GetChar(const coeffs r)
Return the characteristic of the coeff. domain.
Definition: coeffs.h:444
GFInfo
Creation data needed for finite fields.
Definition: coeffs.h:92
n_long_C
complex floating point (GMP) numbers
Definition: coeffs.h:41
n_GetNumerator
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:608
nCoeffString
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:972
n_Z2m
only used if HAVE_RINGS is defined
Definition: coeffs.h:46
n_Procs_s::cfCoeffWrite
void(* cfCoeffWrite)(const coeffs r, BOOLEAN details)
output of coeff description via Print
Definition: coeffs.h:148
n_Procs_s::cfIntMod
numberfunc cfIntMod
Definition: coeffs.h:175
mpz2number
static FORCE_INLINE number mpz2number(mpz_t m, coeffs c)
Definition: coeffs.h:1001
n_Procs_s::mod2mMask
unsigned long mod2mMask
Definition: coeffs.h:404
cf
CanonicalForm cf
Definition: cfModGcd.cc:4024
n_Procs_s::cfRePart
number(* cfRePart)(number a, const coeffs r)
Definition: coeffs.h:200
n_Procs_s::cfDBTest
BOOLEAN(* cfDBTest)(number a, const char *f, const int l, const coeffs r)
Test: is "a" a correct number?
Definition: coeffs.h:415
ICoeffsEnumerator
IEnumerator< number > ICoeffsEnumerator
Abstract interface for an enumerator of number coefficients for an object, e.g. a polynomial.
Definition: coeffs.h:78
n_rep_float
(float), see shortfl.h
Definition: coeffs.h:116
n_Procs_s::has_simple_Alloc
BOOLEAN has_simple_Alloc
TRUE, if nNew/nDelete/nCopy are dummies.
Definition: coeffs.h:134
nCoeff_is_Q_or_BI
static FORCE_INLINE BOOLEAN nCoeff_is_Q_or_BI(const coeffs r)
Definition: coeffs.h:842
n_Delete
static FORCE_INLINE void n_Delete(number *p, const coeffs r)
delete 'p'
Definition: coeffs.h:455
n_nTupel
n-tupel of cf: ZZ/p1,...
Definition: coeffs.h:42
n_GF
\GF{p^n < 2^16}
Definition: coeffs.h:32
nInitChar
coeffs nInitChar(n_coeffType t, void *parameter)
one-time initialisations for new coeffs in case of an error return NULL
Definition: numbers.cc:349
n_Procs_s::npExpTable
unsigned short * npExpTable
Definition: coeffs.h:372
n_Q
rational (GMP) numbers
Definition: coeffs.h:30
auxiliary.h
n_Znm
only used if HAVE_RINGS is defined
Definition: coeffs.h:45
n_Read
static const FORCE_INLINE char * n_Read(const char *s, number *a, const coeffs r)
!!! Recommendation: This method is too cryptic to be part of the user- !!! interface....
Definition: coeffs.h:598
numberfunc
number(* numberfunc)(number a, number b, const coeffs r)
Definition: coeffs.h:70
n_IsZero
static FORCE_INLINE BOOLEAN n_IsZero(number n, const coeffs r)
TRUE iff 'n' represents the zero element.
Definition: coeffs.h:464
nCoeff_is_GF
static FORCE_INLINE BOOLEAN nCoeff_is_GF(const coeffs r)
Definition: coeffs.h:852
n_NumberOfParameters
static FORCE_INLINE int n_NumberOfParameters(const coeffs r)
Returns the number of parameters.
Definition: coeffs.h:804
reporter.h
n_Param
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....
Definition: coeffs.h:813
n_Greater
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 l...
Definition: coeffs.h:511
n_IsOne
static FORCE_INLINE BOOLEAN n_IsOne(number n, const coeffs r)
TRUE iff 'n' represents the one element.
Definition: coeffs.h:468
n_rep_int
(int), see modulop.h
Definition: coeffs.h:110
n_Procs_s::m_nfCharQ
int m_nfCharQ
the number of elements: q
Definition: coeffs.h:362
n_GetUnit
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:532
n_Procs_s::type
n_coeffType type
Definition: coeffs.h:128
n_Procs_s::cfGreater
BOOLEAN(* cfGreater)(number a, number b, const coeffs r)
Definition: coeffs.h:225
nCoeff_is_long_C
static FORCE_INLINE BOOLEAN nCoeff_is_long_C(const coeffs r)
Definition: coeffs.h:907
b
CanonicalForm b
Definition: cfModGcd.cc:4044
n_InitMPZ
static FORCE_INLINE number n_InitMPZ(mpz_t n, const coeffs r)
conversion of a GMP integer to number
Definition: coeffs.h:542
n_Normalize
static FORCE_INLINE void n_Normalize(number &n, const coeffs r)
inplace-normalization of n; produces some canonical representation of n;
Definition: coeffs.h:578
fftable
const unsigned short fftable[]
Definition: ffields.cc:31
n_QuotRem
static FORCE_INLINE number n_QuotRem(number a, number b, number *q, const coeffs r)
Definition: coeffs.h:703
CanonicalForm
factory's main class
Definition: canonicalform.h:77
n_NormalizeHelper
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:717
n_long_R
real floating point (GMP) numbers
Definition: coeffs.h:33
n_Procs_s::cfInit
number(* cfInit)(long i, const coeffs r)
init with an integer
Definition: coeffs.h:178
numstats.h
n_Procs_s::cfDelete
void(* cfDelete)(number *a, const coeffs r)
Definition: coeffs.h:272
n_coeffType
n_coeffType
Definition: coeffs.h:26
nCoeff_is_Q
static FORCE_INLINE BOOLEAN nCoeff_is_Q(const coeffs r)
Definition: coeffs.h:836
n_rep_rat_fct
(fraction), see transext.h
Definition: coeffs.h:114
n_Procs_s::cfDiv
numberfunc cfDiv
Definition: coeffs.h:175
n_CoeffWrite
static FORCE_INLINE void n_CoeffWrite(const coeffs r, BOOLEAN details=TRUE)
output the coeff description
Definition: coeffs.h:741
n_Procs_s::cfPower
void(* cfPower)(number a, int i, number *result, const coeffs r)
Definition: coeffs.h:239
n_Add
static FORCE_INLINE number n_Add(number a, number b, const coeffs r)
return the sum of 'a' and 'b', i.e., a+b
Definition: coeffs.h:656
n_InpAdd
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
Definition: coeffs.h:646
n_polyExt
used to represent polys as coeffcients
Definition: coeffs.h:34
n_Procs_s::cfAdd
numberfunc cfAdd
Definition: coeffs.h:175
TRUE
#define TRUE
Definition: auxiliary.h:98
i
int i
Definition: cfEzgcd.cc:125
Array< CanonicalForm >
n_Procs_s::rep
n_coeffRep rep
Definition: coeffs.h:127
n_coeffRep
n_coeffRep
Definition: coeffs.h:107
nCoeff_is_Ring_ModN
static FORCE_INLINE BOOLEAN nCoeff_is_Ring_ModN(const coeffs r)
Definition: coeffs.h:749
res
CanonicalForm res
Definition: facAbsFact.cc:64
n_Ann
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:701
nMapFunc
number(* nMapFunc)(number a, const coeffs src, const coeffs dst)
maps "a", which lives in src, into dst
Definition: coeffs.h:73
n_Procs_s::cfInt
long(* cfInt)(number &n, const coeffs r)
convertion to long, 0 if impossible
Definition: coeffs.h:187
n_Procs_s::ref
int ref
Definition: coeffs.h:126
n_CF
?
Definition: coeffs.h:47
n_Write
static FORCE_INLINE void n_Write(number n, const coeffs r, const BOOLEAN bShortOut=TRUE)
Definition: coeffs.h:591
n_Procs_s::cfGetUnit
number(* cfGetUnit)(number a, const coeffs r)
Definition: coeffs.h:379
n_Procs_s::cfMPZ
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:190
n_convFactoryNSingN
number n_convFactoryNSingN(const CanonicalForm n, const coeffs r)
Definition: numbers.cc:592
n_Procs_s::is_domain
BOOLEAN is_domain
TRUE, if cf is a domain.
Definition: coeffs.h:142
BOOLEAN
int BOOLEAN
Definition: auxiliary.h:85
n_Procs_s::cfExactDiv
numberfunc cfExactDiv
Definition: coeffs.h:175
nCoeff_is_algExt
static FORCE_INLINE BOOLEAN nCoeff_is_algExt(const coeffs r)
TRUE iff r represents an algebraic extension field.
Definition: coeffs.h:923
n_Procs_s::cfGetNumerator
number(* cfGetNumerator)(number &n, const coeffs r)
Definition: coeffs.h:241
n_Procs_s::cfIsZero
BOOLEAN(*)(*)(*) cfIsZero(number a, const coeffs r)
Definition: coeffs.h:228
n_RePart
static FORCE_INLINE number n_RePart(number i, const coeffs cf)
Definition: coeffs.h:820
n_Procs_s::cfQuot1
coeffs(* cfQuot1)(number c, const coeffs r)
Definition: coeffs.h:406
n_Procs_s::m_nfCharP
int m_nfCharP
the characteristic: p
Definition: coeffs.h:364
n_Procs_s::cfClearDenominators
nCoeffsEnumeratorFunc cfClearDenominators
function pointer behind n_ClearDenominators
Definition: coeffs.h:312
nCoeff_is_Ring
static FORCE_INLINE BOOLEAN nCoeff_is_Ring(const coeffs r)
Definition: coeffs.h:758
n_Procs_s::float_len2
short float_len2
Definition: coeffs.h:353
si_gmp.h
n_Procs_s::cfInpAdd
void(* cfInpAdd)(number &a, number b, const coeffs r)
Inplace: a += b.
Definition: coeffs.h:284
nCoeff_is_Q_a
static FORCE_INLINE BOOLEAN nCoeff_is_Q_a(const coeffs r)
Definition: coeffs.h:898
n_Procs_s::cfInvers
number(* cfInvers)(number a, const coeffs r)
return 1/a
Definition: coeffs.h:197
n_Procs_s::cfInitMPZ
number(* cfInitMPZ)(mpz_t i, const coeffs r)
init with a GMP integer
Definition: coeffs.h:181
n_Procs_s::cfWriteLong
void(* cfWriteLong)(number a, const coeffs r)
print a given number (long format)
Definition: coeffs.h:204
n_Procs_s::float_len
short float_len
Definition: coeffs.h:352
n_Procs_s::cfXExtGcd
number(* cfXExtGcd)(number a, number b, number *s, number *t, number *u, number *v, const coeffs r)
Definition: coeffs.h:256
nCoeff_has_simple_Alloc
static FORCE_INLINE BOOLEAN nCoeff_has_simple_Alloc(const coeffs r)
TRUE if n_Delete/n_New are empty operations.
Definition: coeffs.h:919
n_Procs_s::cfGreaterZero
BOOLEAN(*)(*)(*)(*)(*)(*) cfGreaterZero(number a, const coeffs r)
Definition: coeffs.h:237
coeffs
ip_sring
Definition: ring.h:253
n_Procs_s::cfSubringGcd
number(* cfSubringGcd)(number a, number b, const coeffs r)
Definition: coeffs.h:247
nCoeff_is_long_R
static FORCE_INLINE BOOLEAN nCoeff_is_long_R(const coeffs r)
Definition: coeffs.h:904
n_Z
only used if HAVE_RINGS is defined
Definition: coeffs.h:43
n_Procs_s::cfSub
numberfunc cfSub
Definition: coeffs.h:175
n_Procs_s::m_nfCharQ1
int m_nfCharQ1
q-1
Definition: coeffs.h:365
n_Procs_s::cfSetMap
nMapFunc(* cfSetMap)(const coeffs src, const coeffs dst)
Definition: coeffs.h:275
n_Mult
static FORCE_INLINE number n_Mult(number a, number b, const coeffs r)
return the product of 'a' and 'b', i.e., a*b
Definition: coeffs.h:636
n_Procs_s::cfMult
numberfunc cfMult
Definition: coeffs.h:175
n_Procs_s::npInvTable
unsigned short * npInvTable
Definition: coeffs.h:371
n_Procs_s::cfCopy
number(* cfCopy)(number a, const coeffs r)
return a copy of a
Definition: coeffs.h:199
n_Procs_s::cfImPart
number(* cfImPart)(number a, const coeffs r)
Definition: coeffs.h:201
nCoeff_is_Ring_PtoM
static FORCE_INLINE BOOLEAN nCoeff_is_Ring_PtoM(const coeffs r)
Definition: coeffs.h:752
n_Init
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:538
n_Procs_s::extRing
ring extRing
Definition: coeffs.h:334
n_Procs_s::cfRandom
number(* cfRandom)(siRandProc p, number p1, number p2, const coeffs cf)
a function returning random elements
Definition: coeffs.h:306
nCoeff_is_CF
static FORCE_INLINE BOOLEAN nCoeff_is_CF(const coeffs r)
Definition: coeffs.h:910
n_Procs_s::pParameterNames
const char ** pParameterNames
array containing the names of Parameters (default NULL)
Definition: coeffs.h:322
nCoeff_is_Extension
static FORCE_INLINE BOOLEAN nCoeff_is_Extension(const coeffs r)
Definition: coeffs.h:859
n_InpNeg
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:557
nCoeff_is_transExt
static FORCE_INLINE BOOLEAN nCoeff_is_transExt(const coeffs r)
TRUE iff r represents a transcendental extension field.
Definition: coeffs.h:931
n_rep_poly
(poly), see algext.h
Definition: coeffs.h:113
n_convSingNFactoryN
CanonicalForm n_convSingNFactoryN(number n, BOOLEAN setChar, const coeffs r)
Definition: numbers.cc:597
IEnumerator
Definition: Enumerator.h:124
n_transExt
used for all transcendental extensions, i.e., the top-most extension in an extension tower is transce...
Definition: coeffs.h:38
number2mpz
static FORCE_INLINE void number2mpz(number n, coeffs c, mpz_t m)
Definition: coeffs.h:1000
snumber
'SR_INT' is the type of those integers small enough to fit into 29 bits.
Definition: longrat.h:48
n_Print
void n_Print(number &a, const coeffs r)
print a number (BEWARE of string buffers!) mostly for debugging
Definition: numbers.cc:581
n_Procs_s::cfQuotRem
number(* cfQuotRem)(number a, number b, number *rem, const coeffs r)
Definition: coeffs.h:269
n_Procs_s::cfSetChar
void(* cfSetChar)(const coeffs r)
Definition: coeffs.h:161
n_Farey
static FORCE_INLINE number n_Farey(number a, number b, const coeffs r)
Definition: coeffs.h:797
nCoeff_has_Units
static FORCE_INLINE BOOLEAN nCoeff_has_Units(const coeffs r)
returns TRUE, if r is not a field and r has non-trivial units
Definition: coeffs.h:827
n_R
single prescision (6,6) real numbers
Definition: coeffs.h:31
n_ParameterNames
static FORCE_INLINE const char ** n_ParameterNames(const coeffs r)
Returns a (const!) pointer to (const char*) names of parameters.
Definition: coeffs.h:808
n_Procs_s::m_nfMinPoly
int * m_nfMinPoly
Definition: coeffs.h:367
n_Sub
static FORCE_INLINE number n_Sub(number a, number b, const coeffs r)
return the difference of 'a' and 'b', i.e., a-b
Definition: coeffs.h:669
n_WriteShort
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,...
Definition: coeffs.h:588
STATISTIC
#define STATISTIC(f)
Definition: numstats.h:16
n_Procs_s::cfClearContent
nCoeffsEnumeratorFunc cfClearContent
function pointer behind n_ClearContent
Definition: coeffs.h:309
n_DivComp
static FORCE_INLINE int n_DivComp(number a, number b, const coeffs r)
Definition: coeffs.h:522
n_Procs_s::cfEqual
BOOLEAN(*)(*) cfEqual(number a, number b, const coeffs r)
tests
Definition: coeffs.h:227
n_Lcm
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,...
Definition: coeffs.h:712
nCoeffsEnumeratorFunc
void(* nCoeffsEnumeratorFunc)(ICoeffsEnumerator &numberCollectionEnumerator, number &output, const coeffs r)
goes over coeffs given by the ICoeffsEnumerator and changes them. Additionally returns a number;
Definition: coeffs.h:82
omBin
omBin_t * omBin
Definition: omStructs.h:11
n_ImPart
static FORCE_INLINE number n_ImPart(number i, const coeffs cf)
Definition: coeffs.h:823
n_Procs_s::npPminus1M
int npPminus1M
characteristic - 1
Definition: coeffs.h:375
n_EucNorm
static FORCE_INLINE number n_EucNorm(number a, const coeffs r)
Definition: coeffs.h:697
n_Procs_s::cfNormalizeHelper
number(* cfNormalizeHelper)(number a, number b, const coeffs r)
Definition: coeffs.h:271
const
#define const
Definition: fegetopt.c:40
n_ClearContent
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:941
n_Invers
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
Definition: coeffs.h:564
nCopyCoeff
static FORCE_INLINE coeffs nCopyCoeff(const coeffs r)
"copy" coeffs, i.e. increment ref
Definition: coeffs.h:429
n_Zp
\F{p < 2^31}
Definition: coeffs.h:29
n_WriteFd
static FORCE_INLINE void n_WriteFd(number a, FILE *f, const coeffs r)
io via ssi:
Definition: coeffs.h:983
n_ClearDenominators
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:948
n_rep_gmp_float
(gmp_float), see
Definition: coeffs.h:117
nNew
void nNew(number *a)
Definition: numbers.cc:50
n_Procs_s::cfIsOne
BOOLEAN(*)(*)(*)(*) cfIsOne(number a, const coeffs r)
Definition: coeffs.h:229
n_Procs_s::cfAnn
number(* cfAnn)(number a, const coeffs r)
Definition: coeffs.h:261
n_Procs_s::data
void * data
Definition: coeffs.h:410
n_Procs_s::ch
int ch
Definition: coeffs.h:340
n_IsMOne
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.
Definition: coeffs.h:472
n_Procs_s::cfNormalize
void(* cfNormalize)(number &a, const coeffs r)
Definition: coeffs.h:223
n_GreaterZero
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),...
Definition: coeffs.h:494
n_Procs_s::cfExtGcd
number(* cfExtGcd)(number a, number b, number *s, number *t, const coeffs r)
Definition: coeffs.h:248
n_Copy
static FORCE_INLINE number n_Copy(number n, const coeffs r)
return a copy of 'n'
Definition: coeffs.h:451
n_Gcd
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,...
Definition: coeffs.h:686
n_Procs_s::cfIsUnit
BOOLEAN(* cfIsUnit)(number a, const coeffs r)
Definition: coeffs.h:378
m
int m
Definition: cfEzgcd.cc:121
n_Procs_s::factoryVarOffset
int factoryVarOffset
how many variables of factory are already used by this coeff
Definition: coeffs.h:130
n_rep_gf
(int), see ffields.h
Definition: coeffs.h:119
n_DivBy
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:...
Definition: coeffs.h:783
n_ChineseRemainderSym
static FORCE_INLINE number n_ChineseRemainderSym(number *a, number *b, int rl, BOOLEAN sym, CFArray &inv_cache, const coeffs r)
Definition: coeffs.h:794
assume
#define assume(x)
Definition: mod2.h:384
sirandom.h
NULL
#define NULL
Definition: omList.c:9
n_Procs_s::cfParameter
number(* cfParameter)(const int i, const coeffs r)
create i^th parameter or NULL if not possible
Definition: coeffs.h:303
nCoeffName
static FORCE_INLINE char * nCoeffName(const coeffs cf)
Definition: coeffs.h:976
l
int l
Definition: cfEzgcd.cc:93
n_Procs_s::cfFarey
number(* cfFarey)(number p, number n, const coeffs)
rational reconstruction: "best" rational a/b with a/b = p mod n
Definition: coeffs.h:291
n_SubringGcd
static FORCE_INLINE number n_SubringGcd(number a, number b, const coeffs r)
Definition: coeffs.h:688
n_Procs_s::has_simple_Inverse
BOOLEAN has_simple_Inverse
TRUE, if std should make polynomials monic (if nInvers is cheap) if false, then a gcd routine is used...
Definition: coeffs.h:137
n_Int
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:547
nCoeff_is_Q_algext
static FORCE_INLINE BOOLEAN nCoeff_is_Q_algext(const coeffs r)
is it an alg. ext. of Q?
Definition: coeffs.h:927
n_Procs_s::cfEucNorm
number(* cfEucNorm)(number a, const coeffs r)
Definition: coeffs.h:258
n_Power
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:632
n_Procs_s::cfReadFd
number(* cfReadFd)(s_buff f, const coeffs r)
Definition: coeffs.h:278
v
const Variable & v
< [in] a sqrfree bivariate poly
Definition: facBivar.h:37
n_Procs_s::m_nfM1
int m_nfM1
representation of -1
Definition: coeffs.h:363
n_Equal
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.
Definition: coeffs.h:460
p
int p
Definition: cfModGcd.cc:4019
n_Procs_s::cfLcm
number(* cfLcm)(number a, number b, const coeffs r)
Definition: coeffs.h:270
n_Procs_s::cfKillChar
void(* cfKillChar)(coeffs r)
Definition: coeffs.h:159
n_Procs_s::convFactoryNSingN
number(* convFactoryNSingN)(const CanonicalForm n, const coeffs r)
conversion to CanonicalForm(factory) to number
Definition: coeffs.h:315
s
const CanonicalForm int s
Definition: facAbsFact.cc:55
n_Procs_s::npLogTable
unsigned short * npLogTable
Definition: coeffs.h:373
n_Div
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 exceptio...
Definition: coeffs.h:615
n_SetMap
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:721
n_Size
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:570
siRandProc
int(* siRandProc)()
Definition: sirandom.h:9
n_Procs_s::cfDivBy
BOOLEAN(* cfDivBy)(number a, number b, const coeffs r)
Definition: coeffs.h:381
n_Test
#define n_Test(a, r)
BOOLEAN n_Test(number a, const coeffs r)
Definition: coeffs.h:738
n_Procs_s::cfChineseRemainder
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:297
Enumerator.h
n_unknown
Definition: coeffs.h:28
n_Procs_s::modNumber
mpz_ptr modNumber
Definition: coeffs.h:403
n_Procs_s::nCoeffIsEqual
BOOLEAN(* nCoeffIsEqual)(const coeffs r, n_coeffType n, void *parameter)
Definition: coeffs.h:145
FORCE_INLINE
#define FORCE_INLINE
Definition: auxiliary.h:342
n_MPZ
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:551
n_GetDenom
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:603
nCoeff_is_Ring_Z
static FORCE_INLINE BOOLEAN nCoeff_is_Ring_Z(const coeffs r)
Definition: coeffs.h:755
n_ExtGcd
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:693
n_IsUnit
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:515
n_CoeffRingQuot1
static FORCE_INLINE coeffs n_CoeffRingQuot1(number c, const coeffs r)
Definition: coeffs.h:518
n_ReadFd
static FORCE_INLINE number n_ReadFd(s_buff f, const coeffs r)
io via ssi:
Definition: coeffs.h:987
n_rep_gmp_complex
(gmp_complex), see gnumpc.h
Definition: coeffs.h:118
n_Procs_s
Definition: coeffs.h:122
rem
void rem(unsigned long *a, unsigned long *q, unsigned long p, int &dega, int degq)
Definition: minpoly.cc:572
n_Procs_s::cfIsMOne
BOOLEAN(*)(*)(*)(*)(*) cfIsMOne(number a, const coeffs r)
Definition: coeffs.h:232
nCoeff_is_Zp_a
static FORCE_INLINE BOOLEAN nCoeff_is_Zp_a(const coeffs r)
Definition: coeffs.h:872
nKillChar
void nKillChar(coeffs r)
undo all initialisations
Definition: numbers.cc:510
nCoeff_has_simple_inverse
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.
Definition: coeffs.h:915
n_DBTest
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
Definition: coeffs.h:727
n_algExt
used for all algebraic extensions, i.e., the top-most extension in an extension tower is algebraic
Definition: coeffs.h:35
nCoeff_is_Domain
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)
Definition: coeffs.h:769
n_rep_gap_gmp
(), see rinteger.h, new impl.
Definition: coeffs.h:112