40#define BITS_PER_LONG 8*SIZEOF_LONG
111 r->names = (
char **)
omAlloc0(
N *
sizeof(
char *));
125 if (bitmask!=0) r->wanted_maxExp=bitmask;
144 int *block0 = (
int *)
omAlloc0(2 *
sizeof(
int));
145 int *block1 = (
int *)
omAlloc0(2 *
sizeof(
int));
180 WerrorS(
"weights only for orderings wp,ws,Wp,Ws,a,M");
192 WerrorS(
"Matrix order is not a square matrix");
195 while ((
i<
sz) && (typ==1))
198 while ((
j<
sz) && ((*order)[
j*
sz+
i+2]==0))
j++;
202 WerrorS(
"Matrix order not complete");
204 else if ((*order)[
j*
sz+
i+2]<0)
217 for (
int i=0;
i<
N;
i++)
219 if (names[
i]==
NULL)
return -1;
220 if (
strcmp(n,names[
i]) == 0)
return (
int)
i;
249 PrintS(
"// coefficients: ");
304 Print(
"// number of vars : %d",r->N);
312 Print(
"\n// block %3d : ",
l+1);
319 assume( r->block0[
l] == r->block1[
l] );
320 const int s = r->block0[
l];
328 Print(
" syz_comp: %d",r->block0[
l]);
340 for (
i = r->block0[
l]-1;
i<r->block1[
l];
i++)
347 if (r->wvhdl[
l]!=
NULL)
359 Warn(
"should not have wvhdl entry at pos. %d",
l);
362 int bl=r->block1[
l]-r->block0[
l]+1;
364 j<(r->block1[
l]-r->block0[
l]+1)*(r->block1[
l]-r->block0[
l]+1);
367 PrintS(
"\n// : weights ");
368 for (
i = 0;
i<=r->block1[
l]-r->block0[
l];
i++)
386 int m=r->wvhdl[
l][
bl];
387 Print(
"\n// : %d module weights ",
m);
396 PrintS(
"\n// noncommutative relations:");
402 for (
i = 1;
i<r->N;
i++)
404 for (
j =
i+1;
j<=r->N;
j++)
409 Print(
"\n// %s%s=",r->names[
j-1],r->names[
i-1]);
420 Print(
"\n// is skew constant:%d",r->GetNC()->IsSkewConstant);
425 PrintS(
"\n// quotient of sca by ideal");
438 Print(
"\n// letterplace ring (block size %d, ncgen count %d)",r->isLPring, r->LPncGenCount);
443 PrintS(
"\n// quotient ring from ideal");
456 if (r ==
NULL)
return;
460 if( r->qideal !=
NULL )
475 if (r->order !=
NULL)
486 if (r->wvhdl[
j]!=
NULL)
499 for (
i=0;
i<r->N;
i++)
547 if (r->wvhdl[
l]!=
NULL)
559 Warn(
"should not have wvhdl entry at pos. %d",
l);
567 j<(r->block1[
l]-r->block0[
l]+1)*(r->block1[
l]-r->block0[
l]+1);
574 for (
i = 0;
i<r->block1[
l]-r->block0[
l];
i++)
583 for (
i = 0;
i<r->block1[
l]-r->block0[
l];
i++)
593 if (
j+
i+1==(r->block1[
l]-r->block0[
l]+1)*(r->block1[
l]-r->block0[
l]+1))
604 assume( r->block0[
l] == r->block1[
l] );
605 const int s = r->block0[
l];
613 if (r->wanted_maxExp!=0)
615 long mm=r->wanted_maxExp;
632 for (
i=0;
i<r->N;
i++)
638 for (
i=0;
i<r->N-1;
i++)
730 for(
int i=1;
i<r->N;
i++)
731 for(
int j=
i+1;
j<=r->N;
j++)
735 WarnS(
"Error initializing multiplication!");
790 && (
mpz_cmp(
r1->cf->modNumber,
r2->cf->extRing->cf->modNumber)==0))
823 if (
r1->cf->extRing->cf==
r2->cf)
833 WerrorS (
"coeff sum of two extension fields not implemented");
839 WerrorS(
"coeff sum not yet implemented");
846 char **names=(
char **)
omAlloc0(
l*
sizeof(
char *));
851 for (
i=0;
i<
r1->N;
i++)
855 if (*(
r1->names[
i]) ==
'\0')
887 if (*(
r2->names[
i]) ==
'\0')
979 if ((
r2->block0[0]==1)
986 tmpR.order[1]=
r2->order[0];
992 int l=
r2->block1[0]-
r2->block0[0]+1;
997 l+=
r2->wvhdl[1][
r2->block1[0]-
r2->block0[0]+1]+1;
1068 WarnS(
"rSum: weights not implemented");
1074 for (
i=0;
r1->order[
i]!=0;
i++)
1084 int l=
r1->block1[
i]-
r1->block0[
i]+1;
1089 l+=
r1->wvhdl[
i][
r1->block1[
i]-
r1->block0[
i]+1]+1;
1104 for (
i=0;
r2->order[
i]!=0;
i++)
1118 int l=
r2->block1[
i]-
r2->block0[
i]+1;
1123 l+=
r2->wvhdl[
i][
r2->block1[
i]-
r2->block0[
i]+1]+1;
1133 if((
r1->OrdSgn==-1)||(
r2->OrdSgn==-1))
1159 int l=
r1->block1[
i]-
r1->block0[
i]+1;
1164 l+=
r1->wvhdl[
i][
r1->block1[
i]-
r1->block0[
i]+1]+1;
1265 MATELEM(C,
i,
j) =
p_PermPoly(
MATELEM(
C1,
i,
j),
perm1,
R1,
sum,
nMap1,
par_perm1,
rPar(
R1));
1268 MATELEM(
D,
i,
j) =
p_PermPoly(
MATELEM(
D1,
i,
j),
perm1,
R1,
sum,
nMap1,
par_perm1,
rPar(
R1));
1281 MATELEM(C,
rVar(
R1)+
i,
rVar(
R1)+
j) =
p_PermPoly(
MATELEM(
C2,
i,
j),
perm2,
R2,
sum,
nMap2,
par_perm2,
rPar(
R2));
1284 MATELEM(
D,
rVar(
R1)+
i,
rVar(
R1)+
j) =
p_PermPoly(
MATELEM(
D2,
i,
j),
perm2,
R2,
sum,
nMap2,
par_perm2,
rPar(
R2));
1292 WarnS(
"Error initializing non-commutative multiplication!");
1301 Print(
"\nRefs: R1: %d, R2: %d\n",
R1->GetNC()->ref,
R2->GetNC()->ref);
1430 res->options=r->options;
1445 res->firstBlockEnds=r->firstBlockEnds;
1447 res->real_var_start=r->real_var_start;
1448 res->real_var_end=r->real_var_end;
1452 res->isLPring=r->isLPring;
1453 res->LPncGenCount=r->LPncGenCount;
1456 res->VectorOut=r->VectorOut;
1457 res->ShortOut=r->ShortOut;
1458 res->CanShortOut=r->CanShortOut;
1474 res->bitmask=r->bitmask;
1475 res->divmask=r->divmask;
1476 res->BitsPerExp = r->BitsPerExp;
1477 res->ExpPerLong = r->ExpPerLong;
1498 res->LexOrder=r->LexOrder;
1499 res->MixedOrder=r->MixedOrder;
1507 if (r->wvhdl[
j]!=
NULL)
1513 int l=r->block1[
j]-r->block0[
j]+1;
1518 l+=r->wvhdl[
j][r->block1[
j]-r->block0[
j]+1]+1;
1529 memcpy(
res->block0,r->block0,
i *
sizeof(
int));
1530 memcpy(
res->block1,r->block1,
i *
sizeof(
int));
1545 if (r->qideal!=
NULL)
1574 res->options=r->options;
1589 res->firstBlockEnds=r->firstBlockEnds;
1591 res->real_var_start=r->real_var_start;
1592 res->real_var_end=r->real_var_end;
1596 res->isLPring=r->isLPring;
1597 res->LPncGenCount=r->LPncGenCount;
1600 res->VectorOut=r->VectorOut;
1601 res->ShortOut=r->ShortOut;
1602 res->CanShortOut=r->CanShortOut;
1603 res->LexOrder=r->LexOrder;
1604 res->MixedOrder=r->MixedOrder;
1620 res->bitmask=r->bitmask;
1621 res->divmask=r->divmask;
1622 res->BitsPerExp = r->BitsPerExp;
1623 res->ExpPerLong = r->ExpPerLong;
1649 for (
j=0;
j<
i-1;
j++)
1651 if (r->wvhdl[
j]!=
NULL)
1657 int l=r->block1[
j]-r->block0[
j]+1;
1662 l+=r->wvhdl[
j][r->block1[
j]-r->block0[
j]+1]+1;
1673 memcpy(&(
res->block0[1]),r->block0,(
i-1) *
sizeof(
int));
1674 memcpy(&(
res->block1[1]),r->block1,(
i-1) *
sizeof(
int));
1692 res->wvhdl[0]=(
int *)
A;
1702 if (r->qideal!=
NULL)
1708 WerrorS(
"internal error: rCopy0(Q,TRUE,FALSE)");
1713 WarnS(
"internal bad stuff: rCopy0(Q,TRUE,TRUE)");
1754 if (
r1->bitmask!=
r2->bitmask)
return FALSE;
1755 #ifdef HAVE_SHIFTBBA
1756 if (
r1->isLPring!=
r2->isLPring)
return FALSE;
1757 if (
r1->LPncGenCount!=
r2->LPncGenCount)
return FALSE;
1809 if ((
r1->cf !=
r2->cf)
1811 || (
r1->OrdSgn !=
r2->OrdSgn))
1815 while (
r1->order[
i] != 0)
1817 if (
r2->order[
i] == 0)
return FALSE;
1818 if ((
r1->order[
i] !=
r2->order[
i])
1819 || (
r1->block0[
i] !=
r2->block0[
i])
1820 || (
r1->block1[
i] !=
r2->block1[
i]))
1826 for (
j=0;
j<
r1->block1[
i]-
r1->block0[
i]+1;
j++)
1827 if (
r2->wvhdl[
i][
j] !=
r1->wvhdl[
i][
j])
1833 if (
r2->order[
i] != 0)
return FALSE;
2000 for (pos=0;pos<r->OrdSize;pos++)
2018 return ((
rVar(r) > 1) &&
2024 ((r->order[1]!=0) &&
2030 return ((
rVar(r) > 1) &&
2031 (((r->order[0]==
ringorder_dp)&&(r->block1[0]==r->N)) ||
2032 ((r->order[1]==
ringorder_dp)&&(r->block1[1]==r->N)&&((r->block0[1]==1)))));
2037 return ((
rVar(r) > 1) &&
2038 (((r->order[0]==
ringorder_ds)&&(r->block1[0]==r->N)) ||
2039 ((r->order[1]==
ringorder_ds)&&(r->block1[1]==r->N)&&((r->block0[1]==1)))));
2046 return ((
rVar(r) > 1) &&
2065 if (r->N == 0)
return TRUE;
2067 if ((r->OrdSgn!=1) && (r->OrdSgn!= -1))
2079 for(
int j=0;
j<=
i;
j++)
2082 dError(
"wrong order in r->order");
2093 if (r->VarOffset ==
NULL)
2095 dReportError(
"Null ring VarOffset -- no rComplete (?) in n %s:%d",
fn,
l);
2100 if ((r->OrdSize==0)!=(r->typ==
NULL))
2102 dReportError(
"mismatch OrdSize and typ-pointer in %s:%d");
2108 for(
i=0;
i<=r->N;
i++)
2112 for(
j=0;
j<r->OrdSize;
j++)
2116 const int p = r->typ[
j].data.isTemp.suffixpos;
2123 if(r->typ[
p].ord_typ !=
ro_is)
2124 dReportError(
"ordrec prefix %d is unmatched (suffix: %d is wrong!!!)",
j,
p);
2127 if(r->typ[
j].data.isTemp.pVarOffset[
i] != -1)
2133 else if (r->typ[
j].ord_typ ==
ro_is)
2136 if(r->typ[
j].data.is.pVarOffset[
i] != -1)
2144 if (r->typ[
j].ord_typ==
ro_cp)
2146 if(((
short)r->VarOffset[
i]) == r->typ[
j].data.cp.place)
2151 && (r->VarOffset[
i] == r->typ[
j].data.dp.place))
2157 tmp=r->VarOffset[
i] & 0xffffff;
2158 #if SIZEOF_LONG == 8
2159 if ((r->VarOffset[
i] >> 24) >63)
2161 if ((r->VarOffset[
i] >> 24) >31)
2163 dReportError(
"bit_start out of range:%d",r->VarOffset[
i] >> 24);
2164 if (
i > 0 && ((
tmp<0) ||(
tmp>r->ExpL_Size-1)))
2171 for(
j=0;
j<r->OrdSize;
j++)
2173 if ((r->typ[
j].ord_typ==
ro_dp)
2174 || (r->typ[
j].ord_typ==
ro_wp)
2177 if (r->typ[
j].data.dp.start > r->typ[
j].data.dp.end)
2179 r->typ[
j].data.dp.start, r->typ[
j].data.dp.end);
2180 if ((r->typ[
j].data.dp.start < 1)
2181 || (r->typ[
j].data.dp.end > r->N))
2182 dReportError(
"in ordrec %d: start(%d)<1 or end(%d)>vars(%d)",
j,
2183 r->typ[
j].data.dp.start, r->typ[
j].data.dp.end,r->N);
2247 while((start<end) && (weights[0]==0)) { start++; weights++; }
2248 while((start<end) && (weights[end-start]==0)) { end--; }
2251 for(
i=start;
i<=end;
i++)
2253 if(weights[
i-start]!=1)
2273 for(
i=start;
i<=end;
i++)
2275 if(weights[
i-start]<0)
2297 ord_struct.data.am.weights_m = weights + (end-start+1);
2298 ord_struct.data.am.len_gen=weights[end-start+1];
2333 while((start<end) && (weights[0]==0)) { start++; weights++; }
2334 while((start<end) && (weights[end-start]==0)) { end--; }
2345 for(
i=start;
i<=end;
i++)
2347 if(weights[
i-start]<0)
2517 int *pVarOffset =
tmp_typ[
typ_j].data.isTemp.pVarOffset;
2535 for(
int i = 0;
i <=
N;
i++ )
2538 if(
v[
i] != pVarOffset[
i] )
2540 pVarOffset[
i] =
v[
i];
2542 assume( pVarOffset[
i] != -1 );
2548 if( pVarOffset[0] != -1 )
2549 pVarOffset[0] &= 0x0fff;
2590 bits=16; bitmask=0xffff;
2592 else if (bitmask <= 1L)
2594 bits=1; bitmask = 1L;
2596 else if (bitmask <= 3L)
2598 bits=2; bitmask = 3L;
2600 else if (bitmask <= 7L)
2604 else if (bitmask <= 0xfL)
2606 bits=4; bitmask=0xfL;
2608 else if (bitmask <= 0x1fL)
2610 bits=5; bitmask=0x1fL;
2612 else if (bitmask <= 0x3fL)
2614 bits=6; bitmask=0x3fL;
2617 else if (bitmask <= 0x7fL)
2619 bits=7; bitmask=0x7fL;
2622 else if (bitmask <= 0xffL)
2624 bits=8; bitmask=0xffL;
2627 else if (bitmask <= 0x1ffL)
2629 bits=9; bitmask=0x1ffL;
2632 else if (bitmask <= 0x3ffL)
2634 bits=10; bitmask=0x3ffL;
2637 else if (bitmask <= 0xfffL)
2639 bits=12; bitmask=0xfff;
2642 else if (bitmask <= 0xffffL)
2644 bits=16; bitmask=0xffffL;
2647 else if (bitmask <= 0xfffffL)
2649 bits=20; bitmask=0xfffffL;
2651 else if (bitmask <= 0xffffffffL)
2653 bits=32; bitmask=0xffffffffL;
2655 else if (bitmask <= 0x7fffffffffffffffL)
2657 bits=63; bitmask=0x7fffffffffffffffL;
2661 bits=63; bitmask=0x7fffffffffffffffL;
2664 else if (bitmask <= 0x7fffffff)
2666 bits=31; bitmask=0x7fffffff;
2670 bits=31; bitmask=0x7fffffffL;
2741 if (r->block0[
i]==r->block1[
i])
2766 Warn(
"Error: unhandled ordering in rModifyRing: ringorder_S = [%d]",
r_ord);
2845 block0[
j]=r->block0[
i];
2846 block1[
j]=r->block1[
i];
2847 wvhdl[
j]=r->wvhdl[
i];
2873 res->wanted_maxExp=r->wanted_maxExp;
2880 if (r->pFDegOrig !=
res->pFDegOrig &&
2885 res->firstwv = r->firstwv;
2886 res->firstBlockEnds = r->firstBlockEnds;
2890 res->pLDeg = r->pLDegOrig;
2899 res->typ[0] = r->typ[0];
2901 if (r->typ[0].data.syz.limit > 0)
2903 res->typ[0].data.syz.syz_index
2904 = (
int*)
omAlloc((r->typ[0].data.syz.limit +1)*
sizeof(
int));
2905 memcpy(
res->typ[0].data.syz.syz_index, r->typ[0].data.syz.syz_index,
2906 (r->typ[0].data.syz.limit +1)*
sizeof(
int));
2919 r->typ[
i].data.is.limit,
2930 res->OrdSgn=r->OrdSgn;
2939 WarnS(
"error in nc_rComplete");
2952 WarnS(
"error in sca_Force!");
2978 res->block1[0] = r->N;
2979 res->wvhdl[0] = weights;
2994 WarnS(
"error in nc_rComplete");
3045 res->wanted_maxExp=r->wanted_maxExp;
3056 WarnS(
"error in nc_rComplete");
3100 r->CanShortOut=
FALSE;
3103 r->CanShortOut =
TRUE;
3111 r->CanShortOut=
FALSE;
3119 for (
i=(
N-1);
i>=0;
i--)
3123 r->CanShortOut=
FALSE;
3129 r->ShortOut = r->CanShortOut;
3131 assume( !( !r->CanShortOut && r->ShortOut ) );
3139 if(block1[
i]!=r->N) r->LexOrder=
TRUE;
3140 r->firstBlockEnds=block1[
i];
3141 r->firstwv = wvhdl[
i];
3150 for(
j=block1[
i]-block0[
i];
j>=0;
j--)
3152 if (r->firstwv[
j]==0) r->LexOrder=
TRUE;
3159 for(
j=block1[
i]-block0[
i];
j>=0;
j--)
3161 if (
w[
j]==0) r->LexOrder=
TRUE;
3168 if (r->pFDeg ==
p_Deg)
3189 r->pLDegOrig = r->pLDeg;
3196 int* block0 = r->block0;
3197 int* block1 = r->block1;
3198 int** wvhdl = r->wvhdl;
3207 r->LexOrder =
FALSE;
3214 for(
int ii=block0[0];
ii<=block1[0];
ii++)
3215 if (wvhdl[0][
ii-1]<0) { r->MixedOrder=2;
break;}
3217 for(
int ii=block0[0];
ii<=block1[0];
ii++)
3218 if (wvhdl[0][
ii-1]==0) { r->LexOrder=
TRUE;
break;}
3219 if ((block0[0]==1)&&(block1[0]==r->N))
3230 r->firstwv = wvhdl[0];
3242 if (r->OrdSgn == -1) r->pLDeg =
pLDeg0c;
3261 for(
int ii=block0[0];
ii<=block1[0];
ii++)
3263 if (wvhdl[0][
ii-1]<0) { r->MixedOrder=2;
break;}
3265 if (r->MixedOrder==0)
3267 if ((block0[0]==1)&&(block1[0]==r->N))
3275 r->firstBlockEnds=block1[0];
3276 r->firstwv = wvhdl[0];
3295 r->firstBlockEnds=block1[1];
3296 if (wvhdl!=
NULL) r->firstwv = wvhdl[1];
3304 for(
int ii=block0[1];
ii<=block1[1];
ii++)
3305 if (wvhdl[1][
ii-1]<0) { r->MixedOrder=2;
break;}
3306 if (r->MixedOrder==
FALSE)
3339 if(r->MixedOrder==
FALSE)
3354 r->pFDegOrig = r->pFDeg;
3369 for(
i=0;
i<r->OrdSize;
i++)
3372 ||(r->typ[
i].ord_typ==
ro_am))
3377 r->NegWeightL_Size=
l;
3378 r->NegWeightL_Offset=(
int *)
omAlloc(
l*
sizeof(
int));
3380 for(
i=0;
i<r->OrdSize;
i++)
3384 r->NegWeightL_Offset[
l]=r->typ[
i].data.wp.place;
3387 else if(r->typ[
i].ord_typ==
ro_am)
3389 r->NegWeightL_Offset[
l]=r->typ[
i].data.am.place;
3396 r->NegWeightL_Size = 0;
3397 r->NegWeightL_Offset =
NULL;
3409 if ( (r->cf->extRing!=
NULL)
3418 if (r->LexOrder || r->OrdSgn == -1 || (r->cf->extRing!=
NULL))
3435 r->pLexOrder=r->LexOrder;
3443static inline int sign(
int x) {
return (
x > 0) - (
x < 0);}
3474 r->BitsPerExp =
bits;
3482 for(
i=r->N;
i>=0 ;
i--)
3499 switch (r->order[
i])
3523 r->ComponentOrder=1;
3529 r->ComponentOrder=-1;
3535 k=r->block1[
i]-r->block0[
i]+1;
3540 r->wvhdl[
i]+(r->block1[
i]-r->block0[
i]+1)*
l);
3567 if (r->block0[
i]==r->block1[
i])
3583 if (r->block0[
i]==r->block1[
i])
3599 if (r->block0[
i]==r->block1[
i])
3615 if (r->block0[
i]==r->block1[
i])
3631 if (r->block0[
i]==r->block1[
i])
3653 for(
jj=r->block1[
i]-r->block0[
i];
jj>=0;
jj--)
3664 if (r->block1[
i]!=r->block0[
i])
3678 for(
jj=r->block1[
i]-r->block0[
i];
jj>=0;
jj--)
3689 if (r->block1[
i]!=r->block0[
i])
3700 if (r->block1[
i]!=r->block0[
i])
3711 if (r->block1[
i]!=r->block0[
i])
3723 r->ComponentOrder=-1;
3731 r->ComponentOrder=-1;
3738 assume( r->block0[
i] == r->block1[
i] );
3739 const int s = r->block0[
i];
3785 for(
i=1 ;
i<=r->N ;
i++)
3812 r->ordsgn=(
long *)
omAlloc0(r->ExpL_Size*
sizeof(
long));
3814 for(
j=0;
j<r->CmpL_Size;
j++)
3839 r->pCompIndex=(r->VarOffset[0] & 0xffff);
3842 if (
i==r->pCompIndex)
i++;
3851 if (
i==r->pCompIndex)
i++;
3889 for(
int i=1;
i<=r->N;
i++)
3896 if ((r->block0[
j]<=
i)&&(r->block1[
j]>=
i))
3916 if(r->wvhdl[
j][
i-r->block0[
j]]<0)
3922 else if(r->wvhdl[
j][
i-r->block0[
j]]>0)
3933 if(r->wvhdl[
j][
i-r->block0[
j]]<0)
3939 else if(r->wvhdl[
j][
i-r->block0[
j]]>0)
3947 int add=r->block1[
j]-r->block0[
j]+1;
3952 if (r->wvhdl[
j][
i-r->block0[
j]]<0)
3958 else if(r->wvhdl[
j][
i-r->block0[
j]]>0)
3988 if (
nonneg>0) r->MixedOrder=1;
3999 if (r ==
NULL)
return;
4000 if (r->VarOffset !=
NULL)
4002 if (r->OrdSize!=0 && r->typ !=
NULL)
4004 for(
int i = 0;
i < r->OrdSize;
i++)
4005 if( r->typ[
i].ord_typ ==
ro_is)
4009 if( r->typ[
i].data.is.pVarOffset !=
NULL )
4014 else if (r->typ[
i].ord_typ ==
ro_syz)
4016 if(r->typ[
i].data.syz.limit > 0)
4017 omFreeSize(r->typ[
i].data.syz.syz_index, ((r->typ[
i].data.syz.limit) +1)*
sizeof(
int));
4021 assume( r->typ[
i].data.syzcomp.ShiftedComponents ==
NULL );
4022 assume( r->typ[
i].data.syzcomp.Components ==
NULL );
4032 if (r->PolyBin !=
NULL)
4038 if (r->ordsgn !=
NULL && r->CmpL_Size != 0)
4043 if (r->p_Procs !=
NULL)
4048 omfreeSize(r->VarL_Offset, r->VarL_Size*
sizeof(
int));
4049 r->VarL_Offset=
NULL;
4051 if (r->NegWeightL_Offset!=
NULL)
4053 omFreeSize(r->NegWeightL_Offset, r->NegWeightL_Size*
sizeof(
int));
4054 r->NegWeightL_Offset=
NULL;
4067 for (
i=1;
i<=r->N;
i++)
4073 for (
i=0,
j=0;
i<r->ExpL_Size;
i++)
4088 r->VarL_Offset = (
int*)
omAlloc(r->VarL_Size*
sizeof(
int));
4089 r->VarL_LowIndex = 0;
4092 for (
i=0,
j=0;
i<r->ExpL_Size;
i++)
4096 r->VarL_Offset[
j] =
i;
4097 if (
j > 0 && r->VarL_Offset[
j-1] != r->VarL_Offset[
j] - 1)
4098 r->VarL_LowIndex = -1;
4102 if (r->VarL_LowIndex >= 0)
4103 r->VarL_LowIndex = r->VarL_Offset[0];
4107 j = r->VarL_Offset[
min_j];
4108 r->VarL_Offset[
min_j] = r->VarL_Offset[0];
4109 r->VarL_Offset[0] =
j;
4119 for (
i=0;
i<r->ExpL_Size;
i++)
4123 for (
i=1;
i<=r->N;
i++)
4125 if (
shifts[r->VarOffset[
i] & 0xffffff] > r->VarOffset[
i] >> 24)
4126 shifts[r->VarOffset[
i] & 0xffffff] = r->VarOffset[
i] >> 24;
4129 for (
i=1;
i<=r->N;
i++)
4131 if (
shifts[r->VarOffset[
i] & 0xffffff] != 0)
4133 = (r->VarOffset[
i] & 0xffffff) |
4134 (((r->VarOffset[
i] >> 24) -
shifts[r->VarOffset[
i] & 0xffffff]) << 24);
4142 unsigned long divmask = 1;
4147 divmask |= (((
unsigned long) 1) << (
unsigned long)
i);
4162 const char *
TYP[]={
"ro_dp",
"ro_wp",
"ro_am",
"ro_wp64",
"ro_wp_neg",
"ro_cp",
4163 "ro_syzcomp",
"ro_syz",
"ro_isTemp",
"ro_is",
"ro_none"};
4166 Print(
"ExpL_Size:%d ",r->ExpL_Size);
4167 Print(
"CmpL_Size:%d ",r->CmpL_Size);
4168 Print(
"VarL_Size:%d\n",r->VarL_Size);
4169 Print(
"bitmask=0x%lx (expbound=%ld) \n",r->bitmask, r->bitmask);
4170 Print(
"divmask=%lx\n", r->divmask);
4171 Print(
"BitsPerExp=%d ExpPerLong=%d at L[%d]\n", r->BitsPerExp, r->ExpPerLong, r->VarL_Offset[0]);
4173 Print(
"VarL_LowIndex: %d\n", r->VarL_LowIndex);
4174 PrintS(
"VarL_Offset:\n");
4177 for(
j = 0;
j < r->VarL_Size;
j++)
4178 Print(
" VarL_Offset[%d]: %d ",
j, r->VarL_Offset[
j]);
4185 for(
j=0;
j<=r->N;
j++)
4186 Print(
" v%d at e-pos %d, bit %d\n",
4187 j,r->VarOffset[
j] & 0xffffff, r->VarOffset[
j] >>24);
4189 for(
j=0;
j<r->CmpL_Size;
j++)
4190 Print(
" ordsgn %ld at pos %d\n",r->ordsgn[
j],
j);
4191 Print(
"OrdSgn:%d\n",r->OrdSgn);
4193 for(
j=0;
j<r->OrdSize;
j++)
4195 Print(
" typ %s",
TYP[r->typ[
j].ord_typ]);
4196 if (r->typ[
j].ord_typ==
ro_syz)
4198 const short place = r->typ[
j].data.syz.place;
4199 const int limit = r->typ[
j].data.syz.limit;
4200 const int curr_index = r->typ[
j].data.syz.curr_index;
4201 const int* syz_index = r->typ[
j].data.syz.syz_index;
4203 Print(
" limit %d (place: %d, curr_index: %d), syz_index: ", limit, place, curr_index);
4205 if( syz_index ==
NULL )
4210 for(
i=0;
i <= limit;
i++ )
4211 Print(
"%d ", syz_index[
i]);
4218 Print(
" start (level) %d, suffixpos: %d, VO: ",r->typ[
j].data.isTemp.start, r->typ[
j].data.isTemp.suffixpos);
4221 else if (r->typ[
j].ord_typ==
ro_is)
4223 Print(
" start %d, end: %d: ",r->typ[
j].data.is.start, r->typ[
j].data.is.end);
4227 Print(
" limit %d",r->typ[
j].data.is.limit);
4234 else if (r->typ[
j].ord_typ==
ro_am)
4236 Print(
" place %d",r->typ[
j].data.am.place);
4237 Print(
" start %d",r->typ[
j].data.am.start);
4238 Print(
" end %d",r->typ[
j].data.am.end);
4239 Print(
" len_gen %d",r->typ[
j].data.am.len_gen);
4242 for(
l=r->typ[
j].data.am.start;
l<=r->typ[
j].data.am.end;
l++)
4243 Print(
" %d",r->typ[
j].data.am.weights[
l-r->typ[
j].data.am.start]);
4244 l=r->typ[
j].data.am.end+1;
4245 int ll=r->typ[
j].data.am.weights[
l-r->typ[
j].data.am.start];
4248 Print(
" %d",r->typ[
j].data.am.weights[
lll-r->typ[
j].data.am.start]);
4252 Print(
" place %d",r->typ[
j].data.dp.place);
4256 Print(
" start %d",r->typ[
j].data.dp.start);
4257 Print(
" end %d",r->typ[
j].data.dp.end);
4258 if ((r->typ[
j].ord_typ==
ro_wp)
4262 for(
int l=r->typ[
j].data.wp.start;
l<=r->typ[
j].data.wp.end;
l++)
4263 Print(
" %d",r->typ[
j].data.wp.weights[
l-r->typ[
j].data.wp.start]);
4265 else if (r->typ[
j].ord_typ==
ro_wp64)
4269 for(
l=r->typ[
j].data.wp64.start;
l<=r->typ[
j].data.wp64.end;
l++)
4270 Print(
" %ld",(
long)(r->typ[
j].data.wp64.weights64+
l-r->typ[
j].data.wp64.start));
4276 Print(
"pOrdIndex:%d pCompIndex:%d\n", r->pOrdIndex, r->pCompIndex);
4277 Print(
"OrdSize:%d\n",r->OrdSize);
4278 PrintS(
"--------------------\n");
4279 for(
j=0;
j<r->ExpL_Size;
j++)
4283 Print(
"ordsgn %ld ", r->ordsgn[
j]);
4289 if( (r->VarOffset[
i] & 0xffffff) ==
j )
4290 {
Print(
"v%d at e[%d], bit %d; ",
i,r->VarOffset[
i] & 0xffffff,
4291 r->VarOffset[
i] >>24 ); }
4293 if( r->pCompIndex==
j )
PrintS(
"v0; ");
4294 for(
i=0;
i<r->OrdSize;
i++)
4296 if (r->typ[
i].data.dp.place ==
j)
4298 Print(
"ordrec:%s (start:%d, end:%d) ",
TYP[r->typ[
i].ord_typ],
4299 r->typ[
i].data.dp.start, r->typ[
i].data.dp.end);
4303 if (
j==r->pOrdIndex)
4308 Print(
"LexOrder:%d, MixedOrder:%d\n",r->LexOrder, r->MixedOrder);
4310 Print(
"NegWeightL_Size: %d, NegWeightL_Offset: ", r->NegWeightL_Size);
4311 if (r->NegWeightL_Offset==
NULL)
PrintS(
" NULL");
4313 for(
j = 0;
j < r->NegWeightL_Size;
j++)
4314 Print(
" [%d]: %d ",
j, r->NegWeightL_Offset[
j]);
4335#define pFDeg_CASE(A) if(r->pFDeg == A) PrintS( "" #A "" )
4341 Print(
"(%p)", r->pFDeg);
4344 Print(
"pLDeg : (%p)", r->pLDeg);
4356 else Print(
"%p\n",r->p_Setm);
4366 Print(
"\nexp[0..%d]\n",r->ExpL_Size-1);
4367 for(
i=0;
i<r->ExpL_Size;
i++)
4375 if (
j==0) {
PrintS(
"...\n");
break; }
4384 Print(
"\nexp[0..%d]\n",
R->ExpL_Size - 1);
4385 for(
int i = 0;
i <
R->ExpL_Size;
i++)
4474 WarnS(
"rAssure_SyzComp: input ring has an IS-ordering!");
4485 int ** wvhdl =(
int **)
omAlloc0((
i+1)*
sizeof(
int**));
4488 res->order[
j]=r->order[
j-1];
4489 res->block0[
j]=r->block0[
j-1];
4490 res->block1[
j]=r->block1[
j-1];
4491 if (r->wvhdl[
j-1] !=
NULL)
4497 int l=r->block1[
j-1]-r->block0[
j-1]+1;
4502 l+=r->wvhdl[
j-1][r->block1[
j-1]-r->block0[
j-1]+1]+1;
4505 memcpy(wvhdl[
j],r->wvhdl[
j-1],
l*
sizeof(
int));
4523 WarnS(
"error in nc_rComplete");
4533 if (r->qideal!=
NULL)
4563 pos=r->VarL_LowIndex;
4568 for(
int i=r->OrdSize-1;
i>=0;
i--)
4570 if ((r->typ[
i].ord_typ==
ro_dp)
4571 && (r->typ[
i].data.dp.start==1)
4572 && (r->typ[
i].data.dp.end==r->N))
4574 pos=r->typ[
i].data.dp.place;
4593 res->ExpL_Size=r->ExpL_Size+1;
4597 for(
j=0;
j<r->CmpL_Size;
j++)
4599 res->ordsgn[
j] = r->ordsgn[
j];
4601 res->OrdSize=r->OrdSize+1;
4610 res->typ[
res->OrdSize-1].data.dp.start=1;
4611 res->typ[
res->OrdSize-1].data.dp.end=
res->N;
4612 res->typ[
res->OrdSize-1].data.dp.place=
res->ExpL_Size-1;
4613 pos=
res->ExpL_Size-1;
4629 WarnS(
"error in nc_rComplete");
4635 if (r->qideal!=
NULL)
4665 if (r->order[
i] == 0)
4683 if (r->wvhdl[
j]!=
NULL)
4689 int l=r->block1[
j]-r->block0[
j]+1;
4694 l+=r->wvhdl[
j][r->block1[
j]-r->block0[
j]+1]+1;
4716 WarnS(
"error in nc_rComplete");
4767 WarnS(
"error in nc_rComplete");
4801 WarnS(
"error in nc_rComplete");
4818 WarnS(
"error in nc_SetupQuotient");
4844 (r->order[0] ==
b1) &&
4845 (r->order[1] ==
b2) &&
4858 res->block1[1] = r->N;
4863 res->block1[0] = r->N;
4873 WarnS(
"error in nc_rComplete");
4892 for(
int i=0;
i<r->N;
i++)
4894 if ((*
w)[
i]!=r->wvhdl[0][
i]) { ok=
FALSE;
break;}
4906 res->block1[1] = r->N;
4907 res->wvhdl[0]=(
int*)
omAlloc(r->N*
sizeof(
int));
4908 for(
int i=0;
i<r->N;
i++)
4910 r->wvhdl[0][
i]=(*w)[
i];
4920 WarnS(
"error in nc_rComplete");
4933 Print(
"rAssure_InducedSchreyerOrdering(r, complete = %d, sgn = %d): r: \n", complete,
sgn);
4950 int ** wvhdl =(
int **)
omAlloc0((n+2)*
sizeof(
int**));
4958 res->block0[
j] =
res->block1[
j] = 0;
4962 for(
int i = 0; (
i <= n) && (r->order[
i] != 0);
i++,
j++)
4964 res->order [
j] = r->order [
i];
4965 res->block0[
j] = r->block0[
i];
4966 res->block1[
j] = r->block1[
i];
4968 if (r->wvhdl[
i] !=
NULL)
4974 int l=(r->block1[
i]-r->block0[
i]+1);
4979 l+=r->wvhdl[
i][r->block1[
i]-r->block0[
i]+1]+1;
4982 memcpy(wvhdl[
j],r->wvhdl[
i],
l*
sizeof(
int));
5014 WarnS(
"error in nc_rComplete");
5026 if (r->qideal!=
NULL)
5088 Print(
"rIsIS(p: %d)\nF:",
p);
5099 for(
int pos = 0; pos < r->OrdSize; pos++ )
5100 if( r->typ[pos].ord_typ ==
ro_is)
5122 dReportError(
"Error: WRONG USE of rSetISReference: wrong ring! (typ == NULL)");
5131 dReportError(
"Error: WRONG USE of rSetISReference: specified ordering block was not found!!!" );
5136 if(
i != r->typ[pos].data.is.limit )
5137 Print(
"Changing record on pos: %d\nOld limit: %d --->> New Limit: %d\n", pos, r->typ[pos].data.is.limit,
i);
5143 if( r->typ[pos].data.is.F !=
NULL)
5146 PrintS(
"Deleting old reference set F... \n");
5149 r->typ[pos].data.is.F =
NULL;
5154 r->typ[pos].data.is.F =
FF;
5156 r->typ[pos].data.is.limit =
i;
5180 if ((r->typ!=
NULL) && (r->typ[0].ord_typ==
ro_syz))
5182 r->block0[0]=r->block1[0] =
k;
5183 if(
k == r->typ[0].data.syz.limit )
5187 if (r->typ[0].data.syz.limit == 0)
5189 r->typ[0].data.syz.syz_index = (
int*)
omAlloc0((
k+1)*
sizeof(
int));
5190 r->typ[0].data.syz.syz_index[0] = 0;
5191 r->typ[0].data.syz.curr_index = 1;
5195 r->typ[0].data.syz.syz_index = (
int*)
5197 (r->typ[0].data.syz.limit+1)*
sizeof(
int),
5200 for (
i=r->typ[0].data.syz.limit + 1;
i<=
k;
i++)
5202 r->typ[0].data.syz.syz_index[
i] =
5203 r->typ[0].data.syz.curr_index;
5205 if(
k < r->typ[0].data.syz.limit)
5208 Warn(
"rSetSyzComp called with smaller limit (%d) as before (%d)",
k, r->typ[0].data.syz.limit);
5210 r->typ[0].data.syz.curr_index = 1 + r->typ[0].data.syz.syz_index[
k];
5214 r->typ[0].data.syz.limit =
k;
5215 r->typ[0].data.syz.curr_index++;
5224 Warn(
"rSetSyzComp(%d) in an IS ring! Be careful!",
k);
5229 r->block0[0] = r->block1[0] =
k;
5244 if ((r->typ!=
NULL) && (r->typ[0].ord_typ==
ro_syz) &&
5245 r->typ[0].data.syz.limit > 0 &&
i > 0)
5249 for (
j=0;
j<r->typ[0].data.syz.limit;
j++)
5251 if (r->typ[0].data.syz.syz_index[
j] ==
i &&
5252 r->typ[0].data.syz.syz_index[
j+1] !=
i)
5254 assume(r->typ[0].data.syz.syz_index[
j+1] ==
i+1);
5258 return r->typ[0].data.syz.limit;
5263 WarnS(
"rGetMaxSyzComp: order c");
5278 if ((r->order[0]==
ringorder_dp) &&(r->block0[0]==1) &&(r->block1[0]==r->N))
5281 && ((r->order[1]==
ringorder_dp) &&(r->block0[1]==1) &&(r->block1[1]==r->N)))
5288 if ((r->order[0]==
ringorder_Dp) &&(r->block0[0]==1) &&(r->block1[0]==r->N))
5291 && ((r->order[1]==
ringorder_Dp) &&(r->block0[1]==1) &&(r->block1[1]==r->N)))
5298 if ((r->order[0]==
ringorder_lp) &&(r->block0[0]==1) &&(r->block1[0]==r->N))
5301 && ((r->order[1]==
ringorder_lp) &&(r->block0[1]==1) &&(r->block1[1]==r->N)))
5311 while((r->typ[
i].ord_typ!=
ro_wp64) && (r->typ[
i].ord_typ>0))
i++;
5313 return r->typ[
i].data.wp64.weights64;
5321 memcpy(r->typ[0].data.wp64.weights64,
wv,r->N*
sizeof(
int64));
5332 for(
int k=
size;
k>pos;
k--) r->wvhdl[
k]=r->wvhdl[
k-1];
5344 for(
int k=pos+1;
k<
size;
k++) r->wvhdl[
k]=r->wvhdl[
k+1];
5354 for(
int j=0;
j<=
i2;
j++)
5362#define rOppVar(R,I) (rVar(R)+1-I)
5380 if (src->qideal !=
NULL)
5388 for(
i=
i2;
i>=0;
i--)
5394 p = r->names[
rVar(r)-1-
i];
5395 r->names[
rVar(r)-1-
i] = r->names[
i];
5413 char *
p=r->names[
i];
5466 for(
i=0; src->order[
i]!=0;
i++)
5468 switch (src->order[
i])
5473 r->order[
j]=src->order[
i];
5477 r->block0[
j]=
rOppVar(r, src->block1[
i]);
5478 r->block1[
j]=
rOppVar(r, src->block0[
i]);
5482 r->block0[
j]=
rOppVar(r, src->block1[
i]);
5483 r->block1[
j]=
rOppVar(r, src->block0[
i]);
5489 r->block0[
j]=
rOppVar(r, src->block1[
i]);
5490 r->block1[
j]=
rOppVar(r, src->block0[
i]);
5491 r->wvhdl[
j]=(
int*)
omAlloc((r->block1[
j]-r->block0[
j]+1)*
sizeof(
int));
5492 for(
int k=r->block0[
j];
k<=r->block1[
j];
k++)
5493 r->wvhdl[
j][
k-r->block0[
j]]=1;
5496 r->block0[
j]=
rOppVar(r, src->block1[
i]);
5497 r->block1[
j]=
rOppVar(r, src->block0[
i]);
5505 r->block0[
j]=
rOppVar(r, src->block1[
i]);
5506 r->block1[
j]=
rOppVar(r, src->block0[
i]);
5507 r->wvhdl[
j]=(
int*)
omAlloc((r->block1[
j]-r->block0[
j]+1)*
sizeof(
int));
5508 for(
int k=r->block0[
j];
k<=r->block1[
j];
k++)
5509 r->wvhdl[
j][
k-r->block0[
j]]=1;
5512 r->block0[
j]=
rOppVar(r, src->block1[
i]);
5513 r->block1[
j]=
rOppVar(r, src->block0[
i]);
5521 r->block0[
j]=
rOppVar(r, src->block1[
i]);
5522 r->block1[
j]=
rOppVar(r, src->block0[
i]);
5523 r->wvhdl[
j]=r->wvhdl[
j+1]; r->wvhdl[
j+1]=
NULL;
5527 r->block0[
j]=
rOppVar(r, src->block1[
i]);
5528 r->block1[
j]=
rOppVar(r, src->block0[
i]);
5536 r->block0[
j]=
rOppVar(r, src->block1[
i]);
5537 r->block1[
j]=
rOppVar(r, src->block0[
i]);
5538 r->wvhdl[
j]=r->wvhdl[
j+1]; r->wvhdl[
j+1]=
NULL;
5542 r->block0[
j]=
rOppVar(r, src->block1[
i]);
5543 r->block1[
j]=
rOppVar(r, src->block0[
i]);
5550 r->block0[
j]=
rOppVar(r, src->block1[
i]);
5551 r->block1[
j]=
rOppVar(r, src->block0[
i]);
5552 int n=r->block1[
j]-r->block0[
j];
5554 for (
int nn=0;
nn<=n;
nn++)
5563 r->block0[
j]=
rOppVar(r, src->block1[
i]);
5564 r->block1[
j]=
rOppVar(r, src->block0[
i]);
5609 for(
i=0; src->order[
i]!=0;
i++)
5611 switch (src->order[
i])
5616 r->order[
j]=src->order[
i];
5620 r->block0[
j]=
rOppVar(r, src->block1[
i]);
5621 r->block1[
j]=
rOppVar(r, src->block0[
i]);
5625 r->block0[
j]=
rOppVar(r, src->block1[
i]);
5626 r->block1[
j]=
rOppVar(r, src->block0[
i]);
5631 r->block0[
j]=
rOppVar(r, src->block1[
i]);
5632 r->block1[
j]=
rOppVar(r, src->block0[
i]);
5638 r->block0[
j]=
rOppVar(r, src->block1[
i]);
5639 r->block1[
j]=
rOppVar(r, src->block0[
i]);
5688 for(
i=1;
i<=r->N;
i++)
5704 MATELEM(C,
nj,
ni) =
p_PermPoly(
MATELEM(src->GetNC()->C,
i,
j),perm,src,r,
nMap,
par_perm,
rPar(src));
5707 MATELEM(
D,
nj,
ni) =
p_PermPoly(
MATELEM(src->GetNC()->D,
i,
j),perm,src,r,
nMap,
par_perm,
rPar(src));
5715 WarnS(
"Error initializing non-commutative multiplication!");
5723 assume( r->GetNC()->IsSkewConstant == src->GetNC()->IsSkewConstant);
5730 if (src->qideal !=
NULL)
5733 r->qideal =
idOppose(src, src->qideal, r);
5735 r->qideal =
id_Copy(src->qideal, r);
5767 WarnS(
"Error in rEnvelope at rSum");
5790 const int N = dest->N;
5810 for (
int i = 1;
i <
N;
i++)
5812 for (
int j =
i + 1;
j <=
N;
j++)
5815 const poly
p =
p_NSet(n, dest);
5877 Werror(
"n_IsParam: IsParam is not to be used for (coeff_type = %d)",
getCoeffType(C));
5886 WerrorS(
"only for rings with an ordering of one block");
5903 WerrorS(
"ordering must be dp,Dp,lp,rp,ds,Ds or ls");
5906 for(
int i=r->N-1;
i>=0;
i--)
5910 Werror(
"duplicate variable name >>%s<<",
v);
5916 #ifdef HAVE_SHIFTBBA
5919 R->isLPring=r->isLPring+1;
5920 R->N=((r->N)/r->isLPring)+r->N;
5924 for(
int b=0;
b<((r->N)/r->isLPring);
b++)
5927 for(
int i=
R->isLPring-1;
i>0;
i--)
5928 names[
i+
b*
R->isLPring]=
R->names[
i-1+
b*r->isLPring];
5933 for(
int b=0;
b<((r->N)/r->isLPring);
b++)
5936 for(
int i=
R->isLPring-2;
i>=0;
i--)
5937 names[
i+
b*
R->isLPring]=
R->names[
i+
b*r->isLPring];
5949 for(
int i=
R->N-1;
i>0;
i--) names[
i]=
R->names[
i-1];
5954 for(
int i=
R->N-2;
i>=0;
i--) names[
i]=
R->names[
i];
5968 WerrorS(
"only for rings with an ordering of one block");
5985 WerrorS(
"ordering must be dp,Dp,lp,rp,ds,Ds or ls");
5996 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_aa
for idElimination, like a, except pFDeg, pWeigths ignore it
@ ringorder_is
opposite of ls
@ 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,