Changeset ae5056 in git

Timestamp:

Jun 16, 2009, 10:45:33 AM (14 years ago)

Author:

Martin Monerjan

Branches:

(u'spielwiese', '0d6b7fcd9813a1ca1ed4220cfa2b104b97a0a003')

Children:

8e5a5b4f1f2f9bf6f4661d12232c26be179b09f3

Parents:

e28cf1ea73e36a7c3768b1ea8eb0e279b22ecede

Message:

Crude fix of ring construction, depending on whether the ring to be copied
has order in {dp,Dp,ds,ls}.
Anyhow the ring construction might do with a rewrite from scratch
Fixed copy constructor; minor various bugfixes


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

File:

• kernel/gfan.cc (modified) (16 diffs)

kernel/gfan.cc

@@ -2 +2 @@
 Compute the Groebner fan of an ideal
 $Author: monerjan $
-$Date: 2009-06-14 10:00:14 $
-$Header: /exports/cvsroot-2/cvsroot/kernel/gfan.cc,v 1.60 2009-06-14 10:00:14 monerjan Exp $
-$Id: gfan.cc,v 1.60 2009-06-14 10:00:14 monerjan Exp $
+$Date: 2009-06-16 08:45:33 $
+$Header: /exports/cvsroot-2/cvsroot/kernel/gfan.cc,v 1.61 2009-06-16 08:45:33 monerjan Exp $
+$Id: gfan.cc,v 1.61 2009-06-16 08:45:33 monerjan Exp $
 */
 
@@ -192 +192 @@
                 void setFlipGB(ideal I)
                 {
-                        this->flipGB=I;
+                        this->flipGB=idCopy(I);
                 }
                 
@@ -374 +374 @@
                         this->next=NULL;
                         this->numVars=gc.numVars;
-                        this->UCN=(gc.UCN)+1;
+                        //this->UCN=(gc.UCN)+1;
+                        this->UCN++;
                         this->facetPtr=NULL;
-                        this->gcBasis=gc.gcBasis;
-                        this->baseRing=f.flipRing;
-                        rChangeCurrRing(this->baseRing);
+                        this->gcBasis=idCopy(f.flipGB);
+                        this->inputIdeal=idCopy(this->gcBasis);
+                        this->baseRing=rCopy0(f.flipRing);
+                        //rComplete(this->baseRing);
+                        //rChangeCurrRing(this->baseRing);
                 }
                 
@@ -405 +408 @@
                 }
                 
+                /** \brief Print facets
+                * This is mainly for debugging purposes. Usually called from within gdb
+                */
                 void showFacets(short codim=1)
                 {
@@ -788 +794 @@
                         compute $G_{-\alpha}(in_v(I)) 
                         see journal p. 66
+                        NOTE Check for different rings. Prolly it will not always be necessary to add a weight, if the
+                        srcRing already has a weighted ordering
                         */
                         ring srcRing=currRing;
+                        ring tmpRing;
 
                         //intvec *negfNormal = new intvec(this->numVars);
                         //negfNormal=ivNeg(fNormal);
-                        ring tmpRing=rCopyAndAddWeight(srcRing,ivNeg(fNormal));
+                        if( (srcRing->order[0]==ringorder_dp)
+                                || (srcRing->order[0]==ringorder_Dp)
+                                 || (srcRing->order[0]==ringorder_ds)
+                                 || (srcRing->order[0]==ringorder_ls) )
+                        {
+                                tmpRing=rCopyAndAddWeight(srcRing,ivNeg(fNormal));
+                        }
+                        else
+                        {
+                                tmpRing=rCopy0(srcRing);
+                                int length=fNormal->length();
+                                int *A=(int *)omAlloc(length*sizeof(int));
+                                for(int jj=0;jj<length;jj++)
+                                {
+                                        A[jj]=-(*fNormal)[jj];
+                                }
+                                tmpRing->wvhdl[0]=(int*)A;
+                                rComplete(tmpRing);     
+                        }
                         rChangeCurrRing(tmpRing);
                         
@@ -940 +967 @@
                         turn the minimal basis into a reduced one
                         */
-                        ring dstRing=rCopyAndAddWeight(tmpRing,iv_weight);      
+                        //ring dstRing=rCopyAndAddWeight(tmpRing,iv_weight);    
                         
 //                      int i,j;
@@ -977 +1004 @@
                                 dstRing->wvhdl[0][ii]=(*iv_weight)[ii];                         
                         }*/
+                        ring dstRing=rCopy0(tmpRing);
+                        int length=iv_weight->length();
+                        int *A=(int *)omAlloc(length*sizeof(int));
+                        for(int jj=0;jj<length;jj++)
+                        {
+                                A[jj]=(*iv_weight)[jj];
+                        }
+                        dstRing->wvhdl[0]=(int*)A;
+                        rComplete(dstRing);
+                        //rSetWeightVec(dstRing,iv_weight);
+                        //assume(dstRing!=NULL);
+                        //assume(dstRing->OrdSize>0);
+                        //assume(dstRing->typ[0].ord_typ==ro_dp);
+                        //memcpy(dstRing->typ[0].data.wp.weights,iv_weight,dstRing->N*sizeof(int));             
                         rChangeCurrRing(dstRing);
