My Project
Loading...
Searching...
No Matches
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
2026// return TRUE if p->exp[r->pOrdIndex] holds a weighted degree of p */
2028{
2029 // Hmm.... what about Syz orderings?
2030 return ((rVar(r) > 1) &&
2031 rHasSimpleOrder(r) &&
2034}
2035
2036#ifdef RDEBUG
2037// This should eventually become a full-fledge ring check, like pTest
2038BOOLEAN rDBTest(ring r, const char* fn, const int l)
2039{
2040 int i,j;
2041
2042 if (r == NULL)
2043 {
2044 dReportError("Null ring in %s:%d", fn, l);
2045 return FALSE;
2046 }
2047
2048
2049 if (r->N == 0) return TRUE;
2050
2051 if ((r->OrdSgn!=1) && (r->OrdSgn!= -1))
2052 {
2053 dReportError("missing OrdSgn in %s:%d", fn, l);
2054 return FALSE;
2055 }
2056
2057// omCheckAddrSize(r,sizeof(ip_sring));
2058#if OM_CHECK > 0
2059 i=rBlocks(r);
2060 omCheckAddrSize(r->order,i*sizeof(int));
2061 omCheckAddrSize(r->block0,i*sizeof(int));
2062 omCheckAddrSize(r->block1,i*sizeof(int));
2063 for(int j=0;j<=i;j++)
2064 {
2065 if((r->order[j]<0)||(r->order[j]>ringorder_unspec))
2066 dError("wrong order in r->order");
2067 }
2068 if (r->wvhdl!=NULL)
2069 {
2070 omCheckAddrSize(r->wvhdl,i*sizeof(int *));
2071 for (j=0;j<i; j++)
2072 {
2073 if (r->wvhdl[j] != NULL) omCheckAddr(r->wvhdl[j]);
2074 }
2075 }
2076#endif
2077 if (r->VarOffset == NULL)
2078 {
2079 dReportError("Null ring VarOffset -- no rComplete (?) in n %s:%d", fn, l);
2080 return FALSE;
2081 }
2082 omCheckAddrSize(r->VarOffset,(r->N+1)*sizeof(int));
2083
2084 if ((r->OrdSize==0)!=(r->typ==NULL))
2085 {
2086 dReportError("mismatch OrdSize and typ-pointer in %s:%d");
2087 return FALSE;
2088 }
2089 omcheckAddrSize(r->typ,r->OrdSize*sizeof(*(r->typ)));
2090 omCheckAddrSize(r->VarOffset,(r->N+1)*sizeof(*(r->VarOffset)));
2091 // test assumptions:
2092 for(i=0;i<=r->N;i++) // for all variables (i = 0..N)
2093 {
2094 if(r->typ!=NULL)
2095 {
2096 for(j=0;j<r->OrdSize;j++) // for all ordering blocks (j =0..OrdSize-1)
2097 {
2098 if(r->typ[j].ord_typ == ro_isTemp)
2099 {
2100 const int p = r->typ[j].data.isTemp.suffixpos;
2101
2102 if(p <= j)
2103 dReportError("ordrec prefix %d is unmatched",j);
2104
2105 assume( p < r->OrdSize );
2106
2107 if(r->typ[p].ord_typ != ro_is)
2108 dReportError("ordrec prefix %d is unmatched (suffix: %d is wrong!!!)",j, p);
2109
2110 // Skip all intermediate blocks for undone variables:
2111 if(r->typ[j].data.isTemp.pVarOffset[i] != -1) // Check i^th variable
2112 {
2113 j = p - 1; // SKIP ALL INTERNAL BLOCKS...???
2114 continue; // To make for check OrdSize bound...
2115 }
2116 }
2117 else if (r->typ[j].ord_typ == ro_is)
2118 {
2119 // Skip all intermediate blocks for undone variables:
2120 if(r->typ[j].data.is.pVarOffset[i] != -1)
2121 {
2122 // TODO???
2123 }
2124
2125 }
2126 else
2127 {
2128 if (r->typ[j].ord_typ==ro_cp)
2129 {
2130 if(((short)r->VarOffset[i]) == r->typ[j].data.cp.place)
2131 dReportError("ordrec %d conflicts with var %d",j,i);
2132 }
2133 else
2134 if ((r->typ[j].ord_typ!=ro_syzcomp)
2135 && (r->VarOffset[i] == r->typ[j].data.dp.place))
2136 dReportError("ordrec %d conflicts with var %d",j,i);
2137 }
2138 }
2139 }
2140 int tmp;
2141 tmp=r->VarOffset[i] & 0xffffff;
2142 #if SIZEOF_LONG == 8
2143 if ((r->VarOffset[i] >> 24) >63)
2144 #else
2145 if ((r->VarOffset[i] >> 24) >31)
2146 #endif
2147 dReportError("bit_start out of range:%d",r->VarOffset[i] >> 24);
2148 if (i > 0 && ((tmp<0) ||(tmp>r->ExpL_Size-1)))
2149 {
2150 dReportError("varoffset out of range for var %d: %d",i,tmp);
2151 }
2152 }
2153 if(r->typ!=NULL)
2154 {
2155 for(j=0;j<r->OrdSize;j++)
2156 {
2157 if ((r->typ[j].ord_typ==ro_dp)
2158 || (r->typ[j].ord_typ==ro_wp)
2159 || (r->typ[j].ord_typ==ro_wp_neg))
2160 {
2161 if (r->typ[j].data.dp.start > r->typ[j].data.dp.end)
2162 dReportError("in ordrec %d: start(%d) > end(%d)",j,
2163 r->typ[j].data.dp.start, r->typ[j].data.dp.end);
2164 if ((r->typ[j].data.dp.start < 1)
2165 || (r->typ[j].data.dp.end > r->N))
2166 dReportError("in ordrec %d: start(%d)<1 or end(%d)>vars(%d)",j,
2167 r->typ[j].data.dp.start, r->typ[j].data.dp.end,r->N);
2168 }
2169 }
2170 }
2171
2172 assume(r != NULL);
2173 assume(r->cf != NULL);
2174
2175 if (nCoeff_is_algExt(r->cf))
2176 {
2177 assume(r->cf->extRing != NULL);
2178 assume(r->cf->extRing->qideal != NULL);
2179 omCheckAddr(r->cf->extRing->qideal->m[0]);
2180 }
2181
2182 //assume(r->cf!=NULL);
2183
2184 return TRUE;
2185}
2186#endif
2187
2188static void rO_Align(int &place, int &bitplace)
2189{
2190 // increment place to the next aligned one
2191 // (count as Exponent_t,align as longs)
2192 if (bitplace!=BITS_PER_LONG)
2193 {
2194 place++;
2195 bitplace=BITS_PER_LONG;
2196 }
2197}
2198
2199static void rO_TDegree(int &place, int &bitplace, int start, int end,
2200 long *o, sro_ord &ord_struct)
2201{
2202 // degree (aligned) of variables v_start..v_end, ordsgn 1
2203 rO_Align(place,bitplace);
2204 ord_struct.ord_typ=ro_dp;
2205 ord_struct.data.dp.start=start;
2206 ord_struct.data.dp.end=end;
2207 ord_struct.data.dp.place=place;
2208 o[place]=1;
2209 place++;
2210 rO_Align(place,bitplace);
2211}
2212
2213static void rO_TDegree_neg(int &place, int &bitplace, int start, int end,
2214 long *o, sro_ord &ord_struct)
2215{
2216 // degree (aligned) of variables v_start..v_end, ordsgn -1
2217 rO_Align(place,bitplace);
2218 ord_struct.ord_typ=ro_dp;
2219 ord_struct.data.dp.start=start;
2220 ord_struct.data.dp.end=end;
2221 ord_struct.data.dp.place=place;
2222 o[place]=-1;
2223 place++;
2224 rO_Align(place,bitplace);
2225}
2226
2227static void rO_WDegree(int &place, int &bitplace, int start, int end,
2228 long *o, sro_ord &ord_struct, int *weights)
2229{
2230 // weighted degree (aligned) of variables v_start..v_end, ordsgn 1
2231 while((start<end) && (weights[0]==0)) { start++; weights++; }
2232 while((start<end) && (weights[end-start]==0)) { end--; }
2233 int i;
2234 int pure_tdeg=1;
2235 for(i=start;i<=end;i++)
2236 {
2237 if(weights[i-start]!=1)
2238 {
2239 pure_tdeg=0;
2240 break;
2241 }
2242 }
2243 if (pure_tdeg)
2244 {
2245 rO_TDegree(place,bitplace,start,end,o,ord_struct);
2246 return;
2247 }
2248 rO_Align(place,bitplace);
2249 ord_struct.ord_typ=ro_wp;
2250 ord_struct.data.wp.start=start;
2251 ord_struct.data.wp.end=end;
2252 ord_struct.data.wp.place=place;
2253 ord_struct.data.wp.weights=weights;
2254 o[place]=1;
2255 place++;
2256 rO_Align(place,bitplace);
2257 for(i=start;i<=end;i++)
2258 {
2259 if(weights[i-start]<0)
2260 {
2261 ord_struct.ord_typ=ro_wp_neg;
2262 break;
2263 }
2264 }
2265}
2266
2267static void rO_WMDegree(int &place, int &bitplace, int start, int end,
2268 long *o, sro_ord &ord_struct, int *weights)
2269{
2270 assume(weights != NULL);
2271
2272 // weighted degree (aligned) of variables v_start..v_end, ordsgn 1
2273// while((start<end) && (weights[0]==0)) { start++; weights++; }
2274// while((start<end) && (weights[end-start]==0)) { end--; }
2275 rO_Align(place,bitplace);
2276 ord_struct.ord_typ=ro_am;
2277 ord_struct.data.am.start=start;
2278 ord_struct.data.am.end=end;
2279 ord_struct.data.am.place=place;
2280 ord_struct.data.am.weights=weights;
2281 ord_struct.data.am.weights_m = weights + (end-start+1);
2282 ord_struct.data.am.len_gen=weights[end-start+1];
2283 assume( ord_struct.data.am.weights_m[0] == ord_struct.data.am.len_gen );
2284 o[place]=1;
2285 place++;
2286 rO_Align(place,bitplace);
2287}
2288
2289static void rO_WDegree64(int &place, int &bitplace, int start, int end,
2290 long *o, sro_ord &ord_struct, int64 *weights)
2291{
2292 // weighted degree (aligned) of variables v_start..v_end, ordsgn 1,
2293 // reserved 2 places
2294 rO_Align(place,bitplace);
2295 ord_struct.ord_typ=ro_wp64;
2296 ord_struct.data.wp64.start=start;
2297 ord_struct.data.wp64.end=end;
2298 ord_struct.data.wp64.place=place;
2299 #ifdef HAVE_OMALLOC
2300 ord_struct.data.wp64.weights64=weights;
2301 #else
2302 int l=end-start+1;
2303 ord_struct.data.wp64.weights64=(int64*)omAlloc(l*sizeof(int64));
2304 for(int i=0;i<l;i++) ord_struct.data.wp64.weights64[i]=weights[i];
2305 #endif
2306 o[place]=1;
2307 place++;
2308 o[place]=1;
2309 place++;
2310 rO_Align(place,bitplace);
2311}
2312
2313static void rO_WDegree_neg(int &place, int &bitplace, int start, int end,
2314 long *o, sro_ord &ord_struct, int *weights)
2315{
2316 // weighted degree (aligned) of variables v_start..v_end, ordsgn -1
2317 while((start<end) && (weights[0]==0)) { start++; weights++; }
2318 while((start<end) && (weights[end-start]==0)) { end--; }
2319 rO_Align(place,bitplace);
2320 ord_struct.ord_typ=ro_wp;
2321 ord_struct.data.wp.start=start;
2322 ord_struct.data.wp.end=end;
2323 ord_struct.data.wp.place=place;
2324 ord_struct.data.wp.weights=weights;
2325 o[place]=-1;
2326 place++;
2327 rO_Align(place,bitplace);
2328 int i;
2329 for(i=start;i<=end;i++)
2330 {
2331 if(weights[i-start]<0)
2332 {
2333 ord_struct.ord_typ=ro_wp_neg;
2334 break;
2335 }
2336 }
2337}
2338
2339static void rO_LexVars(int &place, int &bitplace, int start, int end,
2340 int &prev_ord, long *o,int *v, int bits, int opt_var)
2341{
2342 // a block of variables v_start..v_end with lex order, ordsgn 1
2343 int k;
2344 int incr=1;
2345 if(prev_ord==-1) rO_Align(place,bitplace);
2346
2347 if (start>end)
2348 {
2349 incr=-1;
2350 }
2351 for(k=start;;k+=incr)
2352 {
2353 bitplace-=bits;
2354 if (bitplace < 0) { bitplace=BITS_PER_LONG-bits; place++; }
2355 o[place]=1;
2356 v[k]= place | (bitplace << 24);
2357 if (k==end) break;
2358 }
2359 prev_ord=1;
2360 if (opt_var!= -1)
2361 {
2362 assume((opt_var == end+1) ||(opt_var == end-1));
2363 if((opt_var != end+1) &&(opt_var != end-1)) WarnS("hier-2");
2364 int save_bitplace=bitplace;
2365 bitplace-=bits;
2366 if (bitplace < 0)
2367 {
2368 bitplace=save_bitplace;
2369 return;
2370 }
2371 // there is enough space for the optional var
2372 v[opt_var]=place | (bitplace << 24);
2373 }
2374}
2375
2376static void rO_LexVars_neg(int &place, int &bitplace, int start, int end,
2377 int &prev_ord, long *o,int *v, int bits, int opt_var)
2378{
2379 // a block of variables v_start..v_end with lex order, ordsgn -1
2380 int k;
2381 int incr=1;
2382 if(prev_ord==1) rO_Align(place,bitplace);
2383
2384 if (start>end)
2385 {
2386 incr=-1;
2387 }
2388 for(k=start;;k+=incr)
2389 {
2390 bitplace-=bits;
2391 if (bitplace < 0) { bitplace=BITS_PER_LONG-bits; place++; }
2392 o[place]=-1;
2393 v[k]=place | (bitplace << 24);
2394 if (k==end) break;
2395 }
2396 prev_ord=-1;
2397// #if 0
2398 if (opt_var!= -1)
2399 {
2400 assume((opt_var == end+1) ||(opt_var == end-1));
2401 if((opt_var != end+1) &&(opt_var != end-1)) WarnS("hier-1");
2402 int save_bitplace=bitplace;
2403 bitplace-=bits;
2404 if (bitplace < 0)
2405 {
2406 bitplace=save_bitplace;
2407 return;
2408 }
2409 // there is enough space for the optional var
2410 v[opt_var]=place | (bitplace << 24);
2411 }
2412// #endif
2413}
2414
2415static void rO_Syzcomp(int &place, int &bitplace, int &prev_ord,
2416 long *o, sro_ord &ord_struct)
2417{
2418 // ordering is derived from component number
2419 rO_Align(place,bitplace);
2420 ord_struct.ord_typ=ro_syzcomp;
2421 ord_struct.data.syzcomp.place=place;
2422 ord_struct.data.syzcomp.Components=NULL;
2423 ord_struct.data.syzcomp.ShiftedComponents=NULL;
2424 o[place]=1;
2425 prev_ord=1;
2426 place++;
2427 rO_Align(place,bitplace);
2428}
2429
2430static void rO_Syz(int &place, int &bitplace, int &prev_ord,
2431 int syz_comp, long *o, sro_ord &ord_struct)
2432{
2433 // ordering is derived from component number
2434 // let's reserve one Exponent_t for it
2435 if ((prev_ord== 1) || (bitplace!=BITS_PER_LONG))
2436 rO_Align(place,bitplace);
2437 ord_struct.ord_typ=ro_syz;
2438 ord_struct.data.syz.place=place;
2439 ord_struct.data.syz.limit=syz_comp;
2440 if (syz_comp>0)
2441 ord_struct.data.syz.syz_index = (int*) omAlloc0((syz_comp+1)*sizeof(int));
2442 else
2443 ord_struct.data.syz.syz_index = NULL;
2444 ord_struct.data.syz.curr_index = 1;
2445 o[place]= -1;
2446 prev_ord=-1;
2447 place++;
2448}
2449
2450#ifndef SING_NDEBUG
2451# define MYTEST 0
2452#else /* ifndef SING_NDEBUG */
2453# define MYTEST 0
2454#endif /* ifndef SING_NDEBUG */
2455
2456static void rO_ISPrefix(int &place, int &bitplace, int &prev_ord,
2457 long *o, int N, int *v, sro_ord &ord_struct)
2458{
2459 if ((prev_ord== 1) || (bitplace!=BITS_PER_LONG))
2460 rO_Align(place,bitplace);
2461 // since we add something afterwards - it's better to start with anew!?
2462
2463 ord_struct.ord_typ = ro_isTemp;
2464 ord_struct.data.isTemp.start = place;
2465 #ifdef HAVE_OMALLOC
2466 ord_struct.data.isTemp.pVarOffset = (int *)omMemDup(v);
2467 #else
2468 ord_struct.data.isTemp.pVarOffset = (int *)omAlloc((N+1)*sizeof(int));
2469 memcpy(ord_struct.data.isTemp.pVarOffset,v,(N+1)*sizeof(int));
2470 #endif
2471 ord_struct.data.isTemp.suffixpos = -1;
2472
2473 // We will act as rO_Syz on our own!!!
2474 // Here we allocate an exponent as a level placeholder
2475 o[place]= -1;
2476 prev_ord=-1;
2477 place++;
2478}
2479static void rO_ISSuffix(int &place, int &bitplace, int &prev_ord, long *o,
2480 int N, int *v, sro_ord *tmp_typ, int &typ_i, int sgn)
2481{
2482
2483 // Let's find previous prefix:
2484 int typ_j = typ_i - 1;
2485 while(typ_j >= 0)
2486 {
2487 if( tmp_typ[typ_j].ord_typ == ro_isTemp)
2488 break;
2489 typ_j --;
2490 }
2491
2492 assume( typ_j >= 0 );
2493
2494 if( typ_j < 0 ) // Found NO prefix!!! :(
2495 return;
2496
2497 assume( tmp_typ[typ_j].ord_typ == ro_isTemp );
2498
2499 // Get saved state:
2500 const int start = tmp_typ[typ_j].data.isTemp.start;
2501 int *pVarOffset = tmp_typ[typ_j].data.isTemp.pVarOffset;
2502
2503/*
2504 // shift up all blocks
2505 while(typ_j < (typ_i-1))
2506 {
2507 tmp_typ[typ_j] = tmp_typ[typ_j+1];
2508 typ_j++;
2509 }
2510 typ_j = typ_i - 1; // No increment for typ_i
2511*/
2512 tmp_typ[typ_j].data.isTemp.suffixpos = typ_i;
2513
2514 // Let's keep that dummy for now...
2515 typ_j = typ_i; // the typ to change!
2516 typ_i++; // Just for now...
2517
2518
2519 for( int i = 0; i <= N; i++ ) // Note [0] == component !!! No Skip?
2520 {
2521 // Was i-th variable allocated inbetween?
2522 if( v[i] != pVarOffset[i] )
2523 {
2524 pVarOffset[i] = v[i]; // Save for later...
2525 v[i] = -1; // Undo!
2526 assume( pVarOffset[i] != -1 );
2527 }
2528 else
2529 pVarOffset[i] = -1; // No change here...
2530 }
2531
2532 if( pVarOffset[0] != -1 )
2533 pVarOffset[0] &= 0x0fff;
2534
2535 sro_ord &ord_struct = tmp_typ[typ_j];
2536
2537
2538 ord_struct.ord_typ = ro_is;
2539 ord_struct.data.is.start = start;
2540 ord_struct.data.is.end = place;
2541 ord_struct.data.is.pVarOffset = pVarOffset;
2542
2543
2544 // What about component???
2545// if( v[0] != -1 ) // There is a component already...???
2546// if( o[ v[0] & 0x0fff ] == sgn )
2547// {
2548// pVarOffset[0] = -1; // NEVER USED Afterwards...
2549// return;
2550// }
2551
2552
2553 // Moreover: we need to allocate the module component (v[0]) here!
2554 if( v[0] == -1) // It's possible that there was module component v0 at the begining (before prefix)!
2555 {
2556 // Start with a whole long exponent
2557 if( bitplace != BITS_PER_LONG )
2558 rO_Align(place, bitplace);
2559
2560 assume( bitplace == BITS_PER_LONG );
2561 bitplace -= BITS_PER_LONG;
2562 assume(bitplace == 0);
2563 v[0] = place | (bitplace << 24); // Never mind whether pVarOffset[0] > 0!!!
2564 o[place] = sgn; // Singnum for component ordering
2565 prev_ord = sgn;
2566 }
2567}
2568
2569
2570static unsigned long rGetExpSize(unsigned long bitmask, int & bits)
2571{
2572 if (bitmask == 0)
2573 {
2574 bits=16; bitmask=0xffff;
2575 }
2576 else if (bitmask <= 1L)
2577 {
2578 bits=1; bitmask = 1L;
2579 }
2580 else if (bitmask <= 3L)
2581 {
2582 bits=2; bitmask = 3L;
2583 }
2584 else if (bitmask <= 7L)
2585 {
2586 bits=3; bitmask=7L;
2587 }
2588 else if (bitmask <= 0xfL)
2589 {
2590 bits=4; bitmask=0xfL;
2591 }
2592 else if (bitmask <= 0x1fL)
2593 {
2594 bits=5; bitmask=0x1fL;
2595 }
2596 else if (bitmask <= 0x3fL)
2597 {
2598 bits=6; bitmask=0x3fL;
2599 }
2600#if SIZEOF_LONG == 8
2601 else if (bitmask <= 0x7fL)
2602 {
2603 bits=7; bitmask=0x7fL; /* 64 bit longs only */
2604 }
2605#endif
2606 else if (bitmask <= 0xffL)
2607 {
2608 bits=8; bitmask=0xffL;
2609 }
2610#if SIZEOF_LONG == 8
2611 else if (bitmask <= 0x1ffL)
2612 {
2613 bits=9; bitmask=0x1ffL; /* 64 bit longs only */
2614 }
2615#endif
2616 else if (bitmask <= 0x3ffL)
2617 {
2618 bits=10; bitmask=0x3ffL;
2619 }
2620#if SIZEOF_LONG == 8
2621 else if (bitmask <= 0xfffL)
2622 {
2623 bits=12; bitmask=0xfff; /* 64 bit longs only */
2624 }
2625#endif
2626 else if (bitmask <= 0xffffL)
2627 {
2628 bits=16; bitmask=0xffffL;
2629 }
2630#if SIZEOF_LONG == 8
2631 else if (bitmask <= 0xfffffL)
2632 {
2633 bits=20; bitmask=0xfffffL; /* 64 bit longs only */
2634 }
2635 else if (bitmask <= 0xffffffffL)
2636 {
2637 bits=32; bitmask=0xffffffffL;
2638 }
2639 else if (bitmask <= 0x7fffffffffffffffL)
2640 {
2641 bits=63; bitmask=0x7fffffffffffffffL; /* for overflow tests*/
2642 }
2643 else
2644 {
2645 bits=63; bitmask=0x7fffffffffffffffL; /* for overflow tests*/
2646 }
2647#else
2648 else if (bitmask <= 0x7fffffff)
2649 {
2650 bits=31; bitmask=0x7fffffff; /* for overflow tests*/
2651 }
2652 else
2653 {
2654 bits=31; bitmask=0x7fffffffL; /* for overflow tests*/
2655 }
2656#endif
2657 return bitmask;
2658}
2659
2660/*2
2661* optimize rGetExpSize for a block of N variables, exp <=bitmask
2662*/
2663unsigned long rGetExpSize(unsigned long bitmask, int & bits, int N)
2664{
2665 bitmask =rGetExpSize(bitmask, bits);
2666 int vars_per_long=BIT_SIZEOF_LONG/bits;
2667 int bits1;
2668 loop
2669 {
2670 if (bits == BIT_SIZEOF_LONG-1)
2671 {
2672 bits = BIT_SIZEOF_LONG - 1;
2673 return LONG_MAX;
2674 }
2675 unsigned long bitmask1 =rGetExpSize(bitmask+1, bits1);
2676 int vars_per_long1=BIT_SIZEOF_LONG/bits1;
2677 if ((((N+vars_per_long-1)/vars_per_long) ==
2678 ((N+vars_per_long1-1)/vars_per_long1)))
2679 {
2680 vars_per_long=vars_per_long1;
2681 bits=bits1;
2682 bitmask=bitmask1;
2683 }
2684 else
2685 {
2686 return bitmask; /* and bits */
2687 }
2688 }
2689}
2690
2691
2692/*2
2693 * create a copy of the ring r, which must be equivalent to currRing
2694 * used for std computations
2695 * may share data structures with currRing
2696 * DOES CALL rComplete
2697 */
2698ring rModifyRing(ring r, BOOLEAN omit_degree,
2699 BOOLEAN try_omit_comp,
2700 unsigned long exp_limit)
2701{
2702 assume (r != NULL );
2703 assume (exp_limit > 1);
2704 BOOLEAN omitted_degree = FALSE;
2705
2706 int bits;
2707 exp_limit=rGetExpSize(exp_limit, bits, r->N);
2708 BOOLEAN need_other_ring = (exp_limit != r->bitmask);
2709
2710 int iNeedInducedOrderingSetup = 0; ///< How many induced ordering block do we have?
2711
2712 int nblocks=rBlocks(r);
2713 rRingOrder_t *order=(rRingOrder_t*)omAlloc0((nblocks+1)*sizeof(rRingOrder_t));
2714 int *block0=(int*)omAlloc0((nblocks+1)*sizeof(int));
2715 int *block1=(int*)omAlloc0((nblocks+1)*sizeof(int));
2716 int **wvhdl=(int**)omAlloc0((nblocks+1)*sizeof(int *));
2717
2718 int i=0;
2719 int j=0; /* i index in r, j index in res */
2720
2721 for( rRingOrder_t r_ord=r->order[i]; (r_ord != (rRingOrder_t)0) && (i < nblocks); j++, r_ord=r->order[++i])
2722 {
2723 BOOLEAN copy_block_index=TRUE;
2724
2725 if (r->block0[i]==r->block1[i])
2726 {
2727 switch(r_ord)
2728 {
2729 case ringorder_wp:
2730 case ringorder_dp:
2731 case ringorder_Wp:
2732 case ringorder_Dp:
2733 r_ord=ringorder_lp;
2734 break;
2735 case ringorder_Ws:
2736 case ringorder_Ds:
2737 case ringorder_ws:
2738 case ringorder_ds:
2739 r_ord=ringorder_ls;
2740 break;
2741 default:
2742 break;
2743 }
2744 }
2745 switch(r_ord)
2746 {
2747 case ringorder_S:
2748 {
2749#ifndef SING_NDEBUG
2750 Warn("Error: unhandled ordering in rModifyRing: ringorder_S = [%d]", r_ord);
2751#endif
2752 order[j]=r_ord; /*r->order[i];*/
2753 break;
2754 }
2755 case ringorder_C:
2756 case ringorder_c:
2757 if (!try_omit_comp)
2758 {
2759 order[j]=r_ord; /*r->order[i]*/;
2760 }
2761 else
2762 {
2763 j--;
2764 need_other_ring=TRUE;
2765 try_omit_comp=FALSE;
2766 copy_block_index=FALSE;
2767 }
2768 break;
2769 case ringorder_wp:
2770 case ringorder_dp:
2771 case ringorder_ws:
2772 case ringorder_ds:
2773 if(!omit_degree)
2774 {
2775 order[j]=r_ord; /*r->order[i]*/;
2776 }
2777 else
2778 {
2779 order[j]=ringorder_rs;
2780 need_other_ring=TRUE;
2781 omit_degree=FALSE;
2782 omitted_degree = TRUE;
2783 }
2784 break;
2785 case ringorder_Wp:
2786 case ringorder_Dp:
2787 case ringorder_Ws:
2788 case ringorder_Ds:
2789 if(!omit_degree)
2790 {
2791 order[j]=r_ord; /*r->order[i];*/
2792 }
2793 else
2794 {
2795 order[j]=ringorder_lp;
2796 need_other_ring=TRUE;
2797 omit_degree=FALSE;
2798 omitted_degree = TRUE;
2799 }
2800 break;
2801 case ringorder_IS:
2802 {
2803 if (try_omit_comp)
2804 {
2805 // tried, but cannot omit component due to the ordering block [%d]: %d (ringorder_IS)", i, r_ord
2806 try_omit_comp = FALSE;
2807 }
2808 order[j]=r_ord; /*r->order[i];*/
2809 iNeedInducedOrderingSetup++;
2810 break;
2811 }
2812 case ringorder_s:
2813 {
2814 assume((i == 0) && (j == 0));
2815 if (try_omit_comp)
2816 {
2817 // tried, but cannot omit component due to the ordering block [%d]: %d (ringorder_s)", i, r_ord
2818 try_omit_comp = FALSE;
2819 }
2820 order[j]=r_ord; /*r->order[i];*/
2821 break;
2822 }
2823 default:
2824 order[j]=r_ord; /*r->order[i];*/
2825 break;
2826 }
2827 if (copy_block_index)
2828 {
2829 block0[j]=r->block0[i];
2830 block1[j]=r->block1[i];
2831 wvhdl[j]=r->wvhdl[i];
2832 }
2833
2834 // order[j]=ringorder_no; // done by omAlloc0
2835 }
2836 if(!need_other_ring)
2837 {
2838 omFreeSize(order,(nblocks+1)*sizeof(rRingOrder_t));
2839 omFreeSize(block0,(nblocks+1)*sizeof(int));
2840 omFreeSize(block1,(nblocks+1)*sizeof(int));
2841 omFreeSize(wvhdl,(nblocks+1)*sizeof(int *));
2842 return r;
2843 }
2844 ring res=(ring)omAlloc0Bin(sip_sring_bin);
2845 *res = *r;
2846
2847#ifdef HAVE_PLURAL
2848 res->GetNC() = NULL;
2849#endif
2850
2851 // res->qideal, res->idroot ???
2852 res->wvhdl=wvhdl;
2853 res->order=order;
2854 res->block0=block0;
2855 res->block1=block1;
2856 res->bitmask=exp_limit;
2857 res->wanted_maxExp=r->wanted_maxExp;
2858 //int tmpref=r->cf->ref0;
2859 rComplete(res, 1);
2860 //r->cf->ref=tmpref;
2861
2862 // adjust res->pFDeg: if it was changed globally, then
2863 // it must also be changed for new ring
2864 if (r->pFDegOrig != res->pFDegOrig &&
2866 {
2867 // still might need adjustment for weighted orderings
2868 // and omit_degree
2869 res->firstwv = r->firstwv;
2870 res->firstBlockEnds = r->firstBlockEnds;
2871 res->pFDeg = res->pFDegOrig = p_WFirstTotalDegree;
2872 }
2873 if (omitted_degree)
2874 res->pLDeg = r->pLDegOrig;
2875
2876 rOptimizeLDeg(res); // also sets res->pLDegOrig
2877
2878 // set syzcomp
2879 if (res->typ != NULL)
2880 {
2881 if( res->typ[0].ord_typ == ro_syz) // "s" Always on [0] place!
2882 {
2883 res->typ[0] = r->typ[0]; // Copy struct!? + setup the same limit!
2884
2885 if (r->typ[0].data.syz.limit > 0)
2886 {
2887 res->typ[0].data.syz.syz_index
2888 = (int*) omAlloc((r->typ[0].data.syz.limit +1)*sizeof(int));
2889 memcpy(res->typ[0].data.syz.syz_index, r->typ[0].data.syz.syz_index,
2890 (r->typ[0].data.syz.limit +1)*sizeof(int));
2891 }
2892 }
2893
2894 if( iNeedInducedOrderingSetup > 0 )
2895 {
2896 for(j = 0, i = 0; (i < nblocks) && (iNeedInducedOrderingSetup > 0); i++)
2897 if( res->typ[i].ord_typ == ro_is ) // Search for suffixes!
2898 {
2899 ideal F = idrHeadR(r->typ[i].data.is.F, r, res); // Copy F from r into res!
2900 assume(
2902 F, // WILL BE COPIED!
2903 r->typ[i].data.is.limit,
2904 j++
2905 )
2906 );
2907 id_Delete(&F, res);
2908 iNeedInducedOrderingSetup--;
2909 }
2910 } // Process all induced Ordering blocks! ...
2911 }
2912 // the special case: homog (omit_degree) and 1 block rs: that is global:
2913 // it comes from dp
2914 res->OrdSgn=r->OrdSgn;
2915
2916
2917#ifdef HAVE_PLURAL
2918 if (rIsPluralRing(r))
2919 {
2920 if ( nc_rComplete(r, res, false) ) // no qideal!
2921 {
2922#ifndef SING_NDEBUG
2923 WarnS("error in nc_rComplete");
2924#endif
2925 // cleanup?
2926
2927// rDelete(res);
2928// return r;
2929
2930 // just go on..
2931 }
2932
2933 if( rIsSCA(r) )
2934 {
2936 WarnS("error in sca_Force!");
2937 }
2938 }
2939#endif
2940
2941 return res;
2942}
2943
2944// construct Wp,C ring
2945ring rModifyRing_Wp(ring r, int* weights)
2946{
2947 ring res=(ring)omAlloc0Bin(sip_sring_bin);
2948 *res = *r;
2949#ifdef HAVE_PLURAL
2950 res->GetNC() = NULL;
2951#endif
2952
2953 /*weights: entries for 3 blocks: NULL*/
2954 res->wvhdl = (int **)omAlloc0(3 * sizeof(int *));
2955 /*order: Wp,C,0*/
2956 res->order = (rRingOrder_t *) omAlloc(3 * sizeof(rRingOrder_t *));
2957 res->block0 = (int *)omAlloc0(3 * sizeof(int *));
2958 res->block1 = (int *)omAlloc0(3 * sizeof(int *));
2959 /* ringorder Wp for the first block: var 1..r->N */
2960 res->order[0] = ringorder_Wp;
2961 res->block0[0] = 1;
2962 res->block1[0] = r->N;
2963 res->wvhdl[0] = weights;
2964 /* ringorder C for the second block: no vars */
2965 res->order[1] = ringorder_C;
2966 /* the last block: everything is 0 */
2967 res->order[2] = (rRingOrder_t)0;
2968
2969 //int tmpref=r->cf->ref;
2970 rComplete(res, 1);
2971 //r->cf->ref=tmpref;
2972#ifdef HAVE_PLURAL
2973 if (rIsPluralRing(r))
2974 {
2975 if ( nc_rComplete(r, res, false) ) // no qideal!
2976 {
2977#ifndef SING_NDEBUG
2978 WarnS("error in nc_rComplete");
2979#endif
2980 // cleanup?
2981
2982// rDelete(res);
2983// return r;
2984
2985 // just go on..
2986 }
2987 }
2988#endif
2989 return res;
2990}
2991
2992// construct lp, C ring with r->N variables, r->names vars....
2993ring rModifyRing_Simple(ring r, BOOLEAN ommit_degree, BOOLEAN ommit_comp, unsigned long exp_limit, BOOLEAN &simple)
2994{
2995 simple=TRUE;
2996 if (!rHasSimpleOrder(r))
2997 {
2998 simple=FALSE; // sorting needed
2999 assume (r != NULL );
3000 assume (exp_limit > 1);
3001 int bits;
3002
3003 exp_limit=rGetExpSize(exp_limit, bits, r->N);
3004
3005 int nblocks=1+(ommit_comp!=0);
3006 rRingOrder_t *order=(rRingOrder_t*)omAlloc0((nblocks+1)*sizeof(rRingOrder_t));
3007 int *block0=(int*)omAlloc0((nblocks+1)*sizeof(int));
3008 int *block1=(int*)omAlloc0((nblocks+1)*sizeof(int));
3009 int **wvhdl=(int**)omAlloc0((nblocks+1)*sizeof(int *));
3010
3011 order[0]=ringorder_lp;
3012 block0[0]=1;
3013 block1[0]=r->N;
3014 if (!ommit_comp)
3015 {
3016 order[1]=ringorder_C;
3017 }
3018 ring res=(ring)omAlloc0Bin(sip_sring_bin);
3019 *res = *r;
3020#ifdef HAVE_PLURAL
3021 res->GetNC() = NULL;
3022#endif
3023 // res->qideal, res->idroot ???
3024 res->wvhdl=wvhdl;
3025 res->order=order;
3026 res->block0=block0;
3027 res->block1=block1;
3028 res->bitmask=exp_limit;
3029 res->wanted_maxExp=r->wanted_maxExp;
3030 //int tmpref=r->cf->ref;
3031 rComplete(res, 1);
3032 //r->cf->ref=tmpref;
3033
3034#ifdef HAVE_PLURAL
3035 if (rIsPluralRing(r))
3036 {
3037 if ( nc_rComplete(r, res, false) ) // no qideal!
3038 {
3039#ifndef SING_NDEBUG
3040 WarnS("error in nc_rComplete");
3041#endif
3042 // cleanup?
3043
3044// rDelete(res);
3045// return r;
3046
3047 // just go on..
3048 }
3049 }
3050#endif
3051
3053
3054 return res;
3055 }
3056 return rModifyRing(r, ommit_degree, ommit_comp, exp_limit);
3057}
3058
3060{
3061 rUnComplete(r);
3062 omFree(r->order);
3063 omFree(r->block0);
3064 omFree(r->block1);
3065 omFree(r->wvhdl);
3067}
3068
3070{
3071 rUnComplete(r);
3072 omFree(r->order);
3073 omFree(r->block0);
3074 omFree(r->block1);
3075 omFree(r->wvhdl[0]);
3076 omFree(r->wvhdl);
3078}
3079
3080static void rSetOutParams(ring r)
3081{
3082 r->VectorOut = (r->order[0] == ringorder_c);
3083 if (rIsNCRing(r))
3084 r->CanShortOut=FALSE;
3085 else
3086 {
3087 r->CanShortOut = TRUE;
3088 int i;
3089 if (rParameter(r)!=NULL)
3090 {
3091 for (i=0;i<rPar(r);i++)
3092 {
3093 if(strlen(rParameter(r)[i])>1)
3094 {
3095 r->CanShortOut=FALSE;
3096 break;
3097 }
3098 }
3099 }
3100 if (r->CanShortOut)
3101 {
3102 int N = r->N;
3103 for (i=(N-1);i>=0;i--)
3104 {
3105 if(r->names[i] != NULL && strlen(r->names[i])>1)
3106 {
3107 r->CanShortOut=FALSE;
3108 break;
3109 }
3110 }
3111 }
3112 }
3113 r->ShortOut = r->CanShortOut;
3114
3115 assume( !( !r->CanShortOut && r->ShortOut ) );
3116}
3117
3118static void rSetFirstWv(ring r, int i, rRingOrder_t* order, int* block0, int* block1, int** wvhdl)
3119{
3120 // cheat for ringorder_aa
3121 if (order[i] == ringorder_aa)
3122 i++;
3123 if(block1[i]!=r->N) r->LexOrder=TRUE;
3124 r->firstBlockEnds=block1[i];
3125 r->firstwv = wvhdl[i];
3126 if ((order[i]== ringorder_ws)
3127 || (order[i]==ringorder_Ws)
3128 || (order[i]== ringorder_wp)
3129 || (order[i]==ringorder_Wp)
3130 || (order[i]== ringorder_a)
3131 /*|| (order[i]==ringorder_A)*/)
3132 {
3133 int j;
3134 for(j=block1[i]-block0[i];j>=0;j--)
3135 {
3136 if (r->firstwv[j]==0) r->LexOrder=TRUE;
3137 }
3138 }
3139 else if (order[i]==ringorder_a64)
3140 {
3141 int j;
3142 int64 *w=rGetWeightVec(r);
3143 for(j=block1[i]-block0[i];j>=0;j--)
3144 {
3145 if (w[j]==0) r->LexOrder=TRUE;
3146 }
3147 }
3148}
3149
3150static void rOptimizeLDeg(ring r)
3151{
3152 if (r->pFDeg == p_Deg)
3153 {
3154 if (r->pLDeg == pLDeg1)
3155 r->pLDeg = pLDeg1_Deg;
3156 if (r->pLDeg == pLDeg1c)
3157 r->pLDeg = pLDeg1c_Deg;
3158 }
3159 else if (r->pFDeg == p_Totaldegree)
3160 {
3161 if (r->pLDeg == pLDeg1)
3162 r->pLDeg = pLDeg1_Totaldegree;
3163 if (r->pLDeg == pLDeg1c)
3164 r->pLDeg = pLDeg1c_Totaldegree;
3165 }
3166 else if (r->pFDeg == p_WFirstTotalDegree)
3167 {
3168 if (r->pLDeg == pLDeg1)
3169 r->pLDeg = pLDeg1_WFirstTotalDegree;
3170 if (r->pLDeg == pLDeg1c)
3171 r->pLDeg = pLDeg1c_WFirstTotalDegree;
3172 }
3173 r->pLDegOrig = r->pLDeg;
3174}
3175
3176// set pFDeg, pLDeg, requires OrdSgn already set
3177static void rSetDegStuff(ring r)
3178{
3179 rRingOrder_t* order = r->order;
3180 int* block0 = r->block0;
3181 int* block1 = r->block1;
3182 int** wvhdl = r->wvhdl;
3183
3184 if (order[0]==ringorder_S ||order[0]==ringorder_s || order[0]==ringorder_IS)
3185 {
3186 order++;
3187 block0++;
3188 block1++;
3189 wvhdl++;
3190 }
3191 r->LexOrder = FALSE;
3192 r->pFDeg = p_Totaldegree;
3193 r->pLDeg = (r->OrdSgn == 1 ? pLDegb : pLDeg0);
3194
3195 /*======== ordering type is (am,_) ==================*/
3196 if (order[0]==ringorder_am)
3197 {
3198 for(int ii=block0[0];ii<=block1[0];ii++)
3199 if (wvhdl[0][ii-1]<0) { r->MixedOrder=2;break;}
3200 r->LexOrder=FALSE;
3201 for(int ii=block0[0];ii<=block1[0];ii++)
3202 if (wvhdl[0][ii-1]==0) { r->LexOrder=TRUE;break;}
3203 if ((block0[0]==1)&&(block1[0]==r->N))
3204 {
3205 r->pFDeg = p_Deg;
3206 r->pLDeg = pLDeg1c_Deg;
3207 }
3208 else
3209 {
3210 r->pFDeg = p_WTotaldegree;
3211 r->LexOrder=TRUE;
3212 r->pLDeg = pLDeg1c_WFirstTotalDegree;
3213 }
3214 r->firstwv = wvhdl[0];
3215 }
3216 /*======== ordering type is (_,c) =========================*/
3217 else if ((order[0]==ringorder_unspec) || (order[1] == 0)
3218 ||(
3219 ((order[1]==ringorder_c)||(order[1]==ringorder_C)
3220 ||(order[1]==ringorder_S)
3221 ||(order[1]==ringorder_s))
3222 && (order[0]!=ringorder_M)
3223 && (order[2]==0))
3224 )
3225 {
3226 if (r->OrdSgn == -1) r->pLDeg = pLDeg0c;
3227 if ((order[0] == ringorder_lp)
3228 || (order[0] == ringorder_ls)
3229 || (order[0] == ringorder_rp)
3230 || (order[0] == ringorder_rs))
3231 {
3232 r->LexOrder=TRUE;
3233 r->pLDeg = pLDeg1c;
3234 r->pFDeg = p_Totaldegree;
3235 }
3236 else if ((order[0] == ringorder_a)
3237 || (order[0] == ringorder_wp)
3238 || (order[0] == ringorder_Wp))
3239 {
3240 r->pFDeg = p_WFirstTotalDegree;
3241 }
3242 else if ((order[0] == ringorder_ws)
3243 || (order[0] == ringorder_Ws))
3244 {
3245 for(int ii=block0[0];ii<=block1[0];ii++)
3246 {
3247 if (wvhdl[0][ii-1]<0) { r->MixedOrder=2;break;}
3248 }
3249 if (r->MixedOrder==0)
3250 {
3251 if ((block0[0]==1)&&(block1[0]==r->N))
3252 r->pFDeg = p_WTotaldegree;
3253 else
3254 r->pFDeg = p_WFirstTotalDegree;
3255 }
3256 else
3257 r->pFDeg = p_Totaldegree;
3258 }
3259 r->firstBlockEnds=block1[0];
3260 r->firstwv = wvhdl[0];
3261 }
3262 /*======== ordering type is (c,_) =========================*/
3263 else if (((order[0]==ringorder_c)
3264 ||(order[0]==ringorder_C)
3265 ||(order[0]==ringorder_S)
3266 ||(order[0]==ringorder_s))
3267 && (order[1]!=ringorder_M)
3268 && (order[2]==0))
3269 {
3270 if ((order[1] == ringorder_lp)
3271 || (order[1] == ringorder_ls)
3272 || (order[1] == ringorder_rp)
3273 || order[1] == ringorder_rs)
3274 {
3275 r->LexOrder=TRUE;
3276 r->pLDeg = pLDeg1c;
3277 r->pFDeg = p_Totaldegree;
3278 }
3279 r->firstBlockEnds=block1[1];
3280 if (wvhdl!=NULL) r->firstwv = wvhdl[1];
3281 if ((order[1] == ringorder_a)
3282 || (order[1] == ringorder_wp)
3283 || (order[1] == ringorder_Wp))
3284 r->pFDeg = p_WFirstTotalDegree;
3285 else if ((order[1] == ringorder_ws)
3286 || (order[1] == ringorder_Ws))
3287 {
3288 for(int ii=block0[1];ii<=block1[1];ii++)
3289 if (wvhdl[1][ii-1]<0) { r->MixedOrder=2;break;}
3290 if (r->MixedOrder==FALSE)
3291 r->pFDeg = p_WFirstTotalDegree;
3292 else
3293 r->pFDeg = p_Totaldegree;
3294 }
3295 }
3296 /*------- more than one block ----------------------*/
3297 else
3298 {
3299 if ((r->VectorOut)||(order[0]==ringorder_C)||(order[0]==ringorder_S)||(order[0]==ringorder_s))
3300 {
3301 rSetFirstWv(r, 1, order, block0, block1, wvhdl);
3302 }
3303 else
3304 rSetFirstWv(r, 0, order, block0, block1, wvhdl);
3305
3306 if ((order[0]!=ringorder_c)
3307 && (order[0]!=ringorder_C)
3308 && (order[0]!=ringorder_S)
3309 && (order[0]!=ringorder_s))
3310 {
3311 r->pLDeg = pLDeg1c;
3312 }
3313 else
3314 {
3315 r->pLDeg = pLDeg1;
3316 }
3317 r->pFDeg = p_WTotaldegree; // may be improved: p_Totaldegree for lp/dp/ls/.. blocks
3318 }
3319
3322 {
3323 if(r->MixedOrder==FALSE)
3324 r->pFDeg = p_Deg;
3325 else
3326 r->pFDeg = p_Totaldegree;
3327 }
3328
3329 if( rGetISPos(0, r) != -1 ) // Are there Schreyer induced blocks?
3330 {
3331#ifndef SING_NDEBUG
3332 assume( r->pFDeg == p_Deg || r->pFDeg == p_WTotaldegree || r->pFDeg == p_Totaldegree);
3333#endif
3334
3335 r->pLDeg = pLDeg1; // ?
3336 }
3337
3338 r->pFDegOrig = r->pFDeg;
3339 // NOTE: this leads to wrong ecart during std
3340 // in Old/sre.tst
3341 rOptimizeLDeg(r); // also sets r->pLDegOrig
3342}
3343
3344/*2
3345* set NegWeightL_Size, NegWeightL_Offset
3346*/
3347static void rSetNegWeight(ring r)
3348{
3349 int i,l;
3350 if (r->typ!=NULL)
3351 {
3352 l=0;
3353 for(i=0;i<r->OrdSize;i++)
3354 {
3355 if((r->typ[i].ord_typ==ro_wp_neg)
3356 ||(r->typ[i].ord_typ==ro_am))
3357 l++;
3358 }
3359 if (l>0)
3360 {
3361 r->NegWeightL_Size=l;
3362 r->NegWeightL_Offset=(int *) omAlloc(l*sizeof(int));
3363 l=0;
3364 for(i=0;i<r->OrdSize;i++)
3365 {
3366 if(r->typ[i].ord_typ==ro_wp_neg)
3367 {
3368 r->NegWeightL_Offset[l]=r->typ[i].data.wp.place;
3369 l++;
3370 }
3371 else if(r->typ[i].ord_typ==ro_am)
3372 {
3373 r->NegWeightL_Offset[l]=r->typ[i].data.am.place;
3374 l++;
3375 }
3376 }
3377 return;
3378 }
3379 }
3380 r->NegWeightL_Size = 0;
3381 r->NegWeightL_Offset = NULL;
3382}
3383
3384static void rSetOption(ring r)
3385{
3386 // set redthrough
3387 if (!TEST_OPT_OLDSTD && r->OrdSgn == 1 && ! r->LexOrder)
3388 r->options |= Sy_bit(OPT_REDTHROUGH);
3389 else
3390 r->options &= ~Sy_bit(OPT_REDTHROUGH);
3391
3392 // set intStrategy
3393 if ( (r->cf->extRing!=NULL)
3394 || rField_is_Q(r)
3395 || rField_is_Ring(r)
3396 )
3397 r->options |= Sy_bit(OPT_INTSTRATEGY);
3398 else
3399 r->options &= ~Sy_bit(OPT_INTSTRATEGY);
3400
3401 // set redTail
3402 if (r->LexOrder || r->OrdSgn == -1 || (r->cf->extRing!=NULL))
3403 r->options &= ~Sy_bit(OPT_REDTAIL);
3404 else
3405 r->options |= Sy_bit(OPT_REDTAIL);
3406}
3407
3408static void rCheckOrdSgn(ring r,int i/*last block*/);
3409
3410/* -------------------------------------------------------- */
3411/*2
3412* change all global variables to fit the description of the new ring
3413*/
3414
3415void p_SetGlobals(const ring r, BOOLEAN complete)
3416{
3417// // // if (r->ppNoether!=NULL) p_Delete(&r->ppNoether,r); // ???
3418
3419 r->pLexOrder=r->LexOrder;
3420 if (complete)
3421 {
3422 si_opt_1 &= ~ TEST_RINGDEP_OPTS;
3423 si_opt_1 |= r->options;
3424 }
3425}
3426
3427static inline int sign(int x) { return (x > 0) - (x < 0);}
3429{
3430 int i;
3431 poly p=p_One(r);
3432 p_SetExp(p,1,1,r);
3433 p_Setm(p,r);
3434 int vz=sign(p_FDeg(p,r));
3435 for(i=2;i<=rVar(r);i++)
3436 {
3437 p_SetExp(p,i-1,0,r);
3438 p_SetExp(p,i,1,r);
3439 p_Setm(p,r);
3440 if (sign(p_FDeg(p,r))!=vz)
3441 {
3442 p_Delete(&p,r);
3443 return TRUE;
3444 }
3445 }
3446 p_Delete(&p,r);
3447 return FALSE;
3448}
3449
3450BOOLEAN rComplete(ring r, int force)
3451{
3452 if (r->VarOffset!=NULL && force == 0) return FALSE;
3453 rSetOutParams(r);
3454 int n=rBlocks(r)-1;
3455 int i;
3456 int bits;
3457 r->bitmask=rGetExpSize(r->wanted_maxExp,bits,r->N);
3458 r->BitsPerExp = bits;
3459 r->ExpPerLong = BIT_SIZEOF_LONG / bits;
3460 r->divmask=rGetDivMask(bits);
3461
3462 // will be used for ordsgn:
3463 long *tmp_ordsgn=(long *)omAlloc0(3*(n+r->N)*sizeof(long));
3464 // will be used for VarOffset:
3465 int *v=(int *)omAlloc((r->N+1)*sizeof(int));
3466 for(i=r->N; i>=0 ; i--)
3467 {
3468 v[i]=-1;
3469 }
3470 sro_ord *tmp_typ=(sro_ord *)omAlloc0(3*(n+r->N)*sizeof(sro_ord));
3471 int typ_i=0;
3472 int prev_ordsgn=0;
3473
3474 // fill in v, tmp_typ, tmp_ordsgn, determine typ_i (== ordSize)
3475 int j=0;
3476 int j_bits=BITS_PER_LONG;
3477
3478 BOOLEAN need_to_add_comp=FALSE; // Only for ringorder_s and ringorder_S!
3479
3480 for(i=0;i<n;i++)
3481 {
3482 tmp_typ[typ_i].order_index=i;
3483 switch (r->order[i])
3484 {
3485 case ringorder_a:
3486 case ringorder_aa:
3487 rO_WDegree(j,j_bits,r->block0[i],r->block1[i],tmp_ordsgn,tmp_typ[typ_i],
3488 r->wvhdl[i]);
3489 typ_i++;
3490 break;
3491
3492 case ringorder_am:
3493 rO_WMDegree(j,j_bits,r->block0[i],r->block1[i],tmp_ordsgn,tmp_typ[typ_i],
3494 r->wvhdl[i]);
3495 typ_i++;
3496 break;
3497
3498 case ringorder_a64:
3499 rO_WDegree64(j,j_bits,r->block0[i],r->block1[i],tmp_ordsgn,
3500 tmp_typ[typ_i], (int64 *)(r->wvhdl[i]));
3501 typ_i++;
3502 break;
3503
3504 case ringorder_c:
3505 rO_Align(j, j_bits);
3506 rO_LexVars_neg(j, j_bits, 0,0, prev_ordsgn,tmp_ordsgn,v,BITS_PER_LONG, -1);
3507 r->ComponentOrder=1;
3508 break;
3509
3510 case ringorder_C:
3511 rO_Align(j, j_bits);
3512 rO_LexVars(j, j_bits, 0,0, prev_ordsgn,tmp_ordsgn,v,BITS_PER_LONG, -1);
3513 r->ComponentOrder=-1;
3514 break;
3515
3516 case ringorder_M:
3517 {
3518 int k,l;
3519 k=r->block1[i]-r->block0[i]+1; // number of vars
3520 for(l=0;l<k;l++)
3521 {
3522 rO_WDegree(j,j_bits,r->block0[i],r->block1[i],tmp_ordsgn,
3523 tmp_typ[typ_i],
3524 r->wvhdl[i]+(r->block1[i]-r->block0[i]+1)*l);
3525 typ_i++;
3526 }
3527 break;
3528 }
3529
3530 case ringorder_lp:
3531 rO_LexVars(j, j_bits, r->block0[i],r->block1[i], prev_ordsgn,
3532 tmp_ordsgn,v,bits, -1);
3533 break;
3534
3535 case ringorder_ls:
3536 rO_LexVars_neg(j, j_bits, r->block0[i],r->block1[i], prev_ordsgn,
3537 tmp_ordsgn,v, bits, -1);
3538 break;
3539
3540 case ringorder_rs:
3541 rO_LexVars_neg(j, j_bits, r->block1[i],r->block0[i], prev_ordsgn,
3542 tmp_ordsgn,v, bits, -1);
3543 break;
3544
3545 case ringorder_rp:
3546 rO_LexVars(j, j_bits, r->block1[i],r->block0[i], prev_ordsgn,
3547 tmp_ordsgn,v, bits, -1);
3548 break;
3549
3550 case ringorder_dp:
3551 if (r->block0[i]==r->block1[i])
3552 {
3553 rO_LexVars(j, j_bits, r->block0[i],r->block0[i], prev_ordsgn,
3554 tmp_ordsgn,v, bits, -1);
3555 }
3556 else
3557 {
3558 rO_TDegree(j,j_bits,r->block0[i],r->block1[i],tmp_ordsgn,
3559 tmp_typ[typ_i]);
3560 typ_i++;
3561 rO_LexVars_neg(j, j_bits, r->block1[i],r->block0[i]+1,
3562 prev_ordsgn,tmp_ordsgn,v,bits, r->block0[i]);
3563 }
3564 break;
3565
3566 case ringorder_Dp:
3567 if (r->block0[i]==r->block1[i])
3568 {
3569 rO_LexVars(j, j_bits, r->block0[i],r->block0[i], prev_ordsgn,
3570 tmp_ordsgn,v, bits, -1);
3571 }
3572 else
3573 {
3574 rO_TDegree(j,j_bits,r->block0[i],r->block1[i],tmp_ordsgn,
3575 tmp_typ[typ_i]);
3576 typ_i++;
3577 rO_LexVars(j, j_bits, r->block0[i],r->block1[i]-1, prev_ordsgn,
3578 tmp_ordsgn,v, bits, r->block1[i]);
3579 }
3580 break;
3581
3582 case ringorder_ds:
3583 if (r->block0[i]==r->block1[i])
3584 {
3585 rO_LexVars_neg(j, j_bits,r->block0[i],r->block1[i],prev_ordsgn,
3586 tmp_ordsgn,v,bits, -1);
3587 }
3588 else
3589 {
3590 rO_TDegree_neg(j,j_bits,r->block0[i],r->block1[i],tmp_ordsgn,
3591 tmp_typ[typ_i]);
3592 typ_i++;
3593 rO_LexVars_neg(j, j_bits, r->block1[i],r->block0[i]+1,
3594 prev_ordsgn,tmp_ordsgn,v,bits, r->block0[i]);
3595 }
3596 break;
3597
3598 case ringorder_Ds:
3599 if (r->block0[i]==r->block1[i])
3600 {
3601 rO_LexVars_neg(j, j_bits, r->block0[i],r->block0[i],prev_ordsgn,
3602 tmp_ordsgn,v, bits, -1);
3603 }
3604 else
3605 {
3606 rO_TDegree_neg(j,j_bits,r->block0[i],r->block1[i],tmp_ordsgn,
3607 tmp_typ[typ_i]);
3608 typ_i++;
3609 rO_LexVars(j, j_bits, r->block0[i],r->block1[i]-1, prev_ordsgn,
3610 tmp_ordsgn,v, bits, r->block1[i]);
3611 }
3612 break;
3613
3614 case ringorder_wp:
3615 rO_WDegree(j,j_bits,r->block0[i],r->block1[i],tmp_ordsgn,
3616 tmp_typ[typ_i], r->wvhdl[i]);
3617 typ_i++;
3618 { // check for weights <=0
3619 int jj;
3620 BOOLEAN have_bad_weights=FALSE;
3621 for(jj=r->block1[i]-r->block0[i];jj>=0; jj--)
3622 {
3623 if (r->wvhdl[i][jj]<=0) have_bad_weights=TRUE;
3624 }
3625 if (have_bad_weights)
3626 {
3627 rO_TDegree(j,j_bits,r->block0[i],r->block1[i],tmp_ordsgn,
3628 tmp_typ[typ_i]);
3629 typ_i++;
3630 }
3631 }
3632 if (r->block1[i]!=r->block0[i])
3633 {
3634 rO_LexVars_neg(j, j_bits,r->block1[i],r->block0[i]+1, prev_ordsgn,
3635 tmp_ordsgn, v,bits, r->block0[i]);
3636 }
3637 break;
3638
3639 case ringorder_Wp:
3640 rO_WDegree(j,j_bits,r->block0[i],r->block1[i],tmp_ordsgn,
3641 tmp_typ[typ_i], r->wvhdl[i]);
3642 typ_i++;
3643 { // check for weights <=0
3644 int jj;
3645 BOOLEAN have_bad_weights=FALSE;
3646 for(jj=r->block1[i]-r->block0[i];jj>=0; jj--)
3647 {
3648 if (r->wvhdl[i][jj]<=0) have_bad_weights=TRUE;
3649 }
3650 if (have_bad_weights)
3651 {
3652 rO_TDegree(j,j_bits,r->block0[i],r->block1[i],tmp_ordsgn,
3653 tmp_typ[typ_i]);
3654 typ_i++;
3655 }
3656 }
3657 if (r->block1[i]!=r->block0[i])
3658 {
3659 rO_LexVars(j, j_bits,r->block0[i],r->block1[i]-1, prev_ordsgn,
3660 tmp_ordsgn,v, bits, r->block1[i]);
3661 }
3662 break;
3663
3664 case ringorder_ws:
3665 rO_WDegree_neg(j,j_bits,r->block0[i],r->block1[i],tmp_ordsgn,
3666 tmp_typ[typ_i], r->wvhdl[i]);
3667 typ_i++;
3668 if (r->block1[i]!=r->block0[i])
3669 {
3670 rO_LexVars_neg(j, j_bits,r->block1[i],r->block0[i]+1, prev_ordsgn,
3671 tmp_ordsgn, v,bits, r->block0[i]);
3672 }
3673 break;
3674
3675 case ringorder_Ws:
3676 rO_WDegree_neg(j,j_bits,r->block0[i],r->block1[i],tmp_ordsgn,
3677 tmp_typ[typ_i], r->wvhdl[i]);
3678 typ_i++;
3679 if (r->block1[i]!=r->block0[i])
3680 {
3681 rO_LexVars(j, j_bits,r->block0[i],r->block1[i]-1, prev_ordsgn,
3682 tmp_ordsgn,v, bits, r->block1[i]);
3683 }
3684 break;
3685
3686 case ringorder_S:
3687 assume(typ_i == 1); // For LaScala3 only: on the 2nd place ([1])!
3688 // TODO: for K[x]: it is 0...?!
3689 rO_Syzcomp(j, j_bits,prev_ordsgn, tmp_ordsgn,tmp_typ[typ_i]);
3690 need_to_add_comp=TRUE;
3691 r->ComponentOrder=-1;
3692 typ_i++;
3693 break;
3694
3695 case ringorder_s:
3696 assume(typ_i == 0 && j == 0);
3697 rO_Syz(j, j_bits, prev_ordsgn, r->block0[i], tmp_ordsgn, tmp_typ[typ_i]); // set syz-limit?
3698 need_to_add_comp=TRUE;
3699 r->ComponentOrder=-1;
3700 typ_i++;
3701 break;
3702
3703 case ringorder_IS:
3704 {
3705
3706 assume( r->block0[i] == r->block1[i] );
3707 const int s = r->block0[i];
3708 assume( -2 < s && s < 2);
3709
3710 if(s == 0) // Prefix IS
3711 rO_ISPrefix(j, j_bits, prev_ordsgn, tmp_ordsgn, r->N, v, tmp_typ[typ_i++]); // What about prev_ordsgn?
3712 else // s = +1 or -1 // Note: typ_i might be incremented here inside!
3713 {
3714 rO_ISSuffix(j, j_bits, prev_ordsgn, tmp_ordsgn, r->N, v, tmp_typ, typ_i, s); // Suffix.
3715 need_to_add_comp=FALSE;
3716 }
3717
3718 break;
3719 }
3720 case ringorder_unspec:
3721 case ringorder_no:
3722 default:
3723 dReportError("undef. ringorder used\n");
3724 break;
3725 }
3726 }
3727 rCheckOrdSgn(r,n-1);
3728
3729 int j0=j; // save j
3730 int j_bits0=j_bits; // save jbits
3731 rO_Align(j,j_bits);
3732 r->CmpL_Size = j;
3733
3734 j_bits=j_bits0; j=j0;
3735
3736 // fill in some empty slots with variables not already covered
3737 // v0 is special, is therefore normally already covered
3738 // now we do have rings without comp...
3739 if((need_to_add_comp) && (v[0]== -1))
3740 {
3741 if (prev_ordsgn==1)
3742 {
3743 rO_Align(j, j_bits);
3744 rO_LexVars(j, j_bits, 0,0, prev_ordsgn,tmp_ordsgn,v,BITS_PER_LONG, -1);
3745 }
3746 else
3747 {
3748 rO_Align(j, j_bits);
3749 rO_LexVars_neg(j, j_bits, 0,0, prev_ordsgn,tmp_ordsgn,v,BITS_PER_LONG, -1);
3750 }
3751 }
3752 // the variables
3753 for(i=1 ; i<=r->N ; i++)
3754 {
3755 if(v[i]==(-1))
3756 {
3757 if (prev_ordsgn==1)
3758 {
3759 rO_LexVars(j, j_bits, i,i, prev_ordsgn,tmp_ordsgn,v,bits, -1);
3760 }
3761 else
3762 {
3763 rO_LexVars_neg(j,j_bits,i,i, prev_ordsgn,tmp_ordsgn,v,bits, -1);
3764 }
3765 }
3766 }
3767
3768 rO_Align(j,j_bits);
3769 // ----------------------------
3770 // finished with constructing the monomial, computing sizes:
3771
3772 r->ExpL_Size=j;
3773 r->PolyBin = omGetSpecBin(POLYSIZE + (r->ExpL_Size)*sizeof(long));
3774 assume(r->PolyBin != NULL);
3775
3776 // ----------------------------
3777 // indices and ordsgn vector for comparison
3778 //
3779 // r->pCompHighIndex already set
3780 r->ordsgn=(long *)omAlloc0(r->ExpL_Size*sizeof(long));
3781
3782 for(j=0;j<r->CmpL_Size;j++)
3783 {
3784 r->ordsgn[j] = tmp_ordsgn[j];
3785 }
3786
3787 omFreeSize((ADDRESS)tmp_ordsgn,(3*(n+r->N)*sizeof(long)));
3788
3789 // ----------------------------
3790 // description of orderings for setm:
3791 //
3792 r->OrdSize=typ_i;
3793 if (typ_i==0) r->typ=NULL;
3794 else
3795 {
3796 r->typ=(sro_ord*)omAlloc(typ_i*sizeof(sro_ord));
3797 memcpy(r->typ,tmp_typ,typ_i*sizeof(sro_ord));
3798 }
3799 omFreeSize((ADDRESS)tmp_typ,(3*(n+r->N)*sizeof(sro_ord)));
3800
3801 // ----------------------------
3802 // indices for (first copy of ) variable entries in exp.e vector (VarOffset):
3803 r->VarOffset=v;
3804
3805 // ----------------------------
3806 // other indicies
3807 r->pCompIndex=(r->VarOffset[0] & 0xffff); //r->VarOffset[0];
3808 i=0; // position
3809 j=0; // index in r->typ
3810 if (i==r->pCompIndex) i++; // IS???
3811 while ((j < r->OrdSize)
3812 && ((r->typ[j].ord_typ==ro_syzcomp) ||
3813 (r->typ[j].ord_typ==ro_syz) || (r->typ[j].ord_typ==ro_isTemp) || (r->typ[j].ord_typ==ro_is) ||
3814 (r->order[r->typ[j].order_index] == ringorder_aa)))
3815 {
3816 i++; j++;
3817 }
3818
3819 if (i==r->pCompIndex) i++;
3820 r->pOrdIndex=i;
3821
3822 // ----------------------------
3823 rSetDegStuff(r); // OrdSgn etc already set
3824 rSetOption(r);
3825 // ----------------------------
3826 // r->p_Setm
3827 r->p_Setm = p_GetSetmProc(r);
3828
3829 // ----------------------------
3830 // set VarL_*
3831 rSetVarL(r);
3832
3833 // ----------------------------
3834 // right-adjust VarOffset
3836
3837 // ----------------------------
3838 // set NegWeightL*
3839 rSetNegWeight(r);
3840
3841 // ----------------------------
3842 // p_Procs: call AFTER NegWeightL
3843 r->p_Procs = (p_Procs_s*)omAlloc(sizeof(p_Procs_s));
3844 p_ProcsSet(r, r->p_Procs);
3845
3846 // use totaldegree on crazy oderings:
3847 if ((r->pFDeg==p_WTotaldegree) && rOrd_is_MixedDegree_Ordering(r))
3848 r->pFDeg = p_Totaldegree;
3849 return FALSE;
3850}
3851
3852static void rCheckOrdSgn(ring r,int b/*last block*/)
3853{ // set r->OrdSgn, r->MixedOrder
3854 // for each variable:
3855 int nonpos=0;
3856 int nonneg=0;
3857 for(int i=1;i<=r->N;i++)
3858 {
3859 int found=0;
3860 // for all blocks:
3861 for(int j=0;(j<=b) && (found==0);j++)
3862 {
3863 // search the first block containing var(i)
3864 if ((r->block0[j]<=i)&&(r->block1[j]>=i))
3865 {
3866 // what kind if block is it?
3867 if ((r->order[j]==ringorder_ls)
3868 || (r->order[j]==ringorder_ds)
3869 || (r->order[j]==ringorder_Ds)
3870 || (r->order[j]==ringorder_ws)
3871 || (r->order[j]==ringorder_Ws)
3872 || (r->order[j]==ringorder_rs))
3873 {
3874 r->OrdSgn=-1;
3875 nonpos++;
3876 found=1;
3877 }
3878 else if((r->order[j]==ringorder_a)
3879 ||(r->order[j]==ringorder_aa))
3880 {
3881 // <0: local/mixed ordering
3882 // >0: var(i) is okay, look at other vars
3883 // ==0: look at other blocks for var(i)
3884 if(r->wvhdl[j][i-r->block0[j]]<0)
3885 {
3886 r->OrdSgn=-1;
3887 nonpos++;
3888 found=1;
3889 }
3890 else if(r->wvhdl[j][i-r->block0[j]]>0)
3891 {
3892 nonneg++;
3893 found=1;
3894 }
3895 }
3896 else if(r->order[j]==ringorder_M)
3897 {
3898 // <0: local/mixed ordering
3899 // >0: var(i) is okay, look at other vars
3900 // ==0: look at other blocks for var(i)
3901 if(r->wvhdl[j][i-r->block0[j]]<0)
3902 {
3903 r->OrdSgn=-1;
3904 nonpos++;
3905 found=1;
3906 }
3907 else if(r->wvhdl[j][i-r->block0[j]]>0)
3908 {
3909 nonneg++;
3910 found=1;
3911 }
3912 else
3913 {
3914 // very bad: try next row(s)
3915 int add=r->block1[j]-r->block0[j]+1;
3916 int max_i=r->block0[j]+add*add-add-1;
3917 while(found==0)
3918 {
3919 i+=add;
3920 if (r->wvhdl[j][i-r->block0[j]]<0)
3921 {
3922 r->OrdSgn=-1;
3923 nonpos++;
3924 found=1;
3925 }
3926 else if(r->wvhdl[j][i-r->block0[j]]>0)
3927 {
3928 nonneg++;
3929 found=1;
3930 }
3931 else if(i>max_i)
3932 {
3933 nonpos++;
3934 nonneg++;
3935 found=1;
3936 }
3937 }
3938 }
3939 }
3940 else if ((r->order[j]==ringorder_lp)
3941 || (r->order[j]==ringorder_dp)
3942 || (r->order[j]==ringorder_Dp)
3943 || (r->order[j]==ringorder_wp)
3944 || (r->order[j]==ringorder_Wp)
3945 || (r->order[j]==ringorder_rp))
3946 {
3947 found=1;
3948 nonneg++;
3949 }
3950 }
3951 }
3952 }
3953 if (nonpos>0)
3954 {
3955 r->OrdSgn=-1;
3956 if (nonneg>0) r->MixedOrder=1;
3957 }
3958 else
3959 {
3960 r->OrdSgn=1;
3961 r->MixedOrder=0;
3962 }
3963}
3964
3965void rUnComplete(ring r)
3966{
3967 if (r == NULL) return;
3968 if (r->VarOffset != NULL)
3969 {
3970 if (r->OrdSize!=0 && r->typ != NULL)
3971 {
3972 for(int i = 0; i < r->OrdSize; i++)
3973 if( r->typ[i].ord_typ == ro_is) // Search for suffixes! (prefix have the same VarOffset)
3974 {
3975 id_Delete(&r->typ[i].data.is.F, r);
3976
3977 if( r->typ[i].data.is.pVarOffset != NULL )
3978 {
3979 omFreeSize((ADDRESS)r->typ[i].data.is.pVarOffset, (r->N +1)*sizeof(int));
3980 }
3981 }
3982 else if (r->typ[i].ord_typ == ro_syz)
3983 {
3984 if(r->typ[i].data.syz.limit > 0)
3985 omFreeSize(r->typ[i].data.syz.syz_index, ((r->typ[i].data.syz.limit) +1)*sizeof(int));
3986 }
3987 else if (r->typ[i].ord_typ == ro_syzcomp)
3988 {
3989 assume( r->typ[i].data.syzcomp.ShiftedComponents == NULL );
3990 assume( r->typ[i].data.syzcomp.Components == NULL );
3991// WarnS( "rUnComplete : ord_typ == ro_syzcomp was unhandled!!! Possibly memory leak!!!" );
3992#ifndef SING_NDEBUG
3993// assume(0);
3994#endif
3995 }
3996
3997 omFreeSize((ADDRESS)r->typ,r->OrdSize*sizeof(sro_ord)); r->typ = NULL;
3998 }
3999
4000 if (r->PolyBin != NULL)
4001 omUnGetSpecBin(&(r->PolyBin));
4002
4003 omFreeSize((ADDRESS)r->VarOffset, (r->N +1)*sizeof(int));
4004 r->VarOffset=NULL;
4005
4006 if (r->ordsgn != NULL && r->CmpL_Size != 0)
4007 {
4008 omFreeSize((ADDRESS)r->ordsgn,r->ExpL_Size*sizeof(long));
4009 r->ordsgn=NULL;
4010 }
4011 if (r->p_Procs != NULL)
4012 {
4013 omFreeSize(r->p_Procs, sizeof(p_Procs_s));
4014 r->p_Procs=NULL;
4015 }
4016 omfreeSize(r->VarL_Offset, r->VarL_Size*sizeof(int));
4017 r->VarL_Offset=NULL;
4018 }
4019 if (r->NegWeightL_Offset!=NULL)
4020 {
4021 omFreeSize(r->NegWeightL_Offset, r->NegWeightL_Size*sizeof(int));
4022 r->NegWeightL_Offset=NULL;
4023 }
4024}
4025
4026// set r->VarL_Size, r->VarL_Offset, r->VarL_LowIndex
4027static void rSetVarL(ring r)
4028{
4029 int min = INT_MAX, min_j = -1;
4030 int* VarL_Number = (int*) omAlloc0(r->ExpL_Size*sizeof(int));
4031
4032 int i,j;
4033
4034 // count how often a var long is occupied by an exponent
4035 for (i=1; i<=r->N; i++)
4036 {
4037 VarL_Number[r->VarOffset[i] & 0xffffff]++;
4038 }
4039
4040 // determine how many and min
4041 for (i=0, j=0; i<r->ExpL_Size; i++)
4042 {
4043 if (VarL_Number[i] != 0)
4044 {
4045 if (min > VarL_Number[i])
4046 {
4047 min = VarL_Number[i];
4048 min_j = j;
4049 }
4050 j++;
4051 }
4052 }
4053
4054 r->VarL_Size = j; // number of long with exp. entries in
4055 // in p->exp
4056 r->VarL_Offset = (int*) omAlloc(r->VarL_Size*sizeof(int));
4057 r->VarL_LowIndex = 0;
4058
4059 // set VarL_Offset
4060 for (i=0, j=0; i<r->ExpL_Size; i++)
4061 {
4062 if (VarL_Number[i] != 0)
4063 {
4064 r->VarL_Offset[j] = i;
4065 if (j > 0 && r->VarL_Offset[j-1] != r->VarL_Offset[j] - 1)
4066 r->VarL_LowIndex = -1;
4067 j++;
4068 }
4069 }
4070 if (r->VarL_LowIndex >= 0)
4071 r->VarL_LowIndex = r->VarL_Offset[0];
4072
4073 if (min_j != 0)
4074 {
4075 j = r->VarL_Offset[min_j];
4076 r->VarL_Offset[min_j] = r->VarL_Offset[0];
4077 r->VarL_Offset[0] = j;
4078 }
4079 omFree(VarL_Number);
4080}
4081
4082static void rRightAdjustVarOffset(ring r)
4083{
4084 int* shifts = (int*) omAlloc(r->ExpL_Size*sizeof(int));
4085 int i;
4086 // initialize shifts
4087 for (i=0;i<r->ExpL_Size;i++)
4088 shifts[i] = BIT_SIZEOF_LONG;
4089
4090 // find minimal bit shift in each long exp entry
4091 for (i=1;i<=r->N;i++)
4092 {
4093 if (shifts[r->VarOffset[i] & 0xffffff] > r->VarOffset[i] >> 24)
4094 shifts[r->VarOffset[i] & 0xffffff] = r->VarOffset[i] >> 24;
4095 }
4096 // reset r->VarOffset: set the minimal shift to 0
4097 for (i=1;i<=r->N;i++)
4098 {
4099 if (shifts[r->VarOffset[i] & 0xffffff] != 0)
4100 r->VarOffset[i]
4101 = (r->VarOffset[i] & 0xffffff) |
4102 (((r->VarOffset[i] >> 24) - shifts[r->VarOffset[i] & 0xffffff]) << 24);
4103 }
4104 omFree(shifts);
4105}
4106
4107// get r->divmask depending on bits per exponent
4108static unsigned long rGetDivMask(int bits)
4109{
4110 unsigned long divmask = 1;
4111 int i = bits;
4112
4113 while (i < BIT_SIZEOF_LONG)
4114 {
4115 divmask |= (((unsigned long) 1) << (unsigned long) i);
4116 i += bits;
4117 }
4118 return divmask;
4119}
4120
4121#ifdef RDEBUG
4122void rDebugPrint(const ring r)
4123{
4124 if (r==NULL)
4125 {
4126 PrintS("NULL ?\n");
4127 return;
4128 }
4129 // corresponds to ro_typ from ring.h:
4130 const char *TYP[]={"ro_dp","ro_wp","ro_am","ro_wp64","ro_wp_neg","ro_cp",
4131 "ro_syzcomp", "ro_syz", "ro_isTemp", "ro_is", "ro_none"};
4132 int i,j;
4133
4134 Print("ExpL_Size:%d ",r->ExpL_Size);
4135 Print("CmpL_Size:%d ",r->CmpL_Size);
4136 Print("VarL_Size:%d\n",r->VarL_Size);
4137 Print("bitmask=0x%lx (expbound=%ld) \n",r->bitmask, r->bitmask);
4138 Print("divmask=%lx\n", r->divmask);
4139 Print("BitsPerExp=%d ExpPerLong=%d at L[%d]\n", r->BitsPerExp, r->ExpPerLong, r->VarL_Offset[0]);
4140
4141 Print("VarL_LowIndex: %d\n", r->VarL_LowIndex);
4142 PrintS("VarL_Offset:\n");
4143 if (r->VarL_Offset==NULL) PrintS(" NULL");
4144 else
4145 for(j = 0; j < r->VarL_Size; j++)
4146 Print(" VarL_Offset[%d]: %d ", j, r->VarL_Offset[j]);
4147 PrintLn();
4148
4149
4150 PrintS("VarOffset:\n");
4151 if (r->VarOffset==NULL) PrintS(" NULL\n");
4152 else
4153 for(j=0;j<=r->N;j++)
4154 Print(" v%d at e-pos %d, bit %d\n",
4155 j,r->VarOffset[j] & 0xffffff, r->VarOffset[j] >>24);
4156 PrintS("ordsgn:\n");
4157 for(j=0;j<r->CmpL_Size;j++)
4158 Print(" ordsgn %ld at pos %d\n",r->ordsgn[j],j);
4159 Print("OrdSgn:%d\n",r->OrdSgn);
4160 PrintS("ordrec:\n");
4161 for(j=0;j<r->OrdSize;j++)
4162 {
4163 Print(" typ %s", TYP[r->typ[j].ord_typ]);
4164 if (r->typ[j].ord_typ==ro_syz)
4165 {
4166 const short place = r->typ[j].data.syz.place;
4167 const int limit = r->typ[j].data.syz.limit;
4168 const int curr_index = r->typ[j].data.syz.curr_index;
4169 const int* syz_index = r->typ[j].data.syz.syz_index;
4170
4171 Print(" limit %d (place: %d, curr_index: %d), syz_index: ", limit, place, curr_index);
4172
4173 if( syz_index == NULL )
4174 PrintS("(NULL)");
4175 else
4176 {
4177 PrintS("{");
4178 for( i=0; i <= limit; i++ )
4179 Print("%d ", syz_index[i]);
4180 PrintS("}");
4181 }
4182
4183 }
4184 else if (r->typ[j].ord_typ==ro_isTemp)
4185 {
4186 Print(" start (level) %d, suffixpos: %d, VO: ",r->typ[j].data.isTemp.start, r->typ[j].data.isTemp.suffixpos);
4187
4188 }
4189 else if (r->typ[j].ord_typ==ro_is)
4190 {
4191 Print(" start %d, end: %d: ",r->typ[j].data.is.start, r->typ[j].data.is.end);
4192
4193// for( int k = 0; k <= r->N; k++) if (r->typ[j].data.is.pVarOffset[k] != -1) Print("[%2d]: %04x; ", k, r->typ[j].data.is.pVarOffset[k]);
4194
4195 Print(" limit %d",r->typ[j].data.is.limit);
4196#ifndef SING_NDEBUG
4197 //PrintS(" F: ");idShow(r->typ[j].data.is.F, r, r, 1);
4198#endif
4199
4200 PrintLn();
4201 }
4202 else if (r->typ[j].ord_typ==ro_am)
4203 {
4204 Print(" place %d",r->typ[j].data.am.place);
4205 Print(" start %d",r->typ[j].data.am.start);
4206 Print(" end %d",r->typ[j].data.am.end);
4207 Print(" len_gen %d",r->typ[j].data.am.len_gen);
4208 PrintS(" w:");
4209 int l=0;
4210 for(l=r->typ[j].data.am.start;l<=r->typ[j].data.am.end;l++)
4211 Print(" %d",r->typ[j].data.am.weights[l-r->typ[j].data.am.start]);
4212 l=r->typ[j].data.am.end+1;
4213 int ll=r->typ[j].data.am.weights[l-r->typ[j].data.am.start];
4214 PrintS(" m:");
4215 for(int lll=l+1;lll<l+ll+1;lll++)
4216 Print(" %d",r->typ[j].data.am.weights[lll-r->typ[j].data.am.start]);
4217 }
4218 else
4219 {
4220 Print(" place %d",r->typ[j].data.dp.place);
4221
4222 if (r->typ[j].ord_typ!=ro_syzcomp && r->typ[j].ord_typ!=ro_syz)
4223 {
4224 Print(" start %d",r->typ[j].data.dp.start);
4225 Print(" end %d",r->typ[j].data.dp.end);
4226 if ((r->typ[j].ord_typ==ro_wp)
4227 || (r->typ[j].ord_typ==ro_wp_neg))
4228 {
4229 PrintS(" w:");
4230 for(int l=r->typ[j].data.wp.start;l<=r->typ[j].data.wp.end;l++)
4231 Print(" %d",r->typ[j].data.wp.weights[l-r->typ[j].data.wp.start]);
4232 }
4233 else if (r->typ[j].ord_typ==ro_wp64)
4234 {
4235 PrintS(" w64:");
4236 int l;
4237 for(l=r->typ[j].data.wp64.start;l<=r->typ[j].data.wp64.end;l++)
4238 Print(" %ld",(long)(r->typ[j].data.wp64.weights64+l-r->typ[j].data.wp64.start));
4239 }
4240 }
4241 }
4242 PrintLn();
4243 }
4244 Print("pOrdIndex:%d pCompIndex:%d\n", r->pOrdIndex, r->pCompIndex);
4245 Print("OrdSize:%d\n",r->OrdSize);
4246 PrintS("--------------------\n");
4247 for(j=0;j<r->ExpL_Size;j++)
4248 {
4249 Print("L[%d]: ",j);
4250 if (j< r->CmpL_Size)
4251 Print("ordsgn %ld ", r->ordsgn[j]);
4252 else
4253 PrintS("no comp ");
4254 i=1;
4255 for(;i<=r->N;i++)
4256 {
4257 if( (r->VarOffset[i] & 0xffffff) == j )
4258 { Print("v%d at e[%d], bit %d; ", i,r->VarOffset[i] & 0xffffff,
4259 r->VarOffset[i] >>24 ); }
4260 }
4261 if( r->pCompIndex==j ) PrintS("v0; ");
4262 for(i=0;i<r->OrdSize;i++)
4263 {
4264 if (r->typ[i].data.dp.place == j)
4265 {
4266 Print("ordrec:%s (start:%d, end:%d) ",TYP[r->typ[i].ord_typ],
4267 r->typ[i].data.dp.start, r->typ[i].data.dp.end);
4268 }
4269 }
4270
4271 if (j==r->pOrdIndex)
4272 PrintS("pOrdIndex\n");
4273 else
4274 PrintLn();
4275 }
4276 Print("LexOrder:%d, MixedOrder:%d\n",r->LexOrder, r->MixedOrder);
4277
4278 Print("NegWeightL_Size: %d, NegWeightL_Offset: ", r->NegWeightL_Size);
4279 if (r->NegWeightL_Offset==NULL) PrintS(" NULL");
4280 else
4281 for(j = 0; j < r->NegWeightL_Size; j++)
4282 Print(" [%d]: %d ", j, r->NegWeightL_Offset[j]);
4283 PrintLn();
4284
4285 // p_Procs stuff
4286 p_Procs_s proc_names;
4287 const char* field;
4288 const char* length;
4289 const char* ord;
4290 p_Debug_GetProcNames(r, &proc_names); // changes p_Procs!!!
4291 p_Debug_GetSpecNames(r, field, length, ord);
4292
4293 Print("p_Spec : %s, %s, %s\n", field, length, ord);
4294 PrintS("p_Procs :\n");
4295 for (i=0; i<(int) (sizeof(p_Procs_s)/sizeof(void*)); i++)
4296 {
4297 Print(" %s,\n", ((char**) &proc_names)[i]);
4298 }
4299
4300 {
4301 PrintLn();
4302 PrintS("pFDeg : ");
4303#define pFDeg_CASE(A) if(r->pFDeg == A) PrintS( "" #A "" )
4307 pFDeg_CASE(p_Deg); else
4308#undef pFDeg_CASE
4309 Print("(%p)", r->pFDeg); // default case
4310
4311 PrintLn();
4312 Print("pLDeg : (%p)", r->pLDeg);
4313 PrintLn();
4314 }
4315 PrintS("pSetm:");
4316 void p_Setm_Dummy(poly p, const ring r);
4317 void p_Setm_TotalDegree(poly p, const ring r);
4318 void p_Setm_WFirstTotalDegree(poly p, const ring r);
4319 void p_Setm_General(poly p, const ring r);
4320 if (r->p_Setm==p_Setm_General) PrintS("p_Setm_General\n");
4321 else if (r->p_Setm==p_Setm_Dummy) PrintS("p_Setm_Dummy\n");
4322 else if (r->p_Setm==p_Setm_TotalDegree) PrintS("p_Setm_Totaldegree\n");
4323 else if (r->p_Setm==p_Setm_WFirstTotalDegree) PrintS("p_Setm_WFirstTotalDegree\n");
4324 else Print("%p\n",r->p_Setm);
4325}
4326
4327void p_DebugPrint(poly p, const ring r)
4328{
4329 int i,j;
4330 p_Write(p,r);
4331 j=2;
4332 while(p!=NULL)
4333 {
4334 Print("\nexp[0..%d]\n",r->ExpL_Size-1);
4335 for(i=0;i<r->ExpL_Size;i++)
4336 Print("%ld ",p->exp[i]);
4337 PrintLn();
4338 Print("v0:%ld ",p_GetComp(p, r));
4339 for(i=1;i<=r->N;i++) Print(" v%d:%ld",i,p_GetExp(p,i, r));
4340 PrintLn();
4341 pIter(p);
4342 j--;
4343 if (j==0) { PrintS("...\n"); break; }
4344 }
4345}
4346
4347#endif // RDEBUG
4348
4349/// debug-print monomial poly/vector p, assuming that it lives in the ring R
4350static inline void m_DebugPrint(const poly p, const ring R)
4351{
4352 Print("\nexp[0..%d]\n", R->ExpL_Size - 1);
4353 for(int i = 0; i < R->ExpL_Size; i++)
4354 Print("%09lx ", p->exp[i]);
4355 PrintLn();
4356 Print("v0:%9ld ", p_GetComp(p, R));
4357 for(int i = 1; i <= R->N; i++) Print(" v%d:%5ld",i, p_GetExp(p, i, R));
4358 PrintLn();
4359}
4360
4361
4362/*2
4363* asssume that rComplete was called with r
4364* assume that the first block ist ringorder_S
4365* change the block to reflect the sequence given by appending v
4366*/
4367static inline void rNChangeSComps(int* currComponents, long* currShiftedComponents, ring r)
4368{
4369 assume(r->typ[1].ord_typ == ro_syzcomp);
4370
4371 r->typ[1].data.syzcomp.ShiftedComponents = currShiftedComponents;
4372 r->typ[1].data.syzcomp.Components = currComponents;
4373}
4374
4375static inline void rNGetSComps(int** currComponents, long** currShiftedComponents, ring r)
4376{
4377 assume(r->typ[1].ord_typ == ro_syzcomp);
4378
4379 *currShiftedComponents = r->typ[1].data.syzcomp.ShiftedComponents;
4380 *currComponents = r->typ[1].data.syzcomp.Components;
4381}
4382#ifdef PDEBUG
4383static inline void rDBChangeSComps(int* currComponents,
4385 int length,
4386 ring r)
4387{
4388 assume(r->typ[1].ord_typ == ro_syzcomp);
4389
4390 r->typ[1].data.syzcomp.length = length;
4391 rNChangeSComps( currComponents, currShiftedComponents, r);
4392}
4393static inline void rDBGetSComps(int** currComponents,
4394 long** currShiftedComponents,
4395 int *length,
4396 ring r)
4397{
4398 assume(r->typ[1].ord_typ == ro_syzcomp);
4399
4400 *length = r->typ[1].data.syzcomp.length;
4401 rNGetSComps( currComponents, currShiftedComponents, r);
4402}
4403#endif
4404
4405void rChangeSComps(int* currComponents, long* currShiftedComponents, int length, ring r)
4406{
4407#ifdef PDEBUG
4408 rDBChangeSComps(currComponents, currShiftedComponents, length, r);
4409#else
4410 rNChangeSComps(currComponents, currShiftedComponents, r);
4411#endif
4412}
4413
4414void rGetSComps(int** currComponents, long** currShiftedComponents, int *length, ring r)
4415{
4416#ifdef PDEBUG
4417 rDBGetSComps(currComponents, currShiftedComponents, length, r);
4418#else
4419 rNGetSComps(currComponents, currShiftedComponents, r);
4420#endif
4421}
4422
4423
4424/////////////////////////////////////////////////////////////////////////////
4425//
4426// The following routines all take as input a ring r, and return R
4427// where R has a certain property. R might be equal r in which case r
4428// had already this property
4429//
4430ring rAssure_SyzOrder(const ring r, BOOLEAN complete)
4431{
4432 if ( r->order[0] == ringorder_c ) return r;
4433 return rAssure_SyzComp(r,complete);
4434}
4435ring rAssure_SyzComp(const ring r, BOOLEAN complete)
4436{
4437 if ( r->order[0] == ringorder_s ) return r;
4438
4439 if ( r->order[0] == ringorder_IS )
4440 {
4441#ifndef SING_NDEBUG
4442 WarnS("rAssure_SyzComp: input ring has an IS-ordering!");
4443#endif
4444// return r;
4445 }
4446 ring res=rCopy0(r, FALSE, FALSE);
4447 int i=rBlocks(r);
4448 int j;
4449
4450 res->order=(rRingOrder_t *)omAlloc((i+1)*sizeof(rRingOrder_t));
4451 res->block0=(int *)omAlloc0((i+1)*sizeof(int));
4452 res->block1=(int *)omAlloc0((i+1)*sizeof(int));
4453 int ** wvhdl =(int **)omAlloc0((i+1)*sizeof(int**));
4454 for(j=i;j>0;j--)
4455 {
4456 res->order[j]=r->order[j-1];
4457 res->block0[j]=r->block0[j-1];
4458 res->block1[j]=r->block1[j-1];
4459 if (r->wvhdl[j-1] != NULL)
4460 {
4461 #ifdef HAVE_OMALLOC
4462 wvhdl[j] = (int*) omMemDup(r->wvhdl[j-1]);
4463 #else
4464 {
4465 int l=r->block1[j-1]-r->block0[j-1]+1;
4466 if (r->order[j-1]==ringorder_a64) l*=2;
4467 else if (r->order[j-1]==ringorder_M) l=l*l;
4468 else if (r->order[j-1]==ringorder_am)
4469 {
4470 l+=r->wvhdl[j-1][r->block1[j-1]-r->block0[j-1]+1]+1;
4471 }
4472 wvhdl[j]=(int*)omalloc(l*sizeof(int));
4473 memcpy(wvhdl[j],r->wvhdl[j-1],l*sizeof(int));
4474 }
4475 #endif
4476 }
4477 }
4478 res->order[0]=ringorder_s;
4479
4480 res->wvhdl = wvhdl;
4481
4482 if (complete)
4483 {
4484 rComplete(res, 1);
4485#ifdef HAVE_PLURAL
4486 if (rIsPluralRing(r))
4487 {
4488 if ( nc_rComplete(r, res, false) ) // no qideal!
4489 {
4490#ifndef SING_NDEBUG
4491 WarnS("error in nc_rComplete"); // cleanup?// rDelete(res);// return r; // just go on..
4492#endif
4493 }
4494 }
4496#endif
4497
4498#ifdef HAVE_PLURAL
4499 ring old_ring = r;
4500#endif
4501 if (r->qideal!=NULL)
4502 {
4503 res->qideal= idrCopyR_NoSort(r->qideal, r, res);
4504 assume(id_RankFreeModule(res->qideal, res) == 0);
4505#ifdef HAVE_PLURAL
4506 if( rIsPluralRing(res) )
4507 {
4508 if( nc_SetupQuotient(res, r, true) )
4509 {
4510// WarnS("error in nc_SetupQuotient"); // cleanup? rDelete(res); return r; // just go on...?
4511 }
4512 assume(id_RankFreeModule(res->qideal, res) == 0);
4513 }
4514#endif
4515 }
4516
4517#ifdef HAVE_PLURAL
4518 assume((res->qideal==NULL) == (old_ring->qideal==NULL));
4519 assume(rIsPluralRing(res) == rIsPluralRing(old_ring));
4520 assume(rIsSCA(res) == rIsSCA(old_ring));
4521 assume(ncRingType(res) == ncRingType(old_ring));
4522#endif
4523 }
4524 return res;
4525}
4526
4527ring rAssure_TDeg(ring r, int &pos)
4528{
4529 if (r->N==1) // special: dp(1)==lp(1)== no entry in typ
4530 {
4531 pos=r->VarL_LowIndex;
4532 return r;
4533 }
4534 if (r->typ!=NULL)
4535 {
4536 for(int i=r->OrdSize-1;i>=0;i--)
4537 {
4538 if ((r->typ[i].ord_typ==ro_dp)
4539 && (r->typ[i].data.dp.start==1)
4540 && (r->typ[i].data.dp.end==r->N))
4541 {
4542 pos=r->typ[i].data.dp.place;
4543 //printf("no change, pos=%d\n",pos);
4544 return r;
4545 }
4546 }
4547 }
4548
4549#ifdef HAVE_PLURAL
4550 nc_struct* save=r->GetNC();
4551 r->GetNC()=NULL;
4552#endif
4553 ring res=rCopy(r);
4554 if (res->qideal!=NULL)
4555 {
4556 id_Delete(&res->qideal,r);
4557 }
4558
4559 int j;
4560
4561 res->ExpL_Size=r->ExpL_Size+1; // one word more in each monom
4562 res->PolyBin=omGetSpecBin(POLYSIZE + (res->ExpL_Size)*sizeof(long));
4563 omFree((ADDRESS)res->ordsgn);
4564 res->ordsgn=(long *)omAlloc0(res->ExpL_Size*sizeof(long));
4565 for(j=0;j<r->CmpL_Size;j++)
4566 {
4567 res->ordsgn[j] = r->ordsgn[j];
4568 }
4569 res->OrdSize=r->OrdSize+1; // one block more for pSetm
4570 if (r->typ!=NULL)
4571 omFree((ADDRESS)res->typ);
4572 res->typ=(sro_ord*)omAlloc0(res->OrdSize*sizeof(sro_ord));
4573 if (r->typ!=NULL)
4574 memcpy(res->typ,r->typ,r->OrdSize*sizeof(sro_ord));
4575 // the additional block for pSetm: total degree at the last word
4576 // but not included in the compare part
4577 res->typ[res->OrdSize-1].ord_typ=ro_dp;
4578 res->typ[res->OrdSize-1].data.dp.start=1;
4579 res->typ[res->OrdSize-1].data.dp.end=res->N;
4580 res->typ[res->OrdSize-1].data.dp.place=res->ExpL_Size-1;
4581 pos=res->ExpL_Size-1;
4582 //res->pOrdIndex=pos; //NO: think of a(1,0),dp !
4583 extern void p_Setm_General(poly p, ring r);
4584 res->p_Setm=p_Setm_General;
4585 // ----------------------------
4586 omFree((ADDRESS)res->p_Procs);
4587 res->p_Procs = (p_Procs_s*)omAlloc(sizeof(p_Procs_s));
4588
4589 p_ProcsSet(res, res->p_Procs);
4590#ifdef HAVE_PLURAL
4591 r->GetNC()=save;
4592 if (rIsPluralRing(r))
4593 {
4594 if ( nc_rComplete(r, res, false) ) // no qideal!
4595 {
4596#ifndef SING_NDEBUG
4597 WarnS("error in nc_rComplete");
4598#endif
4599 // just go on..
4600 }
4601 }
4602#endif
4603 if (r->qideal!=NULL)
4604 {
4605 res->qideal=idrCopyR_NoSort(r->qideal,r, res);
4606#ifdef HAVE_PLURAL
4607 if (rIsPluralRing(res))
4608 {
4609// nc_SetupQuotient(res, currRing);
4610 nc_SetupQuotient(res, r); // ?
4611 }
4612 assume((res->qideal==NULL) == (r->qideal==NULL));
4613#endif
4614 }
4615
4616#ifdef HAVE_PLURAL
4618 assume(rIsSCA(res) == rIsSCA(r));
4620#endif
4621
4622 return res;
4623}
4624
4625ring rAssure_HasComp(const ring r)
4626{
4627 int last_block;
4628 int i=0;
4629 do
4630 {
4631 if (r->order[i] == ringorder_c ||
4632 r->order[i] == ringorder_C) return r;
4633 if (r->order[i] == 0)
4634 break;
4635 i++;
4636 } while (1);
4637 //WarnS("re-creating ring with comps");
4638 last_block=i-1;
4639
4640 ring new_r = rCopy0(r, FALSE, FALSE);
4641 i+=2;
4642 new_r->wvhdl=(int **)omAlloc0(i * sizeof(int *));
4643 new_r->order = (rRingOrder_t *) omAlloc0(i * sizeof(rRingOrder_t));
4644 new_r->block0 = (int *) omAlloc0(i * sizeof(int));
4645 new_r->block1 = (int *) omAlloc0(i * sizeof(int));
4646 memcpy(new_r->order,r->order,(i-1) * sizeof(rRingOrder_t));
4647 memcpy(new_r->block0,r->block0,(i-1) * sizeof(int));
4648 memcpy(new_r->block1,r->block1,(i-1) * sizeof(int));
4649 for (int j=0; j<=last_block; j++)
4650 {
4651 if (r->wvhdl[j]!=NULL)
4652 {
4653 #ifdef HAVE_OMALLOC
4654 new_r->wvhdl[j] = (int*) omMemDup(r->wvhdl[j]);
4655 #else
4656 {
4657 int l=r->block1[j]-r->block0[j]+1;
4658 if (r->order[j]==ringorder_a64) l*=2;
4659 else if (r->order[j]==ringorder_M) l=l*l;
4660 else if (r->order[j]==ringorder_am)
4661 {
4662 l+=r->wvhdl[j][r->block1[j]-r->block0[j]+1]+1;
4663 }
4664 new_r->wvhdl[j]=(int*)omalloc(l*sizeof(int));
4665 memcpy(new_r->wvhdl[j],r->wvhdl[j],l*sizeof(int));
4666 }
4667 #endif
4668 }
4669 }
4670 last_block++;
4671 new_r->order[last_block]=ringorder_C;
4672 //new_r->block0[last_block]=0;
4673 //new_r->block1[last_block]=0;
4674 //new_r->wvhdl[last_block]=NULL;
4675
4676 rComplete(new_r, 1);
4677
4678#ifdef HAVE_PLURAL
4679 if (rIsPluralRing(r))
4680 {
4681 if ( nc_rComplete(r, new_r, false) ) // no qideal!
4682 {
4683#ifndef SING_NDEBUG
4684 WarnS("error in nc_rComplete"); // cleanup?// rDelete(res);// return r; // just go on..
4685#endif
4686 }
4687 }
4688 assume(rIsPluralRing(r) == rIsPluralRing(new_r));
4689#endif
4690
4691 return new_r;
4692}
4693
4694ring rAssure_CompLastBlock(ring r, BOOLEAN complete)
4695{
4696 int last_block = rBlocks(r) - 2;
4697 if (r->order[last_block] != ringorder_c &&
4698 r->order[last_block] != ringorder_C)
4699 {
4700 int c_pos = 0;
4701 int i;
4702
4703 for (i=0; i< last_block; i++)
4704 {
4705 if (r->order[i] == ringorder_c || r->order[i] == ringorder_C)
4706 {
4707 c_pos = i;
4708 break;
4709 }
4710 }
4711 if (c_pos != -1)
4712 {
4713 ring new_r = rCopy0(r, FALSE, TRUE);
4714 for (i=c_pos+1; i<=last_block; i++)
4715 {
4716 new_r->order[i-1] = new_r->order[i];
4717 new_r->block0[i-1] = new_r->block0[i];
4718 new_r->block1[i-1] = new_r->block1[i];
4719 new_r->wvhdl[i-1] = new_r->wvhdl[i];
4720 }
4721 new_r->order[last_block] = r->order[c_pos];
4722 new_r->block0[last_block] = r->block0[c_pos];
4723 new_r->block1[last_block] = r->block1[c_pos];
4724 new_r->wvhdl[last_block] = r->wvhdl[c_pos];
4725 if (complete)
4726 {
4727 rComplete(new_r, 1);
4728
4729#ifdef HAVE_PLURAL
4730 if (rIsPluralRing(r))
4731 {
4732 if ( nc_rComplete(r, new_r, false) ) // no qideal!
4733 {
4734#ifndef SING_NDEBUG
4735 WarnS("error in nc_rComplete"); // cleanup?// rDelete(res);// return r; // just go on..
4736#endif
4737 }
4738 }
4739 assume(rIsPluralRing(r) == rIsPluralRing(new_r));
4740#endif
4741 }
4742 return new_r;
4743 }
4744 }
4745 return r;
4746}
4747
4748// Moves _c or _C ordering to the last place AND adds _s on the 1st place
4750{
4751 rTest(r);
4752
4753 ring new_r_1 = rAssure_CompLastBlock(r, FALSE); // due to this FALSE - no completion!
4754 ring new_r = rAssure_SyzComp(new_r_1, FALSE); // new_r_1 is used only here!!!
4755
4756 if (new_r == r)
4757 return r;
4758
4759 ring old_r = r;
4760 if (new_r_1 != new_r && new_r_1 != old_r) rDelete(new_r_1);
4761
4762 rComplete(new_r, TRUE);
4763#ifdef HAVE_PLURAL
4764 if (rIsPluralRing(old_r))
4765 {
4766 if ( nc_rComplete(old_r, new_r, false) ) // no qideal!
4767 {
4768# ifndef SING_NDEBUG
4769 WarnS("error in nc_rComplete"); // cleanup? rDelete(res); return r; // just go on...?
4770# endif
4771 }
4772 }
4773#endif
4774
4775///? rChangeCurrRing(new_r);
4776 if (old_r->qideal != NULL)
4777 {
4778 new_r->qideal = idrCopyR(old_r->qideal, old_r, new_r);
4779 }
4780
4781#ifdef HAVE_PLURAL
4782 if( rIsPluralRing(old_r) )
4783 if( nc_SetupQuotient(new_r, old_r, true) )
4784 {
4785#ifndef SING_NDEBUG
4786 WarnS("error in nc_SetupQuotient"); // cleanup? rDelete(res); return r; // just go on...?
4787#endif
4788 }
4789#endif
4790
4791#ifdef HAVE_PLURAL
4792 assume((new_r->qideal==NULL) == (old_r->qideal==NULL));
4793 assume(rIsPluralRing(new_r) == rIsPluralRing(old_r));
4794 assume(rIsSCA(new_r) == rIsSCA(old_r));
4795 assume(ncRingType(new_r) == ncRingType(old_r));
4796#endif
4797
4798 rTest(new_r);
4799 rTest(old_r);
4800 return new_r;
4801}
4802
4803// use this for global orderings consisting of two blocks
4804static ring rAssure_Global(rRingOrder_t b1, rRingOrder_t b2, const ring r)
4805{
4806 int r_blocks = rBlocks(r);
4807
4808 assume(b1 == ringorder_c || b1 == ringorder_C ||
4809 b2 == ringorder_c || b2 == ringorder_C ||
4810 b2 == ringorder_S);
4811 if ((r_blocks == 3) &&
4812 (r->order[0] == b1) &&
4813 (r->order[1] == b2) &&
4814 (r->order[2] == 0))
4815 return r;
4816 ring res = rCopy0(r, FALSE, FALSE);
4817 res->order = (rRingOrder_t*)omAlloc0(3*sizeof(rRingOrder_t));
4818 res->block0 = (int*)omAlloc0(3*sizeof(int));
4819 res->block1 = (int*)omAlloc0(3*sizeof(int));
4820 res->wvhdl = (int**)omAlloc0(3*sizeof(int*));
4821 res->order[0] = b1;
4822 res->order[1] = b2;
4823 if (b1 == ringorder_c || b1 == ringorder_C)
4824 {
4825 res->block0[1] = 1;
4826 res->block1[1] = r->N;
4827 }
4828 else
4829 {
4830 res->block0[0] = 1;
4831 res->block1[0] = r->N;
4832 }
4833 rComplete(res, 1);
4834 if (r->qideal!=NULL) res->qideal= idrCopyR_NoSort(r->qideal, r, res);
4835#ifdef HAVE_PLURAL
4836 if (rIsPluralRing(r))
4837 {
4838 if ( nc_rComplete(r, res, false) ) // no qideal!
4839 {
4840#ifndef SING_NDEBUG
4841 WarnS("error in nc_rComplete");
4842#endif
4843 }
4844 }
4845#endif
4846// rChangeCurrRing(res);
4847 return res;
4848}
4849
4850ring rAssure_InducedSchreyerOrdering(const ring r, BOOLEAN complete/* = TRUE*/, int sgn/* = 1*/)
4851{ // TODO: ???? Add leading Syz-comp ordering here...????
4852
4853#if MYTEST
4854 Print("rAssure_InducedSchreyerOrdering(r, complete = %d, sgn = %d): r: \n", complete, sgn);
4855 rWrite(r);
4856#ifdef RDEBUG
4857 rDebugPrint(r);
4858#endif
4859 PrintLn();
4860#endif
4861 assume((sgn == 1) || (sgn == -1));
4862
4863 ring res=rCopy0(r, FALSE, FALSE); // No qideal & ordering copy.
4864
4865 int n = rBlocks(r); // Including trailing zero!
4866
4867 // Create 2 more blocks for prefix/suffix:
4868 res->order=(rRingOrder_t *)omAlloc0((n+2)*sizeof(rRingOrder_t)); // 0 .. n+1
4869 res->block0=(int *)omAlloc0((n+2)*sizeof(int));
4870 res->block1=(int *)omAlloc0((n+2)*sizeof(int));
4871 int ** wvhdl =(int **)omAlloc0((n+2)*sizeof(int**));
4872
4873 // Encapsulate all existing blocks between induced Schreyer ordering markers: prefix and suffix!
4874 // Note that prefix and suffix have the same ringorder marker and only differ in block[] parameters!
4875
4876 // new 1st block
4877 int j = 0;
4878 res->order[j] = ringorder_IS; // Prefix
4879 res->block0[j] = res->block1[j] = 0;
4880 // wvhdl[j] = NULL;
4881 j++;
4882
4883 for(int i = 0; (i <= n) && (r->order[i] != 0); i++, j++) // i = [0 .. n-1] <- non-zero old blocks
4884 {
4885 res->order [j] = r->order [i];
4886 res->block0[j] = r->block0[i];
4887 res->block1[j] = r->block1[i];
4888
4889 if (r->wvhdl[i] != NULL)
4890 {
4891 #ifdef HAVE_OMALLOC
4892 wvhdl[j] = (int*) omMemDup(r->wvhdl[i]);
4893 #else
4894 {
4895 int l=(r->block1[i]-r->block0[i]+1);
4896 if (r->order[i]==ringorder_a64) l*=2;
4897 else if (r->order[i]==ringorder_M) l=l*l;
4898 else if (r->order[i]==ringorder_am)
4899 {
4900 l+=r->wvhdl[i][r->block1[i]-r->block0[i]+1]+1;
4901 }
4902 wvhdl[j]=(int*)omalloc(l*sizeof(int));
4903 memcpy(wvhdl[j],r->wvhdl[i],l*sizeof(int));
4904 }
4905 #endif
4906 } // else wvhdl[j] = NULL;
4907 }
4908
4909 // new last block
4910 res->order [j] = ringorder_IS; // Suffix
4911 res->block0[j] = res->block1[j] = sgn; // Sign of v[o]: 1 for C, -1 for c
4912 // wvhdl[j] = NULL;
4913 j++;
4914
4915 // res->order [j] = 0; // The End!
4916 res->wvhdl = wvhdl;
4917
4918 // j == the last zero block now!
4919 assume(j == (n+1));
4920 assume(res->order[0]==ringorder_IS);
4921 assume(res->order[j-1]==ringorder_IS);
4922 assume(res->order[j]==0);
4923
4924
4925 if (complete)
4926 {
4927 rComplete(res, 1);
4928
4929#ifdef HAVE_PLURAL
4930 if (rIsPluralRing(r))
4931 {
4932 if ( nc_rComplete(r, res, false) ) // no qideal!
4933 {
4934#ifndef SING_NDEBUG
4935 WarnS("error in nc_rComplete"); // cleanup?// rDelete(res);// return r; // just go on..
4936#endif
4937 }
4938 }
4940#endif
4941
4942
4943#ifdef HAVE_PLURAL
4944 ring old_ring = r;
4945#endif
4946
4947 if (r->qideal!=NULL)
4948 {
4949 res->qideal= idrCopyR_NoSort(r->qideal, r, res);
4950
4951 assume(id_RankFreeModule(res->qideal, res) == 0);
4952
4953#ifdef HAVE_PLURAL
4954 if( rIsPluralRing(res) )
4955 if( nc_SetupQuotient(res, r, true) )
4956 {
4957// WarnS("error in nc_SetupQuotient"); // cleanup? rDelete(res); return r; // just go on...?
4958 }
4959
4960#endif
4961 assume(id_RankFreeModule(res->qideal, res) == 0);
4962 }
4963
4964#ifdef HAVE_PLURAL
4965 assume((res->qideal==NULL) == (old_ring->qideal==NULL));
4966 assume(rIsPluralRing(res) == rIsPluralRing(old_ring));
4967 assume(rIsSCA(res) == rIsSCA(old_ring));
4968 assume(ncRingType(res) == ncRingType(old_ring));
4969#endif
4970 }
4971
4972 return res;
4973}
4974
4975ring rAssure_dp_S(const ring r)
4976{
4978}
4979
4980ring rAssure_dp_C(const ring r)
4981{
4983}
4984
4985ring rAssure_C_dp(const ring r)
4986{
4988}
4989
4990ring rAssure_c_dp(const ring r)
4991{
4993}
4994
4995
4996
4997/// Finds p^th IS ordering, and returns its position in r->typ[]
4998/// returns -1 if something went wrong!
4999/// p - starts with 0!
5000int rGetISPos(const int p, const ring r)
5001{
5002 // Put the reference set F into the ring -ordering -recor
5003#if MYTEST
5004 Print("rIsIS(p: %d)\nF:", p);
5005 PrintLn();
5006#endif
5007
5008 if (r->typ==NULL)
5009 {
5010// dReportError("'rIsIS:' Error: wrong ring! (typ == NULL)");
5011 return -1;
5012 }
5013
5014 int j = p; // Which IS record to use...
5015 for( int pos = 0; pos < r->OrdSize; pos++ )
5016 if( r->typ[pos].ord_typ == ro_is)
5017 if( j-- == 0 )
5018 return pos;
5019
5020 return -1;
5021}
5022
5023
5024
5025
5026
5027
5028/// Changes r by setting induced ordering parameters: limit and reference leading terms
5029/// F belong to r, we will DO a copy!
5030/// We will use it AS IS!
5031/// returns true is everything was allright!
5032BOOLEAN rSetISReference(const ring r, const ideal F, const int i, const int p)
5033{
5034 // Put the reference set F into the ring -ordering -recor
5035
5036 if (r->typ==NULL)
5037 {
5038 dReportError("Error: WRONG USE of rSetISReference: wrong ring! (typ == NULL)");
5039 return FALSE;
5040 }
5041
5042
5043 int pos = rGetISPos(p, r);
5044
5045 if( pos == -1 )
5046 {
5047 dReportError("Error: WRONG USE of rSetISReference: specified ordering block was not found!!!" );
5048 return FALSE;
5049 }
5050
5051#if MYTEST
5052 if( i != r->typ[pos].data.is.limit )
5053 Print("Changing record on pos: %d\nOld limit: %d --->> New Limit: %d\n", pos, r->typ[pos].data.is.limit, i);
5054#endif
5055
5056 const ideal FF = idrHeadR(F, r, r); // id_Copy(F, r); // ???
5057
5058
5059 if( r->typ[pos].data.is.F != NULL)
5060 {
5061#if MYTEST
5062 PrintS("Deleting old reference set F... \n"); // idShow(r->typ[pos].data.is.F, r); PrintLn();
5063#endif
5064 id_Delete(&r->typ[pos].data.is.F, r);
5065 r->typ[pos].data.is.F = NULL;
5066 }
5067
5068 assume(r->typ[pos].data.is.F == NULL);
5069
5070 r->typ[pos].data.is.F = FF; // F is owened by ring now! TODO: delete at the end!
5071
5072 r->typ[pos].data.is.limit = i; // First induced component
5073
5074#if MYTEST
5075 PrintS("New reference set FF : \n"); idShow(FF, r, r, 1); PrintLn();
5076#endif
5077
5078 return TRUE;
5079}
5080
5081#ifdef PDEBUG
5083#endif
5084
5085
5086void rSetSyzComp(int k, const ring r)
5087{
5088 if(k < 0)
5089 {
5090 dReportError("rSetSyzComp with negative limit!");
5091 return;
5092 }
5093
5094 assume( k >= 0 );
5095 if (TEST_OPT_PROT) Print("{%d}", k);
5096 if ((r->typ!=NULL) && (r->typ[0].ord_typ==ro_syz))
5097 {
5098 r->block0[0]=r->block1[0] = k;
5099 if( k == r->typ[0].data.syz.limit )
5100 return; // nothing to do
5101
5102 int i;
5103 if (r->typ[0].data.syz.limit == 0)
5104 {
5105 r->typ[0].data.syz.syz_index = (int*) omAlloc0((k+1)*sizeof(int));
5106 r->typ[0].data.syz.syz_index[0] = 0;
5107 r->typ[0].data.syz.curr_index = 1;
5108 }
5109 else
5110 {
5111 r->typ[0].data.syz.syz_index = (int*)
5112 omReallocSize(r->typ[0].data.syz.syz_index,
5113 (r->typ[0].data.syz.limit+1)*sizeof(int),
5114 (k+1)*sizeof(int));
5115 }
5116 for (i=r->typ[0].data.syz.limit + 1; i<= k; i++)
5117 {
5118 r->typ[0].data.syz.syz_index[i] =
5119 r->typ[0].data.syz.curr_index;
5120 }
5121 if(k < r->typ[0].data.syz.limit) // ?
5122 {
5123#ifndef SING_NDEBUG
5124 Warn("rSetSyzComp called with smaller limit (%d) as before (%d)", k, r->typ[0].data.syz.limit);
5125#endif
5126 r->typ[0].data.syz.curr_index = 1 + r->typ[0].data.syz.syz_index[k];
5127 }
5128
5129
5130 r->typ[0].data.syz.limit = k;
5131 r->typ[0].data.syz.curr_index++;
5132 }
5133 else if(
5134 (r->typ!=NULL) &&
5135 (r->typ[0].ord_typ==ro_isTemp)
5136 )
5137 {
5138// (r->typ[currRing->typ[0].data.isTemp.suffixpos].data.is.limit == k)
5139#ifndef SING_NDEBUG
5140 Warn("rSetSyzComp(%d) in an IS ring! Be careful!", k);
5141#endif
5142 }
5143 else if (r->order[0]==ringorder_s)
5144 {
5145 r->block0[0] = r->block1[0] = k;
5146 }
5147 else if (r->order[0]!=ringorder_c)
5148 {
5149 dReportError("syzcomp in incompatible ring");
5150 }
5151#ifdef PDEBUG
5153 pDBsyzComp=k;
5154#endif
5155}
5156
5157// return the max-comonent wchich has syzIndex i
5158int rGetMaxSyzComp(int i, const ring r)
5159{
5160 if ((r->typ!=NULL) && (r->typ[0].ord_typ==ro_syz) &&
5161 r->typ[0].data.syz.limit > 0 && i > 0)
5162 {
5163 assume(i <= r->typ[0].data.syz.limit);
5164 int j;
5165 for (j=0; j<r->typ[0].data.syz.limit; j++)
5166 {
5167 if (r->typ[0].data.syz.syz_index[j] == i &&
5168 r->typ[0].data.syz.syz_index[j+1] != i)
5169 {
5170 assume(r->typ[0].data.syz.syz_index[j+1] == i+1);
5171 return j;
5172 }
5173 }
5174 return r->typ[0].data.syz.limit;
5175 }
5176 else
5177 {
5178 #ifndef SING_NDEBUG
5179 WarnS("rGetMaxSyzComp: order c");
5180 #endif
5181 return 0;
5182 }
5183}
5184
5186{
5187 assume(r != NULL);
5188 int lb = rBlocks(r) - 2;
5189 return (r->order[lb] == ringorder_c || r->order[lb] == ringorder_C);
5190}
5191
5193{
5194 if ((r->order[0]==ringorder_dp) &&(r->block0[0]==1) &&(r->block1[0]==r->N))
5195 return TRUE;
5196 if (((r->order[0]==ringorder_c)||(r->order[0]==ringorder_C))
5197 && ((r->order[1]==ringorder_dp) &&(r->block0[1]==1) &&(r->block1[1]==r->N)))
5198 return TRUE;
5199 return FALSE;
5200}
5201
5203{
5204 if ((r->order[0]==ringorder_Dp) &&(r->block0[0]==1) &&(r->block1[0]==r->N))
5205 return TRUE;
5206 if (((r->order[0]==ringorder_c)||(r->order[0]==ringorder_C))
5207 && ((r->order[1]==ringorder_Dp) &&(r->block0[1]==1) &&(r->block1[1]==r->N)))
5208 return TRUE;
5209 return FALSE;
5210}
5211
5213{
5214 if ((r->order[0]==ringorder_lp) &&(r->block0[0]==1) &&(r->block1[0]==r->N))
5215 return TRUE;
5216 if (((r->order[0]==ringorder_c)||(r->order[0]==ringorder_C))
5217 && ((r->order[1]==ringorder_lp) &&(r->block0[1]==1) &&(r->block1[1]==r->N)))
5218 return TRUE;
5219 return FALSE;
5220}
5221
5222int64 * rGetWeightVec(const ring r)
5223{
5224 assume(r!=NULL);
5225 assume(r->OrdSize>0);
5226 int i=0;
5227 while((r->typ[i].ord_typ!=ro_wp64) && (r->typ[i].ord_typ>0)) i++;
5228 if (r->typ[i].ord_typ!=ro_wp64) return NULL; /* should not happen*/
5229 return r->typ[i].data.wp64.weights64;
5230}
5231
5232void rSetWeightVec(ring r, int64 *wv)
5233{
5234 assume(r!=NULL);
5235 assume(r->OrdSize>0);
5236 assume(r->typ[0].ord_typ==ro_wp64);
5237 memcpy(r->typ[0].data.wp64.weights64,wv,r->N*sizeof(int64));
5238}
5239
5240#include <ctype.h>
5241
5242static int rRealloc1(ring r, int size, int pos)
5243{
5244 r->order=(rRingOrder_t*)omReallocSize(r->order, size*sizeof(rRingOrder_t), (size+1)*sizeof(rRingOrder_t));
5245 r->block0=(int*)omReallocSize(r->block0, size*sizeof(int), (size+1)*sizeof(int));
5246 r->block1=(int*)omReallocSize(r->block1, size*sizeof(int), (size+1)*sizeof(int));
5247 r->wvhdl=(int **)omReallocSize(r->wvhdl,size*sizeof(int *), (size+1)*sizeof(int *));
5248 for(int k=size; k>pos; k--) r->wvhdl[k]=r->wvhdl[k-1];
5249 r->order[size]=(rRingOrder_t)0;
5250 size++;
5251 return size;
5252}
5253#if 0 // currently unused
5254static int rReallocM1(ring r, int size, int pos)
5255{
5256 r->order=(int*)omReallocSize(r->order, size*sizeof(int), (size-1)*sizeof(int));
5257 r->block0=(int*)omReallocSize(r->block0, size*sizeof(int), (size-1)*sizeof(int));
5258 r->block1=(int*)omReallocSize(r->block1, size*sizeof(int), (size-1)*sizeof(int));
5259 r->wvhdl=(int **)omReallocSize(r->wvhdl,size*sizeof(int *), (size-1)*sizeof(int *));
5260 for(int k=pos+1; k<size; k++) r->wvhdl[k]=r->wvhdl[k+1];
5261 size--;
5262 return size;
5263}
5264#endif
5265static void rOppWeight(int *w, int l)
5266{
5267 /* works for commutative/Plural; need to be changed for Letterplace */
5268 /* Letterpace: each block of vars needs to be reverted on it own */
5269 int i2=(l+1)/2;
5270 for(int j=0; j<=i2; j++)
5271 {
5272 int t=w[j];
5273 w[j]=w[l-j];
5274 w[l-j]=t;
5275 }
5276}
5277
5278#define rOppVar(R,I) (rVar(R)+1-I)
5279/* nice for Plural, need to be changed for Letterplace: requires also the length of a monomial */
5280
5281ring rOpposite(ring src)
5282 /* creates an opposite algebra of R */
5283 /* that is R^opp, where f (*^opp) g = g*f */
5284 /* treats the case of qring */
5285{
5286 if (src == NULL) return(NULL);
5287
5288 //rChangeCurrRing(src);
5289#ifdef RDEBUG
5290 rTest(src);
5291// rWrite(src);
5292// rDebugPrint(src);
5293#endif
5294
5295 ring r = rCopy0(src,FALSE);
5296 if (src->qideal != NULL)
5297 {
5298 id_Delete(&(r->qideal), src);
5299 }
5300
5301 // change vars v1..vN -> vN..v1
5302 int i;
5303 int i2 = (rVar(r)-1)/2;
5304 for(i=i2; i>=0; i--)
5305 {
5306 // index: 0..N-1
5307 //Print("ex var names: %d <-> %d\n",i,rOppVar(r,i));
5308 // exchange names
5309 char *p;
5310 p = r->names[rVar(r)-1-i];
5311 r->names[rVar(r)-1-i] = r->names[i];
5312 r->names[i] = p;
5313 }
5314// i2=(rVar(r)+1)/2;
5315// for(int i=i2; i>0; i--)
5316// {
5317// // index: 1..N
5318// //Print("ex var places: %d <-> %d\n",i,rVar(r)+1-i);
5319// // exchange VarOffset
5320// int t;
5321// t=r->VarOffset[i];
5322// r->VarOffset[i]=r->VarOffset[rOppVar(r,i)];
5323// r->VarOffset[rOppVar(r,i)]=t;
5324// }
5325 // change names:
5326 // TODO: does this work the same way for Letterplace?
5327 for (i=rVar(r)-1; i>=0; i--)
5328 {
5329 char *p=r->names[i];
5330 if(isupper(*p)) *p = tolower(*p);
5331 else *p = toupper(*p);
5332 }
5333 // change ordering: listing
5334 // change ordering: compare
5335// for(i=0; i<r->OrdSize; i++)
5336// {
5337// int t,tt;
5338// switch(r->typ[i].ord_typ)
5339// {
5340// case ro_dp:
5341// //
5342// t=r->typ[i].data.dp.start;
5343// r->typ[i].data.dp.start=rOppVar(r,r->typ[i].data.dp.end);
5344// r->typ[i].data.dp.end=rOppVar(r,t);
5345// break;
5346// case ro_wp:
5347// case ro_wp_neg:
5348// {
5349// t=r->typ[i].data.wp.start;
5350// r->typ[i].data.wp.start=rOppVar(r,r->typ[i].data.wp.end);
5351// r->typ[i].data.wp.end=rOppVar(r,t);
5352// // invert r->typ[i].data.wp.weights
5353// rOppWeight(r->typ[i].data.wp.weights,
5354// r->typ[i].data.wp.end-r->typ[i].data.wp.start);
5355// break;
5356// }
5357// //case ro_wp64:
5358// case ro_syzcomp:
5359// case ro_syz:
5360// WerrorS("not implemented in rOpposite");
5361// // should not happen
5362// break;
5363//
5364// case ro_cp:
5365// t=r->typ[i].data.cp.start;
5366// r->typ[i].data.cp.start=rOppVar(r,r->typ[i].data.cp.end);
5367// r->typ[i].data.cp.end=rOppVar(r,t);
5368// break;
5369// case ro_none:
5370// default:
5371// Werror("unknown type in rOpposite(%d)",r->typ[i].ord_typ);
5372// break;
5373// }
5374// }
5375 // Change order/block structures (needed for rPrint, rAdd etc.)
5376
5377 int j=0;
5378 int l=rBlocks(src);
5379 if ( ! rIsLPRing(src) )
5380 {
5381 // ie Plural or commutative
5382 for(i=0; src->order[i]!=0; i++)
5383 {
5384 switch (src->order[i])
5385 {
5386 case ringorder_c: /* c-> c */
5387 case ringorder_C: /* C-> C */
5388 case ringorder_no /*=0*/: /* end-of-block */
5389 r->order[j]=src->order[i];
5390 j++; break;
5391 case ringorder_lp: /* lp -> rp */
5392 r->order[j]=ringorder_rp;
5393 r->block0[j]=rOppVar(r, src->block1[i]);
5394 r->block1[j]=rOppVar(r, src->block0[i]);
5395 j++;break;
5396 case ringorder_rp: /* rp -> lp */
5397 r->order[j]=ringorder_lp;
5398 r->block0[j]=rOppVar(r, src->block1[i]);
5399 r->block1[j]=rOppVar(r, src->block0[i]);
5400 j++;break;
5401 case ringorder_dp: /* dp -> a(1..1),ls */
5402 {
5403 l=rRealloc1(r,l,j);
5404 r->order[j]=ringorder_a;
5405 r->block0[j]=rOppVar(r, src->block1[i]);
5406 r->block1[j]=rOppVar(r, src->block0[i]);
5407 r->wvhdl[j]=(int*)omAlloc((r->block1[j]-r->block0[j]+1)*sizeof(int));
5408 for(int k=r->block0[j]; k<=r->block1[j]; k++)
5409 r->wvhdl[j][k-r->block0[j]]=1;
5410 j++;
5411 r->order[j]=ringorder_ls;
5412 r->block0[j]=rOppVar(r, src->block1[i]);
5413 r->block1[j]=rOppVar(r, src->block0[i]);
5414 j++;
5415 break;
5416 }
5417 case ringorder_Dp: /* Dp -> a(1..1),rp */
5418 {
5419 l=rRealloc1(r,l,j);
5420 r->order[j]=ringorder_a;
5421 r->block0[j]=rOppVar(r, src->block1[i]);
5422 r->block1[j]=rOppVar(r, src->block0[i]);
5423 r->wvhdl[j]=(int*)omAlloc((r->block1[j]-r->block0[j]+1)*sizeof(int));
5424 for(int k=r->block0[j]; k<=r->block1[j]; k++)
5425 r->wvhdl[j][k-r->block0[j]]=1;
5426 j++;
5427 r->order[j]=ringorder_rp;
5428 r->block0[j]=rOppVar(r, src->block1[i]);
5429 r->block1[j]=rOppVar(r, src->block0[i]);
5430 j++;
5431 break;
5432 }
5433 case ringorder_wp: /* wp -> a(...),ls */
5434 {
5435 l=rRealloc1(r,l,j);
5436 r->order[j]=ringorder_a;
5437 r->block0[j]=rOppVar(r, src->block1[i]);
5438 r->block1[j]=rOppVar(r, src->block0[i]);
5439 r->wvhdl[j]=r->wvhdl[j+1]; r->wvhdl[j+1]=NULL;
5440 rOppWeight(r->wvhdl[j], r->block1[j]-r->block0[j]);
5441 j++;
5442 r->order[j]=ringorder_ls;
5443 r->block0[j]=rOppVar(r, src->block1[i]);
5444 r->block1[j]=rOppVar(r, src->block0[i]);
5445 j++;
5446 break;
5447 }
5448 case ringorder_Wp: /* Wp -> a(...),rp */
5449 {
5450 l=rRealloc1(r,l,j);
5451 r->order[j]=ringorder_a;
5452 r->block0[j]=rOppVar(r, src->block1[i]);
5453 r->block1[j]=rOppVar(r, src->block0[i]);
5454 r->wvhdl[j]=r->wvhdl[j+1]; r->wvhdl[j+1]=NULL;
5455 rOppWeight(r->wvhdl[j], r->block1[j]-r->block0[j]);
5456 j++;
5457 r->order[j]=ringorder_rp;
5458 r->block0[j]=rOppVar(r, src->block1[i]);
5459 r->block1[j]=rOppVar(r, src->block0[i]);
5460 j++;
5461 break;
5462 }
5463 case ringorder_M: /* M -> M */
5464 {
5465 r->order[j]=ringorder_M;
5466 r->block0[j]=rOppVar(r, src->block1[i]);
5467 r->block1[j]=rOppVar(r, src->block0[i]);
5468 int n=r->block1[j]-r->block0[j];
5469 /* M is a (n+1)x(n+1) matrix */
5470 for (int nn=0; nn<=n; nn++)
5471 {
5472 rOppWeight(&(r->wvhdl[j][nn*(n+1)]), n /*r->block1[j]-r->block0[j]*/);
5473 }
5474 j++;
5475 break;
5476 }
5477 case ringorder_a: /* a(...),ls -> wp/dp */
5478 {
5479 r->block0[j]=rOppVar(r, src->block1[i]);
5480 r->block1[j]=rOppVar(r, src->block0[i]);
5481 rOppWeight(r->wvhdl[j], r->block1[j]-r->block0[j]);
5482 if (src->order[i+1]==ringorder_ls)
5483 {
5484 r->order[j]=ringorder_wp;
5485 i++;
5486 //l=rReallocM1(r,l,j);
5487 }
5488 else
5489 {
5490 r->order[j]=ringorder_a;
5491 }
5492 j++;
5493 break;
5494 }
5495 // not yet done:
5496 case ringorder_ls:
5497 case ringorder_rs:
5498 case ringorder_ds:
5499 case ringorder_Ds:
5500 case ringorder_ws:
5501 case ringorder_Ws:
5502 case ringorder_am:
5503 case ringorder_a64:
5504 // should not occur:
5505 case ringorder_S:
5506 case ringorder_IS:
5507 case ringorder_s:
5508 case ringorder_aa:
5509 case ringorder_L:
5510 case ringorder_unspec:
5511 Werror("order %s not (yet) supported", rSimpleOrdStr(src->order[i]));
5512 break;
5513 }
5514 }
5515 } /* end if (!rIsLPRing(src)) */
5516 if (rIsLPRing(src))
5517 {
5518 // applies to Letterplace only
5519 // Letterplace conventions: dp<->Dp, lp<->rp
5520 // Wp(v) cannot be converted since wp(v) does not encode a monomial ordering
5521 // (a(w),<) is troublesome and thus postponed
5522 for(i=0; src->order[i]!=0; i++)
5523 {
5524 switch (src->order[i])
5525 {
5526 case ringorder_c: /* c-> c */
5527 case ringorder_C: /* C-> C */
5528 case ringorder_no /*=0*/: /* end-of-block */
5529 r->order[j]=src->order[i];
5530 j++; break;
5531 case ringorder_lp: /* lp -> rp */
5532 r->order[j]=ringorder_rp;
5533 r->block0[j]=rOppVar(r, src->block1[i]);
5534 r->block1[j]=rOppVar(r, src->block0[i]);
5535 j++;break;
5536 case ringorder_rp: /* rp -> lp */
5537 r->order[j]=ringorder_lp;
5538 r->block0[j]=rOppVar(r, src->block1[i]);
5539 r->block1[j]=rOppVar(r, src->block0[i]);
5540 j++;break;
5541 case ringorder_dp: /* dp -> Dp */
5542 {
5543 r->order[j]=ringorder_Dp;
5544 r->block0[j]=rOppVar(r, src->block1[i]);
5545 r->block1[j]=rOppVar(r, src->block0[i]);
5546 j++;break;
5547 }
5548 case ringorder_Dp: /* Dp -> dp*/
5549 {
5550 r->order[j]=ringorder_dp;
5551 r->block0[j]=rOppVar(r, src->block1[i]);
5552 r->block1[j]=rOppVar(r, src->block0[i]);
5553 j++;break;
5554 }
5555 // not clear how to do:
5556 case ringorder_wp:
5557 case ringorder_Wp:
5558 case ringorder_M:
5559 case ringorder_a:
5560 // not yet done:
5561 case ringorder_ls:
5562 case ringorder_rs:
5563 case ringorder_ds:
5564 case ringorder_Ds:
5565 case ringorder_ws:
5566 case ringorder_Ws:
5567 case ringorder_am:
5568 case ringorder_a64:
5569 // should not occur:
5570 case ringorder_S:
5571 case ringorder_IS:
5572 case ringorder_s:
5573 case ringorder_aa:
5574 case ringorder_L:
5575 case ringorder_unspec:
5576 Werror("order %s not (yet) supported", rSimpleOrdStr(src->order[i]));
5577 break;
5578 }
5579 }
5580 } /* end if (rIsLPRing(src)) */
5581 rComplete(r);
5582
5583 //rChangeCurrRing(r);
5584#ifdef RDEBUG
5585 rTest(r);
5586// rWrite(r);
5587// rDebugPrint(r);
5588#endif
5589
5590#ifdef HAVE_PLURAL
5591 // now, we initialize a non-comm structure on r
5592 if (rIsPluralRing(src))
5593 {
5594// assume( currRing == r);
5595
5596 int *perm = (int *)omAlloc0((rVar(r)+1)*sizeof(int));
5597 int *par_perm = NULL;
5598 nMapFunc nMap = n_SetMap(src->cf,r->cf);
5599 int ni,nj;
5600 for(i=1; i<=r->N; i++)
5601 {
5602 perm[i] = rOppVar(r,i);
5603 }
5604
5605 matrix C = mpNew(rVar(r),rVar(r));
5606 matrix D = mpNew(rVar(r),rVar(r));
5607
5608 for (i=1; i< rVar(r); i++)
5609 {
5610 for (j=i+1; j<=rVar(r); j++)
5611 {
5612 ni = r->N +1 - i;
5613 nj = r->N +1 - j; /* i<j ==> nj < ni */
5614
5615 assume(MATELEM(src->GetNC()->C,i,j) != NULL);
5616 MATELEM(C,nj,ni) = p_PermPoly(MATELEM(src->GetNC()->C,i,j),perm,src,r, nMap,par_perm,rPar(src));
5617
5618 if(MATELEM(src->GetNC()->D,i,j) != NULL)
5619 MATELEM(D,nj,ni) = p_PermPoly(MATELEM(src->GetNC()->D,i,j),perm,src,r, nMap,par_perm,rPar(src));
5620 }
5621 }
5622
5623 id_Test((ideal)C, r);
5624 id_Test((ideal)D, r);
5625
5626 if (nc_CallPlural(C, D, NULL, NULL, r, false, false, true, r)) // no qring setup!
5627 WarnS("Error initializing non-commutative multiplication!");
5628
5629#ifdef RDEBUG
5630 rTest(r);
5631// rWrite(r);
5632// rDebugPrint(r);
5633#endif
5634
5635 assume( r->GetNC()->IsSkewConstant == src->GetNC()->IsSkewConstant);
5636
5637 omFreeSize((ADDRESS)perm,(rVar(r)+1)*sizeof(int));
5638 }
5639#endif /* HAVE_PLURAL */
5640
5641 /* now oppose the qideal for qrings */
5642 if (src->qideal != NULL)
5643 {
5644#ifdef HAVE_PLURAL
5645 r->qideal = idOppose(src, src->qideal, r); // into the currRing: r
5646#else
5647 r->qideal = id_Copy(src->qideal, r); // ?
5648#endif
5649
5650#ifdef HAVE_PLURAL
5651 if( rIsPluralRing(r) )
5652 {
5654#ifdef RDEBUG
5655 rTest(r);
5656// rWrite(r);
5657// rDebugPrint(r);
5658#endif
5659 }
5660#endif
5661 }
5662#ifdef HAVE_PLURAL
5663 if( rIsPluralRing(r) )
5664 assume( ncRingType(r) == ncRingType(src) );
5665#endif
5666 rTest(r);
5667
5668 return r;
5669}
5670
5671ring rEnvelope(ring R)
5672 /* creates an enveloping algebra of R */
5673 /* that is R^e = R \tensor_K R^opp */
5674{
5675 ring Ropp = rOpposite(R);
5676 ring Renv = NULL;
5677 int stat = rSum(R, Ropp, Renv); /* takes care of qideals */
5678 if ( stat <=0 )
5679 WarnS("Error in rEnvelope at rSum");
5680 rTest(Renv);
5681 return Renv;
5682}
5683
5684#ifdef HAVE_PLURAL
5685BOOLEAN nc_rComplete(const ring src, ring dest, bool bSetupQuotient)
5686/* returns TRUE is there were errors */
5687/* dest is actualy equals src with the different ordering */
5688/* we map src->nc correctly to dest->src */
5689/* to be executed after rComplete, before rChangeCurrRing */
5690{
5691// NOTE: Originally used only by idElimination to transfer NC structure to dest
5692// ring created by dirty hack (without nc_CallPlural)
5693 rTest(src);
5694
5695 assume(!rIsPluralRing(dest)); // destination must be a newly constructed commutative ring
5696
5697 if (!rIsPluralRing(src))
5698 {
5699 return FALSE;
5700 }
5701
5702 const int N = dest->N;
5703
5704 assume(src->N == N);
5705
5706// ring save = currRing;
5707
5708// if (dest != save)
5709// rChangeCurrRing(dest);
5710
5711 const ring srcBase = src;
5712
5713 assume( n_SetMap(srcBase->cf,dest->cf) == n_SetMap(dest->cf,dest->cf) ); // currRing is important here!
5714
5715 matrix C = mpNew(N,N); // ring independent
5716 matrix D = mpNew(N,N);
5717
5718 matrix C0 = src->GetNC()->C;
5719 matrix D0 = src->GetNC()->D;
5720
5721 // map C and D into dest
5722 for (int i = 1; i < N; i++)
5723 {
5724 for (int j = i + 1; j <= N; j++)
5725 {
5726 const number n = n_Copy(p_GetCoeff(MATELEM(C0,i,j), srcBase), srcBase->cf); // src, mapping for coeffs into currRing = dest!
5727 const poly p = p_NSet(n, dest);
5728 MATELEM(C,i,j) = p;
5729 if (MATELEM(D0,i,j) != NULL)
5730 MATELEM(D,i,j) = prCopyR(MATELEM(D0,i,j), srcBase, dest); // ?
5731 }
5732 }
5733 /* One must test C and D _only_ in r->GetNC()->basering!!! not in r!!! */
5734
5735 id_Test((ideal)C, dest);
5736 id_Test((ideal)D, dest);
5737
5738 if (nc_CallPlural(C, D, NULL, NULL, dest, bSetupQuotient, false, true, dest)) // also takes care about quotient ideal
5739 {
5740 //WarnS("Error transferring non-commutative structure");
5741 // error message should be in the interpreter interface
5742
5743 mp_Delete(&C, dest);
5744 mp_Delete(&D, dest);
5745
5746// if (currRing != save)
5747// rChangeCurrRing(save);
5748
5749 return TRUE;
5750 }
5751
5752// mp_Delete(&C, dest); // used by nc_CallPlural!
5753// mp_Delete(&D, dest);
5754
5755// if (dest != save)
5756// rChangeCurrRing(save);
5757
5758 assume(rIsPluralRing(dest));
5759 return FALSE;
5760}
5761#endif
5762
5763poly rGetVar(const int varIndex, const ring r)
5764{
5765 poly p = p_ISet(1, r);
5766 p_SetExp(p, varIndex, 1, r);
5767 p_Setm(p, r);
5768 return p;
5769}
5770
5771
5772/// TODO: rewrite somehow...
5773int n_IsParam(const number m, const ring r)
5774{
5775 assume(r != NULL);
5776 const coeffs C = r->cf;
5777 assume(C != NULL);
5778
5780
5781 const n_coeffType _filed_type = getCoeffType(C);
5782
5783 if(( _filed_type == n_algExt )||( _filed_type == n_polyExt ))
5784 return naIsParam(m, C);
5785
5786 if( _filed_type == n_transExt )
5787 return ntIsParam(m, C);
5788
5789 Werror("n_IsParam: IsParam is not to be used for (coeff_type = %d)",getCoeffType(C));
5790
5791 return 0;
5792}
5793
5794ring rPlusVar(const ring r, char *v,int left)
5795{
5796 if (r->order[2]!=0)
5797 {
5798 WerrorS("only for rings with an ordering of one block");
5799 return NULL;
5800 }
5801 int p;
5802 if((r->order[0]==ringorder_C)
5803 ||(r->order[0]==ringorder_c))
5804 p=1;
5805 else
5806 p=0;
5807 if((r->order[p]!=ringorder_dp)
5808 && (r->order[p]!=ringorder_Dp)
5809 && (r->order[p]!=ringorder_lp)
5810 && (r->order[p]!=ringorder_rp)
5811 && (r->order[p]!=ringorder_ds)
5812 && (r->order[p]!=ringorder_Ds)
5813 && (r->order[p]!=ringorder_ls))
5814 {
5815 WerrorS("ordering must be dp,Dp,lp,rp,ds,Ds or ls");
5816 return NULL;
5817 }
5818 for(int i=r->N-1;i>=0;i--)
5819 {
5820 if (strcmp(r->names[i],v)==0)
5821 {
5822 Werror("duplicate variable name >>%s<<",v);
5823 return NULL;
5824 }
5825 }
5826 ring R=rCopy0(r);
5827 char **names;
5828 #ifdef HAVE_SHIFTBBA
5829 if (rIsLPRing(r))
5830 {
5831 R->isLPring=r->isLPring+1;
5832 R->N=((r->N)/r->isLPring)+r->N;
5833 names=(char**)omAlloc(R->N*sizeof(char_ptr));
5834 if (left)
5835 {
5836 for(int b=0;b<((r->N)/r->isLPring);b++)
5837 {
5838 names[b*R->isLPring]=omStrDup(v);
5839 for(int i=R->isLPring-1;i>0;i--)
5840 names[i+b*R->isLPring]=R->names[i-1+b*r->isLPring];
5841 }
5842 }
5843 else
5844 {
5845 for(int b=0;b<((r->N)/r->isLPring);b++)
5846 {
5847 names[(b+1)*R->isLPring-1]=omStrDup(v);
5848 for(int i=R->isLPring-2;i>=0;i--)
5849 names[i+b*R->isLPring]=R->names[i+b*r->isLPring];
5850 }
5851 }
5852 }
5853 else
5854 #endif
5855 {
5856 R->N++;
5857 names=(char**)omAlloc(R->N*sizeof(char_ptr));
5858 if (left)
5859 {
5860 names[0]=omStrDup(v);
5861 for(int i=R->N-1;i>0;i--) names[i]=R->names[i-1];
5862 }
5863 else
5864 {
5865 names[R->N-1]=omStrDup(v);
5866 for(int i=R->N-2;i>=0;i--) names[i]=R->names[i];
5867 }
5868 }
5869 omFreeSize(R->names,r->N*sizeof(char_ptr));
5870 R->names=names;
5871 R->block1[p]=R->N;
5872 rComplete(R);
5873 return R;
5874}
5875
5876ring rMinusVar(const ring r, char *v)
5877{
5878 if (r->order[2]!=0)
5879 {
5880 WerrorS("only for rings with an ordering of one block");
5881 return NULL;
5882 }
5883 int p;
5884 if((r->order[0]==ringorder_C)
5885 ||(r->order[0]==ringorder_c))
5886 p=1;
5887 else
5888 p=0;
5889 if((r->order[p]!=ringorder_dp)
5890 && (r->order[p]!=ringorder_Dp)
5891 && (r->order[p]!=ringorder_lp)
5892 && (r->order[p]!=ringorder_rp)
5893 && (r->order[p]!=ringorder_ds)
5894 && (r->order[p]!=ringorder_Ds)
5895 && (r->order[p]!=ringorder_ls))
5896 {
5897 WerrorS("ordering must be dp,Dp,lp,rp,ds,Ds or ls");
5898 return NULL;
5899 }
5900 ring R=rCopy0(r);
5901 int i=R->N-1;
5902 while(i>=0)
5903 {
5904 if (strcmp(R->names[i],v)==0)
5905 {
5906 R->N--;
5907 omFree(R->names[i]);
5908 for(int j=i;j<R->N;j++) R->names[j]=R->names[j+1];
5909 R->names=(char**)omReallocSize(R->names,r->N*sizeof(char_ptr),R->N*sizeof(char_ptr));
5910 }
5911 i--;
5912 }
5913 R->block1[p]=R->N;
5914 rComplete(R,1);
5915 return R;
5916}
int sgn(const Rational &a)
Definition: GMPrat.cc:430
int naIsParam(number m, const coeffs cf)
if m == var(i)/1 => return i,
Definition: algext.cc:1106
All the auxiliary stuff.
long int64
Definition: auxiliary.h:68
static int si_max(const int a, const int b)
Definition: auxiliary.h:124
#define BIT_SIZEOF_LONG
Definition: auxiliary.h:80
int BOOLEAN
Definition: auxiliary.h:87
#define TRUE
Definition: auxiliary.h:100
#define FALSE
Definition: auxiliary.h:96
void * ADDRESS
Definition: auxiliary.h:119
int size(const CanonicalForm &f, const Variable &v)
int size ( const CanonicalForm & f, const Variable & v )
Definition: cf_ops.cc:600
const CanonicalForm CFMap CFMap & N
Definition: cfEzgcd.cc:56
int l
Definition: cfEzgcd.cc:100
int m
Definition: cfEzgcd.cc:128
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:413
static FORCE_INLINE n_coeffType getCoeffType(const coeffs r)
Returns the type of coeffs domain.
Definition: coeffs.h:422
static FORCE_INLINE coeffs nCopyCoeff(const coeffs r)
"copy" coeffs, i.e. increment ref
Definition: coeffs.h:430
static FORCE_INLINE BOOLEAN nCoeff_is_algExt(const coeffs r)
TRUE iff r represents an algebraic extension field.
Definition: coeffs.h:907
number(* nMapFunc)(number a, const coeffs src, const coeffs dst)
maps "a", which lives in src, into dst
Definition: coeffs.h:73
void nKillChar(coeffs r)
undo all initialisations
Definition: numbers.cc:568
static FORCE_INLINE BOOLEAN n_IsOne(number n, const coeffs r)
TRUE iff 'n' represents the one element.
Definition: coeffs.h:465
#define Print
Definition: emacs.cc:80
#define Warn
Definition: emacs.cc:77
#define WarnS
Definition: emacs.cc:78
#define StringAppend
Definition: emacs.cc:79
const CanonicalForm int s
Definition: facAbsFact.cc:51
CanonicalForm res
Definition: facAbsFact.cc:60
const CanonicalForm & w
Definition: facAbsFact.cc:51
const Variable & v
< [in] a sqrfree bivariate poly
Definition: facBivar.h:39
bool found
Definition: facFactorize.cc:55
for(j=0;j< factors.length();j++)
Definition: facHensel.cc:129
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 bool rIsSCA(const ring r)
Definition: nc.h:190
ideal idOppose(ring Rop_src, ideal I, const ring Rop_dst)
opposes a module I from Rop to currRing(dst)
Definition: old.gring.cc:3389
bool nc_rCopy(ring res, const ring r, bool bSetupQuotient)
Definition: old.gring.cc:3011
bool nc_SetupQuotient(ring rGR, const ring rG=NULL, bool bCopy=false)
Definition: old.gring.cc:3411
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:2690
void nc_rKill(ring r)
complete destructor
Definition: old.gring.cc:2483
#define UPMATELEM(i, j, nVar)
Definition: nc.h:36
bool sca_Force(ring rGR, int b, int e)
Definition: sca.cc:1161
void maFindPerm(char const *const *const preim_names, int preim_n, char const *const *const preim_par, int preim_p, char const *const *const names, int n, char const *const *const par, int nop, int *perm, int *par_perm, n_coeffType ch)
Definition: maps.cc:163
void mp_Delete(matrix *a, const ring r)
Definition: matpol.cc: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:93
#define OPT_REDTAIL
Definition: options.h:92
#define TEST_OPT_OLDSTD
Definition: options.h:124
#define OPT_REDTHROUGH
Definition: options.h:83
#define Sy_bit(x)
Definition: options.h:31
#define TEST_OPT_PROT
Definition: options.h:104
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:378
void p_Write(poly p, ring lmRing, ring tailRing)
Definition: polys0.cc:342
static unsigned long p_SetExp(poly p, const unsigned long e, const unsigned long iBitmask, const int VarOffset)
set a single variable exponent @Note: VarOffset encodes the position in p->exp
Definition: p_polys.h:486
static void p_Setm(poly p, const ring r)
Definition: p_polys.h:231
static long p_GetExp(const poly p, const unsigned long iBitmask, const int VarOffset)
get a single variable exponent @Note: the integer VarOffset encodes:
Definition: p_polys.h:467
static void p_Delete(poly *p, const ring r)
Definition: p_polys.h:899
void p_Write0(poly p, ring lmRing, ring tailRing)
Definition: polys0.cc:332
static long p_Totaldegree(poly p, const ring r)
Definition: p_polys.h:1505
poly prCopyR(poly p, ring src_r, ring dest_r)
Definition: prCopy.cc:34
ideal idrCopyR(ideal id, ring src_r, ring dest_r)
Definition: prCopy.cc:192
ideal idrCopyR_NoSort(ideal id, ring src_r, ring dest_r)
Definition: prCopy.cc:205
ideal idrHeadR(ideal id, ring r, ring dest_r)
Copy leading terms of id[i] via prHeeadR into dest_r.
Definition: prCopy.cc:156
void StringSetS(const char *st)
Definition: reporter.cc:128
void StringAppendS(const char *st)
Definition: reporter.cc:107
void PrintS(const char *s)
Definition: reporter.cc:284
char * StringEndS()
Definition: reporter.cc:151
void PrintLn()
Definition: reporter.cc:310
void Werror(const char *fmt,...)
Definition: reporter.cc:189
static void rSetNegWeight(ring r)
Definition: ring.cc:3347
BOOLEAN rOrd_SetCompRequiresSetm(const ring r)
return TRUE if p_SetComp requires p_Setm
Definition: ring.cc:1993
static void rO_ISSuffix(int &place, int &bitplace, int &prev_ord, long *o, int N, int *v, sro_ord *tmp_typ, int &typ_i, int sgn)
Definition: ring.cc:2479
int rSum(ring r1, ring r2, ring &sum)
Definition: ring.cc:1402
ring rAssure_TDeg(ring r, int &pos)
Definition: ring.cc:4527
void rWrite(ring r, BOOLEAN details)
Definition: ring.cc:226
ring rAssure_InducedSchreyerOrdering(const ring r, BOOLEAN complete, int sgn)
Definition: ring.cc:4850
static ring rAssure_Global(rRingOrder_t b1, rRingOrder_t b2, const ring r)
Definition: ring.cc:4804
BOOLEAN rOrder_is_WeightedOrdering(rRingOrder_t order)
Definition: ring.cc:1947
void rGetSComps(int **currComponents, long **currShiftedComponents, int *length, ring r)
Definition: ring.cc:4414
BOOLEAN rRing_ord_pure_Dp(const ring r)
Definition: ring.cc:5202
static void rNChangeSComps(int *currComponents, long *currShiftedComponents, ring r)
Definition: ring.cc:4367
ring rModifyRing_Wp(ring r, int *weights)
construct Wp, C ring
Definition: ring.cc:2945
BOOLEAN rOrder_is_DegOrdering(const rRingOrder_t order)
Definition: ring.cc:1928
BOOLEAN rHasSimpleOrderAA(ring r)
Definition: ring.cc:1962
void rSetWeightVec(ring r, int64 *wv)
Definition: ring.cc:5232
static void rSetOption(ring r)
Definition: ring.cc:3384
BOOLEAN rComplete(ring r, int force)
this needs to be called whenever a new ring is created: new fields in ring are created (like VarOffse...
Definition: ring.cc:3450
int r_IsRingVar(const char *n, char **names, int N)
Definition: ring.cc:212
#define rOppVar(R, I)
Definition: ring.cc:5278
int rGetISPos(const int p, const ring r)
Finds p^th IS ordering, and returns its position in r->typ[] returns -1 if something went wrong!...
Definition: ring.cc:5000
static void rNGetSComps(int **currComponents, long **currShiftedComponents, ring r)
Definition: ring.cc:4375
#define BITS_PER_LONG
Definition: ring.cc:40
static void rO_WDegree64(int &place, int &bitplace, int start, int end, long *o, sro_ord &ord_struct, int64 *weights)
Definition: ring.cc:2289
BOOLEAN rHasSimpleLexOrder(const ring r)
returns TRUE, if simple lp or ls ordering
Definition: ring.cc:1919
void p_SetGlobals(const ring r, BOOLEAN complete)
set all properties of a new ring - also called by rComplete
Definition: ring.cc:3415
ring rAssure_SyzComp(const ring r, BOOLEAN complete)
Definition: ring.cc:4435
BOOLEAN nc_rComplete(const ring src, ring dest, bool bSetupQuotient)
Definition: ring.cc:5685
void p_DebugPrint(poly p, const ring r)
Definition: ring.cc:4327
void rKillModifiedRing(ring r)
Definition: ring.cc:3059
BOOLEAN rRing_ord_pure_dp(const ring r)
Definition: ring.cc:5192
static void rSetVarL(ring r)
set r->VarL_Size, r->VarL_Offset, r->VarL_LowIndex
Definition: ring.cc:4027
static void rO_LexVars(int &place, int &bitplace, int start, int end, int &prev_ord, long *o, int *v, int bits, int opt_var)
Definition: ring.cc:2339
const char * rSimpleOrdStr(int ord)
Definition: ring.cc:77
BOOLEAN rOrd_is_MixedDegree_Ordering(ring r)
Definition: ring.cc:3428
static void rDBChangeSComps(int *currComponents, long *currShiftedComponents, int length, ring r)
Definition: ring.cc:4383
ring rAssure_c_dp(const ring r)
Definition: ring.cc:4990
static void rSetOutParams(ring r)
Definition: ring.cc:3080
static void rSetDegStuff(ring r)
Definition: ring.cc:3177
static void rDBGetSComps(int **currComponents, long **currShiftedComponents, int *length, ring r)
Definition: ring.cc:4393
rOrderType_t rGetOrderType(ring r)
Definition: ring.cc:1840
int rChar(ring r)
Definition: ring.cc:713
int rTypeOfMatrixOrder(const intvec *order)
Definition: ring.cc:185
VAR omBin sip_sring_bin
Definition: ring.cc:43
void rUnComplete(ring r)
Definition: ring.cc:3965
ring nc_rCreateNCcomm_rCopy(ring r)
Definition: ring.cc:719
char * char_ptr
Definition: ring.cc:42
static void rOppWeight(int *w, int l)
Definition: ring.cc:5265
static void rO_WDegree_neg(int &place, int &bitplace, int start, int end, long *o, sro_ord &ord_struct, int *weights)
Definition: ring.cc:2313
void rKillModified_Wp_Ring(ring r)
Definition: ring.cc:3069
ring rMinusVar(const ring r, char *v)
undo rPlusVar
Definition: ring.cc:5876
BOOLEAN rRing_has_CompLastBlock(const ring r)
Definition: ring.cc:5185
ring rCopy0AndAddA(const ring r, int64vec *wv64, BOOLEAN copy_qideal, BOOLEAN copy_ordering)
Definition: ring.cc:1564
static void rO_Syzcomp(int &place, int &bitplace, int &prev_ord, long *o, sro_ord &ord_struct)
Definition: ring.cc:2415
BOOLEAN rOrd_is_Totaldegree_Ordering(const ring r)
Definition: ring.cc:2013
ring rModifyRing(ring r, BOOLEAN omit_degree, BOOLEAN try_omit_comp, unsigned long exp_limit)
Definition: ring.cc:2698
ring rAssure_SyzOrder(const ring r, BOOLEAN complete)
Definition: ring.cc:4430
static void rO_TDegree(int &place, int &bitplace, int start, int end, long *o, sro_ord &ord_struct)
Definition: ring.cc:2199
ring rAssure_C_dp(const ring r)
Definition: ring.cc:4985
BOOLEAN rHasSimpleOrder(const ring r)
Definition: ring.cc:1887
int rGetMaxSyzComp(int i, const ring r)
return the max-comonent wchich has syzIndex i Assume: i<= syzIndex_limit
Definition: ring.cc:5158
BOOLEAN rSetISReference(const ring r, const ideal F, const int i, const int p)
Changes r by setting induced ordering parameters: limit and reference leading terms F belong to r,...
Definition: ring.cc:5032
char * rString(ring r)
Definition: ring.cc:673
ring rAssure_HasComp(const ring r)
Definition: ring.cc:4625
ring rCopy0(const ring r, BOOLEAN copy_qideal, BOOLEAN copy_ordering)
Definition: ring.cc:1421
static void rO_WMDegree(int &place, int &bitplace, int start, int end, long *o, sro_ord &ord_struct, int *weights)
Definition: ring.cc:2267
static void rO_Syz(int &place, int &bitplace, int &prev_ord, int syz_comp, long *o, sro_ord &ord_struct)
Definition: ring.cc:2430
BOOLEAN rHas_c_Ordering(const ring r)
Definition: ring.cc:1883
static int rRealloc1(ring r, int size, int pos)
Definition: ring.cc:5242
#define pFDeg_CASE(A)
static unsigned long rGetExpSize(unsigned long bitmask, int &bits)
Definition: ring.cc:2570
void rDebugPrint(const ring r)
Definition: ring.cc:4122
static void rCheckOrdSgn(ring r, int i)
Definition: ring.cc:3852
BOOLEAN rRing_ord_pure_lp(const ring r)
Definition: ring.cc:5212
poly rGetVar(const int varIndex, const ring r)
Definition: ring.cc:5763
ring rModifyRing_Simple(ring r, BOOLEAN ommit_degree, BOOLEAN ommit_comp, unsigned long exp_limit, BOOLEAN &simple)
Definition: ring.cc:2993
void rChangeSComps(int *currComponents, long *currShiftedComponents, int length, ring r)
Definition: ring.cc:4405
static void m_DebugPrint(const poly p, const ring R)
debug-print monomial poly/vector p, assuming that it lives in the ring R
Definition: ring.cc:4350
static unsigned long rGetDivMask(int bits)
get r->divmask depending on bits per exponent
Definition: ring.cc:4108
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:4749
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:3150
BOOLEAN rCheckIV(const intvec *iv)
Definition: ring.cc:175
rRingOrder_t rOrderName(char *ordername)
Definition: ring.cc:507
ring rOpposite(ring src)
Definition: ring.cc:5281
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:4082
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:5794
ring rAssure_CompLastBlock(ring r, BOOLEAN complete)
makes sure that c/C ordering is last ordering
Definition: ring.cc:4694
static void rO_ISPrefix(int &place, int &bitplace, int &prev_ord, long *o, int N, int *v, sro_ord &ord_struct)
Definition: ring.cc:2456
static void rO_Align(int &place, int &bitplace)
Definition: ring.cc:2188
ring rAssure_dp_S(const ring r)
Definition: ring.cc:4975
static void rO_TDegree_neg(int &place, int &bitplace, int start, int end, long *o, sro_ord &ord_struct)
Definition: ring.cc:2213
static void rSetFirstWv(ring r, int i, rRingOrder_t *order, int *block0, int *block1, int **wvhdl)
Definition: ring.cc:3118
ring rEnvelope(ring R)
Definition: ring.cc:5671
BOOLEAN rEqual(ring r1, ring r2, BOOLEAN qr)
returns TRUE, if r1 equals r2 FALSE, otherwise Equality is determined componentwise,...
Definition: ring.cc:1746
int rSumInternal(ring r1, ring r2, ring &sum, BOOLEAN vartest, BOOLEAN dp_dp)
returns -1 for not compatible, 1 for compatible (and sum) dp_dp:0: block ordering,...
Definition: ring.cc:749
void rSetSyzComp(int k, const ring r)
Definition: ring.cc:5086
static const char *const ringorder_name[]
Definition: ring.cc:47
static int sign(int x)
Definition: ring.cc:3427
static void rO_WDegree(int &place, int &bitplace, int start, int end, long *o, sro_ord &ord_struct, int *weights)
Definition: ring.cc:2227
BOOLEAN rOrd_is_WeightedDegree_Ordering(const ring r)
Definition: ring.cc:2027
int n_IsParam(const number m, const ring r)
TODO: rewrite somehow...
Definition: ring.cc:5773
int64 * rGetWeightVec(const ring r)
Definition: ring.cc:5222
static void rO_LexVars_neg(int &place, int &bitplace, int start, int end, int &prev_ord, long *o, int *v, int bits, int opt_var)
Definition: ring.cc:2376
ring rAssure_dp_C(const ring r)
Definition: ring.cc:4980
ring rCopy(ring r)
Definition: ring.cc:1731
VAR int pDBsyzComp
Definition: ring.cc:5082
BOOLEAN rDBTest(ring r, const char *fn, const int l)
Definition: ring.cc:2038
struct p_Procs_s p_Procs_s
Definition: ring.h:23
static BOOLEAN rIsPluralRing(const ring r)
we must always have this test!
Definition: ring.h:400
ro_typ ord_typ
Definition: ring.h:220
static int rBlocks(const ring r)
Definition: ring.h:568
static ring rIncRefCnt(ring r)
Definition: ring.h:837
static 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:782
#define rField_is_Ring(R)
Definition: ring.h:485
Definition: ring.h:219
ideal SCAQuotient(const ring r)
Definition: sca.h:10
static short scaLastAltVar(ring r)
Definition: sca.h:25
static short scaFirstAltVar(ring r)
Definition: sca.h:18
ideal idInit(int idsize, int rank)
initialise an ideal / module
Definition: simpleideals.cc:35
void id_Delete(ideal *h, ring r)
deletes an ideal/module/matrix
long id_RankFreeModule(ideal s, ring lmRing, ring tailRing)
return the maximal component number found in any polynomial in s
void idShow(const ideal id, const ring lmRing, const ring tailRing, const int debugPrint)
Definition: simpleideals.cc:57
ideal id_SimpleAdd(ideal h1, ideal h2, const ring R)
concat the lists h1 and h2 without zeros
#define IDELEMS(i)
Definition: simpleideals.h:23
#define id_Test(A, lR)
Definition: simpleideals.h:87
#define R
Definition: sirandom.c:27
#define A
Definition: sirandom.c:24
#define Q
Definition: sirandom.c:26
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