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;
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:
146
147 /// output of coeff description via Print
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
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)
205
206 /// print a given number in a shorter way, if possible
207 /// e.g. in K(a): a2 instead of a^2
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
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);
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);
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
257 //in a Euclidean ring, return the Euclidean norm as a bigint (of type number)
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
270 number (*cfLcm)(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
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.
298
299 /// degree for coeffcients: -1 for 0, 0 for "constants", ...
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
307
308 /// function pointer behind n_ClearContent
310
311 /// function pointer behind n_ClearDenominators
313
314 /// conversion to CanonicalForm(factory) to number
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//-------------------------------------------
380 /// test if b divides a
381 /// cfDivBy(zero,b,r) is true, if b is a zero divisor
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. */
403 unsigned long modExponent;
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
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'
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
458{ assume(r != NULL); assume(r->cfEqual!=NULL); return r->cfEqual(a, b, r); }
459
460/// TRUE iff 'n' represents the zero element
462{ assume(r != NULL); assume(r->cfIsZero!=NULL); return r->cfIsZero(n,r); }
463
464/// TRUE iff 'n' represents the one element
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
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///
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
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
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
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...
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
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)
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'
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)
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)
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
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.
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
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
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
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
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
662{ assume(r != NULL); assume(r->cfGcd!=NULL); return r->cfGcd(a,b,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...
669{ assume(r != NULL); assume(r->cfExtGcd!=NULL); return r->cfExtGcd (a,b,s,t,r); }
671{ assume(r != NULL); assume(r->cfXExtGcd!=NULL); return r->cfXExtGcd (a,b,s,t,u,v,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
677{ assume(r != NULL); return r->cfAnn (a,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
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)
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
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
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))
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
762{ assume(r != NULL); assume(r->cfChineseRemainder != NULL); return r->cfChineseRemainder(a,b,rl,sym,inv_cache,r); }
763
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);
783 assume(r->cfParameter != NULL);
784 return r->cfParameter(iParameter, r);
785}
786
788{ assume(cf != NULL); assume(cf->cfRePart!=NULL); return cf->cfRePart(i,cf); }
789
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
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
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
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
943
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
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
976{ assume(r != NULL); assume(r->convFactoryNSingN != NULL); return r->convFactoryNSingN(n, r); }
977
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); }
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:4083
int p
Definition cfModGcd.cc:4079
CanonicalForm cf
Definition cfModGcd.cc:4084
CanonicalForm b
Definition cfModGcd.cc:4104
FILE * f
Definition checklibs.c:9
factory's main class
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
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
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