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)
357 Warn(
"should not have wvhdl entry at pos. %d",
l);
361 j<(r->block1[
l]-r->block0[
l]+1)*(r->block1[
l]-r->block0[
l]+1);
364 PrintS(
"\n// : weights ");
365 for (
i = 0;
i<=r->block1[
l]-r->block0[
l];
i++)
377 Print(
" %*d" ,nlen,r->wvhdl[
l][
i+
j]);
383 int m=r->wvhdl[
l][
i];
384 Print(
"\n// : %d module weights ",
m);
386 for(;
i<=
m;
i++)
Print(
" %*d" ,nlen,r->wvhdl[
l][
i]);
393 PrintS(
"\n// noncommutative relations:");
399 for (
i = 1;
i<r->N;
i++)
401 for (
j =
i+1;
j<=r->N;
j++)
406 Print(
"\n// %s%s=",r->names[
j-1],r->names[
i-1]);
417 Print(
"\n// is skew constant:%d",r->GetNC()->IsSkewConstant);
422 PrintS(
"\n// quotient of sca by ideal");
435 Print(
"\n// letterplace ring (block size %d, ncgen count %d)",r->isLPring, r->LPncGenCount);
440 PrintS(
"\n// quotient ring from ideal");
453 if (r ==
NULL)
return;
457 if( r->qideal !=
NULL )
472 if (r->order !=
NULL)
483 if (r->wvhdl[
j]!=
NULL)
496 for (
i=0;
i<r->N;
i++)
515 if (order==0)
Werror(
"wrong ring order `%s`",ordername);
525 for (nblocks=0; r->order[nblocks]; nblocks++);
544 if (r->wvhdl[
l]!=
NULL)
555 Warn(
"should not have wvhdl entry at pos. %d",
l);
563 j<(r->block1[
l]-r->block0[
l]+1)*(r->block1[
l]-r->block0[
l]+1);
570 for (
i = 0;
i<r->block1[
l]-r->block0[
l];
i++)
579 for (
i = 0;
i<r->block1[
l]-r->block0[
l];
i++)
589 if (
j+
i+1==(r->block1[
l]-r->block0[
l]+1)*(r->block1[
l]-r->block0[
l]+1))
600 assume( r->block0[
l] == r->block1[
l] );
601 const int s = r->block0[
l];
609 if (r->wanted_maxExp!=0)
611 long mm=r->wanted_maxExp;
628 for (
i=0;
i<r->N;
i++)
630 l+=strlen(r->names[
i])+1;
634 for (
i=0;
i<r->N-1;
i++)
636 strcat(
s,r->names[
i]);
639 strcat(
s,r->names[
i]);
651 char const *
const *
const params =
rParameter(r);
658 l+=strlen(params[
i])+1;
664 strcat(
s, params[
i]);
667 strcat(
s, params[
i]);
678 char *
res=(
char *)
omAlloc(strlen(ch)+strlen(var)+strlen(ord)+9);
679 sprintf(
res,
"(%s),(%s),(%s)",ch,var,ord);
711int rChar(ring r) {
return r->cf->ch; }
726 for(
int i=1;
i<r->N;
i++)
727 for(
int j=
i+1;
j<=r->N;
j++)
731 WarnS(
"Error initializing multiplication!");
751 memset(&tmpR,0,
sizeof(tmpR));
786 && (mpz_cmp(r1->cf->modNumber,r2->cf->extRing->cf->modNumber)==0))
819 if (r1->cf->extRing->cf==r2->cf)
829 WerrorS (
"coeff sum of two extension fields not implemented");
835 WerrorS(
"coeff sum not yet implemented");
842 char **names=(
char **)
omAlloc0(
l*
sizeof(
char *));
847 for (
i=0;
i<r1->N;
i++)
851 if (*(r1->names[
i]) ==
'\0')
883 if (*(r2->names[
i]) ==
'\0')
906 if (strcmp(r1->names[
j],r2->names[
i])==0)
975 if ((r2->block0[0]==1)
976 && (r2->block1[0]==
rVar(r2))
982 tmpR.
order[1]=r2->order[0];
983 if (r2->wvhdl[0]!=
NULL)
1049 if (rb->wvhdl[
i]!=
NULL)
1050 WarnS(
"rSum: weights not implemented");
1056 for (
i=0;r1->order[
i]!=0;
i++)
1061 if (r1->wvhdl[
i]!=
NULL)
1072 for (
i=0;r2->order[
i]!=0;
i++)
1080 if (r2->wvhdl[
i]!=
NULL)
1087 if((r1->OrdSgn==-1)||(r2->OrdSgn==-1))
1107 if (r1->wvhdl[
i]!=
NULL)
1118 Werror(
"variables must not overlap (# of vars: %d,%d -> %d)",
rVar(r1),
rVar(r2),
k);
1124 memcpy(sum,&tmpR,
sizeof(
ip_sring));
1141 if ( (R1_is_nc) || (R2_is_nc))
1165 int *perm1 = (
int *)
omAlloc0((
rVar(R1)+1)*
sizeof(int));
1166 int *par_perm1 =
NULL;
1169 int *perm2 = (
int *)
omAlloc0((
rVar(R2)+1)*
sizeof(int));
1170 int *par_perm2 =
NULL;
1175 perm1, par_perm1, sum->cf->type);
1179 perm2, par_perm2, sum->cf->type);
1182 matrix C1 = R1->GetNC()->C, C2 = R2->GetNC()->C;
1183 matrix D1 = R1->GetNC()->D, D2 = R2->GetNC()->D;
1192 for (
i = 1;
i <=
rVar(R1);
i++)
1205 MATELEM(C,
i,
j) =
p_PermPoly(
MATELEM(C1,
i,
j), perm1, R1, sum, nMap1, par_perm1,
rPar(R1));
1208 MATELEM(
D,
i,
j) =
p_PermPoly(
MATELEM(D1,
i,
j), perm1, R1, sum, nMap1, par_perm1,
rPar(R1));
1221 MATELEM(C,
rVar(R1)+
i,
rVar(R1)+
j) =
p_PermPoly(
MATELEM(C2,
i,
j),perm2,R2,sum, nMap2,par_perm2,
rPar(R2));
1224 MATELEM(
D,
rVar(R1)+
i,
rVar(R1)+
j) =
p_PermPoly(
MATELEM(D2,
i,
j),perm2,R2,sum, nMap2,par_perm2,
rPar(R2));
1232 WarnS(
"Error initializing non-commutative multiplication!");
1241 Print(
"\nRefs: R1: %d, R2: %d\n", R1->GetNC()->ref, R2->GetNC()->ref);
1264 if (r1->qideal!=
NULL)
1275 int *perm1 = (
int *)
omAlloc0((
rVar(r1)+1)*
sizeof(int));
1276 int *par_perm1 =
NULL;
1280 perm1, par_perm1, sum->cf->type);
1284 for (
int for_i=0;for_i<
IDELEMS(r1->qideal);for_i++)
1286 r1->qideal->m[for_i], perm1,
1289 par_perm1,
rPar(r1));
1294 if (r2->qideal!=
NULL)
1298 int *perm2 = (
int *)
omAlloc0((
rVar(r2)+1)*
sizeof(int));
1299 int *par_perm2 =
NULL;
1303 perm2, par_perm2, sum->cf->type);
1307 for (
int for_i=0;for_i<
IDELEMS(r2->qideal);for_i++)
1309 r2->qideal->m[for_i], perm2,
1312 par_perm2,
rPar(r2));
1344int rSum(ring r1, ring r2, ring &sum)
1370 res->options=r->options;
1385 res->firstBlockEnds=r->firstBlockEnds;
1387 res->real_var_start=r->real_var_start;
1388 res->real_var_end=r->real_var_end;
1392 res->isLPring=r->isLPring;
1393 res->LPncGenCount=r->LPncGenCount;
1396 res->VectorOut=r->VectorOut;
1397 res->ShortOut=r->ShortOut;
1398 res->CanShortOut=r->CanShortOut;
1414 res->bitmask=r->bitmask;
1415 res->divmask=r->divmask;
1416 res->BitsPerExp = r->BitsPerExp;
1417 res->ExpPerLong = r->ExpPerLong;
1436 if (copy_ordering ==
TRUE)
1438 res->LexOrder=r->LexOrder;
1439 res->MixedOrder=r->MixedOrder;
1447 if (r->wvhdl[
j]!=
NULL)
1455 memcpy(
res->block0,r->block0,
i *
sizeof(
int));
1456 memcpy(
res->block1,r->block1,
i *
sizeof(
int));
1471 if (r->qideal!=
NULL)
1500 res->options=r->options;
1515 res->firstBlockEnds=r->firstBlockEnds;
1517 res->real_var_start=r->real_var_start;
1518 res->real_var_end=r->real_var_end;
1522 res->isLPring=r->isLPring;
1523 res->LPncGenCount=r->LPncGenCount;
1526 res->VectorOut=r->VectorOut;
1527 res->ShortOut=r->ShortOut;
1528 res->CanShortOut=r->CanShortOut;
1529 res->LexOrder=r->LexOrder;
1530 res->MixedOrder=r->MixedOrder;
1546 res->bitmask=r->bitmask;
1547 res->divmask=r->divmask;
1548 res->BitsPerExp = r->BitsPerExp;
1549 res->ExpPerLong = r->ExpPerLong;
1568 if (copy_ordering ==
TRUE)
1575 for (
j=0;
j<
i-1;
j++)
1577 if (r->wvhdl[
j]!=
NULL)
1585 memcpy(&(
res->block0[1]),r->block0,(
i-1) *
sizeof(
int));
1586 memcpy(&(
res->block1[1]),r->block1,(
i-1) *
sizeof(
int));
1604 res->wvhdl[0]=(
int *)
A;
1614 if (r->qideal!=
NULL)
1620 WerrorS(
"internal error: rCopy0(Q,TRUE,FALSE)");
1625 WarnS(
"internal bad stuff: rCopy0(Q,TRUE,TRUE)");
1662 if (r1 == r2)
return TRUE;
1664 if (r1->cf!=r2->cf)
return FALSE;
1666 if (r1->bitmask!=r2->bitmask)
return FALSE;
1667 #ifdef HAVE_SHIFTBBA
1668 if (r1->isLPring!=r2->isLPring)
return FALSE;
1669 if (r1->LPncGenCount!=r2->LPncGenCount)
return FALSE;
1679 if ((r1->names[
i] !=
NULL) && (r2->names[
i] !=
NULL))
1681 if (strcmp(r1->names[
i], r2->names[
i]))
return FALSE;
1683 else if ((r1->names[
i] !=
NULL) ^ (r2->names[
i] !=
NULL))
1691 if (r1->qideal !=
NULL)
1693 ideal id1 = r1->qideal, id2 = r2->qideal;
1707 else if (r2->qideal !=
NULL)
return FALSE;
1717 if (r1 == r2)
return TRUE;
1721 if ((r1->cf != r2->cf)
1723 || (r1->OrdSgn != r2->OrdSgn))
1727 while (r1->order[
i] != 0)
1729 if (r2->order[
i] == 0)
return FALSE;
1730 if ((r1->order[
i] != r2->order[
i])
1731 || (r1->block0[
i] != r2->block0[
i])
1732 || (r1->block1[
i] != r2->block1[
i]))
1734 if (r1->wvhdl[
i] !=
NULL)
1736 if (r2->wvhdl[
i] ==
NULL)
1738 for (
j=0;
j<r1->block1[
i]-r1->block0[
i]+1;
j++)
1739 if (r2->wvhdl[
i][
j] != r1->wvhdl[
i][
j])
1745 if (r2->order[
i] != 0)
return FALSE;
1806 if (blocks == 1)
return TRUE;
1815 if ((blocks -
s) > 2)
return FALSE;
1881 if (blocks == 1)
return TRUE;
1890 if ((blocks -
s) > 3)
return FALSE;
1893 if ((blocks -
s) == 3)
1912 for (pos=0;pos<r->OrdSize;pos++)
1930 return (
rVar(r) > 1 &&
1936 ((r->order[1]!=0) &&
1944 return ((
rVar(r) > 1) &&
1953 while(r->order[
i]!=0)
1955 if((r->block0[
i]<=
v)
1956 && (r->block1[
i]>=
v))
1961 return (r->wvhdl[
i][
v-r->block0[
i]]>0);
2000 if (r->N == 0)
return TRUE;
2002 if ((r->OrdSgn!=1) && (r->OrdSgn!= -1))
2014 for(
int j=0;
j<=
i;
j++)
2017 dError(
"wrong order in r->order");
2028 if (r->VarOffset ==
NULL)
2030 dReportError(
"Null ring VarOffset -- no rComplete (?) in n %s:%d", fn,
l);
2035 if ((r->OrdSize==0)!=(r->typ==
NULL))
2037 dReportError(
"mismatch OrdSize and typ-pointer in %s:%d");
2043 for(
i=0;
i<=r->N;
i++)
2047 for(
j=0;
j<r->OrdSize;
j++)
2051 const int p = r->typ[
j].data.isTemp.suffixpos;
2056 assume( p < r->OrdSize );
2058 if(r->typ[
p].ord_typ !=
ro_is)
2059 dReportError(
"ordrec prefix %d is unmatched (suffix: %d is wrong!!!)",
j,
p);
2062 if(r->typ[
j].data.isTemp.pVarOffset[
i] != -1)
2068 else if (r->typ[
j].ord_typ ==
ro_is)
2071 if(r->typ[
j].data.is.pVarOffset[
i] != -1)
2079 if (r->typ[
j].ord_typ==
ro_cp)
2081 if(((
short)r->VarOffset[
i]) == r->typ[
j].data.cp.place)
2086 && (r->VarOffset[
i] == r->typ[
j].data.dp.place))
2092 tmp=r->VarOffset[
i] & 0xffffff;
2093 #if SIZEOF_LONG == 8
2094 if ((r->VarOffset[
i] >> 24) >63)
2096 if ((r->VarOffset[
i] >> 24) >31)
2098 dReportError(
"bit_start out of range:%d",r->VarOffset[
i] >> 24);
2099 if (
i > 0 && ((tmp<0) ||(tmp>r->ExpL_Size-1)))
2101 dReportError(
"varoffset out of range for var %d: %d",
i,tmp);
2106 for(
j=0;
j<r->OrdSize;
j++)
2108 if ((r->typ[
j].ord_typ==
ro_dp)
2109 || (r->typ[
j].ord_typ==
ro_wp)
2112 if (r->typ[
j].data.dp.start > r->typ[
j].data.dp.end)
2114 r->typ[
j].data.dp.start, r->typ[
j].data.dp.end);
2115 if ((r->typ[
j].data.dp.start < 1)
2116 || (r->typ[
j].data.dp.end > r->N))
2117 dReportError(
"in ordrec %d: start(%d)<1 or end(%d)>vars(%d)",
j,
2118 r->typ[
j].data.dp.start, r->typ[
j].data.dp.end,r->N);
2150static void rO_TDegree(
int &place,
int &bitplace,
int start,
int end,
2156 ord_struct.
data.dp.start=start;
2157 ord_struct.
data.dp.end=end;
2158 ord_struct.
data.dp.place=place;
2170 ord_struct.
data.dp.start=start;
2171 ord_struct.
data.dp.end=end;
2172 ord_struct.
data.dp.place=place;
2178static void rO_WDegree(
int &place,
int &bitplace,
int start,
int end,
2179 long *o,
sro_ord &ord_struct,
int *weights)
2182 while((start<end) && (weights[0]==0)) { start++; weights++; }
2183 while((start<end) && (weights[end-start]==0)) { end--; }
2186 for(
i=start;
i<=end;
i++)
2188 if(weights[
i-start]!=1)
2196 rO_TDegree(place,bitplace,start,end,o,ord_struct);
2201 ord_struct.
data.wp.start=start;
2202 ord_struct.
data.wp.end=end;
2203 ord_struct.
data.wp.place=place;
2204 ord_struct.
data.wp.weights=weights;
2208 for(
i=start;
i<=end;
i++)
2210 if(weights[
i-start]<0)
2219 long *o,
sro_ord &ord_struct,
int *weights)
2228 ord_struct.
data.am.start=start;
2229 ord_struct.
data.am.end=end;
2230 ord_struct.
data.am.place=place;
2231 ord_struct.
data.am.weights=weights;
2232 ord_struct.
data.am.weights_m = weights + (end-start+1);
2233 ord_struct.
data.am.len_gen=weights[end-start+1];
2234 assume( ord_struct.
data.am.weights_m[0] == ord_struct.
data.am.len_gen );
2247 ord_struct.
data.wp64.start=start;
2248 ord_struct.
data.wp64.end=end;
2249 ord_struct.
data.wp64.place=place;
2250 ord_struct.
data.wp64.weights64=weights;
2259 long *o,
sro_ord &ord_struct,
int *weights)
2262 while((start<end) && (weights[0]==0)) { start++; weights++; }
2263 while((start<end) && (weights[end-start]==0)) { end--; }
2266 ord_struct.
data.wp.start=start;
2267 ord_struct.
data.wp.end=end;
2268 ord_struct.
data.wp.place=place;
2269 ord_struct.
data.wp.weights=weights;
2274 for(
i=start;
i<=end;
i++)
2276 if(weights[
i-start]<0)
2284static void rO_LexVars(
int &place,
int &bitplace,
int start,
int end,
2285 int &prev_ord,
long *o,
int *
v,
int bits,
int opt_var)
2290 if(prev_ord==-1)
rO_Align(place,bitplace);
2296 for(
k=start;;
k+=incr)
2301 v[
k]= place | (bitplace << 24);
2307 assume((opt_var == end+1) ||(opt_var == end-1));
2308 if((opt_var != end+1) &&(opt_var != end-1))
WarnS(
"hier-2");
2309 int save_bitplace=bitplace;
2313 bitplace=save_bitplace;
2317 v[opt_var]=place | (bitplace << 24);
2322 int &prev_ord,
long *o,
int *
v,
int bits,
int opt_var)
2327 if(prev_ord==1)
rO_Align(place,bitplace);
2333 for(
k=start;;
k+=incr)
2338 v[
k]=place | (bitplace << 24);
2345 assume((opt_var == end+1) ||(opt_var == end-1));
2346 if((opt_var != end+1) &&(opt_var != end-1))
WarnS(
"hier-1");
2347 int save_bitplace=bitplace;
2351 bitplace=save_bitplace;
2355 v[opt_var]=place | (bitplace << 24);
2366 ord_struct.
data.syzcomp.place=place;
2367 ord_struct.
data.syzcomp.Components=
NULL;
2368 ord_struct.
data.syzcomp.ShiftedComponents=
NULL;
2375static void rO_Syz(
int &place,
int &bitplace,
int &prev_ord,
2376 int syz_comp,
long *o,
sro_ord &ord_struct)
2383 ord_struct.
data.syz.place=place;
2384 ord_struct.
data.syz.limit=syz_comp;
2386 ord_struct.
data.syz.syz_index = (
int*)
omAlloc0((syz_comp+1)*
sizeof(int));
2388 ord_struct.
data.syz.syz_index =
NULL;
2389 ord_struct.
data.syz.curr_index = 1;
2402 long *o,
int ,
int *
v,
sro_ord &ord_struct)
2409 ord_struct.
data.isTemp.start = place;
2411 ord_struct.
data.isTemp.suffixpos = -1;
2419static void rO_ISSuffix(
int &place,
int &bitplace,
int &prev_ord,
long *o,
2424 int typ_j = typ_i - 1;
2427 if( tmp_typ[typ_j].ord_typ ==
ro_isTemp)
2440 const int start = tmp_typ[typ_j].
data.isTemp.start;
2441 int *pVarOffset = tmp_typ[typ_j].
data.isTemp.pVarOffset;
2452 tmp_typ[typ_j].
data.isTemp.suffixpos = typ_i;
2459 for(
int i = 0;
i <=
N;
i++ )
2462 if(
v[
i] != pVarOffset[
i] )
2464 pVarOffset[
i] =
v[
i];
2466 assume( pVarOffset[
i] != -1 );
2472 if( pVarOffset[0] != -1 )
2473 pVarOffset[0] &= 0x0fff;
2475 sro_ord &ord_struct = tmp_typ[typ_j];
2479 ord_struct.
data.is.start = start;
2480 ord_struct.
data.is.end = place;
2481 ord_struct.
data.is.pVarOffset = pVarOffset;
2503 v[0] = place | (bitplace << 24);
2514 bits=16; bitmask=0xffff;
2516 else if (bitmask <= 1L)
2518 bits=1; bitmask = 1L;
2520 else if (bitmask <= 3L)
2522 bits=2; bitmask = 3L;
2524 else if (bitmask <= 7L)
2528 else if (bitmask <= 0xfL)
2530 bits=4; bitmask=0xfL;
2532 else if (bitmask <= 0x1fL)
2534 bits=5; bitmask=0x1fL;
2536 else if (bitmask <= 0x3fL)
2538 bits=6; bitmask=0x3fL;
2541 else if (bitmask <= 0x7fL)
2543 bits=7; bitmask=0x7fL;
2546 else if (bitmask <= 0xffL)
2548 bits=8; bitmask=0xffL;
2551 else if (bitmask <= 0x1ffL)
2553 bits=9; bitmask=0x1ffL;
2556 else if (bitmask <= 0x3ffL)
2558 bits=10; bitmask=0x3ffL;
2561 else if (bitmask <= 0xfffL)
2563 bits=12; bitmask=0xfff;
2566 else if (bitmask <= 0xffffL)
2568 bits=16; bitmask=0xffffL;
2571 else if (bitmask <= 0xfffffL)
2573 bits=20; bitmask=0xfffffL;
2575 else if (bitmask <= 0xffffffffL)
2577 bits=32; bitmask=0xffffffffL;
2579 else if (bitmask <= 0x7fffffffffffffffL)
2581 bits=63; bitmask=0x7fffffffffffffffL;
2585 bits=63; bitmask=0x7fffffffffffffffL;
2588 else if (bitmask <= 0x7fffffff)
2590 bits=31; bitmask=0x7fffffff;
2594 bits=31; bitmask=0x7fffffffL;
2620 unsigned long bitmask1 =
rGetExpSize(bitmask+1, bits1);
2622 if ((((
N+vars_per_long-1)/vars_per_long) ==
2623 ((
N+vars_per_long1-1)/vars_per_long1)))
2625 vars_per_long=vars_per_long1;
2645 unsigned long exp_limit)
2653 BOOLEAN need_other_ring = (exp_limit != r->bitmask);
2655 int iNeedInducedOrderingSetup = 0;
2659 int *block0=(
int*)
omAlloc0((nblocks+1)*
sizeof(int));
2660 int *block1=(
int*)
omAlloc0((nblocks+1)*
sizeof(int));
2661 int **wvhdl=(
int**)
omAlloc0((nblocks+1)*
sizeof(
int *));
2670 if (r->block0[
i]==r->block1[
i])
2695 Warn(
"Error: unhandled ordering in rModifyRing: ringorder_S = [%d]", r_ord);
2709 need_other_ring=
TRUE;
2710 try_omit_comp=
FALSE;
2711 copy_block_index=
FALSE;
2725 need_other_ring=
TRUE;
2727 omitted_degree =
TRUE;
2741 need_other_ring=
TRUE;
2743 omitted_degree =
TRUE;
2751 try_omit_comp =
FALSE;
2754 iNeedInducedOrderingSetup++;
2763 try_omit_comp =
FALSE;
2772 if (copy_block_index)
2774 block0[
j]=r->block0[
i];
2775 block1[
j]=r->block1[
i];
2776 wvhdl[
j]=r->wvhdl[
i];
2781 if(!need_other_ring)
2801 res->bitmask=exp_limit;
2802 res->wanted_maxExp=r->wanted_maxExp;
2809 if (r->pFDegOrig !=
res->pFDegOrig &&
2814 res->firstwv = r->firstwv;
2815 res->firstBlockEnds = r->firstBlockEnds;
2819 res->pLDeg = r->pLDegOrig;
2828 res->typ[0] = r->typ[0];
2830 if (r->typ[0].data.syz.limit > 0)
2832 res->typ[0].data.syz.syz_index
2833 = (
int*)
omAlloc((r->typ[0].data.syz.limit +1)*
sizeof(int));
2834 memcpy(
res->typ[0].data.syz.syz_index, r->typ[0].data.syz.syz_index,
2835 (r->typ[0].data.syz.limit +1)*
sizeof(
int));
2839 if( iNeedInducedOrderingSetup > 0 )
2841 for(
j = 0,
i = 0; (
i < nblocks) && (iNeedInducedOrderingSetup > 0);
i++)
2848 r->typ[
i].data.is.limit,
2853 iNeedInducedOrderingSetup--;
2859 res->OrdSgn=r->OrdSgn;
2868 WarnS(
"error in nc_rComplete");
2881 WarnS(
"error in sca_Force!");
2907 res->block1[0] = r->N;
2908 res->wvhdl[0] = weights;
2923 WarnS(
"error in nc_rComplete");
2950 int nblocks=1+(ommit_comp!=0);
2952 int *block0=(
int*)
omAlloc0((nblocks+1)*
sizeof(int));
2953 int *block1=(
int*)
omAlloc0((nblocks+1)*
sizeof(int));
2954 int **wvhdl=(
int**)
omAlloc0((nblocks+1)*
sizeof(
int *));
2973 res->bitmask=exp_limit;
2974 res->wanted_maxExp=r->wanted_maxExp;
2985 WarnS(
"error in nc_rComplete");
3001 return rModifyRing(r, ommit_degree, ommit_comp, exp_limit);
3029 r->CanShortOut=
FALSE;
3032 r->CanShortOut =
TRUE;
3040 r->CanShortOut=
FALSE;
3048 for (
i=(
N-1);
i>=0;
i--)
3050 if(r->names[
i] !=
NULL && strlen(r->names[
i])>1)
3052 r->CanShortOut=
FALSE;
3058 r->ShortOut = r->CanShortOut;
3060 assume( !( !r->CanShortOut && r->ShortOut ) );
3068 if(block1[
i]!=r->N) r->LexOrder=
TRUE;
3069 r->firstBlockEnds=block1[
i];
3070 r->firstwv = wvhdl[
i];
3079 for(
j=block1[
i]-r->block0[
i];
j>=0;
j--)
3081 if (r->firstwv[
j]==0) r->LexOrder=
TRUE;
3088 for(
j=block1[
i]-r->block0[
i];
j>=0;
j--)
3090 if (
w[
j]==0) r->LexOrder=
TRUE;
3097 if (r->pFDeg ==
p_Deg)
3118 r->pLDegOrig = r->pLDeg;
3125 int* block0 = r->block0;
3126 int* block1 = r->block1;
3127 int** wvhdl = r->wvhdl;
3136 r->LexOrder =
FALSE;
3143 for(
int ii=block0[0];ii<=block1[0];ii++)
3144 if (wvhdl[0][ii-1]<0) { r->MixedOrder=2;
break;}
3146 for(
int ii=block0[0];ii<=block1[0];ii++)
3147 if (wvhdl[0][ii-1]==0) { r->LexOrder=
TRUE;
break;}
3148 if ((block0[0]==1)&&(block1[0]==r->N))
3159 r->firstwv = wvhdl[0];
3171 if (r->OrdSgn == -1) r->pLDeg =
pLDeg0c;
3190 for(
int ii=block0[0];ii<=block1[0];ii++)
3192 if (wvhdl[0][ii-1]<0) { r->MixedOrder=2;
break;}
3194 if (r->MixedOrder==0)
3196 if ((block0[0]==1)&&(block1[0]==r->N))
3204 r->firstBlockEnds=block1[0];
3205 r->firstwv = wvhdl[0];
3224 r->firstBlockEnds=block1[1];
3225 if (wvhdl!=
NULL) r->firstwv = wvhdl[1];
3233 for(
int ii=block0[1];ii<=block1[1];ii++)
3234 if (wvhdl[1][ii-1]<0) { r->MixedOrder=2;
break;}
3235 if (r->MixedOrder==
FALSE)
3268 if(r->MixedOrder==
FALSE)
3283 r->pFDegOrig = r->pFDeg;
3298 for(
i=0;
i<r->OrdSize;
i++)
3301 ||(r->typ[
i].ord_typ==
ro_am))
3306 r->NegWeightL_Size=
l;
3307 r->NegWeightL_Offset=(
int *)
omAlloc(
l*
sizeof(
int));
3309 for(
i=0;
i<r->OrdSize;
i++)
3313 r->NegWeightL_Offset[
l]=r->typ[
i].data.wp.place;
3316 else if(r->typ[
i].ord_typ==
ro_am)
3318 r->NegWeightL_Offset[
l]=r->typ[
i].data.am.place;
3325 r->NegWeightL_Size = 0;
3326 r->NegWeightL_Offset =
NULL;
3338 if ( (r->cf->extRing!=
NULL)
3347 if (r->LexOrder || r->OrdSgn == -1 || (r->cf->extRing!=
NULL))
3364 r->pLexOrder=r->LexOrder;
3372static inline int sign(
int x) {
return (
x > 0) - (
x < 0);}
3397 if (r->VarOffset!=
NULL && force == 0)
return FALSE;
3402 r->bitmask=
rGetExpSize(r->wanted_maxExp,bits,r->N);
3403 r->BitsPerExp = bits;
3408 long *tmp_ordsgn=(
long *)
omAlloc0(3*(n+r->N)*
sizeof(long));
3410 int *
v=(
int *)
omAlloc((r->N+1)*
sizeof(int));
3411 for(
i=r->N;
i>=0 ;
i--)
3428 switch (r->order[
i])
3432 rO_WDegree(
j,j_bits,r->block0[
i],r->block1[
i],tmp_ordsgn,tmp_typ[typ_i],
3438 rO_WMDegree(
j,j_bits,r->block0[
i],r->block1[
i],tmp_ordsgn,tmp_typ[typ_i],
3445 tmp_typ[typ_i], (
int64 *)(r->wvhdl[
i]));
3452 r->ComponentOrder=1;
3458 r->ComponentOrder=-1;
3464 k=r->block1[
i]-r->block0[
i]+1;
3469 r->wvhdl[
i]+(r->block1[
i]-r->block0[
i]+1)*
l);
3476 rO_LexVars(
j, j_bits, r->block0[
i],r->block1[
i], prev_ordsgn,
3477 tmp_ordsgn,
v,bits, -1);
3482 tmp_ordsgn,
v, bits, -1);
3487 tmp_ordsgn,
v, bits, -1);
3491 rO_LexVars(
j, j_bits, r->block1[
i],r->block0[
i], prev_ordsgn,
3492 tmp_ordsgn,
v, bits, -1);
3496 if (r->block0[
i]==r->block1[
i])
3498 rO_LexVars(
j, j_bits, r->block0[
i],r->block0[
i], prev_ordsgn,
3499 tmp_ordsgn,
v, bits, -1);
3507 prev_ordsgn,tmp_ordsgn,
v,bits, r->block0[
i]);
3512 if (r->block0[
i]==r->block1[
i])
3514 rO_LexVars(
j, j_bits, r->block0[
i],r->block0[
i], prev_ordsgn,
3515 tmp_ordsgn,
v, bits, -1);
3522 rO_LexVars(
j, j_bits, r->block0[
i],r->block1[
i]-1, prev_ordsgn,
3523 tmp_ordsgn,
v, bits, r->block1[
i]);
3528 if (r->block0[
i]==r->block1[
i])
3531 tmp_ordsgn,
v,bits, -1);
3539 prev_ordsgn,tmp_ordsgn,
v,bits, r->block0[
i]);
3544 if (r->block0[
i]==r->block1[
i])
3547 tmp_ordsgn,
v, bits, -1);
3554 rO_LexVars(
j, j_bits, r->block0[
i],r->block1[
i]-1, prev_ordsgn,
3555 tmp_ordsgn,
v, bits, r->block1[
i]);
3561 tmp_typ[typ_i], r->wvhdl[
i]);
3566 for(jj=r->block1[
i]-r->block0[
i];jj>=0; jj--)
3568 if (r->wvhdl[
i][jj]<=0) have_bad_weights=
TRUE;
3570 if (have_bad_weights)
3577 if (r->block1[
i]!=r->block0[
i])
3580 tmp_ordsgn,
v,bits, r->block0[
i]);
3586 tmp_typ[typ_i], r->wvhdl[
i]);
3591 for(jj=r->block1[
i]-r->block0[
i];jj>=0; jj--)
3593 if (r->wvhdl[
i][jj]<=0) have_bad_weights=
TRUE;
3595 if (have_bad_weights)
3602 if (r->block1[
i]!=r->block0[
i])
3604 rO_LexVars(
j, j_bits,r->block0[
i],r->block1[
i]-1, prev_ordsgn,
3605 tmp_ordsgn,
v, bits, r->block1[
i]);
3611 tmp_typ[typ_i], r->wvhdl[
i]);
3613 if (r->block1[
i]!=r->block0[
i])
3616 tmp_ordsgn,
v,bits, r->block0[
i]);
3622 tmp_typ[typ_i], r->wvhdl[
i]);
3624 if (r->block1[
i]!=r->block0[
i])
3626 rO_LexVars(
j, j_bits,r->block0[
i],r->block1[
i]-1, prev_ordsgn,
3627 tmp_ordsgn,
v, bits, r->block1[
i]);
3634 rO_Syzcomp(
j, j_bits,prev_ordsgn, tmp_ordsgn,tmp_typ[typ_i]);
3635 need_to_add_comp=
TRUE;
3636 r->ComponentOrder=-1;
3642 rO_Syz(
j, j_bits, prev_ordsgn, r->block0[
i], tmp_ordsgn, tmp_typ[typ_i]);
3643 need_to_add_comp=
TRUE;
3644 r->ComponentOrder=-1;
3651 assume( r->block0[
i] == r->block1[
i] );
3652 const int s = r->block0[
i];
3656 rO_ISPrefix(
j, j_bits, prev_ordsgn, tmp_ordsgn, r->N,
v, tmp_typ[typ_i++]);
3659 rO_ISSuffix(
j, j_bits, prev_ordsgn, tmp_ordsgn, r->N,
v, tmp_typ, typ_i,
s);
3660 need_to_add_comp=
FALSE;
3679 j_bits=j_bits0;
j=j0;
3684 if((need_to_add_comp) && (
v[0]== -1))
3698 for(
i=1 ;
i<=r->N ;
i++)
3725 r->ordsgn=(
long *)
omAlloc0(r->ExpL_Size*
sizeof(
long));
3727 for(
j=0;
j<r->CmpL_Size;
j++)
3729 r->ordsgn[
j] = tmp_ordsgn[
j];
3738 if (typ_i==0) r->typ=
NULL;
3742 memcpy(r->typ,tmp_typ,typ_i*
sizeof(
sro_ord));
3752 r->pCompIndex=(r->VarOffset[0] & 0xffff);
3755 if (
i==r->pCompIndex)
i++;
3756 while ((j < r->OrdSize)
3764 if (
i==r->pCompIndex)
i++;
3802 for(
int i=1;
i<=r->N;
i++)
3809 if ((r->block0[
j]<=
i)&&(r->block1[
j]>=
i))
3829 if(r->wvhdl[
j][
i-r->block0[
j]]<0)
3835 else if(r->wvhdl[
j][
i-r->block0[
j]]>0)
3846 if(r->wvhdl[
j][
i-r->block0[
j]]<0)
3852 else if(r->wvhdl[
j][
i-r->block0[
j]]>0)
3860 int add=r->block1[
j]-r->block0[
j]+1;
3865 if (r->wvhdl[
j][
i-r->block0[
j]]<0)
3871 else if(r->wvhdl[
j][
i-r->block0[
j]]>0)
3901 if (nonneg>0) r->MixedOrder=1;
3912 if (r ==
NULL)
return;
3913 if (r->VarOffset !=
NULL)
3915 if (r->OrdSize!=0 && r->typ !=
NULL)
3917 for(
int i = 0;
i < r->OrdSize;
i++)
3918 if( r->typ[
i].ord_typ ==
ro_is)
3922 if( r->typ[
i].data.is.pVarOffset !=
NULL )
3927 else if (r->typ[
i].ord_typ ==
ro_syz)
3929 if(r->typ[
i].data.syz.limit > 0)
3930 omFreeSize(r->typ[
i].data.syz.syz_index, ((r->typ[
i].data.syz.limit) +1)*
sizeof(
int));
3934 assume( r->typ[
i].data.syzcomp.ShiftedComponents ==
NULL );
3935 assume( r->typ[
i].data.syzcomp.Components ==
NULL );
3945 if (r->PolyBin !=
NULL)
3951 if (r->ordsgn !=
NULL && r->CmpL_Size != 0)
3956 if (r->p_Procs !=
NULL)
3961 omfreeSize(r->VarL_Offset, r->VarL_Size*
sizeof(
int));
3962 r->VarL_Offset=
NULL;
3964 if (r->NegWeightL_Offset!=
NULL)
3966 omFreeSize(r->NegWeightL_Offset, r->NegWeightL_Size*
sizeof(
int));
3967 r->NegWeightL_Offset=
NULL;
3975 int* VarL_Number = (
int*)
omAlloc0(r->ExpL_Size*
sizeof(
int));
3980 for (
i=1;
i<=r->N;
i++)
3982 VarL_Number[r->VarOffset[
i] & 0xffffff]++;
3986 for (
i=0,
j=0;
i<r->ExpL_Size;
i++)
3988 if (VarL_Number[
i] != 0)
3990 if (
min > VarL_Number[
i])
3992 min = VarL_Number[
i];
4001 r->VarL_Offset = (
int*)
omAlloc(r->VarL_Size*
sizeof(
int));
4002 r->VarL_LowIndex = 0;
4005 for (
i=0,
j=0;
i<r->ExpL_Size;
i++)
4007 if (VarL_Number[
i] != 0)
4009 r->VarL_Offset[
j] =
i;
4010 if (
j > 0 && r->VarL_Offset[
j-1] != r->VarL_Offset[
j] - 1)
4011 r->VarL_LowIndex = -1;
4015 if (r->VarL_LowIndex >= 0)
4016 r->VarL_LowIndex = r->VarL_Offset[0];
4020 j = r->VarL_Offset[min_j];
4021 r->VarL_Offset[min_j] = r->VarL_Offset[0];
4022 r->VarL_Offset[0] =
j;
4029 int* shifts = (
int*)
omAlloc(r->ExpL_Size*
sizeof(
int));
4032 for (
i=0;
i<r->ExpL_Size;
i++)
4036 for (
i=1;
i<=r->N;
i++)
4038 if (shifts[r->VarOffset[
i] & 0xffffff] > r->VarOffset[
i] >> 24)
4039 shifts[r->VarOffset[
i] & 0xffffff] = r->VarOffset[
i] >> 24;
4042 for (
i=1;
i<=r->N;
i++)
4044 if (shifts[r->VarOffset[
i] & 0xffffff] != 0)
4046 = (r->VarOffset[
i] & 0xffffff) |
4047 (((r->VarOffset[
i] >> 24) - shifts[r->VarOffset[
i] & 0xffffff]) << 24);
4055 unsigned long divmask = 1;
4060 divmask |= (((
unsigned long) 1) << (
unsigned long)
i);
4075 const char *TYP[]={
"ro_dp",
"ro_wp",
"ro_am",
"ro_wp64",
"ro_wp_neg",
"ro_cp",
4076 "ro_syzcomp",
"ro_syz",
"ro_isTemp",
"ro_is",
"ro_none"};
4079 Print(
"ExpL_Size:%d ",r->ExpL_Size);
4080 Print(
"CmpL_Size:%d ",r->CmpL_Size);
4081 Print(
"VarL_Size:%d\n",r->VarL_Size);
4082 Print(
"bitmask=0x%lx (expbound=%ld) \n",r->bitmask, r->bitmask);
4083 Print(
"divmask=%lx\n", r->divmask);
4084 Print(
"BitsPerExp=%d ExpPerLong=%d at L[%d]\n", r->BitsPerExp, r->ExpPerLong, r->VarL_Offset[0]);
4086 Print(
"VarL_LowIndex: %d\n", r->VarL_LowIndex);
4087 PrintS(
"VarL_Offset:\n");
4090 for(
j = 0;
j < r->VarL_Size;
j++)
4091 Print(
" VarL_Offset[%d]: %d ",
j, r->VarL_Offset[
j]);
4098 for(
j=0;
j<=r->N;
j++)
4099 Print(
" v%d at e-pos %d, bit %d\n",
4100 j,r->VarOffset[
j] & 0xffffff, r->VarOffset[
j] >>24);
4102 for(
j=0;
j<r->CmpL_Size;
j++)
4103 Print(
" ordsgn %ld at pos %d\n",r->ordsgn[
j],
j);
4104 Print(
"OrdSgn:%d\n",r->OrdSgn);
4106 for(
j=0;
j<r->OrdSize;
j++)
4108 Print(
" typ %s", TYP[r->typ[
j].ord_typ]);
4109 if (r->typ[
j].ord_typ==
ro_syz)
4111 const short place = r->typ[
j].data.syz.place;
4112 const int limit = r->typ[
j].data.syz.limit;
4113 const int curr_index = r->typ[
j].data.syz.curr_index;
4114 const int* syz_index = r->typ[
j].data.syz.syz_index;
4116 Print(
" limit %d (place: %d, curr_index: %d), syz_index: ", limit, place, curr_index);
4118 if( syz_index ==
NULL )
4123 for(
i=0;
i <= limit;
i++ )
4124 Print(
"%d ", syz_index[
i]);
4131 Print(
" start (level) %d, suffixpos: %d, VO: ",r->typ[
j].data.isTemp.start, r->typ[
j].data.isTemp.suffixpos);
4134 else if (r->typ[
j].ord_typ==
ro_is)
4136 Print(
" start %d, end: %d: ",r->typ[
j].data.is.start, r->typ[
j].data.is.end);
4140 Print(
" limit %d",r->typ[
j].data.is.limit);
4147 else if (r->typ[
j].ord_typ==
ro_am)
4149 Print(
" place %d",r->typ[
j].data.am.place);
4150 Print(
" start %d",r->typ[
j].data.am.start);
4151 Print(
" end %d",r->typ[
j].data.am.end);
4152 Print(
" len_gen %d",r->typ[
j].data.am.len_gen);
4155 for(
l=r->typ[
j].data.am.start;l<=r->typ[
j].data.am.end;
l++)
4156 Print(
" %d",r->typ[
j].data.am.weights[
l-r->typ[
j].data.am.start]);
4157 l=r->typ[
j].data.am.end+1;
4158 int ll=r->typ[
j].data.am.weights[
l-r->typ[
j].data.am.start];
4160 for(
int lll=
l+1;lll<
l+ll+1;lll++)
4161 Print(
" %d",r->typ[
j].data.am.weights[lll-r->typ[
j].data.am.start]);
4165 Print(
" place %d",r->typ[
j].data.dp.place);
4169 Print(
" start %d",r->typ[
j].data.dp.start);
4170 Print(
" end %d",r->typ[
j].data.dp.end);
4171 if ((r->typ[
j].ord_typ==
ro_wp)
4175 for(
int l=r->typ[
j].data.wp.start;l<=r->typ[
j].data.wp.end;
l++)
4176 Print(
" %d",r->typ[
j].data.wp.weights[
l-r->typ[
j].data.wp.start]);
4178 else if (r->typ[
j].ord_typ==
ro_wp64)
4182 for(
l=r->typ[
j].data.wp64.start;l<=r->typ[
j].data.wp64.end;
l++)
4183 Print(
" %ld",(
long)(((
int64*)r->typ[
j].data.wp64.weights64)+
l-r->typ[
j].data.wp64.start));
4189 Print(
"pOrdIndex:%d pCompIndex:%d\n", r->pOrdIndex, r->pCompIndex);
4190 Print(
"OrdSize:%d\n",r->OrdSize);
4191 PrintS(
"--------------------\n");
4192 for(
j=0;
j<r->ExpL_Size;
j++)
4195 if (j< r->CmpL_Size)
4196 Print(
"ordsgn %ld ", r->ordsgn[
j]);
4202 if( (r->VarOffset[
i] & 0xffffff) ==
j )
4203 {
Print(
"v%d at e[%d], bit %d; ",
i,r->VarOffset[
i] & 0xffffff,
4204 r->VarOffset[
i] >>24 ); }
4206 if( r->pCompIndex==
j )
PrintS(
"v0; ");
4207 for(
i=0;
i<r->OrdSize;
i++)
4209 if (r->typ[
i].data.dp.place ==
j)
4211 Print(
"ordrec:%s (start:%d, end:%d) ",TYP[r->typ[
i].ord_typ],
4212 r->typ[
i].data.dp.start, r->typ[
i].data.dp.end);
4216 if (
j==r->pOrdIndex)
4221 Print(
"LexOrder:%d, MixedOrder:%d\n",r->LexOrder, r->MixedOrder);
4223 Print(
"NegWeightL_Size: %d, NegWeightL_Offset: ", r->NegWeightL_Size);
4224 if (r->NegWeightL_Offset==
NULL)
PrintS(
" NULL");
4226 for(
j = 0;
j < r->NegWeightL_Size;
j++)
4227 Print(
" [%d]: %d ",
j, r->NegWeightL_Offset[
j]);
4238 Print(
"p_Spec : %s, %s, %s\n", field,
length, ord);
4240 for (
i=0;
i<(int) (
sizeof(
p_Procs_s)/
sizeof(
void*));
i++)
4242 Print(
" %s,\n", ((
char**) &proc_names)[
i]);
4248#define pFDeg_CASE(A) if(r->pFDeg == A) PrintS( "" #A "" )
4254 Print(
"(%p)", r->pFDeg);
4257 Print(
"pLDeg : (%p)", r->pLDeg);
4269 else Print(
"%p\n",r->p_Setm);
4279 Print(
"\nexp[0..%d]\n",r->ExpL_Size-1);
4280 for(
i=0;
i<r->ExpL_Size;
i++)
4288 if (
j==0) {
PrintS(
"...\n");
break; }
4297 Print(
"\nexp[0..%d]\n",
R->ExpL_Size - 1);
4298 for(
int i = 0;
i <
R->ExpL_Size;
i++)
4317 for(
int j = (F->ncols*F->nrows) - 1;
j >= 0;
j-- )
4331 Print(
"gen[%d] -> gen(%d)\n", c,
MIN + (*V)[ c -
MIN - 1 ]);
4355 r->typ[1].data.syzcomp.Components = currComponents;
4363 *currComponents = r->typ[1].data.syzcomp.Components;
4373 r->typ[1].data.syzcomp.length =
length;
4383 *
length = r->typ[1].data.syzcomp.length;
4425 WarnS(
"rAssure_SyzComp: input ring has an IS-ordering!");
4436 int ** wvhdl =(
int **)
omAlloc0((
i+1)*
sizeof(
int**));
4439 res->order[
j]=r->order[
j-1];
4440 res->block0[
j]=r->block0[
j-1];
4441 res->block1[
j]=r->block1[
j-1];
4442 if (r->wvhdl[
j-1] !=
NULL)
4460 WarnS(
"error in nc_rComplete");
4470 if (r->qideal!=
NULL)
4500 pos=r->VarL_LowIndex;
4505 for(
int i=r->OrdSize-1;
i>=0;
i--)
4507 if ((r->typ[
i].ord_typ==
ro_dp)
4508 && (r->typ[
i].data.dp.start==1)
4509 && (r->typ[
i].data.dp.end==r->N))
4511 pos=r->typ[
i].data.dp.place;
4530 res->ExpL_Size=r->ExpL_Size+1;
4534 for(
j=0;
j<r->CmpL_Size;
j++)
4536 res->ordsgn[
j] = r->ordsgn[
j];
4538 res->OrdSize=r->OrdSize+1;
4543 memcpy(
res->typ,r->typ,r->OrdSize*
sizeof(
sro_ord));
4547 res->typ[
res->OrdSize-1].data.dp.start=1;
4548 res->typ[
res->OrdSize-1].data.dp.end=
res->N;
4549 res->typ[
res->OrdSize-1].data.dp.place=
res->ExpL_Size-1;
4550 pos=
res->ExpL_Size-1;
4566 WarnS(
"error in nc_rComplete");
4572 if (r->qideal!=
NULL)
4602 if (r->order[
i] == 0)
4611 new_r->wvhdl=(
int **)
omAlloc0(
i *
sizeof(
int *));
4613 new_r->block0 = (
int *)
omAlloc0(
i *
sizeof(
int));
4614 new_r->block1 = (
int *)
omAlloc0(
i *
sizeof(
int));
4616 memcpy(new_r->block0,r->block0,(
i-1) *
sizeof(
int));
4617 memcpy(new_r->block1,r->block1,(
i-1) *
sizeof(
int));
4618 for (
int j=0;
j<=last_block;
j++)
4620 if (r->wvhdl[
j]!=
NULL)
4622 new_r->wvhdl[
j] = (
int*)
omMemDup(r->wvhdl[
j]);
4639 WarnS(
"error in nc_rComplete");
4651 int last_block =
rBlocks(r) - 2;
4658 for (
i=0;
i< last_block;
i++)
4669 for (
i=c_pos+1;
i<=last_block;
i++)
4671 new_r->order[
i-1] = new_r->order[
i];
4672 new_r->block0[
i-1] = new_r->block0[
i];
4673 new_r->block1[
i-1] = new_r->block1[
i];
4674 new_r->wvhdl[
i-1] = new_r->wvhdl[
i];
4676 new_r->order[last_block] = r->order[c_pos];
4677 new_r->block0[last_block] = r->block0[c_pos];
4678 new_r->block1[last_block] = r->block1[c_pos];
4679 new_r->wvhdl[last_block] = r->wvhdl[c_pos];
4690 WarnS(
"error in nc_rComplete");
4715 if (new_r_1 != new_r && new_r_1 != old_r)
rDelete(new_r_1);
4724 WarnS(
"error in nc_rComplete");
4731 if (old_r->qideal !=
NULL)
4733 new_r->qideal =
idrCopyR(old_r->qideal, old_r, new_r);
4741 WarnS(
"error in nc_SetupQuotient");
4766 if ((r_blocks == 3) &&
4767 (r->order[0] == b1) &&
4768 (r->order[1] == b2) &&
4781 res->block1[1] = r->N;
4786 res->block1[0] = r->N;
4796 WarnS(
"error in nc_rComplete");
4809 Print(
"rAssure_InducedSchreyerOrdering(r, complete = %d, sgn = %d): r: \n", complete,
sgn);
4826 int ** wvhdl =(
int **)
omAlloc0((n+2)*
sizeof(
int**));
4834 res->block0[
j] =
res->block1[
j] = 0;
4838 for(
int i = 0; (
i <= n) && (r->order[
i] != 0);
i++,
j++)
4840 res->order [
j] = r->order [
i];
4841 res->block0[
j] = r->block0[
i];
4842 res->block1[
j] = r->block1[
i];
4844 if (r->wvhdl[
i] !=
NULL)
4876 WarnS(
"error in nc_rComplete");
4888 if (r->qideal!=
NULL)
4945 Print(
"rIsIS(p: %d)\nF:",
p);
4956 for(
int pos = 0; pos < r->OrdSize; pos++ )
4957 if( r->typ[pos].ord_typ ==
ro_is)
4979 dReportError(
"Error: WRONG USE of rSetISReference: wrong ring! (typ == NULL)");
4988 dReportError(
"Error: WRONG USE of rSetISReference: specified ordering block was not found!!!" );
4993 if(
i != r->typ[pos].data.is.limit )
4994 Print(
"Changing record on pos: %d\nOld limit: %d --->> New Limit: %d\n", pos, r->typ[pos].data.is.limit,
i);
4997 const ideal FF =
idrHeadR(F, r, r);
5000 if( r->typ[pos].data.is.F !=
NULL)
5003 PrintS(
"Deleting old reference set F... \n");
5006 r->typ[pos].data.is.F =
NULL;
5011 r->typ[pos].data.is.F = FF;
5013 r->typ[pos].data.is.limit =
i;
5037 if ((r->typ!=
NULL) && (r->typ[0].ord_typ==
ro_syz))
5039 r->block0[0]=r->block1[0] =
k;
5040 if(
k == r->typ[0].data.syz.limit )
5044 if (r->typ[0].data.syz.limit == 0)
5046 r->typ[0].data.syz.syz_index = (
int*)
omAlloc0((
k+1)*
sizeof(int));
5047 r->typ[0].data.syz.syz_index[0] = 0;
5048 r->typ[0].data.syz.curr_index = 1;
5052 r->typ[0].data.syz.syz_index = (
int*)
5054 (r->typ[0].data.syz.limit+1)*
sizeof(int),
5057 for (
i=r->typ[0].data.syz.limit + 1;
i<=
k;
i++)
5059 r->typ[0].data.syz.syz_index[
i] =
5060 r->typ[0].data.syz.curr_index;
5062 if(k < r->typ[0].data.syz.limit)
5065 Warn(
"rSetSyzComp called with smaller limit (%d) as before (%d)",
k, r->typ[0].data.syz.limit);
5067 r->typ[0].data.syz.curr_index = 1 + r->typ[0].data.syz.syz_index[
k];
5071 r->typ[0].data.syz.limit =
k;
5072 r->typ[0].data.syz.curr_index++;
5081 Warn(
"rSetSyzComp(%d) in an IS ring! Be careful!",
k);
5086 r->block0[0] = r->block1[0] =
k;
5101 if ((r->typ!=
NULL) && (r->typ[0].ord_typ==
ro_syz) &&
5102 r->typ[0].data.syz.limit > 0 &&
i > 0)
5104 assume(i <= r->typ[0].data.syz.limit);
5106 for (
j=0;
j<r->typ[0].data.syz.limit;
j++)
5108 if (r->typ[0].data.syz.syz_index[
j] ==
i &&
5109 r->typ[0].data.syz.syz_index[
j+1] !=
i)
5111 assume(r->typ[0].data.syz.syz_index[
j+1] ==
i+1);
5115 return r->typ[0].data.syz.limit;
5120 WarnS(
"rGetMaxSyzComp: order c");
5130 for (
i=0;
i<nb;
i++)
5132 if (r->wvhdl[
i] !=
NULL)
5134 int length = r->block1[
i] - r->block0[
i];
5135 int* wvhdl = r->wvhdl[
i];
5140 if (wvhdl[
j] != 0 && wvhdl[
j] != 1)
return FALSE;
5156 if ((r->order[0]==
ringorder_dp) &&(r->block0[0]==1) &&(r->block1[0]==r->N))
5159 && ((r->order[1]==
ringorder_dp) &&(r->block0[1]==1) &&(r->block1[1]==r->N)))
5166 if ((r->order[0]==
ringorder_Dp) &&(r->block0[0]==1) &&(r->block1[0]==r->N))
5169 && ((r->order[1]==
ringorder_Dp) &&(r->block0[1]==1) &&(r->block1[1]==r->N)))
5176 if ((r->order[0]==
ringorder_lp) &&(r->block0[0]==1) &&(r->block1[0]==r->N))
5179 && ((r->order[1]==
ringorder_lp) &&(r->block0[1]==1) &&(r->block1[1]==r->N)))
5189 while((r->typ[
i].ord_typ!=
ro_wp64) && (r->typ[
i].ord_typ>0))
i++;
5191 return (
int64*)(r->typ[
i].data.wp64.weights64);
5199 memcpy(r->typ[0].data.wp64.weights64,wv,r->N*
sizeof(
int64));
5210 for(
int k=
size;
k>pos;
k--) r->wvhdl[
k]=r->wvhdl[
k-1];
5216static int rReallocM1(ring r,
int size,
int pos)
5222 for(
int k=pos+1;
k<
size;
k++) r->wvhdl[
k]=r->wvhdl[
k+1];
5232 for(
int j=0;
j<=i2;
j++)
5240#define rOppVar(R,I) (rVar(R)+1-I)
5258 if (src->qideal !=
NULL)
5265 int i2 = (
rVar(r)-1)/2;
5266 for(
i=i2;
i>=0;
i--)
5272 p = r->names[
rVar(r)-1-
i];
5273 r->names[
rVar(r)-1-
i] = r->names[
i];
5291 char *
p=r->names[
i];
5292 if(isupper(*
p)) *
p = tolower(*
p);
5293 else *
p = toupper(*
p);
5344 for(
i=0; src->order[
i]!=0;
i++)
5346 switch (src->order[
i])
5351 r->order[
j]=src->order[
i];
5355 r->block0[
j]=
rOppVar(r, src->block1[
i]);
5356 r->block1[
j]=
rOppVar(r, src->block0[
i]);
5360 r->block0[
j]=
rOppVar(r, src->block1[
i]);
5361 r->block1[
j]=
rOppVar(r, src->block0[
i]);
5367 r->block0[
j]=
rOppVar(r, src->block1[
i]);
5368 r->block1[
j]=
rOppVar(r, src->block0[
i]);
5369 r->wvhdl[
j]=(
int*)
omAlloc((r->block1[
j]-r->block0[
j]+1)*
sizeof(int));
5370 for(
int k=r->block0[
j]; k<=r->block1[
j];
k++)
5371 r->wvhdl[
j][
k-r->block0[
j]]=1;
5374 r->block0[
j]=
rOppVar(r, src->block1[
i]);
5375 r->block1[
j]=
rOppVar(r, src->block0[
i]);
5383 r->block0[
j]=
rOppVar(r, src->block1[
i]);
5384 r->block1[
j]=
rOppVar(r, src->block0[
i]);
5385 r->wvhdl[
j]=(
int*)
omAlloc((r->block1[
j]-r->block0[
j]+1)*
sizeof(int));
5386 for(
int k=r->block0[
j]; k<=r->block1[
j];
k++)
5387 r->wvhdl[
j][
k-r->block0[
j]]=1;
5390 r->block0[
j]=
rOppVar(r, src->block1[
i]);
5391 r->block1[
j]=
rOppVar(r, src->block0[
i]);
5399 r->block0[
j]=
rOppVar(r, src->block1[
i]);
5400 r->block1[
j]=
rOppVar(r, src->block0[
i]);
5401 r->wvhdl[
j]=r->wvhdl[
j+1]; r->wvhdl[
j+1]=
NULL;
5405 r->block0[
j]=
rOppVar(r, src->block1[
i]);
5406 r->block1[
j]=
rOppVar(r, src->block0[
i]);
5414 r->block0[
j]=
rOppVar(r, src->block1[
i]);
5415 r->block1[
j]=
rOppVar(r, src->block0[
i]);
5416 r->wvhdl[
j]=r->wvhdl[
j+1]; r->wvhdl[
j+1]=
NULL;
5420 r->block0[
j]=
rOppVar(r, src->block1[
i]);
5421 r->block1[
j]=
rOppVar(r, src->block0[
i]);
5428 r->block0[
j]=
rOppVar(r, src->block1[
i]);
5429 r->block1[
j]=
rOppVar(r, src->block0[
i]);
5430 int n=r->block1[
j]-r->block0[
j];
5432 for (
int nn=0; nn<=n; nn++)
5441 r->block0[
j]=
rOppVar(r, src->block1[
i]);
5442 r->block1[
j]=
rOppVar(r, src->block0[
i]);
5484 for(
i=0; src->order[
i]!=0;
i++)
5486 switch (src->order[
i])
5491 r->order[
j]=src->order[
i];
5495 r->block0[
j]=
rOppVar(r, src->block1[
i]);
5496 r->block1[
j]=
rOppVar(r, src->block0[
i]);
5500 r->block0[
j]=
rOppVar(r, src->block1[
i]);
5501 r->block1[
j]=
rOppVar(r, src->block0[
i]);
5506 r->block0[
j]=
rOppVar(r, src->block1[
i]);
5507 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]);
5559 int *par_perm =
NULL;
5562 for(
i=1;
i<=r->N;
i++)
5578 MATELEM(C,nj,ni) =
p_PermPoly(
MATELEM(src->GetNC()->C,
i,
j),perm,src,r, nMap,par_perm,
rPar(src));
5581 MATELEM(
D,nj,ni) =
p_PermPoly(
MATELEM(src->GetNC()->D,
i,
j),perm,src,r, nMap,par_perm,
rPar(src));
5589 WarnS(
"Error initializing non-commutative multiplication!");
5597 assume( r->GetNC()->IsSkewConstant == src->GetNC()->IsSkewConstant);
5604 if (src->qideal !=
NULL)
5607 r->qideal =
idOppose(src, src->qideal, r);
5609 r->qideal =
id_Copy(src->qideal, r);
5639 int stat =
rSum(
R, Ropp, Renv);
5641 WarnS(
"Error in rEnvelope at rSum");
5664 const int N = dest->N;
5673 const ring srcBase = src;
5680 matrix C0 = src->GetNC()->C;
5681 matrix D0 = src->GetNC()->D;
5684 for (
int i = 1;
i <
N;
i++)
5686 for (
int j =
i + 1;
j <=
N;
j++)
5689 const poly
p =
p_NSet(n, dest);
5731 while(r->order[
i]!=0)
5738 for(
j=r->block1[
i]-r->block0[
i];
j>=0;
j--)
5740 r->wvhdl[
i]=(
int*)w64;
5774 Werror(
"n_IsParam: IsParam is not to be used for (coeff_type = %d)",
getCoeffType(C));
5783 WerrorS(
"only for rings with an ordering of one block");
5800 WerrorS(
"ordering must be dp,Dp,lp,rp,ds,Ds or ls");
5803 for(
int i=r->N-1;
i>=0;
i--)
5805 if (strcmp(r->names[
i],
v)==0)
5807 Werror(
"duplicate variable name >>%s<<",
v);
5813 #ifdef HAVE_SHIFTBBA
5816 R->isLPring=r->isLPring+1;
5817 R->N=((r->N)/r->isLPring)+r->N;
5821 for(
int b=0;
b<((r->N)/r->isLPring);
b++)
5824 for(
int i=
R->isLPring-1;
i>0;
i--)
5825 names[
i+
b*
R->isLPring]=
R->names[
i-1+
b*r->isLPring];
5830 for(
int b=0;
b<((r->N)/r->isLPring);
b++)
5833 for(
int i=
R->isLPring-2;
i>=0;
i--)
5834 names[
i+
b*
R->isLPring]=
R->names[
i+
b*r->isLPring];
5846 for(
int i=
R->N-1;
i>0;
i--) names[
i]=
R->names[
i-1];
5851 for(
int i=
R->N-2;
i>=0;
i--) names[
i]=
R->names[
i];
5865 WerrorS(
"only for rings with an ordering of one block");
5882 WerrorS(
"ordering must be dp,Dp,lp,rp,ds,Ds or ls");
5889 if (strcmp(
R->names[
i],
v)==0)
5893 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)
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 unsigned long p_SetComp(poly p, unsigned long c, ring r)
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)
void p_wrp(poly p, ring lmRing, ring tailRing)
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)
void pISUpdateComponents(ideal F, const intvec *const V, const int MIN, const ring r)
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)
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 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)
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 rModify_a_to_A(ring r)
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
static void rO_ISPrefix(int &place, int &bitplace, int &prev_ord, long *o, int, int *v, sro_ord &ord_struct)
ring rPlusVar(const ring r, char *v, int left)
K[x],"y" -> K[x,y] resp. K[y,x].
BOOLEAN rIsPolyVar(int v, const ring r)
returns TRUE if var(i) belongs to p-block
static void rSetFirstWv(ring r, int i, rRingOrder_t *order, int *block1, int **wvhdl)
ring rAssure_CompLastBlock(ring r, BOOLEAN complete)
makes sure that c/C ordering is last ordering
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)
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[]
BOOLEAN rRing_is_Homog(const ring r)
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)
static int rBlocks(ring r)
struct p_Procs_s p_Procs_s
static BOOLEAN rIsPluralRing(const ring r)
we must always have this test!
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,