Changeset 4d1064 in git


Ignore:
Timestamp:
Jul 8, 2009, 11:57:52 AM (14 years ago)
Author:
Martin Monerjan
Branches:
(u'spielwiese', '0d6b7fcd9813a1ca1ed4220cfa2b104b97a0a003')
Children:
1bc8504ec83c52df89a04fe32cd3fed3cbd7a659
Parents:
ab3db62fd566bf974e5dcf6da2405b18b464b0c4
Message:
2nd try from scratch of enqueue method. Still not working properly.
Fixed copying of codim2Facets, though


git-svn-id: file:///usr/local/Singular/svn/trunk@11959 2c84dea3-7e68-4137-9b89-c4e89433aadc
File:
1 edited

Legend:

Unmodified
Added
Removed

  • kernel/gfan.cc

    rab3db62 r4d1064  
    22Compute the Groebner fan of an ideal
    33$Author: monerjan $
    4 $Date: 2009-07-04 08:55:44 $
    5 $Header: /exports/cvsroot-2/cvsroot/kernel/gfan.cc,v 1.72 2009-07-04 08:55:44 monerjan Exp $
    6 $Id: gfan.cc,v 1.72 2009-07-04 08:55:44 monerjan Exp $
     4$Date: 2009-07-08 09:57:52 $
     5$Header: /exports/cvsroot-2/cvsroot/kernel/gfan.cc,v 1.73 2009-07-08 09:57:52 monerjan Exp $
     6$Id: gfan.cc,v 1.73 2009-07-08 09:57:52 monerjan Exp $
    77*/
    88
    … …  
    9898                facet *prev;            //Pointer to predecessor. Needed for the SearchList in noRevS
    9999                facet *codim2Ptr;       //Pointer to (codim-2)-facet. Bit of recursion here ;-)
    100                 int numCodim2Facets;
     100                int numCodim2Facets;    //#of (codim-2)-facets of this facet. Set in getCodim2Normals()
    101101                ring flipRing;          //the ring on the other side of the facet
    102102                                               
    … …  
    19261926                        facet *sl2Act;
    19271927                        sl2Act = f.codim2Ptr;
     1928                        facet *tBARoot;
     1929                        tBARoot = NULL;                 
     1930                        facet *tBAAct;
     1931                        tBAAct = NULL;
    19281932                        bool doNotAdd=FALSE;
     1933                        int ctr=0;      //encountered qualities in SLA
     1934                        int notParallelCtr=0;
     1935                        int lengthOfSearchList=1;
    19291936                        while(slEnd->next!=NULL)
    19301937                        {
    19311938                                slEnd=slEnd->next;
     1939                                lengthOfSearchList++;
    19321940                        }
    19331941                        slEndStatic = slEnd;
    … …  
    19361944                        intvec *f2Normal = new intvec(this->numVars);
    19371945                        intvec *slNormal = new intvec(this->numVars);
    1938                         intvec *sl2Normal = new intvec(this->numVars);                 
     1946                        intvec *sl2Normal = new intvec(this->numVars);
     1947                                       
     1948//                      while(fAct!=NULL)
     1949//                      {
     1950//                              doNotAdd=TRUE;
     1951//                              fNormal = fAct->getFacetNormal();
     1952//                              slAct = slHead; //return to start of list
     1953//                              codim2Act = fAct->codim2Ptr;
     1954//                              while(slAct!=slEndStatic->next)
     1955//                              {
     1956//                                      slNormal = slAct->getFacetNormal();                                     
     1957//                                      /*If the normals are parallel we check whether the
     1958//                                      codim-2-normals coincide as well*/
     1959//                                      if(isParallel(fNormal,slNormal))
     1960//                                      {
     1961//                                              //NOTE check codim2facets here
     1962//                                              codim2Act = fAct->codim2Ptr;
     1963                                               
     1964//                                              while(codim2Act!=NULL)
     1965//                                              {
     1966//                                                      f2Normal = codim2Act->getFacetNormal();
     1967//                                                      sl2Act = f.codim2Ptr;
     1968//                                                      while(sl2Act!=NULL)
     1969//                                                      {
     1970//                                                              sl2Normal = sl2Act->getFacetNormal();
     1971//                                                              if( !(areEqual(f2Normal,sl2Normal)))
     1972//                                                              {
     1973//                                                                      doNotAdd=FALSE;                                                 
     1974//                                                                      break;                                         
     1975//                                                                     
     1976//                                                              }
     1977//                                                              else
     1978//                                                              {
     1979//                                                                      sl2Act = sl2Act->next;
     1980//                                                                      codim2Act = codim2Act->next;
     1981//                                                              }
     1982//                                                      }
     1983//                                                      if(doNotAdd==FALSE)
     1984//                                                              break;
     1985//                                                      //codim2Act = codim2Act->next;                                                 
     1986//                                              }
     1987//                                              if(doNotAdd==TRUE)
     1988//                                              {       /*dequeue slAct*/
     1989//                                                      if(slAct->prev==NULL && slHead!=NULL)
     1990//                                                      {
     1991//                                                              slHead = slAct->next;
     1992//                                                              slHead->prev = NULL;
     1993//                                                      }
     1994//                                                      else
     1995//                                                      {                                               
     1996//                                                              slAct->prev->next = slAct->next;                                       
     1997//                                                      }
     1998//                                                      //NOTE Memory leak above!
     1999//                                                      break;
     2000//                                              }
     2001////////////
     2002//                                              while(codim2Act!=NULL)
     2003//                                              {
     2004//                                                      f2Normal = codim2Act->getFacetNormal();
     2005//                                                      sl2Act = f.codim2Ptr;
     2006//                                                      while(sl2Act!=NULL)
     2007//                                                      {
     2008//                                                              sl2Normal = sl2Act->getFacetNormal();
     2009//                                                              if(areEqual(f2Normal,sl2Normal))
     2010//                                                              {
     2011//                                                                      ctr++;
     2012//                                                                      break;
     2013//                                                              }
     2014//                                                              sl2Act = sl2Act->next;
     2015//                                                      }
     2016//                                                      codim2Act = codim2Act->next;
     2017//                                              }
     2018//                                              if(ctr!=(this->numVars)-1)
     2019//                                              {
     2020//                                                      doNotAdd=FALSE;
     2021//                                                      break;
     2022//                                              }
     2023//                                              else
     2024//                                              {
     2025//                                                      if(slAct->prev==NULL && slHead!=NULL)
     2026//                                                      {
     2027//                                                              slHead = slAct->next;
     2028//                                                              slHead->prev = NULL;
     2029//                                                      }
     2030//                                                      else
     2031//                                                      {                                               
     2032//                                                              slAct->prev->next = slAct->next;                                       
     2033//                                                      }       
     2034//                                              }                                                       
     2035//                                              //slAct = slAct->next;
     2036//                                      }
     2037//                                      else
     2038//                                      {
     2039//                                              doNotAdd=FALSE;
     2040//                                              break;
     2041//                                      }
     2042//                                      slAct = slAct->next;
     2043//                                     
     2044//                                      //if(doNotAdd==FALSE)
     2045//                                      //      break;                                 
     2046//                              }//while(slAct!=slEndStatic->next)
     2047//                              if(doNotAdd==FALSE)
     2048//                              {
     2049//                                      slEnd->next = new facet();
     2050//                                      slEnd = slEnd->next;
     2051//                                      slEnd->setUCN(this->getUCN());
     2052//                                      slEnd->setFacetNormal(fNormal);
     2053//                              }
     2054//                              fAct = fAct->next;
     2055//                      }                       
    19392056                        while(fAct!=NULL)
    19402057                        {
    19412058                                doNotAdd=TRUE;
    1942                                 fNormal = fAct->getFacetNormal();
    1943                                 slAct = slHead; //return to start of list
    1944                                 codim2Act = fAct->codim2Ptr;
    1945                                 while(slAct!=slEndStatic->next)
    1946                                 {
    1947                                         slNormal = slAct->getFacetNormal();                                     
    1948                                         /*If the normals are parallel we check whether the
    1949                                         codim-2-normals coincide as well*/
    1950                                         if(isParallel(fNormal,slNormal))
    1951                                         {
    1952                                                 //NOTE check codim2facets here
     2059                                fNormal=fAct->getFacetNormal();
     2060                                slAct = slHead;
     2061                                while(slAct!=NULL)
     2062                                {
     2063                                        slNormal = slAct->getFacetNormal();
     2064                                        if(!isParallel(fNormal, slNormal))
     2065                                        {
     2066                                                notParallelCtr++;
     2067                                        }
     2068                                        else
     2069                                        {
    19532070                                                codim2Act = fAct->codim2Ptr;
    19542071                                                while(codim2Act!=NULL)
    … …  
    19592076                                                        {
    19602077                                                                sl2Normal = sl2Act->getFacetNormal();
    1961                                                                 if( !(areEqual(f2Normal,sl2Normal)))
    1962                                                                 {
    1963                                                                         doNotAdd=FALSE;                                                 
    1964                                                                         break;                                         
    1965                                                                        
    1966                                                                 }
    1967                                                                 else
    1968                                                                 {
    1969                                                                         sl2Act = sl2Act->next;
    1970                                                                         codim2Act = codim2Act->next;
    1971                                                                 }
    1972                                                         }
    1973                                                         if(doNotAdd==FALSE)
    1974                                                                 break;
    1975                                                         //codim2Act = codim2Act->next;                                                 
    1976                                                 }
    1977                                                 if(doNotAdd==TRUE)
    1978                                                 {       /*dequeue slAct*/
    1979                                                         if(slAct->prev==NULL && slHead!=NULL)
     2078                                                                if(areEqual(f2Normal, sl2Normal))
     2079                                                                                ctr++;
     2080                                                                sl2Act = sl2Act->next;
     2081                                                        }//while(sl2Act!=NULL)
     2082                                                        codim2Act = codim2Act->next;
     2083                                                }//while(codim2Act!=NULL)
     2084                                                if(ctr==fAct->numCodim2Facets)  //facets ARE equal
     2085                                                {
     2086                                                        if(slAct==slHead)       //We want to delete the first element of SearchList
    19802087                                                        {
    19812088                                                                slHead = slAct->next;
    19822089                                                                slHead->prev = NULL;
     2090                                                                //set a bool flag to mark slAct as to be deleted
    19832091                                                        }
     2092                                                        else if(slAct==slEndStatic)
     2093                                                                {
     2094                                                                        if(slEndStatic->next==NULL)
     2095                                                                        {
     2096                                                                                slEndStatic = slEndStatic->prev;
     2097                                                                                slEndStatic->next = NULL;
     2098                                                                        }
     2099                                                                        else    //we already added a facet after slEndStatic
     2100                                                                        {
     2101                                                                                slEndStatic->prev->next = slEndStatic->next;
     2102                                                                                slEndStatic = slEndStatic->prev;
     2103                                                                                slEnd = slEndStatic;
     2104                                                                        }
     2105                                                                }
    19842106                                                        else
    1985                                                         {                                               
    1986                                                                 slAct->prev->next = slAct->next;                                       
     2107                                                        {
     2108                                                                slAct->prev->next = slAct->next;
    19872109                                                        }
    1988                                                         //NOTE Memory leak above!
     2110                                                        //update lengthOfSearchList
     2111                                                        lengthOfSearchList--;
    19892112                                                        break;
    1990                                                 }       
    1991                                                 slAct = slAct->next;
    1992                                         }
    1993                                         else
    1994                                         {
    1995                                                 doNotAdd=FALSE;
    1996                                                 break;
    1997                                         }
    1998                                         //slAct = slAct->next;
     2113                                                }//if(ctr==fAct->numCodim2Facets)
     2114                                                else    //facets are NOT equal
     2115                                                {
     2116                                                        doNotAdd=FALSE;
     2117                                                        break;
     2118                                                }
     2119                                        }//if(!isParallel(fNormal, slNormal))
     2120                                        slAct = slAct->next;
     2121                                        //if slAct was marked as to be deleted, delete it here!
     2122                                }//while(slAct!=NULL)
     2123                                if( (notParallelCtr==lengthOfSearchList) || (doNotAdd==FALSE) )
     2124                                {
     2125                                        //Add fAct to SLA
     2126                                        facet *marker;
     2127                                        marker = slEnd;
     2128                                        facet *f2Act;
     2129                                        f2Act = fAct->codim2Ptr;
    19992130                                       
    2000                                         //if(doNotAdd==FALSE)
    2001                                         //      break;                                 
    2002                                 }//while(slAct!=slEndStatic->next)
    2003                                 if(doNotAdd==FALSE)
    2004                                 {
    20052131                                        slEnd->next = new facet();
    20062132                                        slEnd = slEnd->next;
     2133                                        facet *slEndCodim2Root;
     2134                                        facet *slEndCodim2Act;
     2135                                        slEndCodim2Root = slEnd->codim2Ptr;
     2136                                        slEndCodim2Act = slEndCodim2Root;
     2137                                                       
    20072138                                        slEnd->setUCN(this->getUCN());
    20082139                                        slEnd->setFacetNormal(fNormal);
     2140                                        slEnd->prev = marker;
     2141                                        //Copy codim2-facets
     2142                                        intvec *f2Normal = new intvec(this->numVars);
     2143                                        while(f2Act!=NULL)
     2144                                        {
     2145                                                f2Normal=f2Act->getFacetNormal();
     2146                                                if(slEndCodim2Root==NULL)
     2147                                                {
     2148                                                        slEndCodim2Root = new facet(2);
     2149                                                        slEnd->codim2Ptr = slEndCodim2Root;                     
     2150                                                        slEndCodim2Root->setFacetNormal(f2Normal);
     2151                                                        slEndCodim2Act = slEndCodim2Root;
     2152                                                }
     2153                                                else                                   
     2154                                                {
     2155                                                        slEndCodim2Act->next = new facet(2);
     2156                                                        slEndCodim2Act = slEndCodim2Act->next;
     2157                                                        slEndCodim2Act->setFacetNormal(f2Normal);
     2158                                                }
     2159                                                f2Act = f2Act->next;
     2160                                        }
     2161                                        delete f2Normal;
     2162                                       
    20092163                                }
    20102164                                fAct = fAct->next;
    2011                         }
     2165                        }//while(fAct!=NULL)
    20122166                        return slHead;
    20132167//                      delete sl2Normal;
Note: See TracChangeset for help on using the changeset viewer.