Changeset 7c0ec6 in git

Timestamp:

Nov 12, 2009, 2:14:54 PM (14 years ago)

Author:

Martin Monerjan

Branches:

(u'spielwiese', 'fe61d9c35bf7c61f2b6cbf1b56e25e2f08d536cc')

Children:

3a7ee744399f1b56c9bf08b3b16e524f0f2f0de4

Parents:

27bb97f5f06fab3d914b8889b6cabffbc4df28b6

Message:

Preprocessing of facets
Computation of initial ideal as stand-alone method
Bugfix for matrix overflow


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

Location:

kernel

Files:

• gfan.cc (modified) (21 diffs)
• gfan.h (modified) (4 diffs)

kernel/gfan.cc

@@ -2 +2 @@
 Compute the Groebner fan of an ideal
 $Author: monerjan $
-$Date: 2009-10-29 16:26:32 $
-$Header: /exports/cvsroot-2/cvsroot/kernel/gfan.cc,v 1.102 2009-10-29 16:26:32 monerjan Exp $
+$Date: 2009/11/03 06:57:32 $
+$Header: /usr/local/Singular/cvsroot/kernel/gfan.cc,v 1.103 2009/11/03 06:57:32 monerjan Exp $
 $Id$
 */
@@ -28 +28 @@
 #include <sstream>
 #include <time.h>
+
 //#include <gmpxx.h>
 
@@ -379 +380 @@
                 delete fDel;
         }
+        //dd_FreeMatrix(this->ddFacets);
 }                       
                 
@@ -475 +477 @@
         }
         cout << endl;
+}
+
+void gcone::invPrint(ideal const &I)
+{
+//      int numElts=IDELEMS(I);
+//      cout << "inv = ";
+//      for(int ii=0;ii<numElts;ii++);
+//      {
+//              pWrite0(pHead(I->m[ii]));
+//              cout << ",";
+//      }
+//      cout << endl;
 }
 
@@ -593 +607 @@
                         pSetm(aktpoly);         //doesn't seem to help anything
                         pGetExpV(aktpoly,v);
+                        
                         for (int kk=0;kk<numvar;kk++)
                         {
@@ -601 +616 @@
                         aktmatrixrow=aktmatrixrow+1;
                 }//while
-                
+                omFree(v);
         } //for
                 
