Changeset e57255 in git

Timestamp:

Dec 16, 2013, 3:12:47 PM (9 years ago)

Author:

Oleksandr Motsak <motsak@…>

Branches:

(u'jengelh-datetime', 'ceac47cbc86fe4a15902392bdbb9bd2ae0ea02c6')(u'spielwiese', 'f875bbaccd0831e36aaed09ff6adeb3eb45aeb94')

Children:

d186d3baff30f2e6e96b2a354ff156ec286fcb4ef24b9c65dd9d2b3d937e5841295580dedc2f7412

Parents:

27877c10cae6d5eb945d62a27d66dfdf8a5a47849e8ae12733559521215c7641624da588f2d8cdf3

Message:

Merge pull request #429 from YueRen/polymakelib

Polymakelib

Files:

• Singular/LIB/COPYING (modified) (1 diff)
• Singular/LIB/polymake.lib (moved) (moved from Singular/LIB/oldpolymake.lib) (42 diffs)
• Singular/LIB/tropical.lib (modified) (18 diffs)
• Singular/ipid.cc (modified) (1 diff)
• Singular/singular-libs (modified) (2 diffs)
• Singular/subexpr.cc (modified) (1 diff)
• Tst/Short/bug_newstruct.res.gz.uu (modified) (1 diff)
• Tst/Short/polymake.tst (modified) (1 diff)
• debian/changelog (modified) (1 diff)
• doc/COPYING.texi (modified) (2 diffs)
• doc/Makefile.bsp (modified) (1 diff)
• doc/NEWS.texi (modified) (3 diffs)
• doc/singular.doc (modified) (previous)
• kernel/kstd1.cc (modified) (2 diffs)
• kernel/kstd2.cc (modified) (2 diffs)

Singular/LIB/COPYING

@@ -134 +134 @@
 paramet.lib     Thomas Keilen                   keilen@mathematik.uni-kl.de
 perron.lib      Oleksandr Motsak                motsak at mathematik dot uni minus kl dot de
-phindex.lib 
+phindex.lib
 pointid.lib     Stefan Steidel                  steidel@mathematik.uni-kl.de
 poly.lib        Olaf Bachmann                   obachman@mathematik.uni-kl.de
                 Gert-Martin Greuel              greuel@mathematik.uni-kl.de
                 Anne Fruehbis-Krueger           anne@mathematik.uni-kl.de
-oldpolymake.lib Thomas Markwig                  keilen@mathematik.uni-kl.de
+polymake.lib    Thomas Markwig                  keilen@mathematik.uni-kl.de
 presolve.lib    Gert-Martin Greuel              greuel@mathematik.uni-kl.de
 primdec.lib     Gerhard Pfister                 pfister@mathematik.uni-kl.de

Singular/LIB/polymake.lib

@@ -1 @@
-////
-version="version oldpolymake.lib 4.0.0.0 Jun_2013 "; // $Id$
+version="version oldpolymake.lib 4.0.0.0 Jun_2013 ";
 category="Tropical Geometry";
 info="
-LIBRARY:   oldpolymake.lib  Computations with polytopes and fans,
-                            interface to polymake and TOPCOM
+LIBRARY:   polymake.lib    Computations with polytopes and fans,
+                           interface to polymake and TOPCOM
 AUTHOR:    Thomas Markwig,  email: keilen@mathematik.uni-kl.de
 
@@ -10 +9 @@
    Most procedures will not work unless polymake or topcom is installed and
    if so, they will only work with the operating system LINUX!
-   For more detailed information see the following note or consult the
+   For more detailed information see IMPORTANT NOTE respectively consult the
    help string of the procedures.
 
-NOTE:
+   The conventions used in this library for polytopes and fans, e.g. the
+   length and labeling of their vertices resp. rays, differs from the conventions
+   used in polymake and thus from the conventions used in the polymake
+   extension polymake.so of Singular. We recommend to use the newer polymake.so
+   whenever possible.
+
+IMPORTANT NOTE:
    Even though this is a Singular library for computing polytopes and fans
    such as the Newton polytope or the Groebner fan of a polynomial, most of
