40#define BITS_PER_LONG 8*SIZEOF_LONG
110 r->names = (
char **)
omAlloc0(
N *
sizeof(
char *));
118 r->wvhdl = (
int **)
omAlloc0((ord_size+1) *
sizeof(
int *));
124 if (bitmask!=0) r->wanted_maxExp=bitmask;
136 return rDefault(
cf,
N,n,ord_size,ord,block0,block1,wvhdl);
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");
188 int sz = (int)
sqrt((
double)(order->
length()-2));
189 if ((sz*sz)!=(order->
length()-2))
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: ");
260 R->ShortOut = bSaveShortOut;
303 Print(
"// number of vars : %d",r->N);
308 for (
int l=0, nlen=0 ;
l<nblocks;
l++)
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++)
341 nlen = strlen(r->names[
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++)
378 Print(
" %*d" ,nlen,r->wvhdl[
l][
i+
j]);
384 int m=r->wvhdl[
l][
i];
385 Print(
"\n// : %d module weights ",
m);
387 for(;
i<=
m;
i++)
Print(
" %*d" ,nlen,r->wvhdl[
l][
i]);
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++)
516 if (order==0)
Werror(
"wrong ring order `%s`",ordername);
526 for (nblocks=0; r->order[nblocks]; nblocks++);
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++)
632 l+=strlen(r->names[
i])+1;
636 for (
i=0;
i<r->N-1;
i++)
638 strcat(
s,r->names[
i]);
641 strcat(
s,r->names[
i]);
653 char const *
const *
const params =
rParameter(r);
660 l+=strlen(params[
i])+1;
666 strcat(
s, params[
i]);
669 strcat(
s, params[
i]);
680 char *
res=(
char *)
omAlloc(strlen(ch)+strlen(var)+strlen(ord)+9);
681 sprintf(
res,
"(%s),(%s),(%s)",ch,var,ord);
713int rChar(ring r) {
return r->cf->ch; }
728 for(
int i=1;
i<r->N;
i++)
729 for(
int j=
i+1;
j<=r->N;
j++)
733 WarnS(
"Error initializing multiplication!");
753 memset(&tmpR,0,
sizeof(tmpR));
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')
908 if (strcmp(r1->names[
j],r2->names[
i])==0)
977 if ((r2->block0[0]==1)
978 && (r2->block1[0]==
rVar(r2))
984 tmpR.
order[1]=r2->order[0];
985 if (r2->wvhdl[0]!=
NULL)
990 int l=r2->block1[0]-r2->block0[0]+1;
995 l+=r2->wvhdl[1][r2->block1[0]-r2->block0[0]+1]+1;
998 memcpy(tmpR.
wvhdl[1],r2->wvhdl[0],
l*
sizeof(
int));
1065 if (rb->wvhdl[
i]!=
NULL)
1066 WarnS(
"rSum: weights not implemented");
1072 for (
i=0;r1->order[
i]!=0;
i++)
1077 if (r1->wvhdl[
i]!=
NULL)
1082 int l=r1->block1[
i]-r1->block0[
i]+1;
1087 l+=r1->wvhdl[
i][r1->block1[
i]-r1->block0[
i]+1]+1;
1090 memcpy(tmpR.
wvhdl[
i],r1->wvhdl[
i],
l*
sizeof(
int));
1102 for (
i=0;r2->order[
i]!=0;
i++)
1110 if (r2->wvhdl[
i]!=
NULL)
1116 int l=r2->block1[
i]-r2->block0[
i]+1;
1121 l+=r2->wvhdl[
i][r2->block1[
i]-r2->block0[
i]+1]+1;
1124 memcpy(tmpR.
wvhdl[
j],r2->wvhdl[
i],
l*
sizeof(
int));
1131 if((r1->OrdSgn==-1)||(r2->OrdSgn==-1))
1151 if (r1->wvhdl[
i]!=
NULL)
1157 int l=r1->block1[
i]-r1->block0[
i]+1;
1162 l+=r1->wvhdl[
i][r1->block1[
i]-r1->block0[
i]+1]+1;
1165 memcpy(tmpR.
wvhdl[
i],r1->wvhdl[
i],
l*
sizeof(
int));
1176 Werror(
"variables must not overlap (# of vars: %d,%d -> %d)",
rVar(r1),
rVar(r2),
k);
1182 memcpy(sum,&tmpR,
sizeof(
ip_sring));
1199 if ( (R1_is_nc) || (R2_is_nc))
1223 int *perm1 = (
int *)
omAlloc0((
rVar(R1)+1)*
sizeof(int));
1224 int *par_perm1 =
NULL;
1227 int *perm2 = (
int *)
omAlloc0((
rVar(R2)+1)*
sizeof(int));
1228 int *par_perm2 =
NULL;
1233 perm1, par_perm1, sum->cf->type);
1237 perm2, par_perm2, sum->cf->type);
1240 matrix C1 = R1->GetNC()->C, C2 = R2->GetNC()->C;
1241 matrix D1 = R1->GetNC()->D, D2 = R2->GetNC()->D;
1250 for (
i = 1;
i <=
rVar(R1);
i++)
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);
1322 if (r1->qideal!=
NULL)
1333 int *perm1 = (
int *)
omAlloc0((
rVar(r1)+1)*
sizeof(int));
1334 int *par_perm1 =
NULL;
1338 perm1, par_perm1, sum->cf->type);
1342 for (
int for_i=0;for_i<
IDELEMS(r1->qideal);for_i++)
1344 r1->qideal->m[for_i], perm1,
1347 par_perm1,
rPar(r1));
1352 if (r2->qideal!=
NULL)
1356 int *perm2 = (
int *)
omAlloc0((
rVar(r2)+1)*
sizeof(int));
1357 int *par_perm2 =
NULL;
1361 perm2, par_perm2, sum->cf->type);
1365 for (
int for_i=0;for_i<
IDELEMS(r2->qideal);for_i++)
1367 r2->qideal->m[for_i], perm2,
1370 par_perm2,
rPar(r2));
1402int rSum(ring r1, ring r2, ring &sum)
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;
1494 if (copy_ordering ==
TRUE)
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;
1519 memcpy(
res->wvhdl[
j],r->wvhdl[
j],
l*
sizeof(
int));
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;
1640 if (copy_ordering ==
TRUE)
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;
1663 memcpy(
res->wvhdl[
j+1],r->wvhdl[
j],
l*
sizeof(
int));
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)");
1748 if (r1 == r2)
return TRUE;
1750 if (r1->cf!=r2->cf)
return FALSE;
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;
1765 if ((r1->names[
i] !=
NULL) && (r2->names[
i] !=
NULL))
1767 if (strcmp(r1->names[
i], r2->names[
i]))
return FALSE;
1769 else if ((r1->names[
i] !=
NULL) ^ (r2->names[
i] !=
NULL))
1777 if (r1->qideal !=
NULL)
1779 ideal id1 = r1->qideal, id2 = r2->qideal;
1793 else if (r2->qideal !=
NULL)
return FALSE;
1803 if (r1 == r2)
return TRUE;
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]))
1820 if (r1->wvhdl[
i] !=
NULL)
1822 if (r2->wvhdl[
i] ==
NULL)
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;
1892 if (blocks == 1)
return TRUE;
1901 if ((blocks -
s) > 2)
return FALSE;
1967 if (blocks == 1)
return TRUE;
1976 if ((blocks -
s) > 3)
return FALSE;
1979 if ((blocks -
s) == 3)
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;
2114 assume( p < r->OrdSize );
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)))
2159 dReportError(
"varoffset out of range for var %d: %d",
i,tmp);
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);
2208static void rO_TDegree(
int &place,
int &bitplace,
int start,
int end,
2214 ord_struct.
data.dp.start=start;
2215 ord_struct.
data.dp.end=end;
2216 ord_struct.
data.dp.place=place;
2228 ord_struct.
data.dp.start=start;
2229 ord_struct.
data.dp.end=end;
2230 ord_struct.
data.dp.place=place;
2236static void rO_WDegree(
int &place,
int &bitplace,
int start,
int end,
2237 long *o,
sro_ord &ord_struct,
int *weights)
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)
2254 rO_TDegree(place,bitplace,start,end,o,ord_struct);
2259 ord_struct.
data.wp.start=start;
2260 ord_struct.
data.wp.end=end;
2261 ord_struct.
data.wp.place=place;
2262 ord_struct.
data.wp.weights=weights;
2266 for(
i=start;
i<=end;
i++)
2268 if(weights[
i-start]<0)
2277 long *o,
sro_ord &ord_struct,
int *weights)
2286 ord_struct.
data.am.start=start;
2287 ord_struct.
data.am.end=end;
2288 ord_struct.
data.am.place=place;
2289 ord_struct.
data.am.weights=weights;
2290 ord_struct.
data.am.weights_m = weights + (end-start+1);
2291 ord_struct.
data.am.len_gen=weights[end-start+1];
2292 assume( ord_struct.
data.am.weights_m[0] == ord_struct.
data.am.len_gen );
2305 ord_struct.
data.wp64.start=start;
2306 ord_struct.
data.wp64.end=end;
2307 ord_struct.
data.wp64.place=place;
2309 ord_struct.
data.wp64.weights64=weights;
2313 for(
int i=0;
i<
l;
i++) ord_struct.
data.wp64.weights64[
i]=weights[
i];
2323 long *o,
sro_ord &ord_struct,
int *weights)
2326 while((start<end) && (weights[0]==0)) { start++; weights++; }
2327 while((start<end) && (weights[end-start]==0)) { end--; }
2330 ord_struct.
data.wp.start=start;
2331 ord_struct.
data.wp.end=end;
2332 ord_struct.
data.wp.place=place;
2333 ord_struct.
data.wp.weights=weights;
2338 for(
i=start;
i<=end;
i++)
2340 if(weights[
i-start]<0)
2348static void rO_LexVars(
int &place,
int &bitplace,
int start,
int end,
2349 int &prev_ord,
long *o,
int *
v,
int bits,
int opt_var)
2354 if(prev_ord==-1)
rO_Align(place,bitplace);
2360 for(
k=start;;
k+=incr)
2365 v[
k]= place | (bitplace << 24);
2371 assume((opt_var == end+1) ||(opt_var == end-1));
2372 if((opt_var != end+1) &&(opt_var != end-1))
WarnS(
"hier-2");
2373 int save_bitplace=bitplace;
2377 bitplace=save_bitplace;
2381 v[opt_var]=place | (bitplace << 24);
2386 int &prev_ord,
long *o,
int *
v,
int bits,
int opt_var)
2391 if(prev_ord==1)
rO_Align(place,bitplace);
2397 for(
k=start;;
k+=incr)
2402 v[
k]=place | (bitplace << 24);
2409 assume((opt_var == end+1) ||(opt_var == end-1));
2410 if((opt_var != end+1) &&(opt_var != end-1))
WarnS(
"hier-1");
2411 int save_bitplace=bitplace;
2415 bitplace=save_bitplace;
2419 v[opt_var]=place | (bitplace << 24);
2430 ord_struct.
data.syzcomp.place=place;
2431 ord_struct.
data.syzcomp.Components=
NULL;
2432 ord_struct.
data.syzcomp.ShiftedComponents=
NULL;
2439static void rO_Syz(
int &place,
int &bitplace,
int &prev_ord,
2440 int syz_comp,
long *o,
sro_ord &ord_struct)
2447 ord_struct.
data.syz.place=place;
2448 ord_struct.
data.syz.limit=syz_comp;
2450 ord_struct.
data.syz.syz_index = (
int*)
omAlloc0((syz_comp+1)*
sizeof(int));
2452 ord_struct.
data.syz.syz_index =
NULL;
2453 ord_struct.
data.syz.curr_index = 1;
2466 long *o,
int N,
int *
v,
sro_ord &ord_struct)
2473 ord_struct.
data.isTemp.start = place;
2477 ord_struct.
data.isTemp.pVarOffset = (
int *)
omAlloc((
N+1)*
sizeof(int));
2478 memcpy(ord_struct.
data.isTemp.pVarOffset,
v,(
N+1)*
sizeof(
int));
2480 ord_struct.
data.isTemp.suffixpos = -1;
2488static void rO_ISSuffix(
int &place,
int &bitplace,
int &prev_ord,
long *o,
2493 int typ_j = typ_i - 1;
2496 if( tmp_typ[typ_j].ord_typ ==
ro_isTemp)
2509 const int start = tmp_typ[typ_j].
data.isTemp.start;
2510 int *pVarOffset = tmp_typ[typ_j].
data.isTemp.pVarOffset;
2521 tmp_typ[typ_j].
data.isTemp.suffixpos = typ_i;
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;
2544 sro_ord &ord_struct = tmp_typ[typ_j];
2548 ord_struct.
data.is.start = start;
2549 ord_struct.
data.is.end = place;
2550 ord_struct.
data.is.pVarOffset = pVarOffset;
2572 v[0] = place | (bitplace << 24);
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;
2684 unsigned long bitmask1 =
rGetExpSize(bitmask+1, bits1);
2686 if ((((
N+vars_per_long-1)/vars_per_long) ==
2687 ((
N+vars_per_long1-1)/vars_per_long1)))
2689 vars_per_long=vars_per_long1;
2709 unsigned long exp_limit)
2717 BOOLEAN need_other_ring = (exp_limit != r->bitmask);
2719 int iNeedInducedOrderingSetup = 0;
2723 int *block0=(
int*)
omAlloc0((nblocks+1)*
sizeof(int));
2724 int *block1=(
int*)
omAlloc0((nblocks+1)*
sizeof(int));
2725 int **wvhdl=(
int**)
omAlloc0((nblocks+1)*
sizeof(
int *));
2734 if (r->block0[
i]==r->block1[
i])
2759 Warn(
"Error: unhandled ordering in rModifyRing: ringorder_S = [%d]", r_ord);
2773 need_other_ring=
TRUE;
2774 try_omit_comp=
FALSE;
2775 copy_block_index=
FALSE;
2789 need_other_ring=
TRUE;
2791 omitted_degree =
TRUE;
2805 need_other_ring=
TRUE;
2807 omitted_degree =
TRUE;
2815 try_omit_comp =
FALSE;
2818 iNeedInducedOrderingSetup++;
2827 try_omit_comp =
FALSE;
2836 if (copy_block_index)
2838 block0[
j]=r->block0[
i];
2839 block1[
j]=r->block1[
i];
2840 wvhdl[
j]=r->wvhdl[
i];
2845 if(!need_other_ring)
2865 res->bitmask=exp_limit;
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));
2903 if( iNeedInducedOrderingSetup > 0 )
2905 for(
j = 0,
i = 0; (
i < nblocks) && (iNeedInducedOrderingSetup > 0);
i++)
2912 r->typ[
i].data.is.limit,
2917 iNeedInducedOrderingSetup--;
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");
3014 int nblocks=1+(ommit_comp!=0);
3016 int *block0=(
int*)
omAlloc0((nblocks+1)*
sizeof(int));
3017 int *block1=(
int*)
omAlloc0((nblocks+1)*
sizeof(int));
3018 int **wvhdl=(
int**)
omAlloc0((nblocks+1)*
sizeof(
int *));
3037 res->bitmask=exp_limit;
3038 res->wanted_maxExp=r->wanted_maxExp;
3049 WarnS(
"error in nc_rComplete");
3065 return rModifyRing(r, ommit_degree, ommit_comp, exp_limit);
3093 r->CanShortOut=
FALSE;
3096 r->CanShortOut =
TRUE;
3104 r->CanShortOut=
FALSE;
3112 for (
i=(
N-1);
i>=0;
i--)
3114 if(r->names[
i] !=
NULL && strlen(r->names[
i])>1)
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);}
3461 if (r->VarOffset!=
NULL && force == 0)
return FALSE;
3466 r->bitmask=
rGetExpSize(r->wanted_maxExp,bits,r->N);
3467 r->BitsPerExp = bits;
3472 long *tmp_ordsgn=(
long *)
omAlloc0(3*(n+r->N)*
sizeof(long));
3474 int *
v=(
int *)
omAlloc((r->N+1)*
sizeof(int));
3475 for(
i=r->N;
i>=0 ;
i--)
3492 switch (r->order[
i])
3496 rO_WDegree(
j,j_bits,r->block0[
i],r->block1[
i],tmp_ordsgn,tmp_typ[typ_i],
3502 rO_WMDegree(
j,j_bits,r->block0[
i],r->block1[
i],tmp_ordsgn,tmp_typ[typ_i],
3509 tmp_typ[typ_i], (
int64 *)(r->wvhdl[
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);
3540 rO_LexVars(
j, j_bits, r->block0[
i],r->block1[
i], prev_ordsgn,
3541 tmp_ordsgn,
v,bits, -1);
3546 tmp_ordsgn,
v, bits, -1);
3551 tmp_ordsgn,
v, bits, -1);
3555 rO_LexVars(
j, j_bits, r->block1[
i],r->block0[
i], prev_ordsgn,
3556 tmp_ordsgn,
v, bits, -1);
3560 if (r->block0[
i]==r->block1[
i])
3562 rO_LexVars(
j, j_bits, r->block0[
i],r->block0[
i], prev_ordsgn,
3563 tmp_ordsgn,
v, bits, -1);
3571 prev_ordsgn,tmp_ordsgn,
v,bits, r->block0[
i]);
3576 if (r->block0[
i]==r->block1[
i])
3578 rO_LexVars(
j, j_bits, r->block0[
i],r->block0[
i], prev_ordsgn,
3579 tmp_ordsgn,
v, bits, -1);
3586 rO_LexVars(
j, j_bits, r->block0[
i],r->block1[
i]-1, prev_ordsgn,
3587 tmp_ordsgn,
v, bits, r->block1[
i]);
3592 if (r->block0[
i]==r->block1[
i])
3595 tmp_ordsgn,
v,bits, -1);
3603 prev_ordsgn,tmp_ordsgn,
v,bits, r->block0[
i]);
3608 if (r->block0[
i]==r->block1[
i])
3611 tmp_ordsgn,
v, bits, -1);
3618 rO_LexVars(
j, j_bits, r->block0[
i],r->block1[
i]-1, prev_ordsgn,
3619 tmp_ordsgn,
v, bits, r->block1[
i]);
3625 tmp_typ[typ_i], r->wvhdl[
i]);
3630 for(jj=r->block1[
i]-r->block0[
i];jj>=0; jj--)
3632 if (r->wvhdl[
i][jj]<=0) have_bad_weights=
TRUE;
3634 if (have_bad_weights)
3641 if (r->block1[
i]!=r->block0[
i])
3644 tmp_ordsgn,
v,bits, r->block0[
i]);
3650 tmp_typ[typ_i], r->wvhdl[
i]);
3655 for(jj=r->block1[
i]-r->block0[
i];jj>=0; jj--)
3657 if (r->wvhdl[
i][jj]<=0) have_bad_weights=
TRUE;
3659 if (have_bad_weights)
3666 if (r->block1[
i]!=r->block0[
i])
3668 rO_LexVars(
j, j_bits,r->block0[
i],r->block1[
i]-1, prev_ordsgn,
3669 tmp_ordsgn,
v, bits, r->block1[
i]);
3675 tmp_typ[typ_i], r->wvhdl[
i]);
3677 if (r->block1[
i]!=r->block0[
i])
3680 tmp_ordsgn,
v,bits, r->block0[
i]);
3686 tmp_typ[typ_i], r->wvhdl[
i]);
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]);
3698 rO_Syzcomp(
j, j_bits,prev_ordsgn, tmp_ordsgn,tmp_typ[typ_i]);
3699 need_to_add_comp=
TRUE;
3700 r->ComponentOrder=-1;
3706 rO_Syz(
j, j_bits, prev_ordsgn, r->block0[
i], tmp_ordsgn, tmp_typ[typ_i]);
3707 need_to_add_comp=
TRUE;
3708 r->ComponentOrder=-1;
3715 assume( r->block0[
i] == r->block1[
i] );
3716 const int s = r->block0[
i];
3720 rO_ISPrefix(
j, j_bits, prev_ordsgn, tmp_ordsgn, r->N,
v, tmp_typ[typ_i++]);
3723 rO_ISSuffix(
j, j_bits, prev_ordsgn, tmp_ordsgn, r->N,
v, tmp_typ, typ_i,
s);
3724 need_to_add_comp=
FALSE;
3743 j_bits=j_bits0;
j=j0;
3748 if((need_to_add_comp) && (
v[0]== -1))
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++)
3793 r->ordsgn[
j] = tmp_ordsgn[
j];
3802 if (typ_i==0) r->typ=
NULL;
3806 memcpy(r->typ,tmp_typ,typ_i*
sizeof(
sro_ord));
3816 r->pCompIndex=(r->VarOffset[0] & 0xffff);
3819 if (
i==r->pCompIndex)
i++;
3820 while ((j < r->OrdSize)
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;
4038 int min = INT_MAX, min_j = -1;
4039 int* VarL_Number = (
int*)
omAlloc0(r->ExpL_Size*
sizeof(
int));
4044 for (
i=1;
i<=r->N;
i++)
4046 VarL_Number[r->VarOffset[
i] & 0xffffff]++;
4050 for (
i=0,
j=0;
i<r->ExpL_Size;
i++)
4052 if (VarL_Number[
i] != 0)
4054 if (
min > VarL_Number[
i])
4056 min = VarL_Number[
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++)
4071 if (VarL_Number[
i] != 0)
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;
4093 int* shifts = (
int*)
omAlloc(r->ExpL_Size*
sizeof(
int));
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];
4224 for(
int lll=
l+1;lll<
l+ll+1;lll++)
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++)
4259 if (j< r->CmpL_Size)
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]);
4302 Print(
"p_Spec : %s, %s, %s\n", field,
length, ord);
4304 for (
i=0;
i<(int) (
sizeof(
p_Procs_s)/
sizeof(
void*));
i++)
4306 Print(
" %s,\n", ((
char**) &proc_names)[
i]);
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++)
4381 r->typ[1].data.syzcomp.Components = currComponents;
4389 *currComponents = r->typ[1].data.syzcomp.Components;
4399 r->typ[1].data.syzcomp.length =
length;
4409 *
length = r->typ[1].data.syzcomp.length;
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;
4583 memcpy(
res->typ,r->typ,r->OrdSize*
sizeof(
sro_ord));
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)
4651 new_r->wvhdl=(
int **)
omAlloc0(
i *
sizeof(
int *));
4653 new_r->block0 = (
int *)
omAlloc0(
i *
sizeof(
int));
4654 new_r->block1 = (
int *)
omAlloc0(
i *
sizeof(
int));
4656 memcpy(new_r->block0,r->block0,(
i-1) *
sizeof(
int));
4657 memcpy(new_r->block1,r->block1,(
i-1) *
sizeof(
int));
4658 for (
int j=0;
j<=last_block;
j++)
4660 if (r->wvhdl[
j]!=
NULL)
4663 new_r->wvhdl[
j] = (
int*)
omMemDup(r->wvhdl[
j]);
4666 int l=r->block1[
j]-r->block0[
j]+1;
4671 l+=r->wvhdl[
j][r->block1[
j]-r->block0[
j]+1]+1;
4673 new_r->wvhdl[
j]=(
int*)
omalloc(
l*
sizeof(
int));
4674 memcpy(new_r->wvhdl[
j],r->wvhdl[
j],
l*
sizeof(
int));
4693 WarnS(
"error in nc_rComplete");
4705 int last_block =
rBlocks(r) - 2;
4712 for (
i=0;
i< last_block;
i++)
4723 for (
i=c_pos+1;
i<=last_block;
i++)
4725 new_r->order[
i-1] = new_r->order[
i];
4726 new_r->block0[
i-1] = new_r->block0[
i];
4727 new_r->block1[
i-1] = new_r->block1[
i];
4728 new_r->wvhdl[
i-1] = new_r->wvhdl[
i];
4730 new_r->order[last_block] = r->order[c_pos];
4731 new_r->block0[last_block] = r->block0[c_pos];
4732 new_r->block1[last_block] = r->block1[c_pos];
4733 new_r->wvhdl[last_block] = r->wvhdl[c_pos];
4744 WarnS(
"error in nc_rComplete");
4769 if (new_r_1 != new_r && new_r_1 != old_r)
rDelete(new_r_1);
4778 WarnS(
"error in nc_rComplete");
4785 if (old_r->qideal !=
NULL)
4787 new_r->qideal =
idrCopyR(old_r->qideal, old_r, new_r);
4795 WarnS(
"error in nc_SetupQuotient");
4820 if ((r_blocks == 3) &&
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");
4863 if ((r_blocks == 3) &&
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);
5117 const ideal FF =
idrHeadR(F, r, r);
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)
5224 assume(i <= r->typ[0].data.syz.limit);
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];
5315static int rReallocM1(ring r,
int size,
int pos)
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)
5364 int i2 = (
rVar(r)-1)/2;
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];
5391 if(isupper(*
p)) *
p = tolower(*
p);
5392 else *
p = toupper(*
p);
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]);
5658 int *par_perm =
NULL;
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);
5738 int stat =
rSum(
R, Ropp, Renv);
5740 WarnS(
"Error in rEnvelope at rSum");
5763 const int N = dest->N;
5772 const ring srcBase = src;
5779 matrix C0 = src->GetNC()->C;
5780 matrix D0 = src->GetNC()->D;
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--)
5881 if (strcmp(r->names[
i],
v)==0)
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");
5965 if (strcmp(
R->names[
i],
v)==0)
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
for(int i=0;i<=n;i++) degsf[i]
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)
if(!FE_OPT_NO_SHELL_FLAG)(void) system(sys)
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,