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