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)
1327 res->options=r->options;
1341 res->OrdSgn=r->OrdSgn;
1343 res->firstBlockEnds=r->firstBlockEnds;
1345 res->real_var_start=r->real_var_start;
1346 res->real_var_end=r->real_var_end;
1349 #ifdef HAVE_SHIFTBBA 1350 res->isLPring=r->isLPring;
1353 res->VectorOut=r->VectorOut;
1354 res->ShortOut=r->ShortOut;
1355 res->CanShortOut=r->CanShortOut;
1356 res->LexOrder=r->LexOrder;
1357 res->MixedOrder=r->MixedOrder;
1359 res->ComponentOrder=r->ComponentOrder;
1376 res->bitmask=r->bitmask;
1377 res->divmask=r->divmask;
1378 res->BitsPerExp = r->BitsPerExp;
1379 res->ExpPerLong = r->ExpPerLong;
1398 if (copy_ordering ==
TRUE)
1401 res->wvhdl = (
int **)
omAlloc(i *
sizeof(
int *));
1402 res->order = (
int *)
omAlloc(i *
sizeof(
int));
1403 res->block0 = (
int *)
omAlloc(i *
sizeof(
int));
1404 res->block1 = (
int *)
omAlloc(i *
sizeof(
int));
1407 if (r->wvhdl[j]!=
NULL)
1409 res->wvhdl[
j] = (
int*)
omMemDup(r->wvhdl[j]);
1414 memcpy(res->order,r->order,i *
sizeof(
int));
1415 memcpy(res->block0,r->block0,i *
sizeof(
int));
1416 memcpy(res->block1,r->block1,i *
sizeof(
int));
1426 res->names = (
char **)
omAlloc0(
rVar(r) *
sizeof(
char *));
1427 for (i=0; i<
rVar(res); i++)
1431 if (r->qideal!=
NULL)
1437 WerrorS(
"internal error: rCopy0(Q,TRUE,FALSE)");
1442 WarnS(
"internal bad stuff: rCopy0(Q,TRUE,TRUE)");
1470 res->options=r->options;
1484 res->OrdSgn=r->OrdSgn;
1486 res->firstBlockEnds=r->firstBlockEnds;
1488 res->real_var_start=r->real_var_start;
1489 res->real_var_end=r->real_var_end;
1492 #ifdef HAVE_SHIFTBBA 1493 res->isLPring=r->isLPring;
1496 res->VectorOut=r->VectorOut;
1497 res->ShortOut=r->ShortOut;
1498 res->CanShortOut=r->CanShortOut;
1499 res->LexOrder=r->LexOrder;
1500 res->MixedOrder=r->MixedOrder;
1502 res->ComponentOrder=r->ComponentOrder;
1519 res->bitmask=r->bitmask;
1520 res->divmask=r->divmask;
1521 res->BitsPerExp = r->BitsPerExp;
1522 res->ExpPerLong = r->ExpPerLong;
1541 if (copy_ordering ==
TRUE)
1544 res->wvhdl = (
int **)
omAlloc(i *
sizeof(
int *));
1545 res->order = (
int *)
omAlloc(i *
sizeof(
int));
1546 res->block0 = (
int *)
omAlloc(i *
sizeof(
int));
1547 res->block1 = (
int *)
omAlloc(i *
sizeof(
int));
1548 for (j=0; j<i-1; j++)
1550 if (r->wvhdl[j]!=
NULL)
1552 res->wvhdl[j+1] = (
int*)
omMemDup(r->wvhdl[j]);
1555 res->wvhdl[j+1]=
NULL;
1557 memcpy(&(res->order[1]),r->order,(i-1) *
sizeof(
int));
1558 memcpy(&(res->block0[1]),r->block0,(i-1) *
sizeof(
int));
1559 memcpy(&(res->block1[1]),r->block1,(i-1) *
sizeof(
int));
1571 int length=wv64->
rows();
1573 for(j=length-1;j>=0;j--)
1577 res->wvhdl[0]=(
int *)A;
1579 res->block1[0]=length;
1582 res->names = (
char **)
omAlloc0(
rVar(r) *
sizeof(
char *));
1583 for (i=0; i<
rVar(res); i++)
1587 if (r->qideal!=
NULL)
1593 WerrorS(
"internal error: rCopy0(Q,TRUE,FALSE)");
1598 WarnS(
"internal bad stuff: rCopy0(Q,TRUE,TRUE)");
1635 if (r1 == r2)
return TRUE;
1637 if (r1->cf!=r2->cf)
return FALSE;
1645 for (i=0; i<
rVar(r1); i++)
1647 if ((r1->names[i] !=
NULL) && (r2->names[
i] !=
NULL))
1649 if (strcmp(r1->names[i], r2->names[i]))
return FALSE;
1651 else if ((r1->names[i] !=
NULL) ^ (r2->names[
i] !=
NULL))
1659 if (r1->qideal !=
NULL)
1661 ideal id1 = r1->qideal, id2 = r2->qideal;
1675 else if (r2->qideal !=
NULL)
return FALSE;
1685 if (r1 == r2)
return TRUE;
1689 if ((r1->cf != r2->cf)
1691 || (r1->OrdSgn != r2->OrdSgn))
1695 while (r1->order[i] != 0)
1697 if (r2->order[i] == 0)
return FALSE;
1698 if ((r1->order[i] != r2->order[i])
1699 || (r1->block0[i] != r2->block0[i])
1700 || (r1->block1[i] != r2->block1[i]))
1702 if (r1->wvhdl[i] !=
NULL)
1704 if (r2->wvhdl[i] ==
NULL)
1706 for (j=0; j<r1->block1[
i]-r1->block0[
i]+1; j++)
1707 if (r2->wvhdl[i][j] != r1->wvhdl[i][j])
1710 else if (r2->wvhdl[i] !=
NULL)
return FALSE;
1713 if (r2->order[i] != 0)
return FALSE;
1774 if (blocks == 1)
return TRUE;
1783 if ((blocks - s) > 2)
return FALSE;
1785 assume( blocks == s + 2 );
1849 if (blocks == 1)
return TRUE;
1858 if ((blocks - s) > 3)
return FALSE;
1861 if ((blocks - s) == 3)
1880 for (pos=0;pos<r->OrdSize;pos++)
1898 return (
rVar(r) > 1 &&
1911 return ((
rVar(r) > 1) &&
1920 while(r->order[i]!=0)
1922 if((r->block0[i]<=v)
1923 && (r->block1[i]>=v))
1928 return (r->wvhdl[i][v-r->block0[i]]>0);
1967 if (r->N == 0)
return TRUE;
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 ) );
3042 if (r->OrdSgn==-1) r->MixedOrder=
TRUE;
3052 if (r->wvhdl[o]!=
NULL)
3055 for(i=r->block1[o]-r->block0[o];i>=0;i--)
3056 if (r->wvhdl[o][i]<0) { r->MixedOrder=2;
break; }
3060 r->ComponentOrder=1;
3064 r->ComponentOrder=
TRUE;
3072 if( r->block0[o] != 0 )
3073 r->ComponentOrder = r->block0[o];
3082 dReportError(
"wrong internal ordering:%d at %s, l:%d\n",o_r,__FILE__,__LINE__);
3086 static void rSetFirstWv(ring r,
int i,
int* order,
int* block1,
int** wvhdl)
3091 if(block1[i]!=r->N) r->LexOrder=
TRUE;
3092 r->firstBlockEnds=block1[
i];
3093 r->firstwv = wvhdl[
i];
3102 for(j=block1[i]-r->block0[i];j>=0;j--)
3104 if (r->firstwv[j]<0) r->MixedOrder=
TRUE;
3105 if (r->firstwv[j]==0) r->LexOrder=
TRUE;
3112 for(j=block1[i]-r->block0[i];j>=0;j--)
3114 if (w[j]==0) r->LexOrder=
TRUE;
3121 if (r->pFDeg ==
p_Deg)
3142 r->pLDegOrig = r->pLDeg;
3148 int* order = r->order;
3149 int* block0 = r->block0;
3150 int* block1 = r->block1;
3151 int** wvhdl = r->wvhdl;
3160 r->LexOrder =
FALSE;
3161 r->MixedOrder =
FALSE;
3162 r->ComponentOrder = 1;
3169 r->MixedOrder =
FALSE;
3170 for(
int ii=block0[0];ii<=block1[0];ii++)
3171 if (wvhdl[0][ii-1]<0) { r->MixedOrder=2;
break;}
3173 for(
int ii=block0[0];ii<=block1[0];ii++)
3174 if (wvhdl[0][ii-1]==0) { r->LexOrder=
TRUE;
break;}
3175 if ((block0[0]==1)&&(block1[0]==r->N))
3186 r->firstwv = wvhdl[0];
3201 r->ComponentOrder=-1;
3202 if (r->OrdSgn == -1) r->pLDeg =
pLDeg0c;
3221 for(
int ii=block0[0];ii<=block1[0];ii++)
3223 if (wvhdl[0][ii-1]<0) { r->MixedOrder=2;
break;}
3225 if (r->MixedOrder==0)
3230 r->firstBlockEnds=block1[0];
3231 r->firstwv = wvhdl[0];
3243 r->ComponentOrder=-1;
3253 r->firstBlockEnds=block1[1];
3254 if (wvhdl!=
NULL) r->firstwv = wvhdl[1];
3262 for(
int ii=block0[1];ii<=block1[1];ii++)
3263 if (wvhdl[1][ii-1]<0) { r->MixedOrder=2;
break;}
3264 if (r->MixedOrder==
FALSE)
3281 int i = 0;
while (order[++i] != 0);
3306 if(r->MixedOrder==
FALSE)
3321 r->pFDegOrig = r->pFDeg;
3337 for(i=0;i<r->OrdSize;i++)
3340 ||(r->typ[i].ord_typ==
ro_am))
3345 r->NegWeightL_Size=
l;
3346 r->NegWeightL_Offset=(
int *)
omAlloc(l*
sizeof(
int));
3348 for(i=0;i<r->OrdSize;i++)
3352 r->NegWeightL_Offset[
l]=r->typ[
i].data.wp.place;
3355 else if(r->typ[i].ord_typ==
ro_am)
3357 r->NegWeightL_Offset[
l]=r->typ[
i].data.am.place;
3364 r->NegWeightL_Size = 0;
3365 r->NegWeightL_Offset =
NULL;
3377 if ( (r->cf->extRing!=
NULL)
3388 if (r->LexOrder || r->OrdSgn == -1 || (r->cf->extRing!=
NULL))
3405 r->pLexOrder=r->LexOrder;
3413 static inline int sign(
int x) {
return (x > 0) - (x < 0);}
3421 for(i=2;i<=
rVar(r);i++)
3438 if (r->VarOffset!=
NULL && force == 0)
return FALSE;
3444 r->BitsPerExp = bits;
3447 if (r->OrdSgn!=-1) r->OrdSgn=1;
3450 long *tmp_ordsgn=(
long *)
omAlloc0(3*(n+r->N)*
sizeof(long));
3452 int *
v=(
int *)
omAlloc((r->N+1)*
sizeof(int));
3453 for(i=r->N; i>=0 ; i--)
3470 switch (r->order[i])
3474 rO_WDegree(j,j_bits,r->block0[i],r->block1[i],tmp_ordsgn,tmp_typ[typ_i],
3480 rO_WMDegree(j,j_bits,r->block0[i],r->block1[i],tmp_ordsgn,tmp_typ[typ_i],
3486 rO_WDegree64(j,j_bits,r->block0[i],r->block1[i],tmp_ordsgn,
3487 tmp_typ[typ_i], (
int64 *)(r->wvhdl[i]));
3504 k=r->block1[
i]-r->block0[
i]+1;
3507 rO_WDegree(j,j_bits,r->block0[i],r->block1[i],tmp_ordsgn,
3509 r->wvhdl[i]+(r->block1[i]-r->block0[i]+1)*l);
3516 rO_LexVars(j, j_bits, r->block0[i],r->block1[i], prev_ordsgn,
3517 tmp_ordsgn,v,bits, -1);
3521 rO_LexVars_neg(j, j_bits, r->block0[i],r->block1[i], prev_ordsgn,
3522 tmp_ordsgn,v, bits, -1);
3527 rO_LexVars_neg(j, j_bits, r->block1[i],r->block0[i], prev_ordsgn,
3528 tmp_ordsgn,v, bits, -1);
3533 rO_LexVars(j, j_bits, r->block1[i],r->block0[i], prev_ordsgn,
3534 tmp_ordsgn,v, bits, -1);
3538 if (r->block0[i]==r->block1[i])
3540 rO_LexVars(j, j_bits, r->block0[i],r->block0[i], prev_ordsgn,
3541 tmp_ordsgn,v, bits, -1);
3545 rO_TDegree(j,j_bits,r->block0[i],r->block1[i],tmp_ordsgn,
3549 prev_ordsgn,tmp_ordsgn,v,bits, r->block0[i]);
3554 if (r->block0[i]==r->block1[i])
3556 rO_LexVars(j, j_bits, r->block0[i],r->block0[i], prev_ordsgn,
3557 tmp_ordsgn,v, bits, -1);
3561 rO_TDegree(j,j_bits,r->block0[i],r->block1[i],tmp_ordsgn,
3564 rO_LexVars(j, j_bits, r->block0[i],r->block1[i]-1, prev_ordsgn,
3565 tmp_ordsgn,v, bits, r->block1[i]);
3570 if (r->block0[i]==r->block1[i])
3573 tmp_ordsgn,v,bits, -1);
3581 prev_ordsgn,tmp_ordsgn,v,bits, r->block0[i]);
3587 if (r->block0[i]==r->block1[i])
3590 tmp_ordsgn,v, bits, -1);
3597 rO_LexVars(j, j_bits, r->block0[i],r->block1[i]-1, prev_ordsgn,
3598 tmp_ordsgn,v, bits, r->block1[i]);
3604 rO_WDegree(j,j_bits,r->block0[i],r->block1[i],tmp_ordsgn,
3605 tmp_typ[typ_i], r->wvhdl[i]);
3610 for(jj=r->block1[i]-r->block0[i];jj>=0; jj--)
3612 if (r->wvhdl[i][jj]<=0) have_bad_weights=
TRUE;
3614 if (have_bad_weights)
3616 rO_TDegree(j,j_bits,r->block0[i],r->block1[i],tmp_ordsgn,
3622 if (r->block1[i]!=r->block0[i])
3624 rO_LexVars_neg(j, j_bits,r->block1[i],r->block0[i]+1, prev_ordsgn,
3625 tmp_ordsgn, v,bits, r->block0[i]);
3630 rO_WDegree(j,j_bits,r->block0[i],r->block1[i],tmp_ordsgn,
3631 tmp_typ[typ_i], r->wvhdl[i]);
3636 for(jj=r->block1[i]-r->block0[i];jj>=0; jj--)
3638 if (r->wvhdl[i][jj]<=0) have_bad_weights=
TRUE;
3640 if (have_bad_weights)
3642 rO_TDegree(j,j_bits,r->block0[i],r->block1[i],tmp_ordsgn,
3648 if (r->block1[i]!=r->block0[i])
3650 rO_LexVars(j, j_bits,r->block0[i],r->block1[i]-1, prev_ordsgn,
3651 tmp_ordsgn,v, bits, r->block1[i]);
3657 tmp_typ[typ_i], r->wvhdl[i]);
3659 if (r->block1[i]!=r->block0[i])
3661 rO_LexVars_neg(j, j_bits,r->block1[i],r->block0[i]+1, prev_ordsgn,
3662 tmp_ordsgn, v,bits, r->block0[i]);
3669 tmp_typ[typ_i], r->wvhdl[i]);
3671 if (r->block1[i]!=r->block0[i])
3673 rO_LexVars(j, j_bits,r->block0[i],r->block1[i]-1, prev_ordsgn,
3674 tmp_ordsgn,v, bits, r->block1[i]);
3682 rO_Syzcomp(j, j_bits,prev_ordsgn, tmp_ordsgn,tmp_typ[typ_i]);
3683 need_to_add_comp=
TRUE;
3688 assume(typ_i == 0 && j == 0);
3689 rO_Syz(j, j_bits, prev_ordsgn, tmp_ordsgn, tmp_typ[typ_i]);
3690 need_to_add_comp=
TRUE;
3697 assume( r->block0[i] == r->block1[i] );
3698 const int s = r->block0[
i];
3699 assume( -2 < s && s < 2);
3702 rO_ISPrefix(j, j_bits, prev_ordsgn, tmp_ordsgn, r->N, v, tmp_typ[typ_i++]);
3705 rO_ISSuffix(j, j_bits, prev_ordsgn, tmp_ordsgn, r->N, v, tmp_typ, typ_i, s);
3706 need_to_add_comp=
FALSE;
3724 j_bits=j_bits0; j=j0;
3729 if((need_to_add_comp) && (v[0]== -1))
3743 for(i=1 ; i<=r->N ; i++)
3749 rO_LexVars(j, j_bits, i,i, prev_ordsgn,tmp_ordsgn,v,bits, -1);
3770 r->ordsgn=(
long *)
omAlloc0(r->ExpL_Size*
sizeof(
long));
3772 for(j=0;j<r->CmpL_Size;j++)
3774 r->ordsgn[
j] = tmp_ordsgn[
j];
3783 if (typ_i==0) r->typ=
NULL;
3787 memcpy(r->typ,tmp_typ,typ_i*
sizeof(
sro_ord));
3797 r->pCompIndex=(r->VarOffset[0] & 0xffff);
3800 if (i==r->pCompIndex) i++;
3801 while ((j < r->OrdSize)
3809 if (i==r->pCompIndex) i++;
3844 if (r->OrdSgn==-1)
return;
3846 for(
int i=1;i<=r->N;i++)
3850 for(
int j=0;(
j<=
b) && (found==0);
j++)
3853 if ((r->block0[
j]<=i)&&(r->block1[
j]>=
i))
3872 if(r->wvhdl[
j][i-r->block0[
j]]<0) { r->OrdSgn=-1;
return;}
3873 if(r->wvhdl[
j][i-r->block0[
j]]>0) { found=1;
break;}
3884 if (r ==
NULL)
return;
3885 if (r->VarOffset !=
NULL)
3887 if (r->OrdSize!=0 && r->typ !=
NULL)
3889 for(
int i = 0; i < r->OrdSize; i++)
3890 if( r->typ[i].ord_typ ==
ro_is)
3893 r->typ[
i].data.is.F =
NULL;
3895 if( r->typ[i].data.is.pVarOffset !=
NULL )
3898 r->typ[
i].data.is.pVarOffset =
NULL;
3901 else if (r->typ[i].ord_typ ==
ro_syz)
3903 if(r->typ[i].data.syz.limit > 0)
3904 omFreeSize(r->typ[i].data.syz.syz_index, ((r->typ[i].data.syz.limit) +1)*
sizeof(
int));
3905 r->typ[
i].data.syz.syz_index =
NULL;
3909 assume( r->typ[i].data.syzcomp.ShiftedComponents ==
NULL );
3910 assume( r->typ[i].data.syzcomp.Components ==
NULL );
3920 if (r->PolyBin !=
NULL)
3925 if (r->ordsgn !=
NULL && r->CmpL_Size != 0)
3927 if (r->p_Procs !=
NULL)
3929 omfreeSize(r->VarL_Offset, r->VarL_Size*
sizeof(
int));
3931 if (r->NegWeightL_Offset!=
NULL)
3933 omFreeSize(r->NegWeightL_Offset, r->NegWeightL_Size*
sizeof(
int));
3934 r->NegWeightL_Offset=
NULL;
3942 int* VarL_Number = (
int*)
omAlloc0(r->ExpL_Size*
sizeof(
int));
3947 for (i=1; i<=r->N; i++)
3949 VarL_Number[r->VarOffset[
i] & 0xffffff]++;
3953 for (i=0, j=0; i<r->ExpL_Size; i++)
3955 if (VarL_Number[i] != 0)
3957 if (min > VarL_Number[i])
3959 min = VarL_Number[
i];
3968 r->VarL_Offset = (
int*)
omAlloc(r->VarL_Size*
sizeof(
int));
3969 r->VarL_LowIndex = 0;
3972 for (i=0, j=0; i<r->ExpL_Size; i++)
3974 if (VarL_Number[i] != 0)
3976 r->VarL_Offset[
j] =
i;
3977 if (j > 0 && r->VarL_Offset[j-1] != r->VarL_Offset[j] - 1)
3978 r->VarL_LowIndex = -1;
3982 if (r->VarL_LowIndex >= 0)
3983 r->VarL_LowIndex = r->VarL_Offset[0];
3985 r->MinExpPerLong =
min;
3988 j = r->VarL_Offset[min_j];
3989 r->VarL_Offset[min_j] = r->VarL_Offset[0];
3990 r->VarL_Offset[0] =
j;
3997 int* shifts = (
int*)
omAlloc(r->ExpL_Size*
sizeof(
int));
4000 for (i=0;i<r->ExpL_Size;i++)
4004 for (i=1;i<=r->N;i++)
4006 if (shifts[r->VarOffset[i] & 0xffffff] > r->VarOffset[i] >> 24)
4007 shifts[r->VarOffset[
i] & 0xffffff] = r->VarOffset[
i] >> 24;
4010 for (i=1;i<=r->N;i++)
4012 if (shifts[r->VarOffset[i] & 0xffffff] != 0)
4014 = (r->VarOffset[
i] & 0xffffff) |
4015 (((r->VarOffset[i] >> 24) - shifts[r->VarOffset[
i] & 0xffffff]) << 24);
4023 unsigned long divmask = 1;
4028 divmask |= (((
unsigned long) 1) << (
unsigned long) i);
4043 const char *TYP[]={
"ro_dp",
"ro_wp",
"ro_am",
"ro_wp64",
"ro_wp_neg",
"ro_cp",
4044 "ro_syzcomp",
"ro_syz",
"ro_isTemp",
"ro_is",
"ro_none"};
4047 Print(
"ExpL_Size:%d ",r->ExpL_Size);
4048 Print(
"CmpL_Size:%d ",r->CmpL_Size);
4049 Print(
"VarL_Size:%d\n",r->VarL_Size);
4050 Print(
"bitmask=0x%lx (expbound=%ld) \n",r->bitmask, r->bitmask);
4051 Print(
"divmask=%lx\n", r->divmask);
4052 Print(
"BitsPerExp=%d ExpPerLong=%d MinExpPerLong=%d at L[%d]\n", r->BitsPerExp, r->ExpPerLong, r->MinExpPerLong, r->VarL_Offset[0]);
4054 Print(
"VarL_LowIndex: %d\n", r->VarL_LowIndex);
4055 PrintS(
"VarL_Offset:\n");
4058 for(j = 0; j < r->VarL_Size; j++)
4059 Print(
" VarL_Offset[%d]: %d ", j, r->VarL_Offset[j]);
4066 for(j=0;j<=r->N;j++)
4067 Print(
" v%d at e-pos %d, bit %d\n",
4068 j,r->VarOffset[j] & 0xffffff, r->VarOffset[j] >>24);
4070 for(j=0;j<r->CmpL_Size;j++)
4071 Print(
" ordsgn %ld at pos %d\n",r->ordsgn[j],j);
4072 Print(
"OrdSgn:%d\n",r->OrdSgn);
4074 for(j=0;j<r->OrdSize;j++)
4076 Print(
" typ %s", TYP[r->typ[j].ord_typ]);
4077 if (r->typ[j].ord_typ==
ro_syz)
4079 const short place = r->typ[
j].data.syz.place;
4080 const int limit = r->typ[
j].data.syz.limit;
4081 const int curr_index = r->typ[
j].data.syz.curr_index;
4082 const int* syz_index = r->typ[
j].data.syz.syz_index;
4084 Print(
" limit %d (place: %d, curr_index: %d), syz_index: ", limit, place, curr_index);
4086 if( syz_index ==
NULL )
4091 for( i=0; i <= limit; i++ )
4092 Print(
"%d ", syz_index[i]);
4099 Print(
" start (level) %d, suffixpos: %d, VO: ",r->typ[j].data.isTemp.start, r->typ[j].data.isTemp.suffixpos);
4102 else if (r->typ[j].ord_typ==
ro_is)
4104 Print(
" start %d, end: %d: ",r->typ[j].data.is.start, r->typ[j].data.is.end);
4108 Print(
" limit %d",r->typ[j].data.is.limit);
4115 else if (r->typ[j].ord_typ==
ro_am)
4117 Print(
" place %d",r->typ[j].data.am.place);
4118 Print(
" start %d",r->typ[j].data.am.start);
4119 Print(
" end %d",r->typ[j].data.am.end);
4120 Print(
" len_gen %d",r->typ[j].data.am.len_gen);
4123 for(l=r->typ[j].data.am.start;l<=r->typ[j].data.am.end;l++)
4124 Print(
" %d",r->typ[j].data.am.weights[l-r->typ[j].data.am.start]);
4125 l=r->typ[
j].data.am.end+1;
4126 int ll=r->typ[
j].data.am.weights[l-r->typ[
j].data.am.start];
4128 for(
int lll=l+1;lll<l+ll+1;lll++)
4129 Print(
" %d",r->typ[j].data.am.weights[lll-r->typ[j].data.am.start]);
4133 Print(
" place %d",r->typ[j].data.dp.place);
4137 Print(
" start %d",r->typ[j].data.dp.start);
4138 Print(
" end %d",r->typ[j].data.dp.end);
4139 if ((r->typ[j].ord_typ==
ro_wp)
4143 for(
int l=r->typ[j].data.wp.start;l<=r->typ[j].data.wp.end;
l++)
4144 Print(
" %d",r->typ[j].data.wp.weights[
l-r->typ[j].data.wp.start]);
4146 else if (r->typ[j].ord_typ==
ro_wp64)
4150 for(l=r->typ[j].data.wp64.start;l<=r->typ[j].data.wp64.end;l++)
4151 Print(
" %ld",(
long)(((
int64*)r->typ[j].data.wp64.weights64)+l-r->typ[j].data.wp64.start));
4157 Print(
"pOrdIndex:%d pCompIndex:%d\n", r->pOrdIndex, r->pCompIndex);
4158 Print(
"OrdSize:%d\n",r->OrdSize);
4159 PrintS(
"--------------------\n");
4160 for(j=0;j<r->ExpL_Size;j++)
4163 if (j< r->CmpL_Size)
4164 Print(
"ordsgn %ld ", r->ordsgn[j]);
4170 if( (r->VarOffset[i] & 0xffffff) == j )
4171 {
Print(
"v%d at e[%d], bit %d; ", i,r->VarOffset[i] & 0xffffff,
4172 r->VarOffset[i] >>24 ); }
4174 if( r->pCompIndex==j )
PrintS(
"v0; ");
4175 for(i=0;i<r->OrdSize;i++)
4177 if (r->typ[i].data.dp.place == j)
4179 Print(
"ordrec:%s (start:%d, end:%d) ",TYP[r->typ[i].ord_typ],
4180 r->typ[i].data.dp.start, r->typ[i].data.dp.end);
4184 if (j==r->pOrdIndex)
4189 Print(
"LexOrder:%d, MixedOrder:%d\n",r->LexOrder, r->MixedOrder);
4191 Print(
"NegWeightL_Size: %d, NegWeightL_Offset: ", r->NegWeightL_Size);
4192 if (r->NegWeightL_Offset==
NULL)
PrintS(
" NULL");
4194 for(j = 0; j < r->NegWeightL_Size; j++)
4195 Print(
" [%d]: %d ", j, r->NegWeightL_Offset[j]);
4206 Print(
"p_Spec : %s, %s, %s\n", field, length, ord);
4208 for (i=0; i<(int) (
sizeof(
p_Procs_s)/
sizeof(
void*)); i++)
4210 Print(
" %s,\n", ((
char**) &proc_names)[i]);
4216 #define pFDeg_CASE(A) if(r->pFDeg == A) PrintS( "" #A "" ) 4222 Print(
"(%p)", r->pFDeg);
4225 Print(
"pLDeg : (%p)", r->pLDeg);
4233 if (r->p_Setm==p_Setm_General)
PrintS(
"p_Setm_General\n");
4234 else if (r->p_Setm==p_Setm_Dummy)
PrintS(
"p_Setm_Dummy\n");
4235 else if (r->p_Setm==p_Setm_TotalDegree)
PrintS(
"p_Setm_Totaldegree\n");
4236 else if (r->p_Setm==p_Setm_WFirstTotalDegree)
PrintS(
"p_Setm_WFirstTotalDegree\n");
4237 else Print(
"%p\n",r->p_Setm);
4247 Print(
"\nexp[0..%d]\n",r->ExpL_Size-1);
4248 for(i=0;i<r->ExpL_Size;i++)
4249 Print(
"%ld ",p->exp[i]);
4256 if (j==0) {
PrintS(
"...\n");
break; }
4265 Print(
"\nexp[0..%d]\n", R->ExpL_Size - 1);
4266 for(
int i = 0; i < R->ExpL_Size; i++)
4267 Print(
"%09lx ", p->exp[i]);
4270 for(
int i = 1; i <= R->N; i++)
Print(
" v%d:%5ld",i,
p_GetExp(p, i, R));
4285 for(
int j = (F->ncols*F->nrows) - 1;
j >= 0;
j-- )
4299 Print(
"gen[%d] -> gen(%d)\n", c, MIN + (*V)[ c - MIN - 1 ]);
4302 p_SetComp(
p, MIN + (*V)[ c - MIN - 1 ], r );
4323 r->typ[1].data.syzcomp.Components = currComponents;
4330 *currShiftedComponents = r->typ[1].data.syzcomp.ShiftedComponents;
4331 *currComponents = r->typ[1].data.syzcomp.Components;
4341 r->typ[1].data.syzcomp.length = length;
4351 *length = r->typ[1].data.syzcomp.length;
4352 rNGetSComps( currComponents, currShiftedComponents, r);
4368 rDBGetSComps(currComponents, currShiftedComponents, length, r);
4370 rNGetSComps(currComponents, currShiftedComponents, r);
4393 WarnS(
"rAssure_SyzComp: input ring has an IS-ordering!");
4401 res->order=(
int *)
omAlloc((i+1)*
sizeof(int));
4402 res->block0=(
int *)
omAlloc0((i+1)*
sizeof(int));
4403 res->block1=(
int *)
omAlloc0((i+1)*
sizeof(int));
4404 int ** wvhdl =(
int **)
omAlloc0((i+1)*
sizeof(
int**));
4407 res->order[
j]=r->order[j-1];
4408 res->block0[
j]=r->block0[j-1];
4409 res->block1[
j]=r->block1[j-1];
4410 if (r->wvhdl[j-1] !=
NULL)
4412 wvhdl[
j] = (
int*)
omMemDup(r->wvhdl[j-1]);
4429 WarnS(
"error in nc_rComplete");
4440 if (r->qideal!=
NULL)
4472 for(i=r->OrdSize-1;i>=0;i--)
4474 if ((r->typ[i].ord_typ==
ro_dp)
4475 && (r->typ[i].data.dp.start==start_var)
4476 && (r->typ[i].data.dp.end==end_var))
4478 pos=r->typ[
i].data.dp.place;
4494 res->ExpL_Size=r->ExpL_Size+1;
4497 res->ordsgn=(
long *)
omAlloc0(res->ExpL_Size*
sizeof(
long));
4498 for(j=0;j<r->CmpL_Size;j++)
4500 res->ordsgn[
j] = r->ordsgn[
j];
4502 res->OrdSize=r->OrdSize+1;
4507 memcpy(res->typ,r->typ,r->OrdSize*
sizeof(
sro_ord));
4510 res->typ[res->OrdSize-1].ord_typ=
ro_dp;
4511 res->typ[res->OrdSize-1].data.dp.start=start_var;
4512 res->typ[res->OrdSize-1].data.dp.end=end_var;
4513 res->typ[res->OrdSize-1].data.dp.place=res->ExpL_Size-1;
4514 pos=res->ExpL_Size-1;
4531 WarnS(
"error in nc_rComplete");
4537 if (r->qideal!=
NULL)
4567 if (r->order[i] == 0)
4576 new_r->wvhdl=(
int **)
omAlloc0(i *
sizeof(
int *));
4577 new_r->order = (
int *)
omAlloc0(i *
sizeof(
int));
4578 new_r->block0 = (
int *)
omAlloc0(i *
sizeof(
int));
4579 new_r->block1 = (
int *)
omAlloc0(i *
sizeof(
int));
4580 memcpy(new_r->order,r->order,(i-1) *
sizeof(
int));
4581 memcpy(new_r->block0,r->block0,(i-1) *
sizeof(
int));
4582 memcpy(new_r->block1,r->block1,(i-1) *
sizeof(
int));
4583 for (
int j=0;
j<=last_block;
j++)
4585 if (r->wvhdl[
j]!=
NULL)
4587 new_r->wvhdl[
j] = (
int*)
omMemDup(r->wvhdl[
j]);
4604 WarnS(
"error in nc_rComplete");
4616 int last_block =
rBlocks(r) - 2;
4623 for (i=0; i< last_block; i++)
4634 for (i=c_pos+1; i<=last_block; i++)
4636 new_r->order[i-1] = new_r->order[
i];
4637 new_r->block0[i-1] = new_r->block0[
i];
4638 new_r->block1[i-1] = new_r->block1[
i];
4639 new_r->wvhdl[i-1] = new_r->wvhdl[
i];
4641 new_r->order[last_block] = r->order[c_pos];
4642 new_r->block0[last_block] = r->block0[c_pos];
4643 new_r->block1[last_block] = r->block1[c_pos];
4644 new_r->wvhdl[last_block] = r->wvhdl[c_pos];
4655 WarnS(
"error in nc_rComplete");
4680 if (new_r_1 != new_r && new_r_1 != old_r)
rDelete(new_r_1);
4688 # ifndef SING_NDEBUG 4689 WarnS(
"error in nc_rComplete");
4696 if (old_r->qideal !=
NULL)
4698 new_r->qideal =
idrCopyR(old_r->qideal, old_r, new_r);
4706 WarnS(
"error in nc_SetupQuotient");
4731 if ((r_blocks == 3) &&
4732 (r->order[0] == b1) &&
4733 (r->order[1] == b2) &&
4737 res->order = (
int*)
omAlloc0(3*
sizeof(
int));
4738 res->block0 = (
int*)
omAlloc0(3*
sizeof(
int));
4739 res->block1 = (
int*)
omAlloc0(3*
sizeof(
int));
4740 res->wvhdl = (
int**)
omAlloc0(3*
sizeof(
int*));
4746 res->block1[1] = r->N;
4751 res->block1[0] = r->N;
4760 WarnS(
"error in nc_rComplete");
4773 Print(
"rAssure_InducedSchreyerOrdering(r, complete = %d, sgn = %d): r: \n", complete,
sgn);
4787 res->order=(
int *)
omAlloc0((n+2)*
sizeof(int));
4788 res->block0=(
int *)
omAlloc0((n+2)*
sizeof(int));
4789 res->block1=(
int *)
omAlloc0((n+2)*
sizeof(int));
4790 int ** wvhdl =(
int **)
omAlloc0((n+2)*
sizeof(
int**));
4798 res->block0[
j] = res->block1[
j] = 0;
4802 for(
int i = 0; (i <= n) && (r->order[i] != 0); i++, j++)
4804 res->order [
j] = r->order [
i];
4805 res->block0[
j] = r->block0[
i];
4806 res->block1[
j] = r->block1[
i];
4808 if (r->wvhdl[i] !=
NULL)
4810 wvhdl[
j] = (
int*)
omMemDup(r->wvhdl[i]);
4816 res->block0[
j] = res->block1[
j] =
sgn;
4827 assume(res->order[j]==0);
4840 WarnS(
"error in nc_rComplete");
4852 if (r->qideal!=
NULL)
4909 Print(
"rIsIS(p: %d)\nF:", p);
4920 for(
int pos = 0; pos < r->OrdSize; pos++ )
4921 if( r->typ[pos].ord_typ ==
ro_is)
4943 dReportError(
"Error: WRONG USE of rSetISReference: wrong ring! (typ == NULL)");
4952 dReportError(
"Error: WRONG USE of rSetISReference: specified ordering block was not found!!!" );
4957 if( i != r->typ[pos].data.is.limit )
4958 Print(
"Changing record on pos: %d\nOld limit: %d --->> New Limit: %d\n", pos, r->typ[pos].data.is.limit, i);
4961 const ideal FF =
idrHeadR(F, r, r);
4964 if( r->typ[pos].data.is.F !=
NULL)
4967 PrintS(
"Deleting old reference set F... \n");
4970 r->typ[pos].data.is.F =
NULL;
4975 r->typ[pos].data.is.F = FF;
4977 r->typ[pos].data.is.limit =
i;
5001 if ((r->typ!=
NULL) && (r->typ[0].ord_typ==
ro_syz))
5003 if( k == r->typ[0].data.syz.limit )
5007 if (r->typ[0].data.syz.limit == 0)
5009 r->typ[0].data.syz.syz_index = (
int*)
omAlloc0((k+1)*
sizeof(int));
5010 r->typ[0].data.syz.syz_index[0] = 0;
5011 r->typ[0].data.syz.curr_index = 1;
5015 r->typ[0].data.syz.syz_index = (
int*)
5017 (r->typ[0].data.syz.limit+1)*
sizeof(int),
5020 for (i=r->typ[0].data.syz.limit + 1; i<= k; i++)
5022 r->typ[0].data.syz.syz_index[
i] =
5023 r->typ[0].data.syz.curr_index;
5025 if(k < r->typ[0].data.syz.limit)
5028 Warn(
"rSetSyzComp called with smaller limit (%d) as before (%d)", k, r->typ[0].data.syz.limit);
5030 r->typ[0].data.syz.curr_index = 1 + r->typ[0].data.syz.syz_index[
k];
5034 r->typ[0].data.syz.limit =
k;
5035 r->typ[0].data.syz.curr_index++;
5044 Warn(
"rSetSyzComp(%d) in an IS ring! Be careful!", k);
5061 if ((r->typ!=
NULL) && (r->typ[0].ord_typ==
ro_syz) &&
5062 r->typ[0].data.syz.limit > 0 && i > 0)
5064 assume(i <= r->typ[0].data.syz.limit);
5066 for (j=0; j<r->typ[0].data.syz.limit; j++)
5068 if (r->typ[0].data.syz.syz_index[j] == i &&
5069 r->typ[0].data.syz.syz_index[j+1] != i)
5071 assume(r->typ[0].data.syz.syz_index[j+1] == i+1);
5075 return r->typ[0].data.syz.limit;
5087 for (i=0; i<nb; i++)
5089 if (r->wvhdl[i] !=
NULL)
5091 int length = r->block1[
i] - r->block0[
i];
5092 int* wvhdl = r->wvhdl[
i];
5096 for (j=0; j< length; j++)
5098 if (wvhdl[j] != 0 && wvhdl[j] != 1)
return FALSE;
5114 return (r->cf->type);
5138 while((r->typ[i].ord_typ!=
ro_wp64) && (r->typ[i].ord_typ>0)) i++;
5140 return (
int64*)(r->typ[
i].data.wp64.weights64);
5148 memcpy(r->typ[0].data.wp64.weights64,wv,r->N*
sizeof(
int64));
5155 r->order=(
int*)
omReallocSize(r->order, size*
sizeof(
int), (size+1)*
sizeof(
int));
5156 r->block0=(
int*)
omReallocSize(r->block0, size*
sizeof(
int), (size+1)*
sizeof(
int));
5157 r->block1=(
int*)
omReallocSize(r->block1, size*
sizeof(
int), (size+1)*
sizeof(
int));
5158 r->wvhdl=(
int **)
omReallocSize(r->wvhdl,size*
sizeof(
int *), (size+1)*
sizeof(
int *));
5159 for(
int k=size;
k>pos;
k--) r->wvhdl[
k]=r->wvhdl[
k-1];
5164 #if 0 // currently unused 5165 static int rReallocM1(ring r,
int size,
int pos)
5167 r->order=(
int*)
omReallocSize(r->order, size*
sizeof(
int), (size-1)*
sizeof(
int));
5168 r->block0=(
int*)
omReallocSize(r->block0, size*
sizeof(
int), (size-1)*
sizeof(
int));
5169 r->block1=(
int*)
omReallocSize(r->block1, size*
sizeof(
int), (size-1)*
sizeof(
int));
5170 r->wvhdl=(
int **)
omReallocSize(r->wvhdl,size*
sizeof(
int *), (size-1)*
sizeof(
int *));
5171 for(
int k=pos+1;
k<
size;
k++) r->wvhdl[
k]=r->wvhdl[
k+1];
5179 for(
int j=0;
j<=i2;
j++)
5187 #define rOppVar(R,I) (rVar(R)+1-I) 5213 int i2 = (
rVar(r)-1)/2;
5214 for(i=i2; i>=0; i--)
5220 p = r->names[
rVar(r)-1-
i];
5221 r->names[
rVar(r)-1-
i] = r->names[
i];
5236 for (i=
rVar(r)-1; i>=0; i--)
5238 char *
p=r->names[
i];
5239 if(isupper(*p)) *p = tolower(*p);
5240 else *p = toupper(*p);
5287 for(i=0; src->order[
i]!=0; i++)
5289 switch (src->order[i])
5294 r->order[
j]=src->order[
i];
5298 r->block0[
j]=
rOppVar(r, src->block1[i]);
5299 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]);
5310 r->block0[
j]=
rOppVar(r, src->block1[i]);
5311 r->block1[
j]=
rOppVar(r, src->block0[i]);
5312 r->wvhdl[
j]=(
int*)
omAlloc((r->block1[j]-r->block0[j]+1)*
sizeof(int));
5313 for(
int k=r->block0[j]; k<=r->block1[j];
k++)
5314 r->wvhdl[
j][
k-r->block0[
j]]=1;
5317 r->block0[
j]=
rOppVar(r, src->block1[i]);
5318 r->block1[
j]=
rOppVar(r, src->block0[i]);
5326 r->block0[
j]=
rOppVar(r, src->block1[i]);
5327 r->block1[
j]=
rOppVar(r, src->block0[i]);
5328 r->wvhdl[
j]=(
int*)
omAlloc((r->block1[j]-r->block0[j]+1)*
sizeof(int));
5329 for(
int k=r->block0[j]; k<=r->block1[j];
k++)
5330 r->wvhdl[
j][
k-r->block0[
j]]=1;
5333 r->block0[
j]=
rOppVar(r, src->block1[i]);
5334 r->block1[
j]=
rOppVar(r, src->block0[i]);
5342 r->block0[
j]=
rOppVar(r, src->block1[i]);
5343 r->block1[
j]=
rOppVar(r, src->block0[i]);
5344 r->wvhdl[
j]=r->wvhdl[j+1]; r->wvhdl[j+1]=
NULL;
5345 rOppWeight(r->wvhdl[j], r->block1[j]-r->block0[j]);
5348 r->block0[
j]=
rOppVar(r, src->block1[i]);
5349 r->block1[
j]=
rOppVar(r, src->block0[i]);
5357 r->block0[
j]=
rOppVar(r, src->block1[i]);
5358 r->block1[
j]=
rOppVar(r, src->block0[i]);
5359 r->wvhdl[
j]=r->wvhdl[j+1]; r->wvhdl[j+1]=
NULL;
5360 rOppWeight(r->wvhdl[j], r->block1[j]-r->block0[j]);
5363 r->block0[
j]=
rOppVar(r, src->block1[i]);
5364 r->block1[
j]=
rOppVar(r, src->block0[i]);
5371 r->block0[
j]=
rOppVar(r, src->block1[i]);
5372 r->block1[
j]=
rOppVar(r, src->block0[i]);
5373 int n=r->block1[
j]-r->block0[
j];
5375 for (
int nn=0; nn<=n; nn++)
5384 r->block0[
j]=
rOppVar(r, src->block1[i]);
5385 r->block1[
j]=
rOppVar(r, src->block0[i]);
5386 rOppWeight(r->wvhdl[j], r->block1[j]-r->block0[j]);
5441 int *par_perm =
NULL;
5444 for(i=1; i<=r->N; i++)
5452 for (i=1; i<
rVar(r); i++)
5454 for (j=i+1; j<=
rVar(r); j++)
5460 MATELEM(C,nj,ni) =
p_PermPoly(
MATELEM(src->GetNC()->C,
i,
j),perm,src,r, nMap,par_perm,
rPar(src));
5463 MATELEM(D,nj,ni) =
p_PermPoly(
MATELEM(src->GetNC()->D,
i,
j),perm,src,r, nMap,par_perm,
rPar(src));
5471 WarnS(
"Error initializing non-commutative multiplication!");
5479 assume( r->GetNC()->IsSkewConstant == src->GetNC()->IsSkewConstant);
5486 if (src->qideal !=
NULL)
5491 r->qideal =
idOppose(src, src->qideal, r);
5493 r->qideal =
id_Copy(src->qideal, r);
5523 int stat =
rSum(R, Ropp, Renv);
5525 WarnS(
"Error in rEnvelope at rSum");
5548 const int N = dest->N;
5557 const ring srcBase = src;
5564 matrix C0 = src->GetNC()->C;
5565 matrix D0 = src->GetNC()->D;
5568 for (
int i = 1; i <
N; i++)
5570 for (
int j = i + 1;
j <=
N;
j++)
5615 while(r->order[i]!=0)
5622 for(j=r->block1[i]-r->block0[i];j>=0;j--)
5624 r->wvhdl[
i]=(
int*)w64;
5625 omFreeSize(w,(r->block1[i]-r->block0[i]+1)*
sizeof(
int));
5658 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)
#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