Changeset 321c9b in git

Timestamp:

Jul 9, 2019, 1:09:57 PM (5 years ago)

Author:

Andreas Steenpass <steenpass@…>

Branches:

(u'spielwiese', 'fe61d9c35bf7c61f2b6cbf1b56e25e2f08d536cc')

Children:

b4cbc239fe58d1eb1df8cf159cc5216476421e53

Parents:

e2ce0cc505caa119e486a0c44578da7fd5a4c423

git-author:

Andreas Steenpass <steenpass@mathematik.uni-kl.de>2019-07-09 13:09:57+02:00

git-committer:

Andreas Steenpass <steenpass@mathematik.uni-kl.de>2019-07-15 12:51:16+02:00

Message:

move create_ring() to standard.lib

Location:

Singular/LIB

Files:

• ring.lib (modified) (2 diffs)
• standard.lib (modified) (3 diffs)

Singular/LIB/ring.lib

@@ -41 +41 @@
  addvarsTo(r,vars,i)      add variables to a ring
  addNvarsTo(r,N,name,i)   add N variables to a ring
- create_ring(l1,l2,l3,l4) return ring(list(l1, l2, l3, l4))
 ";
 
@@ -1335 +1334 @@
   rr;
 }
-
-///////////////////////////////////////////////////////////////////////////////
-//   replacement for ring declarations via execute()
-///////////////////////////////////////////////////////////////////////////////
-
-/*
- * parses
- * "(v1,v2,v3,v4,v5)" to list("v1", "v2", "v3", "v4", "v5"),
- * "(dp(3), a(1,2,3), ds(3))" to list("dp(3)", "a(1,2,3)", "ds(3)"), and
- * "(1,2,3,4)" to list("1", "2", "3", "4")
- */
-static proc tuple_to_tokens(string s)
-{
-  list L;
-  int index = 1;
-  int curr = 2;
-  while (s[curr] == " ")
-  {
-    curr++;
-  }
-  int next = find(s, ",", curr+1);
-  int b = find(s, "(", curr+1);
-  if (b != 0 && b < next)
-  {
-    next = find(s, ",", find(s, ")", b+1)+1);
-  }
-  while (next != 0)
-  {
-    L[index] = string(s[curr, next-curr]);
-    index++;
-    curr = next+1;
-    while (s[curr] == " ")
-    {
-      curr++;
-    }
-    next = find(s, ",", curr+1);
-    b = find(s, "(", curr+1);
-    if (b != 0 && b < next)
-    {
-      next = find(s, ",", find(s, ")", b+1)+1);
-    }
-  }
-  L[index] = string(s[curr, size(s)-curr]);
-  return(L);
-}
-
-/*
- * parses
- * "0" and "(0)" to 0,
- * "32003" and "(32003)" to 32003, and
- * "(32003,a,b,c)" to
- *     list(32003, list("a", "b", "c"), list(list("lp", 1:3)), ideal(0))
- */
-static proc parse_L1(string l1)
-{
-  if (find(l1, "(", 1) == 0)   // no parentheses
-  {
-      return(int(l1));
-  }
-  list tokens = tuple_to_tokens(l1);
-  if (size(tokens) == 1)
-  {
-      return(int(tokens[1]));
-  }
-  list L = int(tokens[1]);
-  L[2] = list(tokens[2..size(tokens)]);
-  L[3] = list(list("lp", 1:(size(tokens)-1)));
-  L[4] = ideal(0);
-  return(L);
-}
-
-static proc parse_var(string v)
-{
-  if (v[1, 4] == "var(" && defined(basering))
-  {
-      int i = int(v[5,size(v)-5]);
-      v = ringlist(basering)[2][i];
-  }
-  return(v);
-}
-
-/*
- * parses
- * "x" to list("x") and
- * "(x,y,z)" to list("x", "y", "z")
- */
-static proc parse_L2(string l2)
-{
-  if (find(l2, "(", 1) == 0)   // no parentheses
-  {
-      return(list(parse_var(l2)));
-  }
-  list V = tuple_to_tokens(l2);
-  for (int i = size(V); i > 0; i--)
-  {
-      V[i] = parse_var(V[i]);
-  }
-  return(V);
-}
-
-/*
- * parses
- * "dp" to list("dp", 1:n_vars),
- * "dp(3)" to list("dp", 1:3),
- * "c" to list("c", intvec(0)), and
- * "wp(3,4)" to list("wp", intvec(3, 4))
- */
-static proc parse_ordering(string ordering, int n_vars)
-{
-  string name;
-  intvec w;
-  int b1 = find(ordering, "(", 1);
-  if (b1 == 0)   // no parentheses
-  {
-    name = ordering;
-    if (name == "C" || name == "c")
-    {
-      w = intvec(0);
-    }
-    else
-    {
-      w = 1:n_vars;
-    }
-  }
-  else
-  {
-    name = ordering[1, b1-1];
-    int b2 = find(ordering, ")", b1+1);
-    int c = find(ordering, ",", b1+1);
-    if (c == 0)
-    {
-      w = 1:int(ordering[b1+1, b2-b1-1]);
-    }
-    else
-    {
-      list W = tuple_to_tokens(ordering[b1, b2-b1+1]);
-      w = intvec(int(W[1..size(W)]));
-    }
-  }
-  return(list(name, w));
-}
-
-static proc parse_L3(string l3, int n_vars)
-{
-  if (l3[1] != "(")
-  {
-    list L =  parse_ordering(l3, n_vars);
-    return(list(L));
-  }
-  // block orderings
-  list L = tuple_to_tokens(l3);
-  for (int i = size(L); i > 0; i--)
-  {
-    L[i] = parse_ordering(L[i], n_vars);
-  }
-  return(L);
-}
-
-proc create_ring(def l1, def l2, def l3, list #)
-"USAGE:  create_ring(l1, l2, l3[, l4, \"no_minpoly\"]);
-         l1 int or list, l2 list or string, l3 list or string, l4 ideal
-RETURN:  ring(list(l1, l2, l3, l4))
-NOTE:    l1, l2, l3, l4 are assumed to be the four entries of ringlist(R)
-         where R is the ring to be returned.
-         @* Optional arguments: If l4 is not given, it is assumend to be
-         ideal(0). If \"no_minpoly\" is given, then the minimal polynomial
-         in l1, if present, is set to 0.
-         @* Shortcuts: Strings such as \"0\", \"(32003)\" or \"(0,a,b,c)\" can
-         be given as l1. Indexed parameters as in \"(0,a(1..3))\" are
-         not supported. Strings such as \"(x,y,z)\" can be given as l2.
-         Indexed variables as in \"(x(1..3),y,z)\" are not supported.
-         Strings representing orderings such as \"dp\" or \"(lp(3), ds(2))\"
-         can be given as l3, except matrix orderings given by
-         \"M([intmat_expression])\".
-EXAMPLE: example create_ring; shows an example
-"
-{
-  /* setup */
-  list L;
-  int kill_ring;
-  if (!defined(basering))
-  {
-    ring R;
-    kill_ring = 1;
-  }
-
-  /* read optional arguments */
-  ideal l4;
-  int no_minpoly;
-  if (size(#) > 0)
-  {
-    if (typeof(#[1]) == "ideal")
-    {
-      ideal l4 = #[1];
-      # = delete(#, 1);
-    }
-    if (typeof(#[1]) == "string")
-    {
-      if (#[1] == "no_minpoly")
-      {
-        no_minpoly = 1;
-      }
-    }
-  }
-
-  /* L[1] */
-  if (typeof(l1) == "list")
-  {
-    if (no_minpoly)
-    {
-      if (typeof(l1) == "list")
-      {
-        if (size(l1) == 4)
-        {
-          if (typeof(l1[4]) == "ideal")
-          {
-            l1[4] = ideal(0);
-          }
-        }
-      }
-    }
-  }
-  if (typeof(l1) == "list" || typeof(l1) == "int")
-  {
-    L[1] = l1;
-  }
-  else
-  {
-    L[1] = parse_L1(l1);
-  }
-
-  /* L[2] */
-  if (typeof(l2) == "list")
-  {
-    L[2] = l2;
-  }
-  else
-  {
-    L[2] = parse_L2(l2);
-  }
-
-  /* L[3] */
-  if (typeof(l3) == "list")
-  {
-    L[3] = l3;
-  }
-  else
-  {
-    L[3] = parse_L3(l3, size(L[2]));
-  }
-
-  /* L[4] */
-  L[4] = l4;
-
-  /* return ring */
-  def S = ring(L);
-  if (kill_ring)
-  {
-    kill(R);
-  }
-  return(S);
-}
-example
-{
-  "EXAMPLE:"; echo = 2;
-  ring R = (0,a), x, lp;
-  minpoly = a^2+1;
-  qring Q = ideal(x^3-2);
-  ring S = create_ring(ringlist(Q)[1], "(x,y,t)", "dp", "no_minpoly");
-  basering;
-}

Singular/LIB/standard.lib

@@ -19 +19 @@
  max(i_1,...,i_k)       maximum of i_1, ..., i_k
  min(i_1,...,i_k)       minimum of i_1, ..., i_k
+ create_ring(l1,l2,l3,l4) return ring(list(l1, l2, l3, l4))
 
 ";
@@ -24 +25 @@
 // hilbRing([i])          ring for computing the (weighted) hilbert series
 // quotientList(L,...)    ringlist for creating a correct quotient ring
-
-LIB "ring.lib";
 
 //////////////////////////////////////////////////////////////////////////////
@@ -2463 +2462 @@
   //exportto(Top,pagelength);
 }
+
+///////////////////////////////////////////////////////////////////////////////
+//   replacement for ring declarations via execute()
+///////////////////////////////////////////////////////////////////////////////
+
+/*
+ * parses
+ * "(v1,v2,v3,v4,v5)" to list("v1", "v2", "v3", "v4", "v5"),
+ * "(dp(3), a(1,2,3), ds(3))" to list("dp(3)", "a(1,2,3)", "ds(3)"), and
+ * "(1,2,3,4)" to list("1", "2", "3", "4")
+ */
+static proc tuple_to_tokens(string s)
+{
+  list L;
+  int index = 1;
+  int curr = 2;
+  while (s[curr] == " ")
+  {
+    curr++;
+  }
+  int next = find(s, ",", curr+1);
+  int b = find(s, "(", curr+1);
+  if (b != 0 && b < next)
+  {
+    next = find(s, ",", find(s, ")", b+1)+1);
+  }
+  while (next != 0)
+  {
+    L[index] = string(s[curr, next-curr]);
+    index++;
+    curr = next+1;
+    while (s[curr] == " ")
+    {
+      curr++;
+    }
+    next = find(s, ",", curr+1);
+    b = find(s, "(", curr+1);
+    if (b != 0 && b < next)
+    {
+      next = find(s, ",", find(s, ")", b+1)+1);
+    }
+  }
+  L[index] = string(s[curr, size(s)-curr]);
+  return(L);
+}
+
+/*
+ * parses
+ * "0" and "(0)" to 0,
+ * "32003" and "(32003)" to 32003, and
+ * "(32003,a,b,c)" to
+ *     list(32003, list("a", "b", "c"), list(list("lp", 1:3)), ideal(0))
+ */
+static proc parse_L1(string l1)
+{
+  if (find(l1, "(", 1) == 0)   // no parentheses
+  {
+      return(int(l1));
+  }
+  list tokens = tuple_to_tokens(l1);
+  if (size(tokens) == 1)
+  {
+      return(int(tokens[1]));
+  }
+  list L = int(tokens[1]);
+  L[2] = list(tokens[2..size(tokens)]);
+  L[3] = list(list("lp", 1:(size(tokens)-1)));
+  L[4] = ideal(0);
+  return(L);
+}
+
+static proc parse_var(string v)
+{
+  if (v[1, 4] == "var(" && defined(basering))
+  {
+      int i = int(v[5,size(v)-5]);
+      v = ringlist(basering)[2][i];
+  }
+  return(v);
+}
+
+/*
+ * parses
+ * "x" to list("x") and
+ * "(x,y,z)" to list("x", "y", "z")
+ */
+static proc parse_L2(string l2)
+{
+  if (find(l2, "(", 1) == 0)   // no parentheses
+  {
+      return(list(parse_var(l2)));
+  }
+  list V = tuple_to_tokens(l2);
+  for (int i = size(V); i > 0; i--)
+  {
+      V[i] = parse_var(V[i]);
+  }
+  return(V);
+}
+
+/*
+ * parses
+ * "dp" to list("dp", 1:n_vars),
+ * "dp(3)" to list("dp", 1:3),
+ * "c" to list("c", intvec(0)), and
+ * "wp(3,4)" to list("wp", intvec(3, 4))
+ */
+static proc parse_ordering(string ordering, int n_vars)
+{
+  string name;
+  intvec w;
+  int b1 = find(ordering, "(", 1);
+  if (b1 == 0)   // no parentheses
+  {
+    name = ordering;
+    if (name == "C" || name == "c")
+    {
+      w = intvec(0);
+    }
+    else
+    {
+      w = 1:n_vars;
+    }
+  }
+  else
+  {
+    name = ordering[1, b1-1];
+    int b2 = find(ordering, ")", b1+1);
+    int c = find(ordering, ",", b1+1);
+    if (c == 0)
+    {
+      w = 1:int(ordering[b1+1, b2-b1-1]);
+    }
+    else
+    {
+      list W = tuple_to_tokens(ordering[b1, b2-b1+1]);
+      w = intvec(int(W[1..size(W)]));
+    }
+  }
+  return(list(name, w));
+}
+
+static proc parse_L3(string l3, int n_vars)
+{
+  if (l3[1] != "(")
+  {
+    list L =  parse_ordering(l3, n_vars);
+    return(list(L));
+  }
+  // block orderings
+  list L = tuple_to_tokens(l3);
+  for (int i = size(L); i > 0; i--)
+  {
+    L[i] = parse_ordering(L[i], n_vars);
+  }
+  return(L);
+}
+
+proc create_ring(def l1, def l2, def l3, list #)
+"USAGE:  create_ring(l1, l2, l3[, l4, \"no_minpoly\"]);
+         l1 int or list, l2 list or string, l3 list or string, l4 ideal
+RETURN:  ring(list(l1, l2, l3, l4))
+NOTE:    l1, l2, l3, l4 are assumed to be the four entries of ringlist(R)
+         where R is the ring to be returned.
+         @* Optional arguments: If l4 is not given, it is assumend to be
+         ideal(0). If \"no_minpoly\" is given, then the minimal polynomial
+         in l1, if present, is set to 0.
+         @* Shortcuts: Strings such as \"0\", \"(32003)\" or \"(0,a,b,c)\" can
+         be given as l1. Indexed parameters as in \"(0,a(1..3))\" are
+         not supported. Strings such as \"(x,y,z)\" can be given as l2.
+         Indexed variables as in \"(x(1..3),y,z)\" are not supported.
+         Strings representing orderings such as \"dp\" or \"(lp(3), ds(2))\"
+         can be given as l3, except matrix orderings given by
+         \"M([intmat_expression])\".
+EXAMPLE: example create_ring; shows an example
+"
+{
+  /* setup */
+  list L;
+  int kill_ring;
+  if (!defined(basering))
+  {
+    ring R;
+    kill_ring = 1;
+  }
+
+  /* read optional arguments */
+  ideal l4;
+  int no_minpoly;
+  if (size(#) > 0)
+  {
+    if (typeof(#[1]) == "ideal")
+    {
+      ideal l4 = #[1];
+      # = delete(#, 1);
+    }
+    if (typeof(#[1]) == "string")
+    {
+      if (#[1] == "no_minpoly")
+      {
+        no_minpoly = 1;
+      }
+    }
+  }
+
+  /* L[1] */
+  if (typeof(l1) == "list")
+  {
+    if (no_minpoly)
+    {
+      if (typeof(l1) == "list")
+      {
+        if (size(l1) == 4)
+        {
+          if (typeof(l1[4]) == "ideal")
+          {
+            l1[4] = ideal(0);
+          }
+        }
+      }
+    }
+  }
+  if (typeof(l1) == "list" || typeof(l1) == "int")
+  {
+    L[1] = l1;
+  }
+  else
+  {
+    L[1] = parse_L1(l1);
+  }
+
+  /* L[2] */
+  if (typeof(l2) == "list")
+  {
+    L[2] = l2;
+  }
+  else
+  {
+    L[2] = parse_L2(l2);
+  }
+
+  /* L[3] */
+  if (typeof(l3) == "list")
+  {
+    L[3] = l3;
+  }
+  else
+  {
+    L[3] = parse_L3(l3, size(L[2]));
+  }
+
+  /* L[4] */
+  L[4] = l4;
+
+  /* return ring */
+  def S = ring(L);
+  if (kill_ring)
+  {
+    kill(R);
+  }
+  return(S);
+}
+example
+{
+  "EXAMPLE:"; echo = 2;
+  ring R = (0,a), x, lp;
+  minpoly = a^2+1;
+  qring Q = ideal(x^3-2);
+  ring S = create_ring(ringlist(Q)[1], "(x,y,t)", "dp", "no_minpoly");
+  basering;
+}