-                        //Maybe add another row to contain the constraints of the standard simplex?
-
-#ifdef gfan_DEBUG
-//                      cout << "The inequality matrix is" << endl;
-//                      dd_WriteMatrix(stdout, ddineq);
+#if false
+        /*Let's make the preprocessing here. This could already be done in the above for-loop,
+        * but for a start it is more convenient here.
+        * We check the necessary condition of FJT p.18
+        * Quote: [...] every non-zero spoly should have at least one of its terms in inv(G)
+        */
+        ideal initialForm=idInit(IDELEMS(I),1);
+        intvec *gamma=new intvec(this->numVars);
+        int falseGammaCounter=0;
+        int *redRowsArray=NULL;
+        int num_alloc=0;
+        int num_elts=0; 
+        for(int ii=0;ii<ddineq->rowsize;ii++)
+        {
+                double tmp;             
+                for(int jj=1;jj<=this->numVars;jj++)
+                {
+                        tmp=mpq_get_d(ddineq->matrix[ii][jj]);
+                        (*gamma)[jj-1]=(int)tmp;
+//                      (*gamma)[jj]=(ddineq->matrix[ii][jj]);
+                }
+                computeInv((ideal&)I,initialForm,*gamma);
+                //Create leading ideal
+                ideal L=idInit(IDELEMS(initialForm),1);
+                for(int jj=0;jj<IDELEMS(initialForm);jj++)
+                {
+                        L->m[jj]=pCopy(pHead(initialForm->m[jj]));
+                }               
+                
+                LObject *P = new sLObject();
+                memset(P,0,sizeof(LObject));
+//              P->p1=L->m[0];
+//              P->p2=L->m[1];
+//              ksCreateSpoly(P);
+//              pWrite(P->p);
+//              cout << "gamma=";
+//              gamma->show(1,0);
+//              cout << endl;
+//              cout << "inv=";
+//              for(int qq=0;qq<IDELEMS(initialForm);qq++)
+//              {
+//                      pWrite0(initialForm->m[qq]);
+//                      cout << ",";                    
+//              }
+//              cout << endl;
+                for(int jj=0;jj<=IDELEMS(initialForm)-2;jj++)
+                {
+                        bool isMaybeFacet=FALSE;
+                        P->p1=initialForm->m[jj];       //build spolys of initialForm in_v
+//                      cout << "P->p1=";
+//                      pWrite0(P->p1);
+//                      cout << endl;
+                        for(int kk=jj+1;kk<=IDELEMS(initialForm)-1;kk++)
+                        {
+                                P->p2=initialForm->m[kk];
+                                ksCreateSpoly(P);
+                                /*cout << "P->p2=";
+                                pWrite0(P->p2);
+                                cout << endl;
+                                cout << "spoly(p1,p2)=";
+                                pWrite0(P->p);
+                                cout << endl;   */                      
+                                if(P->p!=NULL)  //spoly non zero=?
+                                {       
+                                        poly p=pInit();                 
+                                        poly q=pInit();
+                                        p=pCopy(P->p);
+                                        q=pHead(p);     //Monomial q
+                                        isMaybeFacet=FALSE;
+                                        while(p!=NULL)
+                                        {
+                                                q=pHead(p);                                             
+//                                              unsigned long sevSpoly=pGetShortExpVector(q);
+//                                              unsigned long not_sevL;                                         
+                                                for(int ll=0;ll<IDELEMS(L);ll++)
+                                                {
+//                                                      not_sevL=~pGetShortExpVector(L->m[ll]);//                                       
+                                                        //if(!(sevSpoly & not_sevL) && pLmDivisibleBy(L->m[ll],q) )//i.e. spoly is in L 
+                                                        if(pLmEqual(L->m[ll],q) || pDivisibleBy(L->m[ll],q))
+                                                        {                                                       
+                                                                isMaybeFacet=TRUE;
+                                                                break;
+                                                        }
+                                                }
+                                                if(isMaybeFacet==TRUE)
+                                                {
+//                                                      dd_MatrixRowRemove(&ddineq,ii);
+//                                                      set_addelem(redRows,ii);
+//                                                      dd_set_si(ddineq->matrix[ii][0],1);
+//                                                      falseGammaCounter++;
+//                                                      cout << "Removing gamma!" << endl;
+                                                        break;//while(p!=NULL)
+                                                }
+                                                p=pNext(p);                                             
+                                        }//while
+                                        if(isMaybeFacet==FALSE)
+                                        {
+                                                dd_set_si(ddineq->matrix[ii][0],1);                                             
+                                                if(num_alloc==0)
+                                                        num_alloc += 1;
+                                                else
+                                                        num_alloc += 1;
+                                                void *_tmp = realloc(redRowsArray,(num_alloc*sizeof(int)));
+                                                if(!_tmp)
+                                                        WerrorS("Couldn't realloc memory\n");
+                                                redRowsArray = (int*)_tmp;
+                                                redRowsArray[num_elts]=ii;
+                                                num_elts++;
+                                                break;//for(int kk, since we have found one that is not in L    
+                                        }
+                                }//if(P->p!=NULL)
+                        }
+                }//for
+                delete P;
+                //idDelete(L);          
+        }//for(ii<ddineq-rowsize
+        
+        int offset=0;//needed for correction of redRowsArray[ii]
+        for( int ii=0;ii<num_elts;ii++ )
+        {
+                dd_MatrixRowRemove(&ddineq,redRowsArray[ii]+1-offset);//cddlib sucks at enumeration
+                offset++;
+        }
+        free(redRowsArray);
+#endif
+//      cout << "Found " << falseGammaCounter << " false in " << rows << endl;
+        //Maybe add another row to contain the constraints of the standard simplex?
+
+#ifdef gfan_DEBUG
+//      cout << "The inequality matrix is" << endl;
+//      dd_WriteMatrix(stdout, ddineq);
 #endif
 
         // The inequalities are now stored in ddineq
         // Next we check for superflous rows
