 |
My Project
UNKNOWN_GIT_VERSION
|
Go to the documentation of this file.
26 #define TRANSEXT_PRIVATES
172 p->exp[o->
data.dp.place]=ord;
183 int *
w=o->
data.wp.weights;
185 for(
int i=a;
i<=e;
i++) ord+=((
unsigned long)
p_GetExp(
p,
i,r))*((
unsigned long)
w[
i-a]);
189 for(
int i=a;
i<=e;
i++)
199 p->exp[o->
data.wp.place]=ord;
205 const short a=o->
data.am.start;
206 const short e=o->
data.am.end;
207 const int *
w=o->
data.am.weights;
209 for(
short i=a;
i<=e;
i++,
w++)
214 for(
short i=a;
i<=e;
i++)
226 const short len_gen= o->
data.am.len_gen;
228 if ((c > 0) && (c <= len_gen))
235 p->exp[o->
data.am.place] = ord;
242 a=o->
data.wp64.start;
246 for(
int i=a;
i<=e;
i++)
253 if(ei!=0 && ai/ei!=wi)
257 Print(
"ai %lld, wi %lld\n",ai,wi);
259 Print(
"ai %ld, wi %ld\n",ai,wi);
267 Print(
"ai %lld, ord %lld\n",ai,ord);
269 Print(
"ai %ld, ord %ld\n",ai,ord);
274 long a_0=(long)(ord&mask);
275 long a_1=(long)(ord >>31 );
281 p->exp[o->
data.wp64.place]=a_1;
282 p->exp[o->
data.wp64.place+1]=a_0;
295 int pl=o->
data.cp.place;
304 o->
data.syzcomp.Components);
306 o->
data.syzcomp.ShiftedComponents);
307 if (ShiftedComponents !=
NULL)
310 assume(c == 0 || Components[c] != 0);
311 sc = ShiftedComponents[Components[c]];
312 assume(c == 0 || sc != 0);
314 p->exp[o->
data.syzcomp.place]=sc;
320 const short place = o->
data.syz.place;
321 const int limit = o->
data.syz.limit;
323 if (c > (
unsigned long)limit)
324 p->exp[place] = o->
data.syz.curr_index;
327 assume( (1 <= c) && (c <= (
unsigned long)limit) );
328 p->exp[place]= o->
data.syz.syz_index[c];
344 Print(
"p_Setm_General: ro_isTemp ord: pos: %d, p: ", pos);
p_wrp(
p, r);
353 const int*
const pVarOffset = o->
data.isTemp.pVarOffset;
358 for(
int i = 1;
i <= r->N;
i++ )
360 const int vo = pVarOffset[
i];
370 for(
int i = 1;
i <= r->N;
i++ )
372 const int vo = pVarOffset[
i];
392 Print(
"p_Setm_General: ro_is ord: pos: %d, p: ", pos);
p_wrp(
p, r);
401 const ideal F = o->
data.is.F;
402 const int limit = o->
data.is.limit;
404 const int start = o->
data.is.start;
406 if( F !=
NULL && c > limit )
410 Print(
"p_Setm_General: ro_is : in rSetm: pos: %d, c: %d > limit: %d\n", c, pos, limit);
411 PrintS(
"preComputed Values: ");
430 const poly
pp = F->m[c];
439 Print(
"Respective F[c - %d: %d] pp: ", limit, c);
444 const int end = o->
data.is.end;
452 Print(
"p_Setm_General: is(-Temp-) :: c: %d, limit: %d, [st:%d] ===>>> %ld\n", c, limit, start,
p->exp[start]);
458 for(
int i = start;
i <= end;
i++)
459 p->exp[
i] +=
pp->exp[
i];
462 if (r->NegWeightL_Offset !=
NULL)
464 for (
int i=r->NegWeightL_Size-1;
i>=0;
i--)
466 const int _i = r->NegWeightL_Offset[
i];
467 if( start <= _i && _i <= end )
474 const int*
const pVarOffset = o->
data.is.pVarOffset;
478 for(
int i = 1;
i <= r->N;
i++ )
480 const int vo = pVarOffset[
i];
494 const int*
const pVarOffset = o->
data.is.pVarOffset;
499 const int vo = pVarOffset[0];
505 Print(
"ELSE p_Setm_General: ro_is :: c: %d <= limit: %d, vo: %d, exp: %d\n", c, limit, vo,
p->exp[vo]);
518 if (pos == r->OrdSize)
return;
523 void p_Setm_Syz(poly
p, ring r,
int* Components,
long* ShiftedComponents)
559 if (r->typ[0].ord_typ ==
ro_dp &&
560 r->typ[0].data.dp.start == 1 &&
561 r->typ[0].data.dp.end == r->N &&
562 r->typ[0].data.dp.place == r->pOrdIndex)
564 if (r->typ[0].ord_typ ==
ro_wp &&
565 r->typ[0].data.wp.start == 1 &&
566 r->typ[0].data.wp.end == r->N &&
567 r->typ[0].data.wp.place == r->pOrdIndex &&
568 r->typ[0].data.wp.weights == r->firstwv)
593 for (
i=1;
i<= r->firstBlockEnds;
i++)
612 for (
i=0;r->order[
i]!=0;
i++)
619 for (
k=b0 ;
k<=b1 ;
k++)
628 for (
k=b0 ;
k<=b1 ;
k++)
637 for (
k=b0 ;
k<=b1 ;
k++)
650 for (
k=b0 ;
k<=b1 ;
k++)
658 for (
k=0;
k<=(b1 - b0 );
k++)
699 if ((r->firstwv==
NULL) || (
i>r->firstBlockEnds))
703 return r->firstwv[
i-1];
713 for(
i=1;
i<=r->firstBlockEnds;
i++)
754 return r->pFDeg(
p, r);
807 long o = r->pFDeg(
p, r);
883 if ((t=r->pFDeg(
p, r))>
max)
max=t;
893 if ((t=r->pFDeg(
p, r))>
max)
max=t;
1098 static inline unsigned long
1100 unsigned long number_of_exp)
1102 const unsigned long bitmask = r->bitmask;
1103 unsigned long ml1 = l1 & bitmask;
1104 unsigned long ml2 = l2 & bitmask;
1105 unsigned long max = (ml1 > ml2 ? ml1 : ml2);
1106 unsigned long j = number_of_exp - 1;
1110 unsigned long mask = bitmask << r->BitsPerExp;
1115 max |= ((ml1 > ml2 ? ml1 : ml2) & mask);
1118 mask = mask << r->BitsPerExp;
1124 static inline unsigned long
1138 unsigned long l_p, l_max;
1139 unsigned long divmask = r->divmask;
1143 offset = r->VarL_Offset[0];
1148 (((l_max & divmask) ^ (l_p & divmask)) != ((l_max-l_p) & divmask)))
1151 for (
i=1;
i<r->VarL_Size;
i++)
1158 (((l_max & divmask) ^ (l_p & divmask)) != ((l_max-l_p) & divmask)))
1169 unsigned long l_p, divmask = r->divmask;
1174 l_p =
p->exp[r->VarL_Offset[0]];
1176 (((l_max & divmask) ^ (l_p & divmask)) != ((l_max-l_p) & divmask)))
1178 for (
i=1;
i<r->VarL_Size;
i++)
1180 l_p =
p->exp[r->VarL_Offset[
i]];
1183 (((l_max & divmask) ^ (l_p & divmask)) != ((l_max-l_p) & divmask)))
1249 if((
k!=-1)&&(
k!=
i))
return 0;
1266 for(
i=r->N;
i>0;
i--)
1340 const char *
p_Read(
const char *st, poly &rc,
const ring r)
1353 while (*
s!=
'\0')
s++;
1365 const char *s_save=
s;
1367 if (((
unsigned long)
i) > r->bitmask/2)
1398 for(
unsigned int k = iFirstAltVar;
k <= iLastAltVar;
k++)
1418 if ((
s!=st)&&isdigit(st[0]))
1460 for(
i=(
int)r->N;
i;
i--)
1592 for(
int i = (
int)
rVar(r);
i>0;
i--)
1602 void p_Lcm(
const poly a,
const poly
b, poly
m,
const ring r)
1604 for (
int i=r->N;
i; --
i)
1611 poly
p_Lcm(
const poly a,
const poly
b,
const ring r)
1619 #ifdef HAVE_RATGRING
1624 poly
p_LcmRat(
const poly a,
const poly
b,
const long lCompM,
const ring r)
1632 for (
int i = r->real_var_end;
i>=r->real_var_start;
i--)
1699 poly *C = (poly *)
omAlloc0((len+1)*
sizeof(poly));
1700 poly *LM = (poly *)
omAlloc0((len+1)*
sizeof(poly));
1701 int *
D = (
int *)
omAlloc0((len+1)*
sizeof(int));
1702 int *L = (
int *)
omAlloc0((len+1)*
sizeof(int));
1708 int HasConstantCoef = 0;
1709 int is = r->real_var_start - 1;
1721 HasConstantCoef = 1;
1731 int mindeglen = len;
1743 if (
D[
i] == mintdeg)
1745 if (L[
i] < mindeglen)
1752 d =
p_Copy(C[pmindeglen], r);
1824 int divisorLE =
p_GetExp(divisor, 1, r);
1937 poly
p_Sub(poly p1, poly p2,
const ring r)
2017 bin = (number *)
omAlloc0(
h*
sizeof(number));
2038 int e,
h = (
exp >> 1) + 1;
2058 poly tail,
b,
res,
h;
2071 al = (
exp + 1) *
sizeof(poly);
2074 for (e=1; e<
exp; e++)
2080 for (e=
exp-1; e>eh; e--)
2089 for (e=eh; e!=0; e--)
2156 if ( (
i > 0) && ((
unsigned long )
i > (r->bitmask)))
2158 Werror(
"exponent %d is too large, max. is %ld",
i,r->bitmask);
2202 int char_p=
rChar(r);
2203 if ((char_p>0) && (
i>char_p)
2209 while (rest>=char_p)
2224 if ((char_p==0) || (
i<=char_p))
2240 if (ph==
NULL)
return;
2246 if (
cf->cfSubringGcd==
ndGcd)
return;
2251 goto content_finish;
2263 goto content_finish;
2281 #define CLEARENUMERATORS 1
2291 #if CLEARENUMERATORS
2344 #if CLEARENUMERATORS
2409 h =
n_Init(1, r->cf->extRing->cf);
2491 #if 1 // currently only used by Singular/janet
2495 if (ph==
NULL)
return;
2506 if (
n_Size(d,r->cf)<=smax)
2514 if (smax==1) smax=2;
2573 d=
nlAdd(n1,t,r->cf);
2575 d=
nlSub(n1,t,r->cf);
2584 d=
nlAdd(n2,t,r->cf);
2586 d=
nlSub(n2,t,r->cf);
2593 d=
nlGcd(n1,n2,r->cf);
2616 if (s2==-1)
return n_Copy(d,r->cf);
2789 #if CLEARENUMERATORS
2832 #if 0 && CLEARENUMERATORS
2876 #ifdef HAVE_RATGRING
2900 #if CLEARENUMERATORS
2953 #if CLEARENUMERATORS
3141 fraction
f = (fraction)
h;
3152 if (!
n_IsOne (n, C->extRing->cf))
3156 nMap=
n_SetMap (C->extRing->cf, C);
3157 number ninv= nMap (n,C->extRing->cf, C);
3170 number p_GetAllDenom(poly ph,
const ring r)
3172 number d=
n_Init(1,r->cf);
3194 if (r->cf->has_simple_Alloc)
3222 if ((varnum < 1) || (varnum >
rVar(r)))
3271 if (d(qp,r) != o)
return FALSE;
3323 if ((*len == 0) || (
j<*len))
3423 pNext(qq) = pNext_q;
3499 if (*
p==
NULL)
return;
3553 if (
k>len) {
Werror(
"wrong rank:%d, should be %d",len,
k); }
3562 for(
int i=len-1;
i>=0;
i--)
3579 if (*len==0) *len=1;
3580 *
p=(poly*)
omAlloc0((*len)*
sizeof(poly));
3591 r->pFDeg = new_FDeg;
3593 if (new_lDeg ==
NULL)
3594 new_lDeg = r->pLDegOrig;
3596 r->pLDeg = new_lDeg;
3603 r->pFDeg = old_FDeg;
3604 r->pLDeg = old_lDeg;
3619 if ((c>0) && ((r->pModW)->range(c-1))) d+= (*(r->pModW))[c-1];
3633 r->pLexOrder =
TRUE;
3653 if (increment==0)
return;
3654 h=(poly*)
omAlloc0(increment*
sizeof(poly));
3661 memset(&(
h[
l]),0,increment*
sizeof(poly));
3780 while (non_zero !=
NULL)
3804 poly zero, non_zero;
3809 while (non_zero !=
NULL)
3924 poly
n_PermNumber(
const number z,
const int *par_perm,
const int ,
const ring src,
const ring dst)
3927 PrintS(
"\nSource Ring: \n");
3932 number zz =
n_Copy(z, src->cf);
3937 PrintS(
"\nDestination Ring: \n");
3949 const coeffs srcCf = src->cf;
3957 const ring srcExtRing = srcCf->extRing;
3960 const coeffs dstCf = dst->cf;
3972 zz =
NUM((fraction)z);
3976 if( !DENIS1((fraction)z) )
3979 WarnS(
"Not defined: Cannot map a rational fraction and make a polynomial out of it! Ignoring the denominator.");
3985 WerrorS(
"Number permutation is not implemented for this data yet!");
3997 if ((par_perm ==
NULL) && (
rPar(dst) != 0 &&
rVar (srcExtRing) > 0))
4000 perm=(
int *)
omAlloc0((
rVar(srcExtRing)+1)*
sizeof(int));
4011 && (!DENIS1((fraction)z))
4014 number n=nMap(
pGetCoeff(DEN((fraction)z)),srcExtRing->cf, dstCf);
4028 poly
p_PermPoly (poly
p,
const int * perm,
const ring oldRing,
const ring dst,
4035 const int OldpVariables =
rVar(oldRing);
4037 poly result_last =
NULL;
4043 poly tmp_mm=
p_One(dst);
4053 number n = nMap(
p_GetCoeff(
p, oldRing), oldRing->cf, dst->cf);
4082 int mapped_to_par = 0;
4083 for(
int i = 1;
i <= OldpVariables;
i++)
4113 n_Power(ee, e, &eee, dst->cf);
4114 ee =
n_Mult(c, eee, dst->cf);
4120 const int par = -perm[
i];
4124 const coeffs C = dst->cf;
4126 const ring
R = C->extRing;
4134 pcn =
NUM((fraction)c);
4195 if (result_last==
NULL)
4201 pNext(result_last)=qq;
4404 p=
p_JetW(
p_Mult_q(
p,
p_Invers(n-
p_MinDeg(
p,
w,
R),u,
w,
R),
R),n,ww,
R);
4412 while ((p1 !=
NULL) && (p2 !=
NULL))
4431 int i = r1->ExpL_Size;
4433 assume( r1->ExpL_Size == r2->ExpL_Size );
4435 unsigned long *ep = p1->exp;
4436 unsigned long *eq = p2->exp;
4441 if (ep[
i] != eq[
i])
return FALSE;
4451 assume( r1->cf == r2->cf );
4453 while ((p1 !=
NULL) && (p2 !=
NULL))
4494 while ((p1 !=
NULL) )
4556 if (
m==
NULL)
return 0;
4582 if (
p ==
NULL)
return -1;
4589 while ((
l < (
rVar(r))) && (lex == 0))
4606 poly qp1 = *
p,qp2 = *
p;
4631 qp2->next = qp1->next;
4647 const unsigned int s,
const unsigned int n)
4649 #define Sy_bit_L(x) (((unsigned long)1L)<<(x))
4651 unsigned long ev = 0L;
4682 unsigned long ev = 0;
4696 for (;
j<=r->N;
j++)
4736 unsigned long ev = 0;
4740 unsigned long i = 0L;
4751 for (;
j<=r->N;
j++)
4794 #define p_Delete__T p_ShallowDelete
4796 #define n_Delete__T(n, r) do {} while (0)
4807 if ((r==0)&&(a!=
NULL))
4845 int *mf=(
int*)
omAlloc((r->N+1)*
sizeof(int));
4847 int *mh=(
int*)
omAlloc((r->N+1)*
sizeof(int));
4861 for(
unsigned j=r->N;
j!=0;
j--)
4863 if (mh[
j]<mf[
j]) mf[
j]=mh[
j];
4864 if (mf[
j]>0) const_mon=
FALSE;
4866 if (one_coeff && const_mon)
break;
static FORCE_INLINE n_coeffType getCoeffType(const coeffs r)
Returns the type of coeffs domain.
static poly p_Pow_charp(poly p, int i, const ring r)
static int si_min(const int a, const int b)
poly singclap_gcd(poly f, poly g, const ring r)
polynomial gcd via singclap_gcd_r resp. idSyzygies destroys f and g
int dReportError(const char *fmt,...)
static unsigned long p_SubComp(poly p, unsigned long v, ring r)
static poly p_LmFreeAndNext(poly p, ring)
long pLDeg1(poly p, int *l, const ring r)
int exponent(const CanonicalForm &f, int q)
int exponent ( const CanonicalForm & f, int q )
static poly p_LmDeleteAndNext(poly p, const ring r)
long p_DegW(poly p, const short *w, const ring R)
poly p_LcmRat(const poly a, const poly b, const long lCompM, const ring r)
poly p_Subst(poly p, int n, poly e, const ring r)
static BOOLEAN p_LmIsConstantComp(const poly p, const ring r)
static long p_GetExp(const poly p, const unsigned long iBitmask, const int VarOffset)
get a single variable exponent @Note: the integer VarOffset encodes:
void pRestoreDegProcs(ring r, pFDegProc old_FDeg, pLDegProc old_lDeg)
static poly p_MonPower(poly p, int exp, const ring r)
void p_Normalize(poly p, const ring r)
static poly p_Invers(int n, poly u, intvec *w, const ring R)
long pLDeg0c(poly p, int *l, const ring r)
int p_GetVariables(poly p, int *e, const ring r)
set entry e[i] to 1 if var(i) occurs in p, ignore var(j) if e[j]>0 return #(e[i]>0)
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 ...
long(* pLDegProc)(poly p, int *length, ring r)
BOOLEAN rOrd_SetCompRequiresSetm(const ring r)
return TRUE if p_SetComp requires p_Setm
const CanonicalForm int const CFList const Variable & y
long pLDeg0(poly p, int *l, const ring r)
static pLDegProc pOldLDeg
void sBucketDestroyAdd(sBucket_pt bucket, poly *p, int *length)
void sBucket_Add_m(sBucket_pt bucket, poly p)
long pLDeg1_Totaldegree(poly p, int *l, const ring r)
void pEnlargeSet(poly **p, int l, int increment)
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)
int p_Var(poly m, const ring r)
long(* pFDegProc)(poly p, ring r)
static poly p_Head(poly p, const ring r)
static poly p_Mult_mm(poly p, poly m, const ring r)
BOOLEAN p_ComparePolys(poly p1, poly p2, const ring r)
returns TRUE if p1 is a skalar multiple of p2 assume p1 != NULL and p2 != NULL
static poly p_Neg(poly p, const ring r)
int p_IsUnivariate(poly p, const ring r)
return i, if poly depends only on var(i)
static poly p_LmInit(poly p, const ring r)
void p_Split(poly p, poly *h)
static void p_SetCompP(poly p, int i, ring r)
static number * pnBin(int exp, const ring r)
static poly p_TwoMonPower(poly p, int exp, const ring r)
poly p_Homogen(poly p, int varnum, const ring r)
short * iv2array(intvec *iv, const ring R)
poly p_ChineseRemainder(poly *xx, number *x, number *q, int rl, CFArray &inv_cache, const ring R)
poly singclap_pdivide(poly f, poly g, const ring r)
long totaldegreeWecart_IV(poly p, ring r, const short *w)
#define TEST_OPT_CONTENTSB
#define __p_GetComp(p, r)
number ndCopyMap(number a, const coeffs aRing, const coeffs r)
static FORCE_INLINE void n_Delete(number *p, const coeffs r)
delete 'p'
long pLDeg1c_Deg(poly p, int *l, const ring r)
number p_InitContent(poly ph, const ring r)
void p_wrp(poly p, ring lmRing, ring tailRing)
long pLDeg1c_WFirstTotalDegree(poly p, int *l, const ring r)
static unsigned long p_GetMaxExpL2(unsigned long l1, unsigned long l2, const ring r, unsigned long number_of_exp)
const CanonicalForm CFMap CFMap & N
static BOOLEAN rField_is_Zp_a(const ring r)
static FORCE_INLINE BOOLEAN n_IsZero(number n, const coeffs r)
TRUE iff 'n' represents the zero element.
BOOLEAN p_HasNotCF(poly p1, poly p2, const ring r)
poly p_mInit(const char *st, BOOLEAN &ok, const ring r)
static FORCE_INLINE BOOLEAN nCoeff_is_GF(const coeffs r)
void p_SimpleContent(poly ph, int smax, const ring r)
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....
static FORCE_INLINE BOOLEAN n_IsOne(number n, const coeffs r)
TRUE iff 'n' represents the one element.
#define POLY_NEGWEIGHT_OFFSET
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...
static BOOLEAN rField_has_Units(const ring r)
#define __p_Mult_nn(p, n, r)
void p_Lcm(const poly a, const poly b, poly m, const ring r)
BOOLEAN p_IsHomogeneous(poly p, const ring r)
static FORCE_INLINE void n_Normalize(number &n, const coeffs r)
inplace-normalization of n; produces some canonical representation of n;
LINLINE number nlSub(number la, number li, const coeffs r)
static void p_ExpVectorSub(poly p1, poly p2, const ring r)
long pLDegb(poly p, int *l, const ring r)
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,...
#define p_LmEqual(p1, p2, r)
This is a polynomial enumerator for simple iteration over coefficients of polynomials.
void p_Setm_Dummy(poly p, const ring r)
static unsigned long p_SetExp(poly p, const unsigned long e, const unsigned long iBitmask, const int VarOffset)
set a single variable exponent @Note: VarOffset encodes the position in p->exp
BOOLEAN p_LmCheckPolyRing(poly p, ring r)
static BOOLEAN rIsPluralRing(const ring r)
we must always have this test!
static int rGetCurrSyzLimit(const ring r)
static unsigned pLength(poly a)
poly n_PermNumber(const number z, const int *par_perm, const int, const ring src, const ring dst)
static FORCE_INLINE BOOLEAN nCoeff_is_Q(const coeffs r)
int r_IsRingVar(const char *n, char **names, int N)
static void p_SetExpV(poly p, int *ev, const ring r)
void p_LmDeleteAndNextRat(poly *p, int ishift, ring r)
for(int i=0;i<=n;i++) degsf[i]
long p_WFirstTotalDegree(poly p, const ring r)
static poly p_Copy(poly p, const ring r)
returns a copy of p
poly p_Power(poly p, int i, const ring r)
int p_LowVar(poly p, const ring r)
the minimal index of used variables - 1
static pFDegProc pOldFDeg
void p_DeleteComp(poly *p, int k, const ring r)
static short rVar(const ring r)
#define rVar(r) (r->N)
static long p_MinComp(poly p, ring lmRing, ring tailRing)
static void p_ExpVectorAdd(poly p1, poly p2, const ring r)
void p_Setm_Syz(poly p, ring r, int *Components, long *ShiftedComponents)
static long p_GetOrder(poly p, ring r)
#define TEST_OPT_INTSTRATEGY
BOOLEAN p_OneComp(poly p, const ring r)
return TRUE if all monoms have the same component
poly p_PermPoly(poly p, const int *perm, const ring oldRing, const ring dst, nMapFunc nMap, const int *par_perm, int OldPar, BOOLEAN use_mult)
poly p_Sub(poly p1, poly p2, const ring r)
BOOLEAN p_VectorHasUnitB(poly p, int *k, const ring r)
number(* nMapFunc)(number a, const coeffs src, const coeffs dst)
maps "a", which lives in src, into dst
static BOOLEAN rField_is_Q_a(const ring r)
static poly p_SortAdd(poly p, const ring r, BOOLEAN revert=FALSE)
static FORCE_INLINE void n_Write(number n, const coeffs r, const BOOLEAN bShortOut=TRUE)
void PrintS(const char *s)
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....
#define omFreeSize(addr, size)
static FORCE_INLINE BOOLEAN nCoeff_is_algExt(const coeffs r)
TRUE iff r represents an algebraic extension field.
long pLDeg1_WFirstTotalDegree(poly p, int *l, const ring r)
static int p_Cmp(poly p1, poly p2, ring r)
poly p_MDivide(poly a, poly b, const ring r)
poly p_Vec2Poly(poly v, int k, const ring r)
static int p_Comp_k_n(poly a, poly b, int k, ring r)
static short scaFirstAltVar(ring r)
static BOOLEAN rField_is_Ring(const ring r)
static poly p_MonMultC(poly p, poly q, const ring rr)
poly p_DivideM(poly a, poly b, const ring r)
poly p_Div_nn(poly p, const number n, const ring r)
static poly p_Subst2(poly p, int n, number e, const ring r)
sBucket_pt sBucketCreate(const ring r)
void p_ContentRat(poly &ph, const ring r)
poly p_JetW(poly p, int m, short *w, const ring R)
static BOOLEAN rIsRatGRing(const ring r)
static FORCE_INLINE BOOLEAN nCoeff_is_Q_a(const coeffs r)
static int max(int a, int b)
number ndGcd(number, number, const coeffs r)
static void p_LmDelete(poly p, const ring r)
number nlGcd(number a, number b, const coeffs r)
The main handler for Singular numbers which are suitable for Singular polynomials.
poly p_Farey(poly p, number N, const ring r)
poly p_Div_mm(poly p, const poly m, const ring r)
divide polynomial by monomial
void nlNormalize(number &x, const coeffs r)
void p_Write(poly p, ring lmRing, ring tailRing)
long pLDeg1c_Totaldegree(poly p, int *l, const ring r)
poly p_Cleardenom(poly p, const ring r)
static FORCE_INLINE number n_Mult(number a, number b, const coeffs r)
return the product of 'a' and 'b', i.e., a*b
poly p_Last(const poly p, int &l, const ring r)
void p_ProjectiveUnique(poly ph, const ring r)
static int rPar(const ring r)
(r->cf->P)
long pLDeg1c(poly p, int *l, const ring r)
int p_Compare(const poly a, const poly b, const ring R)
static FORCE_INLINE number n_Init(long i, const coeffs r)
a number representing i in the given coeff field/ring r
static BOOLEAN p_DivisibleBy(poly a, poly b, const ring r)
void p_VectorHasUnit(poly p, int *k, int *len, const ring r)
const char * p_Read(const char *st, poly &rc, const ring r)
static void p_GetExpV(poly p, int *ev, const ring r)
static poly p_Init(const ring r, omBin bin)
static int p_LmCmp(poly p, poly q, const ring r)
int p_MinDeg(poly p, intvec *w, const ring R)
static void p_ExpVectorSum(poly pr, poly p1, poly p2, const ring r)
poly p_GetMaxExpP(poly p, const ring r)
return monomial r such that GetExp(r,i) is maximum of all monomials in p; coeff == 0,...
void p_Setm_WFirstTotalDegree(poly p, const ring r)
poly p_GcdMon(poly f, poly g, const ring r)
polynomial gcd for f=mon
poly p_PolyDiv(poly &p, const poly divisor, const BOOLEAN needResult, const ring r)
assumes that p and divisor are univariate polynomials in r, mentioning the same variable; assumes div...
Concrete implementation of enumerators over polynomials.
static void pnFreeBin(number *bin, int exp, const coeffs r)
long p_WDegree(poly p, const ring r)
static FORCE_INLINE BOOLEAN nCoeff_is_Extension(const coeffs 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)
poly p_Series(int n, poly p, poly u, intvec *w, const ring R)
BOOLEAN nlGreaterZero(number za, const coeffs r)
static FORCE_INLINE BOOLEAN nCoeff_is_transExt(const coeffs r)
TRUE iff r represents a transcendental extension field.
void p_Shift(poly *p, int i, const ring r)
shifts components of the vector p by i
static poly p_Subst1(poly p, int n, const ring r)
@ n_transExt
used for all transcendental extensions, i.e., the top-most extension in an extension tower is transce...
static long p_MultExp(poly p, int v, long ee, ring r)
void p_Setm_General(poly p, const ring r)
static FORCE_INLINE number n_Farey(number a, number b, const coeffs r)
poly pp_JetW(poly p, int m, short *w, const ring R)
gmp_float exp(const gmp_float &a)
static FORCE_INLINE number n_Sub(number a, number b, const coeffs r)
return the difference of 'a' and 'b', i.e., a-b
#define p_LmCheckPolyRing2(p, r)
static void p_LmFree(poly p, ring)
poly pp_Jet(poly p, int m, const ring R)
int p_IsPurePower(const poly p, const ring r)
return i, if head depends only on var(i)
void p_ContentForGB(poly ph, const ring r)
number ntInit(long i, const coeffs cf)
static BOOLEAN rIsNCRing(const ring r)
long p_Deg(poly a, const ring r)
void p_Content(poly ph, const ring r)
void nlInpGcd(number &a, number b, const coeffs r)
static void p_Delete(poly *p, const ring r)
static poly p_Add_q(poly p, poly q, const ring r)
static BOOLEAN rField_is_GF(const ring r)
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 ...
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
poly p_TakeOutComp1(poly *p, int k, const ring r)
p_SetmProc p_GetSetmProc(const ring r)
BOOLEAN p_EqualPolys(poly p1, poly p2, const ring r)
poly p_TakeOutComp(poly *p, int k, const ring r)
void rWrite(ring r, BOOLEAN details)
static int si_max(const int a, const int b)
static unsigned long p_AddComp(poly p, unsigned long v, ring r)
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...
void pSetDegProcs(ring r, pFDegProc new_FDeg, pLDegProc new_lDeg)
long pLDeg1_Deg(poly p, int *l, const ring r)
LINLINE number nlAdd(number la, number li, const coeffs r)
BOOLEAN p_CheckPolyRing(poly p, ring r)
#define rRing_has_Comp(r)
poly p_NSet(number n, const ring r)
returns the poly representing the number n, destroys n
@ ringorder_IS
Induced (Schreyer) ordering.
void Werror(const char *fmt,...)
static BOOLEAN pOldLexOrder
static short scaLastAltVar(ring r)
static number p_SetCoeff(poly p, number n, ring r)
void p_Vec2Polys(poly v, poly **p, int *len, const ring r)
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),...
static FORCE_INLINE number n_Copy(number n, const coeffs r)
return a copy of 'n'
static int _componentsExternal
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,...
void WerrorS(const char *s)
static poly p_Pow(poly p, int i, const ring r)
static BOOLEAN rField_has_simple_inverse(const ring r)
static poly p_DiffOpM(poly a, poly b, BOOLEAN multiply, const ring r)
static long p_AddExp(poly p, int v, long ee, ring r)
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:...
static FORCE_INLINE number n_ChineseRemainderSym(number *a, number *b, int rl, BOOLEAN sym, CFArray &inv_cache, const coeffs r)
unsigned long p_GetMaxExpL(poly p, const ring r, unsigned long l_max)
return the maximal exponent of p in form of the maximal long var
const char * eati(const char *s, int *i)
void p_SetModDeg(intvec *w, ring r)
#define p_LmCheckPolyRing1(p, r)
static unsigned long p_SetComp(poly p, unsigned long c, ring r)
static long * _componentsShifted
static FORCE_INLINE number n_SubringGcd(number a, number b, const coeffs r)
long p_WTotaldegree(poly p, const ring r)
poly p_GetCoeffRat(poly p, int ishift, ring r)
static FORCE_INLINE void n_Power(number a, int b, number *res, const coeffs r)
fill res with the power a^b
static void p_Setm(poly p, const ring r)
static unsigned long GetBitFields(const long e, const unsigned int s, const unsigned int n)
static poly p_GetExp_k_n(poly p, int l, int k, const ring r)
static void p_SplitAndReversePoly(poly p, int n, poly *non_zero, poly *zero, const ring r)
const Variable & v
< [in] a sqrfree bivariate poly
static long p_IncrExp(poly p, int v, ring r)
BOOLEAN rSamePolyRep(ring r1, ring r2)
returns TRUE, if r1 and r2 represents the monomials in the same way FALSE, otherwise this is an analo...
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.
void(* p_SetmProc)(poly p, const ring r)
static long p_Totaldegree(poly p, const ring r)
static BOOLEAN p_ExpVectorEqual(poly p1, poly p2, const ring r1, const ring r2)
static BOOLEAN p_IsConstant(const poly p, const ring r)
int p_Size(poly p, const ring r)
static void p_MonMult(poly p, poly q, const ring r)
void p_Vec2Array(poly v, poly *p, int len, const ring r)
vector to already allocated array (len>=p_MaxComp(v,r))
@ ringorder_aa
for idElimination, like a, except pFDeg, pWeigths ignore it
const CanonicalForm int s
poly p_DiffOp(poly a, poly b, BOOLEAN multiply, const ring r)
int status int void size_t count
static BOOLEAN rIsSyzIndexRing(const ring r)
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 nMapFunc n_SetMap(const coeffs src, const coeffs dst)
set the mapping function pointers for translating numbers from src to dst
void p_Norm(poly p1, const ring r)
poly p_ISet(long i, const ring r)
returns the poly representing the integer i
void p_Setm_TotalDegree(poly p, const ring r)
int comp(const CanonicalForm &A, const CanonicalForm &B)
compare polynomials
static poly p_Mult_q(poly p, poly q, const ring r)
@ ringorder_rs
opposite of ls
@ ringorder_a64
for int64 weights
static number & pGetCoeff(poly p)
return an alias to the leading coefficient of p assumes that p != NULL NOTE: not copy
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...
static bool rIsSCA(const ring r)
#define n_Test(a, r)
BOOLEAN n_Test(number a, const coeffs r)
LINLINE void nlDelete(number *a, const coeffs r)
unsigned long p_GetShortExpVector(const poly p, const ring r)
static BOOLEAN rField_is_Zp(const ring r)
static poly p_Subst0(poly p, int n, const ring r)
static long p_MaxComp(poly p, ring lmRing, ring tailRing)
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)
BOOLEAN p_DivisibleByRingCase(poly f, poly g, const ring r)
divisibility check over ground ring (which may contain zero divisors); TRUE iff LT(f) divides LT(g),...
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.
static poly pReverse(poly p)
static long p_DecrExp(poly p, int v, ring r)
poly nc_pSubst(poly p, int n, poly e, const ring r)
substitute the n-th variable by e in p destroy p e is not a constant
poly p_Jet(poly p, int m, const ring R)
static long pModDeg(poly p, ring r)
@ n_algExt
used for all algebraic extensions, i.e., the top-most extension in an extension tower is algebraic
poly p_Diff(poly a, int k, const ring r)
static BOOLEAN rField_is_Q(const ring r)
#define omReallocSize(addr, o_size, size)
void p_Cleardenom_n(poly ph, const ring r, number &c)
int p_Weight(int i, const ring r)