My Project
Loading...
Searching...
No Matches
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
24class 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
51extern const unsigned short fftable[];
52
53struct snumber;
54typedef 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///
66struct n_Procs_s;
67typedef struct n_Procs_s *coeffs;
68typedef struct n_Procs_s const * const_coeffs;
69
70typedef number (*numberfunc)(number a, number b, const coeffs r);
71
72/// maps "a", which lives in src, into dst
73typedef 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;
82typedef 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
92typedef struct
93{
94 int GFChar;
96 const char* GFPar_name;
97} GFInfo;
98
99typedef 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 */
121
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: */
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
427coeffs 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
434void nKillChar(coeffs r);
435
436/// initialisations after each ring change
437static 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.
441static 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'
448static 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'
452static 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
457static 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
461static 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
465static 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
469static 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///
491static 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
508static 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
512static FORCE_INLINE BOOLEAN n_IsUnit(number n, const coeffs r)
513{ assume(r != NULL); assume(r->cfIsUnit!=NULL); return r->cfIsUnit(n,r); }
514
516{ assume(r != NULL); assume(r->cfQuot1 != NULL); return r->cfQuot1(c, r); }
517
518#ifdef HAVE_RINGS
519static 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...
529static 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
535static 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
539static 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]
544static 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
548static 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)
554static 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'
561static 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)
567static 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
575static 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
580static 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
585static FORCE_INLINE void n_WriteShort(number n, const coeffs r)
586{ assume(r != NULL); assume(r->cfWriteShort!=NULL); r->cfWriteShort(n,r); }
587
588static 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.
595static 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)
600static 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)
605static 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
612static 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.
619static 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
625static 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
629static 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
633static 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
638static 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
643static 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
647static 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
652static 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
661static 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); }
663static 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...
668static 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); }
670static 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); }
672static 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
676static FORCE_INLINE number n_Ann(number a, const coeffs r)
677{ assume(r != NULL); return r->cfAnn (a,r); }
678static 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
687static 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)
692static 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
695number ndCopyMap(number a, const coeffs src, const coeffs dst);
696/// set the mapping function pointers for translating numbers from src to dst
697static 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
706static 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
716static 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))
750static 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
761static 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
764static 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
767static 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
775static 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(...)
780static 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
787static FORCE_INLINE number n_RePart(number i, const coeffs cf)
788{ assume(cf != NULL); assume(cf->cfRePart!=NULL); return cf->cfRePart(i,cf); }
789
790static 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
829static 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
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
925static 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
932static 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
941static FORCE_INLINE void n_ClearContent(ICoeffsEnumerator& numberCollectionEnumerator, const coeffs r)
942{ number c; n_ClearContent(numberCollectionEnumerator, c, r); n_Delete(&c, r); }
943
944static 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
950void 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
956static FORCE_INLINE char * nCoeffString(const coeffs cf)
957{ assume( cf != NULL ); return cf->cfCoeffString(cf); }
958
959
960static FORCE_INLINE char * nCoeffName (const coeffs cf)
961{ assume( cf != NULL ); return cf->cfCoeffName(cf); }
962
963static 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:
967static 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:
971static 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
975static 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
978static 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:
984static FORCE_INLINE void number2mpz(number n, coeffs c, mpz_t m){ n_MPZ(m, n, c); }
985static 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 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
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,... ZZ/pn, R, long_R
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 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 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
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 char const ** n_ParameterNames(const coeffs r)
Returns a (const!) pointer to (const char*) names of parameters.
Definition: coeffs.h:775
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 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 char * nCoeffName(const coeffs cf)
Definition: coeffs.h:960
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 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
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