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