source: git/libpolys/coeffs/coeffs.h @ 9b3700

fieker-DuValspielwiese
Last change on this file since 9b3700 was 9b3700, checked in by mlee <martinlee84@…>, 13 years ago
added n_ExtGcd, n_IntMod and n_DivComp to coeffs.h added currRing, currRing->cf at appropiate places in kutil.cc
  • Property mode set to 100644
File size: 24.2 KB
Line 
1#ifndef COEFFS_H
2#define COEFFS_H
3/****************************************
4*  Computer Algebra System SINGULAR     *
5****************************************/
6/* $Id$ */
7/*
8* ABSTRACT
9*/
10
11#include <misc/auxiliary.h>
12/* for assume: */
13#include <reporter/reporter.h>
14
15#include <coeffs/si_gmp.h>
16
17#ifdef HAVE_FACTORY
18class CanonicalForm;
19#endif
20
21enum n_coeffType
22{
23  n_unknown=0,
24  n_Zp,
25  n_Q,
26  n_R,
27  n_GF,
28  n_long_R,
29  n_algExt,  /**< used for all algebraic extensions, i.e.,
30                the top-most extension in an extension tower
31                is algebraic */
32  n_transExt,  /**< used for all transcendental extensions, i.e.,
33                  the top-most extension in an extension tower
34                  is transcendental */
35  n_long_C,
36  // only used if HAVE_RINGS is defined:
37  n_Z,
38  n_Zn,
39  n_Zpn, // does no longer exist?
40  n_Z2m,
41  n_CF
42};
43
44struct snumber;
45typedef struct snumber *   number;
46
47/* standard types */
48#ifdef HAVE_RINGS
49typedef unsigned long NATNUMBER;
50typedef mpz_ptr int_number;
51#endif
52
53struct ip_sring;
54typedef struct ip_sring *         ring;
55
56struct n_Procs_s;
57typedef struct  n_Procs_s  *coeffs;
58
59typedef number (*numberfunc)(number a, number b, const coeffs r);
60
61/// maps "a", which lives in src, into dst
62typedef number (*nMapFunc)(number a, const coeffs src, const coeffs dst);
63
64struct n_Procs_s
65{
66   coeffs next;
67   unsigned int ringtype;  /* =0 => coefficient field,
68                             !=0 => coeffs from one of the rings:
69                              =1 => Z/2^mZ
70                              =2 => Z/nZ, n not a prime
71                              =3 => Z/p^mZ
72                              =4 => Z */
73
74   // general properties:
75   /// TRUE, if nNew/nDelete/nCopy are dummies
76   BOOLEAN has_simple_Alloc;
77   /// TRUE, if std should make polynomials monic (if nInvers is cheap)
78   /// if false, then a gcd routine is used for a content computation
79   BOOLEAN has_simple_Inverse;
80
81   // tests for numbers.cc:
82   BOOLEAN (*nCoeffIsEqual)(const coeffs r, n_coeffType n, void * parameter);
83
84   /// output of coeff description via Print
85   void (*cfCoeffWrite)(const coeffs r);
86
87   // the union stuff
88
89   // Zp:
90   int npPrimeM;
91   int npPminus1M;
92   #ifdef HAVE_DIV_MOD
93   unsigned short *npInvTable;
94   #endif
95   #if !defined(HAVE_DIV_MOD) || !defined(HAVE_MULT_MOD)
96   unsigned short *npExpTable;
97   unsigned short *npLogTable;
98   #endif
99
100   // ?
101   // initialisation:
102   //void (*cfInitChar)(coeffs r, int parameter); // do one-time initialisations
103   void (*cfKillChar)(coeffs r); //  undo all initialisations
104                                // or NULL
105   void (*cfSetChar)(const coeffs r); // initialisations after each ring change
106                                // or NULL
107   // general stuff
108   numberfunc cfMult, cfSub ,cfAdd ,cfDiv, cfIntDiv, cfIntMod, cfExactDiv;
109   /// init with an integer
110   number  (*cfInit)(int i,const coeffs r);
111   /// how complicated, (0) => 0, or positive
112   int     (*cfSize)(number n, const coeffs r);
113   /// convertion, 0 if impossible
114   int     (*cfInt)(number &n, const coeffs r);
115
116#ifdef HAVE_RINGS
117   int     (*cfDivComp)(number a,number b,const coeffs r);
118   BOOLEAN (*cfIsUnit)(number a,const coeffs r);
119   number  (*cfGetUnit)(number a,const coeffs r);
120   number  (*cfExtGcd)(number a, number b, number *s, number *t,const coeffs r);
121#endif
122
123   /// changes argument  inline: a:= -a
124   number  (*cfNeg)(number a, const coeffs r);
125   /// return 1/a
126   number  (*cfInvers)(number a, const coeffs r);
127   /// return a copy of a
128   number  (*cfCopy)(number a, const coeffs r);
129   number  (*cfRePart)(number a, const coeffs r);
130   number  (*cfImPart)(number a, const coeffs r);
131   void    (*cfWrite)(number &a, const coeffs r);
132   const char *  (*cfRead)(const char * s, number * a, const coeffs r);
133   void    (*cfNormalize)(number &a, const coeffs r);
134   BOOLEAN (*cfGreater)(number a,number b, const coeffs r),
135#ifdef HAVE_RINGS
136           (*cfDivBy)(number a, number b, const coeffs r),
137#endif
138            /// tests
139           (*cfEqual)(number a,number b, const coeffs r),
140           (*cfIsZero)(number a, const coeffs r),
141           (*cfIsOne)(number a, const coeffs r),
142           (*cfIsMOne)(number a, const coeffs r),
143           (*cfGreaterZero)(number a, const coeffs r);
144
145   void    (*cfPower)(number a, int i, number * result, const coeffs r);
146   number  (*cfGetDenom)(number &n, const coeffs r);
147   number  (*cfGetNumerator)(number &n, const coeffs r);
148   number  (*cfGcd)(number a, number b, const coeffs r);
149   number  (*cfLcm)(number a, number b, const coeffs r);
150   void    (*cfDelete)(number * a, const coeffs r);
151   nMapFunc (*cfSetMap)(const coeffs src, const coeffs dst);
152
153   /// For extensions (writes into global string buffer)
154   char *  (*cfName)(number n, const coeffs r);
155
156   /// Inplace: a *= b
157   void    (*cfInpMult)(number &a, number b, const coeffs r);
158   /// maps the bigint i (from dummy) into the coeffs dst
159   number  (*cfInit_bigint)(number i, const coeffs dummy, const coeffs dst);
160
161#ifdef HAVE_FACTORY
162   number (*convFactoryNSingN)( const CanonicalForm n, const coeffs r);
163   CanonicalForm (*convSingNFactoryN)( number n, BOOLEAN setChar, const coeffs r );
164#endif
165
166
167#ifdef LDEBUG
168   /// Test: is "a" a correct number?
169   BOOLEAN (*cfDBTest)(number a, const char *f, const int l, const coeffs r);
170#endif
171
172   number nNULL; /* the 0 as constant */
173   int     char_flag;
174   int     ref;
175   n_coeffType type;
176//-------------------------------------------
177
178  /* for extension fields we need to be able to represent polynomials,
179     so here is the polynomial ring: */
180  ring          extRing;
181
182  //number     minpoly;  //< no longer needed: replaced by
183  //                     //< extRing->minideal->[0]
184
185
186//-------------------------------------------
187  char* complex_parameter; //< the name of sqrt(-1), i.e. 'i' or 'j' etc...?
188
189#ifdef HAVE_RINGS
190  /* The following members are for representing the ring Z/n,
191     where n is not a prime. We distinguish four cases:
192     1.) n has at least two distinct prime factors. Then
193         modBase stores n, modExponent stores 1, modNumber
194         stores n, and mod2mMask is not used;
195     2.) n = p^k for some odd prime p and k > 1. Then
196         modBase stores p, modExponent stores k, modNumber
197         stores n, and mod2mMask is not used;
198     3.) n = 2^k for some k > 1; moreover, 2^k - 1 fits in
199         an unsigned long. Then modBase stores 2, modExponent
200         stores k, modNumber is not used, and mod2mMask stores
201         2^k - 1, i.e., the bit mask '111..1' of length k.
202     4.) n = 2^k for some k > 1; but 2^k - 1 does not fit in
203         an unsigned long. Then modBase stores 2, modExponent
204         stores k, modNumber stores n, and mod2mMask is not
205         used;
206     Cases 1.), 2.), and 4.) are covered by the implementation
207     in the files rmodulon.h and rmodulon.cc, whereas case 3.)
208     is implemented in the files rmodulo2m.h and rmodulo2m.cc. */
209  int_number    modBase;
210  unsigned long modExponent;
211  int_number    modNumber;
212  unsigned long mod2mMask;
213#endif
214  int        ch;  /* characteristic, set by the local *InitChar methods;
215                     In field extensions or extensions towers, the
216                     characteristic can be accessed from any of the
217                     intermediate extension fields, i.e., in this case
218                     it is redundant along the chain of field extensions;
219                     CONTRARY to SINGULAR as it was, we do NO LONGER use
220                     negative values for ch;
221                     for rings, ch will also be set and is - per def -
222                     the smallest number of 1's that sum up to zero;
223                     however, in this case ch may not fit in an int,
224                     thus ch may contain a faulty value */
225
226  short      float_len; /* additional char-flags, rInit */
227  short      float_len2; /* additional char-flags, rInit */
228
229  BOOLEAN   ShortOut; /// ffields need this.
230
231// ---------------------------------------------------
232  // for n_GF
233
234  int m_nfCharQ;  ///< the number of elements: q
235  int m_nfM1;       ///< representation of -1
236  int m_nfCharP;  ///< the characteristic: p
237  int m_nfCharQ1; ///< q-1
238  unsigned short *m_nfPlus1Table;
239  int *m_nfMinPoly;
240  char * m_nfParameter;
241};
242//
243// test properties and type
244/// Returns the type of coeffs domain
245static inline n_coeffType getCoeffType(const coeffs r)
246{
247  assume(r != NULL);
248  return r->type;
249}
250
251static inline int nInternalChar(const coeffs r)
252{
253  assume(r != NULL);
254  return r->ch;
255}
256
257/// one-time initialisations for new coeffs
258/// in case of an error return NULL
259coeffs nInitChar(n_coeffType t, void * parameter);
260
261/// undo all initialisations
262void nKillChar(coeffs r);
263
264/// initialisations after each ring change
265static inline void nSetChar(const coeffs r)
266{
267  assume(r!=NULL); // r==NULL is an error
268  if (r->cfSetChar!=NULL) r->cfSetChar(r);
269}
270
271void           nNew(number * a);
272#define n_New(n, r)           nNew(n)
273
274
275// the access methods (part 2):
276
277/// return a copy of 'n'
278static inline number n_Copy(number n,    const coeffs r)
279{   assume(r != NULL); assume(r->cfCopy!=NULL); return r->cfCopy(n, r); }
280
281/// delete 'p'
282static inline void   n_Delete(number* p, const coeffs r)
283{   assume(r != NULL); assume(r->cfDelete!= NULL); r->cfDelete(p, r); }
284
285/// TRUE iff 'a' and 'b' represent the same number;
286/// they may have different representations
287static inline BOOLEAN n_Equal(number a, number b, const coeffs r)
288{ assume(r != NULL); assume(r->cfEqual!=NULL); return r->cfEqual(a, b, r); }
289
290/// TRUE iff 'n' represents the zero element
291static inline BOOLEAN n_IsZero(number n, const coeffs r)
292{ assume(r != NULL); assume(r->cfIsZero!=NULL); return r->cfIsZero(n,r); }
293
294/// TRUE iff 'n' represents the one element
295static inline BOOLEAN n_IsOne(number n,  const coeffs r)
296{ assume(r != NULL); assume(r->cfIsOne!=NULL); return r->cfIsOne(n,r); }
297
298/// TRUE iff 'n' represents the additive inverse of the one element, i.e. -1
299static inline BOOLEAN n_IsMOne(number n, const coeffs r)
300{ assume(r != NULL); assume(r->cfIsMOne!=NULL); return r->cfIsMOne(n,r); }
301
302/// ordered fields: TRUE iff 'n' is positive;
303/// in Z/pZ: TRUE iff 0 < m <= roundedBelow(p/2), where m is the long
304///          representing n
305/// in C:    TRUE iff (Im(n) != 0 and Im(n) >= 0) or
306///                   (Im(n) == 0 and Re(n) >= 0)
307/// in K(a)/<p(a)>: TRUE iff (n != 0 and (LC(n) > 0 or deg(n) > 0))
308/// in K(t_1, ..., t_n): TRUE iff (LC(numerator(n) is a constant and > 0)
309///                            or (LC(numerator(n) is not a constant)
310/// in Z/2^kZ: TRUE iff 0 < n <= 2^(k-1)
311/// in Z/mZ: TRUE iff the internal mpz is greater than zero
312/// in Z: TRUE iff n > 0
313///
314/// !!! Recommendation: remove implementations for unordered fields
315/// !!!                 and raise errors instead, in these cases
316static inline BOOLEAN n_GreaterZero(number n, const coeffs r)
317{
318  assume(r != NULL); assume(r->cfGreaterZero!=NULL);
319  return r->cfGreaterZero(n,r);
320}
321
322/// ordered fields: TRUE iff 'a' is larger than 'b';
323/// in Z/pZ: TRUE iff la > lb, where la and lb are the long's representing
324//                             a and b, respectively
325/// in C:    TRUE iff (Im(a) > Im(b))
326/// in K(a)/<p(a)>: TRUE iff (a != 0 and (b == 0 or deg(a) > deg(b))
327/// in K(t_1, ..., t_n): TRUE only if one or both numerator polynomials are
328///                      zero or if their degrees are equal. In this case,
329///                      TRUE if LC(numerator(a)) > LC(numerator(b))
330/// in Z/2^kZ: TRUE if n_DivBy(a, b)
331/// in Z/mZ: TRUE iff the internal mpz's fulfill the relation '>'
332/// in Z: TRUE iff a > b
333///
334/// !!! Recommendation: remove implementations for unordered fields
335/// !!!                 and raise errors instead, in these cases
336static inline BOOLEAN n_Greater(number a, number b, const coeffs r)
337{ assume(r != NULL); assume(r->cfGreater!=NULL); return r->cfGreater(a,b,r); }
338
339#ifdef HAVE_RINGS
340/// TRUE iff n has a multiplicative inverse in the given coeff field/ring r
341static inline BOOLEAN n_IsUnit(number n, const coeffs r)
342{ assume(r != NULL); assume(r->cfIsUnit!=NULL); return r->cfIsUnit(n,r); }
343
344static inline number n_ExtGcd(number a, number b, number *s, number *t, const coeffs r)
345{ assume(r != NULL); assume(r->cfExtGcd!=NULL); return r->cfExtGcd (a,b,s,t,r); }
346
347static inline int n_DivComp(number a, number b, const coeffs r)
348{ assume(r != NULL); assume(r->cfDivComp!=NULL); return r->cfDivComp (a,b,r); }
349
350/// in Z: 1
351/// in Z/kZ (where k is not a prime): largest divisor of n (taken in Z) that
352///                                   is co-prime with k
353/// in Z/2^kZ: largest odd divisor of n (taken in Z)
354/// other cases: not implemented
355static inline number n_GetUnit(number n, const coeffs r)
356{ assume(r != NULL); assume(r->cfGetUnit!=NULL); return r->cfGetUnit(n,r); }
357#endif
358
359/// a number representing i in the given coeff field/ring r
360static inline number n_Init(int i,       const coeffs r)
361{ assume(r != NULL); assume(r->cfInit!=NULL); return r->cfInit(i,r); }
362
363/// conversion of n to an int; 0 if not possible
364/// in Z/pZ: the representing int lying in (-p/2 .. p/2]
365static inline int n_Int(number &n,       const coeffs r)
366{ assume(r != NULL); assume(r->cfInt!=NULL); return r->cfInt(n,r); }
367
368/// in-place negation of n
369static inline number n_Neg(number n,     const coeffs r)
370{ assume(r != NULL); assume(r->cfNeg!=NULL); return r->cfNeg(n,r); }
371
372/// return the multiplicative inverse of 'a';
373/// raise an error if 'a' is not invertible
374///
375/// !!! Recommendation: rename to 'n_Inverse'
376static inline number n_Invers(number a,  const coeffs r)
377{ assume(r != NULL); assume(r->cfInvers!=NULL); return r->cfInvers(a,r); }
378
379/// return a non-negative measure for the complexity of n;
380/// return 0 only when n represents zero;
381/// (used for pivot strategies in matrix computations with entries from r)
382static inline int    n_Size(number n,    const coeffs r)
383{ assume(r != NULL); assume(r->cfSize!=NULL); return r->cfSize(n,r); }
384
385/// inplace-normalization of n;
386/// produces some canonical representation of n;
387///
388/// !!! Recommendation: remove this method from the user-interface, i.e.,
389/// !!!                 this should be hidden
390static inline void   n_Normalize(number& n, const coeffs r)
391{ assume(r != NULL); assume(r->cfNormalize!=NULL); r->cfNormalize(n,r); }
392
393/// write to the output buffer of the currently used reporter
394static inline void   n_Write(number& n,  const coeffs r)
395{ assume(r != NULL); assume(r->cfWrite!=NULL); r->cfWrite(n,r); }
396
397/// @todo: Describe me!!! --> Hans
398///
399/// !!! Recommendation: This method is to cryptic to be part of the user-
400/// !!!                 interface. As defined here, it is merely a helper
401/// !!!                 method for parsing number input strings.
402static inline const char *n_Read(const char * s, number * a, const coeffs r)
403{ assume(r != NULL); assume(r->cfRead!=NULL); return r->cfRead(s, a, r); }
404
405/// return the denominator of n
406/// (if elements of r are by nature not fractional, result is 1)
407static inline number n_GetDenom(number& n, const coeffs r)
408{ assume(r != NULL); assume(r->cfGetDenom!=NULL); return r->cfGetDenom(n, r); }
409
410/// return the numerator of n
411/// (if elements of r are by nature not fractional, result is n)
412static inline number n_GetNumerator(number& n, const coeffs r)
413{ assume(r != NULL); assume(r->cfGetNumerator!=NULL); return r->cfGetNumerator(n, r); }
414
415/// fill res with the power a^b
416static inline void   n_Power(number a, int b, number *res, const coeffs r)
417{ assume(r != NULL); assume(r->cfPower!=NULL); r->cfPower(a,b,res,r); }
418
419/// return the product of 'a' and 'b', i.e., a*b
420static inline number n_Mult(number a, number b, const coeffs r)
421{ assume(r != NULL); assume(r->cfMult!=NULL); return r->cfMult(a, b, r); }
422
423/// multiplication of 'a' and 'b';
424/// replacement of 'a' by the product a*b
425static inline void n_InpMult(number &a, number b, const coeffs r)
426{ assume(r != NULL); assume(r->cfInpMult!=NULL); r->cfInpMult(a,b,r); }
427
428/// return the difference of 'a' and 'b', i.e., a-b
429static inline number n_Sub(number a, number b, const coeffs r)
430{ assume(r != NULL); assume(r->cfSub!=NULL); return r->cfSub(a, b, r); }
431
432/// return the sum of 'a' and 'b', i.e., a+b
433static inline number n_Add(number a, number b, const coeffs r)
434{ assume(r != NULL); assume(r->cfAdd!=NULL); return r->cfAdd(a, b, r); }
435
436/// return the quotient of 'a' and 'b', i.e., a/b;
437/// raise an error if 'b' is not invertible in r
438static inline number n_Div(number a, number b, const coeffs r)
439{ assume(r != NULL); assume(r->cfDiv!=NULL); return r->cfDiv(a,b,r); }
440
441/// in Z: largest c such that c*b <= a
442/// in Z/nZ, Z/2^kZ: computed as in the case Z (from integers representing
443///                  'a' and 'b')
444/// in Z/pZ: return a/b
445/// in K(a)/<p(a)>: return a/b
446/// in K(t_1, ..., t_n): return a/b
447/// other fields: not implemented
448static inline number n_IntDiv(number a, number b, const coeffs r)
449{ assume(r != NULL); assume(r->cfIntDiv!=NULL); return r->cfIntDiv(a,b,r); }
450
451static inline number n_IntMod(number a, number b, const coeffs r)
452{ assume(r != NULL); assume(r->cfIntMod!=NULL); return r->cfIntMod(a,b,r); }
453/// @todo: Describe me!!!
454///
455/// What is the purpose of this method, especially in comparison with
456/// n_Div?
457/// !!! Recommendation: remove this method from the user-interface.
458static inline number n_ExactDiv(number a, number b, const coeffs r)
459{ assume(r != NULL); assume(r->cfExactDiv!=NULL); return r->cfExactDiv(a,b,r); }
460
461/// in Z: return the gcd of 'a' and 'b'
462/// in Z/nZ, Z/2^kZ: computed as in the case Z
463/// in Z/pZ, C, R: not implemented
464/// in Q: return the gcd of the numerators of 'a' and 'b'
465/// in K(a)/<p(a)>: not implemented
466/// in K(t_1, ..., t_n): not implemented
467static inline number n_Gcd(number a, number b, const coeffs r)
468{ assume(r != NULL); assume(r->cfGcd!=NULL); return r->cfGcd(a,b,r); }
469
470/// in Z: return the lcm of 'a' and 'b'
471/// in Z/nZ, Z/2^kZ: computed as in the case Z
472/// in Z/pZ, C, R: not implemented
473/// in Q: return the lcm of the numerators of 'a' and the denominator of 'b'
474/// in K(a)/<p(a)>: not implemented
475/// in K(t_1, ..., t_n): not implemented
476static inline number n_Lcm(number a, number b, const coeffs r)
477{ assume(r != NULL); assume(r->cfLcm!=NULL); return r->cfLcm(a,b,r); }
478
479/// set the mapping function pointers for translating numbers from src to dst
480static inline nMapFunc n_SetMap(const coeffs src, const coeffs dst)
481{ assume(src != NULL && dst != NULL); assume(dst->cfSetMap!=NULL); return dst->cfSetMap(src,dst); }
482
483/// test whether n is a correct number;
484/// only used if LDEBUG is defined
485static inline BOOLEAN n_DBTest(number n, const char *filename, const int linenumber, const coeffs r)
486{
487  assume(r != NULL); 
488#ifdef LDEBUG
489  assume(r->cfDBTest != NULL); 
490  return r->cfDBTest(n, filename, linenumber, r);
491#else
492  return TRUE;
493#endif
494}
495
496/// output the coeff description
497static inline void   n_CoeffWrite(const coeffs r)
498{ assume(r != NULL); assume(r->cfCoeffWrite != NULL); r->cfCoeffWrite(r); }
499
500// Tests:
501static inline BOOLEAN nCoeff_is_Ring_2toM(const coeffs r)
502{ assume(r != NULL); return (r->ringtype == 1); }
503
504static inline BOOLEAN nCoeff_is_Ring_ModN(const coeffs r)
505{ assume(r != NULL); return (r->ringtype == 2); }
506
507static inline BOOLEAN nCoeff_is_Ring_PtoM(const coeffs r)
508{ assume(r != NULL); return (r->ringtype == 3); }
509
510static inline BOOLEAN nCoeff_is_Ring_Z(const coeffs r)
511{ assume(r != NULL); return (r->ringtype == 4); }
512
513static inline BOOLEAN nCoeff_is_Ring(const coeffs r)
514{ assume(r != NULL); return (r->ringtype != 0); }
515
516/// returns TRUE, if r is not a field and r has no zero divisors (i.e is a domain)
517static inline BOOLEAN nCoeff_is_Domain(const coeffs r)
518{
519  assume(r != NULL); 
520#ifdef HAVE_RINGS
521  return (r->ringtype == 4 || r->ringtype == 0);
522#else
523  return TRUE;
524#endif
525}
526
527/// test whether 'a' is divisible 'b';
528/// for r encoding a field: TRUE iff 'b' does not represent zero
529/// in Z: TRUE iff 'b' divides 'a' (with remainder = zero)
530/// in Z/nZ: TRUE iff (a = 0 and b divides n in Z) or
531///                   (a != 0 and b/gcd(a, b) is co-prime with n, i.e.
532///                                              a unit in Z/nZ)
533/// in Z/2^kZ: TRUE iff ((a = 0 mod 2^k) and (b = 0 or b is a power of 2))
534///                  or ((a, b <> 0) and (b/gcd(a, b) is odd))
535static inline BOOLEAN n_DivBy(number a, number b, const coeffs r)
536{
537  assume(r != NULL);
538#ifdef HAVE_RINGS
539  if( nCoeff_is_Ring(r) )
540  {
541    assume(r->cfDivBy!=NULL); return r->cfDivBy(a,b,r);
542  }
543#endif
544  return !n_IsZero(b, r);
545}
546
547/// returns TRUE, if r is not a field and r has non-trivial units
548static inline BOOLEAN nCoeff_has_Units(const coeffs r)
549{ assume(r != NULL); return ((r->ringtype == 1) || (r->ringtype == 2) || (r->ringtype == 3)); }
550
551static inline BOOLEAN nCoeff_is_Zp(const coeffs r)
552{ assume(r != NULL); return getCoeffType(r)==n_Zp; }
553
554static inline BOOLEAN nCoeff_is_Zp(const coeffs r, int p)
555{ assume(r != NULL); return (getCoeffType(r)  && (r->ch == p)); }
556
557static inline BOOLEAN nCoeff_is_Q(const coeffs r)
558{ assume(r != NULL); return getCoeffType(r)==n_Q; }
559
560static inline BOOLEAN nCoeff_is_numeric(const coeffs r) /* R, long R, long C */
561{ assume(r != NULL);  return (getCoeffType(r)==n_R) || (getCoeffType(r)==n_long_R) || (getCoeffType(r)==n_long_C); }
562// (r->ringtype == 0) && (r->ch ==  -1); ??
563
564static inline BOOLEAN nCoeff_is_R(const coeffs r)
565{ assume(r != NULL); return getCoeffType(r)==n_R; }
566
567static inline BOOLEAN nCoeff_is_GF(const coeffs r)
568{ assume(r != NULL); return getCoeffType(r)==n_GF; }
569
570static inline BOOLEAN nCoeff_is_GF(const coeffs r, int q)
571{ assume(r != NULL); return (getCoeffType(r)==n_GF) && (r->ch == q); }
572
573/* TRUE iff r represents an algebraic or transcendental extension field */
574static inline BOOLEAN nCoeff_is_Extension(const coeffs r)
575{
576  assume(r != NULL);
577  return (getCoeffType(r)==n_algExt) || (getCoeffType(r)==n_transExt);
578}
579
580/* DO NOT USE (only kept for compatibility reasons towards the SINGULAR
581   svn trunk);
582   intension: should be TRUE iff the given r is an extension field above
583   some Z/pZ;
584   actually: TRUE iff the given r is an extension tower of arbitrary
585   height above some field of characteristic p (may be Z/pZ or some
586   Galois field of characteristic p) */
587static inline BOOLEAN nCoeff_is_Zp_a(const coeffs r)
588{
589  assume(r != NULL);
590  return ((r->ringtype == 0) && (r->ch != 0) && nCoeff_is_Extension(r));
591}
592
593/* DO NOT USE (only kept for compatibility reasons towards the SINGULAR
594   svn trunk);
595   intension: should be TRUE iff the given r is an extension field above
596   Z/pZ (with p as provided);
597   actually: TRUE iff the given r is an extension tower of arbitrary
598   height above some field of characteristic p (may be Z/pZ or some
599   Galois field of characteristic p) */
600static inline BOOLEAN nCoeff_is_Zp_a(const coeffs r, int p)
601{
602  assume(r != NULL);
603  return ((r->ringtype == 0) && (r->ch == p) && nCoeff_is_Extension(r));
604}
605
606/* DO NOT USE (only kept for compatibility reasons towards the SINGULAR
607   svn trunk);
608   intension: should be TRUE iff the given r is an extension field
609   above Q;
610   actually: TRUE iff the given r is an extension tower of arbitrary
611   height above some field of characteristic 0 (may be Q, R, or C) */
612static inline BOOLEAN nCoeff_is_Q_a(const coeffs r)
613{
614  assume(r != NULL);
615  return ((r->ringtype == 0) && (r->ch == 0) && nCoeff_is_Extension(r));
616}
617
618static inline BOOLEAN nCoeff_is_long_R(const coeffs r)
619{ assume(r != NULL); return getCoeffType(r)==n_long_R; }
620
621static inline BOOLEAN nCoeff_is_long_C(const coeffs r)
622{ assume(r != NULL); return getCoeffType(r)==n_long_C; }
623
624static inline BOOLEAN nCoeff_is_CF(const coeffs r)
625{ assume(r != NULL); return getCoeffType(r)==n_CF; }
626
627/// TRUE, if the computation of the inverse is fast,
628/// i.e. prefer leading coeff. 1 over content
629static inline BOOLEAN nCoeff_has_simple_inverse(const coeffs r)
630{ assume(r != NULL); return r->has_simple_Inverse; }
631
632/// TRUE if n_Delete/n_New are empty operations
633static inline BOOLEAN nCoeff_has_simple_Alloc(const coeffs r)
634{ assume(r != NULL); return r->has_simple_Alloc; }
635
636/// TRUE iff r represents an algebraic extension field
637static inline BOOLEAN nCoeff_is_algExt(const coeffs r)
638{ assume(r != NULL); return (getCoeffType(r)==n_algExt); }
639
640/// TRUE iff r represents a transcendental extension field
641static inline BOOLEAN nCoeff_is_transExt(const coeffs r)
642{ assume(r != NULL); return (getCoeffType(r)==n_transExt); }
643
644/// BOOLEAN n_Test(number a, const coeffs r)
645#define n_Test(a,r)  n_DBTest(a, __FILE__, __LINE__, r)
646
647// Missing wrappers for: (TODO: review this?)
648// cfIntMod, cfRePart, cfImPart, cfRead, cfName, cfInit_bigint
649// HAVE_RINGS: cfDivComp, cfExtGcd...
650
651// Deprecated:
652static inline int n_GetChar(const coeffs r)
653{ assume(r != NULL); return nInternalChar(r); }
654
655#endif
656
Note: See TracBrowser for help on using the repository browser.