Changeset a355e47 in git

Timestamp:

Feb 5, 2010, 8:06:33 AM (13 years ago)

Author:

Martin Monerjan

Branches:

(u'spielwiese', '828514cf6e480e4bafc26df99217bf2a1ed1ef45')

Children:

55587862408d1e92ee43d342befb2d834ea91635

Parents:

4b3ef4b5fc9fc4028f935c1c66834052d01ef1d2

Message:

Switched to int64vec


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

Location:

kernel

Files:

• gfan.cc (modified) (62 diffs)
• gfan.h (modified) (9 diffs)

kernel/gfan.cc

@@ -13 +13 @@
 #include "kstd1.h"
 #include "kutil.h"      //ksCreateSpoly
-// #include "intvec.h"
+// #include "int64vec.h"
 #include "polys.h"
 #include "ideals.h"
@@ -133 +133 @@
 facet::facet(const facet& f)
 {
-        this->fNormal=ivCopy(f.fNormal);
+        this->fNormal=iv64Copy(f.fNormal);
         this->UCN=f.UCN;
         this->isFlippable=f.isFlippable;
@@ -155 +155 @@
                         f2Act->prev = marker;
                 }
-                intvec *f2Normal;
+                int64vec *f2Normal;
                 f2Normal = f2Copy->getFacetNormal();
 //              f2Act->setFacetNormal(f2Copy->getFacetNormal());
@@ -208 +208 @@
         int notParallelCtr=0;
         int ctr=0;
-        intvec* fNormal; //No new since ivCopy and therefore getFacetNormal return a new
-        intvec* sNormal;
+        int64vec* fNormal; //No new since iv64Copy and therefore getFacetNormal return a new
+        int64vec* sNormal;
         fNormal = f->getFacetNormal();
         sNormal = s->getFacetNormal();
         //Do not need parallelity. Too time consuming
-        if(!isParallel(fNormal,sNormal))
+        if(!isParallel(*fNormal,*sNormal))
                 notParallelCtr++;
-//      intvec *foo=ivNeg(sNormal);
+//      int64vec *foo=ivNeg(sNormal);
 //      if(fNormal->compare(foo)!=0) //facet normals
 //              return TRUE;    
