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