source: git/libpolys/coeffs/coeffs.h @ 06df101

spielwiese
Last change on this file since 06df101 was 6ccdd3a, checked in by Frank Seelisch <seelisch@…>, 13 years ago
renamed algring; comments; transext.* added
  • Property mode set to 100644
File size: 19.8 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   number  (*cfPar)(int i, const coeffs r);
112   int     (*cfParDeg)(number n, const coeffs r);
113   /// how complicated, (0) => 0, or positive
114   int     (*cfSize)(number n, const coeffs r);
115   /// convertion, 0 if impossible
116   int     (*cfInt)(number &n, const coeffs r);
117
118#ifdef HAVE_RINGS
119   int     (*cfDivComp)(number a,number b,const coeffs r);
120   BOOLEAN (*cfIsUnit)(number a,const coeffs r);
121   number  (*cfGetUnit)(number a,const coeffs r);
122   number  (*cfExtGcd)(number a, number b, number *s, number *t,const coeffs r);
123#endif
124
125   /// changes argument  inline: a:= -a
126   number  (*cfNeg)(number a, const coeffs r);
127   /// return 1/a
128   number  (*cfInvers)(number a, const coeffs r);
129   /// return a copy of a
130   number  (*cfCopy)(number a, const coeffs r);
131   number  (*cfRePart)(number a, const coeffs r);
132   number  (*cfImPart)(number a, const coeffs r);
133   void    (*cfWrite)(number &a, const coeffs r);
134   const char *  (*cfRead)(const char * s, number * a, const coeffs r);
135   void    (*cfNormalize)(number &a, const coeffs r);
136   BOOLEAN (*cfGreater)(number a,number b, const coeffs r),
137#ifdef HAVE_RINGS
138           (*cfDivBy)(number a, number b, const coeffs r),
139#endif
140            /// tests
141           (*cfEqual)(number a,number b, const coeffs r),
142           (*cfIsZero)(number a, const coeffs r),
143           (*cfIsOne)(number a, const coeffs r),
144           (*cfIsMOne)(number a, const coeffs r),
145           (*cfGreaterZero)(number a, const coeffs r);
146
147   void    (*cfPower)(number a, int i, number * result, const coeffs r);
148   number  (*cfGetDenom)(number &n, const coeffs r);
149   number  (*cfGetNumerator)(number &n, const coeffs r);
150   number  (*cfGcd)(number a, number b, const coeffs r);
151   number  (*cfLcm)(number a, number b, const coeffs r);
152   void    (*cfDelete)(number * a, const coeffs r);
153   nMapFunc (*cfSetMap)(const coeffs src, const coeffs dst);
154
155   /// For extensions (writes into global string buffer)
156   char *  (*cfName)(number n, const coeffs r);
157
158   /// Inplace: a *= b
159   void    (*cfInpMult)(number &a, number b, const coeffs r);
160   /// maps the bigint i (from dummy) into the coeffs dst
161   number  (*cfInit_bigint)(number i, const coeffs dummy, const coeffs dst);
162
163#ifdef HAVE_FACTORY
164   number (*convFactoryNSingN)( const CanonicalForm n, const coeffs r);
165   CanonicalForm (*convSingNFactoryN)( number n, BOOLEAN setChar, const coeffs r );
166#endif
167
168
169#ifdef LDEBUG
170   /// Test: is "a" a correct number?
171   BOOLEAN (*cfDBTest)(number a, const char *f, const int l, const coeffs r);
172#endif
173
174   number nNULL; /* the 0 as constant */
175   int     char_flag;
176   int     ref;
177   n_coeffType type;
178//-------------------------------------------
179
180  /* for extension fields we need to be able to represent polynomials,
181     so here is the polynomial ring: */
182  ring          extRing;
183
184  //number     minpoly;  //< no longer needed: replaced by
185  //                     //< extRing->minideal->[0]
186
187
188//-------------------------------------------
189  char* complex_parameter; //< the name of sqrt(-1), i.e. 'i' or 'j' etc...?
190
191#ifdef HAVE_RINGS
192  /* The following members are for representing the ring Z/n,
193     where n is not a prime. We distinguish four cases:
194     1.) n has at least two distinct prime factors. Then
195         modBase stores n, modExponent stores 1, modNumber
196         stores n, and mod2mMask is not used;
197     2.) n = p^k for some odd prime p and k > 1. Then
198         modBase stores p, modExponent stores k, modNumber
199         stores n, and mod2mMask is not used;
200     3.) n = 2^k for some k > 1; moreover, 2^k - 1 fits in
201         an unsigned long. Then modBase stores 2, modExponent
202         stores k, modNumber is not used, and mod2mMask stores
203         2^k - 1, i.e., the bit mask '111..1' of length k.
204     4.) n = 2^k for some k > 1; but 2^k - 1 does not fit in
205         an unsigned long. Then modBase stores 2, modExponent
206         stores k, modNumber stores n, and mod2mMask is not
207         used;
208     Cases 1.), 2.), and 4.) are covered by the implementation
209     in the files rmodulon.h and rmodulon.cc, whereas case 3.)
210     is implemented in the files rmodulo2m.h and rmodulo2m.cc. */
211  int_number    modBase;
212  unsigned long modExponent;
213  int_number    modNumber;
214  unsigned long mod2mMask;
215#endif
216  int        ch;  /* characteristic, set by the local *InitChar methods;
217                     In field extensions or extensions towers, the
218                     characteristic can be accessed from any of the
219                     intermediate extension fields, i.e., in this case
220                     it is redundant along the chain of field extensions;
221                     CONTRARY to SINGULAR as it was, we do NO LONGER use
222                     negative values for ch;
223                     for rings, ch will also be set and is - per def -
224                     the smallest number of 1's that sum up to zero;
225                     however, in this case ch may not fit in an int,
226                     thus ch may contain a faulty value */
227
228  short      float_len; /* additional char-flags, rInit */
229  short      float_len2; /* additional char-flags, rInit */
230
231  BOOLEAN   ShortOut; /// ffields need this.
232
233// ---------------------------------------------------
234  // for n_GF
235
236  int m_nfCharQ;  ///< the number of elements: q
237  int m_nfM1;       ///< representation of -1
238  int m_nfCharP;  ///< the characteristic: p
239  int m_nfCharQ1; ///< q-1
240  unsigned short *m_nfPlus1Table;
241  int *m_nfMinPoly;
242  char * m_nfParameter;
243};
244//
245// test properties and type
246/// Returns the type of coeffs domain
247static inline n_coeffType getCoeffType(const coeffs r)
248{
249  assume(r != NULL);
250  return r->type;
251}
252
253static inline int nInternalChar(const coeffs r)
254{
255  assume(r != NULL);
256  return r->ch;
257}
258
259/// one-time initialisations for new coeffs
260/// in case of an error return NULL
261coeffs nInitChar(n_coeffType t, void * parameter);
262
263/// undo all initialisations
264void nKillChar(coeffs r);
265
266/// initialisations after each ring change
267static inline void nSetChar(const coeffs r)
268{
269  assume(r!=NULL); // r==NULL is an error
270  if (r->cfSetChar!=NULL) r->cfSetChar(r);
271}
272
273void           nNew(number * a);
274#define n_New(n, r)           nNew(n)
275
276
277// the access methods (part 2):
278
279/// return a copy of a
280static inline number n_Copy(number n,    const coeffs r)
281{   assume(r != NULL); assume(r->cfCopy!=NULL); return r->cfCopy(n, r); }
282
283static inline void   n_Delete(number* p, const coeffs r)
284{   assume(r != NULL); assume(r->cfDelete!= NULL); r->cfDelete(p, r); }
285
286static inline BOOLEAN n_Equal(number a, number b, const coeffs r)
287{ assume(r != NULL); assume(r->cfEqual!=NULL); return r->cfEqual(a, b, r); }
288
289static inline BOOLEAN n_IsZero(number n, const coeffs r)
290{ assume(r != NULL); assume(r->cfIsZero!=NULL); return r->cfIsZero(n,r); }
291
292static inline BOOLEAN n_IsOne(number n,  const coeffs r)
293{ assume(r != NULL); assume(r->cfIsOne!=NULL); return r->cfIsOne(n,r); }
294
295static inline BOOLEAN n_IsMOne(number n, const coeffs r)
296{ assume(r != NULL); assume(r->cfIsMOne!=NULL); return r->cfIsMOne(n,r); }
297
298static inline BOOLEAN n_GreaterZero(number n, const coeffs r)
299{ assume(r != NULL); assume(r->cfGreaterZero!=NULL); return r->cfGreaterZero(n,r); }
300static inline BOOLEAN n_Greater(number a, number b, const coeffs r)
301{ assume(r != NULL); assume(r->cfGreater!=NULL); return r->cfGreater(a,b,r); }
302
303#ifdef HAVE_RINGS
304static inline BOOLEAN n_IsUnit(number n, const coeffs r)
305{ assume(r != NULL); assume(r->cfIsUnit!=NULL); return r->cfIsUnit(n,r); }
306
307static inline number n_GetUnit(number n, const coeffs r)
308{ assume(r != NULL); assume(r->cfGetUnit!=NULL); return r->cfGetUnit(n,r); }
309
310static inline BOOLEAN n_DivBy(number a, number b, const coeffs r)
311{ assume(r != NULL); assume(r->cfDivBy!=NULL); return r->cfDivBy(a,b,r); }
312#endif
313
314/// init with an integer
315static inline number n_Init(int i,       const coeffs r)
316{ assume(r != NULL); assume(r->cfInit!=NULL); return r->cfInit(i,r); }
317
318/// conversion to int; 0 if not possible
319static inline int n_Int(number n,        const coeffs r)
320{ assume(r != NULL); assume(r->cfInt!=NULL); return r->cfInt(n,r); }
321
322/// changes argument  inline: a:= -a
323static inline number n_Neg(number n,     const coeffs r)
324{ assume(r != NULL); assume(r->cfNeg!=NULL); return r->cfNeg(n,r); }
325
326/// return 1/a
327static inline number n_Invers(number a,  const coeffs r)
328{ assume(r != NULL); assume(r->cfInvers!=NULL); return r->cfInvers(a,r); }
329
330/// use for pivot strategies, (0) => 0, otherwise positive
331static inline int    n_Size(number n,    const coeffs r)
332{ assume(r != NULL); assume(r->cfSize!=NULL); return r->cfSize(n,r); }
333
334/// normalize the number. i.e. go to some canonnical representation (inplace)
335static inline void   n_Normalize(number& n, const coeffs r)
336{ assume(r != NULL); assume(r->cfNormalize!=NULL); r->cfNormalize(n,r); }
337
338/// Normalize and Write to the output buffer of reporter
339static inline void   n_Write(number& n,  const coeffs r)
340{ assume(r != NULL); assume(r->cfWrite!=NULL); r->cfWrite(n,r); }
341
342/// Normalize and get denomerator
343static inline number n_GetDenom(number& n, const coeffs r)
344{ assume(r != NULL); assume(r->cfGetDenom!=NULL); return r->cfGetDenom(n, r); }
345
346/// Normalize and get numerator
347static inline number n_GetNumerator(number& n, const coeffs r)
348{ assume(r != NULL); assume(r->cfGetNumerator!=NULL); return r->cfGetNumerator(n, r); }
349
350static inline void   n_Power(number a, int b, number *res, const coeffs r)
351{ assume(r != NULL); assume(r->cfPower!=NULL); r->cfPower(a,b,res,r); }
352
353static inline number n_Mult(number a, number b, const coeffs r)
354{ assume(r != NULL); assume(r->cfMult!=NULL); return r->cfMult(a, b, r); }
355
356/// Inplace multiplication: a := a * b
357static inline void n_InpMult(number &a, number b, const coeffs r)
358{ assume(r != NULL); assume(r->cfInpMult!=NULL); r->cfInpMult(a,b,r); }
359
360static inline number n_Sub(number a, number b, const coeffs r)
361{ assume(r != NULL); assume(r->cfSub!=NULL); return r->cfSub(a, b, r); }
362
363static inline number n_Add(number a, number b, const coeffs r)
364{ assume(r != NULL); assume(r->cfAdd!=NULL); return r->cfAdd(a, b, r); }
365
366static inline number n_Div(number a, number b, const coeffs r)
367{ assume(r != NULL); assume(r->cfDiv!=NULL); return r->cfDiv(a,b,r); }
368
369static inline number n_IntDiv(number a, number b, const coeffs r)
370{ assume(r != NULL); assume(r->cfIntDiv!=NULL); return r->cfIntDiv(a,b,r); }
371
372static inline number n_ExactDiv(number a, number b, const coeffs r)
373{ assume(r != NULL); assume(r->cfExactDiv!=NULL); return r->cfExactDiv(a,b,r); }
374
375static inline number n_Gcd(number a, number b, const coeffs r)
376{ assume(r != NULL); assume(r->cfGcd!=NULL); return r->cfGcd(a,b,r); }
377
378static inline number n_Lcm(number a, number b, const coeffs r)
379{ assume(r != NULL); assume(r->cfLcm!=NULL); return r->cfLcm(a,b,r); }
380
381static inline nMapFunc n_SetMap(const coeffs src, const coeffs dst)
382{ assume(src != NULL && dst != NULL); assume(dst->cfSetMap!=NULL); return dst->cfSetMap(src,dst); }
383
384static inline number n_Par(int n, const coeffs r)
385{ assume(r != NULL); assume(r->cfPar!=NULL); return r->cfPar(n,r); }
386
387static inline int n_ParDeg(number n, const coeffs r)
388{ assume(r != NULL); assume(r->cfParDeg!=NULL); return r->cfParDeg(n,r); }
389
390/// Tests whether n is a correct number: only used if LDEBUG is defined
391static inline BOOLEAN n_DBTest(number n, const char *filename, const int linenumber, const coeffs r)
392{
393  assume(r != NULL); 
394#ifdef LDEBUG
395  assume(r->cfDBTest != NULL); 
396  return r->cfDBTest(n, filename, linenumber, r);
397#else
398  return TRUE;
399#endif
400}
401
402/// output the coeff description
403static inline void   n_CoeffWrite(const coeffs r)
404{ assume(r != NULL); assume(r->cfCoeffWrite != NULL); r->cfCoeffWrite(r); }
405
406// Tests:
407static inline BOOLEAN nCoeff_is_Ring_2toM(const coeffs r)
408{ assume(r != NULL); return (r->ringtype == 1); }
409
410static inline BOOLEAN nCoeff_is_Ring_ModN(const coeffs r)
411{ assume(r != NULL); return (r->ringtype == 2); }
412
413static inline BOOLEAN nCoeff_is_Ring_PtoM(const coeffs r)
414{ assume(r != NULL); return (r->ringtype == 3); }
415
416static inline BOOLEAN nCoeff_is_Ring_Z(const coeffs r)
417{ assume(r != NULL); return (r->ringtype == 4); }
418
419static inline BOOLEAN nCoeff_is_Ring(const coeffs r)
420{ assume(r != NULL); return (r->ringtype != 0); }
421
422/// returns TRUE, if r is not a field and r has no zero divisors (i.e is a domain)
423static inline BOOLEAN nCoeff_is_Domain(const coeffs r)
424{
425  assume(r != NULL); 
426#ifdef HAVE_RINGS
427  return (r->ringtype == 4 || r->ringtype == 0);
428#else
429  return TRUE;
430#endif
431}
432
433/// returns TRUE, if r is not a field and r has non-trivial units
434static inline BOOLEAN nCoeff_has_Units(const coeffs r)
435{ assume(r != NULL); return ((r->ringtype == 1) || (r->ringtype == 2) || (r->ringtype == 3)); }
436
437static inline BOOLEAN nCoeff_is_Zp(const coeffs r)
438{ assume(r != NULL); return getCoeffType(r)==n_Zp; }
439
440static inline BOOLEAN nCoeff_is_Zp(const coeffs r, int p)
441{ assume(r != NULL); return (getCoeffType(r)  && (r->ch == p)); }
442
443static inline BOOLEAN nCoeff_is_Q(const coeffs r)
444{ assume(r != NULL); return getCoeffType(r)==n_Q; }
445
446static inline BOOLEAN nCoeff_is_numeric(const coeffs r) /* R, long R, long C */
447{ assume(r != NULL);  return (getCoeffType(r)==n_R) || (getCoeffType(r)==n_long_R) || (getCoeffType(r)==n_long_C); }
448// (r->ringtype == 0) && (r->ch ==  -1); ??
449
450static inline BOOLEAN nCoeff_is_R(const coeffs r)
451{ assume(r != NULL); return getCoeffType(r)==n_R; }
452
453static inline BOOLEAN nCoeff_is_GF(const coeffs r)
454{ assume(r != NULL); return getCoeffType(r)==n_GF; }
455
456static inline BOOLEAN nCoeff_is_GF(const coeffs r, int q)
457{ assume(r != NULL); return (getCoeffType(r)==n_GF) && (r->ch == q); }
458
459/* TRUE iff r represents an algebraic or transcendental extension field */
460static inline BOOLEAN nCoeff_is_Extension(const coeffs r)
461{
462  assume(r != NULL);
463  return (getCoeffType(r)==n_algExt) || (getCoeffType(r)==n_transExt);
464}
465
466/* DO NOT USE (only kept for compatibility reasons towards the SINGULAR
467   svn trunk);
468   intension: should be TRUE iff the given r is an extension field above
469   some Z/pZ;
470   actually: TRUE iff the given r is an extension tower of arbitrary
471   height above some field of characteristic p (may be Z/pZ or some
472   Galois field of characteristic p) */
473static inline BOOLEAN nCoeff_is_Zp_a(const coeffs r)
474{
475  assume(r != NULL);
476  return ((r->ringtype == 0) && (r->ch != 0) && nCoeff_is_Extension(r));
477}
478
479/* DO NOT USE (only kept for compatibility reasons towards the SINGULAR
480   svn trunk);
481   intension: should be TRUE iff the given r is an extension field above
482   Z/pZ (with p as provided);
483   actually: TRUE iff the given r is an extension tower of arbitrary
484   height above some field of characteristic p (may be Z/pZ or some
485   Galois field of characteristic p) */
486static inline BOOLEAN nCoeff_is_Zp_a(const coeffs r, int p)
487{
488  assume(r != NULL);
489  return ((r->ringtype == 0) && (r->ch == p) && nCoeff_is_Extension(r));
490}
491
492/* DO NOT USE (only kept for compatibility reasons towards the SINGULAR
493   svn trunk);
494   intension: should be TRUE iff the given r is an extension field
495   above Q;
496   actually: TRUE iff the given r is an extension tower of arbitrary
497   height above some field of characteristic 0 (may be Q, R, or C) */
498static inline BOOLEAN nCoeff_is_Q_a(const coeffs r)
499{
500  assume(r != NULL);
501  return ((r->ringtype == 0) && (r->ch == 0) && nCoeff_is_Extension(r));
502}
503
504static inline BOOLEAN nCoeff_is_long_R(const coeffs r)
505{ assume(r != NULL); return getCoeffType(r)==n_long_R; }
506
507static inline BOOLEAN nCoeff_is_long_C(const coeffs r)
508{ assume(r != NULL); return getCoeffType(r)==n_long_C; }
509
510static inline BOOLEAN nCoeff_is_CF(const coeffs r)
511{ assume(r != NULL); return getCoeffType(r)==n_CF; }
512
513/// TRUE, if the computation of the inverse is fast (i.e. prefer leading coeff. 1 over content)
514static inline BOOLEAN nCoeff_has_simple_inverse(const coeffs r)
515{ assume(r != NULL); return r->has_simple_Inverse; }
516/* Z/2^n, Z/p, GF(p,n), R, long_R, long_C*/
517// /* { return (r->ch>1) || (r->ch== -1); } *//* Z/p, GF(p,n), R, long_R, long_C*/
518// #ifdef HAVE_RINGS
519// { return (r->ringtype > 0) || (r->ch>1) || ((r->ch== -1) && (r->float_len < 10)); } /* Z/2^n, Z/p, GF(p,n), R, long_R, long_C*/
520// #else
521// { return (r->ch>1) || ((r->ch== -1) && (r->float_len < 10)); } /* Z/p, GF(p,n), R, long_R, long_C*/
522// #endif
523
524/// TRUE if n_Delete/n_New are empty operations
525static inline BOOLEAN nCoeff_has_simple_Alloc(const coeffs r)
526{ assume(r != NULL); return r->has_simple_Alloc; }
527/* Z/p, GF(p,n), R, Ring_2toM: nCopy, nNew, nDelete are dummies*/
528// return (rField_is_Zp(r)
529//         || rField_is_GF(r)
530// #ifdef HAVE_RINGS
531//             || rField_is_Ring_2toM(r)
532// #endif
533//             || rField_is_R(r)); }
534
535/* TRUE iff r represents an algebraic extension field */
536static inline BOOLEAN nCoeff_is_algExt(const coeffs r)
537{ assume(r != NULL); return (getCoeffType(r)==n_algExt); }
538
539/* TRUE iff r represents a transcendental extension field */
540static inline BOOLEAN nCoeff_is_transExt(const coeffs r)
541{ assume(r != NULL); return (getCoeffType(r)==n_transExt); }
542
543/// BOOLEAN n_Test(number a, const coeffs r)
544#define n_Test(a,r)  n_DBTest(a, __FILE__, __LINE__, r)
545
546// Missing wrappers for:
547// cfIntMod, cfRePart, cfImPart, cfRead, cfName, cfInit_bigint
548// HAVE_RINGS: cfDivComp, cfExtGcd... cfDivBy
549
550
551// Deprecated:
552static inline int n_GetChar(const coeffs r)
553{ assume(r != NULL); return nInternalChar(r); }
554
555#endif
556
Note: See TracBrowser for help on using the repository browser.