-        ddredrows = dd_RedundantRows(ddineq, &dderr);
-        if (dderr!=dd_NoError)                  // did an error occur?
-        {
-                dd_WriteErrorMessages(stderr,dderr);    //if so tell us
-        } 
-#ifdef gfan_DEBUG
-        else
-        {
+        time_t canonicalizeTic, canonicalizeTac;
+        time(&canonicalizeTic);
+//      ddredrows = dd_RedundantRows(ddineq, &dderr);
+//      if (dderr!=dd_NoError)                  // did an error occur?
+//      {
+//              dd_WriteErrorMessages(stderr,dderr);    //if so tell us
+//      } 
+#ifdef gfan_DEBUG
+//      else
+//      {
 //                              cout << "Redundant rows: ";
 //                              set_fwrite(stdout, ddredrows);          //otherwise print the redundant rows
-        }//if dd_Error
+//      }//if dd_Error
 #endif
         //Remove reduntant rows here!
+        //Necessary check here! C.f. FJT p18
+                
         dd_MatrixCanonicalize(&ddineq, &ddlinset, &ddredrows, &ddnewpos, &dderr);
+        time(&canonicalizeTac);
+        cout << "dd_MatrixCanonicalize time: " << difftime(canonicalizeTac,canonicalizeTic) << "sec" << endl;
         ddrows = ddineq->rowsize;       //Size of the matrix with redundancies removed
         ddcols = ddineq->colsize;
@@ -900 +1047 @@
 //#endif                                
         /*1st step: Compute the initial ideal*/
-        poly initialFormElement[IDELEMS(gb)];   //array of #polys in GB to store initial form
+        /*poly initialFormElement[IDELEMS(gb)];*/       //array of #polys in GB to store initial form
         ideal initialForm=idInit(IDELEMS(gb),this->gcBasis->rank);
         poly aktpoly;
