Changeset 24d587 in git


Ignore:
Timestamp:
Dec 20, 2000, 12:15:50 PM (22 years ago)
Author:
Olaf Bachmann <obachman@…>
Branches:
(u'spielwiese', '0d6b7fcd9813a1ca1ed4220cfa2b104b97a0a003')
Children:
c22d845dacb42bdd0a798a7eb2606d8e9f6f6095
Parents:
bad9f3c06133001d0c55551cbf4faf2ca805670e
Message:
* clean-up[ of LDeg/FDeg stuff
* tailRing for local homg


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

Legend:

Unmodified
Added
Removed

  • Singular/LIB/surf.lib

    rbad9f3 r24d587  
    1 // $Id: surf.lib,v 1.13 2000-12-19 15:05:43 anne Exp $
     1// $Id: surf.lib,v 1.14 2000-12-20 11:15:50 obachman Exp $
    22//
    33// author : Hans Schoenemann
    44//
    55///////////////////////////////////////////////////////////////////////////////
    6 version="$Id: surf.lib,v 1.13 2000-12-19 15:05:43 anne Exp $";
     6version="$Id: surf.lib,v 1.14 2000-12-20 11:15:50 obachman Exp $";
    77category="Visualization";
    88info="
    … …  
    4646RETURN: nothing
    4747NOTE: requires the external program 'surf' to be installed
     48      @*If the (string) variable extra_surf_opts is defined, the the value of
     49      this
    4850EXAMPLE: example plot; shows an example
    4951"

  • Singular/Makefile.in

    rbad9f3 r24d587  
    119119
    120120# normal C source files
    121 CSOURCES=weight0.c fegetopt.c fereadl.c page.c feOpenWinntUrl.c dError.c mmstd.c
     121CSOURCES=weight0.c fegetopt.c fereadl.c page.c feOpenWinntUrl.c dError.c mmstd.c 
    122122
    123123# C++ sources which are used if part of the kernel are dynamically linked

  • Singular/kInline.cc

    rbad9f3 r24d587  
    77 *  Author:  obachman (Olaf Bachmann)
    88 *  Created: 8/00
    9  *  Version: $Id: kInline.cc,v 1.20 2000-12-19 18:31:40 obachman Exp $
     9 *  Version: $Id: kInline.cc,v 1.21 2000-12-20 11:15:42 obachman Exp $
    1010 *******************************************************************/
    1111#ifndef KINLINE_CC
    … …  
    2020
    2121#define HAVE_TAIL_BIN
    22 // Hmm ... this I don't understand:
    23 // with HAVE_LM_BIN, cyclic_7 is appr. 10% slower (on Intel)
     22// This doesn't really work, fixme, if necessary
    2423// #define HAVE_LM_BIN
    2524
    26 KINLINE skStrategy::skStrategy()
    27 {
    28   memset(this, 0, sizeof(skStrategy));
    29   tailRing = currRing;
    30   P.tailRing = currRing;
    31   tl = -1;
    32   sl = -1;
    33 #ifdef HAVE_LM_BIN
    34   lmBin = omGetStickyBinOfBin(currRing->PolyBin);
    35 #endif
    36 #ifdef HAVE_TAIL_BIN
    37   tailBin = omGetStickyBinOfBin(currRing->PolyBin);
    38 #endif
    39   pOrigFDeg = pFDeg;
    40   pOrigLDeg = pLDeg;
    41 }
    42 
    43 KINLINE skStrategy::~skStrategy()
    44 {
    45   if (lmBin != NULL)
    46     omMergeStickyBinIntoBin(lmBin, currRing->PolyBin);
    47   if (tailBin != NULL)
    48     omMergeStickyBinIntoBin(tailBin,
    49                             (tailRing != NULL ? tailRing->PolyBin:
    50                              currRing->PolyBin));
    51   if (currRing != tailRing)
    52     rKillModifiedRing(tailRing);
    53   pLDeg = pOrigLDeg;
    54   pFDeg = pOrigFDeg;
    55 }
    5625
    5726KINLINE TObject* skStrategy::S_2_T(int i)
    … …  
    388357KINLINE long sTObject::pLDeg()
    389358{
    390   return ::pLDeg(GetLmTailRing(), &length, tailRing);
     359  return tailRing->pLDeg(GetLmTailRing(), &length, tailRing);
    391360}
    392361KINLINE long sTObject::SetDegStuffReturnLDeg()
    … …  
    698667    int i = kBucketCanonicalize(bucket);
    699668    pNext(tp) = bucket->buckets[i];
    700     long ldeg = ::pLDeg(tp, &length, tailRing);
     669    long ldeg = tailRing->pLDeg(tp, &length, tailRing);
    701670    pNext(tp) = NULL;
    702671    return ldeg;
    703672  }
    704673  else
    705     return ::pLDeg(tp, &length, tailRing);
     674    return tailRing->pLDeg(tp, &length, tailRing);
    706675}
    707676KINLINE long sLObject::pLDeg(BOOLEAN deg_last)
    … …  
    713682#ifdef HAVE_ASSUME
    714683  long fdeg;
    715   fdeg = ::pLDeg(GetLmTailRing(), &length, tailRing);
    716   assume (pLength == length && fdeg == ::pFDeg(last, tailRing));
     684  fdeg = tailRing->pLDeg(GetLmTailRing(), &length, tailRing);
     685  assume (pLength == length && fdeg == tailRing->pFDeg(last, tailRing));
    717686  return fdeg;
    718687#else
    719688  length = pLength;
    720   return ::pFDeg(last, tailRing);
     689  return tailRing->pFDeg(last, tailRing);
    721690#endif
    722691}

  • Singular/kstd1.cc

    rbad9f3 r24d587  
    22*  Computer Algebra System SINGULAR     *
    33****************************************/
    4 /* $Id: kstd1.cc,v 1.74 2000-12-18 17:26:39 obachman Exp $ */
     4/* $Id: kstd1.cc,v 1.75 2000-12-20 11:15:43 obachman Exp $ */
    55/*
    66* ABSTRACT:
    … …  
    1111
    1212// define if tailrings should be used
    13 // #define HAVE_TAIL_RING
     13#define HAVE_TAIL_RING
    1414
    1515#include "mod2.h"
    … …  
    9090static BOOLEAN kMoraUseBucket(kStrategy strat);
    9191
    92 static void kOptimizeLDeg(pFDegProc fdeg, pLDegProc ldeg, kStrategy strat)
    93 {
    94   if (fdeg == pDeg)
    95   {
    96     if (ldeg == pLDeg1)
    97       pLDeg = pLDeg1_Deg;
    98     if (ldeg == pLDeg1c)
    99       pLDeg = pLDeg1c_Deg;
    100   }
    101   else if (fdeg == pTotaldegree)
    102   {
    103     if (ldeg == pLDeg1)
    104       pLDeg = pLDeg1_Totaldegree;
    105     if (ldeg == pLDeg1c)
    106       pLDeg = pLDeg1c_Totaldegree;
    107   }
    108 
     92static void kOptimizeLDeg(pLDegProc ldeg, kStrategy strat)
     93{
    10994  if (strat->ak == 0 && !rIsSyzIndexRing(currRing))
    11095    strat->length_pLength = TRUE;
     96  else
     97    strat->length_pLength = FALSE;
    11198   
    11299  if ((ldeg == pLDeg0c && !rIsSyzIndexRing(currRing)) ||
    … …  
    227214
    228215    // end of search: have to reduce with pi
    229     if (!K_TEST_OPT_REDTHROUGH && ei > h->ecart)
     216    if (ei > h->ecart)
    230217    {
    231218      // It is not possible to reduce h with smaller ecart;
    … …  
    233220      // if its position in L would be not the last one
    234221      strat->fromT = TRUE;
    235       if (strat->Ll >= 0) /*- L is not empty -*/
     222      if (!K_TEST_OPT_REDTHROUGH && strat->Ll >= 0) /*- L is not empty -*/
    236223      {
    237224        h->SetLmCurrRing();
    … …  
    880867    if (TEST_OPT_WEIGHTM)
    881868    {
    882       if (pFDegOld != pFDeg)
    883       {
    884         pFDeg=pFDegOld;
    885         int i;
    886         for (i =0; i<=strat->Ll; i++)
    887         {
    888           strat->L[i].SetpFDeg();
    889         }
    890         for (i=0; i<=strat->tl; i++)
    891         {
    892           strat->T[i].SetpFDeg();
    893         }
    894       }
    895       pLDeg=pLDegOld;
    896       kOptimizeLDeg(pFDeg, pLDeg, strat);
     869      pRestoreDegProcs(pFDegOld, pLDegOld);
     870      if (strat->tailRing != currRing)
     871      {
     872        strat->tailRing->pFDeg = strat->pOrigFDeg_TailRing;
     873        strat->tailRing->pLDeg = strat->pOrigLDeg_TailRing;
     874      }
     875      int i;
     876      for (i =0; i<=strat->Ll; i++)
     877      {
     878        strat->L[i].SetpFDeg();
     879      }
     880      for (i=0; i<=strat->tl; i++)
     881      {
     882        strat->T[i].SetpFDeg();
     883      }
    897884      if (ecartWeights)
    898885      {
    … …  
    10431030      kEcartWeights(F->m,IDELEMS(F)-1,ecartWeights);
    10441031    }
    1045     pFDeg=totaldegreeWecart;
    1046     pLDeg=maxdegreeWecart;
    1047     for(i=1; i<=pVariables; i++)
    1048       Print(" %d",ecartWeights[i]);
    1049     PrintLn();
    1050     mflush();
    1051   }
    1052   kOptimizeLDeg(pFDeg, pLDeg, strat);
     1032   
     1033    pSetDegProcs(totaldegreeWecart, maxdegreeWecart);
     1034    if (TEST_OPT_PROT)
     1035    {
     1036      for(i=1; i<=pVariables; i++)
     1037        Print(" %d",ecartWeights[i]);
     1038      PrintLn();
     1039      mflush();
     1040    }
     1041  }
     1042  kOptimizeLDeg(pLDeg, strat);
    10531043}
    10541044
    … …  
    11081098
    11091099#ifdef HAVE_TAIL_RING
    1110   kStratInitChangeTailRing(strat);
     1100  if (strat->homog && strat->red == redFirst)
     1101    kStratInitChangeTailRing(strat);
    11111102#endif 
    11121103 
    … …  
    12591250  if (TEST_OPT_WEIGHTM)
    12601251  {
    1261     pFDeg=pFDegOld;
    1262     pLDeg=pLDegOld;
     1252    pRestoreDegProcs(pFDegOld, pLDegOld);
    12631253    if (ecartWeights)
    12641254    {
    … …  
    13771367  if ((TEST_OPT_WEIGHTM)&&(F!=NULL))
    13781368  {
    1379     pFDeg=pFDegOld;
    1380     pLDeg=pLDegOld;
     1369    pRestoreDegProcs(pFDegOld, pLDegOld);
    13811370    if (ecartWeights)
    13821371    {
    … …  
    15221511}
    15231512
    1524 pFDegProc pOldFDeg;
     1513pFDegProc pFDegOld;
     1514pLDegProc pLDegOld;
    15251515intvec * kModW, * kHomW;
    15261516
    … …  
    15691559    pLexOrder=FALSE;
    15701560    strat->kHomW=kHomW=vw;
    1571     pOldFDeg = pFDeg;
    1572     pFDeg = kHomModDeg;
     1561    pFDegOld = pFDeg;
     1562    pLDegOld = pLDeg;
     1563    pSetDegProcs(kHomModDeg);
    15731564    toReset = TRUE;
    15741565  }
    … …  
    15941585      if (vw == NULL)
    15951586      {
    1596         pOldFDeg = pFDeg;
    1597         pFDeg = kModDeg;
     1587        pFDegOld = pFDeg;
     1588        pLDegOld = pLDeg;
     1589        pSetDegProcs(kModDeg);
    15981590        toReset = TRUE;
    15991591      }
    … …  
    16261618  {
    16271619    kModW = NULL;
    1628     pFDeg = pOldFDeg;
     1620    pRestoreDegProcs(pFDegOld, pLDegOld);
    16291621  }
    16301622  pLexOrder = b;
    … …  
    16861678      kModW = *w;
    16871679      strat->kModW = *w;
    1688       pOldFDeg = pFDeg;
    1689       pFDeg = kModDeg;
     1680      assume(pFDeg != NULL && pLDeg != NULL);
     1681      pFDegOld = pFDeg;
     1682      pLDegOld = pLDeg;
     1683      pSetDegProcs(kModDeg);
     1684     
    16901685      toReset = TRUE;
    16911686      if (reduced>1)
    … …  
    17271722  if (toReset)
    17281723  {
     1724    pRestoreDegProcs(pFDegOld, pLDegOld);
    17291725    kModW = NULL;
    1730     pFDeg = pOldFDeg;
    17311726  }
    17321727  pLexOrder = b;

  • Singular/kstd1.h

    rbad9f3 r24d587  
    44*  Computer Algebra System SINGULAR     *
    55****************************************/
    6 /* $Id: kstd1.h,v 1.16 2000-11-14 16:04:55 obachman Exp $ */
     6/* $Id: kstd1.h,v 1.17 2000-12-20 11:15:44 obachman Exp $ */
    77/*
    88* ABSTRACT
    … …  
    4848
    4949
    50 extern pFDegProc pOldFDeg;
     50extern pFDegProc pFDegOld;
     51extern pLDegProc pLDegOld;
    5152extern intvec * kModW;
    5253

  • Singular/kstd2.cc

    rbad9f3 r24d587  
    22*  Computer Algebra System SINGULAR     *
    33****************************************/
    4 /* $Id: kstd2.cc,v 1.69 2000-12-19 18:31:41 obachman Exp $ */
     4/* $Id: kstd2.cc,v 1.70 2000-12-20 11:15:44 obachman Exp $ */
    55/*
    66*  ABSTRACT -  Kernel: alg. of Buchberger
    … …  
    1010// define to enable tailRings
    1111#define HAVE_TAIL_RING
     12// define if no buckets should be used
     13// #define NO_BUCKETS
    1214
    1315#include "mod2.h"
    … …  
    475477      kEcartWeights(F->m,IDELEMS(F)-1,ecartWeights);
    476478    }
    477     pFDeg=totaldegreeWecart;
    478     pLDeg=maxdegreeWecart;
    479     for(i=1; i<=pVariables; i++)
    480       Print(" %d",ecartWeights[i]);
    481     PrintLn();
    482     mflush();
     479    pRestoreDegProcs(totaldegreeWecart, maxdegreeWecart);
     480    if (TEST_OPT_PROT)
     481    {
     482      for(i=1; i<=pVariables; i++)
     483        Print(" %d",ecartWeights[i]);
     484      PrintLn();
     485      mflush();
     486    }
    483487  }
    484488}
    … …  
    510514  reduc = olddeg = lrmax = 0;
    511515
     516#ifndef NO_BUCKETS
    512517  if (!TEST_OPT_NOT_BUCKETS)
    513518    strat->use_buckets = 1;
     519#endif
    514520
    515521  // redtailBBa against T for inhomogenous input
    … …  
    665671  if (TEST_OPT_WEIGHTM)
    666672  {
    667     pFDeg=pFDegOld;
    668     pLDeg=pLDegOld;
     673    pRestoreDegProcs(pFDegOld, pLDegOld);
    669674    if (ecartWeights)
    670675    {
    … …  
    785790  return res;
    786791}
    787 
    788 

  • Singular/kstdfac.cc

    rbad9f3 r24d587  
    22*  Computer Algebra System SINGULAR     *
    33****************************************/
    4 /* $Id: kstdfac.cc,v 1.48 2000-12-18 13:30:36 obachman Exp $ */
     4/* $Id: kstdfac.cc,v 1.49 2000-12-20 11:15:44 obachman Exp $ */
    55/*
    66*  ABSTRACT -  Kernel: factorizing alg. of Buchberger
    … …  
    161161  s->initEcartPair=o->initEcartPair;
    162162  s->posInLOld=o->posInLOld;
    163   s->pOldFDeg=o->pOldFDeg;
    164163  s->Shdl=idCopy(o->Shdl);
    165164  s->S=s->Shdl->m;
    … …  
    758757  if (TEST_OPT_WEIGHTM)
    759758  {
    760     pFDeg=pFDegOld;
    761     pLDeg=pLDegOld;
     759    pRestoreDegProcs(pFDegOld, pLDegOld);
    762760    if (ecartWeights)
    763761    {
    … …  
    805803      kModW = *w;
    806804      strat->kModW = *w;
    807       pOldFDeg = pFDeg;
    808       pFDeg = kModDeg;
     805      pFDegOld = pFDeg;
     806      pLDegOld = pLDeg;
     807      pSetDegProcs(kModDeg);
    809808      toReset = TRUE;
    810809    }
    … …  
    885884  if (toReset)
    886885  {
     886    pRestoreDegProcs(pFDegOld, pLDegOld);
    887887    kModW = NULL;
    888     pFDeg = pOldFDeg;
    889888  }
    890889  pLexOrder = b;

  • Singular/kutil.cc

    rbad9f3 r24d587  
    22*  Computer Algebra System SINGULAR     *
    33****************************************/
    4 /* $Id: kutil.cc,v 1.87 2000-12-19 18:31:41 obachman Exp $ */
     4/* $Id: kutil.cc,v 1.88 2000-12-20 11:15:45 obachman Exp $ */
    55/*
    66* ABSTRACT: kernel: utils for kStd
    … …  
    518518}
    519519
     520static BOOLEAN sloppy_max = FALSE;
    520521BOOLEAN kTest_T(TObject * T, ring strat_tailRing, int i, char TN)
    521522{
    … …  
    566567        omCheckBinAddrSize(T->max, (tailRing->PolyBin->sizeW)*SIZEOF_LONG);
    567568#if KDEBUG > 0
    568         poly test_max = p_GetMaxExpP(pNext(T->t_p), tailRing);
    569         p_Setm(T->max, tailRing);
    570         p_Setm(test_max, tailRing);
    571         BOOLEAN equal = p_ExpVectorEqual(T->max, test_max, tailRing);
    572         if (! equal)
    573           return dReportError("%c[%d].max out of sync", TN, i);
    574         p_LmFree(test_max, tailRing);
     569        if (! sloppy_max)
     570        {
     571          poly test_max = p_GetMaxExpP(pNext(T->t_p), tailRing);
     572          p_Setm(T->max, tailRing);
     573          p_Setm(test_max, tailRing);
     574          BOOLEAN equal = p_ExpVectorEqual(T->max, test_max, tailRing);
     575          if (! equal)
     576            return dReportError("%c[%d].max out of sync", TN, i);
     577          p_LmFree(test_max, tailRing);
     578        }
    575579#endif
    576580      }
    … …  
    26982702  return redtail(&L, pos, strat);
    26992703}
    2700 
    27012704
    27022705poly redtailBba (LObject* L, int pos, kStrategy strat, BOOLEAN withT)
    … …  
    39773980{
    39783981  int i;
    3979 
     3982  int low = (pOrdSgn == 1 ? 1 : 0);
     3983  LObject L;
     3984
     3985#ifdef KDEBUG
     3986  // need to set this: during tailreductions of T[i], T[i].max is out of
     3987  // sync
     3988  sloppy_max = TRUE;
     3989#endif
     3990 
    39803991  strat->noTailReduction = FALSE;
    39813992  if (TEST_OPT_PROT)
    … …  
    39883999    Print("(S:%d)",strat->sl);mflush();
    39894000  }
    3990   if(pOrdSgn==1)
    3991   {
    3992     for (i=strat->sl; i>0; i--)
    3993     {
    3994       TObject* T_j = strat->s_2_t(i);
    3995       if (T_j != NULL)
    3996       {
    3997         assume(strat->S[i] == T_j->p);
    3998         strat->S[i] = redtailBba(T_j, i-1, strat);
    3999         assume(strat->S[i] == T_j->p);
    4000         if (strat->redTailChange && strat->tailRing != currRing)
    4001         {
    4002           if (T_j->max != NULL) p_LmFree(T_j->max, strat->tailRing);
    4003           if (pNext(T_j->p) != NULL)
    4004             T_j->max = p_GetMaxExpP(pNext(T_j->p), strat->tailRing);
    4005           else
    4006             T_j->max = NULL;
    4007         }
    4008       }
     4001  for (i=strat->sl; i>=low; i--)
     4002  {
     4003    TObject* T_j = strat->s_2_t(i);
     4004    if (T_j != NULL)
     4005    {
     4006      L = *T_j;
     4007      poly p;
     4008      if (pOrdSgn == 1)
     4009        strat->S[i] = redtailBba(&L, i-1, strat, FALSE);
    40094010      else
    4010         strat->S[i] = redtailBba(strat->S[i],i-1,strat);
    4011 
    4012       if (TEST_OPT_INTSTRATEGY)
    4013       {
    4014         //if (strat->redTailChange)
    4015           pCleardenom(strat->S[i]);
    4016       }
    4017       if (TEST_OPT_PROT)
    4018       {
    4019         PrintS("-");mflush();
    4020       }
    4021     }
    4022   }
    4023   else
    4024   {
    4025     for (i=strat->sl; i>=0; i--)
    4026     {
    4027       strat->S[i] = redtail(strat->S[i],strat->sl,strat);
    4028       // Hmm .. this might also change strat->T[i]
    4029       // but, we don't need it any more
    4030       if (TEST_OPT_INTSTRATEGY)
    4031         pCleardenom(strat->S[i]);
    4032       if (TEST_OPT_PROT)
    4033         PrintS("-");
    4034     }
    4035   }
     4011        strat->S[i] = redtail(&L, strat->sl, strat);
     4012
     4013      if (strat->redTailChange && strat->tailRing != currRing)
     4014      {
     4015        if (T_j->max != NULL) p_LmFree(T_j->max, strat->tailRing);
     4016        if (pNext(T_j->p) != NULL)
     4017          T_j->max = p_GetMaxExpP(pNext(T_j->p), strat->tailRing);
     4018        else
     4019          T_j->max = NULL;
     4020      }
     4021    }
     4022    else
     4023    {
     4024      assume(currRing == strat->tailRing);
     4025      if (pOrdSgn == 1)
     4026        strat->S[i] = redtailBba(strat->S[i], i-1, strat);
     4027      else
     4028        strat->S[i] = redtail(strat->S[i], strat->sl, strat);
     4029    }
     4030    if (TEST_OPT_INTSTRATEGY)
     4031      pCleardenom(strat->S[i]);
     4032    if (TEST_OPT_PROT)
     4033      PrintS("-");
     4034  }
     4035#ifdef KDEBUG
     4036  sloppy_max = FALSE;
     4037#endif
    40364038}
    40374039
    … …  
    41164118                                  // Hmmm .. the condition pFDeg == pDeg
    41174119                                  // might be too strong
    4118                                   (strat->homog && pFDeg == pDeg && pOrdSgn == 1),
     4120                                  (strat->homog && pFDeg == pDeg),
    41194121                                  !strat->ak,
    41204122                                  expbound);
    4121 
    41224123  if (new_tailRing == currRing) return TRUE;
     4124 
     4125  strat->pOrigFDeg_TailRing = new_tailRing->pFDeg;
     4126  strat->pOrigLDeg_TailRing = new_tailRing->pLDeg;
     4127 
     4128  if (currRing->pFDeg != currRing->pFDegOrig)
     4129  {
     4130    new_tailRing->pFDeg = currRing->pFDeg;
     4131    new_tailRing->pLDeg = currRing->pLDeg;
     4132  }
     4133 
    41234134  if (TEST_OPT_PROT)
    41244135    Print("[%d:%d", (long) new_tailRing->bitmask, new_tailRing->ExpL_Size);
    … …  
    42034214}
    42044215
     4216skStrategy::skStrategy()
     4217{
     4218  memset(this, 0, sizeof(skStrategy));
     4219  tailRing = currRing;
     4220  P.tailRing = currRing;
     4221  tl = -1;
     4222  sl = -1;
     4223#ifdef HAVE_LM_BIN
     4224  lmBin = omGetStickyBinOfBin(currRing->PolyBin);
     4225#endif
     4226#ifdef HAVE_TAIL_BIN
     4227  tailBin = omGetStickyBinOfBin(currRing->PolyBin);
     4228#endif
     4229  pOrigFDeg = pFDeg;
     4230  pOrigLDeg = pLDeg;
     4231}
     4232
     4233
     4234skStrategy::~skStrategy()
     4235{
     4236  if (lmBin != NULL)
     4237    omMergeStickyBinIntoBin(lmBin, currRing->PolyBin);
     4238  if (tailBin != NULL)
     4239    omMergeStickyBinIntoBin(tailBin,
     4240                            (tailRing != NULL ? tailRing->PolyBin:
     4241                             currRing->PolyBin));
     4242  if (currRing != tailRing)
     4243    rKillModifiedRing(tailRing);
     4244  pRestoreDegProcs(pOrigFDeg, pOrigLDeg);
     4245}
    42054246
    42064247#if 0

  • Singular/kutil.h

    rbad9f3 r24d587  
    44*  Computer Algebra System SINGULAR     *
    55****************************************/
    6 /* $Id: kutil.h,v 1.51 2000-12-19 18:31:42 obachman Exp $ */
     6/* $Id: kutil.h,v 1.52 2000-12-20 11:15:46 obachman Exp $ */
    77/*
    88* ABSTRACT: kernel: utils for kStd
    … …  
    218218  pFDegProc pOrigFDeg;
    219219  pLDegProc pOrigLDeg;
    220   pFDegProc pOldFDeg;
     220  pFDegProc pOrigFDeg_TailRing;
     221  pLDegProc pOrigLDeg_TailRing;
     222
    221223  ideal Shdl;
    222224  ideal D; /*V(S) is in D(D)*/
    … …  
    281283  int*      S_2_R;
    282284 
    283   KINLINE skStrategy();
    284   KINLINE ~skStrategy();
     285  skStrategy();
     286  ~skStrategy();
    285287
    286288  // return TObject corresponding to S[i]: assume that it exists

  • Singular/numbers.cc

    rbad9f3 r24d587  
    22*  Computer Algebra System SINGULAR      *
    33*****************************************/
    4 /* $Id: numbers.cc,v 1.35 2000-12-20 10:54:25 pohl Exp $ */
     4/* $Id: numbers.cc,v 1.36 2000-12-20 11:15:46 obachman Exp $ */
    55
    66/*
    … …  
    122122    nfSetChar(c,r->parameter);
    123123  }
     124  /* -------------- long R -----------------------*/
     125  else if (rField_is_long_R(r))
     126  {
     127    setGMPFloatDigits(r->ch_flags,r->ch_flags);
     128  }
     129  /* -------------- long C -----------------------*/
     130  else if (rField_is_long_C(r))
     131  {
     132    setGMPFloatDigits(r->ch_flags,r->ch_flags);
     133  }
     134#ifdef TEST
    124135  /* -------------- R -----------------------*/
    125136  //if (c==(-1))
    126   else if (rField_is_R(r))
    127   {
    128   }
    129   /* -------------- long R -----------------------*/
    130   else if (rField_is_long_R(r))
    131   {
    132     setGMPFloatDigits(r->ch_flags,r->ch_flags);
    133   }
    134   /* -------------- long C -----------------------*/
    135   else if (rField_is_long_C(r))
    136   {
    137     setGMPFloatDigits(r->ch_flags,r->ch_flags);
    138   }
    139 #ifdef TEST
    140   else
     137  else if (!rField_is_R(r) && !rField_is_Q(r))
    141138  {
    142139    WerrorS("unknown field");

  • Singular/p_polys.cc

    rbad9f3 r24d587  
    77 *  Author:  obachman (Olaf Bachmann)
    88 *  Created: 8/00
    9  *  Version: $Id: p_polys.cc,v 1.13 2000-12-14 16:38:53 obachman Exp $
     9 *  Version: $Id: p_polys.cc,v 1.14 2000-12-20 11:15:46 obachman Exp $
    1010 *******************************************************************/
    1111
    … …  
    199199// pWTotalDegree for weighted orderings
    200200// whose first block covers all variables
    201 long pWFirstTotalDegree(poly p, ring r)
     201inline long _pWFirstTotalDegree(poly p, ring r)
    202202{
    203203  int i;
    … …  
    211211}
    212212
     213long pWFirstTotalDegree(poly p, ring r)
     214{
     215  return (long) _pWFirstTotalDegree(p, r);
     216}
    213217
    214218/*2
    … …  
    323327  }
    324328  *l=ll;
    325   return p_GetOrder(p, r);
     329  return r->pFDeg(p, r);
    326330}
    327331
    … …  
    344348      ll++;
    345349    }
    346     o = pFDeg(p, r);
     350    o = r->pFDeg(p, r);
    347351  }
    348352  else
    … …  
    357361      pp = p;
    358362    }
    359     o = pFDeg(pp, r);
     363    o = r->pFDeg(pp, r);
    360364  }
    361365  *l=ll;
    … …  
    373377  p_CheckPolyRing(p, r);
    374378  Exponent_t k= p_GetComp(p, r);
    375   long o = pFDeg(p, r);
     379  long o = r->pFDeg(p, r);
    376380  int ll=1;
    377381
    … …  
    406410  long  t,max;
    407411
    408   max=pFDeg(p, r);
     412  max=r->pFDeg(p, r);
    409413  if (k > 0)
    410414  {
    411415    while (((p=pNext(p))!=NULL) && (p_GetComp(p, r)==k))
    412416    {
    413       t=pFDeg(p, r);
     417      t=r->pFDeg(p, r);
    414418      if (t>max) max=t;
    415419      ll++;
    … …  
    420424    while ((p=pNext(p))!=NULL)
    421425    {
    422       t=pFDeg(p, r);
     426      t=r->pFDeg(p, r);
    423427      if (t>max) max=t;
    424428      ll++;
    … …  
    441445  long  t,max;
    442446
    443   max=pFDeg(p, r);
     447  max=r->pFDeg(p, r);
    444448  if (rIsSyzIndexRing(r))
    445449  {
    … …  
    449453      if (p_GetComp(p, r)<=limit)
    450454      {
    451         if ((t=pFDeg(p, r))>max) max=t;
     455        if ((t=r->pFDeg(p, r))>max) max=t;
    452456        ll++;
    453457      }
    … …  
    459463    while ((p=pNext(p))!=NULL)
    460464    {
    461       if ((t=pFDeg(p, r))>max) max=t;
    462       ll++;
    463     }
    464   }
    465   *l=ll;
    466   return max;
    467 }
    468 
    469 // like pLDeg1, only pFDeg == Deg
     465      if ((t=r->pFDeg(p, r))>max) max=t;
     466      ll++;
     467    }
     468  }
     469  *l=ll;
     470  return max;
     471}
     472
     473// like pLDeg1, only pFDeg == pDeg
    470474long pLDeg1_Deg(poly p,int *l, ring r)
    471475{
     476  assume(r->pFDeg == pDeg);
    472477  p_CheckPolyRing(p, r);
    473478  Exponent_t k= p_GetComp(p, r);
    … …  
    500505long pLDeg1c_Deg(poly p,int *l, ring r)
    501506{
     507  assume(r->pFDeg == pDeg);
    502508  p_CheckPolyRing(p, r);
    503509  int ll=1;
    … …  
    568574
    569575  max=_pTotaldegree(p, r);
     576  if (rIsSyzIndexRing(r))
     577  {
     578    long limit = rGetCurrSyzLimit(r);
     579    while ((p=pNext(p))!=NULL)
     580    {
     581      if (p_GetComp(p, r)<=limit)
     582      {
     583        if ((t=_pTotaldegree(p, r))>max) max=t;
     584        ll++;
     585      }
     586      else break;
     587    }
     588  }
     589  else
     590  {
     591    while ((p=pNext(p))!=NULL)
     592    {
     593      if ((t=_pTotaldegree(p, r))>max) max=t;
     594      ll++;
     595    }
     596  }
     597  *l=ll;
     598  return max;
     599}
     600
     601// like pLDeg1, only pFDeg == pWFirstTotalDegree
     602long pLDeg1_WFirstTotalDegree(poly p,int *l, ring r)
     603{
     604  p_CheckPolyRing(p, r);
     605  Exponent_t k= p_GetComp(p, r);
     606  int ll=1;
     607  long  t,max;
     608
     609  max=_pWFirstTotalDegree(p, r);
     610  if (k > 0)
     611  {
     612    while (((p=pNext(p))!=NULL) && (p_GetComp(p, r)==k))
     613    {
     614      t=_pWFirstTotalDegree(p, r);
     615      if (t>max) max=t;
     616      ll++;
     617    }
     618  }
     619  else
     620  {
     621    while ((p=pNext(p))!=NULL)
     622    {
     623      t=_pWFirstTotalDegree(p, r);
     624      if (t>max) max=t;
     625      ll++;
     626    }
     627  }
     628  *l=ll;
     629  return max;
     630}
     631
     632long pLDeg1c_WFirstTotalDegree(poly p,int *l, ring r)
     633{
     634  p_CheckPolyRing(p, r);
     635  int ll=1;
     636  long  t,max;
     637
     638  max=_pWFirstTotalDegree(p, r);
    570639  if (rIsSyzIndexRing(r))
    571640  {

  • Singular/p_polys.h

    rbad9f3 r24d587  
    88 *  Author:  obachman (Olaf Bachmann)
    99 *  Created: 9/00
    10  *  Version: $Id: p_polys.h,v 1.17 2000-11-24 16:24:42 Singular Exp $
     10 *  Version: $Id: p_polys.h,v 1.18 2000-12-20 11:15:47 obachman Exp $
    1111 *******************************************************************/
    1212#ifndef P_POLYS_H
    … …  
    360360long pLDeg1_Totaldegree(poly p,int *l, ring r);
    361361long pLDeg1c_Totaldegree(poly p,int *l, ring r);
     362long pLDeg1_WFirstTotalDegree(poly p,int *l, ring r);
     363long pLDeg1c_WFirstTotalDegree(poly p,int *l, ring r);
    362364
    363365/***************************************************************

  • Singular/polys.cc

    rbad9f3 r24d587  
    22*  Computer Algebra System SINGULAR     *
    33****************************************/
    4 /* $Id: polys.cc,v 1.73 2000-12-19 18:31:44 obachman Exp $ */
     4/* $Id: polys.cc,v 1.74 2000-12-20 11:15:47 obachman Exp $ */
    55
    66/*
    … …  
    6363}
    6464
     65// resets the pFDeg and pLDeg: if pLDeg is not given, it is
     66// set to currRing->pLDegOrig, i.e. to the respective LDegProc which
     67// only uses pFDeg (and not pDeg, or pTotalDegree, etc)
     68void pSetDegProcs(pFDegProc new_FDeg, pLDegProc new_lDeg = NULL)
     69{
     70  assume(new_FDeg != NULL);
     71  pFDeg = new_FDeg;
     72  currRing->pFDeg = new_FDeg;
     73 
     74  if (new_lDeg == NULL)
     75    new_lDeg = currRing->pLDegOrig;
     76
     77  pLDeg = new_lDeg;
     78  currRing->pLDeg = new_lDeg;
     79}
     80
     81
     82// restores pFDeg and pLDeg:
     83extern void pRestoreDegProcs(pFDegProc old_FDeg, pLDegProc old_lDeg)
     84{
     85  assume(old_FDeg != NULL && old_lDeg != NULL);
     86  pFDeg = old_FDeg;
     87  currRing->pFDeg = old_FDeg;
     88  pLDeg = old_lDeg;
     89  currRing->pLDeg = old_lDeg;
     90}
    6591
    6692/*2

  • Singular/polys.h

    rbad9f3 r24d587  
    44*  Computer Algebra System SINGULAR     *
    55****************************************/
    6 /* $Id: polys.h,v 1.50 2000-12-15 18:49:35 Singular Exp $ */
     6/* $Id: polys.h,v 1.51 2000-12-20 11:15:48 obachman Exp $ */
    77/*
    88* ABSTRACT - all basic methods to manipulate polynomials of the
    … …  
    248248//extern void pChangeRing(ring newRing);
    249249extern void pSetGlobals(ring r, BOOLEAN complete = TRUE);
     250// resets the pFDeg and pLDeg: if pLDeg is not given, it is
     251// set to currRing->pLDegOrig, i.e. to the respective LDegProc which
     252// only uses pFDeg (and not pDeg, or pTotalDegree, etc).
     253// If you use this, make sure your procs does not make any assumptions
     254// on oredering and/or OrdIndex -- otherwise they might return wrong results
     255// on strat->tailRing
     256extern void pSetDegProcs(pFDegProc new_FDeg, pLDegProc new_lDeg = NULL);
     257// restores pFDeg and pLDeg:
     258extern void pRestoreDegProcs(pFDegProc old_FDeg, pLDegProc old_lDeg);
    250259
    251260/*-----------the ordering of monomials:-------------*/
    … …  
    275284long pLDeg1_Totaldegree(poly p,int *l, ring r = currRing);
    276285long pLDeg1c_Totaldegree(poly p,int *l, ring r = currRing);
     286long pLDeg1_WFirstTotalDegree(poly p,int *l, ring r=currRing);
     287long pLDeg1c_WFirstTotalDegree(poly p,int *l, ring r=currRing);
    277288
    278289/*-------------pComp for syzygies:-------------------*/

  • Singular/polys1.cc

    rbad9f3 r24d587  
    22*  Computer Algebra System SINGULAR     *
    33****************************************/
    4 /* $Id: polys1.cc,v 1.58 2000-12-15 18:49:35 Singular Exp $ */
     4/* $Id: polys1.cc,v 1.59 2000-12-20 11:15:48 obachman Exp $ */
    55
    66/*
    … …  
    6969*/
    7070static pFDegProc pOldFDeg;
     71static pLDegProc pOldLDeg;
    7172static intvec * pModW;
    7273static BOOLEAN pOldLexOrder;
    … …  
    8384    pModW = w;
    8485    pOldFDeg = pFDeg;
     86    pOldLDeg = pLDeg;
    8587    pOldLexOrder = pLexOrder;
    86     pFDeg = pModDeg;
     88    pSetDegProcs(pModDeg);
    8789    pLexOrder = TRUE;
    8890  }
    … …  
    9092  {
    9193    pModW = NULL;
    92     pFDeg = pOldFDeg;
     94    pRestoreDegProcs(pOldFDeg, pOldLDeg);
    9395    pLexOrder = pOldLexOrder;
    9496  }

  • Singular/ring.cc

    rbad9f3 r24d587  
    22*  Computer Algebra System SINGULAR     *
    33****************************************/
    4 /* $Id: ring.cc,v 1.151 2000-12-19 18:31:45 obachman Exp $ */
     4/* $Id: ring.cc,v 1.152 2000-12-20 11:15:48 obachman Exp $ */
    55
    66/*
    … …  
    7070// right-adjust r->VarOffset
    7171static void rRightAdjustVarOffset(ring r);
     72static void rOptimizeLDeg(ring r);
    7273
    7374/*0 implementation*/
    … …  
    19761977{
    19771978  int blocks = rBlocks(r) - 1;
    1978   if (blocks != 3) return FALSE;
    1979   return ((r->order[0] == ringorder_aa && r->order[1] != ringorder_M) ||
    1980           (r->order[1] == ringorder_aa && r->order[2] != ringorder_M));
     1979  if (blocks > 3 || blocks < 2) return FALSE;
     1980  if (blocks == 3)
     1981  {
     1982    return ((r->order[0] == ringorder_aa && r->order[1] != ringorder_M &&
     1983             (r->order[2] == ringorder_c || r->order[2] == ringorder_C)) ||
     1984            ((r->order[0] == ringorder_c || r->order[0] == ringorder_C) &&
     1985             r->order[1] == ringorder_aa && r->order[2] != ringorder_M));
     1986  }
     1987  else
     1988  {
     1989    return (r->order[0] == ringorder_aa && r->order[1] != ringorder_M);
     1990  }
    19811991}
    19821992
    … …  
    24572467  assume (exp_limit > 1);
    24582468  BOOLEAN need_other_ring;
     2469  BOOLEAN omitted_degree = FALSE;
    24592470  int bits;
    24602471
    … …  
    25232534          need_other_ring=TRUE;
    25242535          omit_degree=FALSE;
     2536          omitted_degree = TRUE;
    25252537        }
    25262538        break;
    … …  
    25382550          need_other_ring=TRUE;
    25392551          omit_degree=FALSE;
     2552          omitted_degree = TRUE;
    25402553        }
    25412554        break;
    … …  
    25722585  rComplete(res, 1);
    25732586
    2574   // adjust res->pFDeg: if it was changed globaly, then
     2587  // adjust res->pFDeg: if it was changed globally, then
    25752588  // it must also be changed for new ring
    2576   if (pFDeg != r->pFDeg)
    2577     res->pFDeg = pFDeg;
    2578   else if (r->pFDeg != res->pFDeg &&
     2589  if (r->pFDegOrig != res->pFDegOrig &&
    25792590           rOrd_is_WeightedDegree_Ordering(r))
    2580     // still might need adjustment
    2581   {
     2591  {
     2592    // still might need adjustment for weighted orderings
     2593    // and omit_degree
    25822594    res->firstwv = r->firstwv;
    25832595    res->firstBlockEnds = r->firstBlockEnds;
    2584     res->pFDeg = pWFirstTotalDegree;
    2585   }
     2596    res->pFDeg = res->pFDegOrig = pWFirstTotalDegree;
     2597  }
     2598  if (omitted_degree)
     2599    res->pLDeg = res->pLDegOrig = r->pLDegOrig;
     2600 
     2601  rOptimizeLDeg(res);
    25862602
    25872603  // set syzcomp
    … …  
    27042720  r->firstwv = wvhdl[i];
    27052721}
     2722
     2723static void rOptimizeLDeg(ring r)
     2724{
     2725  if (r->pFDeg == pDeg)
     2726  {
     2727    if (r->pLDeg == pLDeg1)
     2728      r->pLDeg = pLDeg1_Deg;
     2729    if (r->pLDeg == pLDeg1c)
     2730      r->pLDeg = pLDeg1c_Deg;
     2731  }
     2732  else if (r->pFDeg == pTotaldegree)
     2733  {
     2734    if (r->pLDeg == pLDeg1)
     2735      r->pLDeg = pLDeg1_Totaldegree;
     2736    if (r->pLDeg == pLDeg1c)
     2737      r->pLDeg = pLDeg1c_Totaldegree;
     2738  }
     2739  else if (r->pFDeg == pWFirstTotalDegree)
     2740  {
     2741    if (r->pLDeg == pLDeg1)
     2742      r->pLDeg = pLDeg1_WFirstTotalDegree;
     2743    if (r->pLDeg == pLDeg1c)
     2744      r->pLDeg = pLDeg1c_WFirstTotalDegree;
     2745  }
     2746}
    27062747 
    27072748// set pFDeg, pLDeg, MixOrder, ComponentOrder, etc
    … …  
    27412782      r->ComponentOrder=-1;
    27422783    if (r->OrdSgn == -1) r->pLDeg = pLDeg0c;
    2743     if ((order[0] == ringorder_lp) || (order[0] == ringorder_ls))
     2784    if ((order[0] == ringorder_lp) || (order[0] == ringorder_ls) || order[0] == ringorder_rp)
    27442785    {
    27452786      r->LexOrder=TRUE;
    … …  
    27632804        order[0]==ringorder_s)
    27642805      r->ComponentOrder=-1;
    2765     if ((order[1] == ringorder_lp) || (order[1] == ringorder_ls))
     2806    if ((order[1] == ringorder_lp) || (order[1] == ringorder_ls) || order[1] == ringorder_rp)
    27662807    {
    27672808      r->LexOrder=TRUE;
    … …  
    28072848    r->pFDeg = pWTotaldegree; // may be improved: pTotaldegree for lp/dp/ls/.. blocks
    28082849  }
    2809   if (rOrd_is_Totaldegree_Ordering(r))
     2850  if (rOrd_is_Totaldegree_Ordering(r) || rOrd_is_WeightedDegree_Ordering(r))
    28102851    r->pFDeg = pDeg;
     2852
     2853  r->pFDegOrig = r->pFDeg;
     2854  r->pLDegOrig = r->pLDeg;
     2855  rOptimizeLDeg(r);
    28112856}
    28122857
    … …  
    28372882        }
    28382883      }
    2839     }
    2840   }
     2884      return;
     2885    }
     2886  }
     2887  r->NegWeightL_Size = 0;
     2888  r->NegWeightL_Offset = NULL;
    28412889}
    28422890

  • Singular/structs.h

    rbad9f3 r24d587  
    44*  Computer Algebra System SINGULAR     *
    55****************************************/
    6 /* $Id: structs.h,v 1.50 2000-12-19 18:31:46 obachman Exp $ */
     6/* $Id: structs.h,v 1.51 2000-12-20 11:15:49 obachman Exp $ */
    77/*
    88* ABSTRACT
    … …  
    432432
    433433  p_Procs_s*    p_Procs;
     434
     435  /* FDeg and LDeg */
    434436  pFDegProc     pFDeg;
    435437  pLDegProc     pLDeg;
     438
     439  /* as it was determined by rComplete */
     440  pFDegProc     pFDegOrig;
     441  /* and as it was determined before rOptimizeLDeg */
     442  pLDegProc     pLDegOrig;
     443 
    436444  p_SetmProc    p_Setm;
    437445  n_Procs_s*    cf;

  • Singular/weight.cc

    rbad9f3 r24d587  
    22*  Computer Algebra System SINGULAR     *
    33****************************************/
    4 /* $Id: weight.cc,v 1.17 2000-10-30 13:40:29 obachman Exp $ */
     4/* $Id: weight.cc,v 1.18 2000-12-20 11:15:50 obachman Exp $ */
    55
    66/*
    … …  
    2222
    2323/*0 implementation*/
    24 
    25 pFDegProc pFDegOld;
    26 pLDegProc pLDegOld;
    27 
    2824#ifndef __MWERKS__
    2925extern "C" double (*wFunctional)(int *degw, int *lpol, int npol,
Note: See TracChangeset for help on using the changeset viewer.