52 #define BITS_PER_LONG 8*SIZEOF_LONG 90 return ringorder_name[ord];
121 r->names = (
char **)
omAlloc0(N *
sizeof(
char *));
129 r->wvhdl = (
int **)
omAlloc0((ord_size+1) *
sizeof(
int *));
146 return rDefault(cf,N,n,ord_size,ord,block0,block1,wvhdl);
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;
257 PrintS(
"// coefficients: ");
269 R->ShortOut = bSaveShortOut;
312 Print(
"// number of vars : %d",r->N);
317 for (
int l=0, nlen=0 ;
l<nblocks;
l++)
320 Print(
"\n// block %3d : ",
l+1);
329 Print(
" syzcomp at %d",r->typ[
l].data.syz.limit);
335 assume( r->block0[
l] == r->block1[
l] );
336 const int s = r->block0[
l];
337 assume( (-2 < s) && (s < 2) );
350 for (i = r->block0[
l]-1; i<r->block1[
l]; i++)
352 nlen = strlen(r->names[i]);
353 Print(
" %s",r->names[i]);
357 if (r->wvhdl[
l]!=
NULL)
360 j<(r->block1[
l]-r->block0[
l]+1)*(r->block1[
l]-r->block0[
l]+1);
363 PrintS(
"\n// : weights ");
364 for (i = 0; i<=r->block1[
l]-r->block0[
l]; i++)
370 Print(
"%*lld " ,nlen,w[i+
j]);
372 Print(
" %*ld" ,nlen,w[i+
j]);
376 Print(
" %*d" ,nlen,r->wvhdl[
l][i+
j]);
382 int m=r->wvhdl[
l][
i];
383 Print(
"\n// : %d module weights ",m);
385 for(;i<=
m;i++)
Print(
" %*d" ,nlen,r->wvhdl[
l][i]);
392 PrintS(
"\n// noncommutative relations:");
398 for (i = 1; i<r->N; i++)
400 for (j = i+1; j<=r->N; j++)
405 Print(
"\n// %s%s=",r->names[j-1],r->names[i-1]);
416 Print(
"\n// is skew constant:%d",r->GetNC()->IsSkewConstant);
421 PrintS(
"\n// quotient of sca by ideal");
441 PrintS(
"\n// quotient ring from ideal");
454 if (r ==
NULL)
return;
461 if( r->qideal !=
NULL )
476 if (r->order !=
NULL)
487 if (r->wvhdl[j]!=
NULL)
500 for (i=0; i<r->N; i++)
519 if (order==0)
Werror(
"wrong ring order `%s`",ordername);
529 for (nblocks=0; r->order[nblocks]; nblocks++);
544 if (r->wvhdl[l]!=
NULL)
548 j<(r->block1[
l]-r->block0[
l]+1)*(r->block1[l]-r->block0[l]+1);
555 for (i = 0; i<r->block1[
l]-r->block0[
l]; i++)
564 for (i = 0; i<r->block1[
l]-r->block0[
l]; i++)
574 if (
j+i+1==(r->block1[l]-r->block0[l]+1)*(r->block1[l]-r->block0[l]+1))
584 assume( r->block0[l] == r->block1[l] );
585 const int s = r->block0[
l];
586 assume( (-2 < s) && (s < 2) );
603 for (i=0; i<r->N; i++)
605 l+=strlen(r->names[i])+1;
609 for (i=0; i<r->N-1; i++)
611 strcat(s,r->names[i]);
614 strcat(s,r->names[i]);
626 char const *
const *
const params =
rParameter(r);
631 for (i=0; i<
rPar(r); i++)
633 l+=strlen(params[i])+1;
637 for (i=0; i<
rPar(r)-1; i++)
639 strcat(s, params[i]);
642 strcat(s, params[i]);
653 char *
res=(
char *)
omAlloc(strlen(ch)+strlen(var)+strlen(ord)+9);
654 sprintf(res,
"(%s),(%s),(%s)",ch,var,ord);
686 int rChar(ring r) {
return r->cf->ch; }
703 for(
int i=1;
i<r->N;
i++)
704 for(
int j=
i+1;
j<=r->N;
j++)
708 WarnS(
"Error initializing multiplication!");
728 memset(&tmpR,0,
sizeof(tmpR));
779 if (r1->cf->extRing->cf==r2->cf)
789 WerrorS (
"coeff sum of two extension fields not implemented");
795 WerrorS(
"coeff sum not yet implemented");
802 char **names=(
char **)
omAlloc0(l*
sizeof(
char *));
807 for (i=0;i<r1->N;i++)
811 if (*(r1->names[i]) ==
'\0')
817 for(j=0;j<
rPar(r2);j++)
819 if (strcmp(r1->names[i],
rParameter(r2)[j])==0)
843 if (*(r2->names[i]) ==
'\0')
849 for(j=0;j<
rPar(r1);j++)
851 if (strcmp(r2->names[i],
rParameter(r1)[j])==0)
866 if (strcmp(r1->names[j],r2->names[i])==0)
912 for(
int i=0;i<
rVar(r1);i++) tmpR.
wvhdl[0][i]=1;
935 if ((r2->block0[0]==1)
936 && (r2->block1[0]==
rVar(r2))
942 tmpR.
order[1]=r2->order[0];
943 if (r2->wvhdl[0]!=
NULL)
1009 if (rb->wvhdl[i]!=
NULL)
1010 WarnS(
"rSum: weights not implemented");
1016 for (i=0;r1->order[
i]!=0;i++)
1021 if (r1->wvhdl[i]!=
NULL)
1030 tmpR.
order[b-2]=r1->order[
i];
1032 for (i=0;r2->order[
i]!=0;i++)
1040 if (r2->wvhdl[i]!=
NULL)
1047 if((r1->OrdSgn==-1)||(r2->OrdSgn==-1))
1051 else if ((k==
rVar(r1)) && (k==
rVar(r2)))
1067 if (r1->wvhdl[i]!=
NULL)
1078 Werror(
"difficulties with variables: %d,%d -> %d",
rVar(r1),
rVar(r2),k);
1084 memcpy(sum,&tmpR,
sizeof(
ip_sring));
1101 if ( (R1_is_nc) || (R2_is_nc))
1125 int *perm1 = (
int *)
omAlloc0((
rVar(R1)+1)*
sizeof(int));
1126 int *par_perm1 =
NULL;
1129 int *perm2 = (
int *)
omAlloc0((
rVar(R2)+1)*
sizeof(int));
1130 int *par_perm2 =
NULL;
1135 perm1, par_perm1, sum->cf->type);
1139 perm2, par_perm2, sum->cf->type);
1142 matrix C1 = R1->GetNC()->C, C2 = R2->GetNC()->C;
1143 matrix D1 = R1->GetNC()->D, D2 = R2->GetNC()->D;
1152 for (i = 1; i <=
rVar(R1); i++)
1153 for (j=
rVar(R1)+1; j <=
l; j++)
1161 for (i=1; i<=
rVar(R1); i++)
1162 for (j=i+1; j<=
rVar(R1); j++)
1165 MATELEM(C,i,j) =
p_PermPoly(
MATELEM(C1,i,j), perm1, R1, sum, nMap1, par_perm1,
rPar(R1));
1168 MATELEM(D,i,j) =
p_PermPoly(
MATELEM(D1,i,j), perm1, R1, sum, nMap1, par_perm1,
rPar(R1));
1177 for (i=1; i<=
rVar(R2); i++)
1178 for (j=i+1; j<=
rVar(R2); j++)
1181 MATELEM(C,
rVar(R1)+i,
rVar(R1)+j) =
p_PermPoly(
MATELEM(C2,i,j),perm2,R2,sum, nMap2,par_perm2,
rPar(R2));
1184 MATELEM(D,
rVar(R1)+i,
rVar(R1)+j) =
p_PermPoly(
MATELEM(D2,i,j),perm2,R2,sum, nMap2,par_perm2,
rPar(R2));
1192 WarnS(
"Error initializing non-commutative multiplication!");
1201 Print(
"\nRefs: R1: %d, R2: %d\n", R1->GetNC()->ref, R2->GetNC()->ref);
1224 if (r1->qideal!=
NULL)
1235 int *perm1 = (
int *)
omAlloc0((
rVar(r1)+1)*
sizeof(int));
1236 int *par_perm1 =
NULL;
1240 perm1, par_perm1, sum->cf->type);
1244 for (
int for_i=0;for_i<
IDELEMS(r1->qideal);for_i++)
1246 r1->qideal->m[for_i], perm1,
1249 par_perm1,
rPar(r1));
1254 if (r2->qideal!=
NULL)
1258 int *perm2 = (
int *)
omAlloc0((
rVar(r2)+1)*
sizeof(int));
1259 int *par_perm2 =
NULL;
1263 perm2, par_perm2, sum->cf->type);
1267 for (
int for_i=0;for_i<
IDELEMS(r2->qideal);for_i++)
1269 r2->qideal->m[for_i], perm2,
1272 par_perm2,
rPar(r2));
1304 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 *));
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]);
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 *));
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(
rRingOrder_t));
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))
1975 for(
int j=0;j<=
i;j++)
1978 dError(
"wrong order in r->order");
1989 if (r->VarOffset ==
NULL)
1991 dReportError(
"Null ring VarOffset -- no rComplete (?) in n %s:%d", fn, l);
1996 if ((r->OrdSize==0)!=(r->typ==
NULL))
1998 dReportError(
"mismatch OrdSize and typ-pointer in %s:%d");
2004 for(i=0;i<=r->N;i++)
2008 for(j=0;j<r->OrdSize;j++)
2012 const int p = r->typ[
j].data.isTemp.suffixpos;
2017 assume( p < r->OrdSize );
2019 if(r->typ[p].ord_typ !=
ro_is)
2020 dReportError(
"ordrec prefix %d is unmatched (suffix: %d is wrong!!!)",j, p);
2023 if(r->typ[j].data.isTemp.pVarOffset[i] != -1)
2029 else if (r->typ[j].ord_typ ==
ro_is)
2032 if(r->typ[j].data.is.pVarOffset[i] != -1)
2040 if (r->typ[j].ord_typ==
ro_cp)
2042 if(((
short)r->VarOffset[i]) == r->typ[j].data.cp.place)
2047 && (r->VarOffset[i] == r->typ[j].data.dp.place))
2053 tmp=r->VarOffset[
i] & 0xffffff;
2054 #if SIZEOF_LONG == 8 2055 if ((r->VarOffset[i] >> 24) >63)
2057 if ((r->VarOffset[i] >> 24) >31)
2059 dReportError(
"bit_start out of range:%d",r->VarOffset[i] >> 24);
2060 if (i > 0 && ((tmp<0) ||(tmp>r->ExpL_Size-1)))
2062 dReportError(
"varoffset out of range for var %d: %d",i,tmp);
2067 for(j=0;j<r->OrdSize;j++)
2069 if ((r->typ[j].ord_typ==
ro_dp)
2070 || (r->typ[j].ord_typ==
ro_wp)
2073 if (r->typ[j].data.dp.start > r->typ[j].data.dp.end)
2075 r->typ[j].data.dp.start, r->typ[j].data.dp.end);
2076 if ((r->typ[j].data.dp.start < 1)
2077 || (r->typ[j].data.dp.end > r->N))
2078 dReportError(
"in ordrec %d: start(%d)<1 or end(%d)>vars(%d)",j,
2079 r->typ[j].data.dp.start, r->typ[j].data.dp.end,r->N);
2111 static void rO_TDegree(
int &place,
int &bitplace,
int start,
int end,
2117 ord_struct.
data.dp.start=start;
2118 ord_struct.
data.dp.end=end;
2119 ord_struct.
data.dp.place=place;
2131 ord_struct.
data.dp.start=start;
2132 ord_struct.
data.dp.end=end;
2133 ord_struct.
data.dp.place=place;
2139 static void rO_WDegree(
int &place,
int &bitplace,
int start,
int end,
2140 long *o,
sro_ord &ord_struct,
int *weights)
2143 while((start<end) && (weights[0]==0)) { start++; weights++; }
2144 while((start<end) && (weights[end-start]==0)) { end--; }
2147 for(i=start;i<=end;i++)
2149 if(weights[i-start]!=1)
2157 rO_TDegree(place,bitplace,start,end,o,ord_struct);
2162 ord_struct.
data.wp.start=start;
2163 ord_struct.
data.wp.end=end;
2164 ord_struct.
data.wp.place=place;
2165 ord_struct.
data.wp.weights=weights;
2169 for(i=start;i<=end;i++)
2171 if(weights[i-start]<0)
2179 static void rO_WMDegree(
int &place,
int &bitplace,
int start,
int end,
2180 long *o,
sro_ord &ord_struct,
int *weights)
2189 ord_struct.
data.am.start=start;
2190 ord_struct.
data.am.end=end;
2191 ord_struct.
data.am.place=place;
2192 ord_struct.
data.am.weights=weights;
2193 ord_struct.
data.am.weights_m = weights + (end-start+1);
2194 ord_struct.
data.am.len_gen=weights[end-start+1];
2195 assume( ord_struct.
data.am.weights_m[0] == ord_struct.
data.am.len_gen );
2208 ord_struct.
data.wp64.start=start;
2209 ord_struct.
data.wp64.end=end;
2210 ord_struct.
data.wp64.place=place;
2211 ord_struct.
data.wp64.weights64=weights;
2220 long *o,
sro_ord &ord_struct,
int *weights)
2223 while((start<end) && (weights[0]==0)) { start++; weights++; }
2224 while((start<end) && (weights[end-start]==0)) { end--; }
2227 ord_struct.
data.wp.start=start;
2228 ord_struct.
data.wp.end=end;
2229 ord_struct.
data.wp.place=place;
2230 ord_struct.
data.wp.weights=weights;
2235 for(i=start;i<=end;i++)
2237 if(weights[i-start]<0)
2245 static void rO_LexVars(
int &place,
int &bitplace,
int start,
int end,
2246 int &prev_ord,
long *o,
int *
v,
int bits,
int opt_var)
2251 if(prev_ord==-1)
rO_Align(place,bitplace);
2257 for(k=start;;k+=incr)
2262 v[
k]= place | (bitplace << 24);
2268 assume((opt_var == end+1) ||(opt_var == end-1));
2269 if((opt_var != end+1) &&(opt_var != end-1))
WarnS(
"hier-2");
2270 int save_bitplace=bitplace;
2274 bitplace=save_bitplace;
2278 v[opt_var]=place | (bitplace << 24);
2283 int &prev_ord,
long *o,
int *
v,
int bits,
int opt_var)
2288 if(prev_ord==1)
rO_Align(place,bitplace);
2294 for(k=start;;k+=incr)
2299 v[
k]=place | (bitplace << 24);
2306 assume((opt_var == end+1) ||(opt_var == end-1));
2307 if((opt_var != end+1) &&(opt_var != end-1))
WarnS(
"hier-1");
2308 int save_bitplace=bitplace;
2312 bitplace=save_bitplace;
2316 v[opt_var]=place | (bitplace << 24);
2327 ord_struct.
data.syzcomp.place=place;
2328 ord_struct.
data.syzcomp.Components=
NULL;
2329 ord_struct.
data.syzcomp.ShiftedComponents=
NULL;
2336 static void rO_Syz(
int &place,
int &bitplace,
int &prev_ord,
2344 ord_struct.
data.syz.place=place;
2345 ord_struct.
data.syz.limit=0;
2346 ord_struct.
data.syz.syz_index =
NULL;
2347 ord_struct.
data.syz.curr_index = 1;
2360 long *o,
int ,
int *
v,
sro_ord &ord_struct)
2367 ord_struct.
data.isTemp.start = place;
2368 ord_struct.
data.isTemp.pVarOffset = (
int *)
omMemDup(v);
2369 ord_struct.
data.isTemp.suffixpos = -1;
2377 static void rO_ISSuffix(
int &place,
int &bitplace,
int &prev_ord,
long *o,
2382 int typ_j = typ_i - 1;
2385 if( tmp_typ[typ_j].ord_typ ==
ro_isTemp)
2398 const int start = tmp_typ[typ_j].
data.isTemp.start;
2399 int *pVarOffset = tmp_typ[typ_j].
data.isTemp.pVarOffset;
2410 tmp_typ[typ_j].
data.isTemp.suffixpos = typ_i;
2417 for(
int i = 0;
i <=
N;
i++ )
2420 if( v[
i] != pVarOffset[
i] )
2422 pVarOffset[
i] = v[
i];
2424 assume( pVarOffset[i] != -1 );
2430 if( pVarOffset[0] != -1 )
2431 pVarOffset[0] &= 0x0fff;
2433 sro_ord &ord_struct = tmp_typ[typ_j];
2437 ord_struct.
data.is.start = start;
2438 ord_struct.
data.is.end = place;
2439 ord_struct.
data.is.pVarOffset = pVarOffset;
2461 v[0] = place | (bitplace << 24);
2472 bits=16; bitmask=0xffff;
2474 else if (bitmask <= 1L)
2476 bits=1; bitmask = 1L;
2478 else if (bitmask <= 3L)
2480 bits=2; bitmask = 3L;
2482 else if (bitmask <= 7L)
2486 else if (bitmask <= 0xfL)
2488 bits=4; bitmask=0xfL;
2490 else if (bitmask <= 0x1fL)
2492 bits=5; bitmask=0x1fL;
2494 else if (bitmask <= 0x3fL)
2496 bits=6; bitmask=0x3fL;
2498 #if SIZEOF_LONG == 8 2499 else if (bitmask <= 0x7fL)
2501 bits=7; bitmask=0x7fL;
2504 else if (bitmask <= 0xffL)
2506 bits=8; bitmask=0xffL;
2508 #if SIZEOF_LONG == 8 2509 else if (bitmask <= 0x1ffL)
2511 bits=9; bitmask=0x1ffL;
2514 else if (bitmask <= 0x3ffL)
2516 bits=10; bitmask=0x3ffL;
2518 #if SIZEOF_LONG == 8 2519 else if (bitmask <= 0xfffL)
2521 bits=12; bitmask=0xfff;
2524 else if (bitmask <= 0xffffL)
2526 bits=16; bitmask=0xffffL;
2528 #if SIZEOF_LONG == 8 2529 else if (bitmask <= 0xfffffL)
2531 bits=20; bitmask=0xfffffL;
2533 else if (bitmask <= 0xffffffffL)
2535 bits=32; bitmask=0xffffffffL;
2537 else if (bitmask <= 0x7fffffffffffffffL)
2539 bits=63; bitmask=0x7fffffffffffffffL;
2543 bits=63; bitmask=0x7fffffffffffffffL;
2546 else if (bitmask <= 0x7fffffff)
2548 bits=31; bitmask=0x7fffffff;
2552 bits=31; bitmask=0x7fffffffL;
2563 #if SIZEOF_LONG == 8 2578 unsigned long bitmask1 =
rGetExpSize(bitmask+1, bits1);
2580 if ((((N+vars_per_long-1)/vars_per_long) ==
2581 ((N+vars_per_long1-1)/vars_per_long1)))
2583 vars_per_long=vars_per_long1;
2603 unsigned long exp_limit)
2610 int iNeedInducedOrderingSetup = 0;
2614 need_other_ring = (exp_limit != r->bitmask);
2618 int *block0=(
int*)
omAlloc0((nblocks+1)*
sizeof(int));
2619 int *block1=(
int*)
omAlloc0((nblocks+1)*
sizeof(int));
2620 int **wvhdl=(
int**)
omAlloc0((nblocks+1)*
sizeof(
int *));
2629 if (r->block0[i]==r->block1[i])
2654 Warn(
"Error: unhandled ordering in rModifyRing: ringorder_S = [%d]", r_ord);
2668 need_other_ring=
TRUE;
2669 try_omit_comp=
FALSE;
2670 copy_block_index=
FALSE;
2684 need_other_ring=
TRUE;
2686 omitted_degree =
TRUE;
2700 need_other_ring=
TRUE;
2702 omitted_degree =
TRUE;
2710 try_omit_comp =
FALSE;
2713 iNeedInducedOrderingSetup++;
2718 assume((i == 0) && (j == 0));
2722 try_omit_comp =
FALSE;
2731 if (copy_block_index)
2733 block0[
j]=r->block0[
i];
2734 block1[
j]=r->block1[
i];
2735 wvhdl[
j]=r->wvhdl[
i];
2740 if(!need_other_ring)
2752 res->GetNC() =
NULL;
2760 res->bitmask=exp_limit;
2767 if (r->pFDegOrig != res->pFDegOrig &&
2772 res->firstwv = r->firstwv;
2773 res->firstBlockEnds = r->firstBlockEnds;
2777 res->pLDeg = r->pLDegOrig;
2782 if (res->typ !=
NULL)
2784 if( res->typ[0].ord_typ ==
ro_syz)
2786 res->typ[0] = r->typ[0];
2788 if (r->typ[0].data.syz.limit > 0)
2790 res->typ[0].data.syz.syz_index
2791 = (
int*)
omAlloc((r->typ[0].data.syz.limit +1)*
sizeof(int));
2792 memcpy(res->typ[0].data.syz.syz_index, r->typ[0].data.syz.syz_index,
2793 (r->typ[0].data.syz.limit +1)*
sizeof(
int));
2797 if( iNeedInducedOrderingSetup > 0 )
2799 for(j = 0, i = 0; (i < nblocks) && (iNeedInducedOrderingSetup > 0); i++)
2800 if( res->typ[i].ord_typ ==
ro_is )
2802 ideal F =
idrHeadR(r->typ[i].data.is.F, r, res);
2806 r->typ[i].data.is.limit,
2811 iNeedInducedOrderingSetup--;
2817 res->OrdSgn=r->OrdSgn;
2826 WarnS(
"error in nc_rComplete");
2839 WarnS(
"error in sca_Force!");
2853 res->GetNC() =
NULL;
2857 res->wvhdl = (
int **)
omAlloc0(3 *
sizeof(
int *));
2860 res->block0 = (
int *)
omAlloc0(3 *
sizeof(
int *));
2861 res->block1 = (
int *)
omAlloc0(3 *
sizeof(
int *));
2865 res->block1[0] = r->N;
2866 res->wvhdl[0] = weights;
2881 WarnS(
"error in nc_rComplete");
2908 int nblocks=1+(ommit_comp!=0);
2910 int *block0=(
int*)
omAlloc0((nblocks+1)*
sizeof(int));
2911 int *block1=(
int*)
omAlloc0((nblocks+1)*
sizeof(int));
2912 int **wvhdl=(
int**)
omAlloc0((nblocks+1)*
sizeof(
int *));
2924 res->GetNC() =
NULL;
2931 res->bitmask=exp_limit;
2942 WarnS(
"error in nc_rComplete");
2958 return rModifyRing(r, ommit_degree, ommit_comp, exp_limit);
2991 r->CanShortOut =
TRUE;
2996 for (i=0;i<
rPar(r);i++)
3000 r->CanShortOut=
FALSE;
3011 if (r->N < N) N = r->N;
3013 for (i=(N-1);i>=0;i--)
3015 if(r->names[i] !=
NULL && strlen(r->names[i])>1)
3017 r->CanShortOut=
FALSE;
3023 r->ShortOut = r->CanShortOut;
3025 assume( !( !r->CanShortOut && r->ShortOut ) );
3033 if(block1[i]!=r->N) r->LexOrder=
TRUE;
3034 r->firstBlockEnds=block1[
i];
3035 r->firstwv = wvhdl[
i];
3044 for(j=block1[i]-r->block0[i];j>=0;j--)
3046 if (r->firstwv[j]<0) r->MixedOrder=
TRUE;
3047 if (r->firstwv[j]==0) r->LexOrder=
TRUE;
3054 for(j=block1[i]-r->block0[i];j>=0;j--)
3056 if (w[j]==0) r->LexOrder=
TRUE;
3063 if (r->pFDeg ==
p_Deg)
3084 r->pLDegOrig = r->pLDeg;
3091 int* block0 = r->block0;
3092 int* block1 = r->block1;
3093 int** wvhdl = r->wvhdl;
3102 r->LexOrder =
FALSE;
3109 r->MixedOrder =
FALSE;
3110 for(
int ii=block0[0];ii<=block1[0];ii++)
3111 if (wvhdl[0][ii-1]<0) { r->MixedOrder=2;
break;}
3113 for(
int ii=block0[0];ii<=block1[0];ii++)
3114 if (wvhdl[0][ii-1]==0) { r->LexOrder=
TRUE;
break;}
3115 if ((block0[0]==1)&&(block1[0]==r->N))
3126 r->firstwv = wvhdl[0];
3138 if (r->OrdSgn == -1) r->pLDeg =
pLDeg0c;
3157 for(
int ii=block0[0];ii<=block1[0];ii++)
3159 if (wvhdl[0][ii-1]<0) { r->MixedOrder=2;
break;}
3161 if (r->MixedOrder==0)
3166 r->firstBlockEnds=block1[0];
3167 r->firstwv = wvhdl[0];
3186 r->firstBlockEnds=block1[1];
3187 if (wvhdl!=
NULL) r->firstwv = wvhdl[1];
3195 for(
int ii=block0[1];ii<=block1[1];ii++)
3196 if (wvhdl[1][ii-1]<0) { r->MixedOrder=2;
break;}
3197 if (r->MixedOrder==
FALSE)
3229 if(r->MixedOrder==
FALSE)
3244 r->pFDegOrig = r->pFDeg;
3259 for(i=0;i<r->OrdSize;i++)
3262 ||(r->typ[i].ord_typ==
ro_am))
3267 r->NegWeightL_Size=
l;
3268 r->NegWeightL_Offset=(
int *)
omAlloc(l*
sizeof(
int));
3270 for(i=0;i<r->OrdSize;i++)
3274 r->NegWeightL_Offset[
l]=r->typ[
i].data.wp.place;
3277 else if(r->typ[i].ord_typ==
ro_am)
3279 r->NegWeightL_Offset[
l]=r->typ[
i].data.am.place;
3286 r->NegWeightL_Size = 0;
3287 r->NegWeightL_Offset =
NULL;
3299 if ( (r->cf->extRing!=
NULL)
3308 if (r->LexOrder || r->OrdSgn == -1 || (r->cf->extRing!=
NULL))
3325 r->pLexOrder=r->LexOrder;
3333 static inline int sign(
int x) {
return (x > 0) - (x < 0);}
3341 for(i=2;i<=
rVar(r);i++)
3358 if (r->VarOffset!=
NULL && force == 0)
return FALSE;
3364 r->BitsPerExp = bits;
3369 long *tmp_ordsgn=(
long *)
omAlloc0(3*(n+r->N)*
sizeof(long));
3371 int *
v=(
int *)
omAlloc((r->N+1)*
sizeof(int));
3372 for(i=r->N; i>=0 ; i--)
3389 switch (r->order[i])
3393 rO_WDegree(j,j_bits,r->block0[i],r->block1[i],tmp_ordsgn,tmp_typ[typ_i],
3399 rO_WMDegree(j,j_bits,r->block0[i],r->block1[i],tmp_ordsgn,tmp_typ[typ_i],
3405 rO_WDegree64(j,j_bits,r->block0[i],r->block1[i],tmp_ordsgn,
3406 tmp_typ[typ_i], (
int64 *)(r->wvhdl[i]));
3413 r->ComponentOrder=1;
3419 r->ComponentOrder=-1;
3425 k=r->block1[
i]-r->block0[
i]+1;
3428 rO_WDegree(j,j_bits,r->block0[i],r->block1[i],tmp_ordsgn,
3430 r->wvhdl[i]+(r->block1[i]-r->block0[i]+1)*l);
3437 rO_LexVars(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->block0[i],r->block1[i], prev_ordsgn,
3443 tmp_ordsgn,v, bits, -1);
3447 rO_LexVars_neg(j, j_bits, r->block1[i],r->block0[i], prev_ordsgn,
3448 tmp_ordsgn,v, bits, -1);
3452 rO_LexVars(j, j_bits, r->block1[i],r->block0[i], prev_ordsgn,
3453 tmp_ordsgn,v, bits, -1);
3457 if (r->block0[i]==r->block1[i])
3459 rO_LexVars(j, j_bits, r->block0[i],r->block0[i], prev_ordsgn,
3460 tmp_ordsgn,v, bits, -1);
3464 rO_TDegree(j,j_bits,r->block0[i],r->block1[i],tmp_ordsgn,
3468 prev_ordsgn,tmp_ordsgn,v,bits, r->block0[i]);
3473 if (r->block0[i]==r->block1[i])
3475 rO_LexVars(j, j_bits, r->block0[i],r->block0[i], prev_ordsgn,
3476 tmp_ordsgn,v, bits, -1);
3480 rO_TDegree(j,j_bits,r->block0[i],r->block1[i],tmp_ordsgn,
3483 rO_LexVars(j, j_bits, r->block0[i],r->block1[i]-1, prev_ordsgn,
3484 tmp_ordsgn,v, bits, r->block1[i]);
3489 if (r->block0[i]==r->block1[i])
3492 tmp_ordsgn,v,bits, -1);
3500 prev_ordsgn,tmp_ordsgn,v,bits, r->block0[i]);
3505 if (r->block0[i]==r->block1[i])
3508 tmp_ordsgn,v, bits, -1);
3515 rO_LexVars(j, j_bits, r->block0[i],r->block1[i]-1, prev_ordsgn,
3516 tmp_ordsgn,v, bits, r->block1[i]);
3521 rO_WDegree(j,j_bits,r->block0[i],r->block1[i],tmp_ordsgn,
3522 tmp_typ[typ_i], r->wvhdl[i]);
3527 for(jj=r->block1[i]-r->block0[i];jj>=0; jj--)
3529 if (r->wvhdl[i][jj]<=0) have_bad_weights=
TRUE;
3531 if (have_bad_weights)
3533 rO_TDegree(j,j_bits,r->block0[i],r->block1[i],tmp_ordsgn,
3538 if (r->block1[i]!=r->block0[i])
3540 rO_LexVars_neg(j, j_bits,r->block1[i],r->block0[i]+1, prev_ordsgn,
3541 tmp_ordsgn, v,bits, r->block0[i]);
3546 rO_WDegree(j,j_bits,r->block0[i],r->block1[i],tmp_ordsgn,
3547 tmp_typ[typ_i], r->wvhdl[i]);
3552 for(jj=r->block1[i]-r->block0[i];jj>=0; jj--)
3554 if (r->wvhdl[i][jj]<=0) have_bad_weights=
TRUE;
3556 if (have_bad_weights)
3558 rO_TDegree(j,j_bits,r->block0[i],r->block1[i],tmp_ordsgn,
3563 if (r->block1[i]!=r->block0[i])
3565 rO_LexVars(j, j_bits,r->block0[i],r->block1[i]-1, prev_ordsgn,
3566 tmp_ordsgn,v, bits, r->block1[i]);
3572 tmp_typ[typ_i], r->wvhdl[i]);
3574 if (r->block1[i]!=r->block0[i])
3576 rO_LexVars_neg(j, j_bits,r->block1[i],r->block0[i]+1, prev_ordsgn,
3577 tmp_ordsgn, v,bits, r->block0[i]);
3583 tmp_typ[typ_i], r->wvhdl[i]);
3585 if (r->block1[i]!=r->block0[i])
3587 rO_LexVars(j, j_bits,r->block0[i],r->block1[i]-1, prev_ordsgn,
3588 tmp_ordsgn,v, bits, r->block1[i]);
3595 rO_Syzcomp(j, j_bits,prev_ordsgn, tmp_ordsgn,tmp_typ[typ_i]);
3596 need_to_add_comp=
TRUE;
3597 r->ComponentOrder=-1;
3602 assume(typ_i == 0 && j == 0);
3603 rO_Syz(j, j_bits, prev_ordsgn, tmp_ordsgn, tmp_typ[typ_i]);
3604 need_to_add_comp=
TRUE;
3605 r->ComponentOrder=-1;
3612 assume( r->block0[i] == r->block1[i] );
3613 const int s = r->block0[
i];
3614 assume( -2 < s && s < 2);
3617 rO_ISPrefix(j, j_bits, prev_ordsgn, tmp_ordsgn, r->N, v, tmp_typ[typ_i++]);
3620 rO_ISSuffix(j, j_bits, prev_ordsgn, tmp_ordsgn, r->N, v, tmp_typ, typ_i, s);
3621 need_to_add_comp=
FALSE;
3640 j_bits=j_bits0; j=j0;
3645 if((need_to_add_comp) && (v[0]== -1))
3659 for(i=1 ; i<=r->N ; i++)
3665 rO_LexVars(j, j_bits, i,i, prev_ordsgn,tmp_ordsgn,v,bits, -1);
3686 r->ordsgn=(
long *)
omAlloc0(r->ExpL_Size*
sizeof(
long));
3688 for(j=0;j<r->CmpL_Size;j++)
3690 r->ordsgn[
j] = tmp_ordsgn[
j];
3699 if (typ_i==0) r->typ=
NULL;
3703 memcpy(r->typ,tmp_typ,typ_i*
sizeof(
sro_ord));
3713 r->pCompIndex=(r->VarOffset[0] & 0xffff);
3716 if (i==r->pCompIndex) i++;
3717 while ((j < r->OrdSize)
3725 if (i==r->pCompIndex) i++;
3763 for(
int i=1;i<=r->N;i++)
3767 for(
int j=0;(
j<=
b) && (found==0);
j++)
3770 if ((r->block0[
j]<=i)&&(r->block1[
j]>=
i))
3790 if(r->wvhdl[
j][i-r->block0[
j]]<0)
3796 else if(r->wvhdl[
j][i-r->block0[
j]]>0)
3807 if(r->wvhdl[
j][i-r->block0[
j]]<0)
3813 else if(r->wvhdl[
j][i-r->block0[
j]]>0)
3842 if (nonneg>0) r->MixedOrder=1;
3853 if (r ==
NULL)
return;
3854 if (r->VarOffset !=
NULL)
3856 if (r->OrdSize!=0 && r->typ !=
NULL)
3858 for(
int i = 0; i < r->OrdSize; i++)
3859 if( r->typ[i].ord_typ ==
ro_is)
3862 r->typ[
i].data.is.F =
NULL;
3864 if( r->typ[i].data.is.pVarOffset !=
NULL )
3867 r->typ[
i].data.is.pVarOffset =
NULL;
3870 else if (r->typ[i].ord_typ ==
ro_syz)
3872 if(r->typ[i].data.syz.limit > 0)
3873 omFreeSize(r->typ[i].data.syz.syz_index, ((r->typ[i].data.syz.limit) +1)*
sizeof(
int));
3874 r->typ[
i].data.syz.syz_index =
NULL;
3878 assume( r->typ[i].data.syzcomp.ShiftedComponents ==
NULL );
3879 assume( r->typ[i].data.syzcomp.Components ==
NULL );
3889 if (r->PolyBin !=
NULL)
3894 if (r->ordsgn !=
NULL && r->CmpL_Size != 0)
3896 if (r->p_Procs !=
NULL)
3898 omfreeSize(r->VarL_Offset, r->VarL_Size*
sizeof(
int));
3900 if (r->NegWeightL_Offset!=
NULL)
3902 omFreeSize(r->NegWeightL_Offset, r->NegWeightL_Size*
sizeof(
int));
3903 r->NegWeightL_Offset=
NULL;
3911 int* VarL_Number = (
int*)
omAlloc0(r->ExpL_Size*
sizeof(
int));
3916 for (i=1; i<=r->N; i++)
3918 VarL_Number[r->VarOffset[
i] & 0xffffff]++;
3922 for (i=0, j=0; i<r->ExpL_Size; i++)
3924 if (VarL_Number[i] != 0)
3926 if (min > VarL_Number[i])
3928 min = VarL_Number[
i];
3937 r->VarL_Offset = (
int*)
omAlloc(r->VarL_Size*
sizeof(
int));
3938 r->VarL_LowIndex = 0;
3941 for (i=0, j=0; i<r->ExpL_Size; i++)
3943 if (VarL_Number[i] != 0)
3945 r->VarL_Offset[
j] =
i;
3946 if (j > 0 && r->VarL_Offset[j-1] != r->VarL_Offset[j] - 1)
3947 r->VarL_LowIndex = -1;
3951 if (r->VarL_LowIndex >= 0)
3952 r->VarL_LowIndex = r->VarL_Offset[0];
3956 j = r->VarL_Offset[min_j];
3957 r->VarL_Offset[min_j] = r->VarL_Offset[0];
3958 r->VarL_Offset[0] =
j;
3965 int* shifts = (
int*)
omAlloc(r->ExpL_Size*
sizeof(
int));
3968 for (i=0;i<r->ExpL_Size;i++)
3972 for (i=1;i<=r->N;i++)
3974 if (shifts[r->VarOffset[i] & 0xffffff] > r->VarOffset[i] >> 24)
3975 shifts[r->VarOffset[
i] & 0xffffff] = r->VarOffset[
i] >> 24;
3978 for (i=1;i<=r->N;i++)
3980 if (shifts[r->VarOffset[i] & 0xffffff] != 0)
3982 = (r->VarOffset[
i] & 0xffffff) |
3983 (((r->VarOffset[i] >> 24) - shifts[r->VarOffset[
i] & 0xffffff]) << 24);
3991 unsigned long divmask = 1;
3996 divmask |= (((
unsigned long) 1) << (
unsigned long) i);
4011 const char *TYP[]={
"ro_dp",
"ro_wp",
"ro_am",
"ro_wp64",
"ro_wp_neg",
"ro_cp",
4012 "ro_syzcomp",
"ro_syz",
"ro_isTemp",
"ro_is",
"ro_none"};
4015 Print(
"ExpL_Size:%d ",r->ExpL_Size);
4016 Print(
"CmpL_Size:%d ",r->CmpL_Size);
4017 Print(
"VarL_Size:%d\n",r->VarL_Size);
4018 Print(
"bitmask=0x%lx (expbound=%ld) \n",r->bitmask, r->bitmask);
4019 Print(
"divmask=%lx\n", r->divmask);
4020 Print(
"BitsPerExp=%d ExpPerLong=%d at L[%d]\n", r->BitsPerExp, r->ExpPerLong, r->VarL_Offset[0]);
4022 Print(
"VarL_LowIndex: %d\n", r->VarL_LowIndex);
4023 PrintS(
"VarL_Offset:\n");
4026 for(j = 0; j < r->VarL_Size; j++)
4027 Print(
" VarL_Offset[%d]: %d ", j, r->VarL_Offset[j]);
4034 for(j=0;j<=r->N;j++)
4035 Print(
" v%d at e-pos %d, bit %d\n",
4036 j,r->VarOffset[j] & 0xffffff, r->VarOffset[j] >>24);
4038 for(j=0;j<r->CmpL_Size;j++)
4039 Print(
" ordsgn %ld at pos %d\n",r->ordsgn[j],j);
4040 Print(
"OrdSgn:%d\n",r->OrdSgn);
4042 for(j=0;j<r->OrdSize;j++)
4044 Print(
" typ %s", TYP[r->typ[j].ord_typ]);
4045 if (r->typ[j].ord_typ==
ro_syz)
4047 const short place = r->typ[
j].data.syz.place;
4048 const int limit = r->typ[
j].data.syz.limit;
4049 const int curr_index = r->typ[
j].data.syz.curr_index;
4050 const int* syz_index = r->typ[
j].data.syz.syz_index;
4052 Print(
" limit %d (place: %d, curr_index: %d), syz_index: ", limit, place, curr_index);
4054 if( syz_index ==
NULL )
4059 for( i=0; i <= limit; i++ )
4060 Print(
"%d ", syz_index[i]);
4067 Print(
" start (level) %d, suffixpos: %d, VO: ",r->typ[j].data.isTemp.start, r->typ[j].data.isTemp.suffixpos);
4070 else if (r->typ[j].ord_typ==
ro_is)
4072 Print(
" start %d, end: %d: ",r->typ[j].data.is.start, r->typ[j].data.is.end);
4076 Print(
" limit %d",r->typ[j].data.is.limit);
4083 else if (r->typ[j].ord_typ==
ro_am)
4085 Print(
" place %d",r->typ[j].data.am.place);
4086 Print(
" start %d",r->typ[j].data.am.start);
4087 Print(
" end %d",r->typ[j].data.am.end);
4088 Print(
" len_gen %d",r->typ[j].data.am.len_gen);
4091 for(l=r->typ[j].data.am.start;l<=r->typ[j].data.am.end;l++)
4092 Print(
" %d",r->typ[j].data.am.weights[l-r->typ[j].data.am.start]);
4093 l=r->typ[
j].data.am.end+1;
4094 int ll=r->typ[
j].data.am.weights[l-r->typ[
j].data.am.start];
4096 for(
int lll=l+1;lll<l+ll+1;lll++)
4097 Print(
" %d",r->typ[j].data.am.weights[lll-r->typ[j].data.am.start]);
4101 Print(
" place %d",r->typ[j].data.dp.place);
4105 Print(
" start %d",r->typ[j].data.dp.start);
4106 Print(
" end %d",r->typ[j].data.dp.end);
4107 if ((r->typ[j].ord_typ==
ro_wp)
4111 for(
int l=r->typ[j].data.wp.start;l<=r->typ[j].data.wp.end;
l++)
4112 Print(
" %d",r->typ[j].data.wp.weights[
l-r->typ[j].data.wp.start]);
4114 else if (r->typ[j].ord_typ==
ro_wp64)
4118 for(l=r->typ[j].data.wp64.start;l<=r->typ[j].data.wp64.end;l++)
4119 Print(
" %ld",(
long)(((
int64*)r->typ[j].data.wp64.weights64)+l-r->typ[j].data.wp64.start));
4125 Print(
"pOrdIndex:%d pCompIndex:%d\n", r->pOrdIndex, r->pCompIndex);
4126 Print(
"OrdSize:%d\n",r->OrdSize);
4127 PrintS(
"--------------------\n");
4128 for(j=0;j<r->ExpL_Size;j++)
4131 if (j< r->CmpL_Size)
4132 Print(
"ordsgn %ld ", r->ordsgn[j]);
4138 if( (r->VarOffset[i] & 0xffffff) == j )
4139 {
Print(
"v%d at e[%d], bit %d; ", i,r->VarOffset[i] & 0xffffff,
4140 r->VarOffset[i] >>24 ); }
4142 if( r->pCompIndex==j )
PrintS(
"v0; ");
4143 for(i=0;i<r->OrdSize;i++)
4145 if (r->typ[i].data.dp.place == j)
4147 Print(
"ordrec:%s (start:%d, end:%d) ",TYP[r->typ[i].ord_typ],
4148 r->typ[i].data.dp.start, r->typ[i].data.dp.end);
4152 if (j==r->pOrdIndex)
4157 Print(
"LexOrder:%d, MixedOrder:%d\n",r->LexOrder, r->MixedOrder);
4159 Print(
"NegWeightL_Size: %d, NegWeightL_Offset: ", r->NegWeightL_Size);
4160 if (r->NegWeightL_Offset==
NULL)
PrintS(
" NULL");
4162 for(j = 0; j < r->NegWeightL_Size; j++)
4163 Print(
" [%d]: %d ", j, r->NegWeightL_Offset[j]);
4174 Print(
"p_Spec : %s, %s, %s\n", field, length, ord);
4176 for (i=0; i<(int) (
sizeof(
p_Procs_s)/
sizeof(
void*)); i++)
4178 Print(
" %s,\n", ((
char**) &proc_names)[i]);
4184 #define pFDeg_CASE(A) if(r->pFDeg == A) PrintS( "" #A "" ) 4190 Print(
"(%p)", r->pFDeg);
4193 Print(
"pLDeg : (%p)", r->pLDeg);
4201 if (r->p_Setm==p_Setm_General)
PrintS(
"p_Setm_General\n");
4202 else if (r->p_Setm==p_Setm_Dummy)
PrintS(
"p_Setm_Dummy\n");
4203 else if (r->p_Setm==p_Setm_TotalDegree)
PrintS(
"p_Setm_Totaldegree\n");
4204 else if (r->p_Setm==p_Setm_WFirstTotalDegree)
PrintS(
"p_Setm_WFirstTotalDegree\n");
4205 else Print(
"%p\n",r->p_Setm);
4215 Print(
"\nexp[0..%d]\n",r->ExpL_Size-1);
4216 for(i=0;i<r->ExpL_Size;i++)
4217 Print(
"%ld ",p->exp[i]);
4224 if (j==0) {
PrintS(
"...\n");
break; }
4233 Print(
"\nexp[0..%d]\n", R->ExpL_Size - 1);
4234 for(
int i = 0; i < R->ExpL_Size; i++)
4235 Print(
"%09lx ", p->exp[i]);
4238 for(
int i = 1; i <= R->N; i++)
Print(
" v%d:%5ld",i,
p_GetExp(p, i, R));
4253 for(
int j = (F->ncols*F->nrows) - 1;
j >= 0;
j-- )
4267 Print(
"gen[%d] -> gen(%d)\n", c, MIN + (*V)[ c - MIN - 1 ]);
4270 p_SetComp(
p, MIN + (*V)[ c - MIN - 1 ], r );
4291 r->typ[1].data.syzcomp.Components = currComponents;
4298 *currShiftedComponents = r->typ[1].data.syzcomp.ShiftedComponents;
4299 *currComponents = r->typ[1].data.syzcomp.Components;
4309 r->typ[1].data.syzcomp.length = length;
4319 *length = r->typ[1].data.syzcomp.length;
4320 rNGetSComps( currComponents, currShiftedComponents, r);
4336 rDBGetSComps(currComponents, currShiftedComponents, length, r);
4338 rNGetSComps(currComponents, currShiftedComponents, r);
4361 WarnS(
"rAssure_SyzComp: input ring has an IS-ordering!");
4370 res->block0=(
int *)
omAlloc0((i+1)*
sizeof(int));
4371 res->block1=(
int *)
omAlloc0((i+1)*
sizeof(int));
4372 int ** wvhdl =(
int **)
omAlloc0((i+1)*
sizeof(
int**));
4375 res->order[
j]=r->order[j-1];
4376 res->block0[
j]=r->block0[j-1];
4377 res->block1[
j]=r->block1[j-1];
4378 if (r->wvhdl[j-1] !=
NULL)
4380 wvhdl[
j] = (
int*)
omMemDup(r->wvhdl[j-1]);
4397 WarnS(
"error in nc_rComplete");
4408 if (r->qideal!=
NULL)
4440 for(i=r->OrdSize-1;i>=0;i--)
4442 if ((r->typ[i].ord_typ==
ro_dp)
4443 && (r->typ[i].data.dp.start==start_var)
4444 && (r->typ[i].data.dp.end==end_var))
4446 pos=r->typ[
i].data.dp.place;
4462 res->ExpL_Size=r->ExpL_Size+1;
4465 res->ordsgn=(
long *)
omAlloc0(res->ExpL_Size*
sizeof(
long));
4466 for(j=0;j<r->CmpL_Size;j++)
4468 res->ordsgn[
j] = r->ordsgn[
j];
4470 res->OrdSize=r->OrdSize+1;
4475 memcpy(res->typ,r->typ,r->OrdSize*
sizeof(
sro_ord));
4478 res->typ[res->OrdSize-1].ord_typ=
ro_dp;
4479 res->typ[res->OrdSize-1].data.dp.start=start_var;
4480 res->typ[res->OrdSize-1].data.dp.end=end_var;
4481 res->typ[res->OrdSize-1].data.dp.place=res->ExpL_Size-1;
4482 pos=res->ExpL_Size-1;
4499 WarnS(
"error in nc_rComplete");
4505 if (r->qideal!=
NULL)
4535 if (r->order[i] == 0)
4544 new_r->wvhdl=(
int **)
omAlloc0(i *
sizeof(
int *));
4546 new_r->block0 = (
int *)
omAlloc0(i *
sizeof(
int));
4547 new_r->block1 = (
int *)
omAlloc0(i *
sizeof(
int));
4548 memcpy(new_r->order,r->order,(i-1) *
sizeof(
rRingOrder_t));
4549 memcpy(new_r->block0,r->block0,(i-1) *
sizeof(
int));
4550 memcpy(new_r->block1,r->block1,(i-1) *
sizeof(
int));
4551 for (
int j=0;
j<=last_block;
j++)
4553 if (r->wvhdl[
j]!=
NULL)
4555 new_r->wvhdl[
j] = (
int*)
omMemDup(r->wvhdl[
j]);
4572 WarnS(
"error in nc_rComplete");
4584 int last_block =
rBlocks(r) - 2;
4591 for (i=0; i< last_block; i++)
4602 for (i=c_pos+1; i<=last_block; i++)
4604 new_r->order[i-1] = new_r->order[
i];
4605 new_r->block0[i-1] = new_r->block0[
i];
4606 new_r->block1[i-1] = new_r->block1[
i];
4607 new_r->wvhdl[i-1] = new_r->wvhdl[
i];
4609 new_r->order[last_block] = r->order[c_pos];
4610 new_r->block0[last_block] = r->block0[c_pos];
4611 new_r->block1[last_block] = r->block1[c_pos];
4612 new_r->wvhdl[last_block] = r->wvhdl[c_pos];
4623 WarnS(
"error in nc_rComplete");
4648 if (new_r_1 != new_r && new_r_1 != old_r)
rDelete(new_r_1);
4656 # ifndef SING_NDEBUG 4657 WarnS(
"error in nc_rComplete");
4664 if (old_r->qideal !=
NULL)
4666 new_r->qideal =
idrCopyR(old_r->qideal, old_r, new_r);
4674 WarnS(
"error in nc_SetupQuotient");
4699 if ((r_blocks == 3) &&
4700 (r->order[0] == b1) &&
4701 (r->order[1] == b2) &&
4706 res->block0 = (
int*)
omAlloc0(3*
sizeof(
int));
4707 res->block1 = (
int*)
omAlloc0(3*
sizeof(
int));
4708 res->wvhdl = (
int**)
omAlloc0(3*
sizeof(
int*));
4714 res->block1[1] = r->N;
4719 res->block1[0] = r->N;
4728 WarnS(
"error in nc_rComplete");
4741 Print(
"rAssure_InducedSchreyerOrdering(r, complete = %d, sgn = %d): r: \n", complete, sgn);
4748 assume((sgn == 1) || (sgn == -1));
4756 res->block0=(
int *)
omAlloc0((n+2)*
sizeof(int));
4757 res->block1=(
int *)
omAlloc0((n+2)*
sizeof(int));
4758 int ** wvhdl =(
int **)
omAlloc0((n+2)*
sizeof(
int**));
4766 res->block0[
j] = res->block1[
j] = 0;
4770 for(
int i = 0; (i <= n) && (r->order[i] != 0); i++, j++)
4772 res->order [
j] = r->order [
i];
4773 res->block0[
j] = r->block0[
i];
4774 res->block1[
j] = r->block1[
i];
4776 if (r->wvhdl[i] !=
NULL)
4778 wvhdl[
j] = (
int*)
omMemDup(r->wvhdl[i]);
4784 res->block0[
j] = res->block1[
j] =
sgn;
4795 assume(res->order[j]==0);
4808 WarnS(
"error in nc_rComplete");
4820 if (r->qideal!=
NULL)
4877 Print(
"rIsIS(p: %d)\nF:", p);
4888 for(
int pos = 0; pos < r->OrdSize; pos++ )
4889 if( r->typ[pos].ord_typ ==
ro_is)
4911 dReportError(
"Error: WRONG USE of rSetISReference: wrong ring! (typ == NULL)");
4920 dReportError(
"Error: WRONG USE of rSetISReference: specified ordering block was not found!!!" );
4925 if( i != r->typ[pos].data.is.limit )
4926 Print(
"Changing record on pos: %d\nOld limit: %d --->> New Limit: %d\n", pos, r->typ[pos].data.is.limit, i);
4929 const ideal FF =
idrHeadR(F, r, r);
4932 if( r->typ[pos].data.is.F !=
NULL)
4935 PrintS(
"Deleting old reference set F... \n");
4938 r->typ[pos].data.is.F =
NULL;
4943 r->typ[pos].data.is.F = FF;
4945 r->typ[pos].data.is.limit =
i;
4969 if ((r->typ!=
NULL) && (r->typ[0].ord_typ==
ro_syz))
4971 if( k == r->typ[0].data.syz.limit )
4975 if (r->typ[0].data.syz.limit == 0)
4977 r->typ[0].data.syz.syz_index = (
int*)
omAlloc0((k+1)*
sizeof(int));
4978 r->typ[0].data.syz.syz_index[0] = 0;
4979 r->typ[0].data.syz.curr_index = 1;
4983 r->typ[0].data.syz.syz_index = (
int*)
4985 (r->typ[0].data.syz.limit+1)*
sizeof(int),
4988 for (i=r->typ[0].data.syz.limit + 1; i<= k; i++)
4990 r->typ[0].data.syz.syz_index[
i] =
4991 r->typ[0].data.syz.curr_index;
4993 if(k < r->typ[0].data.syz.limit)
4996 Warn(
"rSetSyzComp called with smaller limit (%d) as before (%d)", k, r->typ[0].data.syz.limit);
4998 r->typ[0].data.syz.curr_index = 1 + r->typ[0].data.syz.syz_index[
k];
5002 r->typ[0].data.syz.limit =
k;
5003 r->typ[0].data.syz.curr_index++;
5012 Warn(
"rSetSyzComp(%d) in an IS ring! Be careful!", k);
5029 if ((r->typ!=
NULL) && (r->typ[0].ord_typ==
ro_syz) &&
5030 r->typ[0].data.syz.limit > 0 && i > 0)
5032 assume(i <= r->typ[0].data.syz.limit);
5034 for (j=0; j<r->typ[0].data.syz.limit; j++)
5036 if (r->typ[0].data.syz.syz_index[j] == i &&
5037 r->typ[0].data.syz.syz_index[j+1] != i)
5039 assume(r->typ[0].data.syz.syz_index[j+1] == i+1);
5043 return r->typ[0].data.syz.limit;
5055 for (i=0; i<nb; i++)
5057 if (r->wvhdl[i] !=
NULL)
5059 int length = r->block1[
i] - r->block0[
i];
5060 int* wvhdl = r->wvhdl[
i];
5064 for (j=0; j< length; j++)
5066 if (wvhdl[j] != 0 && wvhdl[j] != 1)
return FALSE;
5082 return (r->cf->type);
5104 while((r->typ[i].ord_typ!=
ro_wp64) && (r->typ[i].ord_typ>0)) i++;
5106 return (
int64*)(r->typ[
i].data.wp64.weights64);
5114 memcpy(r->typ[0].data.wp64.weights64,wv,r->N*
sizeof(
int64));
5122 r->block0=(
int*)
omReallocSize(r->block0, size*
sizeof(
int), (size+1)*
sizeof(
int));
5123 r->block1=(
int*)
omReallocSize(r->block1, size*
sizeof(
int), (size+1)*
sizeof(
int));
5124 r->wvhdl=(
int **)
omReallocSize(r->wvhdl,size*
sizeof(
int *), (size+1)*
sizeof(
int *));
5125 for(
int k=size;
k>pos;
k--) r->wvhdl[
k]=r->wvhdl[
k-1];
5130 #if 0 // currently unused 5131 static int rReallocM1(ring r,
int size,
int pos)
5133 r->order=(
int*)
omReallocSize(r->order, size*
sizeof(
int), (size-1)*
sizeof(
int));
5134 r->block0=(
int*)
omReallocSize(r->block0, size*
sizeof(
int), (size-1)*
sizeof(
int));
5135 r->block1=(
int*)
omReallocSize(r->block1, size*
sizeof(
int), (size-1)*
sizeof(
int));
5136 r->wvhdl=(
int **)
omReallocSize(r->wvhdl,size*
sizeof(
int *), (size-1)*
sizeof(
int *));
5137 for(
int k=pos+1;
k<
size;
k++) r->wvhdl[
k]=r->wvhdl[
k+1];
5145 for(
int j=0;
j<=i2;
j++)
5153 #define rOppVar(R,I) (rVar(R)+1-I) 5179 int i2 = (
rVar(r)-1)/2;
5180 for(i=i2; i>=0; i--)
5186 p = r->names[
rVar(r)-1-
i];
5187 r->names[
rVar(r)-1-
i] = r->names[
i];
5202 for (i=
rVar(r)-1; i>=0; i--)
5204 char *
p=r->names[
i];
5205 if(isupper(*p)) *p = tolower(*p);
5206 else *p = toupper(*p);
5253 for(i=0; src->order[
i]!=0; i++)
5255 switch (src->order[i])
5260 r->order[
j]=src->order[
i];
5264 r->block0[
j]=
rOppVar(r, src->block1[i]);
5265 r->block1[
j]=
rOppVar(r, src->block0[i]);
5269 r->block0[
j]=
rOppVar(r, src->block1[i]);
5270 r->block1[
j]=
rOppVar(r, src->block0[i]);
5276 r->block0[
j]=
rOppVar(r, src->block1[i]);
5277 r->block1[
j]=
rOppVar(r, src->block0[i]);
5278 r->wvhdl[
j]=(
int*)
omAlloc((r->block1[j]-r->block0[j]+1)*
sizeof(int));
5279 for(
int k=r->block0[j]; k<=r->block1[j];
k++)
5280 r->wvhdl[
j][
k-r->block0[
j]]=1;
5283 r->block0[
j]=
rOppVar(r, src->block1[i]);
5284 r->block1[
j]=
rOppVar(r, src->block0[i]);
5292 r->block0[
j]=
rOppVar(r, src->block1[i]);
5293 r->block1[
j]=
rOppVar(r, src->block0[i]);
5294 r->wvhdl[
j]=(
int*)
omAlloc((r->block1[j]-r->block0[j]+1)*
sizeof(int));
5295 for(
int k=r->block0[j]; k<=r->block1[j];
k++)
5296 r->wvhdl[
j][
k-r->block0[
j]]=1;
5299 r->block0[
j]=
rOppVar(r, src->block1[i]);
5300 r->block1[
j]=
rOppVar(r, src->block0[i]);
5308 r->block0[
j]=
rOppVar(r, src->block1[i]);
5309 r->block1[
j]=
rOppVar(r, src->block0[i]);
5310 r->wvhdl[
j]=r->wvhdl[j+1]; r->wvhdl[j+1]=
NULL;
5311 rOppWeight(r->wvhdl[j], r->block1[j]-r->block0[j]);
5314 r->block0[
j]=
rOppVar(r, src->block1[i]);
5315 r->block1[
j]=
rOppVar(r, src->block0[i]);
5323 r->block0[
j]=
rOppVar(r, src->block1[i]);
5324 r->block1[
j]=
rOppVar(r, src->block0[i]);
5325 r->wvhdl[
j]=r->wvhdl[j+1]; r->wvhdl[j+1]=
NULL;
5326 rOppWeight(r->wvhdl[j], r->block1[j]-r->block0[j]);
5329 r->block0[
j]=
rOppVar(r, src->block1[i]);
5330 r->block1[
j]=
rOppVar(r, src->block0[i]);
5337 r->block0[
j]=
rOppVar(r, src->block1[i]);
5338 r->block1[
j]=
rOppVar(r, src->block0[i]);
5339 int n=r->block1[
j]-r->block0[
j];
5341 for (
int nn=0; nn<=n; nn++)
5350 r->block0[
j]=
rOppVar(r, src->block1[i]);
5351 r->block1[
j]=
rOppVar(r, src->block0[i]);
5352 rOppWeight(r->wvhdl[j], r->block1[j]-r->block0[j]);
5407 int *par_perm =
NULL;
5410 for(i=1; i<=r->N; i++)
5418 for (i=1; i<
rVar(r); i++)
5420 for (j=i+1; j<=
rVar(r); j++)
5426 MATELEM(C,nj,ni) =
p_PermPoly(
MATELEM(src->GetNC()->C,
i,
j),perm,src,r, nMap,par_perm,
rPar(src));
5429 MATELEM(D,nj,ni) =
p_PermPoly(
MATELEM(src->GetNC()->D,
i,
j),perm,src,r, nMap,par_perm,
rPar(src));
5437 WarnS(
"Error initializing non-commutative multiplication!");
5445 assume( r->GetNC()->IsSkewConstant == src->GetNC()->IsSkewConstant);
5452 if (src->qideal !=
NULL)
5457 r->qideal =
idOppose(src, src->qideal, r);
5459 r->qideal =
id_Copy(src->qideal, r);
5489 int stat =
rSum(R, Ropp, Renv);
5491 WarnS(
"Error in rEnvelope at rSum");
5514 const int N = dest->N;
5523 const ring srcBase = src;
5530 matrix C0 = src->GetNC()->C;
5531 matrix D0 = src->GetNC()->D;
5534 for (
int i = 1; i <
N; i++)
5536 for (
int j = i + 1;
j <=
N;
j++)
5581 while(r->order[i]!=0)
5588 for(j=r->block1[i]-r->block0[i];j>=0;j--)
5590 r->wvhdl[
i]=(
int*)w64;
5591 omFreeSize(w,(r->block1[i]-r->block0[i]+1)*
sizeof(
int));
5624 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 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_InducedSchreyerOrdering(const ring r, BOOLEAN complete, int sgn)
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)
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...
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
static void rSetFirstWv(ring r, int i, rRingOrder_t *order, int *block1, int **wvhdl)
void rWrite(ring r, BOOLEAN details)
ring rDefault(const coeffs cf, int N, char **n, int ord_size, rRingOrder_t *ord, int *block0, int *block1, int **wvhdl)
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 ...
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)
rRingOrder_t rOrderName(char *ordername)
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