-        intvec *check = new intvec(this->numVars);      //array to store the difference of LE and v
-                        
-        for (int ii=0;ii<IDELEMS(gb);ii++)
-        {
-                aktpoly = (poly)gb->m[ii];                                                              
-                int *v=(int *)omAlloc((this->numVars+1)*sizeof(int));
-                int *leadExpV=(int *)omAlloc((this->numVars+1)*sizeof(int));
-                pGetExpV(aktpoly,leadExpV);     //find the leading exponent in leadExpV[1],...,leadExpV[n], use pNext(p)
-                initialFormElement[ii]=pHead(aktpoly);
-                                
-                while(pNext(aktpoly)!=NULL)     /*loop trough terms and check for parallelity*/
-                {
-                        aktpoly=pNext(aktpoly); //next term
-                        pSetm(aktpoly);
-                        pGetExpV(aktpoly,v);            
-                        /* Convert (int)v into (intvec)check */                 
-                        for (int jj=0;jj<this->numVars;jj++)
-                        {
-                                                //cout << "v["<<jj+1<<"]="<<v[jj+1]<<endl;
-                                                //cout << "leadExpV["<<jj+1<<"]="<<leadExpV[jj+1]<<endl;
-                                (*check)[jj]=v[jj+1]-leadExpV[jj+1];
-                        }
-#ifdef gfan_DEBUG
-//                                      cout << "check=";                       
-//                                      check->show();
-//                                      cout << endl;
-#endif
-                        if (isParallel(*check,*fNormal)) //pass *check when 
-                        {
-//                              cout << "Parallel vector found, adding to initialFormElement" << endl;                  
-                                initialFormElement[ii] = pAdd(pCopy(initialFormElement[ii]),(poly)pHead(aktpoly));
-                        }                                               
-                }//while
-#ifdef gfan_DEBUG
-//                              cout << "Initial Form=";                                
-//                              pWrite(initialFormElement[ii]);
-//                              cout << "---" << endl;
-#endif
-                /*Now initialFormElement must be added to (ideal)initialForm */
-                initialForm->m[ii]=initialFormElement[ii];
-        }//for                  
+        /*intvec *check = new intvec(this->numVars);*/  //array to store the difference of LE and v
+        computeInv(gb,initialForm,*fNormal);
+        //NOTE The code below went into gcone::computeInv
+//      for (int ii=0;ii<IDELEMS(gb);ii++)
+//      {
+//              aktpoly = (poly)gb->m[ii];                                                              
+//              int *v=(int *)omAlloc((this->numVars+1)*sizeof(int));
+//              int *leadExpV=(int *)omAlloc((this->numVars+1)*sizeof(int));
+//              pGetExpV(aktpoly,leadExpV);     //find the leading exponent in leadExpV[1],...,leadExpV[n], use pNext(p)
+//              initialFormElement[ii]=pHead(aktpoly);
+//                              
+//              while(pNext(aktpoly)!=NULL)     //*loop trough terms and check for parallelity*/
+//              {
+//                      aktpoly=pNext(aktpoly); //next term
+//                      pSetm(aktpoly);
+//                      pGetExpV(aktpoly,v);            
+//                      /* Convert (int)v into (intvec)check */                 
+//                      for (int jj=0;jj<this->numVars;jj++)
+//                      {
+//                                              //cout << "v["<<jj+1<<"]="<<v[jj+1]<<endl;
+//                                              //cout << "leadExpV["<<jj+1<<"]="<<leadExpV[jj+1]<<endl;
+//                              (*check)[jj]=v[jj+1]-leadExpV[jj+1];
+//                      }
+// #ifdef gfan_DEBUG
+// //                                   cout << "check=";                       
+// //                                   check->show();
+// //                                   cout << endl;
+// #endif
+//                      if (isParallel(*check,*fNormal)) //pass *check when 
+//                      {
+// //                           cout << "Parallel vector found, adding to initialFormElement" << endl;                  
+//                              initialFormElement[ii] = pAdd(pCopy(initialFormElement[ii]),(poly)pHead(aktpoly));
+//                      }                                               
+//              }//while
+// #ifdef gfan_DEBUG
+// //                           cout << "Initial Form=";                                
+// //                           pWrite(initialFormElement[ii]);
+// //                           cout << "---" << endl;
+// #endif
+//              //*Now initialFormElement must be added to (ideal)initialForm */
+//              initialForm->m[ii]=initialFormElement[ii];
+//              omFree(leadExpV);
+//              omFree(v);
+//      }//for                  
 #ifdef gfan_DEBUG
 /*      cout << "Initial ideal is: " << endl;
@@ -985 +1135 @@
                         
         ideal ina;                      
-        ina=idrCopyR(initialForm,srcRing);                      
-#ifdef gfan_DEBUG
-//                      cout << "ina=";
-//                      idShow(ina); cout << endl;
+        ina=idrCopyR(initialForm,srcRing);
+#ifndef NDEBUG                  
+#ifdef gfan_DEBUG
+                        cout << "ina=";
+                        idShow(ina); cout << endl;
+#endif
 #endif
         ideal H;
                         //H=kStd(ina,NULL,isHomog,NULL);        //we know it is homogeneous
-        H=kStd(ina,NULL,testHomog,NULL);
+        H=kStd(ina,NULL,testHomog,NULL);        //This is \mathcal(G)_{>_-\alpha}(in_v(I))
         idSkipZeroes(H);
-#ifdef gfan_DEBUG
-//                      cout << "H="; idShow(H); cout << endl;
+#ifndef NDEBUG
+#ifdef gfan_DEBUG
+                        cout << "H="; idShow(H); cout << endl;
+#endif
 #endif
         /*Substep 2.2
@@ -1004 +1158 @@
         ideal srcRing_HH;                       
         srcRing_H=idrCopyR(H,tmpRing);
-#ifdef gfan_DEBUG
-//                      cout << "srcRing_H = ";
-//                      idShow(srcRing_H); cout << endl;
-#endif
-        srcRing_HH=ffG(srcRing_H,this->gcBasis);                
-#ifdef gfan_DEBUG
-//                      cout << "srcRing_HH = ";
-//                      idShow(srcRing_HH); cout << endl;
+#ifndef NDEBUG
+#ifdef gfan_DEBUG
+                        cout << "srcRing_H = ";
+                        idShow(srcRing_H); cout << endl;
+#endif
+#endif
+        srcRing_HH=ffG(srcRing_H,this->gcBasis);        
+#ifndef NDEBUG
+#ifdef gfan_DEBUG
+                        cout << "srcRing_HH = ";
+                        idShow(srcRing_HH); cout << endl;
+#endif
 #endif
         /*Substep 2.2.1
@@ -1029 +1187 @@
         {
                 poly aktpoly=(poly)srcRing_HH->m[ii];
-                iPMatrixRows = iPMatrixRows+pLength(aktpoly)-1;
+                iPMatrixRows = iPMatrixRows+pLength(aktpoly);
         }
         /* additionally one row for the standard-simplex and another for a row that becomes 0 during
          * construction of the differences
          */
