Changeset 64ced6 in git


Ignore:
Timestamp:
Aug 5, 1997, 3:04:06 PM (27 years ago)
Author:
Hans Schönemann <hannes@…>
Branches:
(u'fieker-DuVal', '117eb8c30fc9e991c4decca4832b1d19036c4c65')(u'spielwiese', '648d28f488f6ff08f5607ff229b9ad9e4a5b93c2')
Children:
5cbec62f96e0342b6ce52432c21b2b7e548b8524
Parents:
927ed626c0e1c0fe73df0b8700d631518ccf69be
Message:
* hannes/brunko: integrated stdtrace (activate by #define STDTRACE)
                 into main source tree
                 (Makefile.in extra.cc kstd1.cc kstd1.h kstd2.cc kstd2.h)


git-svn-id: file:///usr/local/Singular/svn/trunk@601 2c84dea3-7e68-4137-9b89-c4e89433aadc
Location:
Singular
Files:
6 edited

Legend:

Unmodified
Added
Removed
  • Singular/Makefile.in

    r927ed62 r64ced6  
    8181    ipassign.cc ipconv.cc ipid.cc iplib.cc \
    8282    ipprint.cc ipshell.cc khstd.cc kstdfac.cc \
    83     kstd1.cc kstd2.cc kutil.cc lists.cc \
     83    comm.cc kstd1.cc kstd2.cc kutil.cc lists.cc \
    8484    longalg.cc longrat.cc \
    8585    longrat0.cc maps.cc matpol.cc misc.cc \
     
    105105        febase.h ipshell.h mmprivat.h shortfl.h tok.h \
    106106        ffields.h khstd.h silink.h \
    107         fglm.h kstd1.h modulop.h sing_dbm.h weight.h \
     107        fglm.h comm.h kstd1.h modulop.h sing_dbm.h weight.h \
    108108        fglmvec.h kstd2.h mpsr.h sing_mp.h \
    109109        kstdfac.h mpsr_Get.h spolys.h \
     
    126126     febase.o feread.o timer.o intvec.o attrib.o lists.o\
    127127     longrat.o longrat0.o misc.o ring.o numbers.o maps.o\
    128      hilb.o kstd1.o kstd2.o kutil.o khstd.o kstdfac.o modulop.o spolys.o\
     128     hilb.o comm.o kstd1.o kstd2.o kutil.o khstd.o kstdfac.o modulop.o spolys.o\
    129129     ideals.o subexpr.o hdegree.o hutil.o ffields.o shortfl.o \
    130130     longalg.o spolys0.o syz.o syz0.o syz1.o weight.o weight0.o \
     
    318318     febase.og feread.og timer.og intvec.og attrib.og lists.og\
    319319     longrat.og longrat0.og misc.og ring.og numbers.og maps.og\
    320      hilb.og kstd1.og kstd2.og kutil.og khstd.og kstdfac.og modulop.og \
     320     hilb.og comm.og kstd1.og kstd2.og kutil.og khstd.og kstdfac.og modulop.og \
    321321     spolys.og ideals.og subexpr.og hdegree.og hutil.og ffields.og shortfl.og \
    322322     longalg.og spolys0.og syz.og syz0.og syz1.og weight.og \
  • Singular/extra.cc

    r927ed62 r64ced6  
    22*  Computer Algebra System SINGULAR      *
    33*****************************************/
    4 /* $Id: extra.cc,v 1.16 1997-07-11 14:27:52 Singular Exp $ */
     4/* $Id: extra.cc,v 1.17 1997-08-05 13:04:02 Singular Exp $ */
    55/*
    66* ABSTRACT: general interface to internals of Singular ("system" command)
     
    4747#include "kstd1.h"
    4848#include "syz.h"
     49#ifdef STDTRACE
     50//#include "comm.h"
     51#endif
    4952
    5053#ifdef HAVE_FACTORY
     
    514517    else
    515518#endif   
     519#ifdef STDTRACE
     520    /*==================== trace =============================*/
     521    /* Parameter : Ideal, Liste mit Links. */
     522    if(strcmp((char*)(h->Data()),"stdtrace")==0)
     523      {
     524        if ((h->next!=NULL) &&(h->next->Typ()==IDEAL_CMD))
     525        {
     526          leftv root  = NULL,
     527                ptr   = NULL,
     528                lv    = NULL;
     529          lists l     = NULL;
     530          ideal I     = (ideal)(h->next->Data());
     531          lists links = (lists)(h->next->next->Data());
     532          tHomog hom  = testHomog;
     533          int rw      = (int)(h->next->next->next->Data());
     534 
     535          if(I==NULL)
     536            PrintS("I==NULL\n");
     537          for(int i=0; i <= links->nr ; i++)
     538          {
     539            lv = (leftv)Alloc0(sizeof(sleftv));
     540            lv->Copy(&(links->m[i]));
     541            if(root==NULL)
     542            root=lv;
     543            if(ptr==NULL)
     544            {
     545              ptr=lv;
     546              ptr->next=NULL;
     547            }
     548            else
     549            {
     550              ptr->next=lv;
     551              ptr=lv;
     552            }
     553          }
     554          ptr->next=NULL;
     555          l=TraceStd(root,rw,I,currQuotient,testHomog,NULL);
     556          idSkipZeroes(((ideal)l->m[0].Data()));
     557          res->rtyp=LIST_CMD;
     558          res->data=(void *) l;
     559          res->next=NULL;
     560          root->CleanUp();
     561          Free(root,sizeof(sleftv));
     562          return FALSE;
     563        }
     564        else
     565         WerrorS("ideal expected");
     566      }
     567    else 
     568#endif   
    516569/*============================================================*/
    517570      WerrorS("not implemented\n");
  • Singular/kstd1.cc

    r927ed62 r64ced6  
    22*  Computer Algebra System SINGULAR     *
    33****************************************/
    4 /* $Id: kstd1.cc,v 1.8 1997-08-01 10:53:07 Singular Exp $ */
     4/* $Id: kstd1.cc,v 1.9 1997-08-05 13:04:03 Singular Exp $ */
    55/*
    66* ABSTRACT:
     
    2626#include "tok.h"
    2727#include "lists.h"
    28 
     28#ifdef STDTRACE
     29#include "comm.h"
     30#endif
    2931//#include "ipprint.h"
    3032
     
    108110    (*h).p = spSpolyRed(*with,(*h).p,strat->kNoether);
    109111  }
    110   pTest((*h).p);
    111112}
    112113
     
    248249  int pass = 0;
    249250
    250   pTest(h->p);
    251251  if (TEST_OPT_CANCELUNIT) cancelunit(h);
    252252  d = pFDeg((*h).p)+(*h).ecart;
    253253  reddeg = strat->LazyDegree+d;
    254   pTest(h->p);
    255254  loop
    256255  {
    257     pTest(h->p);
    258256    if (j > strat->tl)
    259257    {
     
    336334      }
    337335      doRed(h,&pi,strat->fromT,strat);
    338       pTest(h->p);
    339336      strat->fromT=FALSE;
    340337      if (TEST_OPT_DEBUG)
     
    17061703  return o+(*kModW)[i-1];
    17071704}
    1708 
    17091705ideal std(ideal F, ideal Q, tHomog h,intvec ** w, intvec *hilb,int syzComp,
    17101706          int newIdeal)
     
    17281724  )
    17291725  {
    1730     if (idRankFreeModule(F)==0)
    1731     {
    1732       h = (tHomog)idHomIdeal(F,Q);
     1726    if (idRankFreeModule(F)==0)       
     1727    {
     1728      h = (tHomog)idHomIdeal(F,Q);   
    17331729      w=NULL;
    17341730    }
    17351731    else
    1736       h = (tHomog)idHomModule(F,Q,w);
    1737     //Print("test homog:%d\n",h);
     1732      h = (tHomog)idHomModule(F,Q,w); 
     1733    //Print("test homog:%d\n",h);     
    17381734    //if ((h==isHomog)&&(w!=NULL)&&(*w!=NULL))
    17391735    //{
    17401736    //  (*w)->show();
    17411737    //  PrintLn();
    1742     //  if (F!=NULL) jjPRINT_MA0(idModule2Matrix(idCopy(F)),sNoName);
     1738    //  if (F!=NULL) jjPRINT_MA0(idModule2Matrix(idCopy(F)),sNoName);   
    17431739    //}
    17441740  }
     
    17481744  if (h==isHomog)
    17491745  {
    1750     if ((w!=NULL) && (*w!=NULL))
     1746    if ((w!=NULL) && (*w!=NULL))     
    17511747    {
    17521748      kModW = *w;
     
    17631759  {
    17641760    if (w!=NULL)
    1765       r=mora(F,Q,*w,hilb,strat);
     1761      r=mora(F,Q,*w,hilb,strat);     
    17661762    else
    17671763      r=mora(F,Q,NULL,hilb,strat);
     
    17691765  else
    17701766  {
     1767    #ifdef STDTRACE
     1768    lists l;
     1769    if (w!=NULL)
     1770      l=bbaLink(F,Q,*w,hilb,strat);
     1771    else
     1772      l=bbaLink(F,Q,NULL,hilb,strat);
     1773    r=(ideal)(l->m[0].data);
     1774    l->m[0].data=NULL;
     1775    l->Clean();
     1776    #else
    17711777    if (w!=NULL)
    17721778      r=bba(F,Q,*w,hilb,strat);
    17731779    else
    17741780      r=bba(F,Q,NULL,hilb,strat);
     1781    #endif
    17751782  }
    17761783#ifdef KDEBUG
     
    17901797  return r;
    17911798}
     1799
     1800//##############################################################
     1801//##############################################################
     1802//##############################################################
     1803//##############################################################
     1804//##############################################################
     1805
     1806#ifdef STDTRACE
     1807lists TraceStd(leftv lv,int rw, ideal F, ideal Q, tHomog h,intvec ** w, intvec *hilb,int syzComp,
     1808          int newIdeal)
     1809{
     1810  lists l;
     1811  ideal r;
     1812  stdLink stdTrace=(stdLink) Alloc0(sizeof(skstdLink));
     1813  BOOLEAN b=pLexOrder,toReset=FALSE;
     1814  BOOLEAN delete_w=(w==NULL);
     1815  kStrategy strat=(kStrategy)Alloc0(sizeof(skStrategy));
     1816
     1817  if(!TEST_OPT_RETURN_SB)
     1818    strat->syzComp = syzComp;
     1819  if (TEST_OPT_SB_1)
     1820    strat->newIdeal = newIdeal;
     1821  strat->LazyPass=32000;
     1822  strat->LazyDegree = 10;
     1823//   if(stdTrace!=NULL)
     1824//     stdTrace->GetPrimes(F,primes);  // Array mit Primzahlen muß geordnet sein !
     1825
     1826  if ((h==testHomog)
     1827#ifdef DRING
     1828  && (!pDRING)
     1829#endif
     1830  )
     1831  {
     1832    if (idRankFreeModule(F)==0)
     1833    {
     1834      h = (tHomog)idHomIdeal(F,Q);
     1835      w=NULL;
     1836    }
     1837    else
     1838      h = (tHomog)idHomModule(F,Q,w);
     1839  }
     1840#ifdef DRING
     1841  if (pDRING) h=isNotHomog;
     1842#endif
     1843  if (h==isHomog)
     1844  {
     1845    if ((w!=NULL) && (*w!=NULL))
     1846    {
     1847      kModW = *w;
     1848      pOldFDeg = pFDeg;
     1849      pFDeg = kModDeg;
     1850      toReset = TRUE;
     1851    }
     1852    pLexOrder = TRUE;
     1853    if (hilb==NULL) strat->LazyPass*=2;
     1854  }
     1855  strat->homog=h;
     1856  spSet(currRing);
     1857//   if (pOrdSgn==-1)
     1858//   {
     1859//     if (w!=NULL)
     1860//       r=mora(F,Q,*w,hilb,strat);
     1861//     else
     1862//       r=mora(F,Q,NULL,hilb,strat);
     1863//   }
     1864//   else
     1865  {
     1866    stdTrace->Init(lv,rw);
     1867    if(w==NULL)
     1868      l=bbaLink(F,Q,NULL,hilb,strat,stdTrace);
     1869    else
     1870      l=bbaLink(F,Q,*w,hilb,strat,stdTrace);
     1871    r=(ideal) (l->m[0].Data());
     1872  }
     1873#ifdef KDEBUG
     1874  int i;
     1875  for (i=0; i<IDELEMS(r); i++) pTest(r->m[i]);
     1876#endif
     1877  if (toReset)
     1878  {
     1879    kModW = NULL;
     1880    pFDeg = pOldFDeg;
     1881  }
     1882  pLexOrder = b;
     1883//Print("%d reductions canceled \n",strat->cel);
     1884  HCord=strat->HCord;
     1885  Free((ADDRESS)strat,sizeof(skStrategy));
     1886  if ((delete_w)&&(w!=NULL)&&(*w!=NULL)) delete *w;
     1887  if(stdTrace!=NULL)
     1888  {
     1889    stdTrace->Kill();
     1890    Free(stdTrace, sizeof(skstdLink));
     1891  }
     1892
     1893  return l;
     1894}
     1895#endif
    17921896
    17931897lists min_std(ideal F, ideal Q, tHomog h,intvec ** w, intvec *hilb,int syzComp,
     
    18591963  else
    18601964  {
     1965  #ifdef STDTRACE
     1966    lists rl;
     1967    if (w!=NULL)
     1968      rl=bbaLink(F, Q, *w, hilb, strat, NULL);
     1969    else
     1970      rl=bbaLink(F, Q, NULL, hilb, strat, NULL);
     1971    r=(ideal)(rl->m[0].data);
     1972    rl->m[0].data=NULL;
     1973    rl->Clean();
     1974  #else
    18611975    if (w!=NULL)
    18621976      r=bba(F,Q,*w,hilb,strat);
    18631977    else
    18641978      r=bba(F,Q,NULL,hilb,strat);
     1979  #endif
    18651980  }
    18661981#ifdef KDEBUG
  • Singular/kstd1.h

    r927ed62 r64ced6  
    44*  Computer Algebra System SINGULAR     *
    55****************************************/
    6 /* $Id: kstd1.h,v 1.3 1997-04-09 12:19:52 Singular Exp $ */
     6/* $Id: kstd1.h,v 1.4 1997-08-05 13:04:04 Singular Exp $ */
    77/*
    88* ABSTRACT
     
    2525ideal std(ideal F, ideal Q, tHomog h, intvec ** w,intvec *hilb=NULL,
    2626          int syzComp=0,int newIdeal=0);
     27#ifdef STDTRACE
     28lists TraceStd(leftv,int , ideal F, ideal Q, tHomog h, intvec ** w,intvec *hilb=NULL,
     29          int syzComp=0,int newIdeal=0);
     30#endif         
    2731
    2832/* the following global data are defined in kutil.cc */
  • Singular/kstd2.cc

    r927ed62 r64ced6  
    22*  Computer Algebra System SINGULAR     *
    33****************************************/
    4 /* $Id: kstd2.cc,v 1.6 1997-07-31 14:58:31 Singular Exp $ */
     4/* $Id: kstd2.cc,v 1.7 1997-08-05 13:04:05 Singular Exp $ */
    55/*
    66*  ABSTRACT -  Kernel: alg. of Buchberger
     
    2323#include "intvec.h"
    2424#include "tok.h"
     25#ifdef STDTRACE
     26#include "comm.h"
     27#include "lists.h"
     28#endif
     29// #include "timer.h"
    2530
    2631/*2
     
    877882  }
    878883}
     884
     885#ifdef STDTRACE
     886lists bbaLink (ideal F, ideal Q,intvec *w,intvec *hilb,kStrategy strat, stdLink stdTrace)
     887{
     888  int oldLl;
     889  int srmax,lrmax;
     890  int olddeg,reduc;
     891  int anzTupel=0, anzNew = 0, anzSkipped=0;
     892#ifdef SDRING
     893  polyset aug=(polyset)Alloc(setmax*sizeof(poly));
     894  int augmax=setmax, augl=-1;
     895  poly oldLcm=NULL;
     896#endif
     897  int hilbeledeg=1,hilbcount=0,minimcnt=0;
     898
     899  if(stdTrace!=NULL) stdTrace->Start(strat);
     900
     901  initBuchMoraCrit(strat); /*set Gebauer, honey, sugarCrit*/
     902  initHilbCrit(F,Q,&hilb,strat);
     903  initBba(F,strat);
     904  initBuchMoraPos(strat);
     905  /*set enterS, spSpolyShort, reduce, red, initEcart, initEcartPair*/
     906  /*Shdl=*/initBuchMora(F, Q,strat);
     907  if (strat->minim>0)
     908  {
     909    strat->M=idInit(IDELEMS(F),F->rank);
     910  }
     911  srmax = strat->sl;
     912  reduc = olddeg = lrmax = 0;
     913  /* compute------------------------------------------------------- */
     914  while ((stdTrace!=NULL && !stdTrace->CheckEnd(strat)) || (stdTrace == NULL && strat->Ll>=0))
     915    {
     916//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
     917      if(stdTrace!=NULL && stdTrace->Receive)
     918        {
     919          stdTrace->ReceiveMsg();
     920          stdTrace->ParseMessage(strat);
     921        }
     922//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
     923      if((stdTrace!=NULL && stdTrace->Verwaltung) || (stdTrace == NULL))
     924        {
     925          if (strat->Ll > lrmax) lrmax =strat->Ll;/*stat.*/
     926          if (TEST_OPT_DEBUG) messageSets(strat);
     927          //test_int_std(strat->kIdeal);
     928          if (strat->Ll== 0) strat->interpt=TRUE;
     929          if (TEST_OPT_DEGBOUND
     930              && ((strat->honey && (strat->L[strat->Ll].ecart+pFDeg(strat->L[strat->Ll].p)>Kstd1_deg))
     931                  || ((!strat->honey) && (pFDeg(strat->L[strat->Ll].p)>Kstd1_deg))))
     932            {
     933              /*
     934               *stops computation if
     935               * 24 IN test and the degree +ecart of L[strat->Ll] is bigger then
     936               *a predefined number Kstd1_deg
     937               */
     938              while (strat->Ll >= 0) deleteInL(strat->L,&strat->Ll,strat->Ll,strat);
     939              break;
     940            }
     941        }
     942//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
     943      if((stdTrace!=NULL && stdTrace->TupelL) || (stdTrace == NULL ))
     944        {
     945          /* picks the last element from the lazyset L */
     946          strat->P = strat->L[strat->Ll];
     947          anzTupel++;
     948          strat->Ll--;
     949          if(stdTrace!=NULL && stdTrace->TupelStore)
     950            {
     951              if (TEST_OPT_PROT) PrintS(":");
     952              stdTrace->Store(strat->P);
     953              strat->P.p=NULL;
     954              anzSkipped++;
     955            }
     956        }
     957//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
     958      if((stdTrace!=NULL && stdTrace->SPoly) || (stdTrace == NULL))
     959        {
     960          kTest(strat);
     961          if (pNext(strat->P.p) == strat->tail)
     962            {
     963              /* deletes the short spoly and computes */
     964              pFree1(strat->P.p);
     965              /* the real one */
     966              strat->P.p = spSpolyCreate(strat->P.p1,strat->P.p2,strat->kNoether);
     967            }
     968          if((strat->P.p1==NULL) && (strat->minim>0))
     969            strat->P.p2=pCopy(strat->P.p);
     970        }
     971//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
     972      if((stdTrace!=NULL && stdTrace->Reduzieren) || (stdTrace == NULL))
     973        {
     974#ifdef SDRING
     975          if (strat->P.p != NULL)
     976#endif
     977            {
     978              if (strat->honey)
     979                {
     980                  if (TEST_OPT_PROT) message(strat->P.ecart+pFDeg(strat->P.p),&olddeg,&reduc,strat);
     981                }
     982              else
     983                {
     984                  if (TEST_OPT_PROT) message(pFDeg(strat->P.p),&olddeg,&reduc,strat);
     985                }
     986              /* reduction of the element choosen from L */
     987              oldLl=strat->Ll;
     988              strat->red(&strat->P,strat);
     989              if(stdTrace!=NULL && stdTrace->TupelPosition)
     990                stdTrace->CheckPosition(strat,oldLl);
     991              if((stdTrace!=NULL && stdTrace->TupelMelden))
     992                stdTrace->SendTupel(strat);
     993              if(stdTrace!=NULL && strat->P.p!=NULL && stdTrace->Modus==ModCheck)
     994                anzNew++;
     995            }
     996          if (strat->P.p != NULL)
     997            {
     998#ifdef SDRING
     999              aug[0]=strat->P.p;
     1000              augl=0;
     1001              if (pSDRING)
     1002                {
     1003                  oldLcm=strat->P.lcm;
     1004#ifdef SRING
     1005                  if (pSRING) psAug(pCopy(strat->P.p),pOne(),&aug,&augl,&augmax);
     1006#endif
     1007#ifdef DRING
     1008                  if (pDRING) pdAug(pCopy(strat->P.p),&aug,&augl,&augmax);
     1009#endif
     1010                  if (TEST_OPT_DEBUG)
     1011                    {
     1012                      PrintS(" aug of ");
     1013                      wrp(aug[0]);
     1014                      PrintLn();
     1015                      int iiaug=augl;
     1016                      while (iiaug>=0)
     1017                        {
     1018                          Print(" to %d:",iiaug);
     1019                          wrp(aug[iiaug]);
     1020                          PrintLn();
     1021                          iiaug--;
     1022                        }
     1023                    }
     1024                }
     1025              for (augl++;augl != 0;)
     1026                {
     1027                  strat->P.p=aug[--augl];
     1028                  aug[augl]=NULL;
     1029                  if (pSDRING)
     1030                    {
     1031                      if (oldLcm==NULL) strat->P.lcm=NULL;
     1032                      else  strat->P.lcm=pCopy1(oldLcm);
     1033                    }
     1034                  if ((augl!=0)&&(strat->P.p!=NULL))
     1035                    strat->red(&strat->P,strat);
     1036                  if (strat->P.p != NULL)
     1037                    {
     1038#endif
     1039                      /* statistic */
     1040                      if (TEST_OPT_PROT) PrintS("s");
     1041                      /* enter P.p into s and L */
     1042                      {
     1043                        int pos=posInS(strat->S,strat->sl,strat->P.p);
     1044#ifdef SDRING
     1045                        if ((pSDRING) && (pos<=strat->sl)&& (pComparePolys(strat->P.p,strat->S[pos])))
     1046                          {
     1047                            if (TEST_OPT_PROT)
     1048                              PrintS("d");
     1049                          }
     1050                        else
     1051#endif
     1052                          {
     1053                            if (TEST_OPT_INTSTRATEGY)
     1054                              {
     1055                                if ((!TEST_OPT_MINRES)||(strat->syzComp==0)||(!strat->homog))
     1056                                  {
     1057                                    strat->P.p = redtailBba(strat->P.p,pos-1,strat);
     1058                                    pCleardenom(strat->P.p);
     1059                                  }
     1060                              }
     1061                            else
     1062                              {
     1063                                pNorm(strat->P.p);
     1064                                if ((!TEST_OPT_MINRES)||(strat->syzComp==0)||(!strat->homog))
     1065                                  {
     1066                                    strat->P.p = redtailBba(strat->P.p,pos-1,strat);
     1067                                  }
     1068                              }
     1069                            if (TEST_OPT_DEBUG)
     1070                              {
     1071                                PrintS("new s:");
     1072                                wrp(strat->P.p);
     1073                                PrintLn();
     1074                              }
     1075                            if((strat->P.p1==NULL) && (strat->minim>0))
     1076                              {
     1077                                if (strat->minim==1)
     1078                                  {
     1079                                    strat->M->m[minimcnt]=pCopy(strat->P.p);
     1080                                    pDelete(&strat->P.p2);
     1081                                  }
     1082                                else
     1083                                  {
     1084                                    strat->M->m[minimcnt]=strat->P.p2;
     1085                                    strat->P.p2=NULL;
     1086                                  }
     1087                                minimcnt++;
     1088                              }
     1089                            enterpairs(strat->P.p,strat->sl,strat->P.ecart,pos,strat);
     1090                            if (strat->sl==-1) pos=0;
     1091                            else pos=posInS(strat->S,strat->sl,strat->P.p);
     1092                            strat->enterS(strat->P,pos,strat);
     1093                          }
     1094                        if (hilb!=NULL)
     1095                          {  // xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
     1096                            oldLl=strat->Ll;
     1097                            khCheck(Q,w,hilb,hilbeledeg,hilbcount,strat);
     1098                            if(stdTrace!=NULL)
     1099                              stdTrace->CheckHilb(strat,oldLl);
     1100                          }
     1101                      }
     1102                      if (strat->P.lcm!=NULL) pFree1(strat->P.lcm);
     1103#ifdef SDRING
     1104                    }
     1105                }
     1106              /* delete the old pair */
     1107              if (pSDRING &&(oldLcm!=NULL)) pFree1(oldLcm);
     1108#endif
     1109              if (strat->sl>srmax) srmax = strat->sl;
     1110            }
     1111          if(stdTrace!=NULL && stdTrace->TupelTesten)
     1112            stdTrace->TupelDifferent(strat);
     1113        }
     1114#ifdef KDEBUG
     1115      strat->P.lcm=NULL;
     1116#endif
     1117      kTest(strat);
     1118    }
     1119  if(stdTrace !=NULL)
     1120    if(TEST_OPT_PROT)
     1121      {
     1122        Print("\n(Tupel  Skipped  New) = (%i  %i  %i)\n",anzTupel, anzSkipped, anzNew);
     1123      }
     1124  if((stdTrace!=NULL && stdTrace->ResultSend) || (stdTrace == NULL))
     1125    {
     1126      if (TEST_OPT_DEBUG) messageSets(strat);
     1127      /* complete reduction of the standard basis--------- */
     1128      if (TEST_OPT_REDSB) completeReduce(strat);
     1129      /* release temp data-------------------------------- */
     1130      exitBuchMora(strat);
     1131      if (TEST_OPT_WEIGHTM)
     1132        {
     1133          pFDeg=pFDegOld;
     1134          pLDeg=pLDegOld;
     1135          if (ecartWeights)
     1136            {
     1137              Free((ADDRESS)ecartWeights,(pVariables+1)*sizeof(short));
     1138              ecartWeights=NULL;
     1139            }
     1140        }
     1141#ifdef SDRING
     1142      Free((ADDRESS)aug,augmax*sizeof(poly));
     1143#endif
     1144      if (TEST_OPT_PROT) messageStat(srmax,lrmax,hilbcount,strat);
     1145      if (Q!=NULL) updateResult(strat->Shdl,Q,strat);
     1146    }
     1147  if(stdTrace!=NULL)
     1148    stdTrace->End(strat);
     1149  lists l=(lists)Alloc(sizeof(slists));
     1150  l->Init(2);
     1151  l->m[0].rtyp = IDEAL_CMD;
     1152  l->m[0].data = (void *) strat->Shdl;
     1153   if(stdTrace!=NULL )
     1154     {
     1155       l->m[1].rtyp = LIST_CMD;
     1156       l->m[1].data = (void *)stdTrace->RestTupel();
     1157     }
     1158  return (l);
     1159}
     1160
     1161#else
    8791162
    8801163ideal bba (ideal F, ideal Q,intvec *w,intvec *hilb,kStrategy strat)
     
    10841367  return (strat->Shdl);
    10851368}
     1369#endif
    10861370
    10871371poly kNF2 (ideal F,ideal Q,poly q,kStrategy strat, int lazyReduce)
  • Singular/kstd2.h

    r927ed62 r64ced6  
    44*  Computer Algebra System SINGULAR     *
    55****************************************/
    6 /* $Id: kstd2.h,v 1.3 1997-04-09 12:19:53 Singular Exp $ */
     6/* $Id: kstd2.h,v 1.4 1997-08-05 13:04:06 Singular Exp $ */
    77/*
    88* ABSTRACT -  Kernel: alg. of Buchberger
    99*/
    1010#include "structs.h"
    11 
     11#ifdef STDTRACE
     12#include "comm.h"
     13#endif
    1214/*2
    1315*input: F: a set (array) of polys with <= Fmax entries (0..Fmax-1)
     
    1517*output:*S: the standard base: a set (array) with <= *Smax+1 entries (0..*Smax)
    1618*/
     19#ifdef STDTRACE
     20lists bbaLink(ideal F, ideal Q, intvec *w, intvec *h, kStrategy strat, stdLink =NULL);
     21#else
    1722ideal bba (ideal F, ideal Q,intvec *w,intvec *hilb,kStrategy strat);
     23#endif
    1824poly kNF2 (ideal F, ideal Q, poly q, kStrategy strat, int lazyReduce);
    1925ideal kNF2 (ideal F,ideal Q,ideal q, kStrategy strat, int lazyReduce);
Note: See TracChangeset for help on using the changeset viewer.