18 #ifdef HAVE_COEF_BUCKETS 19 #define USE_COEF_BUCKETS 22 #ifdef USE_COEF_BUCKETS 24 #define MULTIPLY_BUCKET(B,I) do \ 25 { if (B->coef[I]!=NULL) \ 27 assume(p_IsConstant(B->Coef[i],B->bucket->ring)); \ 28 B->buckets[I]=p_Mult_q(B->buckets[I],B->coef[I],B->bucket_ring); \ 32 if (rField_is_Ring(B->bucket_ring)) B->buckets_length[i] = pLength(B->buckets[i]); 34 #define MULTIPLY_BUCKET(B,I) do \ 35 { if (B->coef[I]!=NULL) \ 37 B->buckets[I]=p_Mult_q(B->buckets[I],B->coef[I],B->bucket_ring); \ 43 #define MULTIPLY_BUCKET(B,I) 46 #ifdef USE_COEF_BUCKETS 47 static int coef_start=1;
55 #ifndef BUCKET_TWO_BASE 58 const unsigned int b[] = {0x2, 0xC, 0xF0, 0xFF00, 0xFFFF0000};
59 const unsigned int S[] = {1, 2, 4, 8, 16};
62 if (v & b[4]) { v >>= S[4]; r |= S[3]; }
63 if (v & b[3]) { v >>= S[3]; r |= S[2]; }
64 if (v & b[2]) { v >>= S[2]; r |= S[1]; }
65 if (v & b[1]) { v >>= S[1]; r |= S[0]; }
77 #ifdef BUCKET_TWO_BASE 93 #ifndef HAVE_PSEUDO_BUCKETS 96 #ifdef USE_COEF_BUCKETS 98 if ((bucket->coef[i]!=
NULL) && (bucket->buckets[i]==
NULL))
102 if (bucket->coef[i]!=
NULL)
109 if ((
unsigned)bucket->buckets_length[i] !=
pLength(bucket->buckets[i]))
111 dReportError(
"Bucket %d lengths difference should:%d has:%d",
112 i, bucket->buckets_length[i],
pLength(bucket->buckets[i]));
114 else if (i > 0 && (
int)
pLogLength(bucket->buckets_length[i]) > i)
117 i, bucket->buckets_length[i]);
119 if (i==0 && bucket->buckets_length[0] > 1)
129 #ifdef HAVE_COEF_BUCKETS 133 poly lm = bucket->buckets[0];
137 if (! kbTest_i(bucket, 0))
return FALSE;
138 for (i=1; i<= (int) bucket->buckets_used; i++)
140 if (!kbTest_i(bucket, i))
return FALSE;
141 if (lm !=
NULL && bucket->buckets[i] !=
NULL 158 if (bucket->buckets[i] !=
NULL || bucket->buckets_length[i] != 0)
166 if (bucket->buckets[i]!=
NULL)
171 if (bucket->buckets[j]==bucket->buckets[i])
178 #ifdef HAVE_COEF_BUCKETS 179 if (bucket->coef[i]!=
NULL)
184 if (bucket->coef[j]==bucket->coef[i])
196 #else // HAVE_PSEUDO_BUCKETS 201 #endif // ! HAVE_PSEUDO_BUCKETS 228 for (i=0; i<= bucket->buckets_used; i++)
231 #ifdef USE_COEF_BUCKETS 242 #ifndef HAVE_PSEUDO_BUCKETS 247 if (bucket->buckets[0] !=
NULL)
249 poly lm = bucket->buckets[0];
251 #ifdef BUCKET_TWO_BASE 253 while ( bucket->buckets_length[i] >= l)
260 while ( bucket->buckets_length[i] >= l)
266 #ifndef USE_COEF_BUCKETS 268 pNext(lm) = bucket->buckets[
i];
269 bucket->buckets[
i] = lm;
270 bucket->buckets_length[
i]++;
271 assume(i <= bucket->buckets_used+1);
272 if (i > bucket->buckets_used) bucket->buckets_used =
i;
273 bucket->buckets[0] =
NULL;
274 bucket->buckets_length[0] = 0;
277 if (i > bucket->buckets_used) bucket->buckets_used =
i;
279 if (bucket->buckets[i]!=
NULL)
282 pNext(lm) = bucket->buckets[
i];
283 bucket->buckets[
i] = lm;
284 bucket->buckets_length[
i]++;
285 assume(i <= bucket->buckets_used+1);
297 bucket->buckets[
i]=lm;
298 bucket->buckets_length[
i]=1;
301 bucket->buckets[
i]=lm;
302 bucket->buckets_length[
i]=1;
305 pNext(lm) = bucket->buckets[
i];
306 bucket->buckets[
i] = lm;
307 bucket->buckets_length[
i]++;
308 assume(i <= bucket->buckets_used+1);
311 bucket->buckets[0]=
NULL;
312 bucket->buckets_length[0] = 0;
313 bucket->coef[0]=
NULL;
326 if (bucket->buckets[i] !=
NULL)
return FALSE;
327 #ifdef HAVE_COEF_BUCKETS 328 if (bucket->coef[i] !=
NULL)
return FALSE;
330 if (bucket->buckets_length[i] != 0)
return FALSE;
342 if (lm ==
NULL)
return;
347 bucket->buckets[0] = lm;
348 #ifdef HAVE_COEF_BUCKETS 351 #ifdef USE_COEF_BUCKETS 352 bucket->coef[0]=
NULL;
355 bucket->buckets_length[0] = 1;
357 bucket->buckets_length[0]= 0;
361 bucket->buckets[
i] =
pNext(lm);
363 bucket->buckets_length[
i] = length-1;
364 bucket->buckets_used =
i;
368 bucket->buckets_used = 0;
374 #ifndef HAVE_PSEUDO_BUCKETS 378 poly
p = bucket->buckets[1];
380 int pl = bucket->buckets_length[1];
382 bucket->buckets[1] =
NULL;
383 bucket->buckets_length[1] = 0;
384 #ifdef USE_COEF_BUCKETS 390 for (i=1; i<=bucket->buckets_used; i++)
392 #ifdef USE_COEF_BUCKETS 393 if (bucket->coef[i]!=
NULL)
397 pl, bucket->buckets_length[i], r);
402 p =
p_Add_q(p, bucket->buckets[i],
403 pl, bucket->buckets_length[i], r);
405 p =
p_Add_q(p, bucket->buckets[i],
406 pl, bucket->buckets_length[i], r);
409 bucket->buckets[
i] =
NULL;
410 bucket->buckets_length[
i] = 0;
412 #ifdef HAVE_COEF_BUCKETS 415 lm = bucket->buckets[0];
421 bucket->buckets[0] =
NULL;
422 bucket->buckets_length[0] = 0;
427 bucket->buckets[
i] =
p;
428 bucket->buckets_length[
i] = pl;
434 bucket->buckets_used =
i;
436 #ifdef USE_COEF_BUCKETS 449 #ifdef HAVE_PSEUDO_BUCKETS 453 for (
int i=0; i<=bucket->buckets_used; i++)
465 #ifdef USE_COEF_BUCKETS 469 *p = bucket->buckets[
i];
470 *length = bucket->buckets_length[
i];
471 bucket->buckets[
i] =
NULL;
472 bucket->buckets_length[
i] = 0;
473 bucket->buckets_used = 0;
485 kBucketMergeLm(bucket);
487 bucket->buckets[0] = lm;
488 bucket->buckets_length[0] = 1;
491 #else // HAVE_PSEUDO_BUCKETS 501 if (length <= 0) bucket->
l =
pLength(lm);
530 #endif // ! HAVE_PSEUDO_BUCKETS 536 ring new_tailRing,
omBin new_tailBin,
539 #ifndef HAVE_PSEUDO_BUCKETS 543 for (i=0; i<= bucket->buckets_used; i++)
544 if (bucket->buckets[i] !=
NULL)
547 bucket->buckets[
i] = p_shallow_copy_delete(bucket->buckets[i],
553 bucket->
p = p_shallow_copy_delete(p,
569 int l1 = bucket->buckets_length[
i];
570 poly p1 = bucket->buckets[
i];
571 bucket->buckets[
i] =
NULL;
572 bucket->buckets_length[
i] = 0;
575 while (bucket->buckets[i] !=
NULL)
579 p1 =
p_Add_q(p1, bucket->buckets[i],
580 l1, bucket->buckets_length[i], bucket->
bucket_ring);
581 bucket->buckets[
i] =
NULL;
582 bucket->buckets_length[
i] = 0;
586 bucket->buckets[
i] = p1;
587 bucket->buckets_length[
i]=l1;
588 if (i >= bucket->buckets_used)
589 bucket->buckets_used =
i;
591 kBucketAdjustBucketsUsed(bucket);
600 #ifndef HAVE_PSEUDO_BUCKETS 605 for (i=0; i<= bucket->buckets_used; i++)
607 if (bucket->buckets[i] !=
NULL)
609 #ifdef USE_COEF_BUCKETS 611 bucket->buckets[
i] =
__p_Mult_nn(bucket->buckets[i], n, r);
621 bucket->buckets_length[
i] =
pLength(bucket->buckets[i]);
625 if (bucket->coef[i]!=
NULL)
634 bucket->buckets[
i] =
__p_Mult_nn(bucket->buckets[i], n, r);
637 bucket->buckets_length[
i] =
pLength(bucket->buckets[i]);
656 if (q ==
NULL)
return;
670 kBucketMergeLm(bucket);
674 while (bucket->buckets[i] !=
NULL)
677 #ifdef USE_COEF_BUCKETS 678 if (bucket->coef[i]!=
NULL)
681 l1, bucket->buckets_length[i], r);
686 q =
p_Add_q(q, bucket->buckets[i],
687 l1, bucket->buckets_length[i], r);
689 q =
p_Add_q(q, bucket->buckets[i],
690 l1, bucket->buckets_length[i], r);
692 bucket->buckets[
i] =
NULL;
693 bucket->buckets_length[
i] = 0;
700 bucket->buckets[
i] = q;
701 bucket->buckets_length[
i]=l1;
702 if (i >= bucket->buckets_used)
703 bucket->buckets_used =
i;
705 kBucketAdjustBucketsUsed(bucket);
734 #ifndef HAVE_PSEUDO_BUCKETS 735 kBucketMergeLm(bucket);
739 #if defined(HAVE_PLURAL) 744 p1=r->p_Procs->pp_mm_Mult(p,m,r);
752 if ((i <= bucket->buckets_used) && (bucket->buckets[i] !=
NULL))
754 assume(
pLength(bucket->buckets[i])==(
unsigned)bucket->buckets_length[i]);
768 bucket->buckets_length[i], l1,
770 l1 = bucket->buckets_length[
i];
771 bucket->buckets[
i] =
NULL;
772 bucket->buckets_length[
i] = 0;
778 if (spNoether !=
NULL)
781 p1 = r->p_Procs->pp_Mult_mm_Noether(p1, m, spNoether, l1, r);
786 p1 = r->p_Procs->pp_mm_Mult(p1, m, r);
792 while (bucket->buckets[i] !=
NULL)
796 p1 =
p_Add_q(p1, bucket->buckets[i],
797 l1, bucket->buckets_length[i], r);
798 bucket->buckets[
i] =
NULL;
799 bucket->buckets_length[
i] = 0;
803 bucket->buckets[
i] = p1;
804 bucket->buckets_length[
i]=l1;
805 if (i >= bucket->buckets_used)
806 bucket->buckets_used =
i;
808 kBucketAdjustBucketsUsed(bucket);
809 #else // HAVE_PSEUDO_BUCKETS 839 kBucketMergeLm(bucket);
842 #ifdef USE_COEF_BUCKETS 845 if (i <= bucket->buckets_used && bucket->buckets[i] !=
NULL)
848 #ifdef USE_COEF_BUCKETS 849 if ((bucket->coef[i]!=
NULL) &&(i>=coef_start))
851 number orig_coef=
p_GetCoeff(bucket->coef[i],r);
855 number
gcd=
n_Gcd(add_coef, orig_coef,r);
859 number orig_coef2=
n_ExactDiv(orig_coef,gcd,r);
863 orig_coef=orig_coef2;
875 bucket->buckets[
i]=
__p_Mult_nn(bucket->buckets[i],orig_coef,r);
881 bucket->buckets_length[i], l1, r);
882 l1=bucket->buckets_length[
i];
883 bucket->buckets[
i]=
NULL;
884 bucket->buckets_length[
i] = 0;
895 bucket->buckets_length[i], l1, r);
896 l1 = bucket->buckets_length[
i];
897 bucket->buckets[
i] =
NULL;
898 bucket->buckets_length[
i] = 0;
904 #ifdef USE_COEF_BUCKETS 913 p1 = r->p_Procs->pp_Mult_mm(p1, m, r);
914 #ifdef USE_COEF_BUCKETS 920 while ((bucket->buckets[i] !=
NULL) && (p1!=
NULL))
923 #ifdef USE_COEF_BUCKETS 924 if ((bucket->coef[i]!=
NULL) &&(i>=coef_start))
926 number orig_coef=
p_GetCoeff(bucket->coef[i],r);
929 number add_coef=
n_Copy(n,r);
930 number
gcd=
n_Gcd(add_coef, orig_coef,r);
934 number orig_coef2=
n_ExactDiv(orig_coef,gcd,r);
939 orig_coef=orig_coef2;
945 bucket->buckets[
i]=
__p_Mult_nn(bucket->buckets[i],orig_coef,r);
948 p1 =
p_Add_q(p1, bucket->buckets[i],r);
951 bucket->buckets[
i]=
NULL;
961 #ifdef USE_COEF_BUCKETS 970 p1 =
p_Add_q(p1, bucket->buckets[i],
971 l1, bucket->buckets_length[i], r);
972 bucket->buckets[
i] =
NULL;
973 bucket->buckets_length[
i] = 0;
978 bucket->buckets[
i] = p1;
979 #ifdef USE_COEF_BUCKETS 988 bucket->coef[
i]=
NULL;
995 bucket->buckets_length[
i]=l1;
996 if (i > bucket->buckets_used)
997 bucket->buckets_used =
i;
999 kBucketAdjustBucketsUsed(bucket);
1045 #ifndef HAVE_PSEUDO_BUCKETS 1046 kBucketMergeLm(bucket);
1047 for (i=1; i<=bucket->buckets_used; i++)
1049 if (bucket->buckets[i] !=
NULL)
1056 bucket->buckets_length[
i] -= lq;
1057 assume(
pLength(bucket->buckets[i]) == (
unsigned)bucket->buckets_length[i]);
1062 kBucketAdjustBucketsUsed(bucket);
1114 if ((ct == 0) || (ct == 2))
1147 #ifdef HAVE_SHIFTBBA 1174 #ifdef HAVE_SHIFTBBA 1191 #ifdef HAVE_SHIFTBBA 1202 #ifndef USE_COEF_BUCKETS 1205 if (bucket->buckets[0]==
NULL)
return;
1211 if (cf->cfSubringGcd==
ndGcd)
return;
1213 number nn=
pGetCoeff(bucket->buckets[0]);
1222 if (
n_Size(nn,cf)<2)
return;
1225 number coef=
n_Copy(nn,cf);
1227 for (
int i=1; i<=bucket->buckets_used;i++)
1229 if (bucket->buckets[i]!=
NULL)
1246 for (
int i=0; i<=bucket->buckets_used;i++)
1248 if (bucket->buckets[i]!=
NULL)
1250 poly p=bucket->buckets[
i];
1266 for (
int i=bucket->buckets_used;i>=0;i--)
1268 if (bucket->buckets[i]!=
NULL)
1270 poly p=bucket->buckets[
i];
1282 static BOOLEAN nIsPseudoUnit(number n, ring r)
1289 return (
n_Size(n,r->cf)==1);
1308 if ((bucket->buckets[i]!=
NULL) && (bucket->coef[i]==
NULL))
1319 if ((bucket->buckets[i]!=
NULL)
1320 && (nIsPseudoUnit(
p_GetCoeff(bucket->coef[i],r),r)))
1335 if (bucket->buckets[i]!=
NULL)
1344 if (nIsPseudoUnit(coef,r))
1361 if (bucket->buckets[i]!=
NULL)
1379 poly p=bucket->buckets[
i];
1380 bucket->buckets_length[
i]--;
1381 #ifdef USE_COEF_BUCKETS 1383 if (bucket->coef[i]!=
NULL)
1389 p=bucket->buckets[
i];
1390 bucket->buckets[
i]=
NULL;
1395 bucket->buckets[
i]=
next;
1406 bucket->buckets[
i]=
pNext(bucket->buckets[i]);
1427 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)
number ndGcd(number, number, const coeffs r)
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)
int p_mFirstVblock(poly p, const ring ri)
#define MAX_BUCKET
Bucket definition (should be no one elses business, though)
static BOOLEAN rField_is_Domain(const ring r)
static int LOG4(int v)
Some internal stuff.
static FORCE_INLINE void n_Normalize(number &n, const coeffs r)
inplace-normalization of n; produces some canonical representation of n;
void kBucketNormalize(kBucket_pt bucket)
apply n_Normalize to all coefficients
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 number p_SetCoeff(poly p, number n, ring r)
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 rIsPluralRing(const ring r)
we must always have this test!
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)
#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)
static unsigned pLength(poly a)
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.
number p_InitContent(poly ph, const ring r)
static BOOLEAN rField_is_Zp(const ring r)
void p_Normalize(poly p, const ring r)
static void p_Delete(poly *p, const ring r)
#define omGetSpecBin(size)
#define p_LmEqual(p1, p2, r)
const Variable & v
< [in] a sqrfree bivariate poly
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...
#define __p_Mult_nn(p, n, r)
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 BOOLEAN length(leftv result, leftv arg)
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 unsigned int pLogLength(unsigned int l)
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 int SI_LOG2(int v)
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)
kBucket_pt kBucketCreate(const ring bucket_ring)
Creation/Destruction of buckets.
int kBucketCanonicalize(kBucket_pt bucket)
Canonicalizes Bpoly, i.e. converts polys of buckets into one poly in one bucket: Returns number of bu...
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)
void kBucketSimpleContent(kBucket_pt bucket)
static poly p_Plus_mm_Mult_qq(poly p, poly m, poly q, int &lp, int lq, const ring r)
void k_SplitFrame(poly &m1, poly &m2, int at, const ring r)
void kBucket_Add_q(kBucket_pt bucket, poly q, int *l)
Add to Bucket a poly ,i.e. Bpoly == q+Bpoly.