-        intPointMatrix = dd_CreateMatrix(iPMatrixRows+10,this->numVars+1); //iPMatrixRows+10;
+        intPointMatrix = dd_CreateMatrix(iPMatrixRows+2,this->numVars+1); //iPMatrixRows+10;
         intPointMatrix->numbtype=dd_Integer;    //NOTE: DO NOT REMOVE OR CHANGE TO dd_Rational
-                        
+        
         for (int ii=0;ii<IDELEMS(srcRing_HH);ii++)
         {
@@ -1054 +1212 @@
                         {
 #ifdef gfan_DEBUG
-                                                cout << src_ExpV[kk] << "," << dst_ExpV[kk] << endl;
+//                                              cout << src_ExpV[kk] << "," << dst_ExpV[kk] << endl;
 #endif
                                 if (src_ExpV[kk]!=dst_ExpV[kk])
@@ -1066 +1224 @@
                                 markingsAreCorrect=TRUE; //everything is fine
 #ifdef gfan_DEBUG
-                                                cout << "correct markings" << endl;
+//                                              cout << "correct markings" << endl;
 #endif
                         }//if (pHead(aktpoly)==pHead(H->m[jj])
-                        delete src_ExpV;
-                        delete dst_ExpV;
+//                      delete src_ExpV;
+//                      delete dst_ExpV;
+                        omFree(src_ExpV);
+                        omFree(dst_ExpV);
                 }//for (int jj=0;jj<IDELEMS(H);jj++)
                                 
@@ -1108 +1268 @@
                         aktrow +=1;
                 }
-                delete v;
-                delete leadExpV;
+//              delete v;
+//              delete leadExpV;
+                omFree(v);
+                omFree(leadExpV);
         }//for (int ii=0;ii<IDELEMS(srcRing_HH);ii++)
         /*Now we add the constraint for the standard simplex*/
@@ -1200 +1362 @@
 //      rDelete(dstRing);
 }//void flip(ideal gb, facet *f)
+
+/** \brief Compute initial ideal
+ * Compute the initial ideal in_v(G) wrt a (possible) facet normal
+ * used in gcone::getFacetNormal in order to preprocess possible facet normals
+ * and in gcone::flip for obvious reasons.
+*/
+void gcone::computeInv(ideal &gb, ideal &initialForm, intvec &fNormal)
+{
+        intvec *check = new intvec(this->numVars);
+        poly initialFormElement[IDELEMS(gb)];
+        poly aktpoly;
+        
+        for (int ii=0;ii<IDELEMS(gb);ii++)
+        {
+                aktpoly = (poly)gb->m[ii];                                                              
+                int *v=(int *)omAlloc((this->numVars+1)*sizeof(int));
+                int *leadExpV=(int *)omAlloc((this->numVars+1)*sizeof(int));
+                pGetExpV(aktpoly,leadExpV);     //find the leading exponent in leadExpV[1],...,leadExpV[n], use pNext(p)
+                initialFormElement[ii]=pHead(aktpoly);
                                 
+                while(pNext(aktpoly)!=NULL)     /*loop trough terms and check for parallelity*/
+                {
+                        aktpoly=pNext(aktpoly); //next term
+                        pSetm(aktpoly);
+                        pGetExpV(aktpoly,v);            
+                        /* Convert (int)v into (intvec)check */                 
+                        for (int jj=0;jj<this->numVars;jj++)
+                        {
+                                                //cout << "v["<<jj+1<<"]="<<v[jj+1]<<endl;
+                                                //cout << "leadExpV["<<jj+1<<"]="<<leadExpV[jj+1]<<endl;
+                                (*check)[jj]=v[jj+1]-leadExpV[jj+1];
+                        }
+#ifdef gfan_DEBUG
+//                                      cout << "check=";                       
+//                                      check->show();
+//                                      cout << endl;
+#endif
+                        if (isParallel(*check,fNormal)) //pass *check when 
+                        {
+//                              cout << "Parallel vector found, adding to initialFormElement" << endl;                  
+                                initialFormElement[ii] = pAdd(pCopy(initialFormElement[ii]),(poly)pHead(aktpoly));
+                        }                                               
+                }//while
+#ifdef gfan_DEBUG
+//                              cout << "Initial Form=";                                
+//                              pWrite(initialFormElement[ii]);
+//                              cout << "---" << endl;
+#endif
+                /*Now initialFormElement must be added to (ideal)initialForm */
+                initialForm->m[ii]=initialFormElement[ii];
+                omFree(leadExpV);
+                omFree(v);              
+        }//for
+        delete check;
+}
+
 /** \brief Compute the remainder of a polynomial by a given ideal
  *
@@ -1801 +2018 @@
         
         fAct = gcAct->facetPtr;
-        //NOTE Disabled until code works as expected
-        //gcAct->writeConeToFile(*gcAct);
+        //NOTE Disabled until code works as expected. Reenabled 2.11.2009
+        gcAct->writeConeToFile(*gcAct);
                         
         /*End of initialisation*/
