40#define BITS_PER_LONG 8*SIZEOF_LONG
110 r->names = (
char **)
omAlloc0(
N *
sizeof(
char *));
118 r->wvhdl = (
int **)
omAlloc0((ord_size+1) *
sizeof(
int *));
124 if (bitmask!=0) r->wanted_maxExp=bitmask;
136 return rDefault(
cf,
N,n,ord_size,ord,block0,block1,wvhdl);
143 int *block0 = (
int *)
omAlloc0(2 *
sizeof(
int));
144 int *block1 = (
int *)
omAlloc0(2 *
sizeof(
int));
179 WerrorS(
"weights only for orderings wp,ws,Wp,Ws,a,M");
188 int sz = (int)
sqrt((
double)(order->
length()-2));
189 if ((sz*sz)!=(order->
length()-2))
191 WerrorS(
"Matrix order is not a square matrix");
194 while ((
i<sz) && (typ==1))
197 while ((
j<sz) && ((*order)[
j*sz+
i+2]==0))
j++;
201 WerrorS(
"Matrix order not complete");
203 else if ((*order)[
j*sz+
i+2]<0)
216 for (
int i=0;
i<
N;
i++)
218 if (names[
i]==
NULL)
return -1;
219 if (strcmp(n,names[
i]) == 0)
return (
int)
i;
248 PrintS(
"// coefficients: ");
260 R->ShortOut = bSaveShortOut;
303 Print(
"// number of vars : %d",r->N);
308 for (
int l=0, nlen=0 ;
l<nblocks;
l++)
311 Print(
"\n// block %3d : ",
l+1);
318 assume( r->block0[
l] == r->block1[
l] );
319 const int s = r->block0[
l];
327 Print(
" syz_comp: %d",r->block0[
l]);
339 for (
i = r->block0[
l]-1; i<r->block1[
l];
i++)
341 nlen = strlen(r->names[
i]);
346 if (r->wvhdl[
l]!=
NULL)
358 Warn(
"should not have wvhdl entry at pos. %d",
l);
362 j<(r->block1[
l]-r->block0[
l]+1)*(r->block1[
l]-r->block0[
l]+1);
365 PrintS(
"\n// : weights ");
366 for (
i = 0;
i<=r->block1[
l]-r->block0[
l];
i++)
378 Print(
" %*d" ,nlen,r->wvhdl[
l][
i+
j]);
384 int m=r->wvhdl[
l][
i];
385 Print(
"\n// : %d module weights ",
m);
387 for(;
i<=
m;
i++)
Print(
" %*d" ,nlen,r->wvhdl[
l][
i]);
394 PrintS(
"\n// noncommutative relations:");
400 for (
i = 1;
i<r->N;
i++)
402 for (
j =
i+1;
j<=r->N;
j++)
407 Print(
"\n// %s%s=",r->names[
j-1],r->names[
i-1]);
418 Print(
"\n// is skew constant:%d",r->GetNC()->IsSkewConstant);
423 PrintS(
"\n// quotient of sca by ideal");
436 Print(
"\n// letterplace ring (block size %d, ncgen count %d)",r->isLPring, r->LPncGenCount);
441 PrintS(
"\n// quotient ring from ideal");
454 if (r ==
NULL)
return;
458 if( r->qideal !=
NULL )
473 if (r->order !=
NULL)
484 if (r->wvhdl[
j]!=
NULL)
497 for (
i=0;
i<r->N;
i++)
516 if (order==0)
Werror(
"wrong ring order `%s`",ordername);
526 for (nblocks=0; r->order[nblocks]; nblocks++);
545 if (r->wvhdl[
l]!=
NULL)
557 Warn(
"should not have wvhdl entry at pos. %d",
l);
565 j<(r->block1[
l]-r->block0[
l]+1)*(r->block1[
l]-r->block0[
l]+1);
572 for (
i = 0;
i<r->block1[
l]-r->block0[
l];
i++)
581 for (
i = 0;
i<r->block1[
l]-r->block0[
l];
i++)
591 if (
j+
i+1==(r->block1[
l]-r->block0[
l]+1)*(r->block1[
l]-r->block0[
l]+1))
602 assume( r->block0[
l] == r->block1[
l] );
603 const int s = r->block0[
l];
611 if (r->wanted_maxExp!=0)
613 long mm=r->wanted_maxExp;
630 for (
i=0;
i<r->N;
i++)
632 l+=strlen(r->names[
i])+1;
636 for (
i=0;
i<r->N-1;
i++)
638 strcat(
s,r->names[
i]);
641 strcat(
s,r->names[
i]);
653 char const *
const *
const params =
rParameter(r);
660 l+=strlen(params[
i])+1;
666 strcat(
s, params[
i]);
669 strcat(
s, params[
i]);
680 char *
res=(
char *)
omAlloc(strlen(ch)+strlen(var)+strlen(ord)+9);
681 sprintf(
res,
"(%s),(%s),(%s)",ch,var,ord);
713int rChar(ring r) {
return r->cf->ch; }
728 for(
int i=1;
i<r->N;
i++)
729 for(
int j=
i+1;
j<=r->N;
j++)
733 WarnS(
"Error initializing multiplication!");
753 memset(&tmpR,0,
sizeof(tmpR));
788 && (mpz_cmp(r1->cf->modNumber,r2->cf->extRing->cf->modNumber)==0))
821 if (r1->cf->extRing->cf==r2->cf)
831 WerrorS (
"coeff sum of two extension fields not implemented");
837 WerrorS(
"coeff sum not yet implemented");
844 char **names=(
char **)
omAlloc0(
l*
sizeof(
char *));
849 for (
i=0;
i<r1->N;
i++)
853 if (*(r1->names[
i]) ==
'\0')
885 if (*(r2->names[
i]) ==
'\0')
908 if (strcmp(r1->names[
j],r2->names[
i])==0)
977 if ((r2->block0[0]==1)
978 && (r2->block1[0]==
rVar(r2))
984 tmpR.
order[1]=r2->order[0];
985 if (r2->wvhdl[0]!=
NULL)
990 int l=r2->block1[0]-r2->block0[0]+1;
995 l+=r2->wvhdl[1][r2->block1[0]-r2->block0[0]+1]+1;
998 memcpy(tmpR.
wvhdl[1],r2->wvhdl[0],
l*
sizeof(
int));
1065 if (rb->wvhdl[
i]!=
NULL)
1066 WarnS(
"rSum: weights not implemented");
1072 for (
i=0;r1->order[
i]!=0;
i++)
1077 if (r1->wvhdl[
i]!=
NULL)
1082 int l=r1->block1[
i]-r1->block0[
i]+1;
1087 l+=r1->wvhdl[
i][r1->block1[
i]-r1->block0[
i]+1]+1;
1090 memcpy(tmpR.
wvhdl[
i],r1->wvhdl[
i],
l*
sizeof(
int));
1102 for (
i=0;r2->order[
i]!=0;
i++)
1110 if (r2->wvhdl[
i]!=
NULL)
1116 int l=r2->block1[
i]-r2->block0[
i]+1;
1121 l+=r2->wvhdl[
i][r2->block1[
i]-r2->block0[
i]+1]+1;
1124 memcpy(tmpR.
wvhdl[
j],r2->wvhdl[
i],
l*
sizeof(
int));
1131 if((r1->OrdSgn==-1)||(r2->OrdSgn==-1))
1151 if (r1->wvhdl[
i]!=
NULL)
1157 int l=r1->block1[
i]-r1->block0[
i]+1;
1162 l+=r1->wvhdl[
i][r1->block1[
i]-r1->block0[
i]+1]+1;
1165 memcpy(tmpR.
wvhdl[
i],r1->wvhdl[
i],
l*
sizeof(
int));
1176 Werror(
"variables must not overlap (# of vars: %d,%d -> %d)",
rVar(r1),
rVar(r2),
k);
1182 memcpy(sum,&tmpR,
sizeof(
ip_sring));
1199 if ( (R1_is_nc) || (R2_is_nc))
1223 int *perm1 = (
int *)
omAlloc0((
rVar(R1)+1)*
sizeof(int));
1224 int *par_perm1 =
NULL;
1227 int *perm2 = (
int *)
omAlloc0((
rVar(R2)+1)*
sizeof(int));
1228 int *par_perm2 =
NULL;
1233 perm1, par_perm1, sum->cf->type);
1237 perm2, par_perm2, sum->cf->type);
1240 matrix C1 = R1->GetNC()->C, C2 = R2->GetNC()->C;
1241 matrix D1 = R1->GetNC()->D, D2 = R2->GetNC()->D;
1250 for (
i = 1;
i <=
rVar(R1);
i++)
1263 MATELEM(C,
i,
j) =
p_PermPoly(
MATELEM(C1,
i,
j), perm1, R1, sum, nMap1, par_perm1,
rPar(R1));
1266 MATELEM(
D,
i,
j) =
p_PermPoly(
MATELEM(D1,
i,
j), perm1, R1, sum, nMap1, par_perm1,
rPar(R1));
1279 MATELEM(C,
rVar(R1)+
i,
rVar(R1)+
j) =
p_PermPoly(
MATELEM(C2,
i,
j),perm2,R2,sum, nMap2,par_perm2,
rPar(R2));
1282 MATELEM(
D,
rVar(R1)+
i,
rVar(R1)+
j) =
p_PermPoly(
MATELEM(D2,
i,
j),perm2,R2,sum, nMap2,par_perm2,
rPar(R2));
1290 WarnS(
"Error initializing non-commutative multiplication!");
1299 Print(
"\nRefs: R1: %d, R2: %d\n", R1->GetNC()->ref, R2->GetNC()->ref);
1322 if (r1->qideal!=
NULL)
1333 int *perm1 = (
int *)
omAlloc0((
rVar(r1)+1)*
sizeof(int));
1334 int *par_perm1 =
NULL;
1338 perm1, par_perm1, sum->cf->type);
1342 for (
int for_i=0;for_i<
IDELEMS(r1->qideal);for_i++)
1344 r1->qideal->m[for_i], perm1,
1347 par_perm1,
rPar(r1));
1352 if (r2->qideal!=
NULL)
1356 int *perm2 = (
int *)
omAlloc0((
rVar(r2)+1)*
sizeof(int));
1357 int *par_perm2 =
NULL;
1361 perm2, par_perm2, sum->cf->type);
1365 for (
int for_i=0;for_i<
IDELEMS(r2->qideal);for_i++)
1367 r2->qideal->m[for_i], perm2,
1370 par_perm2,
rPar(r2));
1402int rSum(ring r1, ring r2, ring &sum)
1428 res->options=r->options;
1443 res->firstBlockEnds=r->firstBlockEnds;
1445 res->real_var_start=r->real_var_start;
1446 res->real_var_end=r->real_var_end;
1450 res->isLPring=r->isLPring;
1451 res->LPncGenCount=r->LPncGenCount;
1454 res->VectorOut=r->VectorOut;
1455 res->ShortOut=r->ShortOut;
1456 res->CanShortOut=r->CanShortOut;
1472 res->bitmask=r->bitmask;
1473 res->divmask=r->divmask;
1474 res->BitsPerExp = r->BitsPerExp;
1475 res->ExpPerLong = r->ExpPerLong;
1494 if (copy_ordering ==
TRUE)
1496 res->LexOrder=r->LexOrder;
1497 res->MixedOrder=r->MixedOrder;
1505 if (r->wvhdl[
j]!=
NULL)
1511 int l=r->block1[
j]-r->block0[
j]+1;
1516 l+=r->wvhdl[
j][r->block1[
j]-r->block0[
j]+1]+1;
1519 memcpy(
res->wvhdl[
j],r->wvhdl[
j],
l*
sizeof(
int));
1527 memcpy(
res->block0,r->block0,
i *
sizeof(
int));
1528 memcpy(
res->block1,r->block1,
i *
sizeof(
int));
1543 if (r->qideal!=
NULL)
1572 res->options=r->options;
1587 res->firstBlockEnds=r->firstBlockEnds;
1589 res->real_var_start=r->real_var_start;
1590 res->real_var_end=r->real_var_end;
1594 res->isLPring=r->isLPring;
1595 res->LPncGenCount=r->LPncGenCount;
1598 res->VectorOut=r->VectorOut;
1599 res->ShortOut=r->ShortOut;
1600 res->CanShortOut=r->CanShortOut;
1601 res->LexOrder=r->LexOrder;
1602 res->MixedOrder=r->MixedOrder;
1618 res->bitmask=r->bitmask;
1619 res->divmask=r->divmask;
1620 res->BitsPerExp = r->BitsPerExp;
1621 res->ExpPerLong = r->ExpPerLong;
1640 if (copy_ordering ==
TRUE)
1647 for (
j=0;
j<
i-1;
j++)
1649 if (r->wvhdl[
j]!=
NULL)
1655 int l=r->block1[
j]-r->block0[
j]+1;
1660 l+=r->wvhdl[
j][r->block1[
j]-r->block0[
j]+1]+1;
1663 memcpy(
res->wvhdl[
j+1],r->wvhdl[
j],
l*
sizeof(
int));
1671 memcpy(&(
res->block0[1]),r->block0,(
i-1) *
sizeof(
int));
1672 memcpy(&(
res->block1[1]),r->block1,(
i-1) *
sizeof(
int));
1690 res->wvhdl[0]=(
int *)
A;
1700 if (r->qideal!=
NULL)
1706 WerrorS(
"internal error: rCopy0(Q,TRUE,FALSE)");
1711 WarnS(
"internal bad stuff: rCopy0(Q,TRUE,TRUE)");
1748 if (r1 == r2)
return TRUE;
1750 if (r1->cf!=r2->cf)
return FALSE;
1752 if (r1->bitmask!=r2->bitmask)
return FALSE;
1753 #ifdef HAVE_SHIFTBBA
1754 if (r1->isLPring!=r2->isLPring)
return FALSE;
1755 if (r1->LPncGenCount!=r2->LPncGenCount)
return FALSE;
1765 if ((r1->names[
i] !=
NULL) && (r2->names[
i] !=
NULL))
1767 if (strcmp(r1->names[
i], r2->names[
i]))
return FALSE;
1769 else if ((r1->names[
i] !=
NULL) ^ (r2->names[
i] !=
NULL))
1777 if (r1->qideal !=
NULL)
1779 ideal id1 = r1->qideal, id2 = r2->qideal;
1793 else if (r2->qideal !=
NULL)
return FALSE;
1803 if (r1 == r2)
return TRUE;
1807 if ((r1->cf != r2->cf)
1809 || (r1->OrdSgn != r2->OrdSgn))
1813 while (r1->order[
i] != 0)
1815 if (r2->order[
i] == 0)
return FALSE;
1816 if ((r1->order[
i] != r2->order[
i])
1817 || (r1->block0[
i] != r2->block0[
i])
1818 || (r1->block1[
i] != r2->block1[
i]))
1820 if (r1->wvhdl[
i] !=
NULL)
1822 if (r2->wvhdl[
i] ==
NULL)
1824 for (
j=0;
j<r1->block1[
i]-r1->block0[
i]+1;
j++)
1825 if (r2->wvhdl[
i][
j] != r1->wvhdl[
i][
j])
1831 if (r2->order[
i] != 0)
return FALSE;
1892 if (blocks == 1)
return TRUE;
1901 if ((blocks -
s) > 2)
return FALSE;
1967 if (blocks == 1)
return TRUE;
1976 if ((blocks -
s) > 3)
return FALSE;
1979 if ((blocks -
s) == 3)
1998 for (pos=0;pos<r->OrdSize;pos++)
2016 return (
rVar(r) > 1 &&
2022 ((r->order[1]!=0) &&
2030 return ((
rVar(r) > 1) &&
2049 if (r->N == 0)
return TRUE;
2051 if ((r->OrdSgn!=1) && (r->OrdSgn!= -1))
2063 for(
int j=0;
j<=
i;
j++)
2066 dError(
"wrong order in r->order");
2077 if (r->VarOffset ==
NULL)
2079 dReportError(
"Null ring VarOffset -- no rComplete (?) in n %s:%d", fn,
l);
2084 if ((r->OrdSize==0)!=(r->typ==
NULL))
2086 dReportError(
"mismatch OrdSize and typ-pointer in %s:%d");
2092 for(
i=0;
i<=r->N;
i++)
2096 for(
j=0;
j<r->OrdSize;
j++)
2100 const int p = r->typ[
j].data.isTemp.suffixpos;
2105 assume( p < r->OrdSize );
2107 if(r->typ[
p].ord_typ !=
ro_is)
2108 dReportError(
"ordrec prefix %d is unmatched (suffix: %d is wrong!!!)",
j,
p);
2111 if(r->typ[
j].data.isTemp.pVarOffset[
i] != -1)
2117 else if (r->typ[
j].ord_typ ==
ro_is)
2120 if(r->typ[
j].data.is.pVarOffset[
i] != -1)
2128 if (r->typ[
j].ord_typ==
ro_cp)
2130 if(((
short)r->VarOffset[
i]) == r->typ[
j].data.cp.place)
2135 && (r->VarOffset[
i] == r->typ[
j].data.dp.place))
2141 tmp=r->VarOffset[
i] & 0xffffff;
2142 #if SIZEOF_LONG == 8
2143 if ((r->VarOffset[
i] >> 24) >63)
2145 if ((r->VarOffset[
i] >> 24) >31)
2147 dReportError(
"bit_start out of range:%d",r->VarOffset[
i] >> 24);
2148 if (
i > 0 && ((tmp<0) ||(tmp>r->ExpL_Size-1)))
2150 dReportError(
"varoffset out of range for var %d: %d",
i,tmp);
2155 for(
j=0;
j<r->OrdSize;
j++)
2157 if ((r->typ[
j].ord_typ==
ro_dp)
2158 || (r->typ[
j].ord_typ==
ro_wp)
2161 if (r->typ[
j].data.dp.start > r->typ[
j].data.dp.end)
2163 r->typ[
j].data.dp.start, r->typ[
j].data.dp.end);
2164 if ((r->typ[
j].data.dp.start < 1)
2165 || (r->typ[
j].data.dp.end > r->N))
2166 dReportError(
"in ordrec %d: start(%d)<1 or end(%d)>vars(%d)",
j,
2167 r->typ[
j].data.dp.start, r->typ[
j].data.dp.end,r->N);
2199static void rO_TDegree(
int &place,
int &bitplace,
int start,
int end,
2205 ord_struct.
data.dp.start=start;
2206 ord_struct.
data.dp.end=end;
2207 ord_struct.
data.dp.place=place;
2219 ord_struct.
data.dp.start=start;
2220 ord_struct.
data.dp.end=end;
2221 ord_struct.
data.dp.place=place;
2227static void rO_WDegree(
int &place,
int &bitplace,
int start,
int end,
2228 long *o,
sro_ord &ord_struct,
int *weights)
2231 while((start<end) && (weights[0]==0)) { start++; weights++; }
2232 while((start<end) && (weights[end-start]==0)) { end--; }
2235 for(
i=start;
i<=end;
i++)
2237 if(weights[
i-start]!=1)
2245 rO_TDegree(place,bitplace,start,end,o,ord_struct);
2250 ord_struct.
data.wp.start=start;
2251 ord_struct.
data.wp.end=end;
2252 ord_struct.
data.wp.place=place;
2253 ord_struct.
data.wp.weights=weights;
2257 for(
i=start;
i<=end;
i++)
2259 if(weights[
i-start]<0)
2268 long *o,
sro_ord &ord_struct,
int *weights)
2277 ord_struct.
data.am.start=start;
2278 ord_struct.
data.am.end=end;
2279 ord_struct.
data.am.place=place;
2280 ord_struct.
data.am.weights=weights;
2281 ord_struct.
data.am.weights_m = weights + (end-start+1);
2282 ord_struct.
data.am.len_gen=weights[end-start+1];
2283 assume( ord_struct.
data.am.weights_m[0] == ord_struct.
data.am.len_gen );
2296 ord_struct.
data.wp64.start=start;
2297 ord_struct.
data.wp64.end=end;
2298 ord_struct.
data.wp64.place=place;
2300 ord_struct.
data.wp64.weights64=weights;
2304 for(
int i=0;
i<
l;
i++) ord_struct.
data.wp64.weights64[
i]=weights[
i];
2314 long *o,
sro_ord &ord_struct,
int *weights)
2317 while((start<end) && (weights[0]==0)) { start++; weights++; }
2318 while((start<end) && (weights[end-start]==0)) { end--; }
2321 ord_struct.
data.wp.start=start;
2322 ord_struct.
data.wp.end=end;
2323 ord_struct.
data.wp.place=place;
2324 ord_struct.
data.wp.weights=weights;
2329 for(
i=start;
i<=end;
i++)
2331 if(weights[
i-start]<0)
2339static void rO_LexVars(
int &place,
int &bitplace,
int start,
int end,
2340 int &prev_ord,
long *o,
int *
v,
int bits,
int opt_var)
2345 if(prev_ord==-1)
rO_Align(place,bitplace);
2351 for(
k=start;;
k+=incr)
2356 v[
k]= place | (bitplace << 24);
2362 assume((opt_var == end+1) ||(opt_var == end-1));
2363 if((opt_var != end+1) &&(opt_var != end-1))
WarnS(
"hier-2");
2364 int save_bitplace=bitplace;
2368 bitplace=save_bitplace;
2372 v[opt_var]=place | (bitplace << 24);
2377 int &prev_ord,
long *o,
int *
v,
int bits,
int opt_var)
2382 if(prev_ord==1)
rO_Align(place,bitplace);
2388 for(
k=start;;
k+=incr)
2393 v[
k]=place | (bitplace << 24);
2400 assume((opt_var == end+1) ||(opt_var == end-1));
2401 if((opt_var != end+1) &&(opt_var != end-1))
WarnS(
"hier-1");
2402 int save_bitplace=bitplace;
2406 bitplace=save_bitplace;
2410 v[opt_var]=place | (bitplace << 24);
2421 ord_struct.
data.syzcomp.place=place;
2422 ord_struct.
data.syzcomp.Components=
NULL;
2423 ord_struct.
data.syzcomp.ShiftedComponents=
NULL;
2430static void rO_Syz(
int &place,
int &bitplace,
int &prev_ord,
2431 int syz_comp,
long *o,
sro_ord &ord_struct)
2438 ord_struct.
data.syz.place=place;
2439 ord_struct.
data.syz.limit=syz_comp;
2441 ord_struct.
data.syz.syz_index = (
int*)
omAlloc0((syz_comp+1)*
sizeof(int));
2443 ord_struct.
data.syz.syz_index =
NULL;
2444 ord_struct.
data.syz.curr_index = 1;
2457 long *o,
int N,
int *
v,
sro_ord &ord_struct)
2464 ord_struct.
data.isTemp.start = place;
2468 ord_struct.
data.isTemp.pVarOffset = (
int *)
omAlloc((
N+1)*
sizeof(int));
2469 memcpy(ord_struct.
data.isTemp.pVarOffset,
v,(
N+1)*
sizeof(
int));
2471 ord_struct.
data.isTemp.suffixpos = -1;
2479static void rO_ISSuffix(
int &place,
int &bitplace,
int &prev_ord,
long *o,
2484 int typ_j = typ_i - 1;
2487 if( tmp_typ[typ_j].ord_typ ==
ro_isTemp)
2500 const int start = tmp_typ[typ_j].
data.isTemp.start;
2501 int *pVarOffset = tmp_typ[typ_j].
data.isTemp.pVarOffset;
2512 tmp_typ[typ_j].
data.isTemp.suffixpos = typ_i;
2519 for(
int i = 0;
i <=
N;
i++ )
2522 if(
v[
i] != pVarOffset[
i] )
2524 pVarOffset[
i] =
v[
i];
2526 assume( pVarOffset[
i] != -1 );
2532 if( pVarOffset[0] != -1 )
2533 pVarOffset[0] &= 0x0fff;
2535 sro_ord &ord_struct = tmp_typ[typ_j];
2539 ord_struct.
data.is.start = start;
2540 ord_struct.
data.is.end = place;
2541 ord_struct.
data.is.pVarOffset = pVarOffset;
2563 v[0] = place | (bitplace << 24);
2574 bits=16; bitmask=0xffff;
2576 else if (bitmask <= 1L)
2578 bits=1; bitmask = 1L;
2580 else if (bitmask <= 3L)
2582 bits=2; bitmask = 3L;
2584 else if (bitmask <= 7L)
2588 else if (bitmask <= 0xfL)
2590 bits=4; bitmask=0xfL;
2592 else if (bitmask <= 0x1fL)
2594 bits=5; bitmask=0x1fL;
2596 else if (bitmask <= 0x3fL)
2598 bits=6; bitmask=0x3fL;
2601 else if (bitmask <= 0x7fL)
2603 bits=7; bitmask=0x7fL;
2606 else if (bitmask <= 0xffL)
2608 bits=8; bitmask=0xffL;
2611 else if (bitmask <= 0x1ffL)
2613 bits=9; bitmask=0x1ffL;
2616 else if (bitmask <= 0x3ffL)
2618 bits=10; bitmask=0x3ffL;
2621 else if (bitmask <= 0xfffL)
2623 bits=12; bitmask=0xfff;
2626 else if (bitmask <= 0xffffL)
2628 bits=16; bitmask=0xffffL;
2631 else if (bitmask <= 0xfffffL)
2633 bits=20; bitmask=0xfffffL;
2635 else if (bitmask <= 0xffffffffL)
2637 bits=32; bitmask=0xffffffffL;
2639 else if (bitmask <= 0x7fffffffffffffffL)
2641 bits=63; bitmask=0x7fffffffffffffffL;
2645 bits=63; bitmask=0x7fffffffffffffffL;
2648 else if (bitmask <= 0x7fffffff)
2650 bits=31; bitmask=0x7fffffff;
2654 bits=31; bitmask=0x7fffffffL;
2675 unsigned long bitmask1 =
rGetExpSize(bitmask+1, bits1);
2677 if ((((
N+vars_per_long-1)/vars_per_long) ==
2678 ((
N+vars_per_long1-1)/vars_per_long1)))
2680 vars_per_long=vars_per_long1;
2700 unsigned long exp_limit)
2708 BOOLEAN need_other_ring = (exp_limit != r->bitmask);
2710 int iNeedInducedOrderingSetup = 0;
2714 int *block0=(
int*)
omAlloc0((nblocks+1)*
sizeof(int));
2715 int *block1=(
int*)
omAlloc0((nblocks+1)*
sizeof(int));
2716 int **wvhdl=(
int**)
omAlloc0((nblocks+1)*
sizeof(
int *));
2725 if (r->block0[
i]==r->block1[
i])
2750 Warn(
"Error: unhandled ordering in rModifyRing: ringorder_S = [%d]", r_ord);
2764 need_other_ring=
TRUE;
2765 try_omit_comp=
FALSE;
2766 copy_block_index=
FALSE;
2780 need_other_ring=
TRUE;
2782 omitted_degree =
TRUE;
2796 need_other_ring=
TRUE;
2798 omitted_degree =
TRUE;
2806 try_omit_comp =
FALSE;
2809 iNeedInducedOrderingSetup++;
2818 try_omit_comp =
FALSE;
2827 if (copy_block_index)
2829 block0[
j]=r->block0[
i];
2830 block1[
j]=r->block1[
i];
2831 wvhdl[
j]=r->wvhdl[
i];
2836 if(!need_other_ring)
2856 res->bitmask=exp_limit;
2857 res->wanted_maxExp=r->wanted_maxExp;
2864 if (r->pFDegOrig !=
res->pFDegOrig &&
2869 res->firstwv = r->firstwv;
2870 res->firstBlockEnds = r->firstBlockEnds;
2874 res->pLDeg = r->pLDegOrig;
2883 res->typ[0] = r->typ[0];
2885 if (r->typ[0].data.syz.limit > 0)
2887 res->typ[0].data.syz.syz_index
2888 = (
int*)
omAlloc((r->typ[0].data.syz.limit +1)*
sizeof(int));
2889 memcpy(
res->typ[0].data.syz.syz_index, r->typ[0].data.syz.syz_index,
2890 (r->typ[0].data.syz.limit +1)*
sizeof(
int));
2894 if( iNeedInducedOrderingSetup > 0 )
2896 for(
j = 0,
i = 0; (
i < nblocks) && (iNeedInducedOrderingSetup > 0);
i++)
2903 r->typ[
i].data.is.limit,
2908 iNeedInducedOrderingSetup--;
2914 res->OrdSgn=r->OrdSgn;
2923 WarnS(
"error in nc_rComplete");
2936 WarnS(
"error in sca_Force!");
2962 res->block1[0] = r->N;
2963 res->wvhdl[0] = weights;
2978 WarnS(
"error in nc_rComplete");
3005 int nblocks=1+(ommit_comp!=0);
3007 int *block0=(
int*)
omAlloc0((nblocks+1)*
sizeof(int));
3008 int *block1=(
int*)
omAlloc0((nblocks+1)*
sizeof(int));
3009 int **wvhdl=(
int**)
omAlloc0((nblocks+1)*
sizeof(
int *));
3028 res->bitmask=exp_limit;
3029 res->wanted_maxExp=r->wanted_maxExp;
3040 WarnS(
"error in nc_rComplete");
3056 return rModifyRing(r, ommit_degree, ommit_comp, exp_limit);
3084 r->CanShortOut=
FALSE;
3087 r->CanShortOut =
TRUE;
3095 r->CanShortOut=
FALSE;
3103 for (
i=(
N-1);
i>=0;
i--)
3105 if(r->names[
i] !=
NULL && strlen(r->names[
i])>1)
3107 r->CanShortOut=
FALSE;
3113 r->ShortOut = r->CanShortOut;
3115 assume( !( !r->CanShortOut && r->ShortOut ) );
3123 if(block1[
i]!=r->N) r->LexOrder=
TRUE;
3124 r->firstBlockEnds=block1[
i];
3125 r->firstwv = wvhdl[
i];
3134 for(
j=block1[
i]-block0[
i];
j>=0;
j--)
3136 if (r->firstwv[
j]==0) r->LexOrder=
TRUE;
3143 for(
j=block1[
i]-block0[
i];
j>=0;
j--)
3145 if (
w[
j]==0) r->LexOrder=
TRUE;
3152 if (r->pFDeg ==
p_Deg)
3173 r->pLDegOrig = r->pLDeg;
3180 int* block0 = r->block0;
3181 int* block1 = r->block1;
3182 int** wvhdl = r->wvhdl;
3191 r->LexOrder =
FALSE;
3198 for(
int ii=block0[0];ii<=block1[0];ii++)
3199 if (wvhdl[0][ii-1]<0) { r->MixedOrder=2;
break;}
3201 for(
int ii=block0[0];ii<=block1[0];ii++)
3202 if (wvhdl[0][ii-1]==0) { r->LexOrder=
TRUE;
break;}
3203 if ((block0[0]==1)&&(block1[0]==r->N))
3214 r->firstwv = wvhdl[0];
3226 if (r->OrdSgn == -1) r->pLDeg =
pLDeg0c;
3245 for(
int ii=block0[0];ii<=block1[0];ii++)
3247 if (wvhdl[0][ii-1]<0) { r->MixedOrder=2;
break;}
3249 if (r->MixedOrder==0)
3251 if ((block0[0]==1)&&(block1[0]==r->N))
3259 r->firstBlockEnds=block1[0];
3260 r->firstwv = wvhdl[0];
3279 r->firstBlockEnds=block1[1];
3280 if (wvhdl!=
NULL) r->firstwv = wvhdl[1];
3288 for(
int ii=block0[1];ii<=block1[1];ii++)
3289 if (wvhdl[1][ii-1]<0) { r->MixedOrder=2;
break;}
3290 if (r->MixedOrder==
FALSE)
3323 if(r->MixedOrder==
FALSE)
3338 r->pFDegOrig = r->pFDeg;
3353 for(
i=0;
i<r->OrdSize;
i++)
3356 ||(r->typ[
i].ord_typ==
ro_am))
3361 r->NegWeightL_Size=
l;
3362 r->NegWeightL_Offset=(
int *)
omAlloc(
l*
sizeof(
int));
3364 for(
i=0;
i<r->OrdSize;
i++)
3368 r->NegWeightL_Offset[
l]=r->typ[
i].data.wp.place;
3371 else if(r->typ[
i].ord_typ==
ro_am)
3373 r->NegWeightL_Offset[
l]=r->typ[
i].data.am.place;
3380 r->NegWeightL_Size = 0;
3381 r->NegWeightL_Offset =
NULL;
3393 if ( (r->cf->extRing!=
NULL)
3402 if (r->LexOrder || r->OrdSgn == -1 || (r->cf->extRing!=
NULL))
3419 r->pLexOrder=r->LexOrder;
3427static inline int sign(
int x) {
return (
x > 0) - (
x < 0);}
3452 if (r->VarOffset!=
NULL && force == 0)
return FALSE;
3457 r->bitmask=
rGetExpSize(r->wanted_maxExp,bits,r->N);
3458 r->BitsPerExp = bits;
3463 long *tmp_ordsgn=(
long *)
omAlloc0(3*(n+r->N)*
sizeof(long));
3465 int *
v=(
int *)
omAlloc((r->N+1)*
sizeof(int));
3466 for(
i=r->N;
i>=0 ;
i--)
3483 switch (r->order[
i])
3487 rO_WDegree(
j,j_bits,r->block0[
i],r->block1[
i],tmp_ordsgn,tmp_typ[typ_i],
3493 rO_WMDegree(
j,j_bits,r->block0[
i],r->block1[
i],tmp_ordsgn,tmp_typ[typ_i],
3500 tmp_typ[typ_i], (
int64 *)(r->wvhdl[
i]));
3507 r->ComponentOrder=1;
3513 r->ComponentOrder=-1;
3519 k=r->block1[
i]-r->block0[
i]+1;
3524 r->wvhdl[
i]+(r->block1[
i]-r->block0[
i]+1)*
l);
3531 rO_LexVars(
j, j_bits, r->block0[
i],r->block1[
i], prev_ordsgn,
3532 tmp_ordsgn,
v,bits, -1);
3537 tmp_ordsgn,
v, bits, -1);
3542 tmp_ordsgn,
v, bits, -1);
3546 rO_LexVars(
j, j_bits, r->block1[
i],r->block0[
i], prev_ordsgn,
3547 tmp_ordsgn,
v, bits, -1);
3551 if (r->block0[
i]==r->block1[
i])
3553 rO_LexVars(
j, j_bits, r->block0[
i],r->block0[
i], prev_ordsgn,
3554 tmp_ordsgn,
v, bits, -1);
3562 prev_ordsgn,tmp_ordsgn,
v,bits, r->block0[
i]);
3567 if (r->block0[
i]==r->block1[
i])
3569 rO_LexVars(
j, j_bits, r->block0[
i],r->block0[
i], prev_ordsgn,
3570 tmp_ordsgn,
v, bits, -1);
3577 rO_LexVars(
j, j_bits, r->block0[
i],r->block1[
i]-1, prev_ordsgn,
3578 tmp_ordsgn,
v, bits, r->block1[
i]);
3583 if (r->block0[
i]==r->block1[
i])
3586 tmp_ordsgn,
v,bits, -1);
3594 prev_ordsgn,tmp_ordsgn,
v,bits, r->block0[
i]);
3599 if (r->block0[
i]==r->block1[
i])
3602 tmp_ordsgn,
v, bits, -1);
3609 rO_LexVars(
j, j_bits, r->block0[
i],r->block1[
i]-1, prev_ordsgn,
3610 tmp_ordsgn,
v, bits, r->block1[
i]);
3616 tmp_typ[typ_i], r->wvhdl[
i]);
3621 for(jj=r->block1[
i]-r->block0[
i];jj>=0; jj--)
3623 if (r->wvhdl[
i][jj]<=0) have_bad_weights=
TRUE;
3625 if (have_bad_weights)
3632 if (r->block1[
i]!=r->block0[
i])
3635 tmp_ordsgn,
v,bits, r->block0[
i]);
3641 tmp_typ[typ_i], r->wvhdl[
i]);
3646 for(jj=r->block1[
i]-r->block0[
i];jj>=0; jj--)
3648 if (r->wvhdl[
i][jj]<=0) have_bad_weights=
TRUE;
3650 if (have_bad_weights)
3657 if (r->block1[
i]!=r->block0[
i])
3659 rO_LexVars(
j, j_bits,r->block0[
i],r->block1[
i]-1, prev_ordsgn,
3660 tmp_ordsgn,
v, bits, r->block1[
i]);
3666 tmp_typ[typ_i], r->wvhdl[
i]);
3668 if (r->block1[
i]!=r->block0[
i])
3671 tmp_ordsgn,
v,bits, r->block0[
i]);
3677 tmp_typ[typ_i], r->wvhdl[
i]);
3679 if (r->block1[
i]!=r->block0[
i])
3681 rO_LexVars(
j, j_bits,r->block0[
i],r->block1[
i]-1, prev_ordsgn,
3682 tmp_ordsgn,
v, bits, r->block1[
i]);
3689 rO_Syzcomp(
j, j_bits,prev_ordsgn, tmp_ordsgn,tmp_typ[typ_i]);
3690 need_to_add_comp=
TRUE;
3691 r->ComponentOrder=-1;
3697 rO_Syz(
j, j_bits, prev_ordsgn, r->block0[
i], tmp_ordsgn, tmp_typ[typ_i]);
3698 need_to_add_comp=
TRUE;
3699 r->ComponentOrder=-1;
3706 assume( r->block0[
i] == r->block1[
i] );
3707 const int s = r->block0[
i];
3711 rO_ISPrefix(
j, j_bits, prev_ordsgn, tmp_ordsgn, r->N,
v, tmp_typ[typ_i++]);
3714 rO_ISSuffix(
j, j_bits, prev_ordsgn, tmp_ordsgn, r->N,
v, tmp_typ, typ_i,
s);
3715 need_to_add_comp=
FALSE;
3734 j_bits=j_bits0;
j=j0;
3739 if((need_to_add_comp) && (
v[0]== -1))
3753 for(
i=1 ;
i<=r->N ;
i++)
3780 r->ordsgn=(
long *)
omAlloc0(r->ExpL_Size*
sizeof(
long));
3782 for(
j=0;
j<r->CmpL_Size;
j++)
3784 r->ordsgn[
j] = tmp_ordsgn[
j];
3793 if (typ_i==0) r->typ=
NULL;
3797 memcpy(r->typ,tmp_typ,typ_i*
sizeof(
sro_ord));
3807 r->pCompIndex=(r->VarOffset[0] & 0xffff);
3810 if (
i==r->pCompIndex)
i++;
3811 while ((j < r->OrdSize)
3819 if (
i==r->pCompIndex)
i++;
3857 for(
int i=1;
i<=r->N;
i++)
3864 if ((r->block0[
j]<=
i)&&(r->block1[
j]>=
i))
3884 if(r->wvhdl[
j][
i-r->block0[
j]]<0)
3890 else if(r->wvhdl[
j][
i-r->block0[
j]]>0)
3901 if(r->wvhdl[
j][
i-r->block0[
j]]<0)
3907 else if(r->wvhdl[
j][
i-r->block0[
j]]>0)
3915 int add=r->block1[
j]-r->block0[
j]+1;
3920 if (r->wvhdl[
j][
i-r->block0[
j]]<0)
3926 else if(r->wvhdl[
j][
i-r->block0[
j]]>0)
3956 if (nonneg>0) r->MixedOrder=1;
3967 if (r ==
NULL)
return;
3968 if (r->VarOffset !=
NULL)
3970 if (r->OrdSize!=0 && r->typ !=
NULL)
3972 for(
int i = 0;
i < r->OrdSize;
i++)
3973 if( r->typ[
i].ord_typ ==
ro_is)
3977 if( r->typ[
i].data.is.pVarOffset !=
NULL )
3982 else if (r->typ[
i].ord_typ ==
ro_syz)
3984 if(r->typ[
i].data.syz.limit > 0)
3985 omFreeSize(r->typ[
i].data.syz.syz_index, ((r->typ[
i].data.syz.limit) +1)*
sizeof(
int));
3989 assume( r->typ[
i].data.syzcomp.ShiftedComponents ==
NULL );
3990 assume( r->typ[
i].data.syzcomp.Components ==
NULL );
4000 if (r->PolyBin !=
NULL)
4006 if (r->ordsgn !=
NULL && r->CmpL_Size != 0)
4011 if (r->p_Procs !=
NULL)
4016 omfreeSize(r->VarL_Offset, r->VarL_Size*
sizeof(
int));
4017 r->VarL_Offset=
NULL;
4019 if (r->NegWeightL_Offset!=
NULL)
4021 omFreeSize(r->NegWeightL_Offset, r->NegWeightL_Size*
sizeof(
int));
4022 r->NegWeightL_Offset=
NULL;
4029 int min = INT_MAX, min_j = -1;
4030 int* VarL_Number = (
int*)
omAlloc0(r->ExpL_Size*
sizeof(
int));
4035 for (
i=1;
i<=r->N;
i++)
4037 VarL_Number[r->VarOffset[
i] & 0xffffff]++;
4041 for (
i=0,
j=0;
i<r->ExpL_Size;
i++)
4043 if (VarL_Number[
i] != 0)
4045 if (
min > VarL_Number[
i])
4047 min = VarL_Number[
i];
4056 r->VarL_Offset = (
int*)
omAlloc(r->VarL_Size*
sizeof(
int));
4057 r->VarL_LowIndex = 0;
4060 for (
i=0,
j=0;
i<r->ExpL_Size;
i++)
4062 if (VarL_Number[
i] != 0)
4064 r->VarL_Offset[
j] =
i;
4065 if (
j > 0 && r->VarL_Offset[
j-1] != r->VarL_Offset[
j] - 1)
4066 r->VarL_LowIndex = -1;
4070 if (r->VarL_LowIndex >= 0)
4071 r->VarL_LowIndex = r->VarL_Offset[0];
4075 j = r->VarL_Offset[min_j];
4076 r->VarL_Offset[min_j] = r->VarL_Offset[0];
4077 r->VarL_Offset[0] =
j;
4084 int* shifts = (
int*)
omAlloc(r->ExpL_Size*
sizeof(
int));
4087 for (
i=0;
i<r->ExpL_Size;
i++)
4091 for (
i=1;
i<=r->N;
i++)
4093 if (shifts[r->VarOffset[
i] & 0xffffff] > r->VarOffset[
i] >> 24)
4094 shifts[r->VarOffset[
i] & 0xffffff] = r->VarOffset[
i] >> 24;
4097 for (
i=1;
i<=r->N;
i++)
4099 if (shifts[r->VarOffset[
i] & 0xffffff] != 0)
4101 = (r->VarOffset[
i] & 0xffffff) |
4102 (((r->VarOffset[
i] >> 24) - shifts[r->VarOffset[
i] & 0xffffff]) << 24);
4110 unsigned long divmask = 1;
4115 divmask |= (((
unsigned long) 1) << (
unsigned long)
i);
4130 const char *TYP[]={
"ro_dp",
"ro_wp",
"ro_am",
"ro_wp64",
"ro_wp_neg",
"ro_cp",
4131 "ro_syzcomp",
"ro_syz",
"ro_isTemp",
"ro_is",
"ro_none"};
4134 Print(
"ExpL_Size:%d ",r->ExpL_Size);
4135 Print(
"CmpL_Size:%d ",r->CmpL_Size);
4136 Print(
"VarL_Size:%d\n",r->VarL_Size);
4137 Print(
"bitmask=0x%lx (expbound=%ld) \n",r->bitmask, r->bitmask);
4138 Print(
"divmask=%lx\n", r->divmask);
4139 Print(
"BitsPerExp=%d ExpPerLong=%d at L[%d]\n", r->BitsPerExp, r->ExpPerLong, r->VarL_Offset[0]);
4141 Print(
"VarL_LowIndex: %d\n", r->VarL_LowIndex);
4142 PrintS(
"VarL_Offset:\n");
4145 for(
j = 0;
j < r->VarL_Size;
j++)
4146 Print(
" VarL_Offset[%d]: %d ",
j, r->VarL_Offset[
j]);
4153 for(
j=0;
j<=r->N;
j++)
4154 Print(
" v%d at e-pos %d, bit %d\n",
4155 j,r->VarOffset[
j] & 0xffffff, r->VarOffset[
j] >>24);
4157 for(
j=0;
j<r->CmpL_Size;
j++)
4158 Print(
" ordsgn %ld at pos %d\n",r->ordsgn[
j],
j);
4159 Print(
"OrdSgn:%d\n",r->OrdSgn);
4161 for(
j=0;
j<r->OrdSize;
j++)
4163 Print(
" typ %s", TYP[r->typ[
j].ord_typ]);
4164 if (r->typ[
j].ord_typ==
ro_syz)
4166 const short place = r->typ[
j].data.syz.place;
4167 const int limit = r->typ[
j].data.syz.limit;
4168 const int curr_index = r->typ[
j].data.syz.curr_index;
4169 const int* syz_index = r->typ[
j].data.syz.syz_index;
4171 Print(
" limit %d (place: %d, curr_index: %d), syz_index: ", limit, place, curr_index);
4173 if( syz_index ==
NULL )
4178 for(
i=0;
i <= limit;
i++ )
4179 Print(
"%d ", syz_index[
i]);
4186 Print(
" start (level) %d, suffixpos: %d, VO: ",r->typ[
j].data.isTemp.start, r->typ[
j].data.isTemp.suffixpos);
4189 else if (r->typ[
j].ord_typ==
ro_is)
4191 Print(
" start %d, end: %d: ",r->typ[
j].data.is.start, r->typ[
j].data.is.end);
4195 Print(
" limit %d",r->typ[
j].data.is.limit);
4202 else if (r->typ[
j].ord_typ==
ro_am)
4204 Print(
" place %d",r->typ[
j].data.am.place);
4205 Print(
" start %d",r->typ[
j].data.am.start);
4206 Print(
" end %d",r->typ[
j].data.am.end);
4207 Print(
" len_gen %d",r->typ[
j].data.am.len_gen);
4210 for(
l=r->typ[
j].data.am.start;l<=r->typ[
j].data.am.end;
l++)
4211 Print(
" %d",r->typ[
j].data.am.weights[
l-r->typ[
j].data.am.start]);
4212 l=r->typ[
j].data.am.end+1;
4213 int ll=r->typ[
j].data.am.weights[
l-r->typ[
j].data.am.start];
4215 for(
int lll=
l+1;lll<
l+ll+1;lll++)
4216 Print(
" %d",r->typ[
j].data.am.weights[lll-r->typ[
j].data.am.start]);
4220 Print(
" place %d",r->typ[
j].data.dp.place);
4224 Print(
" start %d",r->typ[
j].data.dp.start);
4225 Print(
" end %d",r->typ[
j].data.dp.end);
4226 if ((r->typ[
j].ord_typ==
ro_wp)
4230 for(
int l=r->typ[
j].data.wp.start;l<=r->typ[
j].data.wp.end;
l++)
4231 Print(
" %d",r->typ[
j].data.wp.weights[
l-r->typ[
j].data.wp.start]);
4233 else if (r->typ[
j].ord_typ==
ro_wp64)
4237 for(
l=r->typ[
j].data.wp64.start;l<=r->typ[
j].data.wp64.end;
l++)
4238 Print(
" %ld",(
long)(r->typ[
j].data.wp64.weights64+
l-r->typ[
j].data.wp64.start));
4244 Print(
"pOrdIndex:%d pCompIndex:%d\n", r->pOrdIndex, r->pCompIndex);
4245 Print(
"OrdSize:%d\n",r->OrdSize);
4246 PrintS(
"--------------------\n");
4247 for(
j=0;
j<r->ExpL_Size;
j++)
4250 if (j< r->CmpL_Size)
4251 Print(
"ordsgn %ld ", r->ordsgn[
j]);
4257 if( (r->VarOffset[
i] & 0xffffff) ==
j )
4258 {
Print(
"v%d at e[%d], bit %d; ",
i,r->VarOffset[
i] & 0xffffff,
4259 r->VarOffset[
i] >>24 ); }
4261 if( r->pCompIndex==
j )
PrintS(
"v0; ");
4262 for(
i=0;
i<r->OrdSize;
i++)
4264 if (r->typ[
i].data.dp.place ==
j)
4266 Print(
"ordrec:%s (start:%d, end:%d) ",TYP[r->typ[
i].ord_typ],
4267 r->typ[
i].data.dp.start, r->typ[
i].data.dp.end);
4271 if (
j==r->pOrdIndex)
4276 Print(
"LexOrder:%d, MixedOrder:%d\n",r->LexOrder, r->MixedOrder);
4278 Print(
"NegWeightL_Size: %d, NegWeightL_Offset: ", r->NegWeightL_Size);
4279 if (r->NegWeightL_Offset==
NULL)
PrintS(
" NULL");
4281 for(
j = 0;
j < r->NegWeightL_Size;
j++)
4282 Print(
" [%d]: %d ",
j, r->NegWeightL_Offset[
j]);
4293 Print(
"p_Spec : %s, %s, %s\n", field,
length, ord);
4295 for (
i=0;
i<(int) (
sizeof(
p_Procs_s)/
sizeof(
void*));
i++)
4297 Print(
" %s,\n", ((
char**) &proc_names)[
i]);
4303#define pFDeg_CASE(A) if(r->pFDeg == A) PrintS( "" #A "" )
4309 Print(
"(%p)", r->pFDeg);
4312 Print(
"pLDeg : (%p)", r->pLDeg);
4324 else Print(
"%p\n",r->p_Setm);
4334 Print(
"\nexp[0..%d]\n",r->ExpL_Size-1);
4335 for(
i=0;
i<r->ExpL_Size;
i++)
4343 if (
j==0) {
PrintS(
"...\n");
break; }
4352 Print(
"\nexp[0..%d]\n",
R->ExpL_Size - 1);
4353 for(
int i = 0;
i <
R->ExpL_Size;
i++)
4372 r->typ[1].data.syzcomp.Components = currComponents;
4380 *currComponents = r->typ[1].data.syzcomp.Components;
4390 r->typ[1].data.syzcomp.length =
length;
4400 *
length = r->typ[1].data.syzcomp.length;
4442 WarnS(
"rAssure_SyzComp: input ring has an IS-ordering!");
4453 int ** wvhdl =(
int **)
omAlloc0((
i+1)*
sizeof(
int**));
4456 res->order[
j]=r->order[
j-1];
4457 res->block0[
j]=r->block0[
j-1];
4458 res->block1[
j]=r->block1[
j-1];
4459 if (r->wvhdl[
j-1] !=
NULL)
4465 int l=r->block1[
j-1]-r->block0[
j-1]+1;
4470 l+=r->wvhdl[
j-1][r->block1[
j-1]-r->block0[
j-1]+1]+1;
4473 memcpy(wvhdl[
j],r->wvhdl[
j-1],
l*
sizeof(
int));
4491 WarnS(
"error in nc_rComplete");
4501 if (r->qideal!=
NULL)
4531 pos=r->VarL_LowIndex;
4536 for(
int i=r->OrdSize-1;
i>=0;
i--)
4538 if ((r->typ[
i].ord_typ==
ro_dp)
4539 && (r->typ[
i].data.dp.start==1)
4540 && (r->typ[
i].data.dp.end==r->N))
4542 pos=r->typ[
i].data.dp.place;
4561 res->ExpL_Size=r->ExpL_Size+1;
4565 for(
j=0;
j<r->CmpL_Size;
j++)
4567 res->ordsgn[
j] = r->ordsgn[
j];
4569 res->OrdSize=r->OrdSize+1;
4574 memcpy(
res->typ,r->typ,r->OrdSize*
sizeof(
sro_ord));
4578 res->typ[
res->OrdSize-1].data.dp.start=1;
4579 res->typ[
res->OrdSize-1].data.dp.end=
res->N;
4580 res->typ[
res->OrdSize-1].data.dp.place=
res->ExpL_Size-1;
4581 pos=
res->ExpL_Size-1;
4597 WarnS(
"error in nc_rComplete");
4603 if (r->qideal!=
NULL)
4633 if (r->order[
i] == 0)
4642 new_r->wvhdl=(
int **)
omAlloc0(
i *
sizeof(
int *));
4644 new_r->block0 = (
int *)
omAlloc0(
i *
sizeof(
int));
4645 new_r->block1 = (
int *)
omAlloc0(
i *
sizeof(
int));
4647 memcpy(new_r->block0,r->block0,(
i-1) *
sizeof(
int));
4648 memcpy(new_r->block1,r->block1,(
i-1) *
sizeof(
int));
4649 for (
int j=0;
j<=last_block;
j++)
4651 if (r->wvhdl[
j]!=
NULL)
4654 new_r->wvhdl[
j] = (
int*)
omMemDup(r->wvhdl[
j]);
4657 int l=r->block1[
j]-r->block0[
j]+1;
4662 l+=r->wvhdl[
j][r->block1[
j]-r->block0[
j]+1]+1;
4664 new_r->wvhdl[
j]=(
int*)
omalloc(
l*
sizeof(
int));
4665 memcpy(new_r->wvhdl[
j],r->wvhdl[
j],
l*
sizeof(
int));
4684 WarnS(
"error in nc_rComplete");
4696 int last_block =
rBlocks(r) - 2;
4703 for (
i=0;
i< last_block;
i++)
4714 for (
i=c_pos+1;
i<=last_block;
i++)
4716 new_r->order[
i-1] = new_r->order[
i];
4717 new_r->block0[
i-1] = new_r->block0[
i];
4718 new_r->block1[
i-1] = new_r->block1[
i];
4719 new_r->wvhdl[
i-1] = new_r->wvhdl[
i];
4721 new_r->order[last_block] = r->order[c_pos];
4722 new_r->block0[last_block] = r->block0[c_pos];
4723 new_r->block1[last_block] = r->block1[c_pos];
4724 new_r->wvhdl[last_block] = r->wvhdl[c_pos];
4735 WarnS(
"error in nc_rComplete");
4760 if (new_r_1 != new_r && new_r_1 != old_r)
rDelete(new_r_1);
4769 WarnS(
"error in nc_rComplete");
4776 if (old_r->qideal !=
NULL)
4778 new_r->qideal =
idrCopyR(old_r->qideal, old_r, new_r);
4786 WarnS(
"error in nc_SetupQuotient");
4811 if ((r_blocks == 3) &&
4812 (r->order[0] == b1) &&
4813 (r->order[1] == b2) &&
4826 res->block1[1] = r->N;
4831 res->block1[0] = r->N;
4841 WarnS(
"error in nc_rComplete");
4854 Print(
"rAssure_InducedSchreyerOrdering(r, complete = %d, sgn = %d): r: \n", complete,
sgn);
4871 int ** wvhdl =(
int **)
omAlloc0((n+2)*
sizeof(
int**));
4879 res->block0[
j] =
res->block1[
j] = 0;
4883 for(
int i = 0; (
i <= n) && (r->order[
i] != 0);
i++,
j++)
4885 res->order [
j] = r->order [
i];
4886 res->block0[
j] = r->block0[
i];
4887 res->block1[
j] = r->block1[
i];
4889 if (r->wvhdl[
i] !=
NULL)
4895 int l=(r->block1[
i]-r->block0[
i]+1);
4900 l+=r->wvhdl[
i][r->block1[
i]-r->block0[
i]+1]+1;
4903 memcpy(wvhdl[
j],r->wvhdl[
i],
l*
sizeof(
int));
4935 WarnS(
"error in nc_rComplete");
4947 if (r->qideal!=
NULL)
5004 Print(
"rIsIS(p: %d)\nF:",
p);
5015 for(
int pos = 0; pos < r->OrdSize; pos++ )
5016 if( r->typ[pos].ord_typ ==
ro_is)
5038 dReportError(
"Error: WRONG USE of rSetISReference: wrong ring! (typ == NULL)");
5047 dReportError(
"Error: WRONG USE of rSetISReference: specified ordering block was not found!!!" );
5052 if(
i != r->typ[pos].data.is.limit )
5053 Print(
"Changing record on pos: %d\nOld limit: %d --->> New Limit: %d\n", pos, r->typ[pos].data.is.limit,
i);
5056 const ideal FF =
idrHeadR(F, r, r);
5059 if( r->typ[pos].data.is.F !=
NULL)
5062 PrintS(
"Deleting old reference set F... \n");
5065 r->typ[pos].data.is.F =
NULL;
5070 r->typ[pos].data.is.F = FF;
5072 r->typ[pos].data.is.limit =
i;
5096 if ((r->typ!=
NULL) && (r->typ[0].ord_typ==
ro_syz))
5098 r->block0[0]=r->block1[0] =
k;
5099 if(
k == r->typ[0].data.syz.limit )
5103 if (r->typ[0].data.syz.limit == 0)
5105 r->typ[0].data.syz.syz_index = (
int*)
omAlloc0((
k+1)*
sizeof(int));
5106 r->typ[0].data.syz.syz_index[0] = 0;
5107 r->typ[0].data.syz.curr_index = 1;
5111 r->typ[0].data.syz.syz_index = (
int*)
5113 (r->typ[0].data.syz.limit+1)*
sizeof(int),
5116 for (
i=r->typ[0].data.syz.limit + 1;
i<=
k;
i++)
5118 r->typ[0].data.syz.syz_index[
i] =
5119 r->typ[0].data.syz.curr_index;
5121 if(k < r->typ[0].data.syz.limit)
5124 Warn(
"rSetSyzComp called with smaller limit (%d) as before (%d)",
k, r->typ[0].data.syz.limit);
5126 r->typ[0].data.syz.curr_index = 1 + r->typ[0].data.syz.syz_index[
k];
5130 r->typ[0].data.syz.limit =
k;
5131 r->typ[0].data.syz.curr_index++;
5140 Warn(
"rSetSyzComp(%d) in an IS ring! Be careful!",
k);
5145 r->block0[0] = r->block1[0] =
k;
5160 if ((r->typ!=
NULL) && (r->typ[0].ord_typ==
ro_syz) &&
5161 r->typ[0].data.syz.limit > 0 &&
i > 0)
5163 assume(i <= r->typ[0].data.syz.limit);
5165 for (
j=0;
j<r->typ[0].data.syz.limit;
j++)
5167 if (r->typ[0].data.syz.syz_index[
j] ==
i &&
5168 r->typ[0].data.syz.syz_index[
j+1] !=
i)
5170 assume(r->typ[0].data.syz.syz_index[
j+1] ==
i+1);
5174 return r->typ[0].data.syz.limit;
5179 WarnS(
"rGetMaxSyzComp: order c");
5194 if ((r->order[0]==
ringorder_dp) &&(r->block0[0]==1) &&(r->block1[0]==r->N))
5197 && ((r->order[1]==
ringorder_dp) &&(r->block0[1]==1) &&(r->block1[1]==r->N)))
5204 if ((r->order[0]==
ringorder_Dp) &&(r->block0[0]==1) &&(r->block1[0]==r->N))
5207 && ((r->order[1]==
ringorder_Dp) &&(r->block0[1]==1) &&(r->block1[1]==r->N)))
5214 if ((r->order[0]==
ringorder_lp) &&(r->block0[0]==1) &&(r->block1[0]==r->N))
5217 && ((r->order[1]==
ringorder_lp) &&(r->block0[1]==1) &&(r->block1[1]==r->N)))
5227 while((r->typ[
i].ord_typ!=
ro_wp64) && (r->typ[
i].ord_typ>0))
i++;
5229 return r->typ[
i].data.wp64.weights64;
5237 memcpy(r->typ[0].data.wp64.weights64,wv,r->N*
sizeof(
int64));
5248 for(
int k=
size;
k>pos;
k--) r->wvhdl[
k]=r->wvhdl[
k-1];
5254static int rReallocM1(ring r,
int size,
int pos)
5260 for(
int k=pos+1;
k<
size;
k++) r->wvhdl[
k]=r->wvhdl[
k+1];
5270 for(
int j=0;
j<=i2;
j++)
5278#define rOppVar(R,I) (rVar(R)+1-I)
5296 if (src->qideal !=
NULL)
5303 int i2 = (
rVar(r)-1)/2;
5304 for(
i=i2;
i>=0;
i--)
5310 p = r->names[
rVar(r)-1-
i];
5311 r->names[
rVar(r)-1-
i] = r->names[
i];
5329 char *
p=r->names[
i];
5330 if(isupper(*
p)) *
p = tolower(*
p);
5331 else *
p = toupper(*
p);
5382 for(
i=0; src->order[
i]!=0;
i++)
5384 switch (src->order[
i])
5389 r->order[
j]=src->order[
i];
5393 r->block0[
j]=
rOppVar(r, src->block1[
i]);
5394 r->block1[
j]=
rOppVar(r, src->block0[
i]);
5398 r->block0[
j]=
rOppVar(r, src->block1[
i]);
5399 r->block1[
j]=
rOppVar(r, src->block0[
i]);
5405 r->block0[
j]=
rOppVar(r, src->block1[
i]);
5406 r->block1[
j]=
rOppVar(r, src->block0[
i]);
5407 r->wvhdl[
j]=(
int*)
omAlloc((r->block1[
j]-r->block0[
j]+1)*
sizeof(int));
5408 for(
int k=r->block0[
j]; k<=r->block1[
j];
k++)
5409 r->wvhdl[
j][
k-r->block0[
j]]=1;
5412 r->block0[
j]=
rOppVar(r, src->block1[
i]);
5413 r->block1[
j]=
rOppVar(r, src->block0[
i]);
5421 r->block0[
j]=
rOppVar(r, src->block1[
i]);
5422 r->block1[
j]=
rOppVar(r, src->block0[
i]);
5423 r->wvhdl[
j]=(
int*)
omAlloc((r->block1[
j]-r->block0[
j]+1)*
sizeof(int));
5424 for(
int k=r->block0[
j]; k<=r->block1[
j];
k++)
5425 r->wvhdl[
j][
k-r->block0[
j]]=1;
5428 r->block0[
j]=
rOppVar(r, src->block1[
i]);
5429 r->block1[
j]=
rOppVar(r, src->block0[
i]);
5437 r->block0[
j]=
rOppVar(r, src->block1[
i]);
5438 r->block1[
j]=
rOppVar(r, src->block0[
i]);
5439 r->wvhdl[
j]=r->wvhdl[
j+1]; r->wvhdl[
j+1]=
NULL;
5443 r->block0[
j]=
rOppVar(r, src->block1[
i]);
5444 r->block1[
j]=
rOppVar(r, src->block0[
i]);
5452 r->block0[
j]=
rOppVar(r, src->block1[
i]);
5453 r->block1[
j]=
rOppVar(r, src->block0[
i]);
5454 r->wvhdl[
j]=r->wvhdl[
j+1]; r->wvhdl[
j+1]=
NULL;
5458 r->block0[
j]=
rOppVar(r, src->block1[
i]);
5459 r->block1[
j]=
rOppVar(r, src->block0[
i]);
5466 r->block0[
j]=
rOppVar(r, src->block1[
i]);
5467 r->block1[
j]=
rOppVar(r, src->block0[
i]);
5468 int n=r->block1[
j]-r->block0[
j];
5470 for (
int nn=0; nn<=n; nn++)
5479 r->block0[
j]=
rOppVar(r, src->block1[
i]);
5480 r->block1[
j]=
rOppVar(r, src->block0[
i]);
5522 for(
i=0; src->order[
i]!=0;
i++)
5524 switch (src->order[
i])
5529 r->order[
j]=src->order[
i];
5533 r->block0[
j]=
rOppVar(r, src->block1[
i]);
5534 r->block1[
j]=
rOppVar(r, src->block0[
i]);
5538 r->block0[
j]=
rOppVar(r, src->block1[
i]);
5539 r->block1[
j]=
rOppVar(r, src->block0[
i]);
5544 r->block0[
j]=
rOppVar(r, src->block1[
i]);
5545 r->block1[
j]=
rOppVar(r, src->block0[
i]);
5551 r->block0[
j]=
rOppVar(r, src->block1[
i]);
5552 r->block1[
j]=
rOppVar(r, src->block0[
i]);
5597 int *par_perm =
NULL;
5600 for(
i=1;
i<=r->N;
i++)
5616 MATELEM(C,nj,ni) =
p_PermPoly(
MATELEM(src->GetNC()->C,
i,
j),perm,src,r, nMap,par_perm,
rPar(src));
5619 MATELEM(
D,nj,ni) =
p_PermPoly(
MATELEM(src->GetNC()->D,
i,
j),perm,src,r, nMap,par_perm,
rPar(src));
5627 WarnS(
"Error initializing non-commutative multiplication!");
5635 assume( r->GetNC()->IsSkewConstant == src->GetNC()->IsSkewConstant);
5642 if (src->qideal !=
NULL)
5645 r->qideal =
idOppose(src, src->qideal, r);
5647 r->qideal =
id_Copy(src->qideal, r);
5677 int stat =
rSum(
R, Ropp, Renv);
5679 WarnS(
"Error in rEnvelope at rSum");
5702 const int N = dest->N;
5711 const ring srcBase = src;
5718 matrix C0 = src->GetNC()->C;
5719 matrix D0 = src->GetNC()->D;
5722 for (
int i = 1;
i <
N;
i++)
5724 for (
int j =
i + 1;
j <=
N;
j++)
5727 const poly
p =
p_NSet(n, dest);
5789 Werror(
"n_IsParam: IsParam is not to be used for (coeff_type = %d)",
getCoeffType(C));
5798 WerrorS(
"only for rings with an ordering of one block");
5815 WerrorS(
"ordering must be dp,Dp,lp,rp,ds,Ds or ls");
5818 for(
int i=r->N-1;
i>=0;
i--)
5820 if (strcmp(r->names[
i],
v)==0)
5822 Werror(
"duplicate variable name >>%s<<",
v);
5828 #ifdef HAVE_SHIFTBBA
5831 R->isLPring=r->isLPring+1;
5832 R->N=((r->N)/r->isLPring)+r->N;
5836 for(
int b=0;
b<((r->N)/r->isLPring);
b++)
5839 for(
int i=
R->isLPring-1;
i>0;
i--)
5840 names[
i+
b*
R->isLPring]=
R->names[
i-1+
b*r->isLPring];
5845 for(
int b=0;
b<((r->N)/r->isLPring);
b++)
5848 for(
int i=
R->isLPring-2;
i>=0;
i--)
5849 names[
i+
b*
R->isLPring]=
R->names[
i+
b*r->isLPring];
5861 for(
int i=
R->N-1;
i>0;
i--) names[
i]=
R->names[
i-1];
5866 for(
int i=
R->N-2;
i>=0;
i--) names[
i]=
R->names[
i];
5880 WerrorS(
"only for rings with an ordering of one block");
5897 WerrorS(
"ordering must be dp,Dp,lp,rp,ds,Ds or ls");
5904 if (strcmp(
R->names[
i],
v)==0)
5908 for(
int j=
i;
j<
R->N;
j++)
R->names[
j]=
R->names[
j+1];
int sgn(const Rational &a)
int naIsParam(number m, const coeffs cf)
if m == var(i)/1 => return i,
static int si_max(const int a, const int b)
const CanonicalForm CFMap CFMap & N
Coefficient rings, fields and other domains suitable for Singular polynomials.
static FORCE_INLINE number n_Copy(number n, const coeffs r)
return a copy of 'n'
static FORCE_INLINE void n_CoeffWrite(const coeffs r, BOOLEAN details=TRUE)
output the coeff description
static FORCE_INLINE BOOLEAN nCoeff_is_Extension(const coeffs r)
@ n_R
single prescision (6,6) real numbers
@ n_polyExt
used to represent polys as coeffcients
@ n_Q
rational (GMP) numbers
@ n_Znm
only used if HAVE_RINGS is defined
@ n_algExt
used for all algebraic extensions, i.e., the top-most extension in an extension tower is algebraic
@ n_Zn
only used if HAVE_RINGS is defined
@ n_transExt
used for all transcendental extensions, i.e., the top-most extension in an extension tower is transce...
static FORCE_INLINE char * nCoeffString(const coeffs cf)
TODO: make it a virtual method of coeffs, together with: Decompose & Compose, rParameter & rPar.
static FORCE_INLINE nMapFunc n_SetMap(const coeffs src, const coeffs dst)
set the mapping function pointers for translating numbers from src to dst
coeffs nInitChar(n_coeffType t, void *parameter)
one-time initialisations for new coeffs in case of an error return NULL
static FORCE_INLINE n_coeffType getCoeffType(const coeffs r)
Returns the type of coeffs domain.
static FORCE_INLINE coeffs nCopyCoeff(const coeffs r)
"copy" coeffs, i.e. increment ref
static FORCE_INLINE BOOLEAN nCoeff_is_algExt(const coeffs r)
TRUE iff r represents an algebraic extension field.
number(* nMapFunc)(number a, const coeffs src, const coeffs dst)
maps "a", which lives in src, into dst
void nKillChar(coeffs r)
undo all initialisations
static FORCE_INLINE BOOLEAN n_IsOne(number n, const coeffs r)
TRUE iff 'n' represents the one element.
const CanonicalForm int s
const Variable & v
< [in] a sqrfree bivariate poly
for(j=0;j< factors.length();j++)
static int min(int a, int b)
void WerrorS(const char *s)
if(!FE_OPT_NO_SHELL_FLAG)(void) system(sys)
ideal id_Copy(ideal h1, const ring r)
copy an ideal
static BOOLEAN length(leftv result, leftv arg)
static bool rIsSCA(const ring r)
ideal idOppose(ring Rop_src, ideal I, const ring Rop_dst)
opposes a module I from Rop to currRing(dst)
bool nc_rCopy(ring res, const ring r, bool bSetupQuotient)
bool nc_SetupQuotient(ring rGR, const ring rG=NULL, bool bCopy=false)
static nc_type & ncRingType(nc_struct *p)
BOOLEAN nc_CallPlural(matrix cc, matrix dd, poly cn, poly dn, ring r, bool bSetupQuotient, bool bCopyInput, bool bBeQuiet, ring curr, bool dummy_ring=false)
returns TRUE if there were errors analyze inputs, check them for consistency detects nc_type,...
void nc_rKill(ring r)
complete destructor
#define UPMATELEM(i, j, nVar)
bool sca_Force(ring rGR, int b, int e)
void maFindPerm(char const *const *const preim_names, int preim_n, char const *const *const preim_par, int preim_p, char const *const *const names, int n, char const *const *const par, int nop, int *perm, int *par_perm, n_coeffType ch)
void mp_Delete(matrix *a, const ring r)
matrix mpNew(int r, int c)
create a r x c zero-matrix
void iiWriteMatrix(matrix im, const char *n, int dim, const ring r, int spaces)
set spaces to zero by default
#define MATELEM(mat, i, j)
1-based access to matrix
STATIC_VAR unsigned add[]
int dReportError(const char *fmt,...)
gmp_float sqrt(const gmp_float &a)
The main handler for Singular numbers which are suitable for Singular polynomials.
#define omFreeSize(addr, size)
#define omCheckAddr(addr)
#define omReallocSize(addr, o_size, size)
#define omCheckAddrSize(addr, size)
#define omFreeBin(addr, bin)
#define omcheckAddrSize(addr, size)
#define omfreeSize(addr, size)
#define omGetSpecBin(size)
#define omUnGetSpecBin(bin_ptr)
void p_ProcsSet(ring r, p_Procs_s *p_Procs)
void p_Debug_GetProcNames(const ring r, p_Procs_s *p_Procs)
void p_Debug_GetSpecNames(const ring r, const char *&field, const char *&length, const char *&ord)
void p_Setm_WFirstTotalDegree(poly p, const ring r)
long pLDegb(poly p, int *l, const ring r)
long pLDeg1_Totaldegree(poly p, int *l, const ring r)
long p_WFirstTotalDegree(poly p, const ring r)
long pLDeg1_WFirstTotalDegree(poly p, int *l, const ring r)
long pLDeg1c_WFirstTotalDegree(poly p, int *l, const ring r)
void p_Setm_Dummy(poly p, const ring r)
void p_Setm_TotalDegree(poly p, const ring r)
poly p_ISet(long i, const ring r)
returns the poly representing the integer i
long pLDeg1c_Deg(poly p, int *l, const ring r)
long pLDeg1(poly p, int *l, const ring r)
poly p_PermPoly(poly p, const int *perm, const ring oldRing, const ring dst, nMapFunc nMap, const int *par_perm, int OldPar, BOOLEAN use_mult)
long pLDeg1_Deg(poly p, int *l, const ring r)
long p_WTotaldegree(poly p, const ring r)
p_SetmProc p_GetSetmProc(const ring r)
void p_Setm_General(poly p, const ring r)
long pLDeg1c(poly p, int *l, const ring r)
long pLDeg1c_Totaldegree(poly p, int *l, const ring r)
long pLDeg0c(poly p, int *l, const ring r)
long pLDeg0(poly p, int *l, const ring r)
poly p_NSet(number n, const ring r)
returns the poly representing the number n, destroys n
long p_Deg(poly a, const ring r)
BOOLEAN p_EqualPolys(poly p1, poly p2, const ring r)
static long p_FDeg(const poly p, const ring r)
void p_Write(poly p, ring lmRing, ring tailRing)
static unsigned long p_SetExp(poly p, const unsigned long e, const unsigned long iBitmask, const int VarOffset)
set a single variable exponent @Note: VarOffset encodes the position in p->exp
static void p_Setm(poly p, const ring r)
static long p_GetExp(const poly p, const unsigned long iBitmask, const int VarOffset)
get a single variable exponent @Note: the integer VarOffset encodes:
static void p_Delete(poly *p, const ring r)
void p_Write0(poly p, ring lmRing, ring tailRing)
static long p_Totaldegree(poly p, const ring r)
poly prCopyR(poly p, ring src_r, ring dest_r)
ideal idrCopyR(ideal id, ring src_r, ring dest_r)
ideal idrCopyR_NoSort(ideal id, ring src_r, ring dest_r)
ideal idrHeadR(ideal id, ring r, ring dest_r)
Copy leading terms of id[i] via prHeeadR into dest_r.
void StringSetS(const char *st)
void StringAppendS(const char *st)
void PrintS(const char *s)
void Werror(const char *fmt,...)
static void rSetNegWeight(ring r)
BOOLEAN rOrd_SetCompRequiresSetm(const ring r)
return TRUE if p_SetComp requires p_Setm
static void rO_ISSuffix(int &place, int &bitplace, int &prev_ord, long *o, int N, int *v, sro_ord *tmp_typ, int &typ_i, int sgn)
int rSum(ring r1, ring r2, ring &sum)
ring rAssure_TDeg(ring r, int &pos)
void rWrite(ring r, BOOLEAN details)
ring rAssure_InducedSchreyerOrdering(const ring r, BOOLEAN complete, int sgn)
static ring rAssure_Global(rRingOrder_t b1, rRingOrder_t b2, const ring r)
BOOLEAN rOrder_is_WeightedOrdering(rRingOrder_t order)
void rGetSComps(int **currComponents, long **currShiftedComponents, int *length, ring r)
BOOLEAN rRing_ord_pure_Dp(const ring r)
static void rNChangeSComps(int *currComponents, long *currShiftedComponents, ring r)
ring rModifyRing_Wp(ring r, int *weights)
construct Wp, C ring
BOOLEAN rOrder_is_DegOrdering(const rRingOrder_t order)
BOOLEAN rHasSimpleOrderAA(ring r)
void rSetWeightVec(ring r, int64 *wv)
static void rSetOption(ring r)
BOOLEAN rComplete(ring r, int force)
this needs to be called whenever a new ring is created: new fields in ring are created (like VarOffse...
int r_IsRingVar(const char *n, char **names, int N)
int rGetISPos(const int p, const ring r)
Finds p^th IS ordering, and returns its position in r->typ[] returns -1 if something went wrong!...
static void rNGetSComps(int **currComponents, long **currShiftedComponents, ring r)
static void rO_WDegree64(int &place, int &bitplace, int start, int end, long *o, sro_ord &ord_struct, int64 *weights)
BOOLEAN rHasSimpleLexOrder(const ring r)
returns TRUE, if simple lp or ls ordering
void p_SetGlobals(const ring r, BOOLEAN complete)
set all properties of a new ring - also called by rComplete
ring rAssure_SyzComp(const ring r, BOOLEAN complete)
BOOLEAN nc_rComplete(const ring src, ring dest, bool bSetupQuotient)
void p_DebugPrint(poly p, const ring r)
void rKillModifiedRing(ring r)
BOOLEAN rRing_ord_pure_dp(const ring r)
static void rSetVarL(ring r)
set r->VarL_Size, r->VarL_Offset, r->VarL_LowIndex
static void rO_LexVars(int &place, int &bitplace, int start, int end, int &prev_ord, long *o, int *v, int bits, int opt_var)
const char * rSimpleOrdStr(int ord)
BOOLEAN rOrd_is_MixedDegree_Ordering(ring r)
static void rDBChangeSComps(int *currComponents, long *currShiftedComponents, int length, ring r)
ring rAssure_c_dp(const ring r)
static void rSetOutParams(ring r)
static void rSetDegStuff(ring r)
static void rDBGetSComps(int **currComponents, long **currShiftedComponents, int *length, ring r)
rOrderType_t rGetOrderType(ring r)
int rTypeOfMatrixOrder(const intvec *order)
ring nc_rCreateNCcomm_rCopy(ring r)
static void rOppWeight(int *w, int l)
static void rO_WDegree_neg(int &place, int &bitplace, int start, int end, long *o, sro_ord &ord_struct, int *weights)
void rKillModified_Wp_Ring(ring r)
ring rMinusVar(const ring r, char *v)
undo rPlusVar
BOOLEAN rRing_has_CompLastBlock(const ring r)
ring rCopy0AndAddA(const ring r, int64vec *wv64, BOOLEAN copy_qideal, BOOLEAN copy_ordering)
static void rO_Syzcomp(int &place, int &bitplace, int &prev_ord, long *o, sro_ord &ord_struct)
BOOLEAN rOrd_is_Totaldegree_Ordering(const ring r)
ring rModifyRing(ring r, BOOLEAN omit_degree, BOOLEAN try_omit_comp, unsigned long exp_limit)
ring rAssure_SyzOrder(const ring r, BOOLEAN complete)
static void rO_TDegree(int &place, int &bitplace, int start, int end, long *o, sro_ord &ord_struct)
ring rAssure_C_dp(const ring r)
BOOLEAN rHasSimpleOrder(const ring r)
int rGetMaxSyzComp(int i, const ring r)
return the max-comonent wchich has syzIndex i Assume: i<= syzIndex_limit
BOOLEAN rSetISReference(const ring r, const ideal F, const int i, const int p)
Changes r by setting induced ordering parameters: limit and reference leading terms F belong to r,...
ring rAssure_HasComp(const ring r)
ring rCopy0(const ring r, BOOLEAN copy_qideal, BOOLEAN copy_ordering)
static void rO_WMDegree(int &place, int &bitplace, int start, int end, long *o, sro_ord &ord_struct, int *weights)
static void rO_Syz(int &place, int &bitplace, int &prev_ord, int syz_comp, long *o, sro_ord &ord_struct)
BOOLEAN rHas_c_Ordering(const ring r)
static int rRealloc1(ring r, int size, int pos)
static unsigned long rGetExpSize(unsigned long bitmask, int &bits)
void rDebugPrint(const ring r)
static void rCheckOrdSgn(ring r, int i)
BOOLEAN rRing_ord_pure_lp(const ring r)
poly rGetVar(const int varIndex, const ring r)
ring rModifyRing_Simple(ring r, BOOLEAN ommit_degree, BOOLEAN ommit_comp, unsigned long exp_limit, BOOLEAN &simple)
void rChangeSComps(int *currComponents, long *currShiftedComponents, int length, ring r)
static void m_DebugPrint(const poly p, const ring R)
debug-print monomial poly/vector p, assuming that it lives in the ring R
static unsigned long rGetDivMask(int bits)
get r->divmask depending on bits per exponent
BOOLEAN rSamePolyRep(ring r1, ring r2)
returns TRUE, if r1 and r2 represents the monomials in the same way FALSE, otherwise this is an analo...
ring rAssure_SyzComp_CompLastBlock(const ring r)
makes sure that c/C ordering is last ordering and SyzIndex is first
char * rCharStr(const ring r)
TODO: make it a virtual method of coeffs, together with: Decompose & Compose, rParameter & rPar.
static void rOptimizeLDeg(ring r)
BOOLEAN rCheckIV(const intvec *iv)
rRingOrder_t rOrderName(char *ordername)
void rDelete(ring r)
unconditionally deletes fields in r
ring rDefault(const coeffs cf, int N, char **n, int ord_size, rRingOrder_t *ord, int *block0, int *block1, int **wvhdl, unsigned long bitmask)
static void rRightAdjustVarOffset(ring r)
right-adjust r->VarOffset
ring rPlusVar(const ring r, char *v, int left)
K[x],"y" -> K[x,y] resp. K[y,x].
ring rAssure_CompLastBlock(ring r, BOOLEAN complete)
makes sure that c/C ordering is last ordering
static void rO_ISPrefix(int &place, int &bitplace, int &prev_ord, long *o, int N, int *v, sro_ord &ord_struct)
static void rO_Align(int &place, int &bitplace)
ring rAssure_dp_S(const ring r)
static void rO_TDegree_neg(int &place, int &bitplace, int start, int end, long *o, sro_ord &ord_struct)
static void rSetFirstWv(ring r, int i, rRingOrder_t *order, int *block0, int *block1, int **wvhdl)
BOOLEAN rEqual(ring r1, ring r2, BOOLEAN qr)
returns TRUE, if r1 equals r2 FALSE, otherwise Equality is determined componentwise,...
int rSumInternal(ring r1, ring r2, ring &sum, BOOLEAN vartest, BOOLEAN dp_dp)
returns -1 for not compatible, 1 for compatible (and sum) dp_dp:0: block ordering,...
void rSetSyzComp(int k, const ring r)
static const char *const ringorder_name[]
static void rO_WDegree(int &place, int &bitplace, int start, int end, long *o, sro_ord &ord_struct, int *weights)
BOOLEAN rOrd_is_WeightedDegree_Ordering(const ring r)
int n_IsParam(const number m, const ring r)
TODO: rewrite somehow...
int64 * rGetWeightVec(const ring r)
static void rO_LexVars_neg(int &place, int &bitplace, int start, int end, int &prev_ord, long *o, int *v, int bits, int opt_var)
ring rAssure_dp_C(const ring r)
BOOLEAN rDBTest(ring r, const char *fn, const int l)
struct p_Procs_s p_Procs_s
static BOOLEAN rIsPluralRing(const ring r)
we must always have this test!
static int rBlocks(const ring r)
static ring rIncRefCnt(ring r)
static int rPar(const ring r)
(r->cf->P)
static BOOLEAN rIsLPRing(const ring r)
@ ringorder_a64
for int64 weights
@ ringorder_rs
opposite of ls
@ ringorder_aa
for idElimination, like a, except pFDeg, pWeigths ignore it
@ ringorder_IS
Induced (Schreyer) ordering.
static BOOLEAN rField_is_Q(const ring r)
static BOOLEAN rShortOut(const ring r)
@ rOrderType_CompExp
simple ordering, component has priority
@ rOrderType_Exp
simple ordering, exponent vector has priority component is compatible with exp-vector order
@ rOrderType_General
non-simple ordering as specified by currRing
@ rOrderType_ExpComp
simple ordering, exponent vector has priority component not compatible with exp-vector order
static BOOLEAN rIsNCRing(const ring r)
static char const ** rParameter(const ring r)
(r->cf->parameter)
static BOOLEAN rCanShortOut(const ring r)
static short rVar(const ring r)
#define rVar(r) (r->N)
#define rField_is_Ring(R)
ideal SCAQuotient(const ring r)
static short scaLastAltVar(ring r)
static short scaFirstAltVar(ring r)
ideal idInit(int idsize, int rank)
initialise an ideal / module
void id_Delete(ideal *h, ring r)
deletes an ideal/module/matrix
long id_RankFreeModule(ideal s, ring lmRing, ring tailRing)
return the maximal component number found in any polynomial in s
void idShow(const ideal id, const ring lmRing, const ring tailRing, const int debugPrint)
ideal id_SimpleAdd(ideal h1, ideal h2, const ring R)
concat the lists h1 and h2 without zeros
EXTERN_VAR long * currShiftedComponents
int ntIsParam(number m, const coeffs cf)
if m == var(i)/1 => return i,