40#define BITS_PER_LONG 8*SIZEOF_LONG
110 r->names = (
char **)
omAlloc0(
N *
sizeof(
char *));
124 if (bitmask!=0) r->wanted_maxExp=bitmask;
143 int *block0 = (
int *)
omAlloc0(2 *
sizeof(
int));
144 int *block1 = (
int *)
omAlloc0(2 *
sizeof(
int));
179 WerrorS(
"weights only for orderings wp,ws,Wp,Ws,a,M");
191 WerrorS(
"Matrix order is not a square matrix");
194 while ((
i<
sz) && (typ==1))
197 while ((
j<
sz) && ((*order)[
j*
sz+
i+2]==0))
j++;
201 WerrorS(
"Matrix order not complete");
203 else if ((*order)[
j*
sz+
i+2]<0)
216 for (
int i=0;
i<
N;
i++)
218 if (names[
i]==
NULL)
return -1;
219 if (
strcmp(n,names[
i]) == 0)
return (
int)
i;
248 PrintS(
"// coefficients: ");
303 Print(
"// number of vars : %d",r->N);
311 Print(
"\n// block %3d : ",
l+1);
318 assume( r->block0[
l] == r->block1[
l] );
319 const int s = r->block0[
l];
327 Print(
" syz_comp: %d",r->block0[
l]);
339 for (
i = r->block0[
l]-1;
i<r->block1[
l];
i++)
346 if (r->wvhdl[
l]!=
NULL)
358 Warn(
"should not have wvhdl entry at pos. %d",
l);
362 j<(r->block1[
l]-r->block0[
l]+1)*(r->block1[
l]-r->block0[
l]+1);
365 PrintS(
"\n// : weights ");
366 for (
i = 0;
i<=r->block1[
l]-r->block0[
l];
i++)
384 int m=r->wvhdl[
l][
i];
385 Print(
"\n// : %d module weights ",
m);
394 PrintS(
"\n// noncommutative relations:");
400 for (
i = 1;
i<r->N;
i++)
402 for (
j =
i+1;
j<=r->N;
j++)
407 Print(
"\n// %s%s=",r->names[
j-1],r->names[
i-1]);
418 Print(
"\n// is skew constant:%d",r->GetNC()->IsSkewConstant);
423 PrintS(
"\n// quotient of sca by ideal");
436 Print(
"\n// letterplace ring (block size %d, ncgen count %d)",r->isLPring, r->LPncGenCount);
441 PrintS(
"\n// quotient ring from ideal");
454 if (r ==
NULL)
return;
458 if( r->qideal !=
NULL )
473 if (r->order !=
NULL)
484 if (r->wvhdl[
j]!=
NULL)
497 for (
i=0;
i<r->N;
i++)
545 if (r->wvhdl[
l]!=
NULL)
557 Warn(
"should not have wvhdl entry at pos. %d",
l);
565 j<(r->block1[
l]-r->block0[
l]+1)*(r->block1[
l]-r->block0[
l]+1);
572 for (
i = 0;
i<r->block1[
l]-r->block0[
l];
i++)
581 for (
i = 0;
i<r->block1[
l]-r->block0[
l];
i++)
591 if (
j+
i+1==(r->block1[
l]-r->block0[
l]+1)*(r->block1[
l]-r->block0[
l]+1))
602 assume( r->block0[
l] == r->block1[
l] );
603 const int s = r->block0[
l];
611 if (r->wanted_maxExp!=0)
613 long mm=r->wanted_maxExp;
630 for (
i=0;
i<r->N;
i++)
636 for (
i=0;
i<r->N-1;
i++)
728 for(
int i=1;
i<r->N;
i++)
729 for(
int j=
i+1;
j<=r->N;
j++)
733 WarnS(
"Error initializing multiplication!");
788 && (
mpz_cmp(
r1->cf->modNumber,
r2->cf->extRing->cf->modNumber)==0))
821 if (
r1->cf->extRing->cf==
r2->cf)
831 WerrorS (
"coeff sum of two extension fields not implemented");
837 WerrorS(
"coeff sum not yet implemented");
844 char **names=(
char **)
omAlloc0(
l*
sizeof(
char *));
849 for (
i=0;
i<
r1->N;
i++)
853 if (*(
r1->names[
i]) ==
'\0')
885 if (*(
r2->names[
i]) ==
'\0')
977 if ((
r2->block0[0]==1)
984 tmpR.order[1]=
r2->order[0];
990 int l=
r2->block1[0]-
r2->block0[0]+1;
995 l+=
r2->wvhdl[1][
r2->block1[0]-
r2->block0[0]+1]+1;
1066 WarnS(
"rSum: weights not implemented");
1072 for (
i=0;
r1->order[
i]!=0;
i++)
1082 int l=
r1->block1[
i]-
r1->block0[
i]+1;
1087 l+=
r1->wvhdl[
i][
r1->block1[
i]-
r1->block0[
i]+1]+1;
1102 for (
i=0;
r2->order[
i]!=0;
i++)
1116 int l=
r2->block1[
i]-
r2->block0[
i]+1;
1121 l+=
r2->wvhdl[
i][
r2->block1[
i]-
r2->block0[
i]+1]+1;
1131 if((
r1->OrdSgn==-1)||(
r2->OrdSgn==-1))
1157 int l=
r1->block1[
i]-
r1->block0[
i]+1;
1162 l+=
r1->wvhdl[
i][
r1->block1[
i]-
r1->block0[
i]+1]+1;
1263 MATELEM(C,
i,
j) =
p_PermPoly(
MATELEM(
C1,
i,
j),
perm1,
R1,
sum,
nMap1,
par_perm1,
rPar(
R1));
1266 MATELEM(
D,
i,
j) =
p_PermPoly(
MATELEM(
D1,
i,
j),
perm1,
R1,
sum,
nMap1,
par_perm1,
rPar(
R1));
1279 MATELEM(C,
rVar(
R1)+
i,
rVar(
R1)+
j) =
p_PermPoly(
MATELEM(
C2,
i,
j),
perm2,
R2,
sum,
nMap2,
par_perm2,
rPar(
R2));
1282 MATELEM(
D,
rVar(
R1)+
i,
rVar(
R1)+
j) =
p_PermPoly(
MATELEM(
D2,
i,
j),
perm2,
R2,
sum,
nMap2,
par_perm2,
rPar(
R2));
1290 WarnS(
"Error initializing non-commutative multiplication!");
1299 Print(
"\nRefs: R1: %d, R2: %d\n",
R1->GetNC()->ref,
R2->GetNC()->ref);
1428 res->options=r->options;
1443 res->firstBlockEnds=r->firstBlockEnds;
1445 res->real_var_start=r->real_var_start;
1446 res->real_var_end=r->real_var_end;
1450 res->isLPring=r->isLPring;
1451 res->LPncGenCount=r->LPncGenCount;
1454 res->VectorOut=r->VectorOut;
1455 res->ShortOut=r->ShortOut;
1456 res->CanShortOut=r->CanShortOut;
1472 res->bitmask=r->bitmask;
1473 res->divmask=r->divmask;
1474 res->BitsPerExp = r->BitsPerExp;
1475 res->ExpPerLong = r->ExpPerLong;
1496 res->LexOrder=r->LexOrder;
1497 res->MixedOrder=r->MixedOrder;
1505 if (r->wvhdl[
j]!=
NULL)
1511 int l=r->block1[
j]-r->block0[
j]+1;
1516 l+=r->wvhdl[
j][r->block1[
j]-r->block0[
j]+1]+1;
1527 memcpy(
res->block0,r->block0,
i *
sizeof(
int));
1528 memcpy(
res->block1,r->block1,
i *
sizeof(
int));
1543 if (r->qideal!=
NULL)
1572 res->options=r->options;
1587 res->firstBlockEnds=r->firstBlockEnds;
1589 res->real_var_start=r->real_var_start;
1590 res->real_var_end=r->real_var_end;
1594 res->isLPring=r->isLPring;
1595 res->LPncGenCount=r->LPncGenCount;
1598 res->VectorOut=r->VectorOut;
1599 res->ShortOut=r->ShortOut;
1600 res->CanShortOut=r->CanShortOut;
1601 res->LexOrder=r->LexOrder;
1602 res->MixedOrder=r->MixedOrder;
1618 res->bitmask=r->bitmask;
1619 res->divmask=r->divmask;
1620 res->BitsPerExp = r->BitsPerExp;
1621 res->ExpPerLong = r->ExpPerLong;
1647 for (
j=0;
j<
i-1;
j++)
1649 if (r->wvhdl[
j]!=
NULL)
1655 int l=r->block1[
j]-r->block0[
j]+1;
1660 l+=r->wvhdl[
j][r->block1[
j]-r->block0[
j]+1]+1;
1671 memcpy(&(
res->block0[1]),r->block0,(
i-1) *
sizeof(
int));
1672 memcpy(&(
res->block1[1]),r->block1,(
i-1) *
sizeof(
int));
1690 res->wvhdl[0]=(
int *)
A;
1700 if (r->qideal!=
NULL)
1706 WerrorS(
"internal error: rCopy0(Q,TRUE,FALSE)");
1711 WarnS(
"internal bad stuff: rCopy0(Q,TRUE,TRUE)");
1752 if (
r1->bitmask!=
r2->bitmask)
return FALSE;
1753 #ifdef HAVE_SHIFTBBA
1754 if (
r1->isLPring!=
r2->isLPring)
return FALSE;
1755 if (
r1->LPncGenCount!=
r2->LPncGenCount)
return FALSE;
1807 if ((
r1->cf !=
r2->cf)
1809 || (
r1->OrdSgn !=
r2->OrdSgn))
1813 while (
r1->order[
i] != 0)
1815 if (
r2->order[
i] == 0)
return FALSE;
1816 if ((
r1->order[
i] !=
r2->order[
i])
1817 || (
r1->block0[
i] !=
r2->block0[
i])
1818 || (
r1->block1[
i] !=
r2->block1[
i]))
1824 for (
j=0;
j<
r1->block1[
i]-
r1->block0[
i]+1;
j++)
1825 if (
r2->wvhdl[
i][
j] !=
r1->wvhdl[
i][
j])
1831 if (
r2->order[
i] != 0)
return FALSE;
1998 for (pos=0;pos<r->OrdSize;pos++)
2016 return (
rVar(r) > 1 &&
2022 ((r->order[1]!=0) &&
2029 return (
rVar(r) > 1 &&
2039 return ((
rVar(r) > 1) &&
2058 if (r->N == 0)
return TRUE;
2060 if ((r->OrdSgn!=1) && (r->OrdSgn!= -1))
2072 for(
int j=0;
j<=
i;
j++)
2075 dError(
"wrong order in r->order");
2086 if (r->VarOffset ==
NULL)
2088 dReportError(
"Null ring VarOffset -- no rComplete (?) in n %s:%d",
fn,
l);
2093 if ((r->OrdSize==0)!=(r->typ==
NULL))
2095 dReportError(
"mismatch OrdSize and typ-pointer in %s:%d");
2101 for(
i=0;
i<=r->N;
i++)
2105 for(
j=0;
j<r->OrdSize;
j++)
2109 const int p = r->typ[
j].data.isTemp.suffixpos;
2116 if(r->typ[
p].ord_typ !=
ro_is)
2117 dReportError(
"ordrec prefix %d is unmatched (suffix: %d is wrong!!!)",
j,
p);
2120 if(r->typ[
j].data.isTemp.pVarOffset[
i] != -1)
2126 else if (r->typ[
j].ord_typ ==
ro_is)
2129 if(r->typ[
j].data.is.pVarOffset[
i] != -1)
2137 if (r->typ[
j].ord_typ==
ro_cp)
2139 if(((
short)r->VarOffset[
i]) == r->typ[
j].data.cp.place)
2144 && (r->VarOffset[
i] == r->typ[
j].data.dp.place))
2150 tmp=r->VarOffset[
i] & 0xffffff;
2151 #if SIZEOF_LONG == 8
2152 if ((r->VarOffset[
i] >> 24) >63)
2154 if ((r->VarOffset[
i] >> 24) >31)
2156 dReportError(
"bit_start out of range:%d",r->VarOffset[
i] >> 24);
2157 if (
i > 0 && ((
tmp<0) ||(
tmp>r->ExpL_Size-1)))
2164 for(
j=0;
j<r->OrdSize;
j++)
2166 if ((r->typ[
j].ord_typ==
ro_dp)
2167 || (r->typ[
j].ord_typ==
ro_wp)
2170 if (r->typ[
j].data.dp.start > r->typ[
j].data.dp.end)
2172 r->typ[
j].data.dp.start, r->typ[
j].data.dp.end);
2173 if ((r->typ[
j].data.dp.start < 1)
2174 || (r->typ[
j].data.dp.end > r->N))
2175 dReportError(
"in ordrec %d: start(%d)<1 or end(%d)>vars(%d)",
j,
2176 r->typ[
j].data.dp.start, r->typ[
j].data.dp.end,r->N);
2240 while((start<end) && (weights[0]==0)) { start++; weights++; }
2241 while((start<end) && (weights[end-start]==0)) { end--; }
2244 for(
i=start;
i<=end;
i++)
2246 if(weights[
i-start]!=1)
2266 for(
i=start;
i<=end;
i++)
2268 if(weights[
i-start]<0)
2290 ord_struct.data.am.weights_m = weights + (end-start+1);
2291 ord_struct.data.am.len_gen=weights[end-start+1];
2326 while((start<end) && (weights[0]==0)) { start++; weights++; }
2327 while((start<end) && (weights[end-start]==0)) { end--; }
2338 for(
i=start;
i<=end;
i++)
2340 if(weights[
i-start]<0)
2510 int *pVarOffset =
tmp_typ[
typ_j].data.isTemp.pVarOffset;
2528 for(
int i = 0;
i <=
N;
i++ )
2531 if(
v[
i] != pVarOffset[
i] )
2533 pVarOffset[
i] =
v[
i];
2535 assume( pVarOffset[
i] != -1 );
2541 if( pVarOffset[0] != -1 )
2542 pVarOffset[0] &= 0x0fff;
2583 bits=16; bitmask=0xffff;
2585 else if (bitmask <= 1L)
2587 bits=1; bitmask = 1L;
2589 else if (bitmask <= 3L)
2591 bits=2; bitmask = 3L;
2593 else if (bitmask <= 7L)
2597 else if (bitmask <= 0xfL)
2599 bits=4; bitmask=0xfL;
2601 else if (bitmask <= 0x1fL)
2603 bits=5; bitmask=0x1fL;
2605 else if (bitmask <= 0x3fL)
2607 bits=6; bitmask=0x3fL;
2610 else if (bitmask <= 0x7fL)
2612 bits=7; bitmask=0x7fL;
2615 else if (bitmask <= 0xffL)
2617 bits=8; bitmask=0xffL;
2620 else if (bitmask <= 0x1ffL)
2622 bits=9; bitmask=0x1ffL;
2625 else if (bitmask <= 0x3ffL)
2627 bits=10; bitmask=0x3ffL;
2630 else if (bitmask <= 0xfffL)
2632 bits=12; bitmask=0xfff;
2635 else if (bitmask <= 0xffffL)
2637 bits=16; bitmask=0xffffL;
2640 else if (bitmask <= 0xfffffL)
2642 bits=20; bitmask=0xfffffL;
2644 else if (bitmask <= 0xffffffffL)
2646 bits=32; bitmask=0xffffffffL;
2648 else if (bitmask <= 0x7fffffffffffffffL)
2650 bits=63; bitmask=0x7fffffffffffffffL;
2654 bits=63; bitmask=0x7fffffffffffffffL;
2657 else if (bitmask <= 0x7fffffff)
2659 bits=31; bitmask=0x7fffffff;
2663 bits=31; bitmask=0x7fffffffL;
2734 if (r->block0[
i]==r->block1[
i])
2759 Warn(
"Error: unhandled ordering in rModifyRing: ringorder_S = [%d]",
r_ord);
2838 block0[
j]=r->block0[
i];
2839 block1[
j]=r->block1[
i];
2840 wvhdl[
j]=r->wvhdl[
i];
2866 res->wanted_maxExp=r->wanted_maxExp;
2873 if (r->pFDegOrig !=
res->pFDegOrig &&
2878 res->firstwv = r->firstwv;
2879 res->firstBlockEnds = r->firstBlockEnds;
2883 res->pLDeg = r->pLDegOrig;
2892 res->typ[0] = r->typ[0];
2894 if (r->typ[0].data.syz.limit > 0)
2896 res->typ[0].data.syz.syz_index
2897 = (
int*)
omAlloc((r->typ[0].data.syz.limit +1)*
sizeof(
int));
2898 memcpy(
res->typ[0].data.syz.syz_index, r->typ[0].data.syz.syz_index,
2899 (r->typ[0].data.syz.limit +1)*
sizeof(
int));
2912 r->typ[
i].data.is.limit,
2923 res->OrdSgn=r->OrdSgn;
2932 WarnS(
"error in nc_rComplete");
2945 WarnS(
"error in sca_Force!");
2971 res->block1[0] = r->N;
2972 res->wvhdl[0] = weights;
2987 WarnS(
"error in nc_rComplete");
3038 res->wanted_maxExp=r->wanted_maxExp;
3049 WarnS(
"error in nc_rComplete");
3093 r->CanShortOut=
FALSE;
3096 r->CanShortOut =
TRUE;
3104 r->CanShortOut=
FALSE;
3112 for (
i=(
N-1);
i>=0;
i--)
3116 r->CanShortOut=
FALSE;
3122 r->ShortOut = r->CanShortOut;
3124 assume( !( !r->CanShortOut && r->ShortOut ) );
3132 if(block1[
i]!=r->N) r->LexOrder=
TRUE;
3133 r->firstBlockEnds=block1[
i];
3134 r->firstwv = wvhdl[
i];
3143 for(
j=block1[
i]-block0[
i];
j>=0;
j--)
3145 if (r->firstwv[
j]==0) r->LexOrder=
TRUE;
3152 for(
j=block1[
i]-block0[
i];
j>=0;
j--)
3154 if (
w[
j]==0) r->LexOrder=
TRUE;
3161 if (r->pFDeg ==
p_Deg)
3182 r->pLDegOrig = r->pLDeg;
3189 int* block0 = r->block0;
3190 int* block1 = r->block1;
3191 int** wvhdl = r->wvhdl;
3200 r->LexOrder =
FALSE;
3207 for(
int ii=block0[0];
ii<=block1[0];
ii++)
3208 if (wvhdl[0][
ii-1]<0) { r->MixedOrder=2;
break;}
3210 for(
int ii=block0[0];
ii<=block1[0];
ii++)
3211 if (wvhdl[0][
ii-1]==0) { r->LexOrder=
TRUE;
break;}
3212 if ((block0[0]==1)&&(block1[0]==r->N))
3223 r->firstwv = wvhdl[0];
3235 if (r->OrdSgn == -1) r->pLDeg =
pLDeg0c;
3254 for(
int ii=block0[0];
ii<=block1[0];
ii++)
3256 if (wvhdl[0][
ii-1]<0) { r->MixedOrder=2;
break;}
3258 if (r->MixedOrder==0)
3260 if ((block0[0]==1)&&(block1[0]==r->N))
3268 r->firstBlockEnds=block1[0];
3269 r->firstwv = wvhdl[0];
3288 r->firstBlockEnds=block1[1];
3289 if (wvhdl!=
NULL) r->firstwv = wvhdl[1];
3297 for(
int ii=block0[1];
ii<=block1[1];
ii++)
3298 if (wvhdl[1][
ii-1]<0) { r->MixedOrder=2;
break;}
3299 if (r->MixedOrder==
FALSE)
3332 if(r->MixedOrder==
FALSE)
3347 r->pFDegOrig = r->pFDeg;
3362 for(
i=0;
i<r->OrdSize;
i++)
3365 ||(r->typ[
i].ord_typ==
ro_am))
3370 r->NegWeightL_Size=
l;
3371 r->NegWeightL_Offset=(
int *)
omAlloc(
l*
sizeof(
int));
3373 for(
i=0;
i<r->OrdSize;
i++)
3377 r->NegWeightL_Offset[
l]=r->typ[
i].data.wp.place;
3380 else if(r->typ[
i].ord_typ==
ro_am)
3382 r->NegWeightL_Offset[
l]=r->typ[
i].data.am.place;
3389 r->NegWeightL_Size = 0;
3390 r->NegWeightL_Offset =
NULL;
3402 if ( (r->cf->extRing!=
NULL)
3411 if (r->LexOrder || r->OrdSgn == -1 || (r->cf->extRing!=
NULL))
3428 r->pLexOrder=r->LexOrder;
3436static inline int sign(
int x) {
return (
x > 0) - (
x < 0);}
3467 r->BitsPerExp =
bits;
3475 for(
i=r->N;
i>=0 ;
i--)
3492 switch (r->order[
i])
3516 r->ComponentOrder=1;
3522 r->ComponentOrder=-1;
3528 k=r->block1[
i]-r->block0[
i]+1;
3533 r->wvhdl[
i]+(r->block1[
i]-r->block0[
i]+1)*
l);
3560 if (r->block0[
i]==r->block1[
i])
3576 if (r->block0[
i]==r->block1[
i])
3592 if (r->block0[
i]==r->block1[
i])
3608 if (r->block0[
i]==r->block1[
i])
3630 for(
jj=r->block1[
i]-r->block0[
i];
jj>=0;
jj--)
3641 if (r->block1[
i]!=r->block0[
i])
3655 for(
jj=r->block1[
i]-r->block0[
i];
jj>=0;
jj--)
3666 if (r->block1[
i]!=r->block0[
i])
3677 if (r->block1[
i]!=r->block0[
i])
3688 if (r->block1[
i]!=r->block0[
i])
3700 r->ComponentOrder=-1;
3708 r->ComponentOrder=-1;
3715 assume( r->block0[
i] == r->block1[
i] );
3716 const int s = r->block0[
i];
3762 for(
i=1 ;
i<=r->N ;
i++)
3789 r->ordsgn=(
long *)
omAlloc0(r->ExpL_Size*
sizeof(
long));
3791 for(
j=0;
j<r->CmpL_Size;
j++)
3816 r->pCompIndex=(r->VarOffset[0] & 0xffff);
3819 if (
i==r->pCompIndex)
i++;
3828 if (
i==r->pCompIndex)
i++;
3866 for(
int i=1;
i<=r->N;
i++)
3873 if ((r->block0[
j]<=
i)&&(r->block1[
j]>=
i))
3893 if(r->wvhdl[
j][
i-r->block0[
j]]<0)
3899 else if(r->wvhdl[
j][
i-r->block0[
j]]>0)
3910 if(r->wvhdl[
j][
i-r->block0[
j]]<0)
3916 else if(r->wvhdl[
j][
i-r->block0[
j]]>0)
3924 int add=r->block1[
j]-r->block0[
j]+1;
3929 if (r->wvhdl[
j][
i-r->block0[
j]]<0)
3935 else if(r->wvhdl[
j][
i-r->block0[
j]]>0)
3965 if (
nonneg>0) r->MixedOrder=1;
3976 if (r ==
NULL)
return;
3977 if (r->VarOffset !=
NULL)
3979 if (r->OrdSize!=0 && r->typ !=
NULL)
3981 for(
int i = 0;
i < r->OrdSize;
i++)
3982 if( r->typ[
i].ord_typ ==
ro_is)
3986 if( r->typ[
i].data.is.pVarOffset !=
NULL )
3991 else if (r->typ[
i].ord_typ ==
ro_syz)
3993 if(r->typ[
i].data.syz.limit > 0)
3994 omFreeSize(r->typ[
i].data.syz.syz_index, ((r->typ[
i].data.syz.limit) +1)*
sizeof(
int));
3998 assume( r->typ[
i].data.syzcomp.ShiftedComponents ==
NULL );
3999 assume( r->typ[
i].data.syzcomp.Components ==
NULL );
4009 if (r->PolyBin !=
NULL)
4015 if (r->ordsgn !=
NULL && r->CmpL_Size != 0)
4020 if (r->p_Procs !=
NULL)
4025 omfreeSize(r->VarL_Offset, r->VarL_Size*
sizeof(
int));
4026 r->VarL_Offset=
NULL;
4028 if (r->NegWeightL_Offset!=
NULL)
4030 omFreeSize(r->NegWeightL_Offset, r->NegWeightL_Size*
sizeof(
int));
4031 r->NegWeightL_Offset=
NULL;
4044 for (
i=1;
i<=r->N;
i++)
4050 for (
i=0,
j=0;
i<r->ExpL_Size;
i++)
4065 r->VarL_Offset = (
int*)
omAlloc(r->VarL_Size*
sizeof(
int));
4066 r->VarL_LowIndex = 0;
4069 for (
i=0,
j=0;
i<r->ExpL_Size;
i++)
4073 r->VarL_Offset[
j] =
i;
4074 if (
j > 0 && r->VarL_Offset[
j-1] != r->VarL_Offset[
j] - 1)
4075 r->VarL_LowIndex = -1;
4079 if (r->VarL_LowIndex >= 0)
4080 r->VarL_LowIndex = r->VarL_Offset[0];
4084 j = r->VarL_Offset[
min_j];
4085 r->VarL_Offset[
min_j] = r->VarL_Offset[0];
4086 r->VarL_Offset[0] =
j;
4096 for (
i=0;
i<r->ExpL_Size;
i++)
4100 for (
i=1;
i<=r->N;
i++)
4102 if (
shifts[r->VarOffset[
i] & 0xffffff] > r->VarOffset[
i] >> 24)
4103 shifts[r->VarOffset[
i] & 0xffffff] = r->VarOffset[
i] >> 24;
4106 for (
i=1;
i<=r->N;
i++)
4108 if (
shifts[r->VarOffset[
i] & 0xffffff] != 0)
4110 = (r->VarOffset[
i] & 0xffffff) |
4111 (((r->VarOffset[
i] >> 24) -
shifts[r->VarOffset[
i] & 0xffffff]) << 24);
4119 unsigned long divmask = 1;
4124 divmask |= (((
unsigned long) 1) << (
unsigned long)
i);
4139 const char *
TYP[]={
"ro_dp",
"ro_wp",
"ro_am",
"ro_wp64",
"ro_wp_neg",
"ro_cp",
4140 "ro_syzcomp",
"ro_syz",
"ro_isTemp",
"ro_is",
"ro_none"};
4143 Print(
"ExpL_Size:%d ",r->ExpL_Size);
4144 Print(
"CmpL_Size:%d ",r->CmpL_Size);
4145 Print(
"VarL_Size:%d\n",r->VarL_Size);
4146 Print(
"bitmask=0x%lx (expbound=%ld) \n",r->bitmask, r->bitmask);
4147 Print(
"divmask=%lx\n", r->divmask);
4148 Print(
"BitsPerExp=%d ExpPerLong=%d at L[%d]\n", r->BitsPerExp, r->ExpPerLong, r->VarL_Offset[0]);
4150 Print(
"VarL_LowIndex: %d\n", r->VarL_LowIndex);
4151 PrintS(
"VarL_Offset:\n");
4154 for(
j = 0;
j < r->VarL_Size;
j++)
4155 Print(
" VarL_Offset[%d]: %d ",
j, r->VarL_Offset[
j]);
4162 for(
j=0;
j<=r->N;
j++)
4163 Print(
" v%d at e-pos %d, bit %d\n",
4164 j,r->VarOffset[
j] & 0xffffff, r->VarOffset[
j] >>24);
4166 for(
j=0;
j<r->CmpL_Size;
j++)
4167 Print(
" ordsgn %ld at pos %d\n",r->ordsgn[
j],
j);
4168 Print(
"OrdSgn:%d\n",r->OrdSgn);
4170 for(
j=0;
j<r->OrdSize;
j++)
4172 Print(
" typ %s",
TYP[r->typ[
j].ord_typ]);
4173 if (r->typ[
j].ord_typ==
ro_syz)
4175 const short place = r->typ[
j].data.syz.place;
4176 const int limit = r->typ[
j].data.syz.limit;
4177 const int curr_index = r->typ[
j].data.syz.curr_index;
4178 const int* syz_index = r->typ[
j].data.syz.syz_index;
4180 Print(
" limit %d (place: %d, curr_index: %d), syz_index: ", limit, place, curr_index);
4182 if( syz_index ==
NULL )
4187 for(
i=0;
i <= limit;
i++ )
4188 Print(
"%d ", syz_index[
i]);
4195 Print(
" start (level) %d, suffixpos: %d, VO: ",r->typ[
j].data.isTemp.start, r->typ[
j].data.isTemp.suffixpos);
4198 else if (r->typ[
j].ord_typ==
ro_is)
4200 Print(
" start %d, end: %d: ",r->typ[
j].data.is.start, r->typ[
j].data.is.end);
4204 Print(
" limit %d",r->typ[
j].data.is.limit);
4211 else if (r->typ[
j].ord_typ==
ro_am)
4213 Print(
" place %d",r->typ[
j].data.am.place);
4214 Print(
" start %d",r->typ[
j].data.am.start);
4215 Print(
" end %d",r->typ[
j].data.am.end);
4216 Print(
" len_gen %d",r->typ[
j].data.am.len_gen);
4219 for(
l=r->typ[
j].data.am.start;
l<=r->typ[
j].data.am.end;
l++)
4220 Print(
" %d",r->typ[
j].data.am.weights[
l-r->typ[
j].data.am.start]);
4221 l=r->typ[
j].data.am.end+1;
4222 int ll=r->typ[
j].data.am.weights[
l-r->typ[
j].data.am.start];
4225 Print(
" %d",r->typ[
j].data.am.weights[
lll-r->typ[
j].data.am.start]);
4229 Print(
" place %d",r->typ[
j].data.dp.place);
4233 Print(
" start %d",r->typ[
j].data.dp.start);
4234 Print(
" end %d",r->typ[
j].data.dp.end);
4235 if ((r->typ[
j].ord_typ==
ro_wp)
4239 for(
int l=r->typ[
j].data.wp.start;
l<=r->typ[
j].data.wp.end;
l++)
4240 Print(
" %d",r->typ[
j].data.wp.weights[
l-r->typ[
j].data.wp.start]);
4242 else if (r->typ[
j].ord_typ==
ro_wp64)
4246 for(
l=r->typ[
j].data.wp64.start;
l<=r->typ[
j].data.wp64.end;
l++)
4247 Print(
" %ld",(
long)(r->typ[
j].data.wp64.weights64+
l-r->typ[
j].data.wp64.start));
4253 Print(
"pOrdIndex:%d pCompIndex:%d\n", r->pOrdIndex, r->pCompIndex);
4254 Print(
"OrdSize:%d\n",r->OrdSize);
4255 PrintS(
"--------------------\n");
4256 for(
j=0;
j<r->ExpL_Size;
j++)
4260 Print(
"ordsgn %ld ", r->ordsgn[
j]);
4266 if( (r->VarOffset[
i] & 0xffffff) ==
j )
4267 {
Print(
"v%d at e[%d], bit %d; ",
i,r->VarOffset[
i] & 0xffffff,
4268 r->VarOffset[
i] >>24 ); }
4270 if( r->pCompIndex==
j )
PrintS(
"v0; ");
4271 for(
i=0;
i<r->OrdSize;
i++)
4273 if (r->typ[
i].data.dp.place ==
j)
4275 Print(
"ordrec:%s (start:%d, end:%d) ",
TYP[r->typ[
i].ord_typ],
4276 r->typ[
i].data.dp.start, r->typ[
i].data.dp.end);
4280 if (
j==r->pOrdIndex)
4285 Print(
"LexOrder:%d, MixedOrder:%d\n",r->LexOrder, r->MixedOrder);
4287 Print(
"NegWeightL_Size: %d, NegWeightL_Offset: ", r->NegWeightL_Size);
4288 if (r->NegWeightL_Offset==
NULL)
PrintS(
" NULL");
4290 for(
j = 0;
j < r->NegWeightL_Size;
j++)
4291 Print(
" [%d]: %d ",
j, r->NegWeightL_Offset[
j]);
4312#define pFDeg_CASE(A) if(r->pFDeg == A) PrintS( "" #A "" )
4318 Print(
"(%p)", r->pFDeg);
4321 Print(
"pLDeg : (%p)", r->pLDeg);
4333 else Print(
"%p\n",r->p_Setm);
4343 Print(
"\nexp[0..%d]\n",r->ExpL_Size-1);
4344 for(
i=0;
i<r->ExpL_Size;
i++)
4352 if (
j==0) {
PrintS(
"...\n");
break; }
4361 Print(
"\nexp[0..%d]\n",
R->ExpL_Size - 1);
4362 for(
int i = 0;
i <
R->ExpL_Size;
i++)
4451 WarnS(
"rAssure_SyzComp: input ring has an IS-ordering!");
4462 int ** wvhdl =(
int **)
omAlloc0((
i+1)*
sizeof(
int**));
4465 res->order[
j]=r->order[
j-1];
4466 res->block0[
j]=r->block0[
j-1];
4467 res->block1[
j]=r->block1[
j-1];
4468 if (r->wvhdl[
j-1] !=
NULL)
4474 int l=r->block1[
j-1]-r->block0[
j-1]+1;
4479 l+=r->wvhdl[
j-1][r->block1[
j-1]-r->block0[
j-1]+1]+1;
4482 memcpy(wvhdl[
j],r->wvhdl[
j-1],
l*
sizeof(
int));
4500 WarnS(
"error in nc_rComplete");
4510 if (r->qideal!=
NULL)
4540 pos=r->VarL_LowIndex;
4545 for(
int i=r->OrdSize-1;
i>=0;
i--)
4547 if ((r->typ[
i].ord_typ==
ro_dp)
4548 && (r->typ[
i].data.dp.start==1)
4549 && (r->typ[
i].data.dp.end==r->N))
4551 pos=r->typ[
i].data.dp.place;
4570 res->ExpL_Size=r->ExpL_Size+1;
4574 for(
j=0;
j<r->CmpL_Size;
j++)
4576 res->ordsgn[
j] = r->ordsgn[
j];
4578 res->OrdSize=r->OrdSize+1;
4587 res->typ[
res->OrdSize-1].data.dp.start=1;
4588 res->typ[
res->OrdSize-1].data.dp.end=
res->N;
4589 res->typ[
res->OrdSize-1].data.dp.place=
res->ExpL_Size-1;
4590 pos=
res->ExpL_Size-1;
4606 WarnS(
"error in nc_rComplete");
4612 if (r->qideal!=
NULL)
4642 if (r->order[
i] == 0)
4660 if (r->wvhdl[
j]!=
NULL)
4666 int l=r->block1[
j]-r->block0[
j]+1;
4671 l+=r->wvhdl[
j][r->block1[
j]-r->block0[
j]+1]+1;
4693 WarnS(
"error in nc_rComplete");
4744 WarnS(
"error in nc_rComplete");
4778 WarnS(
"error in nc_rComplete");
4795 WarnS(
"error in nc_SetupQuotient");
4821 (r->order[0] ==
b1) &&
4822 (r->order[1] ==
b2) &&
4835 res->block1[1] = r->N;
4840 res->block1[0] = r->N;
4850 WarnS(
"error in nc_rComplete");
4869 for(
int i=0;
i<r->N;
i++)
4871 if ((*
w)[
i]!=r->wvhdl[0][
i]) { ok=
FALSE;
break;}
4883 res->block1[1] = r->N;
4884 res->wvhdl[0]=(
int*)
omAlloc(r->N*
sizeof(
int));
4885 for(
int i=0;
i<r->N;
i++)
4887 r->wvhdl[0][
i]=(*w)[
i];
4897 WarnS(
"error in nc_rComplete");
4910 Print(
"rAssure_InducedSchreyerOrdering(r, complete = %d, sgn = %d): r: \n", complete,
sgn);
4927 int ** wvhdl =(
int **)
omAlloc0((n+2)*
sizeof(
int**));
4935 res->block0[
j] =
res->block1[
j] = 0;
4939 for(
int i = 0; (
i <= n) && (r->order[
i] != 0);
i++,
j++)
4941 res->order [
j] = r->order [
i];
4942 res->block0[
j] = r->block0[
i];
4943 res->block1[
j] = r->block1[
i];
4945 if (r->wvhdl[
i] !=
NULL)
4951 int l=(r->block1[
i]-r->block0[
i]+1);
4956 l+=r->wvhdl[
i][r->block1[
i]-r->block0[
i]+1]+1;
4959 memcpy(wvhdl[
j],r->wvhdl[
i],
l*
sizeof(
int));
4991 WarnS(
"error in nc_rComplete");
5003 if (r->qideal!=
NULL)
5065 Print(
"rIsIS(p: %d)\nF:",
p);
5076 for(
int pos = 0; pos < r->OrdSize; pos++ )
5077 if( r->typ[pos].ord_typ ==
ro_is)
5099 dReportError(
"Error: WRONG USE of rSetISReference: wrong ring! (typ == NULL)");
5108 dReportError(
"Error: WRONG USE of rSetISReference: specified ordering block was not found!!!" );
5113 if(
i != r->typ[pos].data.is.limit )
5114 Print(
"Changing record on pos: %d\nOld limit: %d --->> New Limit: %d\n", pos, r->typ[pos].data.is.limit,
i);
5120 if( r->typ[pos].data.is.F !=
NULL)
5123 PrintS(
"Deleting old reference set F... \n");
5126 r->typ[pos].data.is.F =
NULL;
5131 r->typ[pos].data.is.F =
FF;
5133 r->typ[pos].data.is.limit =
i;
5157 if ((r->typ!=
NULL) && (r->typ[0].ord_typ==
ro_syz))
5159 r->block0[0]=r->block1[0] =
k;
5160 if(
k == r->typ[0].data.syz.limit )
5164 if (r->typ[0].data.syz.limit == 0)
5166 r->typ[0].data.syz.syz_index = (
int*)
omAlloc0((
k+1)*
sizeof(
int));
5167 r->typ[0].data.syz.syz_index[0] = 0;
5168 r->typ[0].data.syz.curr_index = 1;
5172 r->typ[0].data.syz.syz_index = (
int*)
5174 (r->typ[0].data.syz.limit+1)*
sizeof(
int),
5177 for (
i=r->typ[0].data.syz.limit + 1;
i<=
k;
i++)
5179 r->typ[0].data.syz.syz_index[
i] =
5180 r->typ[0].data.syz.curr_index;
5182 if(
k < r->typ[0].data.syz.limit)
5185 Warn(
"rSetSyzComp called with smaller limit (%d) as before (%d)",
k, r->typ[0].data.syz.limit);
5187 r->typ[0].data.syz.curr_index = 1 + r->typ[0].data.syz.syz_index[
k];
5191 r->typ[0].data.syz.limit =
k;
5192 r->typ[0].data.syz.curr_index++;
5201 Warn(
"rSetSyzComp(%d) in an IS ring! Be careful!",
k);
5206 r->block0[0] = r->block1[0] =
k;
5221 if ((r->typ!=
NULL) && (r->typ[0].ord_typ==
ro_syz) &&
5222 r->typ[0].data.syz.limit > 0 &&
i > 0)
5226 for (
j=0;
j<r->typ[0].data.syz.limit;
j++)
5228 if (r->typ[0].data.syz.syz_index[
j] ==
i &&
5229 r->typ[0].data.syz.syz_index[
j+1] !=
i)
5231 assume(r->typ[0].data.syz.syz_index[
j+1] ==
i+1);
5235 return r->typ[0].data.syz.limit;
5240 WarnS(
"rGetMaxSyzComp: order c");
5255 if ((r->order[0]==
ringorder_dp) &&(r->block0[0]==1) &&(r->block1[0]==r->N))
5258 && ((r->order[1]==
ringorder_dp) &&(r->block0[1]==1) &&(r->block1[1]==r->N)))
5265 if ((r->order[0]==
ringorder_Dp) &&(r->block0[0]==1) &&(r->block1[0]==r->N))
5268 && ((r->order[1]==
ringorder_Dp) &&(r->block0[1]==1) &&(r->block1[1]==r->N)))
5275 if ((r->order[0]==
ringorder_lp) &&(r->block0[0]==1) &&(r->block1[0]==r->N))
5278 && ((r->order[1]==
ringorder_lp) &&(r->block0[1]==1) &&(r->block1[1]==r->N)))
5288 while((r->typ[
i].ord_typ!=
ro_wp64) && (r->typ[
i].ord_typ>0))
i++;
5290 return r->typ[
i].data.wp64.weights64;
5298 memcpy(r->typ[0].data.wp64.weights64,
wv,r->N*
sizeof(
int64));
5309 for(
int k=
size;
k>pos;
k--) r->wvhdl[
k]=r->wvhdl[
k-1];
5321 for(
int k=pos+1;
k<
size;
k++) r->wvhdl[
k]=r->wvhdl[
k+1];
5331 for(
int j=0;
j<=
i2;
j++)
5339#define rOppVar(R,I) (rVar(R)+1-I)
5357 if (src->qideal !=
NULL)
5365 for(
i=
i2;
i>=0;
i--)
5371 p = r->names[
rVar(r)-1-
i];
5372 r->names[
rVar(r)-1-
i] = r->names[
i];
5390 char *
p=r->names[
i];
5443 for(
i=0; src->order[
i]!=0;
i++)
5445 switch (src->order[
i])
5450 r->order[
j]=src->order[
i];
5454 r->block0[
j]=
rOppVar(r, src->block1[
i]);
5455 r->block1[
j]=
rOppVar(r, src->block0[
i]);
5459 r->block0[
j]=
rOppVar(r, src->block1[
i]);
5460 r->block1[
j]=
rOppVar(r, src->block0[
i]);
5466 r->block0[
j]=
rOppVar(r, src->block1[
i]);
5467 r->block1[
j]=
rOppVar(r, src->block0[
i]);
5468 r->wvhdl[
j]=(
int*)
omAlloc((r->block1[
j]-r->block0[
j]+1)*
sizeof(
int));
5469 for(
int k=r->block0[
j];
k<=r->block1[
j];
k++)
5470 r->wvhdl[
j][
k-r->block0[
j]]=1;
5473 r->block0[
j]=
rOppVar(r, src->block1[
i]);
5474 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]);
5484 r->wvhdl[
j]=(
int*)
omAlloc((r->block1[
j]-r->block0[
j]+1)*
sizeof(
int));
5485 for(
int k=r->block0[
j];
k<=r->block1[
j];
k++)
5486 r->wvhdl[
j][
k-r->block0[
j]]=1;
5489 r->block0[
j]=
rOppVar(r, src->block1[
i]);
5490 r->block1[
j]=
rOppVar(r, src->block0[
i]);
5498 r->block0[
j]=
rOppVar(r, src->block1[
i]);
5499 r->block1[
j]=
rOppVar(r, src->block0[
i]);
5500 r->wvhdl[
j]=r->wvhdl[
j+1]; r->wvhdl[
j+1]=
NULL;
5504 r->block0[
j]=
rOppVar(r, src->block1[
i]);
5505 r->block1[
j]=
rOppVar(r, src->block0[
i]);
5513 r->block0[
j]=
rOppVar(r, src->block1[
i]);
5514 r->block1[
j]=
rOppVar(r, src->block0[
i]);
5515 r->wvhdl[
j]=r->wvhdl[
j+1]; r->wvhdl[
j+1]=
NULL;
5519 r->block0[
j]=
rOppVar(r, src->block1[
i]);
5520 r->block1[
j]=
rOppVar(r, src->block0[
i]);
5527 r->block0[
j]=
rOppVar(r, src->block1[
i]);
5528 r->block1[
j]=
rOppVar(r, src->block0[
i]);
5529 int n=r->block1[
j]-r->block0[
j];
5531 for (
int nn=0;
nn<=n;
nn++)
5540 r->block0[
j]=
rOppVar(r, src->block1[
i]);
5541 r->block1[
j]=
rOppVar(r, src->block0[
i]);
5583 for(
i=0; src->order[
i]!=0;
i++)
5585 switch (src->order[
i])
5590 r->order[
j]=src->order[
i];
5594 r->block0[
j]=
rOppVar(r, src->block1[
i]);
5595 r->block1[
j]=
rOppVar(r, src->block0[
i]);
5599 r->block0[
j]=
rOppVar(r, src->block1[
i]);
5600 r->block1[
j]=
rOppVar(r, src->block0[
i]);
5605 r->block0[
j]=
rOppVar(r, src->block1[
i]);
5606 r->block1[
j]=
rOppVar(r, src->block0[
i]);
5612 r->block0[
j]=
rOppVar(r, src->block1[
i]);
5613 r->block1[
j]=
rOppVar(r, src->block0[
i]);
5661 for(
i=1;
i<=r->N;
i++)
5677 MATELEM(C,
nj,
ni) =
p_PermPoly(
MATELEM(src->GetNC()->C,
i,
j),perm,src,r,
nMap,
par_perm,
rPar(src));
5680 MATELEM(
D,
nj,
ni) =
p_PermPoly(
MATELEM(src->GetNC()->D,
i,
j),perm,src,r,
nMap,
par_perm,
rPar(src));
5688 WarnS(
"Error initializing non-commutative multiplication!");
5696 assume( r->GetNC()->IsSkewConstant == src->GetNC()->IsSkewConstant);
5703 if (src->qideal !=
NULL)
5706 r->qideal =
idOppose(src, src->qideal, r);
5708 r->qideal =
id_Copy(src->qideal, r);
5740 WarnS(
"Error in rEnvelope at rSum");
5763 const int N = dest->N;
5783 for (
int i = 1;
i <
N;
i++)
5785 for (
int j =
i + 1;
j <=
N;
j++)
5788 const poly
p =
p_NSet(n, dest);
5850 Werror(
"n_IsParam: IsParam is not to be used for (coeff_type = %d)",
getCoeffType(C));
5859 WerrorS(
"only for rings with an ordering of one block");
5876 WerrorS(
"ordering must be dp,Dp,lp,rp,ds,Ds or ls");
5879 for(
int i=r->N-1;
i>=0;
i--)
5883 Werror(
"duplicate variable name >>%s<<",
v);
5889 #ifdef HAVE_SHIFTBBA
5892 R->isLPring=r->isLPring+1;
5893 R->N=((r->N)/r->isLPring)+r->N;
5897 for(
int b=0;
b<((r->N)/r->isLPring);
b++)
5900 for(
int i=
R->isLPring-1;
i>0;
i--)
5901 names[
i+
b*
R->isLPring]=
R->names[
i-1+
b*r->isLPring];
5906 for(
int b=0;
b<((r->N)/r->isLPring);
b++)
5909 for(
int i=
R->isLPring-2;
i>=0;
i--)
5910 names[
i+
b*
R->isLPring]=
R->names[
i+
b*r->isLPring];
5922 for(
int i=
R->N-1;
i>0;
i--) names[
i]=
R->names[
i-1];
5927 for(
int i=
R->N-2;
i>=0;
i--) names[
i]=
R->names[
i];
5941 WerrorS(
"only for rings with an ordering of one block");
5958 WerrorS(
"ordering must be dp,Dp,lp,rp,ds,Ds or ls");
5969 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)
static void rO_TDegree_neg(int &place, int &bitplace, int start, int end, long *o, sro_ord &ord_struct)
static void rSetFirstWv(ring r, int i, rRingOrder_t *order, int *block0, int *block1, int **wvhdl)
BOOLEAN rEqual(ring r1, ring r2, BOOLEAN qr)
returns TRUE, if r1 equals r2 FALSE, otherwise Equality is determined componentwise,...
int rSumInternal(ring r1, ring r2, ring &sum, BOOLEAN vartest, BOOLEAN dp_dp)
returns -1 for not compatible, 1 for compatible (and sum) dp_dp:0: block ordering,...
void rSetSyzComp(int k, const ring r)
static const char *const ringorder_name[]
static void rO_WDegree(int &place, int &bitplace, int start, int end, long *o, sro_ord &ord_struct, int *weights)
BOOLEAN rOrd_is_WeightedDegree_Ordering(const ring r)
int n_IsParam(const number m, const ring r)
TODO: rewrite somehow...
int64 * rGetWeightVec(const ring r)
static void rO_LexVars_neg(int &place, int &bitplace, int start, int end, int &prev_ord, long *o, int *v, int bits, int opt_var)
ring rAssure_dp_C(const ring r)
BOOLEAN rDBTest(ring r, const char *fn, const int l)
struct p_Procs_s p_Procs_s
static BOOLEAN rIsPluralRing(const ring r)
we must always have this test!
static int rBlocks(const ring r)
static ring rIncRefCnt(ring r)
static int rPar(const ring r)
(r->cf->P)
static BOOLEAN rIsLPRing(const ring r)
@ ringorder_a64
for int64 weights
@ ringorder_rs
opposite of ls
@ ringorder_aa
for idElimination, like a, except pFDeg, pWeigths ignore it
@ ringorder_IS
Induced (Schreyer) ordering.
static BOOLEAN rField_is_Q(const ring r)
static BOOLEAN rShortOut(const ring r)
@ rOrderType_CompExp
simple ordering, component has priority
@ rOrderType_Exp
simple ordering, exponent vector has priority component is compatible with exp-vector order
@ rOrderType_General
non-simple ordering as specified by currRing
@ rOrderType_ExpComp
simple ordering, exponent vector has priority component not compatible with exp-vector order
static BOOLEAN rIsNCRing(const ring r)
static char const ** rParameter(const ring r)
(r->cf->parameter)
static BOOLEAN rCanShortOut(const ring r)
static short rVar(const ring r)
#define rVar(r) (r->N)
#define rField_is_Ring(R)
ideal SCAQuotient(const ring r)
static short scaLastAltVar(ring r)
static short scaFirstAltVar(ring r)
ideal idInit(int idsize, int rank)
initialise an ideal / module
void id_Delete(ideal *h, ring r)
deletes an ideal/module/matrix
long id_RankFreeModule(ideal s, ring lmRing, ring tailRing)
return the maximal component number found in any polynomial in s
void idShow(const ideal id, const ring lmRing, const ring tailRing, const int debugPrint)
ideal id_SimpleAdd(ideal h1, ideal h2, const ring R)
concat the lists h1 and h2 without zeros
EXTERN_VAR long * currShiftedComponents
int ntIsParam(number m, const coeffs cf)
if m == var(i)/1 => return i,