40#define BITS_PER_LONG 8*SIZEOF_LONG
110 r->names = (
char **)
omAlloc0(
N *
sizeof(
char *));
124 if (bitmask!=0) r->wanted_maxExp=bitmask;
143 int *block0 = (
int *)
omAlloc0(2 *
sizeof(
int));
144 int *block1 = (
int *)
omAlloc0(2 *
sizeof(
int));
179 WerrorS(
"weights only for orderings wp,ws,Wp,Ws,a,M");
191 WerrorS(
"Matrix order is not a square matrix");
194 while ((
i<
sz) && (typ==1))
197 while ((
j<
sz) && ((*order)[
j*
sz+
i+2]==0))
j++;
201 WerrorS(
"Matrix order not complete");
203 else if ((*order)[
j*
sz+
i+2]<0)
216 for (
int i=0;
i<
N;
i++)
218 if (names[
i]==
NULL)
return -1;
219 if (
strcmp(n,names[
i]) == 0)
return (
int)
i;
248 PrintS(
"// coefficients: ");
303 Print(
"// number of vars : %d",r->N);
311 Print(
"\n// block %3d : ",
l+1);
318 assume( r->block0[
l] == r->block1[
l] );
319 const int s = r->block0[
l];
327 Print(
" syz_comp: %d",r->block0[
l]);
339 for (
i = r->block0[
l]-1;
i<r->block1[
l];
i++)
346 if (r->wvhdl[
l]!=
NULL)
358 Warn(
"should not have wvhdl entry at pos. %d",
l);
362 j<(r->block1[
l]-r->block0[
l]+1)*(r->block1[
l]-r->block0[
l]+1);
365 PrintS(
"\n// : weights ");
366 for (
i = 0;
i<=r->block1[
l]-r->block0[
l];
i++)
384 int m=r->wvhdl[
l][
i];
385 Print(
"\n// : %d module weights ",
m);
394 PrintS(
"\n// noncommutative relations:");
400 for (
i = 1;
i<r->N;
i++)
402 for (
j =
i+1;
j<=r->N;
j++)
407 Print(
"\n// %s%s=",r->names[
j-1],r->names[
i-1]);
418 Print(
"\n// is skew constant:%d",r->GetNC()->IsSkewConstant);
423 PrintS(
"\n// quotient of sca by ideal");
436 Print(
"\n// letterplace ring (block size %d, ncgen count %d)",r->isLPring, r->LPncGenCount);
441 PrintS(
"\n// quotient ring from ideal");
454 if (r ==
NULL)
return;
458 if( r->qideal !=
NULL )
473 if (r->order !=
NULL)
484 if (r->wvhdl[
j]!=
NULL)
497 for (
i=0;
i<r->N;
i++)
545 if (r->wvhdl[
l]!=
NULL)
557 Warn(
"should not have wvhdl entry at pos. %d",
l);
565 j<(r->block1[
l]-r->block0[
l]+1)*(r->block1[
l]-r->block0[
l]+1);
572 for (
i = 0;
i<r->block1[
l]-r->block0[
l];
i++)
581 for (
i = 0;
i<r->block1[
l]-r->block0[
l];
i++)
591 if (
j+
i+1==(r->block1[
l]-r->block0[
l]+1)*(r->block1[
l]-r->block0[
l]+1))
602 assume( r->block0[
l] == r->block1[
l] );
603 const int s = r->block0[
l];
611 if (r->wanted_maxExp!=0)
613 long mm=r->wanted_maxExp;
630 for (
i=0;
i<r->N;
i++)
636 for (
i=0;
i<r->N-1;
i++)
728 for(
int i=1;
i<r->N;
i++)
729 for(
int j=
i+1;
j<=r->N;
j++)
733 WarnS(
"Error initializing multiplication!");
788 && (
mpz_cmp(
r1->cf->modNumber,
r2->cf->extRing->cf->modNumber)==0))
821 if (
r1->cf->extRing->cf==
r2->cf)
831 WerrorS (
"coeff sum of two extension fields not implemented");
837 WerrorS(
"coeff sum not yet implemented");
844 char **names=(
char **)
omAlloc0(
l*
sizeof(
char *));
849 for (
i=0;
i<
r1->N;
i++)
853 if (*(
r1->names[
i]) ==
'\0')
885 if (*(
r2->names[
i]) ==
'\0')
977 if ((
r2->block0[0]==1)
984 tmpR.order[1]=
r2->order[0];
990 int l=
r2->block1[0]-
r2->block0[0]+1;
995 l+=
r2->wvhdl[1][
r2->block1[0]-
r2->block0[0]+1]+1;
1066 WarnS(
"rSum: weights not implemented");
1072 for (
i=0;
r1->order[
i]!=0;
i++)
1082 int l=
r1->block1[
i]-
r1->block0[
i]+1;
1087 l+=
r1->wvhdl[
i][
r1->block1[
i]-
r1->block0[
i]+1]+1;
1102 for (
i=0;
r2->order[
i]!=0;
i++)
1116 int l=
r2->block1[
i]-
r2->block0[
i]+1;
1121 l+=
r2->wvhdl[
i][
r2->block1[
i]-
r2->block0[
i]+1]+1;
1131 if((
r1->OrdSgn==-1)||(
r2->OrdSgn==-1))
1157 int l=
r1->block1[
i]-
r1->block0[
i]+1;
1162 l+=
r1->wvhdl[
i][
r1->block1[
i]-
r1->block0[
i]+1]+1;
1263 MATELEM(C,
i,
j) =
p_PermPoly(
MATELEM(
C1,
i,
j),
perm1,
R1,
sum,
nMap1,
par_perm1,
rPar(
R1));
1266 MATELEM(
D,
i,
j) =
p_PermPoly(
MATELEM(
D1,
i,
j),
perm1,
R1,
sum,
nMap1,
par_perm1,
rPar(
R1));
1279 MATELEM(C,
rVar(
R1)+
i,
rVar(
R1)+
j) =
p_PermPoly(
MATELEM(
C2,
i,
j),
perm2,
R2,
sum,
nMap2,
par_perm2,
rPar(
R2));
1282 MATELEM(
D,
rVar(
R1)+
i,
rVar(
R1)+
j) =
p_PermPoly(
MATELEM(
D2,
i,
j),
perm2,
R2,
sum,
nMap2,
par_perm2,
rPar(
R2));
1290 WarnS(
"Error initializing non-commutative multiplication!");
1299 Print(
"\nRefs: R1: %d, R2: %d\n",
R1->GetNC()->ref,
R2->GetNC()->ref);
1428 res->options=r->options;
1443 res->firstBlockEnds=r->firstBlockEnds;
1445 res->real_var_start=r->real_var_start;
1446 res->real_var_end=r->real_var_end;
1450 res->isLPring=r->isLPring;
1451 res->LPncGenCount=r->LPncGenCount;
1454 res->VectorOut=r->VectorOut;
1455 res->ShortOut=r->ShortOut;
1456 res->CanShortOut=r->CanShortOut;
1472 res->bitmask=r->bitmask;
1473 res->divmask=r->divmask;
1474 res->BitsPerExp = r->BitsPerExp;
1475 res->ExpPerLong = r->ExpPerLong;
1496 res->LexOrder=r->LexOrder;
1497 res->MixedOrder=r->MixedOrder;
1505 if (r->wvhdl[
j]!=
NULL)
1511 int l=r->block1[
j]-r->block0[
j]+1;
1516 l+=r->wvhdl[
j][r->block1[
j]-r->block0[
j]+1]+1;
1527 memcpy(
res->block0,r->block0,
i *
sizeof(
int));
1528 memcpy(
res->block1,r->block1,
i *
sizeof(
int));
1543 if (r->qideal!=
NULL)
1572 res->options=r->options;
1587 res->firstBlockEnds=r->firstBlockEnds;
1589 res->real_var_start=r->real_var_start;
1590 res->real_var_end=r->real_var_end;
1594 res->isLPring=r->isLPring;
1595 res->LPncGenCount=r->LPncGenCount;
1598 res->VectorOut=r->VectorOut;
1599 res->ShortOut=r->ShortOut;
1600 res->CanShortOut=r->CanShortOut;
1601 res->LexOrder=r->LexOrder;
1602 res->MixedOrder=r->MixedOrder;
1618 res->bitmask=r->bitmask;
1619 res->divmask=r->divmask;
1620 res->BitsPerExp = r->BitsPerExp;
1621 res->ExpPerLong = r->ExpPerLong;
1647 for (
j=0;
j<
i-1;
j++)
1649 if (r->wvhdl[
j]!=
NULL)
1655 int l=r->block1[
j]-r->block0[
j]+1;
1660 l+=r->wvhdl[
j][r->block1[
j]-r->block0[
j]+1]+1;
1671 memcpy(&(
res->block0[1]),r->block0,(
i-1) *
sizeof(
int));
1672 memcpy(&(
res->block1[1]),r->block1,(
i-1) *
sizeof(
int));
1690 res->wvhdl[0]=(
int *)
A;
1700 if (r->qideal!=
NULL)
1706 WerrorS(
"internal error: rCopy0(Q,TRUE,FALSE)");
1711 WarnS(
"internal bad stuff: rCopy0(Q,TRUE,TRUE)");
1752 if (
r1->bitmask!=
r2->bitmask)
return FALSE;
1753 #ifdef HAVE_SHIFTBBA
1754 if (
r1->isLPring!=
r2->isLPring)
return FALSE;
1755 if (
r1->LPncGenCount!=
r2->LPncGenCount)
return FALSE;
1807 if ((
r1->cf !=
r2->cf)
1809 || (
r1->OrdSgn !=
r2->OrdSgn))
1813 while (
r1->order[
i] != 0)
1815 if (
r2->order[
i] == 0)
return FALSE;
1816 if ((
r1->order[
i] !=
r2->order[
i])
1817 || (
r1->block0[
i] !=
r2->block0[
i])
1818 || (
r1->block1[
i] !=
r2->block1[
i]))
1824 for (
j=0;
j<
r1->block1[
i]-
r1->block0[
i]+1;
j++)
1825 if (
r2->wvhdl[
i][
j] !=
r1->wvhdl[
i][
j])
1831 if (
r2->order[
i] != 0)
return FALSE;
1998 for (pos=0;pos<r->OrdSize;pos++)
2016 return (
rVar(r) > 1 &&
2022 ((r->order[1]!=0) &&
2028 return (
rVar(r) > 1 &&
2030 ((r->order[1]==
ringorder_dp)&&(r->block1[1]==r->N)&&((r->block0[1]==1))));
2035 return (
rVar(r) > 1 &&
2037 ((r->order[1]==
ringorder_ds)&&(r->block1[1]==r->N)&&((r->block0[1]==1))));
2044 return ((
rVar(r) > 1) &&
2063 if (r->N == 0)
return TRUE;
2065 if ((r->OrdSgn!=1) && (r->OrdSgn!= -1))
2077 for(
int j=0;
j<=
i;
j++)
2080 dError(
"wrong order in r->order");
2091 if (r->VarOffset ==
NULL)
2093 dReportError(
"Null ring VarOffset -- no rComplete (?) in n %s:%d",
fn,
l);
2098 if ((r->OrdSize==0)!=(r->typ==
NULL))
2100 dReportError(
"mismatch OrdSize and typ-pointer in %s:%d");
2106 for(
i=0;
i<=r->N;
i++)
2110 for(
j=0;
j<r->OrdSize;
j++)
2114 const int p = r->typ[
j].data.isTemp.suffixpos;
2121 if(r->typ[
p].ord_typ !=
ro_is)
2122 dReportError(
"ordrec prefix %d is unmatched (suffix: %d is wrong!!!)",
j,
p);
2125 if(r->typ[
j].data.isTemp.pVarOffset[
i] != -1)
2131 else if (r->typ[
j].ord_typ ==
ro_is)
2134 if(r->typ[
j].data.is.pVarOffset[
i] != -1)
2142 if (r->typ[
j].ord_typ==
ro_cp)
2144 if(((
short)r->VarOffset[
i]) == r->typ[
j].data.cp.place)
2149 && (r->VarOffset[
i] == r->typ[
j].data.dp.place))
2155 tmp=r->VarOffset[
i] & 0xffffff;
2156 #if SIZEOF_LONG == 8
2157 if ((r->VarOffset[
i] >> 24) >63)
2159 if ((r->VarOffset[
i] >> 24) >31)
2161 dReportError(
"bit_start out of range:%d",r->VarOffset[
i] >> 24);
2162 if (
i > 0 && ((
tmp<0) ||(
tmp>r->ExpL_Size-1)))
2169 for(
j=0;
j<r->OrdSize;
j++)
2171 if ((r->typ[
j].ord_typ==
ro_dp)
2172 || (r->typ[
j].ord_typ==
ro_wp)
2175 if (r->typ[
j].data.dp.start > r->typ[
j].data.dp.end)
2177 r->typ[
j].data.dp.start, r->typ[
j].data.dp.end);
2178 if ((r->typ[
j].data.dp.start < 1)
2179 || (r->typ[
j].data.dp.end > r->N))
2180 dReportError(
"in ordrec %d: start(%d)<1 or end(%d)>vars(%d)",
j,
2181 r->typ[
j].data.dp.start, r->typ[
j].data.dp.end,r->N);
2245 while((start<end) && (weights[0]==0)) { start++; weights++; }
2246 while((start<end) && (weights[end-start]==0)) { end--; }
2249 for(
i=start;
i<=end;
i++)
2251 if(weights[
i-start]!=1)
2271 for(
i=start;
i<=end;
i++)
2273 if(weights[
i-start]<0)
2295 ord_struct.data.am.weights_m = weights + (end-start+1);
2296 ord_struct.data.am.len_gen=weights[end-start+1];
2331 while((start<end) && (weights[0]==0)) { start++; weights++; }
2332 while((start<end) && (weights[end-start]==0)) { end--; }
2343 for(
i=start;
i<=end;
i++)
2345 if(weights[
i-start]<0)
2515 int *pVarOffset =
tmp_typ[
typ_j].data.isTemp.pVarOffset;
2533 for(
int i = 0;
i <=
N;
i++ )
2536 if(
v[
i] != pVarOffset[
i] )
2538 pVarOffset[
i] =
v[
i];
2540 assume( pVarOffset[
i] != -1 );
2546 if( pVarOffset[0] != -1 )
2547 pVarOffset[0] &= 0x0fff;
2588 bits=16; bitmask=0xffff;
2590 else if (bitmask <= 1L)
2592 bits=1; bitmask = 1L;
2594 else if (bitmask <= 3L)
2596 bits=2; bitmask = 3L;
2598 else if (bitmask <= 7L)
2602 else if (bitmask <= 0xfL)
2604 bits=4; bitmask=0xfL;
2606 else if (bitmask <= 0x1fL)
2608 bits=5; bitmask=0x1fL;
2610 else if (bitmask <= 0x3fL)
2612 bits=6; bitmask=0x3fL;
2615 else if (bitmask <= 0x7fL)
2617 bits=7; bitmask=0x7fL;
2620 else if (bitmask <= 0xffL)
2622 bits=8; bitmask=0xffL;
2625 else if (bitmask <= 0x1ffL)
2627 bits=9; bitmask=0x1ffL;
2630 else if (bitmask <= 0x3ffL)
2632 bits=10; bitmask=0x3ffL;
2635 else if (bitmask <= 0xfffL)
2637 bits=12; bitmask=0xfff;
2640 else if (bitmask <= 0xffffL)
2642 bits=16; bitmask=0xffffL;
2645 else if (bitmask <= 0xfffffL)
2647 bits=20; bitmask=0xfffffL;
2649 else if (bitmask <= 0xffffffffL)
2651 bits=32; bitmask=0xffffffffL;
2653 else if (bitmask <= 0x7fffffffffffffffL)
2655 bits=63; bitmask=0x7fffffffffffffffL;
2659 bits=63; bitmask=0x7fffffffffffffffL;
2662 else if (bitmask <= 0x7fffffff)
2664 bits=31; bitmask=0x7fffffff;
2668 bits=31; bitmask=0x7fffffffL;
2739 if (r->block0[
i]==r->block1[
i])
2764 Warn(
"Error: unhandled ordering in rModifyRing: ringorder_S = [%d]",
r_ord);
2843 block0[
j]=r->block0[
i];
2844 block1[
j]=r->block1[
i];
2845 wvhdl[
j]=r->wvhdl[
i];
2871 res->wanted_maxExp=r->wanted_maxExp;
2878 if (r->pFDegOrig !=
res->pFDegOrig &&
2883 res->firstwv = r->firstwv;
2884 res->firstBlockEnds = r->firstBlockEnds;
2888 res->pLDeg = r->pLDegOrig;
2897 res->typ[0] = r->typ[0];
2899 if (r->typ[0].data.syz.limit > 0)
2901 res->typ[0].data.syz.syz_index
2902 = (
int*)
omAlloc((r->typ[0].data.syz.limit +1)*
sizeof(
int));
2903 memcpy(
res->typ[0].data.syz.syz_index, r->typ[0].data.syz.syz_index,
2904 (r->typ[0].data.syz.limit +1)*
sizeof(
int));
2917 r->typ[
i].data.is.limit,
2928 res->OrdSgn=r->OrdSgn;
2937 WarnS(
"error in nc_rComplete");
2950 WarnS(
"error in sca_Force!");
2976 res->block1[0] = r->N;
2977 res->wvhdl[0] = weights;
2992 WarnS(
"error in nc_rComplete");
3043 res->wanted_maxExp=r->wanted_maxExp;
3054 WarnS(
"error in nc_rComplete");
3098 r->CanShortOut=
FALSE;
3101 r->CanShortOut =
TRUE;
3109 r->CanShortOut=
FALSE;
3117 for (
i=(
N-1);
i>=0;
i--)
3121 r->CanShortOut=
FALSE;
3127 r->ShortOut = r->CanShortOut;
3129 assume( !( !r->CanShortOut && r->ShortOut ) );
3137 if(block1[
i]!=r->N) r->LexOrder=
TRUE;
3138 r->firstBlockEnds=block1[
i];
3139 r->firstwv = wvhdl[
i];
3148 for(
j=block1[
i]-block0[
i];
j>=0;
j--)
3150 if (r->firstwv[
j]==0) r->LexOrder=
TRUE;
3157 for(
j=block1[
i]-block0[
i];
j>=0;
j--)
3159 if (
w[
j]==0) r->LexOrder=
TRUE;
3166 if (r->pFDeg ==
p_Deg)
3187 r->pLDegOrig = r->pLDeg;
3194 int* block0 = r->block0;
3195 int* block1 = r->block1;
3196 int** wvhdl = r->wvhdl;
3205 r->LexOrder =
FALSE;
3212 for(
int ii=block0[0];
ii<=block1[0];
ii++)
3213 if (wvhdl[0][
ii-1]<0) { r->MixedOrder=2;
break;}
3215 for(
int ii=block0[0];
ii<=block1[0];
ii++)
3216 if (wvhdl[0][
ii-1]==0) { r->LexOrder=
TRUE;
break;}
3217 if ((block0[0]==1)&&(block1[0]==r->N))
3228 r->firstwv = wvhdl[0];
3240 if (r->OrdSgn == -1) r->pLDeg =
pLDeg0c;
3259 for(
int ii=block0[0];
ii<=block1[0];
ii++)
3261 if (wvhdl[0][
ii-1]<0) { r->MixedOrder=2;
break;}
3263 if (r->MixedOrder==0)
3265 if ((block0[0]==1)&&(block1[0]==r->N))
3273 r->firstBlockEnds=block1[0];
3274 r->firstwv = wvhdl[0];
3293 r->firstBlockEnds=block1[1];
3294 if (wvhdl!=
NULL) r->firstwv = wvhdl[1];
3302 for(
int ii=block0[1];
ii<=block1[1];
ii++)
3303 if (wvhdl[1][
ii-1]<0) { r->MixedOrder=2;
break;}
3304 if (r->MixedOrder==
FALSE)
3337 if(r->MixedOrder==
FALSE)
3352 r->pFDegOrig = r->pFDeg;
3367 for(
i=0;
i<r->OrdSize;
i++)
3370 ||(r->typ[
i].ord_typ==
ro_am))
3375 r->NegWeightL_Size=
l;
3376 r->NegWeightL_Offset=(
int *)
omAlloc(
l*
sizeof(
int));
3378 for(
i=0;
i<r->OrdSize;
i++)
3382 r->NegWeightL_Offset[
l]=r->typ[
i].data.wp.place;
3385 else if(r->typ[
i].ord_typ==
ro_am)
3387 r->NegWeightL_Offset[
l]=r->typ[
i].data.am.place;
3394 r->NegWeightL_Size = 0;
3395 r->NegWeightL_Offset =
NULL;
3407 if ( (r->cf->extRing!=
NULL)
3416 if (r->LexOrder || r->OrdSgn == -1 || (r->cf->extRing!=
NULL))
3433 r->pLexOrder=r->LexOrder;
3441static inline int sign(
int x) {
return (
x > 0) - (
x < 0);}
3472 r->BitsPerExp =
bits;
3480 for(
i=r->N;
i>=0 ;
i--)
3497 switch (r->order[
i])
3521 r->ComponentOrder=1;
3527 r->ComponentOrder=-1;
3533 k=r->block1[
i]-r->block0[
i]+1;
3538 r->wvhdl[
i]+(r->block1[
i]-r->block0[
i]+1)*
l);
3565 if (r->block0[
i]==r->block1[
i])
3581 if (r->block0[
i]==r->block1[
i])
3597 if (r->block0[
i]==r->block1[
i])
3613 if (r->block0[
i]==r->block1[
i])
3635 for(
jj=r->block1[
i]-r->block0[
i];
jj>=0;
jj--)
3646 if (r->block1[
i]!=r->block0[
i])
3660 for(
jj=r->block1[
i]-r->block0[
i];
jj>=0;
jj--)
3671 if (r->block1[
i]!=r->block0[
i])
3682 if (r->block1[
i]!=r->block0[
i])
3693 if (r->block1[
i]!=r->block0[
i])
3705 r->ComponentOrder=-1;
3713 r->ComponentOrder=-1;
3720 assume( r->block0[
i] == r->block1[
i] );
3721 const int s = r->block0[
i];
3767 for(
i=1 ;
i<=r->N ;
i++)
3794 r->ordsgn=(
long *)
omAlloc0(r->ExpL_Size*
sizeof(
long));
3796 for(
j=0;
j<r->CmpL_Size;
j++)
3821 r->pCompIndex=(r->VarOffset[0] & 0xffff);
3824 if (
i==r->pCompIndex)
i++;
3833 if (
i==r->pCompIndex)
i++;
3871 for(
int i=1;
i<=r->N;
i++)
3878 if ((r->block0[
j]<=
i)&&(r->block1[
j]>=
i))
3898 if(r->wvhdl[
j][
i-r->block0[
j]]<0)
3904 else if(r->wvhdl[
j][
i-r->block0[
j]]>0)
3915 if(r->wvhdl[
j][
i-r->block0[
j]]<0)
3921 else if(r->wvhdl[
j][
i-r->block0[
j]]>0)
3929 int add=r->block1[
j]-r->block0[
j]+1;
3934 if (r->wvhdl[
j][
i-r->block0[
j]]<0)
3940 else if(r->wvhdl[
j][
i-r->block0[
j]]>0)
3970 if (
nonneg>0) r->MixedOrder=1;
3981 if (r ==
NULL)
return;
3982 if (r->VarOffset !=
NULL)
3984 if (r->OrdSize!=0 && r->typ !=
NULL)
3986 for(
int i = 0;
i < r->OrdSize;
i++)
3987 if( r->typ[
i].ord_typ ==
ro_is)
3991 if( r->typ[
i].data.is.pVarOffset !=
NULL )
3996 else if (r->typ[
i].ord_typ ==
ro_syz)
3998 if(r->typ[
i].data.syz.limit > 0)
3999 omFreeSize(r->typ[
i].data.syz.syz_index, ((r->typ[
i].data.syz.limit) +1)*
sizeof(
int));
4003 assume( r->typ[
i].data.syzcomp.ShiftedComponents ==
NULL );
4004 assume( r->typ[
i].data.syzcomp.Components ==
NULL );
4014 if (r->PolyBin !=
NULL)
4020 if (r->ordsgn !=
NULL && r->CmpL_Size != 0)
4025 if (r->p_Procs !=
NULL)
4030 omfreeSize(r->VarL_Offset, r->VarL_Size*
sizeof(
int));
4031 r->VarL_Offset=
NULL;
4033 if (r->NegWeightL_Offset!=
NULL)
4035 omFreeSize(r->NegWeightL_Offset, r->NegWeightL_Size*
sizeof(
int));
4036 r->NegWeightL_Offset=
NULL;
4049 for (
i=1;
i<=r->N;
i++)
4055 for (
i=0,
j=0;
i<r->ExpL_Size;
i++)
4070 r->VarL_Offset = (
int*)
omAlloc(r->VarL_Size*
sizeof(
int));
4071 r->VarL_LowIndex = 0;
4074 for (
i=0,
j=0;
i<r->ExpL_Size;
i++)
4078 r->VarL_Offset[
j] =
i;
4079 if (
j > 0 && r->VarL_Offset[
j-1] != r->VarL_Offset[
j] - 1)
4080 r->VarL_LowIndex = -1;
4084 if (r->VarL_LowIndex >= 0)
4085 r->VarL_LowIndex = r->VarL_Offset[0];
4089 j = r->VarL_Offset[
min_j];
4090 r->VarL_Offset[
min_j] = r->VarL_Offset[0];
4091 r->VarL_Offset[0] =
j;
4101 for (
i=0;
i<r->ExpL_Size;
i++)
4105 for (
i=1;
i<=r->N;
i++)
4107 if (
shifts[r->VarOffset[
i] & 0xffffff] > r->VarOffset[
i] >> 24)
4108 shifts[r->VarOffset[
i] & 0xffffff] = r->VarOffset[
i] >> 24;
4111 for (
i=1;
i<=r->N;
i++)
4113 if (
shifts[r->VarOffset[
i] & 0xffffff] != 0)
4115 = (r->VarOffset[
i] & 0xffffff) |
4116 (((r->VarOffset[
i] >> 24) -
shifts[r->VarOffset[
i] & 0xffffff]) << 24);
4124 unsigned long divmask = 1;
4129 divmask |= (((
unsigned long) 1) << (
unsigned long)
i);
4144 const char *
TYP[]={
"ro_dp",
"ro_wp",
"ro_am",
"ro_wp64",
"ro_wp_neg",
"ro_cp",
4145 "ro_syzcomp",
"ro_syz",
"ro_isTemp",
"ro_is",
"ro_none"};
4148 Print(
"ExpL_Size:%d ",r->ExpL_Size);
4149 Print(
"CmpL_Size:%d ",r->CmpL_Size);
4150 Print(
"VarL_Size:%d\n",r->VarL_Size);
4151 Print(
"bitmask=0x%lx (expbound=%ld) \n",r->bitmask, r->bitmask);
4152 Print(
"divmask=%lx\n", r->divmask);
4153 Print(
"BitsPerExp=%d ExpPerLong=%d at L[%d]\n", r->BitsPerExp, r->ExpPerLong, r->VarL_Offset[0]);
4155 Print(
"VarL_LowIndex: %d\n", r->VarL_LowIndex);
4156 PrintS(
"VarL_Offset:\n");
4159 for(
j = 0;
j < r->VarL_Size;
j++)
4160 Print(
" VarL_Offset[%d]: %d ",
j, r->VarL_Offset[
j]);
4167 for(
j=0;
j<=r->N;
j++)
4168 Print(
" v%d at e-pos %d, bit %d\n",
4169 j,r->VarOffset[
j] & 0xffffff, r->VarOffset[
j] >>24);
4171 for(
j=0;
j<r->CmpL_Size;
j++)
4172 Print(
" ordsgn %ld at pos %d\n",r->ordsgn[
j],
j);
4173 Print(
"OrdSgn:%d\n",r->OrdSgn);
4175 for(
j=0;
j<r->OrdSize;
j++)
4177 Print(
" typ %s",
TYP[r->typ[
j].ord_typ]);
4178 if (r->typ[
j].ord_typ==
ro_syz)
4180 const short place = r->typ[
j].data.syz.place;
4181 const int limit = r->typ[
j].data.syz.limit;
4182 const int curr_index = r->typ[
j].data.syz.curr_index;
4183 const int* syz_index = r->typ[
j].data.syz.syz_index;
4185 Print(
" limit %d (place: %d, curr_index: %d), syz_index: ", limit, place, curr_index);
4187 if( syz_index ==
NULL )
4192 for(
i=0;
i <= limit;
i++ )
4193 Print(
"%d ", syz_index[
i]);
4200 Print(
" start (level) %d, suffixpos: %d, VO: ",r->typ[
j].data.isTemp.start, r->typ[
j].data.isTemp.suffixpos);
4203 else if (r->typ[
j].ord_typ==
ro_is)
4205 Print(
" start %d, end: %d: ",r->typ[
j].data.is.start, r->typ[
j].data.is.end);
4209 Print(
" limit %d",r->typ[
j].data.is.limit);
4216 else if (r->typ[
j].ord_typ==
ro_am)
4218 Print(
" place %d",r->typ[
j].data.am.place);
4219 Print(
" start %d",r->typ[
j].data.am.start);
4220 Print(
" end %d",r->typ[
j].data.am.end);
4221 Print(
" len_gen %d",r->typ[
j].data.am.len_gen);
4224 for(
l=r->typ[
j].data.am.start;
l<=r->typ[
j].data.am.end;
l++)
4225 Print(
" %d",r->typ[
j].data.am.weights[
l-r->typ[
j].data.am.start]);
4226 l=r->typ[
j].data.am.end+1;
4227 int ll=r->typ[
j].data.am.weights[
l-r->typ[
j].data.am.start];
4230 Print(
" %d",r->typ[
j].data.am.weights[
lll-r->typ[
j].data.am.start]);
4234 Print(
" place %d",r->typ[
j].data.dp.place);
4238 Print(
" start %d",r->typ[
j].data.dp.start);
4239 Print(
" end %d",r->typ[
j].data.dp.end);
4240 if ((r->typ[
j].ord_typ==
ro_wp)
4244 for(
int l=r->typ[
j].data.wp.start;
l<=r->typ[
j].data.wp.end;
l++)
4245 Print(
" %d",r->typ[
j].data.wp.weights[
l-r->typ[
j].data.wp.start]);
4247 else if (r->typ[
j].ord_typ==
ro_wp64)
4251 for(
l=r->typ[
j].data.wp64.start;
l<=r->typ[
j].data.wp64.end;
l++)
4252 Print(
" %ld",(
long)(r->typ[
j].data.wp64.weights64+
l-r->typ[
j].data.wp64.start));
4258 Print(
"pOrdIndex:%d pCompIndex:%d\n", r->pOrdIndex, r->pCompIndex);
4259 Print(
"OrdSize:%d\n",r->OrdSize);
4260 PrintS(
"--------------------\n");
4261 for(
j=0;
j<r->ExpL_Size;
j++)
4265 Print(
"ordsgn %ld ", r->ordsgn[
j]);
4271 if( (r->VarOffset[
i] & 0xffffff) ==
j )
4272 {
Print(
"v%d at e[%d], bit %d; ",
i,r->VarOffset[
i] & 0xffffff,
4273 r->VarOffset[
i] >>24 ); }
4275 if( r->pCompIndex==
j )
PrintS(
"v0; ");
4276 for(
i=0;
i<r->OrdSize;
i++)
4278 if (r->typ[
i].data.dp.place ==
j)
4280 Print(
"ordrec:%s (start:%d, end:%d) ",
TYP[r->typ[
i].ord_typ],
4281 r->typ[
i].data.dp.start, r->typ[
i].data.dp.end);
4285 if (
j==r->pOrdIndex)
4290 Print(
"LexOrder:%d, MixedOrder:%d\n",r->LexOrder, r->MixedOrder);
4292 Print(
"NegWeightL_Size: %d, NegWeightL_Offset: ", r->NegWeightL_Size);
4293 if (r->NegWeightL_Offset==
NULL)
PrintS(
" NULL");
4295 for(
j = 0;
j < r->NegWeightL_Size;
j++)
4296 Print(
" [%d]: %d ",
j, r->NegWeightL_Offset[
j]);
4317#define pFDeg_CASE(A) if(r->pFDeg == A) PrintS( "" #A "" )
4323 Print(
"(%p)", r->pFDeg);
4326 Print(
"pLDeg : (%p)", r->pLDeg);
4338 else Print(
"%p\n",r->p_Setm);
4348 Print(
"\nexp[0..%d]\n",r->ExpL_Size-1);
4349 for(
i=0;
i<r->ExpL_Size;
i++)
4357 if (
j==0) {
PrintS(
"...\n");
break; }
4366 Print(
"\nexp[0..%d]\n",
R->ExpL_Size - 1);
4367 for(
int i = 0;
i <
R->ExpL_Size;
i++)
4456 WarnS(
"rAssure_SyzComp: input ring has an IS-ordering!");
4467 int ** wvhdl =(
int **)
omAlloc0((
i+1)*
sizeof(
int**));
4470 res->order[
j]=r->order[
j-1];
4471 res->block0[
j]=r->block0[
j-1];
4472 res->block1[
j]=r->block1[
j-1];
4473 if (r->wvhdl[
j-1] !=
NULL)
4479 int l=r->block1[
j-1]-r->block0[
j-1]+1;
4484 l+=r->wvhdl[
j-1][r->block1[
j-1]-r->block0[
j-1]+1]+1;
4487 memcpy(wvhdl[
j],r->wvhdl[
j-1],
l*
sizeof(
int));
4505 WarnS(
"error in nc_rComplete");
4515 if (r->qideal!=
NULL)
4545 pos=r->VarL_LowIndex;
4550 for(
int i=r->OrdSize-1;
i>=0;
i--)
4552 if ((r->typ[
i].ord_typ==
ro_dp)
4553 && (r->typ[
i].data.dp.start==1)
4554 && (r->typ[
i].data.dp.end==r->N))
4556 pos=r->typ[
i].data.dp.place;
4575 res->ExpL_Size=r->ExpL_Size+1;
4579 for(
j=0;
j<r->CmpL_Size;
j++)
4581 res->ordsgn[
j] = r->ordsgn[
j];
4583 res->OrdSize=r->OrdSize+1;
4592 res->typ[
res->OrdSize-1].data.dp.start=1;
4593 res->typ[
res->OrdSize-1].data.dp.end=
res->N;
4594 res->typ[
res->OrdSize-1].data.dp.place=
res->ExpL_Size-1;
4595 pos=
res->ExpL_Size-1;
4611 WarnS(
"error in nc_rComplete");
4617 if (r->qideal!=
NULL)
4647 if (r->order[
i] == 0)
4665 if (r->wvhdl[
j]!=
NULL)
4671 int l=r->block1[
j]-r->block0[
j]+1;
4676 l+=r->wvhdl[
j][r->block1[
j]-r->block0[
j]+1]+1;
4698 WarnS(
"error in nc_rComplete");
4749 WarnS(
"error in nc_rComplete");
4783 WarnS(
"error in nc_rComplete");
4800 WarnS(
"error in nc_SetupQuotient");
4826 (r->order[0] ==
b1) &&
4827 (r->order[1] ==
b2) &&
4840 res->block1[1] = r->N;
4845 res->block1[0] = r->N;
4855 WarnS(
"error in nc_rComplete");
4874 for(
int i=0;
i<r->N;
i++)
4876 if ((*
w)[
i]!=r->wvhdl[0][
i]) { ok=
FALSE;
break;}
4888 res->block1[1] = r->N;
4889 res->wvhdl[0]=(
int*)
omAlloc(r->N*
sizeof(
int));
4890 for(
int i=0;
i<r->N;
i++)
4892 r->wvhdl[0][
i]=(*w)[
i];
4902 WarnS(
"error in nc_rComplete");
4915 Print(
"rAssure_InducedSchreyerOrdering(r, complete = %d, sgn = %d): r: \n", complete,
sgn);
4932 int ** wvhdl =(
int **)
omAlloc0((n+2)*
sizeof(
int**));
4940 res->block0[
j] =
res->block1[
j] = 0;
4944 for(
int i = 0; (
i <= n) && (r->order[
i] != 0);
i++,
j++)
4946 res->order [
j] = r->order [
i];
4947 res->block0[
j] = r->block0[
i];
4948 res->block1[
j] = r->block1[
i];
4950 if (r->wvhdl[
i] !=
NULL)
4956 int l=(r->block1[
i]-r->block0[
i]+1);
4961 l+=r->wvhdl[
i][r->block1[
i]-r->block0[
i]+1]+1;
4964 memcpy(wvhdl[
j],r->wvhdl[
i],
l*
sizeof(
int));
4996 WarnS(
"error in nc_rComplete");
5008 if (r->qideal!=
NULL)
5070 Print(
"rIsIS(p: %d)\nF:",
p);
5081 for(
int pos = 0; pos < r->OrdSize; pos++ )
5082 if( r->typ[pos].ord_typ ==
ro_is)
5104 dReportError(
"Error: WRONG USE of rSetISReference: wrong ring! (typ == NULL)");
5113 dReportError(
"Error: WRONG USE of rSetISReference: specified ordering block was not found!!!" );
5118 if(
i != r->typ[pos].data.is.limit )
5119 Print(
"Changing record on pos: %d\nOld limit: %d --->> New Limit: %d\n", pos, r->typ[pos].data.is.limit,
i);
5125 if( r->typ[pos].data.is.F !=
NULL)
5128 PrintS(
"Deleting old reference set F... \n");
5131 r->typ[pos].data.is.F =
NULL;
5136 r->typ[pos].data.is.F =
FF;
5138 r->typ[pos].data.is.limit =
i;
5162 if ((r->typ!=
NULL) && (r->typ[0].ord_typ==
ro_syz))
5164 r->block0[0]=r->block1[0] =
k;
5165 if(
k == r->typ[0].data.syz.limit )
5169 if (r->typ[0].data.syz.limit == 0)
5171 r->typ[0].data.syz.syz_index = (
int*)
omAlloc0((
k+1)*
sizeof(
int));
5172 r->typ[0].data.syz.syz_index[0] = 0;
5173 r->typ[0].data.syz.curr_index = 1;
5177 r->typ[0].data.syz.syz_index = (
int*)
5179 (r->typ[0].data.syz.limit+1)*
sizeof(
int),
5182 for (
i=r->typ[0].data.syz.limit + 1;
i<=
k;
i++)
5184 r->typ[0].data.syz.syz_index[
i] =
5185 r->typ[0].data.syz.curr_index;
5187 if(
k < r->typ[0].data.syz.limit)
5190 Warn(
"rSetSyzComp called with smaller limit (%d) as before (%d)",
k, r->typ[0].data.syz.limit);
5192 r->typ[0].data.syz.curr_index = 1 + r->typ[0].data.syz.syz_index[
k];
5196 r->typ[0].data.syz.limit =
k;
5197 r->typ[0].data.syz.curr_index++;
5206 Warn(
"rSetSyzComp(%d) in an IS ring! Be careful!",
k);
5211 r->block0[0] = r->block1[0] =
k;
5226 if ((r->typ!=
NULL) && (r->typ[0].ord_typ==
ro_syz) &&
5227 r->typ[0].data.syz.limit > 0 &&
i > 0)
5231 for (
j=0;
j<r->typ[0].data.syz.limit;
j++)
5233 if (r->typ[0].data.syz.syz_index[
j] ==
i &&
5234 r->typ[0].data.syz.syz_index[
j+1] !=
i)
5236 assume(r->typ[0].data.syz.syz_index[
j+1] ==
i+1);
5240 return r->typ[0].data.syz.limit;
5245 WarnS(
"rGetMaxSyzComp: order c");
5260 if ((r->order[0]==
ringorder_dp) &&(r->block0[0]==1) &&(r->block1[0]==r->N))
5263 && ((r->order[1]==
ringorder_dp) &&(r->block0[1]==1) &&(r->block1[1]==r->N)))
5270 if ((r->order[0]==
ringorder_Dp) &&(r->block0[0]==1) &&(r->block1[0]==r->N))
5273 && ((r->order[1]==
ringorder_Dp) &&(r->block0[1]==1) &&(r->block1[1]==r->N)))
5280 if ((r->order[0]==
ringorder_lp) &&(r->block0[0]==1) &&(r->block1[0]==r->N))
5283 && ((r->order[1]==
ringorder_lp) &&(r->block0[1]==1) &&(r->block1[1]==r->N)))
5293 while((r->typ[
i].ord_typ!=
ro_wp64) && (r->typ[
i].ord_typ>0))
i++;
5295 return r->typ[
i].data.wp64.weights64;
5303 memcpy(r->typ[0].data.wp64.weights64,
wv,r->N*
sizeof(
int64));
5314 for(
int k=
size;
k>pos;
k--) r->wvhdl[
k]=r->wvhdl[
k-1];
5326 for(
int k=pos+1;
k<
size;
k++) r->wvhdl[
k]=r->wvhdl[
k+1];
5336 for(
int j=0;
j<=
i2;
j++)
5344#define rOppVar(R,I) (rVar(R)+1-I)
5362 if (src->qideal !=
NULL)
5370 for(
i=
i2;
i>=0;
i--)
5376 p = r->names[
rVar(r)-1-
i];
5377 r->names[
rVar(r)-1-
i] = r->names[
i];
5395 char *
p=r->names[
i];
5448 for(
i=0; src->order[
i]!=0;
i++)
5450 switch (src->order[
i])
5455 r->order[
j]=src->order[
i];
5459 r->block0[
j]=
rOppVar(r, src->block1[
i]);
5460 r->block1[
j]=
rOppVar(r, src->block0[
i]);
5464 r->block0[
j]=
rOppVar(r, src->block1[
i]);
5465 r->block1[
j]=
rOppVar(r, src->block0[
i]);
5471 r->block0[
j]=
rOppVar(r, src->block1[
i]);
5472 r->block1[
j]=
rOppVar(r, src->block0[
i]);
5473 r->wvhdl[
j]=(
int*)
omAlloc((r->block1[
j]-r->block0[
j]+1)*
sizeof(
int));
5474 for(
int k=r->block0[
j];
k<=r->block1[
j];
k++)
5475 r->wvhdl[
j][
k-r->block0[
j]]=1;
5478 r->block0[
j]=
rOppVar(r, src->block1[
i]);
5479 r->block1[
j]=
rOppVar(r, src->block0[
i]);
5487 r->block0[
j]=
rOppVar(r, src->block1[
i]);
5488 r->block1[
j]=
rOppVar(r, src->block0[
i]);
5489 r->wvhdl[
j]=(
int*)
omAlloc((r->block1[
j]-r->block0[
j]+1)*
sizeof(
int));
5490 for(
int k=r->block0[
j];
k<=r->block1[
j];
k++)
5491 r->wvhdl[
j][
k-r->block0[
j]]=1;
5494 r->block0[
j]=
rOppVar(r, src->block1[
i]);
5495 r->block1[
j]=
rOppVar(r, src->block0[
i]);
5503 r->block0[
j]=
rOppVar(r, src->block1[
i]);
5504 r->block1[
j]=
rOppVar(r, src->block0[
i]);
5505 r->wvhdl[
j]=r->wvhdl[
j+1]; r->wvhdl[
j+1]=
NULL;
5509 r->block0[
j]=
rOppVar(r, src->block1[
i]);
5510 r->block1[
j]=
rOppVar(r, src->block0[
i]);
5518 r->block0[
j]=
rOppVar(r, src->block1[
i]);
5519 r->block1[
j]=
rOppVar(r, src->block0[
i]);
5520 r->wvhdl[
j]=r->wvhdl[
j+1]; r->wvhdl[
j+1]=
NULL;
5524 r->block0[
j]=
rOppVar(r, src->block1[
i]);
5525 r->block1[
j]=
rOppVar(r, src->block0[
i]);
5532 r->block0[
j]=
rOppVar(r, src->block1[
i]);
5533 r->block1[
j]=
rOppVar(r, src->block0[
i]);
5534 int n=r->block1[
j]-r->block0[
j];
5536 for (
int nn=0;
nn<=n;
nn++)
5545 r->block0[
j]=
rOppVar(r, src->block1[
i]);
5546 r->block1[
j]=
rOppVar(r, src->block0[
i]);
5588 for(
i=0; src->order[
i]!=0;
i++)
5590 switch (src->order[
i])
5595 r->order[
j]=src->order[
i];
5599 r->block0[
j]=
rOppVar(r, src->block1[
i]);
5600 r->block1[
j]=
rOppVar(r, src->block0[
i]);
5604 r->block0[
j]=
rOppVar(r, src->block1[
i]);
5605 r->block1[
j]=
rOppVar(r, src->block0[
i]);
5610 r->block0[
j]=
rOppVar(r, src->block1[
i]);
5611 r->block1[
j]=
rOppVar(r, src->block0[
i]);
5617 r->block0[
j]=
rOppVar(r, src->block1[
i]);
5618 r->block1[
j]=
rOppVar(r, src->block0[
i]);
5666 for(
i=1;
i<=r->N;
i++)
5682 MATELEM(C,
nj,
ni) =
p_PermPoly(
MATELEM(src->GetNC()->C,
i,
j),perm,src,r,
nMap,
par_perm,
rPar(src));
5685 MATELEM(
D,
nj,
ni) =
p_PermPoly(
MATELEM(src->GetNC()->D,
i,
j),perm,src,r,
nMap,
par_perm,
rPar(src));
5693 WarnS(
"Error initializing non-commutative multiplication!");
5701 assume( r->GetNC()->IsSkewConstant == src->GetNC()->IsSkewConstant);
5708 if (src->qideal !=
NULL)
5711 r->qideal =
idOppose(src, src->qideal, r);
5713 r->qideal =
id_Copy(src->qideal, r);
5745 WarnS(
"Error in rEnvelope at rSum");
5768 const int N = dest->N;
5788 for (
int i = 1;
i <
N;
i++)
5790 for (
int j =
i + 1;
j <=
N;
j++)
5793 const poly
p =
p_NSet(n, dest);
5855 Werror(
"n_IsParam: IsParam is not to be used for (coeff_type = %d)",
getCoeffType(C));
5864 WerrorS(
"only for rings with an ordering of one block");
5881 WerrorS(
"ordering must be dp,Dp,lp,rp,ds,Ds or ls");
5884 for(
int i=r->N-1;
i>=0;
i--)
5888 Werror(
"duplicate variable name >>%s<<",
v);
5894 #ifdef HAVE_SHIFTBBA
5897 R->isLPring=r->isLPring+1;
5898 R->N=((r->N)/r->isLPring)+r->N;
5902 for(
int b=0;
b<((r->N)/r->isLPring);
b++)
5905 for(
int i=
R->isLPring-1;
i>0;
i--)
5906 names[
i+
b*
R->isLPring]=
R->names[
i-1+
b*r->isLPring];
5911 for(
int b=0;
b<((r->N)/r->isLPring);
b++)
5914 for(
int i=
R->isLPring-2;
i>=0;
i--)
5915 names[
i+
b*
R->isLPring]=
R->names[
i+
b*r->isLPring];
5927 for(
int i=
R->N-1;
i>0;
i--) names[
i]=
R->names[
i-1];
5932 for(
int i=
R->N-2;
i>=0;
i--) names[
i]=
R->names[
i];
5946 WerrorS(
"only for rings with an ordering of one block");
5963 WerrorS(
"ordering must be dp,Dp,lp,rp,ds,Ds or ls");
5974 for(
int j=
i;
j<
R->N;
j++)
R->names[
j]=
R->names[
j+1];
int sgn(const Rational &a)
int naIsParam(number m, const coeffs cf)
if m == var(i)/1 => return i,
static int si_max(const int a, const int b)
const CanonicalForm CFMap CFMap & N
Coefficient rings, fields and other domains suitable for Singular polynomials.
static FORCE_INLINE number n_Copy(number n, const coeffs r)
return a copy of 'n'
static FORCE_INLINE void n_CoeffWrite(const coeffs r, BOOLEAN details=TRUE)
output the coeff description
static FORCE_INLINE BOOLEAN nCoeff_is_Extension(const coeffs r)
@ n_R
single prescision (6,6) real numbers
@ n_polyExt
used to represent polys as coeffcients
@ n_Q
rational (GMP) numbers
@ n_Znm
only used if HAVE_RINGS is defined
@ n_algExt
used for all algebraic extensions, i.e., the top-most extension in an extension tower is algebraic
@ n_Zn
only used if HAVE_RINGS is defined
@ n_transExt
used for all transcendental extensions, i.e., the top-most extension in an extension tower is transce...
static FORCE_INLINE char * nCoeffString(const coeffs cf)
TODO: make it a virtual method of coeffs, together with: Decompose & Compose, rParameter & rPar.
static FORCE_INLINE nMapFunc n_SetMap(const coeffs src, const coeffs dst)
set the mapping function pointers for translating numbers from src to dst
coeffs nInitChar(n_coeffType t, void *parameter)
one-time initialisations for new coeffs in case of an error return NULL
static FORCE_INLINE n_coeffType getCoeffType(const coeffs r)
Returns the type of coeffs domain.
static FORCE_INLINE coeffs nCopyCoeff(const coeffs r)
"copy" coeffs, i.e. increment ref
static FORCE_INLINE BOOLEAN nCoeff_is_algExt(const coeffs r)
TRUE iff r represents an algebraic extension field.
number(* nMapFunc)(number a, const coeffs src, const coeffs dst)
maps "a", which lives in src, into dst
void nKillChar(coeffs r)
undo all initialisations
static FORCE_INLINE BOOLEAN n_IsOne(number n, const coeffs r)
TRUE iff 'n' represents the one element.
const CanonicalForm int s
const Variable & v
< [in] a sqrfree bivariate poly
static int min(int a, int b)
void WerrorS(const char *s)
ideal id_Copy(ideal h1, const ring r)
copy an ideal
static BOOLEAN length(leftv result, leftv arg)
static bool rIsSCA(const ring r)
ideal idOppose(ring Rop_src, ideal I, const ring Rop_dst)
opposes a module I from Rop to currRing(dst)
bool nc_rCopy(ring res, const ring r, bool bSetupQuotient)
bool nc_SetupQuotient(ring rGR, const ring rG=NULL, bool bCopy=false)
static nc_type & ncRingType(nc_struct *p)
BOOLEAN nc_CallPlural(matrix cc, matrix dd, poly cn, poly dn, ring r, bool bSetupQuotient, bool bCopyInput, bool bBeQuiet, ring curr, bool dummy_ring=false)
returns TRUE if there were errors analyze inputs, check them for consistency detects nc_type,...
void nc_rKill(ring r)
complete destructor
#define UPMATELEM(i, j, nVar)
bool sca_Force(ring rGR, int b, int e)
void maFindPerm(char const *const *const preim_names, int preim_n, char const *const *const preim_par, int preim_p, char const *const *const names, int n, char const *const *const par, int nop, int *perm, int *par_perm, n_coeffType ch)
void mp_Delete(matrix *a, const ring r)
matrix mpNew(int r, int c)
create a r x c zero-matrix
void iiWriteMatrix(matrix im, const char *n, int dim, const ring r, int spaces)
set spaces to zero by default
#define MATELEM(mat, i, j)
1-based access to matrix
STATIC_VAR unsigned add[]
int dReportError(const char *fmt,...)
gmp_float sqrt(const gmp_float &a)
The main handler for Singular numbers which are suitable for Singular polynomials.
#define omFreeSize(addr, size)
#define omCheckAddr(addr)
#define omReallocSize(addr, o_size, size)
#define omCheckAddrSize(addr, size)
#define omFreeBin(addr, bin)
#define omcheckAddrSize(addr, size)
#define omfreeSize(addr, size)
#define omGetSpecBin(size)
#define omUnGetSpecBin(bin_ptr)
void p_ProcsSet(ring r, p_Procs_s *p_Procs)
void p_Debug_GetProcNames(const ring r, p_Procs_s *p_Procs)
void p_Debug_GetSpecNames(const ring r, const char *&field, const char *&length, const char *&ord)
void p_Setm_WFirstTotalDegree(poly p, const ring r)
long pLDegb(poly p, int *l, const ring r)
long pLDeg1_Totaldegree(poly p, int *l, const ring r)
long p_WFirstTotalDegree(poly p, const ring r)
long pLDeg1_WFirstTotalDegree(poly p, int *l, const ring r)
long pLDeg1c_WFirstTotalDegree(poly p, int *l, const ring r)
void p_Setm_Dummy(poly p, const ring r)
void p_Setm_TotalDegree(poly p, const ring r)
poly p_ISet(long i, const ring r)
returns the poly representing the integer i
long pLDeg1c_Deg(poly p, int *l, const ring r)
long pLDeg1(poly p, int *l, const ring r)
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)
long pLDeg1_Deg(poly p, int *l, const ring r)
long p_WTotaldegree(poly p, const ring r)
p_SetmProc p_GetSetmProc(const ring r)
void p_Setm_General(poly p, const ring r)
long pLDeg1c(poly p, int *l, const ring r)
long pLDeg1c_Totaldegree(poly p, int *l, const ring r)
long pLDeg0c(poly p, int *l, const ring r)
long pLDeg0(poly p, int *l, const ring r)
poly p_NSet(number n, const ring r)
returns the poly representing the number n, destroys n
long p_Deg(poly a, const ring r)
BOOLEAN p_EqualPolys(poly p1, poly p2, const ring r)
static long p_FDeg(const poly p, const ring r)
void p_Write(poly p, ring lmRing, ring tailRing)
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
static void p_Setm(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:
static void p_Delete(poly *p, const ring r)
void p_Write0(poly p, ring lmRing, ring tailRing)
static long p_Totaldegree(poly p, const ring r)
poly prCopyR(poly p, ring src_r, ring dest_r)
ideal idrCopyR(ideal id, ring src_r, ring dest_r)
ideal idrCopyR_NoSort(ideal id, ring src_r, ring dest_r)
ideal idrHeadR(ideal id, ring r, ring dest_r)
Copy leading terms of id[i] via prHeeadR into dest_r.
void StringSetS(const char *st)
void StringAppendS(const char *st)
void PrintS(const char *s)
void Werror(const char *fmt,...)
static void rSetNegWeight(ring r)
BOOLEAN rOrd_SetCompRequiresSetm(const ring r)
return TRUE if p_SetComp requires p_Setm
static void rO_ISSuffix(int &place, int &bitplace, int &prev_ord, long *o, int N, int *v, sro_ord *tmp_typ, int &typ_i, int sgn)
int rSum(ring r1, ring r2, ring &sum)
ring rAssure_TDeg(ring r, int &pos)
void rWrite(ring r, BOOLEAN details)
ring rAssure_InducedSchreyerOrdering(const ring r, BOOLEAN complete, int sgn)
static ring rAssure_Global(rRingOrder_t b1, rRingOrder_t b2, const ring r)
BOOLEAN rOrder_is_WeightedOrdering(rRingOrder_t order)
void rGetSComps(int **currComponents, long **currShiftedComponents, int *length, ring r)
BOOLEAN rRing_ord_pure_Dp(const ring r)
static void rNChangeSComps(int *currComponents, long *currShiftedComponents, ring r)
ring rModifyRing_Wp(ring r, int *weights)
construct Wp, C ring
BOOLEAN rOrder_is_DegOrdering(const rRingOrder_t order)
BOOLEAN rHasSimpleOrderAA(ring r)
void rSetWeightVec(ring r, int64 *wv)
static void rSetOption(ring r)
BOOLEAN rComplete(ring r, int force)
this needs to be called whenever a new ring is created: new fields in ring are created (like VarOffse...
int r_IsRingVar(const char *n, char **names, int N)
int rGetISPos(const int p, const ring r)
Finds p^th IS ordering, and returns its position in r->typ[] returns -1 if something went wrong!...
static void rNGetSComps(int **currComponents, long **currShiftedComponents, ring r)
static void rO_WDegree64(int &place, int &bitplace, int start, int end, long *o, sro_ord &ord_struct, int64 *weights)
BOOLEAN rHasSimpleLexOrder(const ring r)
returns TRUE, if simple lp or ls ordering
void p_SetGlobals(const ring r, BOOLEAN complete)
set all properties of a new ring - also called by rComplete
ring rAssure_SyzComp(const ring r, BOOLEAN complete)
BOOLEAN nc_rComplete(const ring src, ring dest, bool bSetupQuotient)
void p_DebugPrint(poly p, const ring r)
void rKillModifiedRing(ring r)
BOOLEAN rRing_ord_pure_dp(const ring r)
static void rSetVarL(ring r)
set r->VarL_Size, r->VarL_Offset, r->VarL_LowIndex
static void rO_LexVars(int &place, int &bitplace, int start, int end, int &prev_ord, long *o, int *v, int bits, int opt_var)
const char * rSimpleOrdStr(int ord)
ring rAssure_Wp_C(const ring r, intvec *w)
BOOLEAN rOrd_is_MixedDegree_Ordering(ring r)
static void rDBChangeSComps(int *currComponents, long *currShiftedComponents, int length, ring r)
ring rAssure_c_dp(const ring r)
static void rSetOutParams(ring r)
static void rSetDegStuff(ring r)
static void rDBGetSComps(int **currComponents, long **currShiftedComponents, int *length, ring r)
rOrderType_t rGetOrderType(ring r)
int rTypeOfMatrixOrder(const intvec *order)
ring nc_rCreateNCcomm_rCopy(ring r)
static void rOppWeight(int *w, int l)
static void rO_WDegree_neg(int &place, int &bitplace, int start, int end, long *o, sro_ord &ord_struct, int *weights)
void rKillModified_Wp_Ring(ring r)
ring rMinusVar(const ring r, char *v)
undo rPlusVar
BOOLEAN rRing_has_CompLastBlock(const ring r)
ring rAssure_Dp_C(const ring r)
ring rCopy0AndAddA(const ring r, int64vec *wv64, BOOLEAN copy_qideal, BOOLEAN copy_ordering)
static void rO_Syzcomp(int &place, int &bitplace, int &prev_ord, long *o, sro_ord &ord_struct)
BOOLEAN rOrd_is_Totaldegree_Ordering(const ring r)
ring rModifyRing(ring r, BOOLEAN omit_degree, BOOLEAN try_omit_comp, unsigned long exp_limit)
ring rAssure_SyzOrder(const ring r, BOOLEAN complete)
static void rO_TDegree(int &place, int &bitplace, int start, int end, long *o, sro_ord &ord_struct)
ring rAssure_C_dp(const ring r)
BOOLEAN rHasSimpleOrder(const ring r)
int rGetMaxSyzComp(int i, const ring r)
return the max-comonent wchich has syzIndex i Assume: i<= syzIndex_limit
BOOLEAN rSetISReference(const ring r, const ideal F, const int i, const int p)
Changes r by setting induced ordering parameters: limit and reference leading terms F belong to r,...
ring rAssure_HasComp(const ring r)
ring rCopy0(const ring r, BOOLEAN copy_qideal, BOOLEAN copy_ordering)
static void rO_WMDegree(int &place, int &bitplace, int start, int end, long *o, sro_ord &ord_struct, int *weights)
static void rO_Syz(int &place, int &bitplace, int &prev_ord, int syz_comp, long *o, sro_ord &ord_struct)
BOOLEAN rHas_c_Ordering(const ring r)
static int rRealloc1(ring r, int size, int pos)
static unsigned long rGetExpSize(unsigned long bitmask, int &bits)
void rDebugPrint(const ring r)
static void rCheckOrdSgn(ring r, int i)
BOOLEAN rRing_ord_pure_lp(const ring r)
poly rGetVar(const int varIndex, const ring r)
BOOLEAN rOrd_is_dp(const ring r)
ring rModifyRing_Simple(ring r, BOOLEAN ommit_degree, BOOLEAN ommit_comp, unsigned long exp_limit, BOOLEAN &simple)
void rChangeSComps(int *currComponents, long *currShiftedComponents, int length, ring r)
static void m_DebugPrint(const poly p, const ring R)
debug-print monomial poly/vector p, assuming that it lives in the ring R
static unsigned long rGetDivMask(int bits)
get r->divmask depending on bits per exponent
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...
ring rAssure_SyzComp_CompLastBlock(const ring r)
makes sure that c/C ordering is last ordering and SyzIndex is first
char * rCharStr(const ring r)
TODO: make it a virtual method of coeffs, together with: Decompose & Compose, rParameter & rPar.
static void rOptimizeLDeg(ring r)
BOOLEAN rCheckIV(const intvec *iv)
rRingOrder_t rOrderName(char *ordername)
void rDelete(ring r)
unconditionally deletes fields in r
ring rDefault(const coeffs cf, int N, char **n, int ord_size, rRingOrder_t *ord, int *block0, int *block1, int **wvhdl, unsigned long bitmask)
static void rRightAdjustVarOffset(ring r)
right-adjust r->VarOffset
ring rPlusVar(const ring r, char *v, int left)
K[x],"y" -> K[x,y] resp. K[y,x].
ring rAssure_CompLastBlock(ring r, BOOLEAN complete)
makes sure that c/C ordering is last ordering
static void rO_ISPrefix(int &place, int &bitplace, int &prev_ord, long *o, int N, int *v, sro_ord &ord_struct)
static void rO_Align(int &place, int &bitplace)
ring rAssure_dp_S(const ring r)
BOOLEAN rOrd_is_ds(const ring r)
static void rO_TDegree_neg(int &place, int &bitplace, int start, int end, long *o, sro_ord &ord_struct)
static void rSetFirstWv(ring r, int i, rRingOrder_t *order, int *block0, int *block1, int **wvhdl)
BOOLEAN rEqual(ring r1, ring r2, BOOLEAN qr)
returns TRUE, if r1 equals r2 FALSE, otherwise Equality is determined componentwise,...
int rSumInternal(ring r1, ring r2, ring &sum, BOOLEAN vartest, BOOLEAN dp_dp)
returns -1 for not compatible, 1 for compatible (and sum) dp_dp:0: block ordering,...
void rSetSyzComp(int k, const ring r)
static const char *const ringorder_name[]
static void rO_WDegree(int &place, int &bitplace, int start, int end, long *o, sro_ord &ord_struct, int *weights)
BOOLEAN rOrd_is_WeightedDegree_Ordering(const ring r)
int n_IsParam(const number m, const ring r)
TODO: rewrite somehow...
int64 * rGetWeightVec(const ring r)
static void rO_LexVars_neg(int &place, int &bitplace, int start, int end, int &prev_ord, long *o, int *v, int bits, int opt_var)
ring rAssure_dp_C(const ring r)
BOOLEAN rDBTest(ring r, const char *fn, const int l)
struct p_Procs_s p_Procs_s
static BOOLEAN rIsPluralRing(const ring r)
we must always have this test!
static int rBlocks(const ring r)
static ring rIncRefCnt(ring r)
static int rPar(const ring r)
(r->cf->P)
static BOOLEAN rIsLPRing(const ring r)
@ ringorder_a64
for int64 weights
@ ringorder_rs
opposite of ls
@ ringorder_aa
for idElimination, like a, except pFDeg, pWeigths ignore it
@ ringorder_IS
Induced (Schreyer) ordering.
static BOOLEAN rField_is_Q(const ring r)
static BOOLEAN rShortOut(const ring r)
@ rOrderType_CompExp
simple ordering, component has priority
@ rOrderType_Exp
simple ordering, exponent vector has priority component is compatible with exp-vector order
@ rOrderType_General
non-simple ordering as specified by currRing
@ rOrderType_ExpComp
simple ordering, exponent vector has priority component not compatible with exp-vector order
static BOOLEAN rIsNCRing(const ring r)
static char const ** rParameter(const ring r)
(r->cf->parameter)
static BOOLEAN rCanShortOut(const ring r)
static short rVar(const ring r)
#define rVar(r) (r->N)
#define rField_is_Ring(R)
ideal SCAQuotient(const ring r)
static short scaLastAltVar(ring r)
static short scaFirstAltVar(ring r)
ideal idInit(int idsize, int rank)
initialise an ideal / module
void id_Delete(ideal *h, ring r)
deletes an ideal/module/matrix
long id_RankFreeModule(ideal s, ring lmRing, ring tailRing)
return the maximal component number found in any polynomial in s
void idShow(const ideal id, const ring lmRing, const ring tailRing, const int debugPrint)
ideal id_SimpleAdd(ideal h1, ideal h2, const ring R)
concat the lists h1 and h2 without zeros
EXTERN_VAR long * currShiftedComponents
int ntIsParam(number m, const coeffs cf)
if m == var(i)/1 => return i,