52 #define BITS_PER_LONG 8*SIZEOF_LONG 90 return ringorder_name[ord];
113 ring
rDefault(
const coeffs cf,
int N,
char **n,
int ord_size,
int *ord,
int *block0,
int *block1,
int** wvhdl)
121 r->names = (
char **)
omAlloc0(N *
sizeof(
char *));
129 r->wvhdl = (
int **)
omAlloc0((ord_size+1) *
sizeof(
int *));
140 ring
rDefault(
int ch,
int N,
char **n,
int ord_size,
int *ord,
int *block0,
int *block1,
int ** wvhdl)
146 return rDefault(cf,N,n,ord_size,ord,block0,block1,wvhdl);
152 int *order = (
int *)
omAlloc(2*
sizeof(
int));
153 int *block0 = (
int *)
omAlloc0(2 *
sizeof(
int));
154 int *block1 = (
int *)
omAlloc0(2 *
sizeof(
int));
162 return rDefault(cf,N,n,2,order,block0,block1);
189 WerrorS(
"weights only for orderings wp,ws,Wp,Ws,a,M");
198 int sz = (int)
sqrt((
double)(order->
length()-2));
199 if ((sz*sz)!=(order->
length()-2))
201 WerrorS(
"Matrix order is not a square matrix");
204 while ((i<sz) && (typ==1))
207 while ((
j<sz) && ((*order)[
j*sz+i+2]==0))
j++;
211 WerrorS(
"Matrix order not complete");
213 else if ((*order)[
j*sz+i+2]<0)
226 for (
int i=0;
i<
N;
i++)
228 if (names[
i]==
NULL)
return -1;
229 if (strcmp(n,names[
i]) == 0)
return (
int)
i;
268 R->ShortOut = bSaveShortOut;
310 Print(
"// number of vars : %d",r->N);
315 for (
int l=0, nlen=0 ;
l<nblocks;
l++)
318 Print(
"\n// block %3d : ",
l+1);
327 Print(
" syzcomp at %d",r->typ[
l].data.syz.limit);
333 assume( r->block0[
l] == r->block1[
l] );
334 const int s = r->block0[
l];
335 assume( (-2 < s) && (s < 2) );
348 for (i = r->block0[
l]-1; i<r->block1[
l]; i++)
350 nlen = strlen(r->names[i]);
351 Print(
" %s",r->names[i]);
355 if (r->wvhdl[
l]!=
NULL)
358 j<(r->block1[
l]-r->block0[
l]+1)*(r->block1[
l]-r->block0[
l]+1);
361 PrintS(
"\n// : weights ");
362 for (i = 0; i<=r->block1[
l]-r->block0[
l]; i++)
368 Print(
"%*lld " ,nlen,w[i+
j]);
370 Print(
" %*ld" ,nlen,w[i+
j]);
374 Print(
" %*d" ,nlen,r->wvhdl[
l][i+
j]);
380 int m=r->wvhdl[
l][
i];
381 Print(
"\n// : %d module weights ",m);
383 for(;i<=
m;i++)
Print(
" %*d" ,nlen,r->wvhdl[
l][i]);
390 PrintS(
"\n// noncommutative relations:");
396 for (i = 1; i<r->N; i++)
398 for (j = i+1; j<=r->N; j++)
403 Print(
"\n// %s%s=",r->names[j-1],r->names[i-1]);
414 Print(
"\n// is skew constant:%d",r->GetNC()->IsSkewConstant);
419 PrintS(
"\n// quotient of sca by ideal");
439 PrintS(
"\n// quotient ring from ideal");
452 if (r ==
NULL)
return;
459 if( r->qideal !=
NULL )
474 if (r->order !=
NULL)
485 if (r->wvhdl[j]!=
NULL)
498 for (i=0; i<r->N; i++)
517 if (order==0)
Werror(
"wrong ring order `%s`",ordername);
527 for (nblocks=0; r->order[nblocks]; nblocks++);
542 if (r->wvhdl[l]!=
NULL)
546 j<(r->block1[
l]-r->block0[
l]+1)*(r->block1[l]-r->block0[l]+1);
553 for (i = 0; i<r->block1[
l]-r->block0[
l]; i++)
562 for (i = 0; i<r->block1[
l]-r->block0[
l]; i++)
572 if (
j+i+1==(r->block1[l]-r->block0[l]+1)*(r->block1[l]-r->block0[l]+1))
582 assume( r->block0[l] == r->block1[l] );
583 const int s = r->block0[
l];
584 assume( (-2 < s) && (s < 2) );
601 for (i=0; i<r->N; i++)
603 l+=strlen(r->names[i])+1;
607 for (i=0; i<r->N-1; i++)
609 strcat(s,r->names[i]);
612 strcat(s,r->names[i]);
624 char const *
const *
const params =
rParameter(r);
629 for (i=0; i<
rPar(r); i++)
631 l+=strlen(params[i])+1;
635 for (i=0; i<
rPar(r)-1; i++)
637 strcat(s, params[i]);
640 strcat(s, params[i]);
651 char *
res=(
char *)
omAlloc(strlen(ch)+strlen(var)+strlen(ord)+9);
652 sprintf(res,
"(%s),(%s),(%s)",ch,var,ord);
684 int rChar(ring r) {
return r->cf->ch; }
701 for(
int i=1;
i<r->N;
i++)
702 for(
int j=
i+1;
j<=r->N;
j++)
706 WarnS(
"Error initializing multiplication!");
726 memset(&tmpR,0,
sizeof(tmpR));
777 if (r1->cf->extRing->cf==r2->cf)
787 WerrorS (
"coeff sum of two extension fields not implemented");
793 WerrorS(
"coeff sum not yet implemented");
800 char **names=(
char **)
omAlloc0(l*
sizeof(
char *));
805 for (i=0;i<r1->N;i++)
809 if (*(r1->names[i]) ==
'\0')
815 for(j=0;j<
rPar(r2);j++)
817 if (strcmp(r1->names[i],
rParameter(r2)[j])==0)
841 if (*(r2->names[i]) ==
'\0')
847 for(j=0;j<
rPar(r1);j++)
849 if (strcmp(r2->names[i],
rParameter(r1)[j])==0)
864 if (strcmp(r1->names[j],r2->names[i])==0)
910 for(
int i=0;i<
rVar(r1);i++) tmpR.
wvhdl[0][i]=1;
933 if ((r2->block0[0]==1)
934 && (r2->block1[0]==
rVar(r2))
940 tmpR.
order[1]=r2->order[0];
941 if (r2->wvhdl[0]!=
NULL)
1007 if (rb->wvhdl[i]!=
NULL)
1008 WarnS(
"rSum: weights not implemented");
1014 for (i=0;r1->order[
i]!=0;i++)
1019 if (r1->wvhdl[i]!=
NULL)
1028 tmpR.
order[b-2]=r1->order[
i];
1030 for (i=0;r2->order[
i]!=0;i++)
1038 if (r2->wvhdl[i]!=
NULL)
1045 if((r1->OrdSgn==-1)||(r2->OrdSgn==-1))
1049 else if ((k==
rVar(r1)) && (k==
rVar(r2)))
1065 if (r1->wvhdl[i]!=
NULL)
1076 Werror(
"difficulties with variables: %d,%d -> %d",
rVar(r1),
rVar(r2),k);
1082 memcpy(sum,&tmpR,
sizeof(
ip_sring));
1099 if ( (R1_is_nc) || (R2_is_nc))
1123 int *perm1 = (
int *)
omAlloc0((
rVar(R1)+1)*
sizeof(int));
1124 int *par_perm1 =
NULL;
1127 int *perm2 = (
int *)
omAlloc0((
rVar(R2)+1)*
sizeof(int));
1128 int *par_perm2 =
NULL;
1133 perm1, par_perm1, sum->cf->type);
1137 perm2, par_perm2, sum->cf->type);
1140 matrix C1 = R1->GetNC()->C, C2 = R2->GetNC()->C;
1141 matrix D1 = R1->GetNC()->D, D2 = R2->GetNC()->D;
1150 for (i = 1; i <=
rVar(R1); i++)
1151 for (j=
rVar(R1)+1; j <=
l; j++)
1159 for (i=1; i<=
rVar(R1); i++)
1160 for (j=i+1; j<=
rVar(R1); j++)
1163 MATELEM(C,i,j) =
p_PermPoly(
MATELEM(C1,i,j), perm1, R1, sum, nMap1, par_perm1,
rPar(R1));
1166 MATELEM(D,i,j) =
p_PermPoly(
MATELEM(D1,i,j), perm1, R1, sum, nMap1, par_perm1,
rPar(R1));
1175 for (i=1; i<=
rVar(R2); i++)
1176 for (j=i+1; j<=
rVar(R2); j++)
1179 MATELEM(C,
rVar(R1)+i,
rVar(R1)+j) =
p_PermPoly(
MATELEM(C2,i,j),perm2,R2,sum, nMap2,par_perm2,
rPar(R2));
1182 MATELEM(D,
rVar(R1)+i,
rVar(R1)+j) =
p_PermPoly(
MATELEM(D2,i,j),perm2,R2,sum, nMap2,par_perm2,
rPar(R2));
1190 WarnS(
"Error initializing non-commutative multiplication!");
1199 Print(
"\nRefs: R1: %d, R2: %d\n", R1->GetNC()->ref, R2->GetNC()->ref);
1222 if (r1->qideal!=
NULL)
1233 int *perm1 = (
int *)
omAlloc0((
rVar(r1)+1)*
sizeof(int));
1234 int *par_perm1 =
NULL;
1238 perm1, par_perm1, sum->cf->type);
1242 for (
int for_i=0;for_i<
IDELEMS(r1->qideal);for_i++)
1244 r1->qideal->m[for_i], perm1,
1247 par_perm1,
rPar(r1));
1252 if (r2->qideal!=
NULL)
1256 int *perm2 = (
int *)
omAlloc0((
rVar(r2)+1)*
sizeof(int));
1257 int *par_perm2 =
NULL;
1261 perm2, par_perm2, sum->cf->type);
1265 for (
int for_i=0;for_i<
IDELEMS(r2->qideal);for_i++)
1267 r2->qideal->m[for_i], perm2,
1270 par_perm2,
rPar(r2));
1302 int rSum(ring r1, ring r2, ring &sum)
1330 res->options=r->options;
1344 res->OrdSgn=r->OrdSgn;
1346 res->firstBlockEnds=r->firstBlockEnds;
1348 res->real_var_start=r->real_var_start;
1349 res->real_var_end=r->real_var_end;
1352 #ifdef HAVE_SHIFTBBA 1353 res->isLPring=r->isLPring;
1356 res->VectorOut=r->VectorOut;
1357 res->ShortOut=r->ShortOut;
1358 res->CanShortOut=r->CanShortOut;
1359 res->LexOrder=r->LexOrder;
1360 res->MixedOrder=r->MixedOrder;
1362 res->ComponentOrder=r->ComponentOrder;
1378 res->bitmask=r->bitmask;
1379 res->divmask=r->divmask;
1380 res->BitsPerExp = r->BitsPerExp;
1381 res->ExpPerLong = r->ExpPerLong;
1400 if (copy_ordering ==
TRUE)
1403 res->wvhdl = (
int **)
omAlloc(i *
sizeof(
int *));
1404 res->order = (
int *)
omAlloc(i *
sizeof(
int));
1405 res->block0 = (
int *)
omAlloc(i *
sizeof(
int));
1406 res->block1 = (
int *)
omAlloc(i *
sizeof(
int));
1409 if (r->wvhdl[j]!=
NULL)
1411 res->wvhdl[
j] = (
int*)
omMemDup(r->wvhdl[j]);
1416 memcpy(res->order,r->order,i *
sizeof(
int));
1417 memcpy(res->block0,r->block0,i *
sizeof(
int));
1418 memcpy(res->block1,r->block1,i *
sizeof(
int));
1428 res->names = (
char **)
omAlloc0(
rVar(r) *
sizeof(
char *));
1429 for (i=0; i<
rVar(res); i++)
1433 if (r->qideal!=
NULL)
1439 WerrorS(
"internal error: rCopy0(Q,TRUE,FALSE)");
1444 WarnS(
"internal bad stuff: rCopy0(Q,TRUE,TRUE)");
1472 res->options=r->options;
1486 res->OrdSgn=r->OrdSgn;
1488 res->firstBlockEnds=r->firstBlockEnds;
1490 res->real_var_start=r->real_var_start;
1491 res->real_var_end=r->real_var_end;
1494 #ifdef HAVE_SHIFTBBA 1495 res->isLPring=r->isLPring;
1498 res->VectorOut=r->VectorOut;
1499 res->ShortOut=r->ShortOut;
1500 res->CanShortOut=r->CanShortOut;
1501 res->LexOrder=r->LexOrder;
1502 res->MixedOrder=r->MixedOrder;
1504 res->ComponentOrder=r->ComponentOrder;
1520 res->bitmask=r->bitmask;
1521 res->divmask=r->divmask;
1522 res->BitsPerExp = r->BitsPerExp;
1523 res->ExpPerLong = r->ExpPerLong;
1542 if (copy_ordering ==
TRUE)
1545 res->wvhdl = (
int **)
omAlloc(i *
sizeof(
int *));
1546 res->order = (
int *)
omAlloc(i *
sizeof(
int));
1547 res->block0 = (
int *)
omAlloc(i *
sizeof(
int));
1548 res->block1 = (
int *)
omAlloc(i *
sizeof(
int));
1549 for (j=0; j<i-1; j++)
1551 if (r->wvhdl[j]!=
NULL)
1553 res->wvhdl[j+1] = (
int*)
omMemDup(r->wvhdl[j]);
1556 res->wvhdl[j+1]=
NULL;
1558 memcpy(&(res->order[1]),r->order,(i-1) *
sizeof(
int));
1559 memcpy(&(res->block0[1]),r->block0,(i-1) *
sizeof(
int));
1560 memcpy(&(res->block1[1]),r->block1,(i-1) *
sizeof(
int));
1572 int length=wv64->
rows();
1574 for(j=length-1;j>=0;j--)
1578 res->wvhdl[0]=(
int *)A;
1580 res->block1[0]=length;
1583 res->names = (
char **)
omAlloc0(
rVar(r) *
sizeof(
char *));
1584 for (i=0; i<
rVar(res); i++)
1588 if (r->qideal!=
NULL)
1594 WerrorS(
"internal error: rCopy0(Q,TRUE,FALSE)");
1599 WarnS(
"internal bad stuff: rCopy0(Q,TRUE,TRUE)");
1636 if (r1 == r2)
return TRUE;
1638 if (r1->cf!=r2->cf)
return FALSE;
1646 for (i=0; i<
rVar(r1); i++)
1648 if ((r1->names[i] !=
NULL) && (r2->names[
i] !=
NULL))
1650 if (strcmp(r1->names[i], r2->names[i]))
return FALSE;
1652 else if ((r1->names[i] !=
NULL) ^ (r2->names[
i] !=
NULL))
1660 if (r1->qideal !=
NULL)
1662 ideal id1 = r1->qideal, id2 = r2->qideal;
1676 else if (r2->qideal !=
NULL)
return FALSE;
1686 if (r1 == r2)
return TRUE;
1690 if ((r1->cf != r2->cf)
1692 || (r1->OrdSgn != r2->OrdSgn))
1696 while (r1->order[i] != 0)
1698 if (r2->order[i] == 0)
return FALSE;
1699 if ((r1->order[i] != r2->order[i])
1700 || (r1->block0[i] != r2->block0[i])
1701 || (r1->block1[i] != r2->block1[i]))
1703 if (r1->wvhdl[i] !=
NULL)
1705 if (r2->wvhdl[i] ==
NULL)
1707 for (j=0; j<r1->block1[
i]-r1->block0[
i]+1; j++)
1708 if (r2->wvhdl[i][j] != r1->wvhdl[i][j])
1711 else if (r2->wvhdl[i] !=
NULL)
return FALSE;
1714 if (r2->order[i] != 0)
return FALSE;
1775 if (blocks == 1)
return TRUE;
1784 if ((blocks - s) > 2)
return FALSE;
1786 assume( blocks == s + 2 );
1850 if (blocks == 1)
return TRUE;
1859 if ((blocks - s) > 3)
return FALSE;
1862 if ((blocks - s) == 3)
1881 for (pos=0;pos<r->OrdSize;pos++)
1899 return (
rVar(r) > 1 &&
1912 return ((
rVar(r) > 1) &&
1921 while(r->order[i]!=0)
1923 if((r->block0[i]<=v)
1924 && (r->block1[i]>=v))
1929 return (r->wvhdl[i][v-r->block0[i]]>0);
1968 if (r->N == 0)
return TRUE;
1985 if (r->VarOffset ==
NULL)
1987 dReportError(
"Null ring VarOffset -- no rComplete (?) in n %s:%d", fn, l);
1992 if ((r->OrdSize==0)!=(r->typ==
NULL))
1994 dReportError(
"mismatch OrdSize and typ-pointer in %s:%d");
2000 for(i=0;i<=r->N;i++)
2004 for(j=0;j<r->OrdSize;j++)
2008 const int p = r->typ[
j].data.isTemp.suffixpos;
2013 assume( p < r->OrdSize );
2015 if(r->typ[p].ord_typ !=
ro_is)
2016 dReportError(
"ordrec prefix %d is unmatched (suffix: %d is wrong!!!)",j, p);
2019 if(r->typ[j].data.isTemp.pVarOffset[i] != -1)
2025 else if (r->typ[j].ord_typ ==
ro_is)
2028 if(r->typ[j].data.is.pVarOffset[i] != -1)
2036 if (r->typ[j].ord_typ==
ro_cp)
2038 if(((
short)r->VarOffset[i]) == r->typ[j].data.cp.place)
2043 && (r->VarOffset[i] == r->typ[j].data.dp.place))
2049 tmp=r->VarOffset[
i] & 0xffffff;
2050 #if SIZEOF_LONG == 8 2051 if ((r->VarOffset[i] >> 24) >63)
2053 if ((r->VarOffset[i] >> 24) >31)
2055 dReportError(
"bit_start out of range:%d",r->VarOffset[i] >> 24);
2056 if (i > 0 && ((tmp<0) ||(tmp>r->ExpL_Size-1)))
2058 dReportError(
"varoffset out of range for var %d: %d",i,tmp);
2063 for(j=0;j<r->OrdSize;j++)
2065 if ((r->typ[j].ord_typ==
ro_dp)
2066 || (r->typ[j].ord_typ==
ro_wp)
2069 if (r->typ[j].data.dp.start > r->typ[j].data.dp.end)
2071 r->typ[j].data.dp.start, r->typ[j].data.dp.end);
2072 if ((r->typ[j].data.dp.start < 1)
2073 || (r->typ[j].data.dp.end > r->N))
2074 dReportError(
"in ordrec %d: start(%d)<1 or end(%d)>vars(%d)",j,
2075 r->typ[j].data.dp.start, r->typ[j].data.dp.end,r->N);
2107 static void rO_TDegree(
int &place,
int &bitplace,
int start,
int end,
2113 ord_struct.
data.dp.start=start;
2114 ord_struct.
data.dp.end=end;
2115 ord_struct.
data.dp.place=place;
2127 ord_struct.
data.dp.start=start;
2128 ord_struct.
data.dp.end=end;
2129 ord_struct.
data.dp.place=place;
2135 static void rO_WDegree(
int &place,
int &bitplace,
int start,
int end,
2136 long *o,
sro_ord &ord_struct,
int *weights)
2139 while((start<end) && (weights[0]==0)) { start++; weights++; }
2140 while((start<end) && (weights[end-start]==0)) { end--; }
2143 for(i=start;i<=end;i++)
2145 if(weights[i-start]!=1)
2153 rO_TDegree(place,bitplace,start,end,o,ord_struct);
2158 ord_struct.
data.wp.start=start;
2159 ord_struct.
data.wp.end=end;
2160 ord_struct.
data.wp.place=place;
2161 ord_struct.
data.wp.weights=weights;
2165 for(i=start;i<=end;i++)
2167 if(weights[i-start]<0)
2175 static void rO_WMDegree(
int &place,
int &bitplace,
int start,
int end,
2176 long *o,
sro_ord &ord_struct,
int *weights)
2185 ord_struct.
data.am.start=start;
2186 ord_struct.
data.am.end=end;
2187 ord_struct.
data.am.place=place;
2188 ord_struct.
data.am.weights=weights;
2189 ord_struct.
data.am.weights_m = weights + (end-start+1);
2190 ord_struct.
data.am.len_gen=weights[end-start+1];
2191 assume( ord_struct.
data.am.weights_m[0] == ord_struct.
data.am.len_gen );
2204 ord_struct.
data.wp64.start=start;
2205 ord_struct.
data.wp64.end=end;
2206 ord_struct.
data.wp64.place=place;
2207 ord_struct.
data.wp64.weights64=weights;
2216 long *o,
sro_ord &ord_struct,
int *weights)
2219 while((start<end) && (weights[0]==0)) { start++; weights++; }
2220 while((start<end) && (weights[end-start]==0)) { end--; }
2223 ord_struct.
data.wp.start=start;
2224 ord_struct.
data.wp.end=end;
2225 ord_struct.
data.wp.place=place;
2226 ord_struct.
data.wp.weights=weights;
2231 for(i=start;i<=end;i++)
2233 if(weights[i-start]<0)
2241 static void rO_LexVars(
int &place,
int &bitplace,
int start,
int end,
2242 int &prev_ord,
long *o,
int *
v,
int bits,
int opt_var)
2247 if(prev_ord==-1)
rO_Align(place,bitplace);
2253 for(k=start;;k+=incr)
2258 v[
k]= place | (bitplace << 24);
2264 assume((opt_var == end+1) ||(opt_var == end-1));
2265 if((opt_var != end+1) &&(opt_var != end-1))
WarnS(
"hier-2");
2266 int save_bitplace=bitplace;
2270 bitplace=save_bitplace;
2274 v[opt_var]=place | (bitplace << 24);
2279 int &prev_ord,
long *o,
int *
v,
int bits,
int opt_var)
2284 if(prev_ord==1)
rO_Align(place,bitplace);
2290 for(k=start;;k+=incr)
2295 v[
k]=place | (bitplace << 24);
2302 assume((opt_var == end+1) ||(opt_var == end-1));
2303 if((opt_var != end+1) &&(opt_var != end-1))
WarnS(
"hier-1");
2304 int save_bitplace=bitplace;
2308 bitplace=save_bitplace;
2312 v[opt_var]=place | (bitplace << 24);
2323 ord_struct.
data.syzcomp.place=place;
2324 ord_struct.
data.syzcomp.Components=
NULL;
2325 ord_struct.
data.syzcomp.ShiftedComponents=
NULL;
2332 static void rO_Syz(
int &place,
int &bitplace,
int &prev_ord,
2340 ord_struct.
data.syz.place=place;
2341 ord_struct.
data.syz.limit=0;
2342 ord_struct.
data.syz.syz_index =
NULL;
2343 ord_struct.
data.syz.curr_index = 1;
2356 long *o,
int ,
int *
v,
sro_ord &ord_struct)
2363 ord_struct.
data.isTemp.start = place;
2364 ord_struct.
data.isTemp.pVarOffset = (
int *)
omMemDup(v);
2365 ord_struct.
data.isTemp.suffixpos = -1;
2373 static void rO_ISSuffix(
int &place,
int &bitplace,
int &prev_ord,
long *o,
2378 int typ_j = typ_i - 1;
2381 if( tmp_typ[typ_j].ord_typ ==
ro_isTemp)
2394 const int start = tmp_typ[typ_j].
data.isTemp.start;
2395 int *pVarOffset = tmp_typ[typ_j].
data.isTemp.pVarOffset;
2406 tmp_typ[typ_j].
data.isTemp.suffixpos = typ_i;
2413 for(
int i = 0;
i <=
N;
i++ )
2416 if( v[
i] != pVarOffset[
i] )
2418 pVarOffset[
i] = v[
i];
2420 assume( pVarOffset[i] != -1 );
2426 if( pVarOffset[0] != -1 )
2427 pVarOffset[0] &= 0x0fff;
2429 sro_ord &ord_struct = tmp_typ[typ_j];
2433 ord_struct.
data.is.start = start;
2434 ord_struct.
data.is.end = place;
2435 ord_struct.
data.is.pVarOffset = pVarOffset;
2457 v[0] = place | (bitplace << 24);
2468 bits=16; bitmask=0xffff;
2470 else if (bitmask <= 1L)
2472 bits=1; bitmask = 1L;
2474 else if (bitmask <= 3L)
2476 bits=2; bitmask = 3L;
2478 else if (bitmask <= 7L)
2482 else if (bitmask <= 0xfL)
2484 bits=4; bitmask=0xfL;
2486 else if (bitmask <= 0x1fL)
2488 bits=5; bitmask=0x1fL;
2490 else if (bitmask <= 0x3fL)
2492 bits=6; bitmask=0x3fL;
2494 #if SIZEOF_LONG == 8 2495 else if (bitmask <= 0x7fL)
2497 bits=7; bitmask=0x7fL;
2500 else if (bitmask <= 0xffL)
2502 bits=8; bitmask=0xffL;
2504 #if SIZEOF_LONG == 8 2505 else if (bitmask <= 0x1ffL)
2507 bits=9; bitmask=0x1ffL;
2510 else if (bitmask <= 0x3ffL)
2512 bits=10; bitmask=0x3ffL;
2514 #if SIZEOF_LONG == 8 2515 else if (bitmask <= 0xfffL)
2517 bits=12; bitmask=0xfff;
2520 else if (bitmask <= 0xffffL)
2522 bits=16; bitmask=0xffffL;
2524 #if SIZEOF_LONG == 8 2525 else if (bitmask <= 0xfffffL)
2527 bits=20; bitmask=0xfffffL;
2529 else if (bitmask <= 0xffffffffL)
2531 bits=32; bitmask=0xffffffffL;
2533 else if (bitmask <= 0x7fffffffffffffffL)
2535 bits=63; bitmask=0x7fffffffffffffffL;
2539 bits=63; bitmask=0x7fffffffffffffffL;
2542 else if (bitmask <= 0x7fffffff)
2544 bits=31; bitmask=0x7fffffff;
2548 bits=31; bitmask=0x7fffffffL;
2559 #if SIZEOF_LONG == 8 2574 unsigned long bitmask1 =
rGetExpSize(bitmask+1, bits1);
2576 if ((((N+vars_per_long-1)/vars_per_long) ==
2577 ((N+vars_per_long1-1)/vars_per_long1)))
2579 vars_per_long=vars_per_long1;
2599 unsigned long exp_limit)
2606 int iNeedInducedOrderingSetup = 0;
2610 need_other_ring = (exp_limit != r->bitmask);
2613 int *order=(
int*)
omAlloc0((nblocks+1)*
sizeof(int));
2614 int *block0=(
int*)
omAlloc0((nblocks+1)*
sizeof(int));
2615 int *block1=(
int*)
omAlloc0((nblocks+1)*
sizeof(int));
2616 int **wvhdl=(
int**)
omAlloc0((nblocks+1)*
sizeof(
int *));
2621 for(
int r_ord=r->order[i]; (r_ord != 0) && (i < nblocks); j++, r_ord=r->order[++
i])
2625 if (r->block0[i]==r->block1[i])
2650 Warn(
"Error: unhandled ordering in rModifyRing: ringorder_S = [%d]", r_ord);
2664 need_other_ring=
TRUE;
2665 try_omit_comp=
FALSE;
2666 copy_block_index=
FALSE;
2680 need_other_ring=
TRUE;
2682 omitted_degree =
TRUE;
2696 need_other_ring=
TRUE;
2698 omitted_degree =
TRUE;
2706 try_omit_comp =
FALSE;
2709 iNeedInducedOrderingSetup++;
2714 assume((i == 0) && (j == 0));
2718 try_omit_comp =
FALSE;
2727 if (copy_block_index)
2729 block0[
j]=r->block0[
i];
2730 block1[
j]=r->block1[
i];
2731 wvhdl[
j]=r->wvhdl[
i];
2736 if(!need_other_ring)
2748 res->GetNC() =
NULL;
2756 res->bitmask=exp_limit;
2763 if (r->pFDegOrig != res->pFDegOrig &&
2768 res->firstwv = r->firstwv;
2769 res->firstBlockEnds = r->firstBlockEnds;
2773 res->pLDeg = r->pLDegOrig;
2778 if (res->typ !=
NULL)
2780 if( res->typ[0].ord_typ ==
ro_syz)
2782 res->typ[0] = r->typ[0];
2784 if (r->typ[0].data.syz.limit > 0)
2786 res->typ[0].data.syz.syz_index
2787 = (
int*)
omAlloc((r->typ[0].data.syz.limit +1)*
sizeof(int));
2788 memcpy(res->typ[0].data.syz.syz_index, r->typ[0].data.syz.syz_index,
2789 (r->typ[0].data.syz.limit +1)*
sizeof(
int));
2793 if( iNeedInducedOrderingSetup > 0 )
2795 for(j = 0, i = 0; (i < nblocks) && (iNeedInducedOrderingSetup > 0); i++)
2796 if( res->typ[i].ord_typ ==
ro_is )
2798 ideal F =
idrHeadR(r->typ[i].data.is.F, r, res);
2802 r->typ[i].data.is.limit,
2807 iNeedInducedOrderingSetup--;
2813 res->OrdSgn=r->OrdSgn;
2822 WarnS(
"error in nc_rComplete");
2835 WarnS(
"error in sca_Force!");
2849 res->GetNC() =
NULL;
2853 res->wvhdl = (
int **)
omAlloc0(3 *
sizeof(
int *));
2855 res->order = (
int *)
omAlloc(3 *
sizeof(
int *));
2856 res->block0 = (
int *)
omAlloc0(3 *
sizeof(
int *));
2857 res->block1 = (
int *)
omAlloc0(3 *
sizeof(
int *));
2861 res->block1[0] = r->N;
2862 res->wvhdl[0] = weights;
2877 WarnS(
"error in nc_rComplete");
2904 int nblocks=1+(ommit_comp!=0);
2905 int *order=(
int*)
omAlloc0((nblocks+1)*
sizeof(int));
2906 int *block0=(
int*)
omAlloc0((nblocks+1)*
sizeof(int));
2907 int *block1=(
int*)
omAlloc0((nblocks+1)*
sizeof(int));
2908 int **wvhdl=(
int**)
omAlloc0((nblocks+1)*
sizeof(
int *));
2920 res->GetNC() =
NULL;
2927 res->bitmask=exp_limit;
2938 WarnS(
"error in nc_rComplete");
2954 return rModifyRing(r, ommit_degree, ommit_comp, exp_limit);
2987 r->CanShortOut =
TRUE;
2992 for (i=0;i<
rPar(r);i++)
2996 r->CanShortOut=
FALSE;
3007 if (r->N < N) N = r->N;
3009 for (i=(N-1);i>=0;i--)
3011 if(r->names[i] !=
NULL && strlen(r->names[i])>1)
3013 r->CanShortOut=
FALSE;
3019 r->ShortOut = r->CanShortOut;
3021 assume( !( !r->CanShortOut && r->ShortOut ) );
3043 if (r->OrdSgn==-1) r->MixedOrder=
TRUE;
3053 if (r->wvhdl[o]!=
NULL)
3056 for(i=r->block1[o]-r->block0[o];i>=0;i--)
3057 if (r->wvhdl[o][i]<0) { r->MixedOrder=2;
break; }
3061 r->ComponentOrder=1;
3065 r->ComponentOrder=
TRUE;
3073 if( r->block0[o] != 0 )
3074 r->ComponentOrder = r->block0[o];
3083 dReportError(
"wrong internal ordering:%d at %s, l:%d\n",o_r,__FILE__,__LINE__);
3087 static void rSetFirstWv(ring r,
int i,
int* order,
int* block1,
int** wvhdl)
3092 if(block1[i]!=r->N) r->LexOrder=
TRUE;
3093 r->firstBlockEnds=block1[
i];
3094 r->firstwv = wvhdl[
i];
3103 for(j=block1[i]-r->block0[i];j>=0;j--)
3105 if (r->firstwv[j]<0) r->MixedOrder=
TRUE;
3106 if (r->firstwv[j]==0) r->LexOrder=
TRUE;
3113 for(j=block1[i]-r->block0[i];j>=0;j--)
3115 if (w[j]==0) r->LexOrder=
TRUE;
3122 if (r->pFDeg ==
p_Deg)
3143 r->pLDegOrig = r->pLDeg;
3149 int* order = r->order;
3150 int* block0 = r->block0;
3151 int* block1 = r->block1;
3152 int** wvhdl = r->wvhdl;
3161 r->LexOrder =
FALSE;
3162 r->MixedOrder =
FALSE;
3163 r->ComponentOrder = 1;
3170 r->MixedOrder =
FALSE;
3171 for(
int ii=block0[0];ii<=block1[0];ii++)
3172 if (wvhdl[0][ii-1]<0) { r->MixedOrder=2;
break;}
3174 for(
int ii=block0[0];ii<=block1[0];ii++)
3175 if (wvhdl[0][ii-1]==0) { r->LexOrder=
TRUE;
break;}
3176 if ((block0[0]==1)&&(block1[0]==r->N))
3187 r->firstwv = wvhdl[0];
3202 r->ComponentOrder=-1;
3203 if (r->OrdSgn == -1) r->pLDeg =
pLDeg0c;
3222 for(
int ii=block0[0];ii<=block1[0];ii++)
3224 if (wvhdl[0][ii-1]<0) { r->MixedOrder=2;
break;}
3226 if (r->MixedOrder==0)
3231 r->firstBlockEnds=block1[0];
3232 r->firstwv = wvhdl[0];
3244 r->ComponentOrder=-1;
3254 r->firstBlockEnds=block1[1];
3255 if (wvhdl!=
NULL) r->firstwv = wvhdl[1];
3263 for(
int ii=block0[1];ii<=block1[1];ii++)
3264 if (wvhdl[1][ii-1]<0) { r->MixedOrder=2;
break;}
3265 if (r->MixedOrder==
FALSE)
3282 int i = 0;
while (order[++i] != 0);
3307 if(r->MixedOrder==
FALSE)
3322 r->pFDegOrig = r->pFDeg;
3338 for(i=0;i<r->OrdSize;i++)
3341 ||(r->typ[i].ord_typ==
ro_am))
3346 r->NegWeightL_Size=
l;
3347 r->NegWeightL_Offset=(
int *)
omAlloc(l*
sizeof(
int));
3349 for(i=0;i<r->OrdSize;i++)
3353 r->NegWeightL_Offset[
l]=r->typ[
i].data.wp.place;
3356 else if(r->typ[i].ord_typ==
ro_am)
3358 r->NegWeightL_Offset[
l]=r->typ[
i].data.am.place;
3365 r->NegWeightL_Size = 0;
3366 r->NegWeightL_Offset =
NULL;
3378 if ( (r->cf->extRing!=
NULL)
3387 if (r->LexOrder || r->OrdSgn == -1 || (r->cf->extRing!=
NULL))
3404 r->pLexOrder=r->LexOrder;
3412 static inline int sign(
int x) {
return (x > 0) - (x < 0);}
3420 for(i=2;i<=
rVar(r);i++)
3437 if (r->VarOffset!=
NULL && force == 0)
return FALSE;
3443 r->BitsPerExp = bits;
3446 if (r->OrdSgn!=-1) r->OrdSgn=1;
3449 long *tmp_ordsgn=(
long *)
omAlloc0(3*(n+r->N)*
sizeof(long));
3451 int *
v=(
int *)
omAlloc((r->N+1)*
sizeof(int));
3452 for(i=r->N; i>=0 ; i--)
3469 switch (r->order[i])
3473 rO_WDegree(j,j_bits,r->block0[i],r->block1[i],tmp_ordsgn,tmp_typ[typ_i],
3479 rO_WMDegree(j,j_bits,r->block0[i],r->block1[i],tmp_ordsgn,tmp_typ[typ_i],
3485 rO_WDegree64(j,j_bits,r->block0[i],r->block1[i],tmp_ordsgn,
3486 tmp_typ[typ_i], (
int64 *)(r->wvhdl[i]));
3503 k=r->block1[
i]-r->block0[
i]+1;
3506 rO_WDegree(j,j_bits,r->block0[i],r->block1[i],tmp_ordsgn,
3508 r->wvhdl[i]+(r->block1[i]-r->block0[i]+1)*l);
3515 rO_LexVars(j, j_bits, r->block0[i],r->block1[i], prev_ordsgn,
3516 tmp_ordsgn,v,bits, -1);
3520 rO_LexVars_neg(j, j_bits, r->block0[i],r->block1[i], prev_ordsgn,
3521 tmp_ordsgn,v, bits, -1);
3526 rO_LexVars_neg(j, j_bits, r->block1[i],r->block0[i], prev_ordsgn,
3527 tmp_ordsgn,v, bits, -1);
3532 rO_LexVars(j, j_bits, r->block1[i],r->block0[i], prev_ordsgn,
3533 tmp_ordsgn,v, bits, -1);
3537 if (r->block0[i]==r->block1[i])
3539 rO_LexVars(j, j_bits, r->block0[i],r->block0[i], prev_ordsgn,
3540 tmp_ordsgn,v, bits, -1);
3544 rO_TDegree(j,j_bits,r->block0[i],r->block1[i],tmp_ordsgn,
3548 prev_ordsgn,tmp_ordsgn,v,bits, r->block0[i]);
3553 if (r->block0[i]==r->block1[i])
3555 rO_LexVars(j, j_bits, r->block0[i],r->block0[i], prev_ordsgn,
3556 tmp_ordsgn,v, bits, -1);
3560 rO_TDegree(j,j_bits,r->block0[i],r->block1[i],tmp_ordsgn,
3563 rO_LexVars(j, j_bits, r->block0[i],r->block1[i]-1, prev_ordsgn,
3564 tmp_ordsgn,v, bits, r->block1[i]);
3569 if (r->block0[i]==r->block1[i])
3572 tmp_ordsgn,v,bits, -1);
3580 prev_ordsgn,tmp_ordsgn,v,bits, r->block0[i]);
3586 if (r->block0[i]==r->block1[i])
3589 tmp_ordsgn,v, bits, -1);
3596 rO_LexVars(j, j_bits, r->block0[i],r->block1[i]-1, prev_ordsgn,
3597 tmp_ordsgn,v, bits, r->block1[i]);
3603 rO_WDegree(j,j_bits,r->block0[i],r->block1[i],tmp_ordsgn,
3604 tmp_typ[typ_i], r->wvhdl[i]);
3609 for(jj=r->block1[i]-r->block0[i];jj>=0; jj--)
3611 if (r->wvhdl[i][jj]<=0) have_bad_weights=
TRUE;
3613 if (have_bad_weights)
3615 rO_TDegree(j,j_bits,r->block0[i],r->block1[i],tmp_ordsgn,
3621 if (r->block1[i]!=r->block0[i])
3623 rO_LexVars_neg(j, j_bits,r->block1[i],r->block0[i]+1, prev_ordsgn,
3624 tmp_ordsgn, v,bits, r->block0[i]);
3629 rO_WDegree(j,j_bits,r->block0[i],r->block1[i],tmp_ordsgn,
3630 tmp_typ[typ_i], r->wvhdl[i]);
3635 for(jj=r->block1[i]-r->block0[i];jj>=0; jj--)
3637 if (r->wvhdl[i][jj]<=0) have_bad_weights=
TRUE;
3639 if (have_bad_weights)
3641 rO_TDegree(j,j_bits,r->block0[i],r->block1[i],tmp_ordsgn,
3647 if (r->block1[i]!=r->block0[i])
3649 rO_LexVars(j, j_bits,r->block0[i],r->block1[i]-1, prev_ordsgn,
3650 tmp_ordsgn,v, bits, r->block1[i]);
3656 tmp_typ[typ_i], r->wvhdl[i]);
3658 if (r->block1[i]!=r->block0[i])
3660 rO_LexVars_neg(j, j_bits,r->block1[i],r->block0[i]+1, prev_ordsgn,
3661 tmp_ordsgn, v,bits, r->block0[i]);
3668 tmp_typ[typ_i], r->wvhdl[i]);
3670 if (r->block1[i]!=r->block0[i])
3672 rO_LexVars(j, j_bits,r->block0[i],r->block1[i]-1, prev_ordsgn,
3673 tmp_ordsgn,v, bits, r->block1[i]);
3681 rO_Syzcomp(j, j_bits,prev_ordsgn, tmp_ordsgn,tmp_typ[typ_i]);
3682 need_to_add_comp=
TRUE;
3687 assume(typ_i == 0 && j == 0);
3688 rO_Syz(j, j_bits, prev_ordsgn, tmp_ordsgn, tmp_typ[typ_i]);
3689 need_to_add_comp=
TRUE;
3696 assume( r->block0[i] == r->block1[i] );
3697 const int s = r->block0[
i];
3698 assume( -2 < s && s < 2);
3701 rO_ISPrefix(j, j_bits, prev_ordsgn, tmp_ordsgn, r->N, v, tmp_typ[typ_i++]);
3704 rO_ISSuffix(j, j_bits, prev_ordsgn, tmp_ordsgn, r->N, v, tmp_typ, typ_i, s);
3705 need_to_add_comp=
FALSE;
3723 j_bits=j_bits0; j=j0;
3728 if((need_to_add_comp) && (v[0]== -1))
3742 for(i=1 ; i<=r->N ; i++)
3748 rO_LexVars(j, j_bits, i,i, prev_ordsgn,tmp_ordsgn,v,bits, -1);
3769 r->ordsgn=(
long *)
omAlloc0(r->ExpL_Size*
sizeof(
long));
3771 for(j=0;j<r->CmpL_Size;j++)
3773 r->ordsgn[
j] = tmp_ordsgn[
j];
3782 if (typ_i==0) r->typ=
NULL;
3786 memcpy(r->typ,tmp_typ,typ_i*
sizeof(
sro_ord));
3796 r->pCompIndex=(r->VarOffset[0] & 0xffff);
3799 if (i==r->pCompIndex) i++;
3800 while ((j < r->OrdSize)
3808 if (i==r->pCompIndex) i++;
3843 if (r->OrdSgn==-1)
return;
3845 for(
int i=1;i<=r->N;i++)
3849 for(
int j=0;(
j<=
b) && (found==0);
j++)
3852 if ((r->block0[
j]<=i)&&(r->block1[
j]>=
i))
3871 if(r->wvhdl[
j][i-r->block0[
j]]<0) { r->OrdSgn=-1;
return;}
3872 if(r->wvhdl[
j][i-r->block0[
j]]>0) { found=1;
break;}
3883 if (r ==
NULL)
return;
3884 if (r->VarOffset !=
NULL)
3886 if (r->OrdSize!=0 && r->typ !=
NULL)
3888 for(
int i = 0; i < r->OrdSize; i++)
3889 if( r->typ[i].ord_typ ==
ro_is)
3892 r->typ[
i].data.is.F =
NULL;
3894 if( r->typ[i].data.is.pVarOffset !=
NULL )
3897 r->typ[
i].data.is.pVarOffset =
NULL;
3900 else if (r->typ[i].ord_typ ==
ro_syz)
3902 if(r->typ[i].data.syz.limit > 0)
3903 omFreeSize(r->typ[i].data.syz.syz_index, ((r->typ[i].data.syz.limit) +1)*
sizeof(
int));
3904 r->typ[
i].data.syz.syz_index =
NULL;
3908 assume( r->typ[i].data.syzcomp.ShiftedComponents ==
NULL );
3909 assume( r->typ[i].data.syzcomp.Components ==
NULL );
3919 if (r->PolyBin !=
NULL)
3924 if (r->ordsgn !=
NULL && r->CmpL_Size != 0)
3926 if (r->p_Procs !=
NULL)
3928 omfreeSize(r->VarL_Offset, r->VarL_Size*
sizeof(
int));
3930 if (r->NegWeightL_Offset!=
NULL)
3932 omFreeSize(r->NegWeightL_Offset, r->NegWeightL_Size*
sizeof(
int));
3933 r->NegWeightL_Offset=
NULL;
3941 int* VarL_Number = (
int*)
omAlloc0(r->ExpL_Size*
sizeof(
int));
3946 for (i=1; i<=r->N; i++)
3948 VarL_Number[r->VarOffset[
i] & 0xffffff]++;
3952 for (i=0, j=0; i<r->ExpL_Size; i++)
3954 if (VarL_Number[i] != 0)
3956 if (min > VarL_Number[i])
3958 min = VarL_Number[
i];
3967 r->VarL_Offset = (
int*)
omAlloc(r->VarL_Size*
sizeof(
int));
3968 r->VarL_LowIndex = 0;
3971 for (i=0, j=0; i<r->ExpL_Size; i++)
3973 if (VarL_Number[i] != 0)
3975 r->VarL_Offset[
j] =
i;
3976 if (j > 0 && r->VarL_Offset[j-1] != r->VarL_Offset[j] - 1)
3977 r->VarL_LowIndex = -1;
3981 if (r->VarL_LowIndex >= 0)
3982 r->VarL_LowIndex = r->VarL_Offset[0];
3986 j = r->VarL_Offset[min_j];
3987 r->VarL_Offset[min_j] = r->VarL_Offset[0];
3988 r->VarL_Offset[0] =
j;
3995 int* shifts = (
int*)
omAlloc(r->ExpL_Size*
sizeof(
int));
3998 for (i=0;i<r->ExpL_Size;i++)
4002 for (i=1;i<=r->N;i++)
4004 if (shifts[r->VarOffset[i] & 0xffffff] > r->VarOffset[i] >> 24)
4005 shifts[r->VarOffset[
i] & 0xffffff] = r->VarOffset[
i] >> 24;
4008 for (i=1;i<=r->N;i++)
4010 if (shifts[r->VarOffset[i] & 0xffffff] != 0)
4012 = (r->VarOffset[
i] & 0xffffff) |
4013 (((r->VarOffset[i] >> 24) - shifts[r->VarOffset[
i] & 0xffffff]) << 24);
4021 unsigned long divmask = 1;
4026 divmask |= (((
unsigned long) 1) << (
unsigned long) i);
4041 const char *TYP[]={
"ro_dp",
"ro_wp",
"ro_am",
"ro_wp64",
"ro_wp_neg",
"ro_cp",
4042 "ro_syzcomp",
"ro_syz",
"ro_isTemp",
"ro_is",
"ro_none"};
4045 Print(
"ExpL_Size:%d ",r->ExpL_Size);
4046 Print(
"CmpL_Size:%d ",r->CmpL_Size);
4047 Print(
"VarL_Size:%d\n",r->VarL_Size);
4048 Print(
"bitmask=0x%lx (expbound=%ld) \n",r->bitmask, r->bitmask);
4049 Print(
"divmask=%lx\n", r->divmask);
4050 Print(
"BitsPerExp=%d ExpPerLong=%d at L[%d]\n", r->BitsPerExp, r->ExpPerLong, r->VarL_Offset[0]);
4052 Print(
"VarL_LowIndex: %d\n", r->VarL_LowIndex);
4053 PrintS(
"VarL_Offset:\n");
4056 for(j = 0; j < r->VarL_Size; j++)
4057 Print(
" VarL_Offset[%d]: %d ", j, r->VarL_Offset[j]);
4064 for(j=0;j<=r->N;j++)
4065 Print(
" v%d at e-pos %d, bit %d\n",
4066 j,r->VarOffset[j] & 0xffffff, r->VarOffset[j] >>24);
4068 for(j=0;j<r->CmpL_Size;j++)
4069 Print(
" ordsgn %ld at pos %d\n",r->ordsgn[j],j);
4070 Print(
"OrdSgn:%d\n",r->OrdSgn);
4072 for(j=0;j<r->OrdSize;j++)
4074 Print(
" typ %s", TYP[r->typ[j].ord_typ]);
4075 if (r->typ[j].ord_typ==
ro_syz)
4077 const short place = r->typ[
j].data.syz.place;
4078 const int limit = r->typ[
j].data.syz.limit;
4079 const int curr_index = r->typ[
j].data.syz.curr_index;
4080 const int* syz_index = r->typ[
j].data.syz.syz_index;
4082 Print(
" limit %d (place: %d, curr_index: %d), syz_index: ", limit, place, curr_index);
4084 if( syz_index ==
NULL )
4089 for( i=0; i <= limit; i++ )
4090 Print(
"%d ", syz_index[i]);
4097 Print(
" start (level) %d, suffixpos: %d, VO: ",r->typ[j].data.isTemp.start, r->typ[j].data.isTemp.suffixpos);
4100 else if (r->typ[j].ord_typ==
ro_is)
4102 Print(
" start %d, end: %d: ",r->typ[j].data.is.start, r->typ[j].data.is.end);
4106 Print(
" limit %d",r->typ[j].data.is.limit);
4113 else if (r->typ[j].ord_typ==
ro_am)
4115 Print(
" place %d",r->typ[j].data.am.place);
4116 Print(
" start %d",r->typ[j].data.am.start);
4117 Print(
" end %d",r->typ[j].data.am.end);
4118 Print(
" len_gen %d",r->typ[j].data.am.len_gen);
4121 for(l=r->typ[j].data.am.start;l<=r->typ[j].data.am.end;l++)
4122 Print(
" %d",r->typ[j].data.am.weights[l-r->typ[j].data.am.start]);
4123 l=r->typ[
j].data.am.end+1;
4124 int ll=r->typ[
j].data.am.weights[l-r->typ[
j].data.am.start];
4126 for(
int lll=l+1;lll<l+ll+1;lll++)
4127 Print(
" %d",r->typ[j].data.am.weights[lll-r->typ[j].data.am.start]);
4131 Print(
" place %d",r->typ[j].data.dp.place);
4135 Print(
" start %d",r->typ[j].data.dp.start);
4136 Print(
" end %d",r->typ[j].data.dp.end);
4137 if ((r->typ[j].ord_typ==
ro_wp)
4141 for(
int l=r->typ[j].data.wp.start;l<=r->typ[j].data.wp.end;
l++)
4142 Print(
" %d",r->typ[j].data.wp.weights[
l-r->typ[j].data.wp.start]);
4144 else if (r->typ[j].ord_typ==
ro_wp64)
4148 for(l=r->typ[j].data.wp64.start;l<=r->typ[j].data.wp64.end;l++)
4149 Print(
" %ld",(
long)(((
int64*)r->typ[j].data.wp64.weights64)+l-r->typ[j].data.wp64.start));
4155 Print(
"pOrdIndex:%d pCompIndex:%d\n", r->pOrdIndex, r->pCompIndex);
4156 Print(
"OrdSize:%d\n",r->OrdSize);
4157 PrintS(
"--------------------\n");
4158 for(j=0;j<r->ExpL_Size;j++)
4161 if (j< r->CmpL_Size)
4162 Print(
"ordsgn %ld ", r->ordsgn[j]);
4168 if( (r->VarOffset[i] & 0xffffff) == j )
4169 {
Print(
"v%d at e[%d], bit %d; ", i,r->VarOffset[i] & 0xffffff,
4170 r->VarOffset[i] >>24 ); }
4172 if( r->pCompIndex==j )
PrintS(
"v0; ");
4173 for(i=0;i<r->OrdSize;i++)
4175 if (r->typ[i].data.dp.place == j)
4177 Print(
"ordrec:%s (start:%d, end:%d) ",TYP[r->typ[i].ord_typ],
4178 r->typ[i].data.dp.start, r->typ[i].data.dp.end);
4182 if (j==r->pOrdIndex)
4187 Print(
"LexOrder:%d, MixedOrder:%d\n",r->LexOrder, r->MixedOrder);
4189 Print(
"NegWeightL_Size: %d, NegWeightL_Offset: ", r->NegWeightL_Size);
4190 if (r->NegWeightL_Offset==
NULL)
PrintS(
" NULL");
4192 for(j = 0; j < r->NegWeightL_Size; j++)
4193 Print(
" [%d]: %d ", j, r->NegWeightL_Offset[j]);
4204 Print(
"p_Spec : %s, %s, %s\n", field, length, ord);
4206 for (i=0; i<(int) (
sizeof(
p_Procs_s)/
sizeof(
void*)); i++)
4208 Print(
" %s,\n", ((
char**) &proc_names)[i]);
4214 #define pFDeg_CASE(A) if(r->pFDeg == A) PrintS( "" #A "" ) 4220 Print(
"(%p)", r->pFDeg);
4223 Print(
"pLDeg : (%p)", r->pLDeg);
4231 if (r->p_Setm==p_Setm_General)
PrintS(
"p_Setm_General\n");
4232 else if (r->p_Setm==p_Setm_Dummy)
PrintS(
"p_Setm_Dummy\n");
4233 else if (r->p_Setm==p_Setm_TotalDegree)
PrintS(
"p_Setm_Totaldegree\n");
4234 else if (r->p_Setm==p_Setm_WFirstTotalDegree)
PrintS(
"p_Setm_WFirstTotalDegree\n");
4235 else Print(
"%p\n",r->p_Setm);
4245 Print(
"\nexp[0..%d]\n",r->ExpL_Size-1);
4246 for(i=0;i<r->ExpL_Size;i++)
4247 Print(
"%ld ",p->exp[i]);
4254 if (j==0) {
PrintS(
"...\n");
break; }
4263 Print(
"\nexp[0..%d]\n", R->ExpL_Size - 1);
4264 for(
int i = 0; i < R->ExpL_Size; i++)
4265 Print(
"%09lx ", p->exp[i]);
4268 for(
int i = 1; i <= R->N; i++)
Print(
" v%d:%5ld",i,
p_GetExp(p, i, R));
4283 for(
int j = (F->ncols*F->nrows) - 1;
j >= 0;
j-- )
4297 Print(
"gen[%d] -> gen(%d)\n", c, MIN + (*V)[ c - MIN - 1 ]);
4300 p_SetComp(
p, MIN + (*V)[ c - MIN - 1 ], r );
4321 r->typ[1].data.syzcomp.Components = currComponents;
4328 *currShiftedComponents = r->typ[1].data.syzcomp.ShiftedComponents;
4329 *currComponents = r->typ[1].data.syzcomp.Components;
4339 r->typ[1].data.syzcomp.length = length;
4349 *length = r->typ[1].data.syzcomp.length;
4350 rNGetSComps( currComponents, currShiftedComponents, r);
4366 rDBGetSComps(currComponents, currShiftedComponents, length, r);
4368 rNGetSComps(currComponents, currShiftedComponents, r);
4391 WarnS(
"rAssure_SyzComp: input ring has an IS-ordering!");
4399 res->order=(
int *)
omAlloc((i+1)*
sizeof(int));
4400 res->block0=(
int *)
omAlloc0((i+1)*
sizeof(int));
4401 res->block1=(
int *)
omAlloc0((i+1)*
sizeof(int));
4402 int ** wvhdl =(
int **)
omAlloc0((i+1)*
sizeof(
int**));
4405 res->order[
j]=r->order[j-1];
4406 res->block0[
j]=r->block0[j-1];
4407 res->block1[
j]=r->block1[j-1];
4408 if (r->wvhdl[j-1] !=
NULL)
4410 wvhdl[
j] = (
int*)
omMemDup(r->wvhdl[j-1]);
4427 WarnS(
"error in nc_rComplete");
4438 if (r->qideal!=
NULL)
4470 for(i=r->OrdSize-1;i>=0;i--)
4472 if ((r->typ[i].ord_typ==
ro_dp)
4473 && (r->typ[i].data.dp.start==start_var)
4474 && (r->typ[i].data.dp.end==end_var))
4476 pos=r->typ[
i].data.dp.place;
4492 res->ExpL_Size=r->ExpL_Size+1;
4495 res->ordsgn=(
long *)
omAlloc0(res->ExpL_Size*
sizeof(
long));
4496 for(j=0;j<r->CmpL_Size;j++)
4498 res->ordsgn[
j] = r->ordsgn[
j];
4500 res->OrdSize=r->OrdSize+1;
4505 memcpy(res->typ,r->typ,r->OrdSize*
sizeof(
sro_ord));
4508 res->typ[res->OrdSize-1].ord_typ=
ro_dp;
4509 res->typ[res->OrdSize-1].data.dp.start=start_var;
4510 res->typ[res->OrdSize-1].data.dp.end=end_var;
4511 res->typ[res->OrdSize-1].data.dp.place=res->ExpL_Size-1;
4512 pos=res->ExpL_Size-1;
4529 WarnS(
"error in nc_rComplete");
4535 if (r->qideal!=
NULL)
4565 if (r->order[i] == 0)
4574 new_r->wvhdl=(
int **)
omAlloc0(i *
sizeof(
int *));
4575 new_r->order = (
int *)
omAlloc0(i *
sizeof(
int));
4576 new_r->block0 = (
int *)
omAlloc0(i *
sizeof(
int));
4577 new_r->block1 = (
int *)
omAlloc0(i *
sizeof(
int));
4578 memcpy(new_r->order,r->order,(i-1) *
sizeof(
int));
4579 memcpy(new_r->block0,r->block0,(i-1) *
sizeof(
int));
4580 memcpy(new_r->block1,r->block1,(i-1) *
sizeof(
int));
4581 for (
int j=0;
j<=last_block;
j++)
4583 if (r->wvhdl[
j]!=
NULL)
4585 new_r->wvhdl[
j] = (
int*)
omMemDup(r->wvhdl[
j]);
4602 WarnS(
"error in nc_rComplete");
4614 int last_block =
rBlocks(r) - 2;
4621 for (i=0; i< last_block; i++)
4632 for (i=c_pos+1; i<=last_block; i++)
4634 new_r->order[i-1] = new_r->order[
i];
4635 new_r->block0[i-1] = new_r->block0[
i];
4636 new_r->block1[i-1] = new_r->block1[
i];
4637 new_r->wvhdl[i-1] = new_r->wvhdl[
i];
4639 new_r->order[last_block] = r->order[c_pos];
4640 new_r->block0[last_block] = r->block0[c_pos];
4641 new_r->block1[last_block] = r->block1[c_pos];
4642 new_r->wvhdl[last_block] = r->wvhdl[c_pos];
4653 WarnS(
"error in nc_rComplete");
4678 if (new_r_1 != new_r && new_r_1 != old_r)
rDelete(new_r_1);
4686 # ifndef SING_NDEBUG 4687 WarnS(
"error in nc_rComplete");
4694 if (old_r->qideal !=
NULL)
4696 new_r->qideal =
idrCopyR(old_r->qideal, old_r, new_r);
4704 WarnS(
"error in nc_SetupQuotient");
4729 if ((r_blocks == 3) &&
4730 (r->order[0] == b1) &&
4731 (r->order[1] == b2) &&
4735 res->order = (
int*)
omAlloc0(3*
sizeof(
int));
4736 res->block0 = (
int*)
omAlloc0(3*
sizeof(
int));
4737 res->block1 = (
int*)
omAlloc0(3*
sizeof(
int));
4738 res->wvhdl = (
int**)
omAlloc0(3*
sizeof(
int*));
4744 res->block1[1] = r->N;
4749 res->block1[0] = r->N;
4758 WarnS(
"error in nc_rComplete");
4771 Print(
"rAssure_InducedSchreyerOrdering(r, complete = %d, sgn = %d): r: \n", complete,
sgn);
4785 res->order=(
int *)
omAlloc0((n+2)*
sizeof(int));
4786 res->block0=(
int *)
omAlloc0((n+2)*
sizeof(int));
4787 res->block1=(
int *)
omAlloc0((n+2)*
sizeof(int));
4788 int ** wvhdl =(
int **)
omAlloc0((n+2)*
sizeof(
int**));
4796 res->block0[
j] = res->block1[
j] = 0;
4800 for(
int i = 0; (i <= n) && (r->order[i] != 0); i++, j++)
4802 res->order [
j] = r->order [
i];
4803 res->block0[
j] = r->block0[
i];
4804 res->block1[
j] = r->block1[
i];
4806 if (r->wvhdl[i] !=
NULL)
4808 wvhdl[
j] = (
int*)
omMemDup(r->wvhdl[i]);
4814 res->block0[
j] = res->block1[
j] =
sgn;
4825 assume(res->order[j]==0);
4838 WarnS(
"error in nc_rComplete");
4850 if (r->qideal!=
NULL)
4907 Print(
"rIsIS(p: %d)\nF:", p);
4918 for(
int pos = 0; pos < r->OrdSize; pos++ )
4919 if( r->typ[pos].ord_typ ==
ro_is)
4941 dReportError(
"Error: WRONG USE of rSetISReference: wrong ring! (typ == NULL)");
4950 dReportError(
"Error: WRONG USE of rSetISReference: specified ordering block was not found!!!" );
4955 if( i != r->typ[pos].data.is.limit )
4956 Print(
"Changing record on pos: %d\nOld limit: %d --->> New Limit: %d\n", pos, r->typ[pos].data.is.limit, i);
4959 const ideal FF =
idrHeadR(F, r, r);
4962 if( r->typ[pos].data.is.F !=
NULL)
4965 PrintS(
"Deleting old reference set F... \n");
4968 r->typ[pos].data.is.F =
NULL;
4973 r->typ[pos].data.is.F = FF;
4975 r->typ[pos].data.is.limit =
i;
4999 if ((r->typ!=
NULL) && (r->typ[0].ord_typ==
ro_syz))
5001 if( k == r->typ[0].data.syz.limit )
5005 if (r->typ[0].data.syz.limit == 0)
5007 r->typ[0].data.syz.syz_index = (
int*)
omAlloc0((k+1)*
sizeof(int));
5008 r->typ[0].data.syz.syz_index[0] = 0;
5009 r->typ[0].data.syz.curr_index = 1;
5013 r->typ[0].data.syz.syz_index = (
int*)
5015 (r->typ[0].data.syz.limit+1)*
sizeof(int),
5018 for (i=r->typ[0].data.syz.limit + 1; i<= k; i++)
5020 r->typ[0].data.syz.syz_index[
i] =
5021 r->typ[0].data.syz.curr_index;
5023 if(k < r->typ[0].data.syz.limit)
5026 Warn(
"rSetSyzComp called with smaller limit (%d) as before (%d)", k, r->typ[0].data.syz.limit);
5028 r->typ[0].data.syz.curr_index = 1 + r->typ[0].data.syz.syz_index[
k];
5032 r->typ[0].data.syz.limit =
k;
5033 r->typ[0].data.syz.curr_index++;
5042 Warn(
"rSetSyzComp(%d) in an IS ring! Be careful!", k);
5059 if ((r->typ!=
NULL) && (r->typ[0].ord_typ==
ro_syz) &&
5060 r->typ[0].data.syz.limit > 0 && i > 0)
5062 assume(i <= r->typ[0].data.syz.limit);
5064 for (j=0; j<r->typ[0].data.syz.limit; j++)
5066 if (r->typ[0].data.syz.syz_index[j] == i &&
5067 r->typ[0].data.syz.syz_index[j+1] != i)
5069 assume(r->typ[0].data.syz.syz_index[j+1] == i+1);
5073 return r->typ[0].data.syz.limit;
5085 for (i=0; i<nb; i++)
5087 if (r->wvhdl[i] !=
NULL)
5089 int length = r->block1[
i] - r->block0[
i];
5090 int* wvhdl = r->wvhdl[
i];
5094 for (j=0; j< length; j++)
5096 if (wvhdl[j] != 0 && wvhdl[j] != 1)
return FALSE;
5112 return (r->cf->type);
5134 while((r->typ[i].ord_typ!=
ro_wp64) && (r->typ[i].ord_typ>0)) i++;
5136 return (
int64*)(r->typ[
i].data.wp64.weights64);
5144 memcpy(r->typ[0].data.wp64.weights64,wv,r->N*
sizeof(
int64));
5151 r->order=(
int*)
omReallocSize(r->order, size*
sizeof(
int), (size+1)*
sizeof(
int));
5152 r->block0=(
int*)
omReallocSize(r->block0, size*
sizeof(
int), (size+1)*
sizeof(
int));
5153 r->block1=(
int*)
omReallocSize(r->block1, size*
sizeof(
int), (size+1)*
sizeof(
int));
5154 r->wvhdl=(
int **)
omReallocSize(r->wvhdl,size*
sizeof(
int *), (size+1)*
sizeof(
int *));
5155 for(
int k=size;
k>pos;
k--) r->wvhdl[
k]=r->wvhdl[
k-1];
5160 #if 0 // currently unused 5161 static int rReallocM1(ring r,
int size,
int pos)
5163 r->order=(
int*)
omReallocSize(r->order, size*
sizeof(
int), (size-1)*
sizeof(
int));
5164 r->block0=(
int*)
omReallocSize(r->block0, size*
sizeof(
int), (size-1)*
sizeof(
int));
5165 r->block1=(
int*)
omReallocSize(r->block1, size*
sizeof(
int), (size-1)*
sizeof(
int));
5166 r->wvhdl=(
int **)
omReallocSize(r->wvhdl,size*
sizeof(
int *), (size-1)*
sizeof(
int *));
5167 for(
int k=pos+1;
k<
size;
k++) r->wvhdl[
k]=r->wvhdl[
k+1];
5175 for(
int j=0;
j<=i2;
j++)
5183 #define rOppVar(R,I) (rVar(R)+1-I) 5209 int i2 = (
rVar(r)-1)/2;
5210 for(i=i2; i>=0; i--)
5216 p = r->names[
rVar(r)-1-
i];
5217 r->names[
rVar(r)-1-
i] = r->names[
i];
5232 for (i=
rVar(r)-1; i>=0; i--)
5234 char *
p=r->names[
i];
5235 if(isupper(*p)) *p = tolower(*p);
5236 else *p = toupper(*p);
5283 for(i=0; src->order[
i]!=0; i++)
5285 switch (src->order[i])
5290 r->order[
j]=src->order[
i];
5294 r->block0[
j]=
rOppVar(r, src->block1[i]);
5295 r->block1[
j]=
rOppVar(r, src->block0[i]);
5299 r->block0[
j]=
rOppVar(r, src->block1[i]);
5300 r->block1[
j]=
rOppVar(r, src->block0[i]);
5306 r->block0[
j]=
rOppVar(r, src->block1[i]);
5307 r->block1[
j]=
rOppVar(r, src->block0[i]);
5308 r->wvhdl[
j]=(
int*)
omAlloc((r->block1[j]-r->block0[j]+1)*
sizeof(int));
5309 for(
int k=r->block0[j]; k<=r->block1[j];
k++)
5310 r->wvhdl[
j][
k-r->block0[
j]]=1;
5313 r->block0[
j]=
rOppVar(r, src->block1[i]);
5314 r->block1[
j]=
rOppVar(r, src->block0[i]);
5322 r->block0[
j]=
rOppVar(r, src->block1[i]);
5323 r->block1[
j]=
rOppVar(r, src->block0[i]);
5324 r->wvhdl[
j]=(
int*)
omAlloc((r->block1[j]-r->block0[j]+1)*
sizeof(int));
5325 for(
int k=r->block0[j]; k<=r->block1[j];
k++)
5326 r->wvhdl[
j][
k-r->block0[
j]]=1;
5329 r->block0[
j]=
rOppVar(r, src->block1[i]);
5330 r->block1[
j]=
rOppVar(r, src->block0[i]);
5338 r->block0[
j]=
rOppVar(r, src->block1[i]);
5339 r->block1[
j]=
rOppVar(r, src->block0[i]);
5340 r->wvhdl[
j]=r->wvhdl[j+1]; r->wvhdl[j+1]=
NULL;
5341 rOppWeight(r->wvhdl[j], r->block1[j]-r->block0[j]);
5344 r->block0[
j]=
rOppVar(r, src->block1[i]);
5345 r->block1[
j]=
rOppVar(r, src->block0[i]);
5353 r->block0[
j]=
rOppVar(r, src->block1[i]);
5354 r->block1[
j]=
rOppVar(r, src->block0[i]);
5355 r->wvhdl[
j]=r->wvhdl[j+1]; r->wvhdl[j+1]=
NULL;
5356 rOppWeight(r->wvhdl[j], r->block1[j]-r->block0[j]);
5359 r->block0[
j]=
rOppVar(r, src->block1[i]);
5360 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 int n=r->block1[
j]-r->block0[
j];
5371 for (
int nn=0; nn<=n; nn++)
5380 r->block0[
j]=
rOppVar(r, src->block1[i]);
5381 r->block1[
j]=
rOppVar(r, src->block0[i]);
5382 rOppWeight(r->wvhdl[j], r->block1[j]-r->block0[j]);
5437 int *par_perm =
NULL;
5440 for(i=1; i<=r->N; i++)
5448 for (i=1; i<
rVar(r); i++)
5450 for (j=i+1; j<=
rVar(r); j++)
5456 MATELEM(C,nj,ni) =
p_PermPoly(
MATELEM(src->GetNC()->C,
i,
j),perm,src,r, nMap,par_perm,
rPar(src));
5459 MATELEM(D,nj,ni) =
p_PermPoly(
MATELEM(src->GetNC()->D,
i,
j),perm,src,r, nMap,par_perm,
rPar(src));
5467 WarnS(
"Error initializing non-commutative multiplication!");
5475 assume( r->GetNC()->IsSkewConstant == src->GetNC()->IsSkewConstant);
5482 if (src->qideal !=
NULL)
5487 r->qideal =
idOppose(src, src->qideal, r);
5489 r->qideal =
id_Copy(src->qideal, r);
5519 int stat =
rSum(R, Ropp, Renv);
5521 WarnS(
"Error in rEnvelope at rSum");
5544 const int N = dest->N;
5553 const ring srcBase = src;
5560 matrix C0 = src->GetNC()->C;
5561 matrix D0 = src->GetNC()->D;
5564 for (
int i = 1; i <
N; i++)
5566 for (
int j = i + 1;
j <=
N;
j++)
5611 while(r->order[i]!=0)
5618 for(j=r->block1[i]-r->block0[i];j>=0;j--)
5620 r->wvhdl[
i]=(
int*)w64;
5621 omFreeSize(w,(r->block1[i]-r->block0[i]+1)*
sizeof(
int));
5654 Werror(
"n_IsParam: IsParam is not to be used for (coeff_type = %d)",
getCoeffType(C));
static void rHighSet(ring r, int o_r, int o)
for idElimination, like a, except pFDeg, pWeigths ignore it
n_coeffType rFieldType(ring r)
ideal SCAQuotient(const ring r)
void p_Setm_General(poly p, const ring r)
const CanonicalForm int s
void p_DebugPrint(poly p, const ring r)
#define omCheckAddrSize(addr, size)
static void rOptimizeLDeg(ring r)
long pLDeg1(poly p, int *l, const ring r)
only used if HAVE_RINGS is defined
#define omcheckAddrSize(addr, size)
poly rGetVar(const int varIndex, const ring r)
static void rO_LexVars(int &place, int &bitplace, int start, int end, int &prev_ord, long *o, int *v, int bits, int opt_var)
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, 1: dp,dp, 2: aa(...),dp vartest: check for name conflicts
non-simple ordering as specified by currRing
simple ordering, exponent vector has priority < component is compatible with exp-vector order ...
static void rSetNegWeight(ring r)
poly prCopyR(poly p, ring src_r, ring dest_r)
static BOOLEAN rField_is_Zp_a(const ring r)
long pLDeg1c_Totaldegree(poly p, int *l, const ring r)
p_SetmProc p_GetSetmProc(const ring r)
rOrderType_t rGetOrderType(ring r)
only used if HAVE_RINGS is defined
used for all transcendental extensions, i.e., the top-most extension in an extension tower is transce...
static int min(int a, int b)
BOOLEAN rRing_is_Homog(ring r)
static void rSetFirstWv(ring r, int i, int *order, int *block1, int **wvhdl)
static BOOLEAN rField_is_Ring_PtoM(const ring r)
int sgn(const Rational &a)
long pLDeg1c(poly p, int *l, const ring r)
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)
size_t omSizeOfAddr(const void *addr)
ideal id_Copy(ideal h1, const ring r)
copy an ideal
static FORCE_INLINE BOOLEAN n_IsOne(number n, const coeffs r)
TRUE iff 'n' represents the one element.
BOOLEAN nc_rComplete(const ring src, ring dest, bool bSetupQuotient)
static int rPar(const ring r)
(r->cf->P)
poly p_NSet(number n, const ring r)
returns the poly representing the number n, destroys n
BOOLEAN rOrd_is_WeightedDegree_Ordering(const ring r)
void p_Setm_WFirstTotalDegree(poly p, const ring r)
static BOOLEAN rField_is_Ring_ModN(const ring r)
static unsigned long p_SetComp(poly p, unsigned long c, ring r)
struct p_Procs_s p_Procs_s
static BOOLEAN rField_is_R(const ring r)
static int rRealloc1(ring r, int size, int pos)
BOOLEAN rOrd_is_MixedDegree_Ordering(ring r)
bool nc_SetupQuotient(ring rGR, const ring rG=NULL, bool bCopy=false)
ring rCopy0AndAddA(const ring r, int64vec *wv64, BOOLEAN copy_qideal, BOOLEAN copy_ordering)
ring rModifyRing_Wp(ring r, int *weights)
construct Wp, C ring
BOOLEAN rIsPolyVar(int v, const ring r)
returns TRUE if var(i) belongs to p-block
#define omFreeSize(addr, size)
static BOOLEAN rShortOut(const ring r)
static short rVar(const ring r)
#define rVar(r) (r->N)
void id_Delete(ideal *h, ring r)
deletes an ideal/module/matrix
#define omfreeSize(addr, size)
static void m_DebugPrint(const poly p, const ring R)
debug-print monomial poly/vector p, assuming that it lives in the ring R
long pLDeg0c(poly p, int *l, const ring r)
void nc_rKill(ring r)
complete destructor
static void rNGetSComps(int **currComponents, long **currShiftedComponents, ring r)
static void rOppWeight(int *w, int l)
ring rModifyRing(ring r, BOOLEAN omit_degree, BOOLEAN try_omit_comp, unsigned long exp_limit)
void p_Debug_GetSpecNames(const ring r, const char *&field, const char *&length, const char *&ord)
BOOLEAN rOrder_is_WeightedOrdering(rRingOrder_t order)
#define omUnGetSpecBin(bin_ptr)
static BOOLEAN rField_is_Q_a(const ring r)
ring rAssure_SyzOrder(const ring r, BOOLEAN complete)
static void rO_Syz(int &place, int &bitplace, int &prev_ord, long *o, sro_ord &ord_struct)
static long p_Totaldegree(poly p, const ring r)
static void rO_ISPrefix(int &place, int &bitplace, int &prev_ord, long *o, int, int *v, sro_ord &ord_struct)
ring rAssure_TDeg(ring r, int start_var, int end_var, int &pos)
BOOLEAN rOrder_is_DegOrdering(const rRingOrder_t order)
simple ordering, component has priority
void WerrorS(const char *s)
void p_Setm_TotalDegree(poly p, const ring r)
static BOOLEAN rField_is_GF(const ring r)
static char const ** rParameter(const ring r)
(r->cf->parameter)
long * currShiftedComponents
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! p - ...
BOOLEAN rDBTest(ring r, const char *fn, const int l)
ring rAssure_HasComp(const ring r)
long pLDeg1_Deg(poly p, int *l, const ring r)
ring rAssure_c_dp(const ring r)
static BOOLEAN rCanShortOut(const ring r)
BOOLEAN rHasSimpleOrder(const ring r)
BOOLEAN rHas_c_Ordering(const ring r)
ideal idrHeadR(ideal id, ring r, ring dest_r)
Copy leading terms of id[i] via prHeeadR into dest_r.
BOOLEAN rHasSimpleOrderAA(ring r)
ideal idOppose(ring Rop_src, ideal I, const ring Rop_dst)
opposes a module I from Rop to currRing(dst)
static void rSetOption(ring r)
real floating point (GMP) numbers
void iiWriteMatrix(matrix im, const char *n, int dim, const ring r, int spaces)
set spaces to zero by default
void idShow(const ideal id, const ring lmRing, const ring tailRing, const int debugPrint)
static void rDBGetSComps(int **currComponents, long **currShiftedComponents, int *length, ring r)
simple ordering, exponent vector has priority < component not compatible with exp-vector order ...
long pLDeg1c_Deg(poly p, int *l, const ring r)
ring rAssure_SyzComp_CompLastBlock(const ring r, BOOLEAN)
makes sure that c/C ordering is last ordering and SyzIndex is first
int rSum(ring r1, ring r2, ring &sum)
static void rSetDegStuff(ring r)
#define omReallocSize(addr, o_size, size)
bool sca_Force(ring rGR, int b, int e)
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)
static void rO_Align(int &place, int &bitplace)
single prescision (6,6) real numbers
void rGetSComps(int **currComponents, long **currShiftedComponents, int *length, ring r)
static void rDBChangeSComps(int *currComponents, long *currShiftedComponents, int length, ring r)
static int rBlocks(ring r)
int r_IsRingVar(const char *n, char **names, int N)
long p_Deg(poly a, 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)
static void rO_WMDegree(int &place, int &bitplace, int start, int end, long *o, sro_ord &ord_struct, int *weights)
Coefficient rings, fields and other domains suitable for Singular polynomials.
static FORCE_INLINE BOOLEAN nCoeff_is_algExt(const coeffs r)
TRUE iff r represents an algebraic extension field.
int naIsParam(number m, const coeffs cf)
if m == var(i)/1 => return i,
long id_RankFreeModule(ideal s, ring lmRing, ring tailRing)
return the maximal component number found in any polynomial in s
const CanonicalForm CFMap CFMap & N
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...
static void rO_WDegree_neg(int &place, int &bitplace, int start, int end, long *o, sro_ord &ord_struct, int *weights)
for(int i=0;i< R->ExpL_Size;i++) Print("%09lx "
static long p_GetExp(const poly p, const unsigned long iBitmask, const int VarOffset)
get a single variable exponent : the integer VarOffset encodes:
only used if HAVE_RINGS is defined
static BOOLEAN rIsPluralRing(const ring r)
we must always have this test!
The main handler for Singular numbers which are suitable for Singular polynomials.
long p_WFirstTotalDegree(poly p, const ring r)
void StringSetS(const char *st)
int rGetMaxSyzComp(int i, const ring r)
return the max-comonent wchich has syzIndex i Assume: i<= syzIndex_limit
static void rO_TDegree_neg(int &place, int &bitplace, int start, int end, long *o, sro_ord &ord_struct)
ring rCopy0(const ring r, BOOLEAN copy_qideal, BOOLEAN copy_ordering)
void StringAppendS(const char *st)
number(* nMapFunc)(number a, const coeffs src, const coeffs dst)
maps "a", which lives in src, into dst
long pLDeg0(poly p, int *l, const ring r)
ring rAssure_SyzComp(const ring r, BOOLEAN complete)
ring rAssure_dp_C(const ring r)
complex floating point (GMP) numbers
const char * rSimpleOrdStr(int ord)
gmp_float sqrt(const gmp_float &a)
static ring rAssure_Global(rRingOrder_t b1, rRingOrder_t b2, const ring r)
BOOLEAN rOrd_is_Totaldegree_Ordering(const ring r)
void p_Setm_Dummy(poly p, const ring r)
static long p_FDeg(const poly p, const ring r)
BOOLEAN rCheckIV(const intvec *iv)
int rOrderName(char *ordername)
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 rDefault(const coeffs cf, int N, char **n, int ord_size, int *ord, int *block0, int *block1, int **wvhdl)
only used if HAVE_RINGS is defined
static int si_max(const int a, const int b)
void rDebugPrint(const ring r)
static void rO_WDegree64(int &place, int &bitplace, int start, int end, long *o, sro_ord &ord_struct, int64 *weights)
Induced (Schreyer) ordering.
void PrintS(const char *s)
static BOOLEAN rField_is_Q(const ring r)
ring rAssure_CompLastBlock(ring r, BOOLEAN complete)
makes sure that c/C ordering is last ordering
static void rO_Syzcomp(int &place, int &bitplace, int &prev_ord, long *o, sro_ord &ord_struct)
void p_Debug_GetProcNames(const ring r, p_Procs_s *p_Procs)
BOOLEAN rOrd_SetCompRequiresSetm(const ring r)
return TRUE if p_SetComp requires p_Setm
static void rSetVarL(ring r)
set r->VarL_Size, r->VarL_Offset, r->VarL_LowIndex
void rWrite(ring r, BOOLEAN details)
void rKillModified_Wp_Ring(ring r)
static void rSetOutParams(ring r)
static unsigned long rGetExpSize(unsigned long bitmask, int &bits)
BOOLEAN rEqual(ring r1, ring r2, BOOLEAN qr)
returns TRUE, if r1 equals r2 FALSE, otherwise Equality is determined componentwise, if qr == 1, then qrideal equality is tested, as well
void mp_Delete(matrix *a, const ring r)
static FORCE_INLINE nMapFunc n_SetMap(const coeffs src, const coeffs dst)
set the mapping function pointers for translating numbers from src to dst
static short scaFirstAltVar(ring r)
static FORCE_INLINE n_coeffType getCoeffType(const coeffs r)
Returns the type of coeffs domain.
BOOLEAN p_EqualPolys(poly p1, poly p2, const ring r)
static BOOLEAN rField_is_long_C(const ring r)
void rSetSyzComp(int k, const ring r)
static BOOLEAN rField_is_Zp(const ring r)
void pISUpdateComponents(ideal F, const intvec *const V, const int MIN, const ring r)
matrix mpNew(int r, int c)
create a r x c zero-matrix
static FORCE_INLINE coeffs nCopyCoeff(const coeffs r)
"copy" coeffs, i.e. increment ref
void p_Write0(poly p, ring lmRing, ring tailRing)
static void p_Delete(poly *p, const ring r)
#define omGetSpecBin(size)
ideal idInit(int idsize, int rank)
initialise an ideal / module
void rSetWeightVec(ring r, int64 *wv)
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...
const Variable & v
< [in] a sqrfree bivariate poly
bool nc_rCopy(ring res, const ring r, bool bSetupQuotient)
static unsigned long rGetDivMask(int bits)
get r->divmask depending on bits per exponent
static unsigned long p_SetExp(poly p, const unsigned long e, const unsigned long iBitmask, const int VarOffset)
set a single variable exponent : VarOffset encodes the position in p->exp
BOOLEAN rHasSimpleLexOrder(const ring r)
returns TRUE, if simple lp or ls ordering
static void rO_TDegree(int &place, int &bitplace, int start, int end, long *o, sro_ord &ord_struct)
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)
long pLDegb(poly p, int *l, const ring r)
static FORCE_INLINE void n_CoeffWrite(const coeffs r, BOOLEAN details=TRUE)
output the coeff description
static BOOLEAN rField_is_Ring_2toM(const ring r)
static BOOLEAN rField_is_Ring(const ring r)
ring rAssure_dp_S(const ring r)
static const char *const ringorder_name[]
long pLDeg1_Totaldegree(poly p, int *l, const ring r)
static FORCE_INLINE number n_Copy(number n, const coeffs r)
return a copy of 'n'
void rDelete(ring r)
unconditionally deletes fields in r
ring rAssure_C_dp(const ring r)
used for all algebraic extensions, i.e., the top-most extension in an extension tower is algebraic ...
ring rAssure_InducedSchreyerOrdering(const ring r, BOOLEAN complete=TRUE, int sgn=1)
static BOOLEAN rField_is_Ring_Z(const ring r)
ring nc_rCreateNCcomm_rCopy(ring r)
void p_ProcsSet(ring r, p_Procs_s *p_Procs)
static BOOLEAN rField_is_long_R(const ring r)
int rTypeOfMatrixOrder(const intvec *order)
static short scaLastAltVar(ring r)
static void rO_WDegree(int &place, int &bitplace, int start, int end, long *o, sro_ord &ord_struct, int *weights)
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...
void rModify_a_to_A(ring r)
static bool rIsSCA(const ring r)
static void rRightAdjustVarOffset(ring r)
right-adjust r->VarOffset
void rKillModifiedRing(ring r)
ideal idrCopyR(ideal id, ring src_r, ring dest_r)
static void p_Setm(poly p, const ring r)
long pLDeg1_WFirstTotalDegree(poly p, int *l, const ring r)
static nc_type & ncRingType(nc_struct *p)
long pLDeg1c_WFirstTotalDegree(poly p, int *l, const ring r)
int dReportError(const char *fmt,...)
static FORCE_INLINE BOOLEAN nCoeff_is_Extension(const coeffs r)
int ntIsParam(number m, const coeffs cf)
if m == var(i)/1 => return i,
int n_IsParam(const number m, const ring r)
TODO: rewrite somehow...
#define TEST_RINGDEP_OPTS
long p_WTotaldegree(poly p, const ring r)
#define omCheckAddr(addr)
void p_wrp(poly p, ring lmRing, ring tailRing)
char * rCharStr(const ring r)
TODO: make it a virtual method of coeffs, together with: Decompose & Compose, rParameter & rPar...
void p_Write(poly p, ring lmRing, ring tailRing)
static FORCE_INLINE char * nCoeffString(const coeffs cf)
TODO: make it a virtual method of coeffs, together with: Decompose & Compose, rParameter & rPar...
static void rCheckOrdSgn(ring r, int i)
#define omFreeBin(addr, bin)
ring rModifyRing_Simple(ring r, BOOLEAN ommit_degree, BOOLEAN ommit_comp, unsigned long exp_limit, BOOLEAN &simple)
void p_SetGlobals(const ring r, BOOLEAN complete)
set all properties of a new ring - also called by rComplete
BOOLEAN rRing_has_CompLastBlock(ring r)
void rKillModifiedRing_Simple(ring r)
ideal idrCopyR_NoSort(ideal id, ring src_r, ring dest_r)
void rChangeSComps(int *currComponents, long *currShiftedComponents, int length, ring r)
void nKillChar(coeffs r)
undo all initialisations
ideal id_SimpleAdd(ideal h1, ideal h2, const ring R)
concat the lists h1 and h2 without zeros
poly p_ISet(long i, const ring r)
returns the poly representing the integer i
void Werror(const char *fmt,...)
int64 * rGetWeightVec(const ring r)
static void rNChangeSComps(int *currComponents, long *currShiftedComponents, ring r)
used to represent polys as coeffcients
#define UPMATELEM(i, j, nVar)
#define MATELEM(mat, i, j)
coeffs nInitChar(n_coeffType t, void *parameter)
one-time initialisations for new coeffs in case of an error return NULL