source: git/kernel/GBEngine/kstd1.cc @ e21795

spielwiese
Last change on this file since e21795 was e21795, checked in by Hans Schoenemann <hannes@…>, 8 years ago
moved rField_is_Ring out of loops
  • Property mode set to 100644
File size: 85.8 KB
Line 
1/****************************************
2*  Computer Algebra System SINGULAR     *
3****************************************/
4/*
5* ABSTRACT:
6*/
7
8// TODO: why the following is here instead of mod2.h???
9
10
11// define if buckets should be used
12#define MORA_USE_BUCKETS
13
14#define ADIDEBUG 0
15#define ADIDEBUG_NF 0
16#define PRE_INTEGER_CHECK 0
17
18#include <kernel/mod2.h>
19
20#include <omalloc/omalloc.h>
21
22#include <misc/options.h>
23#include <misc/intvec.h>
24
25#include <polys/weight.h>
26#include <kernel/polys.h>
27
28#include <kernel/GBEngine/kutil.h>
29#include <kernel/GBEngine/kstd1.h>
30#include <kernel/GBEngine/khstd.h>
31#include <kernel/combinatorics/stairc.h>
32//#include "cntrlc.h"
33#include <kernel/ideals.h>
34//#include "../Singular/ipid.h"
35
36//#include "ipprint.h"
37
38#ifdef HAVE_PLURAL
39#include <polys/nc/nc.h>
40#include <polys/nc/sca.h>
41#include <kernel/GBEngine/nc.h>
42#endif
43
44#include <kernel/GBEngine/kInline.h>
45
46
47/* the list of all options which give a warning by test */
48BITSET kOptions=Sy_bit(OPT_PROT)           /*  0 */
49                |Sy_bit(OPT_REDSB)         /*  1 */
50                |Sy_bit(OPT_NOT_SUGAR)     /*  3 */
51                |Sy_bit(OPT_INTERRUPT)     /*  4 */
52                |Sy_bit(OPT_SUGARCRIT)     /*  5 */
53                |Sy_bit(OPT_REDTHROUGH)
54                |Sy_bit(OPT_OLDSTD)
55                |Sy_bit(OPT_FASTHC)        /* 10 */
56                |Sy_bit(OPT_INTSTRATEGY)   /* 26 */
57                |Sy_bit(OPT_INFREDTAIL)    /* 28 */
58                |Sy_bit(OPT_NOTREGULARITY) /* 30 */
59                |Sy_bit(OPT_WEIGHTM);      /* 31 */
60
61/* the list of all options which may be used by option and test */
62/* defintion of ALL options: libpolys/misc/options.h */
63BITSET validOpts=Sy_bit(0)
64                |Sy_bit(1)
65                |Sy_bit(2) // obachman 10/00: replaced by notBucket
66                |Sy_bit(3)
67                |Sy_bit(4)
68                |Sy_bit(5)
69                |Sy_bit(6)
70//                |Sy_bit(7) obachman 11/00 tossed: 12/00 used for redThrough
71                |Sy_bit(7) // OPT_REDTHROUGH
72                |Sy_bit(8) // obachman 11/00 tossed -> motsak 2011 experimental: OPT_NO_SYZ_MINIM
73                |Sy_bit(9)
74                |Sy_bit(10)
75                |Sy_bit(11)
76                |Sy_bit(12)
77                |Sy_bit(13)
78                |Sy_bit(14)
79                |Sy_bit(15)
80                |Sy_bit(16)
81                |Sy_bit(17)
82                |Sy_bit(18)
83                |Sy_bit(19)
84//                |Sy_bit(20) obachman 11/00 tossed: 12/00 used for redOldStd
85                |Sy_bit(OPT_OLDSTD)
86                |Sy_bit(21)
87                |Sy_bit(22)
88                /*|Sy_bit(23)*/
89                /*|Sy_bit(24)*/
90                |Sy_bit(OPT_REDTAIL)
91                |Sy_bit(OPT_INTSTRATEGY)
92                |Sy_bit(27)
93                |Sy_bit(28)
94                |Sy_bit(29)
95                |Sy_bit(30)
96                |Sy_bit(31);
97
98//static BOOLEAN posInLOldFlag;
99           /*FALSE, if posInL == posInL10*/
100// returns TRUE if mora should use buckets, false otherwise
101static BOOLEAN kMoraUseBucket(kStrategy strat);
102
103static void kOptimizeLDeg(pLDegProc ldeg, kStrategy strat)
104{
105//  if (strat->ak == 0 && !rIsSyzIndexRing(currRing))
106    strat->length_pLength = TRUE;
107//  else
108//    strat->length_pLength = FALSE;
109
110  if ((ldeg == pLDeg0c /*&& !rIsSyzIndexRing(currRing)*/) ||
111      (ldeg == pLDeg0 && strat->ak == 0))
112  {
113    strat->LDegLast = TRUE;
114  }
115  else
116  {
117    strat->LDegLast = FALSE;
118  }
119}
120
121
122static int doRed (LObject* h, TObject* with,BOOLEAN intoT,kStrategy strat, bool redMoraNF)
123{
124  int ret;
125#if KDEBUG > 0
126  kTest_L(h);
127  kTest_T(with);
128#endif
129  // Hmmm ... why do we do this -- polys from T should already be normalized
130  if (!TEST_OPT_INTSTRATEGY)
131    with->pNorm();
132#ifdef KDEBUG
133  if (TEST_OPT_DEBUG)
134  {
135    PrintS("reduce ");h->wrp();PrintS(" with ");with->wrp();PrintLn();
136  }
137#endif
138  if (intoT)
139  {
140    // need to do it exacly like this: otherwise
141    // we might get errors
142    LObject L= *h;
143    L.Copy();
144    h->GetP();
145    h->length=h->pLength=pLength(h->p);
146    ret = ksReducePoly(&L, with, strat->kNoetherTail(), NULL, strat);
147    if (ret)
148    {
149      if (ret < 0) return ret;
150      if (h->tailRing != strat->tailRing)
151        h->ShallowCopyDelete(strat->tailRing,
152                             pGetShallowCopyDeleteProc(h->tailRing,
153                                                       strat->tailRing));
154    }
155    #ifdef HAVE_RINGS
156    if(redMoraNF && (rField_is_Ring(currRing)))
157      enterT_strong(*h,strat);
158    else
159    #endif
160      enterT(*h,strat);
161    *h = L;
162  }
163  else
164    ret = ksReducePoly(h, with, strat->kNoetherTail(), NULL, strat);
165#ifdef KDEBUG
166  if (TEST_OPT_DEBUG)
167  {
168    PrintS("to ");h->wrp();PrintLn();
169  }
170#endif
171  return ret;
172}
173
174int redEcart (LObject* h,kStrategy strat)
175{
176  int i,at,ei,li,ii;
177  int j = 0;
178  int pass = 0;
179  long d,reddeg;
180
181  d = h->GetpFDeg()+ h->ecart;
182  reddeg = strat->LazyDegree+d;
183  h->SetShortExpVector();
184  loop
185  {
186    j = kFindDivisibleByInT(strat, h);
187    if (j < 0)
188    {
189      if (strat->honey) h->SetLength(strat->length_pLength);
190      return 1;
191    }
192
193    ei = strat->T[j].ecart;
194    ii = j;
195
196    if (ei > h->ecart && ii < strat->tl)
197    {
198      li = strat->T[j].length;
199      // the polynomial to reduce with (up to the moment) is;
200      // pi with ecart ei and length li
201      // look for one with smaller ecart
202      i = j;
203      loop
204      {
205        /*- takes the first possible with respect to ecart -*/
206        i++;
207#if 1
208        if (i > strat->tl) break;
209        if ((strat->T[i].ecart < ei || (strat->T[i].ecart == ei &&
210                                        strat->T[i].length < li))
211            &&
212            p_LmShortDivisibleBy(strat->T[i].GetLmTailRing(), strat->sevT[i], h->GetLmTailRing(), ~h->sev, strat->tailRing))
213#else
214          j = kFindDivisibleByInT(strat, h, i);
215        if (j < 0) break;
216        i = j;
217        if (strat->T[i].ecart < ei || (strat->T[i].ecart == ei &&
218                                        strat->T[i].length < li))
219#endif
220        {
221          // the polynomial to reduce with is now
222          ii = i;
223          ei = strat->T[i].ecart;
224          if (ei <= h->ecart) break;
225          li = strat->T[i].length;
226        }
227      }
228    }
229
230    // end of search: have to reduce with pi
231    if (ei > h->ecart)
232    {
233      // It is not possible to reduce h with smaller ecart;
234      // if possible h goes to the lazy-set L,i.e
235      // if its position in L would be not the last one
236      strat->fromT = TRUE;
237      if (!TEST_OPT_REDTHROUGH && strat->Ll >= 0) /*- L is not empty -*/
238      {
239        h->SetLmCurrRing();
240        if (strat->honey && strat->posInLDependsOnLength)
241          h->SetLength(strat->length_pLength);
242        assume(h->FDeg == h->pFDeg());
243        at = strat->posInL(strat->L,strat->Ll,h,strat);
244        if (at <= strat->Ll)
245        {
246          /*- h will not become the next element to reduce -*/
247          enterL(&strat->L,&strat->Ll,&strat->Lmax,*h,at);
248#ifdef KDEBUG
249          if (TEST_OPT_DEBUG) Print(" ecart too big; -> L%d\n",at);
250#endif
251          h->Clear();
252          strat->fromT = FALSE;
253          return -1;
254        }
255      }
256    }
257
258    // now we finally can reduce
259    doRed(h,&(strat->T[ii]),strat->fromT,strat,FALSE);
260    strat->fromT=FALSE;
261
262    // are we done ???
263    if (h->IsNull())
264    {
265      assume(!rField_is_Ring(currRing));
266      if (h->lcm!=NULL) pLmFree(h->lcm);
267      h->Clear();
268      return 0;
269    }
270
271    // NO!
272    h->SetShortExpVector();
273    h->SetpFDeg();
274    if (strat->honey)
275    {
276      if (ei <= h->ecart)
277        h->ecart = d-h->GetpFDeg();
278      else
279        h->ecart = d-h->GetpFDeg()+ei-h->ecart;
280    }
281    else
282      // this has the side effect of setting h->length
283      h->ecart = h->pLDeg(strat->LDegLast) - h->GetpFDeg();
284#if 0
285    if (strat->syzComp!=0)
286    {
287      if ((strat->syzComp>0) && (h->Comp() > strat->syzComp))
288      {
289        assume(h->MinComp() > strat->syzComp);
290        if (strat->honey) h->SetLength();
291#ifdef KDEBUG
292        if (TEST_OPT_DEBUG) PrintS(" > syzComp\n");
293#endif
294        return -2;
295      }
296    }
297#endif
298    /*- try to reduce the s-polynomial -*/
299    pass++;
300    d = h->GetpFDeg()+h->ecart;
301    /*
302     *test whether the polynomial should go to the lazyset L
303     *-if the degree jumps
304     *-if the number of pre-defined reductions jumps
305     */
306    if (!TEST_OPT_REDTHROUGH && (strat->Ll >= 0)
307        && ((d >= reddeg) || (pass > strat->LazyPass)))
308    {
309      h->SetLmCurrRing();
310      if (strat->honey && strat->posInLDependsOnLength)
311        h->SetLength(strat->length_pLength);
312      assume(h->FDeg == h->pFDeg());
313      at = strat->posInL(strat->L,strat->Ll,h,strat);
314      if (at <= strat->Ll)
315      {
316        int dummy=strat->sl;
317        if (kFindDivisibleByInS(strat, &dummy, h) < 0)
318        {
319          if (strat->honey && !strat->posInLDependsOnLength)
320            h->SetLength(strat->length_pLength);
321          return 1;
322        }
323        enterL(&strat->L,&strat->Ll,&strat->Lmax,*h,at);
324#ifdef KDEBUG
325        if (TEST_OPT_DEBUG) Print(" degree jumped; ->L%d\n",at);
326#endif
327        h->Clear();
328        return -1;
329      }
330    }
331    else if ((TEST_OPT_PROT) && (strat->Ll < 0) && (d >= reddeg))
332    {
333      Print(".%ld",d);mflush();
334      reddeg = d+1;
335      if (h->pTotalDeg()+h->ecart >= (int)strat->tailRing->bitmask)
336      {
337        strat->overflow=TRUE;
338        //Print("OVERFLOW in redEcart d=%ld, max=%ld",d,strat->tailRing->bitmask);
339        h->GetP();
340        at = strat->posInL(strat->L,strat->Ll,h,strat);
341        enterL(&strat->L,&strat->Ll,&strat->Lmax,*h,at);
342        h->Clear();
343        return -1;
344      }
345    }
346  }
347}
348
349#ifdef HAVE_RINGS
350int redRiloc (LObject* h,kStrategy strat)
351{
352  int i,at,ei,li,ii;
353  int j = 0;
354  int pass = 0;
355  long d,reddeg;
356
357
358#if ADIDEBUG_NF
359  int iii;
360  PrintS("\n---------------------------- NEW REDRILOC COMPUTATION ----------------------------\n");
361  PrintS("    The pair h :\n");
362  PrintS("\n      p1 = "); p_Write(h->p1,strat->tailRing);
363  PrintS("\n      p2 = "); p_Write(h->p2,strat->tailRing);
364  PrintS("\n      p  = "); p_Write(h->p,strat->tailRing);
365  PrintS("\n    The actual reducer T is: ");
366  if(strat->tl<0)
367    {PrintS(" Empty.\n");}
368  else
369  {
370    for (iii=0;iii<=strat->tl;iii++)
371    {
372      Print("\n      T[%i] = ",iii);p_Write(strat->T[iii].p,strat->tailRing);
373    }
374  }
375#endif /* ADIDEBUG_NF */
376
377  d = h->GetpFDeg()+ h->ecart;
378  reddeg = strat->LazyDegree+d;
379  h->SetShortExpVector();
380#if ADIDEBUG_NF
381  Print("\n  Searching for a poly in T that divides h (of ecart %i) ...\n",h->ecart);
382#endif
383  loop
384  {
385    j = kFindDivisibleByInT(strat, h);
386#if ADIDEBUG_NF
387    if(j != -1)
388    {
389      ei = strat->T[j].ecart;
390      Print("\n    Found one: T[%i] of ecart %i: ",j,ei);
391      p_Write(strat->T[j].p,strat->tailRing);
392      PrintS("\n    Try to find another with smaller ecart:\n");
393    }
394    else
395    {
396      PrintS("\n    No poly in T divides h.\n");
397    }
398    //getchar();
399#endif
400    if (j < 0)
401    {
402      // over ZZ: cleanup coefficients by complete reduction with monomials
403      postReduceByMon(h, strat);
404      if(h->p == NULL)
405      {
406        if (h->lcm!=NULL) pLmDelete(h->lcm);
407        h->Clear();
408        return 0;
409      }
410      if (strat->honey) h->SetLength(strat->length_pLength);
411      if(strat->tl >= 0)
412          h->i_r1 = strat->tl;
413      else
414          h->i_r1 = -1;
415      if (h->GetLmTailRing() == NULL)
416      {
417        if (h->lcm!=NULL) pLmDelete(h->lcm);
418        h->Clear();
419        return 0;
420      }
421      return 1;
422    }
423
424    ei = strat->T[j].ecart;
425    ii = j;
426#if ADIDEBUG_NF
427    iii=ii;
428#endif
429    if (ei > h->ecart && ii < strat->tl)
430    {
431      li = strat->T[j].length;
432      // the polynomial to reduce with (up to the moment) is;
433      // pi with ecart ei and length li
434      // look for one with smaller ecart
435      i = j;
436      loop
437      {
438        /*- takes the first possible with respect to ecart -*/
439        i++;
440#if 1
441        if (i > strat->tl) break;
442        if ((strat->T[i].ecart < ei || (strat->T[i].ecart == ei &&
443                                        strat->T[i].length < li))
444            &&
445            p_LmShortDivisibleBy(strat->T[i].GetLmTailRing(), strat->sevT[i], h->GetLmTailRing(), ~h->sev, strat->tailRing)
446            &&
447            n_DivBy(h->p->coef,strat->T[i].p->coef,strat->tailRing))
448#else
449          j = kFindDivisibleByInT(strat, h, i);
450        if (j < 0) break;
451        i = j;
452        if (strat->T[i].ecart < ei || (strat->T[i].ecart == ei &&
453                                        strat->T[i].length < li))
454#endif
455        {
456          // the polynomial to reduce with is now
457          #if ADIDEBUG_NF
458          printf("\n    Intermidiate one, h.ecart = %i < ecart = %i < ei = %i: ",h->ecart,strat->T[i].ecart, ei);
459          pWrite(strat->T[i].p);
460          #endif
461          ii = i;
462          ei = strat->T[i].ecart;
463          if (ei <= h->ecart) break;
464          li = strat->T[i].length;
465        }
466      }
467
468#if ADIDEBUG_NF
469      if(iii == ii)
470      {
471        PrintS("\n    None was found.\n");
472      }
473      else
474      {
475        Print("\n    A better one (ecart = %i): T[%i] = ",ei,ii);
476        p_Write(strat->T[ii].p,strat->tailRing);
477        PrintLn();
478      }
479#endif
480    }
481
482    // end of search: have to reduce with pi
483    if (ei > h->ecart)
484    {
485      #if ADIDEBUG_NF
486      printf("\nHAD TO REDUCE WITH BIGGER ECART!!!\n");
487      #endif
488      // It is not possible to reduce h with smaller ecart;
489      // if possible h goes to the lazy-set L,i.e
490      // if its position in L would be not the last one
491      strat->fromT = TRUE;
492      if (!TEST_OPT_REDTHROUGH && strat->Ll >= 0) /*- L is not empty -*/
493      {
494        h->SetLmCurrRing();
495        if (strat->honey && strat->posInLDependsOnLength)
496          h->SetLength(strat->length_pLength);
497        assume(h->FDeg == h->pFDeg());
498        at = strat->posInL(strat->L,strat->Ll,h,strat);
499        if (at <= strat->Ll && pLmCmp(h->p, strat->L[strat->Ll].p) != 0 && !nEqual(h->p->coef, strat->L[strat->Ll].p->coef))
500        {
501          /*- h will not become the next element to reduce -*/
502          enterL(&strat->L,&strat->Ll,&strat->Lmax,*h,at);
503          #ifdef KDEBUG
504          if (TEST_OPT_DEBUG) Print(" ecart too big; -> L%d\n",at);
505          #endif
506          h->Clear();
507          strat->fromT = FALSE;
508          return -1;
509        }
510      }
511      doRed(h,&(strat->T[ii]),strat->fromT,strat,TRUE);
512    }
513    else
514    {
515      // now we finally can reduce
516      doRed(h,&(strat->T[ii]),strat->fromT,strat,FALSE);
517    }
518    strat->fromT=FALSE;
519    // are we done ???
520    if (h->IsNull())
521    {
522      #if ADIDEBUG_NF
523      printf("\nReduced to 0. Exit\n");
524      #endif
525      if (h->lcm!=NULL) pLmDelete(h->lcm);
526      h->Clear();
527      return 0;
528    }
529
530    // NO!
531    h->SetShortExpVector();
532    h->SetpFDeg();
533    if (strat->honey)
534    {
535      if (ei <= h->ecart)
536        h->ecart = d-h->GetpFDeg();
537      else
538        h->ecart = d-h->GetpFDeg()+ei-h->ecart;
539    }
540    else
541      // this has the side effect of setting h->length
542      h->ecart = h->pLDeg(strat->LDegLast) - h->GetpFDeg();
543    #if ADIDEBUG_NF
544    printf("\n  Partial Reduced (ecart %i) h = ",h->ecart);p_Write(h->p,strat->tailRing);
545    PrintLn();
546    #endif
547    /*- try to reduce the s-polynomial -*/
548    pass++;
549    d = h->GetpFDeg()+h->ecart;
550    /*
551     *test whether the polynomial should go to the lazyset L
552     *-if the degree jumps
553     *-if the number of pre-defined reductions jumps
554     */
555    if (!TEST_OPT_REDTHROUGH && (strat->Ll >= 0)
556        && ((d >= reddeg) || (pass > strat->LazyPass)))
557    {
558      h->SetLmCurrRing();
559      if (strat->honey && strat->posInLDependsOnLength)
560        h->SetLength(strat->length_pLength);
561      assume(h->FDeg == h->pFDeg());
562      at = strat->posInL(strat->L,strat->Ll,h,strat);
563      if (at <= strat->Ll)
564      {
565        int dummy=strat->sl;
566        if (kFindDivisibleByInS(strat, &dummy, h) < 0)
567        {
568          if (strat->honey && !strat->posInLDependsOnLength)
569            h->SetLength(strat->length_pLength);
570          return 1;
571        }
572        enterL(&strat->L,&strat->Ll,&strat->Lmax,*h,at);
573#ifdef KDEBUG
574        if (TEST_OPT_DEBUG) Print(" degree jumped; ->L%d\n",at);
575#endif
576        h->Clear();
577        return -1;
578      }
579    }
580    else if ((TEST_OPT_PROT) && (strat->Ll < 0) && (d >= reddeg))
581    {
582      Print(".%ld",d);mflush();
583      reddeg = d+1;
584      if (h->pTotalDeg()+h->ecart >= (int)strat->tailRing->bitmask)
585      {
586        strat->overflow=TRUE;
587        //Print("OVERFLOW in redEcart d=%ld, max=%ld",d,strat->tailRing->bitmask);
588        h->GetP();
589        at = strat->posInL(strat->L,strat->Ll,h,strat);
590        enterL(&strat->L,&strat->Ll,&strat->Lmax,*h,at);
591        h->Clear();
592        return -1;
593      }
594    }
595  }
596}
597#endif
598
599/*2
600*reduces h with elements from T choosing  the first possible
601* element in t with respect to the given pDivisibleBy
602*/
603int redFirst (LObject* h,kStrategy strat)
604{
605  if (h->IsNull()) return 0;
606
607  int at;
608  long reddeg,d;
609  int pass = 0;
610  int j = 0;
611
612  if (! strat->homog)
613  {
614    d = h->GetpFDeg() + h->ecart;
615    reddeg = strat->LazyDegree+d;
616  }
617  h->SetShortExpVector();
618  loop
619  {
620    j = kFindDivisibleByInT(strat, h);
621    if (j < 0)
622    {
623      h->SetDegStuffReturnLDeg(strat->LDegLast);
624      return 1;
625    }
626
627    if (!TEST_OPT_INTSTRATEGY)
628      strat->T[j].pNorm();
629#ifdef KDEBUG
630    if (TEST_OPT_DEBUG)
631    {
632      PrintS("reduce ");
633      h->wrp();
634      PrintS(" with ");
635      strat->T[j].wrp();
636    }
637#endif
638    ksReducePoly(h, &(strat->T[j]), strat->kNoetherTail(), NULL, strat);
639#ifdef KDEBUG
640    if (TEST_OPT_DEBUG)
641    {
642      PrintS(" to ");
643      wrp(h->p);
644      PrintLn();
645    }
646#endif
647    if (h->IsNull())
648    {
649      assume(!rField_is_Ring(currRing));
650      if (h->lcm!=NULL) pLmFree(h->lcm);
651      h->Clear();
652      return 0;
653    }
654    h->SetShortExpVector();
655
656#if 0
657    if ((strat->syzComp!=0) && !strat->honey)
658    {
659      if ((strat->syzComp>0) &&
660          (h->Comp() > strat->syzComp))
661      {
662        assume(h->MinComp() > strat->syzComp);
663#ifdef KDEBUG
664        if (TEST_OPT_DEBUG) PrintS(" > syzComp\n");
665#endif
666        if (strat->homog)
667          h->SetDegStuffReturnLDeg(strat->LDegLast);
668        return -2;
669      }
670    }
671#endif
672    if (!strat->homog)
673    {
674      if (!TEST_OPT_OLDSTD && strat->honey)
675      {
676        h->SetpFDeg();
677        if (strat->T[j].ecart <= h->ecart)
678          h->ecart = d - h->GetpFDeg();
679        else
680          h->ecart = d - h->GetpFDeg() + strat->T[j].ecart - h->ecart;
681
682        d = h->GetpFDeg() + h->ecart;
683      }
684      else
685        d = h->SetDegStuffReturnLDeg(strat->LDegLast);
686      /*- try to reduce the s-polynomial -*/
687      pass++;
688      /*
689       *test whether the polynomial should go to the lazyset L
690       *-if the degree jumps
691       *-if the number of pre-defined reductions jumps
692       */
693      if (!TEST_OPT_REDTHROUGH && (strat->Ll >= 0)
694          && ((d >= reddeg) || (pass > strat->LazyPass)))
695      {
696        h->SetLmCurrRing();
697        if (strat->posInLDependsOnLength)
698          h->SetLength(strat->length_pLength);
699        at = strat->posInL(strat->L,strat->Ll,h,strat);
700        if (at <= strat->Ll)
701        {
702          int dummy=strat->sl;
703          if (kFindDivisibleByInS(strat,&dummy, h) < 0)
704            return 1;
705          enterL(&strat->L,&strat->Ll,&strat->Lmax,*h,at);
706#ifdef KDEBUG
707          if (TEST_OPT_DEBUG) Print(" degree jumped; ->L%d\n",at);
708#endif
709          h->Clear();
710          return -1;
711        }
712      }
713      if ((TEST_OPT_PROT) && (strat->Ll < 0) && (d >= reddeg))
714      {
715        reddeg = d+1;
716        Print(".%ld",d);mflush();
717        if (h->pTotalDeg()+h->ecart >= (int)strat->tailRing->bitmask)
718        {
719          strat->overflow=TRUE;
720          //Print("OVERFLOW in redFirst d=%ld, max=%ld",d,strat->tailRing->bitmask);
721          h->GetP();
722          at = strat->posInL(strat->L,strat->Ll,h,strat);
723          enterL(&strat->L,&strat->Ll,&strat->Lmax,*h,at);
724          h->Clear();
725          return -1;
726        }
727      }
728    }
729  }
730}
731
732/*2
733* reduces h with elements from T choosing first possible
734* element in T with respect to the given ecart
735* used for computing normal forms outside kStd
736*/
737static poly redMoraNF (poly h,kStrategy strat, int flag)
738{
739  LObject H;
740  H.p = h;
741  int j = 0;
742  int z = 10;
743  int o = H.SetpFDeg();
744  H.ecart = currRing->pLDeg(H.p,&H.length,currRing)-o;
745  if ((flag & 2) == 0) cancelunit(&H,TRUE);
746  H.sev = pGetShortExpVector(H.p);
747  unsigned long not_sev = ~ H.sev;
748  loop
749  {
750    if (j > strat->tl)
751    {
752      return H.p;
753    }
754    if (TEST_V_DEG_STOP)
755    {
756      if (kModDeg(H.p)>Kstd1_deg) pLmDelete(&H.p);
757      if (H.p==NULL) return NULL;
758    }
759    if (p_LmShortDivisibleBy(strat->T[j].GetLmTailRing(), strat->sevT[j], H.GetLmTailRing(), not_sev, strat->tailRing)
760        )
761    {
762      /*- remember the found T-poly -*/
763      // poly pi = strat->T[j].p;
764      int ei = strat->T[j].ecart;
765      int li = strat->T[j].length;
766      int ii = j;
767      /*
768      * the polynomial to reduce with (up to the moment) is;
769      * pi with ecart ei and length li
770      */
771      loop
772      {
773        /*- look for a better one with respect to ecart -*/
774        /*- stop, if the ecart is small enough (<=ecart(H)) -*/
775        j++;
776        if (j > strat->tl) break;
777        if (ei <= H.ecart) break;
778        if (((strat->T[j].ecart < ei)
779          || ((strat->T[j].ecart == ei)
780        && (strat->T[j].length < li)))
781        && pLmShortDivisibleBy(strat->T[j].p,strat->sevT[j], H.p, not_sev)
782        )
783        {
784          /*
785          * the polynomial to reduce with is now;
786          */
787          // pi = strat->T[j].p;
788          ei = strat->T[j].ecart;
789          li = strat->T[j].length;
790          ii = j;
791        }
792      }
793      /*
794      * end of search: have to reduce with pi
795      */
796      z++;
797      if (z>10)
798      {
799        pNormalize(H.p);
800        z=0;
801      }
802      if ((ei > H.ecart) && (!strat->kHEdgeFound))
803      {
804        /*
805        * It is not possible to reduce h with smaller ecart;
806        * we have to reduce with bad ecart: H has to enter in T
807        */
808        doRed(&H,&(strat->T[ii]),TRUE,strat,TRUE);
809        if (H.p == NULL)
810          return NULL;
811      }
812      else
813      {
814        /*
815        * we reduce with good ecart, h need not to be put to T
816        */
817        doRed(&H,&(strat->T[ii]),FALSE,strat,TRUE);
818        if (H.p == NULL)
819          return NULL;
820      }
821      /*- try to reduce the s-polynomial -*/
822      o = H.SetpFDeg();
823      if ((flag &2 ) == 0) cancelunit(&H,TRUE);
824      H.ecart = currRing->pLDeg(H.p,&(H.length),currRing)-o;
825      j = 0;
826      H.sev = pGetShortExpVector(H.p);
827      not_sev = ~ H.sev;
828    }
829    else
830    {
831      j++;
832    }
833  }
834}
835
836#ifdef HAVE_RINGS
837static poly redMoraNFRing (poly h,kStrategy strat, int flag)
838{
839  LObject H;
840  H.p = h;
841  int j = 0;
842  int z = 10;
843  int o = H.SetpFDeg();
844  H.ecart = currRing->pLDeg(H.p,&H.length,currRing)-o;
845  if ((flag & 2) == 0) cancelunit(&H,TRUE);
846  H.sev = pGetShortExpVector(H.p);
847  unsigned long not_sev = ~ H.sev;
848  loop
849  {
850    if (j > strat->tl)
851    {
852      return H.p;
853    }
854    if (TEST_V_DEG_STOP)
855    {
856      if (kModDeg(H.p)>Kstd1_deg) pLmDelete(&H.p);
857      if (H.p==NULL) return NULL;
858    }
859    #if ADIDEBUG_NF
860    printf("\nSearching for a reducer...\n");
861    #endif
862    if (p_LmShortDivisibleBy(strat->T[j].GetLmTailRing(), strat->sevT[j], H.GetLmTailRing(), not_sev, strat->tailRing)
863        && (n_DivBy(H.p->coef, strat->T[j].p->coef,strat->tailRing))
864        )
865    {
866      /*- remember the found T-poly -*/
867      // poly pi = strat->T[j].p;
868      int ei = strat->T[j].ecart;
869      int li = strat->T[j].length;
870      int ii = j;
871      #if ADIDEBUG_NF
872      printf("\nFound: j = %i, ecart = %i\nTrying to find a better one...\n",j,ei);pWrite(strat->T[j].p);
873      #endif
874      /*
875      * the polynomial to reduce with (up to the moment) is;
876      * pi with ecart ei and length li
877      */
878      loop
879      {
880        /*- look for a better one with respect to ecart -*/
881        /*- stop, if the ecart is small enough (<=ecart(H)) -*/
882        j++;
883        if (j > strat->tl) break;
884        if (ei <= H.ecart) break;
885        if (((strat->T[j].ecart < ei)
886          || ((strat->T[j].ecart == ei)
887        && (strat->T[j].length < li)))
888        && pLmShortDivisibleBy(strat->T[j].p,strat->sevT[j], H.p, not_sev)
889        && (n_DivBy(H.p->coef, strat->T[j].p->coef,strat->tailRing))
890        )
891        {
892          /*
893          * the polynomial to reduce with is now;
894          */
895          // pi = strat->T[j].p;
896          ei = strat->T[j].ecart;
897          li = strat->T[j].length;
898          ii = j;
899          #if ADIDEBUG_NF
900          printf("\nFound a better one: j = %i, ecart = %i\nTrying to find a better one...\n",j,ei);
901          pWrite(strat->T[j].p);
902          #endif
903        }
904      }
905      /*
906      * end of search: have to reduce with pi
907      */
908      z++;
909      if (z>10)
910      {
911        pNormalize(H.p);
912        z=0;
913      }
914      if ((ei > H.ecart) && (!strat->kHEdgeFound))
915      {
916        /*
917        * It is not possible to reduce h with smaller ecart;
918        * we have to reduce with bad ecart: H has to enter in T
919        */
920        #if ADIDEBUG_NF
921        printf("\nHAVE TO REDUCE IT WITH BIGGER ECART\n");
922        #endif
923        doRed(&H,&(strat->T[ii]),TRUE,strat,TRUE);
924        if (H.p == NULL)
925          return NULL;
926      }
927      else
928      {
929        /*
930        * we reduce with good ecart, h need not to be put to T
931        */
932        doRed(&H,&(strat->T[ii]),FALSE,strat,TRUE);
933        if (H.p == NULL)
934          return NULL;
935      }
936      #if ADIDEBUG_NF
937      printf("\nAfter the small reduction it looks like this:\n");pWrite(H.p);
938      getchar();
939      #endif
940      /*- try to reduce the s-polynomial -*/
941      o = H.SetpFDeg();
942      if ((flag &2 ) == 0) cancelunit(&H,TRUE);
943      H.ecart = currRing->pLDeg(H.p,&(H.length),currRing)-o;
944      j = 0;
945      H.sev = pGetShortExpVector(H.p);
946      not_sev = ~ H.sev;
947    }
948    else
949    {
950      j++;
951    }
952  }
953}
954#endif
955
956/*2
957*reorders  L with respect to posInL
958*/
959void reorderL(kStrategy strat)
960{
961  int i,j,at;
962  LObject p;
963
964  for (i=1; i<=strat->Ll; i++)
965  {
966    at = strat->posInL(strat->L,i-1,&(strat->L[i]),strat);
967    if (at != i)
968    {
969      p = strat->L[i];
970      for (j=i-1; j>=at; j--) strat->L[j+1] = strat->L[j];
971      strat->L[at] = p;
972    }
973  }
974}
975
976/*2
977*reorders  T with respect to length
978*/
979void reorderT(kStrategy strat)
980{
981  int i,j,at;
982  TObject p;
983  unsigned long sev;
984
985
986  for (i=1; i<=strat->tl; i++)
987  {
988    if (strat->T[i-1].length > strat->T[i].length)
989    {
990      p = strat->T[i];
991      sev = strat->sevT[i];
992      at = i-1;
993      loop
994      {
995        at--;
996        if (at < 0) break;
997        if (strat->T[i].length > strat->T[at].length) break;
998      }
999      for (j = i-1; j>at; j--)
1000      {
1001        strat->T[j+1]=strat->T[j];
1002        strat->sevT[j+1]=strat->sevT[j];
1003        strat->R[strat->T[j+1].i_r] = &(strat->T[j+1]);
1004      }
1005      strat->T[at+1]=p;
1006      strat->sevT[at+1] = sev;
1007      strat->R[p.i_r] = &(strat->T[at+1]);
1008    }
1009  }
1010}
1011
1012/*2
1013*looks whether exactly (currRing->N)-1 axis are used
1014*returns last != 0 in this case
1015*last is the (first) unused axis
1016*/
1017void missingAxis (int* last,kStrategy strat)
1018{
1019  int   i = 0;
1020  int   k = 0;
1021
1022  *last = 0;
1023  if (!currRing->MixedOrder)
1024  {
1025    loop
1026    {
1027      i++;
1028      if (i > (currRing->N)) break;
1029      if (strat->NotUsedAxis[i])
1030      {
1031        *last = i;
1032        k++;
1033      }
1034      if (k>1)
1035      {
1036        *last = 0;
1037        break;
1038      }
1039    }
1040  }
1041}
1042
1043/*2
1044*last is the only non used axis, it looks
1045*for a monomial in p being a pure power of this
1046*variable and returns TRUE in this case
1047*(*length) gives the length between the pure power and the leading term
1048*(should be minimal)
1049*/
1050BOOLEAN hasPurePower (const poly p,int last, int *length,kStrategy strat)
1051{
1052  poly h;
1053  int i;
1054
1055  if (pNext(p) == strat->tail)
1056    return FALSE;
1057  pp_Test(p, currRing, strat->tailRing);
1058  if (strat->ak <= 0 || p_MinComp(p, currRing, strat->tailRing) == strat->ak)
1059  {
1060    i = p_IsPurePower(p, currRing);
1061    if (rField_is_Ring(currRing) && (!n_IsUnit(pGetCoeff(p), currRing->cf))) i=0;
1062    if (i == last)
1063    {
1064      *length = 0;
1065      return TRUE;
1066    }
1067    *length = 1;
1068    h = pNext(p);
1069    while (h != NULL)
1070    {
1071      i = p_IsPurePower(h, strat->tailRing);
1072      if (rField_is_Ring(currRing) && (!n_IsUnit(pGetCoeff(h), currRing->cf))) i=0;
1073      if (i==last) return TRUE;
1074      (*length)++;
1075      pIter(h);
1076    }
1077  }
1078  return FALSE;
1079}
1080
1081BOOLEAN hasPurePower (LObject *L,int last, int *length,kStrategy strat)
1082{
1083  if (L->bucket != NULL)
1084  {
1085    poly p = L->CanonicalizeP();
1086    BOOLEAN ret = hasPurePower(p, last, length, strat);
1087    pNext(p) = NULL;
1088    return ret;
1089  }
1090  else
1091  {
1092    return hasPurePower(L->p, last, length, strat);
1093  }
1094}
1095
1096/*2
1097* looks up the position of polynomial p in L
1098* in the case of looking for the pure powers
1099*/
1100int posInL10 (const LSet set,const int length, LObject* p,const kStrategy strat)
1101{
1102  int j,dp,dL;
1103
1104  if (length<0) return 0;
1105  if (hasPurePower(p,strat->lastAxis,&dp,strat))
1106  {
1107    int op= p->GetpFDeg() +p->ecart;
1108    for (j=length; j>=0; j--)
1109    {
1110      if (!hasPurePower(&(set[j]),strat->lastAxis,&dL,strat))
1111        return j+1;
1112      if (dp < dL)
1113        return j+1;
1114      if ((dp == dL)
1115          && (set[j].GetpFDeg()+set[j].ecart >= op))
1116        return j+1;
1117    }
1118  }
1119  j=length;
1120  loop
1121  {
1122    if (j<0) break;
1123    if (!hasPurePower(&(set[j]),strat->lastAxis,&dL,strat)) break;
1124    j--;
1125  }
1126  return strat->posInLOld(set,j,p,strat);
1127}
1128
1129
1130/*2
1131* computes the s-polynomials L[ ].p in L
1132*/
1133void updateL(kStrategy strat)
1134{
1135  LObject p;
1136  int dL;
1137  int j=strat->Ll;
1138  loop
1139  {
1140    if (j<0) break;
1141    if (hasPurePower(&(strat->L[j]),strat->lastAxis,&dL,strat))
1142    {
1143      p=strat->L[strat->Ll];
1144      strat->L[strat->Ll]=strat->L[j];
1145      strat->L[j]=p;
1146      break;
1147    }
1148    j--;
1149  }
1150  if (j<0)
1151  {
1152    j=strat->Ll;
1153    loop
1154    {
1155      if (j<0) break;
1156      if (pNext(strat->L[j].p) == strat->tail)
1157      {
1158#ifdef HAVE_RINGS
1159        if (rField_is_Ring(currRing))
1160          pLmDelete(strat->L[j].p);    /*deletes the short spoly and computes*/
1161        else
1162#else
1163          pLmFree(strat->L[j].p);    /*deletes the short spoly and computes*/
1164#endif
1165        strat->L[j].p = NULL;
1166        poly m1 = NULL, m2 = NULL;
1167        // check that spoly creation is ok
1168        while (strat->tailRing != currRing &&
1169               !kCheckSpolyCreation(&(strat->L[j]), strat, m1, m2))
1170        {
1171          assume(m1 == NULL && m2 == NULL);
1172          // if not, change to a ring where exponents are at least
1173          // large enough
1174          kStratChangeTailRing(strat);
1175        }
1176        /* create the real one */
1177        ksCreateSpoly(&(strat->L[j]), strat->kNoetherTail(), FALSE,
1178                      strat->tailRing, m1, m2, strat->R);
1179
1180        strat->L[j].SetLmCurrRing();
1181        if (!strat->honey)
1182          strat->initEcart(&strat->L[j]);
1183        else
1184          strat->L[j].SetLength(strat->length_pLength);
1185
1186        BOOLEAN pp = hasPurePower(&(strat->L[j]),strat->lastAxis,&dL,strat);
1187
1188        if (strat->use_buckets) strat->L[j].PrepareRed(TRUE);
1189
1190        if (pp)
1191        {
1192          p=strat->L[strat->Ll];
1193          strat->L[strat->Ll]=strat->L[j];
1194          strat->L[j]=p;
1195          break;
1196        }
1197      }
1198      j--;
1199    }
1200  }
1201}
1202
1203/*2
1204* computes the s-polynomials L[ ].p in L and
1205* cuts elements in L above noether
1206*/
1207void updateLHC(kStrategy strat)
1208{
1209
1210  int i = 0;
1211  kTest_TS(strat);
1212  while (i <= strat->Ll)
1213  {
1214    if (pNext(strat->L[i].p) == strat->tail)
1215    {
1216       /*- deletes the int spoly and computes -*/
1217      if (pLmCmp(strat->L[i].p,strat->kNoether) == -1)
1218      {
1219        #ifdef HAVE_RINGS
1220        if (rField_is_Ring(currRing))
1221          pLmDelete(strat->L[i].p);
1222        else
1223        #endif
1224          pLmFree(strat->L[i].p);
1225        strat->L[i].p = NULL;
1226      }
1227      else
1228      {
1229        #ifdef HAVE_RINGS
1230        if (rField_is_Ring(currRing))
1231          pLmDelete(strat->L[i].p);
1232        else
1233        #endif
1234          pLmFree(strat->L[i].p);
1235        strat->L[i].p = NULL;
1236        poly m1 = NULL, m2 = NULL;
1237        // check that spoly creation is ok
1238        while (strat->tailRing != currRing &&
1239               !kCheckSpolyCreation(&(strat->L[i]), strat, m1, m2))
1240        {
1241          assume(m1 == NULL && m2 == NULL);
1242          // if not, change to a ring where exponents are at least
1243          // large enough
1244          kStratChangeTailRing(strat);
1245        }
1246        /* create the real one */
1247        ksCreateSpoly(&(strat->L[i]), strat->kNoetherTail(), FALSE,
1248                      strat->tailRing, m1, m2, strat->R);
1249        if (! strat->L[i].IsNull())
1250        {
1251          strat->L[i].SetLmCurrRing();
1252          strat->L[i].SetpFDeg();
1253          strat->L[i].ecart
1254            = strat->L[i].pLDeg(strat->LDegLast) - strat->L[i].GetpFDeg();
1255          if (strat->use_buckets) strat->L[i].PrepareRed(TRUE);
1256        }
1257      }
1258    }
1259    else
1260      deleteHC(&(strat->L[i]), strat);
1261    if (strat->L[i].IsNull())
1262      deleteInL(strat->L,&strat->Ll,i,strat);
1263    else
1264    {
1265#ifdef KDEBUG
1266      kTest_L(&(strat->L[i]), strat->tailRing, TRUE, i, strat->T, strat->tl);
1267#endif
1268      i++;
1269    }
1270  }
1271  kTest_TS(strat);
1272}
1273
1274/*2
1275* cuts in T above strat->kNoether and tries to cancel a unit
1276* changes also S as S is a subset of T
1277*/
1278void updateT(kStrategy strat)
1279{
1280  int i = 0;
1281  LObject p;
1282
1283  while (i <= strat->tl)
1284  {
1285    p = strat->T[i];
1286    deleteHC(&p,strat, TRUE);
1287    /*- tries to cancel a unit: -*/
1288    cancelunit(&p);
1289    if (TEST_OPT_INTSTRATEGY) /* deleteHC and/or cancelunit may have changed p*/
1290      p.pCleardenom();
1291    if (p.p != strat->T[i].p)
1292    {
1293      strat->sevT[i] = pGetShortExpVector(p.p);
1294      p.SetpFDeg();
1295    }
1296    strat->T[i] = p;
1297    i++;
1298  }
1299}
1300
1301/*2
1302* arranges red, pos and T if strat->kHEdgeFound (first time)
1303*/
1304void firstUpdate(kStrategy strat)
1305{
1306  if (strat->update)
1307  {
1308    kTest_TS(strat);
1309    strat->update = (strat->tl == -1);
1310    if (TEST_OPT_WEIGHTM)
1311    {
1312      pRestoreDegProcs(currRing,strat->pOrigFDeg, strat->pOrigLDeg);
1313      if (strat->tailRing != currRing)
1314      {
1315        strat->tailRing->pFDeg = strat->pOrigFDeg_TailRing;
1316        strat->tailRing->pLDeg = strat->pOrigLDeg_TailRing;
1317      }
1318      int i;
1319      for (i=strat->Ll; i>=0; i--)
1320      {
1321        strat->L[i].SetpFDeg();
1322      }
1323      for (i=strat->tl; i>=0; i--)
1324      {
1325        strat->T[i].SetpFDeg();
1326      }
1327      if (ecartWeights)
1328      {
1329        omFreeSize((ADDRESS)ecartWeights,(rVar(currRing)+1)*sizeof(short));
1330        ecartWeights=NULL;
1331      }
1332    }
1333    if (TEST_OPT_FASTHC)
1334    {
1335      strat->posInL = strat->posInLOld;
1336      strat->lastAxis = 0;
1337    }
1338    if (TEST_OPT_FINDET)
1339      return;
1340
1341#ifdef HAVE_RINGS
1342    if ( (!rField_is_Ring(currRing)) || (rHasGlobalOrdering(currRing)))
1343#endif
1344    {
1345      strat->red = redFirst;
1346      strat->use_buckets = kMoraUseBucket(strat);
1347    }
1348    updateT(strat);
1349
1350#ifdef HAVE_RINGS
1351    if ( (!rField_is_Ring(currRing)) || (rHasGlobalOrdering(currRing)))
1352#endif
1353    {
1354      strat->posInT = posInT2;
1355      reorderT(strat);
1356    }
1357  }
1358  kTest_TS(strat);
1359}
1360
1361/*2
1362*-puts p to the standardbasis s at position at
1363*-reduces the tail of p if TEST_OPT_REDTAIL
1364*-tries to cancel a unit
1365*-HEckeTest
1366*  if TRUE
1367*  - decides about reduction-strategies
1368*  - computes noether
1369*  - stops computation if TEST_OPT_FINDET
1370*  - cuts the tails of the polynomials
1371*    in s,t and the elements in L above noether
1372*    and cancels units if possible
1373*  - reorders s,L
1374*/
1375void enterSMora (LObject &p,int atS,kStrategy strat, int atR = -1)
1376{
1377  enterSBba(p, atS, strat, atR);
1378  #ifdef KDEBUG
1379  if (TEST_OPT_DEBUG)
1380  {
1381    Print("new s%d:",atS);
1382    p_wrp(p.p,currRing,strat->tailRing);
1383    PrintLn();
1384  }
1385  #endif
1386  if ((!strat->kHEdgeFound) || (strat->kNoether!=NULL)) HEckeTest(p.p,strat);
1387  if (strat->kHEdgeFound)
1388  {
1389    if (newHEdge(strat))
1390    {
1391      firstUpdate(strat);
1392      if (TEST_OPT_FINDET)
1393        return;
1394
1395      /*- cuts elements in L above noether and reorders L -*/
1396      updateLHC(strat);
1397      /*- reorders L with respect to posInL -*/
1398      reorderL(strat);
1399    }
1400  }
1401  else if (strat->kNoether!=NULL)
1402    strat->kHEdgeFound = TRUE;
1403  else if (TEST_OPT_FASTHC)
1404  {
1405    if (strat->posInLOldFlag)
1406    {
1407      missingAxis(&strat->lastAxis,strat);
1408      if (strat->lastAxis)
1409      {
1410        strat->posInLOld = strat->posInL;
1411        strat->posInLOldFlag = FALSE;
1412        strat->posInL = posInL10;
1413        strat->posInLDependsOnLength = TRUE;
1414        updateL(strat);
1415        reorderL(strat);
1416      }
1417    }
1418    else if (strat->lastAxis)
1419      updateL(strat);
1420  }
1421}
1422
1423/*2
1424*-puts p to the standardbasis s at position at
1425*-HEckeTest
1426*  if TRUE
1427*  - computes noether
1428*/
1429void enterSMoraNF (LObject &p, int atS,kStrategy strat, int atR = -1)
1430{
1431  enterSBba(p, atS, strat, atR);
1432  if ((!strat->kHEdgeFound) || (strat->kNoether!=NULL)) HEckeTest(p.p,strat);
1433  if (strat->kHEdgeFound)
1434    newHEdge(strat);
1435  else if (strat->kNoether!=NULL)
1436    strat->kHEdgeFound = TRUE;
1437}
1438
1439void initBba(kStrategy strat)
1440{
1441 /* setting global variables ------------------- */
1442  strat->enterS = enterSBba;
1443    strat->red = redHoney;
1444  if (strat->honey)
1445    strat->red = redHoney;
1446  else if (currRing->pLexOrder && !strat->homog)
1447    strat->red = redLazy;
1448  else
1449  {
1450    strat->LazyPass *=4;
1451    strat->red = redHomog;
1452  }
1453#ifdef HAVE_RINGS  //TODO Oliver
1454  if (rField_is_Ring(currRing))
1455  {
1456    strat->red = redRing;
1457  }
1458#endif
1459  if (currRing->pLexOrder && strat->honey)
1460    strat->initEcart = initEcartNormal;
1461  else
1462    strat->initEcart = initEcartBBA;
1463  if (strat->honey)
1464    strat->initEcartPair = initEcartPairMora;
1465  else
1466    strat->initEcartPair = initEcartPairBba;
1467//  if ((TEST_OPT_WEIGHTM)&&(F!=NULL))
1468//  {
1469//    //interred  machen   Aenderung
1470//    strat->pOrigFDeg=pFDeg;
1471//    strat->pOrigLDeg=pLDeg;
1472//    //h=ggetid("ecart");
1473//    //if ((h!=NULL) /*&& (IDTYP(h)==INTVEC_CMD)*/)
1474//    //{
1475//    //  ecartWeights=iv2array(IDINTVEC(h));
1476//    //}
1477//    //else
1478//    {
1479//      ecartWeights=(short *)omAlloc(((currRing->N)+1)*sizeof(short));
1480//      /*uses automatic computation of the ecartWeights to set them*/
1481//      kEcartWeights(F->m,IDELEMS(F)-1,ecartWeights);
1482//    }
1483//    pRestoreDegProcs(currRing,totaldegreeWecart, maxdegreeWecart);
1484//    if (TEST_OPT_PROT)
1485//    {
1486//      for(i=1; i<=(currRing->N); i++)
1487//        Print(" %d",ecartWeights[i]);
1488//      PrintLn();
1489//      mflush();
1490//    }
1491//  }
1492}
1493
1494void initSba(ideal F,kStrategy strat)
1495{
1496  int i;
1497  //idhdl h;
1498 /* setting global variables ------------------- */
1499  strat->enterS = enterSSba;
1500    strat->red2 = redHoney;
1501  if (strat->honey)
1502    strat->red2 = redHoney;
1503  else if (currRing->pLexOrder && !strat->homog)
1504    strat->red2 = redLazy;
1505  else
1506  {
1507    strat->LazyPass *=4;
1508    strat->red2 = redHomog;
1509  }
1510#if defined(HAVE_RINGS)
1511  if (rField_is_Ring(currRing))
1512  {
1513    if(rHasLocalOrMixedOrdering(currRing))
1514      {strat->red = redRiloc;}
1515    else
1516      {strat->red2 = redRing;}
1517  }
1518#endif
1519  if (currRing->pLexOrder && strat->honey)
1520    strat->initEcart = initEcartNormal;
1521  else
1522    strat->initEcart = initEcartBBA;
1523  if (strat->honey)
1524    strat->initEcartPair = initEcartPairMora;
1525  else
1526    strat->initEcartPair = initEcartPairBba;
1527  //strat->kIdeal = NULL;
1528  //if (strat->ak==0) strat->kIdeal->rtyp=IDEAL_CMD;
1529  //else              strat->kIdeal->rtyp=MODUL_CMD;
1530  //strat->kIdeal->data=(void *)strat->Shdl;
1531  if ((TEST_OPT_WEIGHTM)&&(F!=NULL))
1532  {
1533    //interred  machen   Aenderung
1534    strat->pOrigFDeg  = currRing->pFDeg;
1535    strat->pOrigLDeg  = currRing->pLDeg;
1536    //h=ggetid("ecart");
1537    //if ((h!=NULL) /*&& (IDTYP(h)==INTVEC_CMD)*/)
1538    //{
1539    //  ecartWeights=iv2array(IDINTVEC(h));
1540    //}
1541    //else
1542    {
1543      ecartWeights=(short *)omAlloc(((currRing->N)+1)*sizeof(short));
1544      /*uses automatic computation of the ecartWeights to set them*/
1545      kEcartWeights(F->m,IDELEMS(F)-1,ecartWeights, currRing);
1546    }
1547    pRestoreDegProcs(currRing, totaldegreeWecart, maxdegreeWecart);
1548    if (TEST_OPT_PROT)
1549    {
1550      for(i=1; i<=(currRing->N); i++)
1551        Print(" %d",ecartWeights[i]);
1552      PrintLn();
1553      mflush();
1554    }
1555  }
1556  // for sig-safe reductions in signature-based
1557  // standard basis computations
1558  strat->red          = redSig;
1559  //strat->sbaOrder  = 1;
1560  strat->currIdx      = 1;
1561}
1562
1563void initMora(ideal F,kStrategy strat)
1564{
1565  int i,j;
1566
1567  strat->NotUsedAxis = (BOOLEAN *)omAlloc(((currRing->N)+1)*sizeof(BOOLEAN));
1568  for (j=(currRing->N); j>0; j--) strat->NotUsedAxis[j] = TRUE;
1569  strat->enterS = enterSMora;
1570  strat->initEcartPair = initEcartPairMora; /*- ecart approximation -*/
1571  strat->posInLOld = strat->posInL;
1572  strat->posInLOldFlag = TRUE;
1573  strat->initEcart = initEcartNormal;
1574  strat->kHEdgeFound = (currRing->ppNoether) != NULL;
1575  if ( strat->kHEdgeFound )
1576     strat->kNoether = pCopy((currRing->ppNoether));
1577  else if (strat->kHEdgeFound || strat->homog)
1578    strat->red = redFirst;  /*take the first possible in T*/
1579  else
1580    strat->red = redEcart;/*take the first possible in under ecart-restriction*/
1581  if (strat->kHEdgeFound)
1582  {
1583    strat->HCord = currRing->pFDeg((currRing->ppNoether),currRing)+1;
1584    strat->posInT = posInT2;
1585  }
1586  else
1587  {
1588    strat->HCord = 32000;/*- very large -*/
1589  }
1590
1591#ifdef HAVE_RINGS
1592  if (rField_is_Ring(currRing))
1593    strat->red = redRiloc;
1594#endif
1595
1596  /*reads the ecartWeights used for Graebes method from the
1597   *intvec ecart and set ecartWeights
1598   */
1599  if ((TEST_OPT_WEIGHTM)&&(F!=NULL))
1600  {
1601    //interred  machen   Aenderung
1602    strat->pOrigFDeg=currRing->pFDeg;
1603    strat->pOrigLDeg=currRing->pLDeg;
1604    ecartWeights=(short *)omAlloc(((currRing->N)+1)*sizeof(short));
1605    /*uses automatic computation of the ecartWeights to set them*/
1606    kEcartWeights(F->m,IDELEMS(F)-1,ecartWeights,currRing);
1607
1608    pSetDegProcs(currRing,totaldegreeWecart, maxdegreeWecart);
1609    if (TEST_OPT_PROT)
1610    {
1611      for(i=1; i<=(currRing->N); i++)
1612        Print(" %d",ecartWeights[i]);
1613      PrintLn();
1614      mflush();
1615    }
1616  }
1617  kOptimizeLDeg(currRing->pLDeg, strat);
1618}
1619
1620void kDebugPrint(kStrategy strat);
1621
1622ideal mora (ideal F, ideal Q,intvec *w,intvec *hilb,kStrategy strat)
1623{
1624#ifdef HAVE_RINGS
1625#if ADIDEBUG
1626int loop_count;
1627loop_count = 1;
1628#endif
1629#endif
1630  int olddeg = 0;
1631  int reduc = 0;
1632  int red_result = 1;
1633  int hilbeledeg=1,hilbcount=0;
1634  BITSET save1;
1635  SI_SAVE_OPT1(save1);
1636  if (currRing->MixedOrder)
1637  {
1638    si_opt_1 &= ~Sy_bit(OPT_REDSB);
1639    si_opt_1 &= ~Sy_bit(OPT_REDTAIL);
1640  }
1641
1642  strat->update = TRUE;
1643  /*- setting global variables ------------------- -*/
1644  initBuchMoraCrit(strat);
1645  initHilbCrit(F,Q,&hilb,strat);
1646  initMora(F,strat);
1647  if(rField_is_Ring(currRing))
1648    initBuchMoraPosRing(strat);
1649  else
1650    initBuchMoraPos(strat);
1651  /*Shdl=*/initBuchMora(F,Q,strat);
1652  if (TEST_OPT_FASTHC) missingAxis(&strat->lastAxis,strat);
1653  /*updateS in initBuchMora has Hecketest
1654  * and could have put strat->kHEdgdeFound FALSE*/
1655  if ((currRing->ppNoether)!=NULL)
1656  {
1657    strat->kHEdgeFound = TRUE;
1658  }
1659  if (strat->kHEdgeFound && strat->update)
1660  {
1661    firstUpdate(strat);
1662    updateLHC(strat);
1663    reorderL(strat);
1664  }
1665  if (TEST_OPT_FASTHC && (strat->lastAxis) && strat->posInLOldFlag)
1666  {
1667    strat->posInLOld = strat->posInL;
1668    strat->posInLOldFlag = FALSE;
1669    strat->posInL = posInL10;
1670    updateL(strat);
1671    reorderL(strat);
1672  }
1673  kTest_TS(strat);
1674  strat->use_buckets = kMoraUseBucket(strat);
1675
1676#ifdef HAVE_TAIL_RING
1677  if (strat->homog && strat->red == redFirst)
1678    if(!idIs0(F) &&(!rField_is_Ring(currRing)))
1679      kStratInitChangeTailRing(strat);
1680#endif
1681
1682  if (BVERBOSE(23))
1683  {
1684    kDebugPrint(strat);
1685  }
1686
1687  /*- compute-------------------------------------------*/
1688  while (strat->Ll >= 0)
1689  {
1690    #if ADIDEBUG
1691    printf("\n      ------------------------NEW LOOP\n");
1692    printf("\nShdl = \n");
1693    for(int iii = 0; iii<= strat->sl; iii++)
1694    {
1695        printf("S[%i]:",iii);
1696        p_Write(strat->S[iii], strat->tailRing);
1697    }
1698    printf("\n   list   L has %i\n", strat->Ll);
1699    int iii;
1700    #if ADIDEBUG
1701    for(iii = 0; iii<= strat->Ll; iii++)
1702    {
1703        printf("L[%i]:",iii);
1704        pWrite(strat->L[iii].p);
1705        pWrite(strat->L[iii].p1);
1706        pWrite(strat->L[iii].p2);
1707    }
1708    #endif
1709    getchar();
1710    #endif
1711    #ifdef KDEBUG
1712    if (TEST_OPT_DEBUG) messageSets(strat);
1713    #endif
1714    if (TEST_OPT_DEGBOUND
1715    && (strat->L[strat->Ll].ecart+strat->L[strat->Ll].GetpFDeg()> Kstd1_deg))
1716    {
1717      /*
1718      * stops computation if
1719      * - 24 (degBound)
1720      *   && upper degree is bigger than Kstd1_deg
1721      */
1722      while ((strat->Ll >= 0)
1723        && (strat->L[strat->Ll].p1!=NULL) && (strat->L[strat->Ll].p2!=NULL)
1724        && (strat->L[strat->Ll].ecart+strat->L[strat->Ll].GetpFDeg()> Kstd1_deg)
1725      )
1726      {
1727        deleteInL(strat->L,&strat->Ll,strat->Ll,strat);
1728        //if (TEST_OPT_PROT)
1729        //{
1730        //   PrintS("D"); mflush();
1731        //}
1732      }
1733      if (strat->Ll<0) break;
1734      else strat->noClearS=TRUE;
1735    }
1736    strat->P = strat->L[strat->Ll];/*- picks the last element from the lazyset L -*/
1737    if (strat->Ll==0) strat->interpt=TRUE;
1738    strat->Ll--;
1739    // create the real Spoly
1740    if (pNext(strat->P.p) == strat->tail)
1741    {
1742      /*- deletes the short spoly and computes -*/
1743#ifdef HAVE_RINGS
1744      if (rField_is_Ring(currRing))
1745        pLmDelete(strat->P.p);
1746      else
1747#endif
1748      pLmFree(strat->P.p);
1749      strat->P.p = NULL;
1750      poly m1 = NULL, m2 = NULL;
1751      // check that spoly creation is ok
1752      while (strat->tailRing != currRing &&
1753             !kCheckSpolyCreation(&(strat->P), strat, m1, m2))
1754      {
1755        assume(m1 == NULL && m2 == NULL);
1756        // if not, change to a ring where exponents are large enough
1757        kStratChangeTailRing(strat);
1758      }
1759      /* create the real one */
1760      ksCreateSpoly(&(strat->P), strat->kNoetherTail(), strat->use_buckets,
1761                    strat->tailRing, m1, m2, strat->R);
1762      if (!strat->use_buckets)
1763        strat->P.SetLength(strat->length_pLength);
1764    }
1765    else if (strat->P.p1 == NULL)
1766    {
1767      // for input polys, prepare reduction (buckets !)
1768      strat->P.SetLength(strat->length_pLength);
1769      strat->P.PrepareRed(strat->use_buckets);
1770    }
1771
1772    // the s-poly
1773    if (!strat->P.IsNull())
1774    {
1775      // might be NULL from noether !!!
1776      if (TEST_OPT_PROT)
1777        message(strat->P.ecart+strat->P.GetpFDeg(),&olddeg,&reduc,strat, red_result);
1778      // reduce
1779      #if ADIDEBUG
1780      printf("\nThis is P vor red:\n");p_Write(strat->P.p,strat->tailRing);p_Write(strat->P.p1,strat->tailRing);p_Write(strat->P.p2,strat->tailRing);
1781      printf("\nBefore Ll = %i\n", strat->Ll);
1782      #endif
1783      #ifdef HAVE_RINGS
1784      if(rField_is_Ring(strat->tailRing) && rHasLocalOrMixedOrdering(currRing))
1785      {
1786        red_result = strat->red(&strat->P,strat);
1787      }
1788      else
1789      #endif
1790        red_result = strat->red(&strat->P,strat);
1791      #if ADIDEBUG
1792      printf("\nThis is P nach red:\n");p_Write(strat->P.p,strat->tailRing);p_Write(strat->P.p1,strat->tailRing);p_Write(strat->P.p2,strat->tailRing);
1793      printf("\nAfter Ll = %i\n", strat->Ll);
1794      #endif
1795    }
1796
1797    // the reduced s-poly
1798    if (! strat->P.IsNull())
1799    {
1800      strat->P.GetP();
1801      // statistics
1802      if (TEST_OPT_PROT) PrintS("s");
1803      // normalization
1804      if (TEST_OPT_INTSTRATEGY)
1805        strat->P.pCleardenom();
1806      else
1807        strat->P.pNorm();
1808      // tailreduction
1809      strat->P.p = redtail(&(strat->P),strat->sl,strat);
1810      if (strat->P.p==NULL)
1811      {
1812        WerrorS("expoent overflow - wrong ordering");
1813        return(idInit(1,1));
1814      }
1815      // set ecart -- might have changed because of tail reductions
1816      if ((!strat->noTailReduction) && (!strat->honey))
1817        strat->initEcart(&strat->P);
1818      // cancel unit
1819      cancelunit(&strat->P);
1820      // for char 0, clear denominators
1821      if ((strat->P.p->next==NULL) /* i.e. cancelunit did something*/
1822      && TEST_OPT_INTSTRATEGY)
1823        strat->P.pCleardenom();
1824
1825      enterT(strat->P,strat);
1826      // build new pairs
1827#ifdef HAVE_RINGS
1828      if (rField_is_Ring(currRing))
1829      {
1830        superenterpairs(strat->P.p,strat->sl,strat->P.ecart,0,strat, strat->tl);
1831      }
1832      else
1833#endif
1834      enterpairs(strat->P.p,strat->sl,strat->P.ecart,0,strat, strat->tl);
1835      // put in S
1836
1837        #if ADIDEBUG
1838        Print("\n    The new pair list L -- after superenterpairs in loop %d -- is:\n",loop_count);
1839        for(int iii=0;iii<=strat->Ll;iii++)
1840        {
1841          printf("\n    L[%d]:\n",iii);
1842          PrintS("         ");p_Write(strat->L[iii].p,strat->tailRing);
1843          PrintS("         ");p_Write(strat->L[iii].p1,strat->tailRing);
1844          PrintS("         ");p_Write(strat->L[iii].p2,strat->tailRing);
1845        }
1846        #endif
1847      strat->enterS(strat->P,
1848                    posInS(strat,strat->sl,strat->P.p, strat->P.ecart),
1849                    strat, strat->tl);
1850      #if ADIDEBUG
1851      printf("\nThis pair has been added to S:\n");
1852      pWrite(strat->P.p);
1853      pWrite(strat->P.p1);
1854      pWrite(strat->P.p2);
1855      #endif
1856
1857      // apply hilbert criterion
1858      if (hilb!=NULL)
1859      {
1860        if (strat->homog==isHomog)
1861          khCheck(Q,w,hilb,hilbeledeg,hilbcount,strat);
1862        else
1863          khCheckLocInhom(Q,w,hilb,hilbcount,strat);
1864      }
1865
1866      // clear strat->P
1867      if (strat->P.lcm!=NULL)
1868      {
1869#ifdef HAVE_RINGS
1870        if (rField_is_Ring(currRing)) pLmDelete(strat->P.lcm);
1871        else
1872#else
1873          pLmFree(strat->P.lcm);
1874#endif
1875        strat->P.lcm=NULL;
1876      }
1877
1878#ifdef KDEBUG
1879      // make sure kTest_TS does not complain about strat->P
1880      memset(&strat->P,0,sizeof(strat->P));
1881#endif
1882    }
1883    if (strat->kHEdgeFound)
1884    {
1885      if ((TEST_OPT_FINDET)
1886      || ((TEST_OPT_MULTBOUND) && (scMult0Int(strat->Shdl,NULL,strat->tailRing) < Kstd1_mu)))
1887      {
1888        // obachman: is this still used ???
1889        /*
1890        * stops computation if strat->kHEdgeFound and
1891        * - 27 (finiteDeterminacyTest)
1892        * or
1893        * - 23
1894        *   (multBound)
1895        *   && multiplicity of the ideal is smaller then a predefined number mu
1896        */
1897        while (strat->Ll >= 0) deleteInL(strat->L,&strat->Ll,strat->Ll,strat);
1898      }
1899    }
1900    kTest_TS(strat);
1901  }
1902  /*- complete reduction of the standard basis------------------------ -*/
1903  if (TEST_OPT_REDSB) completeReduce(strat);
1904  else if (TEST_OPT_PROT) PrintLn();
1905  /*- release temp data------------------------------- -*/
1906  exitBuchMora(strat);
1907  /*- polynomials used for HECKE: HC, noether -*/
1908  if (TEST_OPT_FINDET)
1909  {
1910    if (strat->kHEdge!=NULL)
1911      Kstd1_mu=currRing->pFDeg(strat->kHEdge,currRing);
1912    else
1913      Kstd1_mu=-1;
1914  }
1915  pDelete(&strat->kHEdge);
1916  strat->update = TRUE; //???
1917  strat->lastAxis = 0; //???
1918  pDelete(&strat->kNoether);
1919  omFreeSize((ADDRESS)strat->NotUsedAxis,((currRing->N)+1)*sizeof(BOOLEAN));
1920  if ((TEST_OPT_PROT)||(TEST_OPT_DEBUG))  messageStat(hilbcount,strat);
1921//  if (TEST_OPT_WEIGHTM)
1922//  {
1923//    pRestoreDegProcs(currRing,strat->pOrigFDeg, strat->pOrigLDeg);
1924//    if (ecartWeights)
1925//    {
1926//      omFreeSize((ADDRESS)ecartWeights,((currRing->N)+1)*sizeof(short));
1927//      ecartWeights=NULL;
1928//    }
1929//  }
1930  #ifdef HAVE_RINGS
1931  if(nCoeff_is_Ring_Z(currRing->cf))
1932    finalReduceByMon(strat);
1933  #endif
1934  if (Q!=NULL) updateResult(strat->Shdl,Q,strat);
1935  SI_RESTORE_OPT1(save1);
1936  idTest(strat->Shdl);
1937  return (strat->Shdl);
1938}
1939
1940poly kNF1 (ideal F,ideal Q,poly q, kStrategy strat, int lazyReduce)
1941{
1942  assume(q!=NULL);
1943  assume(!(idIs0(F)&&(Q==NULL)));
1944
1945// lazy_reduce flags: can be combined by |
1946//#define KSTD_NF_LAZY   1
1947  // do only a reduction of the leading term
1948//#define KSTD_NF_ECART  2
1949  // only local: recude even with bad ecart
1950  poly   p;
1951  int   i;
1952  int   j;
1953  int   o;
1954  LObject   h;
1955  BITSET save1;
1956  SI_SAVE_OPT1(save1);
1957
1958  //if ((idIs0(F))&&(Q==NULL))
1959  //  return pCopy(q); /*F=0*/
1960  //strat->ak = si_max(idRankFreeModule(F),pMaxComp(q));
1961  /*- creating temp data structures------------------- -*/
1962  strat->kHEdgeFound = (currRing->ppNoether) != NULL;
1963  strat->kNoether    = pCopy((currRing->ppNoether));
1964  si_opt_1|=Sy_bit(OPT_REDTAIL);
1965  si_opt_1&=~Sy_bit(OPT_INTSTRATEGY);
1966  if (TEST_OPT_STAIRCASEBOUND
1967  && (! TEST_V_DEG_STOP)
1968  && (0<Kstd1_deg)
1969  && ((!strat->kHEdgeFound)
1970    ||(TEST_OPT_DEGBOUND && (pWTotaldegree(strat->kNoether)<Kstd1_deg))))
1971  {
1972    pDelete(&strat->kNoether);
1973    strat->kNoether=pOne();
1974    pSetExp(strat->kNoether,1, Kstd1_deg+1);
1975    pSetm(strat->kNoether);
1976    strat->kHEdgeFound=TRUE;
1977  }
1978  initBuchMoraCrit(strat);
1979  if(rField_is_Ring(currRing))
1980    initBuchMoraPosRing(strat);
1981  else
1982    initBuchMoraPos(strat);
1983  initMora(F,strat);
1984  strat->enterS = enterSMoraNF;
1985  /*- set T -*/
1986  strat->tl = -1;
1987  strat->tmax = setmaxT;
1988  strat->T = initT();
1989  strat->R = initR();
1990  strat->sevT = initsevT();
1991  /*- set S -*/
1992  strat->sl = -1;
1993  /*- init local data struct.-------------------------- -*/
1994  /*Shdl=*/initS(F,Q,strat);
1995  if ((strat->ak!=0)
1996  && (strat->kHEdgeFound))
1997  {
1998    if (strat->ak!=1)
1999    {
2000      pSetComp(strat->kNoether,1);
2001      pSetmComp(strat->kNoether);
2002      poly p=pHead(strat->kNoether);
2003      pSetComp(p,strat->ak);
2004      pSetmComp(p);
2005      p=pAdd(strat->kNoether,p);
2006      strat->kNoether=pNext(p);
2007      p_LmFree(p,currRing);
2008    }
2009  }
2010  if ((lazyReduce & KSTD_NF_LAZY)==0)
2011  {
2012    for (i=strat->sl; i>=0; i--)
2013      pNorm(strat->S[i]);
2014  }
2015  /*- puts the elements of S also to T -*/
2016  for (i=0; i<=strat->sl; i++)
2017  {
2018    h.p = strat->S[i];
2019    h.ecart = strat->ecartS[i];
2020    if (strat->sevS[i] == 0) strat->sevS[i] = pGetShortExpVector(h.p);
2021    else assume(strat->sevS[i] == pGetShortExpVector(h.p));
2022    h.length = pLength(h.p);
2023    h.sev = strat->sevS[i];
2024    h.SetpFDeg();
2025    enterT(h,strat);
2026  }
2027#ifdef KDEBUG
2028//  kDebugPrint(strat);
2029#endif
2030  /*- compute------------------------------------------- -*/
2031  p = pCopy(q);
2032  deleteHC(&p,&o,&j,strat);
2033  kTest(strat);
2034  if (TEST_OPT_PROT) { PrintS("r"); mflush(); }
2035  if (BVERBOSE(23)) kDebugPrint(strat);
2036  #ifdef HAVE_RINGS
2037  if(rField_is_Ring(currRing))
2038  {
2039    if (p!=NULL) p = redMoraNFRing(p,strat, lazyReduce & KSTD_NF_ECART);
2040  }
2041  else
2042  #endif
2043    if (p!=NULL) p = redMoraNF(p,strat, lazyReduce & KSTD_NF_ECART);
2044  if ((p!=NULL)&&((lazyReduce & KSTD_NF_LAZY)==0))
2045  {
2046    if (TEST_OPT_PROT) { PrintS("t"); mflush(); }
2047    p = redtail(p,strat->sl,strat);
2048  }
2049  /*- release temp data------------------------------- -*/
2050  cleanT(strat);
2051  assume(strat->L==NULL); /*strat->L unsed */
2052  assume(strat->B==NULL); /*strat->B unused */
2053  omFreeSize((ADDRESS)strat->T,strat->tmax*sizeof(TObject));
2054  omFreeSize((ADDRESS)strat->ecartS,IDELEMS(strat->Shdl)*sizeof(int));
2055  omFreeSize((ADDRESS)strat->sevS,IDELEMS(strat->Shdl)*sizeof(unsigned long));
2056  omFreeSize((ADDRESS)strat->NotUsedAxis,((currRing->N)+1)*sizeof(BOOLEAN));
2057  omFree(strat->sevT);
2058  omFree(strat->S_2_R);
2059  omFree(strat->R);
2060
2061  if ((Q!=NULL)&&(strat->fromQ!=NULL))
2062  {
2063    i=((IDELEMS(Q)+IDELEMS(F)+15)/16)*16;
2064    omFreeSize((ADDRESS)strat->fromQ,i*sizeof(int));
2065    strat->fromQ=NULL;
2066  }
2067  pDelete(&strat->kHEdge);
2068  pDelete(&strat->kNoether);
2069//  if ((TEST_OPT_WEIGHTM)&&(F!=NULL))
2070//  {
2071//    pRestoreDegProcs(currRing,strat->pOrigFDeg, strat->pOrigLDeg);
2072//    if (ecartWeights)
2073//    {
2074//      omFreeSize((ADDRESS *)&ecartWeights,((currRing->N)+1)*sizeof(short));
2075//      ecartWeights=NULL;
2076//    }
2077//  }
2078  idDelete(&strat->Shdl);
2079  SI_RESTORE_OPT1(save1);
2080  if (TEST_OPT_PROT) PrintLn();
2081  return p;
2082}
2083
2084ideal kNF1 (ideal F,ideal Q,ideal q, kStrategy strat, int lazyReduce)
2085{
2086  assume(!idIs0(q));
2087  assume(!(idIs0(F)&&(Q==NULL)));
2088
2089// lazy_reduce flags: can be combined by |
2090//#define KSTD_NF_LAZY   1
2091  // do only a reduction of the leading term
2092//#define KSTD_NF_ECART  2
2093  // only local: recude even with bad ecart
2094  poly   p;
2095  int   i;
2096  int   j;
2097  int   o;
2098  LObject   h;
2099  ideal res;
2100  BITSET save1;
2101  SI_SAVE_OPT1(save1);
2102
2103  //if (idIs0(q)) return idInit(IDELEMS(q),si_max(q->rank,F->rank));
2104  //if ((idIs0(F))&&(Q==NULL))
2105  //  return idCopy(q); /*F=0*/
2106  //strat->ak = si_max(idRankFreeModule(F),idRankFreeModule(q));
2107  /*- creating temp data structures------------------- -*/
2108  strat->kHEdgeFound = (currRing->ppNoether) != NULL;
2109  strat->kNoether=pCopy((currRing->ppNoether));
2110  si_opt_1|=Sy_bit(OPT_REDTAIL);
2111  if (TEST_OPT_STAIRCASEBOUND
2112  && (0<Kstd1_deg)
2113  && ((!strat->kHEdgeFound)
2114    ||(TEST_OPT_DEGBOUND && (pWTotaldegree(strat->kNoether)<Kstd1_deg))))
2115  {
2116    pDelete(&strat->kNoether);
2117    strat->kNoether=pOne();
2118    pSetExp(strat->kNoether,1, Kstd1_deg+1);
2119    pSetm(strat->kNoether);
2120    strat->kHEdgeFound=TRUE;
2121  }
2122  initBuchMoraCrit(strat);
2123  if(rField_is_Ring(currRing))
2124    initBuchMoraPosRing(strat);
2125  else
2126    initBuchMoraPos(strat);
2127  initMora(F,strat);
2128  strat->enterS = enterSMoraNF;
2129  /*- set T -*/
2130  strat->tl = -1;
2131  strat->tmax = setmaxT;
2132  strat->T = initT();
2133  strat->R = initR();
2134  strat->sevT = initsevT();
2135  /*- set S -*/
2136  strat->sl = -1;
2137  /*- init local data struct.-------------------------- -*/
2138  /*Shdl=*/initS(F,Q,strat);
2139  if ((strat->ak!=0)
2140  && (strat->kHEdgeFound))
2141  {
2142    if (strat->ak!=1)
2143    {
2144      pSetComp(strat->kNoether,1);
2145      pSetmComp(strat->kNoether);
2146      poly p=pHead(strat->kNoether);
2147      pSetComp(p,strat->ak);
2148      pSetmComp(p);
2149      p=pAdd(strat->kNoether,p);
2150      strat->kNoether=pNext(p);
2151      p_LmFree(p,currRing);
2152    }
2153  }
2154  if (TEST_OPT_INTSTRATEGY && ((lazyReduce & KSTD_NF_LAZY)==0))
2155  {
2156    for (i=strat->sl; i>=0; i--)
2157      pNorm(strat->S[i]);
2158  }
2159  /*- compute------------------------------------------- -*/
2160  res=idInit(IDELEMS(q),strat->ak);
2161  for (i=0; i<IDELEMS(q); i++)
2162  {
2163    if (q->m[i]!=NULL)
2164    {
2165      p = pCopy(q->m[i]);
2166      deleteHC(&p,&o,&j,strat);
2167      if (p!=NULL)
2168      {
2169        /*- puts the elements of S also to T -*/
2170        for (j=0; j<=strat->sl; j++)
2171        {
2172          h.p = strat->S[j];
2173          h.ecart = strat->ecartS[j];
2174          h.pLength = h.length = pLength(h.p);
2175          if (strat->sevS[j] == 0) strat->sevS[j] = pGetShortExpVector(h.p);
2176          else assume(strat->sevS[j] == pGetShortExpVector(h.p));
2177          h.sev = strat->sevS[j];
2178          h.SetpFDeg();
2179          #ifdef HAVE_RINGS
2180          if(rField_is_Ring(currRing) && rHasLocalOrMixedOrdering(currRing))
2181            enterT_strong(h,strat);
2182          else
2183          #endif
2184            enterT(h,strat);
2185        }
2186        if (TEST_OPT_PROT) { PrintS("r"); mflush(); }
2187        #ifdef HAVE_RINGS
2188        if(rField_is_Ring(currRing))
2189        {
2190          p = redMoraNFRing(p,strat, lazyReduce & KSTD_NF_ECART);
2191        }
2192        else
2193        #endif
2194          p = redMoraNF(p,strat, lazyReduce & KSTD_NF_ECART);
2195        if ((p!=NULL)&&((lazyReduce & KSTD_NF_LAZY)==0))
2196        {
2197          if (TEST_OPT_PROT) { PrintS("t"); mflush(); }
2198          p = redtail(p,strat->sl,strat);
2199        }
2200        cleanT(strat);
2201      }
2202      res->m[i]=p;
2203    }
2204    //else
2205    //  res->m[i]=NULL;
2206  }
2207  /*- release temp data------------------------------- -*/
2208  assume(strat->L==NULL); /*strat->L unsed */
2209  assume(strat->B==NULL); /*strat->B unused */
2210  omFreeSize((ADDRESS)strat->T,strat->tmax*sizeof(TObject));
2211  omFreeSize((ADDRESS)strat->ecartS,IDELEMS(strat->Shdl)*sizeof(int));
2212  omFreeSize((ADDRESS)strat->sevS,IDELEMS(strat->Shdl)*sizeof(unsigned long));
2213  omFreeSize((ADDRESS)strat->NotUsedAxis,((currRing->N)+1)*sizeof(BOOLEAN));
2214  omFree(strat->sevT);
2215  omFree(strat->S_2_R);
2216  omFree(strat->R);
2217  if ((Q!=NULL)&&(strat->fromQ!=NULL))
2218  {
2219    i=((IDELEMS(Q)+IDELEMS(F)+15)/16)*16;
2220    omFreeSize((ADDRESS)strat->fromQ,i*sizeof(int));
2221    strat->fromQ=NULL;
2222  }
2223  pDelete(&strat->kHEdge);
2224  pDelete(&strat->kNoether);
2225//  if ((TEST_OPT_WEIGHTM)&&(F!=NULL))
2226//  {
2227//    pFDeg=strat->pOrigFDeg;
2228//    pLDeg=strat->pOrigLDeg;
2229//    if (ecartWeights)
2230//    {
2231//      omFreeSize((ADDRESS *)&ecartWeights,((currRing->N)+1)*sizeof(short));
2232//      ecartWeights=NULL;
2233//    }
2234//  }
2235  idDelete(&strat->Shdl);
2236  SI_RESTORE_OPT1(save1);
2237  if (TEST_OPT_PROT) PrintLn();
2238  return res;
2239}
2240
2241intvec * kModW, * kHomW;
2242
2243long kModDeg(poly p, ring r)
2244{
2245  long o=p_WDegree(p, r);
2246  long i=p_GetComp(p, r);
2247  if (i==0) return o;
2248  //assume((i>0) && (i<=kModW->length()));
2249  if (i<=kModW->length())
2250    return o+(*kModW)[i-1];
2251  return o;
2252}
2253long kHomModDeg(poly p, ring r)
2254{
2255  int i;
2256  long j=0;
2257
2258  for (i=r->N;i>0;i--)
2259    j+=p_GetExp(p,i,r)*(*kHomW)[i-1];
2260  if (kModW == NULL) return j;
2261  i = p_GetComp(p,r);
2262  if (i==0) return j;
2263  return j+(*kModW)[i-1];
2264}
2265
2266ideal kStd(ideal F, ideal Q, tHomog h,intvec ** w, intvec *hilb,int syzComp,
2267          int newIdeal, intvec *vw, s_poly_proc_t sp)
2268{
2269  if(idIs0(F))
2270    return idInit(1,F->rank);
2271
2272  ideal r;
2273  BOOLEAN b=currRing->pLexOrder,toReset=FALSE;
2274  BOOLEAN delete_w=(w==NULL);
2275  kStrategy strat=new skStrategy;
2276
2277  strat->s_poly=sp;
2278  if(!TEST_OPT_RETURN_SB)
2279    strat->syzComp = syzComp;
2280  if (TEST_OPT_SB_1
2281    &&(!rField_is_Ring(currRing))
2282    )
2283    strat->newIdeal = newIdeal;
2284  if (rField_has_simple_inverse(currRing))
2285    strat->LazyPass=20;
2286  else
2287    strat->LazyPass=2;
2288  strat->LazyDegree = 1;
2289  strat->ak = id_RankFreeModule(F,currRing);
2290  strat->kModW=kModW=NULL;
2291  strat->kHomW=kHomW=NULL;
2292  if (vw != NULL)
2293  {
2294    currRing->pLexOrder=FALSE;
2295    strat->kHomW=kHomW=vw;
2296    strat->pOrigFDeg = currRing->pFDeg;
2297    strat->pOrigLDeg = currRing->pLDeg;
2298    pSetDegProcs(currRing,kHomModDeg);
2299    toReset = TRUE;
2300  }
2301  if (h==testHomog)
2302  {
2303    if (strat->ak == 0)
2304    {
2305      h = (tHomog)idHomIdeal(F,Q);
2306      w=NULL;
2307    }
2308    else if (!TEST_OPT_DEGBOUND)
2309    {
2310      h = (tHomog)idHomModule(F,Q,w);
2311    }
2312  }
2313  currRing->pLexOrder=b;
2314  if (h==isHomog)
2315  {
2316    if (strat->ak > 0 && (w!=NULL) && (*w!=NULL))
2317    {
2318      strat->kModW = kModW = *w;
2319      if (vw == NULL)
2320      {
2321        strat->pOrigFDeg = currRing->pFDeg;
2322        strat->pOrigLDeg = currRing->pLDeg;
2323        pSetDegProcs(currRing,kModDeg);
2324        toReset = TRUE;
2325      }
2326    }
2327    currRing->pLexOrder = TRUE;
2328    if (hilb==NULL) strat->LazyPass*=2;
2329  }
2330  strat->homog=h;
2331#ifdef KDEBUG
2332  idTest(F);
2333  if (Q!=NULL) idTest(Q);
2334#endif
2335#ifdef HAVE_PLURAL
2336  if (rIsPluralRing(currRing))
2337  {
2338    const BOOLEAN bIsSCA  = rIsSCA(currRing) && strat->z2homog; // for Z_2 prod-crit
2339    strat->no_prod_crit   = ! bIsSCA;
2340    if (w!=NULL)
2341      r = nc_GB(F, Q, *w, hilb, strat, currRing);
2342    else
2343      r = nc_GB(F, Q, NULL, hilb, strat, currRing);
2344  }
2345  else
2346#endif
2347  {
2348    #if PRE_INTEGER_CHECK
2349    //the preinteger check strategy is not for modules
2350    if(rField_is_Ring(currRing) && nCoeff_is_Ring_Z(currRing->cf) && strat->ak <= 0)
2351    {
2352      ideal FCopy = idCopy(F);
2353      poly pFmon = preIntegerCheck(FCopy, Q);
2354      if(pFmon != NULL)
2355      {
2356        idInsertPoly(FCopy, pFmon);
2357        #if ADIDEBUG
2358        printf("\nPreintegerCheck found this constant:\n");pWrite(pFmon);
2359        #endif
2360
2361        strat->kModW=kModW=NULL;
2362        if (h==testHomog)
2363        {
2364            if (strat->ak == 0)
2365            {
2366              h = (tHomog)idHomIdeal(FCopy,Q);
2367              w=NULL;
2368            }
2369            else if (!TEST_OPT_DEGBOUND)
2370            {
2371                h = (tHomog)idHomModule(FCopy,Q,w);
2372            }
2373        }
2374        currRing->pLexOrder=b;
2375        if (h==isHomog)
2376        {
2377          if (strat->ak > 0 && (w!=NULL) && (*w!=NULL))
2378          {
2379            strat->kModW = kModW = *w;
2380            if (vw == NULL)
2381            {
2382              strat->pOrigFDeg = currRing->pFDeg;
2383              strat->pOrigLDeg = currRing->pLDeg;
2384              pSetDegProcs(currRing,kModDeg);
2385              toReset = TRUE;
2386            }
2387          }
2388          currRing->pLexOrder = TRUE;
2389          if (hilb==NULL) strat->LazyPass*=2;
2390        }
2391        strat->homog=h;
2392      }
2393      else
2394      {
2395        #if ADIDEBUG
2396        printf("\npreIntegerCheck didn't found any new information\n");
2397        #endif
2398      }
2399      omTestMemory(1);
2400      if(w == NULL)
2401      {
2402        if(rHasLocalOrMixedOrdering(currRing))
2403            r=mora(FCopy,Q,NULL,hilb,strat);
2404        else
2405            r=bba(FCopy,Q,NULL,hilb,strat);
2406      }
2407      else
2408      {
2409        if(rHasLocalOrMixedOrdering(currRing))
2410            r=mora(FCopy,Q,*w,hilb,strat);
2411        else
2412            r=bba(FCopy,Q,*w,hilb,strat);
2413      }
2414      idDelete(&FCopy);
2415    }
2416    else
2417    #endif
2418    {
2419      if(w==NULL)
2420      {
2421        if(rHasLocalOrMixedOrdering(currRing))
2422          r=mora(F,Q,NULL,hilb,strat);
2423        else
2424          r=bba(F,Q,NULL,hilb,strat);
2425      }
2426      else
2427      {
2428        if(rHasLocalOrMixedOrdering(currRing))
2429          r=mora(F,Q,*w,hilb,strat);
2430        else
2431          r=bba(F,Q,*w,hilb,strat);
2432      }
2433    }
2434  }
2435#ifdef KDEBUG
2436  idTest(r);
2437#endif
2438  if (toReset)
2439  {
2440    kModW = NULL;
2441    pRestoreDegProcs(currRing,strat->pOrigFDeg, strat->pOrigLDeg);
2442  }
2443  currRing->pLexOrder = b;
2444//Print("%d reductions canceled \n",strat->cel);
2445  HCord=strat->HCord;
2446  delete(strat);
2447  if ((delete_w)&&(w!=NULL)&&(*w!=NULL)) delete *w;
2448  return r;
2449}
2450
2451ideal kSba(ideal F, ideal Q, tHomog h,intvec ** w, int sbaOrder, int arri, intvec *hilb,int syzComp,
2452          int newIdeal, intvec *vw)
2453{
2454  if(idIs0(F))
2455    return idInit(1,F->rank);
2456
2457  ideal r;
2458  BOOLEAN b=currRing->pLexOrder,toReset=FALSE;
2459  BOOLEAN delete_w=(w==NULL);
2460  kStrategy strat=new skStrategy;
2461  strat->sbaOrder = sbaOrder;
2462  if (arri!=0)
2463  {
2464    strat->rewCrit1 = arriRewDummy;
2465    strat->rewCrit2 = arriRewCriterion;
2466    strat->rewCrit3 = arriRewCriterionPre;
2467  }
2468  else
2469  {
2470    strat->rewCrit1 = faugereRewCriterion;
2471    strat->rewCrit2 = faugereRewCriterion;
2472    strat->rewCrit3 = faugereRewCriterion;
2473  }
2474
2475  if(!TEST_OPT_RETURN_SB)
2476    strat->syzComp = syzComp;
2477  if (TEST_OPT_SB_1)
2478    if(!rField_is_Ring(currRing))
2479      strat->newIdeal = newIdeal;
2480  if (rField_has_simple_inverse(currRing))
2481    strat->LazyPass=20;
2482  else
2483    strat->LazyPass=2;
2484  strat->LazyDegree = 1;
2485  strat->enterOnePair=enterOnePairNormal;
2486  strat->chainCrit=chainCritNormal;
2487  if (TEST_OPT_SB_1) strat->chainCrit=chainCritOpt_1;
2488  strat->ak = id_RankFreeModule(F,currRing);
2489  strat->kModW=kModW=NULL;
2490  strat->kHomW=kHomW=NULL;
2491  if (vw != NULL)
2492  {
2493    currRing->pLexOrder=FALSE;
2494    strat->kHomW=kHomW=vw;
2495    strat->pOrigFDeg = currRing->pFDeg;
2496    strat->pOrigLDeg = currRing->pLDeg;
2497    pSetDegProcs(currRing,kHomModDeg);
2498    toReset = TRUE;
2499  }
2500  if (h==testHomog)
2501  {
2502    if (strat->ak == 0)
2503    {
2504      h = (tHomog)idHomIdeal(F,Q);
2505      w=NULL;
2506    }
2507    else if (!TEST_OPT_DEGBOUND)
2508    {
2509      h = (tHomog)idHomModule(F,Q,w);
2510    }
2511  }
2512  currRing->pLexOrder=b;
2513  if (h==isHomog)
2514  {
2515    if (strat->ak > 0 && (w!=NULL) && (*w!=NULL))
2516    {
2517      strat->kModW = kModW = *w;
2518      if (vw == NULL)
2519      {
2520        strat->pOrigFDeg = currRing->pFDeg;
2521        strat->pOrigLDeg = currRing->pLDeg;
2522        pSetDegProcs(currRing,kModDeg);
2523        toReset = TRUE;
2524      }
2525    }
2526    currRing->pLexOrder = TRUE;
2527    if (hilb==NULL) strat->LazyPass*=2;
2528  }
2529  strat->homog=h;
2530#ifdef KDEBUG
2531  idTest(F);
2532  idTest(Q);
2533#endif
2534#ifdef HAVE_PLURAL
2535  if (rIsPluralRing(currRing))
2536  {
2537    const BOOLEAN bIsSCA  = rIsSCA(currRing) && strat->z2homog; // for Z_2 prod-crit
2538    strat->no_prod_crit   = ! bIsSCA;
2539    if (w!=NULL)
2540      r = nc_GB(F, Q, *w, hilb, strat, currRing);
2541    else
2542      r = nc_GB(F, Q, NULL, hilb, strat, currRing);
2543  }
2544  else
2545#endif
2546  if (rField_is_Ring(currRing))
2547    r=bba(F,Q,NULL,hilb,strat);
2548  else
2549  {
2550    if (rHasLocalOrMixedOrdering(currRing))
2551    {
2552      if (w!=NULL)
2553        r=mora(F,Q,*w,hilb,strat);
2554      else
2555        r=mora(F,Q,NULL,hilb,strat);
2556    }
2557    else
2558    {
2559      if (w!=NULL)
2560        r=sba(F,Q,*w,hilb,strat);
2561      else
2562        r=sba(F,Q,NULL,hilb,strat);
2563    }
2564  }
2565#ifdef KDEBUG
2566  idTest(r);
2567#endif
2568  if (toReset)
2569  {
2570    kModW = NULL;
2571    pRestoreDegProcs(currRing,strat->pOrigFDeg, strat->pOrigLDeg);
2572  }
2573  currRing->pLexOrder = b;
2574//Print("%d reductions canceled \n",strat->cel);
2575  HCord=strat->HCord;
2576  delete(strat);
2577  if ((delete_w)&&(w!=NULL)&&(*w!=NULL)) delete *w;
2578  return r;
2579}
2580
2581#ifdef HAVE_SHIFTBBA
2582ideal kStdShift(ideal F, ideal Q, tHomog h,intvec ** w, intvec *hilb,int syzComp,
2583                int newIdeal, intvec *vw, int uptodeg, int lV)
2584{
2585  ideal r;
2586  BOOLEAN b=currRing->pLexOrder,toReset=FALSE;
2587  BOOLEAN delete_w=(w==NULL);
2588  kStrategy strat=new skStrategy;
2589
2590  if(!TEST_OPT_RETURN_SB)
2591    strat->syzComp = syzComp;
2592  if (TEST_OPT_SB_1)
2593    if(!rField_is_Ring(currRing))
2594      strat->newIdeal = newIdeal;
2595  if (rField_has_simple_inverse(currRing))
2596    strat->LazyPass=20;
2597  else
2598    strat->LazyPass=2;
2599  strat->LazyDegree = 1;
2600  strat->ak = id_RankFreeModule(F,currRing);
2601  strat->kModW=kModW=NULL;
2602  strat->kHomW=kHomW=NULL;
2603  if (vw != NULL)
2604  {
2605    currRing->pLexOrder=FALSE;
2606    strat->kHomW=kHomW=vw;
2607    strat->pOrigFDeg = currRing->pFDeg;
2608    strat->pOrigLDeg = currRing->pLDeg;
2609    pSetDegProcs(currRing,kHomModDeg);
2610    toReset = TRUE;
2611  }
2612  if (h==testHomog)
2613  {
2614    if (strat->ak == 0)
2615    {
2616      h = (tHomog)idHomIdeal(F,Q);
2617      w=NULL;
2618    }
2619    else if (!TEST_OPT_DEGBOUND)
2620    {
2621      h = (tHomog)idHomModule(F,Q,w);
2622    }
2623  }
2624  currRing->pLexOrder=b;
2625  if (h==isHomog)
2626  {
2627    if (strat->ak > 0 && (w!=NULL) && (*w!=NULL))
2628    {
2629      strat->kModW = kModW = *w;
2630      if (vw == NULL)
2631      {
2632        strat->pOrigFDeg = currRing->pFDeg;
2633        strat->pOrigLDeg = currRing->pLDeg;
2634        pSetDegProcs(currRing,kModDeg);
2635        toReset = TRUE;
2636      }
2637    }
2638    currRing->pLexOrder = TRUE;
2639    if (hilb==NULL) strat->LazyPass*=2;
2640  }
2641  strat->homog=h;
2642#ifdef KDEBUG
2643  idTest(F);
2644#endif
2645  if (rHasLocalOrMixedOrdering(currRing))
2646  {
2647    /* error: no local ord yet with shifts */
2648    Print("No local ordering possible for shifts");
2649    return(NULL);
2650  }
2651  else
2652  {
2653    /* global ordering */
2654    if (w!=NULL)
2655      r=bbaShift(F,Q,*w,hilb,strat,uptodeg,lV);
2656    else
2657      r=bbaShift(F,Q,NULL,hilb,strat,uptodeg,lV);
2658  }
2659#ifdef KDEBUG
2660  idTest(r);
2661#endif
2662  if (toReset)
2663  {
2664    kModW = NULL;
2665    pRestoreDegProcs(currRing,strat->pOrigFDeg, strat->pOrigLDeg);
2666  }
2667  currRing->pLexOrder = b;
2668//Print("%d reductions canceled \n",strat->cel);
2669  HCord=strat->HCord;
2670  delete(strat);
2671  if ((delete_w)&&(w!=NULL)&&(*w!=NULL)) delete *w;
2672  return r;
2673}
2674#endif
2675
2676//##############################################################
2677//##############################################################
2678//##############################################################
2679//##############################################################
2680//##############################################################
2681
2682ideal kMin_std(ideal F, ideal Q, tHomog h,intvec ** w, ideal &M, intvec *hilb,
2683              int syzComp, int reduced)
2684{
2685  if(idIs0(F))
2686  {
2687    M=idInit(1,F->rank);
2688    return idInit(1,F->rank);
2689  }
2690  if(rField_is_Ring(currRing))
2691  {
2692    ideal sb;
2693    sb = kStd(F, Q, h, w, hilb);
2694    idSkipZeroes(sb);
2695    if(IDELEMS(sb) <= IDELEMS(F))
2696    {
2697        M = idCopy(sb);
2698        idSkipZeroes(M);
2699        return(sb);
2700    }
2701    else
2702    {
2703        M = idCopy(F);
2704        idSkipZeroes(M);
2705        return(sb);
2706    }
2707  }
2708  ideal r=NULL;
2709  int Kstd1_OldDeg = Kstd1_deg,i;
2710  intvec* temp_w=NULL;
2711  BOOLEAN b=currRing->pLexOrder,toReset=FALSE;
2712  BOOLEAN delete_w=(w==NULL);
2713  BOOLEAN oldDegBound=TEST_OPT_DEGBOUND;
2714  kStrategy strat=new skStrategy;
2715
2716  if(!TEST_OPT_RETURN_SB)
2717     strat->syzComp = syzComp;
2718  if (rField_has_simple_inverse(currRing))
2719    strat->LazyPass=20;
2720  else
2721    strat->LazyPass=2;
2722  strat->LazyDegree = 1;
2723  strat->minim=(reduced % 2)+1;
2724  strat->ak = id_RankFreeModule(F,currRing);
2725  if (delete_w)
2726  {
2727    temp_w=new intvec((strat->ak)+1);
2728    w = &temp_w;
2729  }
2730  if (h==testHomog)
2731  {
2732    if (strat->ak == 0)
2733    {
2734      h = (tHomog)idHomIdeal(F,Q);
2735      w=NULL;
2736    }
2737    else
2738    {
2739      h = (tHomog)idHomModule(F,Q,w);
2740    }
2741  }
2742  if (h==isHomog)
2743  {
2744    if (strat->ak > 0 && (w!=NULL) && (*w!=NULL))
2745    {
2746      kModW = *w;
2747      strat->kModW = *w;
2748      assume(currRing->pFDeg != NULL && currRing->pLDeg != NULL);
2749      strat->pOrigFDeg = currRing->pFDeg;
2750      strat->pOrigLDeg = currRing->pLDeg;
2751      pSetDegProcs(currRing,kModDeg);
2752
2753      toReset = TRUE;
2754      if (reduced>1)
2755      {
2756        Kstd1_OldDeg=Kstd1_deg;
2757        Kstd1_deg = -1;
2758        for (i=IDELEMS(F)-1;i>=0;i--)
2759        {
2760          if ((F->m[i]!=NULL) && (currRing->pFDeg(F->m[i],currRing)>=Kstd1_deg))
2761            Kstd1_deg = currRing->pFDeg(F->m[i],currRing)+1;
2762        }
2763      }
2764    }
2765    currRing->pLexOrder = TRUE;
2766    strat->LazyPass*=2;
2767  }
2768  strat->homog=h;
2769  if (rHasLocalOrMixedOrdering(currRing))
2770  {
2771    if (w!=NULL)
2772      r=mora(F,Q,*w,hilb,strat);
2773    else
2774      r=mora(F,Q,NULL,hilb,strat);
2775  }
2776  else
2777  {
2778    if (w!=NULL)
2779      r=bba(F,Q,*w,hilb,strat);
2780    else
2781      r=bba(F,Q,NULL,hilb,strat);
2782  }
2783#ifdef KDEBUG
2784  {
2785    int i;
2786    for (i=IDELEMS(r)-1; i>=0; i--) pTest(r->m[i]);
2787  }
2788#endif
2789  idSkipZeroes(r);
2790  if (toReset)
2791  {
2792    pRestoreDegProcs(currRing,strat->pOrigFDeg, strat->pOrigLDeg);
2793    kModW = NULL;
2794  }
2795  currRing->pLexOrder = b;
2796  HCord=strat->HCord;
2797  if ((delete_w)&&(temp_w!=NULL)) delete temp_w;
2798  if ((IDELEMS(r)==1) && (r->m[0]!=NULL) && pIsConstant(r->m[0]) && (strat->ak==0))
2799  {
2800    M=idInit(1,F->rank);
2801    M->m[0]=pOne();
2802    //if (strat->ak!=0) { pSetComp(M->m[0],strat->ak); pSetmComp(M->m[0]); }
2803    if (strat->M!=NULL) idDelete(&strat->M);
2804  }
2805  else if (strat->M==NULL)
2806  {
2807    M=idInit(1,F->rank);
2808    Warn("no minimal generating set computed");
2809  }
2810  else
2811  {
2812    idSkipZeroes(strat->M);
2813    M=strat->M;
2814  }
2815  delete(strat);
2816  if (reduced>2)
2817  {
2818    Kstd1_deg=Kstd1_OldDeg;
2819    if (!oldDegBound)
2820      si_opt_1 &= ~Sy_bit(OPT_DEGBOUND);
2821  }
2822  else
2823  {
2824    if (IDELEMS(M)>IDELEMS(r)) {
2825       idDelete(&M);
2826       M=idCopy(r); }
2827  }
2828  return r;
2829}
2830
2831poly kNF(ideal F, ideal Q, poly p,int syzComp, int lazyReduce)
2832{
2833  if (p==NULL)
2834     return NULL;
2835
2836  poly pp = p;
2837
2838#ifdef HAVE_PLURAL
2839  if(rIsSCA(currRing))
2840  {
2841    const unsigned int m_iFirstAltVar = scaFirstAltVar(currRing);
2842    const unsigned int m_iLastAltVar  = scaLastAltVar(currRing);
2843    pp = p_KillSquares(pp, m_iFirstAltVar, m_iLastAltVar, currRing);
2844
2845    if(Q == currRing->qideal)
2846      Q = SCAQuotient(currRing);
2847  }
2848#endif
2849
2850  if ((idIs0(F))&&(Q==NULL))
2851  {
2852#ifdef HAVE_PLURAL
2853    if(p != pp)
2854      return pp;
2855#endif
2856    return pCopy(p); /*F+Q=0*/
2857  }
2858
2859  kStrategy strat=new skStrategy;
2860  strat->syzComp = syzComp;
2861  strat->ak = si_max(id_RankFreeModule(F,currRing),pMaxComp(p));
2862  poly res;
2863
2864  if (rHasLocalOrMixedOrdering(currRing))
2865    res=kNF1(F,Q,pp,strat,lazyReduce);
2866  else
2867    res=kNF2(F,Q,pp,strat,lazyReduce);
2868  delete(strat);
2869
2870#ifdef HAVE_PLURAL
2871  if(pp != p)
2872    p_Delete(&pp, currRing);
2873#endif
2874  return res;
2875}
2876
2877ideal kNF(ideal F, ideal Q, ideal p,int syzComp,int lazyReduce)
2878{
2879  ideal res;
2880  if (TEST_OPT_PROT)
2881  {
2882    Print("(S:%d)",IDELEMS(p));mflush();
2883  }
2884  if (idIs0(p))
2885    return idInit(IDELEMS(p),si_max(p->rank,F->rank));
2886
2887  ideal pp = p;
2888#ifdef HAVE_PLURAL
2889  if(rIsSCA(currRing))
2890  {
2891    const unsigned int m_iFirstAltVar = scaFirstAltVar(currRing);
2892    const unsigned int m_iLastAltVar  = scaLastAltVar(currRing);
2893    pp = id_KillSquares(pp, m_iFirstAltVar, m_iLastAltVar, currRing, false);
2894
2895    if(Q == currRing->qideal)
2896      Q = SCAQuotient(currRing);
2897  }
2898#endif
2899
2900  if ((idIs0(F))&&(Q==NULL))
2901  {
2902#ifdef HAVE_PLURAL
2903    if(p != pp)
2904      return pp;
2905#endif
2906    return idCopy(p); /*F+Q=0*/
2907  }
2908
2909  kStrategy strat=new skStrategy;
2910  strat->syzComp = syzComp;
2911  strat->ak = si_max(id_RankFreeModule(F,currRing),id_RankFreeModule(p,currRing));
2912  if (strat->ak>0) // only for module case, see Tst/Short/bug_reduce.tst
2913  {
2914    strat->ak = si_max(strat->ak,(int)F->rank);
2915  }
2916
2917  if (rHasLocalOrMixedOrdering(currRing))
2918    res=kNF1(F,Q,pp,strat,lazyReduce);
2919  else
2920    res=kNF2(F,Q,pp,strat,lazyReduce);
2921  delete(strat);
2922
2923#ifdef HAVE_PLURAL
2924  if(pp != p)
2925    id_Delete(&pp, currRing);
2926#endif
2927
2928  return res;
2929}
2930
2931poly k_NF (ideal F, ideal Q, poly p,int syzComp, int lazyReduce, const ring _currRing)
2932{
2933  const ring save = currRing;
2934  if( currRing != _currRing ) rChangeCurrRing(_currRing);
2935  poly ret = kNF(F, Q, p, syzComp, lazyReduce);
2936  if( currRing != save )     rChangeCurrRing(save);
2937  return ret;
2938}
2939
2940/*2
2941*interreduces F
2942*/
2943// old version
2944ideal kInterRedOld (ideal F, ideal Q)
2945{
2946  int j;
2947  kStrategy strat = new skStrategy;
2948
2949  ideal tempF = F;
2950  ideal tempQ = Q;
2951
2952#ifdef HAVE_PLURAL
2953  if(rIsSCA(currRing))
2954  {
2955    const unsigned int m_iFirstAltVar = scaFirstAltVar(currRing);
2956    const unsigned int m_iLastAltVar  = scaLastAltVar(currRing);
2957    tempF = id_KillSquares(F, m_iFirstAltVar, m_iLastAltVar, currRing);
2958
2959    // this should be done on the upper level!!! :
2960    //    tempQ = SCAQuotient(currRing);
2961
2962    if(Q == currRing->qideal)
2963      tempQ = SCAQuotient(currRing);
2964  }
2965#endif
2966
2967//  if (TEST_OPT_PROT)
2968//  {
2969//    writeTime("start InterRed:");
2970//    mflush();
2971//  }
2972  //strat->syzComp     = 0;
2973  strat->kHEdgeFound = (currRing->ppNoether) != NULL;
2974  strat->kNoether=pCopy((currRing->ppNoether));
2975  strat->ak = id_RankFreeModule(tempF,currRing);
2976  initBuchMoraCrit(strat);
2977  strat->NotUsedAxis = (BOOLEAN *)omAlloc(((currRing->N)+1)*sizeof(BOOLEAN));
2978  for (j=(currRing->N); j>0; j--) strat->NotUsedAxis[j] = TRUE;
2979  strat->enterS      = enterSBba;
2980  strat->posInT      = posInT17;
2981  strat->initEcart   = initEcartNormal;
2982  strat->sl   = -1;
2983  strat->tl          = -1;
2984  strat->tmax        = setmaxT;
2985  strat->T           = initT();
2986  strat->R           = initR();
2987  strat->sevT        = initsevT();
2988  if (rHasLocalOrMixedOrdering(currRing))   strat->honey = TRUE;
2989  initS(tempF, tempQ, strat);
2990  if (TEST_OPT_REDSB)
2991    strat->noTailReduction=FALSE;
2992  updateS(TRUE,strat);
2993  if (TEST_OPT_REDSB && TEST_OPT_INTSTRATEGY)
2994    completeReduce(strat);
2995  //else if (TEST_OPT_PROT) PrintLn();
2996  pDelete(&strat->kHEdge);
2997  omFreeSize((ADDRESS)strat->T,strat->tmax*sizeof(TObject));
2998  omFreeSize((ADDRESS)strat->ecartS,IDELEMS(strat->Shdl)*sizeof(int));
2999  omFreeSize((ADDRESS)strat->sevS,IDELEMS(strat->Shdl)*sizeof(unsigned long));
3000  omFreeSize((ADDRESS)strat->NotUsedAxis,((currRing->N)+1)*sizeof(BOOLEAN));
3001  omfree(strat->sevT);
3002  omfree(strat->S_2_R);
3003  omfree(strat->R);
3004
3005  if (strat->fromQ)
3006  {
3007    for (j=IDELEMS(strat->Shdl)-1;j>=0;j--)
3008    {
3009      if(strat->fromQ[j]) pDelete(&strat->Shdl->m[j]);
3010    }
3011    omFreeSize((ADDRESS)strat->fromQ,IDELEMS(strat->Shdl)*sizeof(int));
3012  }
3013//  if (TEST_OPT_PROT)
3014//  {
3015//    writeTime("end Interred:");
3016//    mflush();
3017//  }
3018  ideal shdl=strat->Shdl;
3019  idSkipZeroes(shdl);
3020  if (strat->fromQ)
3021  {
3022    strat->fromQ=NULL;
3023    ideal res=kInterRed(shdl,NULL);
3024    idDelete(&shdl);
3025    shdl=res;
3026  }
3027  delete(strat);
3028#ifdef HAVE_PLURAL
3029  if( tempF != F )
3030    id_Delete( &tempF, currRing);
3031#endif
3032  return shdl;
3033}
3034// new version
3035ideal kInterRedBba (ideal F, ideal Q, int &need_retry)
3036{
3037  need_retry=0;
3038  int   red_result = 1;
3039  int   olddeg,reduc;
3040  BOOLEAN withT = FALSE;
3041  // BOOLEAN toReset=FALSE;
3042  kStrategy strat=new skStrategy;
3043  tHomog h;
3044  intvec * w=NULL;
3045
3046  if (rField_has_simple_inverse(currRing))
3047    strat->LazyPass=20;
3048  else
3049    strat->LazyPass=2;
3050  strat->LazyDegree = 1;
3051  strat->ak = id_RankFreeModule(F,currRing);
3052  strat->syzComp = strat->ak;
3053  strat->kModW=kModW=NULL;
3054  strat->kHomW=kHomW=NULL;
3055  if (strat->ak == 0)
3056  {
3057    h = (tHomog)idHomIdeal(F,Q);
3058    w=NULL;
3059  }
3060  else if (!TEST_OPT_DEGBOUND)
3061  {
3062    h = (tHomog)idHomModule(F,Q,&w);
3063  }
3064  if (h==isHomog)
3065  {
3066    if (strat->ak > 0 && (w!=NULL) && (w!=NULL))
3067    {
3068      strat->kModW = kModW = w;
3069      strat->pOrigFDeg = currRing->pFDeg;
3070      strat->pOrigLDeg = currRing->pLDeg;
3071      pSetDegProcs(currRing,kModDeg);
3072      // toReset = TRUE;
3073    }
3074    strat->LazyPass*=2;
3075  }
3076  strat->homog=h;
3077#ifdef KDEBUG
3078  idTest(F);
3079#endif
3080
3081  initBuchMoraCrit(strat); /*set Gebauer, honey, sugarCrit*/
3082  if(rField_is_Ring(currRing))
3083    initBuchMoraPosRing(strat);
3084  else
3085    initBuchMoraPos(strat);
3086  initBba(strat);
3087  /*set enterS, spSpolyShort, reduce, red, initEcart, initEcartPair*/
3088  strat->posInL=posInL0; /* ord according pComp */
3089
3090  /*Shdl=*/initBuchMora(F, Q, strat);
3091  reduc = olddeg = 0;
3092
3093#ifndef NO_BUCKETS
3094  if (!TEST_OPT_NOT_BUCKETS)
3095    strat->use_buckets = 1;
3096#endif
3097
3098  // redtailBBa against T for inhomogenous input
3099  if (!TEST_OPT_OLDSTD)
3100    withT = ! strat->homog;
3101
3102  // strat->posInT = posInT_pLength;
3103  kTest_TS(strat);
3104
3105#ifdef HAVE_TAIL_RING
3106  kStratInitChangeTailRing(strat);
3107#endif
3108
3109  /* compute------------------------------------------------------- */
3110  while (strat->Ll >= 0)
3111  {
3112    #ifdef KDEBUG
3113      if (TEST_OPT_DEBUG) messageSets(strat);
3114    #endif
3115    if (strat->Ll== 0) strat->interpt=TRUE;
3116    /* picks the last element from the lazyset L */
3117    strat->P = strat->L[strat->Ll];
3118    strat->Ll--;
3119
3120    if (strat->P.p1 == NULL)
3121    {
3122      // for input polys, prepare reduction
3123      strat->P.PrepareRed(strat->use_buckets);
3124    }
3125
3126    if (strat->P.p == NULL && strat->P.t_p == NULL)
3127    {
3128      red_result = 0;
3129    }
3130    else
3131    {
3132      if (TEST_OPT_PROT)
3133        message(strat->P.pFDeg(),
3134                &olddeg,&reduc,strat, red_result);
3135
3136      /* reduction of the element chosen from L */
3137      red_result = strat->red(&strat->P,strat);
3138    }
3139
3140    // reduction to non-zero new poly
3141    if (red_result == 1)
3142    {
3143      /* statistic */
3144      if (TEST_OPT_PROT) PrintS("s");
3145
3146      // get the polynomial (canonicalize bucket, make sure P.p is set)
3147      strat->P.GetP(strat->lmBin);
3148
3149      int pos=posInS(strat,strat->sl,strat->P.p,strat->P.ecart);
3150
3151      // reduce the tail and normalize poly
3152      // in the ring case we cannot expect LC(f) = 1,
3153      // therefore we call pContent instead of pNorm
3154      if ((TEST_OPT_INTSTRATEGY) || (rField_is_Ring(currRing)))
3155      {
3156        strat->P.pCleardenom();
3157        if (0)
3158        //if ((TEST_OPT_REDSB)||(TEST_OPT_REDTAIL))
3159        {
3160          strat->P.p = redtailBba(&(strat->P),pos-1,strat, withT);
3161          strat->P.pCleardenom();
3162        }
3163      }
3164      else
3165      {
3166        strat->P.pNorm();
3167        if (0)
3168        //if ((TEST_OPT_REDSB)||(TEST_OPT_REDTAIL))
3169          strat->P.p = redtailBba(&(strat->P),pos-1,strat, withT);
3170      }
3171
3172#ifdef KDEBUG
3173      if (TEST_OPT_DEBUG){PrintS("new s:");strat->P.wrp();PrintLn();}
3174#endif
3175
3176      // enter into S, L, and T
3177      if ((!TEST_OPT_IDLIFT) || (pGetComp(strat->P.p) <= strat->syzComp))
3178      {
3179        enterT(strat->P, strat);
3180        // posInS only depends on the leading term
3181        strat->enterS(strat->P, pos, strat, strat->tl);
3182
3183        if (pos<strat->sl)
3184        {
3185          need_retry++;
3186          // move all "larger" elements fromS to L
3187          // remove them from T
3188          int ii=pos+1;
3189          for(;ii<=strat->sl;ii++)
3190          {
3191            LObject h;
3192            memset(&h,0,sizeof(h));
3193            h.tailRing=strat->tailRing;
3194            h.p=strat->S[ii]; strat->S[ii]=NULL;
3195            strat->initEcart(&h);
3196            h.sev=strat->sevS[ii];
3197            int jj=strat->tl;
3198            while (jj>=0)
3199            {
3200              if (strat->T[jj].p==h.p)
3201              {
3202                strat->T[jj].p=NULL;
3203                if (jj<strat->tl)
3204                {
3205                  memmove(&(strat->T[jj]),&(strat->T[jj+1]),
3206                          (strat->tl-jj)*sizeof(strat->T[jj]));
3207                  memmove(&(strat->sevT[jj]),&(strat->sevT[jj+1]),
3208                          (strat->tl-jj)*sizeof(strat->sevT[jj]));
3209                }
3210                strat->tl--;
3211                break;
3212              }
3213              jj--;
3214            }
3215            int lpos=strat->posInL(strat->L,strat->Ll,&h,strat);
3216            enterL(&strat->L,&strat->Ll,&strat->Lmax,h,lpos);
3217            #ifdef KDEBUG
3218            if (TEST_OPT_DEBUG)
3219            {
3220              Print("move S[%d] -> L[%d]: ",ii,pos);
3221              p_wrp(h.p,currRing, strat->tailRing);
3222              PrintLn();
3223            }
3224            #endif
3225          }
3226          if (strat->fromQ!=NULL)
3227          {
3228            for(ii=pos+1;ii<=strat->sl;ii++) strat->fromQ[ii]=0;
3229          }
3230          strat->sl=pos;
3231        }
3232      }
3233      else
3234      {
3235        // clean P
3236      }
3237      if (strat->P.lcm!=NULL)
3238#ifdef HAVE_RINGS
3239        pLmDelete(strat->P.lcm);
3240#else
3241        pLmFree(strat->P.lcm);
3242#endif
3243    }
3244
3245#ifdef KDEBUG
3246    if (TEST_OPT_DEBUG)
3247    {
3248      messageSets(strat);
3249    }
3250    memset(&(strat->P), 0, sizeof(strat->P));
3251#endif
3252    //kTest_TS(strat);: i_r out of sync in kInterRedBba, but not used!
3253  }
3254#ifdef KDEBUG
3255  //if (TEST_OPT_DEBUG) messageSets(strat);
3256#endif
3257  /* complete reduction of the standard basis--------- */
3258
3259  if((need_retry<=0) && (TEST_OPT_REDSB))
3260  {
3261    completeReduce(strat);
3262#ifdef HAVE_TAIL_RING
3263    if (strat->completeReduce_retry)
3264    {
3265      // completeReduce needed larger exponents, retry
3266      // to reduce with S (instead of T)
3267      // and in currRing (instead of strat->tailRing)
3268      cleanT(strat);strat->tailRing=currRing;
3269      int i;
3270      for(i=strat->sl;i>=0;i--) strat->S_2_R[i]=-1;
3271      completeReduce(strat);
3272    }
3273#endif
3274  }
3275  else if (TEST_OPT_PROT) PrintLn();
3276
3277  /* release temp data-------------------------------- */
3278  exitBuchMora(strat);
3279//  if (TEST_OPT_WEIGHTM)
3280//  {
3281//    pRestoreDegProcs(currRing,strat->pOrigFDeg, strat->pOrigLDeg);
3282//    if (ecartWeights)
3283//    {
3284//      omFreeSize((ADDRESS)ecartWeights,((currRing->N)+1)*sizeof(short));
3285//      ecartWeights=NULL;
3286//    }
3287//  }
3288  //if (TEST_OPT_PROT) messageStat(0/*hilbcount*/,strat);
3289  if (Q!=NULL) updateResult(strat->Shdl,Q,strat);
3290  ideal res=strat->Shdl;
3291  strat->Shdl=NULL;
3292  delete strat;
3293  if (w!=NULL) delete w;
3294  return res;
3295}
3296ideal kInterRed (ideal F, ideal Q)
3297{
3298#ifdef HAVE_PLURAL
3299  if(rIsPluralRing(currRing)) return kInterRedOld(F,Q);
3300#endif
3301  if ((rHasLocalOrMixedOrdering(currRing))|| (rField_is_numeric(currRing))
3302  ||(rField_is_Ring(currRing))
3303  )
3304    return kInterRedOld(F,Q);
3305
3306    //return kInterRedOld(F,Q);
3307
3308  BITSET save1;
3309  SI_SAVE_OPT1(save1);
3310  //si_opt_1|=Sy_bit(OPT_NOT_SUGAR);
3311  si_opt_1|=Sy_bit(OPT_REDTHROUGH);
3312  //si_opt_1&= ~Sy_bit(OPT_REDTAIL);
3313  //si_opt_1&= ~Sy_bit(OPT_REDSB);
3314  //extern char * showOption() ;
3315  //Print("%s\n",showOption());
3316
3317  int need_retry;
3318  int counter=3;
3319  ideal res, res1;
3320  int elems;
3321  ideal null=NULL;
3322  if ((Q==NULL) || (!TEST_OPT_REDSB))
3323  {
3324    elems=idElem(F);
3325    res=kInterRedBba(F,Q,need_retry);
3326  }
3327  else
3328  {
3329    ideal FF=idSimpleAdd(F,Q);
3330    res=kInterRedBba(FF,NULL,need_retry);
3331    idDelete(&FF);
3332    null=idInit(1,1);
3333    if (need_retry)
3334      res1=kNF(null,Q,res,0,KSTD_NF_LAZY);
3335    else
3336      res1=kNF(null,Q,res);
3337    idDelete(&res);
3338    res=res1;
3339    need_retry=1;
3340  }
3341  if (idElem(res)<=1) need_retry=0;
3342  while (need_retry && (counter>0))
3343  {
3344    #ifdef KDEBUG
3345    if (TEST_OPT_DEBUG) { Print("retry counter %d\n",counter); }
3346    #endif
3347    res1=kInterRedBba(res,Q,need_retry);
3348    int new_elems=idElem(res1);
3349    counter -= (new_elems >= elems);
3350    elems = new_elems;
3351    idDelete(&res);
3352    if (idElem(res1)<=1) need_retry=0;
3353    if ((Q!=NULL) && (TEST_OPT_REDSB))
3354    {
3355      if (need_retry)
3356        res=kNF(null,Q,res1,0,KSTD_NF_LAZY);
3357      else
3358        res=kNF(null,Q,res1);
3359      idDelete(&res1);
3360    }
3361    else
3362      res = res1;
3363    if (idElem(res)<=1) need_retry=0;
3364  }
3365  if (null!=NULL) idDelete(&null);
3366  SI_RESTORE_OPT1(save1);
3367  idSkipZeroes(res);
3368  return res;
3369}
3370
3371// returns TRUE if mora should use buckets, false otherwise
3372static BOOLEAN kMoraUseBucket(kStrategy strat)
3373{
3374#ifdef MORA_USE_BUCKETS
3375  if (TEST_OPT_NOT_BUCKETS)
3376    return FALSE;
3377  if (strat->red == redFirst)
3378  {
3379#ifdef NO_LDEG
3380    if (strat->syzComp==0)
3381      return TRUE;
3382#else
3383    if ((strat->homog || strat->honey) && (strat->syzComp==0))
3384      return TRUE;
3385#endif
3386  }
3387  else
3388  {
3389    #ifdef HAVE_RINGS
3390    assume(strat->red == redEcart || strat->red == redRiloc);
3391    #else
3392    assume(strat->red == redEcart);
3393    #endif
3394    if (strat->honey && (strat->syzComp==0))
3395      return TRUE;
3396  }
3397#endif
3398  return FALSE;
3399}
Note: See TracBrowser for help on using the repository browser.