passagemath-singular 10.6.31rc3__cp314-cp314-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl

sage_wheels/share/singular/LIB/normaliz.lib

@@ -0,0 +1,2226 @@
+//// Singular library normaliz.lib
+version="version normaliz.lib 4.4.1.2 July_2025 "; // $Id: 92f0b75c305fabbb45fb0054da4108ddb8c9cb52 $
+category="Commutative Algebra";
+info="
+LIBRARY: normaliz.lib  Provides an interface for the use of Normaliz 3.10.0 or
+         newer within SINGULAR.
+AUTHORS: Winfried Bruns, wbruns@uos.de
+         Christof Soeger, Christof.Soeger@Uni-Osnabrueck.de
+
+OVERVIEW:
+@texinfo
+The library normaliz.lib provides an interface for the use of Normaliz 3.10.0 or
+newer within SINGULAR. The exchange of data is via files.
+In addition to the top level
+functions that aim at objects of type ideal or ring, several other auxiliary
+functions allow the user to apply Normaliz to data of type intmat.  Options
+such as compoutationn goals or algorithmic variants can be activated.To some extent,
+SINGULAR can therefore be used as an environment for interactive access to Normaliz.
+@* Please see the @code{Normaliz.pdf} (included in the Normaliz
+distribution) for a more extensive documentation of Normaliz.
+
+Normaliz allows the use of a grading. In the Singular functions that access
+Normaliz the parameter grading is an intvec that assigns a (not necessarily
+positive) degree to every variable of the ambient polynomial ring.
+But it must give positive degrees to the generators given to the function.
+
+Singular and Normaliz exchange data via files. The input files use the Normaliz 3 syntax.
+These files are automatically
+created and erased behind the scenes. As long as one wants to use only the
+ring-theoretic functions there is no need for file management.
+@*Note that the numerical invariants computed by Normaliz can be
+accessed in this \"automatic file mode\".
+@*However, if Singular is used as a frontend for Normaliz or the user
+wants to inspect data not automatically returned to Singular, then
+an explicit filename and a path can be specified for the exchange of
+data. Moreover, the library provides functions for access to these files.
+Deletion of the files is left to the user.  (Not all output files
+of Normaliz can be read by this library.)
+
+Use of this library requires the program Normaliz to be installed.
+You can download it from
+@uref{https://github.com/Normaliz/Normaliz/releases}. Please make sure
+that the executable is in the search path or use setNmzExecPath
+(@ref{setNmzExecPath}).
+@end texinfo
+
+KEYWORDS: integral closure; normalization; toric ring
+
+PROCEDURES:
+ intclToricRing(ideal I)      computes the integral closure of the toric ring
+                              generated by the leading monomials of the
+                              elements of I in the basering
+ normalToricRing(ideal I)     computes the normalization of the toric ring
+                              generated by the leading monomials of the
+                              elements of I
+ proc hilbertSeriesToricRing(ideal I) computes the Hilbert series of the toric ring
+                              generated by the lead monomials of the elements in I.
+                              A grading can be specified
+ normalToricRingFromBinomials(ideal I)  computes the normalization of the
+                              polynomial ring modulo the unique minimal binomial
+                              prime ideal of the binomial ideal I
+ toricRingFromBinomials(ideal I)  computes the polynomial ring modulo the unique
+                              inimal binomial prime ideal of the binomial ideal I
+ ehrhartRing(ideal I)         considers the exponent vectors of the elements of I
+                              as points of a lattice polytope and computes the
+                              integral cloure of the polytopal algebra
+ intclMonIdeal(ideal I)       Computes the integral closure of the Rees algebra
+                              of the ideal generated by the leading monomials of
+                              the elements of I
+ definingBinomialIdeal(ideal I) computes the defining binomail ideal of the toric ring
+                              generated by the leading monomials of the elements of I
+ latticeIdeal(ideal I)        computes the lattice ideal defined by the binomial ideal I
+ groebnerBasis(ideal I)       computes a Gröbner basis of the lattice ideal defined by
+                              the binomial ideal I
+ torusInvariants(intmat T)    computes the ring of invariants of a torus action
+ finiteDiagInvariants(intmat C)  computes the ring of invariants of a finite
+                                 abelian group acting diagonally on a polynomial
+                                 ring
+ diagInvariants(intmat C)     computes the ring of invariants of a
+                              diagonalizable group
+ intersectionValRings(intmat V)   computes the intersection of the polynomial
+                                  ring with the valuation rings of monomial
+                                  valuations
+ intersectionValRingIdeals(intmat V)       computes ideals of monomial valuations
+ showNuminvs()                prints the numerical invariants found by Normaliz
+ exportNuminvs()              exports the numerical invariants found by Normaliz
+
+ allNmzOptions() prints all available Normaliz options with thei naming string,
+                               the default value and the string passed to Normaliz
+ setNmzOption(string s, int onoff) sets the option s to onoff
+ addNmzOption(string short_cut, string nmz_oprion) adds a Normaliz option to the list
+                              of predefined ones and activates it
+ showNmzOptions()             prints the enabled options to the standard output
+ resetNmzOptions() resets the options to the default choice
+
+ normaliz(intmat input_mat,string nmz_type,...) applies Normaliz to the input matrix
+                              of type nmz_type. Further arguments can be additional matrices and integer parameters.
+ setNmzExecPath(string nmz_exec_path_name) sets the path to the Normaliz
+                                           executable
+
+ writeNmzData(intmat sgr, string nmz_type) creates an input file for Normaliz
+                            (also from a list of pairs sgr, nmz_type)
+ readNmzData(string nmz_suffix) reads the Normaliz output file with the
+                                specified suffix
+
+ setNmzFilename(string nmz_filename_name) sets the filename for the exchange
+                                          of data
+ setNmzDataPath(string nmz_data_path_name) sets the directory for the exchange
+                                           of data
+ writeNmzPaths()              writes the path names into two files
+ startNmz()                   retrieves the path names written by writeNmzPaths
+ rmNmzFiles()                 removes the files created for and by Normaliz
+
+ mons2intmat(ideal I)         returns the intmat whose rows represent the
+                              leading exponents of the elements of I
+ intmat2mons(intmat expo_vecs) returns the ideal generated by the monomials
+                               which have the rows of expo_vecs as
+                               exponent vector
+ binomials2intmat(ideal I)    returns the intmat whose rows represent the
+                              exponents of the elements of the binomial ideal I
+ intmat2binomials(intmat expo_vecs)   returns the ideal generated by the binomials
+                              represent by the rows of the intmat expo_vecs
+";
+
+
+// helpers
+static proc fileExists(string f)
+{
+    return(status (f,"exists")=="yes");
+}
+
+static proc appendSlash(string s)
+// if nonempty and / is not the terminating char
+{
+    if(size(s)>0)
+    {
+        if(s[size(s)]!="/")
+        {
+            s=s+"/";
+            return(s);
+        }
+    }
+    return(s);
+}
+
+// filenames and paths
+
+proc setNmzExecPath(string nmz_exec_path_name)
+"USAGE:   setNmzExecPath(string s);   @code{s} path to the Normaliz executable
+CREATE:   @code{Normaliz::nmz_exec_path} to save the given path @code{s}
+NOTE:     It is not necessary to use this function if the Normaliz executable
+          is in the search path of the system.
+SEE ALSO: setNmzOption
+EXAMPLE:  example setNmzExecPath; shows an example"
+{
+    nmz_exec_path=nmz_exec_path_name;
+    nmz_exec_path=appendSlash(nmz_exec_path);
+}
+example
+{ "EXAMPLE:";echo = 2;
+  setNmzExecPath("../Normaliz/");
+}
+
+proc setNmzFilename(string nmz_filename_name)
+"USAGE:   setNmzFilename(string s);
+CREATE:   @code{Normaliz::nmz_filename} to save the given filename @code{s}
+NOTE:     The function sets the filename for the exchange of data. Unless a
+          path is set by setNmzDataPath, files will be created in the current
+          directory.
+          @* If a non-empty filename is set, the files created for and by
+             Normaliz are kept. This is mandatory for the data access functions
+             (see @ref{writeNmzData} and @ref{readNmzData}).
+          @* Resetting the filename by setNmzFilename(\"\") forces the library
+             to return to deletion of temporary files, but the files created
+             while the filename had been set will not be erased.
+SEE ALSO: writeNmzData, readNmzData, setNmzDataPath, rmNmzFiles
+EXAMPLE:  example setNmzFilename; shows an example"
+{
+    nmz_filename=nmz_filename_name;
+    if(nmz_filename_name!="")
+    {
+        nmz_files_keep_switch=1;
+    }
+    else
+    {
+        nmz_files_keep_switch=0;
+    }
+}
+example
+{ "EXAMPLE:";echo = 2;
+  setNmzDataPath("examples/");
+  setNmzFilename("example1");
+  //now the files for the exchange with Normaliz are examples/example1.SUFFIX
+}
+
+proc setNmzDataPath(string nmz_data_path_name)
+"USAGE:   setNmzDataPath(string s);
+CREATE:   @code{Normaliz::nmz_data_path} to save the given path @code{s}
+NOTE:     The function sets the path for the exchange of data. By default the
+          files will be created in the current directory.
+          @* It seems that Singular cannot use filenames starting with @code{~}
+             or @code{$HOME} in its input/output functions.
+          @* You must also avoid path names starting with @code{/} if you work
+             under Cygwin, since Singular and Normaliz interpret them in
+             different ways.
+SEE ALSO: writeNmzData, readNmzData, rmNmzFiles, setNmzFilename
+EXAMPLE:  example setNmzDataPath; shows an example"
+{
+    nmz_data_path=nmz_data_path_name;
+    nmz_data_path=appendSlash(nmz_data_path);
+}
+example
+{ "EXAMPLE:";echo = 2;
+  setNmzDataPath("examples/");
+  setNmzFilename("example1");
+  //now the files for the exchange with Normalize are examples/example1.SUFFIX
+}
+
+proc writeNmzPaths();
+"USAGE:   writeNmzPaths();
+CREATE:   the file nmz_sing_exec.path where the path to the Normaliz executable
+          is saved
+          @* the file nmz_sing_data.path where the directory for the exchange
+          of data is saved
+NOTE:     Both files are saved in the current directory. If one of the names
+          has not been defined, the corresponding file is created, but
+          contains nothing.
+SEE ALSO: setNmzDataPath, setNmzExecPath, startNmz
+EXAMPLE:  example writeNmzPaths; shows an example
+"{
+    link outf=":w nmz_sing_exec.path";
+    write(outf, nmz_exec_path);
+    close(outf);
+
+    outf=":w nmz_sing_data.path";
+    write(outf, nmz_data_path);
+    close(outf);
+}
+example
+{ "EXAMPLE:";echo = 2;
+  setNmzExecPath("../Normaliz/");
+  writeNmzPaths();
+  int dummy=system("sh","cat nmz_sing_exec.path");
+  dummy=system("sh","cat nmz_sing_data.path");
+}
+
+proc startNmz()
+"USAGE:   startNmz();
+PURPOSE:  This function reads the files written by @code{writeNmzPaths()},
+          retrieves the path names, and types them on the standard output
+          (as far as they have been set). Thus, once the path names have been
+          stored, a Normaliz session can simply be opened by this function.
+SEE ALSO: setNmzDataPath, setNmzExecPath, writeNmzPaths
+EXAMPLE:  example startNmz; shows an example
+"
+{
+    link inf=":r nmz_sing_exec.path";
+    string s=read(inf);
+    int i,p;
+    p=findWord("/",s,1);
+    if(p!=-1)
+    {
+        for(i=size(s);i>=1;i--)
+        {
+            if(s[i]=="/")
+            {
+                s=s[1..i];
+                break;
+            }
+        }
+        nmz_exec_path=s;
+        "nmz_exec_path is",nmz_exec_path;
+    }
+    else
+    {
+        "nmz_exec_path not set";
+    }
+
+    inf=":r nmz_sing_data.path";
+    s=read(inf);
+    p=findWord("/",s,1);
+    if(p!=-1)
+    {
+        for(i=size(s);i>=1;i--)
+        {
+            if(s[i]=="/")
+            {
+                s=s[1..i];
+                break;
+            }
+        }
+        nmz_data_path=s;
+        "nmz_data_path is",nmz_data_path;
+    }
+    else
+    {
+        "nmz_data_path not set";
+    }
+}
+example
+{ "EXAMPLE:"; echo=2;
+  writeNmzPaths();
+  startNmz();
+}
+
+static proc getNmzFile()
+{
+    if(nmz_files_keep_switch)
+    {
+        return(nmz_data_path+nmz_filename);
+    }
+    else
+    {
+        return(nmz_filename);
+    }
+}
+
+static proc makeTempNmzDataPath()
+{
+    string testdir, testdir1;
+    int i,dummy;
+
+    testdir1="/tmp/nmz_sing_"+string(system("pid"));
+    testdir=testdir1;
+    while(fileExists(testdir))
+    {
+        i = i +1;
+        testdir=testdir1+string(i);
+    }
+    dummy=system("sh","mkdir "+ testdir);
+    nmz_filename=testdir+"/nmz"; //files are nmz+suffix in testdir
+}
+
+static proc eraseTempNmzDataPath();
+{
+    int dummy;
+
+    string tmpdir=getNmzFile();
+    tmpdir=tmpdir[1..size(tmpdir)-4]; // remove "/nmz"
+    dummy=system("sh","rm -r "+tmpdir);
+    setNmzFilename("");
+}
+
+static proc setNmzExec()
+{
+    return(nmz_exec_path+"normaliz");
+}
+
+proc rmNmzFiles()
+"USAGE:  rmNmzFiles();
+PURPOSE: This function removes the files created for and by Normaliz, using
+         the last filename specified.
+         It needs an explicit filename set (see @ref{setNmzFilename}).
+SEE ALSO: writeNmzData, readNmzData, setNmzFilename, setNmzDataPath
+EXAMPLE:  example rmNmzFiles; shows an example
+"{
+
+    if(!nmz_files_keep_switch)
+    {
+        ERROR("rmNmzFiles: no filename specified");
+    }
+
+    list suffixes="in","gen","out","cst","typ","egn","esp","inv","tri","ht1",
+                  "ext","dec", "lat", "mod", "tgn", "msp", "inc", "fac", "aut",
+                  "IntHull.out", "symm.out", ".ProjectCone.out, grb, mrk, rep", "ogn";
+    int i,dummy;
+    string f;
+
+    for(i=1;i<=size(suffixes);i++)
+    {
+        f=getNmzFile()+"."+suffixes[i];
+        if (fileExists(f))
+        {
+            dummy=system("sh","rm "+f+ "&> /dev/null");
+        }
+    }
+}
+example
+{ "EXAMPLE:"; echo=2;
+  setNmzFilename("VeryInteresting");
+  rmNmzFiles();
+}
+
+
+
+// parsing normaliz output
+
+static proc digit(string s)
+{
+    if(s==" ") // skip blanks quickly
+    {
+        return(0);
+    }
+
+    if((s[1]>="0" && s[1]<="9")||s[1]=="-")
+    {
+        return(1);
+    }
+    return(0);
+}
+
+static proc nextWord(string s, int p)
+{
+    int j,sw,ew;
+
+    for(;p<=size(s);p++) // must start with a letter
+    {
+
+        if((s[p]>="a" && s[p]<="z")||
+             (s[p]>="A" && s[p]<="Z"))
+        {
+            sw=p; break;
+        }
+    }
+    if(p>size(s))
+    {
+        return(-1,-1); // no word found
+    }
+
+    for(;p<=size(s);p++) // now numerals and -_ allowed
+    {
+        if(!((s[p]>="a" && s[p]<="z")||
+             (s[p]>="A" && s[p]<="Z")||
+             (s[p]>="0" && s[p]<="9")||
+              s[p]=="_"||s[p]=="-"))
+        {
+            break;
+        }
+    }
+    return(sw,p);
+}
+
+static proc getInt(string s, int p)
+{
+    string nst;
+    int i,j,en,sn;
+
+    for(;p<=size(s);p++)
+    {
+
+        if(digit(s[p]))
+        {
+            sn=p; break;
+        }
+    }
+    if(not(sn))
+    {
+        return(0,-1); // -1 indicates: no number found
+    }
+    p++;
+    for(;p<=size(s);p++)
+    {
+        if(!digit(s[p]))
+        {
+            en=p-1; break;
+        }
+    }
+    if(p>size(s))
+    {
+        en=size(s);
+    }
+    nst="i="+s[sn,en-sn+1];
+    execute(nst);
+    return(i,p);
+}
+
+static proc getBigInt(string s, int p)
+{
+    string nst;
+    int j,en,sn;
+    bigint i;
+
+    for(;p<=size(s);p++)
+    {
+
+        if(digit(s[p]))
+        {
+            sn=p; break;
+        }
+    }
+    if(not(sn))
+    {
+        return(0,-1); // -1 indicates: no number found
+    }
+    p++;
+    for(;p<=size(s);p++)
+    {
+        if(!digit(s[p]))
+        {
+            en=p-1; break;
+        }
+    }
+    if(p>size(s))
+    {
+        en=size(s);
+    }
+    nst="i="+s[sn,en-sn+1];
+    execute(nst);
+    return(i,p);
+}
+
+
+static proc getRational(string s, int p)
+{
+    string nst;
+    int i,j,en,sn;
+
+    for(;p<=size(s);p++)
+    {
+        if(digit(s[p]))
+        {
+            sn=p; break;
+        }
+    }
+    if(not(sn))
+    {
+        return(0,-1); // -1 indicates: no number found
+    }
+    p++;
+    int slash_at;
+    for(;p<=size(s);p++)
+    {
+        if(s[p]=="/")
+        {
+            slash_at=p;
+            p++;
+            continue;
+        }
+        if(!digit(s[p]))
+        {
+            en=p-1; break;
+        }
+    }
+    if(p>size(s))
+    {
+        en=size(s);
+    }
+    if(slash_at)
+    {
+        nst="i="+s[sn,slash_at-sn];
+        execute(nst);
+        nst="j="+s[slash_at+1,en-slash_at];
+        execute(nst);
+        return(i,p,j);
+    }
+    nst="i="+s[sn,en-sn+1];
+    execute(nst);
+    return(i,p);
+}
+
+
+static proc findWord(string s, string t, int p)
+{
+    for(;p<=size(t)-size(s)+1;p++)
+    {
+        if(t[p]==s[1])
+        {
+            if(t[p,size(s)]==s)
+            {
+                 return(p+size(s));
+            }
+        }
+    }
+    return(-1);
+}
+
+
+static proc skipEqualsign(string s,int p)
+{
+    for(;p<=size(s);p++)
+    {
+        if(s[p]=="=")
+        {
+            break;
+        }
+    }
+    return(p+1);
+}
+
+
+// input and output to/from normaliz
+
+// for backward compatibility:
+static proc num_type_to_string(int nmz_type)
+{
+    if (nmz_type == 20) {
+        return("grading");}
+    if (nmz_type == 0) {
+        return("integral_closure");}
+    if (nmz_type == 1) {
+        return("normalization");}
+    if (nmz_type == 2) {
+        return("polytope");}
+    if (nmz_type == 3) {
+        return("rees_algebra");}
+    if (nmz_type == 4) {
+        return("inequalities");}
+    if (nmz_type == 5) {
+        return("equations");}
+    if (nmz_type == 6) {
+        return("congruences");}
+    if (nmz_type == 10) {
+        return("lattice_ideal");}
+    if (nmz_type == -1) {
+        return("-1");}
+}
+
+//list must have pairs of intmat, nmz_type
+static proc doWriteNmzData(list #)
+{
+    string s;
+    int i,j;
+    link outf=":w "+ getNmzFile() +".in";  // also sets the filename
+
+    intmat sgr;
+    intvec vecinput;
+    int num_rows, num_cols;
+    string nmz_type;
+
+    write(outf,"amb_space auto");
+
+    for (int k=1; k<=size(#); k=k+2) {
+    //get data from the parameter list
+        if(typeof(#[k+1]) == "int"){
+            nmz_type = num_type_to_string(#[k+1]);}
+        else{
+            nmz_type   = #[k+1];}
+
+        if (nmz_type != "-1") { //skip -1 type
+
+            if(typeof(#[k]) == "int"){
+                s= nmz_type + " ";
+                s= s + string(#[k]);
+                write(outf, s);
+            }
+            if(typeof(#[k]) == "intvec"){
+                vecinput = #[k];
+                s= nmz_type;
+                write(outf, s);
+                write(outf,"[");
+                s = "";
+                for(i=1;i<= size(vecinput);i++){
+                    s= s + string(vecinput[i]);
+                }
+                write(outf,s);
+                write(outf,"]");
+            }
+            if(typeof(#[k]) != "int" && typeof(#[k]) != "intvec"){
+                write(outf, nmz_type);
+                sgr = #[k];
+                num_rows = nrows(sgr);
+                num_cols = ncols(sgr);
+
+                if(nmz_type != "grading")
+                {
+                    write(outf,"[");
+                }
+
+                for(i=1;i<=nrows(sgr);i++)
+                {
+                    s="[";
+                    for(j=1;j<=num_cols -1;j++)
+                    {
+                        s= s + string(sgr[i,j]);
+                        s = s + ", ";
+                    }
+                    s= s + string(sgr[i,num_cols]);
+                    s = s + "]";
+                    write(outf,s);
+                }
+                if(nmz_type != "grading")
+                {
+                    write(outf,"]");
+                }
+            }
+        }
+    }
+    close(outf);
+}
+
+static proc prepareGrading(list #)
+{
+    if (size(#)==0) {
+        return(0,-1); // type -1 specifies discard the matrix
+    }
+    if (size(#)>1) {
+        print(#);
+        ERROR("To many parameters!");
+    }
+    intmat g = intmat(#[1],1,size(#[1]));
+    return (g,"grading");
+}
+
+
+proc writeNmzData(list #)
+"USAGE:   writeNmzData(intmat M, string nmz_type);
+          writeNmzData(intmat M, string nmz_type, intmat M2, string nmz_type2, ...);
+CREATE:   Creates an input file for Normaliz from the matrix M. The second
+          parameter sets the type. How the matrix is interpreted depends on the
+          type. See the Normaliz documentation for more information.
+
+          It is also possible to give more than one pair of matrix and type. In
+NOTE:     Needs an explicit filename set. The filename is created from the
+          current filename.
+   @*     Note that all high level functions in normaliz.lib write and read their
+          data automatically to and from the hard disk so that writeNmzData will
+          hardly ever be used explicitly.
+SEE ALSO: readNmzData, rmNmzFiles, setNmzFilename, setNmzDataPath
+EXAMPLE:  example writeNmzData; shows an example"
+{
+    if(nmz_filename=="")
+    {
+        ERROR("writeNmzData: no filename specified");
+    }
+    doWriteNmzData(#);
+}
+example
+{ "EXAMPLE:"; echo=2;
+  setNmzFilename("VeryInteresting");
+  intmat sgr[3][3]=1,2,3,4,5,6,7,8,10;
+  writeNmzData(sgr,"cone_and_lattice");
+  int dummy=system("sh","cat VeryInteresting.in");
+
+  intmat Inequalities[2][3] = 2,-1,0, // 2x-y >= 0
+                             1, 1,0; //  x+y >= 0
+  intmat Equation[1][3] = 0,1,-1;    // y = z
+  intmat Congruence[1][4] = 1,0,0,3;  // x = 0 (3)
+  writeNmzData(Inequalities,"inequalities",Equation,"equations",Congruence,"congruences");
+  dummy=system("sh","cat VeryInteresting.in");
+}
+
+static proc readNmzSparseMatrix(string nmz_suffix)
+{
+    string s;
+    int n_rows,n_cols;            //number of rows/columns
+    int p;                     //position
+    int i,j;
+
+    string filename = getNmzFile() + "."+ nmz_suffix;
+    link in_f=":r "+ filename;
+    s=read(in_f);
+    close(in_f);
+
+    p=1;
+
+    (n_rows,p)=getInt(s,p);
+    n_rows = - n_rows;
+    (n_cols,p)=getInt(s,p);
+
+    intmat nmz_gen[n_rows][n_cols];
+    int nr_nonzero_entries;
+    int k;
+    for(i=1;i<=n_rows;i++)
+    {
+        (nr_nonzero_entries,p)=getInt(s,p);
+        for(j=1;j<=nr_nonzero_entries;j++)
+        {
+            (k,p)=getInt(s,p);
+            (nmz_gen[i,k],p) = getInt(s,p);
+        }
+    }
+
+    return(nmz_gen);
+}
+
+
+proc readNmzData(string nmz_suffix)
+"USAGE:  readNmzData(string suffix);
+RETURN:  Reads an output file of Normaliz containing an integer matrix and
+         returns it as an intmat. For example, this function is useful if one
+         wants to inspect the support hyperplanes. The filename is created
+         from the current  filename and the suffix given to the function.
+         In addition to file suffixes, also sup, equ and cgr are allowed.
+         They extract the support hyperplanes, equations and congruences,
+         respectively, from the cst file.
+NOTE:    Needs an explicit filename set by setNmzFilename.
+   @*    Note that all functions in normaliz.lib write and read their data
+         automatically so that readNmzData will usually not be used explicitly.
+   @*    This function reads only the first matrix in a file! But see su, equ, cgr above.)
+   @*    It is the responsability of the user to make sure that an output file
+         read by this function has been created for the current input file of Normaliz.
+         Files are not automatically removed before a new computation starts.
+   @*    Not every output file can be read by this function.
+SEE ALSO: writeNmzData, rmNmzFiles, setNmzFilename, setNmzDataPath
+EXAMPLE:  example readNmzData; shows an example"
+{
+    if(nmz_filename=="")
+    {
+        ERROR("readNmzData: no filename specified");
+    }
+
+    if(nmz_suffix == "rep" || nmz_suffix == "grb" || nmz_suffix == "mrk"){
+        return(readNmzSparseMatrix(nmz_suffix));
+    }
+
+    string s;
+    int n_rows,n_cols;            //number of rows/columns
+    int p;                     //position
+    int i,j;
+    int returnvalue;
+
+    int which_matrix = 1;
+    if(nmz_suffix == "sup"){
+        nmz_suffix = "cst";
+    }
+    if(nmz_suffix == "equ"){
+        nmz_suffix = "cst";
+        which_matrix = 2;
+    }
+    if(nmz_suffix == "cgr"){
+        nmz_suffix = "cst";
+        which_matrix = 3;
+    }
+
+    string filename = getNmzFile() + "."+ nmz_suffix;
+    link in_f=":r "+ filename;
+    s=read(in_f);
+    close(in_f);
+
+    p=1;
+    for(int mm = 1; mm <= which_matrix; mm = mm + 1)
+    {
+        (n_rows,p)=getInt(s,p);
+        (n_cols,p)=getInt(s,p);
+        if( mm > 1){
+            kill nmz_gen;
+        }
+        intmat nmz_gen[n_rows][n_cols];
+        for(i=1;i<=n_rows;i++)
+        {
+            for(j=1;j<=n_cols;j++)
+            {
+                (nmz_gen[i,j],p) = getInt(s,p);
+            }
+        }
+    }
+    return(nmz_gen);
+}
+example
+{ "EXAMPLE:"; echo=2;
+  setNmzFilename("VeryInteresting");
+  intmat sgr[3][3]=1,2,3,4,5,6,7,8,9;
+  intmat sgrnormal=normaliz(sgr,"cone");
+  readNmzData("sup");
+  readNmzData("equ");
+}
+
+
+
+proc setNmzOption(string s, int onoff)
+"USAGE:   setNmzOption(string s, int onoff);
+PURPOSE:  If @code{onoff=1} the option @code{s} is activated, and
+          if @code{onoff=0} it is deactivated.
+The predefined Normaliz options are accessible via the following names:
+@* @code{-s:  supp}
+@* @code{-t:  triang}
+@* @code{-v:  volume}
+@* @code{-p:  hvect} deprecated, replacement:
+@* @code{-p:  hvect_deg1}
+@* @code{-q:  only_hvect}
+@* @code{--FVector:  fvect}
+@* @code{-1:  height1}
+@* @code{-G:  Gorenst}
+@* @code{-w:  witness}
+@* @code{--IsIntegrallyClosed:  intclosed}
+@* @code{-C:  classgroup}
+@* @code{-n:  normal}  deprecated, replacement:
+@* @code{-n:  hilbbasvol}
+@* @code{-N:  normal_l}  deprecated, replacement:
+@* @code{-N:  hilbbas}
+@* @code{-h:  hilb} deprecated, replacement:
+@* @code{-h:  hilbbas_hvect}
+@* @code{--MarkovBasis: groebner}
+@* @code{--GroebnerBasis: markov}
+@* @code{--Lex: lex}
+@* @code{--RevLex: revlex}
+@* @code{--DegLex: deglex}
+@* @code{-d:  dual}
+@* @code{-M:  genoverori}
+@* @code{-a:  allf}
+@* @code{--typ:  type}
+@* @code{-c:  control} deprecated, replacement:
+@* @code{-c:  verbose}
+@* @code{-e:  errorcheck} allowed, but ignored
+@* @code{-B:  bigint} Use GMP for arbitrary precision integers
+@* @code{-x=N:  threads} In this case the int parameter is used to set the
+                         number of threads N, deafult 8, 0 means no explicit limiting.
+
+            Further Normaliz otions can be adeded to tzhe nlist by addNmzOption.
+
+SEE ALSO: allNmzOptions,showNmzOptions, addNmzOption, resetNmzOptions
+EXAMPLE:  example setNmzOption; shows an example
+"
+{
+    for(int i=1;i<=size(nmz_options);i++)
+    {
+        if(s==nmz_options[i][1])
+        {
+            nmz_options[i][2]=onoff;
+            return(1);
+        }
+    }
+    "Invalid option ", s;
+    return(0);
+}
+example
+{ "EXAMPLE:"; echo=2;
+  setNmzOption("only_hvect",1);
+  showNmzOptions();
+  setNmzOption("only_hvect",0);
+  showNmzOptions();
+}
+
+proc resetNmzOptions()
+"USAGE:   resetNmzOptions();
+PURPOSE:  Resets the options to the dafault value.
+SEE ALSO: showNmzOptions, setNmzOption, allNmzOptions, addNmzOption
+EXAMPLE:  example resetNmzOptions; shows an example
+"
+{
+  nmz_options = default_options;
+}
+example
+{ "EXAMPLE:"; echo=2;
+  setNmzOption("only_hvect",1);
+  showNmzOptions();
+  resetNmzOptions();
+  showNmzOptions();
+}
+
+static proc collectNmzOptions()
+{
+    string run_options=" -f ";
+    for(int i=1;i<=size(nmz_options);i++)
+    {
+        if(nmz_options[i][2])
+        {
+            run_options=run_options+nmz_options[i][3];
+            if (nmz_options[i][1]=="threads") {
+                run_options=run_options+string(nmz_options[i][2]);
+            }
+            run_options=run_options+" ";
+        }
+    }
+    return(run_options+" ");
+}
+
+proc addNmzOption(string short_cut, string nmz_option)
+"USAGE:   addNmzOption(string short_cut, string nmz_option)
+NOTE:     This function allows the addition of Normaliz options
+          in addition to the predefined ones. Adding an option does not
+          activate it.
+    @*    Note: The function prefixes a single letter option by - and
+          multiletter options by --.
+SEE ALSO: allNmzOptions,showNmzOptions, setNmzOption, resetNmzOptions
+EXAMPLE:  example addNmzOption; shows an example
+"
+{
+    if(size(nmz_option) == 1){
+        nmz_option = "-" + nmz_option;
+    }
+    else{
+        nmz_option = "--" + nmz_option;
+    }
+    list new_option = list(short_cut, 0, nmz_option);
+    nmz_options = nmz_options + list(new_option);
+}
+example
+{ "EXAMPLE:"; echo=2;
+  addNmzOption("FL", "FaceLattice");
+  setNmzOption("FL", 1);
+  showNmzOptions();
+  resetNmzOptions();
+}
+
+proc showNmzOptions()
+"USAGE:   showNmzOptions();
+RETURN:   Returns the string of activated options.
+NOTE:     This string is used as parameter when calling Normaliz.
+SEE ALSO: setNmzOption
+EXAMPLE:  example showNmzOptions; shows an example
+"
+{
+    return(collectNmzOptions());
+}
+example
+{ "EXAMPLE:"; echo=2;
+  setNmzOption("hilb",1);
+  showNmzOptions();
+  setNmzOption("hilb",0);
+  showNmzOptions();
+}
+
+
+static proc runNormaliz(list #)
+{
+    if(!nmz_files_keep_switch)
+    {
+        makeTempNmzDataPath();
+    }
+
+    doWriteNmzData(#);
+
+    if(nmz_files_keep_switch)
+    {
+       int dummy=system("sh",setNmzExec()+ collectNmzOptions() + getNmzFile());
+    }
+    else
+    {
+        string gotodir="/tmp";
+        string fname=getNmzFile();
+        fname=fname[6..size(fname)];
+        string exec="cd "+gotodir+" ; ";
+        exec=exec+setNmzExec()+ collectNmzOptions()+" ";
+        exec=exec+fname+" ;";
+        int dummy=system("sh",exec);
+    }
+
+    Num_Invs=getNuminvs();
+
+    int gens_computed = 0;
+    for( int i = 1; i <= size(Num_Invs); i = i+1){
+        if(Num_Invs[i][1] == "hilbert_basis_elements"){
+            gens_computed = 1;
+        }
+    }
+
+    if(!gens_computed) // return input matrix if "gen" has not been generated
+    {
+        if(!nmz_files_keep_switch)
+        {
+            eraseTempNmzDataPath();
+        }
+        return(#[1]);
+    }
+
+    intmat Gen=readNmzData("gen");
+
+    if(!nmz_files_keep_switch)
+    {
+        eraseTempNmzDataPath();
+    }
+
+    return(Gen);
+
+}
+
+proc normaliz(list #)
+"USAGE:   normaliz(intmat input_mat,string nmz_type);
+          normaliz(intmat input_mat, string nmz_type,  ...);
+RETURN:   The function applies Normaliz to the matrix input_mat ofe type nmz_type.
+          One can add further pairs "value, type" such as vectors or numerical
+          parameters. See Normaliz manual for possible types and values.
+          The function returns the intmat defined by the file ith suffix gen, provided it has been computed. Otherwise it returns the input_mat.
+NOTE:     You will find procedures for many applications of Normaliz in this
+          library, so the explicit call of this procedure may not be necessary.
+
+          The function reads the numerical invariants computed by normaliz. The integers among
+          them are converted to the Singular type int. It may to bee too small for
+          the Hilbert function or the multiplicity, especially if computed for a non-standard grading.
+          To prevent a disaster set the predefined global variable BigNumInvs = 1. Returnung to
+          BigNumInvs = 0 switches this feature off.
+SEE ALSO: intclToricRing, normalToricRing, ehrhartRing, intclMonIdeal,
+          torusInvariants, diagInvariants, finiteDiagInvariants, intersectionValRings,
+             intersectionValRingIdeals
+EXAMPLE:  example normaliz; shows an example
+"
+{
+    return(runNormaliz(#));
+}
+example
+{ "EXAMPLE:"; echo=2;
+  ring R=0,(x,y,z),dp;
+  intmat M[3][2]=3,1,
+                 3,2,
+                 1,3;
+  normaliz(M,"cone");
+  intmat Inequalities[2][3] = 2,-1,0, // 2x-y >= 0
+                             1, 1,0; //  x+y >= 0
+  intmat Equation[1][3] = 0,1,-1;    // y = z
+  intmat Congruence[1][4] = 1,0,0,3;  // x = 0 (3)
+  normaliz(Inequalities,"inequalities",Equation,"equations",Congruence,"congruences");
+}
+
+
+// retrieving normaliz numerical invariants
+
+static proc getNuminvs()
+{
+    string s;
+    list num_invs;
+    int p,sw,v_length,i,dummy_int;
+    bigint DummyInt;
+    intvec dummy_vec;
+    string type_inv,name_inv,dummy_bool;
+    int make_big_int;
+
+    link in_f=":r "+ getNmzFile() + "."+"inv";
+    s=read(in_f);
+
+    p=1;
+    while(p<size(s))
+    {
+        (sw,p)=nextWord(s,p);
+        if(sw==-1)
+        {
+            break;
+        }
+        type_inv=s[sw..p-1];
+        if(type_inv=="vector")
+        {
+            (v_length,p)=getInt(s,p);
+            (sw,p)=nextWord(s,p);
+            name_inv=s[sw..p-1];
+            if(name_inv=="h-vector")
+            {
+                name_inv="h_vector";
+            }
+            make_big_int = 0;
+            if(name_inv == "hilbert_series_num" || name_inv == "hilbert_series_cyclo_num"){
+                if(BigNumInvs){
+                    make_big_int = 1;
+                }
+            }
+              if(defined(DummyMat)==voice){
+                kill(DummyMat);
+            }
+            bigintmat DummyMat[1][v_length];
+            if(name_inv!="hilbert_polynomial"
+              && name_inv!="hilbert_quasipolynomial")
+            {
+                for(i=1;i<=v_length;i++)
+                {
+                    if(i==1 && !make_big_int)
+                    {
+                        if(!make_big_int){
+                            (dummy_int,p)=getInt(s,p);
+                            dummy_vec=dummy_int;
+                        }
+                    }
+                    else
+                    {
+                        if(!make_big_int){
+                            (dummy_int,p)=getInt(s,p);
+                            dummy_vec=dummy_vec,dummy_int;
+                        }
+                        else{
+                            (DummyInt,p) = getBigInt(s,p);
+                            DummyMat[1,i] = DummyInt;
+                        }
+                    }
+                }
+                if(!make_big_int){
+                    num_invs=num_invs+list(list(name_inv,dummy_vec,"intvec"));
+                }
+                else{
+                    num_invs=num_invs+list(list(name_inv,DummyMat,"bigintvec", v_length));
+                }
+            }
+            else
+            {
+                p=skipEqualsign(s,p);
+            }
+        }
+        if(type_inv=="integer")
+        {
+            (sw,p)=nextWord(s,p);
+            name_inv=s[sw..p-1];
+            if (name_inv!="hilbert_quasipolynomial_denom") {
+                if(!BigNumInvs || (name_inv != "multiplicity" && name_inv != "multiplicity_num" && name_inv != "multiplicity_denom")){
+                   (dummy_int,p)=getInt(s,p);
+                    num_invs=num_invs+list(list(name_inv,dummy_int,"int"));
+                }
+                else {
+                    (DummyInt,p)=getBigInt(s,p);
+                    num_invs=num_invs+list(list(name_inv,dummy_int,"bigint"));
+                }
+            }
+        }
+        if(type_inv=="boolean")
+        {
+            (sw,p)=nextWord(s,p);
+            name_inv=s[sw..p-1];
+            p=skipEqualsign(s,p);
+            (sw,p)=nextWord(s,p);
+            dummy_bool=s[sw..p-1];
+            dummy_int=0;
+            if(dummy_bool=="true")
+            {
+                dummy_int=1;
+            }
+            num_invs=num_invs+list(list(name_inv,dummy_int,"int"));
+        }
+    }
+    return(num_invs);
+}
+
+
+proc showNuminvs()
+"USAGE:   showNuminvs();
+PURPOSE:  prints the numerical invariants
+SEE ALSO: exportNuminvs
+EXAMPLE:  example showNuminvs(); shows an example
+"
+{
+    list dummy;
+    int i;
+    for(i=1;i<=size(Num_Invs);i++)
+    {
+        dummy=Num_Invs[i];
+        dummy[1],":", dummy[2];
+    }
+}
+example
+{ "EXAMPLE:"; echo=2;
+  ring R=0,(x,y,z,t),dp;
+  ideal I=x3,x2y,y3;
+  list l=intclMonIdeal(I);
+  showNuminvs();
+}
+
+
+proc exportNuminvs()
+"USAGE:   exportNuminvs();
+CREATE:   Creates top-level variables which contain the numerical invariants.
+          Depending on the options of normaliz different invariants are
+          calculated. Use showNuminvs (@ref{showNuminvs}) to see which
+          invariants are available.
+SEE ALSO: showNuminvs
+EXAMPLE:  example exportNuminvs; shows an example
+"
+{
+    list dummy;
+    int i;
+    string s;
+    for(i=1;i<=size(Exported_Num_Invs);i++)
+    {
+        dummy=Exported_Num_Invs[i];
+        s="kill  nmz_" + dummy[1];
+        execute(s);
+    }
+    for(i=1;i<=size(Num_Invs);i++)
+    {
+        dummy=Num_Invs[i];
+        if(dummy[3] != "bigintvec"){
+            s=dummy[3]+" nmz_" + dummy[1] + "=dummy[2]; exportto(Top," + "nmz_" + dummy[1] + ");";
+        }
+        else{
+            s = "bigintmat " + "nmz_" + dummy[1] + "[1][";
+            s = s + string(dummy[4]) + "]";
+            s = s + " = dummy[2];  exportto(Top," + "nmz_" + dummy[1] + ");";
+        }
+
+        execute(s);
+    }
+    Exported_Num_Invs = Num_Invs;
+}
+example
+{ "EXAMPLE:"; echo=2;
+  ring R=0,(x,y,z,t),dp;
+  ideal I=x3,x2y,y3;
+  list l=intclMonIdeal(I);
+  exportNuminvs();
+  // for example, now the following variables are set:
+  nmz_hilbert_basis_elements;
+  nmz_number_extreme_rays;
+  nmz_rank;
+  nmz_number_support_hyperplanes;
+  if (defined(nmz_multiplicity)) {nmz_multiplicity;}
+  else {nmz_multiplicity_num;}
+  nmz_primary;
+}
+
+
+// intmats to/from monomials
+
+proc mons2intmat(ideal I)
+"USAGE:   mons2intmat(ideal I);
+RETURN:   Returns the intmat whose rows represent the leading exponents of the
+          (non-zero) elements of I. The length of each row is nvars(basering).
+SEE ALSO: intmat2mons
+EXAMPLE:  example mons2intmat; shows an example"
+{
+    int i,j,k;
+    intmat expo_vecs[size(I)][nvars(basering)];
+    intvec expo_v;
+
+    k=0;
+    for(i=1;i<=ncols(I);i++)
+    {
+        if(I[i]!=0)
+        {
+            k++;
+            expo_v=leadexp(I[i]);
+            for(j=1;j<=nvars(basering);j++)
+            {
+                expo_vecs[k,j]=expo_v[j];
+            }
+        }
+    }
+    return(expo_vecs);
+}
+example
+{ "EXAMPLE:"; echo=2;
+  ring R=0,(x,y,z),dp;
+  ideal I=x2,y2,x2yz3;
+  mons2intmat(I);
+}
+
+proc intmat2mons(intmat expo_vecs)
+"USAGE:   intmat2mons(intmat M);
+RETURN:   an ideal generated by the monomials which correspond to the exponent
+          vectors given by the rows of @code{M}
+NOTE:     The number of variables in the basering @code{nvars(basering)} has to
+          be at least the number of columns @code{ncols(M)}, otherwise the
+          function exits with an error.
+          is thrown (see @ref{ERROR}).
+SEE ALSO: mons2intmat
+EXAMPLE:  example intmat2mons; shows an example
+"
+{
+    int i,j;
+    poly m;
+    ideal mons;
+
+    if(nvars(basering)<ncols(expo_vecs))
+    {
+        ERROR("intmat2mons: not enough variables in ring");
+    }
+
+    for(i=1;i<=nrows(expo_vecs);i++)
+    {
+        m=1;
+        for(j=1;j<=ncols(expo_vecs);j++)
+        {
+            m=m*var(j)^expo_vecs[i,j];
+        }
+        mons=mons,m;
+    }
+     mons=simplify(mons,2);    // get rid of starting 0
+     return(mons);
+}
+example
+{ "EXAMPLE:"; echo=2;
+  ring R=0,(x,y,z),dp;
+  intmat expo_vecs[3][3] =
+  2,0,0,
+  0,2,0,
+  2,1,3;
+  intmat2mons(expo_vecs);
+}
+
+static proc intmat2monsSel(intmat expo_vecs, int d)
+{
+    int i,j;
+    poly m;
+    ideal mons;
+
+    if(nvars(basering)<ncols(expo_vecs)-1)
+    {
+        ERROR("intmat2monsSel: not enough variables in ring");
+    }
+
+    for(i=1;i<=nrows(expo_vecs);i++)
+    {
+        if(expo_vecs[i,ncols(expo_vecs)]==d)
+        {
+            m=1;
+            for(j=1;j<=ncols(expo_vecs)-1;j++)
+            {
+                m=m*var(j)^expo_vecs[i,j];
+            }
+            mons=mons,m;
+        }
+    }
+    mons=simplify(mons,2);    // get rid of starting 0
+    return(mons);
+}
+
+
+proc binomials2intmat(ideal I)
+"USAGE:   binomials2intmat(ideal I);
+RETURN:   Returns the intmat whose rows represent the exponents of the
+          (non-zero) elements of I which have to be binomials.
+          The length of each row is nvars(basering).
+SEE ALSO: intmat2binomials, mons2intmat, intmat2mons
+EXAMPLE:  example binomials2intmat; shows an example"
+{
+    int i,j,k;
+    intmat expo_vecs[size(I)][nvars(basering)];
+    intvec expo_v;
+
+    k=0;
+    poly f;
+
+    for(i=1; i<=ncols(I); i++)
+    {
+        if( I[i] != 0 )
+        {
+            k++;
+            f = I[i];
+            if (leadcoef(f) != 1) {f = -f;}  //works in all characteristics
+            if (size(f)!=2 || leadcoef(f)!=1 || leadcoef(f[2])!=-1)
+            {
+                ERROR(string("normalToricRing: binomial ideal expected: generator ",i,": ",I[i]));
+            }
+
+            expo_v = leadexp(f)-leadexp(f[2]);
+            for(j=1;j<=nvars(basering);j++)
+            {
+                expo_vecs[k,j]=expo_v[j];
+            }
+        }
+    }
+    return(expo_vecs);
+}
+example
+{ "EXAMPLE:"; echo=2;
+  ring S = 37,(u,v,w,x,y,z),dp;
+  ideal I = u2v-xyz, ux2-vyz, uvw-y2z;
+  binomials2intmat(I);
+}
+
+proc intmat2binomials(intmat expo_vecs)
+"USAGE:   intmat2binomials(intmat M);
+RETURN:   an ideal generated by the binomials which correspond to the exponent
+          vectors given by the rows of @code{M}
+NOTE:     The number of variables in the basering @code{nvars(basering)} has to
+          be at least the number of columns @code{ncols(M)}, otherwise the
+          function exits with an error is thrown (see @ref{ERROR}).
+          The vector with all entries zero represents 1.
+SEE ALSO: binomials2intmat
+EXAMPLE:  example intmat2binomials; shows an example"
+{
+    int i,j;
+    poly f,g;
+    ideal binoms;
+    // expo_vecs;
+
+    if(nvars(basering)<ncols(expo_vecs))
+    {
+        ERROR("intmat2binomilals: not enough variables in ring");
+    }
+
+    for(i=1;i<=nrows(expo_vecs);i++)
+    {
+        f=1;
+        g=1;
+        for(j=1;j<=ncols(expo_vecs);j++)
+        {
+            if(expo_vecs[i,j]>0)
+            {
+                f=f*var(j)^expo_vecs[i,j];
+            }
+            if(expo_vecs[i,j]<0)
+            {
+                g=g*var(j)^(-expo_vecs[i,j]);
+            }
+        }
+        binoms=binoms,f-g;
+    }
+    binoms = simplify(binoms,2);  // get rid of starting 0
+    return(binoms);
+}
+example
+{ "EXAMPLE:"; echo=2;
+  ring S = 37,(u,v,w,x,y,z),dp;
+  intmat M[2][6] = 1,0,1,-1,-2,0,  -3,4,5,0,0,1;
+  intmat2binomials(M);
+}
+
+// integral closure of rings and ideals
+
+static proc runIntclToricRing(ideal I, string nmz_type, list #)
+{
+    intmat expo_vecs=mons2intmat(I);
+    return( intmat2mons( runNormaliz(expo_vecs,nmz_type, prepareGrading(#)) ) );
+}
+
+proc intclToricRing(ideal I, list #)
+"USAGE:   intclToricRing(ideal I);
+          intclToricRing(ideal I, intvec grading);
+RETURN:   The toric ring S is the subalgebra of the basering generated by
+          the leading monomials of the elements of I (considered as a list
+          of polynomials). The function computes the integral
+          closure T of S in the basering and returns an ideal listing
+          the algebra generators of T over the coefficient field.
+@*        The function returns the input ideal I if an option
+          blocking the computation of Hilbert bases has been activated.
+          However, in this case some numerical invariants are computed, and
+          some other data may be contained in files that you can read into
+          Singular (see @ref{showNuminvs}, @ref{exportNuminvs}).
+NOTE:     A mathematical remark: the toric ring depends on the list of
+          monomials given, and not only on the ideal they generate!
+SEE ALSO:  normalToricRing, ehrhartRing, intclMonIdeal
+EXAMPLE:   example intclToricRing; shows an example
+"
+{
+    return(runIntclToricRing(I,"cone",#));
+}
+example
+{ "EXAMPLE:"; echo=2;
+  ring R=37,(x,y,t),dp;
+  ideal I=x3,x2y,y3;
+  intclToricRing(I);
+  showNuminvs();
+  //now the same example with another grading
+  intvec grading = 2,3,1;
+  intclToricRing(I,grading);
+  showNuminvs();
+
+}
+
+proc normalToricRing(ideal I, list #)
+"USAGE:   normalToricRing(ideal I);
+          normalToricRing(ideal I, intvec grading);
+RETURN:   The toric ring S is the subalgebra of the basering generated by the
+          leading monomials of the elements of I (considered as a list of
+          polynomials). The function computes the
+          normalisation T of S and returns an ideal listing the algebra
+          generators of T over the coefficient field.
+@*        The function returns the input ideal I if one of the options
+          blocking the computation of Hilbert bases has been activated.
+          However, in this case some numerical invariants are computed, and
+          some other data may be contained in files that you can read into
+          Singular (see @ref{showNuminvs}, @ref{exportNuminvs}).
+NOTE:     A mathematical remark: the toric ring depends on the list of
+          monomials given, and not only on the ideal they generate!
+SEE ALSO: toricRingFromBinomials, intclToricRing, ehrhartRing, intclMonIdeal, normalToricRingFromBinomials
+EXAMPLE:  example normalToricRing; shows an example
+"
+{
+    return(runIntclToricRing(I,"cone_and_lattice",#));
+}
+example
+{ "EXAMPLE:"; echo=2;
+  ring  R = 37,(x,y,t),dp;
+  ideal I = x3,x2y,y3;
+  normalToricRing(I);
+}
+
+proc hilbertSeriesToricRing(ideal I, list #)
+"USAGE:   hilbertSeriesToricRing(ideal I);
+          hilbertSeriesToricRing(ideal I, intvec grading);
+RETURN:   The toric ring is the subalgebra of the ring generated by the
+          leading monomials of the elements of I (considered as a list of
+          polynomials). The function computes the Hilbert series of the toric
+          ring with respect to the grading. It assumes the standard grading on
+          the ambient polynomial ring is none is given explicitly.
+          The grading is normalized, i.e. diided by the gcd of the degrees of the
+          generators.
+          The return value is the pair of numerator polynomial encoded as an
+          intvec and the denomionator, also encoded as an intvec, whose components
+          e stand nfor the factors (1-t^e) of the denominator,
+NOTE:     A mathematical remark: the toric ring depends on the list of
+          monomials given, and not only on the ideal they generate!
+SEE ALSO: toricRingFromBinomials, normalToricRing, intclToricRing
+"
+EXAMPLE:  example hilbertSeriesToricRing; shows an example
+{
+    intmat U = mons2intmat(I);
+    int swallow = setNmzOption("only_hvect",1);
+    intmat Dummy = runNormaliz(U,"monoid", prepareGrading(#));
+    swallow = setNmzOption("only_hvect",0);
+    exportNuminvs();
+    return(nmz_hilbert_series_num,nmz_hilbert_series_denom);
+}
+example
+{ "EXAMPLE:"; echo=2;
+  ring  R = 37,(x,y),dp;
+  ideal I = x3, x2y,y3;
+  intvec hilb_num, hilb_denom;
+  (hilb_num, hilb_denom) = hilbertSeriesToricRing(I);
+  "num", hilb_num, " denom",hilb_denom;
+}
+
+proc normalToricRingFromBinomials(ideal I, list #)
+"USAGE:   normalToricRingFromBinomials(ideal I);
+          normalToricRingFromBinomials(ideal I, intvec grading);
+RETURN:   @texinfo
+@tex
+The ideal $I$ is generated by binomials of type $X^a-X^b$ (multiindex notation)
+in the surrounding polynomial ring $K[X]=K[X_1,...,X_n]$. The binomials
+represent a congruence on the monoid ${Z}^n$ with residue monoid $M$.
+Let $N$ be the image of $M$ in gp($M$)/torsion. Then $N$ is universal in the
+sense that every homomorphism from $M$ to an affine monoid factors through $N$.
+If $I$ is a prime ideal, then $K[N]= K[X]/I$. In general, $K[N]=K[X]/P$ where
+$P$ is the unique minimal prime ideal of $I$ generated by binomials of type
+$X^a-X^b$.
+
+The function computes the normalization of $K[N]$ and returns a newly created
+polynomial ring of the same Krull dimension, whose variables are
+$x(1),...,x(n-r)$, where $r$ is the rank of the matrix with rows $a-b$.
+(In general there is no canonical choice for such an embedding.)
+Inside this polynomial ring there is an ideal $I$ which lists the algebra
+generators of the normalization of $K[N]$.
+@end tex
+@end texinfo
+@*        The function returns the input ideal I if an option blocking
+          the computation of Hilbert bases has been activated.
+          However, in this case some numerical invariants are computed, and
+          some other data may be contained in files that you can read into
+          Singular (see @ref{showNuminvs}, @ref{exportNuminvs}).
+SEE ALSO: intclToricRing, normalToricRing, ehrhartRing, intclMonIdeal
+EXAMPLE:  example normalToricRing; shows an example
+"
+{
+    intmat expo_vecs = binomials2intmat(I);
+    intmat result = runNormaliz(expo_vecs,"normal_toric_ideal",prepareGrading(#));
+
+    list baseringlist = ringlist(basering);
+    ring S = (baseringlist[1]),(x(1..ncols(result))),dp;
+    ideal I = intmat2mons(result);
+    export(I);
+    return (S);
+}
+example
+{ "EXAMPLE:"; echo=2;
+  ring R = 37,(u,v,w,x,y,z),dp;
+  ideal I = u2v-xyz, ux2-wyz, uvw-y2z;
+  def S = normalToricRingFromBinomials(I);
+  setring S;
+  I;
+}
+
+proc toricRingFromBinomials(ideal I, list #)
+"USAGE:   toricRingFromBinomials(ideal I);
+          toricRingFromBinomials(ideal I, intvec grading);
+RETURN:   @texinfo
+@tex
+The ideal $I$ is generated by binomials of type $X^a-X^b$ (multiindex notation)
+in the surrounding polynomial ring $K[X]=K[X_1,...,X_n]$. The binomials
+represent a congruence on the monoid ${Z}^n$ with residue monoid $M$.
+Let $N$ be the image of $M$ in gp($M$)/torsion. Then $N$ is universal in the
+sense that every homomorphism from $M$ to an affine monoid factors through $N$.
+If $I$ is a prime ideal, then $K[N]= K[X]/I$. In general, $K[N]=K[X]/P$ where
+$P$ is the unique minimal prime ideal of $I$ generated by binomials of type
+$X^a-X^b$.
+
+The function computes $K[N]$ and returns a newly created
+polynomial ring of the same Krull dimension, whose variables are
+$x(1),...,x(n-r)$, where $r$ is the rank of the matrix with rows $a-b$.
+(In general there is no canonical choice for such an embedding.)
+@end tex
+@end texinfo
+@*        The function returns the input ideal I if an option blocking
+          the computation of Hilbert bases has been activated.
+          However, in this case some numerical invariants are computed, and
+          some other data may be contained in files that you can read into
+          Singular (see @ref{showNuminvs}, @ref{exportNuminvs}).
+SEE ALSO: toricRingFromBinomials, normalToricRingFromBinomials
+EXAMPLE:  example normalToricRing; shows an example"
+{
+    intmat expo_vecs = binomials2intmat(I);
+    intmat result = runNormaliz(expo_vecs,"toric_ideal",prepareGrading(#));
+
+    list baseringlist = ringlist(basering);
+    ring S = (baseringlist[1]),(x(1..ncols(result))),dp;
+    ideal I = intmat2mons(result);
+    export(I);
+    return (S);
+}
+example
+{ "EXAMPLE:"; echo=2;
+  ring R = 37,(u,v,w,x,y,z),dp;
+  ideal I = u2v-xyz, ux2-wyz, uvw-y2z;
+  def S = toricRingFromBinomials(I);
+  setring S;
+  I;
+}
+
+proc definingBinomialIdeal(ideal I)
+"USAGE:   definingBinomialIdeal(ideal I);
+RETURN:   The toric ring S is the subalgebra of the basering generated by the
+          leading monomials of the elements of I (considered as a list of
+          polynomials). The function computes the computes the definig binomial
+          ideal J of S with respect to the generators and returns it, together with
+          J. DSee eample.
+NOTE:     A mathematical remark: the toric ring depends on the list of
+          monomials given, and not only on the ideal they generate!
+          This function requires the previous setting of an NmzFilename.
+          The function does not delete the written files.
+SEE ALSO: normalToricRingFromBinomials
+EXAMPLE:  example definingBinomialIdeal; shows an example"
+{
+    if(!nmz_files_keep_switch){
+        ERROR("definingBinomialIdeal requires a filename");
+    }
+    setNmzOption("markov",1);
+    intmat Dummy = normaliz(mons2intmat(I), "monoid");
+    setNmzOption("markov",0);
+    intmat bin = readNmzData("mrk");
+    list baseringlist = ringlist(basering);
+    ring S = (baseringlist[1]),(x(1..ncols(bin))),dp;
+    ideal J = intmat2binomials(bin);
+    export(J);
+    return(S);
+}
+example
+{ "EXAMPLE:"; echo=2;
+    ring R = 37,(x,y,z,w),dp;
+    ideal I = x4,x3y,x2y2,xy3,y4;
+    setNmzFilename("binomials");
+    def S = definingBinomialIdeal(I);
+    setring S;
+    J;
+}
+
+
+proc latticeIdeal(ideal I)
+"USAGE:   latticeIdeal(ideal I);
+RETURN:   Returns the lattice ideal defined by the elements of I
+          which have to be binomials. The lattice ideal is
+          the restriction to the polynomial ring of the ideal of
+          the Laurent polynomial ring generated by I
+NOTE:     This function requires the previous setting of an NmzFilename.
+          The function does not delete the written files.
+SEE ALSO: intmat2binomials
+EXAMPLE:  example latticeIdeal; shows an example
+"
+{
+    if(!nmz_files_keep_switch){
+        ERROR("latticeIdeal requires a filename");
+    }
+    intmat B = binomials2intmat(I);
+    setNmzOption("markov",1);
+    intmat Dummy = normaliz(B, "lattice_ideal");
+    setNmzOption("markov",0);
+    intmat bin = readNmzData("mrk");
+    return(intmat2binomials(bin));
+}
+example
+{ "EXAMPLE:"; echo=2;
+  setNmzFilename("binomials");
+  ring S = 37,(u,v,w,x,y,z),dp;
+  ideal I = u2-v2, x2-y2, y2-vw, z2-xy;
+  latticeIdeal(I);
+}
+
+proc groebnerBasis(ideal I)
+"USAGE:   groebnerBasis(ideal I);
+RETURN:   Returns a Gr\"obner basis of the lattice ideal defined by the
+          elements of I  which have to be binomials. The lattice ideal is
+          the restriction to the polynomial ring of the ideal of
+          the Laurent polynomial ring generated by I. The default monomial
+          order is DegRevLex where Deg is the total degree on the ambient
+          polynomial ring. Lex and DegLex orders can be chosen via options.
+NOTE:     This function requires the previous setting of an NmzFilename.
+          The function does not delete the written files.
+SEE ALSO: latticeIdeal
+EXAMPLE:  example groebnerBasis; shows an example"
+{
+
+    if(!nmz_files_keep_switch){
+        ERROR("groebnerBasis requires a filename");
+    }
+    intmat B = binomials2intmat(I);
+    int swallow = setNmzOption("groebner",1);
+    intmat Dummy = normaliz(B, "lattice_ideal");
+    swallow = setNmzOption("groebner",0);
+    intmat bin = readNmzData("grb");
+    return(intmat2binomials(bin));
+}
+example
+{ "EXAMPLE:"; echo=2;
+  setNmzFilename("binomials");
+  ring S = 37,(u,v,w,x,y,z),dp;
+  ideal I = u2-v2, x2-y2, y2-vw, z2-xy;
+  groebnerBasis(I);
+  setNmzOption("lex",1);
+  groebnerBasis(I);
+  setNmzOption("lex",0);
+}
+
+static proc runIntclMonIdeal(ideal I, string nmz_type, list #)
+{
+    intmat expo_vecs=mons2intmat(I);
+    int i,last_comp;
+
+    // we test if there is room for the Rees algebra
+
+    for(i=1;i<=nrows(expo_vecs);i++)
+    {
+        if(expo_vecs[i,ncols(expo_vecs)]!=0)
+        {
+            last_comp=1;  break; // no
+        }
+    }
+
+    //adjust size of input matrix
+    if (!last_comp) { // remove last component
+        intmat tmp[nrows(expo_vecs)][ncols(expo_vecs)-1]
+               = expo_vecs[1..nrows(expo_vecs),1..(ncols(expo_vecs)-1)];
+        expo_vecs = tmp;
+    }
+    intmat nmz_data=runNormaliz(expo_vecs,nmz_type,prepareGrading(#));
+
+    if(last_comp)
+    {
+        ideal I1=intmat2monsSel(nmz_data,1);
+        return(list(I1));
+    }
+    else
+    {
+        ideal I1=intmat2monsSel(nmz_data,1);
+        ideal I2=intmat2mons(nmz_data);
+        return(list(I1,I2));
+    }
+}
+
+proc ehrhartRing(ideal I)
+"USAGE:    ehrhartRing(ideal I);
+RETURN:    The exponent vectors of the leading monomials of the elements of I
+           are considered as points of a lattice polytope P.
+           The Ehrhart ring of a (lattice) polytope P is the monoid algebra
+           defined by the monoid of lattice points in the cone over the
+           polytope P; see Bruns and Gubeladze, Polytopes, Rings, and K-theory,
+           Springer 2009, pp. 228, 229.
+           The function returns a list of ideals:
+@*         (i) If the last ring variable is not used by the monomials, it is
+               treated as the auxiliary variable of the Ehrhart ring. The
+               function returns two ideals, the first containing the monomials
+               representing all the lattice points of the polytope, the second
+               containing the algebra generators of the Ehrhart ring over the
+               coefficient field.
+@*         (ii) If the last ring variable is used by the monomials, the list
+                returned contains only one ideal, namely the monomials
+                representing the lattice points of the polytope.
+@*
+@*        The function returns the a list containing the input ideal I if
+          an option blocking the computation of the Hilbert basis has been activated.
+          However, in this case some numerical invariants are computed, and
+          some other data may be contained in files that you can read into
+          Singular (see @ref{showNuminvs}, @ref{exportNuminvs}).
+NOTE:      A mathematical remark: the Ehrhart ring depends on the list of
+           monomials given, and not only on the ideal they generate!
+SEE ALSO: intclToricRing, normalToricRing, intclMonIdeal
+EXAMPLE:  example ehrhartRing; shows an example
+"
+{
+    return(runIntclMonIdeal(I,"polytope"));
+}
+example
+{ "EXAMPLE:"; echo=2;
+  ring R=37,(x,y,t),dp;
+  ideal J=x3,x2y,y3,xy2t7;
+  ehrhartRing(J);
+}
+
+proc intclMonIdeal(ideal I, list #)
+"USAGE:   intclMonIdeal(ideal I);
+          intclMonIdeal(ideal I, intvec grading);
+RETURN:   The exponent vectors of the leading monomials of the elements of I
+          are considered as generators of a monomial ideal for which the
+          normalization of its Rees algebra is computed. For a Definition of the
+          Rees algebra (or Rees ring) see Bruns and Herzog, Cohen-Macaulay
+          rings, Cambridge University Press 1998, p. 182.
+          The function returns a list of ideals:
+@* (i) If the last ring variable is not used by the monomials, it is treated
+       as the auxiliary variable of the Rees algebra. The function returns two
+       ideals, the first containing the monomials generating the integral
+       closure of the monomial ideal, the second containing the algebra
+         generators of the normalization of the Rees algebra.
+@* (ii) If the last ring variable is used by the monomials, the list returned
+        contains only one ideal, namely the monomials generating the integral
+        closure of the ideal.
+@*        The function returns the a list containing the input ideal I if an option
+          blocking the computation of Hilbert bases has been activated.
+          However, in this case some numerical invariants are computed, and
+          some other data may be contained in files that you can read into
+          Singular (see @ref{showNuminvs}, @ref{exportNuminvs}).
+SEE ALSO: intclToricRing, normalToricRing, ehrhartRing
+EXAMPLE:  example intclMonIdeal; shows an example
+"
+{
+    return(runIntclMonIdeal(I,"rees_algebra",#));
+}
+example
+{ "EXAMPLE:"; echo=2;
+    ring R=0,(x,y,z,t),dp;
+    ideal I=x^2,y^2,z^3;
+    list l=intclMonIdeal(I);
+    l[1]; // integral closure of I
+    l[2];  // monomials generating the integral closure of the Rees algebra
+}
+
+// torus invariants and valuation rings and ideals
+
+proc torusInvariants(intmat E, list #)
+"USAGE:   torusInvariants(intmat A);
+          torusInvariants(intmat A, intvec grading);
+RETURN:   @texinfo
+Returns an ideal representing the list of monomials generating the ring of
+invariants as an algebra over the coefficient field.
+@tex
+$R^T$.
+@end tex
+@*        The function returns the ideal given by the input matrix A if one of
+          the options @code{supp}, @code{triang}, @code{volume}, or
+          @code{hseries} has been activated.
+          However, in this case some numerical invariants are computed, and
+          some other data may be contained in files that you can read into
+          Singular (see @ref{showNuminvs}, @ref{exportNuminvs}).
+@end texinfo
+BACKGROUND: @texinfo
+@tex
+ Let $T = (K^*)^r$ be the $r$-dimensional torus acting on the polynomial ring
+ $R = K[X_1 ,\ldots,X_n]$ diagonally. Such an action can be described as
+ follows: there are integers $a_{i,j}$, $i=1,\ldots,r$, $j=1,\ldots,n$, such
+ that $(\lambda_1,\ldots,\lambda_r)\in T$ acts by the substitution
+$$ X_j \mapsto \lambda_1^{a_{1,j}} \cdots \lambda_r^{a_{r,j}}X_j,
+   \quad j=1,\ldots,n.$$
+In order to compute the ring of invariants $R^T$ one must specify the matrix
+$A=(a_{i,j})$.
+@end tex
+@end texinfo
+SEE ALSO: diagInvariants, finiteDiagInvariants, intersectionValRings,
+          intersectionValRingIdeals
+EXAMPLE:  example torusInvariants; shows an example
+"
+{
+    if(nvars(basering)!=ncols(E))
+    {
+        ERROR("torusInvariants: wrong number of columns in matrix");
+    }
+    return( intmat2mons( runNormaliz(E,"equations",prepareGrading(#)) ) );
+}
+example
+{ "EXAMPLE:"; echo=2;
+  ring R=0,(x,y,z,w),dp;
+  intmat E[2][4] = -1,-1,2,0, 1,1,-2,-1;
+  torusInvariants(E);
+}
+
+proc finiteDiagInvariants(intmat C, list #)
+"USAGE:   finiteDiagInvariants(intmat U);
+          finiteDiagInvariants(intmat U, intvec grading);
+RETURN:   @texinfo
+@tex
+This function computes the ring of invariants of a finite abelian group $G$
+acting diagonally on the surrounding polynomial ring $K[X_1,...,X_n]$. The
+group is the direct product of cyclic groups generated by finitely many
+elements $g_1,...,g_w$. The element $g_i$ acts on the indeterminate $X_j$ by
+$g_i(X_j)=\lambda_i^{u_{ij}}X_j$ where $\lambda_i$ is a primitive root of
+unity of order equal to $ord(g_i)$. The ring of invariants is generated by all
+monomials satisfying the system
+$u_{i1}a_1+\ldots+u_{in} a_n \equiv 0$ mod ord$(g_i)$, $i=1,\ldots,w$.
+The input to the function is the $w\times(n+1)$ matrix $U$ with rows
+$u_{i1}\ldots u_{in}$ ord$(gi)$, $i=1,\ldots,w$. The output is a monomial ideal
+listing the algebra generators of the subalgebra of invariants
+{$R^G=\{f\in R : g_i f = f$ for all $i=1,\ldots,w\}$}.
+@end tex
+@end texinfo
+@*        The function returns the ideal given by the input matrix C if one of
+          the options @code{supp}, @code{triang}, @code{volume}, or
+          @code{hseries} has been activated.
+          However, in this case some numerical invariants are computed, and
+          some other data may be contained in files that you can read into
+          Singular (see @ref{showNuminvs}, @ref{exportNuminvs}).
+NOTE:
+SEE ALSO: torusInvariants, diagInvariants, intersectionValRings,
+          intersectionValRingIdeals
+EXAMPLE:  example finiteDiagInvariants; shows an example
+"
+{
+    if(nvars(basering)!=ncols(C)-1)
+    {
+        ERROR("finiteDiagInvariants: wrong number of columns in matrix");
+    }
+    return( intmat2mons( runNormaliz(C,"congruences",prepareGrading(#)) ) );
+}
+example
+{ "EXAMPLE:"; echo=2;
+  ring R = 0,(x,y,z,w),dp;
+  intmat C[2][5] = 1,1,1,1,5, 1,0,2,0,7;
+  finiteDiagInvariants(C);
+}
+
+proc diagInvariants(intmat E, intmat C, list #)
+"USAGE:   diagInvariants(intmat A, intmat U);
+          diagInvariants(intmat A, intmat U, intvec grading);
+RETURN:   @texinfo
+@tex
+This function computes the ring of invariants of a diagonalizable group
+$D = T\times G$ where $T$ is a torus and $G$ is a finite abelian group, both
+acting diagonally on the polynomial ring $K[X_1,\ldots,X_n]$. The group
+actions are specified by the input matrices A and U. The first matrix specifies
+the torus action, the second the action of the finite group. See
+torusInvariants and finiteDiagInvariants for more detail. The output is a
+monomial ideal listing the algebra generators of the subalgebra of invariants.
+@end tex
+@end texinfo
+@*        The function returns the ideal given by the input matrix A if one of
+          the options @code{supp}, @code{triang}, @code{volume}, or
+          @code{hseries} has been activated.
+          However, in this case some numerical invariants are computed, and
+          some other data may be contained in files that you can read into
+          Singular (see @ref{showNuminvs}, @ref{exportNuminvs}).
+SEE ALSO: torusInvariants, finiteDiagInvariants, intersectionValRings, intersectionValRingIdeals
+EXAMPLE:  example diagInvariants; shows an example
+"
+{
+    if(nvars(basering)!=ncols(E) || nvars(basering)!=ncols(C)-1)
+    {
+        ERROR("diagInvariants: wrong number of columns in matrix");
+    }
+    return( intmat2mons( runNormaliz(E,"equations",C,"congruences",prepareGrading(#)) ) );
+}
+example
+{ "EXAMPLE:"; echo=2;
+  ring R=0,(x,y,z,w),dp;
+  intmat E[2][4] = -1,-1,2,0, 1,1,-2,-1;
+  intmat C[2][5] = 1,1,1,1,5, 1,0,2,0,7;
+  diagInvariants(E,C);
+}
+
+proc intersectionValRings(intmat V, list #)
+"USAGE:   intersectionValRings(intmat V, intvec grading);
+RETURN:   The function returns a monomial ideal, to be considered as the list
+          of monomials generating @math{S} as an algebra over the coefficient
+          field.
+BACKGROUND: @texinfo
+@tex
+A discrete monomial valuation $v$ on $R = K[X_1 ,\ldots,X_n]$ is determined by
+the values $v(X_j)$ of the indeterminates. This function computes the
+subalgebra $S = \{ f \in R : v_i ( f ) \geq 0,\ i = 1,\ldots,r\}$ for several
+such valuations $v_i$, $i=1,\ldots,r$. It needs the matrix $V = (v_i(X_j))$ as
+its input.
+@end tex
+@end texinfo
+@*        The function returns the ideal given by the input matrix V if one of
+          the options @code{supp}, @code{triang}, @code{volume}, or
+          @code{hseries} has been activated.
+          However, in this case some numerical invariants are computed, and
+          some other data may be contained in files that you can read into
+          Singular (see @ref{showNuminvs}, @ref{exportNuminvs}).
+SEE ALSO: torusInvariants, diagInvariants, finiteDiagInvariants, intersectionValRingIdeals
+EXAMPLE:  example intersectionValRings; shows an example
+"
+{
+
+    if(nvars(basering)!=ncols(V))
+    {
+        ERROR("intersectionValRings: wrong number of columns in matrix");
+    }
+
+    intmat V1[nrows(V)+ncols(V)][ncols(V)];
+    int i,j;
+
+    for(i=1;i<=ncols(V);i++)
+    {
+        V1[i,i]=1;
+    }
+    for(i=1;i<=nrows(V);i++)
+    {
+        for(j=1;j<=ncols(V);j++)
+        {
+            V1[i+ncols(V),j]=V[i,j];
+        }
+    }
+
+/*    if(!GenGen) // return V
+    {
+        runNormaliz(V1,4,prepareGrading(#));
+        return(V);
+    }
+*/
+    return(intmat2mons(runNormaliz(V1,"inequalities",prepareGrading(#))));
+}
+example
+{ "EXAMPLE:"; echo=2;
+  ring R=0,(x,y,z,w),dp;
+  intmat V0[2][4]=0,1,2,3, -1,1,2,1;
+  intersectionValRings(V0);
+}
+
+proc intersectionValRingIdeals(intmat V, list #)
+"USAGE:   intersectionValRingIdeals(intmat V);
+          intersectionValRingIdeals(intmat V, intvec grading);
+RETURN:   The function returns two ideals, both to be considered as lists of
+          monomials. The
+          first is the system of monomial generators of @math{S}, the second
+          the system of generators of @math{M}.
+@*        The function returns a list consisting of the ideal given by the
+          blocking the computation of Hilbert bases has been activated.
+          However, in this case some numerical invariants are computed, and
+          some other data may be contained in files that you can read into
+          Singular (see @ref{showNuminvs}, @ref{exportNuminvs}).
+BACKGROUND: @texinfo
+@tex
+A discrete monomial valuation $v$ on $R = K[X_1 ,\ldots,X_n]$ is determined by
+the values $v(X_j)$ of the indeterminates. This function computes the
+subalgebra $S = \{ f \in R : v_i ( f ) \geq 0,\ i = 1,\ldots,r\}$ for several
+such valuations $v_i$, $i=1,\ldots,r$. It needs the matrix $V = (v_i(X_j))$ as
+its input.
+
+This function simultaneously determines the $S$-submodule
+$M = \{ f \in R : v_i(f) \geq w_i ,\ i = 1,\ldots,r\}$ for integers
+$w_1,\ldots\,w_r$. (If $w_i \geq 0$ for all $i$, $M$ is an ideal of $S$.)
+The numbers $w_i$ form the $(n+1)$th column of the input matrix.
+@end tex
+@end texinfo
+NOTE:   The function also gives an error message if the matrix V has the
+        wrong number of columns.
+SEE ALSO: torusInvariants, diagInvariants, finiteDiagInvariants, intersectionValRings
+EXAMPLE:  example intersectionValRingIdeals; shows an example
+"
+{
+    if(nvars(basering)!=ncols(V)-1)
+    {
+        ERROR("intersectionValRingIdeals: wrong number of columns in matrix");
+    }
+
+    intmat V1[nrows(V)+ncols(V)][ncols(V)];
+    int i,j;
+
+    for(i=1;i<=ncols(V);i++)
+    {
+        V1[i,i]=1;
+    }
+    for(i=1;i<=nrows(V);i++)
+    {
+        for(j=1;j<=ncols(V);j++)
+        {
+            V1[i+ncols(V),j]=V[i,j];
+        }
+    }
+    for(i=1;i<=nrows(V);i++)
+    {
+        V1[i+ncols(V),ncols(V)]=-V1[i+ncols(V),ncols(V)];
+    }
+
+    intmat nmz_data=runNormaliz(V1,"inequalities",prepareGrading(#));
+    ideal I1=intmat2monsSel(nmz_data,0);
+    ideal I2=intmat2monsSel(nmz_data,1);
+    return(list(I1,I2));
+}
+example
+{ "EXAMPLE:"; echo=2;
+ ring R=0,(x,y,z,w),dp;
+ intmat V[2][5]=0,1,2,3,4, -1,1,2,1,3;
+ intersectionValRingIdeals(V);
+}
+
+proc allNmzOptions()
+"USAGE:   proc alNmzOptions();
+PURPOSE:  The function prints a list of the Normaliz options that
+          are available in this library: the string naming the option,
+          the default value, and the option sent to Normaliz.
+SEE ALSO: setNmzOption, showNmzOptions
+EXAMPLE:  example allNmzOptions; shows an example
+"
+{
+    for(int i=1;i<=size(nmz_options);i++){
+        if(size(nmz_options[i]) == 3){
+            nmz_options[i][1], nmz_options[i][2], nmz_options[i][3];
+        }
+        else{
+            nmz_options[i][1], nmz_options[i][2], nmz_options[i][3], nmz_options[i][4] ;
+        }
+    }
+    " ";
+}
+example
+{ "EXAMPLE:"; echo=2;
+    allNmzOptions();
+}
+
+static proc mod_init()
+{
+  string nmz_exec_path; export nmz_exec_path;
+  string nmz_filename; export nmz_filename;
+  int nmz_files_keep_switch;export nmz_files_keep_switch;
+  string nmz_data_path; export nmz_data_path;
+  // int GenGen=1; export GenGen; // indicates whether "gen" is generated // no longer used
+  list Num_Invs; export Num_Invs;
+  list Exported_Num_Invs; export Exported_Num_Invs;
+
+// options for running normaliz
+//
+// component 1 is name of option
+// 2 is default value
+// 3 is command line option to be passed to Normaliz
+// 4 is a potential comment pointing to better use
+
+  list nmz_options=
+        list("supp",0,"-s"),
+        list("triang",0,"-T"),
+        list("volume",0,"-v"),
+        list("hvect",0,"-p"," -- name deprecated, use hvect_deg1"),
+        list("hvect_deg1",0, "-p"),
+        list("only_hvect",0,"-q"),
+        list("fvect",0,"--FVector"),
+        list("height1",0,"-1"),
+        list("Gorenst",0,"-G"),
+        list("intclosed",0,"--IsIntegrallyClosed"),
+        list("witness",0,"--w"),
+        list("classgroup",0,"-C"),
+        list("normal",0,"-n"," -- name deprecated, use hilbbasvol"),
+        list("hilbbasvol",0,"-n"),
+        list("normal_l",0,"-N"," -- name deprecated, use hilbbas"),
+        list("hilbbas",0,"-N"),
+        list("hilb",0,"-h"," -- name deprecated, use hilbbas_hvect"),
+        list("hilbbas_hvect",0,"-h"),
+        list("dual",0,"-d"),
+        list("markov", 0, "--MarkovBasis --BinomialsPacked"),
+        list("groebner", 0, "--GroebnerBasis --BinomialsPacked"),
+        list("lex", 0, "--Lex"),
+        list("revlex", 0, "--RevLex"),
+        list("lex", 0, "--Lex"),
+        list("deglex", 0, "--DegLex"),
+        list("genoverori",0,"-M --mod"),
+        list("type",0,"--typ"),
+        list("control",0,"-c"," -- name deprecated, use verbose"),
+        list("verbose",0,"-c"),
+        list("allf",0,"-a"),
+        list("bigint",0,"-B"),
+        list("threads",8,"-x="),
+        list("errorcheck",0,"-e", " -- allowed, but ignored by Normaliz");
+    export nmz_options;
+    list default_options = nmz_options;
+    export default_options;
+
+    int BigNumInvs = 0;
+    exportto(Top, BigNumInvs);
+}