@@ -19 +24 @@
 @* - polymake by Ewgenij Gawrilow, TU Berlin and Michael Joswig, TU Darmstadt
 @*   (see http://www.math.tu-berlin.de/polymake/),
-@* respectively (only in the procedure triangularions) by the program
-@* - topcom by Joerg Rambau, Universitaet Bayreuth (see http://www.uni-bayreuth.de/
-     departments/wirtschaftsmathematik/rambau/TOPCOM);
-@*   This library should rather be seen as an interface which allows to use a
+@* respectively (only in the procedure triangulations) by the program
+@* - topcom by Joerg Rambau, Universitaet Bayreuth (see
+@*   http://www.uni-bayreuth.de/departments/wirtschaftsmathematik/rambau/TOPCOM);
+@*   this library should rather be seen as an interface which allows to use a
      (very limited) number of options which polymake respectively topcom offers
      to compute with polytopes and fans and to make the results available in
@@ -32 +37 @@
      independent of both, polymake and topcom.
 
-PROCEDURES:
-  polymakePolytope()   computes the vertices of a polytope using polymake
-  newtonPolytopeP()     computes the Newton polytope of a polynomial
-  newtonPolytopeLP()   computes the lattice points of the Newton polytope
-  normalFan()          computes the normal fan of a polytope
-  groebnerFan()        computes the Groebner fan of a polynomial
-  intmatToPolymake()   transforms an integer matrix into polymake format
-  polymakeToIntmat()   transforms polymake output into an integer matrix
-
-  triangulations()     computes all triangulations of a marked polytope
-  secondaryPolytope()  computes the secondary polytope of a marked polytope
-
-  secondaryFan()       computes the secondary fan of a marked polytope
-
-  cycleLength()      computes the cycleLength of cycle
-  splitPolygon()     splits a marked polygon into vertices, facets, interior points
-  eta()              computes the eta-vector of a triangulation
-  findOrientedBoundary()    computes the boundary of a convex hull
-  cyclePoints()      computes lattice points connected to some lattice point
-  latticeArea()      computes the lattice area of a polygon
-  picksFormula()     computes the ingrediants of Pick's formula for a polygon
-  ellipticNF()       computes the normal form of an elliptic polygon
-  ellipticNFDB()     displays the 16 normal forms of elliptic polygons
-
-  polymakeKeepTmpFiles()  determines if the files created in /tmp should be kept
+PROCEDURES USING POLYMAKE:
+  polymakePolytope()  computes the vertices of a polytope using polymake
+  newtonPolytopeP()    computes the Newton polytope of a polynomial
+  newtonPolytopeLP()  computes the lattice points of the Newton polytope
+  normalFanL()         computes the normal fan of a polytope
+  groebnerFan()       computes the Groebner fan of a polynomial
+
+PROCEDURES USING TOPCOM:
+  triangulations()    computes all triangulations of a marked polytope
+  secondaryPolytope() computes the secondary polytope of a marked polytope
+
+PROCEDURES USING POLYMAKE AND TOPCOM:
+  secondaryFan()      computes the secondary fan of a marked polytope
+
+PROCEDURES CONERNED WITH PLANAR POLYGONS:
+  cycleLength()    computes the cycleLength of cycle
+  splitPolygon()   splits a marked polygon into vertices, facets, interior points
+  eta()            computes the eta-vector of a triangulation
+  findOrientedBoundary()  computes the boundary of a convex hull
+  cyclePoints()    computes lattice points connected to some lattice point
+  latticeArea()    computes the lattice area of a polygon
+  picksFormula()   computes the ingrediants of Pick's formula for a polygon
+  ellipticNF()     computes the normal form of an elliptic polygon
+  ellipticNFDB()   displays the 16 normal forms of elliptic polygons
 
 KEYWORDS:    polytope; fan; secondary fan; secondary polytope; polymake;
@@ -85 +89 @@
 ////////////////////////////////////////////////////////////////////////////////
 
+static proc mod_init ()
+{
+  LIB "gfanlib.so";
+  LIB "polymake.so";
+}
 
 /////////////////////////////////////////////////////////////////////////////
@@ -90 +99 @@
 /////////////////////////////////////////////////////////////////////////////
 
-proc polymakePolytope (intmat polytop,list #)
-"USAGE:  polymakePolytope(polytope[,#]);   polytope list, # string
-ASSUME:  each row of polytope gives the coordinates of a lattice point of a
+proc polymakePolytope (intmat points)
+"USAGE:  polymakePolytope(points);   polytope intmat
+ASSUME:  each row of points gives the coordinates of a lattice point of a
          polytope with their affine coordinates as given by the output of
          secondaryPolytope
 PURPOSE: the procedure calls polymake to compute the vertices of the polytope
          as well as its dimension and information on its facets
-RETURN:  list L with four entries
+RETURN:  list, L with four entries
 @*            L[1] : an integer matrix whose rows are the coordinates of vertices
                      of the polytope
 @*            L[2] : the dimension of the polytope
-@*            L[3] : a list whose i-th entry explains to which vertices the
+@*            L[3] : a list whose ith entry explains to which vertices the
                      ith vertex of the Newton polytope is connected
                      -- i.e. L[3][i] is an integer vector and an entry k in
                         there means that the vertex L[1][i] is connected to the
                         vertex L[1][k]
-@*            L[4] : an integer matrix whose rows mulitplied by
+@*            L[4] : an matrix of type bigintmat whose rows mulitplied by
                      (1,var(1),...,var(nvar)) give a linear system of equations
                      describing the affine hull of the polytope,
@@ -118 +127 @@
          convention which starts indexing its vertices by zero while we start
          with one !
-@*    -  the procedure creates the file  /tmp/polytope.polymake which contains
-         the polytope in polymake format; if you wish to use this for further
-         computations with polymake, you have to use the procedure
-         polymakeKeepTmpFiles in before
-@*    -  moreover, the procedure creates the file /tmp/polytope.output which
-         it deletes again before ending
-@*    -  it is possible to provide an optional second argument a string
-         which then will be used instead of 'polytope' in the name of the
-         polymake output file
 EXAMPLE: example polymakePolytope;   shows an example"
 {
-  // the header for the file secendarypolytope.polymake
-  string sp="_application polytope
-_version 2.2
-_type RationalPolytope
-
-POINTS
-";
+  // add a first column to polytope as homogenising coordinate
+  points=intmatAddFirstColumn(points,"points");
+  polytope polytop=polytopeViaPoints(points);
+  list graph=vertexAdjacencyGraph(polytop)[2];
   int i,j;
-  // set the name for the polymake output file
-  if (size(#)>0)
-  {
-    if (typeof(#[1])=="string")
-    {
-      string dateiname=#[1];
-    }
-    else
-    {
-      string dateiname="polytope";
-    }
-  }
-  else
-  {
-    string dateiname="polytope";
-  }
-  // create the lattice point list for polymake
-  sp=sp+intmatToPolymake(polytop,"points");
-  // initialise dateiname.polymake and compute the vertices
-  write(":w /tmp/"+dateiname+".polymake",sp);
-  system("sh","cd /tmp; polymake "+dateiname+".polymake VERTICES > "+dateiname+".output");
-  string vertices=read("/tmp/"+dateiname+".output");
-  system("sh","/bin/rm /tmp/"+dateiname+".output");
-  intmat np=polymakeToIntmat(vertices,"affine");
-  // compute the dimension
-  system("sh","cd /tmp; polymake "+dateiname+".polymake DIM > "+dateiname+".output");
-  string pdim=read("/tmp/"+dateiname+".output");
-  system("sh","/bin/rm /tmp/"+dateiname+".output");
-  pdim=pdim[5,size(pdim)-6];
-  execute("int nd="+pdim+";");
-  // compute the vertex-edge graph
-  system("sh","cd /tmp; polymake "+dateiname+".polymake GRAPH > "+dateiname+".output");
-  string vertexedgegraph=read("/tmp/"+dateiname+".output");
-  system("sh","/bin/rm /tmp/"+dateiname+".output");
-  vertexedgegraph=vertexedgegraph[7,size(vertexedgegraph)-8];
-  string newveg;
-  for (i=1;i<=size(vertexedgegraph);i++)
-  {
-    if (vertexedgegraph[i]=="{")
-    {
-      newveg=newveg+"intvec(";
-    }
-    else
-    {
-      if (vertexedgegraph[i]=="}")
-      {
-        newveg=newveg+"),";
-      }
-      else
-      {
-        if (vertexedgegraph[i]==" ")
-        {
-          newveg=newveg+",";
-        }
-        else
-        {
-          newveg=newveg+vertexedgegraph[i];
-        }
-      }
-    }
-  }
-  newveg=newveg[1,size(newveg)-1];
-  execute("list nveg="+newveg+";");
-  // raise each entry in nveg by one
-  for (i=1;i<=size(nveg);i++)
-  {
-    for (j=1;j<=size(nveg[i]);j++)
-    {
-      nveg[i][j]=nveg[i][j]+1;
-    }
-  }
-  // compute the affine hull
-  system("sh","cd /tmp; polymake "+dateiname+".polymake AFFINE_HULL > "+dateiname+".output");
-  string equations=read("/tmp/"+dateiname+".output");
-  system("sh","/bin/rm /tmp/"+dateiname+".output");
-  if (size(equations)>14)
-  {
-    intmat neq=polymakeToIntmat(equations,"cleardenom");
-  }
-  else
-  {
-    intmat neq[1][ncols(polytop)+1];
-  }
-  // delete the tmp-files, if polymakekeeptmpfiles is not set
-  if (defined(polymakekeeptmpfiles)==0)
-  {
-    system("sh","/bin/rm /tmp/"+dateiname+".polymake");
-  }
-  // return the files
-  return(list(np,nd,nveg,neq));
+  for (i=1;i<=size(graph);i++)
+  {
+    for (j=1;j<=size(graph[i]);j++)
+    {
+      graph[i][j]=graph[i][j]+1;
+    }
+  }
+  return(list(intmatcoldelete(vertices(polytop),1),dimension(polytop),graph,equations(polytop)));
 }
 example
@@ -247 +162 @@
    ring r=0,x(1..4),dp;
    matrix M[5][1]=1,x(1),x(2),x(3),x(4);
-   np[4]*M;
+   intmat(np[4])*M;
 }
 
 /////////////////////////////////////////////////////////////////////////////
 
-proc newtonPolytopeP (poly f,list #)
-"USAGE: newtonPolytopeP(f[,#]);  f poly, # string
-RETURN: list L with four entries
+proc newtonPolytopeP (poly f)
+"USAGE: newtonPolytopeP(f);  f poly
+RETURN: list, L with four entries
 @*            L[1] : an integer matrix whose rows are the coordinates of vertices
                      of the Newton polytope of f
@@ -263 +178 @@
                         there means that the vertex L[1][i] is
                         connected to the vertex L[1][k]
-@*            L[4] : an integer matrix whose rows mulitplied by
+@*            L[4] : an matrix of type bigintmat whose rows mulitplied by
                      (1,var(1),...,var(nvar)) give a linear system of equations
                      describing the affine hull of the Newton polytope, i.e. the
@@ -269 +184 @@
 NOTE: -  if we replace the first column of L[4] by zeros, i.e. if we move
          the affine hull to the origin, then we get the equations for the
-         orthogonal comploment of the linearity space of the normal fan dual
+         orthogonal complement of the linearity space of the normal fan dual
          to the Newton polytope, i.e. we get the EQUATIONS that
          we need as input for polymake when computing the normal fan
@@ -275 +190 @@
          TU Berlin and Michael Joswig, so it only works if polymake is installed;
          see http://www.math.tu-berlin.de/polymake/
-@*    -  the procedure creates the file  /tmp/newtonPolytope.polymake which
-         contains the polytope in polymake format and which can be used for
-         further computations with polymake
-@*    -  moreover, the procedure creates the file /tmp/newtonPolytope.output
-         and deletes it again before ending
-@*    -  it is possible to give as an optional second argument a string
-         which then will be used instead of 'newtonPolytope' in the name of
-         the polymake output file
 EXAMPLE: example newtonPolytopeP;   shows an example"
 {
@@ -296 +203 @@
     f=f-lead(f);
   }
-  if (size(#)==0)
-  {
-    #[1]="newtonPolytope";
-  }
   // call polymakePolytope with exponents
-  return(polymakePolytope(exponents,#));
+  return(polymakePolytope(exponents));
 }
 example
@@ -330 +233 @@
    // the Newton polytope is contained in the affine space given
    //     by the equations
-   np[4]*M;
+   intmat(np[4])*M;
 }
 
@@ -339 +242 @@
 RETURN: list, the exponent vectors of the monomials occuring in f,
               i.e. the lattice points of the Newton polytope of f
-EXAMPLE: example normalFan;   shows an example"
+EXAMPLE: example newtonPolytopeLP;   shows an example"
 {
   list np;
@@ -363 +266 @@
 /////////////////////////////////////////////////////////////////////////////
 
-proc normalFan (intmat vertices,intmat affinehull,list graph,int er,list #)
-"USAGE:  normalFan (vert,aff,graph,rays,[,#]);   vert,aff intmat,  graph list, rays int, # string
+proc normalFanL (def vertices, def affinehull,list graph,int er,list #)
+"USAGE:  normalFanL (vert,aff,graph,rays,[,#]);   vert,aff intmat,  graph list, rays int, # string
 ASSUME:  - vert is an integer matrix whose rows are the coordinate of
            the vertices of a convex lattice polytope;
@@ -396 +299 @@
 @*       - in the optional argument # it is possible to hand over other names
            for the variables to be used -- be careful, the format must be correct
-           which is not tested, e.g. if you want the variable names to be
-           u00,u10,u01,u11 then you must hand over the string 'u11,u10,u01,u11'
-EXAMPLE: example normalFan;   shows an example"
-{
+           and that is not tested, e.g. if you want the variable names to be
+           u00,u10,u01,u11 then you must hand over the string u11,u10,u01,u11
+EXAMPLE: example normalFanL;   shows an example"
+{
+  if (typeof(affinehull) != "intmat" && typeof (affinehull) != "bigintmat")
+  {
+    ERROR("normalFanL: input affinehull has to be either intmat or bigintmat");
+    list L;
+    return (L);
+  }
   list ineq; // stores the inequalities of the cones
   int i,j,k;
@@ -431 +340 @@
     list pp;  // contain strings representing the inequalities
               // describing the normal cone
-    intmat ie[size(graph[i])][ncols(vertices)]; // contains the inequalities
-                                                // as rows
+    if (typeof (vertices) == "intmat")
+    {
+      intmat ie[size(graph[i])][ncols(vertices)]; // contains the inequalities
+    }                                             // as rows
+    if (typeof (vertices) == "bigintmat")
+    {
+      bigintmat ie[size(graph[i])][ncols(vertices)]; // contains the inequalities
+    }                                                // as rows
     // consider all the vertices to which the ith vertex in the
     // polytope is connected by an edge
@@ -469 +384 @@
   }
   // remove the first column of affine hull to compute the linearity space
-  intmat linearity=intmatcoldelete(affinehull,1);
+  bigintmat linearity[1][ncols(vertices)];
+  if (nrows(affinehull)>0)
+  {
+    linearity=intmatcoldelete(affinehull,1);
+  }
   //////////////////////////////////////////////////////////////////
   // Compute next the extreme rays of the cones
@@ -476 +395 @@
   {
     list extremerays; // keeps the result
-    string polymake; // keeps polymake output
-    // the header for ineq.polymake
-    string head="_application polytope
-_version 2.2
-_type RationalPolytope
-
-INEQUALITIES
-";
-    // the tail for both polymake files
-    string tail="
-EQUATIONS
-";
-    tail=tail+intmatToPolymake(linearity,"rays");
-    string ungleichungen; // keeps the inequalities for the polymake code
+    cone kegel;
+    bigintmat linearspan=intmatAddFirstColumn(linearity,"rays");
     intmat M; // the matrix keeping the inequalities
-    // create the file ineq.output
-    write(":w /tmp/ineq.output","");
-    int dimension; // keeps the dimension of the intersection the
-                   // bad cones with the u11tobeseencone
     for (i=1;i<=size(ineq);i++)
     {
-      i,". Cone of ",nrows(vertices); // indicate how many
-                                      // vertices have been dealt with
-      ungleichungen=intmatToPolymake(ineq[i][1],"rays");
-      // write the inequalities to ineq.polymake and call polymake
-      write(":w /tmp/ineq.polymake",head+ungleichungen+tail);
-      ungleichungen=""; // clear ungleichungen
-      system("sh","cd /tmp; /bin/rm ineq.output; polymake ineq.polymake VERTICES > ineq.output");
-      // read the result of polymake
-      polymake=read("/tmp/ineq.output");
-      intmat VERT=polymakeToIntmat(polymake,"affine");
-      extremerays[i]=VERT;
-      kill VERT;
+      kegel=coneViaInequalities(intmatAddFirstColumn(ineq[i][1],"rays"),linearspan);
+      extremerays[i]=intmatcoldelete(rays(kegel),1);
     }
     for (i=1;i<=size(ineq);i++)
@@ -514 +407 @@
       ineq[i]=ineq[i]+list(extremerays[i]);
     }
-  }
-  // delete the tmp-files, if polymakekeeptmpfiles is not set
-  if (defined(polymakekeeptmpfiles)==0)
-  {
-    system("sh","/bin/rm /tmp/ineq.polymake");
-    system("sh","/bin/rm /tmp/ineq.output");
   }
   // get the linearity space
@@ -534 +421 @@
    list np=newtonPolytopeP(f);
    // the Groebner fan of f, i.e. the normal fan of the Newton polytope
-   list gf=normalFan(np[1],np[4],np[3],1,"x,y,z");
+   list gf=normalFanL(np[1],np[4],np[3],1,"x,y,z");
    // the number of cones in the Groebner fan of f is:
    size(gf[1]);
@@ -549 +436 @@
 /////////////////////////////////////////////////////////////////////////////
 
-proc groebnerFan (poly f,list #)
-"USAGE:  groebnerFan(f[,#]);  f poly, # string
+proc groebnerFan (poly f)
+"USAGE:  groebnerFan(f);  f poly
 RETURN:  list, the ith entry of L[1] contains information about the ith cone
                in the Groebner fan dual to the ith vertex in the Newton
@@ -564 +451 @@
                       in each cone
 @*             L[3] = the Newton polytope of f in the format of the procedure
-                      newtonPolytope
-@*             L[4] = integer matrix where each row represents the exponet
+                      newtonPolytopeP
+@*             L[4] = integer matrix where each row represents the exponent
                       vector of one monomial occuring in the input polynomial
 NOTE: - if you have already computed the Newton polytope of f then you might want
-        to use the procedure normalFan instead in order to avoid doing costly
+        to use the procedure normalFanL instead in order to avoid doing costly
         computation twice
 @*    - the procedure calls for its computation polymake by Ewgenij Gawrilow,
         TU Berlin and Michael Joswig, so it only works if polymake is installed;
         see http://www.math.tu-berlin.de/polymake/
-@*    - the procedure creates the file  /tmp/newtonPolytope.polymake which
-        contains the Newton polytope of f in polymake format and which can
-        be used for further computations with polymake
-@*    - it is possible to give as an optional second argument as string which
-        then will be used instead of 'newtonPolytope' in the name of the
-        polymake output file
 EXAMPLE: example groebnerFan;   shows an example"
 {
@@ -591 +472 @@
     f=f-lead(f);
   }
-  if (size(#)==0)
-  {
-    #[1]="newtonPolytope";
-  }
   // call polymakePolytope with exponents
-  list newtonp=polymakePolytope(exponents,"newtonPolytope");
+  list newtonp=polymakePolytope(exponents);
   // get the variables as string
   string variablen;
@@ -604 +481 @@
   }
   variablen=variablen[1,size(variablen)-1];
-  // call normalFan in order to compute the Groebner fan
-  list gf=normalFan(newtonp[1],newtonp[4],newtonp[3],1,variablen);
+  // call normalFanL in order to compute the Groebner fan
+  list gf=normalFanL(newtonp[1],newtonp[4],newtonp[3],1,variablen);
   // append newtonp to gf
   gf[3]=newtonp;
@@ -642 +519 @@
 
 
-/////////////////////////////////////////////////////////////////////////////
-
-proc intmatToPolymake (intmat M,string art)
-"USAGE:  intmatToPolymake(M,art);  M intmat, art string
-ASSUME:  - M is an integer matrix which should be transformed into polymake
-           format;
-@*       - art is one of the following strings:
-@*           + 'rays'   : indicating that a first column of 0's should be added
-@*           + 'points' : indicating that a first column of 1's should be added
-RETURN:  string, the matrix is transformed in a string and a first column has
-                 been added
-EXAMPLE: example intmatToPolymake;   shows an example"
-{
-  if (art=="rays")
-  {
-    string anf="0 ";
-  }
-  else
-  {
-    string anf="1 ";
-  }
-  string sp;
-  int i,j;
-  // create the lattice point list for polymake
-  for (i=1;i<=nrows(M);i++)
-  {
-    sp=sp+anf;
-    for (j=1;j<=ncols(M);j++)
-    {
-      sp=sp+string(M[i,j])+" ";
-      if (j==ncols(M))
-      {
-        sp=sp+"
-";
-      }
-    }
-  }
-  return(sp);
-}
-example
-{
-   "EXAMPLE:";
-   echo=2;
-   intmat M[3][4]=1,2,3,4,5,6,7,8,9,10,11,12;
-   intmatToPolymake(M,"rays");
-   intmatToPolymake(M,"points");
-}
-
-/////////////////////////////////////////////////////////////////////////////
-
-proc polymakeToIntmat (string pm,string art)
-"USAGE:  polymakeToIntmat(pm,art);  pm, art string
-ASSUME:  pm is the result of calling polymake with one 'argument' like
-         VERTICES, AFFINE_HULL, etc., so that the first row of the string is
-         the name of the corresponding 'argument' and the further rows contain
-         the result which consists of vectors either over the integers
-         or over the rationals
-RETURN:  intmat, the rows of the matrix are basically the vectors in pm, starting
-                 from the second row, where each row has been multiplied with the
-                 lowest common multiple of the denominators of its entries as if
-                 it is an integer matrix; moreover, if art=='affine', then
-                 the first column is omitted since we only want affine
-                 coordinates
-EXAMPLE: example polymakeToIntmat;   shows an example"
-{
-  // we need a line break
-  string zeilenumbruch="
-";
-  // remove the 'argment' name, i.e. the first row of pm
-  while (pm[1]!=zeilenumbruch)
-  {
-    pm=stringdelete(pm,1);
-  }
-  pm=stringdelete(pm,1);
-  // find out how many entries each vector has, namely one more
-  // than 'spaces' in a row
-  int i=1;
-  int s=1;
-  int z=1;
-  while (pm[i]!=zeilenumbruch)
-  {
-    if (pm[i]==" ")
-    {
-      s++;
-    }
-    i++;
-  }
-  // if we want to have affine coordinates
-  if (art=="affine")
-  {
-    s--; // then there is one column less
-    // and the entry of the first column (in the first row) has to be removed
-    while (pm[1]!=" ")
-    {
-      pm=stringdelete(pm,1);
-    }
-    pm=stringdelete(pm,1);
-  }
-  // we add two line breaks at the end in order to have this as
-  // a stopping criterion
-  pm=pm+zeilenumbruch+zeilenumbruch;
-  // we now have to work through each row
-  for (i=1;i<=size(pm);i++)
-  {
-    // if there are two consecutive line breaks we are done
-    if ((pm[i]==zeilenumbruch) and (pm[i+1]==zeilenumbruch))
-    {
-      i=size(pm)+1;
-    }
-    else
-    {
-      // a line break has to be replaced by a comma
-      if (pm[i]==zeilenumbruch)
-      {
-        z++;
-        pm[i]=",";
-        // if we want to have affine coordinates,
-        // then we have to delete the first entry in each row
-        if (art=="affine")
-        {
-         while (pm[i+1]!=" ")
-         {
-           pm=stringdelete(pm,i+1);
-         }
-         pm=stringdelete(pm,i+1);
-        }
-      }
-      // a space has to be replaced by a comma
-      if (pm[i]==" ")
-      {
-        pm[i]=",";
-      }
-    }
-  }
-  // if we have introduced superflous commata at the end, they should be removed
-  while (pm[size(pm)]==",")
-  {
-    pm=stringdelete(pm,size(pm));
-  }
-  // since the matrix could be over the rationals,
-  // we need a ring with rational coefficients
-  ring zwischering=0,x,lp;
-  // create the matrix with the elements of pm as entries
-  execute("matrix mm["+string(z)+"]["+string(s)+"]="+pm+";");
-  // transform this into an integer matrix
-  matrix M[1][ncols(mm)]; // takes a row of mm
-  int cm;  // takes a lowest common multiple
-  // multiply each row by an integer such that its entries are integers
-  for (int j=1;j<=nrows(mm);j++)
-  {
-    M=mm[j,1..ncols(mm)];
-    cm=commondenominator(M);
-    for (i=1;i<=ncols(mm);i++)
-    {
-      mm[j,i]=cm*mm[j,i];
-    }
-  }
-  // transform the matrix mm into an integer matrix
-  execute("intmat im["+string(z)+"]["+string(s)+"]="+string(mm)+";");
-  return(im);
-}
-example
-{
-   "EXAMPLE:";
-   echo=2;
-   // this is the usual output of some polymake computation
-   string pm="VERTICES
-0 1 3 5/3 1/3 -1 -23/3 -1/3 5/3 1/3 1
-0 1 3 -23/3 5/3 1 5/3 1/3 1/3 -1/3 -1
-0 1 1 1/3 -1/3 -1 5/3 1/3 -23/3 5/3 3
-0 1 1 5/3 -23/3 3 1/3 5/3 -1/3 1/3 -1
-0 1 -1 1/3 5/3 3 -1/3 -23/3 1/3 5/3 1
-0 1 -1 -1/3 1/3 1 1/3 5/3 5/3 -23/3 3
-0 1 -1 1 3 -5 -1 3 -1 1 -1
-0 1 -1 -1 -1 -1 1 1 3 3 -5
-0 1 -5 3 1 -1 3 -1 1 -1 -1
-
-";
-   intmat PM=polymakeToIntmat(pm,"affine");
-   // note that the first column has been removed, since we asked for
-   // affine coordinates, and the denominators have been cleared
-   print(PM);
-}
-
 ///////////////////////////////////////////////////////////////////////////////
 /// PROCEDURES USING TOPCOM
 ///////////////////////////////////////////////////////////////////////////////
 
-proc triangulations (list polygon)
-"USAGE:  triangulations(polygon); list polygon
+proc triangulations (list polygon,list #)
+"USAGE:  triangulations(polygon[,#]); list polygon, list #
 ASSUME:  polygon is a list of integer vectors of the same size representing
          the affine coordinates of the lattice points
@@ -846 +539 @@
        this  procedure; see
 @*     http://www.uni-bayreuth.de/departments/wirtschaftsmathematik/rambau/TOPCOM
+@*   - if you only want to have the regular triangulations the procedure should
+       be called with the string 'regular' as optional argument
 @*   - the procedure creates the files /tmp/triangulationsinput and
        /tmp/triangulationsoutput;
@@ -851 +546 @@
        output containing the triangulations of corresponding to points in the
        format of points2triangs; if you wish to use this for further
-       computations with topcom, you have to use the procedure
-       polymakeKeepTmpFiles in before
+       computations with topcom, you have to call the procedure with the
+       string 'keepfiles' as optional argument
 @*   - note that an integer i in an integer vector representing a triangle
        refers to the ith lattice point, i.e. polygon[i]; this convention is
@@ -860 +555 @@
 {
   int i,j;
+  // check for optional arguments
+  int regular,keepfiles;
+  if (size(#)>0)
+  {
+    for (i=1;i<=size(#);i++)
+    {
+      if (typeof(#[i])=="string")
+      {
+        if (#[i]=="keepfiles")
+        {
+          keepfiles=1;
+        }
+        if (#[i]=="regular")
+        {
+          regular=1;
+        }
+      }
+    }
+  }
   // prepare the input for points2triangs by writing the input polygon in the
   // necessary format
@@ -875 +589 @@
   write(":w /tmp/triangulationsinput",spi);
   // call points2triangs
-  system("sh","cd /tmp; points2triangs < triangulationsinput > triangulationsoutput");
+  if (regular==1) // compute only regular triangulations
+  {
+    system("sh","cd /tmp; points2triangs --regular < triangulationsinput > triangulationsoutput");
+  }
+  else // compute all triangulations
+  {
+    system("sh","cd /tmp; points2triangs < triangulationsinput > triangulationsoutput");
+  }
   string p2t=read("/tmp/triangulationsoutput"); // takes result of points2triangs
-  // delete the tmp-files, if polymakekeeptmpfiles is not set
-  if (defined(polymakekeeptmpfiles)==0)
+  // delete the tmp-files, if no second argument is given
+  if (keepfiles==0)
   {
     system("sh","cd /tmp; rm -f triangulationsinput; rm -f triangulationsoutput");
@@ -953 +674 @@
             else
             {
-              np2t=np2t+p2t[i];
+              if (p2t[i]=="[")
+              {
+                // in Topcom version 17.4 (and maybe also in earlier versions) the list
+                // of triangulations is indexed starting with index 0, in Singular
+                // we have to start with index 1
+                np2t=np2t+p2t[i]+"1+";
+              }
+              else
+              {
+                np2t=np2t+p2t[i];
+              }
             }
           }
@@ -962 +693 @@
   list T;
   execute(np2t);
+  // depending on the version of Topcom, the list T has or has not an entry T[1]
+  // if it has none, the entry should be removed
+  while (typeof(T[1])=="none")
+  {
+    T=delete(T,1);
+  }
   // raise each index by one
   for (i=1;i<=size(T);i++)
@@ -1000 +737 @@
 RETURN:  list, say L, such that:
 @*             L[1] = intmat, each row gives the affine coordinates of a lattice
-                      point in the secondary polytope given by the marked polytope
-                      corresponding to polygon
+                      point in the secondary polytope given by the marked
+                      polytope corresponding to polygon
 @*             L[2] = the list of corresponding triangulations
 NOTE: if the triangluations are not handed over as optional argument the
@@ -1114 +851 @@
        see http://www.math.tu-berlin.de/polymake/
 @*   - in the optional argument # it is possible to hand over other names for
-       the variables to be used -- be careful, the format must be correct
-       which is not tested, e.g. if you want the variable names to be
+       the variables to be used -- be careful, the format must be correct and
+       that is not tested, e.g. if you want the variable names to be
        u00,u10,u01,u11 then you must hand over the string 'u11,u10,u01,u11'
 @*   - if the triangluations are not handed over as optional argument the
@@ -1135 +872 @@
   list sp=secondaryPolytope(polygon,triang);
   list spp=polymakePolytope(sp[1]);
-  list sf=normalFan(spp[1],spp[4],spp[3],1);
+  list sf=normalFanL(spp[1],spp[4],spp[3],1);
   return(list(sf[1],sf[2],spp,triang));
 }
@@ -1378 +1115 @@
 @*       triang is a list of integer vectors all of size three describing a
          triangulation of the polygon described by polygon; if an entry of
-         triang is the vector (i,j,k) then the triangle is built from the vertices
+         triang is the vector (i,j,k) then the triangle is built by the vertices
          with indices i, j and k
 RETURN:  intvec, the integer vector eta describing that vertex of the Newton
@@ -1948 +1685 @@
   // points and
   // the number b of boundary points are connected by the formula: A=b+2g-2
-  return(list(area,bdpts,(area-bdpts+2)/2));
+  return(list(area,bdpts,(area-bdpts+2) div 2));
 }
 example
@@ -1973 +1710 @@
 "USAGE:  ellipticNF(polygon);   polygon list
 ASSUME:  polygon is a list of integer vectors in the plane such that their
-         convex hull C has precisely one interior lattice point, i.e. C is the
+         convex hull C has precisely one interior lattice point; i.e. C is the
          Newton polygon of an elliptic curve
 PURPOSE: compute the normal form of the polygon with respect to the unimodular
@@ -1991 +1728 @@
   int i;            // index
   intvec edge;      // stores the vector of an edge
-  intvec boundary;  // stores lattice lengths of the edges of the Newton cylce
+  intvec boundary;  // stores lattice lengths of the edges of the Newton cycle
   // find the vertices of the Newton cycle and order it clockwise
   list pg=findOrientedBoundary(polygon)[2];
@@ -2302 +2039 @@
 
 /////////////////////////////////////////////////////////////////////////////////
-/// AUXILARY PROCEDURES
-/////////////////////////////////////////////////////////////////////////////////
-
-proc polymakeKeepTmpFiles (int i)
-"USAGE:  polymakeKeepTmpFiles(int i);   i int
-PURPOSE: some procedures create files in the directory /tmp which are used for
-         computations with polymake respectively topcom; these will be removed
-         when the corresponding procedure is left; however, it might be
-         desireable to keep them for further computations with either polymake or
-         topcom; this can be achieved by this procedure; call the procedure as:
-@*       - polymakeKeepTmpFiles(1); - then the files will be kept
-@*       - polymakeKeepTmpFiles(0); - then files will be removed in the future
-RETURN:  none"
-{
-  if ((i==1) and (defined(polymakekeeptmpfiles)==0))
-  {
-    int polymakekeeptmpfiles;
-    export(polymakekeeptmpfiles);
-  }
-  if (i!=1)
-  {
-    if (defined(polymakekeeptmpfiles))
-    {
-      kill polymakekeeptmpfiles;
-    }
-  }
-}
-
-
-/////////////////////////////////////////////////////////////////////////////////
 /////////////////////////////////////////////////////////////////////////////////
 /// AUXILARY PROCEDURES, WHICH ARE DECLARED STATIC
@@ -2364 +2071 @@
 }
 
-static proc intmatcoldelete (intmat w,int i)
+static proc intmatcoldelete (def w,int i)
 "USAGE:      intmatcoldelete(w,i); w intmat, i int
 RETURN:      intmat, the integer matrix w with the ith comlumn deleted
-NOTE:        the procedure is called by intmatsort and normalFan"
-{
-  if ((i<1) or (i>ncols(w)) or (ncols(w)==1))
-  {
-    return(w);
-  }
-  if (i==1)
-  {
-    intmat M[nrows(w)][ncols(w)-1]=w[1..nrows(w),2..ncols(w)];
-    return(M);
-  }
-  if (i==ncols(w))
-  {
-    intmat M[nrows(w)][ncols(w)-1]=w[1..nrows(w),1..ncols(w)-1];
-    return(M);
-  }
-  else
-  {
-    intmat M[nrows(w)][i-1]=w[1..nrows(w),1..i-1];
-    intmat N[nrows(w)][ncols(w)-i]=w[1..nrows(w),i+1..ncols(w)];
-    return(intmatconcat(M,N));
+NOTE:        the procedure is called by intmatsort and normalFanL"
+{
+  if (typeof(w)=="intmat")
+  {
+    if ((i<1) or (i>ncols(w)) or (ncols(w)==1))
+    {
+      return(w);
+    }
+    if (i==1)
+    {
+      intmat M[nrows(w)][ncols(w)-1]=w[1..nrows(w),2..ncols(w)];
+      return(M);
+    }
+    if (i==ncols(w))
+    {
+      intmat M[nrows(w)][ncols(w)-1]=w[1..nrows(w),1..ncols(w)-1];
+      return(M);
+    }
+    else
+    {
+      intmat M[nrows(w)][i-1]=w[1..nrows(w),1..i-1];
+      intmat N[nrows(w)][ncols(w)-i]=w[1..nrows(w),i+1..ncols(w)];
+      return(intmatconcat(M,N));
+    }
+  }
+  if (typeof(w)=="bigintmat")
+  {
+    if ((i<1) or (i>ncols(w)) or (ncols(w)==1))
+    {
+      return(w);
+    }
+    if (i==1)
+    {
+      bigintmat M[nrows(w)][ncols(w)-1]=w[1..nrows(w),2..ncols(w)];
+      return(M);
+    }
+    if (i==ncols(w))
+    {
+      bigintmat M[nrows(w)][ncols(w)-1]=w[1..nrows(w),1..ncols(w)-1];
+      return(M);
+    }
+    else
+    {
+      bigintmat MN[nrows(w)][ncols(w)-1];
+      MN[1..nrows(w),1..i-1]=w[1..nrows(w),1..i-1];
+      MN[1..nrows(w),i..ncols(w)-1]=w[1..nrows(w),i+1..ncols(w)];
+      return(MN);
+    }
+  } else
+  {
+    ERROR("intmatcoldelete: input matrix has to be of type intmat or bigintmat");
+    intmat M; return(M);
   }
 }
@@ -2683 +2421 @@
   return(list(coord,coords,latex));
 }
+
+static proc intmatAddFirstColumn (def M,string art)
+"USAGE:  intmatAddFirstColumn(M,art);  M intmat, art string
+ASSUME:  - M is an integer matrix where a first column of 0's or 1's should be added
+@*       - art is one of the following strings:
+@*         + 'rays'   : indicating that a first column of 0's should be added
+@*         + 'points' : indicating that a first column of 1's should be added
+RETURN:  intmat, a first column has been added to the matrix"
+{
+  if (typeof (M) == "intmat")
+  {
+    intmat N[nrows(M)][ncols(M)+1];
+    int i,j;
+    for (i=1;i<=nrows(M);i++)
+    {
+      if (art=="rays")
+      {
+        N[i,1]=0;
+      }
+      else
+      {
+        N[i,1]=1;
+      }
+      for (j=1;j<=ncols(M);j++)
+      {
+        N[i,j+1]=M[i,j];
+      }
+    }
+    return(N);
+  }
+  if (typeof (M) == "bigintmat")
+  {
+    bigintmat N[nrows(M)][ncols(M)+1];
+    int i,j;
+    for (i=1;i<=nrows(M);i++)
+    {
+      if (art=="rays")
+      {
+        N[i,1]=0;
+      }
+      else
+      {
+        N[i,1]=1;
+      }
+      for (j=1;j<=ncols(M);j++)
+      {
+        N[i,j+1]=M[i,j];
+      }
+    }
+    return(N);
+  }
+  else
+  {
+    ERROR ("intmatAddFirstColumn: input matrix has to be either intmat or bigintmat");
+    intmat N;
+    return (N);
+  }
+}
+
+
+

Singular/LIB/tropical.lib

@@ -1 @@
-///////////////////////////////////////////////////////////
-version="version tropical.lib 4.0.0.0 Jun_2013 "; // $Id$
+//
+version="$Id$";
 category="Tropical Geometry";
 info="
@@ -650 +650 @@
           // pass first to a ring where a and @a
           // are variables in order to use maps
-          string @mp= string(minpoly);
+          poly mp=minpoly;
           ring INTERRING=char(LIFTRING),(t,@a,a),dp;
-          execute("poly mp=" + @mp + ";");
+          poly mp=imap(LIFTRING,mp);
           ideal LIFT=imap(LIFTRING,LIFT);
           kill LIFTRING;
@@ -1012 +1012 @@
   {
     def GLOBALRING=basering;
-    string @mp= string(minpoly);
+    number mp=minpoly;
     execute("ring LOCALRING=("+charstr(basering)+"),("+varstr(basering)+"),ds;");
-    execute("minpoly= " + @mp + ";");
     poly f=imap(GLOBALRING,f);
+    minpoly=imap(GLOBALRING,mp);
   }
   // check if a substitution is necessary
@@ -1049 +1049 @@
     if (minpoly!=0)
     {
-      string @mp= string(minpoly);
+      poly mp=minpoly;
       def OLDRING=basering;
       execute("ring NEWRING=0,("+varstr(basering)+","+parstr(basering)+"),ds;");
-      execute("ideal I = " + @mp + ";");
-      I = I,imap(OLDRING,f);
+      ideal I=imap(OLDRING,mp),imap(OLDRING,f);
     }
     else
@@ -1065 +1064 @@
       w=NewtP[jj]-NewtP[jj+1];
       ggteiler=gcd(w[1],w[2]);
-      zw=w[1]/ggteiler;
-      w[1]=w[2]/ggteiler;
+      zw=w[1] div ggteiler;
+      w[1]=w[2] div ggteiler;
       w[2]=zw;
       // if we have introduced a third variable for the parameter, then w needs a third component
@@ -1134 +1133 @@
     else
     {
-      string @mp= string(minpoly);
+      poly mp=minpoly;
       ring degreering=0,a,dp;
-      execute("poly mp=" + @mp + ";");
+      poly mp=imap(countring,mp);
       numberofbranchesfound=numberofbranchesfound+deg(mp);
       setring countring;
@@ -1158 +1157 @@
    ring r=0,(x,y),ds;
    poly f=x2-y4+x5y7;
-   puiseuxExpansion(puiseuxExpansion(f,3));
+   puiseuxExpansion(f,3,"subst");
+   displayPuiseuxExpansion(puiseuxExpansion(f,3));
 }
 
@@ -1540 +1540 @@
       ggt=gcd(normalvector[1],normalvector[2]);   // the gcd of the entries
       zw=normalvector[2];    // create the outward pointing normal vector
-      normalvector[2]=-normalvector[1]/ggt;
-      normalvector[1]=zw/ggt;
+      normalvector[2]=-normalvector[1] div ggt;
+      normalvector[1]=zw div ggt;
       if (size(#)==0) // we are computing w.r.t. minimum
       {
@@ -2718 +2718 @@
         if(k<>j)  // except the unit vector of the non-zero component
         {
-          intvec u; u[size(w)]=0; u[k]=1;
-          O[r,1..size(w)]=u; r=r+1;
+          intvec u;
+          u[size(w)]=0; 
+          u[k]=1;
+          O[r,1..size(w)]=u; 
+          r=r+1;
+          kill u;
         }
       }
@@ -4708 +4712 @@
         wneu=NewtP[1]-NewtP[2];
         int ggteiler=gcd(wneu[1],wneu[2]);
-        wneu[1]=-wneu[1]/ggteiler;
-        wneu[2]=wneu[2]/ggteiler;
+        wneu[1]=-wneu[1] div ggteiler;
+        wneu[2]=wneu[2] div ggteiler;
         if (wneu[1]>0)
         {
@@ -4807 +4811 @@
   for (jj=1;jj<=anzahlvariablen+numberdeletedvariables-1;jj++)
   {
-    PARA[jj]=(PARA[jj]+a[jj+1])*t^(tw[jj+1]*tweight/ww[1]);
+    PARA[jj]=(PARA[jj]+a[jj+1])*t^(tw[jj+1]*tweight div ww[1]);
   }
   // if we have reached the stop-level, i.e. either
@@ -5353 +5357 @@
     if (koeffizienten[j-ord(p)+1]!=0)
     {
-      if ((j-(N*wj)/w1)==0)
+      if ((j-(N*wj) div w1)==0)
       {
         dp=dp+displaycoef(koeffizienten[j-ord(p)+1]);
       }
-      if (((j-(N*wj)/w1)==1) and (N!=1))
+      if (((j-(N*wj) div w1)==1) and (N!=1))
       {
         dp=dp+displaycoef(koeffizienten[j-ord(p)+1])+"*t^(1/"+string(N)+")";
       }
-      if (((j-(N*wj)/w1)==1) and (N==1))
+      if (((j-(N*wj) div w1)==1) and (N==1))
       {
         dp=dp+displaycoef(koeffizienten[j-ord(p)+1])+"*t";
       }
-      if (((j-(N*wj)/w1)==-1) and (N==1))
+      if (((j-(N*wj) div w1)==-1) and (N==1))
       {
         dp=dp+displaycoef(koeffizienten[j-ord(p)+1])+"*1/t";
       }
-      if (((j-(N*wj)/w1)==-1) and (N!=1))
+      if (((j-(N*wj) div w1)==-1) and (N!=1))
       {
         dp=dp+displaycoef(koeffizienten[j-ord(p)+1])+"*1/t^(1/"+string(N)+")";
       }
-      if (((j-(N*wj)/w1)>1) and (N==1))
-      {
-        dp=dp+displaycoef(koeffizienten[j-ord(p)+1])+"*t^"+string(j-(N*wj)/w1);
-      }
-      if (((j-(N*wj)/w1)>1) and (N!=1))
-      {
-        dp=dp+displaycoef(koeffizienten[j-ord(p)+1])+"*t^("+string(j-(N*wj)/w1)+"/"+string(N)+")";
-      }
-      if (((j-(N*wj)/w1)<-1) and (N==1))
+      if (((j-(N*wj) div w1)>1) and (N==1))
+      {
+        dp=dp+displaycoef(koeffizienten[j-ord(p)+1])+"*t^"+string(j-(N*wj) div w1);
+      }
+      if (((j-(N*wj) div w1)>1) and (N!=1))
+      {
+        dp=dp+displaycoef(koeffizienten[j-ord(p)+1])+"*t^("+string(j-(N*wj) div w1)+"/"+string(N)+")";
+      }
+      if (((j-(N*wj) div w1)<-1) and (N==1))
       {
         dp=dp+displaycoef(koeffizienten[j-ord(p)+1])+"*1/t^"+string(wj-j);
       }
-      if (((j-(N*wj)/w1)<-1) and (N!=1))
-      {
-        dp=dp+displaycoef(koeffizienten[j-ord(p)+1])+"*1/t^("+string((N*wj)/w1-j)+"/"+string(N)+")";
+      if (((j-(N*wj) div w1)<-1) and (N!=1))
+      {
+        dp=dp+displaycoef(koeffizienten[j-ord(p)+1])+"*1/t^("+string((N*wj) div w1-j)+"/"+string(N)+")";
       }
       if (j<deg(p))
@@ -5495 +5499 @@
     {
       setring LIFTRing;
-      string @mp= string(minpoly);
+      poly mp=minpoly;
       execute("ring TESTRing=("+charstr(LIFTRing)+"),("+varstr(BASERING)+"),dp;");
-      execute("minpoly= " + @mp + ";");
+      minpoly=number(imap(LIFTRing,mp));
       ideal i=imap(BASERING,i);
     }
@@ -5769 +5773 @@
               wneu=NewtP[jjj]-NewtP[jjj+1];
               int ggteiler=gcd(wneu[1],wneu[2]);
-              wneu[1]=-wneu[1]/ggteiler;
-              wneu[2]=wneu[2]/ggteiler;
+              wneu[1]=-wneu[1] div ggteiler;
+              wneu[2]=wneu[2] div ggteiler;
               if (wneu[1]>0)
               {
@@ -5869 +5873 @@
         {
           execute("ring PARARing=("+string(char(basering))+",@a),t,ls;");
-          minpoly=number(imap(PREGFANRING,m)); // ?
+          minpoly=number(imap(PREGFANRING,m));
         }
         else
@@ -5908 +5912 @@
         for (jjj=1;jjj<=anzahlvariablen+numberdeletedvariables-1;jjj++)
         {
-          PARA[jjj]=(PARA[jjj]+zeros[size(zeros)][jjj+1])*t^(ww[jjj+1]*tweight/ww[1]);
+          PARA[jjj]=(PARA[jjj]+zeros[size(zeros)][jjj+1])*t^(ww[jjj+1]*tweight div ww[1]);
         }
         // delete the last entry in zero, since that one has
@@ -6033 +6037 @@
     {
       I=subst(i,var(lastvar),0);
-      while (subst(I[1],t,0)==0)
+      while ((I[1]!=0) and (subst(I[1],t,0)==0))
       {
         I[1]=I[1]/t;
@@ -7814 +7818 @@
     poly denom=delta*hn^5;
     poly ggt=gcd(num,denom);
-    num=num/ggt;
-    denom=denom/ggt;
+    num=num div ggt;
+    denom=denom div ggt;
     setring BASERING;
     poly num=imap(TRING,num);

Singular/ipid.cc

@@ -433 +433 @@
   else if ((IDTYP(h)==RING_CMD)||(IDTYP(h)==QRING_CMD))
     rKill(h);
-  else
+  else if (IDDATA(h)!=NULL)
     s_internalDelete(IDTYP(h),IDDATA(h),r);
   //  general  -------------------------------------------------------------

Singular/singular-libs

@@ -23 +23 @@
         paraplanecurves.lib phindex.lib \
         pointid.lib poly.lib \
-        oldpolymake.lib presolve.lib primdec.lib primdecint.lib \
+        polymake.lib presolve.lib primdec.lib primdecint.lib \
         primitiv.lib qhmoduli.lib random.lib realclassify.lib \
         realrad.lib reesclos.lib resbinomial.lib \
@@ -57 +57 @@
         ncfactor.lib nctools.lib perron.lib qmatrix.lib \
         ncall.lib
-        
 
+

Singular/subexpr.cc

@@ -455 +455 @@
 void s_internalDelete(const int t,  void *d, const ring r)
 {
+  assume(d!=NULL);
   switch (t)
   {

Tst/Short/bug_newstruct.res.gz.uu

@@ -1 +1 @@
 begin 640 bug_newstruct.res.gz
-M'XL(")/1P5$``V)U9U]N97=S=')U8W0N<F5S`)6236O"0!"&[_D5+\%#`A+=
-MJJUMZI86+P$1P=*K^=K(0K*1_6CIO^_&F(W7GG9FWOEXAMGCYS;9`R`4N^0#
-MOE8ZJGGNQ][QICQ0V.")"ZZ#,/:Z%Y0B-^>38#]*2U/HR%J1TIEV50L*9R\C
-MS&9PR5#:5)535]$H!?ZEY-]<M=*?^C57-M<T329*-471"@:=\=H/1[C'NS%/
-M$:XENU%>T[ZLB#WKO2'MO!1<P8B255RPLA>8E*U$6Q1&2E:""U@W9U4K&?IF
-MM4W&^J5O81NF;L@SQ4"-@YM-YA2':,#?C%"$=$*WR&;`*C(!T6ID2O&SP"39
-M?[WODNTDF(?0+1K6Y,S25="_%W9=,EBN%N&_T`FQ[&ZNHR?VO!;Z&G[M.E//
-=,=_\(?/NI,2>M/L4W<F-"D@83[P_D)E)>TH"````
+M'XL("+JRJ5(``V)U9U]N97=S=')U8W0N<F5S`)62RVK#,!!%]_Z*B\G"AN!$
+M;=JF=:/2DHTAA$!*MXD?<A#84I#DEOY]I3B6L^U*,W/G<8;1_G.=;0$0BDWV
+M@=!HDS2\"--@?U7N*&SPP`4W49P&[@6E*+K30;`?;517FL1:B3:Y\57W%-Y>
+M))C-X).A35?77GU(1BD*SQ7_YEJJ<!HV7-O<KFUS4>DI2BD83,Z;,![A'F_&
+M/"6XE&Q&>4G[LC(-K/>&H_..X!J=J%C-!:MZ@2DE%619=DJQ"ES`N@6KI6+H
+MFS4V&<N7OH5M>/1#GBD&:NS\;#*GV"4#_FJ$(L0);I'5@%7F`D(:Y%KSD\`D
+MVWZ];[+U))K',!(M:PMFZ6J8WS.[+!DM'A;QO]`)L>Q^KJ<G]KP6^A)^=9UI
+>X)FO_I!Y<U)B3^H^A3MYIR,2IY/@#R.]3(I*`@``
 `
 end

Tst/Short/polymake.tst

@@ -3 +3 @@
 LIB "tst.lib";
 tst_init();
-LIB "oldpolymake.lib"; // TODO: update test result!
+LIB "polymake.lib";
 ///////////////////////////////////////////////////////////////////////////
 // A) Test for Procedures using Polymake
 ///////////////////////////////////////////////////////////////////////////
 example polymakePolytope;
-example newtonPolytope;
+example newtonPolytopeP;
 example newtonPolytopeLP;
-example normalFan;
+example normalFanL;
 example groebnerFan;
-example intmatToPolymake;
-example polymakeToIntmat;
 ///////////////////////////////////////////////////////////////////////////
 // B) Test for Procedures using Topcom

debian/changelog

@@ -1 @@
-singular (3.1.3.sw-1) unstable; urgency=low
+singular (4.0.0-1) unstable; urgency=low
 
   * Initial release.

doc/COPYING.texi

@@ -131 +131 @@
 @copyright{} Winfried Bruns and Bogdan Ichim
 @* @uref{http://www.mathematik.uni-osnabrueck.de/normaliz/}
-@item polymake (used by oldpolymake.lib, @pxref{oldpolymake_lib})
+@item polymake (used by polymake.lib, @pxref{polymake_lib})
 @copyright{} Ewgenij Gawrilow and Michael Joswig
 @* @uref{http://www.polymake.de/}
@@ -142 +142 @@
 @copyright{} Oliver Labs (2001-2008), Stephan Holzer (2004-2005)
 @* @uref{http://surfex.AlgebraicSurface.net}
-@item TOPCOM (used by oldpolymake.lib, @pxref{oldpolymake_lib})
+@item TOPCOM (used by polymake.lib, @pxref{polymake_lib})
 @copyright{} J@"org Rambau
 @* @uref{http://www.rambau.wm.uni-bayreuth.de/TOPCOM/}

doc/Makefile.bsp

@@ -63 +63 @@
 CHKSUM_DB       = ${DOC_SUBDIR}/chksum
 # which tags to avoid:
-DOC2TEX_EXAMPLE_EXCLUSIONS = -exclude oldpolymake
+DOC2TEX_EXAMPLE_EXCLUSIONS = -exclude polymake
 # which tags to avoid:
-TAG             = oldpolymake
+TAG             = polymake
 DOC2TEX         = ${PERL} ./doc2tex.pl -docdir ${DOC_SUBDIR} \
                   -Singular ${SINGULAR} -verbose ${VERBOSE} -make ${MAKE} \

doc/NEWS.texi

@@ -42 +42 @@
 @itemize
 @item @nref{sba}: an F5 like Groebner base computation
+@item @nref{ASSUME}: support for debugging libraries
 @end itemize
 
@@ -47 +48 @@
 @itemize
 @item @nref{classifyci_lib}: Isolated complete intersection singularities in characteristic  0
-@item @xref{schubert_lib}:  Proceduces for Intersection Theory
+@item @nref{derham_lib}: Computation of deRham cohomology
 @end itemize
 
@@ -54 +55 @@
 @item
 improved grobcov.lib (@nref{grobcov_lib})
+@item
+fixed normal.lib (@nref{normal_lib})
 @end itemize
 

kernel/kstd1.cc

@@ -2969 +2969 @@
 
       // enter into S, L, and T
-      //if ((!TEST_OPT_IDLIFT) || (pGetComp(strat->P.p) <= strat->syzComp))
+      if ((!TEST_OPT_IDLIFT) || (pGetComp(strat->P.p) <= strat->syzComp))
+      {
         enterT(strat->P, strat);
-      // posInS only depends on the leading term
-      strat->enterS(strat->P, pos, strat, strat->tl);
-
+        // posInS only depends on the leading term
+        strat->enterS(strat->P, pos, strat, strat->tl);
+
+        if (pos<strat->sl)
+        {
+          need_retry++;
+          // move all "larger" elements fromS to L
+          // remove them from T
+          int ii=pos+1;
+          for(;ii<=strat->sl;ii++)
+          {
+            LObject h;
+            memset(&h,0,sizeof(h));
+            h.tailRing=strat->tailRing;
+            h.p=strat->S[ii]; strat->S[ii]=NULL;
+            strat->initEcart(&h);
+            h.sev=strat->sevS[ii];
+            int jj=strat->tl;
+            while (jj>=0)
+            {
+              if (strat->T[jj].p==h.p)
+              {
+                strat->T[jj].p=NULL;
+                if (jj<strat->tl)
+                {
+                  memmove(&(strat->T[jj]),&(strat->T[jj+1]),
+                          (strat->tl-jj)*sizeof(strat->T[jj]));
+                  memmove(&(strat->sevT[jj]),&(strat->sevT[jj+1]),
+                          (strat->tl-jj)*sizeof(strat->sevT[jj]));
+                }
+                strat->tl--;
+                break;
+              }
+              jj--;
+            }
+            int lpos=strat->posInL(strat->L,strat->Ll,&h,strat);
+            enterL(&strat->L,&strat->Ll,&strat->Lmax,h,lpos);
+            #ifdef KDEBUG
+            if (TEST_OPT_DEBUG)
+            {
+              Print("move S[%d] -> L[%d]: ",ii,pos);
+              p_wrp(h.p,currRing, strat->tailRing);
+              PrintLn();
+            }
+            #endif
+          }
+          if (strat->fromQ!=NULL)
+          {
+            for(ii=pos+1;ii<=strat->sl;ii++) strat->fromQ[ii]=0;
+          }
+          strat->sl=pos;
+        }
+      }
+      else
+      {
+        // clean P
+      }
       if (strat->P.lcm!=NULL)
 #ifdef HAVE_RINGS
@@ -2980 +3035 @@
         pLmFree(strat->P.lcm);
 #endif
-      if (pos<strat->sl)
-      {
-        need_retry++;
-        // move all "larger" elements fromS to L
-        // remove them from T
-        int ii=pos+1;
-        for(;ii<=strat->sl;ii++)
-        {
-          LObject h;
-          memset(&h,0,sizeof(h));
-          h.tailRing=strat->tailRing;
-          h.p=strat->S[ii]; strat->S[ii]=NULL;
-          strat->initEcart(&h);
-          h.sev=strat->sevS[ii];
-          int jj=strat->tl;
-          while (jj>=0)
-          {
-            if (strat->T[jj].p==h.p)
-            {
-              strat->T[jj].p=NULL;
-              if (jj<strat->tl)
-              {
-                memmove(&(strat->T[jj]),&(strat->T[jj+1]),
-                        (strat->tl-jj)*sizeof(strat->T[jj]));
-                memmove(&(strat->sevT[jj]),&(strat->sevT[jj+1]),
-                        (strat->tl-jj)*sizeof(strat->sevT[jj]));
-              }
-              strat->tl--;
-              break;
-            }
-            jj--;
-          }
-          int lpos=strat->posInL(strat->L,strat->Ll,&h,strat);
-          enterL(&strat->L,&strat->Ll,&strat->Lmax,h,lpos);
-          #ifdef KDEBUG
-          if (TEST_OPT_DEBUG)
-          {
-            Print("move S[%d] -> L[%d]: ",ii,pos);
-            p_wrp(h.p,currRing, strat->tailRing);
-            PrintLn();
-          }
-          #endif
-        }
-        if (strat->fromQ!=NULL)
-        {
-          for(ii=pos+1;ii<=strat->sl;ii++) strat->fromQ[ii]=0;
-        }
-        strat->sl=pos;
-      }
     }
 

kernel/kstd2.cc

@@ -1390 +1390 @@
 
       // enter into S, L, and T
-      //if ((!TEST_OPT_IDLIFT) || (pGetComp(strat->P.p) <= strat->syzComp))
+      if ((!TEST_OPT_IDLIFT) || (pGetComp(strat->P.p) <= strat->syzComp))
+      {
         enterT(strat->P, strat);
 #ifdef HAVE_RINGS
-      if (rField_is_Ring(currRing))
-        superenterpairs(strat->P.p,strat->sl,strat->P.ecart,pos,strat, strat->tl);
-      else
-#endif
-        enterpairs(strat->P.p,strat->sl,strat->P.ecart,pos,strat, strat->tl);
-      // posInS only depends on the leading term
-      strat->enterS(strat->P, pos, strat, strat->tl);
+        if (rField_is_Ring(currRing))
+          superenterpairs(strat->P.p,strat->sl,strat->P.ecart,pos,strat, strat->tl);
+        else
+#endif
+          enterpairs(strat->P.p,strat->sl,strat->P.ecart,pos,strat, strat->tl);
+        // posInS only depends on the leading term
+        strat->enterS(strat->P, pos, strat, strat->tl);
 #if 0
-      int pl=pLength(strat->P.p);
-      if (pl==1)
-      {
-        //if (TEST_OPT_PROT)
-        //PrintS("<1>");
-      }
-      else if (pl==2)
-      {
-        //if (TEST_OPT_PROT)
-        //PrintS("<2>");
-      }
-#endif
+        int pl=pLength(strat->P.p);
+        if (pl==1)
+        {
+          //if (TEST_OPT_PROT)
+          //PrintS("<1>");
+        }
+        else if (pl==2)
+        {
+          //if (TEST_OPT_PROT)
+          //PrintS("<2>");
+        }
+#endif
+      }
       if (hilb!=NULL) khCheck(Q,w,hilb,hilbeledeg,hilbcount,strat);
 //      Print("[%d]",hilbeledeg);
@@ -2449 +2451 @@
       // enter into S, L, and T
       // here we need to recompute new signatures, but those are trivial ones
-      //if ((!TEST_OPT_IDLIFT) || (pGetComp(strat->P.p) <= strat->syzComp))
-      enterT(strat->P, strat);
-      // posInS only depends on the leading term
-      strat->enterS(strat->P, pos, strat, strat->tl);
+      if ((!TEST_OPT_IDLIFT) || (pGetComp(strat->P.p) <= strat->syzComp))
+      {
+        enterT(strat->P, strat);
+        // posInS only depends on the leading term
+        strat->enterS(strat->P, pos, strat, strat->tl);
 //#if 1
 #ifdef DEBUGF5
-      Print("ELEMENT ADDED TO GCURR DURING INTERRED: ");
-      pWrite(pHead(strat->S[strat->sl]));
-      pWrite(strat->sig[strat->sl]);
-#endif
-      if (hilb!=NULL) khCheck(Q,w,hilb,hilbeledeg,hilbcount,strat);
+        Print("ELEMENT ADDED TO GCURR DURING INTERRED: ");
+        pWrite(pHead(strat->S[strat->sl]));
+        pWrite(strat->sig[strat->sl]);
+#endif
+        if (hilb!=NULL) khCheck(Q,w,hilb,hilbeledeg,hilbcount,strat);
+      }
       //      Print("[%d]",hilbeledeg);
       if (strat->P.lcm!=NULL)