@@ -1810 +2027 @@
           We always choose the first facet from fListPtr as facet to be flipped
         */                      
+        time_t tic, tac;
         while((SearchListAct!=NULL))// && counter<10)
         {//NOTE See to it that the cone is only changed after ALL facets have been flipped!                             
@@ -1816 +2034 @@
                 while(fAct!=NULL)
                 {       //Since SLA should only contain flippables there should be no need to check for that
+                        time(&tic);
                         gcAct->flip(gcAct->gcBasis,fAct);
+                        time(&tac);
+                        cout << "t_flip = " << difftime(tac,tic) << endl;
                         ring rTmp=rCopy(fAct->flipRing);
                         rComplete(rTmp);                        
@@ -1831 +2052 @@
 //                      idDelete((ideal *)&fAct->flipGB);
 //                      rDelete(fAct->flipRing);
+                        time(&tic);
                         gcTmp->getConeNormals(gcTmp->gcBasis, FALSE);                                   
+                        time(&tac);
+                        cout << "t_getConeNormals = " << difftime(tac,tic) << endl;
                         gcTmp->getCodim2Normals(*gcTmp);                                        
                         gcTmp->normalize();
@@ -2410 +2634 @@
         string UCNstr = ss.str();               
                         
-        string prefix="/tmp/cone";
+        string prefix="/tmp/cone";
+//      string prefix="./";     //crude hack -> run tests in separate directories
         string suffix=".sg";
         string filename;
@@ -2416 +2641 @@
         filename.append(UCNstr);
         filename.append(suffix);
-                                        
+        
+        
+//      int thisPID = getpid();
+//      ss << thisPID;
+//      string strPID = ss.str();
+//      string prefix="./";
+                                                
         ofstream gcOutputFile(filename.c_str());
         facet *fAct;
@@ -2654 +2885 @@
         gcInputFile.close();
         rChangeCurrRing(saveRing);
-}       
+}
+        
+// static void gcone::idPrint(ideal &I)
+// {
+//      for(int ii=0;ii<IDELEMS(I);ii++)
+//      {
+//              cout << "_[" << ii << "]=" << I->m[ii] << endl;
+//      }
+// }
 
 

kernel/gfan.h

@@ -3 +3 @@
 
 $Author: monerjan $
-$Date: 2009-10-23 14:56:55 $
-$Header: /exports/cvsroot-2/cvsroot/kernel/gfan.h,v 1.12 2009-10-23 14:56:55 monerjan Exp $
+$Date: 2009/11/03 06:57:32 $
+$Header: /usr/local/Singular/cvsroot/kernel/gfan.h,v 1.13 2009/11/03 06:57:32 monerjan Exp $
 $Id$
 */
@@ -153 +153 @@
                 void showSLA(facet &f);
                 void idDebugPrint(ideal const &I);
+                void invPrint(ideal const &I);
                 bool isMonomial(ideal const &I);
                 void setNumFacets();
@@ -160 +161 @@
                 void getCodim2Normals(gcone const &gc);
                 void flip(ideal gb, facet *f);
+                void computeInv(ideal &gb, ideal &inv, intvec &f);
                 poly restOfDiv(poly const &f, ideal const &I);
                 ideal ffG(ideal const &H, ideal const &G);
@@ -180 +182 @@
                 void writeConeToFile(gcone const &gc, bool usingIntPoints=FALSE);
                 void readConeFromFile(int gcNum, gcone *gc);
+//              static void gcone::idPrint(ideal &I);
                 friend class facet;     
 };