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;
1345 res->firstBlockEnds=r->firstBlockEnds;
1347 res->real_var_start=r->real_var_start;
1348 res->real_var_end=r->real_var_end;
1351 #ifdef HAVE_SHIFTBBA 1352 res->isLPring=r->isLPring;
1355 res->VectorOut=r->VectorOut;
1356 res->ShortOut=r->ShortOut;
1357 res->CanShortOut=r->CanShortOut;
1373 res->bitmask=r->bitmask;
1374 res->divmask=r->divmask;
1375 res->BitsPerExp = r->BitsPerExp;
1376 res->ExpPerLong = r->ExpPerLong;
1395 if (copy_ordering ==
TRUE)
1397 res->LexOrder=r->LexOrder;
1398 res->MixedOrder=r->MixedOrder;
1400 res->wvhdl = (
int **)
omAlloc(i *
sizeof(
int *));
1401 res->order = (
int *)
omAlloc(i *
sizeof(
int));
1402 res->block0 = (
int *)
omAlloc(i *
sizeof(
int));
1403 res->block1 = (
int *)
omAlloc(i *
sizeof(
int));
1406 if (r->wvhdl[j]!=
NULL)
1408 res->wvhdl[
j] = (
int*)
omMemDup(r->wvhdl[j]);
1413 memcpy(res->order,r->order,i *
sizeof(
int));
1414 memcpy(res->block0,r->block0,i *
sizeof(
int));
1415 memcpy(res->block1,r->block1,i *
sizeof(
int));
1425 res->names = (
char **)
omAlloc0(
rVar(r) *
sizeof(
char *));
1426 for (i=0; i<
rVar(res); i++)
1430 if (r->qideal!=
NULL)
1436 WerrorS(
"internal error: rCopy0(Q,TRUE,FALSE)");
1441 WarnS(
"internal bad stuff: rCopy0(Q,TRUE,TRUE)");
1468 res->options=r->options;
1483 res->firstBlockEnds=r->firstBlockEnds;
1485 res->real_var_start=r->real_var_start;
1486 res->real_var_end=r->real_var_end;
1489 #ifdef HAVE_SHIFTBBA 1490 res->isLPring=r->isLPring;
1493 res->VectorOut=r->VectorOut;
1494 res->ShortOut=r->ShortOut;
1495 res->CanShortOut=r->CanShortOut;
1496 res->LexOrder=r->LexOrder;
1497 res->MixedOrder=r->MixedOrder;
1513 res->bitmask=r->bitmask;
1514 res->divmask=r->divmask;
1515 res->BitsPerExp = r->BitsPerExp;
1516 res->ExpPerLong = r->ExpPerLong;
1535 if (copy_ordering ==
TRUE)
1538 res->wvhdl = (
int **)
omAlloc(i *
sizeof(
int *));
1539 res->order = (
int *)
omAlloc(i *
sizeof(
int));
1540 res->block0 = (
int *)
omAlloc(i *
sizeof(
int));
1541 res->block1 = (
int *)
omAlloc(i *
sizeof(
int));
1542 for (j=0; j<i-1; j++)
1544 if (r->wvhdl[j]!=
NULL)
1546 res->wvhdl[j+1] = (
int*)
omMemDup(r->wvhdl[j]);
1549 res->wvhdl[j+1]=
NULL;
1551 memcpy(&(res->order[1]),r->order,(i-1) *
sizeof(
int));
1552 memcpy(&(res->block0[1]),r->block0,(i-1) *
sizeof(
int));
1553 memcpy(&(res->block1[1]),r->block1,(i-1) *
sizeof(
int));
1565 int length=wv64->
rows();
1567 for(j=length-1;j>=0;j--)
1571 res->wvhdl[0]=(
int *)A;
1573 res->block1[0]=length;
1576 res->names = (
char **)
omAlloc0(
rVar(r) *
sizeof(
char *));
1577 for (i=0; i<
rVar(res); i++)
1581 if (r->qideal!=
NULL)
1587 WerrorS(
"internal error: rCopy0(Q,TRUE,FALSE)");
1592 WarnS(
"internal bad stuff: rCopy0(Q,TRUE,TRUE)");
1629 if (r1 == r2)
return TRUE;
1631 if (r1->cf!=r2->cf)
return FALSE;
1639 for (i=0; i<
rVar(r1); i++)
1641 if ((r1->names[i] !=
NULL) && (r2->names[
i] !=
NULL))
1643 if (strcmp(r1->names[i], r2->names[i]))
return FALSE;
1645 else if ((r1->names[i] !=
NULL) ^ (r2->names[
i] !=
NULL))
1653 if (r1->qideal !=
NULL)
1655 ideal id1 = r1->qideal, id2 = r2->qideal;
1669 else if (r2->qideal !=
NULL)
return FALSE;
1679 if (r1 == r2)
return TRUE;
1683 if ((r1->cf != r2->cf)
1685 || (r1->OrdSgn != r2->OrdSgn))
1689 while (r1->order[i] != 0)
1691 if (r2->order[i] == 0)
return FALSE;
1692 if ((r1->order[i] != r2->order[i])
1693 || (r1->block0[i] != r2->block0[i])
1694 || (r1->block1[i] != r2->block1[i]))
1696 if (r1->wvhdl[i] !=
NULL)
1698 if (r2->wvhdl[i] ==
NULL)
1700 for (j=0; j<r1->block1[
i]-r1->block0[
i]+1; j++)
1701 if (r2->wvhdl[i][j] != r1->wvhdl[i][j])
1704 else if (r2->wvhdl[i] !=
NULL)
return FALSE;
1707 if (r2->order[i] != 0)
return FALSE;
1768 if (blocks == 1)
return TRUE;
1777 if ((blocks - s) > 2)
return FALSE;
1779 assume( blocks == s + 2 );
1843 if (blocks == 1)
return TRUE;
1852 if ((blocks - s) > 3)
return FALSE;
1855 if ((blocks - s) == 3)
1874 for (pos=0;pos<r->OrdSize;pos++)
1892 return (
rVar(r) > 1 &&
1905 return ((
rVar(r) > 1) &&
1914 while(r->order[i]!=0)
1916 if((r->block0[i]<=v)
1917 && (r->block1[i]>=v))
1922 return (r->wvhdl[i][v-r->block0[i]]>0);
1961 if (r->N == 0)
return TRUE;
1963 if ((r->OrdSgn!=1) && (r->OrdSgn!= -1))
1984 if (r->VarOffset ==
NULL)
1986 dReportError(
"Null ring VarOffset -- no rComplete (?) in n %s:%d", fn, l);
1991 if ((r->OrdSize==0)!=(r->typ==
NULL))
1993 dReportError(
"mismatch OrdSize and typ-pointer in %s:%d");
1999 for(i=0;i<=r->N;i++)
2003 for(j=0;j<r->OrdSize;j++)
2007 const int p = r->typ[
j].data.isTemp.suffixpos;
2012 assume( p < r->OrdSize );
2014 if(r->typ[p].ord_typ !=
ro_is)
2015 dReportError(
"ordrec prefix %d is unmatched (suffix: %d is wrong!!!)",j, p);
2018 if(r->typ[j].data.isTemp.pVarOffset[i] != -1)
2024 else if (r->typ[j].ord_typ ==
ro_is)
2027 if(r->typ[j].data.is.pVarOffset[i] != -1)
2035 if (r->typ[j].ord_typ==
ro_cp)
2037 if(((
short)r->VarOffset[i]) == r->typ[j].data.cp.place)
2042 && (r->VarOffset[i] == r->typ[j].data.dp.place))
2048 tmp=r->VarOffset[
i] & 0xffffff;
2049 #if SIZEOF_LONG == 8 2050 if ((r->VarOffset[i] >> 24) >63)
2052 if ((r->VarOffset[i] >> 24) >31)
2054 dReportError(
"bit_start out of range:%d",r->VarOffset[i] >> 24);
2055 if (i > 0 && ((tmp<0) ||(tmp>r->ExpL_Size-1)))
2057 dReportError(
"varoffset out of range for var %d: %d",i,tmp);
2062 for(j=0;j<r->OrdSize;j++)
2064 if ((r->typ[j].ord_typ==
ro_dp)
2065 || (r->typ[j].ord_typ==
ro_wp)
2068 if (r->typ[j].data.dp.start > r->typ[j].data.dp.end)
2070 r->typ[j].data.dp.start, r->typ[j].data.dp.end);
2071 if ((r->typ[j].data.dp.start < 1)
2072 || (r->typ[j].data.dp.end > r->N))
2073 dReportError(
"in ordrec %d: start(%d)<1 or end(%d)>vars(%d)",j,
2074 r->typ[j].data.dp.start, r->typ[j].data.dp.end,r->N);
2106 static void rO_TDegree(
int &place,
int &bitplace,
int start,
int end,
2112 ord_struct.
data.dp.start=start;
2113 ord_struct.
data.dp.end=end;
2114 ord_struct.
data.dp.place=place;
2126 ord_struct.
data.dp.start=start;
2127 ord_struct.
data.dp.end=end;
2128 ord_struct.
data.dp.place=place;
2134 static void rO_WDegree(
int &place,
int &bitplace,
int start,
int end,
2135 long *o,
sro_ord &ord_struct,
int *weights)
2138 while((start<end) && (weights[0]==0)) { start++; weights++; }
2139 while((start<end) && (weights[end-start]==0)) { end--; }
2142 for(i=start;i<=end;i++)
2144 if(weights[i-start]!=1)
2152 rO_TDegree(place,bitplace,start,end,o,ord_struct);
2157 ord_struct.
data.wp.start=start;
2158 ord_struct.
data.wp.end=end;
2159 ord_struct.
data.wp.place=place;
2160 ord_struct.
data.wp.weights=weights;
2164 for(i=start;i<=end;i++)
2166 if(weights[i-start]<0)
2174 static void rO_WMDegree(
int &place,
int &bitplace,
int start,
int end,
2175 long *o,
sro_ord &ord_struct,
int *weights)
2184 ord_struct.
data.am.start=start;
2185 ord_struct.
data.am.end=end;
2186 ord_struct.
data.am.place=place;
2187 ord_struct.
data.am.weights=weights;
2188 ord_struct.
data.am.weights_m = weights + (end-start+1);
2189 ord_struct.
data.am.len_gen=weights[end-start+1];
2190 assume( ord_struct.
data.am.weights_m[0] == ord_struct.
data.am.len_gen );
2203 ord_struct.
data.wp64.start=start;
2204 ord_struct.
data.wp64.end=end;
2205 ord_struct.
data.wp64.place=place;
2206 ord_struct.
data.wp64.weights64=weights;
2215 long *o,
sro_ord &ord_struct,
int *weights)
2218 while((start<end) && (weights[0]==0)) { start++; weights++; }
2219 while((start<end) && (weights[end-start]==0)) { end--; }
2222 ord_struct.
data.wp.start=start;
2223 ord_struct.
data.wp.end=end;
2224 ord_struct.
data.wp.place=place;
2225 ord_struct.
data.wp.weights=weights;
2230 for(i=start;i<=end;i++)
2232 if(weights[i-start]<0)
2240 static void rO_LexVars(
int &place,
int &bitplace,
int start,
int end,
2241 int &prev_ord,
long *o,
int *
v,
int bits,
int opt_var)
2246 if(prev_ord==-1)
rO_Align(place,bitplace);
2252 for(k=start;;k+=incr)
2257 v[
k]= place | (bitplace << 24);
2263 assume((opt_var == end+1) ||(opt_var == end-1));
2264 if((opt_var != end+1) &&(opt_var != end-1))
WarnS(
"hier-2");
2265 int save_bitplace=bitplace;
2269 bitplace=save_bitplace;
2273 v[opt_var]=place | (bitplace << 24);
2278 int &prev_ord,
long *o,
int *
v,
int bits,
int opt_var)
2283 if(prev_ord==1)
rO_Align(place,bitplace);
2289 for(k=start;;k+=incr)
2294 v[
k]=place | (bitplace << 24);
2301 assume((opt_var == end+1) ||(opt_var == end-1));
2302 if((opt_var != end+1) &&(opt_var != end-1))
WarnS(
"hier-1");
2303 int save_bitplace=bitplace;
2307 bitplace=save_bitplace;
2311 v[opt_var]=place | (bitplace << 24);
2322 ord_struct.
data.syzcomp.place=place;
2323 ord_struct.
data.syzcomp.Components=
NULL;
2324 ord_struct.
data.syzcomp.ShiftedComponents=
NULL;
2331 static void rO_Syz(
int &place,
int &bitplace,
int &prev_ord,
2339 ord_struct.
data.syz.place=place;
2340 ord_struct.
data.syz.limit=0;
2341 ord_struct.
data.syz.syz_index =
NULL;
2342 ord_struct.
data.syz.curr_index = 1;
2355 long *o,
int ,
int *
v,
sro_ord &ord_struct)
2362 ord_struct.
data.isTemp.start = place;
2363 ord_struct.
data.isTemp.pVarOffset = (
int *)
omMemDup(v);
2364 ord_struct.
data.isTemp.suffixpos = -1;
2372 static void rO_ISSuffix(
int &place,
int &bitplace,
int &prev_ord,
long *o,
2377 int typ_j = typ_i - 1;
2380 if( tmp_typ[typ_j].ord_typ ==
ro_isTemp)
2393 const int start = tmp_typ[typ_j].
data.isTemp.start;
2394 int *pVarOffset = tmp_typ[typ_j].
data.isTemp.pVarOffset;
2405 tmp_typ[typ_j].
data.isTemp.suffixpos = typ_i;
2412 for(
int i = 0;
i <=
N;
i++ )
2415 if( v[
i] != pVarOffset[
i] )
2417 pVarOffset[
i] = v[
i];
2419 assume( pVarOffset[i] != -1 );
2425 if( pVarOffset[0] != -1 )
2426 pVarOffset[0] &= 0x0fff;
2428 sro_ord &ord_struct = tmp_typ[typ_j];
2432 ord_struct.
data.is.start = start;
2433 ord_struct.
data.is.end = place;
2434 ord_struct.
data.is.pVarOffset = pVarOffset;
2456 v[0] = place | (bitplace << 24);
2467 bits=16; bitmask=0xffff;
2469 else if (bitmask <= 1L)
2471 bits=1; bitmask = 1L;
2473 else if (bitmask <= 3L)
2475 bits=2; bitmask = 3L;
2477 else if (bitmask <= 7L)
2481 else if (bitmask <= 0xfL)
2483 bits=4; bitmask=0xfL;
2485 else if (bitmask <= 0x1fL)
2487 bits=5; bitmask=0x1fL;
2489 else if (bitmask <= 0x3fL)
2491 bits=6; bitmask=0x3fL;
2493 #if SIZEOF_LONG == 8 2494 else if (bitmask <= 0x7fL)
2496 bits=7; bitmask=0x7fL;
2499 else if (bitmask <= 0xffL)
2501 bits=8; bitmask=0xffL;
2503 #if SIZEOF_LONG == 8 2504 else if (bitmask <= 0x1ffL)
2506 bits=9; bitmask=0x1ffL;
2509 else if (bitmask <= 0x3ffL)
2511 bits=10; bitmask=0x3ffL;
2513 #if SIZEOF_LONG == 8 2514 else if (bitmask <= 0xfffL)
2516 bits=12; bitmask=0xfff;
2519 else if (bitmask <= 0xffffL)
2521 bits=16; bitmask=0xffffL;
2523 #if SIZEOF_LONG == 8 2524 else if (bitmask <= 0xfffffL)
2526 bits=20; bitmask=0xfffffL;
2528 else if (bitmask <= 0xffffffffL)
2530 bits=32; bitmask=0xffffffffL;
2532 else if (bitmask <= 0x7fffffffffffffffL)
2534 bits=63; bitmask=0x7fffffffffffffffL;
2538 bits=63; bitmask=0x7fffffffffffffffL;
2541 else if (bitmask <= 0x7fffffff)
2543 bits=31; bitmask=0x7fffffff;
2547 bits=31; bitmask=0x7fffffffL;
2558 #if SIZEOF_LONG == 8 2573 unsigned long bitmask1 =
rGetExpSize(bitmask+1, bits1);
2575 if ((((N+vars_per_long-1)/vars_per_long) ==
2576 ((N+vars_per_long1-1)/vars_per_long1)))
2578 vars_per_long=vars_per_long1;
2598 unsigned long exp_limit)
2605 int iNeedInducedOrderingSetup = 0;
2609 need_other_ring = (exp_limit != r->bitmask);
2612 int *order=(
int*)
omAlloc0((nblocks+1)*
sizeof(int));
2613 int *block0=(
int*)
omAlloc0((nblocks+1)*
sizeof(int));
2614 int *block1=(
int*)
omAlloc0((nblocks+1)*
sizeof(int));
2615 int **wvhdl=(
int**)
omAlloc0((nblocks+1)*
sizeof(
int *));
2620 for(
int r_ord=r->order[i]; (r_ord != 0) && (i < nblocks); j++, r_ord=r->order[++
i])
2624 if (r->block0[i]==r->block1[i])
2649 Warn(
"Error: unhandled ordering in rModifyRing: ringorder_S = [%d]", r_ord);
2663 need_other_ring=
TRUE;
2664 try_omit_comp=
FALSE;
2665 copy_block_index=
FALSE;
2679 need_other_ring=
TRUE;
2681 omitted_degree =
TRUE;
2695 need_other_ring=
TRUE;
2697 omitted_degree =
TRUE;
2705 try_omit_comp =
FALSE;
2708 iNeedInducedOrderingSetup++;
2713 assume((i == 0) && (j == 0));
2717 try_omit_comp =
FALSE;
2726 if (copy_block_index)
2728 block0[
j]=r->block0[
i];
2729 block1[
j]=r->block1[
i];
2730 wvhdl[
j]=r->wvhdl[
i];
2735 if(!need_other_ring)
2747 res->GetNC() =
NULL;
2755 res->bitmask=exp_limit;
2762 if (r->pFDegOrig != res->pFDegOrig &&
2767 res->firstwv = r->firstwv;
2768 res->firstBlockEnds = r->firstBlockEnds;
2772 res->pLDeg = r->pLDegOrig;
2777 if (res->typ !=
NULL)
2779 if( res->typ[0].ord_typ ==
ro_syz)
2781 res->typ[0] = r->typ[0];
2783 if (r->typ[0].data.syz.limit > 0)
2785 res->typ[0].data.syz.syz_index
2786 = (
int*)
omAlloc((r->typ[0].data.syz.limit +1)*
sizeof(int));
2787 memcpy(res->typ[0].data.syz.syz_index, r->typ[0].data.syz.syz_index,
2788 (r->typ[0].data.syz.limit +1)*
sizeof(
int));
2792 if( iNeedInducedOrderingSetup > 0 )
2794 for(j = 0, i = 0; (i < nblocks) && (iNeedInducedOrderingSetup > 0); i++)
2795 if( res->typ[i].ord_typ ==
ro_is )
2797 ideal F =
idrHeadR(r->typ[i].data.is.F, r, res);
2801 r->typ[i].data.is.limit,
2806 iNeedInducedOrderingSetup--;
2812 res->OrdSgn=r->OrdSgn;
2821 WarnS(
"error in nc_rComplete");
2834 WarnS(
"error in sca_Force!");
2848 res->GetNC() =
NULL;
2852 res->wvhdl = (
int **)
omAlloc0(3 *
sizeof(
int *));
2854 res->order = (
int *)
omAlloc(3 *
sizeof(
int *));
2855 res->block0 = (
int *)
omAlloc0(3 *
sizeof(
int *));
2856 res->block1 = (
int *)
omAlloc0(3 *
sizeof(
int *));
2860 res->block1[0] = r->N;
2861 res->wvhdl[0] = weights;
2876 WarnS(
"error in nc_rComplete");
2903 int nblocks=1+(ommit_comp!=0);
2904 int *order=(
int*)
omAlloc0((nblocks+1)*
sizeof(int));
2905 int *block0=(
int*)
omAlloc0((nblocks+1)*
sizeof(int));
2906 int *block1=(
int*)
omAlloc0((nblocks+1)*
sizeof(int));
2907 int **wvhdl=(
int**)
omAlloc0((nblocks+1)*
sizeof(
int *));
2919 res->GetNC() =
NULL;
2926 res->bitmask=exp_limit;
2937 WarnS(
"error in nc_rComplete");
2953 return rModifyRing(r, ommit_degree, ommit_comp, exp_limit);
2986 r->CanShortOut =
TRUE;
2991 for (i=0;i<
rPar(r);i++)
2995 r->CanShortOut=
FALSE;
3006 if (r->N < N) N = r->N;
3008 for (i=(N-1);i>=0;i--)
3010 if(r->names[i] !=
NULL && strlen(r->names[i])>1)
3012 r->CanShortOut=
FALSE;
3018 r->ShortOut = r->CanShortOut;
3020 assume( !( !r->CanShortOut && r->ShortOut ) );
3023 static void rSetFirstWv(ring r,
int i,
int* order,
int* block1,
int** wvhdl)
3028 if(block1[i]!=r->N) r->LexOrder=
TRUE;
3029 r->firstBlockEnds=block1[
i];
3030 r->firstwv = wvhdl[
i];
3039 for(j=block1[i]-r->block0[i];j>=0;j--)
3041 if (r->firstwv[j]<0) r->MixedOrder=
TRUE;
3042 if (r->firstwv[j]==0) r->LexOrder=
TRUE;
3049 for(j=block1[i]-r->block0[i];j>=0;j--)
3051 if (w[j]==0) r->LexOrder=
TRUE;
3058 if (r->pFDeg ==
p_Deg)
3079 r->pLDegOrig = r->pLDeg;
3085 int* order = r->order;
3086 int* block0 = r->block0;
3087 int* block1 = r->block1;
3088 int** wvhdl = r->wvhdl;
3097 r->LexOrder =
FALSE;
3104 r->MixedOrder =
FALSE;
3105 for(
int ii=block0[0];ii<=block1[0];ii++)
3106 if (wvhdl[0][ii-1]<0) { r->MixedOrder=2;
break;}
3108 for(
int ii=block0[0];ii<=block1[0];ii++)
3109 if (wvhdl[0][ii-1]==0) { r->LexOrder=
TRUE;
break;}
3110 if ((block0[0]==1)&&(block1[0]==r->N))
3121 r->firstwv = wvhdl[0];
3133 if (r->OrdSgn == -1) r->pLDeg =
pLDeg0c;
3152 for(
int ii=block0[0];ii<=block1[0];ii++)
3154 if (wvhdl[0][ii-1]<0) { r->MixedOrder=2;
break;}
3156 if (r->MixedOrder==0)
3161 r->firstBlockEnds=block1[0];
3162 r->firstwv = wvhdl[0];
3181 r->firstBlockEnds=block1[1];
3182 if (wvhdl!=
NULL) r->firstwv = wvhdl[1];
3190 for(
int ii=block0[1];ii<=block1[1];ii++)
3191 if (wvhdl[1][ii-1]<0) { r->MixedOrder=2;
break;}
3192 if (r->MixedOrder==
FALSE)
3224 if(r->MixedOrder==
FALSE)
3239 r->pFDegOrig = r->pFDeg;
3254 for(i=0;i<r->OrdSize;i++)
3257 ||(r->typ[i].ord_typ==
ro_am))
3262 r->NegWeightL_Size=
l;
3263 r->NegWeightL_Offset=(
int *)
omAlloc(l*
sizeof(
int));
3265 for(i=0;i<r->OrdSize;i++)
3269 r->NegWeightL_Offset[
l]=r->typ[
i].data.wp.place;
3272 else if(r->typ[i].ord_typ==
ro_am)
3274 r->NegWeightL_Offset[
l]=r->typ[
i].data.am.place;
3281 r->NegWeightL_Size = 0;
3282 r->NegWeightL_Offset =
NULL;
3294 if ( (r->cf->extRing!=
NULL)
3303 if (r->LexOrder || r->OrdSgn == -1 || (r->cf->extRing!=
NULL))
3320 r->pLexOrder=r->LexOrder;
3328 static inline int sign(
int x) {
return (x > 0) - (x < 0);}
3336 for(i=2;i<=
rVar(r);i++)
3353 if (r->VarOffset!=
NULL && force == 0)
return FALSE;
3359 r->BitsPerExp = bits;
3364 long *tmp_ordsgn=(
long *)
omAlloc0(3*(n+r->N)*
sizeof(long));
3366 int *
v=(
int *)
omAlloc((r->N+1)*
sizeof(int));
3367 for(i=r->N; i>=0 ; i--)
3384 switch (r->order[i])
3388 rO_WDegree(j,j_bits,r->block0[i],r->block1[i],tmp_ordsgn,tmp_typ[typ_i],
3394 rO_WMDegree(j,j_bits,r->block0[i],r->block1[i],tmp_ordsgn,tmp_typ[typ_i],
3400 rO_WDegree64(j,j_bits,r->block0[i],r->block1[i],tmp_ordsgn,
3401 tmp_typ[typ_i], (
int64 *)(r->wvhdl[i]));
3408 r->ComponentOrder=1;
3414 r->ComponentOrder=-1;
3420 k=r->block1[
i]-r->block0[
i]+1;
3423 rO_WDegree(j,j_bits,r->block0[i],r->block1[i],tmp_ordsgn,
3425 r->wvhdl[i]+(r->block1[i]-r->block0[i]+1)*l);
3432 rO_LexVars(j, j_bits, r->block0[i],r->block1[i], prev_ordsgn,
3433 tmp_ordsgn,v,bits, -1);
3437 rO_LexVars_neg(j, j_bits, r->block0[i],r->block1[i], prev_ordsgn,
3438 tmp_ordsgn,v, bits, -1);
3442 rO_LexVars_neg(j, j_bits, r->block1[i],r->block0[i], prev_ordsgn,
3443 tmp_ordsgn,v, bits, -1);
3447 rO_LexVars(j, j_bits, r->block1[i],r->block0[i], prev_ordsgn,
3448 tmp_ordsgn,v, bits, -1);
3452 if (r->block0[i]==r->block1[i])
3454 rO_LexVars(j, j_bits, r->block0[i],r->block0[i], prev_ordsgn,
3455 tmp_ordsgn,v, bits, -1);
3459 rO_TDegree(j,j_bits,r->block0[i],r->block1[i],tmp_ordsgn,
3463 prev_ordsgn,tmp_ordsgn,v,bits, r->block0[i]);
3468 if (r->block0[i]==r->block1[i])
3470 rO_LexVars(j, j_bits, r->block0[i],r->block0[i], prev_ordsgn,
3471 tmp_ordsgn,v, bits, -1);
3475 rO_TDegree(j,j_bits,r->block0[i],r->block1[i],tmp_ordsgn,
3478 rO_LexVars(j, j_bits, r->block0[i],r->block1[i]-1, prev_ordsgn,
3479 tmp_ordsgn,v, bits, r->block1[i]);
3484 if (r->block0[i]==r->block1[i])
3487 tmp_ordsgn,v,bits, -1);
3495 prev_ordsgn,tmp_ordsgn,v,bits, r->block0[i]);
3500 if (r->block0[i]==r->block1[i])
3503 tmp_ordsgn,v, bits, -1);
3510 rO_LexVars(j, j_bits, r->block0[i],r->block1[i]-1, prev_ordsgn,
3511 tmp_ordsgn,v, bits, r->block1[i]);
3516 rO_WDegree(j,j_bits,r->block0[i],r->block1[i],tmp_ordsgn,
3517 tmp_typ[typ_i], r->wvhdl[i]);
3522 for(jj=r->block1[i]-r->block0[i];jj>=0; jj--)
3524 if (r->wvhdl[i][jj]<=0) have_bad_weights=
TRUE;
3526 if (have_bad_weights)
3528 rO_TDegree(j,j_bits,r->block0[i],r->block1[i],tmp_ordsgn,
3533 if (r->block1[i]!=r->block0[i])
3535 rO_LexVars_neg(j, j_bits,r->block1[i],r->block0[i]+1, prev_ordsgn,
3536 tmp_ordsgn, v,bits, r->block0[i]);
3541 rO_WDegree(j,j_bits,r->block0[i],r->block1[i],tmp_ordsgn,
3542 tmp_typ[typ_i], r->wvhdl[i]);
3547 for(jj=r->block1[i]-r->block0[i];jj>=0; jj--)
3549 if (r->wvhdl[i][jj]<=0) have_bad_weights=
TRUE;
3551 if (have_bad_weights)
3553 rO_TDegree(j,j_bits,r->block0[i],r->block1[i],tmp_ordsgn,
3558 if (r->block1[i]!=r->block0[i])
3560 rO_LexVars(j, j_bits,r->block0[i],r->block1[i]-1, prev_ordsgn,
3561 tmp_ordsgn,v, bits, r->block1[i]);
3567 tmp_typ[typ_i], r->wvhdl[i]);
3569 if (r->block1[i]!=r->block0[i])
3571 rO_LexVars_neg(j, j_bits,r->block1[i],r->block0[i]+1, prev_ordsgn,
3572 tmp_ordsgn, v,bits, r->block0[i]);
3578 tmp_typ[typ_i], r->wvhdl[i]);
3580 if (r->block1[i]!=r->block0[i])
3582 rO_LexVars(j, j_bits,r->block0[i],r->block1[i]-1, prev_ordsgn,
3583 tmp_ordsgn,v, bits, r->block1[i]);
3590 rO_Syzcomp(j, j_bits,prev_ordsgn, tmp_ordsgn,tmp_typ[typ_i]);
3591 need_to_add_comp=
TRUE;
3592 r->ComponentOrder=-1;
3597 assume(typ_i == 0 && j == 0);
3598 rO_Syz(j, j_bits, prev_ordsgn, tmp_ordsgn, tmp_typ[typ_i]);
3599 need_to_add_comp=
TRUE;
3600 r->ComponentOrder=-1;
3607 assume( r->block0[i] == r->block1[i] );
3608 const int s = r->block0[
i];
3609 assume( -2 < s && s < 2);
3612 rO_ISPrefix(j, j_bits, prev_ordsgn, tmp_ordsgn, r->N, v, tmp_typ[typ_i++]);
3615 rO_ISSuffix(j, j_bits, prev_ordsgn, tmp_ordsgn, r->N, v, tmp_typ, typ_i, s);
3616 need_to_add_comp=
FALSE;
3635 j_bits=j_bits0; j=j0;
3640 if((need_to_add_comp) && (v[0]== -1))
3654 for(i=1 ; i<=r->N ; i++)
3660 rO_LexVars(j, j_bits, i,i, prev_ordsgn,tmp_ordsgn,v,bits, -1);
3681 r->ordsgn=(
long *)
omAlloc0(r->ExpL_Size*
sizeof(
long));
3683 for(j=0;j<r->CmpL_Size;j++)
3685 r->ordsgn[
j] = tmp_ordsgn[
j];
3694 if (typ_i==0) r->typ=
NULL;
3698 memcpy(r->typ,tmp_typ,typ_i*
sizeof(
sro_ord));
3708 r->pCompIndex=(r->VarOffset[0] & 0xffff);
3711 if (i==r->pCompIndex) i++;
3712 while ((j < r->OrdSize)
3720 if (i==r->pCompIndex) i++;
3758 for(
int i=1;i<=r->N;i++)
3762 for(
int j=0;(
j<=
b) && (found==0);
j++)
3765 if ((r->block0[
j]<=i)&&(r->block1[
j]>=
i))
3785 if(r->wvhdl[
j][i-r->block0[
j]]<0)
3791 else if(r->wvhdl[
j][i-r->block0[
j]]>0)
3802 if(r->wvhdl[
j][i-r->block0[
j]]<0)
3808 else if(r->wvhdl[
j][i-r->block0[
j]]>0)
3837 if (nonneg>0) r->MixedOrder=1;
3848 if (r ==
NULL)
return;
3849 if (r->VarOffset !=
NULL)
3851 if (r->OrdSize!=0 && r->typ !=
NULL)
3853 for(
int i = 0; i < r->OrdSize; i++)
3854 if( r->typ[i].ord_typ ==
ro_is)
3857 r->typ[
i].data.is.F =
NULL;
3859 if( r->typ[i].data.is.pVarOffset !=
NULL )
3862 r->typ[
i].data.is.pVarOffset =
NULL;
3865 else if (r->typ[i].ord_typ ==
ro_syz)
3867 if(r->typ[i].data.syz.limit > 0)
3868 omFreeSize(r->typ[i].data.syz.syz_index, ((r->typ[i].data.syz.limit) +1)*
sizeof(
int));
3869 r->typ[
i].data.syz.syz_index =
NULL;
3873 assume( r->typ[i].data.syzcomp.ShiftedComponents ==
NULL );
3874 assume( r->typ[i].data.syzcomp.Components ==
NULL );
3884 if (r->PolyBin !=
NULL)
3889 if (r->ordsgn !=
NULL && r->CmpL_Size != 0)
3891 if (r->p_Procs !=
NULL)
3893 omfreeSize(r->VarL_Offset, r->VarL_Size*
sizeof(
int));
3895 if (r->NegWeightL_Offset!=
NULL)
3897 omFreeSize(r->NegWeightL_Offset, r->NegWeightL_Size*
sizeof(
int));
3898 r->NegWeightL_Offset=
NULL;
3906 int* VarL_Number = (
int*)
omAlloc0(r->ExpL_Size*
sizeof(
int));
3911 for (i=1; i<=r->N; i++)
3913 VarL_Number[r->VarOffset[
i] & 0xffffff]++;
3917 for (i=0, j=0; i<r->ExpL_Size; i++)
3919 if (VarL_Number[i] != 0)
3921 if (min > VarL_Number[i])
3923 min = VarL_Number[
i];
3932 r->VarL_Offset = (
int*)
omAlloc(r->VarL_Size*
sizeof(
int));
3933 r->VarL_LowIndex = 0;
3936 for (i=0, j=0; i<r->ExpL_Size; i++)
3938 if (VarL_Number[i] != 0)
3940 r->VarL_Offset[
j] =
i;
3941 if (j > 0 && r->VarL_Offset[j-1] != r->VarL_Offset[j] - 1)
3942 r->VarL_LowIndex = -1;
3946 if (r->VarL_LowIndex >= 0)
3947 r->VarL_LowIndex = r->VarL_Offset[0];
3951 j = r->VarL_Offset[min_j];
3952 r->VarL_Offset[min_j] = r->VarL_Offset[0];
3953 r->VarL_Offset[0] =
j;
3960 int* shifts = (
int*)
omAlloc(r->ExpL_Size*
sizeof(
int));
3963 for (i=0;i<r->ExpL_Size;i++)
3967 for (i=1;i<=r->N;i++)
3969 if (shifts[r->VarOffset[i] & 0xffffff] > r->VarOffset[i] >> 24)
3970 shifts[r->VarOffset[
i] & 0xffffff] = r->VarOffset[
i] >> 24;
3973 for (i=1;i<=r->N;i++)
3975 if (shifts[r->VarOffset[i] & 0xffffff] != 0)
3977 = (r->VarOffset[
i] & 0xffffff) |
3978 (((r->VarOffset[i] >> 24) - shifts[r->VarOffset[
i] & 0xffffff]) << 24);
3986 unsigned long divmask = 1;
3991 divmask |= (((
unsigned long) 1) << (
unsigned long) i);
4006 const char *TYP[]={
"ro_dp",
"ro_wp",
"ro_am",
"ro_wp64",
"ro_wp_neg",
"ro_cp",
4007 "ro_syzcomp",
"ro_syz",
"ro_isTemp",
"ro_is",
"ro_none"};
4010 Print(
"ExpL_Size:%d ",r->ExpL_Size);
4011 Print(
"CmpL_Size:%d ",r->CmpL_Size);
4012 Print(
"VarL_Size:%d\n",r->VarL_Size);
4013 Print(
"bitmask=0x%lx (expbound=%ld) \n",r->bitmask, r->bitmask);
4014 Print(
"divmask=%lx\n", r->divmask);
4015 Print(
"BitsPerExp=%d ExpPerLong=%d at L[%d]\n", r->BitsPerExp, r->ExpPerLong, r->VarL_Offset[0]);
4017 Print(
"VarL_LowIndex: %d\n", r->VarL_LowIndex);
4018 PrintS(
"VarL_Offset:\n");
4021 for(j = 0; j < r->VarL_Size; j++)
4022 Print(
" VarL_Offset[%d]: %d ", j, r->VarL_Offset[j]);
4029 for(j=0;j<=r->N;j++)
4030 Print(
" v%d at e-pos %d, bit %d\n",
4031 j,r->VarOffset[j] & 0xffffff, r->VarOffset[j] >>24);
4033 for(j=0;j<r->CmpL_Size;j++)
4034 Print(
" ordsgn %ld at pos %d\n",r->ordsgn[j],j);
4035 Print(
"OrdSgn:%d\n",r->OrdSgn);
4037 for(j=0;j<r->OrdSize;j++)
4039 Print(
" typ %s", TYP[r->typ[j].ord_typ]);
4040 if (r->typ[j].ord_typ==
ro_syz)
4042 const short place = r->typ[
j].data.syz.place;
4043 const int limit = r->typ[
j].data.syz.limit;
4044 const int curr_index = r->typ[
j].data.syz.curr_index;
4045 const int* syz_index = r->typ[
j].data.syz.syz_index;
4047 Print(
" limit %d (place: %d, curr_index: %d), syz_index: ", limit, place, curr_index);
4049 if( syz_index ==
NULL )
4054 for( i=0; i <= limit; i++ )
4055 Print(
"%d ", syz_index[i]);
4062 Print(
" start (level) %d, suffixpos: %d, VO: ",r->typ[j].data.isTemp.start, r->typ[j].data.isTemp.suffixpos);
4065 else if (r->typ[j].ord_typ==
ro_is)
4067 Print(
" start %d, end: %d: ",r->typ[j].data.is.start, r->typ[j].data.is.end);
4071 Print(
" limit %d",r->typ[j].data.is.limit);
4078 else if (r->typ[j].ord_typ==
ro_am)
4080 Print(
" place %d",r->typ[j].data.am.place);
4081 Print(
" start %d",r->typ[j].data.am.start);
4082 Print(
" end %d",r->typ[j].data.am.end);
4083 Print(
" len_gen %d",r->typ[j].data.am.len_gen);
4086 for(l=r->typ[j].data.am.start;l<=r->typ[j].data.am.end;l++)
4087 Print(
" %d",r->typ[j].data.am.weights[l-r->typ[j].data.am.start]);
4088 l=r->typ[
j].data.am.end+1;
4089 int ll=r->typ[
j].data.am.weights[l-r->typ[
j].data.am.start];
4091 for(
int lll=l+1;lll<l+ll+1;lll++)
4092 Print(
" %d",r->typ[j].data.am.weights[lll-r->typ[j].data.am.start]);
4096 Print(
" place %d",r->typ[j].data.dp.place);
4100 Print(
" start %d",r->typ[j].data.dp.start);
4101 Print(
" end %d",r->typ[j].data.dp.end);
4102 if ((r->typ[j].ord_typ==
ro_wp)
4106 for(
int l=r->typ[j].data.wp.start;l<=r->typ[j].data.wp.end;
l++)
4107 Print(
" %d",r->typ[j].data.wp.weights[
l-r->typ[j].data.wp.start]);
4109 else if (r->typ[j].ord_typ==
ro_wp64)
4113 for(l=r->typ[j].data.wp64.start;l<=r->typ[j].data.wp64.end;l++)
4114 Print(
" %ld",(
long)(((
int64*)r->typ[j].data.wp64.weights64)+l-r->typ[j].data.wp64.start));
4120 Print(
"pOrdIndex:%d pCompIndex:%d\n", r->pOrdIndex, r->pCompIndex);
4121 Print(
"OrdSize:%d\n",r->OrdSize);
4122 PrintS(
"--------------------\n");
4123 for(j=0;j<r->ExpL_Size;j++)
4126 if (j< r->CmpL_Size)
4127 Print(
"ordsgn %ld ", r->ordsgn[j]);
4133 if( (r->VarOffset[i] & 0xffffff) == j )
4134 {
Print(
"v%d at e[%d], bit %d; ", i,r->VarOffset[i] & 0xffffff,
4135 r->VarOffset[i] >>24 ); }
4137 if( r->pCompIndex==j )
PrintS(
"v0; ");
4138 for(i=0;i<r->OrdSize;i++)
4140 if (r->typ[i].data.dp.place == j)
4142 Print(
"ordrec:%s (start:%d, end:%d) ",TYP[r->typ[i].ord_typ],
4143 r->typ[i].data.dp.start, r->typ[i].data.dp.end);
4147 if (j==r->pOrdIndex)
4152 Print(
"LexOrder:%d, MixedOrder:%d\n",r->LexOrder, r->MixedOrder);
4154 Print(
"NegWeightL_Size: %d, NegWeightL_Offset: ", r->NegWeightL_Size);
4155 if (r->NegWeightL_Offset==
NULL)
PrintS(
" NULL");
4157 for(j = 0; j < r->NegWeightL_Size; j++)
4158 Print(
" [%d]: %d ", j, r->NegWeightL_Offset[j]);
4169 Print(
"p_Spec : %s, %s, %s\n", field, length, ord);
4171 for (i=0; i<(int) (
sizeof(
p_Procs_s)/
sizeof(
void*)); i++)
4173 Print(
" %s,\n", ((
char**) &proc_names)[i]);
4179 #define pFDeg_CASE(A) if(r->pFDeg == A) PrintS( "" #A "" ) 4185 Print(
"(%p)", r->pFDeg);
4188 Print(
"pLDeg : (%p)", r->pLDeg);
4196 if (r->p_Setm==p_Setm_General)
PrintS(
"p_Setm_General\n");
4197 else if (r->p_Setm==p_Setm_Dummy)
PrintS(
"p_Setm_Dummy\n");
4198 else if (r->p_Setm==p_Setm_TotalDegree)
PrintS(
"p_Setm_Totaldegree\n");
4199 else if (r->p_Setm==p_Setm_WFirstTotalDegree)
PrintS(
"p_Setm_WFirstTotalDegree\n");
4200 else Print(
"%p\n",r->p_Setm);
4210 Print(
"\nexp[0..%d]\n",r->ExpL_Size-1);
4211 for(i=0;i<r->ExpL_Size;i++)
4212 Print(
"%ld ",p->exp[i]);
4219 if (j==0) {
PrintS(
"...\n");
break; }
4228 Print(
"\nexp[0..%d]\n", R->ExpL_Size - 1);
4229 for(
int i = 0; i < R->ExpL_Size; i++)
4230 Print(
"%09lx ", p->exp[i]);
4233 for(
int i = 1; i <= R->N; i++)
Print(
" v%d:%5ld",i,
p_GetExp(p, i, R));
4248 for(
int j = (F->ncols*F->nrows) - 1;
j >= 0;
j-- )
4262 Print(
"gen[%d] -> gen(%d)\n", c, MIN + (*V)[ c - MIN - 1 ]);
4265 p_SetComp(
p, MIN + (*V)[ c - MIN - 1 ], r );
4286 r->typ[1].data.syzcomp.Components = currComponents;
4293 *currShiftedComponents = r->typ[1].data.syzcomp.ShiftedComponents;
4294 *currComponents = r->typ[1].data.syzcomp.Components;
4304 r->typ[1].data.syzcomp.length = length;
4314 *length = r->typ[1].data.syzcomp.length;
4315 rNGetSComps( currComponents, currShiftedComponents, r);
4331 rDBGetSComps(currComponents, currShiftedComponents, length, r);
4333 rNGetSComps(currComponents, currShiftedComponents, r);
4356 WarnS(
"rAssure_SyzComp: input ring has an IS-ordering!");
4364 res->order=(
int *)
omAlloc((i+1)*
sizeof(int));
4365 res->block0=(
int *)
omAlloc0((i+1)*
sizeof(int));
4366 res->block1=(
int *)
omAlloc0((i+1)*
sizeof(int));
4367 int ** wvhdl =(
int **)
omAlloc0((i+1)*
sizeof(
int**));
4370 res->order[
j]=r->order[j-1];
4371 res->block0[
j]=r->block0[j-1];
4372 res->block1[
j]=r->block1[j-1];
4373 if (r->wvhdl[j-1] !=
NULL)
4375 wvhdl[
j] = (
int*)
omMemDup(r->wvhdl[j-1]);
4392 WarnS(
"error in nc_rComplete");
4403 if (r->qideal!=
NULL)
4435 for(i=r->OrdSize-1;i>=0;i--)
4437 if ((r->typ[i].ord_typ==
ro_dp)
4438 && (r->typ[i].data.dp.start==start_var)
4439 && (r->typ[i].data.dp.end==end_var))
4441 pos=r->typ[
i].data.dp.place;
4457 res->ExpL_Size=r->ExpL_Size+1;
4460 res->ordsgn=(
long *)
omAlloc0(res->ExpL_Size*
sizeof(
long));
4461 for(j=0;j<r->CmpL_Size;j++)
4463 res->ordsgn[
j] = r->ordsgn[
j];
4465 res->OrdSize=r->OrdSize+1;
4470 memcpy(res->typ,r->typ,r->OrdSize*
sizeof(
sro_ord));
4473 res->typ[res->OrdSize-1].ord_typ=
ro_dp;
4474 res->typ[res->OrdSize-1].data.dp.start=start_var;
4475 res->typ[res->OrdSize-1].data.dp.end=end_var;
4476 res->typ[res->OrdSize-1].data.dp.place=res->ExpL_Size-1;
4477 pos=res->ExpL_Size-1;
4494 WarnS(
"error in nc_rComplete");
4500 if (r->qideal!=
NULL)
4530 if (r->order[i] == 0)
4539 new_r->wvhdl=(
int **)
omAlloc0(i *
sizeof(
int *));
4540 new_r->order = (
int *)
omAlloc0(i *
sizeof(
int));
4541 new_r->block0 = (
int *)
omAlloc0(i *
sizeof(
int));
4542 new_r->block1 = (
int *)
omAlloc0(i *
sizeof(
int));
4543 memcpy(new_r->order,r->order,(i-1) *
sizeof(
int));
4544 memcpy(new_r->block0,r->block0,(i-1) *
sizeof(
int));
4545 memcpy(new_r->block1,r->block1,(i-1) *
sizeof(
int));
4546 for (
int j=0;
j<=last_block;
j++)
4548 if (r->wvhdl[
j]!=
NULL)
4550 new_r->wvhdl[
j] = (
int*)
omMemDup(r->wvhdl[
j]);
4567 WarnS(
"error in nc_rComplete");
4579 int last_block =
rBlocks(r) - 2;
4586 for (i=0; i< last_block; i++)
4597 for (i=c_pos+1; i<=last_block; i++)
4599 new_r->order[i-1] = new_r->order[
i];
4600 new_r->block0[i-1] = new_r->block0[
i];
4601 new_r->block1[i-1] = new_r->block1[
i];
4602 new_r->wvhdl[i-1] = new_r->wvhdl[
i];
4604 new_r->order[last_block] = r->order[c_pos];
4605 new_r->block0[last_block] = r->block0[c_pos];
4606 new_r->block1[last_block] = r->block1[c_pos];
4607 new_r->wvhdl[last_block] = r->wvhdl[c_pos];
4618 WarnS(
"error in nc_rComplete");
4643 if (new_r_1 != new_r && new_r_1 != old_r)
rDelete(new_r_1);
4651 # ifndef SING_NDEBUG 4652 WarnS(
"error in nc_rComplete");
4659 if (old_r->qideal !=
NULL)
4661 new_r->qideal =
idrCopyR(old_r->qideal, old_r, new_r);
4669 WarnS(
"error in nc_SetupQuotient");
4694 if ((r_blocks == 3) &&
4695 (r->order[0] == b1) &&
4696 (r->order[1] == b2) &&
4700 res->order = (
int*)
omAlloc0(3*
sizeof(
int));
4701 res->block0 = (
int*)
omAlloc0(3*
sizeof(
int));
4702 res->block1 = (
int*)
omAlloc0(3*
sizeof(
int));
4703 res->wvhdl = (
int**)
omAlloc0(3*
sizeof(
int*));
4709 res->block1[1] = r->N;
4714 res->block1[0] = r->N;
4723 WarnS(
"error in nc_rComplete");
4736 Print(
"rAssure_InducedSchreyerOrdering(r, complete = %d, sgn = %d): r: \n", complete,
sgn);
4750 res->order=(
int *)
omAlloc0((n+2)*
sizeof(int));
4751 res->block0=(
int *)
omAlloc0((n+2)*
sizeof(int));
4752 res->block1=(
int *)
omAlloc0((n+2)*
sizeof(int));
4753 int ** wvhdl =(
int **)
omAlloc0((n+2)*
sizeof(
int**));
4761 res->block0[
j] = res->block1[
j] = 0;
4765 for(
int i = 0; (i <= n) && (r->order[i] != 0); i++, j++)
4767 res->order [
j] = r->order [
i];
4768 res->block0[
j] = r->block0[
i];
4769 res->block1[
j] = r->block1[
i];
4771 if (r->wvhdl[i] !=
NULL)
4773 wvhdl[
j] = (
int*)
omMemDup(r->wvhdl[i]);
4779 res->block0[
j] = res->block1[
j] =
sgn;
4790 assume(res->order[j]==0);
4803 WarnS(
"error in nc_rComplete");
4815 if (r->qideal!=
NULL)
4872 Print(
"rIsIS(p: %d)\nF:", p);
4883 for(
int pos = 0; pos < r->OrdSize; pos++ )
4884 if( r->typ[pos].ord_typ ==
ro_is)
4906 dReportError(
"Error: WRONG USE of rSetISReference: wrong ring! (typ == NULL)");
4915 dReportError(
"Error: WRONG USE of rSetISReference: specified ordering block was not found!!!" );
4920 if( i != r->typ[pos].data.is.limit )
4921 Print(
"Changing record on pos: %d\nOld limit: %d --->> New Limit: %d\n", pos, r->typ[pos].data.is.limit, i);
4924 const ideal FF =
idrHeadR(F, r, r);
4927 if( r->typ[pos].data.is.F !=
NULL)
4930 PrintS(
"Deleting old reference set F... \n");
4933 r->typ[pos].data.is.F =
NULL;
4938 r->typ[pos].data.is.F = FF;
4940 r->typ[pos].data.is.limit =
i;
4964 if ((r->typ!=
NULL) && (r->typ[0].ord_typ==
ro_syz))
4966 if( k == r->typ[0].data.syz.limit )
4970 if (r->typ[0].data.syz.limit == 0)
4972 r->typ[0].data.syz.syz_index = (
int*)
omAlloc0((k+1)*
sizeof(int));
4973 r->typ[0].data.syz.syz_index[0] = 0;
4974 r->typ[0].data.syz.curr_index = 1;
4978 r->typ[0].data.syz.syz_index = (
int*)
4980 (r->typ[0].data.syz.limit+1)*
sizeof(int),
4983 for (i=r->typ[0].data.syz.limit + 1; i<= k; i++)
4985 r->typ[0].data.syz.syz_index[
i] =
4986 r->typ[0].data.syz.curr_index;
4988 if(k < r->typ[0].data.syz.limit)
4991 Warn(
"rSetSyzComp called with smaller limit (%d) as before (%d)", k, r->typ[0].data.syz.limit);
4993 r->typ[0].data.syz.curr_index = 1 + r->typ[0].data.syz.syz_index[
k];
4997 r->typ[0].data.syz.limit =
k;
4998 r->typ[0].data.syz.curr_index++;
5007 Warn(
"rSetSyzComp(%d) in an IS ring! Be careful!", k);
5024 if ((r->typ!=
NULL) && (r->typ[0].ord_typ==
ro_syz) &&
5025 r->typ[0].data.syz.limit > 0 && i > 0)
5027 assume(i <= r->typ[0].data.syz.limit);
5029 for (j=0; j<r->typ[0].data.syz.limit; j++)
5031 if (r->typ[0].data.syz.syz_index[j] == i &&
5032 r->typ[0].data.syz.syz_index[j+1] != i)
5034 assume(r->typ[0].data.syz.syz_index[j+1] == i+1);
5038 return r->typ[0].data.syz.limit;
5050 for (i=0; i<nb; i++)
5052 if (r->wvhdl[i] !=
NULL)
5054 int length = r->block1[
i] - r->block0[
i];
5055 int* wvhdl = r->wvhdl[
i];
5059 for (j=0; j< length; j++)
5061 if (wvhdl[j] != 0 && wvhdl[j] != 1)
return FALSE;
5077 return (r->cf->type);
5099 while((r->typ[i].ord_typ!=
ro_wp64) && (r->typ[i].ord_typ>0)) i++;
5101 return (
int64*)(r->typ[
i].data.wp64.weights64);
5109 memcpy(r->typ[0].data.wp64.weights64,wv,r->N*
sizeof(
int64));
5116 r->order=(
int*)
omReallocSize(r->order, size*
sizeof(
int), (size+1)*
sizeof(
int));
5117 r->block0=(
int*)
omReallocSize(r->block0, size*
sizeof(
int), (size+1)*
sizeof(
int));
5118 r->block1=(
int*)
omReallocSize(r->block1, size*
sizeof(
int), (size+1)*
sizeof(
int));
5119 r->wvhdl=(
int **)
omReallocSize(r->wvhdl,size*
sizeof(
int *), (size+1)*
sizeof(
int *));
5120 for(
int k=size;
k>pos;
k--) r->wvhdl[
k]=r->wvhdl[
k-1];
5125 #if 0 // currently unused 5126 static int rReallocM1(ring r,
int size,
int pos)
5128 r->order=(
int*)
omReallocSize(r->order, size*
sizeof(
int), (size-1)*
sizeof(
int));
5129 r->block0=(
int*)
omReallocSize(r->block0, size*
sizeof(
int), (size-1)*
sizeof(
int));
5130 r->block1=(
int*)
omReallocSize(r->block1, size*
sizeof(
int), (size-1)*
sizeof(
int));
5131 r->wvhdl=(
int **)
omReallocSize(r->wvhdl,size*
sizeof(
int *), (size-1)*
sizeof(
int *));
5132 for(
int k=pos+1;
k<
size;
k++) r->wvhdl[
k]=r->wvhdl[
k+1];
5140 for(
int j=0;
j<=i2;
j++)
5148 #define rOppVar(R,I) (rVar(R)+1-I) 5174 int i2 = (
rVar(r)-1)/2;
5175 for(i=i2; i>=0; i--)
5181 p = r->names[
rVar(r)-1-
i];
5182 r->names[
rVar(r)-1-
i] = r->names[
i];
5197 for (i=
rVar(r)-1; i>=0; i--)
5199 char *
p=r->names[
i];
5200 if(isupper(*p)) *p = tolower(*p);
5201 else *p = toupper(*p);
5248 for(i=0; src->order[
i]!=0; i++)
5250 switch (src->order[i])
5255 r->order[
j]=src->order[
i];
5259 r->block0[
j]=
rOppVar(r, src->block1[i]);
5260 r->block1[
j]=
rOppVar(r, src->block0[i]);
5264 r->block0[
j]=
rOppVar(r, src->block1[i]);
5265 r->block1[
j]=
rOppVar(r, src->block0[i]);
5271 r->block0[
j]=
rOppVar(r, src->block1[i]);
5272 r->block1[
j]=
rOppVar(r, src->block0[i]);
5273 r->wvhdl[
j]=(
int*)
omAlloc((r->block1[j]-r->block0[j]+1)*
sizeof(int));
5274 for(
int k=r->block0[j]; k<=r->block1[j];
k++)
5275 r->wvhdl[
j][
k-r->block0[
j]]=1;
5278 r->block0[
j]=
rOppVar(r, src->block1[i]);
5279 r->block1[
j]=
rOppVar(r, src->block0[i]);
5287 r->block0[
j]=
rOppVar(r, src->block1[i]);
5288 r->block1[
j]=
rOppVar(r, src->block0[i]);
5289 r->wvhdl[
j]=(
int*)
omAlloc((r->block1[j]-r->block0[j]+1)*
sizeof(int));
5290 for(
int k=r->block0[j]; k<=r->block1[j];
k++)
5291 r->wvhdl[
j][
k-r->block0[
j]]=1;
5294 r->block0[
j]=
rOppVar(r, src->block1[i]);
5295 r->block1[
j]=
rOppVar(r, src->block0[i]);
5303 r->block0[
j]=
rOppVar(r, src->block1[i]);
5304 r->block1[
j]=
rOppVar(r, src->block0[i]);
5305 r->wvhdl[
j]=r->wvhdl[j+1]; r->wvhdl[j+1]=
NULL;
5306 rOppWeight(r->wvhdl[j], r->block1[j]-r->block0[j]);
5309 r->block0[
j]=
rOppVar(r, src->block1[i]);
5310 r->block1[
j]=
rOppVar(r, src->block0[i]);
5318 r->block0[
j]=
rOppVar(r, src->block1[i]);
5319 r->block1[
j]=
rOppVar(r, src->block0[i]);
5320 r->wvhdl[
j]=r->wvhdl[j+1]; r->wvhdl[j+1]=
NULL;
5321 rOppWeight(r->wvhdl[j], r->block1[j]-r->block0[j]);
5324 r->block0[
j]=
rOppVar(r, src->block1[i]);
5325 r->block1[
j]=
rOppVar(r, src->block0[i]);
5332 r->block0[
j]=
rOppVar(r, src->block1[i]);
5333 r->block1[
j]=
rOppVar(r, src->block0[i]);
5334 int n=r->block1[
j]-r->block0[
j];
5336 for (
int nn=0; nn<=n; nn++)
5345 r->block0[
j]=
rOppVar(r, src->block1[i]);
5346 r->block1[
j]=
rOppVar(r, src->block0[i]);
5347 rOppWeight(r->wvhdl[j], r->block1[j]-r->block0[j]);
5402 int *par_perm =
NULL;
5405 for(i=1; i<=r->N; i++)
5413 for (i=1; i<
rVar(r); i++)
5415 for (j=i+1; j<=
rVar(r); j++)
5421 MATELEM(C,nj,ni) =
p_PermPoly(
MATELEM(src->GetNC()->C,
i,
j),perm,src,r, nMap,par_perm,
rPar(src));
5424 MATELEM(D,nj,ni) =
p_PermPoly(
MATELEM(src->GetNC()->D,
i,
j),perm,src,r, nMap,par_perm,
rPar(src));
5432 WarnS(
"Error initializing non-commutative multiplication!");
5440 assume( r->GetNC()->IsSkewConstant == src->GetNC()->IsSkewConstant);
5447 if (src->qideal !=
NULL)
5452 r->qideal =
idOppose(src, src->qideal, r);
5454 r->qideal =
id_Copy(src->qideal, r);
5484 int stat =
rSum(R, Ropp, Renv);
5486 WarnS(
"Error in rEnvelope at rSum");
5509 const int N = dest->N;
5518 const ring srcBase = src;
5525 matrix C0 = src->GetNC()->C;
5526 matrix D0 = src->GetNC()->D;
5529 for (
int i = 1; i <
N; i++)
5531 for (
int j = i + 1;
j <=
N;
j++)
5576 while(r->order[i]!=0)
5583 for(j=r->block1[i]-r->block0[i];j>=0;j--)
5585 r->wvhdl[
i]=(
int*)w64;
5586 omFreeSize(w,(r->block1[i]-r->block0[i]+1)*
sizeof(
int));
5619 Werror(
"n_IsParam: IsParam is not to be used for (coeff_type = %d)",
getCoeffType(C));
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