40#define BITS_PER_LONG 8*SIZEOF_LONG
111 r->names = (
char **)
omAlloc0(
N *
sizeof(
char *));
119 r->wvhdl = (
int **)
omAlloc0((ord_size+1) *
sizeof(
int *));
125 if (bitmask!=0) r->wanted_maxExp=bitmask;
137 return rDefault(
cf,
N,n,ord_size,ord,block0,block1,wvhdl);
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");
189 int sz = (int)
sqrt((
double)(order->
length()-2));
190 if ((sz*sz)!=(order->
length()-2))
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: ");
261 R->ShortOut = bSaveShortOut;
304 Print(
"// number of vars : %d",r->N);
309 for (
int l=0, nlen=0 ;
l<nblocks;
l++)
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++)
342 nlen = strlen(r->names[
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++)
380 Print(
" %*d" ,nlen,r->wvhdl[
l][
i+
j]);
386 int m=r->wvhdl[
l][bl];
387 Print(
"\n// : %d module weights ",
m);
389 for(;
i<=
m;
i++)
Print(
" %*d" ,nlen,r->wvhdl[
l][
i]);
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;
461 if( r->qideal !=
NULL )
476 if (r->order !=
NULL)
487 if (r->wvhdl[
j]!=
NULL)
500 for (
i=0;
i<r->N;
i++)
519 if (order==0)
Werror(
"wrong ring order `%s`",ordername);
529 for (nblocks=0; r->order[nblocks]; nblocks++);
548 if (r->wvhdl[
l]!=
NULL)
560 Warn(
"should not have wvhdl entry at pos. %d",
l);
568 j<(r->block1[
l]-r->block0[
l]+1)*(r->block1[
l]-r->block0[
l]+1);
575 for (
i = 0;
i<r->block1[
l]-r->block0[
l];
i++)
584 for (
i = 0;
i<r->block1[
l]-r->block0[
l];
i++)
594 if (
j+
i+1==(r->block1[
l]-r->block0[
l]+1)*(r->block1[
l]-r->block0[
l]+1))
605 assume( r->block0[
l] == r->block1[
l] );
606 const int s = r->block0[
l];
614 if (r->wanted_maxExp!=0)
616 long mm=r->wanted_maxExp;
633 for (
i=0;
i<r->N;
i++)
635 l+=strlen(r->names[
i])+1;
639 for (
i=0;
i<r->N-1;
i++)
641 strcat(
s,r->names[
i]);
644 strcat(
s,r->names[
i]);
656 char const *
const *
const params =
rParameter(r);
663 l+=strlen(params[
i])+1;
669 strcat(
s, params[
i]);
672 strcat(
s, params[
i]);
683 char *
res=(
char *)
omAlloc(strlen(ch)+strlen(var)+strlen(ord)+9);
684 sprintf(
res,
"(%s),(%s),(%s)",ch,var,ord);
716int rChar(ring r) {
return r->cf->ch; }
731 for(
int i=1;
i<r->N;
i++)
732 for(
int j=
i+1;
j<=r->N;
j++)
736 WarnS(
"Error initializing multiplication!");
756 memset(&tmpR,0,
sizeof(tmpR));
791 && (mpz_cmp(r1->cf->modNumber,r2->cf->extRing->cf->modNumber)==0))
824 if (r1->cf->extRing->cf==r2->cf)
834 WerrorS (
"coeff sum of two extension fields not implemented");
840 WerrorS(
"coeff sum not yet implemented");
847 char **names=(
char **)
omAlloc0(
l*
sizeof(
char *));
852 for (
i=0;
i<r1->N;
i++)
856 if (*(r1->names[
i]) ==
'\0')
888 if (*(r2->names[
i]) ==
'\0')
911 if (strcmp(r1->names[
j],r2->names[
i])==0)
980 if ((r2->block0[0]==1)
981 && (r2->block1[0]==
rVar(r2))
987 tmpR.
order[1]=r2->order[0];
988 if (r2->wvhdl[0]!=
NULL)
993 int l=r2->block1[0]-r2->block0[0]+1;
998 l+=r2->wvhdl[1][r2->block1[0]-r2->block0[0]+1]+1;
1001 memcpy(tmpR.
wvhdl[1],r2->wvhdl[0],
l*
sizeof(
int));
1068 if (rb->wvhdl[
i]!=
NULL)
1069 WarnS(
"rSum: weights not implemented");
1075 for (
i=0;r1->order[
i]!=0;
i++)
1080 if (r1->wvhdl[
i]!=
NULL)
1085 int l=r1->block1[
i]-r1->block0[
i]+1;
1090 l+=r1->wvhdl[
i][r1->block1[
i]-r1->block0[
i]+1]+1;
1093 memcpy(tmpR.
wvhdl[
i],r1->wvhdl[
i],
l*
sizeof(
int));
1105 for (
i=0;r2->order[
i]!=0;
i++)
1113 if (r2->wvhdl[
i]!=
NULL)
1119 int l=r2->block1[
i]-r2->block0[
i]+1;
1124 l+=r2->wvhdl[
i][r2->block1[
i]-r2->block0[
i]+1]+1;
1127 memcpy(tmpR.
wvhdl[
j],r2->wvhdl[
i],
l*
sizeof(
int));
1134 if((r1->OrdSgn==-1)||(r2->OrdSgn==-1))
1154 if (r1->wvhdl[
i]!=
NULL)
1160 int l=r1->block1[
i]-r1->block0[
i]+1;
1165 l+=r1->wvhdl[
i][r1->block1[
i]-r1->block0[
i]+1]+1;
1168 memcpy(tmpR.
wvhdl[
i],r1->wvhdl[
i],
l*
sizeof(
int));
1179 Werror(
"variables must not overlap (# of vars: %d,%d -> %d)",
rVar(r1),
rVar(r2),
k);
1185 memcpy(sum,&tmpR,
sizeof(
ip_sring));
1202 if ( (R1_is_nc) || (R2_is_nc))
1226 int *perm1 = (
int *)
omAlloc0((
rVar(R1)+1)*
sizeof(
int));
1227 int *par_perm1 =
NULL;
1230 int *perm2 = (
int *)
omAlloc0((
rVar(R2)+1)*
sizeof(
int));
1231 int *par_perm2 =
NULL;
1236 perm1, par_perm1, sum->cf->type);
1240 perm2, par_perm2, sum->cf->type);
1243 matrix C1 = R1->GetNC()->C, C2 = R2->GetNC()->C;
1244 matrix D1 = R1->GetNC()->D, D2 = R2->GetNC()->D;
1253 for (
i = 1;
i <=
rVar(R1);
i++)
1266 MATELEM(C,
i,
j) =
p_PermPoly(
MATELEM(C1,
i,
j), perm1, R1, sum, nMap1, par_perm1,
rPar(R1));
1269 MATELEM(
D,
i,
j) =
p_PermPoly(
MATELEM(D1,
i,
j), perm1, R1, sum, nMap1, par_perm1,
rPar(R1));
1282 MATELEM(C,
rVar(R1)+
i,
rVar(R1)+
j) =
p_PermPoly(
MATELEM(C2,
i,
j),perm2,R2,sum, nMap2,par_perm2,
rPar(R2));
1285 MATELEM(
D,
rVar(R1)+
i,
rVar(R1)+
j) =
p_PermPoly(
MATELEM(D2,
i,
j),perm2,R2,sum, nMap2,par_perm2,
rPar(R2));
1293 WarnS(
"Error initializing non-commutative multiplication!");
1302 Print(
"\nRefs: R1: %d, R2: %d\n", R1->GetNC()->ref, R2->GetNC()->ref);
1325 if (r1->qideal!=
NULL)
1336 int *perm1 = (
int *)
omAlloc0((
rVar(r1)+1)*
sizeof(
int));
1337 int *par_perm1 =
NULL;
1341 perm1, par_perm1, sum->cf->type);
1345 for (
int for_i=0;for_i<
IDELEMS(r1->qideal);for_i++)
1347 r1->qideal->m[for_i], perm1,
1350 par_perm1,
rPar(r1));
1355 if (r2->qideal!=
NULL)
1359 int *perm2 = (
int *)
omAlloc0((
rVar(r2)+1)*
sizeof(
int));
1360 int *par_perm2 =
NULL;
1364 perm2, par_perm2, sum->cf->type);
1368 for (
int for_i=0;for_i<
IDELEMS(r2->qideal);for_i++)
1370 r2->qideal->m[for_i], perm2,
1373 par_perm2,
rPar(r2));
1405int rSum(ring r1, ring r2, ring &sum)
1431 res->options=r->options;
1446 res->firstBlockEnds=r->firstBlockEnds;
1448 res->real_var_start=r->real_var_start;
1449 res->real_var_end=r->real_var_end;
1453 res->isLPring=r->isLPring;
1454 res->LPncGenCount=r->LPncGenCount;
1457 res->VectorOut=r->VectorOut;
1458 res->ShortOut=r->ShortOut;
1459 res->CanShortOut=r->CanShortOut;
1475 res->bitmask=r->bitmask;
1476 res->divmask=r->divmask;
1477 res->BitsPerExp = r->BitsPerExp;
1478 res->ExpPerLong = r->ExpPerLong;
1497 if (copy_ordering ==
TRUE)
1499 res->LexOrder=r->LexOrder;
1500 res->MixedOrder=r->MixedOrder;
1508 if (r->wvhdl[
j]!=
NULL)
1514 int l=r->block1[
j]-r->block0[
j]+1;
1519 l+=r->wvhdl[
j][r->block1[
j]-r->block0[
j]+1]+1;
1522 memcpy(
res->wvhdl[
j],r->wvhdl[
j],
l*
sizeof(
int));
1530 memcpy(
res->block0,r->block0,
i *
sizeof(
int));
1531 memcpy(
res->block1,r->block1,
i *
sizeof(
int));
1546 if (r->qideal!=
NULL)
1575 res->options=r->options;
1590 res->firstBlockEnds=r->firstBlockEnds;
1592 res->real_var_start=r->real_var_start;
1593 res->real_var_end=r->real_var_end;
1597 res->isLPring=r->isLPring;
1598 res->LPncGenCount=r->LPncGenCount;
1601 res->VectorOut=r->VectorOut;
1602 res->ShortOut=r->ShortOut;
1603 res->CanShortOut=r->CanShortOut;
1604 res->LexOrder=r->LexOrder;
1605 res->MixedOrder=r->MixedOrder;
1621 res->bitmask=r->bitmask;
1622 res->divmask=r->divmask;
1623 res->BitsPerExp = r->BitsPerExp;
1624 res->ExpPerLong = r->ExpPerLong;
1643 if (copy_ordering ==
TRUE)
1650 for (
j=0;
j<
i-1;
j++)
1652 if (r->wvhdl[
j]!=
NULL)
1658 int l=r->block1[
j]-r->block0[
j]+1;
1663 l+=r->wvhdl[
j][r->block1[
j]-r->block0[
j]+1]+1;
1666 memcpy(
res->wvhdl[
j+1],r->wvhdl[
j],
l*
sizeof(
int));
1674 memcpy(&(
res->block0[1]),r->block0,(
i-1) *
sizeof(
int));
1675 memcpy(&(
res->block1[1]),r->block1,(
i-1) *
sizeof(
int));
1693 res->wvhdl[0]=(
int *)
A;
1703 if (r->qideal!=
NULL)
1709 WerrorS(
"internal error: rCopy0(Q,TRUE,FALSE)");
1714 WarnS(
"internal bad stuff: rCopy0(Q,TRUE,TRUE)");
1751 if (r1 == r2)
return TRUE;
1753 if (r1->cf!=r2->cf)
return FALSE;
1755 if (r1->bitmask!=r2->bitmask)
return FALSE;
1756 #ifdef HAVE_SHIFTBBA
1757 if (r1->isLPring!=r2->isLPring)
return FALSE;
1758 if (r1->LPncGenCount!=r2->LPncGenCount)
return FALSE;
1768 if ((r1->names[
i] !=
NULL) && (r2->names[
i] !=
NULL))
1770 if (strcmp(r1->names[
i], r2->names[
i]))
return FALSE;
1772 else if ((r1->names[
i] !=
NULL) ^ (r2->names[
i] !=
NULL))
1780 if (r1->qideal !=
NULL)
1782 ideal id1 = r1->qideal, id2 = r2->qideal;
1796 else if (r2->qideal !=
NULL)
return FALSE;
1806 if (r1 == r2)
return TRUE;
1810 if ((r1->cf != r2->cf)
1812 || (r1->OrdSgn != r2->OrdSgn))
1816 while (r1->order[
i] != 0)
1818 if (r2->order[
i] == 0)
return FALSE;
1819 if ((r1->order[
i] != r2->order[
i])
1820 || (r1->block0[
i] != r2->block0[
i])
1821 || (r1->block1[
i] != r2->block1[
i]))
1823 if (r1->wvhdl[
i] !=
NULL)
1825 if (r2->wvhdl[
i] ==
NULL)
1827 for (
j=0;
j<r1->block1[
i]-r1->block0[
i]+1;
j++)
1828 if (r2->wvhdl[
i][
j] != r1->wvhdl[
i][
j])
1834 if (r2->order[
i] != 0)
return FALSE;
1895 if (blocks == 1)
return TRUE;
1904 if ((blocks -
s) > 2)
return FALSE;
1970 if (blocks == 1)
return TRUE;
1979 if ((blocks -
s) > 3)
return FALSE;
1982 if ((blocks -
s) == 3)
2001 for (pos=0;pos<r->OrdSize;pos++)
2019 return ((
rVar(r) > 1) &&
2025 ((r->order[1]!=0) &&
2031 return ((
rVar(r) > 1) &&
2032 (((r->order[0]==
ringorder_dp)&&(r->block1[0]==r->N)) ||
2033 ((r->order[1]==
ringorder_dp)&&(r->block1[1]==r->N)&&((r->block0[1]==1)))));
2038 return ((
rVar(r) > 1) &&
2039 (((r->order[0]==
ringorder_ds)&&(r->block1[0]==r->N)) ||
2040 ((r->order[1]==
ringorder_ds)&&(r->block1[1]==r->N)&&((r->block0[1]==1)))));
2047 return ((
rVar(r) > 1) &&
2066 if (r->N == 0)
return TRUE;
2068 if ((r->OrdSgn!=1) && (r->OrdSgn!= -1))
2080 for(
int j=0;
j<=
i;
j++)
2083 dError(
"wrong order in r->order");
2094 if (r->VarOffset ==
NULL)
2096 dReportError(
"Null ring VarOffset -- no rComplete (?) in n %s:%d", fn,
l);
2101 if ((r->OrdSize==0)!=(r->typ==
NULL))
2103 dReportError(
"mismatch OrdSize and typ-pointer in %s:%d");
2109 for(
i=0;
i<=r->N;
i++)
2113 for(
j=0;
j<r->OrdSize;
j++)
2117 const int p = r->typ[
j].data.isTemp.suffixpos;
2124 if(r->typ[
p].ord_typ !=
ro_is)
2125 dReportError(
"ordrec prefix %d is unmatched (suffix: %d is wrong!!!)",
j,
p);
2128 if(r->typ[
j].data.isTemp.pVarOffset[
i] != -1)
2134 else if (r->typ[
j].ord_typ ==
ro_is)
2137 if(r->typ[
j].data.is.pVarOffset[
i] != -1)
2145 if (r->typ[
j].ord_typ==
ro_cp)
2147 if(((
short)r->VarOffset[
i]) == r->typ[
j].data.cp.place)
2152 && (r->VarOffset[
i] == r->typ[
j].data.dp.place))
2158 tmp=r->VarOffset[
i] & 0xffffff;
2159 #if SIZEOF_LONG == 8
2160 if ((r->VarOffset[
i] >> 24) >63)
2162 if ((r->VarOffset[
i] >> 24) >31)
2164 dReportError(
"bit_start out of range:%d",r->VarOffset[
i] >> 24);
2165 if (
i > 0 && ((tmp<0) ||(tmp>r->ExpL_Size-1)))
2167 dReportError(
"varoffset out of range for var %d: %d",
i,tmp);
2172 for(
j=0;
j<r->OrdSize;
j++)
2174 if ((r->typ[
j].ord_typ==
ro_dp)
2175 || (r->typ[
j].ord_typ==
ro_wp)
2178 if (r->typ[
j].data.dp.start > r->typ[
j].data.dp.end)
2180 r->typ[
j].data.dp.start, r->typ[
j].data.dp.end);
2181 if ((r->typ[
j].data.dp.start < 1)
2182 || (r->typ[
j].data.dp.end > r->N))
2183 dReportError(
"in ordrec %d: start(%d)<1 or end(%d)>vars(%d)",
j,
2184 r->typ[
j].data.dp.start, r->typ[
j].data.dp.end,r->N);
2216static void rO_TDegree(
int &place,
int &bitplace,
int start,
int end,
2222 ord_struct.
data.dp.start=start;
2223 ord_struct.
data.dp.end=end;
2224 ord_struct.
data.dp.place=place;
2236 ord_struct.
data.dp.start=start;
2237 ord_struct.
data.dp.end=end;
2238 ord_struct.
data.dp.place=place;
2244static void rO_WDegree(
int &place,
int &bitplace,
int start,
int end,
2245 long *o,
sro_ord &ord_struct,
int *weights)
2248 while((start<end) && (weights[0]==0)) { start++; weights++; }
2249 while((start<end) && (weights[end-start]==0)) { end--; }
2252 for(
i=start;
i<=end;
i++)
2254 if(weights[
i-start]!=1)
2262 rO_TDegree(place,bitplace,start,end,o,ord_struct);
2267 ord_struct.
data.wp.start=start;
2268 ord_struct.
data.wp.end=end;
2269 ord_struct.
data.wp.place=place;
2270 ord_struct.
data.wp.weights=weights;
2274 for(
i=start;
i<=end;
i++)
2276 if(weights[
i-start]<0)
2285 long *o,
sro_ord &ord_struct,
int *weights)
2294 ord_struct.
data.am.start=start;
2295 ord_struct.
data.am.end=end;
2296 ord_struct.
data.am.place=place;
2297 ord_struct.
data.am.weights=weights;
2298 ord_struct.
data.am.weights_m = weights + (end-start+1);
2299 ord_struct.
data.am.len_gen=weights[end-start+1];
2300 assume( ord_struct.
data.am.weights_m[0] == ord_struct.
data.am.len_gen );
2313 ord_struct.
data.wp64.start=start;
2314 ord_struct.
data.wp64.end=end;
2315 ord_struct.
data.wp64.place=place;
2317 ord_struct.
data.wp64.weights64=weights;
2321 for(
int i=0;
i<
l;
i++) ord_struct.
data.wp64.weights64[
i]=weights[
i];
2331 long *o,
sro_ord &ord_struct,
int *weights)
2334 while((start<end) && (weights[0]==0)) { start++; weights++; }
2335 while((start<end) && (weights[end-start]==0)) { end--; }
2338 ord_struct.
data.wp.start=start;
2339 ord_struct.
data.wp.end=end;
2340 ord_struct.
data.wp.place=place;
2341 ord_struct.
data.wp.weights=weights;
2346 for(
i=start;
i<=end;
i++)
2348 if(weights[
i-start]<0)
2356static void rO_LexVars(
int &place,
int &bitplace,
int start,
int end,
2357 int &prev_ord,
long *o,
int *
v,
int bits,
int opt_var)
2362 if(prev_ord==-1)
rO_Align(place,bitplace);
2368 for(
k=start;;
k+=incr)
2373 v[
k]= place | (bitplace << 24);
2379 assume((opt_var == end+1) ||(opt_var == end-1));
2380 if((opt_var != end+1) &&(opt_var != end-1))
WarnS(
"hier-2");
2381 int save_bitplace=bitplace;
2385 bitplace=save_bitplace;
2389 v[opt_var]=place | (bitplace << 24);
2394 int &prev_ord,
long *o,
int *
v,
int bits,
int opt_var)
2399 if(prev_ord==1)
rO_Align(place,bitplace);
2405 for(
k=start;;
k+=incr)
2410 v[
k]=place | (bitplace << 24);
2417 assume((opt_var == end+1) ||(opt_var == end-1));
2418 if((opt_var != end+1) &&(opt_var != end-1))
WarnS(
"hier-1");
2419 int save_bitplace=bitplace;
2423 bitplace=save_bitplace;
2427 v[opt_var]=place | (bitplace << 24);
2438 ord_struct.
data.syzcomp.place=place;
2439 ord_struct.
data.syzcomp.Components=
NULL;
2440 ord_struct.
data.syzcomp.ShiftedComponents=
NULL;
2447static void rO_Syz(
int &place,
int &bitplace,
int &prev_ord,
2448 int syz_comp,
long *o,
sro_ord &ord_struct)
2455 ord_struct.
data.syz.place=place;
2456 ord_struct.
data.syz.limit=syz_comp;
2458 ord_struct.
data.syz.syz_index = (
int*)
omAlloc0((syz_comp+1)*
sizeof(
int));
2460 ord_struct.
data.syz.syz_index =
NULL;
2461 ord_struct.
data.syz.curr_index = 1;
2474 long *o,
int N,
int *
v,
sro_ord &ord_struct)
2481 ord_struct.
data.isTemp.start = place;
2485 ord_struct.
data.isTemp.pVarOffset = (
int *)
omAlloc((
N+1)*
sizeof(
int));
2486 memcpy(ord_struct.
data.isTemp.pVarOffset,
v,(
N+1)*
sizeof(
int));
2488 ord_struct.
data.isTemp.suffixpos = -1;
2496static void rO_ISSuffix(
int &place,
int &bitplace,
int &prev_ord,
long *o,
2501 int typ_j = typ_i - 1;
2504 if( tmp_typ[typ_j].ord_typ ==
ro_isTemp)
2517 const int start = tmp_typ[typ_j].
data.isTemp.start;
2518 int *pVarOffset = tmp_typ[typ_j].
data.isTemp.pVarOffset;
2529 tmp_typ[typ_j].
data.isTemp.suffixpos = typ_i;
2536 for(
int i = 0;
i <=
N;
i++ )
2539 if(
v[
i] != pVarOffset[
i] )
2541 pVarOffset[
i] =
v[
i];
2543 assume( pVarOffset[
i] != -1 );
2549 if( pVarOffset[0] != -1 )
2550 pVarOffset[0] &= 0x0fff;
2552 sro_ord &ord_struct = tmp_typ[typ_j];
2556 ord_struct.
data.is.start = start;
2557 ord_struct.
data.is.end = place;
2558 ord_struct.
data.is.pVarOffset = pVarOffset;
2580 v[0] = place | (bitplace << 24);
2591 bits=16; bitmask=0xffff;
2593 else if (bitmask <= 1L)
2595 bits=1; bitmask = 1L;
2597 else if (bitmask <= 3L)
2599 bits=2; bitmask = 3L;
2601 else if (bitmask <= 7L)
2605 else if (bitmask <= 0xfL)
2607 bits=4; bitmask=0xfL;
2609 else if (bitmask <= 0x1fL)
2611 bits=5; bitmask=0x1fL;
2613 else if (bitmask <= 0x3fL)
2615 bits=6; bitmask=0x3fL;
2618 else if (bitmask <= 0x7fL)
2620 bits=7; bitmask=0x7fL;
2623 else if (bitmask <= 0xffL)
2625 bits=8; bitmask=0xffL;
2628 else if (bitmask <= 0x1ffL)
2630 bits=9; bitmask=0x1ffL;
2633 else if (bitmask <= 0x3ffL)
2635 bits=10; bitmask=0x3ffL;
2638 else if (bitmask <= 0xfffL)
2640 bits=12; bitmask=0xfff;
2643 else if (bitmask <= 0xffffL)
2645 bits=16; bitmask=0xffffL;
2648 else if (bitmask <= 0xfffffL)
2650 bits=20; bitmask=0xfffffL;
2652 else if (bitmask <= 0xffffffffL)
2654 bits=32; bitmask=0xffffffffL;
2656 else if (bitmask <= 0x7fffffffffffffffL)
2658 bits=63; bitmask=0x7fffffffffffffffL;
2662 bits=63; bitmask=0x7fffffffffffffffL;
2665 else if (bitmask <= 0x7fffffff)
2667 bits=31; bitmask=0x7fffffff;
2671 bits=31; bitmask=0x7fffffffL;
2692 unsigned long bitmask1 =
rGetExpSize(bitmask+1, bits1);
2694 if ((((
N+vars_per_long-1)/vars_per_long) ==
2695 ((
N+vars_per_long1-1)/vars_per_long1)))
2697 vars_per_long=vars_per_long1;
2717 unsigned long exp_limit)
2725 BOOLEAN need_other_ring = (exp_limit != r->bitmask);
2727 int iNeedInducedOrderingSetup = 0;
2731 int *block0=(
int*)
omAlloc0((nblocks+1)*
sizeof(
int));
2732 int *block1=(
int*)
omAlloc0((nblocks+1)*
sizeof(
int));
2733 int **wvhdl=(
int**)
omAlloc0((nblocks+1)*
sizeof(
int *));
2742 if (r->block0[
i]==r->block1[
i])
2767 Warn(
"Error: unhandled ordering in rModifyRing: ringorder_S = [%d]", r_ord);
2781 need_other_ring=
TRUE;
2782 try_omit_comp=
FALSE;
2783 copy_block_index=
FALSE;
2797 need_other_ring=
TRUE;
2799 omitted_degree =
TRUE;
2813 need_other_ring=
TRUE;
2815 omitted_degree =
TRUE;
2823 try_omit_comp =
FALSE;
2826 iNeedInducedOrderingSetup++;
2835 try_omit_comp =
FALSE;
2844 if (copy_block_index)
2846 block0[
j]=r->block0[
i];
2847 block1[
j]=r->block1[
i];
2848 wvhdl[
j]=r->wvhdl[
i];
2853 if(!need_other_ring)
2873 res->bitmask=exp_limit;
2874 res->wanted_maxExp=r->wanted_maxExp;
2881 if (r->pFDegOrig !=
res->pFDegOrig &&
2886 res->firstwv = r->firstwv;
2887 res->firstBlockEnds = r->firstBlockEnds;
2891 res->pLDeg = r->pLDegOrig;
2900 res->typ[0] = r->typ[0];
2902 if (r->typ[0].data.syz.limit > 0)
2904 res->typ[0].data.syz.syz_index
2905 = (
int*)
omAlloc((r->typ[0].data.syz.limit +1)*
sizeof(
int));
2906 memcpy(
res->typ[0].data.syz.syz_index, r->typ[0].data.syz.syz_index,
2907 (r->typ[0].data.syz.limit +1)*
sizeof(
int));
2911 if( iNeedInducedOrderingSetup > 0 )
2913 for(
j = 0,
i = 0; (
i < nblocks) && (iNeedInducedOrderingSetup > 0);
i++)
2920 r->typ[
i].data.is.limit,
2925 iNeedInducedOrderingSetup--;
2931 res->OrdSgn=r->OrdSgn;
2940 WarnS(
"error in nc_rComplete");
2953 WarnS(
"error in sca_Force!");
2979 res->block1[0] = r->N;
2980 res->wvhdl[0] = weights;
2995 WarnS(
"error in nc_rComplete");
3022 int nblocks=1+(ommit_comp!=0);
3024 int *block0=(
int*)
omAlloc0((nblocks+1)*
sizeof(
int));
3025 int *block1=(
int*)
omAlloc0((nblocks+1)*
sizeof(
int));
3026 int **wvhdl=(
int**)
omAlloc0((nblocks+1)*
sizeof(
int *));
3045 res->bitmask=exp_limit;
3046 res->wanted_maxExp=r->wanted_maxExp;
3057 WarnS(
"error in nc_rComplete");
3073 return rModifyRing(r, ommit_degree, ommit_comp, exp_limit);
3101 r->CanShortOut=
FALSE;
3104 r->CanShortOut =
TRUE;
3112 r->CanShortOut=
FALSE;
3120 for (
i=(
N-1);
i>=0;
i--)
3122 if(r->names[
i] !=
NULL && strlen(r->names[
i])>1)
3124 r->CanShortOut=
FALSE;
3130 r->ShortOut = r->CanShortOut;
3132 assume( !( !r->CanShortOut && r->ShortOut ) );
3140 if(block1[
i]!=r->N) r->LexOrder=
TRUE;
3141 r->firstBlockEnds=block1[
i];
3142 r->firstwv = wvhdl[
i];
3151 for(
j=block1[
i]-block0[
i];
j>=0;
j--)
3153 if (r->firstwv[
j]==0) r->LexOrder=
TRUE;
3160 for(
j=block1[
i]-block0[
i];
j>=0;
j--)
3162 if (
w[
j]==0) r->LexOrder=
TRUE;
3169 if (r->pFDeg ==
p_Deg)
3190 r->pLDegOrig = r->pLDeg;
3197 int* block0 = r->block0;
3198 int* block1 = r->block1;
3199 int** wvhdl = r->wvhdl;
3208 r->LexOrder =
FALSE;
3215 for(
int ii=block0[0];ii<=block1[0];ii++)
3216 if (wvhdl[0][ii-1]<0) { r->MixedOrder=2;
break;}
3218 for(
int ii=block0[0];ii<=block1[0];ii++)
3219 if (wvhdl[0][ii-1]==0) { r->LexOrder=
TRUE;
break;}
3220 if ((block0[0]==1)&&(block1[0]==r->N))
3231 r->firstwv = wvhdl[0];
3243 if (r->OrdSgn == -1) r->pLDeg =
pLDeg0c;
3262 for(
int ii=block0[0];ii<=block1[0];ii++)
3264 if (wvhdl[0][ii-1]<0) { r->MixedOrder=2;
break;}
3266 if (r->MixedOrder==0)
3268 if ((block0[0]==1)&&(block1[0]==r->N))
3276 r->firstBlockEnds=block1[0];
3277 r->firstwv = wvhdl[0];
3296 r->firstBlockEnds=block1[1];
3297 if (wvhdl!=
NULL) r->firstwv = wvhdl[1];
3305 for(
int ii=block0[1];ii<=block1[1];ii++)
3306 if (wvhdl[1][ii-1]<0) { r->MixedOrder=2;
break;}
3307 if (r->MixedOrder==
FALSE)
3340 if(r->MixedOrder==
FALSE)
3355 r->pFDegOrig = r->pFDeg;
3370 for(
i=0;
i<r->OrdSize;
i++)
3373 ||(r->typ[
i].ord_typ==
ro_am))
3378 r->NegWeightL_Size=
l;
3379 r->NegWeightL_Offset=(
int *)
omAlloc(
l*
sizeof(
int));
3381 for(
i=0;
i<r->OrdSize;
i++)
3385 r->NegWeightL_Offset[
l]=r->typ[
i].data.wp.place;
3388 else if(r->typ[
i].ord_typ==
ro_am)
3390 r->NegWeightL_Offset[
l]=r->typ[
i].data.am.place;
3397 r->NegWeightL_Size = 0;
3398 r->NegWeightL_Offset =
NULL;
3410 if ( (r->cf->extRing!=
NULL)
3419 if (r->LexOrder || r->OrdSgn == -1 || (r->cf->extRing!=
NULL))
3434 r->pLexOrder=r->LexOrder;
3442static inline int sign(
int x) {
return (
x > 0) - (
x < 0);}
3467 if (r->VarOffset!=
NULL && force == 0)
return FALSE;
3472 r->bitmask=
rGetExpSize(r->wanted_maxExp,bits,r->N);
3473 r->BitsPerExp = bits;
3478 long *tmp_ordsgn=(
long *)
omAlloc0(3*(n+r->N)*
sizeof(
long));
3480 int *
v=(
int *)
omAlloc((r->N+1)*
sizeof(
int));
3481 for(
i=r->N;
i>=0 ;
i--)
3498 switch (r->order[
i])
3502 rO_WDegree(
j,j_bits,r->block0[
i],r->block1[
i],tmp_ordsgn,tmp_typ[typ_i],
3508 rO_WMDegree(
j,j_bits,r->block0[
i],r->block1[
i],tmp_ordsgn,tmp_typ[typ_i],
3515 tmp_typ[typ_i], (
int64 *)(r->wvhdl[
i]));
3522 r->ComponentOrder=1;
3528 r->ComponentOrder=-1;
3534 k=r->block1[
i]-r->block0[
i]+1;
3539 r->wvhdl[
i]+(r->block1[
i]-r->block0[
i]+1)*
l);
3546 rO_LexVars(
j, j_bits, r->block0[
i],r->block1[
i], prev_ordsgn,
3547 tmp_ordsgn,
v,bits, -1);
3552 tmp_ordsgn,
v, bits, -1);
3557 tmp_ordsgn,
v, bits, -1);
3561 rO_LexVars(
j, j_bits, r->block1[
i],r->block0[
i], prev_ordsgn,
3562 tmp_ordsgn,
v, bits, -1);
3566 if (r->block0[
i]==r->block1[
i])
3568 rO_LexVars(
j, j_bits, r->block0[
i],r->block0[
i], prev_ordsgn,
3569 tmp_ordsgn,
v, bits, -1);
3577 prev_ordsgn,tmp_ordsgn,
v,bits, r->block0[
i]);
3582 if (r->block0[
i]==r->block1[
i])
3584 rO_LexVars(
j, j_bits, r->block0[
i],r->block0[
i], prev_ordsgn,
3585 tmp_ordsgn,
v, bits, -1);
3592 rO_LexVars(
j, j_bits, r->block0[
i],r->block1[
i]-1, prev_ordsgn,
3593 tmp_ordsgn,
v, bits, r->block1[
i]);
3598 if (r->block0[
i]==r->block1[
i])
3600 rO_LexVars(
j, j_bits, r->block0[
i],r->block0[
i], prev_ordsgn,
3601 tmp_ordsgn,
v, bits, -1);
3608 rO_LexVars(
j, j_bits, r->block1[
i],r->block0[
i], prev_ordsgn,
3609 tmp_ordsgn,
v, bits, -1);
3614 if (r->block0[
i]==r->block1[
i])
3617 tmp_ordsgn,
v,bits, -1);
3625 prev_ordsgn,tmp_ordsgn,
v,bits, r->block0[
i]);
3630 if (r->block0[
i]==r->block1[
i])
3633 tmp_ordsgn,
v, bits, -1);
3640 rO_LexVars(
j, j_bits, r->block0[
i],r->block1[
i]-1, prev_ordsgn,
3641 tmp_ordsgn,
v, bits, r->block1[
i]);
3647 tmp_typ[typ_i], r->wvhdl[
i]);
3652 for(jj=r->block1[
i]-r->block0[
i];jj>=0; jj--)
3654 if (r->wvhdl[
i][jj]<=0) have_bad_weights=
TRUE;
3656 if (have_bad_weights)
3663 if (r->block1[
i]!=r->block0[
i])
3666 tmp_ordsgn,
v,bits, r->block0[
i]);
3672 tmp_typ[typ_i], r->wvhdl[
i]);
3677 for(jj=r->block1[
i]-r->block0[
i];jj>=0; jj--)
3679 if (r->wvhdl[
i][jj]<=0) have_bad_weights=
TRUE;
3681 if (have_bad_weights)
3688 if (r->block1[
i]!=r->block0[
i])
3690 rO_LexVars(
j, j_bits,r->block0[
i],r->block1[
i]-1, prev_ordsgn,
3691 tmp_ordsgn,
v, bits, r->block1[
i]);
3697 tmp_typ[typ_i], r->wvhdl[
i]);
3699 if (r->block1[
i]!=r->block0[
i])
3702 tmp_ordsgn,
v,bits, r->block0[
i]);
3708 tmp_typ[typ_i], r->wvhdl[
i]);
3710 if (r->block1[
i]!=r->block0[
i])
3712 rO_LexVars(
j, j_bits,r->block0[
i],r->block1[
i]-1, prev_ordsgn,
3713 tmp_ordsgn,
v, bits, r->block1[
i]);
3720 rO_Syzcomp(
j, j_bits,prev_ordsgn, tmp_ordsgn,tmp_typ[typ_i]);
3721 need_to_add_comp=
TRUE;
3722 r->ComponentOrder=-1;
3728 rO_Syz(
j, j_bits, prev_ordsgn, r->block0[
i], tmp_ordsgn, tmp_typ[typ_i]);
3729 need_to_add_comp=
TRUE;
3730 r->ComponentOrder=-1;
3737 assume( r->block0[
i] == r->block1[
i] );
3738 const int s = r->block0[
i];
3742 rO_ISPrefix(
j, j_bits, prev_ordsgn, tmp_ordsgn, r->N,
v, tmp_typ[typ_i++]);
3745 rO_ISSuffix(
j, j_bits, prev_ordsgn, tmp_ordsgn, r->N,
v, tmp_typ, typ_i,
s);
3746 need_to_add_comp=
FALSE;
3765 j_bits=j_bits0;
j=j0;
3770 if((need_to_add_comp) && (
v[0]== -1))
3784 for(
i=1 ;
i<=r->N ;
i++)
3811 r->ordsgn=(
long *)
omAlloc0(r->ExpL_Size*
sizeof(
long));
3813 for(
j=0;
j<r->CmpL_Size;
j++)
3815 r->ordsgn[
j] = tmp_ordsgn[
j];
3824 if (typ_i==0) r->typ=
NULL;
3828 memcpy(r->typ,tmp_typ,typ_i*
sizeof(
sro_ord));
3838 r->pCompIndex=(r->VarOffset[0] & 0xffff);
3841 if (
i==r->pCompIndex)
i++;
3850 if (
i==r->pCompIndex)
i++;
3888 for(
int i=1;
i<=r->N;
i++)
3895 if ((r->block0[
j]<=
i)&&(r->block1[
j]>=
i))
3915 if(r->wvhdl[
j][
i-r->block0[
j]]<0)
3921 else if(r->wvhdl[
j][
i-r->block0[
j]]>0)
3932 if(r->wvhdl[
j][
i-r->block0[
j]]<0)
3938 else if(r->wvhdl[
j][
i-r->block0[
j]]>0)
3946 int add=r->block1[
j]-r->block0[
j]+1;
3951 if (r->wvhdl[
j][
i-r->block0[
j]]<0)
3957 else if(r->wvhdl[
j][
i-r->block0[
j]]>0)
3987 if (nonneg>0) r->MixedOrder=1;
3998 if (r ==
NULL)
return;
3999 if (r->VarOffset !=
NULL)
4001 if (r->OrdSize!=0 && r->typ !=
NULL)
4003 for(
int i = 0;
i < r->OrdSize;
i++)
4004 if( r->typ[
i].ord_typ ==
ro_is)
4008 if( r->typ[
i].data.is.pVarOffset !=
NULL )
4013 else if (r->typ[
i].ord_typ ==
ro_syz)
4015 if(r->typ[
i].data.syz.limit > 0)
4016 omFreeSize(r->typ[
i].data.syz.syz_index, ((r->typ[
i].data.syz.limit) +1)*
sizeof(
int));
4020 assume( r->typ[
i].data.syzcomp.ShiftedComponents ==
NULL );
4021 assume( r->typ[
i].data.syzcomp.Components ==
NULL );
4031 if (r->PolyBin !=
NULL)
4037 if (r->ordsgn !=
NULL && r->CmpL_Size != 0)
4042 if (r->p_Procs !=
NULL)
4047 omfreeSize(r->VarL_Offset, r->VarL_Size*
sizeof(
int));
4048 r->VarL_Offset=
NULL;
4050 if (r->NegWeightL_Offset!=
NULL)
4052 omFreeSize(r->NegWeightL_Offset, r->NegWeightL_Size*
sizeof(
int));
4053 r->NegWeightL_Offset=
NULL;
4060 int min = INT_MAX, min_j = -1;
4061 int* VarL_Number = (
int*)
omAlloc0(r->ExpL_Size*
sizeof(
int));
4066 for (
i=1;
i<=r->N;
i++)
4068 VarL_Number[r->VarOffset[
i] & 0xffffff]++;
4072 for (
i=0,
j=0;
i<r->ExpL_Size;
i++)
4074 if (VarL_Number[
i] != 0)
4076 if (
min > VarL_Number[
i])
4078 min = VarL_Number[
i];
4087 r->VarL_Offset = (
int*)
omAlloc(r->VarL_Size*
sizeof(
int));
4088 r->VarL_LowIndex = 0;
4091 for (
i=0,
j=0;
i<r->ExpL_Size;
i++)
4093 if (VarL_Number[
i] != 0)
4095 r->VarL_Offset[
j] =
i;
4096 if (
j > 0 && r->VarL_Offset[
j-1] != r->VarL_Offset[
j] - 1)
4097 r->VarL_LowIndex = -1;
4101 if (r->VarL_LowIndex >= 0)
4102 r->VarL_LowIndex = r->VarL_Offset[0];
4106 j = r->VarL_Offset[min_j];
4107 r->VarL_Offset[min_j] = r->VarL_Offset[0];
4108 r->VarL_Offset[0] =
j;
4115 int* shifts = (
int*)
omAlloc(r->ExpL_Size*
sizeof(
int));
4118 for (
i=0;
i<r->ExpL_Size;
i++)
4122 for (
i=1;
i<=r->N;
i++)
4124 if (shifts[r->VarOffset[
i] & 0xffffff] > r->VarOffset[
i] >> 24)
4125 shifts[r->VarOffset[
i] & 0xffffff] = r->VarOffset[
i] >> 24;
4128 for (
i=1;
i<=r->N;
i++)
4130 if (shifts[r->VarOffset[
i] & 0xffffff] != 0)
4132 = (r->VarOffset[
i] & 0xffffff) |
4133 (((r->VarOffset[
i] >> 24) - shifts[r->VarOffset[
i] & 0xffffff]) << 24);
4141 unsigned long divmask = 1;
4146 divmask |= (((
unsigned long) 1) << (
unsigned long)
i);
4161 const char *TYP[]={
"ro_dp",
"ro_wp",
"ro_am",
"ro_wp64",
"ro_wp_neg",
"ro_cp",
4162 "ro_syzcomp",
"ro_syz",
"ro_isTemp",
"ro_is",
"ro_none"};
4165 Print(
"ExpL_Size:%d ",r->ExpL_Size);
4166 Print(
"CmpL_Size:%d ",r->CmpL_Size);
4167 Print(
"VarL_Size:%d\n",r->VarL_Size);
4168 Print(
"bitmask=0x%lx (expbound=%ld) \n",r->bitmask, r->bitmask);
4169 Print(
"divmask=%lx\n", r->divmask);
4170 Print(
"BitsPerExp=%d ExpPerLong=%d at L[%d]\n", r->BitsPerExp, r->ExpPerLong, r->VarL_Offset[0]);
4172 Print(
"VarL_LowIndex: %d\n", r->VarL_LowIndex);
4173 PrintS(
"VarL_Offset:\n");
4176 for(
j = 0;
j < r->VarL_Size;
j++)
4177 Print(
" VarL_Offset[%d]: %d ",
j, r->VarL_Offset[
j]);
4184 for(
j=0;
j<=r->N;
j++)
4185 Print(
" v%d at e-pos %d, bit %d\n",
4186 j,r->VarOffset[
j] & 0xffffff, r->VarOffset[
j] >>24);
4188 for(
j=0;
j<r->CmpL_Size;
j++)
4189 Print(
" ordsgn %ld at pos %d\n",r->ordsgn[
j],
j);
4190 Print(
"OrdSgn:%d\n",r->OrdSgn);
4192 for(
j=0;
j<r->OrdSize;
j++)
4194 Print(
" typ %s", TYP[r->typ[
j].ord_typ]);
4195 if (r->typ[
j].ord_typ==
ro_syz)
4197 const short place = r->typ[
j].data.syz.place;
4198 const int limit = r->typ[
j].data.syz.limit;
4199 const int curr_index = r->typ[
j].data.syz.curr_index;
4200 const int* syz_index = r->typ[
j].data.syz.syz_index;
4202 Print(
" limit %d (place: %d, curr_index: %d), syz_index: ", limit, place, curr_index);
4204 if( syz_index ==
NULL )
4209 for(
i=0;
i <= limit;
i++ )
4210 Print(
"%d ", syz_index[
i]);
4217 Print(
" start (level) %d, suffixpos: %d, VO: ",r->typ[
j].data.isTemp.start, r->typ[
j].data.isTemp.suffixpos);
4220 else if (r->typ[
j].ord_typ==
ro_is)
4222 Print(
" start %d, end: %d: ",r->typ[
j].data.is.start, r->typ[
j].data.is.end);
4226 Print(
" limit %d",r->typ[
j].data.is.limit);
4233 else if (r->typ[
j].ord_typ==
ro_am)
4235 Print(
" place %d",r->typ[
j].data.am.place);
4236 Print(
" start %d",r->typ[
j].data.am.start);
4237 Print(
" end %d",r->typ[
j].data.am.end);
4238 Print(
" len_gen %d",r->typ[
j].data.am.len_gen);
4241 for(
l=r->typ[
j].data.am.start;
l<=r->typ[
j].data.am.end;
l++)
4242 Print(
" %d",r->typ[
j].data.am.weights[
l-r->typ[
j].data.am.start]);
4243 l=r->typ[
j].data.am.end+1;
4244 int ll=r->typ[
j].data.am.weights[
l-r->typ[
j].data.am.start];
4246 for(
int lll=
l+1;lll<
l+ll+1;lll++)
4247 Print(
" %d",r->typ[
j].data.am.weights[lll-r->typ[
j].data.am.start]);
4251 Print(
" place %d",r->typ[
j].data.dp.place);
4255 Print(
" start %d",r->typ[
j].data.dp.start);
4256 Print(
" end %d",r->typ[
j].data.dp.end);
4257 if ((r->typ[
j].ord_typ==
ro_wp)
4261 for(
int l=r->typ[
j].data.wp.start;
l<=r->typ[
j].data.wp.end;
l++)
4262 Print(
" %d",r->typ[
j].data.wp.weights[
l-r->typ[
j].data.wp.start]);
4264 else if (r->typ[
j].ord_typ==
ro_wp64)
4268 for(
l=r->typ[
j].data.wp64.start;
l<=r->typ[
j].data.wp64.end;
l++)
4269 Print(
" %ld",(
long)(r->typ[
j].data.wp64.weights64+
l-r->typ[
j].data.wp64.start));
4275 Print(
"pOrdIndex:%d pCompIndex:%d\n", r->pOrdIndex, r->pCompIndex);
4276 Print(
"OrdSize:%d\n",r->OrdSize);
4277 PrintS(
"--------------------\n");
4278 for(
j=0;
j<r->ExpL_Size;
j++)
4282 Print(
"ordsgn %ld ", r->ordsgn[
j]);
4288 if( (r->VarOffset[
i] & 0xffffff) ==
j )
4289 {
Print(
"v%d at e[%d], bit %d; ",
i,r->VarOffset[
i] & 0xffffff,
4290 r->VarOffset[
i] >>24 ); }
4292 if( r->pCompIndex==
j )
PrintS(
"v0; ");
4293 for(
i=0;
i<r->OrdSize;
i++)
4295 if (r->typ[
i].data.dp.place ==
j)
4297 Print(
"ordrec:%s (start:%d, end:%d) ",TYP[r->typ[
i].ord_typ],
4298 r->typ[
i].data.dp.start, r->typ[
i].data.dp.end);
4302 if (
j==r->pOrdIndex)
4307 Print(
"LexOrder:%d, MixedOrder:%d\n",r->LexOrder, r->MixedOrder);
4309 Print(
"NegWeightL_Size: %d, NegWeightL_Offset: ", r->NegWeightL_Size);
4310 if (r->NegWeightL_Offset==
NULL)
PrintS(
" NULL");
4312 for(
j = 0;
j < r->NegWeightL_Size;
j++)
4313 Print(
" [%d]: %d ",
j, r->NegWeightL_Offset[
j]);
4324 Print(
"p_Spec : %s, %s, %s\n", field,
length, ord);
4326 for (
i=0;
i<(int) (
sizeof(
p_Procs_s)/
sizeof(
void*));
i++)
4328 Print(
" %s,\n", ((
char**) &proc_names)[
i]);
4334#define pFDeg_CASE(A) if(r->pFDeg == A) PrintS( "" #A "" )
4340 Print(
"(%p)", r->pFDeg);
4343 Print(
"pLDeg : (%p)", r->pLDeg);
4355 else Print(
"%p\n",r->p_Setm);
4365 Print(
"\nexp[0..%d]\n",r->ExpL_Size-1);
4366 for(
i=0;
i<r->ExpL_Size;
i++)
4374 if (
j==0) {
PrintS(
"...\n");
break; }
4383 Print(
"\nexp[0..%d]\n",
R->ExpL_Size - 1);
4384 for(
int i = 0;
i <
R->ExpL_Size;
i++)
4403 r->typ[1].data.syzcomp.Components = currComponents;
4411 *currComponents = r->typ[1].data.syzcomp.Components;
4421 r->typ[1].data.syzcomp.length =
length;
4431 *
length = r->typ[1].data.syzcomp.length;
4473 WarnS(
"rAssure_SyzComp: input ring has an IS-ordering!");
4484 int ** wvhdl =(
int **)
omAlloc0((
i+1)*
sizeof(
int**));
4487 res->order[
j]=r->order[
j-1];
4488 res->block0[
j]=r->block0[
j-1];
4489 res->block1[
j]=r->block1[
j-1];
4490 if (r->wvhdl[
j-1] !=
NULL)
4496 int l=r->block1[
j-1]-r->block0[
j-1]+1;
4501 l+=r->wvhdl[
j-1][r->block1[
j-1]-r->block0[
j-1]+1]+1;
4504 memcpy(wvhdl[
j],r->wvhdl[
j-1],
l*
sizeof(
int));
4522 WarnS(
"error in nc_rComplete");
4532 if (r->qideal!=
NULL)
4562 pos=r->VarL_LowIndex;
4567 for(
int i=r->OrdSize-1;
i>=0;
i--)
4569 if ((r->typ[
i].ord_typ==
ro_dp)
4570 && (r->typ[
i].data.dp.start==1)
4571 && (r->typ[
i].data.dp.end==r->N))
4573 pos=r->typ[
i].data.dp.place;
4592 res->ExpL_Size=r->ExpL_Size+1;
4596 for(
j=0;
j<r->CmpL_Size;
j++)
4598 res->ordsgn[
j] = r->ordsgn[
j];
4600 res->OrdSize=r->OrdSize+1;
4605 memcpy(
res->typ,r->typ,r->OrdSize*
sizeof(
sro_ord));
4609 res->typ[
res->OrdSize-1].data.dp.start=1;
4610 res->typ[
res->OrdSize-1].data.dp.end=
res->N;
4611 res->typ[
res->OrdSize-1].data.dp.place=
res->ExpL_Size-1;
4612 pos=
res->ExpL_Size-1;
4628 WarnS(
"error in nc_rComplete");
4634 if (r->qideal!=
NULL)
4664 if (r->order[
i] == 0)
4673 new_r->wvhdl=(
int **)
omAlloc0(
i *
sizeof(
int *));
4675 new_r->block0 = (
int *)
omAlloc0(
i *
sizeof(
int));
4676 new_r->block1 = (
int *)
omAlloc0(
i *
sizeof(
int));
4678 memcpy(new_r->block0,r->block0,(
i-1) *
sizeof(
int));
4679 memcpy(new_r->block1,r->block1,(
i-1) *
sizeof(
int));
4680 for (
int j=0;
j<=last_block;
j++)
4682 if (r->wvhdl[
j]!=
NULL)
4685 new_r->wvhdl[
j] = (
int*)
omMemDup(r->wvhdl[
j]);
4688 int l=r->block1[
j]-r->block0[
j]+1;
4693 l+=r->wvhdl[
j][r->block1[
j]-r->block0[
j]+1]+1;
4695 new_r->wvhdl[
j]=(
int*)
omalloc(
l*
sizeof(
int));
4696 memcpy(new_r->wvhdl[
j],r->wvhdl[
j],
l*
sizeof(
int));
4715 WarnS(
"error in nc_rComplete");
4727 int last_block =
rBlocks(r) - 2;
4734 for (
i=0;
i< last_block;
i++)
4745 for (
i=c_pos+1;
i<=last_block;
i++)
4747 new_r->order[
i-1] = new_r->order[
i];
4748 new_r->block0[
i-1] = new_r->block0[
i];
4749 new_r->block1[
i-1] = new_r->block1[
i];
4750 new_r->wvhdl[
i-1] = new_r->wvhdl[
i];
4752 new_r->order[last_block] = r->order[c_pos];
4753 new_r->block0[last_block] = r->block0[c_pos];
4754 new_r->block1[last_block] = r->block1[c_pos];
4755 new_r->wvhdl[last_block] = r->wvhdl[c_pos];
4766 WarnS(
"error in nc_rComplete");
4791 if (new_r_1 != new_r && new_r_1 != old_r)
rDelete(new_r_1);
4800 WarnS(
"error in nc_rComplete");
4807 if (old_r->qideal !=
NULL)
4809 new_r->qideal =
idrCopyR(old_r->qideal, old_r, new_r);
4817 WarnS(
"error in nc_SetupQuotient");
4842 if ((r_blocks == 3) &&
4843 (r->order[0] == b1) &&
4844 (r->order[1] == b2) &&
4857 res->block1[1] = r->N;
4862 res->block1[0] = r->N;
4872 WarnS(
"error in nc_rComplete");
4885 if ((r_blocks == 3) &&
4891 for(
int i=0;
i<r->N;
i++)
4893 if ((*
w)[
i]!=r->wvhdl[0][
i]) { ok=
FALSE;
break;}
4905 res->block1[1] = r->N;
4906 res->wvhdl[0]=(
int*)
omAlloc(r->N*
sizeof(
int));
4907 for(
int i=0;
i<r->N;
i++)
4909 r->wvhdl[0][
i]=(*w)[
i];
4919 WarnS(
"error in nc_rComplete");
4932 Print(
"rAssure_InducedSchreyerOrdering(r, complete = %d, sgn = %d): r: \n", complete,
sgn);
4949 int ** wvhdl =(
int **)
omAlloc0((n+2)*
sizeof(
int**));
4957 res->block0[
j] =
res->block1[
j] = 0;
4961 for(
int i = 0; (
i <= n) && (r->order[
i] != 0);
i++,
j++)
4963 res->order [
j] = r->order [
i];
4964 res->block0[
j] = r->block0[
i];
4965 res->block1[
j] = r->block1[
i];
4967 if (r->wvhdl[
i] !=
NULL)
4973 int l=(r->block1[
i]-r->block0[
i]+1);
4978 l+=r->wvhdl[
i][r->block1[
i]-r->block0[
i]+1]+1;
4981 memcpy(wvhdl[
j],r->wvhdl[
i],
l*
sizeof(
int));
5013 WarnS(
"error in nc_rComplete");
5025 if (r->qideal!=
NULL)
5087 Print(
"rIsIS(p: %d)\nF:",
p);
5098 for(
int pos = 0; pos < r->OrdSize; pos++ )
5099 if( r->typ[pos].ord_typ ==
ro_is)
5121 dReportError(
"Error: WRONG USE of rSetISReference: wrong ring! (typ == NULL)");
5130 dReportError(
"Error: WRONG USE of rSetISReference: specified ordering block was not found!!!" );
5135 if(
i != r->typ[pos].data.is.limit )
5136 Print(
"Changing record on pos: %d\nOld limit: %d --->> New Limit: %d\n", pos, r->typ[pos].data.is.limit,
i);
5139 const ideal FF =
idrHeadR(F, r, r);
5142 if( r->typ[pos].data.is.F !=
NULL)
5145 PrintS(
"Deleting old reference set F... \n");
5148 r->typ[pos].data.is.F =
NULL;
5153 r->typ[pos].data.is.F = FF;
5155 r->typ[pos].data.is.limit =
i;
5179 if ((r->typ!=
NULL) && (r->typ[0].ord_typ==
ro_syz))
5181 r->block0[0]=r->block1[0] =
k;
5182 if(
k == r->typ[0].data.syz.limit )
5186 if (r->typ[0].data.syz.limit == 0)
5188 r->typ[0].data.syz.syz_index = (
int*)
omAlloc0((
k+1)*
sizeof(
int));
5189 r->typ[0].data.syz.syz_index[0] = 0;
5190 r->typ[0].data.syz.curr_index = 1;
5194 r->typ[0].data.syz.syz_index = (
int*)
5196 (r->typ[0].data.syz.limit+1)*
sizeof(
int),
5199 for (
i=r->typ[0].data.syz.limit + 1;
i<=
k;
i++)
5201 r->typ[0].data.syz.syz_index[
i] =
5202 r->typ[0].data.syz.curr_index;
5204 if(
k < r->typ[0].data.syz.limit)
5207 Warn(
"rSetSyzComp called with smaller limit (%d) as before (%d)",
k, r->typ[0].data.syz.limit);
5209 r->typ[0].data.syz.curr_index = 1 + r->typ[0].data.syz.syz_index[
k];
5213 r->typ[0].data.syz.limit =
k;
5214 r->typ[0].data.syz.curr_index++;
5223 Warn(
"rSetSyzComp(%d) in an IS ring! Be careful!",
k);
5228 r->block0[0] = r->block1[0] =
k;
5243 if ((r->typ!=
NULL) && (r->typ[0].ord_typ==
ro_syz) &&
5244 r->typ[0].data.syz.limit > 0 &&
i > 0)
5248 for (
j=0;
j<r->typ[0].data.syz.limit;
j++)
5250 if (r->typ[0].data.syz.syz_index[
j] ==
i &&
5251 r->typ[0].data.syz.syz_index[
j+1] !=
i)
5253 assume(r->typ[0].data.syz.syz_index[
j+1] ==
i+1);
5257 return r->typ[0].data.syz.limit;
5262 WarnS(
"rGetMaxSyzComp: order c");
5277 if ((r->order[0]==
ringorder_dp) &&(r->block0[0]==1) &&(r->block1[0]==r->N))
5280 && ((r->order[1]==
ringorder_dp) &&(r->block0[1]==1) &&(r->block1[1]==r->N)))
5287 if ((r->order[0]==
ringorder_Dp) &&(r->block0[0]==1) &&(r->block1[0]==r->N))
5290 && ((r->order[1]==
ringorder_Dp) &&(r->block0[1]==1) &&(r->block1[1]==r->N)))
5297 if ((r->order[0]==
ringorder_lp) &&(r->block0[0]==1) &&(r->block1[0]==r->N))
5300 && ((r->order[1]==
ringorder_lp) &&(r->block0[1]==1) &&(r->block1[1]==r->N)))
5310 while((r->typ[
i].ord_typ!=
ro_wp64) && (r->typ[
i].ord_typ>0))
i++;
5312 return r->typ[
i].data.wp64.weights64;
5320 memcpy(r->typ[0].data.wp64.weights64,wv,r->N*
sizeof(
int64));
5331 for(
int k=
size;
k>pos;
k--) r->wvhdl[
k]=r->wvhdl[
k-1];
5337static int rReallocM1(ring r,
int size,
int pos)
5343 for(
int k=pos+1;
k<
size;
k++) r->wvhdl[
k]=r->wvhdl[
k+1];
5353 for(
int j=0;
j<=i2;
j++)
5361#define rOppVar(R,I) (rVar(R)+1-I)
5379 if (src->qideal !=
NULL)
5386 int i2 = (
rVar(r)-1)/2;
5387 for(
i=i2;
i>=0;
i--)
5393 p = r->names[
rVar(r)-1-
i];
5394 r->names[
rVar(r)-1-
i] = r->names[
i];
5412 char *
p=r->names[
i];
5413 if(isupper(*
p)) *
p = tolower(*
p);
5414 else *
p = toupper(*
p);
5465 for(
i=0; src->order[
i]!=0;
i++)
5467 switch (src->order[
i])
5472 r->order[
j]=src->order[
i];
5476 r->block0[
j]=
rOppVar(r, src->block1[
i]);
5477 r->block1[
j]=
rOppVar(r, src->block0[
i]);
5481 r->block0[
j]=
rOppVar(r, src->block1[
i]);
5482 r->block1[
j]=
rOppVar(r, src->block0[
i]);
5488 r->block0[
j]=
rOppVar(r, src->block1[
i]);
5489 r->block1[
j]=
rOppVar(r, src->block0[
i]);
5490 r->wvhdl[
j]=(
int*)
omAlloc((r->block1[
j]-r->block0[
j]+1)*
sizeof(
int));
5491 for(
int k=r->block0[
j];
k<=r->block1[
j];
k++)
5492 r->wvhdl[
j][
k-r->block0[
j]]=1;
5495 r->block0[
j]=
rOppVar(r, src->block1[
i]);
5496 r->block1[
j]=
rOppVar(r, src->block0[
i]);
5504 r->block0[
j]=
rOppVar(r, src->block1[
i]);
5505 r->block1[
j]=
rOppVar(r, src->block0[
i]);
5506 r->wvhdl[
j]=(
int*)
omAlloc((r->block1[
j]-r->block0[
j]+1)*
sizeof(
int));
5507 for(
int k=r->block0[
j];
k<=r->block1[
j];
k++)
5508 r->wvhdl[
j][
k-r->block0[
j]]=1;
5511 r->block0[
j]=
rOppVar(r, src->block1[
i]);
5512 r->block1[
j]=
rOppVar(r, src->block0[
i]);
5520 r->block0[
j]=
rOppVar(r, src->block1[
i]);
5521 r->block1[
j]=
rOppVar(r, src->block0[
i]);
5522 r->wvhdl[
j]=r->wvhdl[
j+1]; r->wvhdl[
j+1]=
NULL;
5526 r->block0[
j]=
rOppVar(r, src->block1[
i]);
5527 r->block1[
j]=
rOppVar(r, src->block0[
i]);
5535 r->block0[
j]=
rOppVar(r, src->block1[
i]);
5536 r->block1[
j]=
rOppVar(r, src->block0[
i]);
5537 r->wvhdl[
j]=r->wvhdl[
j+1]; r->wvhdl[
j+1]=
NULL;
5541 r->block0[
j]=
rOppVar(r, src->block1[
i]);
5542 r->block1[
j]=
rOppVar(r, src->block0[
i]);
5549 r->block0[
j]=
rOppVar(r, src->block1[
i]);
5550 r->block1[
j]=
rOppVar(r, src->block0[
i]);
5551 int n=r->block1[
j]-r->block0[
j];
5553 for (
int nn=0; nn<=n; nn++)
5562 r->block0[
j]=
rOppVar(r, src->block1[
i]);
5563 r->block1[
j]=
rOppVar(r, src->block0[
i]);
5608 for(
i=0; src->order[
i]!=0;
i++)
5610 switch (src->order[
i])
5615 r->order[
j]=src->order[
i];
5619 r->block0[
j]=
rOppVar(r, src->block1[
i]);
5620 r->block1[
j]=
rOppVar(r, src->block0[
i]);
5624 r->block0[
j]=
rOppVar(r, src->block1[
i]);
5625 r->block1[
j]=
rOppVar(r, src->block0[
i]);
5630 r->block0[
j]=
rOppVar(r, src->block1[
i]);
5631 r->block1[
j]=
rOppVar(r, src->block0[
i]);
5637 r->block0[
j]=
rOppVar(r, src->block1[
i]);
5638 r->block1[
j]=
rOppVar(r, src->block0[
i]);
5684 int *par_perm =
NULL;
5687 for(
i=1;
i<=r->N;
i++)
5703 MATELEM(C,nj,ni) =
p_PermPoly(
MATELEM(src->GetNC()->C,
i,
j),perm,src,r, nMap,par_perm,
rPar(src));
5706 MATELEM(
D,nj,ni) =
p_PermPoly(
MATELEM(src->GetNC()->D,
i,
j),perm,src,r, nMap,par_perm,
rPar(src));
5714 WarnS(
"Error initializing non-commutative multiplication!");
5722 assume( r->GetNC()->IsSkewConstant == src->GetNC()->IsSkewConstant);
5729 if (src->qideal !=
NULL)
5732 r->qideal =
idOppose(src, src->qideal, r);
5734 r->qideal =
id_Copy(src->qideal, r);
5764 int stat =
rSum(
R, Ropp, Renv);
5766 WarnS(
"Error in rEnvelope at rSum");
5789 const int N = dest->N;
5798 const ring srcBase = src;
5805 matrix C0 = src->GetNC()->C;
5806 matrix D0 = src->GetNC()->D;
5809 for (
int i = 1;
i <
N;
i++)
5811 for (
int j =
i + 1;
j <=
N;
j++)
5814 const poly
p =
p_NSet(n, dest);
5876 Werror(
"n_IsParam: IsParam is not to be used for (coeff_type = %d)",
getCoeffType(C));
5885 WerrorS(
"only for rings with an ordering of one block");
5902 WerrorS(
"ordering must be dp,Dp,lp,rp,ds,Ds or ls");
5905 for(
int i=r->N-1;
i>=0;
i--)
5907 if (strcmp(r->names[
i],
v)==0)
5909 Werror(
"duplicate variable name >>%s<<",
v);
5915 #ifdef HAVE_SHIFTBBA
5918 R->isLPring=r->isLPring+1;
5919 R->N=((r->N)/r->isLPring)+r->N;
5923 for(
int b=0;
b<((r->N)/r->isLPring);
b++)
5926 for(
int i=
R->isLPring-1;
i>0;
i--)
5927 names[
i+
b*
R->isLPring]=
R->names[
i-1+
b*r->isLPring];
5932 for(
int b=0;
b<((r->N)/r->isLPring);
b++)
5935 for(
int i=
R->isLPring-2;
i>=0;
i--)
5936 names[
i+
b*
R->isLPring]=
R->names[
i+
b*r->isLPring];
5948 for(
int i=
R->N-1;
i>0;
i--) names[
i]=
R->names[
i-1];
5953 for(
int i=
R->N-2;
i>=0;
i--) names[
i]=
R->names[
i];
5967 WerrorS(
"only for rings with an ordering of one block");
5984 WerrorS(
"ordering must be dp,Dp,lp,rp,ds,Ds or ls");
5991 if (strcmp(
R->names[
i],
v)==0)
5995 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)
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)
union sro_ord::@006200034235045362245112336324125006204215012002 data
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,