22 #ifdef HAVE_COEF_BUCKETS 23 #define USE_COEF_BUCKETS 26 #ifdef USE_COEF_BUCKETS 28 #define MULTIPLY_BUCKET(B,I) do \ 29 { if (B->coef[I]!=NULL) \ 31 assume(p_IsConstant(B->Coef[i],B->bucket->ring)); \ 32 B->buckets[I]=p_Mult_q(B->buckets[I],B->coef[I],B->bucket_ring); \ 36 if (rField_is_Ring(B->bucket_ring)) B->buckets_length[i] = pLength(B->buckets[i]); 38 #define MULTIPLY_BUCKET(B,I) do \ 39 { if (B->coef[I]!=NULL) \ 41 B->buckets[I]=p_Mult_q(B->buckets[I],B->coef[I],B->bucket_ring); \ 47 #define MULTIPLY_BUCKET(B,I) 50 #ifdef USE_COEF_BUCKETS 51 static int coef_start=1;
65 #ifdef BUCKET_TWO_BASE 66 while ((l = (l >> 1))) i++;
68 while ((l = (l >> 2))) i++;
81 #ifndef HAVE_PSEUDO_BUCKETS 84 #ifdef USE_COEF_BUCKETS 86 if ((bucket->coef[i]!=
NULL) && (bucket->buckets[i]==
NULL))
90 if (bucket->coef[i]!=
NULL)
97 if (bucket->buckets_length[i] !=
pLength(bucket->buckets[i]))
99 dReportError(
"Bucket %d lengths difference should:%d has:%d",
100 i, bucket->buckets_length[i],
pLength(bucket->buckets[i]));
102 else if (i > 0 && (
int)
pLogLength(bucket->buckets_length[i]) > i)
105 i, bucket->buckets_length[i]);
107 if (i==0 && bucket->buckets_length[0] > 1)
117 #ifdef HAVE_COEF_BUCKETS 121 poly lm = bucket->buckets[0];
125 if (! kbTest_i(bucket, 0))
return FALSE;
126 for (i=1; i<= (int) bucket->buckets_used; i++)
128 if (!kbTest_i(bucket, i))
return FALSE;
129 if (lm !=
NULL && bucket->buckets[i] !=
NULL 146 if (bucket->buckets[i] !=
NULL || bucket->buckets_length[i] != 0)
154 if (bucket->buckets[i]!=
NULL)
159 if (bucket->buckets[j]==bucket->buckets[i])
166 #ifdef HAVE_COEF_BUCKETS 167 if (bucket->coef[i]!=
NULL)
172 if (bucket->coef[j]==bucket->coef[i])
184 #else // HAVE_PSEUDO_BUCKETS 189 #endif // ! HAVE_PSEUDO_BUCKETS 216 for (i=0; i<= bucket->buckets_used; i++)
219 if (bucket->buckets[i] !=
NULL)
222 #ifdef USE_COEF_BUCKETS 223 if (bucket->coef[i]!=
NULL)
235 #ifndef HAVE_PSEUDO_BUCKETS 240 if (bucket->buckets[0] !=
NULL)
242 poly lm = bucket->buckets[0];
244 #ifdef BUCKET_TWO_BASE 246 while ( bucket->buckets_length[i] >= l)
253 while ( bucket->buckets_length[i] >= l)
259 #ifndef USE_COEF_BUCKETS 261 pNext(lm) = bucket->buckets[
i];
262 bucket->buckets[
i] = lm;
263 bucket->buckets_length[
i]++;
264 assume(i <= bucket->buckets_used+1);
265 if (i > bucket->buckets_used) bucket->buckets_used =
i;
266 bucket->buckets[0] =
NULL;
267 bucket->buckets_length[0] = 0;
270 if (i > bucket->buckets_used) bucket->buckets_used =
i;
272 if (bucket->buckets[i]!=
NULL)
275 pNext(lm) = bucket->buckets[
i];
276 bucket->buckets[
i] = lm;
277 bucket->buckets_length[
i]++;
278 assume(i <= bucket->buckets_used+1);
290 bucket->buckets[
i]=lm;
291 bucket->buckets_length[
i]=1;
294 bucket->buckets[
i]=lm;
295 bucket->buckets_length[
i]=1;
298 pNext(lm) = bucket->buckets[
i];
299 bucket->buckets[
i] = lm;
300 bucket->buckets_length[
i]++;
301 assume(i <= bucket->buckets_used+1);
304 bucket->buckets[0]=
NULL;
305 bucket->buckets_length[0] = 0;
306 bucket->coef[0]=
NULL;
319 if (bucket->buckets[i] !=
NULL)
return FALSE;
320 #ifdef HAVE_COEF_BUCKETS 321 if (bucket->coef[i] !=
NULL)
return FALSE;
323 if (bucket->buckets_length[i] != 0)
return FALSE;
335 if (lm ==
NULL)
return;
340 bucket->buckets[0] = lm;
341 #ifdef HAVE_COEF_BUCKETS 344 #ifdef USE_COEF_BUCKETS 345 bucket->coef[0]=
NULL;
348 bucket->buckets_length[0] = 1;
350 bucket->buckets_length[0]= 0;
354 bucket->buckets[
i] =
pNext(lm);
356 bucket->buckets_length[
i] = length-1;
357 bucket->buckets_used =
i;
361 bucket->buckets_used = 0;
370 poly p = bucket->buckets[1];
372 int pl = bucket->buckets_length[1];
374 bucket->buckets[1] =
NULL;
375 bucket->buckets_length[1] = 0;
376 #ifdef USE_COEF_BUCKETS 382 for (i=1; i<=bucket->buckets_used; i++)
384 #ifdef USE_COEF_BUCKETS 385 if (bucket->coef[i]!=
NULL)
389 pl, bucket->buckets_length[i], r);
394 p =
p_Add_q(p, bucket->buckets[i],
395 pl, bucket->buckets_length[i], r);
397 p =
p_Add_q(p, bucket->buckets[i],
398 pl, bucket->buckets_length[i], r);
401 bucket->buckets[
i] =
NULL;
402 bucket->buckets_length[
i] = 0;
404 #ifdef HAVE_COEF_BUCKETS 407 lm = bucket->buckets[0];
413 bucket->buckets[0] =
NULL;
414 bucket->buckets_length[0] = 0;
419 bucket->buckets[
i] =
p;
420 bucket->buckets_length[
i] = pl;
426 bucket->buckets_used =
i;
428 #ifdef USE_COEF_BUCKETS 443 #ifdef USE_COEF_BUCKETS 447 *p = bucket->buckets[
i];
448 *length = bucket->buckets_length[
i];
449 bucket->buckets[
i] =
NULL;
450 bucket->buckets_length[
i] = 0;
451 bucket->buckets_used = 0;
463 kBucketMergeLm(bucket);
465 bucket->buckets[0] = lm;
466 bucket->buckets_length[0] = 1;
469 #else // HAVE_PSEUDO_BUCKETS 479 if (length <= 0) bucket->
l =
pLength(lm);
480 else bucket->
l = length;
508 #endif // ! HAVE_PSEUDO_BUCKETS 514 ring new_tailRing,
omBin new_tailBin,
517 #ifndef HAVE_PSEUDO_BUCKETS 521 for (i=0; i<= bucket->buckets_used; i++)
522 if (bucket->buckets[i] !=
NULL)
525 bucket->buckets[
i] = p_shallow_copy_delete(bucket->buckets[i],
531 bucket->
p = p_shallow_copy_delete(p,
547 int l1 = bucket->buckets_length[
i];
548 poly p1 = bucket->buckets[
i];
549 bucket->buckets[
i] =
NULL;
550 bucket->buckets_length[
i] = 0;
553 while (bucket->buckets[i] !=
NULL)
557 p1 =
p_Add_q(p1, bucket->buckets[i],
558 l1, bucket->buckets_length[i], bucket->
bucket_ring);
559 bucket->buckets[
i] =
NULL;
560 bucket->buckets_length[
i] = 0;
564 bucket->buckets[
i] = p1;
565 bucket->buckets_length[
i]=l1;
566 if (i >= bucket->buckets_used)
567 bucket->buckets_used =
i;
569 kBucketAdjustBucketsUsed(bucket);
578 #ifndef HAVE_PSEUDO_BUCKETS 583 for (i=0; i<= bucket->buckets_used; i++)
585 if (bucket->buckets[i] !=
NULL)
587 #ifdef USE_COEF_BUCKETS 589 bucket->buckets[
i] =
p_Mult_nn(bucket->buckets[i], n, r);
600 bucket->buckets_length[
i] =
pLength(bucket->buckets[i]);
605 if (bucket->coef[i]!=
NULL)
607 bucket->coef[
i] =
p_Mult_nn(bucket->coef[i],n,r);
614 bucket->buckets[
i] =
p_Mult_nn(bucket->buckets[i], n, r);
618 bucket->buckets_length[
i] =
pLength(bucket->buckets[i]);
638 if (q ==
NULL)
return;
652 kBucketMergeLm(bucket);
656 while (bucket->buckets[i] !=
NULL)
659 #ifdef USE_COEF_BUCKETS 660 if (bucket->coef[i]!=
NULL)
663 l1, bucket->buckets_length[i], r);
668 q =
p_Add_q(q, bucket->buckets[i],
669 l1, bucket->buckets_length[i], r);
671 q =
p_Add_q(q, bucket->buckets[i],
672 l1, bucket->buckets_length[i], r);
674 bucket->buckets[
i] =
NULL;
675 bucket->buckets_length[
i] = 0;
682 bucket->buckets[
i] = q;
683 bucket->buckets_length[
i]=l1;
684 if (i >= bucket->buckets_used)
685 bucket->buckets_used =
i;
687 kBucketAdjustBucketsUsed(bucket);
716 #ifndef HAVE_PSEUDO_BUCKETS 717 kBucketMergeLm(bucket);
721 #if defined(HAVE_RINGS)||defined(HAVE_PLURAL) 734 if ((i <= bucket->buckets_used) && (bucket->buckets[i] !=
NULL))
736 assume(
pLength(bucket->buckets[i])==bucket->buckets_length[i]);
750 bucket->buckets_length[i], l1,
752 l1 = bucket->buckets_length[
i];
753 bucket->buckets[
i] =
NULL;
754 bucket->buckets_length[
i] = 0;
760 if (spNoether !=
NULL)
763 p1 = r->p_Procs->pp_Mult_mm_Noether(p1, m, spNoether, l1, r);
768 p1 = r->p_Procs->pp_Mult_mm(p1, m, r);
774 while (bucket->buckets[i] !=
NULL)
778 p1 =
p_Add_q(p1, bucket->buckets[i],
779 l1, bucket->buckets_length[i], r);
780 bucket->buckets[
i] =
NULL;
781 bucket->buckets_length[
i] = 0;
785 bucket->buckets[
i] = p1;
786 bucket->buckets_length[
i]=l1;
787 if (i >= bucket->buckets_used)
788 bucket->buckets_used =
i;
790 kBucketAdjustBucketsUsed(bucket);
791 #else // HAVE_PSEUDO_BUCKETS 821 kBucketMergeLm(bucket);
824 #ifdef USE_COEF_BUCKETS 827 if (i <= bucket->buckets_used && bucket->buckets[i] !=
NULL)
830 #ifdef USE_COEF_BUCKETS 831 if ((bucket->coef[i]!=
NULL) &&(i>=coef_start))
833 number orig_coef=
p_GetCoeff(bucket->coef[i],r);
837 number
gcd=
n_Gcd(add_coef, orig_coef,r);
841 number orig_coef2=
n_ExactDiv(orig_coef,gcd,r);
845 orig_coef=orig_coef2;
857 bucket->buckets[
i]=
p_Mult_nn(bucket->buckets[i],orig_coef,r);
863 bucket->buckets_length[i], l1, r);
864 l1=bucket->buckets_length[
i];
865 bucket->buckets[
i]=
NULL;
866 bucket->buckets_length[
i] = 0;
877 bucket->buckets_length[i], l1, r);
878 l1 = bucket->buckets_length[
i];
879 bucket->buckets[
i] =
NULL;
880 bucket->buckets_length[
i] = 0;
886 #ifdef USE_COEF_BUCKETS 895 p1 = r->p_Procs->pp_Mult_mm(p1, m, r);
896 #ifdef USE_COEF_BUCKETS 902 while ((bucket->buckets[i] !=
NULL) && (p1!=
NULL))
905 #ifdef USE_COEF_BUCKETS 906 if ((bucket->coef[i]!=
NULL) &&(i>=coef_start))
908 number orig_coef=
p_GetCoeff(bucket->coef[i],r);
911 number add_coef=
n_Copy(n,r);
912 number
gcd=
n_Gcd(add_coef, orig_coef,r);
916 number orig_coef2=
n_ExactDiv(orig_coef,gcd,r);
921 orig_coef=orig_coef2;
927 bucket->buckets[
i]=
p_Mult_nn(bucket->buckets[i],orig_coef,r);
930 p1 =
p_Add_q(p1, bucket->buckets[i],r);
933 bucket->buckets[
i]=
NULL;
943 #ifdef USE_COEF_BUCKETS 952 p1 =
p_Add_q(p1, bucket->buckets[i],
953 l1, bucket->buckets_length[i], r);
954 bucket->buckets[
i] =
NULL;
955 bucket->buckets_length[
i] = 0;
960 bucket->buckets[
i] = p1;
961 #ifdef USE_COEF_BUCKETS 970 bucket->coef[
i]=
NULL;
974 if ((p1==
NULL) && (bucket->coef[i]!=
NULL))
977 bucket->buckets_length[
i]=l1;
978 if (i > bucket->buckets_used)
979 bucket->buckets_used =
i;
981 kBucketAdjustBucketsUsed(bucket);
1027 #ifndef HAVE_PSEUDO_BUCKETS 1028 kBucketMergeLm(bucket);
1029 for (i=1; i<=bucket->buckets_used; i++)
1031 if (bucket->buckets[i] !=
NULL)
1038 bucket->buckets_length[
i] -= lq;
1039 assume(
pLength(bucket->buckets[i]) == bucket->buckets_length[i]);
1044 kBucketAdjustBucketsUsed(bucket);
1096 if ((ct == 0) || (ct == 2))
1161 #ifndef USE_COEF_BUCKETS 1164 static BOOLEAN nIsPseudoUnit(number n, ring r)
1171 return (
n_Size(n,r->cf)==1);
1190 if ((bucket->buckets[i]!=
NULL) && (bucket->coef[i]==
NULL))
1201 if ((bucket->buckets[i]!=
NULL)
1202 && (nIsPseudoUnit(
p_GetCoeff(bucket->coef[i],r),r)))
1217 if (bucket->buckets[i]!=
NULL)
1226 if (nIsPseudoUnit(coef,r))
1243 if (bucket->buckets[i]!=
NULL)
1261 poly p=bucket->buckets[
i];
1262 bucket->buckets_length[
i]--;
1263 #ifdef USE_COEF_BUCKETS 1265 if (bucket->coef[i]!=
NULL)
1271 p=bucket->buckets[
i];
1272 bucket->buckets[
i]=
NULL;
1277 bucket->buckets[
i]=
next;
1288 bucket->buckets[
i]=
pNext(bucket->buckets[i]);
1309 number an = *
a, bn = *
b;
void kBucketClear(kBucket_pt bucket, poly *p, int *length)
CFFList append(const CFFList &Inputlist, const CFFactor &TheFactor)
BOOLEAN kbTest(kBucket_pt bucket)
Tests.
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...
poly kBucketExtractLmOfBucket(kBucket_pt bucket, int i)
#define MULTIPLY_BUCKET(B, I)
void kBucketShallowCopyDelete(kBucket_pt bucket, ring new_tailRing, omBin new_tailBin, pShallowCopyDeleteProc p_shallow_copy_delete)
For changing the ring of the Bpoly to new_tailBin.
void kBucketInit(kBucket_pt bucket, poly lm, int length)
void p_TakeOutComp(poly *p, long comp, poly *q, int *lq, const ring r)
number kBucketPolyRed(kBucket_pt bucket, poly p1, int l1, poly spNoether)
static FORCE_INLINE BOOLEAN n_IsOne(number n, const coeffs r)
TRUE iff 'n' represents the one element.
poly p_NSet(number n, const ring r)
returns the poly representing the number n, destroys n
static unsigned long p_SetComp(poly p, unsigned long c, ring r)
static FORCE_INLINE number n_Init(long i, const coeffs r)
a number representing i in the given coeff field/ring r
const poly kBucketGetLm(kBucket_pt bucket)
int ksCheckCoeff(number *a, number *b)
#define MAX_BUCKET
Bucket definition (should be no one elses business, though)
static poly pp_Mult_mm(poly p, poly m, const ring r)
static BOOLEAN rField_is_Domain(const ring r)
static FORCE_INLINE void n_Normalize(number &n, const coeffs r)
inplace-normalization of n; produces some canonical representation of n;
static char const ** rParameter(const ring r)
(r->cf->parameter)
static number & pGetCoeff(poly p)
return an alias to the leading coefficient of p assumes that p != NULL NOTE: not copy ...
void kBucket_Mult_n(kBucket_pt bucket, number n)
Multiply Bucket by number ,i.e. Bpoly == n*Bpoly.
static bool rIsPluralRing(const ring r)
we must always have this test!
kBucket_pt kBucketCreate(ring bucket_ring)
Creation/Destruction of buckets.
static number p_SetCoeff(poly p, number n, ring r)
static int pLength(poly a)
poly kBucketExtractLm(kBucket_pt bucket)
int comp(const CanonicalForm &A, const CanonicalForm &B)
compare polynomials
#define pFalseReturn(cond)
poly kBucket_ExtractLarger(kBucket_pt bucket, poly q, poly append)
Extract all monomials of bucket which are larger than q Append those to append, and return last monom...
Coefficient rings, fields and other domains suitable for Singular polynomials.
void kBucketDestroy(kBucket_pt *bucket_pt)
static void p_SetCompP(poly p, int i, ring r)
static BOOLEAN p_IsConstant(const poly p, const ring r)
The main handler for Singular numbers which are suitable for Singular polynomials.
#define n_Test(a, r)
BOOLEAN n_Test(number a, const coeffs r)
static BOOLEAN p_DivisibleBy(poly a, poly b, const ring r)
void kBucketSetLm(kBucket_pt bucket, poly lm)
static int p_LmCmp(poly p, poly q, const ring r)
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)
void kBucketSimpleContent(kBucket_pt)
#define omCheckAddrBin(addr, bin)
void PrintS(const char *s)
static void p_ExpVectorSub(poly p1, poly p2, const ring r)
static poly p_Mult_nn(poly p, number n, const ring r)
void kBucket_Minus_m_Mult_p(kBucket_pt bucket, poly m, poly p, int *l, poly spNoether)
Bpoly == Bpoly - m*p; where m is a monom Does not destroy p and m assume (*l <= 0 || pLength(p) == *l...
static FORCE_INLINE BOOLEAN n_IsZero(number n, const coeffs r)
TRUE iff 'n' represents the zero element.
void kBucketAdjust(kBucket_pt bucket, int i)
Bucket number i from bucket is out of length sync, resync.
static BOOLEAN rField_is_Zp(const ring r)
static void p_Delete(poly *p, const ring r)
#define omGetSpecBin(size)
#define p_LmEqual(p1, p2, r)
unsigned int pLogLength(unsigned int l)
Some internal stuff.
poly(* pShallowCopyDeleteProc)(poly s_p, ring source_r, ring dest_r, omBin dest_bin)
returns a poly from dest_r which is a ShallowCopy of s_p from source_r assumes that source_r->N == de...
static BOOLEAN rField_is_Ring(const ring r)
static FORCE_INLINE number n_Copy(number n, const coeffs r)
return a copy of 'n'
void kBucket_Plus_mm_Mult_pp(kBucket_pt bucket, poly m, poly p, int l)
Bpoly == Bpoly + m*p; where m is a monom Does not destroy p and m assume (l <= 0 || pLength(p) == l) ...
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...
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 ...
static void p_Setm(poly p, const ring r)
static poly p_Minus_mm_Mult_qq(poly p, const poly m, const poly q, int &lp, int lq, const poly spNoether, const ring r)
static FORCE_INLINE number n_SubringGcd(number a, number b, const coeffs r)
int dReportError(const char *fmt,...)
static void p_LmDelete(poly p, const ring r)
#define p_SetCoeff0(p, n, r)
static FORCE_INLINE void n_Delete(number *p, const coeffs r)
delete 'p'
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.
static poly p_Add_q(poly p, poly q, const ring r)
BOOLEAN kBucketIsCleared(kBucket_pt bucket)
#define omFreeBin(addr, bin)
int kBucketCanonicalize(kBucket_pt bucket)
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...
void kBucketDeleteAndDestroy(kBucket_pt *bucket_pt)
void kBucketTakeOutComp(kBucket_pt bucket, long comp, poly *r_p, int *l)
static poly p_Plus_mm_Mult_qq(poly p, poly m, poly q, int &lp, int lq, const ring r)
void kBucket_Add_q(kBucket_pt bucket, poly q, int *l)
Add to Bucket a poly ,i.e. Bpoly == q+Bpoly.