My Project
ring.cc
Go to the documentation of this file.
1 /****************************************
2 * Computer Algebra System SINGULAR *
3 ****************************************/
4 /*
5 * ABSTRACT - the interpreter related ring operations
6 */
7 
8 /* includes */
9 #include <cmath>
10 
11 #include "misc/auxiliary.h"
12 #include "misc/mylimits.h"
13 #include "misc/options.h"
14 #include "misc/int64vec.h"
15 
16 #include "coeffs/numbers.h"
17 #include "coeffs/coeffs.h"
18 
20 #include "polys/simpleideals.h"
21 #include "polys/monomials/ring.h"
22 #include "polys/monomials/maps.h"
23 #include "polys/prCopy.h"
25 
26 #include "polys/matpol.h"
27 
28 #include "polys/monomials/ring.h"
29 
30 #ifdef HAVE_PLURAL
31 #include "polys/nc/nc.h"
32 #include "polys/nc/sca.h"
33 #endif
34 
35 
36 #include "ext_fields/algext.h"
37 #include "ext_fields/transext.h"
38 
39 
40 #define BITS_PER_LONG 8*SIZEOF_LONG
41 
42 typedef char * char_ptr;
45 
46 
47 static const char * const ringorder_name[] =
48 {
49  " ?", ///< ringorder_no = 0,
50  "a", ///< ringorder_a,
51  "A", ///< ringorder_a64,
52  "c", ///< ringorder_c,
53  "C", ///< ringorder_C,
54  "M", ///< ringorder_M,
55  "S", ///< ringorder_S,
56  "s", ///< ringorder_s,
57  "lp", ///< ringorder_lp,
58  "dp", ///< ringorder_dp,
59  "rp", ///< ringorder_rp,
60  "Dp", ///< ringorder_Dp,
61  "wp", ///< ringorder_wp,
62  "Wp", ///< ringorder_Wp,
63  "ls", ///< ringorder_ls,
64  "ds", ///< ringorder_ds,
65  "Ds", ///< ringorder_Ds,
66  "ws", ///< ringorder_ws,
67  "Ws", ///< ringorder_Ws,
68  "am", ///< ringorder_am,
69  "L", ///< ringorder_L,
70  "aa", ///< ringorder_aa
71  "rs", ///< ringorder_rs,
72  "IS", ///< ringorder_IS
73  " _" ///< ringorder_unspec
74 };
75 
76 
77 const char * rSimpleOrdStr(int ord)
78 {
79  return ringorder_name[ord];
80 }
81 
82 /// unconditionally deletes fields in r
83 void rDelete(ring r);
84 /// set r->VarL_Size, r->VarL_Offset, r->VarL_LowIndex
85 static void rSetVarL(ring r);
86 /// get r->divmask depending on bits per exponent
87 static unsigned long rGetDivMask(int bits);
88 /// right-adjust r->VarOffset
89 static void rRightAdjustVarOffset(ring r);
90 static void rOptimizeLDeg(ring r);
91 
92 /*0 implementation*/
93 //BOOLEAN rField_is_R(ring r)
94 //{
95 // if (r->cf->ch== -1)
96 // {
97 // if (r->float_len==(short)0) return TRUE;
98 // }
99 // return FALSE;
100 //}
101 
102 ring rDefault(const coeffs cf, int N, char **n,int ord_size, rRingOrder_t *ord, int *block0, int *block1, int** wvhdl, unsigned long bitmask)
103 {
104  assume( cf != NULL);
105  ring r=(ring) omAlloc0Bin(sip_sring_bin);
106  r->N = N;
107  r->cf = cf;
108  /*rPar(r) = 0; Alloc0 */
109  /*names*/
110  r->names = (char **) omAlloc0(N * sizeof(char *));
111  int i;
112  for(i=0;i<N;i++)
113  {
114  r->names[i] = omStrDup(n[i]);
115  }
116  /*weights: entries for 2 blocks: NULL*/
117  if (wvhdl==NULL)
118  r->wvhdl = (int **)omAlloc0((ord_size+1) * sizeof(int *));
119  else
120  r->wvhdl=wvhdl;
121  r->order = ord;
122  r->block0 = block0;
123  r->block1 = block1;
124  if (bitmask!=0) r->wanted_maxExp=bitmask;
125 
126  /* complete ring intializations */
127  rComplete(r);
128  return r;
129 }
130 ring rDefault(int ch, int N, char **n,int ord_size, rRingOrder_t *ord, int *block0, int *block1,int ** wvhdl)
131 {
132  coeffs cf;
133  if (ch==0) cf=nInitChar(n_Q,NULL);
134  else cf=nInitChar(n_Zp,(void*)(long)ch);
135  assume( cf != NULL);
136  return rDefault(cf,N,n,ord_size,ord,block0,block1,wvhdl);
137 }
138 ring rDefault(const coeffs cf, int N, char **n, const rRingOrder_t o)
139 {
140  assume( cf != NULL);
141  /*order: o=lp,0*/
142  rRingOrder_t *order = (rRingOrder_t *) omAlloc(2* sizeof(rRingOrder_t));
143  int *block0 = (int *)omAlloc0(2 * sizeof(int));
144  int *block1 = (int *)omAlloc0(2 * sizeof(int));
145  /* ringorder o=lp for the first block: var 1..N */
146  order[0] = o;
147  block0[0] = 1;
148  block1[0] = N;
149  /* the last block: everything is 0 */
150  order[1] = (rRingOrder_t)0;
151 
152  return rDefault(cf,N,n,2,order,block0,block1);
153 }
154 
155 ring rDefault(int ch, int N, char **n)
156 {
157  coeffs cf;
158  if (ch==0) cf=nInitChar(n_Q,NULL);
159  else cf=nInitChar(n_Zp,(void*)(long)ch);
160  assume( cf != NULL);
161  return rDefault(cf,N,n);
162 }
163 
164 ///////////////////////////////////////////////////////////////////////////
165 //
166 // rInit: define a new ring from sleftv's
167 //
168 //-> ipshell.cc
169 
170 /////////////////////////////
171 // Auxillary functions
172 //
173 
174 // check intvec, describing the ordering
176 {
177  if ((iv->length()!=2)&&(iv->length()!=3))
178  {
179  WerrorS("weights only for orderings wp,ws,Wp,Ws,a,M");
180  return TRUE;
181  }
182  return FALSE;
183 }
184 
185 int rTypeOfMatrixOrder(const intvec* order)
186 {
187  int i=0,j,typ=1;
188  int sz = (int)sqrt((double)(order->length()-2));
189  if ((sz*sz)!=(order->length()-2))
190  {
191  WerrorS("Matrix order is not a square matrix");
192  typ=0;
193  }
194  while ((i<sz) && (typ==1))
195  {
196  j=0;
197  while ((j<sz) && ((*order)[j*sz+i+2]==0)) j++;
198  if (j>=sz)
199  {
200  typ = 0;
201  WerrorS("Matrix order not complete");
202  }
203  else if ((*order)[j*sz+i+2]<0)
204  typ = -1;
205  else
206  i++;
207  }
208  return typ;
209 }
210 
211 
212 int r_IsRingVar(const char *n, char**names,int N)
213 {
214  if (names!=NULL)
215  {
216  for (int i=0; i<N; i++)
217  {
218  if (names[i]==NULL) return -1;
219  if (strcmp(n,names[i]) == 0) return (int)i;
220  }
221  }
222  return -1;
223 }
224 
225 
226 void rWrite(ring r, BOOLEAN details)
227 {
228  if ((r==NULL)||(r->order==NULL))
229  return; /*to avoid printing after errors....*/
230 
231  assume(r != NULL);
232  const coeffs C = r->cf;
233  assume(C != NULL);
234 
235  int nblocks=rBlocks(r);
236 
237  // omCheckAddrSize(r,sizeof(ip_sring));
238  omCheckAddrSize(r->order,nblocks*sizeof(int));
239  omCheckAddrSize(r->block0,nblocks*sizeof(int));
240  omCheckAddrSize(r->block1,nblocks*sizeof(int));
241  omCheckAddrSize(r->wvhdl,nblocks*sizeof(int *));
242  omCheckAddrSize(r->names,r->N*sizeof(char *));
243 
244  nblocks--;
245 
246 
247  //Print("ref:%d, C->ref:%d\n",r->ref,C->ref);
248  PrintS("// coefficients: ");
249  if( nCoeff_is_algExt(C) )
250  {
251  // NOTE: the following (non-thread-safe!) UGLYNESS
252  // (changing naRing->ShortOut for a while) is due to Hans!
253  // Just think of other ring using the VERY SAME naRing and possible
254  // side-effects...
255  ring R = C->extRing;
256  const BOOLEAN bSaveShortOut = rShortOut(R); R->ShortOut = rShortOut(r) & rCanShortOut(R);
257 
258  n_CoeffWrite(C, details); // for correct printing of minpoly... WHAT AN UGLYNESS!!!
259 
260  R->ShortOut = bSaveShortOut;
261  }
262  else
263  n_CoeffWrite(C, details);
264  PrintLn();
265 // {
266 // PrintS("// characteristic : ");
267 //
268 // char const * const * const params = rParameter(r);
269 //
270 // if (params!=NULL)
271 // {
272 // Print ("// %d parameter : ",rPar(r));
273 //
274 // char const * const * sp= params;
275 // int nop=0;
276 // while (nop<rPar(r))
277 // {
278 // PrintS(*sp);
279 // PrintS(" ");
280 // sp++; nop++;
281 // }
282 // PrintS("\n// minpoly : ");
283 // if ( rField_is_long_C(r) )
284 // {
285 // // i^2+1:
286 // Print("(%s^2+1)\n", params[0]);
287 // }
288 // else if (rMinpolyIsNULL(r))
289 // {
290 // PrintS("0\n");
291 // }
292 // else
293 // {
294 // StringSetS(""); n_Write(r->cf->minpoly, r); PrintS(StringEndS("\n")); // NOTE/TODO: use StringAppendS("\n"); omFree(s);
295 // }
296 // //if (r->qideal!=NULL)
297 // //{
298 // // iiWriteMatrix((matrix)r->qideal,"// minpolys",1,r,0);
299 // // PrintLn();
300 // //}
301 // }
302 // }
303  Print("// number of vars : %d",r->N);
304 
305  //for (nblocks=0; r->order[nblocks]; nblocks++);
306  nblocks=rBlocks(r)-1;
307 
308  for (int l=0, nlen=0 ; l<nblocks; l++)
309  {
310  int i;
311  Print("\n// block %3d : ",l+1);
312 
313  Print("ordering %s", rSimpleOrdStr(r->order[l]));
314 
315 
316  if (r->order[l] == ringorder_IS)
317  {
318  assume( r->block0[l] == r->block1[l] );
319  const int s = r->block0[l];
320  assume( (-2 < s) && (s < 2) );
321  Print("(%d)", s); // 0 => prefix! +/-1 => suffix!
322  continue;
323  }
324  else if (r->order[l]==ringorder_s)
325  {
326  assume( l == 0 );
327  Print(" syz_comp: %d",r->block0[l]);
328  continue;
329  }
330  else if (
331  ( (r->order[l] >= ringorder_lp)
332  ||(r->order[l] == ringorder_M)
333  ||(r->order[l] == ringorder_a)
334  ||(r->order[l] == ringorder_am)
335  ||(r->order[l] == ringorder_a64)
336  ||(r->order[l] == ringorder_aa) ) && (r->order[l] < ringorder_IS) )
337  {
338  PrintS("\n// : names ");
339  for (i = r->block0[l]-1; i<r->block1[l]; i++)
340  {
341  nlen = strlen(r->names[i]);
342  Print(" %s",r->names[i]);
343  }
344  }
345 
346  if (r->wvhdl[l]!=NULL)
347  {
348  #ifndef SING_NDEBUG
349  if((r->order[l] != ringorder_wp)
350  &&(r->order[l] != ringorder_Wp)
351  &&(r->order[l] != ringorder_ws)
352  &&(r->order[l] != ringorder_Ws)
353  &&(r->order[l] != ringorder_a)
354  &&(r->order[l] != ringorder_a64)
355  &&(r->order[l] != ringorder_am)
356  &&(r->order[l] != ringorder_M))
357  {
358  Warn("should not have wvhdl entry at pos. %d",l);
359  }
360  #endif
361  for (int j= 0;
362  j<(r->block1[l]-r->block0[l]+1)*(r->block1[l]-r->block0[l]+1);
363  j+=i)
364  {
365  PrintS("\n// : weights ");
366  for (i = 0; i<=r->block1[l]-r->block0[l]; i++)
367  {
368  if (r->order[l] == ringorder_a64)
369  {
370  int64 *w=(int64 *)r->wvhdl[l];
371  #if SIZEOF_LONG == 4
372  Print("%*lld " ,nlen,w[i+j]);
373  #else
374  Print(" %*ld" ,nlen,w[i+j]);
375  #endif
376  }
377  else
378  Print(" %*d" ,nlen,r->wvhdl[l][i+j]);
379  }
380  if (r->order[l]!=ringorder_M) break;
381  }
382  if (r->order[l]==ringorder_am)
383  {
384  int m=r->wvhdl[l][i];
385  Print("\n// : %d module weights ",m);
386  m+=i;i++;
387  for(;i<=m;i++) Print(" %*d" ,nlen,r->wvhdl[l][i]);
388  }
389  }
390  }
391 #ifdef HAVE_PLURAL
392  if(rIsPluralRing(r))
393  {
394  PrintS("\n// noncommutative relations:");
395  if( details )
396  {
397  poly pl=NULL;
398  int nl;
399  int i,j;
400  for (i = 1; i<r->N; i++)
401  {
402  for (j = i+1; j<=r->N; j++)
403  {
404  nl = n_IsOne(p_GetCoeff(MATELEM(r->GetNC()->C,i,j),r), r->cf);
405  if ( (MATELEM(r->GetNC()->D,i,j)!=NULL) || (!nl) )
406  {
407  Print("\n// %s%s=",r->names[j-1],r->names[i-1]);
408  pl = MATELEM(r->GetNC()->MT[UPMATELEM(i,j,r->N)],1,1);
409  p_Write0(pl, r, r);
410  }
411  }
412  }
413  } else
414  PrintS(" ...");
415 
416 #if MYTEST /*Singularg should not differ from Singular except in error case*/
417  Print("\n// noncommutative type:%d", (int)ncRingType(r));
418  Print("\n// is skew constant:%d",r->GetNC()->IsSkewConstant);
419  if( rIsSCA(r) )
420  {
421  Print("\n// alternating variables: [%d, %d]", scaFirstAltVar(r), scaLastAltVar(r));
422  const ideal Q = SCAQuotient(r); // resides within r!
423  PrintS("\n// quotient of sca by ideal");
424 
425  if (Q!=NULL)
426  {
427  iiWriteMatrix((matrix)Q,"scaQ",1,r,0);
428  }
429  else
430  PrintS(" (NULL)");
431  }
432 #endif
433  }
434  if (rIsLPRing(r))
435  {
436  Print("\n// letterplace ring (block size %d, ncgen count %d)",r->isLPring, r->LPncGenCount);
437  }
438 #endif
439  if (r->qideal!=NULL)
440  {
441  PrintS("\n// quotient ring from ideal");
442  if( details )
443  {
444  PrintLn();
445  iiWriteMatrix((matrix)r->qideal,"_",1,r,0);
446  } else PrintS(" ...");
447  }
448 }
449 
450 void rDelete(ring r)
451 {
452  int i, j;
453 
454  if (r == NULL) return;
455  if( r->ref > 0 ) // ->ref means the number of Interpreter objects referring to the ring...
456  return;
457 
458  if( r->qideal != NULL )
459  {
460  ideal q = r->qideal;
461  r->qideal = NULL;
462  id_Delete(&q, r);
463  }
464 
465 #ifdef HAVE_PLURAL
466  if (rIsPluralRing(r))
467  nc_rKill(r);
468 #endif
469 
470  rUnComplete(r); // may need r->cf for p_Delete
471  nKillChar(r->cf); r->cf = NULL;
472  // delete order stuff
473  if (r->order != NULL)
474  {
475  i=rBlocks(r);
476  assume(r->block0 != NULL && r->block1 != NULL && r->wvhdl != NULL);
477  // delete order
478  omFreeSize((ADDRESS)r->order,i*sizeof(rRingOrder_t));
479  omFreeSize((ADDRESS)r->block0,i*sizeof(int));
480  omFreeSize((ADDRESS)r->block1,i*sizeof(int));
481  // delete weights
482  for (j=0; j<i; j++)
483  {
484  if (r->wvhdl[j]!=NULL)
485  omFree(r->wvhdl[j]);
486  }
487  omFreeSize((ADDRESS)r->wvhdl,i*sizeof(int *));
488  }
489  else
490  {
491  assume(r->block0 == NULL && r->block1 == NULL && r->wvhdl == NULL);
492  }
493 
494  // delete varnames
495  if(r->names!=NULL)
496  {
497  for (i=0; i<r->N; i++)
498  {
499  if (r->names[i] != NULL) omFree((ADDRESS)r->names[i]);
500  }
501  omFreeSize((ADDRESS)r->names,r->N*sizeof(char *));
502  }
503 
505 }
506 
507 rRingOrder_t rOrderName(char * ordername)
508 {
509  int order=ringorder_unspec;
510  while (order!= 0)
511  {
512  if (strcmp(ordername,rSimpleOrdStr(order))==0)
513  break;
514  order--;
515  }
516  if (order==0) Werror("wrong ring order `%s`",ordername);
517  omFree((ADDRESS)ordername);
518  return (rRingOrder_t)order;
519 }
520 
521 char * rOrdStr(ring r)
522 {
523  if ((r==NULL)||(r->order==NULL)) return omStrDup("");
524  int nblocks,l,i;
525 
526  for (nblocks=0; r->order[nblocks]; nblocks++);
527  nblocks--;
528 
529  StringSetS("");
530  for (l=0; ; l++)
531  {
532  StringAppendS((char *)rSimpleOrdStr(r->order[l]));
533  if (r->order[l] == ringorder_s)
534  {
535  StringAppend("(%d)",r->block0[l]);
536  }
537  else if (
538  (r->order[l] != ringorder_c)
539  && (r->order[l] != ringorder_C)
540  && (r->order[l] != ringorder_s)
541  && (r->order[l] != ringorder_S)
542  && (r->order[l] != ringorder_IS)
543  )
544  {
545  if (r->wvhdl[l]!=NULL)
546  {
547  #ifndef SING_NDEBUG
548  if((r->order[l] != ringorder_wp)
549  &&(r->order[l] != ringorder_Wp)
550  &&(r->order[l] != ringorder_ws)
551  &&(r->order[l] != ringorder_Ws)
552  &&(r->order[l] != ringorder_a)
553  &&(r->order[l] != ringorder_a64)
554  &&(r->order[l] != ringorder_am)
555  &&(r->order[l] != ringorder_M))
556  {
557  Warn("should not have wvhdl entry at pos. %d",l);
558  StringAppend("(%d)",r->block1[l]-r->block0[l]+1);
559  }
560  else
561  #endif
562  {
563  StringAppendS("(");
564  for (int j= 0;
565  j<(r->block1[l]-r->block0[l]+1)*(r->block1[l]-r->block0[l]+1);
566  j+=i+1)
567  {
568  char c=',';
569  if(r->order[l]==ringorder_a64)
570  {
571  int64 * w=(int64 *)r->wvhdl[l];
572  for (i = 0; i<r->block1[l]-r->block0[l]; i++)
573  {
574  StringAppend("%lld," ,w[i]);
575  }
576  StringAppend("%lld)" ,w[i]);
577  break;
578  }
579  else
580  {
581  for (i = 0; i<r->block1[l]-r->block0[l]; i++)
582  {
583  StringAppend("%d," ,r->wvhdl[l][i+j]);
584  }
585  }
586  if (r->order[l]!=ringorder_M)
587  {
588  StringAppend("%d)" ,r->wvhdl[l][i+j]);
589  break;
590  }
591  if (j+i+1==(r->block1[l]-r->block0[l]+1)*(r->block1[l]-r->block0[l]+1))
592  c=')';
593  StringAppend("%d%c" ,r->wvhdl[l][i+j],c);
594  }
595  }
596  }
597  else
598  StringAppend("(%d)",r->block1[l]-r->block0[l]+1);
599  }
600  else if (r->order[l] == ringorder_IS)
601  {
602  assume( r->block0[l] == r->block1[l] );
603  const int s = r->block0[l];
604  assume( (-2 < s) && (s < 2) );
605 
606  StringAppend("(%d)", s);
607  }
608 
609  if (l==nblocks)
610  {
611  if (r->wanted_maxExp!=0)
612  {
613  long mm=r->wanted_maxExp;
614  if (mm>MAX_INT_VAL) mm=MAX_INT_VAL;
615  StringAppend(",L(%ld)",mm);
616  }
617  return StringEndS();
618  }
619  StringAppendS(",");
620  }
621 }
622 
623 char * rVarStr(ring r)
624 {
625  if ((r==NULL)||(r->names==NULL)) return omStrDup("");
626  int i;
627  int l=2;
628  char *s;
629 
630  for (i=0; i<r->N; i++)
631  {
632  l+=strlen(r->names[i])+1;
633  }
634  s=(char *)omAlloc((long)l);
635  s[0]='\0';
636  for (i=0; i<r->N-1; i++)
637  {
638  strcat(s,r->names[i]);
639  strcat(s,",");
640  }
641  strcat(s,r->names[i]);
642  return s;
643 }
644 
645 /// TODO: make it a virtual method of coeffs, together with:
646 /// Decompose & Compose, rParameter & rPar
647 char * rCharStr(const ring r){ assume( r != NULL ); return nCoeffString(r->cf); }
648 
649 char * rParStr(ring r)
650 {
651  if ((r==NULL)||(rParameter(r)==NULL)) return omStrDup("");
652 
653  char const * const * const params = rParameter(r);
654 
655  int i;
656  int l=2;
657 
658  for (i=0; i<rPar(r); i++)
659  {
660  l+=strlen(params[i])+1;
661  }
662  char *s=(char *)omAlloc((long)l);
663  s[0]='\0';
664  for (i=0; i<rPar(r)-1; i++)
665  {
666  strcat(s, params[i]);
667  strcat(s,",");
668  }
669  strcat(s, params[i]);
670  return s;
671 }
672 
673 char * rString(ring r)
674 {
675  if ((r!=NULL)&&(r->cf!=NULL))
676  {
677  char *ch=rCharStr(r);
678  char *var=rVarStr(r);
679  char *ord=rOrdStr(r);
680  char *res=(char *)omAlloc(strlen(ch)+strlen(var)+strlen(ord)+9);
681  sprintf(res,"(%s),(%s),(%s)",ch,var,ord);
682  omFree((ADDRESS)ch);
683  omFree((ADDRESS)var);
684  omFree((ADDRESS)ord);
685  return res;
686  }
687  else
688  return omStrDup("undefined");
689 }
690 
691 
692 /*
693 // The fowolling function seems to be never used. Remove?
694 static int binaryPower (const int a, const int b)
695 {
696  // computes a^b according to the binary representation of b,
697  // i.e., a^7 = a^4 * a^2 * a^1. This saves some multiplications.
698  int result = 1;
699  int factor = a;
700  int bb = b;
701  while (bb != 0)
702  {
703  if (bb % 2 != 0) result = result * factor;
704  bb = bb / 2;
705  factor = factor * factor;
706  }
707  return result;
708 }
709 */
710 
711 /* we keep this otherwise superfluous method for compatibility reasons
712  towards the SINGULAR svn trunk */
713 int rChar(ring r) { return r->cf->ch; }
714 
715 
716 
717 // creates a commutative nc extension; "converts" comm.ring to a Plural ring
718 #ifdef HAVE_PLURAL
720 {
721  r = rCopy(r);
722  if (rIsPluralRing(r))
723  return r;
724 
725  matrix C = mpNew(r->N,r->N); // ring-independent!?!
726  matrix D = mpNew(r->N,r->N);
727 
728  for(int i=1; i<r->N; i++)
729  for(int j=i+1; j<=r->N; j++)
730  MATELEM(C,i,j) = p_One( r);
731 
732  if (nc_CallPlural(C, D, NULL, NULL, r, false, true, false, r/*??currRing??*/, TRUE)) // TODO: what about quotient ideal?
733  WarnS("Error initializing multiplication!"); // No reaction!???
734 
735  return r;
736 }
737 #endif
738 
739 
740 /*2
741  *returns -1 for not compatible, (sum is undefined)
742  * 1 for compatible (and sum)
743  */
744 /* vartest: test for variable/paramter names
745 * dp_dp: 0:block ordering
746 * 1:for comm. rings: use block order dp + dp/ds/wp
747 * 2:order aa(..),dp
748 */
749 int rSumInternal(ring r1, ring r2, ring &sum, BOOLEAN vartest, BOOLEAN dp_dp)
750 {
751 
752  ip_sring tmpR;
753  memset(&tmpR,0,sizeof(tmpR));
754  /* check coeff. field =====================================================*/
755 
756  if (r1->cf==r2->cf)
757  {
758  tmpR.cf=nCopyCoeff(r1->cf);
759  }
760  else /* different type */
761  {
762  if (getCoeffType(r1->cf)==n_Zp)
763  {
764  if (getCoeffType(r2->cf)==n_Q)
765  {
766  tmpR.cf=nCopyCoeff(r1->cf);
767  }
768  else if (nCoeff_is_Extension(r2->cf) && rChar(r2) == rChar(r1))
769  {
770  /*AlgExtInfo extParam;
771  extParam.r = r2->cf->extRing;
772  extParam.i = r2->cf->extRing->qideal;*/
773  tmpR.cf=nCopyCoeff(r2->cf);
774  }
775  else
776  {
777  WerrorS("Z/p+...");
778  return -1;
779  }
780  }
781  else if ((getCoeffType(r1->cf)==n_Zn)||(getCoeffType(r1->cf)==n_Znm))
782  {
783  if (getCoeffType(r2->cf)==n_Q)
784  {
785  tmpR.cf=nCopyCoeff(r1->cf);
786  }
787  else if (nCoeff_is_Extension(r2->cf)
788  && (mpz_cmp(r1->cf->modNumber,r2->cf->extRing->cf->modNumber)==0))
789  { // covers transext.cc and algext.cc
790  tmpR.cf=nCopyCoeff(r2->cf);
791  }
792  else
793  {
794  WerrorS("Z/n+...");
795  return -1;
796  }
797  }
798  else if (getCoeffType(r1->cf)==n_R)
799  {
800  WerrorS("R+..");
801  return -1;
802  }
803  else if (getCoeffType(r1->cf)==n_Q)
804  {
805  if (getCoeffType(r2->cf)==n_Zp)
806  {
807  tmpR.cf=nCopyCoeff(r2->cf);
808  }
809  else if (nCoeff_is_Extension(r2->cf))
810  {
811  tmpR.cf=nCopyCoeff(r2->cf);
812  }
813  else
814  {
815  WerrorS("Q+...");
816  return -1;
817  }
818  }
819  else if (nCoeff_is_Extension(r1->cf))
820  {
821  if (r1->cf->extRing->cf==r2->cf)
822  {
823  tmpR.cf=nCopyCoeff(r1->cf);
824  }
825  else if (getCoeffType(r1->cf->extRing->cf)==n_Zp && getCoeffType(r2->cf)==n_Q) //r2->cf == n_Zp should have been handled above
826  {
827  tmpR.cf=nCopyCoeff(r1->cf);
828  }
829  else
830  {
831  WerrorS ("coeff sum of two extension fields not implemented");
832  return -1;
833  }
834  }
835  else
836  {
837  WerrorS("coeff sum not yet implemented");
838  return -1;
839  }
840  }
841  /* variable names ========================================================*/
842  int i,j,k;
843  int l=r1->N+r2->N;
844  char **names=(char **)omAlloc0(l*sizeof(char *));
845  k=0;
846 
847  // collect all varnames from r1, except those which are parameters
848  // of r2, or those which are the empty string
849  for (i=0;i<r1->N;i++)
850  {
851  BOOLEAN b=TRUE;
852 
853  if (*(r1->names[i]) == '\0')
854  b = FALSE;
855  else if ((rParameter(r2)!=NULL) && (strlen(r1->names[i])==1))
856  {
857  if (vartest)
858  {
859  for(j=0;j<rPar(r2);j++)
860  {
861  if (strcmp(r1->names[i],rParameter(r2)[j])==0)
862  {
863  b=FALSE;
864  break;
865  }
866  }
867  }
868  }
869 
870  if (b)
871  {
872  //Print("name : %d: %s\n",k,r1->names[i]);
873  names[k]=omStrDup(r1->names[i]);
874  k++;
875  }
876  //else
877  // Print("no name (par1) %s\n",r1->names[i]);
878  }
879  // Add variables from r2, except those which are parameters of r1
880  // those which are empty strings, and those which equal a var of r1
881  for(i=0;i<r2->N;i++)
882  {
883  BOOLEAN b=TRUE;
884 
885  if (*(r2->names[i]) == '\0')
886  b = FALSE;
887  else if ((rParameter(r1)!=NULL) && (strlen(r2->names[i])==1))
888  {
889  if (vartest)
890  {
891  for(j=0;j<rPar(r1);j++)
892  {
893  if (strcmp(r2->names[i],rParameter(r1)[j])==0)
894  {
895  b=FALSE;
896  break;
897  }
898  }
899  }
900  }
901 
902  if (b)
903  {
904  if (vartest)
905  {
906  for(j=0;j<r1->N;j++)
907  {
908  if (strcmp(r1->names[j],r2->names[i])==0)
909  {
910  b=FALSE;
911  break;
912  }
913  }
914  }
915  if (b)
916  {
917  //Print("name : %d : %s\n",k,r2->names[i]);
918  names[k]=omStrDup(r2->names[i]);
919  k++;
920  }
921  //else
922  // Print("no name (var): %s\n",r2->names[i]);
923  }
924  //else
925  // Print("no name (par): %s\n",r2->names[i]);
926  }
927  // check whether we found any vars at all
928  if (k == 0)
929  {
930  names[k]=omStrDup("");
931  k=1;
932  }
933  tmpR.N=k;
934  tmpR.names=names;
935  /* ordering *======================================================== */
936  tmpR.OrdSgn=0;
937  if ((dp_dp==2)
938  && (r1->OrdSgn==1)
939  && (r2->OrdSgn==1)
940 #ifdef HAVE_PLURAL
941  && !rIsPluralRing(r1) && !rIsPluralRing(r2)
942 #endif
943  )
944  {
945  tmpR.order=(rRingOrder_t*)omAlloc0(4*sizeof(rRingOrder_t));
946  tmpR.block0=(int*)omAlloc0(4*sizeof(int));
947  tmpR.block1=(int*)omAlloc0(4*sizeof(int));
948  tmpR.wvhdl=(int**) omAlloc0(4*sizeof(int**));
949  // ----
950  tmpR.block0[0] = 1;
951  tmpR.block1[0] = rVar(r1)+rVar(r2);
952  tmpR.order[0] = ringorder_aa;
953  tmpR.wvhdl[0]=(int*)omAlloc0((rVar(r1)+rVar(r2) + 1)*sizeof(int));
954  for(int i=0;i<rVar(r1);i++) tmpR.wvhdl[0][i]=1;
955  // ----
956  tmpR.block0[1] = 1;
957  tmpR.block1[1] = rVar(r1)+rVar(r2);
958  tmpR.order[1] = ringorder_dp;
959  // ----
960  tmpR.order[2] = ringorder_C;
961  }
962  else if (dp_dp
963 #ifdef HAVE_PLURAL
964  && !rIsPluralRing(r1) && !rIsPluralRing(r2)
965 #endif
966  )
967  {
968  tmpR.order=(rRingOrder_t*)omAlloc(4*sizeof(rRingOrder_t));
969  tmpR.block0=(int*)omAlloc0(4*sizeof(int));
970  tmpR.block1=(int*)omAlloc0(4*sizeof(int));
971  tmpR.wvhdl=(int**)omAlloc0(4*sizeof(int *));
972  tmpR.order[0]=ringorder_dp;
973  tmpR.block0[0]=1;
974  tmpR.block1[0]=rVar(r1);
975  if (r2->OrdSgn==1)
976  {
977  if ((r2->block0[0]==1)
978  && (r2->block1[0]==rVar(r2))
979  && ((r2->order[0]==ringorder_wp)
980  || (r2->order[0]==ringorder_Wp)
981  || (r2->order[0]==ringorder_Dp))
982  )
983  {
984  tmpR.order[1]=r2->order[0];
985  if (r2->wvhdl[0]!=NULL)
986  #ifdef HAVE_OMALLOC
987  tmpR.wvhdl[1]=(int *)omMemDup(r2->wvhdl[0]);
988  #else
989  {
990  int l=r2->block1[0]-r2->block0[0]+1;
991  if (r2->order[0]==ringorder_a64) l*=2;
992  else if (r2->order[0]==ringorder_M) l=l*l;
993  else if (r2->order[0]==ringorder_am)
994  {
995  l+=r2->wvhdl[1][r2->block1[0]-r2->block0[0]+1]+1;
996  }
997  tmpR.wvhdl[1]=(int*)omalloc(l*sizeof(int));
998  memcpy(tmpR.wvhdl[1],r2->wvhdl[0],l*sizeof(int));
999  }
1000  #endif
1001  }
1002  else
1003  tmpR.order[1]=ringorder_dp;
1004  }
1005  else
1006  {
1007  tmpR.order[1]=ringorder_ds;
1008  tmpR.OrdSgn=-1;
1009  }
1010  tmpR.block0[1]=rVar(r1)+1;
1011  tmpR.block1[1]=rVar(r1)+rVar(r2);
1012  tmpR.order[2]=ringorder_C;
1013  tmpR.order[3]=(rRingOrder_t)0;
1014  }
1015  else
1016  {
1017  if ((r1->order[0]==ringorder_unspec)
1018  && (r2->order[0]==ringorder_unspec))
1019  {
1020  tmpR.order=(rRingOrder_t*)omAlloc(3*sizeof(rRingOrder_t));
1021  tmpR.block0=(int*)omAlloc(3*sizeof(int));
1022  tmpR.block1=(int*)omAlloc(3*sizeof(int));
1023  tmpR.wvhdl=(int**)omAlloc0(3*sizeof(int *));
1024  tmpR.order[0]=ringorder_unspec;
1025  tmpR.order[1]=ringorder_C;
1026  tmpR.order[2]=(rRingOrder_t)0;
1027  tmpR.block0[0]=1;
1028  tmpR.block1[0]=tmpR.N;
1029  }
1030  else if (l==k) /* r3=r1+r2 */
1031  {
1032  int b;
1033  ring rb;
1034  if (r1->order[0]==ringorder_unspec)
1035  {
1036  /* extend order of r2 to r3 */
1037  b=rBlocks(r2);
1038  rb=r2;
1039  tmpR.OrdSgn=r2->OrdSgn;
1040  }
1041  else if (r2->order[0]==ringorder_unspec)
1042  {
1043  /* extend order of r1 to r3 */
1044  b=rBlocks(r1);
1045  rb=r1;
1046  tmpR.OrdSgn=r1->OrdSgn;
1047  }
1048  else
1049  {
1050  b=rBlocks(r1)+rBlocks(r2)-2; /* for only one order C, only one 0 */
1051  rb=NULL;
1052  }
1053  tmpR.order=(rRingOrder_t*)omAlloc0(b*sizeof(rRingOrder_t));
1054  tmpR.block0=(int*)omAlloc0(b*sizeof(int));
1055  tmpR.block1=(int*)omAlloc0(b*sizeof(int));
1056  tmpR.wvhdl=(int**)omAlloc0(b*sizeof(int *));
1057  /* weights not implemented yet ...*/
1058  if (rb!=NULL)
1059  {
1060  for (i=0;i<b;i++)
1061  {
1062  tmpR.order[i]=rb->order[i];
1063  tmpR.block0[i]=rb->block0[i];
1064  tmpR.block1[i]=rb->block1[i];
1065  if (rb->wvhdl[i]!=NULL)
1066  WarnS("rSum: weights not implemented");
1067  }
1068  tmpR.block0[0]=1;
1069  }
1070  else /* ring sum for complete rings */
1071  {
1072  for (i=0;r1->order[i]!=0;i++)
1073  {
1074  tmpR.order[i]=r1->order[i];
1075  tmpR.block0[i]=r1->block0[i];
1076  tmpR.block1[i]=r1->block1[i];
1077  if (r1->wvhdl[i]!=NULL)
1078  #ifdef HAVE_OMALLOC
1079  tmpR.wvhdl[i] = (int*) omMemDup(r1->wvhdl[i]);
1080  #else
1081  {
1082  int l=r1->block1[i]-r1->block0[i]+1;
1083  if (r1->order[i]==ringorder_a64) l*=2;
1084  else if (r1->order[i]==ringorder_M) l=l*l;
1085  else if (r1->order[i]==ringorder_am)
1086  {
1087  l+=r1->wvhdl[i][r1->block1[i]-r1->block0[i]+1]+1;
1088  }
1089  tmpR.wvhdl[i]=(int*)omalloc(l*sizeof(int));
1090  memcpy(tmpR.wvhdl[i],r1->wvhdl[i],l*sizeof(int));
1091  }
1092  #endif
1093  }
1094  j=i;
1095  i--;
1096  if ((r1->order[i]==ringorder_c)
1097  ||(r1->order[i]==ringorder_C))
1098  {
1099  j--;
1100  tmpR.order[b-2]=r1->order[i];
1101  }
1102  for (i=0;r2->order[i]!=0;i++)
1103  {
1104  if ((r2->order[i]!=ringorder_c)
1105  &&(r2->order[i]!=ringorder_C))
1106  {
1107  tmpR.order[j]=r2->order[i];
1108  tmpR.block0[j]=r2->block0[i]+rVar(r1);
1109  tmpR.block1[j]=r2->block1[i]+rVar(r1);
1110  if (r2->wvhdl[i]!=NULL)
1111  {
1112  #ifdef HAVE_OMALLOC
1113  tmpR.wvhdl[j] = (int*) omMemDup(r2->wvhdl[i]);
1114  #else
1115  {
1116  int l=r2->block1[i]-r2->block0[i]+1;
1117  if (r2->order[i]==ringorder_a64) l*=2;
1118  else if (r2->order[i]==ringorder_M) l=l*l;
1119  else if (r2->order[i]==ringorder_am)
1120  {
1121  l+=r2->wvhdl[i][r2->block1[i]-r2->block0[i]+1]+1;
1122  }
1123  tmpR.wvhdl[j]=(int*)omalloc(l*sizeof(int));
1124  memcpy(tmpR.wvhdl[j],r2->wvhdl[i],l*sizeof(int));
1125  }
1126  #endif
1127  }
1128  j++;
1129  }
1130  }
1131  if((r1->OrdSgn==-1)||(r2->OrdSgn==-1))
1132  tmpR.OrdSgn=-1;
1133  }
1134  }
1135  else if ((k==rVar(r1)) && (k==rVar(r2))) /* r1 and r2 are "quite"
1136  the same ring */
1137  /* copy r1, because we have the variables from r1 */
1138  {
1139  int b=rBlocks(r1);
1140 
1141  tmpR.order=(rRingOrder_t*)omAlloc0(b*sizeof(rRingOrder_t));
1142  tmpR.block0=(int*)omAlloc0(b*sizeof(int));
1143  tmpR.block1=(int*)omAlloc0(b*sizeof(int));
1144  tmpR.wvhdl=(int**)omAlloc0(b*sizeof(int *));
1145  /* weights not implemented yet ...*/
1146  for (i=0;i<b;i++)
1147  {
1148  tmpR.order[i]=r1->order[i];
1149  tmpR.block0[i]=r1->block0[i];
1150  tmpR.block1[i]=r1->block1[i];
1151  if (r1->wvhdl[i]!=NULL)
1152  {
1153  #ifdef HAVE_OMALLOC
1154  tmpR.wvhdl[i] = (int*) omMemDup(r1->wvhdl[i]);
1155  #else
1156  {
1157  int l=r1->block1[i]-r1->block0[i]+1;
1158  if (r1->order[i]==ringorder_a64) l*=2;
1159  else if (r1->order[i]==ringorder_M) l=l*l;
1160  else if (r1->order[i]==ringorder_am)
1161  {
1162  l+=r1->wvhdl[i][r1->block1[i]-r1->block0[i]+1]+1;
1163  }
1164  tmpR.wvhdl[i]=(int*)omalloc(l*sizeof(int));
1165  memcpy(tmpR.wvhdl[i],r1->wvhdl[i],l*sizeof(int));
1166  }
1167  #endif
1168  }
1169  }
1170  tmpR.OrdSgn=r1->OrdSgn;
1171  }
1172  else
1173  {
1174  for(i=0;i<k;i++) omFree((ADDRESS)tmpR.names[i]);
1175  omFreeSize((ADDRESS)names,tmpR.N*sizeof(char *));
1176  Werror("variables must not overlap (# of vars: %d,%d -> %d)",rVar(r1),rVar(r2),k);
1177  return -1;
1178  }
1179  }
1180  tmpR.bitmask=si_max(r1->bitmask,r2->bitmask);
1181  sum=(ring)omAllocBin(sip_sring_bin);
1182  memcpy(sum,&tmpR,sizeof(ip_sring));
1183  rComplete(sum);
1184 
1185 //#ifdef RDEBUG
1186 // rDebugPrint(sum);
1187 //#endif
1188 
1189 
1190 
1191 #ifdef HAVE_PLURAL
1192  if(1)
1193  {
1194 // ring old_ring = currRing;
1195 
1196  BOOLEAN R1_is_nc = rIsPluralRing(r1);
1197  BOOLEAN R2_is_nc = rIsPluralRing(r2);
1198 
1199  if ( (R1_is_nc) || (R2_is_nc))
1200  {
1201  ring R1 = nc_rCreateNCcomm_rCopy(r1);
1202  assume( rIsPluralRing(R1) );
1203 
1204 #if 0
1205 #ifdef RDEBUG
1206  rWrite(R1);
1207  rDebugPrint(R1);
1208 #endif
1209 #endif
1210  ring R2 = nc_rCreateNCcomm_rCopy(r2);
1211 #if 0
1212 #ifdef RDEBUG
1213  rWrite(R2);
1214  rDebugPrint(R2);
1215 #endif
1216 #endif
1217 
1218 // rChangeCurrRing(sum); // ?
1219 
1220  // Projections from R_i into Sum:
1221  /* multiplication matrices business: */
1222  /* find permutations of vars and pars */
1223  int *perm1 = (int *)omAlloc0((rVar(R1)+1)*sizeof(int));
1224  int *par_perm1 = NULL;
1225  if (rPar(R1)!=0) par_perm1=(int *)omAlloc0((rPar(R1)+1)*sizeof(int));
1226 
1227  int *perm2 = (int *)omAlloc0((rVar(R2)+1)*sizeof(int));
1228  int *par_perm2 = NULL;
1229  if (rPar(R2)!=0) par_perm2=(int *)omAlloc0((rPar(R2)+1)*sizeof(int));
1230 
1231  maFindPerm(R1->names, rVar(R1), rParameter(R1), rPar(R1),
1232  sum->names, rVar(sum), rParameter(sum), rPar(sum),
1233  perm1, par_perm1, sum->cf->type);
1234 
1235  maFindPerm(R2->names, rVar(R2), rParameter(R2), rPar(R2),
1236  sum->names, rVar(sum), rParameter(sum), rPar(sum),
1237  perm2, par_perm2, sum->cf->type);
1238 
1239 
1240  matrix C1 = R1->GetNC()->C, C2 = R2->GetNC()->C;
1241  matrix D1 = R1->GetNC()->D, D2 = R2->GetNC()->D;
1242 
1243  // !!!! BUG? C1 and C2 might live in different baserings!!!
1244 
1245  int l = rVar(R1) + rVar(R2);
1246 
1247  matrix C = mpNew(l,l);
1248  matrix D = mpNew(l,l);
1249 
1250  for (i = 1; i <= rVar(R1); i++)
1251  for (j= rVar(R1)+1; j <= l; j++)
1252  MATELEM(C,i,j) = p_One(sum); // in 'sum'
1253 
1254  id_Test((ideal)C, sum);
1255 
1256  nMapFunc nMap1 = n_SetMap(R1->cf,sum->cf); /* can change something global: not usable
1257  after the next nSetMap call :( */
1258  // Create blocked C and D matrices:
1259  for (i=1; i<= rVar(R1); i++)
1260  for (j=i+1; j<=rVar(R1); j++)
1261  {
1262  assume(MATELEM(C1,i,j) != NULL);
1263  MATELEM(C,i,j) = p_PermPoly(MATELEM(C1,i,j), perm1, R1, sum, nMap1, par_perm1, rPar(R1)); // need ADD + CMP ops.
1264 
1265  if (MATELEM(D1,i,j) != NULL)
1266  MATELEM(D,i,j) = p_PermPoly(MATELEM(D1,i,j), perm1, R1, sum, nMap1, par_perm1, rPar(R1));
1267  }
1268 
1269  id_Test((ideal)C, sum);
1270  id_Test((ideal)D, sum);
1271 
1272 
1273  nMapFunc nMap2 = n_SetMap(R2->cf,sum->cf); /* can change something global: not usable
1274  after the next nSetMap call :( */
1275  for (i=1; i<= rVar(R2); i++)
1276  for (j=i+1; j<=rVar(R2); j++)
1277  {
1278  assume(MATELEM(C2,i,j) != NULL);
1279  MATELEM(C,rVar(R1)+i,rVar(R1)+j) = p_PermPoly(MATELEM(C2,i,j),perm2,R2,sum, nMap2,par_perm2,rPar(R2));
1280 
1281  if (MATELEM(D2,i,j) != NULL)
1282  MATELEM(D,rVar(R1)+i,rVar(R1)+j) = p_PermPoly(MATELEM(D2,i,j),perm2,R2,sum, nMap2,par_perm2,rPar(R2));
1283  }
1284 
1285  id_Test((ideal)C, sum);
1286  id_Test((ideal)D, sum);
1287 
1288  // Now sum is non-commutative with blocked structure constants!
1289  if (nc_CallPlural(C, D, NULL, NULL, sum, false, false, true, sum))
1290  WarnS("Error initializing non-commutative multiplication!");
1291 
1292  /* delete R1, R2*/
1293 
1294 #if 0
1295 #ifdef RDEBUG
1296  rWrite(sum);
1297  rDebugPrint(sum);
1298 
1299  Print("\nRefs: R1: %d, R2: %d\n", R1->GetNC()->ref, R2->GetNC()->ref);
1300 
1301 #endif
1302 #endif
1303 
1304 
1305  rDelete(R1);
1306  rDelete(R2);
1307 
1308  /* delete perm arrays */
1309  if (perm1!=NULL) omFree((ADDRESS)perm1);
1310  if (perm2!=NULL) omFree((ADDRESS)perm2);
1311  if (par_perm1!=NULL) omFree((ADDRESS)par_perm1);
1312  if (par_perm2!=NULL) omFree((ADDRESS)par_perm2);
1313 
1314 // rChangeCurrRing(old_ring);
1315  }
1316 
1317  }
1318 #endif
1319 
1320  ideal Q=NULL;
1321  ideal Q1=NULL, Q2=NULL;
1322  if (r1->qideal!=NULL)
1323  {
1324 // rChangeCurrRing(sum);
1325 // if (r2->qideal!=NULL)
1326 // {
1327 // WerrorS("todo: qring+qring");
1328 // return -1;
1329 // }
1330 // else
1331 // {}
1332  /* these were defined in the Plural Part above... */
1333  int *perm1 = (int *)omAlloc0((rVar(r1)+1)*sizeof(int));
1334  int *par_perm1 = NULL;
1335  if (rPar(r1)!=0) par_perm1=(int *)omAlloc0((rPar(r1)+1)*sizeof(int));
1336  maFindPerm(r1->names, rVar(r1), rParameter(r1), rPar(r1),
1337  sum->names, rVar(sum), rParameter(sum), rPar(sum),
1338  perm1, par_perm1, sum->cf->type);
1339  nMapFunc nMap1 = n_SetMap(r1->cf,sum->cf);
1340  Q1 = idInit(IDELEMS(r1->qideal),1);
1341 
1342  for (int for_i=0;for_i<IDELEMS(r1->qideal);for_i++)
1343  Q1->m[for_i] = p_PermPoly(
1344  r1->qideal->m[for_i], perm1,
1345  r1, sum,
1346  nMap1,
1347  par_perm1, rPar(r1));
1348 
1349  omFree((ADDRESS)perm1);
1350  }
1351 
1352  if (r2->qideal!=NULL)
1353  {
1354  //if (currRing!=sum)
1355  // rChangeCurrRing(sum);
1356  int *perm2 = (int *)omAlloc0((rVar(r2)+1)*sizeof(int));
1357  int *par_perm2 = NULL;
1358  if (rPar(r2)!=0) par_perm2=(int *)omAlloc0((rPar(r2)+1)*sizeof(int));
1359  maFindPerm(r2->names, rVar(r2), rParameter(r2), rPar(r2),
1360  sum->names, rVar(sum), rParameter(sum), rPar(sum),
1361  perm2, par_perm2, sum->cf->type);
1362  nMapFunc nMap2 = n_SetMap(r2->cf,sum->cf);
1363  Q2 = idInit(IDELEMS(r2->qideal),1);
1364 
1365  for (int for_i=0;for_i<IDELEMS(r2->qideal);for_i++)
1366  Q2->m[for_i] = p_PermPoly(
1367  r2->qideal->m[for_i], perm2,
1368  r2, sum,
1369  nMap2,
1370  par_perm2, rPar(r2));
1371 
1372  omFree((ADDRESS)perm2);
1373  }
1374  if (Q1!=NULL)
1375  {
1376  if ( Q2!=NULL)
1377  Q = id_SimpleAdd(Q1,Q2,sum);
1378  else
1379  Q=id_Copy(Q1,sum);
1380  }
1381  else
1382  {
1383  if ( Q2!=NULL)
1384  Q = id_Copy(Q2,sum);
1385  else
1386  Q=NULL;
1387  }
1388  sum->qideal = Q;
1389 
1390 #ifdef HAVE_PLURAL
1391  if( rIsPluralRing(sum) )
1392  nc_SetupQuotient( sum );
1393 #endif
1394  return 1;
1395 }
1396 
1397 /*2
1398  *returns -1 for not compatible, (sum is undefined)
1399  * 0 for equal, (and sum)
1400  * 1 for compatible (and sum)
1401  */
1402 int rSum(ring r1, ring r2, ring &sum)
1403 {
1404  if ((r1==NULL)||(r2==NULL)
1405  ||(r1->cf==NULL)||(r2->cf==NULL))
1406  return -1;
1407  if (r1==r2)
1408  {
1409  sum=r1;
1410  rIncRefCnt(r1);
1411  return 0;
1412  }
1413  return rSumInternal(r1,r2,sum,TRUE,FALSE);
1414 }
1415 
1416 /*2
1417  * create a copy of the ring r
1418  * used for qring definition,..
1419  * DOES NOT CALL rComplete
1420  */
1421 ring rCopy0(const ring r, BOOLEAN copy_qideal, BOOLEAN copy_ordering)
1422 {
1423  if (r == NULL) return NULL;
1424  int i,j;
1425  ring res=(ring)omAlloc0Bin(sip_sring_bin);
1426  //memset: res->idroot=NULL; /* local objects */
1427  //ideal minideal;
1428  res->options=r->options; /* ring dependent options */
1429 
1430  //memset: res->ordsgn=NULL;
1431  //memset: res->typ=NULL;
1432  //memset: res->VarOffset=NULL;
1433  //memset: res->firstwv=NULL;
1434 
1435  //struct omBin PolyBin; /* Bin from where monoms are allocated */
1436  //memset: res->PolyBin=NULL; // rComplete
1437  res->cf=nCopyCoeff(r->cf); /* coeffs */
1438 
1439  //memset: res->ref=0; /* reference counter to the ring */
1440 
1441  res->N=rVar(r); /* number of vars */
1442 
1443  res->firstBlockEnds=r->firstBlockEnds;
1444 #ifdef HAVE_PLURAL
1445  res->real_var_start=r->real_var_start;
1446  res->real_var_end=r->real_var_end;
1447 #endif
1448 
1449 #ifdef HAVE_SHIFTBBA
1450  res->isLPring=r->isLPring; /* 0 for non-letterplace rings, otherwise the number of LP blocks, at least 1, known also as lV */
1451  res->LPncGenCount=r->LPncGenCount;
1452 #endif
1453 
1454  res->VectorOut=r->VectorOut;
1455  res->ShortOut=r->ShortOut;
1456  res->CanShortOut=r->CanShortOut;
1457 
1458  //memset: res->ExpL_Size=0;
1459  //memset: res->CmpL_Size=0;
1460  //memset: res->VarL_Size=0;
1461  //memset: res->pCompIndex=0;
1462  //memset: res->pOrdIndex=0;
1463  //memset: res->OrdSize=0;
1464  //memset: res->VarL_LowIndex=0;
1465  //memset: res->NegWeightL_Size=0;
1466  //memset: res->NegWeightL_Offset=NULL;
1467  //memset: res->VarL_Offset=NULL;
1468 
1469  // the following are set by rComplete unless predefined
1470  // therefore, we copy these values: maybe they are non-standard
1471  /* mask for getting single exponents */
1472  res->bitmask=r->bitmask;
1473  res->divmask=r->divmask;
1474  res->BitsPerExp = r->BitsPerExp;
1475  res->ExpPerLong = r->ExpPerLong;
1476 
1477  //memset: res->p_Procs=NULL;
1478  //memset: res->pFDeg=NULL;
1479  //memset: res->pLDeg=NULL;
1480  //memset: res->pFDegOrig=NULL;
1481  //memset: res->pLDegOrig=NULL;
1482  //memset: res->p_Setm=NULL;
1483  //memset: res->cf=NULL;
1484 
1485 /*
1486  if (r->extRing!=NULL)
1487  r->extRing->ref++;
1488 
1489  res->extRing=r->extRing;
1490  //memset: res->qideal=NULL;
1491 */
1492 
1493 
1494  if (copy_ordering == TRUE)
1495  {
1496  res->LexOrder=r->LexOrder; // TRUE if the monomial ordering has polynomial and power series blocks
1497  res->MixedOrder=r->MixedOrder; // TRUE for mixed (global/local) ordering, FALSE otherwise,
1498  i=rBlocks(r);
1499  res->wvhdl = (int **)omAlloc(i * sizeof(int *));
1500  res->order = (rRingOrder_t *) omAlloc(i * sizeof(rRingOrder_t));
1501  res->block0 = (int *) omAlloc(i * sizeof(int));
1502  res->block1 = (int *) omAlloc(i * sizeof(int));
1503  for (j=0; j<i; j++)
1504  {
1505  if (r->wvhdl[j]!=NULL)
1506  {
1507  #ifdef HAVE_OMALLOC
1508  res->wvhdl[j] = (int*) omMemDup(r->wvhdl[j]);
1509  #else
1510  {
1511  int l=r->block1[j]-r->block0[j]+1;
1512  if (r->order[j]==ringorder_a64) l*=2;
1513  else if (r->order[j]==ringorder_M) l=l*l;
1514  else if (r->order[j]==ringorder_am)
1515  {
1516  l+=r->wvhdl[j][r->block1[j]-r->block0[j]+1]+1;
1517  }
1518  res->wvhdl[j]=(int*)omalloc(l*sizeof(int));
1519  memcpy(res->wvhdl[j],r->wvhdl[j],l*sizeof(int));
1520  }
1521  #endif
1522  }
1523  else
1524  res->wvhdl[j]=NULL;
1525  }
1526  memcpy(res->order,r->order,i * sizeof(rRingOrder_t));
1527  memcpy(res->block0,r->block0,i * sizeof(int));
1528  memcpy(res->block1,r->block1,i * sizeof(int));
1529  }
1530  //memset: else
1531  //memset: {
1532  //memset: res->wvhdl = NULL;
1533  //memset: res->order = NULL;
1534  //memset: res->block0 = NULL;
1535  //memset: res->block1 = NULL;
1536  //memset: }
1537 
1538  res->names = (char **)omAlloc0(rVar(r) * sizeof(char *));
1539  for (i=0; i<rVar(res); i++)
1540  {
1541  res->names[i] = omStrDup(r->names[i]);
1542  }
1543  if (r->qideal!=NULL)
1544  {
1545  if (copy_qideal)
1546  {
1547  assume(copy_ordering);
1548  rComplete(res);
1549  res->qideal= idrCopyR_NoSort(r->qideal, r, res);
1550  rUnComplete(res);
1551  }
1552  //memset: else res->qideal = NULL;
1553  }
1554  //memset: else res->qideal = NULL;
1555  //memset: res->GetNC() = NULL; // copy is purely commutative!!!
1556  return res;
1557 }
1558 
1559 /*2
1560  * create a copy of the ring r
1561  * used for qring definition,..
1562  * DOES NOT CALL rComplete
1563  */
1564 ring rCopy0AndAddA(const ring r, int64vec *wv64, BOOLEAN copy_qideal, BOOLEAN copy_ordering)
1565 {
1566  if (r == NULL) return NULL;
1567  int i,j;
1568  ring res=(ring)omAlloc0Bin(sip_sring_bin);
1569  //memcpy(res,r,sizeof(ip_sring));
1570  //memset: res->idroot=NULL; /* local objects */
1571  //ideal minideal;
1572  res->options=r->options; /* ring dependent options */
1573 
1574  //memset: res->ordsgn=NULL;
1575  //memset: res->typ=NULL;
1576  //memset: res->VarOffset=NULL;
1577  //memset: res->firstwv=NULL;
1578 
1579  //struct omBin PolyBin; /* Bin from where monoms are allocated */
1580  //memset: res->PolyBin=NULL; // rComplete
1581  res->cf=nCopyCoeff(r->cf); /* coeffs */
1582 
1583  //memset: res->ref=0; /* reference counter to the ring */
1584 
1585  res->N=rVar(r); /* number of vars */
1586 
1587  res->firstBlockEnds=r->firstBlockEnds;
1588 #ifdef HAVE_PLURAL
1589  res->real_var_start=r->real_var_start;
1590  res->real_var_end=r->real_var_end;
1591 #endif
1592 
1593 #ifdef HAVE_SHIFTBBA
1594  res->isLPring=r->isLPring; /* 0 for non-letterplace rings, otherwise the number of LP blocks, at least 1, known also as lV */
1595  res->LPncGenCount=r->LPncGenCount;
1596 #endif
1597 
1598  res->VectorOut=r->VectorOut;
1599  res->ShortOut=r->ShortOut;
1600  res->CanShortOut=r->CanShortOut;
1601  res->LexOrder=r->LexOrder; // TRUE if the monomial ordering has polynomial and power series blocks
1602  res->MixedOrder=r->MixedOrder; // TRUE for mixed (global/local) ordering, FALSE otherwise,
1603 
1604  //memset: res->ExpL_Size=0;
1605  //memset: res->CmpL_Size=0;
1606  //memset: res->VarL_Size=0;
1607  //memset: res->pCompIndex=0;
1608  //memset: res->pOrdIndex=0;
1609  //memset: res->OrdSize=0;
1610  //memset: res->VarL_LowIndex=0;
1611  //memset: res->NegWeightL_Size=0;
1612  //memset: res->NegWeightL_Offset=NULL;
1613  //memset: res->VarL_Offset=NULL;
1614 
1615  // the following are set by rComplete unless predefined
1616  // therefore, we copy these values: maybe they are non-standard
1617  /* mask for getting single exponents */
1618  res->bitmask=r->bitmask;
1619  res->divmask=r->divmask;
1620  res->BitsPerExp = r->BitsPerExp;
1621  res->ExpPerLong = r->ExpPerLong;
1622 
1623  //memset: res->p_Procs=NULL;
1624  //memset: res->pFDeg=NULL;
1625  //memset: res->pLDeg=NULL;
1626  //memset: res->pFDegOrig=NULL;
1627  //memset: res->pLDegOrig=NULL;
1628  //memset: res->p_Setm=NULL;
1629  //memset: res->cf=NULL;
1630 
1631 /*
1632  if (r->extRing!=NULL)
1633  r->extRing->ref++;
1634 
1635  res->extRing=r->extRing;
1636  //memset: res->qideal=NULL;
1637 */
1638 
1639 
1640  if (copy_ordering == TRUE)
1641  {
1642  i=rBlocks(r)+1; // DIFF to rCopy0
1643  res->wvhdl = (int **)omAlloc(i * sizeof(int *));
1644  res->order = (rRingOrder_t *) omAlloc(i * sizeof(rRingOrder_t));
1645  res->block0 = (int *) omAlloc(i * sizeof(int));
1646  res->block1 = (int *) omAlloc(i * sizeof(int));
1647  for (j=0; j<i-1; j++)
1648  {
1649  if (r->wvhdl[j]!=NULL)
1650  {
1651  #ifdef HAVE_OMALLOC
1652  res->wvhdl[j+1] = (int*) omMemDup(r->wvhdl[j]); //DIFF
1653  #else
1654  {
1655  int l=r->block1[j]-r->block0[j]+1;
1656  if (r->order[j]==ringorder_a64) l*=2;
1657  else if (r->order[j]==ringorder_M) l=l*l;
1658  else if (r->order[j]==ringorder_am)
1659  {
1660  l+=r->wvhdl[j][r->block1[j]-r->block0[j]+1]+1;
1661  }
1662  res->wvhdl[j+1]=(int*)omalloc(l*sizeof(int));
1663  memcpy(res->wvhdl[j+1],r->wvhdl[j],l*sizeof(int));
1664  }
1665  #endif
1666  }
1667  else
1668  res->wvhdl[j+1]=NULL; //DIFF
1669  }
1670  memcpy(&(res->order[1]),r->order,(i-1) * sizeof(rRingOrder_t)); //DIFF
1671  memcpy(&(res->block0[1]),r->block0,(i-1) * sizeof(int)); //DIFF
1672  memcpy(&(res->block1[1]),r->block1,(i-1) * sizeof(int)); //DIFF
1673  }
1674  //memset: else
1675  //memset: {
1676  //memset: res->wvhdl = NULL;
1677  //memset: res->order = NULL;
1678  //memset: res->block0 = NULL;
1679  //memset: res->block1 = NULL;
1680  //memset: }
1681 
1682  //the added A
1683  res->order[0]=ringorder_a64;
1684  int length=wv64->rows();
1685  int64 *A=(int64 *)omAlloc(length*sizeof(int64));
1686  for(j=length-1;j>=0;j--)
1687  {
1688  A[j]=(*wv64)[j];
1689  }
1690  res->wvhdl[0]=(int *)A;
1691  res->block0[0]=1;
1692  res->block1[0]=length;
1693  //
1694 
1695  res->names = (char **)omAlloc0(rVar(r) * sizeof(char *));
1696  for (i=0; i<rVar(res); i++)
1697  {
1698  res->names[i] = omStrDup(r->names[i]);
1699  }
1700  if (r->qideal!=NULL)
1701  {
1702  if (copy_qideal)
1703  {
1704  #ifndef SING_NDEBUG
1705  if (!copy_ordering)
1706  WerrorS("internal error: rCopy0(Q,TRUE,FALSE)");
1707  else
1708  #endif
1709  {
1710  #ifndef SING_NDEBUG
1711  WarnS("internal bad stuff: rCopy0(Q,TRUE,TRUE)");
1712  #endif
1713  rComplete(res);
1714  res->qideal= idrCopyR_NoSort(r->qideal, r, res);
1715  rUnComplete(res);
1716  }
1717  }
1718  //memset: else res->qideal = NULL;
1719  }
1720  //memset: else res->qideal = NULL;
1721  //memset: res->GetNC() = NULL; // copy is purely commutative!!!
1722  return res;
1723 }
1724 
1725 /*2
1726  * create a copy of the ring r, which must be equivalent to currRing
1727  * used for qring definition,..
1728  * (i.e.: normal rings: same nCopy as currRing;
1729  * qring: same nCopy, same idCopy as currRing)
1730  */
1731 ring rCopy(ring r)
1732 {
1733  if (r == NULL) return NULL;
1734  ring res=rCopy0(r,FALSE,TRUE);
1735  rComplete(res, 1); // res is purely commutative so far
1736  if (r->qideal!=NULL) res->qideal=idrCopyR_NoSort(r->qideal, r, res);
1737 
1738 #ifdef HAVE_PLURAL
1739  if (rIsPluralRing(r))
1740  if( nc_rCopy(res, r, true) ) {}
1741 #endif
1742 
1743  return res;
1744 }
1745 
1746 BOOLEAN rEqual(ring r1, ring r2, BOOLEAN qr)
1747 {
1748  if (r1 == r2) return TRUE;
1749  if (r1 == NULL || r2 == NULL) return FALSE;
1750  if (r1->cf!=r2->cf) return FALSE;
1751  if (rVar(r1)!=rVar(r2)) 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;
1756  #endif
1757 
1758  if( !rSamePolyRep(r1, r2) )
1759  return FALSE;
1760 
1761  int i/*, j*/;
1762 
1763  for (i=0; i<rVar(r1); i++)
1764  {
1765  if ((r1->names[i] != NULL) && (r2->names[i] != NULL))
1766  {
1767  if (strcmp(r1->names[i], r2->names[i])) return FALSE;
1768  }
1769  else if ((r1->names[i] != NULL) ^ (r2->names[i] != NULL))
1770  {
1771  return FALSE;
1772  }
1773  }
1774 
1775  if (qr)
1776  {
1777  if (r1->qideal != NULL)
1778  {
1779  ideal id1 = r1->qideal, id2 = r2->qideal;
1780  int i, n;
1781  poly *m1, *m2;
1782 
1783  if (id2 == NULL) return FALSE;
1784  if ((n = IDELEMS(id1)) != IDELEMS(id2)) return FALSE;
1785 
1786  {
1787  m1 = id1->m;
1788  m2 = id2->m;
1789  for (i=0; i<n; i++)
1790  if (! p_EqualPolys(m1[i],m2[i], r1, r2)) return FALSE;
1791  }
1792  }
1793  else if (r2->qideal != NULL) return FALSE;
1794  }
1795 
1796  return TRUE;
1797 }
1798 
1799 BOOLEAN rSamePolyRep(ring r1, ring r2)
1800 {
1801  int i, j;
1802 
1803  if (r1 == r2) return TRUE;
1804 
1805  if (r1 == NULL || r2 == NULL) return FALSE;
1806 
1807  if ((r1->cf != r2->cf)
1808  || (rVar(r1) != rVar(r2))
1809  || (r1->OrdSgn != r2->OrdSgn))
1810  return FALSE;
1811 
1812  i=0;
1813  while (r1->order[i] != 0)
1814  {
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]))
1819  return FALSE;
1820  if (r1->wvhdl[i] != NULL)
1821  {
1822  if (r2->wvhdl[i] == NULL)
1823  return FALSE;
1824  for (j=0; j<r1->block1[i]-r1->block0[i]+1; j++)
1825  if (r2->wvhdl[i][j] != r1->wvhdl[i][j])
1826  return FALSE;
1827  }
1828  else if (r2->wvhdl[i] != NULL) return FALSE;
1829  i++;
1830  }
1831  if (r2->order[i] != 0) return FALSE;
1832 
1833  // we do not check variable names
1834  // we do not check minpoly/minideal
1835  // we do not check qideal
1836 
1837  return TRUE;
1838 }
1839 
1841 {
1842  // check for simple ordering
1843  if (rHasSimpleOrder(r))
1844  {
1845  if ((r->order[1] == ringorder_c)
1846  || (r->order[1] == ringorder_C))
1847  {
1848  switch(r->order[0])
1849  {
1850  case ringorder_dp:
1851  case ringorder_wp:
1852  case ringorder_ds:
1853  case ringorder_ws:
1854  case ringorder_ls:
1855  case ringorder_unspec:
1856  if (r->order[1] == ringorder_C
1857  || r->order[0] == ringorder_unspec)
1858  return rOrderType_ExpComp;
1859  return rOrderType_Exp;
1860 
1861  default:
1862  assume(r->order[0] == ringorder_lp ||
1863  r->order[0] == ringorder_rs ||
1864  r->order[0] == ringorder_Dp ||
1865  r->order[0] == ringorder_Wp ||
1866  r->order[0] == ringorder_Ds ||
1867  r->order[0] == ringorder_Ws);
1868 
1869  if (r->order[1] == ringorder_c) return rOrderType_ExpComp;
1870  return rOrderType_Exp;
1871  }
1872  }
1873  else
1874  {
1875  assume((r->order[0]==ringorder_c)||(r->order[0]==ringorder_C));
1876  return rOrderType_CompExp;
1877  }
1878  }
1879  else
1880  return rOrderType_General;
1881 }
1882 
1884 {
1885  return (r->order[0] == ringorder_c);
1886 }
1888 {
1889  if (r->order[0] == ringorder_unspec) return TRUE;
1890  int blocks = rBlocks(r) - 1;
1891  assume(blocks >= 1);
1892  if (blocks == 1) return TRUE;
1893 
1894  int s = 0;
1895  while( (s < blocks) && (r->order[s] == ringorder_IS) && (r->order[blocks-1] == ringorder_IS) )
1896  {
1897  s++;
1898  blocks--;
1899  }
1900 
1901  if ((blocks - s) > 2) return FALSE;
1902 
1903  assume( blocks == s + 2 );
1904 
1905  if (
1906  (r->order[s] != ringorder_c)
1907  && (r->order[s] != ringorder_C)
1908  && (r->order[s+1] != ringorder_c)
1909  && (r->order[s+1] != ringorder_C)
1910  )
1911  return FALSE;
1912  if ((r->order[s+1] == ringorder_M)
1913  || (r->order[s] == ringorder_M))
1914  return FALSE;
1915  return TRUE;
1916 }
1917 
1918 // returns TRUE, if simple lp or ls ordering
1920 {
1921  return rHasSimpleOrder(r) &&
1922  (r->order[0] == ringorder_ls ||
1923  r->order[0] == ringorder_lp ||
1924  r->order[1] == ringorder_ls ||
1925  r->order[1] == ringorder_lp);
1926 }
1927 
1929 {
1930  switch(order)
1931  {
1932  case ringorder_dp:
1933  case ringorder_Dp:
1934  case ringorder_ds:
1935  case ringorder_Ds:
1936  case ringorder_Ws:
1937  case ringorder_Wp:
1938  case ringorder_ws:
1939  case ringorder_wp:
1940  return TRUE;
1941 
1942  default:
1943  return FALSE;
1944  }
1945 }
1946 
1948 {
1949  switch(order)
1950  {
1951  case ringorder_Ws:
1952  case ringorder_Wp:
1953  case ringorder_ws:
1954  case ringorder_wp:
1955  return TRUE;
1956 
1957  default:
1958  return FALSE;
1959  }
1960 }
1961 
1963 {
1964  if (r->order[0] == ringorder_unspec) return TRUE;
1965  int blocks = rBlocks(r) - 1;
1966  assume(blocks >= 1);
1967  if (blocks == 1) return TRUE;
1968 
1969  int s = 0;
1970  while( (s < blocks) && (r->order[s] == ringorder_IS) && (r->order[blocks-1] == ringorder_IS) )
1971  {
1972  s++;
1973  blocks--;
1974  }
1975 
1976  if ((blocks - s) > 3) return FALSE;
1977 
1978 // if ((blocks > 3) || (blocks < 2)) return FALSE;
1979  if ((blocks - s) == 3)
1980  {
1981  return (((r->order[s] == ringorder_aa) && (r->order[s+1] != ringorder_M) &&
1982  ((r->order[s+2] == ringorder_c) || (r->order[s+2] == ringorder_C))) ||
1983  (((r->order[s] == ringorder_c) || (r->order[s] == ringorder_C)) &&
1984  (r->order[s+1] == ringorder_aa) && (r->order[s+2] != ringorder_M)));
1985  }
1986  else
1987  {
1988  return ((r->order[s] == ringorder_aa) && (r->order[s+1] != ringorder_M));
1989  }
1990 }
1991 
1992 // return TRUE if p_SetComp requires p_Setm
1994 {
1995  if (r->typ != NULL)
1996  {
1997  int pos;
1998  for (pos=0;pos<r->OrdSize;pos++)
1999  {
2000  sro_ord* o=&(r->typ[pos]);
2001  if ( (o->ord_typ == ro_syzcomp)
2002  || (o->ord_typ == ro_syz)
2003  || (o->ord_typ == ro_is)
2004  || (o->ord_typ == ro_am)
2005  || (o->ord_typ == ro_isTemp))
2006  return TRUE;
2007  }
2008  }
2009  return FALSE;
2010 }
2011 
2012 // return TRUE if p->exp[r->pOrdIndex] holds total degree of p */
2014 {
2015  // Hmm.... what about Syz orderings?
2016  return (rVar(r) > 1 &&
2017  ((rHasSimpleOrder(r) &&
2018  (rOrder_is_DegOrdering((rRingOrder_t)r->order[0]) ||
2019  rOrder_is_DegOrdering(( rRingOrder_t)r->order[1]))) ||
2020  (rHasSimpleOrderAA(r) &&
2021  (rOrder_is_DegOrdering((rRingOrder_t)r->order[1]) ||
2022  ((r->order[1]!=0) &&
2023  rOrder_is_DegOrdering((rRingOrder_t)r->order[2]))))));
2024 }
2025 
2026 // return TRUE if p->exp[r->pOrdIndex] holds a weighted degree of p */
2028 {
2029  // Hmm.... what about Syz orderings?
2030  return ((rVar(r) > 1) &&
2031  rHasSimpleOrder(r) &&
2032  (rOrder_is_WeightedOrdering((rRingOrder_t)r->order[0]) ||
2033  rOrder_is_WeightedOrdering(( rRingOrder_t)r->order[1])));
2034 }
2035 
2036 #ifdef RDEBUG
2037 // This should eventually become a full-fledge ring check, like pTest
2038 BOOLEAN rDBTest(ring r, const char* fn, const int l)
2039 {
2040  int i,j;
2041 
2042  if (r == NULL)
2043  {
2044  dReportError("Null ring in %s:%d", fn, l);
2045  return FALSE;
2046  }
2047 
2048 
2049  if (r->N == 0) return TRUE;
2050 
2051  if ((r->OrdSgn!=1) && (r->OrdSgn!= -1))
2052  {
2053  dReportError("missing OrdSgn in %s:%d", fn, l);
2054  return FALSE;
2055  }
2056 
2057 // omCheckAddrSize(r,sizeof(ip_sring));
2058 #if OM_CHECK > 0
2059  i=rBlocks(r);
2060  omCheckAddrSize(r->order,i*sizeof(int));
2061  omCheckAddrSize(r->block0,i*sizeof(int));
2062  omCheckAddrSize(r->block1,i*sizeof(int));
2063  for(int j=0;j<=i;j++)
2064  {
2065  if((r->order[j]<0)||(r->order[j]>ringorder_unspec))
2066  dError("wrong order in r->order");
2067  }
2068  if (r->wvhdl!=NULL)
2069  {
2070  omCheckAddrSize(r->wvhdl,i*sizeof(int *));
2071  for (j=0;j<i; j++)
2072  {
2073  if (r->wvhdl[j] != NULL) omCheckAddr(r->wvhdl[j]);
2074  }
2075  }
2076 #endif
2077  if (r->VarOffset == NULL)
2078  {
2079  dReportError("Null ring VarOffset -- no rComplete (?) in n %s:%d", fn, l);
2080  return FALSE;
2081  }
2082  omCheckAddrSize(r->VarOffset,(r->N+1)*sizeof(int));
2083 
2084  if ((r->OrdSize==0)!=(r->typ==NULL))
2085  {
2086  dReportError("mismatch OrdSize and typ-pointer in %s:%d");
2087  return FALSE;
2088  }
2089  omcheckAddrSize(r->typ,r->OrdSize*sizeof(*(r->typ)));
2090  omCheckAddrSize(r->VarOffset,(r->N+1)*sizeof(*(r->VarOffset)));
2091  // test assumptions:
2092  for(i=0;i<=r->N;i++) // for all variables (i = 0..N)
2093  {
2094  if(r->typ!=NULL)
2095  {
2096  for(j=0;j<r->OrdSize;j++) // for all ordering blocks (j =0..OrdSize-1)
2097  {
2098  if(r->typ[j].ord_typ == ro_isTemp)
2099  {
2100  const int p = r->typ[j].data.isTemp.suffixpos;
2101 
2102  if(p <= j)
2103  dReportError("ordrec prefix %d is unmatched",j);
2104 
2105  assume( p < r->OrdSize );
2106 
2107  if(r->typ[p].ord_typ != ro_is)
2108  dReportError("ordrec prefix %d is unmatched (suffix: %d is wrong!!!)",j, p);
2109 
2110  // Skip all intermediate blocks for undone variables:
2111  if(r->typ[j].data.isTemp.pVarOffset[i] != -1) // Check i^th variable
2112  {
2113  j = p - 1; // SKIP ALL INTERNAL BLOCKS...???
2114  continue; // To make for check OrdSize bound...
2115  }
2116  }
2117  else if (r->typ[j].ord_typ == ro_is)
2118  {
2119  // Skip all intermediate blocks for undone variables:
2120  if(r->typ[j].data.is.pVarOffset[i] != -1)
2121  {
2122  // TODO???
2123  }
2124 
2125  }
2126  else
2127  {
2128  if (r->typ[j].ord_typ==ro_cp)
2129  {
2130  if(((short)r->VarOffset[i]) == r->typ[j].data.cp.place)
2131  dReportError("ordrec %d conflicts with var %d",j,i);
2132  }
2133  else
2134  if ((r->typ[j].ord_typ!=ro_syzcomp)
2135  && (r->VarOffset[i] == r->typ[j].data.dp.place))
2136  dReportError("ordrec %d conflicts with var %d",j,i);
2137  }
2138  }
2139  }
2140  int tmp;
2141  tmp=r->VarOffset[i] & 0xffffff;
2142  #if SIZEOF_LONG == 8
2143  if ((r->VarOffset[i] >> 24) >63)
2144  #else
2145  if ((r->VarOffset[i] >> 24) >31)
2146  #endif
2147  dReportError("bit_start out of range:%d",r->VarOffset[i] >> 24);
2148  if (i > 0 && ((tmp<0) ||(tmp>r->ExpL_Size-1)))
2149  {
2150  dReportError("varoffset out of range for var %d: %d",i,tmp);
2151  }
2152  }
2153  if(r->typ!=NULL)
2154  {
2155  for(j=0;j<r->OrdSize;j++)
2156  {
2157  if ((r->typ[j].ord_typ==ro_dp)
2158  || (r->typ[j].ord_typ==ro_wp)
2159  || (r->typ[j].ord_typ==ro_wp_neg))
2160  {
2161  if (r->typ[j].data.dp.start > r->typ[j].data.dp.end)
2162  dReportError("in ordrec %d: start(%d) > end(%d)",j,
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);
2168  }
2169  }
2170  }
2171 
2172  assume(r != NULL);
2173  assume(r->cf != NULL);
2174 
2175  if (nCoeff_is_algExt(r->cf))
2176  {
2177  assume(r->cf->extRing != NULL);
2178  assume(r->cf->extRing->qideal != NULL);
2179  omCheckAddr(r->cf->extRing->qideal->m[0]);
2180  }
2181 
2182  //assume(r->cf!=NULL);
2183 
2184  return TRUE;
2185 }
2186 #endif
2187 
2188 static void rO_Align(int &place, int &bitplace)
2189 {
2190  // increment place to the next aligned one
2191  // (count as Exponent_t,align as longs)
2192  if (bitplace!=BITS_PER_LONG)
2193  {
2194  place++;
2195  bitplace=BITS_PER_LONG;
2196  }
2197 }
2198 
2199 static void rO_TDegree(int &place, int &bitplace, int start, int end,
2200  long *o, sro_ord &ord_struct)
2201 {
2202  // degree (aligned) of variables v_start..v_end, ordsgn 1
2203  rO_Align(place,bitplace);
2204  ord_struct.ord_typ=ro_dp;
2205  ord_struct.data.dp.start=start;
2206  ord_struct.data.dp.end=end;
2207  ord_struct.data.dp.place=place;
2208  o[place]=1;
2209  place++;
2210  rO_Align(place,bitplace);
2211 }
2212 
2213 static void rO_TDegree_neg(int &place, int &bitplace, int start, int end,
2214  long *o, sro_ord &ord_struct)
2215 {
2216  // degree (aligned) of variables v_start..v_end, ordsgn -1
2217  rO_Align(place,bitplace);
2218  ord_struct.ord_typ=ro_dp;
2219  ord_struct.data.dp.start=start;
2220  ord_struct.data.dp.end=end;
2221  ord_struct.data.dp.place=place;
2222  o[place]=-1;
2223  place++;
2224  rO_Align(place,bitplace);
2225 }
2226 
2227 static void rO_WDegree(int &place, int &bitplace, int start, int end,
2228  long *o, sro_ord &ord_struct, int *weights)
2229 {
2230  // weighted degree (aligned) of variables v_start..v_end, ordsgn 1
2231  while((start<end) && (weights[0]==0)) { start++; weights++; }
2232  while((start<end) && (weights[end-start]==0)) { end--; }
2233  int i;
2234  int pure_tdeg=1;
2235  for(i=start;i<=end;i++)
2236  {
2237  if(weights[i-start]!=1)
2238  {
2239  pure_tdeg=0;
2240  break;
2241  }
2242  }
2243  if (pure_tdeg)
2244  {
2245  rO_TDegree(place,bitplace,start,end,o,ord_struct);
2246  return;
2247  }
2248  rO_Align(place,bitplace);
2249  ord_struct.ord_typ=ro_wp;
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;
2254  o[place]=1;
2255  place++;
2256  rO_Align(place,bitplace);
2257  for(i=start;i<=end;i++)
2258  {
2259  if(weights[i-start]<0)
2260  {
2261  ord_struct.ord_typ=ro_wp_neg;
2262  break;
2263  }
2264  }
2265 }
2266 
2267 static void rO_WMDegree(int &place, int &bitplace, int start, int end,
2268  long *o, sro_ord &ord_struct, int *weights)
2269 {
2270  assume(weights != NULL);
2271 
2272  // weighted degree (aligned) of variables v_start..v_end, ordsgn 1
2273 // while((start<end) && (weights[0]==0)) { start++; weights++; }
2274 // while((start<end) && (weights[end-start]==0)) { end--; }
2275  rO_Align(place,bitplace);
2276  ord_struct.ord_typ=ro_am;
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 );
2284  o[place]=1;
2285  place++;
2286  rO_Align(place,bitplace);
2287 }
2288 
2289 static void rO_WDegree64(int &place, int &bitplace, int start, int end,
2290  long *o, sro_ord &ord_struct, int64 *weights)
2291 {
2292  // weighted degree (aligned) of variables v_start..v_end, ordsgn 1,
2293  // reserved 2 places
2294  rO_Align(place,bitplace);
2295  ord_struct.ord_typ=ro_wp64;
2296  ord_struct.data.wp64.start=start;
2297  ord_struct.data.wp64.end=end;
2298  ord_struct.data.wp64.place=place;
2299  #ifdef HAVE_OMALLOC
2300  ord_struct.data.wp64.weights64=weights;
2301  #else
2302  int l=end-start+1;
2303  ord_struct.data.wp64.weights64=(int64*)omAlloc(l*sizeof(int64));
2304  for(int i=0;i<l;i++) ord_struct.data.wp64.weights64[i]=weights[i];
2305  #endif
2306  o[place]=1;
2307  place++;
2308  o[place]=1;
2309  place++;
2310  rO_Align(place,bitplace);
2311 }
2312 
2313 static void rO_WDegree_neg(int &place, int &bitplace, int start, int end,
2314  long *o, sro_ord &ord_struct, int *weights)
2315 {
2316  // weighted degree (aligned) of variables v_start..v_end, ordsgn -1
2317  while((start<end) && (weights[0]==0)) { start++; weights++; }
2318  while((start<end) && (weights[end-start]==0)) { end--; }
2319  rO_Align(place,bitplace);
2320  ord_struct.ord_typ=ro_wp;
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;
2325  o[place]=-1;
2326  place++;
2327  rO_Align(place,bitplace);
2328  int i;
2329  for(i=start;i<=end;i++)
2330  {
2331  if(weights[i-start]<0)
2332  {
2333  ord_struct.ord_typ=ro_wp_neg;
2334  break;
2335  }
2336  }
2337 }
2338 
2339 static void rO_LexVars(int &place, int &bitplace, int start, int end,
2340  int &prev_ord, long *o,int *v, int bits, int opt_var)
2341 {
2342  // a block of variables v_start..v_end with lex order, ordsgn 1
2343  int k;
2344  int incr=1;
2345  if(prev_ord==-1) rO_Align(place,bitplace);
2346 
2347  if (start>end)
2348  {
2349  incr=-1;
2350  }
2351  for(k=start;;k+=incr)
2352  {
2353  bitplace-=bits;
2354  if (bitplace < 0) { bitplace=BITS_PER_LONG-bits; place++; }
2355  o[place]=1;
2356  v[k]= place | (bitplace << 24);
2357  if (k==end) break;
2358  }
2359  prev_ord=1;
2360  if (opt_var!= -1)
2361  {
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;
2365  bitplace-=bits;
2366  if (bitplace < 0)
2367  {
2368  bitplace=save_bitplace;
2369  return;
2370  }
2371  // there is enough space for the optional var
2372  v[opt_var]=place | (bitplace << 24);
2373  }
2374 }
2375 
2376 static void rO_LexVars_neg(int &place, int &bitplace, int start, int end,
2377  int &prev_ord, long *o,int *v, int bits, int opt_var)
2378 {
2379  // a block of variables v_start..v_end with lex order, ordsgn -1
2380  int k;
2381  int incr=1;
2382  if(prev_ord==1) rO_Align(place,bitplace);
2383 
2384  if (start>end)
2385  {
2386  incr=-1;
2387  }
2388  for(k=start;;k+=incr)
2389  {
2390  bitplace-=bits;
2391  if (bitplace < 0) { bitplace=BITS_PER_LONG-bits; place++; }
2392  o[place]=-1;
2393  v[k]=place | (bitplace << 24);
2394  if (k==end) break;
2395  }
2396  prev_ord=-1;
2397 // #if 0
2398  if (opt_var!= -1)
2399  {
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;
2403  bitplace-=bits;
2404  if (bitplace < 0)
2405  {
2406  bitplace=save_bitplace;
2407  return;
2408  }
2409  // there is enough space for the optional var
2410  v[opt_var]=place | (bitplace << 24);
2411  }
2412 // #endif
2413 }
2414 
2415 static void rO_Syzcomp(int &place, int &bitplace, int &prev_ord,
2416  long *o, sro_ord &ord_struct)
2417 {
2418  // ordering is derived from component number
2419  rO_Align(place,bitplace);
2420  ord_struct.ord_typ=ro_syzcomp;
2421  ord_struct.data.syzcomp.place=place;
2422  ord_struct.data.syzcomp.Components=NULL;
2423  ord_struct.data.syzcomp.ShiftedComponents=NULL;
2424  o[place]=1;
2425  prev_ord=1;
2426  place++;
2427  rO_Align(place,bitplace);
2428 }
2429 
2430 static void rO_Syz(int &place, int &bitplace, int &prev_ord,
2431  int syz_comp, long *o, sro_ord &ord_struct)
2432 {
2433  // ordering is derived from component number
2434  // let's reserve one Exponent_t for it
2435  if ((prev_ord== 1) || (bitplace!=BITS_PER_LONG))
2436  rO_Align(place,bitplace);
2437  ord_struct.ord_typ=ro_syz;
2438  ord_struct.data.syz.place=place;
2439  ord_struct.data.syz.limit=syz_comp;
2440  if (syz_comp>0)
2441  ord_struct.data.syz.syz_index = (int*) omAlloc0((syz_comp+1)*sizeof(int));
2442  else
2443  ord_struct.data.syz.syz_index = NULL;
2444  ord_struct.data.syz.curr_index = 1;
2445  o[place]= -1;
2446  prev_ord=-1;
2447  place++;
2448 }
2449 
2450 #ifndef SING_NDEBUG
2451 # define MYTEST 0
2452 #else /* ifndef SING_NDEBUG */
2453 # define MYTEST 0
2454 #endif /* ifndef SING_NDEBUG */
2455 
2456 static void rO_ISPrefix(int &place, int &bitplace, int &prev_ord,
2457  long *o, int N, int *v, sro_ord &ord_struct)
2458 {
2459  if ((prev_ord== 1) || (bitplace!=BITS_PER_LONG))
2460  rO_Align(place,bitplace);
2461  // since we add something afterwards - it's better to start with anew!?
2462 
2463  ord_struct.ord_typ = ro_isTemp;
2464  ord_struct.data.isTemp.start = place;
2465  #ifdef HAVE_OMALLOC
2466  ord_struct.data.isTemp.pVarOffset = (int *)omMemDup(v);
2467  #else
2468  ord_struct.data.isTemp.pVarOffset = (int *)omAlloc((N+1)*sizeof(int));
2469  memcpy(ord_struct.data.isTemp.pVarOffset,v,(N+1)*sizeof(int));
2470  #endif
2471  ord_struct.data.isTemp.suffixpos = -1;
2472 
2473  // We will act as rO_Syz on our own!!!
2474  // Here we allocate an exponent as a level placeholder
2475  o[place]= -1;
2476  prev_ord=-1;
2477  place++;
2478 }
2479 static void rO_ISSuffix(int &place, int &bitplace, int &prev_ord, long *o,
2480  int N, int *v, sro_ord *tmp_typ, int &typ_i, int sgn)
2481 {
2482 
2483  // Let's find previous prefix:
2484  int typ_j = typ_i - 1;
2485  while(typ_j >= 0)
2486  {
2487  if( tmp_typ[typ_j].ord_typ == ro_isTemp)
2488  break;
2489  typ_j --;
2490  }
2491 
2492  assume( typ_j >= 0 );
2493 
2494  if( typ_j < 0 ) // Found NO prefix!!! :(
2495  return;
2496 
2497  assume( tmp_typ[typ_j].ord_typ == ro_isTemp );
2498 
2499  // Get saved state:
2500  const int start = tmp_typ[typ_j].data.isTemp.start;
2501  int *pVarOffset = tmp_typ[typ_j].data.isTemp.pVarOffset;
2502 
2503 /*
2504  // shift up all blocks
2505  while(typ_j < (typ_i-1))
2506  {
2507  tmp_typ[typ_j] = tmp_typ[typ_j+1];
2508  typ_j++;
2509  }
2510  typ_j = typ_i - 1; // No increment for typ_i
2511 */
2512  tmp_typ[typ_j].data.isTemp.suffixpos = typ_i;
2513 
2514  // Let's keep that dummy for now...
2515  typ_j = typ_i; // the typ to change!
2516  typ_i++; // Just for now...
2517 
2518 
2519  for( int i = 0; i <= N; i++ ) // Note [0] == component !!! No Skip?
2520  {
2521  // Was i-th variable allocated inbetween?
2522  if( v[i] != pVarOffset[i] )
2523  {
2524  pVarOffset[i] = v[i]; // Save for later...
2525  v[i] = -1; // Undo!
2526  assume( pVarOffset[i] != -1 );
2527  }
2528  else
2529  pVarOffset[i] = -1; // No change here...
2530  }
2531 
2532  if( pVarOffset[0] != -1 )
2533  pVarOffset[0] &= 0x0fff;
2534 
2535  sro_ord &ord_struct = tmp_typ[typ_j];
2536 
2537 
2538  ord_struct.ord_typ = ro_is;
2539  ord_struct.data.is.start = start;
2540  ord_struct.data.is.end = place;
2541  ord_struct.data.is.pVarOffset = pVarOffset;
2542 
2543 
2544  // What about component???
2545 // if( v[0] != -1 ) // There is a component already...???
2546 // if( o[ v[0] & 0x0fff ] == sgn )
2547 // {
2548 // pVarOffset[0] = -1; // NEVER USED Afterwards...
2549 // return;
2550 // }
2551 
2552 
2553  // Moreover: we need to allocate the module component (v[0]) here!
2554  if( v[0] == -1) // It's possible that there was module component v0 at the begining (before prefix)!
2555  {
2556  // Start with a whole long exponent
2557  if( bitplace != BITS_PER_LONG )
2558  rO_Align(place, bitplace);
2559 
2560  assume( bitplace == BITS_PER_LONG );
2561  bitplace -= BITS_PER_LONG;
2562  assume(bitplace == 0);
2563  v[0] = place | (bitplace << 24); // Never mind whether pVarOffset[0] > 0!!!
2564  o[place] = sgn; // Singnum for component ordering
2565  prev_ord = sgn;
2566  }
2567 }
2568 
2569 
2570 static unsigned long rGetExpSize(unsigned long bitmask, int & bits)
2571 {
2572  if (bitmask == 0)
2573  {
2574  bits=16; bitmask=0xffff;
2575  }
2576  else if (bitmask <= 1L)
2577  {
2578  bits=1; bitmask = 1L;
2579  }
2580  else if (bitmask <= 3L)
2581  {
2582  bits=2; bitmask = 3L;
2583  }
2584  else if (bitmask <= 7L)
2585  {
2586  bits=3; bitmask=7L;
2587  }
2588  else if (bitmask <= 0xfL)
2589  {
2590  bits=4; bitmask=0xfL;
2591  }
2592  else if (bitmask <= 0x1fL)
2593  {
2594  bits=5; bitmask=0x1fL;
2595  }
2596  else if (bitmask <= 0x3fL)
2597  {
2598  bits=6; bitmask=0x3fL;
2599  }
2600 #if SIZEOF_LONG == 8
2601  else if (bitmask <= 0x7fL)
2602  {
2603  bits=7; bitmask=0x7fL; /* 64 bit longs only */
2604  }
2605 #endif
2606  else if (bitmask <= 0xffL)
2607  {
2608  bits=8; bitmask=0xffL;
2609  }
2610 #if SIZEOF_LONG == 8
2611  else if (bitmask <= 0x1ffL)
2612  {
2613  bits=9; bitmask=0x1ffL; /* 64 bit longs only */
2614  }
2615 #endif
2616  else if (bitmask <= 0x3ffL)
2617  {
2618  bits=10; bitmask=0x3ffL;
2619  }
2620 #if SIZEOF_LONG == 8
2621  else if (bitmask <= 0xfffL)
2622  {
2623  bits=12; bitmask=0xfff; /* 64 bit longs only */
2624  }
2625 #endif
2626  else if (bitmask <= 0xffffL)
2627  {
2628  bits=16; bitmask=0xffffL;
2629  }
2630 #if SIZEOF_LONG == 8
2631  else if (bitmask <= 0xfffffL)
2632  {
2633  bits=20; bitmask=0xfffffL; /* 64 bit longs only */
2634  }
2635  else if (bitmask <= 0xffffffffL)
2636  {
2637  bits=32; bitmask=0xffffffffL;
2638  }
2639  else if (bitmask <= 0x7fffffffffffffffL)
2640  {
2641  bits=63; bitmask=0x7fffffffffffffffL; /* for overflow tests*/
2642  }
2643  else
2644  {
2645  bits=63; bitmask=0x7fffffffffffffffL; /* for overflow tests*/
2646  }
2647 #else
2648  else if (bitmask <= 0x7fffffff)
2649  {
2650  bits=31; bitmask=0x7fffffff; /* for overflow tests*/
2651  }
2652  else
2653  {
2654  bits=31; bitmask=0x7fffffffL; /* for overflow tests*/
2655  }
2656 #endif
2657  return bitmask;
2658 }
2659 
2660 /*2
2661 * optimize rGetExpSize for a block of N variables, exp <=bitmask
2662 */
2663 unsigned long rGetExpSize(unsigned long bitmask, int & bits, int N)
2664 {
2665  bitmask =rGetExpSize(bitmask, bits);
2666  int vars_per_long=BIT_SIZEOF_LONG/bits;
2667  int bits1;
2668  loop
2669  {
2670  if (bits == BIT_SIZEOF_LONG-1)
2671  {
2672  bits = BIT_SIZEOF_LONG - 1;
2673  return LONG_MAX;
2674  }
2675  unsigned long bitmask1 =rGetExpSize(bitmask+1, bits1);
2676  int vars_per_long1=BIT_SIZEOF_LONG/bits1;
2677  if ((((N+vars_per_long-1)/vars_per_long) ==
2678  ((N+vars_per_long1-1)/vars_per_long1)))
2679  {
2680  vars_per_long=vars_per_long1;
2681  bits=bits1;
2682  bitmask=bitmask1;
2683  }
2684  else
2685  {
2686  return bitmask; /* and bits */
2687  }
2688  }
2689 }
2690 
2691 
2692 /*2
2693  * create a copy of the ring r, which must be equivalent to currRing
2694  * used for std computations
2695  * may share data structures with currRing
2696  * DOES CALL rComplete
2697  */
2698 ring rModifyRing(ring r, BOOLEAN omit_degree,
2699  BOOLEAN try_omit_comp,
2700  unsigned long exp_limit)
2701 {
2702  assume (r != NULL );
2703  assume (exp_limit > 1);
2704  BOOLEAN omitted_degree = FALSE;
2705 
2706  int bits;
2707  exp_limit=rGetExpSize(exp_limit, bits, r->N);
2708  BOOLEAN need_other_ring = (exp_limit != r->bitmask);
2709 
2710  int iNeedInducedOrderingSetup = 0; ///< How many induced ordering block do we have?
2711 
2712  int nblocks=rBlocks(r);
2713  rRingOrder_t *order=(rRingOrder_t*)omAlloc0((nblocks+1)*sizeof(rRingOrder_t));
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 *));
2717 
2718  int i=0;
2719  int j=0; /* i index in r, j index in res */
2720 
2721  for( rRingOrder_t r_ord=r->order[i]; (r_ord != (rRingOrder_t)0) && (i < nblocks); j++, r_ord=r->order[++i])
2722  {
2723  BOOLEAN copy_block_index=TRUE;
2724 
2725  if (r->block0[i]==r->block1[i])
2726  {
2727  switch(r_ord)
2728  {
2729  case ringorder_wp:
2730  case ringorder_dp:
2731  case ringorder_Wp:
2732  case ringorder_Dp:
2733  r_ord=ringorder_lp;
2734  break;
2735  case ringorder_Ws:
2736  case ringorder_Ds:
2737  case ringorder_ws:
2738  case ringorder_ds:
2739  r_ord=ringorder_ls;
2740  break;
2741  default:
2742  break;
2743  }
2744  }
2745  switch(r_ord)
2746  {
2747  case ringorder_S:
2748  {
2749 #ifndef SING_NDEBUG
2750  Warn("Error: unhandled ordering in rModifyRing: ringorder_S = [%d]", r_ord);
2751 #endif
2752  order[j]=r_ord; /*r->order[i];*/
2753  break;
2754  }
2755  case ringorder_C:
2756  case ringorder_c:
2757  if (!try_omit_comp)
2758  {
2759  order[j]=r_ord; /*r->order[i]*/;
2760  }
2761  else
2762  {
2763  j--;
2764  need_other_ring=TRUE;
2765  try_omit_comp=FALSE;
2766  copy_block_index=FALSE;
2767  }
2768  break;
2769  case ringorder_wp:
2770  case ringorder_dp:
2771  case ringorder_ws:
2772  case ringorder_ds:
2773  if(!omit_degree)
2774  {
2775  order[j]=r_ord; /*r->order[i]*/;
2776  }
2777  else
2778  {
2779  order[j]=ringorder_rs;
2780  need_other_ring=TRUE;
2781  omit_degree=FALSE;
2782  omitted_degree = TRUE;
2783  }
2784  break;
2785  case ringorder_Wp:
2786  case ringorder_Dp:
2787  case ringorder_Ws:
2788  case ringorder_Ds:
2789  if(!omit_degree)
2790  {
2791  order[j]=r_ord; /*r->order[i];*/
2792  }
2793  else
2794  {
2795  order[j]=ringorder_lp;
2796  need_other_ring=TRUE;
2797  omit_degree=FALSE;
2798  omitted_degree = TRUE;
2799  }
2800  break;
2801  case ringorder_IS:
2802  {
2803  if (try_omit_comp)
2804  {
2805  // tried, but cannot omit component due to the ordering block [%d]: %d (ringorder_IS)", i, r_ord
2806  try_omit_comp = FALSE;
2807  }
2808  order[j]=r_ord; /*r->order[i];*/
2809  iNeedInducedOrderingSetup++;
2810  break;
2811  }
2812  case ringorder_s:
2813  {
2814  assume((i == 0) && (j == 0));
2815  if (try_omit_comp)
2816  {
2817  // tried, but cannot omit component due to the ordering block [%d]: %d (ringorder_s)", i, r_ord
2818  try_omit_comp = FALSE;
2819  }
2820  order[j]=r_ord; /*r->order[i];*/
2821  break;
2822  }
2823  default:
2824  order[j]=r_ord; /*r->order[i];*/
2825  break;
2826  }
2827  if (copy_block_index)
2828  {
2829  block0[j]=r->block0[i];
2830  block1[j]=r->block1[i];
2831  wvhdl[j]=r->wvhdl[i];
2832  }
2833 
2834  // order[j]=ringorder_no; // done by omAlloc0
2835  }
2836  if(!need_other_ring)
2837  {
2838  omFreeSize(order,(nblocks+1)*sizeof(rRingOrder_t));
2839  omFreeSize(block0,(nblocks+1)*sizeof(int));
2840  omFreeSize(block1,(nblocks+1)*sizeof(int));
2841  omFreeSize(wvhdl,(nblocks+1)*sizeof(int *));
2842  return r;
2843  }
2844  ring res=(ring)omAlloc0Bin(sip_sring_bin);
2845  *res = *r;
2846 
2847 #ifdef HAVE_PLURAL
2848  res->GetNC() = NULL;
2849 #endif
2850 
2851  // res->qideal, res->idroot ???
2852  res->wvhdl=wvhdl;
2853  res->order=order;
2854  res->block0=block0;
2855  res->block1=block1;
2856  res->bitmask=exp_limit;
2857  res->wanted_maxExp=r->wanted_maxExp;
2858  //int tmpref=r->cf->ref0;
2859  rComplete(res, 1);
2860  //r->cf->ref=tmpref;
2861 
2862  // adjust res->pFDeg: if it was changed globally, then
2863  // it must also be changed for new ring
2864  if (r->pFDegOrig != res->pFDegOrig &&
2866  {
2867  // still might need adjustment for weighted orderings
2868  // and omit_degree
2869  res->firstwv = r->firstwv;
2870  res->firstBlockEnds = r->firstBlockEnds;
2871  res->pFDeg = res->pFDegOrig = p_WFirstTotalDegree;
2872  }
2873  if (omitted_degree)
2874  res->pLDeg = r->pLDegOrig;
2875 
2876  rOptimizeLDeg(res); // also sets res->pLDegOrig
2877 
2878  // set syzcomp
2879  if (res->typ != NULL)
2880  {
2881  if( res->typ[0].ord_typ == ro_syz) // "s" Always on [0] place!
2882  {
2883  res->typ[0] = r->typ[0]; // Copy struct!? + setup the same limit!
2884 
2885  if (r->typ[0].data.syz.limit > 0)
2886  {
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));
2891  }
2892  }
2893 
2894  if( iNeedInducedOrderingSetup > 0 )
2895  {
2896  for(j = 0, i = 0; (i < nblocks) && (iNeedInducedOrderingSetup > 0); i++)
2897  if( res->typ[i].ord_typ == ro_is ) // Search for suffixes!
2898  {
2899  ideal F = idrHeadR(r->typ[i].data.is.F, r, res); // Copy F from r into res!
2900  assume(
2902  F, // WILL BE COPIED!
2903  r->typ[i].data.is.limit,
2904  j++
2905  )
2906  );
2907  id_Delete(&F, res);
2908  iNeedInducedOrderingSetup--;
2909  }
2910  } // Process all induced Ordering blocks! ...
2911  }
2912  // the special case: homog (omit_degree) and 1 block rs: that is global:
2913  // it comes from dp
2914  res->OrdSgn=r->OrdSgn;
2915 
2916 
2917 #ifdef HAVE_PLURAL
2918  if (rIsPluralRing(r))
2919  {
2920  if ( nc_rComplete(r, res, false) ) // no qideal!
2921  {
2922 #ifndef SING_NDEBUG
2923  WarnS("error in nc_rComplete");
2924 #endif
2925  // cleanup?
2926 
2927 // rDelete(res);
2928 // return r;
2929 
2930  // just go on..
2931  }
2932 
2933  if( rIsSCA(r) )
2934  {
2935  if( !sca_Force(res, scaFirstAltVar(r), scaLastAltVar(r)) )
2936  WarnS("error in sca_Force!");
2937  }
2938  }
2939 #endif
2940 
2941  return res;
2942 }
2943 
2944 // construct Wp,C ring
2945 ring rModifyRing_Wp(ring r, int* weights)
2946 {
2947  ring res=(ring)omAlloc0Bin(sip_sring_bin);
2948  *res = *r;
2949 #ifdef HAVE_PLURAL
2950  res->GetNC() = NULL;
2951 #endif
2952 
2953  /*weights: entries for 3 blocks: NULL*/
2954  res->wvhdl = (int **)omAlloc0(3 * sizeof(int *));
2955  /*order: Wp,C,0*/
2956  res->order = (rRingOrder_t *) omAlloc(3 * sizeof(rRingOrder_t *));
2957  res->block0 = (int *)omAlloc0(3 * sizeof(int *));
2958  res->block1 = (int *)omAlloc0(3 * sizeof(int *));
2959  /* ringorder Wp for the first block: var 1..r->N */
2960  res->order[0] = ringorder_Wp;
2961  res->block0[0] = 1;
2962  res->block1[0] = r->N;
2963  res->wvhdl[0] = weights;
2964  /* ringorder C for the second block: no vars */
2965  res->order[1] = ringorder_C;
2966  /* the last block: everything is 0 */
2967  res->order[2] = (rRingOrder_t)0;
2968 
2969  //int tmpref=r->cf->ref;
2970  rComplete(res, 1);
2971  //r->cf->ref=tmpref;
2972 #ifdef HAVE_PLURAL
2973  if (rIsPluralRing(r))
2974  {
2975  if ( nc_rComplete(r, res, false) ) // no qideal!
2976  {
2977 #ifndef SING_NDEBUG
2978  WarnS("error in nc_rComplete");
2979 #endif
2980  // cleanup?
2981 
2982 // rDelete(res);
2983 // return r;
2984 
2985  // just go on..
2986  }
2987  }
2988 #endif
2989  return res;
2990 }
2991 
2992 // construct lp, C ring with r->N variables, r->names vars....
2993 ring rModifyRing_Simple(ring r, BOOLEAN ommit_degree, BOOLEAN ommit_comp, unsigned long exp_limit, BOOLEAN &simple)
2994 {
2995  simple=TRUE;
2996  if (!rHasSimpleOrder(r))
2997  {
2998  simple=FALSE; // sorting needed
2999  assume (r != NULL );
3000  assume (exp_limit > 1);
3001  int bits;
3002 
3003  exp_limit=rGetExpSize(exp_limit, bits, r->N);
3004 
3005  int nblocks=1+(ommit_comp!=0);
3006  rRingOrder_t *order=(rRingOrder_t*)omAlloc0((nblocks+1)*sizeof(rRingOrder_t));
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 *));
3010 
3011  order[0]=ringorder_lp;
3012  block0[0]=1;
3013  block1[0]=r->N;
3014  if (!ommit_comp)
3015  {
3016  order[1]=ringorder_C;
3017  }
3018  ring res=(ring)omAlloc0Bin(sip_sring_bin);
3019  *res = *r;
3020 #ifdef HAVE_PLURAL
3021  res->GetNC() = NULL;
3022 #endif
3023  // res->qideal, res->idroot ???
3024  res->wvhdl=wvhdl;
3025  res->order=order;
3026  res->block0=block0;
3027  res->block1=block1;
3028  res->bitmask=exp_limit;
3029  res->wanted_maxExp=r->wanted_maxExp;
3030  //int tmpref=r->cf->ref;
3031  rComplete(res, 1);
3032  //r->cf->ref=tmpref;
3033 
3034 #ifdef HAVE_PLURAL
3035  if (rIsPluralRing(r))
3036  {
3037  if ( nc_rComplete(r, res, false) ) // no qideal!
3038  {
3039 #ifndef SING_NDEBUG
3040  WarnS("error in nc_rComplete");
3041 #endif
3042  // cleanup?
3043 
3044 // rDelete(res);
3045 // return r;
3046 
3047  // just go on..
3048  }
3049  }
3050 #endif
3051 
3052  rOptimizeLDeg(res);
3053 
3054  return res;
3055  }
3056  return rModifyRing(r, ommit_degree, ommit_comp, exp_limit);
3057 }
3058 
3059 void rKillModifiedRing(ring r)
3060 {
3061  rUnComplete(r);
3062  omFree(r->order);
3063  omFree(r->block0);
3064  omFree(r->block1);
3065  omFree(r->wvhdl);
3067 }
3068 
3070 {
3071  rUnComplete(r);
3072  omFree(r->order);
3073  omFree(r->block0);
3074  omFree(r->block1);
3075  omFree(r->wvhdl[0]);
3076  omFree(r->wvhdl);
3078 }
3079 
3080 static void rSetOutParams(ring r)
3081 {
3082  r->VectorOut = (r->order[0] == ringorder_c);
3083  if (rIsNCRing(r))
3084  r->CanShortOut=FALSE;
3085  else
3086  {
3087  r->CanShortOut = TRUE;
3088  int i;
3089  if (rParameter(r)!=NULL)
3090  {
3091  for (i=0;i<rPar(r);i++)
3092  {
3093  if(strlen(rParameter(r)[i])>1)
3094  {
3095  r->CanShortOut=FALSE;
3096  break;
3097  }
3098  }
3099  }
3100  if (r->CanShortOut)
3101  {
3102  int N = r->N;
3103  for (i=(N-1);i>=0;i--)
3104  {
3105  if(r->names[i] != NULL && strlen(r->names[i])>1)
3106  {
3107  r->CanShortOut=FALSE;
3108  break;
3109  }
3110  }
3111  }
3112  }
3113  r->ShortOut = r->CanShortOut;
3114 
3115  assume( !( !r->CanShortOut && r->ShortOut ) );
3116 }
3117 
3118 static void rSetFirstWv(ring r, int i, rRingOrder_t* order, int* block0, int* block1, int** wvhdl)
3119 {
3120  // cheat for ringorder_aa
3121  if (order[i] == ringorder_aa)
3122  i++;
3123  if(block1[i]!=r->N) r->LexOrder=TRUE;
3124  r->firstBlockEnds=block1[i];
3125  r->firstwv = wvhdl[i];
3126  if ((order[i]== ringorder_ws)
3127  || (order[i]==ringorder_Ws)
3128  || (order[i]== ringorder_wp)
3129  || (order[i]==ringorder_Wp)
3130  || (order[i]== ringorder_a)
3131  /*|| (order[i]==ringorder_A)*/)
3132  {
3133  int j;
3134  for(j=block1[i]-block0[i];j>=0;j--)
3135  {
3136  if (r->firstwv[j]==0) r->LexOrder=TRUE;
3137  }
3138  }
3139  else if (order[i]==ringorder_a64)
3140  {
3141  int j;
3142  int64 *w=rGetWeightVec(r);
3143  for(j=block1[i]-block0[i];j>=0;j--)
3144  {
3145  if (w[j]==0) r->LexOrder=TRUE;
3146  }
3147  }
3148 }
3149 
3150 static void rOptimizeLDeg(ring r)
3151 {
3152  if (r->pFDeg == p_Deg)
3153  {
3154  if (r->pLDeg == pLDeg1)
3155  r->pLDeg = pLDeg1_Deg;
3156  if (r->pLDeg == pLDeg1c)
3157  r->pLDeg = pLDeg1c_Deg;
3158  }
3159  else if (r->pFDeg == p_Totaldegree)
3160  {
3161  if (r->pLDeg == pLDeg1)
3162  r->pLDeg = pLDeg1_Totaldegree;
3163  if (r->pLDeg == pLDeg1c)
3164  r->pLDeg = pLDeg1c_Totaldegree;
3165  }
3166  else if (r->pFDeg == p_WFirstTotalDegree)
3167  {
3168  if (r->pLDeg == pLDeg1)
3169  r->pLDeg = pLDeg1_WFirstTotalDegree;
3170  if (r->pLDeg == pLDeg1c)
3171  r->pLDeg = pLDeg1c_WFirstTotalDegree;
3172  }
3173  r->pLDegOrig = r->pLDeg;
3174 }
3175 
3176 // set pFDeg, pLDeg, requires OrdSgn already set
3177 static void rSetDegStuff(ring r)
3178 {
3179  rRingOrder_t* order = r->order;
3180  int* block0 = r->block0;
3181  int* block1 = r->block1;
3182  int** wvhdl = r->wvhdl;
3183 
3184  if (order[0]==ringorder_S ||order[0]==ringorder_s || order[0]==ringorder_IS)
3185  {
3186  order++;
3187  block0++;
3188  block1++;
3189  wvhdl++;
3190  }
3191  r->LexOrder = FALSE;
3192  r->pFDeg = p_Totaldegree;
3193  r->pLDeg = (r->OrdSgn == 1 ? pLDegb : pLDeg0);
3194 
3195  /*======== ordering type is (am,_) ==================*/
3196  if (order[0]==ringorder_am)
3197  {
3198  for(int ii=block0[0];ii<=block1[0];ii++)
3199  if (wvhdl[0][ii-1]<0) { r->MixedOrder=2;break;}
3200  r->LexOrder=FALSE;
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))
3204  {
3205  r->pFDeg = p_Deg;
3206  r->pLDeg = pLDeg1c_Deg;
3207  }
3208  else
3209  {
3210  r->pFDeg = p_WTotaldegree;
3211  r->LexOrder=TRUE;
3212  r->pLDeg = pLDeg1c_WFirstTotalDegree;
3213  }
3214  r->firstwv = wvhdl[0];
3215  }
3216  /*======== ordering type is (_,c) =========================*/
3217  else if ((order[0]==ringorder_unspec) || (order[1] == 0)
3218  ||(
3219  ((order[1]==ringorder_c)||(order[1]==ringorder_C)
3220  ||(order[1]==ringorder_S)
3221  ||(order[1]==ringorder_s))
3222  && (order[0]!=ringorder_M)
3223  && (order[2]==0))
3224  )
3225  {
3226  if (r->OrdSgn == -1) r->pLDeg = pLDeg0c;
3227  if ((order[0] == ringorder_lp)
3228  || (order[0] == ringorder_ls)
3229  || (order[0] == ringorder_rp)
3230  || (order[0] == ringorder_rs))
3231  {
3232  r->LexOrder=TRUE;
3233  r->pLDeg = pLDeg1c;
3234  r->pFDeg = p_Totaldegree;
3235  }
3236  else if ((order[0] == ringorder_a)
3237  || (order[0] == ringorder_wp)
3238  || (order[0] == ringorder_Wp))
3239  {
3240  r->pFDeg = p_WFirstTotalDegree;
3241  }
3242  else if ((order[0] == ringorder_ws)
3243  || (order[0] == ringorder_Ws))
3244  {
3245  for(int ii=block0[0];ii<=block1[0];ii++)
3246  {
3247  if (wvhdl[0][ii-1]<0) { r->MixedOrder=2;break;}
3248  }
3249  if (r->MixedOrder==0)
3250  {
3251  if ((block0[0]==1)&&(block1[0]==r->N))
3252  r->pFDeg = p_WTotaldegree;
3253  else
3254  r->pFDeg = p_WFirstTotalDegree;
3255  }
3256  else
3257  r->pFDeg = p_Totaldegree;
3258  }
3259  r->firstBlockEnds=block1[0];
3260  r->firstwv = wvhdl[0];
3261  }
3262  /*======== ordering type is (c,_) =========================*/
3263  else if (((order[0]==ringorder_c)
3264  ||(order[0]==ringorder_C)
3265  ||(order[0]==ringorder_S)
3266  ||(order[0]==ringorder_s))
3267  && (order[1]!=ringorder_M)
3268  && (order[2]==0))
3269  {
3270  if ((order[1] == ringorder_lp)
3271  || (order[1] == ringorder_ls)
3272  || (order[1] == ringorder_rp)
3273  || order[1] == ringorder_rs)
3274  {
3275  r->LexOrder=TRUE;
3276  r->pLDeg = pLDeg1c;
3277  r->pFDeg = p_Totaldegree;
3278  }
3279  r->firstBlockEnds=block1[1];
3280  if (wvhdl!=NULL) r->firstwv = wvhdl[1];
3281  if ((order[1] == ringorder_a)
3282  || (order[1] == ringorder_wp)
3283  || (order[1] == ringorder_Wp))
3284  r->pFDeg = p_WFirstTotalDegree;
3285  else if ((order[1] == ringorder_ws)
3286  || (order[1] == ringorder_Ws))
3287  {
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)
3291  r->pFDeg = p_WFirstTotalDegree;
3292  else
3293  r->pFDeg = p_Totaldegree;
3294  }
3295  }
3296  /*------- more than one block ----------------------*/
3297  else
3298  {
3299  if ((r->VectorOut)||(order[0]==ringorder_C)||(order[0]==ringorder_S)||(order[0]==ringorder_s))
3300  {
3301  rSetFirstWv(r, 1, order, block0, block1, wvhdl);
3302  }
3303  else
3304  rSetFirstWv(r, 0, order, block0, block1, wvhdl);
3305 
3306  if ((order[0]!=ringorder_c)
3307  && (order[0]!=ringorder_C)
3308  && (order[0]!=ringorder_S)
3309  && (order[0]!=ringorder_s))
3310  {
3311  r->pLDeg = pLDeg1c;
3312  }
3313  else
3314  {
3315  r->pLDeg = pLDeg1;
3316  }
3317  r->pFDeg = p_WTotaldegree; // may be improved: p_Totaldegree for lp/dp/ls/.. blocks
3318  }
3319 
3322  {
3323  if(r->MixedOrder==FALSE)
3324  r->pFDeg = p_Deg;
3325  else
3326  r->pFDeg = p_Totaldegree;
3327  }
3328 
3329  if( rGetISPos(0, r) != -1 ) // Are there Schreyer induced blocks?
3330  {
3331 #ifndef SING_NDEBUG
3332  assume( r->pFDeg == p_Deg || r->pFDeg == p_WTotaldegree || r->pFDeg == p_Totaldegree);
3333 #endif
3334 
3335  r->pLDeg = pLDeg1; // ?
3336  }
3337 
3338  r->pFDegOrig = r->pFDeg;
3339  // NOTE: this leads to wrong ecart during std
3340  // in Old/sre.tst
3341  rOptimizeLDeg(r); // also sets r->pLDegOrig
3342 }
3343 
3344 /*2
3345 * set NegWeightL_Size, NegWeightL_Offset
3346 */
3347 static void rSetNegWeight(ring r)
3348 {
3349  int i,l;
3350  if (r->typ!=NULL)
3351  {
3352  l=0;
3353  for(i=0;i<r->OrdSize;i++)
3354  {
3355  if((r->typ[i].ord_typ==ro_wp_neg)
3356  ||(r->typ[i].ord_typ==ro_am))
3357  l++;
3358  }
3359  if (l>0)
3360  {
3361  r->NegWeightL_Size=l;
3362  r->NegWeightL_Offset=(int *) omAlloc(l*sizeof(int));
3363  l=0;
3364  for(i=0;i<r->OrdSize;i++)
3365  {
3366  if(r->typ[i].ord_typ==ro_wp_neg)
3367  {
3368  r->NegWeightL_Offset[l]=r->typ[i].data.wp.place;
3369  l++;
3370  }
3371  else if(r->typ[i].ord_typ==ro_am)
3372  {
3373  r->NegWeightL_Offset[l]=r->typ[i].data.am.place;
3374  l++;
3375  }
3376  }
3377  return;
3378  }
3379  }
3380  r->NegWeightL_Size = 0;
3381  r->NegWeightL_Offset = NULL;
3382 }
3383 
3384 static void rSetOption(ring r)
3385 {
3386  // set redthrough
3387  if (!TEST_OPT_OLDSTD && r->OrdSgn == 1 && ! r->LexOrder)
3388  r->options |= Sy_bit(OPT_REDTHROUGH);
3389  else
3390  r->options &= ~Sy_bit(OPT_REDTHROUGH);
3391 
3392  // set intStrategy
3393  if ( (r->cf->extRing!=NULL)
3394  || rField_is_Q(r)
3395  || rField_is_Ring(r)
3396  )
3397  r->options |= Sy_bit(OPT_INTSTRATEGY);
3398  else
3399  r->options &= ~Sy_bit(OPT_INTSTRATEGY);
3400 
3401  // set redTail
3402  if (r->LexOrder || r->OrdSgn == -1 || (r->cf->extRing!=NULL))
3403  r->options &= ~Sy_bit(OPT_REDTAIL);
3404  else
3405  r->options |= Sy_bit(OPT_REDTAIL);
3406 }
3407 
3408 static void rCheckOrdSgn(ring r,int i/*last block*/);
3409 
3410 /* -------------------------------------------------------- */
3411 /*2
3412 * change all global variables to fit the description of the new ring
3413 */
3414 
3415 void p_SetGlobals(const ring r, BOOLEAN complete)
3416 {
3417 // // // if (r->ppNoether!=NULL) p_Delete(&r->ppNoether,r); // ???
3418 
3419  r->pLexOrder=r->LexOrder;
3420  if (complete)
3421  {
3423  si_opt_1 |= r->options;
3424  }
3425 }
3426 
3427 static inline int sign(int x) { return (x > 0) - (x < 0);}
3429 {
3430  int i;
3431  poly p=p_One(r);
3432  p_SetExp(p,1,1,r);
3433  p_Setm(p,r);
3434  int vz=sign(p_FDeg(p,r));
3435  for(i=2;i<=rVar(r);i++)
3436  {
3437  p_SetExp(p,i-1,0,r);
3438  p_SetExp(p,i,1,r);
3439  p_Setm(p,r);
3440  if (sign(p_FDeg(p,r))!=vz)
3441  {
3442  p_Delete(&p,r);
3443  return TRUE;
3444  }
3445  }
3446  p_Delete(&p,r);
3447  return FALSE;
3448 }
3449 
3450 BOOLEAN rComplete(ring r, int force)
3451 {
3452  if (r->VarOffset!=NULL && force == 0) return FALSE;
3453  rSetOutParams(r);
3454  int n=rBlocks(r)-1;
3455  int i;
3456  int bits;
3457  r->bitmask=rGetExpSize(r->wanted_maxExp,bits,r->N);
3458  r->BitsPerExp = bits;
3459  r->ExpPerLong = BIT_SIZEOF_LONG / bits;
3460  r->divmask=rGetDivMask(bits);
3461 
3462  // will be used for ordsgn:
3463  long *tmp_ordsgn=(long *)omAlloc0(3*(n+r->N)*sizeof(long));
3464  // will be used for VarOffset:
3465  int *v=(int *)omAlloc((r->N+1)*sizeof(int));
3466  for(i=r->N; i>=0 ; i--)
3467  {
3468  v[i]=-1;
3469  }
3470  sro_ord *tmp_typ=(sro_ord *)omAlloc0(3*(n+r->N)*sizeof(sro_ord));
3471  int typ_i=0;
3472  int prev_ordsgn=0;
3473 
3474  // fill in v, tmp_typ, tmp_ordsgn, determine typ_i (== ordSize)
3475  int j=0;
3476  int j_bits=BITS_PER_LONG;
3477 
3478  BOOLEAN need_to_add_comp=FALSE; // Only for ringorder_s and ringorder_S!
3479 
3480  for(i=0;i<n;i++)
3481  {
3482  tmp_typ[typ_i].order_index=i;
3483  switch (r->order[i])
3484  {
3485  case ringorder_a:
3486  case ringorder_aa:
3487  rO_WDegree(j,j_bits,r->block0[i],r->block1[i],tmp_ordsgn,tmp_typ[typ_i],
3488  r->wvhdl[i]);
3489  typ_i++;
3490  break;
3491 
3492  case ringorder_am:
3493  rO_WMDegree(j,j_bits,r->block0[i],r->block1[i],tmp_ordsgn,tmp_typ[typ_i],
3494  r->wvhdl[i]);
3495  typ_i++;
3496  break;
3497 
3498  case ringorder_a64:
3499  rO_WDegree64(j,j_bits,r->block0[i],r->block1[i],tmp_ordsgn,
3500  tmp_typ[typ_i], (int64 *)(r->wvhdl[i]));
3501  typ_i++;
3502  break;
3503 
3504  case ringorder_c:
3505  rO_Align(j, j_bits);
3506  rO_LexVars_neg(j, j_bits, 0,0, prev_ordsgn,tmp_ordsgn,v,BITS_PER_LONG, -1);
3507  r->ComponentOrder=1;
3508  break;
3509 
3510  case ringorder_C:
3511  rO_Align(j, j_bits);
3512  rO_LexVars(j, j_bits, 0,0, prev_ordsgn,tmp_ordsgn,v,BITS_PER_LONG, -1);
3513  r->ComponentOrder=-1;
3514  break;
3515 
3516  case ringorder_M:
3517  {
3518  int k,l;
3519  k=r->block1[i]-r->block0[i]+1; // number of vars
3520  for(l=0;l<k;l++)
3521  {
3522  rO_WDegree(j,j_bits,r->block0[i],r->block1[i],tmp_ordsgn,
3523  tmp_typ[typ_i],
3524  r->wvhdl[i]+(r->block1[i]-r->block0[i]+1)*l);
3525  typ_i++;
3526  }
3527  break;
3528  }
3529 
3530  case ringorder_lp:
3531  rO_LexVars(j, j_bits, r->block0[i],r->block1[i], prev_ordsgn,
3532  tmp_ordsgn,v,bits, -1);
3533  break;
3534 
3535  case ringorder_ls:
3536  rO_LexVars_neg(j, j_bits, r->block0[i],r->block1[i], prev_ordsgn,
3537  tmp_ordsgn,v, bits, -1);
3538  break;
3539 
3540  case ringorder_rs:
3541  rO_LexVars_neg(j, j_bits, r->block1[i],r->block0[i], prev_ordsgn,
3542  tmp_ordsgn,v, bits, -1);
3543  break;
3544 
3545  case ringorder_rp:
3546  rO_LexVars(j, j_bits, r->block1[i],r->block0[i], prev_ordsgn,
3547  tmp_ordsgn,v, bits, -1);
3548  break;
3549 
3550  case ringorder_dp:
3551  if (r->block0[i]==r->block1[i])
3552  {
3553  rO_LexVars(j, j_bits, r->block0[i],r->block0[i], prev_ordsgn,
3554  tmp_ordsgn,v, bits, -1);
3555  }
3556  else
3557  {
3558  rO_TDegree(j,j_bits,r->block0[i],r->block1[i],tmp_ordsgn,
3559  tmp_typ[typ_i]);
3560  typ_i++;
3561  rO_LexVars_neg(j, j_bits, r->block1[i],r->block0[i]+1,
3562  prev_ordsgn,tmp_ordsgn,v,bits, r->block0[i]);
3563  }
3564  break;
3565 
3566  case ringorder_Dp:
3567  if (r->block0[i]==r->block1[i])
3568  {
3569  rO_LexVars(j, j_bits, r->block0[i],r->block0[i], prev_ordsgn,
3570  tmp_ordsgn,v, bits, -1);
3571  }
3572  else
3573  {
3574  rO_TDegree(j,j_bits,r->block0[i],r->block1[i],tmp_ordsgn,
3575  tmp_typ[typ_i]);
3576  typ_i++;
3577  rO_LexVars(j, j_bits, r->block0[i],r->block1[i]-1, prev_ordsgn,
3578  tmp_ordsgn,v, bits, r->block1[i]);
3579  }
3580  break;
3581 
3582  case ringorder_ds:
3583  if (r->block0[i]==r->block1[i])
3584  {
3585  rO_LexVars_neg(j, j_bits,r->block0[i],r->block1[i],prev_ordsgn,
3586  tmp_ordsgn,v,bits, -1);
3587  }
3588  else
3589  {
3590  rO_TDegree_neg(j,j_bits,r->block0[i],r->block1[i],tmp_ordsgn,
3591  tmp_typ[typ_i]);
3592  typ_i++;
3593  rO_LexVars_neg(j, j_bits, r->block1[i],r->block0[i]+1,
3594  prev_ordsgn,tmp_ordsgn,v,bits, r->block0[i]);
3595  }
3596  break;
3597 
3598  case ringorder_Ds:
3599  if (r->block0[i]==r->block1[i])
3600  {
3601  rO_LexVars_neg(j, j_bits, r->block0[i],r->block0[i],prev_ordsgn,
3602  tmp_ordsgn,v, bits, -1);
3603  }
3604  else
3605  {
3606  rO_TDegree_neg(j,j_bits,r->block0[i],r->block1[i],tmp_ordsgn,
3607  tmp_typ[typ_i]);
3608  typ_i++;
3609  rO_LexVars(j, j_bits, r->block0[i],r->block1[i]-1, prev_ordsgn,
3610  tmp_ordsgn,v, bits, r->block1[i]);
3611  }
3612  break;
3613 
3614  case ringorder_wp:
3615  rO_WDegree(j,j_bits,r->block0[i],r->block1[i],tmp_ordsgn,
3616  tmp_typ[typ_i], r->wvhdl[i]);
3617  typ_i++;
3618  { // check for weights <=0
3619  int jj;
3620  BOOLEAN have_bad_weights=FALSE;
3621  for(jj=r->block1[i]-r->block0[i];jj>=0; jj--)
3622  {
3623  if (r->wvhdl[i][jj]<=0) have_bad_weights=TRUE;
3624  }
3625  if (have_bad_weights)
3626  {
3627  rO_TDegree(j,j_bits,r->block0[i],r->block1[i],tmp_ordsgn,
3628  tmp_typ[typ_i]);
3629  typ_i++;
3630  }
3631  }
3632  if (r->block1[i]!=r->block0[i])
3633  {
3634  rO_LexVars_neg(j, j_bits,r->block1[i],r->block0[i]+1, prev_ordsgn,
3635  tmp_ordsgn, v,bits, r->block0[i]);
3636  }
3637  break;
3638 
3639  case ringorder_Wp:
3640  rO_WDegree(j,j_bits,r->block0[i],r->block1[i],tmp_ordsgn,
3641  tmp_typ[typ_i], r->wvhdl[i]);
3642  typ_i++;
3643  { // check for weights <=0
3644  int jj;
3645  BOOLEAN have_bad_weights=FALSE;
3646  for(jj=r->block1[i]-r->block0[i];jj>=0; jj--)
3647  {
3648  if (r->wvhdl[i][jj]<=0) have_bad_weights=TRUE;
3649  }
3650  if (have_bad_weights)
3651  {
3652  rO_TDegree(j,j_bits,r->block0[i],r->block1[i],tmp_ordsgn,
3653  tmp_typ[typ_i]);
3654  typ_i++;
3655  }
3656  }
3657  if (r->block1[i]!=r->block0[i])
3658  {
3659  rO_LexVars(j, j_bits,r->block0[i],r->block1[i]-1, prev_ordsgn,
3660  tmp_ordsgn,v, bits, r->block1[i]);
3661  }
3662  break;
3663 
3664  case ringorder_ws:
3665  rO_WDegree_neg(j,j_bits,r->block0[i],r->block1[i],tmp_ordsgn,
3666  tmp_typ[typ_i], r->wvhdl[i]);
3667  typ_i++;
3668  if (r->block1[i]!=r->block0[i])
3669  {
3670  rO_LexVars_neg(j, j_bits,r->block1[i],r->block0[i]+1, prev_ordsgn,
3671  tmp_ordsgn, v,bits, r->block0[i]);
3672  }
3673  break;
3674 
3675  case ringorder_Ws:
3676  rO_WDegree_neg(j,j_bits,r->block0[i],r->block1[i],tmp_ordsgn,
3677  tmp_typ[typ_i], r->wvhdl[i]);
3678  typ_i++;
3679  if (r->block1[i]!=r->block0[i])
3680  {
3681  rO_LexVars(j, j_bits,r->block0[i],r->block1[i]-1, prev_ordsgn,
3682  tmp_ordsgn,v, bits, r->block1[i]);
3683  }
3684  break;
3685 
3686  case ringorder_S:
3687  assume(typ_i == 1); // For LaScala3 only: on the 2nd place ([1])!
3688  // TODO: for K[x]: it is 0...?!
3689  rO_Syzcomp(j, j_bits,prev_ordsgn, tmp_ordsgn,tmp_typ[typ_i]);
3690  need_to_add_comp=TRUE;
3691  r->ComponentOrder=-1;
3692  typ_i++;
3693  break;
3694 
3695  case ringorder_s:
3696  assume(typ_i == 0 && j == 0);
3697  rO_Syz(j, j_bits, prev_ordsgn, r->block0[i], tmp_ordsgn, tmp_typ[typ_i]); // set syz-limit?
3698  need_to_add_comp=TRUE;
3699  r->ComponentOrder=-1;
3700  typ_i++;
3701  break;
3702 
3703  case ringorder_IS:
3704  {
3705 
3706  assume( r->block0[i] == r->block1[i] );
3707  const int s = r->block0[i];
3708  assume( -2 < s && s < 2);
3709 
3710  if(s == 0) // Prefix IS
3711  rO_ISPrefix(j, j_bits, prev_ordsgn, tmp_ordsgn, r->N, v, tmp_typ[typ_i++]); // What about prev_ordsgn?
3712  else // s = +1 or -1 // Note: typ_i might be incremented here inside!
3713  {
3714  rO_ISSuffix(j, j_bits, prev_ordsgn, tmp_ordsgn, r->N, v, tmp_typ, typ_i, s); // Suffix.
3715  need_to_add_comp=FALSE;
3716  }
3717 
3718  break;
3719  }
3720  case ringorder_unspec:
3721  case ringorder_no:
3722  default:
3723  dReportError("undef. ringorder used\n");
3724  break;
3725  }
3726  }
3727  rCheckOrdSgn(r,n-1);
3728 
3729  int j0=j; // save j
3730  int j_bits0=j_bits; // save jbits
3731  rO_Align(j,j_bits);
3732  r->CmpL_Size = j;
3733 
3734  j_bits=j_bits0; j=j0;
3735 
3736  // fill in some empty slots with variables not already covered
3737  // v0 is special, is therefore normally already covered
3738  // now we do have rings without comp...
3739  if((need_to_add_comp) && (v[0]== -1))
3740  {
3741  if (prev_ordsgn==1)
3742  {
3743  rO_Align(j, j_bits);
3744  rO_LexVars(j, j_bits, 0,0, prev_ordsgn,tmp_ordsgn,v,BITS_PER_LONG, -1);
3745  }
3746  else
3747  {
3748  rO_Align(j, j_bits);
3749  rO_LexVars_neg(j, j_bits, 0,0, prev_ordsgn,tmp_ordsgn,v,BITS_PER_LONG, -1);
3750  }
3751  }
3752  // the variables
3753  for(i=1 ; i<=r->N ; i++)
3754  {
3755  if(v[i]==(-1))
3756  {
3757  if (prev_ordsgn==1)
3758  {
3759  rO_LexVars(j, j_bits, i,i, prev_ordsgn,tmp_ordsgn,v,bits, -1);
3760  }
3761  else
3762  {
3763  rO_LexVars_neg(j,j_bits,i,i, prev_ordsgn,tmp_ordsgn,v,bits, -1);
3764  }
3765  }
3766  }
3767 
3768  rO_Align(j,j_bits);
3769  // ----------------------------
3770  // finished with constructing the monomial, computing sizes:
3771 
3772  r->ExpL_Size=j;
3773  r->PolyBin = omGetSpecBin(POLYSIZE + (r->ExpL_Size)*sizeof(long));
3774  assume(r->PolyBin != NULL);
3775 
3776  // ----------------------------
3777  // indices and ordsgn vector for comparison
3778  //
3779  // r->pCompHighIndex already set
3780  r->ordsgn=(long *)omAlloc0(r->ExpL_Size*sizeof(long));
3781 
3782  for(j=0;j<r->CmpL_Size;j++)
3783  {
3784  r->ordsgn[j] = tmp_ordsgn[j];
3785  }
3786 
3787  omFreeSize((ADDRESS)tmp_ordsgn,(3*(n+r->N)*sizeof(long)));
3788 
3789  // ----------------------------
3790  // description of orderings for setm:
3791  //
3792  r->OrdSize=typ_i;
3793  if (typ_i==0) r->typ=NULL;
3794  else
3795  {
3796  r->typ=(sro_ord*)omAlloc(typ_i*sizeof(sro_ord));
3797  memcpy(r->typ,tmp_typ,typ_i*sizeof(sro_ord));
3798  }
3799  omFreeSize((ADDRESS)tmp_typ,(3*(n+r->N)*sizeof(sro_ord)));
3800 
3801  // ----------------------------
3802  // indices for (first copy of ) variable entries in exp.e vector (VarOffset):
3803  r->VarOffset=v;
3804 
3805  // ----------------------------
3806  // other indicies
3807  r->pCompIndex=(r->VarOffset[0] & 0xffff); //r->VarOffset[0];
3808  i=0; // position
3809  j=0; // index in r->typ
3810  if (i==r->pCompIndex) i++; // IS???
3811  while ((j < r->OrdSize)
3812  && ((r->typ[j].ord_typ==ro_syzcomp) ||
3813  (r->typ[j].ord_typ==ro_syz) || (r->typ[j].ord_typ==ro_isTemp) || (r->typ[j].ord_typ==ro_is) ||
3814  (r->order[r->typ[j].order_index] == ringorder_aa)))
3815  {
3816  i++; j++;
3817  }
3818 
3819  if (i==r->pCompIndex) i++;
3820  r->pOrdIndex=i;
3821 
3822  // ----------------------------
3823  rSetDegStuff(r); // OrdSgn etc already set
3824  rSetOption(r);
3825  // ----------------------------
3826  // r->p_Setm
3827  r->p_Setm = p_GetSetmProc(r);
3828 
3829  // ----------------------------
3830  // set VarL_*
3831  rSetVarL(r);
3832 
3833  // ----------------------------
3834  // right-adjust VarOffset
3836 
3837  // ----------------------------
3838  // set NegWeightL*
3839  rSetNegWeight(r);
3840 
3841  // ----------------------------
3842  // p_Procs: call AFTER NegWeightL
3843  r->p_Procs = (p_Procs_s*)omAlloc(sizeof(p_Procs_s));
3844  p_ProcsSet(r, r->p_Procs);
3845 
3846  // use totaldegree on crazy oderings:
3847  if ((r->pFDeg==p_WTotaldegree) && rOrd_is_MixedDegree_Ordering(r))
3848  r->pFDeg = p_Totaldegree;
3849  return FALSE;
3850 }
3851 
3852 static void rCheckOrdSgn(ring r,int b/*last block*/)
3853 { // set r->OrdSgn, r->MixedOrder
3854  // for each variable:
3855  int nonpos=0;
3856  int nonneg=0;
3857  for(int i=1;i<=r->N;i++)
3858  {
3859  int found=0;
3860  // for all blocks:
3861  for(int j=0;(j<=b) && (found==0);j++)
3862  {
3863  // search the first block containing var(i)
3864  if ((r->block0[j]<=i)&&(r->block1[j]>=i))
3865  {
3866  // what kind if block is it?
3867  if ((r->order[j]==ringorder_ls)
3868  || (r->order[j]==ringorder_ds)
3869  || (r->order[j]==ringorder_Ds)
3870  || (r->order[j]==ringorder_ws)
3871  || (r->order[j]==ringorder_Ws)
3872  || (r->order[j]==ringorder_rs))
3873  {
3874  r->OrdSgn=-1;
3875  nonpos++;
3876  found=1;
3877  }
3878  else if((r->order[j]==ringorder_a)
3879  ||(r->order[j]==ringorder_aa))
3880  {
3881  // <0: local/mixed ordering
3882  // >0: var(i) is okay, look at other vars
3883  // ==0: look at other blocks for var(i)
3884  if(r->wvhdl[j][i-r->block0[j]]<0)
3885  {
3886  r->OrdSgn=-1;
3887  nonpos++;
3888  found=1;
3889  }
3890  else if(r->wvhdl[j][i-r->block0[j]]>0)
3891  {
3892  nonneg++;
3893  found=1;
3894  }
3895  }
3896  else if(r->order[j]==ringorder_M)
3897  {
3898  // <0: local/mixed ordering
3899  // >0: var(i) is okay, look at other vars
3900  // ==0: look at other blocks for var(i)
3901  if(r->wvhdl[j][i-r->block0[j]]<0)
3902  {
3903  r->OrdSgn=-1;
3904  nonpos++;
3905  found=1;
3906  }
3907  else if(r->wvhdl[j][i-r->block0[j]]>0)
3908  {
3909  nonneg++;
3910  found=1;
3911  }
3912  else
3913  {
3914  // very bad: try next row(s)
3915  int add=r->block1[j]-r->block0[j]+1;
3916  int max_i=r->block0[j]+add*add-add-1;
3917  while(found==0)
3918  {
3919  i+=add;
3920  if (r->wvhdl[j][i-r->block0[j]]<0)
3921  {
3922  r->OrdSgn=-1;
3923  nonpos++;
3924  found=1;
3925  }
3926  else if(r->wvhdl[j][i-r->block0[j]]>0)
3927  {
3928  nonneg++;
3929  found=1;
3930  }
3931  else if(i>max_i)
3932  {
3933  nonpos++;
3934  nonneg++;
3935  found=1;
3936  }
3937  }
3938  }
3939  }
3940  else if ((r->order[j]==ringorder_lp)
3941  || (r->order[j]==ringorder_dp)
3942  || (r->order[j]==ringorder_Dp)
3943  || (r->order[j]==ringorder_wp)
3944  || (r->order[j]==ringorder_Wp)
3945  || (r->order[j]==ringorder_rp))
3946  {
3947  found=1;
3948  nonneg++;
3949  }
3950  }
3951  }
3952  }
3953  if (nonpos>0)
3954  {
3955  r->OrdSgn=-1;
3956  if (nonneg>0) r->MixedOrder=1;
3957  }
3958  else
3959  {
3960  r->OrdSgn=1;
3961  r->MixedOrder=0;
3962  }
3963 }
3964 
3965 void rUnComplete(ring r)
3966 {
3967  if (r == NULL) return;
3968  if (r->VarOffset != NULL)
3969  {
3970  if (r->OrdSize!=0 && r->typ != NULL)
3971  {
3972  for(int i = 0; i < r->OrdSize; i++)
3973  if( r->typ[i].ord_typ == ro_is) // Search for suffixes! (prefix have the same VarOffset)
3974  {
3975  id_Delete(&r->typ[i].data.is.F, r);
3976 
3977  if( r->typ[i].data.is.pVarOffset != NULL )
3978  {
3979  omFreeSize((ADDRESS)r->typ[i].data.is.pVarOffset, (r->N +1)*sizeof(int));
3980  }
3981  }
3982  else if (r->typ[i].ord_typ == ro_syz)
3983  {
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));
3986  }
3987  else if (r->typ[i].ord_typ == ro_syzcomp)
3988  {
3989  assume( r->typ[i].data.syzcomp.ShiftedComponents == NULL );
3990  assume( r->typ[i].data.syzcomp.Components == NULL );
3991 // WarnS( "rUnComplete : ord_typ == ro_syzcomp was unhandled!!! Possibly memory leak!!!" );
3992 #ifndef SING_NDEBUG
3993 // assume(0);
3994 #endif
3995  }
3996 
3997  omFreeSize((ADDRESS)r->typ,r->OrdSize*sizeof(sro_ord)); r->typ = NULL;
3998  }
3999 
4000  if (r->PolyBin != NULL)
4001  omUnGetSpecBin(&(r->PolyBin));
4002 
4003  omFreeSize((ADDRESS)r->VarOffset, (r->N +1)*sizeof(int));
4004  r->VarOffset=NULL;
4005 
4006  if (r->ordsgn != NULL && r->CmpL_Size != 0)
4007  {
4008  omFreeSize((ADDRESS)r->ordsgn,r->ExpL_Size*sizeof(long));
4009  r->ordsgn=NULL;
4010  }
4011  if (r->p_Procs != NULL)
4012  {
4013  omFreeSize(r->p_Procs, sizeof(p_Procs_s));
4014  r->p_Procs=NULL;
4015  }
4016  omfreeSize(r->VarL_Offset, r->VarL_Size*sizeof(int));
4017  r->VarL_Offset=NULL;
4018  }
4019  if (r->NegWeightL_Offset!=NULL)
4020  {
4021  omFreeSize(r->NegWeightL_Offset, r->NegWeightL_Size*sizeof(int));
4022  r->NegWeightL_Offset=NULL;
4023  }
4024 }
4025 
4026 // set r->VarL_Size, r->VarL_Offset, r->VarL_LowIndex
4027 static void rSetVarL(ring r)
4028 {
4029  int min = MAX_INT_VAL, min_j = -1;
4030  int* VarL_Number = (int*) omAlloc0(r->ExpL_Size*sizeof(int));
4031 
4032  int i,j;
4033 
4034  // count how often a var long is occupied by an exponent
4035  for (i=1; i<=r->N; i++)
4036  {
4037  VarL_Number[r->VarOffset[i] & 0xffffff]++;
4038  }
4039 
4040  // determine how many and min
4041  for (i=0, j=0; i<r->ExpL_Size; i++)
4042  {
4043  if (VarL_Number[i] != 0)
4044  {
4045  if (min > VarL_Number[i])
4046  {
4047  min = VarL_Number[i];
4048  min_j = j;
4049  }
4050  j++;
4051  }
4052  }
4053 
4054  r->VarL_Size = j; // number of long with exp. entries in
4055  // in p->exp
4056  r->VarL_Offset = (int*) omAlloc(r->VarL_Size*sizeof(int));
4057  r->VarL_LowIndex = 0;
4058 
4059  // set VarL_Offset
4060  for (i=0, j=0; i<r->ExpL_Size; i++)
4061  {
4062  if (VarL_Number[i] != 0)
4063  {
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;
4067  j++;
4068  }
4069  }
4070  if (r->VarL_LowIndex >= 0)
4071  r->VarL_LowIndex = r->VarL_Offset[0];
4072 
4073  if (min_j != 0)
4074  {
4075  j = r->VarL_Offset[min_j];
4076  r->VarL_Offset[min_j] = r->VarL_Offset[0];
4077  r->VarL_Offset[0] = j;
4078  }
4079  omFree(VarL_Number);
4080 }
4081 
4082 static void rRightAdjustVarOffset(ring r)
4083 {
4084  int* shifts = (int*) omAlloc(r->ExpL_Size*sizeof(int));
4085  int i;
4086  // initialize shifts
4087  for (i=0;i<r->ExpL_Size;i++)
4088  shifts[i] = BIT_SIZEOF_LONG;
4089 
4090  // find minimal bit shift in each long exp entry
4091  for (i=1;i<=r->N;i++)
4092  {
4093  if (shifts[r->VarOffset[i] & 0xffffff] > r->VarOffset[i] >> 24)
4094  shifts[r->VarOffset[i] & 0xffffff] = r->VarOffset[i] >> 24;
4095  }
4096  // reset r->VarOffset: set the minimal shift to 0
4097  for (i=1;i<=r->N;i++)
4098  {
4099  if (shifts[r->VarOffset[i] & 0xffffff] != 0)
4100  r->VarOffset[i]
4101  = (r->VarOffset[i] & 0xffffff) |
4102  (((r->VarOffset[i] >> 24) - shifts[r->VarOffset[i] & 0xffffff]) << 24);
4103  }
4104  omFree(shifts);
4105 }
4106 
4107 // get r->divmask depending on bits per exponent
4108 static unsigned long rGetDivMask(int bits)
4109 {
4110  unsigned long divmask = 1;
4111  int i = bits;
4112 
4113  while (i < BIT_SIZEOF_LONG)
4114  {
4115  divmask |= (((unsigned long) 1) << (unsigned long) i);
4116  i += bits;
4117  }
4118  return divmask;
4119 }
4120 
4121 #ifdef RDEBUG
4122 void rDebugPrint(const ring r)
4123 {
4124  if (r==NULL)
4125  {
4126  PrintS("NULL ?\n");
4127  return;
4128  }
4129  // corresponds to ro_typ from ring.h:
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"};
4132  int i,j;
4133 
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]);
4140 
4141  Print("VarL_LowIndex: %d\n", r->VarL_LowIndex);
4142  PrintS("VarL_Offset:\n");
4143  if (r->VarL_Offset==NULL) PrintS(" NULL");
4144  else
4145  for(j = 0; j < r->VarL_Size; j++)
4146  Print(" VarL_Offset[%d]: %d ", j, r->VarL_Offset[j]);
4147  PrintLn();
4148 
4149 
4150  PrintS("VarOffset:\n");
4151  if (r->VarOffset==NULL) PrintS(" NULL\n");
4152  else
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);
4156  PrintS("ordsgn:\n");
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);
4160  PrintS("ordrec:\n");
4161  for(j=0;j<r->OrdSize;j++)
4162  {
4163  Print(" typ %s", TYP[r->typ[j].ord_typ]);
4164  if (r->typ[j].ord_typ==ro_syz)
4165  {
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;
4170 
4171  Print(" limit %d (place: %d, curr_index: %d), syz_index: ", limit, place, curr_index);
4172 
4173  if( syz_index == NULL )
4174  PrintS("(NULL)");
4175  else
4176  {
4177  PrintS("{");
4178  for( i=0; i <= limit; i++ )
4179  Print("%d ", syz_index[i]);
4180  PrintS("}");
4181  }
4182 
4183  }
4184  else if (r->typ[j].ord_typ==ro_isTemp)
4185  {
4186  Print(" start (level) %d, suffixpos: %d, VO: ",r->typ[j].data.isTemp.start, r->typ[j].data.isTemp.suffixpos);
4187 
4188  }
4189  else if (r->typ[j].ord_typ==ro_is)
4190  {
4191  Print(" start %d, end: %d: ",r->typ[j].data.is.start, r->typ[j].data.is.end);
4192 
4193 // for( int k = 0; k <= r->N; k++) if (r->typ[j].data.is.pVarOffset[k] != -1) Print("[%2d]: %04x; ", k, r->typ[j].data.is.pVarOffset[k]);
4194 
4195  Print(" limit %d",r->typ[j].data.is.limit);
4196 #ifndef SING_NDEBUG
4197  //PrintS(" F: ");idShow(r->typ[j].data.is.F, r, r, 1);
4198 #endif
4199 
4200  PrintLn();
4201  }
4202  else if (r->typ[j].ord_typ==ro_am)
4203  {
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);
4208  PrintS(" w:");
4209  int l=0;
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];
4214  PrintS(" m:");
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]);
4217  }
4218  else
4219  {
4220  Print(" place %d",r->typ[j].data.dp.place);
4221 
4222  if (r->typ[j].ord_typ!=ro_syzcomp && r->typ[j].ord_typ!=ro_syz)
4223  {
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)
4227  || (r->typ[j].ord_typ==ro_wp_neg))
4228  {
4229  PrintS(" w:");
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]);
4232  }
4233  else if (r->typ[j].ord_typ==ro_wp64)
4234  {
4235  PrintS(" w64:");
4236  int l;
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));
4239  }
4240  }
4241  }
4242  PrintLn();
4243  }
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++)
4248  {
4249  Print("L[%d]: ",j);
4250  if (j< r->CmpL_Size)
4251  Print("ordsgn %ld ", r->ordsgn[j]);
4252  else
4253  PrintS("no comp ");
4254  i=1;
4255  for(;i<=r->N;i++)
4256  {
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 ); }
4260  }
4261  if( r->pCompIndex==j ) PrintS("v0; ");
4262  for(i=0;i<r->OrdSize;i++)
4263  {
4264  if (r->typ[i].data.dp.place == j)
4265  {
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);
4268  }
4269  }
4270 
4271  if (j==r->pOrdIndex)
4272  PrintS("pOrdIndex\n");
4273  else
4274  PrintLn();
4275  }
4276  Print("LexOrder:%d, MixedOrder:%d\n",r->LexOrder, r->MixedOrder);
4277 
4278  Print("NegWeightL_Size: %d, NegWeightL_Offset: ", r->NegWeightL_Size);
4279  if (r->NegWeightL_Offset==NULL) PrintS(" NULL");
4280  else
4281  for(j = 0; j < r->NegWeightL_Size; j++)
4282  Print(" [%d]: %d ", j, r->NegWeightL_Offset[j]);
4283  PrintLn();
4284 
4285  // p_Procs stuff
4286  p_Procs_s proc_names;
4287  const char* field;
4288  const char* length;
4289  const char* ord;
4290  p_Debug_GetProcNames(r, &proc_names); // changes p_Procs!!!
4291  p_Debug_GetSpecNames(r, field, length, ord);
4292 
4293  Print("p_Spec : %s, %s, %s\n", field, length, ord);
4294  PrintS("p_Procs :\n");
4295  for (i=0; i<(int) (sizeof(p_Procs_s)/sizeof(void*)); i++)
4296  {
4297  Print(" %s,\n", ((char**) &proc_names)[i]);
4298  }
4299 
4300  {
4301  PrintLn();
4302  PrintS("pFDeg : ");
4303 #define pFDeg_CASE(A) if(r->pFDeg == A) PrintS( "" #A "" )
4304  pFDeg_CASE(p_Totaldegree); else
4306  pFDeg_CASE(p_WTotaldegree); else
4307  pFDeg_CASE(p_Deg); else
4308 #undef pFDeg_CASE
4309  Print("(%p)", r->pFDeg); // default case
4310 
4311  PrintLn();
4312  Print("pLDeg : (%p)", r->pLDeg);
4313  PrintLn();
4314  }
4315  PrintS("pSetm:");
4316  void p_Setm_Dummy(poly p, const ring r);
4317  void p_Setm_TotalDegree(poly p, const ring r);
4318  void p_Setm_WFirstTotalDegree(poly p, const ring r);
4319  void p_Setm_General(poly p, const ring r);
4320  if (r->p_Setm==p_Setm_General) PrintS("p_Setm_General\n");
4321  else if (r->p_Setm==p_Setm_Dummy) PrintS("p_Setm_Dummy\n");
4322  else if (r->p_Setm==p_Setm_TotalDegree) PrintS("p_Setm_Totaldegree\n");
4323  else if (r->p_Setm==p_Setm_WFirstTotalDegree) PrintS("p_Setm_WFirstTotalDegree\n");
4324  else Print("%p\n",r->p_Setm);
4325 }
4326 
4327 void p_DebugPrint(poly p, const ring r)
4328 {
4329  int i,j;
4330  p_Write(p,r);
4331  j=2;
4332  while(p!=NULL)
4333  {
4334  Print("\nexp[0..%d]\n",r->ExpL_Size-1);
4335  for(i=0;i<r->ExpL_Size;i++)
4336  Print("%ld ",p->exp[i]);
4337  PrintLn();
4338  Print("v0:%ld ",p_GetComp(p, r));
4339  for(i=1;i<=r->N;i++) Print(" v%d:%ld",i,p_GetExp(p,i, r));
4340  PrintLn();
4341  pIter(p);
4342  j--;
4343  if (j==0) { PrintS("...\n"); break; }
4344  }
4345 }
4346 
4347 #endif // RDEBUG
4348 
4349 /// debug-print monomial poly/vector p, assuming that it lives in the ring R
4350 static inline void m_DebugPrint(const poly p, const ring R)
4351 {
4352  Print("\nexp[0..%d]\n", R->ExpL_Size - 1);
4353  for(int i = 0; i < R->ExpL_Size; i++)
4354  Print("%09lx ", p->exp[i]);
4355  PrintLn();
4356  Print("v0:%9ld ", p_GetComp(p, R));
4357  for(int i = 1; i <= R->N; i++) Print(" v%d:%5ld",i, p_GetExp(p, i, R));
4358  PrintLn();
4359 }
4360 
4361 
4362 /*2
4363 * asssume that rComplete was called with r
4364 * assume that the first block ist ringorder_S
4365 * change the block to reflect the sequence given by appending v
4366 */
4367 static inline void rNChangeSComps(int* currComponents, long* currShiftedComponents, ring r)
4368 {
4369  assume(r->typ[1].ord_typ == ro_syzcomp);
4370 
4371  r->typ[1].data.syzcomp.ShiftedComponents = currShiftedComponents;
4372  r->typ[1].data.syzcomp.Components = currComponents;
4373 }
4374 
4375 static inline void rNGetSComps(int** currComponents, long** currShiftedComponents, ring r)
4376 {
4377  assume(r->typ[1].ord_typ == ro_syzcomp);
4378 
4379  *currShiftedComponents = r->typ[1].data.syzcomp.ShiftedComponents;
4380  *currComponents = r->typ[1].data.syzcomp.Components;
4381 }
4382 #ifdef PDEBUG
4383 static inline void rDBChangeSComps(int* currComponents,
4384  long* currShiftedComponents,
4385  int length,
4386  ring r)
4387 {
4388  assume(r->typ[1].ord_typ == ro_syzcomp);
4389 
4390  r->typ[1].data.syzcomp.length = length;
4391  rNChangeSComps( currComponents, currShiftedComponents, r);
4392 }
4393 static inline void rDBGetSComps(int** currComponents,
4394  long** currShiftedComponents,
4395  int *length,
4396  ring r)
4397 {
4398  assume(r->typ[1].ord_typ == ro_syzcomp);
4399 
4400  *length = r->typ[1].data.syzcomp.length;
4401  rNGetSComps( currComponents, currShiftedComponents, r);
4402 }
4403 #endif
4404 
4405 void rChangeSComps(int* currComponents, long* currShiftedComponents, int length, ring r)
4406 {
4407 #ifdef PDEBUG
4408  rDBChangeSComps(currComponents, currShiftedComponents, length, r);
4409 #else
4410  rNChangeSComps(currComponents, currShiftedComponents, r);
4411 #endif
4412 }
4413 
4414 void rGetSComps(int** currComponents, long** currShiftedComponents, int *length, ring r)
4415 {
4416 #ifdef PDEBUG
4417  rDBGetSComps(currComponents, currShiftedComponents, length, r);
4418 #else
4419  rNGetSComps(currComponents, currShiftedComponents, r);
4420 #endif
4421 }
4422 
4423 
4424 /////////////////////////////////////////////////////////////////////////////
4425 //
4426 // The following routines all take as input a ring r, and return R
4427 // where R has a certain property. R might be equal r in which case r
4428 // had already this property
4429 //
4430 ring rAssure_SyzOrder(const ring r, BOOLEAN complete)
4431 {
4432  if ( r->order[0] == ringorder_c ) return r;
4433  return rAssure_SyzComp(r,complete);
4434 }
4435 ring rAssure_SyzComp(const ring r, BOOLEAN complete)
4436 {
4437  if ( r->order[0] == ringorder_s ) return r;
4438 
4439  if ( r->order[0] == ringorder_IS )
4440  {
4441 #ifndef SING_NDEBUG
4442  WarnS("rAssure_SyzComp: input ring has an IS-ordering!");
4443 #endif
4444 // return r;
4445  }
4446  ring res=rCopy0(r, FALSE, FALSE);
4447  int i=rBlocks(r);
4448  int j;
4449 
4450  res->order=(rRingOrder_t *)omAlloc((i+1)*sizeof(rRingOrder_t));
4451  res->block0=(int *)omAlloc0((i+1)*sizeof(int));
4452  res->block1=(int *)omAlloc0((i+1)*sizeof(int));
4453  int ** wvhdl =(int **)omAlloc0((i+1)*sizeof(int**));
4454  for(j=i;j>0;j--)
4455  {
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)
4460  {
4461  #ifdef HAVE_OMALLOC
4462  wvhdl[j] = (int*) omMemDup(r->wvhdl[j-1]);
4463  #else
4464  {
4465  int l=r->block1[j-1]-r->block0[j-1]+1;
4466  if (r->order[j-1]==ringorder_a64) l*=2;
4467  else if (r->order[j-1]==ringorder_M) l=l*l;
4468  else if (r->order[j-1]==ringorder_am)
4469  {
4470  l+=r->wvhdl[j-1][r->block1[j-1]-r->block0[j-1]+1]+1;
4471  }
4472  wvhdl[j]=(int*)omalloc(l*sizeof(int));
4473  memcpy(wvhdl[j],r->wvhdl[j-1],l*sizeof(int));
4474  }
4475  #endif
4476  }
4477  }
4478  res->order[0]=ringorder_s;
4479 
4480  res->wvhdl = wvhdl;
4481 
4482  if (complete)
4483  {
4484  rComplete(res, 1);
4485 #ifdef HAVE_PLURAL
4486  if (rIsPluralRing(r))
4487  {
4488  if ( nc_rComplete(r, res, false) ) // no qideal!
4489  {
4490 #ifndef SING_NDEBUG
4491  WarnS("error in nc_rComplete"); // cleanup?// rDelete(res);// return r; // just go on..
4492 #endif
4493  }
4494  }
4496 #endif
4497 
4498 #ifdef HAVE_PLURAL
4499  ring old_ring = r;
4500 #endif
4501  if (r->qideal!=NULL)
4502  {
4503  res->qideal= idrCopyR_NoSort(r->qideal, r, res);
4504  assume(id_RankFreeModule(res->qideal, res) == 0);
4505 #ifdef HAVE_PLURAL
4506  if( rIsPluralRing(res) )
4507  {
4508  if( nc_SetupQuotient(res, r, true) )
4509  {
4510 // WarnS("error in nc_SetupQuotient"); // cleanup? rDelete(res); return r; // just go on...?
4511  }
4512  assume(id_RankFreeModule(res->qideal, res) == 0);
4513  }
4514 #endif
4515  }
4516 
4517 #ifdef HAVE_PLURAL
4518  assume((res->qideal==NULL) == (old_ring->qideal==NULL));
4519  assume(rIsPluralRing(res) == rIsPluralRing(old_ring));
4520  assume(rIsSCA(res) == rIsSCA(old_ring));
4521  assume(ncRingType(res) == ncRingType(old_ring));
4522 #endif
4523  }
4524  return res;
4525 }
4526 
4527 ring rAssure_TDeg(ring r, int &pos)
4528 {
4529  if (r->N==1) // special: dp(1)==lp(1)== no entry in typ
4530  {
4531  pos=r->VarL_LowIndex;
4532  return r;
4533  }
4534  if (r->typ!=NULL)
4535  {
4536  for(int i=r->OrdSize-1;i>=0;i--)
4537  {
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))
4541  {
4542  pos=r->typ[i].data.dp.place;
4543  //printf("no change, pos=%d\n",pos);
4544  return r;
4545  }
4546  }
4547  }
4548 
4549 #ifdef HAVE_PLURAL
4550  nc_struct* save=r->GetNC();
4551  r->GetNC()=NULL;
4552 #endif
4553  ring res=rCopy(r);
4554  if (res->qideal!=NULL)
4555  {
4556  id_Delete(&res->qideal,r);
4557  }
4558 
4559  int j;
4560 
4561  res->ExpL_Size=r->ExpL_Size+1; // one word more in each monom
4562  res->PolyBin=omGetSpecBin(POLYSIZE + (res->ExpL_Size)*sizeof(long));
4563  omFree((ADDRESS)res->ordsgn);
4564  res->ordsgn=(long *)omAlloc0(res->ExpL_Size*sizeof(long));
4565  for(j=0;j<r->CmpL_Size;j++)
4566  {
4567  res->ordsgn[j] = r->ordsgn[j];
4568  }
4569  res->OrdSize=r->OrdSize+1; // one block more for pSetm
4570  if (r->typ!=NULL)
4571  omFree((ADDRESS)res->typ);
4572  res->typ=(sro_ord*)omAlloc0(res->OrdSize*sizeof(sro_ord));
4573  if (r->typ!=NULL)
4574  memcpy(res->typ,r->typ,r->OrdSize*sizeof(sro_ord));
4575  // the additional block for pSetm: total degree at the last word
4576  // but not included in the compare part
4577  res->typ[res->OrdSize-1].ord_typ=ro_dp;
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;
4582  //res->pOrdIndex=pos; //NO: think of a(1,0),dp !
4583  extern void p_Setm_General(poly p, ring r);
4584  res->p_Setm=p_Setm_General;
4585  // ----------------------------
4586  omFree((ADDRESS)res->p_Procs);
4587  res->p_Procs = (p_Procs_s*)omAlloc(sizeof(p_Procs_s));
4588 
4589  p_ProcsSet(res, res->p_Procs);
4590 #ifdef HAVE_PLURAL
4591  r->GetNC()=save;
4592  if (rIsPluralRing(r))
4593  {
4594  if ( nc_rComplete(r, res, false) ) // no qideal!
4595  {
4596 #ifndef SING_NDEBUG
4597  WarnS("error in nc_rComplete");
4598 #endif
4599  // just go on..
4600  }
4601  }
4602 #endif
4603  if (r->qideal!=NULL)
4604  {
4605  res->qideal=idrCopyR_NoSort(r->qideal,r, res);
4606 #ifdef HAVE_PLURAL
4607  if (rIsPluralRing(res))
4608  {
4609 // nc_SetupQuotient(res, currRing);
4610  nc_SetupQuotient(res, r); // ?
4611  }
4612  assume((res->qideal==NULL) == (r->qideal==NULL));
4613 #endif
4614  }
4615 
4616 #ifdef HAVE_PLURAL
4618  assume(rIsSCA(res) == rIsSCA(r));
4619  assume(ncRingType(res) == ncRingType(r));
4620 #endif
4621 
4622  return res;
4623 }
4624 
4625 ring rAssure_HasComp(const ring r)
4626 {
4627  int last_block;
4628  int i=0;
4629  do
4630  {
4631  if (r->order[i] == ringorder_c ||
4632  r->order[i] == ringorder_C) return r;
4633  if (r->order[i] == 0)
4634  break;
4635  i++;
4636  } while (1);
4637  //WarnS("re-creating ring with comps");
4638  last_block=i-1;
4639 
4640  ring new_r = rCopy0(r, FALSE, FALSE);
4641  i+=2;
4642  new_r->wvhdl=(int **)omAlloc0(i * sizeof(int *));
4643  new_r->order = (rRingOrder_t *) omAlloc0(i * sizeof(rRingOrder_t));
4644  new_r->block0 = (int *) omAlloc0(i * sizeof(int));
4645  new_r->block1 = (int *) omAlloc0(i * sizeof(int));
4646  memcpy(new_r->order,r->order,(i-1) * sizeof(rRingOrder_t));
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++)
4650  {
4651  if (r->wvhdl[j]!=NULL)
4652  {
4653  #ifdef HAVE_OMALLOC
4654  new_r->wvhdl[j] = (int*) omMemDup(r->wvhdl[j]);
4655  #else
4656  {
4657  int l=r->block1[j]-r->block0[j]+1;
4658  if (r->order[j]==ringorder_a64) l*=2;
4659  else if (r->order[j]==ringorder_M) l=l*l;
4660  else if (r->order[j]==ringorder_am)
4661  {
4662  l+=r->wvhdl[j][r->block1[j]-r->block0[j]+1]+1;
4663  }
4664  new_r->wvhdl[j]=(int*)omalloc(l*sizeof(int));
4665  memcpy(new_r->wvhdl[j],r->wvhdl[j],l*sizeof(int));
4666  }
4667  #endif
4668  }
4669  }
4670  last_block++;
4671  new_r->order[last_block]=ringorder_C;
4672  //new_r->block0[last_block]=0;
4673  //new_r->block1[last_block]=0;
4674  //new_r->wvhdl[last_block]=NULL;
4675 
4676  rComplete(new_r, 1);
4677 
4678 #ifdef HAVE_PLURAL
4679  if (rIsPluralRing(r))
4680  {
4681  if ( nc_rComplete(r, new_r, false) ) // no qideal!
4682  {
4683 #ifndef SING_NDEBUG
4684  WarnS("error in nc_rComplete"); // cleanup?// rDelete(res);// return r; // just go on..
4685 #endif
4686  }
4687  }
4688  assume(rIsPluralRing(r) == rIsPluralRing(new_r));
4689 #endif
4690 
4691  return new_r;
4692 }
4693 
4694 ring rAssure_CompLastBlock(ring r, BOOLEAN complete)
4695 {
4696  int last_block = rBlocks(r) - 2;
4697  if (r->order[last_block] != ringorder_c &&
4698  r->order[last_block] != ringorder_C)
4699  {
4700  int c_pos = 0;
4701  int i;
4702 
4703  for (i=0; i< last_block; i++)
4704  {
4705  if (r->order[i] == ringorder_c || r->order[i] == ringorder_C)
4706  {
4707  c_pos = i;
4708  break;
4709  }
4710  }
4711  if (c_pos != -1)
4712  {
4713  ring new_r = rCopy0(r, FALSE, TRUE);
4714  for (i=c_pos+1; i<=last_block; i++)
4715  {
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];
4720  }
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];
4725  if (complete)
4726  {
4727  rComplete(new_r, 1);
4728 
4729 #ifdef HAVE_PLURAL
4730  if (rIsPluralRing(r))
4731  {
4732  if ( nc_rComplete(r, new_r, false) ) // no qideal!
4733  {
4734 #ifndef SING_NDEBUG
4735  WarnS("error in nc_rComplete"); // cleanup?// rDelete(res);// return r; // just go on..
4736 #endif
4737  }
4738  }
4739  assume(rIsPluralRing(r) == rIsPluralRing(new_r));
4740 #endif
4741  }
4742  return new_r;
4743  }
4744  }
4745  return r;
4746 }
4747 
4748 // Moves _c or _C ordering to the last place AND adds _s on the 1st place
4750 {
4751  rTest(r);
4752 
4753  ring new_r_1 = rAssure_CompLastBlock(r, FALSE); // due to this FALSE - no completion!
4754  ring new_r = rAssure_SyzComp(new_r_1, FALSE); // new_r_1 is used only here!!!
4755 
4756  if (new_r == r)
4757  return r;
4758 
4759  ring old_r = r;
4760  if (new_r_1 != new_r && new_r_1 != old_r) rDelete(new_r_1);
4761 
4762  rComplete(new_r, TRUE);
4763 #ifdef HAVE_PLURAL
4764  if (rIsPluralRing(old_r))
4765  {
4766  if ( nc_rComplete(old_r, new_r, false) ) // no qideal!
4767  {
4768 # ifndef SING_NDEBUG
4769  WarnS("error in nc_rComplete"); // cleanup? rDelete(res); return r; // just go on...?
4770 # endif
4771  }
4772  }
4773 #endif
4774 
4775 ///? rChangeCurrRing(new_r);
4776  if (old_r->qideal != NULL)
4777  {
4778  new_r->qideal = idrCopyR(old_r->qideal, old_r, new_r);
4779  }
4780 
4781 #ifdef HAVE_PLURAL
4782  if( rIsPluralRing(old_r) )
4783  if( nc_SetupQuotient(new_r, old_r, true) )
4784  {
4785 #ifndef SING_NDEBUG
4786  WarnS("error in nc_SetupQuotient"); // cleanup? rDelete(res); return r; // just go on...?
4787 #endif
4788  }
4789 #endif
4790 
4791 #ifdef HAVE_PLURAL
4792  assume((new_r->qideal==NULL) == (old_r->qideal==NULL));
4793  assume(rIsPluralRing(new_r) == rIsPluralRing(old_r));
4794  assume(rIsSCA(new_r) == rIsSCA(old_r));
4795  assume(ncRingType(new_r) == ncRingType(old_r));
4796 #endif
4797 
4798  rTest(new_r);
4799  rTest(old_r);
4800  return new_r;
4801 }
4802 
4803 // use this for global orderings consisting of two blocks
4804 static ring rAssure_Global(rRingOrder_t b1, rRingOrder_t b2, const ring r)
4805 {
4806  int r_blocks = rBlocks(r);
4807 
4808  assume(b1 == ringorder_c || b1 == ringorder_C ||
4809  b2 == ringorder_c || b2 == ringorder_C ||
4810  b2 == ringorder_S);
4811  if ((r_blocks == 3) &&
4812  (r->order[0] == b1) &&
4813  (r->order[1] == b2) &&
4814  (r->order[2] == 0))
4815  return r;
4816  ring res = rCopy0(r, FALSE, FALSE);
4817  res->order = (rRingOrder_t*)omAlloc0(3*sizeof(rRingOrder_t));
4818  res->block0 = (int*)omAlloc0(3*sizeof(int));
4819  res->block1 = (int*)omAlloc0(3*sizeof(int));
4820  res->wvhdl = (int**)omAlloc0(3*sizeof(int*));
4821  res->order[0] = b1;
4822  res->order[1] = b2;
4823  if (b1 == ringorder_c || b1 == ringorder_C)
4824  {
4825  res->block0[1] = 1;
4826  res->block1[1] = r->N;
4827  }
4828  else
4829  {
4830  res->block0[0] = 1;
4831  res->block1[0] = r->N;
4832  }
4833  rComplete(res, 1);
4834  if (r->qideal!=NULL) res->qideal= idrCopyR_NoSort(r->qideal, r, res);
4835 #ifdef HAVE_PLURAL
4836  if (rIsPluralRing(r))
4837  {
4838  if ( nc_rComplete(r, res, false) ) // no qideal!
4839  {
4840 #ifndef SING_NDEBUG
4841  WarnS("error in nc_rComplete");
4842 #endif
4843  }
4844  }
4845 #endif
4846 // rChangeCurrRing(res);
4847  return res;
4848 }
4849 
4850 ring rAssure_InducedSchreyerOrdering(const ring r, BOOLEAN complete/* = TRUE*/, int sgn/* = 1*/)
4851 { // TODO: ???? Add leading Syz-comp ordering here...????
4852 
4853 #if MYTEST
4854  Print("rAssure_InducedSchreyerOrdering(r, complete = %d, sgn = %d): r: \n", complete, sgn);
4855  rWrite(r);
4856 #ifdef RDEBUG
4857  rDebugPrint(r);
4858 #endif
4859  PrintLn();
4860 #endif
4861  assume((sgn == 1) || (sgn == -1));
4862 
4863  ring res=rCopy0(r, FALSE, FALSE); // No qideal & ordering copy.
4864 
4865  int n = rBlocks(r); // Including trailing zero!
4866 
4867  // Create 2 more blocks for prefix/suffix:
4868  res->order=(rRingOrder_t *)omAlloc0((n+2)*sizeof(rRingOrder_t)); // 0 .. n+1
4869  res->block0=(int *)omAlloc0((n+2)*sizeof(int));
4870  res->block1=(int *)omAlloc0((n+2)*sizeof(int));
4871  int ** wvhdl =(int **)omAlloc0((n+2)*sizeof(int**));
4872 
4873  // Encapsulate all existing blocks between induced Schreyer ordering markers: prefix and suffix!
4874  // Note that prefix and suffix have the same ringorder marker and only differ in block[] parameters!
4875 
4876  // new 1st block
4877  int j = 0;
4878  res->order[j] = ringorder_IS; // Prefix
4879  res->block0[j] = res->block1[j] = 0;
4880  // wvhdl[j] = NULL;
4881  j++;
4882 
4883  for(int i = 0; (i <= n) && (r->order[i] != 0); i++, j++) // i = [0 .. n-1] <- non-zero old blocks
4884  {
4885  res->order [j] = r->order [i];
4886  res->block0[j] = r->block0[i];
4887  res->block1[j] = r->block1[i];
4888 
4889  if (r->wvhdl[i] != NULL)
4890  {
4891  #ifdef HAVE_OMALLOC
4892  wvhdl[j] = (int*) omMemDup(r->wvhdl[i]);
4893  #else
4894  {
4895  int l=(r->block1[i]-r->block0[i]+1);
4896  if (r->order[i]==ringorder_a64) l*=2;
4897  else if (r->order[i]==ringorder_M) l=l*l;
4898  else if (r->order[i]==ringorder_am)
4899  {
4900  l+=r->wvhdl[i][r->block1[i]-r->block0[i]+1]+1;
4901  }
4902  wvhdl[j]=(int*)omalloc(l*sizeof(int));
4903  memcpy(wvhdl[j],r->wvhdl[i],l*sizeof(int));
4904  }
4905  #endif
4906  } // else wvhdl[j] = NULL;
4907  }
4908 
4909  // new last block
4910  res->order [j] = ringorder_IS; // Suffix
4911  res->block0[j] = res->block1[j] = sgn; // Sign of v[o]: 1 for C, -1 for c
4912  // wvhdl[j] = NULL;
4913  j++;
4914 
4915  // res->order [j] = 0; // The End!
4916  res->wvhdl = wvhdl;
4917 
4918  // j == the last zero block now!
4919  assume(j == (n+1));
4920  assume(res->order[0]==ringorder_IS);
4921  assume(res->order[j-1]==ringorder_IS);
4922  assume(res->order[j]==0);
4923 
4924 
4925  if (complete)
4926  {
4927  rComplete(res, 1);
4928 
4929 #ifdef HAVE_PLURAL
4930  if (rIsPluralRing(r))
4931  {
4932  if ( nc_rComplete(r, res, false) ) // no qideal!
4933  {
4934 #ifndef SING_NDEBUG
4935  WarnS("error in nc_rComplete"); // cleanup?// rDelete(res);// return r; // just go on..
4936 #endif
4937  }
4938  }
4940 #endif
4941 
4942 
4943 #ifdef HAVE_PLURAL
4944  ring old_ring = r;
4945 #endif
4946 
4947  if (r->qideal!=NULL)
4948  {
4949  res->qideal= idrCopyR_NoSort(r->qideal, r, res);
4950 
4951  assume(id_RankFreeModule(res->qideal, res) == 0);
4952 
4953 #ifdef HAVE_PLURAL
4954  if( rIsPluralRing(res) )
4955  if( nc_SetupQuotient(res, r, true) )
4956  {
4957 // WarnS("error in nc_SetupQuotient"); // cleanup? rDelete(res); return r; // just go on...?
4958  }
4959 
4960 #endif
4961  assume(id_RankFreeModule(res->qideal, res) == 0);
4962  }
4963 
4964 #ifdef HAVE_PLURAL
4965  assume((res->qideal==NULL) == (old_ring->qideal==NULL));
4966  assume(rIsPluralRing(res) == rIsPluralRing(old_ring));
4967  assume(rIsSCA(res) == rIsSCA(old_ring));
4968  assume(ncRingType(res) == ncRingType(old_ring));
4969 #endif
4970  }
4971 
4972  return res;
4973 }
4974 
4975 ring rAssure_dp_S(const ring r)
4976 {
4978 }
4979 
4980 ring rAssure_dp_C(const ring r)
4981 {
4983 }
4984 
4985 ring rAssure_C_dp(const ring r)
4986 {
4988 }
4989 
4990 ring rAssure_c_dp(const ring r)
4991 {
4993 }
4994 
4995 
4996 
4997 /// Finds p^th IS ordering, and returns its position in r->typ[]
4998 /// returns -1 if something went wrong!
4999 /// p - starts with 0!
5000 int rGetISPos(const int p, const ring r)
5001 {
5002  // Put the reference set F into the ring -ordering -recor
5003 #if MYTEST
5004  Print("rIsIS(p: %d)\nF:", p);
5005  PrintLn();
5006 #endif
5007 
5008  if (r->typ==NULL)
5009  {
5010 // dReportError("'rIsIS:' Error: wrong ring! (typ == NULL)");
5011  return -1;
5012  }
5013 
5014  int j = p; // Which IS record to use...
5015  for( int pos = 0; pos < r->OrdSize; pos++ )
5016  if( r->typ[pos].ord_typ == ro_is)
5017  if( j-- == 0 )
5018  return pos;
5019 
5020  return -1;
5021 }
5022 
5023 
5024 
5025 
5026 
5027 
5028 /// Changes r by setting induced ordering parameters: limit and reference leading terms
5029 /// F belong to r, we will DO a copy!
5030 /// We will use it AS IS!
5031 /// returns true is everything was allright!
5032 BOOLEAN rSetISReference(const ring r, const ideal F, const int i, const int p)
5033 {
5034  // Put the reference set F into the ring -ordering -recor
5035 
5036  if (r->typ==NULL)
5037  {
5038  dReportError("Error: WRONG USE of rSetISReference: wrong ring! (typ == NULL)");
5039  return FALSE;
5040  }
5041 
5042 
5043  int pos = rGetISPos(p, r);
5044 
5045  if( pos == -1 )
5046  {
5047  dReportError("Error: WRONG USE of rSetISReference: specified ordering block was not found!!!" );
5048  return FALSE;
5049  }
5050 
5051 #if MYTEST
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);
5054 #endif
5055 
5056  const ideal FF = idrHeadR(F, r, r); // id_Copy(F, r); // ???
5057 
5058 
5059  if( r->typ[pos].data.is.F != NULL)
5060  {
5061 #if MYTEST
5062  PrintS("Deleting old reference set F... \n"); // idShow(r->typ[pos].data.is.F, r); PrintLn();
5063 #endif
5064  id_Delete(&r->typ[pos].data.is.F, r);
5065  r->typ[pos].data.is.F = NULL;
5066  }
5067 
5068  assume(r->typ[pos].data.is.F == NULL);
5069 
5070  r->typ[pos].data.is.F = FF; // F is owened by ring now! TODO: delete at the end!
5071 
5072  r->typ[pos].data.is.limit = i; // First induced component
5073 
5074 #if MYTEST
5075  PrintS("New reference set FF : \n"); idShow(FF, r, r, 1); PrintLn();
5076 #endif
5077 
5078  return TRUE;
5079 }
5080 
5081 #ifdef PDEBUG
5083 #endif
5084 
5085 
5086 void rSetSyzComp(int k, const ring r)
5087 {
5088  if(k < 0)
5089  {
5090  dReportError("rSetSyzComp with negative limit!");
5091  return;
5092  }
5093 
5094  assume( k >= 0 );
5095  if (TEST_OPT_PROT) Print("{%d}", k);
5096  if ((r->typ!=NULL) && (r->typ[0].ord_typ==ro_syz))
5097  {
5098  r->block0[0]=r->block1[0] = k;
5099  if( k == r->typ[0].data.syz.limit )
5100  return; // nothing to do
5101 
5102  int i;
5103  if (r->typ[0].data.syz.limit == 0)
5104  {
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;
5108  }
5109  else
5110  {
5111  r->typ[0].data.syz.syz_index = (int*)
5112  omReallocSize(r->typ[0].data.syz.syz_index,
5113  (r->typ[0].data.syz.limit+1)*sizeof(int),
5114  (k+1)*sizeof(int));
5115  }
5116  for (i=r->typ[0].data.syz.limit + 1; i<= k; i++)
5117  {
5118  r->typ[0].data.syz.syz_index[i] =
5119  r->typ[0].data.syz.curr_index;
5120  }
5121  if(k < r->typ[0].data.syz.limit) // ?
5122  {
5123 #ifndef SING_NDEBUG
5124  Warn("rSetSyzComp called with smaller limit (%d) as before (%d)", k, r->typ[0].data.syz.limit);
5125 #endif
5126  r->typ[0].data.syz.curr_index = 1 + r->typ[0].data.syz.syz_index[k];
5127  }
5128 
5129 
5130  r->typ[0].data.syz.limit = k;
5131  r->typ[0].data.syz.curr_index++;
5132  }
5133  else if(
5134  (r->typ!=NULL) &&
5135  (r->typ[0].ord_typ==ro_isTemp)
5136  )
5137  {
5138 // (r->typ[currRing->typ[0].data.isTemp.suffixpos].data.is.limit == k)
5139 #ifndef SING_NDEBUG
5140  Warn("rSetSyzComp(%d) in an IS ring! Be careful!", k);
5141 #endif
5142  }
5143  else if (r->order[0]==ringorder_s)
5144  {
5145  r->block0[0] = r->block1[0] = k;
5146  }
5147  else if (r->order[0]!=ringorder_c)
5148  {
5149  dReportError("syzcomp in incompatible ring");
5150  }
5151 #ifdef PDEBUG
5152  EXTERN_VAR int pDBsyzComp;
5153  pDBsyzComp=k;
5154 #endif
5155 }
5156 
5157 // return the max-comonent wchich has syzIndex i
5158 int rGetMaxSyzComp(int i, const ring r)
5159 {
5160  if ((r->typ!=NULL) && (r->typ[0].ord_typ==ro_syz) &&
5161  r->typ[0].data.syz.limit > 0 && i > 0)
5162  {
5163  assume(i <= r->typ[0].data.syz.limit);
5164  int j;
5165  for (j=0; j<r->typ[0].data.syz.limit; j++)
5166  {
5167  if (r->typ[0].data.syz.syz_index[j] == i &&
5168  r->typ[0].data.syz.syz_index[j+1] != i)
5169  {
5170  assume(r->typ[0].data.syz.syz_index[j+1] == i+1);
5171  return j;
5172  }
5173  }
5174  return r->typ[0].data.syz.limit;
5175  }
5176  else
5177  {
5178  #ifndef SING_NDEBUG
5179  WarnS("rGetMaxSyzComp: order c");
5180  #endif
5181  return 0;
5182  }
5183 }
5184 
5186 {
5187  assume(r != NULL);
5188  int lb = rBlocks(r) - 2;
5189  return (r->order[lb] == ringorder_c || r->order[lb] == ringorder_C);
5190 }
5191 
5193 {
5194  if ((r->order[0]==ringorder_dp) &&(r->block0[0]==1) &&(r->block1[0]==r->N))
5195  return TRUE;
5196  if (((r->order[0]==ringorder_c)||(r->order[0]==ringorder_C))
5197  && ((r->order[1]==ringorder_dp) &&(r->block0[1]==1) &&(r->block1[1]==r->N)))
5198  return TRUE;
5199  return FALSE;
5200 }
5201 
5203 {
5204  if ((r->order[0]==ringorder_Dp) &&(r->block0[0]==1) &&(r->block1[0]==r->N))
5205  return TRUE;
5206  if (((r->order[0]==ringorder_c)||(r->order[0]==ringorder_C))
5207  && ((r->order[1]==ringorder_Dp) &&(r->block0[1]==1) &&(r->block1[1]==r->N)))
5208  return TRUE;
5209  return FALSE;
5210 }
5211 
5213 {
5214  if ((r->order[0]==ringorder_lp) &&(r->block0[0]==1) &&(r->block1[0]==r->N))
5215  return TRUE;
5216  if (((r->order[0]==ringorder_c)||(r->order[0]==ringorder_C))
5217  && ((r->order[1]==ringorder_lp) &&(r->block0[1]==1) &&(r->block1[1]==r->N)))
5218  return TRUE;
5219  return FALSE;
5220 }
5221 
5222 int64 * rGetWeightVec(const ring r)
5223 {
5224  assume(r!=NULL);
5225  assume(r->OrdSize>0);
5226  int i=0;
5227  while((r->typ[i].ord_typ!=ro_wp64) && (r->typ[i].ord_typ>0)) i++;
5228  if (r->typ[i].ord_typ!=ro_wp64) return NULL; /* should not happen*/
5229  return r->typ[i].data.wp64.weights64;
5230 }
5231 
5232 void rSetWeightVec(ring r, int64 *wv)
5233 {
5234  assume(r!=NULL);
5235  assume(r->OrdSize>0);
5236  assume(r->typ[0].ord_typ==ro_wp64);
5237  memcpy(r->typ[0].data.wp64.weights64,wv,r->N*sizeof(int64));
5238 }
5239 
5240 #include <ctype.h>
5241 
5242 static int rRealloc1(ring r, int size, int pos)
5243 {
5244  r->order=(rRingOrder_t*)omReallocSize(r->order, size*sizeof(rRingOrder_t), (size+1)*sizeof(rRingOrder_t));
5245  r->block0=(int*)omReallocSize(r->block0, size*sizeof(int), (size+1)*sizeof(int));
5246  r->block1=(int*)omReallocSize(r->block1, size*sizeof(int), (size+1)*sizeof(int));
5247  r->wvhdl=(int **)omReallocSize(r->wvhdl,size*sizeof(int *), (size+1)*sizeof(int *));
5248  for(int k=size; k>pos; k--) r->wvhdl[k]=r->wvhdl[k-1];
5249  r->order[size]=(rRingOrder_t)0;
5250  size++;
5251  return size;
5252 }
5253 #if 0 // currently unused
5254 static int rReallocM1(ring r, int size, int pos)
5255 {
5256  r->order=(int*)omReallocSize(r->order, size*sizeof(int), (size-1)*sizeof(int));
5257  r->block0=(int*)omReallocSize(r->block0, size*sizeof(int), (size-1)*sizeof(int));
5258  r->block1=(int*)omReallocSize(r->block1, size*sizeof(int), (size-1)*sizeof(int));
5259  r->wvhdl=(int **)omReallocSize(r->wvhdl,size*sizeof(int *), (size-1)*sizeof(int *));
5260  for(int k=pos+1; k<size; k++) r->wvhdl[k]=r->wvhdl[k+1];
5261  size--;
5262  return size;
5263 }
5264 #endif
5265 static void rOppWeight(int *w, int l)
5266 {
5267  /* works for commutative/Plural; need to be changed for Letterplace */
5268  /* Letterpace: each block of vars needs to be reverted on it own */
5269  int i2=(l+1)/2;
5270  for(int j=0; j<=i2; j++)
5271  {
5272  int t=w[j];
5273  w[j]=w[l-j];
5274  w[l-j]=t;
5275  }
5276 }
5277 
5278 #define rOppVar(R,I) (rVar(R)+1-I)
5279 /* nice for Plural, need to be changed for Letterplace: requires also the length of a monomial */
5280 
5281 ring rOpposite(ring src)
5282  /* creates an opposite algebra of R */
5283  /* that is R^opp, where f (*^opp) g = g*f */
5284  /* treats the case of qring */
5285 {
5286  if (src == NULL) return(NULL);
5287 
5288  //rChangeCurrRing(src);
5289 #ifdef RDEBUG
5290  rTest(src);
5291 // rWrite(src);
5292 // rDebugPrint(src);
5293 #endif
5294 
5295  ring r = rCopy0(src,FALSE);
5296  if (src->qideal != NULL)
5297  {
5298  id_Delete(&(r->qideal), src);
5299  }
5300 
5301  // change vars v1..vN -> vN..v1
5302  int i;
5303  int i2 = (rVar(r)-1)/2;
5304  for(i=i2; i>=0; i--)
5305  {
5306  // index: 0..N-1
5307  //Print("ex var names: %d <-> %d\n",i,rOppVar(r,i));
5308  // exchange names
5309  char *p;
5310  p = r->names[rVar(r)-1-i];
5311  r->names[rVar(r)-1-i] = r->names[i];
5312  r->names[i] = p;
5313  }
5314 // i2=(rVar(r)+1)/2;
5315 // for(int i=i2; i>0; i--)
5316 // {
5317 // // index: 1..N
5318 // //Print("ex var places: %d <-> %d\n",i,rVar(r)+1-i);
5319 // // exchange VarOffset
5320 // int t;
5321 // t=r->VarOffset[i];
5322 // r->VarOffset[i]=r->VarOffset[rOppVar(r,i)];
5323 // r->VarOffset[rOppVar(r,i)]=t;
5324 // }
5325  // change names:
5326  // TODO: does this work the same way for Letterplace?
5327  for (i=rVar(r)-1; i>=0; i--)
5328  {
5329  char *p=r->names[i];
5330  if(isupper(*p)) *p = tolower(*p);
5331  else *p = toupper(*p);
5332  }
5333  // change ordering: listing
5334  // change ordering: compare
5335 // for(i=0; i<r->OrdSize; i++)
5336 // {
5337 // int t,tt;
5338 // switch(r->typ[i].ord_typ)
5339 // {
5340 // case ro_dp:
5341 // //
5342 // t=r->typ[i].data.dp.start;
5343 // r->typ[i].data.dp.start=rOppVar(r,r->typ[i].data.dp.end);
5344 // r->typ[i].data.dp.end=rOppVar(r,t);
5345 // break;
5346 // case ro_wp:
5347 // case ro_wp_neg:
5348 // {
5349 // t=r->typ[i].data.wp.start;
5350 // r->typ[i].data.wp.start=rOppVar(r,r->typ[i].data.wp.end);
5351 // r->typ[i].data.wp.end=rOppVar(r,t);
5352 // // invert r->typ[i].data.wp.weights
5353 // rOppWeight(r->typ[i].data.wp.weights,
5354 // r->typ[i].data.wp.end-r->typ[i].data.wp.start);
5355 // break;
5356 // }
5357 // //case ro_wp64:
5358 // case ro_syzcomp:
5359 // case ro_syz:
5360 // WerrorS("not implemented in rOpposite");
5361 // // should not happen
5362 // break;
5363 //
5364 // case ro_cp:
5365 // t=r->typ[i].data.cp.start;
5366 // r->typ[i].data.cp.start=rOppVar(r,r->typ[i].data.cp.end);
5367 // r->typ[i].data.cp.end=rOppVar(r,t);
5368 // break;
5369 // case ro_none:
5370 // default:
5371 // Werror("unknown type in rOpposite(%d)",r->typ[i].ord_typ);
5372 // break;
5373 // }
5374 // }
5375  // Change order/block structures (needed for rPrint, rAdd etc.)
5376 
5377  int j=0;
5378  int l=rBlocks(src);
5379  if ( ! rIsLPRing(src) )
5380  {
5381  // ie Plural or commutative
5382  for(i=0; src->order[i]!=0; i++)
5383  {
5384  switch (src->order[i])
5385  {
5386  case ringorder_c: /* c-> c */
5387  case ringorder_C: /* C-> C */
5388  case ringorder_no /*=0*/: /* end-of-block */
5389  r->order[j]=src->order[i];
5390  j++; break;
5391  case ringorder_lp: /* lp -> rp */
5392  r->order[j]=ringorder_rp;
5393  r->block0[j]=rOppVar(r, src->block1[i]);
5394  r->block1[j]=rOppVar(r, src->block0[i]);
5395  j++;break;
5396  case ringorder_rp: /* rp -> lp */
5397  r->order[j]=ringorder_lp;
5398  r->block0[j]=rOppVar(r, src->block1[i]);
5399  r->block1[j]=rOppVar(r, src->block0[i]);
5400  j++;break;
5401  case ringorder_dp: /* dp -> a(1..1),ls */
5402  {
5403  l=rRealloc1(r,l,j);
5404  r->order[j]=ringorder_a;
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;
5410  j++;
5411  r->order[j]=ringorder_ls;
5412  r->block0[j]=rOppVar(r, src->block1[i]);
5413  r->block1[j]=rOppVar(r, src->block0[i]);
5414  j++;
5415  break;
5416  }
5417  case ringorder_Dp: /* Dp -> a(1..1),rp */
5418  {
5419  l=rRealloc1(r,l,j);
5420  r->order[j]=ringorder_a;
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;
5426  j++;
5427  r->order[j]=ringorder_rp;
5428  r->block0[j]=rOppVar(r, src->block1[i]);
5429  r->block1[j]=rOppVar(r, src->block0[i]);
5430  j++;
5431  break;
5432  }
5433  case ringorder_wp: /* wp -> a(...),ls */
5434  {
5435  l=rRealloc1(r,l,j);
5436  r->order[j]=ringorder_a;
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;
5440  rOppWeight(r->wvhdl[j], r->block1[j]-r->block0[j]);
5441  j++;
5442  r->order[j]=ringorder_ls;
5443  r->block0[j]=rOppVar(r, src->block1[i]);
5444  r->block1[j]=rOppVar(r, src->block0[i]);
5445  j++;
5446  break;
5447  }
5448  case ringorder_Wp: /* Wp -> a(...),rp */
5449  {
5450  l=rRealloc1(r,l,j);
5451  r->order[j]=ringorder_a;
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;
5455  rOppWeight(r->wvhdl[j], r->block1[j]-r->block0[j]);
5456  j++;
5457  r->order[j]=ringorder_rp;
5458  r->block0[j]=rOppVar(r, src->block1[i]);
5459  r->block1[j]=rOppVar(r, src->block0[i]);
5460  j++;
5461  break;
5462  }
5463  case ringorder_M: /* M -> M */
5464  {
5465  r->order[j]=ringorder_M;
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];
5469  /* M is a (n+1)x(n+1) matrix */
5470  for (int nn=0; nn<=n; nn++)
5471  {
5472  rOppWeight(&(r->wvhdl[j][nn*(n+1)]), n /*r->block1[j]-r->block0[j]*/);
5473  }
5474  j++;
5475  break;
5476  }
5477  case ringorder_a: /* a(...),ls -> wp/dp */
5478  {
5479  r->block0[j]=rOppVar(r, src->block1[i]);
5480  r->block1[j]=rOppVar(r, src->block0[i]);
5481  rOppWeight(r->wvhdl[j], r->block1[j]-r->block0[j]);
5482  if (src->order[i+1]==ringorder_ls)
5483  {
5484  r->order[j]=ringorder_wp;
5485  i++;
5486  //l=rReallocM1(r,l,j);
5487  }
5488  else
5489  {
5490  r->order[j]=ringorder_a;
5491  }
5492  j++;
5493  break;
5494  }
5495  // not yet done:
5496  case ringorder_ls:
5497  case ringorder_rs:
5498  case ringorder_ds:
5499  case ringorder_Ds:
5500  case ringorder_ws:
5501  case ringorder_Ws:
5502  case ringorder_am:
5503  case ringorder_a64:
5504  // should not occur:
5505  case ringorder_S:
5506  case ringorder_IS:
5507  case ringorder_s:
5508  case ringorder_aa:
5509  case ringorder_L:
5510  case ringorder_unspec:
5511  Werror("order %s not (yet) supported", rSimpleOrdStr(src->order[i]));
5512  break;
5513  }
5514  }
5515  } /* end if (!rIsLPRing(src)) */
5516  if (rIsLPRing(src))
5517  {
5518  // applies to Letterplace only
5519  // Letterplace conventions: dp<->Dp, lp<->rp
5520  // Wp(v) cannot be converted since wp(v) does not encode a monomial ordering
5521  // (a(w),<) is troublesome and thus postponed
5522  for(i=0; src->order[i]!=0; i++)
5523  {
5524  switch (src->order[i])
5525  {
5526  case ringorder_c: /* c-> c */
5527  case ringorder_C: /* C-> C */
5528  case ringorder_no /*=0*/: /* end-of-block */
5529  r->order[j]=src->order[i];
5530  j++; break;
5531  case ringorder_lp: /* lp -> rp */
5532  r->order[j]=ringorder_rp;
5533  r->block0[j]=rOppVar(r, src->block1[i]);
5534  r->block1[j]=rOppVar(r, src->block0[i]);
5535  j++;break;
5536  case ringorder_rp: /* rp -> lp */
5537  r->order[j]=ringorder_lp;
5538  r->block0[j]=rOppVar(r, src->block1[i]);
5539  r->block1[j]=rOppVar(r, src->block0[i]);
5540  j++;break;
5541  case ringorder_dp: /* dp -> Dp */
5542  {
5543  r->order[j]=ringorder_Dp;
5544  r->block0[j]=rOppVar(r, src->block1[i]);
5545  r->block1[j]=rOppVar(r, src->block0[i]);
5546  j++;break;
5547  }
5548  case ringorder_Dp: /* Dp -> dp*/
5549  {
5550  r->order[j]=ringorder_dp;
5551  r->block0[j]=rOppVar(r, src->block1[i]);
5552  r->block1[j]=rOppVar(r, src->block0[i]);
5553  j++;break;
5554  }
5555  // not clear how to do:
5556  case ringorder_wp:
5557  case ringorder_Wp:
5558  case ringorder_M:
5559  case ringorder_a:
5560  // not yet done:
5561  case ringorder_ls:
5562  case ringorder_rs:
5563  case ringorder_ds:
5564  case ringorder_Ds:
5565  case ringorder_ws:
5566  case ringorder_Ws:
5567  case ringorder_am:
5568  case ringorder_a64:
5569  // should not occur:
5570  case ringorder_S:
5571  case ringorder_IS:
5572  case ringorder_s:
5573  case ringorder_aa:
5574  case ringorder_L:
5575  case ringorder_unspec:
5576  Werror("order %s not (yet) supported", rSimpleOrdStr(src->order[i]));
5577  break;
5578  }
5579  }
5580  } /* end if (rIsLPRing(src)) */
5581  rComplete(r);
5582 
5583  //rChangeCurrRing(r);
5584 #ifdef RDEBUG
5585  rTest(r);
5586 // rWrite(r);
5587 // rDebugPrint(r);
5588 #endif
5589 
5590 #ifdef HAVE_PLURAL
5591  // now, we initialize a non-comm structure on r
5592  if (rIsPluralRing(src))
5593  {
5594 // assume( currRing == r);
5595 
5596  int *perm = (int *)omAlloc0((rVar(r)+1)*sizeof(int));
5597  int *par_perm = NULL;
5598  nMapFunc nMap = n_SetMap(src->cf,r->cf);
5599  int ni,nj;
5600  for(i=1; i<=r->N; i++)
5601  {
5602  perm[i] = rOppVar(r,i);
5603  }
5604 
5605  matrix C = mpNew(rVar(r),rVar(r));
5606  matrix D = mpNew(rVar(r),rVar(r));
5607 
5608  for (i=1; i< rVar(r); i++)
5609  {
5610  for (j=i+1; j<=rVar(r); j++)
5611  {
5612  ni = r->N +1 - i;
5613  nj = r->N +1 - j; /* i<j ==> nj < ni */
5614 
5615  assume(MATELEM(src->GetNC()->C,i,j) != NULL);
5616  MATELEM(C,nj,ni) = p_PermPoly(MATELEM(src->GetNC()->C,i,j),perm,src,r, nMap,par_perm,rPar(src));
5617 
5618  if(MATELEM(src->GetNC()->D,i,j) != NULL)
5619  MATELEM(D,nj,ni) = p_PermPoly(MATELEM(src->GetNC()->D,i,j),perm,src,r, nMap,par_perm,rPar(src));
5620  }
5621  }
5622 
5623  id_Test((ideal)C, r);
5624  id_Test((ideal)D, r);
5625 
5626  if (nc_CallPlural(C, D, NULL, NULL, r, false, false, true, r)) // no qring setup!
5627  WarnS("Error initializing non-commutative multiplication!");
5628 
5629 #ifdef RDEBUG
5630  rTest(r);
5631 // rWrite(r);
5632 // rDebugPrint(r);
5633 #endif
5634 
5635  assume( r->GetNC()->IsSkewConstant == src->GetNC()->IsSkewConstant);
5636 
5637  omFreeSize((ADDRESS)perm,(rVar(r)+1)*sizeof(int));
5638  }
5639 #endif /* HAVE_PLURAL */
5640 
5641  /* now oppose the qideal for qrings */
5642  if (src->qideal != NULL)
5643  {
5644 #ifdef HAVE_PLURAL
5645  r->qideal = idOppose(src, src->qideal, r); // into the currRing: r
5646 #else
5647  r->qideal = id_Copy(src->qideal, r); // ?
5648 #endif
5649 
5650 #ifdef HAVE_PLURAL
5651  if( rIsPluralRing(r) )
5652  {
5653  nc_SetupQuotient(r);
5654 #ifdef RDEBUG
5655  rTest(r);
5656 // rWrite(r);
5657 // rDebugPrint(r);
5658 #endif
5659  }
5660 #endif
5661  }
5662 #ifdef HAVE_PLURAL
5663  if( rIsPluralRing(r) )
5664  assume( ncRingType(r) == ncRingType(src) );
5665 #endif
5666  rTest(r);
5667 
5668  return r;
5669 }
5670 
5671 ring rEnvelope(ring R)
5672  /* creates an enveloping algebra of R */
5673  /* that is R^e = R \tensor_K R^opp */
5674 {
5675  ring Ropp = rOpposite(R);
5676  ring Renv = NULL;
5677  int stat = rSum(R, Ropp, Renv); /* takes care of qideals */
5678  if ( stat <=0 )
5679  WarnS("Error in rEnvelope at rSum");
5680  rTest(Renv);
5681  return Renv;
5682 }
5683 
5684 #ifdef HAVE_PLURAL
5685 BOOLEAN nc_rComplete(const ring src, ring dest, bool bSetupQuotient)
5686 /* returns TRUE is there were errors */
5687 /* dest is actualy equals src with the different ordering */
5688 /* we map src->nc correctly to dest->src */
5689 /* to be executed after rComplete, before rChangeCurrRing */
5690 {
5691 // NOTE: Originally used only by idElimination to transfer NC structure to dest
5692 // ring created by dirty hack (without nc_CallPlural)
5693  rTest(src);
5694 
5695  assume(!rIsPluralRing(dest)); // destination must be a newly constructed commutative ring
5696 
5697  if (!rIsPluralRing(src))
5698  {
5699  return FALSE;
5700  }
5701 
5702  const int N = dest->N;
5703 
5704  assume(src->N == N);
5705 
5706 // ring save = currRing;
5707 
5708 // if (dest != save)
5709 // rChangeCurrRing(dest);
5710 
5711  const ring srcBase = src;
5712 
5713  assume( n_SetMap(srcBase->cf,dest->cf) == n_SetMap(dest->cf,dest->cf) ); // currRing is important here!
5714 
5715  matrix C = mpNew(N,N); // ring independent
5716  matrix D = mpNew(N,N);
5717 
5718  matrix C0 = src->GetNC()->C;
5719  matrix D0 = src->GetNC()->D;
5720 
5721  // map C and D into dest
5722  for (int i = 1; i < N; i++)
5723  {
5724  for (int j = i + 1; j <= N; j++)
5725  {
5726  const number n = n_Copy(p_GetCoeff(MATELEM(C0,i,j), srcBase), srcBase->cf); // src, mapping for coeffs into currRing = dest!
5727  const poly p = p_NSet(n, dest);
5728  MATELEM(C,i,j) = p;
5729  if (MATELEM(D0,i,j) != NULL)
5730  MATELEM(D,i,j) = prCopyR(MATELEM(D0,i,j), srcBase, dest); // ?
5731  }
5732  }
5733  /* One must test C and D _only_ in r->GetNC()->basering!!! not in r!!! */
5734 
5735  id_Test((ideal)C, dest);
5736  id_Test((ideal)D, dest);
5737 
5738  if (nc_CallPlural(C, D, NULL, NULL, dest, bSetupQuotient, false, true, dest)) // also takes care about quotient ideal
5739  {
5740  //WarnS("Error transferring non-commutative structure");
5741  // error message should be in the interpreter interface
5742 
5743  mp_Delete(&C, dest);
5744  mp_Delete(&D, dest);
5745 
5746 // if (currRing != save)
5747 // rChangeCurrRing(save);
5748 
5749  return TRUE;
5750  }
5751 
5752 // mp_Delete(&C, dest); // used by nc_CallPlural!
5753 // mp_Delete(&D, dest);
5754 
5755 // if (dest != save)
5756 // rChangeCurrRing(save);
5757 
5758  assume(rIsPluralRing(dest));
5759  return FALSE;
5760 }
5761 #endif
5762 
5763 poly rGetVar(const int varIndex, const ring r)
5764 {
5765  poly p = p_ISet(1, r);
5766  p_SetExp(p, varIndex, 1, r);
5767  p_Setm(p, r);
5768  return p;
5769 }
5770 
5771 
5772 /// TODO: rewrite somehow...
5773 int n_IsParam(const number m, const ring r)
5774 {
5775  assume(r != NULL);
5776  const coeffs C = r->cf;
5777  assume(C != NULL);
5778 
5780 
5781  const n_coeffType _filed_type = getCoeffType(C);
5782 
5783  if(( _filed_type == n_algExt )||( _filed_type == n_polyExt ))
5784  return naIsParam(m, C);
5785 
5786  if( _filed_type == n_transExt )
5787  return ntIsParam(m, C);
5788 
5789  Werror("n_IsParam: IsParam is not to be used for (coeff_type = %d)",getCoeffType(C));
5790 
5791  return 0;
5792 }
5793 
5794 ring rPlusVar(const ring r, char *v,int left)
5795 {
5796  if (r->order[2]!=0)
5797  {
5798  WerrorS("only for rings with an ordering of one block");
5799  return NULL;
5800  }
5801  int p;
5802  if((r->order[0]==ringorder_C)
5803  ||(r->order[0]==ringorder_c))
5804  p=1;
5805  else
5806  p=0;
5807  if((r->order[p]!=ringorder_dp)
5808  && (r->order[p]!=ringorder_Dp)
5809  && (r->order[p]!=ringorder_lp)
5810  && (r->order[p]!=ringorder_rp)
5811  && (r->order[p]!=ringorder_ds)
5812  && (r->order[p]!=ringorder_Ds)
5813  && (r->order[p]!=ringorder_ls))
5814  {
5815  WerrorS("ordering must be dp,Dp,lp,rp,ds,Ds or ls");
5816  return NULL;
5817  }
5818  for(int i=r->N-1;i>=0;i--)
5819  {
5820  if (strcmp(r->names[i],v)==0)
5821  {
5822  Werror("duplicate variable name >>%s<<",v);
5823  return NULL;
5824  }
5825  }
5826  ring R=rCopy0(r);
5827  char **names;
5828  #ifdef HAVE_SHIFTBBA
5829  if (rIsLPRing(r))
5830  {
5831  R->isLPring=r->isLPring+1;
5832  R->N=((r->N)/r->isLPring)+r->N;
5833  names=(char**)omAlloc(R->N*sizeof(char_ptr));
5834  if (left)
5835  {
5836  for(int b=0;b<((r->N)/r->isLPring);b++)
5837  {
5838  names[b*R->isLPring]=omStrDup(v);
5839  for(int i=R->isLPring-1;i>0;i--)
5840  names[i+b*R->isLPring]=R->names[i-1+b*r->isLPring];
5841  }
5842  }
5843  else
5844  {
5845  for(int b=0;b<((r->N)/r->isLPring);b++)
5846  {
5847  names[(b+1)*R->isLPring-1]=omStrDup(v);
5848  for(int i=R->isLPring-2;i>=0;i--)
5849  names[i+b*R->isLPring]=R->names[i+b*r->isLPring];
5850  }
5851  }
5852  }
5853  else
5854  #endif
5855  {
5856  R->N++;
5857  names=(char**)omAlloc(R->N*sizeof(char_ptr));
5858  if (left)
5859  {
5860  names[0]=omStrDup(v);
5861  for(int i=R->N-1;i>0;i--) names[i]=R->names[i-1];
5862  }
5863  else
5864  {
5865  names[R->N-1]=omStrDup(v);
5866  for(int i=R->N-2;i>=0;i--) names[i]=R->names[i];
5867  }
5868  }
5869  omFreeSize(R->names,r->N*sizeof(char_ptr));
5870  R->names=names;
5871  R->block1[p]=R->N;
5872  rComplete(R);
5873  return R;
5874 }
5875 
5876 ring rMinusVar(const ring r, char *v)
5877 {
5878  if (r->order[2]!=0)
5879  {
5880  WerrorS("only for rings with an ordering of one block");
5881  return NULL;
5882  }
5883  int p;
5884  if((r->order[0]==ringorder_C)
5885  ||(r->order[0]==ringorder_c))
5886  p=1;
5887  else
5888  p=0;
5889  if((r->order[p]!=ringorder_dp)
5890  && (r->order[p]!=ringorder_Dp)
5891  && (r->order[p]!=ringorder_lp)
5892  && (r->order[p]!=ringorder_rp)
5893  && (r->order[p]!=ringorder_ds)
5894  && (r->order[p]!=ringorder_Ds)
5895  && (r->order[p]!=ringorder_ls))
5896  {
5897  WerrorS("ordering must be dp,Dp,lp,rp,ds,Ds or ls");
5898  return NULL;
5899  }
5900  ring R=rCopy0(r);
5901  int i=R->N-1;
5902  while(i>=0)
5903  {
5904  if (strcmp(R->names[i],v)==0)
5905  {
5906  R->N--;
5907  omFree(R->names[i]);
5908  for(int j=i;j<R->N;j++) R->names[j]=R->names[j+1];
5909  R->names=(char**)omReallocSize(R->names,r->N*sizeof(char_ptr),R->N*sizeof(char_ptr));
5910  }
5911  i--;
5912  }
5913  R->block1[p]=R->N;
5914  rComplete(R,1);
5915  return R;
5916 }
int sgn(const Rational &a)
Definition: GMPrat.cc:430
int naIsParam(number m, const coeffs cf)
if m == var(i)/1 => return i,
Definition: algext.cc:1106
All the auxiliary stuff.
long int64
Definition: auxiliary.h:68
static int si_max(const int a, const int b)
Definition: auxiliary.h:124
#define BIT_SIZEOF_LONG
Definition: auxiliary.h:80
int BOOLEAN
Definition: auxiliary.h:87
#define TRUE
Definition: auxiliary.h:100
#define FALSE
Definition: auxiliary.h:96
void * ADDRESS
Definition: auxiliary.h:119
int size(const CanonicalForm &f, const Variable &v)
int size ( const CanonicalForm & f, const Variable & v )
Definition: cf_ops.cc:600
const CanonicalForm CFMap CFMap & N
Definition: cfEzgcd.cc:56
int l
Definition: cfEzgcd.cc:100
int m
Definition: cfEzgcd.cc:128
for(int i=0;i<=n;i++) degsf[i]
Definition: cfEzgcd.cc:72
int i
Definition: cfEzgcd.cc:132
int k
Definition: cfEzgcd.cc:99
Variable x
Definition: cfModGcd.cc:4082
int p
Definition: cfModGcd.cc:4078
CanonicalForm cf
Definition: cfModGcd.cc:4083
CanonicalForm b
Definition: cfModGcd.cc:4103
int rows() const
Definition: int64vec.h:66
Definition: intvec.h:23
int length() const
Definition: intvec.h:94
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'
Definition: coeffs.h:448
static FORCE_INLINE char * nCoeffString(const coeffs cf)
TODO: make it a virtual method of coeffs, together with: Decompose & Compose, rParameter & rPar.
Definition: coeffs.h:956
static FORCE_INLINE void n_CoeffWrite(const coeffs r, BOOLEAN details=TRUE)
output the coeff description
Definition: coeffs.h:716
static FORCE_INLINE BOOLEAN nCoeff_is_Extension(const coeffs r)
Definition: coeffs.h:843
n_coeffType
Definition: coeffs.h:27
@ n_R
single prescision (6,6) real numbers
Definition: coeffs.h:31
@ n_polyExt
used to represent polys as coeffcients
Definition: coeffs.h:34
@ n_Q
rational (GMP) numbers
Definition: coeffs.h:30
@ n_Znm
only used if HAVE_RINGS is defined
Definition: coeffs.h:45
@ n_algExt
used for all algebraic extensions, i.e., the top-most extension in an extension tower is algebraic
Definition: coeffs.h:35
@ n_Zn
only used if HAVE_RINGS is defined
Definition: coeffs.h:44
@ n_Zp
\F{p < 2^31}
Definition: coeffs.h:29
@ n_transExt
used for all transcendental extensions, i.e., the top-most extension in an extension tower is transce...
Definition: coeffs.h:38
static FORCE_INLINE nMapFunc n_SetMap(const coeffs src, const coeffs dst)
set the mapping function pointers for translating numbers from src to dst
Definition: coeffs.h:697
coeffs nInitChar(n_coeffType t, void *parameter)
one-time initialisations for new coeffs in case of an error return NULL
Definition: numbers.cc:413
static FORCE_INLINE n_coeffType getCoeffType(const coeffs r)
Returns the type of coeffs domain.
Definition: coeffs.h:422
static FORCE_INLINE coeffs nCopyCoeff(const coeffs r)
"copy" coeffs, i.e. increment ref
Definition: coeffs.h:430
static FORCE_INLINE BOOLEAN nCoeff_is_algExt(const coeffs r)
TRUE iff r represents an algebraic extension field.
Definition: coeffs.h:907
number(* nMapFunc)(number a, const coeffs src, const coeffs dst)
maps "a", which lives in src, into dst
Definition: coeffs.h:73
void nKillChar(coeffs r)
undo all initialisations
Definition: numbers.cc:568
static FORCE_INLINE BOOLEAN n_IsOne(number n, const coeffs r)
TRUE iff 'n' represents the one element.
Definition: coeffs.h:465
#define Print
Definition: emacs.cc:80
#define Warn
Definition: emacs.cc:77
#define WarnS
Definition: emacs.cc:78
#define StringAppend
Definition: emacs.cc:79
const CanonicalForm int s
Definition: facAbsFact.cc:51
CanonicalForm res
Definition: facAbsFact.cc:60
const CanonicalForm & w
Definition: facAbsFact.cc:51
const Variable & v
< [in] a sqrfree bivariate poly
Definition: facBivar.h:39
bool found
Definition: facFactorize.cc:55
int j
Definition: facHensel.cc:110
static int min(int a, int b)
Definition: fast_mult.cc:268
void WerrorS(const char *s)
Definition: feFopen.cc:24
if(!FE_OPT_NO_SHELL_FLAG)(void) system(sys)
#define D(A)
Definition: gentable.cc:131
#define EXTERN_VAR
Definition: globaldefs.h:6
#define VAR
Definition: globaldefs.h:5
ideal id_Copy(ideal h1, const ring r)
copy an ideal
static BOOLEAN length(leftv result, leftv arg)
Definition: interval.cc:257
STATIC_VAR jList * Q
Definition: janet.cc:30
static bool rIsSCA(const ring r)
Definition: nc.h:190
ideal idOppose(ring Rop_src, ideal I, const ring Rop_dst)
opposes a module I from Rop to currRing(dst)
Definition: old.gring.cc:3389
bool nc_rCopy(ring res, const ring r, bool bSetupQuotient)
Definition: old.gring.cc:3011
bool nc_SetupQuotient(ring rGR, const ring rG=NULL, bool bCopy=false)
Definition: old.gring.cc:3411
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,...
Definition: old.gring.cc:2690
static nc_type & ncRingType(nc_struct *p)
Definition: nc.h:159
void nc_rKill(ring r)
complete destructor
Definition: old.gring.cc:2483
#define UPMATELEM(i, j, nVar)
Definition: nc.h:36
bool sca_Force(ring rGR, int b, int e)
Definition: sca.cc:1161
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)
Definition: maps.cc:163
void mp_Delete(matrix *a, const ring r)
Definition: matpol.cc:880
matrix mpNew(int r, int c)
create a r x c zero-matrix
Definition: matpol.cc:37
void iiWriteMatrix(matrix im, const char *n, int dim, const ring r, int spaces)
set spaces to zero by default
Definition: matpol.cc:834
#define MATELEM(mat, i, j)
1-based access to matrix
Definition: matpol.h:29
STATIC_VAR unsigned add[]
Definition: misc_ip.cc:107
#define assume(x)
Definition: mod2.h:389
int dReportError(const char *fmt,...)
Definition: dError.cc:44
#define p_GetComp(p, r)
Definition: monomials.h:64
#define pIter(p)
Definition: monomials.h:37
#define POLYSIZE
Definition: monomials.h:233
#define p_GetCoeff(p, r)
Definition: monomials.h:50
gmp_float sqrt(const gmp_float &a)
Definition: mpr_complex.cc:327
const int MAX_INT_VAL
Definition: mylimits.h:12
The main handler for Singular numbers which are suitable for Singular polynomials.
Definition: qr.h:46
#define omStrDup(s)
Definition: omAllocDecl.h:263
#define omFreeSize(addr, size)
Definition: omAllocDecl.h:260
#define omCheckAddr(addr)
Definition: omAllocDecl.h:328
#define omAlloc(size)
Definition: omAllocDecl.h:210
#define omReallocSize(addr, o_size, size)
Definition: omAllocDecl.h:220
#define omAllocBin(bin)
Definition: omAllocDecl.h:205
#define omCheckAddrSize(addr, size)
Definition: omAllocDecl.h:327
#define omAlloc0Bin(bin)
Definition: omAllocDecl.h:206
#define omalloc(size)
Definition: omAllocDecl.h:228
#define omFree(addr)
Definition: omAllocDecl.h:261
#define omAlloc0(size)
Definition: omAllocDecl.h:211
#define omFreeBin(addr, bin)
Definition: omAllocDecl.h:259
#define omMemDup(s)
Definition: omAllocDecl.h:264
#define omcheckAddrSize(addr, size)
Definition: omAllocDecl.h:329
#define omfreeSize(addr, size)
Definition: omAllocDecl.h:236
#define omGetSpecBin(size)
Definition: omBin.h:11
#define omUnGetSpecBin(bin_ptr)
Definition: omBin.h:14
#define NULL
Definition: omList.c:12
omBin_t * omBin
Definition: omStructs.h:12
VAR unsigned si_opt_1
Definition: options.c:5
#define OPT_INTSTRATEGY
Definition: options.h:93
#define OPT_REDTAIL
Definition: options.h:92
#define TEST_OPT_OLDSTD
Definition: options.h:124
#define OPT_REDTHROUGH
Definition: options.h:83
#define Sy_bit(x)
Definition: options.h:31
#define TEST_OPT_PROT
Definition: options.h:104
#define TEST_RINGDEP_OPTS
Definition: options.h:101
void p_ProcsSet(ring r, p_Procs_s *p_Procs)
Definition: p_Procs_Set.h:141
void p_Debug_GetProcNames(const ring r, p_Procs_s *p_Procs)
Definition: p_Procs_Set.h:232
void p_Debug_GetSpecNames(const ring r, const char *&field, const char *&length, const char *&ord)
Definition: p_Procs_Set.h:221
void p_Setm_WFirstTotalDegree(poly p, const ring r)
Definition: p_polys.cc:554
long pLDegb(poly p, int *l, const ring r)
Definition: p_polys.cc:811
long pLDeg1_Totaldegree(poly p, int *l, const ring r)
Definition: p_polys.cc:975
long p_WFirstTotalDegree(poly p, const ring r)
Definition: p_polys.cc:596
long pLDeg1_WFirstTotalDegree(poly p, int *l, const ring r)
Definition: p_polys.cc:1038
long pLDeg1c_WFirstTotalDegree(poly p, int *l, const ring r)
Definition: p_polys.cc:1068
void p_Setm_Dummy(poly p, const ring r)
Definition: p_polys.cc:541
void p_Setm_TotalDegree(poly p, const ring r)
Definition: p_polys.cc:547
poly p_ISet(long i, const ring r)
returns the poly representing the integer i
Definition: p_polys.cc:1297
long pLDeg1c_Deg(poly p, int *l, const ring r)
Definition: p_polys.cc:941
long pLDeg1(poly p, int *l, const ring r)
Definition: p_polys.cc:841
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)
Definition: p_polys.cc:4126
long pLDeg1_Deg(poly p, int *l, const ring r)
Definition: p_polys.cc:910
long p_WTotaldegree(poly p, const ring r)
Definition: p_polys.cc:613
p_SetmProc p_GetSetmProc(const ring r)
Definition: p_polys.cc:560
void p_Setm_General(poly p, const ring r)
Definition: p_polys.cc:158
long pLDeg1c(poly p, int *l, const ring r)
Definition: p_polys.cc:877
long pLDeg1c_Totaldegree(poly p, int *l, const ring r)
Definition: p_polys.cc:1005
long pLDeg0c(poly p, int *l, const ring r)
Definition: p_polys.cc:770
long pLDeg0(poly p, int *l, const ring r)
Definition: p_polys.cc:739
poly p_One(const ring r)
Definition: p_polys.cc:1313
poly p_NSet(number n, const ring r)
returns the poly representing the number n, destroys n
Definition: p_polys.cc:1469
long p_Deg(poly a, const ring r)
Definition: p_polys.cc:587
BOOLEAN p_EqualPolys(poly p1, poly p2, const ring r)
Definition: p_polys.cc:4508
static long p_FDeg(const poly p, const ring r)
Definition: p_polys.h:378
void p_Write(poly p, ring lmRing, ring tailRing)
Definition: polys0.cc:342
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
Definition: p_polys.h:486
static void p_Setm(poly p, const ring r)
Definition: p_polys.h:231
static long p_GetExp(const poly p, const unsigned long iBitmask, const int VarOffset)
get a single variable exponent @Note: the integer VarOffset encodes:
Definition: p_polys.h:467
static void p_Delete(poly *p, const ring r)
Definition: p_polys.h:899
void p_Write0(poly p, ring lmRing, ring tailRing)
Definition: polys0.cc:332
static long p_Totaldegree(poly p, const ring r)
Definition: p_polys.h:1505
poly prCopyR(poly p, ring src_r, ring dest_r)
Definition: prCopy.cc:34
ideal idrCopyR(ideal id, ring src_r, ring dest_r)
Definition: prCopy.cc:192
ideal idrCopyR_NoSort(ideal id, ring src_r, ring dest_r)
Definition: prCopy.cc:205
ideal idrHeadR(ideal id, ring r, ring dest_r)
Copy leading terms of id[i] via prHeeadR into dest_r.
Definition: prCopy.cc:156
void StringSetS(const char *st)
Definition: reporter.cc:128
void StringAppendS(const char *st)
Definition: reporter.cc:107
void PrintS(const char *s)
Definition: reporter.cc:284
char * StringEndS()
Definition: reporter.cc:151
void PrintLn()
Definition: reporter.cc:310
void Werror(const char *fmt,...)
Definition: reporter.cc:189
static void rSetNegWeight(ring r)
Definition: ring.cc:3347
BOOLEAN rOrd_SetCompRequiresSetm(const ring r)
return TRUE if p_SetComp requires p_Setm
Definition: ring.cc:1993
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)
Definition: ring.cc:2479
int rSum(ring r1, ring r2, ring &sum)
Definition: ring.cc:1402
ring rAssure_TDeg(ring r, int &pos)
Definition: ring.cc:4527
void rWrite(ring r, BOOLEAN details)
Definition: ring.cc:226
ring rAssure_InducedSchreyerOrdering(const ring r, BOOLEAN complete, int sgn)
Definition: ring.cc:4850
static ring rAssure_Global(rRingOrder_t b1, rRingOrder_t b2, const ring r)
Definition: ring.cc:4804
BOOLEAN rOrder_is_WeightedOrdering(rRingOrder_t order)
Definition: ring.cc:1947
void rGetSComps(int **currComponents, long **currShiftedComponents, int *length, ring r)
Definition: ring.cc:4414
BOOLEAN rRing_ord_pure_Dp(const ring r)
Definition: ring.cc:5202
static void rNChangeSComps(int *currComponents, long *currShiftedComponents, ring r)
Definition: ring.cc:4367
ring rModifyRing_Wp(ring r, int *weights)
construct Wp, C ring
Definition: ring.cc:2945
BOOLEAN rOrder_is_DegOrdering(const rRingOrder_t order)
Definition: ring.cc:1928
char * rVarStr(ring r)
Definition: ring.cc:623
BOOLEAN rHasSimpleOrderAA(ring r)
Definition: ring.cc:1962
void rSetWeightVec(ring r, int64 *wv)
Definition: ring.cc:5232
const char * rSimpleOrdStr(int ord)
Definition: ring.cc:77
static void rSetOption(ring r)
Definition: ring.cc:3384
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...
Definition: ring.cc:3450
int r_IsRingVar(const char *n, char **names, int N)
Definition: ring.cc:212
#define rOppVar(R, I)
Definition: ring.cc:5278
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!...
Definition: ring.cc:5000
static void rNGetSComps(int **currComponents, long **currShiftedComponents, ring r)
Definition: ring.cc:4375
#define BITS_PER_LONG
Definition: ring.cc:40
static void rO_WDegree64(int &place, int &bitplace, int start, int end, long *o, sro_ord &ord_struct, int64 *weights)
Definition: ring.cc:2289
BOOLEAN rHasSimpleLexOrder(const ring r)
returns TRUE, if simple lp or ls ordering
Definition: ring.cc:1919
void p_SetGlobals(const ring r, BOOLEAN complete)
set all properties of a new ring - also called by rComplete
Definition: ring.cc:3415
ring rAssure_SyzComp(const ring r, BOOLEAN complete)
Definition: ring.cc:4435
BOOLEAN nc_rComplete(const ring src, ring dest, bool bSetupQuotient)
Definition: ring.cc:5685
void p_DebugPrint(poly p, const ring r)
Definition: ring.cc:4327
void rKillModifiedRing(ring r)
Definition: ring.cc:3059
BOOLEAN rRing_ord_pure_dp(const ring r)
Definition: ring.cc:5192
static void rSetVarL(ring r)
set r->VarL_Size, r->VarL_Offset, r->VarL_LowIndex
Definition: ring.cc:4027
static void rO_LexVars(int &place, int &bitplace, int start, int end, int &prev_ord, long *o, int *v, int bits, int opt_var)
Definition: ring.cc:2339
BOOLEAN rOrd_is_MixedDegree_Ordering(ring r)
Definition: ring.cc:3428
static void rDBChangeSComps(int *currComponents, long *currShiftedComponents, int length, ring r)
Definition: ring.cc:4383
ring rAssure_c_dp(const ring r)
Definition: ring.cc:4990
static void rSetOutParams(ring r)
Definition: ring.cc:3080
static void rSetDegStuff(ring r)
Definition: ring.cc:3177
static void rDBGetSComps(int **currComponents, long **currShiftedComponents, int *length, ring r)
Definition: ring.cc:4393
rOrderType_t rGetOrderType(ring r)
Definition: ring.cc:1840
int rChar(ring r)
Definition: ring.cc:713
int rTypeOfMatrixOrder(const intvec *order)
Definition: ring.cc:185
char * rOrdStr(ring r)
Definition: ring.cc:521
VAR omBin sip_sring_bin
Definition: ring.cc:43
void rUnComplete(ring r)
Definition: ring.cc:3965
ring nc_rCreateNCcomm_rCopy(ring r)
Definition: ring.cc:719
char * char_ptr
Definition: ring.cc:42
static void rOppWeight(int *w, int l)
Definition: ring.cc:5265
static void rO_WDegree_neg(int &place, int &bitplace, int start, int end, long *o, sro_ord &ord_struct, int *weights)
Definition: ring.cc:2313
void rKillModified_Wp_Ring(ring r)
Definition: ring.cc:3069
ring rMinusVar(const ring r, char *v)
undo rPlusVar
Definition: ring.cc:5876
BOOLEAN rRing_has_CompLastBlock(const ring r)
Definition: ring.cc:5185
ring rCopy0AndAddA(const ring r, int64vec *wv64, BOOLEAN copy_qideal, BOOLEAN copy_ordering)
Definition: ring.cc:1564
static void rO_Syzcomp(int &place, int &bitplace, int &prev_ord, long *o, sro_ord &ord_struct)
Definition: ring.cc:2415
BOOLEAN rOrd_is_Totaldegree_Ordering(const ring r)
Definition: ring.cc:2013
ring rModifyRing(ring r, BOOLEAN omit_degree, BOOLEAN try_omit_comp, unsigned long exp_limit)
Definition: ring.cc:2698
ring rAssure_SyzOrder(const ring r, BOOLEAN complete)
Definition: ring.cc:4430
static void rO_TDegree(int &place, int &bitplace, int start, int end, long *o, sro_ord &ord_struct)
Definition: ring.cc:2199
ring rAssure_C_dp(const ring r)
Definition: ring.cc:4985
BOOLEAN rHasSimpleOrder(const ring r)
Definition: ring.cc:1887
char * rCharStr(const ring r)
TODO: make it a virtual method of coeffs, together with: Decompose & Compose, rParameter & rPar.
Definition: ring.cc:647
int rGetMaxSyzComp(int i, const ring r)
return the max-comonent wchich has syzIndex i Assume: i<= syzIndex_limit
Definition: ring.cc:5158
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,...
Definition: ring.cc:5032
ring rAssure_HasComp(const ring r)
Definition: ring.cc:4625
ring rCopy0(const ring r, BOOLEAN copy_qideal, BOOLEAN copy_ordering)
Definition: ring.cc:1421
static void rO_WMDegree(int &place, int &bitplace, int start, int end, long *o, sro_ord &ord_struct, int *weights)
Definition: ring.cc:2267
static void rO_Syz(int &place, int &bitplace, int &prev_ord, int syz_comp, long *o, sro_ord &ord_struct)
Definition: ring.cc:2430
BOOLEAN rHas_c_Ordering(const ring r)
Definition: ring.cc:1883
static int rRealloc1(ring r, int size, int pos)
Definition: ring.cc:5242
#define pFDeg_CASE(A)
static unsigned long rGetExpSize(unsigned long bitmask, int &bits)
Definition: ring.cc:2570
void rDebugPrint(const ring r)
Definition: ring.cc:4122
static void rCheckOrdSgn(ring r, int i)
Definition: ring.cc:3852
BOOLEAN rRing_ord_pure_lp(const ring r)
Definition: ring.cc:5212
poly rGetVar(const int varIndex, const ring r)
Definition: ring.cc:5763
ring rModifyRing_Simple(ring r, BOOLEAN ommit_degree, BOOLEAN ommit_comp, unsigned long exp_limit, BOOLEAN &simple)
Definition: ring.cc:2993
void rChangeSComps(int *currComponents, long *currShiftedComponents, int length, ring r)
Definition: ring.cc:4405
static void m_DebugPrint(const poly p, const ring R)
debug-print monomial poly/vector p, assuming that it lives in the ring R
Definition: ring.cc:4350
static unsigned long rGetDivMask(int bits)
get r->divmask depending on bits per exponent
Definition: ring.cc:4108
char * rString(ring r)
Definition: ring.cc:673
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...
Definition: ring.cc:1799
int64 * rGetWeightVec(const ring r)
Definition: ring.cc:5222
ring rAssure_SyzComp_CompLastBlock(const ring r)
makes sure that c/C ordering is last ordering and SyzIndex is first
Definition: ring.cc:4749
static void rOptimizeLDeg(ring r)
Definition: ring.cc:3150
BOOLEAN rCheckIV(const intvec *iv)
Definition: ring.cc:175
rRingOrder_t rOrderName(char *ordername)
Definition: ring.cc:507
ring rOpposite(ring src)
Definition: ring.cc:5281
void rDelete(ring r)
unconditionally deletes fields in r
Definition: ring.cc:450
ring rDefault(const coeffs cf, int N, char **n, int ord_size, rRingOrder_t *ord, int *block0, int *block1, int **wvhdl, unsigned long bitmask)
Definition: ring.cc:102
static void rRightAdjustVarOffset(ring r)
right-adjust r->VarOffset
Definition: ring.cc:4082
VAR omBin char_ptr_bin
Definition: ring.cc:44
ring rPlusVar(const ring r, char *v, int left)
K[x],"y" -> K[x,y] resp. K[y,x].
Definition: ring.cc:5794
char * rParStr(ring r)
Definition: ring.cc:649
ring rAssure_CompLastBlock(ring r, BOOLEAN complete)
makes sure that c/C ordering is last ordering
Definition: ring.cc:4694
static void rO_ISPrefix(int &place, int &bitplace, int &prev_ord, long *o, int N, int *v, sro_ord &ord_struct)
Definition: ring.cc:2456
static void rO_Align(int &place, int &bitplace)
Definition: ring.cc:2188
ring rAssure_dp_S(const ring r)
Definition: ring.cc:4975
static void rO_TDegree_neg(int &place, int &bitplace, int start, int end, long *o, sro_ord &ord_struct)
Definition: ring.cc:2213
static void rSetFirstWv(ring r, int i, rRingOrder_t *order, int *block0, int *block1, int **wvhdl)
Definition: ring.cc:3118
ring rEnvelope(ring R)
Definition: ring.cc:5671
BOOLEAN rEqual(ring r1, ring r2, BOOLEAN qr)
returns TRUE, if r1 equals r2 FALSE, otherwise Equality is determined componentwise,...
Definition: ring.cc:1746
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,...
Definition: ring.cc:749
void rSetSyzComp(int k, const ring r)
Definition: ring.cc:5086
static const char *const ringorder_name[]
Definition: ring.cc:47
static int sign(int x)
Definition: ring.cc:3427
static void rO_WDegree(int &place, int &bitplace, int start, int end, long *o, sro_ord &ord_struct, int *weights)
Definition: ring.cc:2227
BOOLEAN rOrd_is_WeightedDegree_Ordering(const ring r)
Definition: ring.cc:2027
int n_IsParam(const number m, const ring r)
TODO: rewrite somehow...
Definition: ring.cc:5773
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)
Definition: ring.cc:2376
ring rAssure_dp_C(const ring r)
Definition: ring.cc:4980
ring rCopy(ring r)
Definition: ring.cc:1731
VAR int pDBsyzComp
Definition: ring.cc:5082
BOOLEAN rDBTest(ring r, const char *fn, const int l)
Definition: ring.cc:2038
struct p_Procs_s p_Procs_s
Definition: ring.h:23
static BOOLEAN rIsPluralRing(const ring r)
we must always have this test!
Definition: ring.h:400
ro_typ ord_typ
Definition: ring.h:220
static int rBlocks(const ring r)
Definition: ring.h:568
static ring rIncRefCnt(ring r)
Definition: ring.h:837
static char const ** rParameter(const ring r)
(r->cf->parameter)
Definition: ring.h:625
static int rPar(const ring r)
(r->cf->P)
Definition: ring.h:599
@ ro_wp64
Definition: ring.h:55
@ ro_syz
Definition: ring.h:60
@ ro_cp
Definition: ring.h:58
@ ro_dp
Definition: ring.h:52
@ ro_is
Definition: ring.h:61
@ ro_wp_neg
Definition: ring.h:56
@ ro_wp
Definition: ring.h:53
@ ro_isTemp
Definition: ring.h:61
@ ro_am
Definition: ring.h:54
@ ro_syzcomp
Definition: ring.h:59
static BOOLEAN rIsLPRing(const ring r)
Definition: ring.h:411
rRingOrder_t
order stuff
Definition: ring.h:68
@ ringorder_lp
Definition: ring.h:77
@ ringorder_a
Definition: ring.h:70
@ ringorder_am
Definition: ring.h:88
@ ringorder_a64
for int64 weights
Definition: ring.h:71
@ ringorder_rs
opposite of ls
Definition: ring.h:92
@ ringorder_C
Definition: ring.h:73
@ ringorder_S
S?
Definition: ring.h:75
@ ringorder_ds
Definition: ring.h:84
@ ringorder_Dp
Definition: ring.h:80
@ ringorder_unspec
Definition: ring.h:94
@ ringorder_L
Definition: ring.h:89
@ ringorder_Ds
Definition: ring.h:85
@ ringorder_dp
Definition: ring.h:78
@ ringorder_c
Definition: ring.h:72
@ ringorder_rp
Definition: ring.h:79
@ ringorder_aa
for idElimination, like a, except pFDeg, pWeigths ignore it
Definition: ring.h:91
@ ringorder_no
Definition: ring.h:69
@ ringorder_Wp
Definition: ring.h:82
@ ringorder_ws
Definition: ring.h:86
@ ringorder_Ws
Definition: ring.h:87
@ ringorder_IS
Induced (Schreyer) ordering.
Definition: ring.h:93
@ ringorder_ls
Definition: ring.h:83
@ ringorder_s
s?
Definition: ring.h:76
@ ringorder_wp
Definition: ring.h:81
@ ringorder_M
Definition: ring.h:74
static BOOLEAN rField_is_Q(const ring r)
Definition: ring.h:506
static BOOLEAN rShortOut(const ring r)
Definition: ring.h:581
rOrderType_t
Definition: ring.h:98
@ rOrderType_CompExp
simple ordering, component has priority
Definition: ring.h:100
@ rOrderType_Exp
simple ordering, exponent vector has priority component is compatible with exp-vector order
Definition: ring.h:103
@ rOrderType_General
non-simple ordering as specified by currRing
Definition: ring.h:99
@ rOrderType_ExpComp
simple ordering, exponent vector has priority component not compatible with exp-vector order
Definition: ring.h:101
static BOOLEAN rIsNCRing(const ring r)
Definition: ring.h:421
int order_index
Definition: ring.h:221
static BOOLEAN rCanShortOut(const ring r)
Definition: ring.h:586
static short rVar(const ring r)
#define rVar(r) (r->N)
Definition: ring.h:592
union sro_ord::@1 data
#define rTest(r)
Definition: ring.h:782
#define rField_is_Ring(R)
Definition: ring.h:485
Definition: ring.h:219
ideal SCAQuotient(const ring r)
Definition: sca.h:10
static short scaLastAltVar(ring r)
Definition: sca.h:25
static short scaFirstAltVar(ring r)
Definition: sca.h:18
ideal idInit(int idsize, int rank)
initialise an ideal / module
Definition: simpleideals.cc:35
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)
Definition: simpleideals.cc:57
ideal id_SimpleAdd(ideal h1, ideal h2, const ring R)
concat the lists h1 and h2 without zeros
#define IDELEMS(i)
Definition: simpleideals.h:23
#define id_Test(A, lR)
Definition: simpleideals.h:87
#define R
Definition: sirandom.c:27
#define A
Definition: sirandom.c:24
Definition: ring.h:248
n_Procs_s * cf
Definition: ring.h:368
int * block0
Definition: ring.h:254
short N
Definition: ring.h:303
int * block1
Definition: ring.h:255
rRingOrder_t * order
Definition: ring.h:253
int ** wvhdl
Definition: ring.h:257
unsigned long bitmask
Definition: ring.h:350
char ** names
Definition: ring.h:258
short OrdSgn
Definition: ring.h:305
Definition: nc.h:68
char * char_ptr
Definition: structs.h:53
#define loop
Definition: structs.h:75
EXTERN_VAR long * currShiftedComponents
Definition: syz.h:118
int ntIsParam(number m, const coeffs cf)
if m == var(i)/1 => return i,
Definition: transext.cc:2308