+                        
 #ifdef gfan_DEBUG
                         rWrite(dstRing); cout << endl;
@@ -990 +1032 @@
                         test|=Sy_bit(OPT_REDSB);
                         test|=Sy_bit(6);        //OPT_DEBUG                                     
-                        dstRing_I=kStd(idrCopyR(this->inputIdeal,this->rootRing),NULL,testHomog,NULL);                                  
+                        dstRing_I=kStd(idrCopyR(this->inputIdeal,this->baseRing),NULL,testHomog,NULL);                                  
                         kInterRed(dstRing_I);
                         idSkipZeroes(dstRing_I);
@@ -997 +1039 @@
                         
                         f->setFlipGB(dstRing_I);//store the flipped GB
-                        f->flipRing=dstRing;    //store the ring on the other side
+                        f->flipRing=rCopy0(dstRing);    //store the ring on the other side
 #ifdef gfan_DEBUG
                         cout << "Flipped GB is: " << endl;
                         f->printFlipGB();
 #endif                  
-                        //rChangeCurrRing(srcRing);     //return to the ring we started the computation of flipGB in
+                        rChangeCurrRing(srcRing);       //return to the ring we started the computation of flipGB in
                 }//void flip(ideal gb, facet *f)
                                 
@@ -1223 +1265 @@
                                 dd_WriteNumber(stdout,lpSol->sol[ii]);
                         }
+                        cout << endl;
 #endif
                         
@@ -1249 +1292 @@
                                 mpq_clear(product);
                         }
+#ifdef gfan_DEBUG
+                        iv.show();
+                        cout << endl;
+#endif
                         mpq_clear(qkgV);
                         mpz_clear(tmp);
@@ -1522 +1569 @@
                 * soon as we compute this facet again. Comparison of facets is done by...
                 */
-                void noRevS(gcone &gc, bool usingIntPoint=FALSE)
+                void noRevS(gcone &gcRoot, bool usingIntPoint=FALSE)
                 {       
                         facet *SearchListRoot = new facet(); //The list containing ALL facets we come across
@@ -1528 +1575 @@
                         SearchListAct = SearchListRoot;
                         
+                        gcone *gcAct;
+                        gcAct = &gcRoot;
+                        gcone = *gcPtr;
+                        gcPtr = &gcRoot;
+                        
                         facet *fAct;
-                        fAct = gc.facetPtr;                     
-                        
+                        fAct = gcAct->facetPtr;                 
+                                                
+                        int UCNcounter=gcAct->getUCN();
 #ifdef gfan_DEBUG
                         cout << "NoRevs" << endl;
                         cout << "Facets are:" << endl;
-                        gc.showFacets();
+                        gcAct->showFacets();
 #endif                  
                         
-                        this->getCodim2Normals(gc);
+                        gcAct->getCodim2Normals(*gcAct);
                                 
                         //Compute unique representation of codim-2-facets
-                        this->normalize();
+                        gcAct->normalize();
                         
                         /*Make a copy of the facet list of first cone
@@ -1555 +1608 @@
                         SearchListAct = SearchListRoot; //Set to beginning of list
                         
-                        fAct = gc.facetPtr;
+                        fAct = gcAct->facetPtr;
                         if(areEqual(fAct->getFacetNormal(),fAct->next->getFacetNormal()))
                         {
@@ -1561 +1614 @@
                         }
                         
-                        gc.writeConeToFile(gc);
-                        
+                        gcAct->writeConeToFile(*gcAct);
+                        
+                        /*End of initialisation*/
+                        fAct = gcAct->facetPtr;
                         /*2nd step
                         Choose a facet from fListPtr, flip it and forget the previous cone
@@ -1568 +1623 @@
                         */
                         while(SearchListAct->next!=NULL)
-                        {
-                                gc.flip(gc.gcBasis,SearchListAct);
-                                gcone *gcTmp = new gcone::gcone(gc,*SearchListAct);
-                        
-                        //gcTmp->getConeNormals();
+                        {//NOTE See to it that the cone is only changed after ALL facets have been flipped!
+                                //As of now this is not the case!
+                                gcAct->flip(gcAct->gcBasis,SearchListAct);
+                                /*ring rTmp=rCopy(SearchListAct->flipRing);
+                                //NOTE It is absolutely crucial to go to the new ring before constructing a new cone!
+                                rComplete(rTmp);
+                                rChangeCurrRing(rTmp);
+                                gcone *gcTmp = new gcone::gcone(*gcAct,*SearchListAct);
+                                gcAct = gcTmp;
+                                gcAct->getConeNormals(gcAct->gcBasis, FALSE);*/
+                                //gcAct->getCodim2Normals(*gcAct);                      
+                        
                         //add new facets
                         //fListPtr = fListPtr->next;
                                 SearchListAct = SearchListAct->next;
-                        }
+                        }                       
                 
                         //NOTE Hm, comment in and get a crash for free...