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: ");
265 if (C->is_field)
PrintS(
" considered as a field\n");
266 else PrintS(
" considered as a non-field\n");
306 Print(
"// number of vars : %d",r->N);
314 Print(
"\n// block %3d : ",
l+1);
321 assume( r->block0[
l] == r->block1[
l] );
322 const int s = r->block0[
l];
330 Print(
" syz_comp: %d",r->block0[
l]);
342 for (
i = r->block0[
l]-1;
i<r->block1[
l];
i++)
349 if (r->wvhdl[
l]!=
NULL)
361 Warn(
"should not have wvhdl entry at pos. %d",
l);
364 int bl=r->block1[
l]-r->block0[
l]+1;
366 j<(r->block1[
l]-r->block0[
l]+1)*(r->block1[
l]-r->block0[
l]+1);
369 PrintS(
"\n// : weights ");
370 for (
i = 0;
i<=r->block1[
l]-r->block0[
l];
i++)
388 int m=r->wvhdl[
l][
bl];
389 Print(
"\n// : %d module weights ",
m);
398 PrintS(
"\n// noncommutative relations:");
404 for (
i = 1;
i<r->N;
i++)
406 for (
j =
i+1;
j<=r->N;
j++)
411 Print(
"\n// %s%s=",r->names[
j-1],r->names[
i-1]);
422 Print(
"\n// is skew constant:%d",r->GetNC()->IsSkewConstant);
427 PrintS(
"\n// quotient of sca by ideal");
440 Print(
"\n// letterplace ring (block size %d, ncgen count %d)",r->isLPring, r->LPncGenCount);
445 PrintS(
"\n// quotient ring from ideal");
458 if (r ==
NULL)
return;
463 if( r->qideal !=
NULL )
478 if (r->order !=
NULL)
489 if (r->wvhdl[
j]!=
NULL)
502 for (
i=0;
i<r->N;
i++)
550 if (r->wvhdl[
l]!=
NULL)
562 Warn(
"should not have wvhdl entry at pos. %d",
l);
570 j<(r->block1[
l]-r->block0[
l]+1)*(r->block1[
l]-r->block0[
l]+1);
577 for (
i = 0;
i<r->block1[
l]-r->block0[
l];
i++)
586 for (
i = 0;
i<r->block1[
l]-r->block0[
l];
i++)
596 if (
j+
i+1==(r->block1[
l]-r->block0[
l]+1)*(r->block1[
l]-r->block0[
l]+1))
607 assume( r->block0[
l] == r->block1[
l] );
608 const int s = r->block0[
l];
616 if (r->wanted_maxExp!=0)
618 long mm=r->wanted_maxExp;
635 for (
i=0;
i<r->N;
i++)
641 for (
i=0;
i<r->N-1;
i++)
733 for(
int i=1;
i<r->N;
i++)
734 for(
int j=
i+1;
j<=r->N;
j++)
738 WarnS(
"Error initializing multiplication!");
793 && (
mpz_cmp(
r1->cf->modNumber,
r2->cf->extRing->cf->modNumber)==0))
826 if (
r1->cf->extRing->cf==
r2->cf)
836 WerrorS (
"coeff sum of two extension fields not implemented");
842 WerrorS(
"coeff sum not yet implemented");
849 char **names=(
char **)
omAlloc0(
l*
sizeof(
char *));
854 for (
i=0;
i<
r1->N;
i++)
858 if (*(
r1->names[
i]) ==
'\0')
890 if (*(
r2->names[
i]) ==
'\0')
982 if ((
r2->block0[0]==1)
989 tmpR.order[1]=
r2->order[0];
995 int l=
r2->block1[0]-
r2->block0[0]+1;
1000 l+=
r2->wvhdl[1][
r2->block1[0]-
r2->block0[0]+1]+1;
1071 WarnS(
"rSum: weights not implemented");
1077 for (
i=0;
r1->order[
i]!=0;
i++)
1087 int l=
r1->block1[
i]-
r1->block0[
i]+1;
1092 l+=
r1->wvhdl[
i][
r1->block1[
i]-
r1->block0[
i]+1]+1;
1107 for (
i=0;
r2->order[
i]!=0;
i++)
1121 int l=
r2->block1[
i]-
r2->block0[
i]+1;
1126 l+=
r2->wvhdl[
i][
r2->block1[
i]-
r2->block0[
i]+1]+1;
1136 if((
r1->OrdSgn==-1)||(
r2->OrdSgn==-1))
1162 int l=
r1->block1[
i]-
r1->block0[
i]+1;
1167 l+=
r1->wvhdl[
i][
r1->block1[
i]-
r1->block0[
i]+1]+1;
1268 MATELEM(C,
i,
j) =
p_PermPoly(
MATELEM(
C1,
i,
j),
perm1,
R1,
sum,
nMap1,
par_perm1,
rPar(
R1));
1271 MATELEM(
D,
i,
j) =
p_PermPoly(
MATELEM(
D1,
i,
j),
perm1,
R1,
sum,
nMap1,
par_perm1,
rPar(
R1));
1284 MATELEM(C,
rVar(
R1)+
i,
rVar(
R1)+
j) =
p_PermPoly(
MATELEM(
C2,
i,
j),
perm2,
R2,
sum,
nMap2,
par_perm2,
rPar(
R2));
1287 MATELEM(
D,
rVar(
R1)+
i,
rVar(
R1)+
j) =
p_PermPoly(
MATELEM(
D2,
i,
j),
perm2,
R2,
sum,
nMap2,
par_perm2,
rPar(
R2));
1295 WarnS(
"Error initializing non-commutative multiplication!");
1304 Print(
"\nRefs: R1: %d, R2: %d\n",
R1->GetNC()->ref,
R2->GetNC()->ref);
1433 res->options=r->options;
1448 res->firstBlockEnds=r->firstBlockEnds;
1450 res->real_var_start=r->real_var_start;
1451 res->real_var_end=r->real_var_end;
1455 res->isLPring=r->isLPring;
1456 res->LPncGenCount=r->LPncGenCount;
1459 res->VectorOut=r->VectorOut;
1460 res->ShortOut=r->ShortOut;
1461 res->CanShortOut=r->CanShortOut;
1477 res->bitmask=r->bitmask;
1478 res->divmask=r->divmask;
1479 res->BitsPerExp = r->BitsPerExp;
1480 res->ExpPerLong = r->ExpPerLong;
1501 res->LexOrder=r->LexOrder;
1502 res->MixedOrder=r->MixedOrder;
1510 if (r->wvhdl[
j]!=
NULL)
1516 int l=r->block1[
j]-r->block0[
j]+1;
1521 l+=r->wvhdl[
j][r->block1[
j]-r->block0[
j]+1]+1;
1532 memcpy(
res->block0,r->block0,
i *
sizeof(
int));
1533 memcpy(
res->block1,r->block1,
i *
sizeof(
int));
1548 if (r->qideal!=
NULL)
1577 res->options=r->options;
1592 res->firstBlockEnds=r->firstBlockEnds;
1594 res->real_var_start=r->real_var_start;
1595 res->real_var_end=r->real_var_end;
1599 res->isLPring=r->isLPring;
1600 res->LPncGenCount=r->LPncGenCount;
1603 res->VectorOut=r->VectorOut;
1604 res->ShortOut=r->ShortOut;
1605 res->CanShortOut=r->CanShortOut;
1606 res->LexOrder=r->LexOrder;
1607 res->MixedOrder=r->MixedOrder;
1623 res->bitmask=r->bitmask;
1624 res->divmask=r->divmask;
1625 res->BitsPerExp = r->BitsPerExp;
1626 res->ExpPerLong = r->ExpPerLong;
1652 for (
j=0;
j<
i-1;
j++)
1654 if (r->wvhdl[
j]!=
NULL)
1660 int l=r->block1[
j]-r->block0[
j]+1;
1665 l+=r->wvhdl[
j][r->block1[
j]-r->block0[
j]+1]+1;
1676 memcpy(&(
res->block0[1]),r->block0,(
i-1) *
sizeof(
int));
1677 memcpy(&(
res->block1[1]),r->block1,(
i-1) *
sizeof(
int));
1695 res->wvhdl[0]=(
int *)
A;
1705 if (r->qideal!=
NULL)
1711 WerrorS(
"internal error: rCopy0(Q,TRUE,FALSE)");
1716 WarnS(
"internal bad stuff: rCopy0(Q,TRUE,TRUE)");
1757 if (
r1->bitmask!=
r2->bitmask)
return FALSE;
1758 #ifdef HAVE_SHIFTBBA
1759 if (
r1->isLPring!=
r2->isLPring)
return FALSE;
1760 if (
r1->LPncGenCount!=
r2->LPncGenCount)
return FALSE;
1812 if ((
r1->cf !=
r2->cf)
1814 || (
r1->OrdSgn !=
r2->OrdSgn))
1818 while (
r1->order[
i] != 0)
1820 if (
r2->order[
i] == 0)
return FALSE;
1821 if ((
r1->order[
i] !=
r2->order[
i])
1822 || (
r1->block0[
i] !=
r2->block0[
i])
1823 || (
r1->block1[
i] !=
r2->block1[
i]))
1829 for (
j=0;
j<
r1->block1[
i]-
r1->block0[
i]+1;
j++)
1830 if (
r2->wvhdl[
i][
j] !=
r1->wvhdl[
i][
j])
1836 if (
r2->order[
i] != 0)
return FALSE;
1930 if ((r->block0[
s]!=1)||(r->block1[
s]!=r->N))
2021 for (pos=0;pos<r->OrdSize;pos++)
2039 return ((
rVar(r) > 1) &&
2045 ((r->order[1]!=0) &&
2053 return ((
rVar(r) > 1) &&
2055 &&(r->block0[ord]==1)
2056 &&(r->block1[ord]==r->N));
2063 return ((
rVar(r) > 1) &&
2065 &&(r->block0[ord]==1)
2066 &&(r->block1[ord]==r->N));
2073 return ((
rVar(r) > 1) &&
2075 &&(r->block0[ord]==1)
2076 &&(r->block1[ord]==r->N));
2083 return ((
rVar(r) > 1) &&
2102 if (r->N == 0)
return TRUE;
2104 if ((r->OrdSgn!=1) && (r->OrdSgn!= -1))
2116 for(
int j=0;
j<=
i;
j++)
2119 dError(
"wrong order in r->order");
2130 if (r->VarOffset ==
NULL)
2132 dReportError(
"Null ring VarOffset -- no rComplete (?) in n %s:%d",
fn,
l);
2137 if ((r->OrdSize==0)!=(r->typ==
NULL))
2139 dReportError(
"mismatch OrdSize and typ-pointer in %s:%d");
2145 for(
i=0;
i<=r->N;
i++)
2149 for(
j=0;
j<r->OrdSize;
j++)
2153 const int p = r->typ[
j].data.isTemp.suffixpos;
2160 if(r->typ[
p].ord_typ !=
ro_is)
2161 dReportError(
"ordrec prefix %d is unmatched (suffix: %d is wrong!!!)",
j,
p);
2164 if(r->typ[
j].data.isTemp.pVarOffset[
i] != -1)
2170 else if (r->typ[
j].ord_typ ==
ro_is)
2173 if(r->typ[
j].data.is.pVarOffset[
i] != -1)
2181 if (r->typ[
j].ord_typ==
ro_cp)
2183 if(((
short)r->VarOffset[
i]) == r->typ[
j].data.cp.place)
2188 && (r->VarOffset[
i] == r->typ[
j].data.dp.place))
2194 tmp=r->VarOffset[
i] & 0xffffff;
2195 #if SIZEOF_LONG == 8
2196 if ((r->VarOffset[
i] >> 24) >63)
2198 if ((r->VarOffset[
i] >> 24) >31)
2200 dReportError(
"bit_start out of range:%d",r->VarOffset[
i] >> 24);
2201 if (
i > 0 && ((
tmp<0) ||(
tmp>r->ExpL_Size-1)))
2208 for(
j=0;
j<r->OrdSize;
j++)
2210 if ((r->typ[
j].ord_typ==
ro_dp)
2211 || (r->typ[
j].ord_typ==
ro_wp)
2214 if (r->typ[
j].data.dp.start > r->typ[
j].data.dp.end)
2216 r->typ[
j].data.dp.start, r->typ[
j].data.dp.end);
2217 if ((r->typ[
j].data.dp.start < 1)
2218 || (r->typ[
j].data.dp.end > r->N))
2219 dReportError(
"in ordrec %d: start(%d)<1 or end(%d)>vars(%d)",
j,
2220 r->typ[
j].data.dp.start, r->typ[
j].data.dp.end,r->N);
2284 while((start<end) && (weights[0]==0)) { start++; weights++; }
2285 while((start<end) && (weights[end-start]==0)) { end--; }
2288 for(
i=start;
i<=end;
i++)
2290 if(weights[
i-start]!=1)
2310 for(
i=start;
i<=end;
i++)
2312 if(weights[
i-start]<0)
2334 ord_struct.data.am.weights_m = weights + (end-start+1);
2335 ord_struct.data.am.len_gen=weights[end-start+1];
2370 while((start<end) && (weights[0]==0)) { start++; weights++; }
2371 while((start<end) && (weights[end-start]==0)) { end--; }
2382 for(
i=start;
i<=end;
i++)
2384 if(weights[
i-start]<0)
2554 int *pVarOffset =
tmp_typ[
typ_j].data.isTemp.pVarOffset;
2572 for(
int i = 0;
i <=
N;
i++ )
2575 if(
v[
i] != pVarOffset[
i] )
2577 pVarOffset[
i] =
v[
i];
2579 assume( pVarOffset[
i] != -1 );
2585 if( pVarOffset[0] != -1 )
2586 pVarOffset[0] &= 0x0fff;
2627 bits=16; bitmask=0xffff;
2629 else if (bitmask <= 1L)
2631 bits=1; bitmask = 1L;
2633 else if (bitmask <= 3L)
2635 bits=2; bitmask = 3L;
2637 else if (bitmask <= 7L)
2641 else if (bitmask <= 0xfL)
2643 bits=4; bitmask=0xfL;
2645 else if (bitmask <= 0x1fL)
2647 bits=5; bitmask=0x1fL;
2649 else if (bitmask <= 0x3fL)
2651 bits=6; bitmask=0x3fL;
2654 else if (bitmask <= 0x7fL)
2656 bits=7; bitmask=0x7fL;
2659 else if (bitmask <= 0xffL)
2661 bits=8; bitmask=0xffL;
2664 else if (bitmask <= 0x1ffL)
2666 bits=9; bitmask=0x1ffL;
2669 else if (bitmask <= 0x3ffL)
2671 bits=10; bitmask=0x3ffL;
2674 else if (bitmask <= 0xfffL)
2676 bits=12; bitmask=0xfff;
2679 else if (bitmask <= 0xffffL)
2681 bits=16; bitmask=0xffffL;
2684 else if (bitmask <= 0xfffffL)
2686 bits=20; bitmask=0xfffffL;
2688 else if (bitmask <= 0xffffffffL)
2690 bits=32; bitmask=0xffffffffL;
2692 else if (bitmask <= 0x7fffffffffffffffL)
2694 bits=63; bitmask=0x7fffffffffffffffL;
2698 bits=63; bitmask=0x7fffffffffffffffL;
2701 else if (bitmask <= 0x7fffffff)
2703 bits=31; bitmask=0x7fffffff;
2707 bits=31; bitmask=0x7fffffffL;
2778 if (r->block0[
i]==r->block1[
i])
2803 Warn(
"Error: unhandled ordering in rModifyRing: ringorder_S = [%d]",
r_ord);
2882 block0[
j]=r->block0[
i];
2883 block1[
j]=r->block1[
i];
2884 wvhdl[
j]=r->wvhdl[
i];
2910 res->wanted_maxExp=r->wanted_maxExp;
2917 if (r->pFDegOrig !=
res->pFDegOrig &&
2922 res->firstwv = r->firstwv;
2923 res->firstBlockEnds = r->firstBlockEnds;
2927 res->pLDeg = r->pLDegOrig;
2936 res->typ[0] = r->typ[0];
2938 if (r->typ[0].data.syz.limit > 0)
2940 res->typ[0].data.syz.syz_index
2941 = (
int*)
omAlloc((r->typ[0].data.syz.limit +1)*
sizeof(
int));
2942 memcpy(
res->typ[0].data.syz.syz_index, r->typ[0].data.syz.syz_index,
2943 (r->typ[0].data.syz.limit +1)*
sizeof(
int));
2956 r->typ[
i].data.is.limit,
2967 res->OrdSgn=r->OrdSgn;
2976 WarnS(
"error in nc_rComplete");
2989 WarnS(
"error in sca_Force!");
3015 res->block1[0] = r->N;
3016 res->wvhdl[0] = weights;
3031 WarnS(
"error in nc_rComplete");
3082 res->wanted_maxExp=r->wanted_maxExp;
3093 WarnS(
"error in nc_rComplete");
3138 r->CanShortOut=
FALSE;
3141 r->CanShortOut =
TRUE;
3149 r->CanShortOut=
FALSE;
3157 for (
i=(
N-1);
i>=0;
i--)
3161 r->CanShortOut=
FALSE;
3167 r->ShortOut = r->CanShortOut;
3169 assume( !( !r->CanShortOut && r->ShortOut ) );
3177 if(block1[
i]!=r->N) r->LexOrder=
TRUE;
3178 r->firstBlockEnds=block1[
i];
3179 r->firstwv = wvhdl[
i];
3188 for(
j=block1[
i]-block0[
i];
j>=0;
j--)
3190 if (r->firstwv[
j]==0) r->LexOrder=
TRUE;
3197 for(
j=block1[
i]-block0[
i];
j>=0;
j--)
3199 if (
w[
j]==0) r->LexOrder=
TRUE;
3206 if (r->pFDeg ==
p_Deg)
3227 r->pLDegOrig = r->pLDeg;
3241 if (r->order[
i]==0)
break;
3251 int* block0 = r->block0;
3252 int* block1 = r->block1;
3253 int** wvhdl = r->wvhdl;
3262 r->LexOrder =
FALSE;
3269 for(
int ii=block0[0];
ii<=block1[0];
ii++)
3270 if (wvhdl[0][
ii-1]<0) { r->MixedOrder=2;
break;}
3272 for(
int ii=block0[0];
ii<=block1[0];
ii++)
3273 if (wvhdl[0][
ii-1]==0) { r->LexOrder=
TRUE;
break;}
3274 if ((block0[0]==1)&&(block1[0]==r->N))
3285 r->firstwv = wvhdl[0];
3297 if (r->OrdSgn == -1) r->pLDeg =
pLDeg0c;
3316 for(
int ii=block0[0];
ii<=block1[0];
ii++)
3318 if (wvhdl[0][
ii-1]<0) { r->MixedOrder=2;
break;}
3320 if (r->MixedOrder==0)
3322 if ((block0[0]==1)&&(block1[0]==r->N))
3330 r->firstBlockEnds=block1[0];
3331 r->firstwv = wvhdl[0];
3350 r->firstBlockEnds=block1[1];
3351 if (wvhdl!=
NULL) r->firstwv = wvhdl[1];
3359 for(
int ii=block0[1];
ii<=block1[1];
ii++)
3360 if (wvhdl[1][
ii-1]<0) { r->MixedOrder=2;
break;}
3361 if (r->MixedOrder==
FALSE)
3394 if(r->MixedOrder==
FALSE)
3409 r->pFDegOrig = r->pFDeg;
3424 for(
i=0;
i<r->OrdSize;
i++)
3427 ||(r->typ[
i].ord_typ==
ro_am))
3432 r->NegWeightL_Size=
l;
3433 r->NegWeightL_Offset=(
int *)
omAlloc(
l*
sizeof(
int));
3435 for(
i=0;
i<r->OrdSize;
i++)
3439 r->NegWeightL_Offset[
l]=r->typ[
i].data.wp.place;
3442 else if(r->typ[
i].ord_typ==
ro_am)
3444 r->NegWeightL_Offset[
l]=r->typ[
i].data.am.place;
3451 r->NegWeightL_Size = 0;
3452 r->NegWeightL_Offset =
NULL;
3464 if ( (r->cf->extRing!=
NULL)
3474 if (r->LexOrder || r->OrdSgn == -1 || (r->cf->extRing!=
NULL))
3489 r->pLexOrder=r->LexOrder;
3497static inline int sign(
int x) {
return (
x > 0) - (
x < 0);}
3528 r->BitsPerExp =
bits;
3536 for(
i=r->N;
i>=0 ;
i--)
3553 switch (r->order[
i])
3577 r->ComponentOrder=1;
3583 r->ComponentOrder=-1;
3589 k=r->block1[
i]-r->block0[
i]+1;
3594 r->wvhdl[
i]+(r->block1[
i]-r->block0[
i]+1)*
l);
3621 if (r->block0[
i]==r->block1[
i])
3637 if (r->block0[
i]==r->block1[
i])
3653 if (r->block0[
i]==r->block1[
i])
3669 if (r->block0[
i]==r->block1[
i])
3685 if (r->block0[
i]==r->block1[
i])
3707 for(
jj=r->block1[
i]-r->block0[
i];
jj>=0;
jj--)
3718 if (r->block1[
i]!=r->block0[
i])
3732 for(
jj=r->block1[
i]-r->block0[
i];
jj>=0;
jj--)
3743 if (r->block1[
i]!=r->block0[
i])
3754 if (r->block1[
i]!=r->block0[
i])
3765 if (r->block1[
i]!=r->block0[
i])
3777 r->ComponentOrder=-1;
3785 r->ComponentOrder=-1;
3792 assume( r->block0[
i] == r->block1[
i] );
3793 const int s = r->block0[
i];
3839 for(
i=1 ;
i<=r->N ;
i++)
3866 r->ordsgn=(
long *)
omAlloc0(r->ExpL_Size*
sizeof(
long));
3868 for(
j=0;
j<r->CmpL_Size;
j++)
3893 r->pCompIndex=(r->VarOffset[0] & 0xffff);
3896 if (
i==r->pCompIndex)
i++;
3905 if (
i==r->pCompIndex)
i++;
3943 for(
int i=1;
i<=r->N;
i++)
3950 if ((r->block0[
j]<=
i)&&(r->block1[
j]>=
i))
3970 if(r->wvhdl[
j][
i-r->block0[
j]]<0)
3976 else if(r->wvhdl[
j][
i-r->block0[
j]]>0)
3987 if(r->wvhdl[
j][
i-r->block0[
j]]<0)
3993 else if(r->wvhdl[
j][
i-r->block0[
j]]>0)
4001 int add=r->block1[
j]-r->block0[
j]+1;
4006 if (r->wvhdl[
j][
i-r->block0[
j]]<0)
4012 else if(r->wvhdl[
j][
i-r->block0[
j]]>0)
4042 if (
nonneg>0) r->MixedOrder=1;
4053 if (r ==
NULL)
return;
4054 if (r->VarOffset !=
NULL)
4056 if (r->OrdSize!=0 && r->typ !=
NULL)
4058 for(
int i = 0;
i < r->OrdSize;
i++)
4059 if( r->typ[
i].ord_typ ==
ro_is)
4063 if( r->typ[
i].data.is.pVarOffset !=
NULL )
4068 else if (r->typ[
i].ord_typ ==
ro_syz)
4070 if(r->typ[
i].data.syz.limit > 0)
4071 omFreeSize(r->typ[
i].data.syz.syz_index, ((r->typ[
i].data.syz.limit) +1)*
sizeof(
int));
4075 assume( r->typ[
i].data.syzcomp.ShiftedComponents ==
NULL );
4076 assume( r->typ[
i].data.syzcomp.Components ==
NULL );
4086 if (r->PolyBin !=
NULL)
4092 if (r->ordsgn !=
NULL && r->CmpL_Size != 0)
4097 if (r->p_Procs !=
NULL)
4102 omfreeSize(r->VarL_Offset, r->VarL_Size*
sizeof(
int));
4103 r->VarL_Offset=
NULL;
4105 if (r->NegWeightL_Offset!=
NULL)
4107 omFreeSize(r->NegWeightL_Offset, r->NegWeightL_Size*
sizeof(
int));
4108 r->NegWeightL_Offset=
NULL;
4121 for (
i=1;
i<=r->N;
i++)
4127 for (
i=0,
j=0;
i<r->ExpL_Size;
i++)
4142 r->VarL_Offset = (
int*)
omAlloc(r->VarL_Size*
sizeof(
int));
4143 r->VarL_LowIndex = 0;
4146 for (
i=0,
j=0;
i<r->ExpL_Size;
i++)
4150 r->VarL_Offset[
j] =
i;
4151 if (
j > 0 && r->VarL_Offset[
j-1] != r->VarL_Offset[
j] - 1)
4152 r->VarL_LowIndex = -1;
4156 if (r->VarL_LowIndex >= 0)
4157 r->VarL_LowIndex = r->VarL_Offset[0];
4161 j = r->VarL_Offset[
min_j];
4162 r->VarL_Offset[
min_j] = r->VarL_Offset[0];
4163 r->VarL_Offset[0] =
j;
4173 for (
i=0;
i<r->ExpL_Size;
i++)
4177 for (
i=1;
i<=r->N;
i++)
4179 if (
shifts[r->VarOffset[
i] & 0xffffff] > r->VarOffset[
i] >> 24)
4180 shifts[r->VarOffset[
i] & 0xffffff] = r->VarOffset[
i] >> 24;
4183 for (
i=1;
i<=r->N;
i++)
4185 if (
shifts[r->VarOffset[
i] & 0xffffff] != 0)
4187 = (r->VarOffset[
i] & 0xffffff) |
4188 (((r->VarOffset[
i] >> 24) -
shifts[r->VarOffset[
i] & 0xffffff]) << 24);
4196 unsigned long divmask = 1;
4201 divmask |= (((
unsigned long) 1) << (
unsigned long)
i);
4216 const char *
TYP[]={
"ro_dp",
"ro_wp",
"ro_am",
"ro_wp64",
"ro_wp_neg",
"ro_cp",
4217 "ro_syzcomp",
"ro_syz",
"ro_isTemp",
"ro_is",
"ro_none"};
4220 Print(
"ExpL_Size:%d ",r->ExpL_Size);
4221 Print(
"CmpL_Size:%d ",r->CmpL_Size);
4222 Print(
"VarL_Size:%d\n",r->VarL_Size);
4223 Print(
"bitmask=0x%lx (expbound=%ld) \n",r->bitmask, r->bitmask);
4224 Print(
"divmask=%lx\n", r->divmask);
4225 Print(
"BitsPerExp=%d ExpPerLong=%d at L[%d]\n", r->BitsPerExp, r->ExpPerLong, r->VarL_Offset[0]);
4227 Print(
"VarL_LowIndex: %d\n", r->VarL_LowIndex);
4228 PrintS(
"VarL_Offset:\n");
4231 for(
j = 0;
j < r->VarL_Size;
j++)
4232 Print(
" VarL_Offset[%d]: %d ",
j, r->VarL_Offset[
j]);
4239 for(
j=0;
j<=r->N;
j++)
4240 Print(
" v%d at e-pos %d, bit %d\n",
4241 j,r->VarOffset[
j] & 0xffffff, r->VarOffset[
j] >>24);
4243 for(
j=0;
j<r->CmpL_Size;
j++)
4244 Print(
" ordsgn %ld at pos %d\n",r->ordsgn[
j],
j);
4245 Print(
"OrdSgn:%d\n",r->OrdSgn);
4247 for(
j=0;
j<r->OrdSize;
j++)
4249 Print(
" typ %s",
TYP[r->typ[
j].ord_typ]);
4250 if (r->typ[
j].ord_typ==
ro_syz)
4252 const short place = r->typ[
j].data.syz.place;
4253 const int limit = r->typ[
j].data.syz.limit;
4254 const int curr_index = r->typ[
j].data.syz.curr_index;
4255 const int* syz_index = r->typ[
j].data.syz.syz_index;
4257 Print(
" limit %d (place: %d, curr_index: %d), syz_index: ", limit, place, curr_index);
4259 if( syz_index ==
NULL )
4264 for(
i=0;
i <= limit;
i++ )
4265 Print(
"%d ", syz_index[
i]);
4272 Print(
" start (level) %d, suffixpos: %d, VO: ",r->typ[
j].data.isTemp.start, r->typ[
j].data.isTemp.suffixpos);
4275 else if (r->typ[
j].ord_typ==
ro_is)
4277 Print(
" start %d, end: %d: ",r->typ[
j].data.is.start, r->typ[
j].data.is.end);
4281 Print(
" limit %d",r->typ[
j].data.is.limit);
4288 else if (r->typ[
j].ord_typ==
ro_am)
4290 Print(
" place %d",r->typ[
j].data.am.place);
4291 Print(
" start %d",r->typ[
j].data.am.start);
4292 Print(
" end %d",r->typ[
j].data.am.end);
4293 Print(
" len_gen %d",r->typ[
j].data.am.len_gen);
4296 for(
l=r->typ[
j].data.am.start;
l<=r->typ[
j].data.am.end;
l++)
4297 Print(
" %d",r->typ[
j].data.am.weights[
l-r->typ[
j].data.am.start]);
4298 l=r->typ[
j].data.am.end+1;
4299 int ll=r->typ[
j].data.am.weights[
l-r->typ[
j].data.am.start];
4302 Print(
" %d",r->typ[
j].data.am.weights[
lll-r->typ[
j].data.am.start]);
4306 Print(
" place %d",r->typ[
j].data.dp.place);
4310 Print(
" start %d",r->typ[
j].data.dp.start);
4311 Print(
" end %d",r->typ[
j].data.dp.end);
4312 if ((r->typ[
j].ord_typ==
ro_wp)
4316 for(
int l=r->typ[
j].data.wp.start;
l<=r->typ[
j].data.wp.end;
l++)
4317 Print(
" %d",r->typ[
j].data.wp.weights[
l-r->typ[
j].data.wp.start]);
4319 else if (r->typ[
j].ord_typ==
ro_wp64)
4323 for(
l=r->typ[
j].data.wp64.start;
l<=r->typ[
j].data.wp64.end;
l++)
4324 Print(
" %ld",(
long)(r->typ[
j].data.wp64.weights64+
l-r->typ[
j].data.wp64.start));
4330 Print(
"pOrdIndex:%d pCompIndex:%d\n", r->pOrdIndex, r->pCompIndex);
4331 Print(
"OrdSize:%d\n",r->OrdSize);
4332 PrintS(
"--------------------\n");
4333 for(
j=0;
j<r->ExpL_Size;
j++)
4337 Print(
"ordsgn %ld ", r->ordsgn[
j]);
4343 if( (r->VarOffset[
i] & 0xffffff) ==
j )
4344 {
Print(
"v%d at e[%d], bit %d; ",
i,r->VarOffset[
i] & 0xffffff,
4345 r->VarOffset[
i] >>24 ); }
4347 if( r->pCompIndex==
j )
PrintS(
"v0; ");
4348 for(
i=0;
i<r->OrdSize;
i++)
4350 if (r->typ[
i].data.dp.place ==
j)
4352 Print(
"ordrec:%s (start:%d, end:%d) ",
TYP[r->typ[
i].ord_typ],
4353 r->typ[
i].data.dp.start, r->typ[
i].data.dp.end);
4357 if (
j==r->pOrdIndex)
4362 Print(
"LexOrder:%d, MixedOrder:%d\n",r->LexOrder, r->MixedOrder);
4364 Print(
"NegWeightL_Size: %d, NegWeightL_Offset: ", r->NegWeightL_Size);
4365 if (r->NegWeightL_Offset==
NULL)
PrintS(
" NULL");
4367 for(
j = 0;
j < r->NegWeightL_Size;
j++)
4368 Print(
" [%d]: %d ",
j, r->NegWeightL_Offset[
j]);
4389#define pFDeg_CASE(A) if(r->pFDeg == A) PrintS( "" #A "" )
4395 Print(
"(%p)", r->pFDeg);
4398 Print(
"pLDeg : (%p)", r->pLDeg);
4410 else Print(
"%p\n",r->p_Setm);
4420 Print(
"\nexp[0..%d]\n",r->ExpL_Size-1);
4421 for(
i=0;
i<r->ExpL_Size;
i++)
4429 if (
j==0) {
PrintS(
"...\n");
break; }
4438 Print(
"\nexp[0..%d]\n",
R->ExpL_Size - 1);
4439 for(
int i = 0;
i <
R->ExpL_Size;
i++)
4528 WarnS(
"rAssure_SyzComp: input ring has an IS-ordering!");
4539 int ** wvhdl =(
int **)
omAlloc0((
i+1)*
sizeof(
int**));
4542 res->order[
j]=r->order[
j-1];
4543 res->block0[
j]=r->block0[
j-1];
4544 res->block1[
j]=r->block1[
j-1];
4545 if (r->wvhdl[
j-1] !=
NULL)
4551 int l=r->block1[
j-1]-r->block0[
j-1]+1;
4556 l+=r->wvhdl[
j-1][r->block1[
j-1]-r->block0[
j-1]+1]+1;
4559 memcpy(wvhdl[
j],r->wvhdl[
j-1],
l*
sizeof(
int));
4577 WarnS(
"error in nc_rComplete");
4587 if (r->qideal!=
NULL)
4617 pos=r->VarL_LowIndex;
4622 for(
int i=r->OrdSize-1;
i>=0;
i--)
4624 if ((r->typ[
i].ord_typ==
ro_dp)
4625 && (r->typ[
i].data.dp.start==1)
4626 && (r->typ[
i].data.dp.end==r->N))
4628 pos=r->typ[
i].data.dp.place;
4647 res->ExpL_Size=r->ExpL_Size+1;
4651 for(
j=0;
j<r->CmpL_Size;
j++)
4653 res->ordsgn[
j] = r->ordsgn[
j];
4655 res->OrdSize=r->OrdSize+1;
4664 res->typ[
res->OrdSize-1].data.dp.start=1;
4665 res->typ[
res->OrdSize-1].data.dp.end=
res->N;
4666 res->typ[
res->OrdSize-1].data.dp.place=
res->ExpL_Size-1;
4667 pos=
res->ExpL_Size-1;
4683 WarnS(
"error in nc_rComplete");
4689 if (r->qideal!=
NULL)
4719 if (r->order[
i] == 0)
4737 if (r->wvhdl[
j]!=
NULL)
4743 int l=r->block1[
j]-r->block0[
j]+1;
4748 l+=r->wvhdl[
j][r->block1[
j]-r->block0[
j]+1]+1;
4770 WarnS(
"error in nc_rComplete");
4821 WarnS(
"error in nc_rComplete");
4855 WarnS(
"error in nc_rComplete");
4872 WarnS(
"error in nc_SetupQuotient");
4898 (r->order[0] ==
b1) &&
4899 (r->order[1] ==
b2) &&
4912 res->block1[1] = r->N;
4917 res->block1[0] = r->N;
4927 WarnS(
"error in nc_rComplete");
4946 for(
int i=0;
i<r->N;
i++)
4948 if ((*
w)[
i]!=r->wvhdl[0][
i]) { ok=
FALSE;
break;}
4960 res->block1[1] = r->N;
4961 res->wvhdl[0]=(
int*)
omAlloc(r->N*
sizeof(
int));
4962 for(
int i=0;
i<r->N;
i++)
4964 r->wvhdl[0][
i]=(*w)[
i];
4974 WarnS(
"error in nc_rComplete");
4987 Print(
"rAssure_InducedSchreyerOrdering(r, complete = %d, sgn = %d): r: \n", complete,
sgn);
5004 int ** wvhdl =(
int **)
omAlloc0((n+2)*
sizeof(
int**));
5012 res->block0[
j] =
res->block1[
j] = 0;
5016 for(
int i = 0; (
i <= n) && (r->order[
i] != 0);
i++,
j++)
5018 res->order [
j] = r->order [
i];
5019 res->block0[
j] = r->block0[
i];
5020 res->block1[
j] = r->block1[
i];
5022 if (r->wvhdl[
i] !=
NULL)
5028 int l=(r->block1[
i]-r->block0[
i]+1);
5033 l+=r->wvhdl[
i][r->block1[
i]-r->block0[
i]+1]+1;
5036 memcpy(wvhdl[
j],r->wvhdl[
i],
l*
sizeof(
int));
5068 WarnS(
"error in nc_rComplete");
5080 if (r->qideal!=
NULL)
5142 Print(
"rIsIS(p: %d)\nF:",
p);
5153 for(
int pos = 0; pos < r->OrdSize; pos++ )
5154 if( r->typ[pos].ord_typ ==
ro_is)
5176 dReportError(
"Error: WRONG USE of rSetISReference: wrong ring! (typ == NULL)");
5185 dReportError(
"Error: WRONG USE of rSetISReference: specified ordering block was not found!!!" );
5190 if(
i != r->typ[pos].data.is.limit )
5191 Print(
"Changing record on pos: %d\nOld limit: %d --->> New Limit: %d\n", pos, r->typ[pos].data.is.limit,
i);
5197 if( r->typ[pos].data.is.F !=
NULL)
5200 PrintS(
"Deleting old reference set F... \n");
5203 r->typ[pos].data.is.F =
NULL;
5208 r->typ[pos].data.is.F =
FF;
5210 r->typ[pos].data.is.limit =
i;
5234 if ((r->typ!=
NULL) && (r->typ[0].ord_typ==
ro_syz))
5236 r->block0[0]=r->block1[0] =
k;
5237 if(
k == r->typ[0].data.syz.limit )
5241 if (r->typ[0].data.syz.limit == 0)
5243 r->typ[0].data.syz.syz_index = (
int*)
omAlloc0((
k+1)*
sizeof(
int));
5244 r->typ[0].data.syz.syz_index[0] = 0;
5245 r->typ[0].data.syz.curr_index = 1;
5249 r->typ[0].data.syz.syz_index = (
int*)
5251 (r->typ[0].data.syz.limit+1)*
sizeof(
int),
5254 for (
i=r->typ[0].data.syz.limit + 1;
i<=
k;
i++)
5256 r->typ[0].data.syz.syz_index[
i] =
5257 r->typ[0].data.syz.curr_index;
5259 if(
k < r->typ[0].data.syz.limit)
5262 Warn(
"rSetSyzComp called with smaller limit (%d) as before (%d)",
k, r->typ[0].data.syz.limit);
5264 r->typ[0].data.syz.curr_index = 1 + r->typ[0].data.syz.syz_index[
k];
5268 r->typ[0].data.syz.limit =
k;
5269 r->typ[0].data.syz.curr_index++;
5278 Warn(
"rSetSyzComp(%d) in an IS ring! Be careful!",
k);
5283 r->block0[0] = r->block1[0] =
k;
5298 if ((r->typ!=
NULL) && (r->typ[0].ord_typ==
ro_syz) &&
5299 r->typ[0].data.syz.limit > 0 &&
i > 0)
5303 for (
j=0;
j<r->typ[0].data.syz.limit;
j++)
5305 if (r->typ[0].data.syz.syz_index[
j] ==
i &&
5306 r->typ[0].data.syz.syz_index[
j+1] !=
i)
5308 assume(r->typ[0].data.syz.syz_index[
j+1] ==
i+1);
5312 return r->typ[0].data.syz.limit;
5317 WarnS(
"rGetMaxSyzComp: order c");
5332 if ((r->order[0]==
ringorder_dp) &&(r->block0[0]==1) &&(r->block1[0]==r->N))
5335 && ((r->order[1]==
ringorder_dp) &&(r->block0[1]==1) &&(r->block1[1]==r->N)))
5342 if ((r->order[0]==
ringorder_Dp) &&(r->block0[0]==1) &&(r->block1[0]==r->N))
5345 && ((r->order[1]==
ringorder_Dp) &&(r->block0[1]==1) &&(r->block1[1]==r->N)))
5352 if ((r->order[0]==
ringorder_lp) &&(r->block0[0]==1) &&(r->block1[0]==r->N))
5355 && ((r->order[1]==
ringorder_lp) &&(r->block0[1]==1) &&(r->block1[1]==r->N)))
5365 while((r->typ[
i].ord_typ!=
ro_wp64) && (r->typ[
i].ord_typ>0))
i++;
5367 return r->typ[
i].data.wp64.weights64;
5375 memcpy(r->typ[0].data.wp64.weights64,
wv,r->N*
sizeof(
int64));
5386 for(
int k=
size;
k>pos;
k--) r->wvhdl[
k]=r->wvhdl[
k-1];
5398 for(
int k=pos+1;
k<
size;
k++) r->wvhdl[
k]=r->wvhdl[
k+1];
5408 for(
int j=0;
j<=
i2;
j++)
5416#define rOppVar(R,I) (rVar(R)+1-I)
5434 if (src->qideal !=
NULL)
5442 for(
i=
i2;
i>=0;
i--)
5448 p = r->names[
rVar(r)-1-
i];
5449 r->names[
rVar(r)-1-
i] = r->names[
i];
5467 char *
p=r->names[
i];
5520 for(
i=0; src->order[
i]!=0;
i++)
5522 switch (src->order[
i])
5527 r->order[
j]=src->order[
i];
5531 r->block0[
j]=
rOppVar(r, src->block1[
i]);
5532 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]);
5543 r->block0[
j]=
rOppVar(r, src->block1[
i]);
5544 r->block1[
j]=
rOppVar(r, src->block0[
i]);
5545 r->wvhdl[
j]=(
int*)
omAlloc((r->block1[
j]-r->block0[
j]+1)*
sizeof(
int));
5546 for(
int k=r->block0[
j];
k<=r->block1[
j];
k++)
5547 r->wvhdl[
j][
k-r->block0[
j]]=1;
5550 r->block0[
j]=
rOppVar(r, src->block1[
i]);
5551 r->block1[
j]=
rOppVar(r, src->block0[
i]);
5559 r->block0[
j]=
rOppVar(r, src->block1[
i]);
5560 r->block1[
j]=
rOppVar(r, src->block0[
i]);
5561 r->wvhdl[
j]=(
int*)
omAlloc((r->block1[
j]-r->block0[
j]+1)*
sizeof(
int));
5562 for(
int k=r->block0[
j];
k<=r->block1[
j];
k++)
5563 r->wvhdl[
j][
k-r->block0[
j]]=1;
5566 r->block0[
j]=
rOppVar(r, src->block1[
i]);
5567 r->block1[
j]=
rOppVar(r, src->block0[
i]);
5575 r->block0[
j]=
rOppVar(r, src->block1[
i]);
5576 r->block1[
j]=
rOppVar(r, src->block0[
i]);
5577 r->wvhdl[
j]=r->wvhdl[
j+1]; r->wvhdl[
j+1]=
NULL;
5581 r->block0[
j]=
rOppVar(r, src->block1[
i]);
5582 r->block1[
j]=
rOppVar(r, src->block0[
i]);
5590 r->block0[
j]=
rOppVar(r, src->block1[
i]);
5591 r->block1[
j]=
rOppVar(r, src->block0[
i]);
5592 r->wvhdl[
j]=r->wvhdl[
j+1]; r->wvhdl[
j+1]=
NULL;
5596 r->block0[
j]=
rOppVar(r, src->block1[
i]);
5597 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]);
5606 int n=r->block1[
j]-r->block0[
j];
5608 for (
int nn=0;
nn<=n;
nn++)
5617 r->block0[
j]=
rOppVar(r, src->block1[
i]);
5618 r->block1[
j]=
rOppVar(r, src->block0[
i]);
5663 for(
i=0; src->order[
i]!=0;
i++)
5665 switch (src->order[
i])
5670 r->order[
j]=src->order[
i];
5674 r->block0[
j]=
rOppVar(r, src->block1[
i]);
5675 r->block1[
j]=
rOppVar(r, src->block0[
i]);
5679 r->block0[
j]=
rOppVar(r, src->block1[
i]);
5680 r->block1[
j]=
rOppVar(r, src->block0[
i]);
5685 r->block0[
j]=
rOppVar(r, src->block1[
i]);
5686 r->block1[
j]=
rOppVar(r, src->block0[
i]);
5692 r->block0[
j]=
rOppVar(r, src->block1[
i]);
5693 r->block1[
j]=
rOppVar(r, src->block0[
i]);
5742 for(
i=1;
i<=r->N;
i++)
5758 MATELEM(C,
nj,
ni) =
p_PermPoly(
MATELEM(src->GetNC()->C,
i,
j),perm,src,r,
nMap,
par_perm,
rPar(src));
5761 MATELEM(
D,
nj,
ni) =
p_PermPoly(
MATELEM(src->GetNC()->D,
i,
j),perm,src,r,
nMap,
par_perm,
rPar(src));
5769 WarnS(
"Error initializing non-commutative multiplication!");
5777 assume( r->GetNC()->IsSkewConstant == src->GetNC()->IsSkewConstant);
5784 if (src->qideal !=
NULL)
5787 r->qideal =
idOppose(src, src->qideal, r);
5789 r->qideal =
id_Copy(src->qideal, r);
5821 WarnS(
"Error in rEnvelope at rSum");
5844 const int N = dest->N;
5864 for (
int i = 1;
i <
N;
i++)
5866 for (
int j =
i + 1;
j <=
N;
j++)
5869 const poly
p =
p_NSet(n, dest);
5931 Werror(
"n_IsParam: IsParam is not to be used for (coeff_type = %d)",
getCoeffType(C));
5940 WerrorS(
"only for rings with an ordering of one block");
5957 WerrorS(
"ordering must be dp,Dp,lp,rp,ds,Ds or ls");
5960 for(
int i=r->N-1;
i>=0;
i--)
5964 Werror(
"duplicate variable name >>%s<<",
v);
5970 #ifdef HAVE_SHIFTBBA
5973 R->isLPring=r->isLPring+1;
5974 R->N=((r->N)/r->isLPring)+r->N;
5978 for(
int b=0;
b<((r->N)/r->isLPring);
b++)
5981 for(
int i=
R->isLPring-1;
i>0;
i--)
5982 names[
i+
b*
R->isLPring]=
R->names[
i-1+
b*r->isLPring];
5987 for(
int b=0;
b<((r->N)/r->isLPring);
b++)
5990 for(
int i=
R->isLPring-2;
i>=0;
i--)
5991 names[
i+
b*
R->isLPring]=
R->names[
i+
b*r->isLPring];
6003 for(
int i=
R->N-1;
i>0;
i--) names[
i]=
R->names[
i-1];
6008 for(
int i=
R->N-2;
i>=0;
i--) names[
i]=
R->names[
i];
6022 WerrorS(
"only for rings with an ordering of one block");
6039 WerrorS(
"ordering must be dp,Dp,lp,rp,ds,Ds or ls");
6050 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 coefficients
@ 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)
BOOLEAN rHasBlockOrder(const ring r)
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)
BOOLEAN rOrd_is_Ds(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,