source: git/kernel/kstd2.cc @ 5fdd0f

spielwiese
Last change on this file since 5fdd0f was b130fb, checked in by Hans Schönemann <hannes@…>, 19 years ago
*hannes: gcc-3.4 git-svn-id: file:///usr/local/Singular/svn/trunk@7733 2c84dea3-7e68-4137-9b89-c4e89433aadc
  • Property mode set to 100644
File size: 18.0 KB
Line 
1/****************************************
2*  Computer Algebra System SINGULAR     *
3****************************************/
4/* $Id: kstd2.cc,v 1.2 2005-02-17 09:42:20 Singular Exp $ */
5/*
6*  ABSTRACT -  Kernel: alg. of Buchberger
7*/
8
9// #define PDEBUG 2
10// define to enable tailRings
11#define HAVE_TAIL_RING
12// define if no buckets should be used
13// #define NO_BUCKETS
14
15#include "mod2.h"
16#include "kutil.h"
17#include "structs.h"
18#include "omalloc.h"
19#include "polys.h"
20#include "ideals.h"
21#include "febase.h"
22#include "kstd1.h"
23#include "khstd.h"
24#include "kbuckets.h"
25//#include "cntrlc.h"
26#include "weight.h"
27#include "intvec.h"
28#ifdef HAVE_PLURAL
29#include "gring.h"
30#endif
31// #include "timer.h"
32
33// return -1 if no divisor is found
34//        number of first divisor, otherwise
35int kFindDivisibleByInT(const TSet &T, const unsigned long* sevT,
36                        const int tl, const LObject* L, const int start)
37{
38  unsigned long not_sev = ~L->sev;
39  int j = start;
40  poly p;
41  ring r;
42  L->GetLm(p, r);
43
44  pAssume(~not_sev == p_GetShortExpVector(p, r));
45
46  if (r == currRing)
47  {
48    loop
49    {
50      if (j > tl) return -1;
51#if defined(PDEBUG) || defined(PDIV_DEBUG)
52      if (p_LmShortDivisibleBy(T[j].p, sevT[j],
53                               p, not_sev, r))
54        return j;
55#else
56      if (!(sevT[j] & not_sev) &&
57          p_LmDivisibleBy(T[j].p, p, r))
58        return j;
59#endif
60      j++;
61    }
62  }
63  else
64  {
65    loop
66    {
67      if (j > tl) return -1;
68#if defined(PDEBUG) || defined(PDIV_DEBUG)
69      if (p_LmShortDivisibleBy(T[j].t_p, sevT[j],
70                               p, not_sev, r))
71        return j;
72#else
73      if (!(sevT[j] & not_sev) &&
74          p_LmDivisibleBy(T[j].t_p, p, r))
75        return j;
76#endif
77      j++;
78    }
79  }
80}
81
82// same as above, only with set S
83int kFindDivisibleByInS(const polyset &S, const unsigned long* sev, const int sl, LObject* L)
84{
85  unsigned long not_sev = ~L->sev;
86  poly p = L->GetLmCurrRing();
87  int j = 0;
88
89  pAssume(~not_sev == p_GetShortExpVector(p, currRing));
90  loop
91  {
92    if (j > sl) return -1;
93#if defined(PDEBUG) || defined(PDIV_DEBUG)
94    if (p_LmShortDivisibleBy(S[j], sev[j],
95                             p, not_sev, currRing))
96        return j;
97#else
98    if ( !(sev[j] & not_sev) &&
99         p_LmDivisibleBy(S[j], p, currRing))
100      return j;
101#endif
102    j++;
103  }
104}
105
106/*2
107*  reduction procedure for the homogeneous case
108*  and the case of a degree-ordering
109*/
110int redHomog (LObject* h,kStrategy strat)
111{
112//  if (strat->tl<0) return 1;
113#ifdef KDEBUG
114  if (TEST_OPT_DEBUG)
115  {
116    PrintS("red:");
117    h->wrp();
118    PrintS(" ");
119  }
120#endif
121  int j;
122  loop
123  {
124    // find a poly with which we can reduce
125    h->SetShortExpVector();
126    j = kFindDivisibleByInT(strat->T, strat->sevT, strat->tl, h);
127    if (j < 0)
128    {
129      h->SetpFDeg();
130      return 1;
131    }
132
133    // now we found one which is divisible -- reduce it
134    ksReducePoly(h, &(strat->T[j]), NULL, NULL, strat);
135
136#ifdef KDEBUG
137    if (TEST_OPT_DEBUG)
138    {
139      Print("\nto ", h->t_p);
140      h->wrp();
141      PrintLn();
142    }
143#endif
144    if (h->GetLmTailRing() == NULL)
145    {
146      if (h->lcm!=NULL) pLmFree(h->lcm);
147#ifdef KDEBUG
148      h->lcm=NULL;
149#endif
150      return 0;
151    }
152  }
153}
154
155
156/*2
157*  reduction procedure for the inhomogeneous case
158*  and not a degree-ordering
159*/
160int redLazy (LObject* h,kStrategy strat)
161{
162  if (strat->tl<0) return 1;
163  int at,d,i;
164  int j = 0;
165  int pass = 0;
166  assume(h->pFDeg() == h->FDeg);
167  long reddeg = h->GetpFDeg();
168
169  h->SetShortExpVector();
170  loop
171  {
172    j = kFindDivisibleByInT(strat->T, strat->sevT, strat->tl, h);
173    if (j < 0) return 1;
174
175#ifdef KDEBUG
176    if (TEST_OPT_DEBUG)
177    {
178      PrintS("red:");
179      h->wrp();
180      PrintS(" with ");
181      strat->T[j].wrp();
182    }
183#endif
184
185    ksReducePoly(h, &(strat->T[j]), NULL, NULL, strat);
186
187#ifdef KDEBUG
188    if (TEST_OPT_DEBUG)
189    {
190      PrintS("\nto ");
191      h->wrp();
192      PrintLn();
193    }
194#endif
195
196    if (h->GetLmTailRing() == NULL)
197    {
198      if (h->lcm!=NULL) pLmFree(h->lcm);
199#ifdef KDEBUG
200      h->lcm=NULL;
201#endif
202      return 0;
203    }
204    h->SetShortExpVector();
205    d = h->SetpFDeg();
206    /*- try to reduce the s-polynomial -*/
207    pass++;
208    if (!K_TEST_OPT_REDTHROUGH &&
209        (strat->Ll >= 0) && ((d > reddeg) || (pass > strat->LazyPass)))
210    {
211      h->SetLmCurrRing();
212      at = posInL11(strat->L,strat->Ll,h,strat);
213      if (at <= strat->Ll)
214      {
215        if (kFindDivisibleByInS(strat->S, strat->sevS, strat->sl, h) < 0)
216          return 1;
217#ifdef KDEBUG
218        if (TEST_OPT_DEBUG) Print(" ->L[%d]\n",at);
219#endif
220        enterL(&strat->L,&strat->Ll,&strat->Lmax,*h,at);
221        h->Clear();
222        return -1;
223      }
224    }
225    else if ((TEST_OPT_PROT) && (strat->Ll < 0) && (d != reddeg))
226    {
227      Print(".%d",d);mflush();
228      reddeg = d;
229    }
230  }
231}
232
233/*2
234*  reduction procedure for the sugar-strategy (honey)
235* reduces h with elements from T choosing first possible
236* element in T with respect to the given ecart
237*/
238int redHoney (LObject* h, kStrategy strat)
239{
240  if (strat->tl<0) return 1;
241  assume(h->FDeg == h->pFDeg());
242
243  poly h_p;
244  int i,j,at,pass,ei, ii, h_d;
245  unsigned long not_sev;
246  long reddeg,d;
247
248  pass = j = 0;
249  d = reddeg = h->GetpFDeg() + h->ecart;
250  h->SetShortExpVector();
251  h_p = h->GetLmTailRing();
252  not_sev = ~ h->sev;
253  loop
254  {
255    j = kFindDivisibleByInT(strat->T, strat->sevT, strat->tl, h);
256    if (j < 0) return 1;
257
258    ei = strat->T[j].ecart;
259    ii = j;
260    /*
261     * the polynomial to reduce with (up to the moment) is;
262     * pi with ecart ei
263     */
264    i = j;
265    loop
266    {
267      /*- takes the first possible with respect to ecart -*/
268      i++;
269      if (i > strat->tl)
270        break;
271      if (ei <= h->ecart)
272        break;
273      if ((strat->T[i].ecart < ei) &&
274          p_LmShortDivisibleBy(strat->T[i].GetLmTailRing(), strat->sevT[i],
275                               h_p, not_sev, strat->tailRing))
276      {
277        /*
278         * the polynomial to reduce with is now;
279         */
280        ei = strat->T[i].ecart;
281        ii = i;
282      }
283    }
284
285    /*
286     * end of search: have to reduce with pi
287     */
288    if (!K_TEST_OPT_REDTHROUGH && (pass!=0) && (ei > h->ecart))
289    {
290      h->SetLmCurrRing();
291      /*
292       * It is not possible to reduce h with smaller ecart;
293       * if possible h goes to the lazy-set L,i.e
294       * if its position in L would be not the last one
295       */
296      if (strat->Ll >= 0) /* L is not empty */
297      {
298        at = strat->posInL(strat->L,strat->Ll,h,strat);
299        if(at <= strat->Ll)
300          /*- h will not become the next element to reduce -*/
301        {
302          enterL(&strat->L,&strat->Ll,&strat->Lmax,*h,at);
303#ifdef KDEBUG
304          if (TEST_OPT_DEBUG) Print(" ecart too big: -> L%d\n",at);
305#endif
306          h->Clear();
307          return -1;
308        }
309      }
310    }
311#ifdef KDEBUG
312    if (TEST_OPT_DEBUG)
313    {
314      PrintS("red:");
315      h->wrp();
316      PrintS(" with ");
317      strat->T[ii].wrp();
318    }
319#endif
320    assume(strat->fromT == FALSE);
321
322    ksReducePoly(h, &(strat->T[ii]), NULL, NULL, strat);
323
324#ifdef KDEBUG
325    if (TEST_OPT_DEBUG)
326    {
327      PrintS("\nto ");
328      h->wrp();
329      PrintLn();
330    }
331#endif
332
333    h_p = h->GetLmTailRing();
334    if (h_p == NULL)
335    {
336      if (h->lcm!=NULL) pLmFree(h->lcm);
337#ifdef KDEBUG
338      h->lcm=NULL;
339#endif
340      return 0;
341    }
342    h->SetShortExpVector();
343    not_sev = ~ h->sev;
344    h_d = h->SetpFDeg();
345    /* compute the ecart */
346    if (ei <= h->ecart)
347      h->ecart = d-h_d;
348    else
349      h->ecart = d-h_d+ei-h->ecart;
350    /*
351     * try to reduce the s-polynomial h
352     *test first whether h should go to the lazyset L
353     *-if the degree jumps
354     *-if the number of pre-defined reductions jumps
355     */
356    pass++;
357    d = h_d + h->ecart;
358    if (!K_TEST_OPT_REDTHROUGH && (strat->Ll >= 0) && ((d > reddeg) || (pass > strat->LazyPass)))
359    {
360      h->SetLmCurrRing();
361      at = strat->posInL(strat->L,strat->Ll,h,strat);
362      if (at <= strat->Ll)
363      {
364        if (kFindDivisibleByInS(strat->S, strat->sevS, strat->sl, h) < 0)
365          return 1;
366        enterL(&strat->L,&strat->Ll,&strat->Lmax,*h,at);
367#ifdef KDEBUG
368        if (TEST_OPT_DEBUG)
369          Print(" degree jumped: -> L%d\n",at);
370#endif
371        h->Clear();
372        return -1;
373      }
374    }
375    else if (TEST_OPT_PROT && (strat->Ll < 0) && (d > reddeg))
376    {
377      reddeg = d;
378      Print(".%d",d); mflush();
379    }
380  }
381}
382/*2
383*  reduction procedure for the normal form
384*/
385
386poly redNF (poly h,kStrategy strat)
387{
388  if (h==NULL) return NULL;
389  int j;
390
391  if (0 > strat->sl)
392  {
393    return h;
394  }
395  LObject P(h);
396  P.SetShortExpVector();
397  P.bucket = kBucketCreate(currRing);
398  kBucketInit(P.bucket,P.p,pLength(P.p));
399  loop
400  {
401    j=kFindDivisibleByInS(strat->S,strat->sevS,strat->sl,&P);
402    if (j>=0)
403    {
404      nNormalize(pGetCoeff(P.p));
405#ifdef KDEBUG
406      if (TEST_OPT_DEBUG)
407      {
408        PrintS("red:");
409        wrp(h);
410        PrintS(" with ");
411        wrp(strat->S[j]);
412      }
413#endif
414#ifdef HAVE_PLURAL
415      if (rIsPluralRing(currRing))
416      {
417        number coef;
418        nc_kBucketPolyRed(P.bucket,strat->S[j],&coef);
419        nDelete(&coef);
420      }
421      else
422#endif
423      {
424        number coef;
425        coef=kBucketPolyRed(P.bucket,strat->S[j],pLength(strat->S[j]),strat->kNoether);
426        nDelete(&coef);
427      }
428      h = kBucketGetLm(P.bucket);
429      if (h==NULL)
430      {
431        kBucketDestroy(&P.bucket);
432        return NULL;
433      }
434      P.p=h;
435      P.t_p=NULL;
436      P.SetShortExpVector();
437#ifdef KDEBUG
438      if (TEST_OPT_DEBUG)
439      {
440        PrintS("\nto:");
441        wrp(h);
442        PrintLn();
443      }
444#endif
445    }
446    else
447    {
448      P.p=kBucketClear(P.bucket);
449      kBucketDestroy(&P.bucket);
450      pNormalize(P.p);
451      return P.p;
452    }
453  }
454}
455
456#ifdef KDEBUG
457static int bba_count = 0;
458#endif
459
460ideal bba (ideal F, ideal Q,intvec *w,intvec *hilb,kStrategy strat)
461{
462#ifdef KDEBUG
463  bba_count++;
464  int loop_count = 0;
465#endif
466  om_Opts.MinTrack = 5;
467  int   srmax,lrmax, red_result = 1;
468  int   olddeg,reduc;
469  int hilbeledeg=1,hilbcount=0,minimcnt=0;
470  BOOLEAN withT = FALSE;
471
472  initBuchMoraCrit(strat); /*set Gebauer, honey, sugarCrit*/
473  initBuchMoraPos(strat);
474  initHilbCrit(F,Q,&hilb,strat);
475  initBba(F,strat);
476  /*set enterS, spSpolyShort, reduce, red, initEcart, initEcartPair*/
477  /*Shdl=*/initBuchMora(F, Q,strat);
478  if (strat->minim>0) strat->M=idInit(IDELEMS(F),F->rank);
479  srmax = strat->sl;
480  reduc = olddeg = lrmax = 0;
481
482#ifndef NO_BUCKETS
483  if (!TEST_OPT_NOT_BUCKETS)
484    strat->use_buckets = 1;
485#endif
486
487  // redtailBBa against T for inhomogenous input
488  if (!K_TEST_OPT_OLDSTD)
489    withT = ! strat->homog;
490
491  // strat->posInT = posInT_pLength;
492  kTest_TS(strat);
493
494#ifdef HAVE_TAIL_RING
495  kStratInitChangeTailRing(strat);
496#endif
497
498  /* compute------------------------------------------------------- */
499  while (strat->Ll >= 0)
500  {
501    if (strat->Ll > lrmax) lrmax =strat->Ll;/*stat.*/
502#ifdef KDEBUG
503    loop_count++;
504    if (TEST_OPT_DEBUG) messageSets(strat);
505#endif
506    if (strat->Ll== 0) strat->interpt=TRUE;
507    if (TEST_OPT_DEGBOUND
508        && ((strat->honey && (strat->L[strat->Ll].ecart+pFDeg(strat->L[strat->Ll].p,currRing)>Kstd1_deg))
509            || ((!strat->honey) && (pFDeg(strat->L[strat->Ll].p,currRing)>Kstd1_deg))))
510    {
511      /*
512       *stops computation if
513       * 24 IN test and the degree +ecart of L[strat->Ll] is bigger then
514       *a predefined number Kstd1_deg
515       */
516      while (strat->Ll >= 0) deleteInL(strat->L,&strat->Ll,strat->Ll,strat);
517      break;
518    }
519    /* picks the last element from the lazyset L */
520    strat->P = strat->L[strat->Ll];
521    strat->Ll--;
522
523    if (pNext(strat->P.p) == strat->tail)
524    {
525      // deletes the short spoly
526      pLmFree(strat->P.p);
527      strat->P.p = NULL;
528      poly m1 = NULL, m2 = NULL;
529
530      // check that spoly creation is ok
531      while (strat->tailRing != currRing &&
532             !kCheckSpolyCreation(&(strat->P), strat, m1, m2))
533      {
534        assume(m1 == NULL && m2 == NULL);
535        // if not, change to a ring where exponents are at least
536        // large enough
537        kStratChangeTailRing(strat);
538      }
539      // create the real one
540      ksCreateSpoly(&(strat->P), NULL, strat->use_buckets,
541                    strat->tailRing, m1, m2, strat->R);
542    }
543    else if (strat->P.p1 == NULL)
544    {
545      if (strat->minim > 0)
546        strat->P.p2=p_Copy(strat->P.p, currRing, strat->tailRing);
547      // for input polys, prepare reduction
548      strat->P.PrepareRed(strat->use_buckets);
549    }
550
551    if (TEST_OPT_PROT)
552      message((strat->honey ? strat->P.ecart : 0) + strat->P.pFDeg(),
553              &olddeg,&reduc,strat, red_result);
554
555    /* reduction of the element choosen from L */
556    red_result = strat->red(&strat->P,strat);
557
558    // reduction to non-zero new poly
559    if (red_result == 1)
560    {
561      /* statistic */
562      if (TEST_OPT_PROT) PrintS("s");
563
564      // get the polynomial (canonicalize bucket, make sure P.p is set)
565      strat->P.GetP(strat->lmBin);
566
567      int pos=posInS(strat,strat->sl,strat->P.p,strat->P.ecart);
568
569      // reduce the tail and normalize poly
570      if (TEST_OPT_INTSTRATEGY)
571      {
572        strat->P.pCleardenom();
573        if ((TEST_OPT_REDSB)||(TEST_OPT_REDTAIL))
574        {
575          strat->P.p = redtailBba(&(strat->P),pos-1,strat, withT);
576          strat->P.pCleardenom();
577        }
578      }
579      else
580      {
581        strat->P.pNorm();
582        if ((TEST_OPT_REDSB)||(TEST_OPT_REDTAIL))
583          strat->P.p = redtailBba(&(strat->P),pos-1,strat, withT);
584      }
585
586#ifdef KDEBUG
587      if (TEST_OPT_DEBUG){PrintS("new s:");strat->P.wrp();PrintLn();}
588#endif
589
590      // min_std stuff
591      if ((strat->P.p1==NULL) && (strat->minim>0))
592      {
593        if (strat->minim==1)
594        {
595          strat->M->m[minimcnt]=p_Copy(strat->P.p,currRing,strat->tailRing);
596          p_Delete(&strat->P.p2, currRing, strat->tailRing);
597        }
598        else
599        {
600          strat->M->m[minimcnt]=strat->P.p2;
601          strat->P.p2=NULL;
602        }
603        if (strat->tailRing!=currRing && pNext(strat->M->m[minimcnt])!=NULL)
604          pNext(strat->M->m[minimcnt])
605            = strat->p_shallow_copy_delete(pNext(strat->M->m[minimcnt]),
606                                           strat->tailRing, currRing,
607                                           currRing->PolyBin);
608        minimcnt++;
609      }
610
611      // enter into S, L, and T
612      enterT(strat->P, strat);
613      enterpairs(strat->P.p,strat->sl,strat->P.ecart,pos,strat, strat->tl);
614      // posInS only depends on the leading term
615      strat->enterS(strat->P, pos, strat, strat->tl);
616      if (hilb!=NULL) khCheck(Q,w,hilb,hilbeledeg,hilbcount,strat);
617//      Print("[%d]",hilbeledeg);
618      if (strat->P.lcm!=NULL) pLmFree(strat->P.lcm);
619      if (strat->sl>srmax) srmax = strat->sl;
620    }
621    else if (strat->P.p1 == NULL && strat->minim > 0)
622    {
623      p_Delete(&strat->P.p2, currRing, strat->tailRing);
624    }
625#ifdef KDEBUG
626    memset(&(strat->P), 0, sizeof(strat->P));
627#endif
628    kTest_TS(strat);
629  }
630#ifdef KDEBUG
631  if (TEST_OPT_DEBUG) messageSets(strat);
632#endif
633  /* complete reduction of the standard basis--------- */
634  if (TEST_OPT_REDSB) completeReduce(strat);
635  /* release temp data-------------------------------- */
636  exitBuchMora(strat);
637  if (TEST_OPT_WEIGHTM)
638  {
639    pRestoreDegProcs(pFDegOld, pLDegOld);
640    if (ecartWeights)
641    {
642      omFreeSize((ADDRESS)ecartWeights,(pVariables+1)*sizeof(short));
643      ecartWeights=NULL;
644    }
645  }
646  if (TEST_OPT_PROT) messageStat(srmax,lrmax,hilbcount,strat);
647  if (Q!=NULL) updateResult(strat->Shdl,Q,strat);
648  return (strat->Shdl);
649}
650
651poly kNF2 (ideal F,ideal Q,poly q,kStrategy strat, int lazyReduce)
652{
653  poly   p;
654  int   i;
655
656  if ((idIs0(F))&&(Q==NULL))
657    return pCopy(q); /*F=0*/
658  strat->ak = idRankFreeModule(F);
659  /*- creating temp data structures------------------- -*/
660  BITSET save_test=test;
661  test|=Sy_bit(OPT_REDTAIL);
662  initBuchMoraCrit(strat);
663  strat->initEcart = initEcartBBA;
664  strat->enterS = enterSBba;
665  /*- set S -*/
666  strat->sl = -1;
667  /*- init local data struct.---------------------------------------- -*/
668  /*Shdl=*/initS(F,Q,strat);
669  /*- compute------------------------------------------------------- -*/
670  //if ((TEST_OPT_INTSTRATEGY)&&(lazyReduce==0))
671  {
672    for (i=strat->sl;i>=0;i--)
673      pNorm(strat->S[i]);
674  }
675  kTest(strat);
676  if (TEST_OPT_PROT) { PrintS("r"); mflush(); }
677  p = redNF(pCopy(q),strat);
678  if ((p!=NULL)&&(lazyReduce==0))
679  {
680    if (TEST_OPT_PROT) { PrintS("t"); mflush(); }
681    p = redtailBba(p,strat->sl,strat);
682  }
683  /*- release temp data------------------------------- -*/
684  omfree(strat->sevS);
685  omfree(strat->ecartS);
686  omfree(strat->T);
687  omfree(strat->sevT);
688  omfree(strat->R);
689  omfree(strat->S_2_R);
690  omfree(strat->L);
691  omfree(strat->B);
692  omfree(strat->fromQ);
693  idDelete(&strat->Shdl);
694  test=save_test;
695  if (TEST_OPT_PROT) PrintLn();
696  return p;
697}
698
699ideal kNF2 (ideal F,ideal Q,ideal q,kStrategy strat, int lazyReduce)
700{
701  poly   p;
702  int   i;
703  ideal res;
704
705  if (idIs0(q))
706    return idInit(IDELEMS(q),q->rank);
707  if ((idIs0(F))&&(Q==NULL))
708    return idCopy(q); /*F=0*/
709  strat->ak = idRankFreeModule(F);
710  /*- creating temp data structures------------------- -*/
711  BITSET save_test=test;
712  test|=Sy_bit(OPT_REDTAIL);
713  initBuchMoraCrit(strat);
714  strat->initEcart = initEcartBBA;
715  strat->enterS = enterSBba;
716  /*- set S -*/
717  strat->sl = -1;
718  /*- init local data struct.---------------------------------------- -*/
719  /*Shdl=*/initS(F,Q,strat);
720  /*- compute------------------------------------------------------- -*/
721  res=idInit(IDELEMS(q),q->rank);
722  //if ((TEST_OPT_INTSTRATEGY)&&(lazyReduce==0))
723  {
724    for (i=strat->sl;i>=0;i--)
725      pNorm(strat->S[i]);
726  }
727  for (i=IDELEMS(q)-1; i>=0; i--)
728  {
729    if (q->m[i]!=NULL)
730    {
731      if (TEST_OPT_PROT) { PrintS("r");mflush(); }
732      p = redNF(pCopy(q->m[i]),strat);
733      if ((p!=NULL)&&(lazyReduce==0))
734      {
735        if (TEST_OPT_PROT) { PrintS("t"); mflush(); }
736        p = redtailBba(p,strat->sl,strat);
737      }
738      res->m[i]=p;
739    }
740    //else
741    //  res->m[i]=NULL;
742  }
743  /*- release temp data------------------------------- -*/
744  omfree(strat->sevS);
745  omfree(strat->ecartS);
746  omfree(strat->T);
747  omfree(strat->sevT);
748  omfree(strat->R);
749  omfree(strat->S_2_R);
750  omfree(strat->L);
751  omfree(strat->B);
752  omfree(strat->fromQ);
753  idDelete(&strat->Shdl);
754  test=save_test;
755  if (TEST_OPT_PROT) PrintLn();
756  return res;
757}
Note: See TracBrowser for help on using the repository browser.