My Project
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 
24 class CanonicalForm;
25 
27 {
29  n_Zp, /**< \F{p < 2^31} */
30  n_Q, /**< rational (GMP) numbers */
31  n_R, /**< single prescision (6,6) real numbers */
32  n_GF, /**< \GF{p^n < 2^16} */
33  n_long_R, /**< real floating point (GMP) numbers */
34  n_polyExt, /**< used to represent polys as coeffcients */
35  n_algExt, /**< used for all algebraic extensions, i.e.,
36  the top-most extension in an extension tower
37  is algebraic */
38  n_transExt, /**< used for all transcendental extensions, i.e.,
39  the top-most extension in an extension tower
40  is transcendental */
41  n_long_C, /**< complex floating point (GMP) numbers */
42  n_nTupel, /**< n-tupel of cf: ZZ/p1,... ZZ/pn, R, long_R */
43  n_Z, /**< only used if HAVE_RINGS is defined */
44  n_Zn, /**< only used if HAVE_RINGS is defined */
45  n_Znm, /**< only used if HAVE_RINGS is defined */
46  n_Z2m, /**< only used if HAVE_RINGS is defined */
47  n_FlintQrat, /**< rational funtion field over Q */
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 
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 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 (integer) 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 of 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  /// test if b divides a
381  /// cfDivBy(zero,b,r) is true, if b is a zero divisor
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
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 { assume(r!=NULL); assume(r->cfSetChar != NULL); r->cfSetChar(r); }
439 
440 /// Return the characteristic of the coeff. domain.
441 static FORCE_INLINE int n_GetChar(const coeffs r)
442 { assume(r != NULL); return r->ch; }
443 
444 
445 // the access methods (part 2):
446 
447 /// return a copy of 'n'
448 static FORCE_INLINE number n_Copy(number n, const coeffs r)
449 { assume(r != NULL); assume(r->cfCopy!=NULL); return r->cfCopy(n, r); }
450 
451 /// delete 'p'
452 static FORCE_INLINE void n_Delete(number* p, const coeffs r)
453 { assume(r != NULL); assume(r->cfDelete!= NULL); r->cfDelete(p, r); }
454 
455 /// TRUE iff 'a' and 'b' represent the same number;
456 /// they may have different representations
457 static FORCE_INLINE BOOLEAN n_Equal(number a, number b, const coeffs r)
458 { assume(r != NULL); assume(r->cfEqual!=NULL); return r->cfEqual(a, b, r); }
459 
460 /// TRUE iff 'n' represents the zero element
461 static FORCE_INLINE BOOLEAN n_IsZero(number n, const coeffs r)
462 { assume(r != NULL); assume(r->cfIsZero!=NULL); return r->cfIsZero(n,r); }
463 
464 /// TRUE iff 'n' represents the one element
465 static FORCE_INLINE BOOLEAN n_IsOne(number n, const coeffs r)
466 { assume(r != NULL); assume(r->cfIsOne!=NULL); return r->cfIsOne(n,r); }
467 
468 /// TRUE iff 'n' represents the additive inverse of the one element, i.e. -1
469 static FORCE_INLINE BOOLEAN n_IsMOne(number n, const coeffs r)
470 { assume(r != NULL); assume(r->cfIsMOne!=NULL); return r->cfIsMOne(n,r); }
471 
472 /// ordered fields: TRUE iff 'n' is positive;
473 /// in Z/pZ: TRUE iff 0 < m <= roundedBelow(p/2), where m is the long
474 /// representing n
475 /// in C: TRUE iff (Im(n) != 0 and Im(n) >= 0) or
476 /// (Im(n) == 0 and Re(n) >= 0)
477 /// in K(a)/<p(a)>: TRUE iff (n != 0 and (LC(n) > 0 or deg(n) > 0))
478 /// in K(t_1, ..., t_n): TRUE iff (LC(numerator(n) is a constant and > 0)
479 /// or (LC(numerator(n) is not a constant)
480 /// in Z/2^kZ: TRUE iff 0 < n <= 2^(k-1)
481 /// in Z/mZ: TRUE iff the internal mpz is greater than zero
482 /// in Z: TRUE iff n > 0
483 ///
484 /// !!! Recommendation: remove implementations for unordered fields
485 /// !!! and raise errors instead, in these cases
486 /// !!! Do not follow this recommendation: while writing polys,
487 /// !!! between 2 monomials will be an additional + iff !n_GreaterZero(next coeff)
488 /// Then change definition to include n_GreaterZero => printing does NOT
489 /// start with -
490 ///
491 static FORCE_INLINE BOOLEAN n_GreaterZero(number n, const coeffs r)
492 { assume(r != NULL); assume(r->cfGreaterZero!=NULL); return r->cfGreaterZero(n,r); }
493 
494 /// ordered fields: TRUE iff 'a' is larger than 'b';
495 /// in Z/pZ: TRUE iff la > lb, where la and lb are the long's representing
496 // a and b, respectively
497 /// in C: TRUE iff (Im(a) > Im(b))
498 /// in K(a)/<p(a)>: TRUE iff (a != 0 and (b == 0 or deg(a) > deg(b))
499 /// in K(t_1, ..., t_n): TRUE only if one or both numerator polynomials are
500 /// zero or if their degrees are equal. In this case,
501 /// TRUE if LC(numerator(a)) > LC(numerator(b))
502 /// in Z/2^kZ: TRUE if n_DivBy(a, b)
503 /// in Z/mZ: TRUE iff the internal mpz's fulfill the relation '>'
504 /// in Z: TRUE iff a > b
505 ///
506 /// !!! Recommendation: remove implementations for unordered fields
507 /// !!! and raise errors instead, in these cases
508 static FORCE_INLINE BOOLEAN n_Greater(number a, number b, const coeffs r)
509 { assume(r != NULL); assume(r->cfGreater!=NULL); return r->cfGreater(a,b,r); }
510 
511 /// TRUE iff n has a multiplicative inverse in the given coeff field/ring r
512 static FORCE_INLINE BOOLEAN n_IsUnit(number n, const coeffs r)
513 { assume(r != NULL); assume(r->cfIsUnit!=NULL); return r->cfIsUnit(n,r); }
514 
515 static FORCE_INLINE coeffs n_CoeffRingQuot1(number c, const coeffs r)
516 { assume(r != NULL); assume(r->cfQuot1 != NULL); return r->cfQuot1(c, r); }
517 
518 #ifdef HAVE_RINGS
519 static FORCE_INLINE int n_DivComp(number a, number b, const coeffs r)
520 { assume(r != NULL); assume(r->cfDivComp!=NULL); return r->cfDivComp (a,b,r); }
521 
522 /// in Z: 1
523 /// in Z/kZ (where k is not a prime): largest divisor of n (taken in Z) that
524 /// is co-prime with k
525 /// in Z/2^kZ: largest odd divisor of n (taken in Z)
526 /// other cases: not implemented
527 // CF: shold imply that n/GetUnit(n) is normalized in Z/kZ
528 // it would make more sense to return the inverse...
529 static FORCE_INLINE number n_GetUnit(number n, const coeffs r)
530 { assume(r != NULL); assume(r->cfGetUnit!=NULL); return r->cfGetUnit(n,r); }
531 
532 #endif
533 
534 /// a number representing i in the given coeff field/ring r
535 static FORCE_INLINE number n_Init(long i, const coeffs r)
536 { assume(r != NULL); assume(r->cfInit!=NULL); return r->cfInit(i,r); }
537 
538 /// conversion of a GMP integer to number
539 static FORCE_INLINE number n_InitMPZ(mpz_t n, const coeffs r)
540 { assume(r != NULL); assume(r->cfInitMPZ != NULL); return r->cfInitMPZ(n,r); }
541 
542 /// conversion of n to an int; 0 if not possible
543 /// in Z/pZ: the representing int lying in (-p/2 .. p/2]
544 static FORCE_INLINE long n_Int(number &n, const coeffs r)
545 { assume(r != NULL); assume(r->cfInt!=NULL); return r->cfInt(n,r); }
546 
547 /// conversion of n to a GMP integer; 0 if not possible
548 static FORCE_INLINE void n_MPZ(mpz_t result, number &n, const coeffs r)
549 { assume(r != NULL); assume(r->cfMPZ!=NULL); r->cfMPZ(result, n, r); }
550 
551 
552 /// in-place negation of n
553 /// MUST BE USED: n = n_InpNeg(n) (no copy is returned)
554 static FORCE_INLINE number n_InpNeg(number n, const coeffs r)
555 { assume(r != NULL); assume(r->cfInpNeg!=NULL); return r->cfInpNeg(n,r); }
556 
557 /// return the multiplicative inverse of 'a';
558 /// raise an error if 'a' is not invertible
559 ///
560 /// !!! Recommendation: rename to 'n_Inverse'
561 static FORCE_INLINE number n_Invers(number a, const coeffs r)
562 { assume(r != NULL); assume(r->cfInvers!=NULL); return r->cfInvers(a,r); }
563 
564 /// return a non-negative measure for the complexity of n;
565 /// return 0 only when n represents zero;
566 /// (used for pivot strategies in matrix computations with entries from r)
567 static FORCE_INLINE int n_Size(number n, const coeffs r)
568 { assume(r != NULL); assume(r->cfSize!=NULL); return r->cfSize(n,r); }
569 
570 /// inplace-normalization of n;
571 /// produces some canonical representation of n;
572 ///
573 /// !!! Recommendation: remove this method from the user-interface, i.e.,
574 /// !!! this should be hidden
575 static FORCE_INLINE void n_Normalize(number& n, const coeffs r)
576 { assume(r != NULL); assume(r->cfNormalize!=NULL); r->cfNormalize(n,r); }
577 
578 /// write to the output buffer of the currently used reporter
579 //CF: the "&" should be removed, as one wants to write constants as well
580 static FORCE_INLINE void n_WriteLong(number n, const coeffs r)
581 { assume(r != NULL); assume(r->cfWriteLong!=NULL); r->cfWriteLong(n,r); }
582 
583 /// write to the output buffer of the currently used reporter
584 /// in a shortest possible way, e.g. in K(a): a2 instead of a^2
585 static FORCE_INLINE void n_WriteShort(number n, const coeffs r)
586 { assume(r != NULL); assume(r->cfWriteShort!=NULL); r->cfWriteShort(n,r); }
587 
588 static FORCE_INLINE void n_Write(number n, const coeffs r, const BOOLEAN bShortOut = TRUE)
589 { if (bShortOut) n_WriteShort(n, r); else n_WriteLong(n, r); }
590 
591 
592 /// !!! Recommendation: This method is too cryptic to be part of the user-
593 /// !!! interface. As defined here, it is merely a helper
594 /// !!! method for parsing number input strings.
595 static FORCE_INLINE const char *n_Read(const char * s, number * a, const coeffs r)
596 { assume(r != NULL); assume(r->cfRead!=NULL); return r->cfRead(s, a, r); }
597 
598 /// return the denominator of n
599 /// (if elements of r are by nature not fractional, result is 1)
600 static FORCE_INLINE number n_GetDenom(number& n, const coeffs r)
601 { assume(r != NULL); assume(r->cfGetDenom!=NULL); return r->cfGetDenom(n, r); }
602 
603 /// return the numerator of n
604 /// (if elements of r are by nature not fractional, result is n)
605 static FORCE_INLINE number n_GetNumerator(number& n, const coeffs r)
606 { assume(r != NULL); assume(r->cfGetNumerator!=NULL); return r->cfGetNumerator(n, r); }
607 
608 /// return the quotient of 'a' and 'b', i.e., a/b;
609 /// raises an error if 'b' is not invertible in r
610 /// exception in Z: raises an error if 'a' is not divisible by 'b'
611 /// always: n_Div(a,b,r)*b+n_IntMod(a,b,r)==a
612 static FORCE_INLINE number n_Div(number a, number b, const coeffs r)
613 { assume(r != NULL); assume(r->cfDiv!=NULL); return r->cfDiv(a,b,r); }
614 
615 /// assume that there is a canonical subring in cf and we know
616 /// that division is possible for these a and b in the subring,
617 /// n_ExactDiv performs it, may skip additional tests.
618 /// Can always be substituted by n_Div at the cost of larger computing time.
619 static FORCE_INLINE number n_ExactDiv(number a, number b, const coeffs r)
620 { assume(r != NULL); assume(r->cfExactDiv!=NULL); return r->cfExactDiv(a,b,r); }
621 
622 /// for r a field, return n_Init(0,r)
623 /// always: n_Div(a,b,r)*b+n_IntMod(a,b,r)==a
624 /// n_IntMod(a,b,r) >=0
625 static FORCE_INLINE number n_IntMod(number a, number b, const coeffs r)
626 { assume(r != NULL); return r->cfIntMod(a,b,r); }
627 
628 /// fill res with the power a^b
629 static FORCE_INLINE void n_Power(number a, int b, number *res, const coeffs r)
630 { assume(r != NULL); assume(r->cfPower!=NULL); r->cfPower(a,b,res,r); }
631 
632 /// return the product of 'a' and 'b', i.e., a*b
633 static FORCE_INLINE number n_Mult(number a, number b, const coeffs r)
634 { assume(r != NULL); assume(r->cfMult!=NULL); return r->cfMult(a, b, r); }
635 
636 /// multiplication of 'a' and 'b';
637 /// replacement of 'a' by the product a*b
638 static FORCE_INLINE void n_InpMult(number &a, number b, const coeffs r)
639 { assume(r != NULL); assume(r->cfInpMult!=NULL); r->cfInpMult(a,b,r); }
640 
641 /// addition of 'a' and 'b';
642 /// replacement of 'a' by the sum a+b
643 static FORCE_INLINE void n_InpAdd(number &a, number b, const coeffs r)
644 { assume(r != NULL); assume(r->cfInpAdd!=NULL); r->cfInpAdd(a,b,r); }
645 
646 /// return the sum of 'a' and 'b', i.e., a+b
647 static FORCE_INLINE number n_Add(number a, number b, const coeffs r)
648 { assume(r != NULL); assume(r->cfAdd!=NULL); return r->cfAdd(a, b, r); }
649 
650 
651 /// return the difference of 'a' and 'b', i.e., a-b
652 static FORCE_INLINE number n_Sub(number a, number b, const coeffs r)
653 { assume(r != NULL); assume(r->cfSub!=NULL); return r->cfSub(a, b, r); }
654 
655 /// in Z: return the gcd of 'a' and 'b'
656 /// in Z/nZ, Z/2^kZ: computed as in the case Z
657 /// in Z/pZ, C, R: not implemented
658 /// in Q: return the gcd of the numerators of 'a' and 'b'
659 /// in K(a)/<p(a)>: not implemented
660 /// in K(t_1, ..., t_n): not implemented
661 static FORCE_INLINE number n_Gcd(number a, number b, const coeffs r)
662 { assume(r != NULL); assume(r->cfGcd!=NULL); return r->cfGcd(a,b,r); }
663 static FORCE_INLINE number n_SubringGcd(number a, number b, const coeffs r)
664 { assume(r != NULL); assume(r->cfSubringGcd!=NULL); return r->cfSubringGcd(a,b,r); }
665 
666 /// beware that ExtGCD is only relevant for a few chosen coeff. domains
667 /// and may perform something unexpected in some cases...
668 static FORCE_INLINE number n_ExtGcd(number a, number b, number *s, number *t, const coeffs r)
669 { assume(r != NULL); assume(r->cfExtGcd!=NULL); return r->cfExtGcd (a,b,s,t,r); }
670 static FORCE_INLINE number n_XExtGcd(number a, number b, number *s, number *t, number *u, number *v, const coeffs r)
671 { assume(r != NULL); assume(r->cfXExtGcd!=NULL); return r->cfXExtGcd (a,b,s,t,u,v,r); }
672 static FORCE_INLINE number n_EucNorm(number a, const coeffs r)
673 { assume(r != NULL); assume(r->cfEucNorm!=NULL); return r->cfEucNorm (a,r); }
674 /// if r is a ring with zero divisors, return an annihilator!=0 of b
675 /// otherwise return NULL
676 static FORCE_INLINE number n_Ann(number a, const coeffs r)
677 { assume(r != NULL); return r->cfAnn (a,r); }
678 static FORCE_INLINE number n_QuotRem(number a, number b, number *q, const coeffs r)
679 { assume(r != NULL); assume(r->cfQuotRem!=NULL); return r->cfQuotRem (a,b,q,r); }
680 
681 
682 /// in Z: return the lcm of 'a' and 'b'
683 /// in Z/nZ, Z/2^kZ: computed as in the case Z
684 /// in Z/pZ, C, R: not implemented
685 /// in K(a)/<p(a)>: not implemented
686 /// in K(t_1, ..., t_n): not implemented
687 static FORCE_INLINE number n_Lcm(number a, number b, const coeffs r)
688 { assume(r != NULL); assume(r->cfLcm!=NULL); return r->cfLcm(a,b,r); }
689 
690 /// assume that r is a quotient field (otherwise, return 1)
691 /// for arguments (a1/a2,b1/b2) return (lcm(a1,b2)/1)
692 static FORCE_INLINE number n_NormalizeHelper(number a, number b, const coeffs r)
693 { assume(r != NULL); assume(r->cfNormalizeHelper!=NULL); return r->cfNormalizeHelper(a,b,r); }
694 
695 number ndCopyMap(number a, const coeffs src, const coeffs dst);
696 /// set the mapping function pointers for translating numbers from src to dst
697 static FORCE_INLINE nMapFunc n_SetMap(const coeffs src, const coeffs dst)
698 { assume(src != NULL && dst != NULL); assume(dst->cfSetMap!=NULL);
699  if (src==dst) return ndCopyMap;
700  return dst->cfSetMap(src,dst);
701 }
702 
703 #ifdef LDEBUG
704 /// test whether n is a correct number;
705 /// only used if LDEBUG is defined
706 static FORCE_INLINE BOOLEAN n_DBTest(number n, const char *filename, const int linenumber, const coeffs r)
707 { assume(r != NULL); assume(r->cfDBTest != NULL); return r->cfDBTest(n, filename, linenumber, r); }
708 /// BOOLEAN n_Test(number a, const coeffs r)
709 #define n_Test(a,r) n_DBTest(a, __FILE__, __LINE__, r)
710 #else
711 #define n_Test(a,r) 1
712 #endif
713 
714 
715 /// output the coeff description
716 static FORCE_INLINE void n_CoeffWrite(const coeffs r, BOOLEAN details = TRUE)
717 { assume(r != NULL); assume(r->cfCoeffWrite != NULL); r->cfCoeffWrite(r, details); }
718 
719 // Tests:
720 #ifdef HAVE_RINGS
722 { assume(r != NULL); return (getCoeffType(r)==n_Z2m); }
723 
725 { assume(r != NULL); return (getCoeffType(r)==n_Znm); }
726 
728 { assume(r != NULL); return (r->is_field==0); }
729 #else
730 #define nCoeff_is_Ring_2toM(A) 0
731 #define nCoeff_is_Ring_PtoM(A) 0
732 #define nCoeff_is_Ring(A) 0
733 #endif
734 
735 /// returns TRUE, if r is a field or r has no zero divisors (i.e is a domain)
737 {
738  assume(r != NULL);
739  return (r->is_domain);
740 }
741 
742 /// test whether 'a' is divisible 'b';
743 /// for r encoding a field: TRUE iff 'b' does not represent zero
744 /// in Z: TRUE iff 'b' divides 'a' (with remainder = zero)
745 /// in Z/nZ: TRUE iff (a = 0 and b divides n in Z) or
746 /// (a != 0 and b/gcd(a, b) is co-prime with n, i.e.
747 /// a unit in Z/nZ)
748 /// in Z/2^kZ: TRUE iff ((a = 0 mod 2^k) and (b = 0 or b is a power of 2))
749 /// or ((a, b <> 0) and (b/gcd(a, b) is odd))
750 static FORCE_INLINE BOOLEAN n_DivBy(number a, number b, const coeffs r)
751 { assume(r != NULL);
752 #ifdef HAVE_RINGS
753  if( nCoeff_is_Ring(r) )
754  {
755  assume(r->cfDivBy!=NULL); return r->cfDivBy(a,b,r);
756  }
757 #endif
758  return !n_IsZero(b, r);
759 }
760 
761 static FORCE_INLINE number n_ChineseRemainderSym(number *a, number *b, int rl, BOOLEAN sym,CFArray &inv_cache,const coeffs r)
762 { assume(r != NULL); assume(r->cfChineseRemainder != NULL); return r->cfChineseRemainder(a,b,rl,sym,inv_cache,r); }
763 
764 static FORCE_INLINE number n_Farey(number a, number b, const coeffs r)
765 { assume(r != NULL); assume(r->cfFarey != NULL); return r->cfFarey(a,b,r); }
766 
767 static FORCE_INLINE int n_ParDeg(number n, const coeffs r)
768 { assume(r != NULL); assume(r->cfParDeg != NULL); return r->cfParDeg(n,r); }
769 
770 /// Returns the number of parameters
772 { assume(r != NULL); return r->iNumberOfParameters; }
773 
774 /// Returns a (const!) pointer to (const char*) names of parameters
775 static FORCE_INLINE char const * * n_ParameterNames(const coeffs r)
776 { assume(r != NULL); return r->pParameterNames; }
777 
778 /// return the (iParameter^th) parameter as a NEW number
779 /// NOTE: parameter numbering: 1..n_NumberOfParameters(...)
780 static FORCE_INLINE number n_Param(const int iParameter, const coeffs r)
781 { assume(r != NULL);
782  assume((iParameter >= 1) || (iParameter <= n_NumberOfParameters(r)));
783  assume(r->cfParameter != NULL);
784  return r->cfParameter(iParameter, r);
785 }
786 
787 static FORCE_INLINE number n_RePart(number i, const coeffs cf)
788 { assume(cf != NULL); assume(cf->cfRePart!=NULL); return cf->cfRePart(i,cf); }
789 
790 static FORCE_INLINE number n_ImPart(number i, const coeffs cf)
791 { assume(cf != NULL); assume(cf->cfImPart!=NULL); return cf->cfImPart(i,cf); }
792 
793 /// returns TRUE, if r is not a field and r has non-trivial units
795 { assume(r != NULL); return ((getCoeffType(r)==n_Zn) || (getCoeffType(r)==n_Z2m) || (getCoeffType(r)==n_Znm)); }
796 
798 { assume(r != NULL); return getCoeffType(r)==n_Zp; }
799 
801 { assume(r != NULL); return ((getCoeffType(r)==n_Zp) && (r->ch == p)); }
802 
804 {
805  assume(r != NULL);
806  #if SI_INTEGER_VARIANT==1
807  return getCoeffType(r)==n_Q && (r->is_field);
808  #else
809  return getCoeffType(r)==n_Q;
810  #endif
811 }
812 
814 {
815  assume(r != NULL);
816  #if SI_INTEGER_VARIANT==1
817  return ((getCoeffType(r)==n_Q) && (!r->is_field));
818  #else
819  return getCoeffType(r)==n_Z;
820  #endif
821 }
822 
824 { assume(r != NULL); return getCoeffType(r)==n_Zn; }
825 
827 { assume(r != NULL); return getCoeffType(r)==n_Q; }
828 
829 static FORCE_INLINE BOOLEAN nCoeff_is_numeric(const coeffs r) /* R, long R, long C */
830 { assume(r != NULL); return (getCoeffType(r)==n_R) || (getCoeffType(r)==n_long_R) || (getCoeffType(r)==n_long_C); }
831 // (r->ringtype == 0) && (r->ch == -1); ??
832 
834 { assume(r != NULL); return getCoeffType(r)==n_R; }
835 
837 { assume(r != NULL); return getCoeffType(r)==n_GF; }
838 
839 static FORCE_INLINE BOOLEAN nCoeff_is_GF(const coeffs r, int q)
840 { assume(r != NULL); return (getCoeffType(r)==n_GF) && (r->ch == q); }
841 
842 /* TRUE iff r represents an algebraic or transcendental extension field */
844 {
845  assume(r != NULL);
846  return (getCoeffType(r)==n_algExt) || (getCoeffType(r)==n_transExt);
847 }
848 
849 /* DO NOT USE (only kept for compatibility reasons towards the SINGULAR
850  svn trunk);
851  intension: should be TRUE iff the given r is an extension field above
852  some Z/pZ;
853  actually: TRUE iff the given r is an extension tower of arbitrary
854  height above some field of characteristic p (may be Z/pZ or some
855  Galois field of characteristic p) */
857 {
858  assume(r != NULL);
859  return ((!nCoeff_is_Ring(r)) && (n_GetChar(r) != 0) && nCoeff_is_Extension(r));
860 }
861 
862 /* DO NOT USE (only kept for compatibility reasons towards the SINGULAR
863  svn trunk);
864  intension: should be TRUE iff the given r is an extension field above
865  Z/pZ (with p as provided);
866  actually: TRUE iff the given r is an extension tower of arbitrary
867  height above some field of characteristic p (may be Z/pZ or some
868  Galois field of characteristic p) */
870 {
871  assume(r != NULL);
872  assume(p != 0);
873  return ((!nCoeff_is_Ring(r)) && (n_GetChar(r) == p) && nCoeff_is_Extension(r));
874 }
875 
876 /* DO NOT USE (only kept for compatibility reasons towards the SINGULAR
877  svn trunk);
878  intension: should be TRUE iff the given r is an extension field
879  above Q;
880  actually: TRUE iff the given r is an extension tower of arbitrary
881  height above some field of characteristic 0 (may be Q, R, or C) */
883 {
884  assume(r != NULL);
885  return ((n_GetChar(r) == 0) && nCoeff_is_Extension(r));
886 }
887 
889 { assume(r != NULL); return getCoeffType(r)==n_long_R; }
890 
892 { assume(r != NULL); return getCoeffType(r)==n_long_C; }
893 
895 { assume(r != NULL); return getCoeffType(r)==n_CF; }
896 
897 /// TRUE, if the computation of the inverse is fast,
898 /// i.e. prefer leading coeff. 1 over content
900 { assume(r != NULL); return r->has_simple_Inverse; }
901 
902 /// TRUE if n_Delete is empty operation
904 { assume(r != NULL); return r->has_simple_Alloc; }
905 
906 /// TRUE iff r represents an algebraic extension field
908 { assume(r != NULL); return (getCoeffType(r)==n_algExt); }
909 
910 /// is it an alg. ext. of Q?
912 { assume(r != NULL); return ((n_GetChar(r) == 0) && nCoeff_is_algExt(r)); }
913 
914 /// TRUE iff r represents a transcendental extension field
916 { assume(r != NULL); return (getCoeffType(r)==n_transExt); }
917 
918 /// Computes the content and (inplace) divides it out on a collection
919 /// of numbers
920 /// number @em c is the content (i.e. the GCD of all the coeffs, which
921 /// we divide out inplace)
922 /// NOTE: it assumes all coefficient numbers to be integer!!!
923 /// NOTE/TODO: see also the description by Hans
924 /// TODO: rename into n_ClearIntegerContent
925 static FORCE_INLINE void n_ClearContent(ICoeffsEnumerator& numberCollectionEnumerator, number& c, const coeffs r)
926 { assume(r != NULL); r->cfClearContent(numberCollectionEnumerator, c, r); }
927 
928 /// (inplace) Clears denominators on a collection of numbers
929 /// number @em d is the LCM of all the coefficient denominators (i.e. the number
930 /// with which all the number coeffs. were multiplied)
931 /// NOTE/TODO: see also the description by Hans
932 static FORCE_INLINE void n_ClearDenominators(ICoeffsEnumerator& numberCollectionEnumerator, number& d, const coeffs r)
933 { assume(r != NULL); r->cfClearDenominators(numberCollectionEnumerator, d, r); }
934 
935 // convenience helpers (no number returned - but the input enumeration
936 // is to be changed
937 // TODO: do we need separate hooks for these as our existing code does
938 // *different things* there: compare p_Cleardenom (which calls
939 // *p_Content) and p_Cleardenom_n (which doesn't)!!!
940 
941 static FORCE_INLINE void n_ClearContent(ICoeffsEnumerator& numberCollectionEnumerator, const coeffs r)
942 { number c; n_ClearContent(numberCollectionEnumerator, c, r); n_Delete(&c, r); }
943 
944 static FORCE_INLINE void n_ClearDenominators(ICoeffsEnumerator& numberCollectionEnumerator, const coeffs r)
945 { assume(r != NULL); number d; n_ClearDenominators(numberCollectionEnumerator, d, r); n_Delete(&d, r); }
946 
947 
948 /// print a number (BEWARE of string buffers!)
949 /// mostly for debugging
950 void n_Print(number& a, const coeffs r);
951 
952 
953 
954 /// TODO: make it a virtual method of coeffs, together with:
955 /// Decompose & Compose, rParameter & rPar
956 static FORCE_INLINE char * nCoeffString(const coeffs cf)
957 { assume( cf != NULL ); return cf->cfCoeffString(cf); }
958 
959 
960 static FORCE_INLINE char * nCoeffName (const coeffs cf)
961 { assume( cf != NULL ); return cf->cfCoeffName(cf); }
962 
963 static FORCE_INLINE number n_Random(siRandProc p, number p1, number p2, const coeffs cf)
964 { assume( cf != NULL ); assume( cf->cfRandom != NULL ); return cf->cfRandom(p, p1, p2, cf); }
965 
966 /// io via ssi:
967 static FORCE_INLINE void n_WriteFd(number a, const ssiInfo *f, const coeffs r)
968 { assume(r != NULL); assume(r->cfWriteFd != NULL); return r->cfWriteFd(a, f, r); }
969 
970 /// io via ssi:
971 static FORCE_INLINE number n_ReadFd( const ssiInfo *f, const coeffs r)
972 { assume(r != NULL); assume(r->cfReadFd != NULL); return r->cfReadFd(f, r); }
973 
974 
975 static FORCE_INLINE number n_convFactoryNSingN( const CanonicalForm n, const coeffs r)
976 { assume(r != NULL); assume(r->convFactoryNSingN != NULL); return r->convFactoryNSingN(n, r); }
977 
978 static FORCE_INLINE CanonicalForm n_convSingNFactoryN( number n, BOOLEAN setChar, const coeffs r )
979 { assume(r != NULL); assume(r->convSingNFactoryN != NULL); return r->convSingNFactoryN(n, setChar, r); }
980 
981 
982 // TODO: remove the following functions...
983 // the following 2 inline functions are just convenience shortcuts for Frank's code:
984 static FORCE_INLINE void number2mpz(number n, coeffs c, mpz_t m){ n_MPZ(m, n, c); }
985 static FORCE_INLINE number mpz2number(mpz_t m, coeffs c){ return n_InitMPZ(m, c); }
986 
987 #endif
988 
Abstract API for enumerators.
All the auxiliary stuff.
int BOOLEAN
Definition: auxiliary.h:87
#define TRUE
Definition: auxiliary.h:100
#define FORCE_INLINE
Definition: auxiliary.h:329
int l
Definition: cfEzgcd.cc:100
int m
Definition: cfEzgcd.cc:128
int i
Definition: cfEzgcd.cc:132
Variable x
Definition: cfModGcd.cc:4082
int p
Definition: cfModGcd.cc:4078
CanonicalForm cf
Definition: cfModGcd.cc:4083
CanonicalForm b
Definition: cfModGcd.cc:4103
FILE * f
Definition: checklibs.c:9
factory's main class
Definition: canonicalform.h:86
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:767
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:633
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:984
static FORCE_INLINE coeffs n_CoeffRingQuot1(number c, const coeffs r)
Definition: coeffs.h:515
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:780
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:544
static FORCE_INLINE number n_Copy(number n, const coeffs r)
return a copy of 'n'
Definition: coeffs.h:448
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:692
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:956
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:647
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:600
static FORCE_INLINE number n_ReadFd(const ssiInfo *f, const coeffs r)
io via ssi:
Definition: coeffs.h:971
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:794
static FORCE_INLINE void n_CoeffWrite(const coeffs r, BOOLEAN details=TRUE)
output the coeff description
Definition: coeffs.h:716
static FORCE_INLINE BOOLEAN nCoeff_is_GF(const coeffs r)
Definition: coeffs.h:836
static FORCE_INLINE BOOLEAN nCoeff_is_Z(const coeffs r)
Definition: coeffs.h:813
static FORCE_INLINE BOOLEAN nCoeff_is_Extension(const coeffs r)
Definition: coeffs.h:843
number ndCopyMap(number a, const coeffs src, const coeffs dst)
Definition: numbers.cc:291
static FORCE_INLINE number n_Random(siRandProc p, number p1, number p2, const coeffs cf)
Definition: coeffs.h:963
static FORCE_INLINE BOOLEAN nCoeff_is_long_R(const coeffs r)
Definition: coeffs.h:888
static FORCE_INLINE char * nCoeffName(const coeffs cf)
Definition: coeffs.h:960
int GFDegree
Definition: coeffs.h:95
static FORCE_INLINE number mpz2number(mpz_t m, coeffs c)
Definition: coeffs.h:985
static FORCE_INLINE BOOLEAN nCoeff_is_Ring_PtoM(const coeffs r)
Definition: coeffs.h:724
static FORCE_INLINE void n_WriteFd(number a, const ssiInfo *f, const coeffs r)
io via ssi:
Definition: coeffs.h:967
n_coeffType
Definition: coeffs.h:27
@ n_R
single prescision (6,6) real numbers
Definition: coeffs.h:31
@ n_GF
\GF{p^n < 2^16}
Definition: coeffs.h:32
@ n_FlintQrat
rational funtion field over Q
Definition: coeffs.h:47
@ n_polyExt
used to represent polys as coeffcients
Definition: coeffs.h:34
@ n_Q
rational (GMP) numbers
Definition: coeffs.h:30
@ n_Znm
only used if HAVE_RINGS is defined
Definition: coeffs.h:45
@ n_algExt
used for all algebraic extensions, i.e., the top-most extension in an extension tower is algebraic
Definition: coeffs.h:35
@ n_Zn
only used if HAVE_RINGS is defined
Definition: coeffs.h:44
@ n_long_R
real floating point (GMP) numbers
Definition: coeffs.h:33
@ n_Z2m
only used if HAVE_RINGS is defined
Definition: coeffs.h:46
@ n_Zp
\F{p < 2^31}
Definition: coeffs.h:29
@ 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:38
@ n_unknown
Definition: coeffs.h:28
@ n_Z
only used if HAVE_RINGS is defined
Definition: coeffs.h:43
@ n_nTupel
n-tupel of cf: ZZ/p1,...
Definition: coeffs.h:42
@ n_long_C
complex floating point (GMP) numbers
Definition: coeffs.h:41
static FORCE_INLINE number n_convFactoryNSingN(const CanonicalForm n, const coeffs r)
Definition: coeffs.h:975
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:661
static FORCE_INLINE BOOLEAN nCoeff_is_CF(const coeffs r)
Definition: coeffs.h:894
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:561
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:512
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:672
short float_len2
additional char-flags, rInit
Definition: coeffs.h:102
static FORCE_INLINE BOOLEAN nCoeff_is_numeric(const coeffs r)
Definition: coeffs.h:829
static FORCE_INLINE number n_QuotRem(number a, number b, number *q, const coeffs r)
Definition: coeffs.h:678
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:619
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:491
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:736
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:676
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:548
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:469
static FORCE_INLINE BOOLEAN nCoeff_is_Zp_a(const coeffs r)
Definition: coeffs.h:856
void n_Print(number &a, const coeffs r)
print a number (BEWARE of string buffers!) mostly for debugging
Definition: numbers.cc:667
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:697
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:554
static FORCE_INLINE void n_WriteLong(number n, const coeffs r)
write to the output buffer of the currently used reporter
Definition: coeffs.h:580
static FORCE_INLINE BOOLEAN nCoeff_is_Q_algext(const coeffs r)
is it an alg. ext. of Q?
Definition: coeffs.h:911
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:595
const char * par_name
parameter name
Definition: coeffs.h:103
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:629
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:899
static FORCE_INLINE number n_Farey(number a, number b, const coeffs r)
Definition: coeffs.h:764
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:612
static FORCE_INLINE CanonicalForm n_convSingNFactoryN(number n, BOOLEAN setChar, const coeffs r)
Definition: coeffs.h:978
static FORCE_INLINE number n_RePart(number i, const coeffs cf)
Definition: coeffs.h:787
static FORCE_INLINE BOOLEAN nCoeff_is_Q(const coeffs r)
Definition: coeffs.h:803
coeffs nInitChar(n_coeffType t, void *parameter)
one-time initialisations for new coeffs in case of an error return NULL
Definition: numbers.cc:413
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:508
const unsigned short fftable[]
Definition: ffields.cc:27
static FORCE_INLINE void nSetChar(const coeffs r)
initialisations after each ring change
Definition: coeffs.h:437
static FORCE_INLINE char const ** n_ParameterNames(const coeffs r)
Returns a (const!) pointer to (const char*) names of parameters.
Definition: coeffs.h:775
static FORCE_INLINE BOOLEAN n_IsZero(number n, const coeffs r)
TRUE iff 'n' represents the zero element.
Definition: coeffs.h:461
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:567
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:529
static FORCE_INLINE BOOLEAN nCoeff_has_simple_Alloc(const coeffs r)
TRUE if n_Delete is empty operation.
Definition: coeffs.h:903
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:652
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:932
static FORCE_INLINE BOOLEAN nCoeff_is_Ring(const coeffs r)
Definition: coeffs.h:727
static FORCE_INLINE BOOLEAN nCoeff_is_Q_or_BI(const coeffs r)
Definition: coeffs.h:826
static FORCE_INLINE n_coeffType getCoeffType(const coeffs r)
Returns the type of coeffs domain.
Definition: coeffs.h:422
static FORCE_INLINE number n_ChineseRemainderSym(number *a, number *b, int rl, BOOLEAN sym, CFArray &inv_cache, const coeffs r)
Definition: coeffs.h:761
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:441
static FORCE_INLINE coeffs nCopyCoeff(const coeffs r)
"copy" coeffs, i.e. increment ref
Definition: coeffs.h:430
static FORCE_INLINE void n_Delete(number *p, const coeffs r)
delete 'p'
Definition: coeffs.h:452
static FORCE_INLINE BOOLEAN nCoeff_is_Zn(const coeffs r)
Definition: coeffs.h:823
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:687
static FORCE_INLINE number n_InitMPZ(mpz_t n, const coeffs r)
conversion of a GMP integer to number
Definition: coeffs.h:539
static FORCE_INLINE int n_NumberOfParameters(const coeffs r)
Returns the number of parameters.
Definition: coeffs.h:771
static FORCE_INLINE void n_Write(number n, const coeffs r, const BOOLEAN bShortOut=TRUE)
Definition: coeffs.h:588
static FORCE_INLINE BOOLEAN nCoeff_is_Zp(const coeffs r)
Definition: coeffs.h:797
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:668
static FORCE_INLINE BOOLEAN nCoeff_is_Q_a(const coeffs r)
Definition: coeffs.h:882
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:535
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:625
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:925
static FORCE_INLINE BOOLEAN nCoeff_is_Ring_2toM(const coeffs r)
Definition: coeffs.h:721
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:750
static FORCE_INLINE BOOLEAN nCoeff_is_algExt(const coeffs r)
TRUE iff r represents an algebraic extension field.
Definition: coeffs.h:907
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:638
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:457
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:605
EXTERN_VAR omBin rnumber_bin
Definition: coeffs.h:84
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:706
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:585
static FORCE_INLINE number n_SubringGcd(number a, number b, const coeffs r)
Definition: coeffs.h:663
static FORCE_INLINE int n_DivComp(number a, number b, const coeffs r)
Definition: coeffs.h:519
static FORCE_INLINE number n_ImPart(number i, const coeffs cf)
Definition: coeffs.h:790
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:833
static FORCE_INLINE void n_Normalize(number &n, const coeffs r)
inplace-normalization of n; produces some canonical representation of n;
Definition: coeffs.h:575
const char * GFPar_name
Definition: coeffs.h:96
static FORCE_INLINE BOOLEAN nCoeff_is_long_C(const coeffs r)
Definition: coeffs.h:891
int GFChar
Definition: coeffs.h:94
void nKillChar(coeffs r)
undo all initialisations
Definition: numbers.cc:568
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:643
static FORCE_INLINE BOOLEAN n_IsOne(number n, const coeffs r)
TRUE iff 'n' represents the one element.
Definition: coeffs.h:465
static FORCE_INLINE BOOLEAN nCoeff_is_transExt(const coeffs r)
TRUE iff r represents a transcendental extension field.
Definition: coeffs.h:915
static FORCE_INLINE number n_XExtGcd(number a, number b, number *s, number *t, number *u, number *v, const coeffs r)
Definition: coeffs.h:670
Creation data needed for finite fields.
Definition: coeffs.h:93
return result
Definition: facAbsBiFact.cc:75
const CanonicalForm int s
Definition: facAbsFact.cc:51
CanonicalForm res
Definition: facAbsFact.cc:60
const Variable & v
< [in] a sqrfree bivariate poly
Definition: facBivar.h:39
#define const
Definition: fegetopt.c:39
#define EXTERN_VAR
Definition: globaldefs.h:6
'SR_INT' is the type of those integers small enough to fit into 29 bits.
Definition: longrat.h:49
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:389
The main handler for Singular numbers which are suitable for Singular polynomials.
#define NULL
Definition: omList.c:12
omBin_t * omBin
Definition: omStructs.h:12
Definition: s_buff.h:21
int(* siRandProc)(void)
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:405
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 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 (integer) number n into a GMP number, 0 if impossible.
Definition: coeffs.h:190
unsigned long modExponent
Definition: coeffs.h:403
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:411
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:402
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:416
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:404
coeffs(* cfQuot1)(number c, const coeffs r)
Definition: coeffs.h:407
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)
test if b divides a cfDivBy(zero,b,r) is true, if b is a zero divisor
Definition: coeffs.h:382
nCoeffsEnumeratorFunc cfClearContent
function pointer behind n_ClearContent
Definition: coeffs.h:309
nCoeffsEnumeratorFunc cfClearDenominators
function pointer behind n_ClearDenominators
Definition: coeffs.h:312