@@ -226 +226 @@
                 while(f2Act!=NULL)
                 {
-                        intvec* f2Normal;
+                        int64vec* f2Normal;
                         f2Normal = f2Act->getFacetNormal();
                         s2Act = s->codim2Ptr;
                         while(s2Act!=NULL)
                         {
-                                intvec* s2Normal;
+                                int64vec* s2Normal;
                                 s2Normal = s2Act->getFacetNormal();
 //                              bool foo=areEqual(f2Normal,s2Normal);
@@ -258 +258 @@
 }       
                 
-/** Stores the facet normal \param intvec*/
-inline void facet::setFacetNormal(intvec *iv)
-{
-        this->fNormal = ivCopy(iv);                     
+/** Stores the facet normal \param int64vec*/
+inline void facet::setFacetNormal(int64vec *iv)
+{
+        this->fNormal = iv64Copy(iv);                   
 }
                 
 /** Hopefully returns the facet normal 
-* Mind: ivCopy returns a new intvec, so use this in the following way:
-* intvec *iv;
+* Mind: iv64Copy returns a new int64vec, so use this in the following way:
+* int64vec *iv;
 * iv = this->getFacetNormal();
 * [...]
 * delete(iv);
 */
-inline intvec *facet::getFacetNormal()
+inline int64vec *facet::getFacetNormal()
 {                               
-        return ivCopy(this->fNormal);
+        return iv64Copy(this->fNormal);
 //      return this->fNormal;
 }
@@ -318 +318 @@
 {
         if(this!=NULL)//  && this!=(facet *)0xfbfbfbfbfbfbfbfb)// || this!=(facet *)0xfbfbfbfb) )
-//      if(this!=NULL && ( this->fNormal!=(intvec *)0xfbfbfbfb || this->fNormal!=(intvec *)0xfbfbfbfbfbfbfbfb) )
+//      if(this!=NULL && ( this->fNormal!=(int64vec *)0xfbfbfbfb || this->fNormal!=(int64vec *)0xfbfbfbfbfbfbfbfb) )
                 return this->UCN;
         else
@@ -325 +325 @@
                 
 /** Store an interior point of the facet */
-inline void facet::setInteriorPoint(intvec *iv)
-{
-        this->interiorPoint = ivCopy(iv);
+inline void facet::setInteriorPoint(int64vec *iv)
+{
+        this->interiorPoint = iv64Copy(iv);
 }
                 
 /** Returns a pointer to this->interiorPoint
-* MIND: ivCopy returns a new intvec
+* MIND: iv64Copy returns a new int64vec
 * @see facet::getFacetNormal
 */
-inline intvec *facet::getInteriorPoint()
-{
-        return ivCopy(this->interiorPoint);
+inline int64vec *facet::getInteriorPoint()
+{
+        return iv64Copy(this->interiorPoint);
 }       
                 
@@ -346 +346 @@
         facet *codim2Act;                       
         codim2Act = this->codim2Ptr;
-        intvec *fNormal;
+        int64vec *fNormal;
         fNormal = this->getFacetNormal();       
         cout << "=======================" << endl;
@@ -356 +356 @@
         while(codim2Act!=NULL)
         {
-                intvec *f2Normal;
+                int64vec *f2Normal;
                 f2Normal = codim2Act->getFacetNormal();
                 cout << "(";
@@ -487 +487 @@
         
 /** \brief Set the interior point of a cone */
-inline void gcone::setIntPoint(intvec *iv)
-{
-        this->ivIntPt=ivCopy(iv);
+inline void gcone::setIntPoint(int64vec *iv)
+{
+        this->ivIntPt=iv64Copy(iv);
 }
                 
 /** \brief Return the interior point */
-inline intvec *gcone::getIntPoint()
-{
-        return ivCopy(this->ivIntPt);
+inline int64vec *gcone::getIntPoint()
+{
+        return iv64Copy(this->ivIntPt);
 }
                 
@@ -524 +524 @@
         while(f!=NULL)
         {
-                intvec *iv;
+                int64vec *iv;
                 iv = f->getFacetNormal();
                 cout << "(";
@@ -561 +561 @@
         while(fAct!=NULL)
         {
-                intvec *fNormal;                
+                int64vec *fNormal;              
                 fNormal=fAct->getFacetNormal();
                 cout << "(";
@@ -574 +574 @@
                 while(codim2Act!=NULL)
                 {
-                        intvec *f2Normal;
+                        int64vec *f2Normal;
                         f2Normal = codim2Act->getFacetNormal();
                         cout << "(";
@@ -721 +721 @@
         */
 //      ideal initialForm=idInit(IDELEMS(I),1);
-//      intvec *gamma=new intvec(this->numVars);
+//      int64vec *gamma=new int64vec(this->numVars);
         int falseGammaCounter=0;
         int *redRowsArray=NULL;
@@ -731 +731 @@
                 //read row ii into gamma
                 double tmp;
-                intvec *gamma=new intvec(this->numVars);
+                int64vec *gamma=new int64vec(this->numVars);
                 for(int jj=1;jj<=this->numVars;jj++)
                 {
@@ -833 +833 @@
         for(int ii=0;ii<ddineq->rowsize;ii++)
         {
-                intvec *ivPos = new intvec(this->numVars);
+                int64vec *ivPos = new int64vec(this->numVars);
                 for(int jj=0;jj<this->numVars;jj++)
                         (*ivPos)[jj]=(int)mpq_get_d(ddineq->matrix[ii][jj+1]);
@@ -840 +840 @@
                 for(int jj=0;jj<this->numVars;jj++)
                 {
-                        intvec *ivCanonical = new intvec(this->numVars);
+                        int64vec *ivCanonical = new int64vec(this->numVars);
                         jj==0 ? (*ivCanonical)[ivPos->length()-1]=1 : (*ivCanonical)[jj-1]=1;
                         if(dotProduct(*ivCanonical,*ivPos)!=0)
@@ -891 +891 @@
         for (int kk = 0; kk<ddrows; kk++)
         {
-                intvec *load = new intvec(this->numVars);//intvec to store a single facet normal that will then be stored via setFacetNormal
+                int64vec *load = new int64vec(this->numVars);//int64vec to store a single facet normal that will then be stored via setFacetNormal
                 for (int jj = 1; jj <ddcols; jj++)
                 {
@@ -908 +908 @@
                         for(int jj = 0; jj<load->length(); jj++)
                         {
-                                intvec *ivCanonical = new intvec(load->length());
+                                int64vec *ivCanonical = new int64vec(load->length());
                                 (*ivCanonical)[jj]=1;
                                 if (dotProduct(*load,*ivCanonical)<0)   
@@ -996 +996 @@
         if (compIntPoint==TRUE)
         {
-                intvec *iv = new intvec(this->numVars);
+                int64vec *iv = new int64vec(this->numVars);
                 dd_MatrixPtr posRestr=dd_CreateMatrix(this->numVars,this->numVars+1);
                 int jj=1;
@@ -1084 +1084 @@
                                 codim2Act = codim2Act->next;
                         }
-                        intvec *n = new intvec(this->numVars);
+                        int64vec *n = new int64vec(this->numVars);
 #ifdef gfanp
                         timeval t_mI_start, t_mI_end;
@@ -1109 +1109 @@
                 */
                 //TODO It might be faster to compute jus the implied equations instead of a relative interior point
-//              intvec *iv_intPoint = new intvec(this->numVars);
+//              int64vec *iv_intPoint = new int64vec(this->numVars);
 //              dd_MatrixPtr shiftMatrix;
 //              dd_MatrixPtr intPointMatrix;
@@ -1207 +1207 @@
         while(fAct!=NULL)
         {
-                intvec *fNormal;// = new intvec(this->numVars);
+                int64vec *fNormal;// = new int64vec(this->numVars);
                 fNormal = fAct->getFacetNormal();
                 for(int ii=0;ii<rows;ii++)
                 {
-                        intvec *rowvec = new intvec(this->numVars);
+                        int64vec *rowvec = new int64vec(this->numVars);
                         makeInt(P,ii+1,*rowvec);//get an integer entry instead of rational
                         if(dotProduct(*fNormal,*rowvec)==0)
@@ -1285 +1285 @@
                 {
                         containsStrictlyPosRay==TRUE;
-                        intvec *rayvec;
+                        int64vec *rayvec;
                         rayvec = codim2Act->getFacetNormal();//Mind this is no normal but a ray!
                         int negCtr=0;
@@ -1335 +1335 @@
         gettimeofday(&start, 0);
 #endif          
-        intvec *fNormal;// = new intvec(this->numVars); //facet normal, check for parallelity                   
+        int64vec *fNormal;// = new int64vec(this->numVars);     //facet normal, check for parallelity                   
         fNormal = f->getFacetNormal();  //read this->fNormal;
 
@@ -1373 +1373 @@
         if( (srcRing->order[0]!=ringorder_a))
         {
-                intvec *iv = new intvec(this->numVars);
+                int64vec *iv = new int64vec(this->numVars);
                 iv = ivNeg(fNormal);
 //              tmpRing=rCopyAndAddWeight(srcRing,ivNeg(fNormal));
@@ -1580 +1580 @@
         dd_FreeMatrix(posRestr);
 
-        intvec *iv_weight = new intvec(this->numVars);
+        int64vec *iv_weight = new int64vec(this->numVars);
 #ifdef gfanp
         timeval t_dd_start, t_dd_end;
@@ -1603 +1603 @@
         for(int ii=0;ii<P->rowsize;ii++)
         {
-                intvec *iv_row=new intvec(this->numVars);
+                int64vec *iv_row=new int64vec(this->numVars);
                 makeInt(P,ii+1,*iv_row);
                 iv_weight =ivAdd(iv_weight, iv_row);
@@ -1682 +1682 @@
  * and in gcone::flip for obvious reasons.
 */
-inline void gcone::computeInv(ideal &gb, ideal &initialForm, intvec &fNormal)
+inline void gcone::computeInv(ideal &gb, ideal &initialForm, int64vec &fNormal)
 {
 #ifdef gfanp
@@ -1697 +1697 @@
                 while(pNext(aktpoly)!=NULL)     /*loop trough terms and check for parallelity*/
                 {
-                        intvec *check = new intvec(this->numVars);
+                        int64vec *check = new int64vec(this->numVars);
                         aktpoly=pNext(aktpoly); //next term
 //                      pSetm(aktpoly);
                         int *v=(int *)omAlloc((this->numVars+1)*sizeof(int));
                         pGetExpV(aktpoly,v);            
-                        /* Convert (int)v into (intvec)check */                 
+                        /* Convert (int)v into (int64vec)check */                       
                         for (int jj=0;jj<this->numVars;jj++)
                         {
@@ -1786 +1786 @@
         for(int ii=0;ii<ddineq->rowsize;ii++)
         {
-                intvec *iv = new intvec(this->numVars);
+                int64vec *iv = new int64vec(this->numVars);
+                int64vec *ivNull = new int64vec(this->numVars);//Needed for intvec64::compare(*intvec)
                 int posCtr=0;
                 for(int jj=0;jj<this->numVars;jj++)
@@ -1796 +1797 @@
                 }
 //              if( (iv->compare(0)==0) || (posCtr==iv->length()) )
-                if( (posCtr==iv->length()) || (iv->compare(0)==0) )             
+                if( (posCtr==iv->length()) || (iv->compare(ivNull)==0) )                
                 {
                         dd_MatrixRowRemove(&ddineq,ii+1);
@@ -1812 +1813 @@
 //      for(int ii=0;ii<num_newRows-1;ii++)
 //      {
-//              intvec *iv = new intvec(this->numVars);//1st vector to check against
+//              int64vec *iv = new int64vec(this->numVars);//1st vector to check against
 //              for(int jj=0;jj<this->numVars;jj++)
 //                      (*iv)[jj]=(int)mpq_get_d(ddineq->matrix[ii][jj+1]);
 //              for(int jj=ii+1;jj</*ddineq->rowsize*/num_newRows;jj++)
 //              {
-//                      intvec *ivCheck = new intvec(this->numVars);//Checked against iv
+//                      int64vec *ivCheck = new int64vec(this->numVars);//Checked against iv
 //                      for(int kk=0;kk<this->numVars;kk++)
 //                              (*ivCheck)[kk]=(int)mpq_get_d(ddineq->matrix[jj][kk+1]);
@@ -1868 +1869 @@
 }//void getGB
                 
-/** \brief Compute the negative of a given intvec
+/** \brief Compute the negative of a given int64vec
         */              
-inline intvec *gcone::ivNeg(const intvec *iv)
-{
+inline int64vec *gcone::ivNeg(int64vec *iv)
+{       //Hm, switching to int64vec const int64vec does no longer work
         //NOTE: Can't this be done without new?
-        intvec *res;// = new intvec(iv->length());
-        res=ivCopy(iv);
+        int64vec *res;// = new int64vec(iv->length());
+        res=iv64Copy(iv);
         *res *= (int)-1;                                                
         return res;
@@ -1883 +1884 @@
 *
 */
-inline int gcone::dotProduct(const intvec &iva, const intvec &ivb)                              
+inline int gcone::dotProduct(int64vec &iva, int64vec &ivb)                              
 {                       
         int res=0;
@@ -1897 +1898 @@
  * \f$ \alpha\parallel\beta\Leftrightarrow\langle\alpha,\beta\rangle^2=\langle\alpha,\alpha\rangle\langle\beta,\beta\rangle \f$
  */
-inline bool gcone::isParallel(const intvec &a, const intvec &b)
+inline bool gcone::isParallel(int64vec &a, int64vec &b)
 {                       
         int lhs,rhs;
@@ -1916 +1917 @@
                 
 /** \brief Compute an interior point of a given cone
- * Result will be written into intvec iv. 
+ * Result will be written into int64vec iv. 
  * Any rational point is automatically converted into an integer.
  */
-inline void gcone::interiorPoint( dd_MatrixPtr &M, intvec &iv) //no const &M here since we want to remove redundant rows
+inline void gcone::interiorPoint( dd_MatrixPtr &M, int64vec &iv) //no const &M here since we want to remove redundant rows
 {
         dd_LPPtr lp,lpInt;
@@ -2018 +2019 @@
 }//void interiorPoint(dd_MatrixPtr const &M)
 
-inline void gcone::interiorPoint2(const dd_MatrixPtr &M, intvec &iv)
+inline void gcone::interiorPoint2(const dd_MatrixPtr &M, int64vec &iv)
 {
         KMatrix<Rational> mMat(M->rowsize+1,M->colsize);
@@ -2070 +2071 @@
  * 
  */
-ring gcone::rCopyAndAddWeight(const ring &r, const intvec *ivw)                         
+ring gcone::rCopyAndAddWeight(const ring &r, int64vec *ivw)                             
 {
         ring res=rCopy0(r);
@@ -2105 +2106 @@
 }//rCopyAndAdd
                 
-ring rCopyAndChangeWeight(ring const &r, intvec *ivw)
+ring rCopyAndChangeWeight(ring const &r, int64vec *ivw)
 {
         ring res=rCopy0(currRing);
@@ -2126 +2127 @@
 /** \brief Check for equality of two intvecs
  */
-inline bool gcone::areEqual(const intvec &a, const intvec &b)
+inline bool gcone::areEqual(int64vec &a, int64vec &b)
 {
         bool res=TRUE;
@@ -2262 +2263 @@
  * Compute gcBasis and facets for the arbitrary starting cone. Store \f$(codim-1)\f$-facets as normals.
  * In order to represent a facet uniquely compute also the \f$(codim-2)\f$-facets and norm by the gcd of the components.
- * Keep a list of facets as a linked list containing an intvec and an integer matrix.
+ * Keep a list of facets as a linked list containing an int64vec and an integer matrix.
  * Since a \f$(codim-1)\f$-facet belongs to exactly two full dimensional cones, we remove a facet from the list as
  * soon as we compute this facet again. Comparison of facets is done by...
@@ -2329 +2330 @@
                 if(fAct->isFlippable==TRUE)
                 {
-                        intvec *fNormal;
+                        int64vec *fNormal;
                         fNormal = fAct->getFacetNormal();
                         if( ii==0 || (ii>0 && SearchListAct==NULL) ) //1st facet may be non-flippable
@@ -2353 +2354 @@
 //                      for(int jj=0;jj<fAct->numRays-1;jj++)
                         {
-                                intvec *f2Normal;
+                                int64vec *f2Normal;
                                 f2Normal = codim2Act->getFacetNormal();
                                 if(jj==0)
@@ -2511 +2512 @@
  *
  * We compute the lcm of the denominators and multiply with this to get integer values.         
- * \param dd_MatrixPtr,intvec
+ * \param dd_MatrixPtr,int64vec
  */
-inline void gcone::makeInt(const dd_MatrixPtr &M, const int line, intvec &n)
+inline void gcone::makeInt(const dd_MatrixPtr &M, const int line, int64vec &n)
 {                       
 //      mpz_t denom[this->numVars];
@@ -2582 +2583 @@
         while(fAct!=NULL)
         {
-                intvec *fNormal;
+                int64vec *fNormal;
                 fNormal = fAct->getFacetNormal();
                 for(int ii=0;ii<this->numVars;ii++)
@@ -2595 +2596 @@
                 while(codim2Act!=NULL)
                 {                               
-                        intvec *n;
+                        int64vec *n;
                         n=codim2Act->getFacetNormal();
                         for(int ii=0;ii<this->numVars;ii++)
@@ -2673 +2674 @@
         }
         /*1st step: compare facetNormals*/
-//      intvec *fNormal=NULL;gcone::
-//      intvec *slNormal=NULL;
+//      int64vec *fNormal=NULL;gcone::
+//      int64vec *slNormal=NULL;
                         
         while(fAct!=NULL)
@@ -2680 +2681 @@
                 if(fAct->isFlippable==TRUE)
                 {
-                        intvec *fNormal=NULL;
-//                      intvec *slNormal=NULL;
+                        int64vec *fNormal=NULL;
+//                      int64vec *slNormal=NULL;
                         fNormal=fAct->getFacetNormal();
                         slAct = slHead;
@@ -2711 +2712 @@
                         //while(slAct!=slEndStatic->next)
                         {
-                                intvec *slNormal=NULL;
+                                int64vec *slNormal=NULL;
                                 removalOccured=FALSE;
                                 slNormal = slAct->getFacetNormal();
@@ -2797 +2798 @@
                                 slEnd->prev = marker;
                                 //Copy codim2-facets
-//                              intvec *f2Normal=new intvec(this->numVars);
+//                              int64vec *f2Normal=new int64vec(this->numVars);
                                 while(f2Act!=NULL)
                                 {
-                                        intvec *f2Normal;
+                                        int64vec *f2Normal;
                                         f2Normal=f2Act->getFacetNormal();
                                         if(slEndCodim2Root==NULL)
@@ -2894 +2895 @@
         while(fAct!=NULL)
         {
-                intvec *comp;
+                int64vec *comp;
                 comp = fAct->getFacetNormal();
                 for(int ii=0;ii<this->numVars;ii++)
@@ -2969 +2970 @@
                 while(fAct!=NULL)
                 {       
-                        intvec *iv;
+                        int64vec *iv;
                         iv=fAct->getFacetNormal();
                         f2Act=fAct->codim2Ptr;
@@ -2986 +2987 @@
                         while(f2Act!=NULL)
                         {
-                                intvec *iv2;
+                                int64vec *iv2;
                                 iv2=f2Act->getFacetNormal();    
                                 for(int jj=0;jj<iv2->length();jj++)
@@ -3057 +3058 @@
 //                      string strweight;
 //                      strweight=line.substr(0,line.find_first_of(")"));
-//                      intvec *iv=new intvec(this->numVars);
+//                      int64vec *iv=new int64vec(this->numVars);
 //                      for(int ii=0;ii<this->numVars;ii++)
 //                      {
@@ -3259 +3260 @@
 
                 l->m[2].rtyp=INTVEC_CMD;
-                intvec iv=(gcAct->f2M(gcAct,gcAct->facetPtr));
-                l->m[2].data=(void*)ivCopy(&iv);
+                int64vec iv=(gcAct->f2M(gcAct,gcAct->facetPtr));
+                l->m[2].data=(void*)iv64Copy(&iv);
                 
                 l->m[3].rtyp=LIST_CMD;
@@ -3270 +3271 @@
                         {
                                 lCodim2List->m[jj].rtyp=INTVEC_CMD;
-                                intvec ivC2=(gcAct->f2M(gcAct,fAct,2));
-                                lCodim2List->m[jj].data=(void*)ivCopy(&ivC2);
+                                int64vec ivC2=(gcAct->f2M(gcAct,fAct,2));
+                                lCodim2List->m[jj].data=(void*)iv64Copy(&ivC2);
                                 jj++;
                                 fAct = fAct->next;
@@ -3291 +3292 @@
 *
 */
-inline intvec gcone::f2M(gcone *gc, facet *f, int n)
+inline int64vec gcone::f2M(gcone *gc, facet *f, int n)
 {
         facet *fAct;
-        intvec *res;//=new intvec(this->numVars);       
+        int64vec *res;//=new int64vec(this->numVars);   
 //      int codim=n;
 //      int bound;
@@ -3300 +3301 @@
         if(n==1)
         {
-                intvec *m1Res=new intvec(gc->numFacets,gc->numVars,0);
-                res = ivCopy(m1Res);
+                int64vec *m1Res=new int64vec(gc->numFacets,gc->numVars,0);
+                res = iv64Copy(m1Res);
                 fAct = gc->facetPtr;
                 delete m1Res;
@@ -3309 +3310 @@
         {
                 fAct = f->codim2Ptr;
-                intvec *m2Res = new intvec(f->numCodim2Facets,gc->numVars,0);
-                res = ivCopy(m2Res);
+                int64vec *m2Res = new int64vec(f->numCodim2Facets,gc->numVars,0);
+                res = iv64Copy(m2Res);
                 delete m2Res;   
 //              bound = fAct->numCodim2Facets*(this->numVars);
@@ -3318 +3319 @@
         while(fAct!=NULL )//&& ii < bound )
         {
-                intvec *fNormal;
+                int64vec *fNormal;
                 fNormal = fAct->getFacetNormal();
                 for(int jj=0;jj<this->numVars;jj++)

kernel/gfan.h

@@ -13 +13 @@
 
 #include "intvec.h"
+#include "int64vec.h"
 
 #define p800
@@ -34 +35 @@
 lists gfan(ideal inputIdeal, int heuristic);
 
-//int dotProduct(intvec a, intvec b);
-//bool isParallel(intvec a, intvec b);
+//int dotProduct(int64vec a, int64vec b);
+//bool isParallel(int64vec a, int64vec b);
 
 class facet
@@ -41 +42 @@
         private:
                 /** \brief Inner normal of the facet, describing it uniquely up to isomorphism */
-                intvec *fNormal;
+                int64vec *fNormal;
                 
                 /** \brief An interior point of the facet*/
-                intvec *interiorPoint;
+                int64vec *interiorPoint;
                 
                 /** \brief Universal Cone Number
@@ -89 +90 @@
                 /** \brief Comparison of facets*/
                 inline bool areEqual(facet *f, facet *g);
-                /** Stores the facet normal \param intvec*/
-                inline void setFacetNormal(intvec *iv);
+                /** Stores the facet normal \param int64vec*/
+                inline void setFacetNormal(int64vec *iv);
                 /** Hopefully returns the facet normal */
-                inline intvec *getFacetNormal();
+                inline int64vec *getFacetNormal();
                 /** Method to print the facet normal*/
                 inline void printNormal();
@@ -108 +109 @@
                 inline int getUCN();
                 /** Store an interior point of the facet */
-                inline void setInteriorPoint(intvec *iv);
-                inline intvec *getInteriorPoint();
+                inline void setInteriorPoint(int64vec *iv);
+                inline int64vec *getInteriorPoint();
                 /** \brief Debugging function
                  * prints the facet normal an all (codim-2)-facets that belong to it
@@ -130 +131 @@
                 ideal inputIdeal;       //the original
                 ring baseRing;          //the basering of the cone                              
-                intvec *ivIntPt;        //an interior point of the cone
+                int64vec *ivIntPt;      //an interior point of the cone
                 int UCN;                //unique number of the cone
                 int pred;               //UCN of the cone this one is derived from
@@ -188 +189 @@
                 inline int getCounter();
                 inline ring getBaseRing();
-                inline void setIntPoint(intvec *iv);
-                inline intvec *getIntPoint();
+                inline void setIntPoint(int64vec *iv);
+                inline int64vec *getIntPoint();
                 inline void showIntPoint();
                 inline void setNumFacets();
@@ -200 +201 @@
                 inline void invPrint(const ideal &I);
                 inline bool isMonomial(const ideal &I);
-                inline intvec *ivNeg(const intvec *iv);
-                inline int dotProduct(const intvec &iva, const intvec &ivb);
-                inline bool isParallel(const intvec &a, const intvec &b);
-                inline bool areEqual(const intvec &a, const intvec &b);
+                inline int64vec *ivNeg(int64vec *iv);
+                inline int dotProduct(int64vec &iva, int64vec &ivb);
+                inline bool isParallel(int64vec &a, int64vec &b);
+                inline bool areEqual(int64vec &a, int64vec &b);
                 inline bool areEqual(facet *f, facet *g);
                 inline int intgcd(int a, int b);
                 inline void writeConeToFile(const gcone &gc, bool usingIntPoints=FALSE);
                 inline void readConeFromFile(int gcNum, gcone *gc);
-                inline intvec f2M(gcone *gc, facet *f, int n=1);
+                inline int64vec f2M(gcone *gc, facet *f, int n=1);
                 inline void sortRays(gcone *gc);
                 //The real stuff
@@ -215 +216 @@
                 inline void getExtremalRays(const gcone &gc);
                 inline void flip(ideal gb, facet *f);
-                inline void computeInv(ideal &gb, ideal &inv, intvec &f);
+                inline void computeInv(ideal &gb, ideal &inv, int64vec &f);
 //              poly restOfDiv(poly const &f, ideal const &I); removed with r12286
                 inline ideal ffG(const ideal &H, const ideal &G);
                 inline void getGB(ideal const &inputIdeal);             
-                inline void interiorPoint( dd_MatrixPtr &M, intvec &iv);
-                inline void interiorPoint2(const dd_MatrixPtr &M, intvec &iv);
+                inline void interiorPoint( dd_MatrixPtr &M, int64vec &iv);
+                inline void interiorPoint2(const dd_MatrixPtr &M, int64vec &iv);
                 inline void preprocessInequalities(dd_MatrixPtr &M);
-                ring rCopyAndAddWeight(const ring &r, const intvec *ivw);
-                ring rCopyAndChangeWeight(const ring &r, intvec *ivw);          
+                ring rCopyAndAddWeight(const ring &r, int64vec *ivw);
+                ring rCopyAndChangeWeight(const ring &r, int64vec *ivw);                
 //              void reverseSearch(gcone *gcAct); //NOTE both removed from r12286
 //              bool isSearchFacet(gcone &gcTmp, facet *testfacet);
                 void noRevS(gcone &gcRoot, bool usingIntPoint=FALSE);
-                inline void makeInt(const dd_MatrixPtr &M, const int line, intvec &n);
+                inline void makeInt(const dd_MatrixPtr &M, const int line, int64vec &n);
                 inline void normalize();
                 facet * enqueueNewFacets(facet *f);