Changeset 6ed15c in git

Timestamp:

May 2, 2005, 9:43:22 AM (18 years ago)

Author:

Hans Schönemann <hannes@…>

Branches:

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

Children:

6eff86e3417d554a62456e5d4f0634e215db4891

Parents:

d1a54b1d03b681db8f1032e2f169a09db7a0faf7

Message:

*lossen: new lib


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

Files:

• Singular/LIB/presolve.lib (modified) (19 diffs)
• Singular/LIB/solve.lib (modified) (47 diffs)
• Tst/Long/solve_l.res.gz.uu (modified) (1 diff)
• Tst/Long/solve_l.stat (modified) (1 diff)
• Tst/Long/solve_l.tst (modified) (3 diffs)
• Tst/Short/solve_s.res.gz.uu (modified) (1 diff)
• Tst/Short/solve_s.stat (modified) (1 diff)
• Tst/Short/solve_s.tst (modified) (2 diffs)

Singular/LIB/presolve.lib

@@ -1 +1 @@
 //last change: 13.02.2001 (Eric Westenberger)
 ///////////////////////////////////////////////////////////////////////////////
-version="$Id: presolve.lib,v 1.20 2005-04-28 09:22:18 Singular Exp $";
+version="$Id: presolve.lib,v 1.21 2005-05-02 07:43:22 Singular Exp $";
 category="Symbolic-numerical solving";
 info="
@@ -13 +13 @@
  elimpartanyr(i,p);     factors of p partially eliminated from i in any ring
  fastelim(i,p[..]);     fast elimination of factors of p from i [options]
+ faststd(id,[..]);      fast std for ideal id [options]
  findvars(id[..]);      ideal of variables occuring in id [more information]
  hilbvec(id[,c,o]);     intvec of Hilberseries of id [in char c and ord o]
@@ -18 +19 @@
  tolessvars(id[,]);     maps id to new basering having only vars occuring in id
  solvelinearpart(id);   reduced std-basis of linear part of id
- sortandmap(id,s1,s2);  map to new basering with vars sorted w.r.t. complexity
+ sortandmap(id [..]);   map to new basering with vars sorted w.r.t. complexity
  sortvars(id[n1,p1..]); sort vars w.r.t. complexity in id [different blocks]
  valvars(id[..]);       valuation of vars w.r.t. to their complexity in id
@@ -451 +452 @@
    }
    else
-//------- h!=0: homogenize and compute Hilbert-series using hilbvec ----------
-   {
-      intvec hi = hilbvec(L[1]);         // Hilbert-series of i
+//------- h!=0: homogenize and compute Hilbert series using hilbvec ----------
+   {
+      intvec hi = hilbvec(L[1]);         // Hilbert series of i
       execute("ring r2=("+charstr(P)+"),("+varstr(basering)+",@homo),dp;");
       list L = imap(r1,L);
@@ -479 +480 @@
 ///////////////////////////////////////////////////////////////////////////////
 
-proc faststd (@id,string @s1,string @s2, list #)
-"USAGE:   faststd(id,s1,s2[,\"hilb\",\"sort\",\"dec\",o,\"blocks\"]);
-         id=ideal/module, s1,s2=strings (names for new ring and maped id)
-         o = string (allowed ordstring:\"lp\",\"dp\",\"Dp\",\"ls\",\"ds\",\"Ds\")
-         \"hilb\",\"sort\",\"dec\",\"block\" options for Hilbert-std, sortandmap
-COMPUTE: create a new ring (with \"best\" ordering of vars) and compute a
-         std-basis of id (hopefully faster)
-         - If say, s1=\"R\" and s2=\"j\", the new basering has name R and the
-           std-basis of the image of id in R has name j
-         - \"hilb\"  : use Hilbert-series driven std-basis computation
-         - \"sort\"  : use 'sortandmap' for a best ordering of vars
-         - \"dec\"   : order vars w.r.t. decreasing complexity (with \"sort\")
-         - \"block\" : create blockordering, each block having ordstr=o, s.t.
-                     vars of same complexity are in one block (with \"sort\")
-         - o       : defines the basic ordering of the resulting ring
-         default: o = ordering of 1-st block of basering - if it is allowed,
-                      else o=\"dp\",
-                  \"sort\", if none of the optional parameters is given
-RETURN:  nothing
-NOTE:    This proc is only useful for hard problems where other methods fail.
-         \"hilb\" is useful for hard orderings (as \"lp\") or for characteristic 0,
-         it is correct for \"lp\",\"dp\",\"Dp\" (and for blockorderings combining
-         these) but not for s-orderings or if the vars have different weights.
+proc faststd (@id, list #)
+"USAGE:   faststd(id [,\"hilb\",\"sort\",\"dec\",o,\"blocks\"]);
+         id=ideal/module, o=string (allowed:\"lp\",\"dp\",\"Dp\",\"ls\",
+         \"ds\",\"Ds\"),  \"hilb\",\"sort\",\"dec\",\"block\" options for 
+         Hilbert-driven std, and the procedure sortandmap
+RETURN:  a ring R, in which an ideal STD_id is stored: @*
+         - the ring R differs from the active basering only in the choice 
+         of monomial ordering and in the sorting of the variables.
+         - STD_id is a standard basis for the image (under imap) of the input 
+         ideal/module id with respect to the new monomial ordering. @*
+NOTE:    Using the optional input parameters, we may modify the computations
+         performed: @*
+         - \"hilb\"  : use Hilbert-driven standard basis computation@*
+         - \"sort\"  : use 'sortandmap' for a best sorting of the variables@*
+         - \"dec\"   : order vars w.r.t. decreasing complexity (with \"sort\")@*
+         - \"block\" : create block ordering, each block having ordstr=o, s.t.
+                     vars of same complexity are in one block (with \"sort\")@*
+         - o       : defines the basic ordering of the resulting ring@*
+         [default: o=ordering of 1st block of basering (if allowed, else o=\"dp\"],
+                  \"sort\", if none of the optional parameters is given @*
+         This proc is only useful for hard problems where other methods fail.@*
+         \"hilb\" is useful for hard orderings (as \"lp\") or for characteristic 0,@*
+         it is correct for \"lp\",\"dp\",\"Dp\" (and for block orderings combining
+         these) but not for s-orderings or if the vars have different weights.@*
          There seem to be only few cases in which \"dec\" is fast
 EXAMPLE: example faststd; shows an example.
@@ -536 +538 @@
       }
    }
-   if( voice==2 ) { "// choosen options, hilb sort dec block:",@h,@s,@n,@m; }
+   if( voice==2 ) { "// chosen options, hilb sort dec block:",@h,@s,@n,@m; }
 
 //-------------------- nosort: create ring with new name ----------------------
    if ( @s==0 )
    {
-      execute("ring "+@s1+"=("+charstr(@P)+"),("+varstr(@P)+"),("+@o+");");
-      def @id = imap(@P,@id);
-      verbose(noredefine);
-      def @P = basering;
-      verbose(redefine);
-      kill `@s1`;
-      if ( @h==0 ) { @id = std(@id); }
-   }
-//--------- sort: create new ring with "best" ordering of variables -----------
- proc bestorder(@id,string @s1,string @s2,int @n,string @o,int @m,int @l)
-  {
-     intvec getoption = option(get);
-     option(redSB);
-     @id = interred(sort(@id)[1]);
-     poly @p = product(maxideal(1),1..@l);
-     def i,s1,s2,n,p,o,m = @id,@s1,@s2,@n,@p,@o,@m;
-     sortandmap(i,s1,s2,n,p,0,o,m);
-     option(set,getoption);
-     keepring(basering);
-  }
+      execute("ring @S1 =("+charstr(@P)+"),("+varstr(@P)+"),("+@o+");");
+      def STD_id = imap(@P,@id);
+      if ( @h==0 ) { STD_id = std(STD_id); }
+   }
+
 //---------------------- no hilb: compute SB directly -------------------------
    if ( @s != 0 and @h == 0 )
    {
-      bestorder(@id,@s1,@s2,@n,@o,@m,nvars(@P));
-      verbose(noredefine);
-      def @P = basering;
-      verbose(redefine);
-      kill `@s1`;
-      def @id = `@s2`;
-      @id = std(@id);
+      intvec getoption = option(get);
+      option(redSB);
+      @id = interred(sort(@id)[1]);
+      poly @p = product(maxideal(1),1..nvars(@P));
+      def @S1=sortandmap(@id,@n,@p,0,@o,@m);
+      setring @S1;
+      option(set,getoption);
+      def STD_id=imap(@S1,IMAG);
+      STD_id = std(STD_id);
    }
 //------- hilb: homogenize and compute Hilbert-series using hilbvec -----------
@@ -576 +565 @@
    if ( @h != 0 )
    {
-      execute("ring @Q=("+charstr(@P)+"),("+varstr(@P)+",@homo),("+@o+");");
+      execute("ring @Q=("+charstr(@P)+"),("+varstr(@P)+",@homo),("+@o+");");  
       def @id = imap(@P,@id);
-      kill @P;
       @id = homog(@id,@homo);               // @homo = homogenizing var
       if ( @s != 0 )
       {
-         bestorder(@id,@s1,@s2,@n,@o,@m,nvars(@Q)-1);
-         verbose(noredefine);
-         def @Q= basering;
-         kill `@s1`;
-         def @id = `@s2`;
-         verbose(redefine);
+        intvec getoption = option(get);
+        option(redSB);
+        @id = interred(sort(@id)[1]);
+        poly @p = product(maxideal(1),1..(nvars(@Q)-1));
+        def @S1=sortandmap(@id,@n,@p,0,@o,@m);
+        setring @S1;
+        option(set,getoption);
+        kill @Q;
+        def @Q= basering;
+        def @id = IMAG;
       }
       intvec @hi;                     // encoding of Hilbert-series of i
@@ -603 +595 @@
          else { @o = @o[1,size(@o)-8] + @o[size(@o)-1,2]; }
       }
-      execute("ring @P=("+charstr(@Q)+"),("+@va+"),("+@o+");");
-      def @id = imap(@Q,@id);
-   }
-   def `@s1` = @P;
-   def `@s2` = @id;
-   attrib(`@s2`,"isSB",1);
-   export(`@s2`);
-   kill @P;
-   keepring(basering);
-   if( voice==2 ) { "// basering is now "+@s1+", std-basis has name "+@s2; }
-   return();
+      kill @S1;      
+      execute("ring @S1=("+charstr(@Q)+"),("+@va+"),("+@o+");");
+      def STD_id = imap(@Q,@id);
+   }
+   attrib(STD_id,"isSB",1);
+   export STD_id;
+   if (defined(IMAG)) { kill IMAG; } 
+   setring @P;
+   dbprint(printlevel-voice+3,"
+// 'faststd' created a ring, in which an object STD_id is stored. 
+// To access the object, type (if the name R was assigned to the return value):
+        setring R; STD_id; ");
+   return(@S1);
 }
 example
@@ -620 +614 @@
    ideal i = w2+f2-1, x2+t2+a2-1,  y2+u2+b2-1, z2+v2+c2-1,
             d2+e2-1, f4+2u, wa+tf, xy+tu+ab;
-  option(prot); timer=1;
+   option(prot); timer=1;
    int time = timer;
    ideal j=std(i);
    timer-time;
-   show(R);dim(j),mult(j);
-   int time = timer;
-   faststd(i,"R","i");                      // use "best" ordering of vars
+   dim(j),mult(j);
+
+   time = timer;
+   def R=faststd(i);                      // use "best" ordering of vars
    timer-time;
-   show(R);dim(i),mult(i);
-   setring s;time = timer;
-   faststd(i,"R","i","hilb");                // hilb-std only
+   show(R);setring R;dim(STD_id),mult(STD_id);
+
+   setring s;kill R;time = timer;
+   def R=faststd(i,"hilb");                // hilb-std only
    timer-time;
-   show(R);dim(i),mult(i);
-   setring s;time = timer;
-   faststd(i,"R","i","hilb","sort");         // hilb-std,"best" ordering
+   show(R);setring R;dim(STD_id),mult(STD_id);
+
+   setring s;kill R;time = timer;
+   def R=faststd(i,"hilb","sort");         // hilb-std,"best" ordering
    timer-time;
-   show(R);dim(i),mult(i);
-    setring s;time = timer;
-   faststd(i,"R","i","hilb","sort","block","dec"); // hilb-std,"best",blocks
+   show(R);setring R;dim(STD_id),mult(STD_id);
+
+   setring s;kill R;time = timer;
+   def R=faststd(i,"hilb","sort","block","dec"); // hilb-std,"best",blocks
    timer-time;
-   show(R);dim(i),mult(i);
-  setring s;time = timer;
+   show(R);setring R;dim(STD_id),mult(STD_id);
+
+   setring s;kill R;time = timer;
    timer-time;time = timer;
-   faststd(i,"R","i","sort","block","Dp"); //"best",decreasing,Dp-blocks
+   def R=faststd(i,"sort","block","Dp"); //"best",decreasing,Dp-blocks
    timer-time;
-   show(R);dim(i),mult(i);
+   show(R);setring R;dim(STD_id),mult(STD_id);
 }
 ///////////////////////////////////////////////////////////////////////////////
@@ -750 +749 @@
 proc tolessvars (id ,list #)
 "USAGE:   tolessvars(id [,s1,s2] ); id poly/ideal/vector/module/matrix,
-          s1,s2=strings@*
-          s1: name of new ring,@*
-          s2: new ordering@*
-          (default: s1=\"R(n)\" where n is the # of vars in the new ring,
-          s2=\"dp\" or \"ds\" depending whether the first block of the old
-          ordering is a p- resp. an s-ordering)
-
-CREATE:  nothing, if id contains all vars of the basering.@*
-         Else, create a ring with same char as the basering, but possibly less
-         variables (only those variables which actually occur in id) and map
-         id to the new ring, which will be the basering after the proc has
-         finished.
-DISPLAY: If printlevel >=0, display ideal of vars, which have been ommitted from
-         the old ring
-RETURN:  the original ideal id (see NOTE)
-NOTE:    You must not type, say, 'ideal id=tolessvars(id);' since the ring
-         to which 'id' would belong will only be defined by the r.h.s.. But you
-         may type 'def id=tolessvars(id);' or 'list id=tolessvars(id);'
-         since then 'id' does not a priory belong to a ring, its type will
-         be defined by the right hand side. Moreover, do not use a name which
-         occurs in the old ring, for the same reason.
+          s1=string (new ordering)@*
+          [default: s1=\"dp\" or \"ds\" depending on whether the first block 
+          of the old ordering is a p- resp. an s-ordering)
+RETURN:  If id contains all vars of the basering: empty list. @*
+         Else: ring R with the same char as the basering, but possibly less
+         variables (only those variables which actually occur in id). In R
+         an object IMAG (image of id under imap) is stored.  
+DISPLAY: If printlevel >=0, display ideal of vars, which have been ommitted 
+         from the old ring.
 EXAMPLE: example tolessvars; shows an example
 "
@@ -776 +763 @@
 //---------------- initialisation and check occurence of vars -----------------
    int s,ii,n,fp,fs;
-   string s1,s2,newvar;
+   string s2,newvar;
    int pr = printlevel-voice+3;  // p = printlevel+1 (default: p=1)
    def P = basering;
@@ -791 +778 @@
    if( n == nvars(P) )
    {
-      dbprint( pr,"","// all variables occured in "+typeof(id)+", no change of ring!");
-      return(id);
+     dbprint(printlevel-voice+3,"
+// All variables appear in input object. 
+// empty list returned. "); 
+     return(list());
    }
 //----------------- prepare new ring, map to it and return --------------------
-   s1 = "R("+string(n)+")";
    if ( size(#) == 0 )
    {
@@ -803 +791 @@
        else {  s2="ds"; }
    }
-   if ( size(#) ==1 ) { s1=#[1]; }
-   if ( size(#) ==2 ) { s1=#[1]; s2=#[2]; }
-   //dbprint( pr,"","// variables which did not occur:",simplify(max,2) );
+   if ( size(#) ==1 ) { s2=#[1]; }
    dbprint( pr,"","// variables which did not occur:",L[3] );
-
-   execute("ring "+s1+"=("+charstr(P)+"),("+newvar+"),("+s2+");");
-   def id = imap(P,id);
-   export(basering);
-   keepring (basering);
-   dbprint( pr,"// basering is now "+s1 );
-   return(id);
+   execute("ring S1=("+charstr(P)+"),("+newvar+"),("+s2+");");
+   def IMAG = imap(P,id);
+   export IMAG;
+   dbprint(printlevel-voice+3,"
+// 'tolessvars' created a ring, in which an object IMAG is stored. 
+// To access the object, type (if the name R was assigned to the return value):
+        setring R; IMAG; ");
+   return(S1);
 }
 example
@@ -819 +806 @@
    ring r  = 0,(x,y,z),dp;
    ideal i = y2-x3,x-3,y-2x;
-   def j   = tolessvars(i,"R_r","lp");
+   def R_r = tolessvars(i,"lp");
+   setring R_r;
    show(basering);
-   j;
+   IMAG;
    kill R_r;
 }
@@ -876 +864 @@
 ///////////////////////////////////////////////////////////////////////////////
 
-proc sortandmap (@id,string @s1,string @s2, list #)
-"USAGE:   sortandmap(id,s1,s2[,n1,p1,n2,p2...,o1,m1,o2,m2...]);@*
+proc sortandmap (@id, list #)
+"USAGE:   sortandmap(id [,n1,p1,n2,p2...,o1,m1,o2,m2...]);@*
          id=poly/ideal/vector/module,@*
-         s1,s2 = strings (names for new ring and mapped id),@*
          p1,p2,...= polynomials (product of variables),@*
          n1,n2,...= integers,@*
@@ -886 +873 @@
          (default: p1=product of all vars, n1=0, o1=\"dp\",m1=0)
          the last pi (containing the remaining vars) may be omitted
-CREATE:  a new ring and map id into it, the new ring has same char as basering
-         but with new ordering and vars sorted in the following manner:
+RETURN:  a ring R, in which a poly/ideal/vector/module IMAG is stored: @*
+         - the ring R differs from the active basering only in the choice 
+         of monomial ordering and in the sorting of the variables.@*
+         - IMAG is the image (under imap) of the input ideal/module id @*
+         The new monomial ordering and sorting of vars is as follows:
   @format
   - each block of vars occuring in pi is sorted w.r.t. its complexity in id,
   - ni controls the sorting in i-th block (= vars occuring in pi):
-    ni=0 (resp.!=0) means that less (resp. more) complex vars come first
+    ni=0 (resp.!=0) means that least complex (resp. most complex) vars come 
+    first @*
   - oi and mi define the monomial ordering of the i-th block:
     if mi =0, oi=ordstr(i-th block)
@@ -898 +889 @@
       in one block
   @end format
-  Note that only simple ordstrings oi are allowed:
-  \"lp\",\"dp\",\"Dp\",\"ls\",\"ds\",\"Ds\".
-RETURN:  nothing
+         Note that only simple ordstrings oi are allowed: \"lp\",\"dp\",\"Dp\",
+         \"ls\",\"ds\",\"Ds\". @*
 NOTE:    We define a variable x to be more complex than y (with respect to id)
          if val(x) > val(y) lexicographically, where val(x) denotes the
@@ -946 +936 @@
    }
    @o=@o[1..size(@o)-1];
-//------------------ create new ring and make objects global -----------------
-   execute("ring "+@s1+"=("+charstr(@P)+"),("+@va+"),("+@o+");");
-   def @id = imap(@P,@id);
-   execute("def "+ @s2+"=@id;");
-   execute("export("+@s1+");");
-   execute("export("+@s2+");");
-   keepring(basering);
-   return();
+   execute("ring @S1 =("+charstr(@P)+"),("+@va+"),("+@o+");");
+   def IMAG = imap(@P,@id);
+   export IMAG;
+   dbprint(printlevel-voice+3,"
+// 'sortandmap' created a ring, in which an object IMAG is stored. 
+// To access the object, type (if the name R was assigned to the return value):
+        setring R; IMAG; ");
+   return(@S1);
 }
 example
@@ -959 +949 @@
    ring s = 32003,(x,y,z),dp;
    ideal i=x3+y2,xz+z2;
-   sortandmap(i,"R_r","i");
-   // i is now an ideal in the new basering R_r
+   def R_r=sortandmap(i);  
    show(R_r);
+   setring R_r; IMAG;
    kill R_r; setring s;
-   sortandmap(i,"R_r","i",1,xy,0,z,0,"ds",0,"lp",0);
+   def R_r=sortandmap(i,1,xy,0,z,0,"ds",0,"lp",0);
    show(R_r);
+   setring R_r; IMAG;
    kill R_r;
 }

Singular/LIB/solve.lib

@@ -1 +1 @@
 ///////////////////////////////////////////////////////////////////////////////
-version="$Id: solve.lib,v 1.28 2005-04-25 16:57:36 Singular Exp $";
+version="$Id: solve.lib,v 1.29 2005-05-02 07:43:22 Singular Exp $";
 category="Symbolic-numerical solving";
 info="
@@ -46 +46 @@
          parameters. 
 RETURN:  list of (complex) roots of the polynomial f, depending on n. The 
-         result is of type
- string: if the basering is not complex,
- number: otherwise.
+         result is of type@*
+          string: if the basering is not complex,@*
+          number: otherwise.
 NOTE:    If printlevel >0: displays comments ( default = 0 ).
          If s != 0 and if the procedure stops with ERROR, try a higher
@@ -516 +516 @@
 
 proc solve( ideal G, list # )
-"USAGE:   solve(G [, m, n, l] ); G = ideal,
-         m, n, l = integers (control parameters of the method)
+"USAGE:   solve(G [, m, n [, l]] [,\"oldring\"] [,\"nodisplay\"] ); G = ideal,
+         m, n, l = integers (control parameters of the method), outR ring
          m: precision of output in digits ( 4 <= m) and of the
             generated ring of complex numbers;
@@ -525 +525 @@
          l: precision of internal computation in decimal digits ( l >=8 )
             only if the basering is not complex or complex with smaller
-            precision,
-         ( default: m, n, l = 8, 0, 30 or
-                    for (n != 0 and size(#) = 2) l = 60 )
+            precision, @*
+         [default: (m,n,l) = (8,0,30), or if only (m,n) are set explicitly
+          with n!=0, then (m,n,l) = (m,n,60) ]
 ASSUME:  the ideal is 0-dimensional;@*
-         basering has characteristic 0 and is either complex or
-         without parameters;
-RETURN:  list of solutions of the ideal G, depending on n; one solution is a 
-         list of complex numbers in the generated output ring (the new 
-         basering).
- The result is a list L
-    n  = 0: a list of all different solutions (L[i]),
-    n != 0: a list of two elements,
-            L[i][1] contains all different solutions with the same multiplicity
-            L[i][2] the multiplicity
- L is ordered w.r.t. multiplicity (the smallest first).
-NOTE:    If the problem is not 0-dim. the procedure stops with ERROR, if the 
-         ideal G is not a lex. standard basis, it is generated with internal 
-         computation (Hilbert driven), if the input-ring (with char 0) has 
-         the name \"<A>\", the lexicographical and complex output-ring has the 
-         name \"<A>C\".
+         basering has characteristic 0 and is either complex or without 
+         parameters;
+RETURN:  (1) If called without the additional parameter @code{\"oldring\"}: @*
+         ring @code{R} with the same number of variables but with complex 
+         coefficients (and precision m). @code{R} comes with a list 
+         @code{SOL} of numbers, in which complex roots of G are stored: @*
+         * If n  = 0, @code{SOL} is the list of all different solutions, each 
+         of them being represented by a list of numbers. @*
+         * If n != 0, @code{SOL} is a list of two list: SOL[i][1] is the list 
+         of all different solutions with the multiplicity SOL[i][2].@*
+         SOL is ordered w.r.t. multiplicity (the smallest first). @*
+         (2) If called with the additional parameter @code{\"oldring\"}, the 
+         procedure looks for an appropriate ring (on the Top level) in which 
+         the solutions can be stored (interactive). @*
+         The user may then select an appropriate ring and choose a name for 
+         the output list in this ring. The list is exported directly to the 
+         selected ring and the return value is a string \"result exported to\"
+         + name of the selected ring.
+NOTE:    If the problem is not 0-dim. the procedure stops with ERROR. If the 
+         ideal G is not a lexicographic Groebner basis, the lexicographic 
+         Groebner basis is computed internally (Hilbert driven).  @*
+         The computed solutions are displayed, unless @code{solve} is called
+         with the additional parameter @code{\"nodisplay\"}.
 EXAMPLE: example solve; shows an example
 "
@@ -550 +557 @@
 // test if basering admissible
   if (char(basering)!=0){ERROR("characteristic of basering not 0");}
-  if ((charstr(basering)[1]=="0") and (npars(basering)!=0)){ERROR("basering has parameters");}
+  if ((charstr(basering)[1]=="0") and (npars(basering)!=0)){
+    ERROR("basering has parameters");
+  }
 
 // some global settings and control
+  int oldr, nodisp, ii, jj;
+  list LL;
   int outprec = 8;
   int mu = 0;
   int prec = 30;
-  if (size(#)>0){outprec = #[1];if (outprec<4){outprec = 4;}}
-  if (size(#)>1){mu = #[2];}
-  if (size(#)>2){prec = #[3];if (prec<8){prec = 8;}}
-  else {if(mu!=0){prec = 60;}}
+  // check additional parameters...
+  if (size(#)>0){
+    int sofar=1;
+    if (typeof(#[1])=="int"){
+      outprec = #[1];
+      if (outprec<4){outprec = 4;}
+      if (size(#)>1){
+        if (typeof(#[2])=="int"){ 
+          mu = #[2];
+          if (size(#)>2){
+            if (typeof(#[3])=="int"){ 
+              prec = #[3];
+              if (prec<8){prec = 8;}
+            }
+            else {
+              if(mu!=0){prec = 60;}
+              if (#[3]=="oldring"){ oldr=1; }
+              if (#[3]=="nodisplay"){ nodisp=1; }
+            }
+            sofar=3;
+          }
+        }
+        else {
+          if (#[2]=="oldring"){ oldr=1; }
+          if (#[2]=="nodisplay"){ nodisp=1; }
+        }
+        sofar=2;
+      }
+    }
+    else {
+      if (#[1]=="oldring"){ oldr=1; }
+      if (#[1]=="nodisplay"){ nodisp=1; }
+    }   
+    for (ii=sofar+1;ii<=size(#);ii++) { // check for additional strings
+       if (#[ii]=="oldring"){ oldr=1; }
+       if (#[ii]=="nodisplay"){ nodisp=1; }
+    }
+  }   
   if (outprec>prec){prec = outprec;}
-  string rinC = nameof(basering)+"C";
+
+  // if interaktive version is chosen -- choice of basering (Top::`outR`)
+  // and name for list of solutions (outL):
+  if (oldr==1) {
+    list Out; 
+    LL=names(Top);
+    for (ii=1;ii<=size(LL);ii++)
+    { 
+      if (typeof(`LL[ii]`)=="ring") {
+        if (find(charstr(`LL[ii]`),"complex,"+string(outprec))){
+          jj++;
+          Out[jj]=LL[ii];
+        }
+      }
+    }
+    if (size(Out)>0) {
+      print("// *** You may select between the following rings for storing "+
+            "the list of");
+      print("// *** complex solutions:");
+      Out;
+      print("// *** Enter the number of the chosen ring");
+      print("// ***  (0: none of them => new ring created and returned)");
+      string chosen;
+      while (chosen=="") { chosen=read(""); }
+      execute("def tchosen = "+chosen);
+      if (typeof(tchosen)=="int") {
+        if ((tchosen>0) and (tchosen<=size(Out))) {
+          string outR = Out[tchosen];
+          print("// *** You have chosen the ring "+ outR +". In this ring"
+                +" the following objects");
+          print("//*** are defined:");
+          listvar(Top::`outR`);
+          print("// *** Enter a name for the list of solutions (different "+
+                "from existing names):"); 
+          string outL;
+          while (outL==""){ outL=read(""); }
+        }
+      }
+    }
+    else {
+      print("No appropriate ring for storing the list of solutions found " +
+             "=> new ring created and returned");
+    }
+    if (not(defined(outR))) { oldr=0; }   
+  }
+
+//  string rinC = nameof(basering)+"C";
   string sord = ordstr(basering);
   int nv = nvars(basering);
@@ -578 +669 @@
   if (sb){if (dim(G)!=0){ERROR("ideal not zero-dimensional");}}
 
-// the trivial homog case
+// the trivial homogeneous case (unique solution: (0,...0))
   if (homog(G))
   {
@@ -587 +678 @@
       ideal G = std(imap(rin,G));
       if (dim(G)!=0){ERROR("ideal not zero-dimensional");}
-    }
-    changering(rinC,outprec);
-    list ret0;
-    if (mu==0){ret0[1] = zerolist(nv);}
-    else{ret0[1] = list(zerolist(nv),list(vdim(G)));}
-    option(set,ovec);
-    keepring basering;
-    return(ret0);
+      int vdG=vdim(G);
+    }
+    if (oldr!=1) { 
+      execute("ring rinC =(complex,"+string(outprec)+
+                 "),("+varstr(basering)+"),lp;"); 
+      list SOL;
+      if (mu==0){SOL[1] = zerolist(nv);}
+      else{SOL[1] = list(zerolist(nv),list(vdG));}
+      export SOL;
+      if (nodisp==0) { print(SOL); }
+      option(set,ovec);
+      dbprint( printlevel-voice+3,"
+// 'solve' created a ring, in which a list SOL of numbers (the complex solutions)
+// is stored. 
+// To access the list of complex solutions, type (if the name R was assigned 
+// to the return value): 
+        setring R; SOL; ");
+      return(rinC);
+    }
+    else {
+      setring (Top::`outR`);
+      list SOL;
+      if (mu==0){SOL[1] = zerolist(nv);}
+      else{SOL[1] = list(zerolist(nv),list(vdG));}
+      execute("def "+outL + "=SOL;");
+      execute("export "+outL+";");
+      if (nodisp==0) { print(SOL); }
+      option(set,ovec);
+      kill SOL;
+      return("result exported to "+outR+" as list "+outL);
+    }
   }
 
 // look for reduced standard basis in lex
-  if (sb*lp==0)
-  {
-    if (sb==0)
-    {
-      execute("ring dphilb=("+charstr(rin)+"),("+
-      varstr(rin)+"),dp;");
+  if (sb*lp==0) {
+    if (sb==0) {
+      execute("ring dphilb=("+charstr(rin)+"),("+ varstr(rin)+"),dp;");
       ideal G = imap(rin,G);
       G = std(G);
       if (dim(G)!=0){ERROR("ideal not zero-dimensional");}
     }
-    else
-    {
+    else {
       def dphilb = basering;      
     }    
-    execute("ring lexhilb=("+charstr(rin)+"),("+
-    varstr(rin)+"),lp;");
+    execute("ring lexhilb=("+charstr(rin)+"),("+ varstr(rin)+"),lp;");
     option(redTail);
     ideal H = fglm(dphilb,G);
@@ -619 +728 @@
     H = simplify(H,2);
     if (lp){setring rin;}
-    else
-    {
+    else {
       execute("ring lplex=("+charstr(rin)+"),("+
       varstr(rin)+"),lp;");
@@ -631 +739 @@
 // only 1 variable
   def hr = basering;
-  if (nv==1)
-  {
-    if ((mu==0) and (charstr(basering)[1]=="0")) // special case 
-    {
+  if (nv==1) {
+    if ((mu==0) and (charstr(basering)[1]=="0")) { // special case 
       list L = laguerre_solve(H[1],prec,prec,mu,0); // list of strings
-      changering(rinC,outprec);
-      list sp;
-      for (int ii=1; ii<=size(L); ii++ ) 
-      { 
-        execute("sp[ii]="+L[ii]); 
-      }
-      keepring basering;
-      return(sp);
-    }
-    else
-    {
+      if (oldr!=1) { 
+        execute("ring rinC =(complex,"+string(outprec)+
+                   "),("+varstr(basering)+"),lp;"); 
+        list SOL;
+        for (ii=1; ii<=size(L); ii++ ) { execute("SOL[ii]="+L[ii]+";"); }
+        export SOL;
+        if (nodisp==0) { print(SOL); }
+        option(set,ovec);
+        dbprint( printlevel-voice+3,"
+// 'solve' created a ring, in which a list SOL of numbers (the complex solutions)
+// is stored. 
+// To access the list of complex solutions, type (if the name R was assigned 
+// to the return value): 
+        setring R; SOL; ");
+        return(rinC);
+      }
+      else {
+        setring (Top::`outR`);
+        list SOL;
+        for (ii=1; ii<=size(L); ii++ ) { execute("SOL[ii]="+L[ii]+";"); }
+        execute("def "+outL + "=SOL;");
+        execute("export "+outL+";");
+        if (nodisp==0) { print(SOL); }
+        option(set,ovec);
+        kill SOL;
+        return("result exported to "+outR+" as list "+outL);
+      }
+    }
+    else {
       execute("ring internC=(complex,"+string(prec)+
                  "),("+varstr(basering)+"),lp;");
-
       ideal H = imap(hr,H);
       list sp = splittolist(splitsqrfree(H[1],var(1)));
-      int jj = size(sp);
+      jj = size(sp);
       while(jj>0)
       {
@@ -659 +782 @@
       }
       setring hr;
-      changering(rinC,outprec);
-      list sp=imap(internC,sp);
-
-      keepring basering;
-      if(mu!=0){return(sp);}
-      jj = size(sp);
-      list ll=sp[jj][1];
-      while(jj>1)
-      {
-        jj--;
-        ll = sp[jj][1]+ll;
-      }
-      return(ll);
+      if (oldr!=1) { 
+        execute("ring rinC =(complex,"+string(outprec)+
+                 "),("+varstr(basering)+"),lp;"); 
+        list SOL;
+        list sp=imap(internC,sp);
+        if(mu!=0){ SOL=sp; }
+        else {
+          jj = size(sp);
+          SOL=sp[jj][1];
+          while(jj>1) {
+            jj--;
+            SOL = sp[jj][1]+SOL;
+          }
+        }
+        export SOL;
+        if (nodisp==0) { print(SOL); }
+        option(set,ovec);
+        dbprint( printlevel-voice+3,"
+// 'solve' created a ring, in which a list SOL of numbers (the complex solutions)
+// is stored. 
+// To access the list of complex solutions, type (if the name R was assigned 
+// to the return value): 
+        setring R; SOL; ");
+        return(rinC);
+      }
+      else {
+        setring (Top::`outR`);
+        list SOL;
+        list sp=imap(internC,sp);
+        if(mu!=0){ SOL=sp; }
+        else {
+          jj = size(sp);
+          SOL=sp[jj][1];
+          while(jj>1) {
+            jj--;
+            SOL = sp[jj][1]+SOL;
+          }
+        }
+        kill sp;
+        execute("def "+outL + "=SOL;");
+        execute("export "+outL+";");
+        if (nodisp==0) { print(SOL); }
+        option(set,ovec);
+        kill SOL;
+        return("result exported to "+outR+" as list "+outL);
+      }
     }    
   }    
@@ -695 +851 @@
   else
   {
-    changering(rinC,prec);
+    execute("ring rinC =(complex,"+string(outprec)+
+                 "),("+varstr(basering)+"),lp;"); 
   }
   list triC = imap(hr,sp);
@@ -724 +881 @@
 // final computations
   option(set,ovec);
-  if (outprec==prec)
-  {
-    keepring basering;
-    return(ret1);
-  }
-  changering(rinC,outprec);
-  keepring basering;
-  return(imap(internC,ret1));
+  if (outprec==prec) { // we are in ring rinC
+    if (oldr!=1) {
+      list SOL=ret1;
+      export SOL;
+      if (nodisp==0) { print(SOL); }
+      dbprint( printlevel-voice+3,"
+// 'solve' created a ring, in which a list SOL of numbers (the complex solutions)
+// is stored. 
+// To access the list of complex solutions, type (if the name R was assigned 
+// to the return value): 
+        setring R; SOL; ");
+      return(rinC);
+    }
+    else {
+      setring (Top::`outR`);
+      list SOL=imap(rinC,ret1);
+      execute("def "+outL + "=SOL;");
+      execute("export "+outL+";");
+      if (nodisp==0) { print(SOL); }
+      kill SOL;
+      return("result exported to "+outR+" as list "+outL);    
+    }
+  }
+  else {
+    if (oldr!=1) {
+      execute("ring rinC =(complex,"+string(outprec)+
+                 "),("+varstr(basering)+"),lp;"); 
+      list SOL=imap(internC,ret1);
+      export SOL;
+      if (nodisp==0) { print(SOL); }
+      dbprint( printlevel-voice+3,"
+// 'solve' created a ring, in which a list SOL of numbers (the complex solutions)
+// is stored. 
+// To access the list of complex solutions, type (if the name R was assigned 
+// to the return value): 
+        setring R; SOL; ");
+      return(rinC);
+    }
+    else {
+      setring (Top::`outR`);
+      list SOL=imap(internC,ret1);
+      execute("def "+outL + "=SOL;");
+      execute("export "+outL+";");
+      if (nodisp==0) { print(SOL); }
+      kill SOL;
+      return("result exported to "+outR+" as list "+outL);    
+    }
+  }
 }
 example
@@ -737 +934 @@
     "EXAMPLE:";echo=2;
     // Find all roots of a multivariate ideal using triangular sets:
-    int d=4;// with these 3 parameters you may construct
-    int t=3;// very hard problems for 'solve'
-    int s=2;
+    int d,t,s = 4,3,2 ; 
     int i;
-    ring A=0,(x(1..d)),dp;
+    ring A=0,x(1..d),dp;
     poly p=-1;
-    for(i=d;i>0;i--){p=p+x(i)^s;}
-    ideal I=x(d)^t-x(d)^s+p;
-    for(i=d-1;i>0;i--){I=x(i)^t-x(i)^s+p,I;}
+    for (i=d; i>0; i--) { p=p+x(i)^s; }
+    ideal I = x(d)^t-x(d)^s+p;
+    for (i=d-1; i>0; i--) { I=x(i)^t-x(i)^s+p,I; }
     I;
-    // the mutiplicity is
+    // the multiplicity is
     vdim(std(I));
-    list l1=solve(I,6,0);
-    // the current ring is
-    AC;
+    def AC=solve(I,6,0,"nodisplay");  // solutions should not be displayed
+    // list of solutions is stored in AC as the list SOL (default name)
+    setring AC;
+    size(SOL);               // number of different solutions
+    SOL[5];                  // the 5th solution
     // you must start with char. 0
     setring A;
-    list l2=solve(I,6,1);
-    // the number of different solutions is
-    size(l1);
-    // this is equal to
-    size(l2[1][1])+size(l2[2][1]);
-    // the number of solutions with multiplicity is
-    size(l2[1][1])*l2[1][2]+size(l2[2][1])*l2[2][2];
-    // the solutions with multiplicity
-    l2[2][2];
-    // are
-    l2[2][1];
+    def AC1=solve(I,6,1,"nodisplay");
+    setring AC1;
+    size(SOL);               // number of different multiplicities
+    SOL[1][1][1];            // a solution with
+    SOL[1][2];               // multiplicity 1
+    SOL[2][1][1];            // a solution with
+    SOL[2][2];               // multiplicity 12
+    // the number of different solutions is equal to
+    size(SOL[1][1])+size(SOL[2][1]);
+    // the number of complex solutions (counted with multiplicities) is
+    size(SOL[1][1])*SOL[1][2]+size(SOL[2][1])*SOL[2][2];
 }
 //////////////////////////////////////////////////////////////////////////////
 //                subprocedures for solve
 
-/* ----------------------- support ----------------------- */
-/*
-* the complex ring with precision outprec
-* has the well defined name: rinC
-* 1. if such a ring exists with the precision outprec,
-*    this will be the current ring
-* 2. otherwise such a ring will be created
-*/
-static proc changering(string rinC, int outprec)
-{
-  string rinDC = "ring "+rinC+"=(complex,"+string(outprec)+
-                 "),("+varstr(basering)+"),lp;";
-  string h = "int ex=defined("+rinC+");";
-
-  execute(h);
-  if (ex)
-  {
-    h = "setring "+rinC+";";
-    execute(h);
-    if (system("getPrecDigits")==outprec)
-    {"// name of current ring: "+rinC;}
-    else
-    {
-      execute("kill "+rinC+";");
-      execute(rinDC);
-      execute("export "+rinC+";");
-      "// name of new current ring: "+rinC;
-    }
-  }
-  else
-  {
-    execute(rinDC);
-    execute("export "+rinC+";");
-    "// name of new current ring: "+rinC;
-  }
-  keepring basering;
-}
 
 /*
@@ -1335 +1495 @@
     interpolate( 3, v, 4 );
 }
+
 ///////////////////////////////////////////////////////////////////////////////
-
+// changed for Singular 3
+// Return value is now a list: (rlist, rn@)
 static proc psubst( int d, int dd, int n, list resl,
-                    ideal fi, int elem, int nv, int prec )
+                    ideal fi, int elem, int nv, int prec, int rn@, list rlist)
 {
     //   nv: number of ring variables         (fixed value)
@@ -1349 +1511 @@
     //    d: actual variable
 
+    list LL;
+    int pdebug;
     int olddd=dd;
 
-    if ( pdebug>=1 )
-    {"// 0 step "+string(dd)+" of "+string(elem);}
+    dbprint(printlevel-voice+2, "// 0 step "+string(dd)+" of "+string(elem) );
 
     if ( dd <= elem )
@@ -1362 +1525 @@
         int thedd;
 
-        if ( pdebug>=1 )
-        {"// 1 dd = "+string(dd);}
+        dbprint( printlevel-voice+1,"// 1 dd = "+string(dd) );
 
         thedd=0;
@@ -1372 +1534 @@
             if ( n-1 > 0 )
             {
-                if ( pdebug>=2 )
-                {
+                dbprint( printlevel-voice,
                     "// 2 ps=fi["+string(dd+1)+"]"+" size="
                         +string(size(coeffs(ps,var(n-1))))
-                        +"  leadexp(ps)="+string(leadexp(ps));
-                }
+                        +"  leadexp(ps)="+string(leadexp(ps)) );
+
                 if ( size(coeffs(ps,var(n-1))) == 1 )
                 {
@@ -1392 +1553 @@
             else
             {
-                if ( pdebug>=2 )
-                {
+                dbprint( printlevel-voice,
                     "// 2 ps=fi["+string(dd+1)+"]"+"  leadexp(ps)="
-                        +string(leadexp(ps));
-                }
+                        +string(leadexp(ps)) );
                 dd++;
             }
@@ -1403 +1562 @@
         ps= fi[thedd];
 
-        if ( pdebug>=1 )
-        {
+        dbprint( printlevel-voice+1,
             "// 3    fi["+string(thedd-1)+"]"+"  leadexp(fi[thedd-1])="
-                +string(leadexp(fi[thedd-1]));
+                +string(leadexp(fi[thedd-1])) );
+        dbprint( printlevel-voice+1,
             "// 3 ps=fi["+string(thedd)+"]"+"  leadexp(ps)="
-                +string(leadexp(ps));
-        }
+                +string(leadexp(ps)) );
 
         for ( k= nv; k > nv-d; k-- )
         {
-            if ( pdebug>=2 )
-            {
+            dbprint( printlevel-voice,
                 "// 4 subst(fi["+string(thedd)+"],"
-                    +string(var(k))+","+string(resl[k])+");";
-            }
+                    +string(var(k))+","+string(resl[k])+");" );
             ps = subst(ps,var(k),resl[k]);
         }
 
-        if ( pdebug>=2 )
-        { "// 5 substituted ps="+string(ps); }
+        dbprint( printlevel-voice, "// 5 substituted ps="+string(ps) ); 
 
         if ( ps != 0 )
@@ -1430 +1585 @@
         else
         {
-            if ( pdebug>=1 )
-            { "// 30 ps == 0, thats not cool..."; }
-            lsr=@ln; // lsr=number(0);
+            dbprint( printlevel-voice+1,"// 30 ps == 0, thats not cool...");
+            lsr=list(number(0)); 
         }
 
-        if ( pdebug>=1 )
-        { "// 6 laguerre_solve found roots: lsr["+string(size(lsr))+"]"; }
+        dbprint( printlevel-voice+1, 
+         "// 6 laguerre_solve found roots: lsr["+string(size(lsr))+"]" ); 
 
         if ( size(lsr) > 1 )
         {
-            if ( pdebug>=1 )
-            {
+            dbprint( printlevel-voice+1,  
                 "// 10 checking roots found before, range "
-                    +string(dd-olddd)+" -- "+string(dd);
-                "// 10 thedd = "+string(thedd);
-            }
+                    +string(dd-olddd)+" -- "+string(dd) );
+            dbprint( printlevel-voice+1,  
+                "// 10 thedd = "+string(thedd) );
 
             int i,j,l;
@@ -1525 +1678 @@
                 "Numerical problem: No root found...";
                 "Output may be incorrect!";
-                nares=@ln;
+                nares=list(number(0));
             }
 
@@ -1541 +1694 @@
                         rn@++;  
                     }
-                    psubst( d+1, dd+1, n-1, resl, fi, elem, nv, prec );
+                    LL = psubst( d+1, dd+1, n-1, resl, fi, elem, nv, prec, 
+                                 rn@, rlist );
+                    rlist = LL[1];
+                    rn@ = LL[2];
                 }
                 else
                 {
-                    if ( i > 1 ) {  rn@++; }  //bug found by O.Labs
-                    if ( pdebug>=1 )
-                    {"// 30_1 <"+string(rn@)+"> "+string(size(resl))+" <-----";}
-                    if ( pdebug>=2 )
-                    { resl; }
-                    rlist[rn@]=resl;
+                   if ( i > 1 ) {  rn@++; }  //bug found by O.Labs
+                   if ( pdebug>=1 )
+                   {"// 30_1 <"+string(rn@)+"> "+string(size(resl))+" <-----";}
+                   if ( pdebug>=2 ){ resl; }
+                   rlist[rn@]=resl;
                 }
             }
@@ -1562 +1717 @@
             if ( dd < elem )
             {
-                psubst( d+1, dd+1, n-1, resl, fi, elem, nv, prec );
+                LL= psubst( d+1, dd+1, n-1, resl, fi, elem, nv, prec, 
+                            rn@, rlist );
+                rlist = LL[1];
+                rn@ = LL[2];
             }
             else
@@ -1574 +1732 @@
         }
     }
+    return(list(rlist,rn@));
 }
 
@@ -1581 +1740 @@
 "USAGE:   fglm_solve(i [, p] ); i ideal, p integer
 ASSUME:  the ground field has char 0.
-RETURN:  a list of numbers, the complex roots of i; 
-         p>0: gives precision of complex numbers in decimal digits (default: 
-         p=30). 
+RETURN:  ring @code{R} with the same number of variables but with complex 
+         coefficients (and precision p). @code{R} comes with a list 
+         @code{rlist} of numbers, in which the complex roots of i are stored.@*
+         p>0: gives precision of complex numbers in decimal digits [default: 
+         p=30]. 
 NOTE:    The procedure uses a standard basis of i to determine all complex 
          roots of i.
-         It creates a ring rC with the same number of variables but with 
-         complex coefficients (and precision p).
 EXAMPLE: example fglm_solve; shows an example
 "
@@ -1598 +1757 @@
     }
 
-    lex_solve(stdfglm(fi),prec);
-    keepring basering;
+    def R = lex_solve(stdfglm(fi),prec);
+    dbprint( printlevel-voice+3,"
+// 'fglm_solve' created a ring, in which a list rlist of numbers (the
+// complex solutions) is stored. 
+// To access the list of complex solutions, type (if the name R was assigned 
+// to the return value): 
+        setring R; rlist; ");
+    return(R);
 }
 example
@@ -1606 +1771 @@
     ring r = 0,(x,y),lp;
     // compute the intersection points of two curves
-    ideal s=  x2 + y2 - 10, x2 + xy + 2y2 - 16;
-    fglm_solve(s,10);
-    rlist;
+    ideal s =  x2 + y2 - 10, x2 + xy + 2y2 - 16;
+    def R = fglm_solve(s,10);
+    setring R; rlist;
 }
 
@@ -1618 +1783 @@
 ASSUME:  i is a reduced lexicographical Groebner bases of a zero-dimensional 
          ideal, sorted by increasing leading terms.
-RETURN:  nothing
-CREATE:  The procedure creates a complec ring with the same variables but
-         with complex coefficients (and precision p).
-         In this ring a list rlist of numbers is created, in which the complex
-         roots of i are stored.
+RETURN:  ring @code{R} with the same number of variables but with complex 
+         coefficients (and precision p). @code{R} comes with a list 
+         @code{rlist} of numbers, in which the complex roots of i are stored.
 EXAMPLE: example lex_solve; shows an example
 "
 {
     int prec=30;
+    list LL;
 
     if ( size(#)>=1  && typeof(#[1])=="int")
@@ -1633 +1797 @@
     }
 
-    if ( !defined(pdebug) )
-    {
-        int pdebug;
-        pdebug=0;
-        export pdebug;
-    }
-
-    string orings= nameof(basering);
+    if ( !defined(pdebug) ) { int pdebug; }
     def oring= basering;
 
     // change the ground field to complex numbers
-    string nrings= "ring "+orings+"C=(complex,"+string(prec)
+    string nrings= "ring RC =(complex,"+string(prec)
         +"),("+varstr(basering)+"),lp;";
     execute(nrings);
 
-    if ( pdebug>=0 )
-    { "// name of new ring: "+string(nameof(basering));}
-
     // map fi from old to new ring
     ideal fi= imap(oring,fi);
-
-    // list with entry 0 (number)
-    number nn=0;
-    if ( !defined(@ln) )
-    {
-        list @ln;
-        export @ln;
-    }
-    @ln=nn;
 
     int idelem= size(fi);
@@ -1674 +1819 @@
     }
 
-    if ( !defined(rn@) )
-    {
-        int rn@;
-        export rn@;
-    }
-    rn@=0;
-
     li= laguerre_solve(fi[1],prec,prec,0);
     lis= size(li);
 
-    if ( pdebug>=1 )
-    {"// laguerre found roots: "+string(size(li));}
+    dbprint(printlevel-voice+2,"// laguerre found roots: "+string(size(li)));
+    int rn@;
 
     for ( j= 1; j <= lis; j++ )
     {
-        if ( pdebug>=1 )
-        {"// root "+string(j);}
+        dbprint(printlevel-voice+1,"// root "+string(j) );
         rn@++;
         resl[nv]= li[j];
-        psubst( 1, 2, nv-1, resl, fi, idelem, nv, prec );
-    }
-
-    if ( pdebug>=0 )
-    {"// list of roots: "+nameof(rlist);}
-
-    // keep the ring and exit
-    keepring basering;
+        LL = psubst( 1, 2, nv-1, resl, fi, idelem, nv, prec, rn@, rlist );
+        rlist=LL[1];
+        rn@=LL[2];
+    }
+
+    dbprint( printlevel-voice+3,"
+// 'lex_solve' created a ring, in which a list rlist of numbers (the
+// complex solutions) is stored. 
+// To access the list of complex solutions, type (if the name R was assigned 
+// to the return value): 
+        setring R; rlist; ");
+
+    return(RC);
 }
 example
@@ -1707 +1849 @@
     ring r = 0,(x,y),lp;
     // compute the intersection points of two curves
-    ideal s=  x2 + y2 - 10, x2 + xy + 2y2 - 16;
-    lex_solve(stdfglm(s),10);
-    rlist;
+    ideal s =  x2 + y2 - 10, x2 + xy + 2y2 - 16;
+    def R = lex_solve(stdfglm(s),10);
+    setring R; rlist;
 }
 
@@ -1718 +1860 @@
          p>0: gives precision of complex numbers in digits (default: p=30).
 ASSUME:  the ground field has char 0;  i is a zero-dimensional ideal
-RETURN:  nothing
-CREATE:  The procedure creates a ring rC with the same number of variables but
-         with complex coefficients (and precision p).@*
-         In rC a list rlist of numbers is created, in which the complex
-         roots of i are stored.@*
-         The proc uses a triangular system (Lazard's Algorithm with 
-         factorization) computed from a standard basis to determine recursively 
-         all complex roots with Laguerre's algorithm of input ideal i.
+RETURN:  ring @code{R} with the same number of variables but with complex 
+         coefficients (and precision p). @code{R} comes with a list 
+         @code{rlist} of numbers, in which the complex roots of i are stored.
+NOTE:    The proc uses a triangular system (Lazard's Algorithm with 
+         factorization) computed from a standard basis to determine 
+         recursively all complex roots of the input ideal i with Laguerre's 
+         algorithm. 
 EXAMPLE: example triangLf_solve; shows an example
 "
@@ -1736 +1877 @@
     }
 
-    triang_solve(triangLfak(stdfglm(fi)),prec);
-    keepring basering;
+    def R=triang_solve(triangLfak(stdfglm(fi)),prec);
+    dbprint( printlevel-voice+3,"
+// 'triangLf_solve' created a ring, in which a list rlist of numbers (the
+// complex solutions) is stored. 
+// To access the list of complex solutions, type (if the name R was assigned 
+// to the return value): 
+        setring R; rlist; ");
+    return(R);
 }
 example
@@ -1744 +1891 @@
     ring r = 0,(x,y),lp;
     // compute the intersection points of two curves
-    ideal s=  x2 + y2 - 10, x2 + xy + 2y2 - 16;
-    triangLf_solve(s,10);
-    rlist;
+    ideal s = x2 + y2 - 10, x2 + xy + 2y2 - 16;
+    def R = triangLf_solve(s,10);
+    setring R; rlist;
 }
 
@@ -1756 +1903 @@
 ASSUME:  the ground field has char 0;@*
          i zero-dimensional ideal
-RETURN:  nothing
-CREATE:  The procedure creates a ring rC with the same number of variables but
-         with complex coefficients (and precision p).@*
-         In rC a list rlist of numbers is created, in which the complex
-         roots of i are stored.@*
-         The proc uses a triangular system (Moellers Algorithm) computed from a
+RETURN:  ring @code{R} with the same number of variables but with complex 
+         coefficients (and precision p). @code{R} comes with a list 
+         @code{rlist} of numbers, in which the complex roots of i are stored.
+NOTE:    The proc uses a triangular system (Moellers Algorithm) computed from a
          standard basis to determine recursively all complex roots with 
          Laguerre's algorithm of input ideal i.
@@ -1774 +1919 @@
     }
 
-    triang_solve(triangM(stdfglm(fi)),prec);
-    keepring basering;
+    def R = triang_solve(triangM(stdfglm(fi)),prec);
+    dbprint( printlevel-voice+3,"
+// 'triangM_solve' created a ring, in which a list rlist of numbers (the
+// complex solutions) is stored. 
+// To access the list of complex solutions, type (if the name R was assigned 
+// to the return value): 
+        setring R; rlist; ");
+    return(R);
 }
 example
@@ -1782 +1933 @@
     ring r = 0,(x,y),lp;
     // compute the intersection points of two curves
-    ideal s=  x2 + y2 - 10, x2 + xy + 2y2 - 16;
-    triangM_solve(s,10);
-    rlist;
+    ideal s =  x2 + y2 - 10, x2 + xy + 2y2 - 16;
+    def R = triangM_solve(s,10);
+    setring R; rlist;
 }
 
@@ -1793 +1944 @@
          p>0: gives precision of complex numbers in digits (default: p=30).
 ASSUME:  the ground field has char 0; i is a zero-dimensional ideal.
-RETURN:  nothing
-CREATE:  The procedure creates a ring rC with the same number of variables but
-         with complex coefficients (and precision p).@*
-         In rC a list rlist of numbers is created, in which the complex
-         roots of i are stored.@*
-         The proc uses a triangular system (Lazard's Algorithm) computed from 
+RETURN:  ring @code{R} with the same number of variables but with complex 
+         coefficients (and precision p). @code{R} comes with a list 
+         @code{rlist} of numbers, in which the complex roots of i are stored.
+NOTE:    The proc uses a triangular system (Lazard's Algorithm) computed from 
          a standard basis to determine recursively all complex roots with 
          Laguerre's algorithm of input ideal i.
@@ -1811 +1960 @@
     }
 
-    triang_solve(triangL(stdfglm(fi)),prec);
-    keepring basering;
+    def R=triang_solve(triangL(stdfglm(fi)),prec);
+    dbprint( printlevel-voice+3,"
+// 'triangL_solve' created a ring, in which a list rlist of numbers (the
+// complex solutions) is stored. 
+// To access the list of complex solutions, type (if the name R was assigned 
+// to the return value): 
+        setring R; rlist; ");
+    return(R);
 }
 example
@@ -1819 +1974 @@
     ring r = 0,(x,y),lp;
     // compute the intersection points of two curves
-    ideal s=  x2 + y2 - 10, x2 + xy + 2y2 - 16;
-    triangL_solve(s,10);
-    rlist;
+    ideal s =  x2 + y2 - 10, x2 + xy + 2y2 - 16;
+    def R = triangL_solve(s,10);
+    setring R; rlist;
 }
 
@@ -1828 +1983 @@
 
 proc triang_solve( list lfi, int prec, list # )
-"USAGE:   triang_solve(l,p [, d] ); l=list, p,d=integers,@*
+"USAGE:   triang_solve(l,p [,d] ); l=list, p,d=integers@*
          l a list of finitely many triangular systems, such that the union of 
          their varieties equals the variety of the initial ideal.@*
@@ -1837 +1992 @@
          l was computed using Algorithm of Lazard or Algorithm of Moeller
          (see triang.lib).
-RETURN:  nothing
-CREATE:  The procedure creates a ring rC with the same number of variables but
-         with complex coefficients (and precision p).@*
-         In rC a list rlist of numbers is created, in which the complex
-         roots of i are stored.@*
+RETURN:  ring @code{R} with the same number of variables but with complex 
+         coefficients (and precision p). @code{R} comes with a list 
+         @code{rlist} of numbers, in which the complex roots of l are stored.@*
 EXAMPLE: example triang_solve; shows an example
 "
 {
-    if ( !defined(pdebug) )
-    {
-        int pdebug;
-        export pdebug;
-    }
-    pdebug=0;
-
-    string orings= nameof(basering);
     def oring= basering;
+    list LL;
 
     // change the ground field to complex numbers
-    string nrings= "ring "+orings+"C=(real,"+string(prec)
+    string nrings= "ring RC =(complex,"+string(prec)
         +",I),("+varstr(basering)+"),lp;";
     execute(nrings);
 
-    if ( pdebug>=0 )
-    { "// name of new ring: "+string(nameof(basering));}
-
     // list with entry 0 (number)
     number nn=0;
-    if ( !defined(@ln) )
-    {
-        list @ln;
-        export @ln;
-    }
-    @ln=nn;
 
     // set number of digits for zero-comparison of roots
@@ -1876 +2013 @@
     {
         int myCompDigits;
-        export  myCompDigits;
     }
     if ( size(#)>=1  && typeof(#[1])=="int" )
@@ -1887 +2023 @@
     }
 
-    if ( pdebug>=1 )
-    {"// myCompDigits="+string(myCompDigits);}
+    dbprint( printlevel-voice+2,"// myCompDigits="+string(myCompDigits) );
 
     int idelem;
     int nv= nvars(basering);
-    int i,j,k,lis;
+    int i,j,lis;
     list resu,li;
 
@@ -1901 +2036 @@
     }
 
-    if ( !defined(rn@) )
-    {
-        int rn@;
-        export rn@;
-    }
-    rn@=0;
+    int rn@=0;
 
     // map the list
     list lfi= imap(oring,lfi);
-
     int slfi= size(lfi);
+
     ideal fi;
-
     for ( i= 1; i <= slfi; i++ )
     {
@@ -1925 +2054 @@
         lis= size(li);
 
-        if ( pdebug>=1 )
-        {"// laguerre found roots: "+string(size(li));}
+        dbprint( printlevel-voice+2,"// laguerre found roots: "+string(lis) );
 
         for ( j= 1; j <= lis; j++ )
         {
-            if ( pdebug>=1 )
-            {"// root "+string(j);}
+            dbprint( printlevel-voice+2,"// root "+string(j) );
             rn@++;
             resu[nv]= li[j];
-            psubst( 1, 2, nv-1, resu, fi, idelem, nv, myCompDigits );
+            LL = psubst( 1, 2, nv-1, resu, fi, idelem, nv, myCompDigits, 
+                         rn@, rlist );
+            rlist = LL[1];
+            rn@ = LL[2];
         }
     }
 
-    if ( pdebug>=0 )
-    {"// list of roots: "+nameof(rlist);}
-    // keep the ring and exit
-    keepring basering;
+    dbprint( printlevel-voice+3,"
+// 'triang_solve' created a ring, in which a list rlist of numbers (the
+// complex solutions) is stored. 
+// To access the list of complex solutions, type (if the name R was assigned 
+// to the return value): 
+        setring R; rlist; ");
+
+    return(RC);
 }
 example
@@ -1949 +2083 @@
     // compute the intersection points of two curves
     ideal s=  x2 + y2 - 10, x2 + xy + 2y2 - 16;
-    triang_solve(triangLfak(stdfglm(s)),10);
-    rlist;
+    def R=triang_solve(triangLfak(stdfglm(s)),10);
+    setring R; rlist;
 }
 

Tst/Long/solve_l.res.gz.uu

@@ -1 +1 @@
 begin 640 solve_l.res.gz
-M'XL(""Q>X$```W-O;'9E7VPN<F5S`.U=6V\;1[)^]Z\8&'D010[5]XL#^6&S
-M^V!@SWG)P7D)$D.[D6P"LF1(BI?VK]^OAUW5/>1('"HF`@AC&)8X4UU=]?6E
-M+NPN__Q_?W_WOTW3R+?-V=FKG_,GM<2GYO[V^LOE^_OEP_U#TS;W'V_O'IJ'
-MR_N'^^;J]JYA8KTLOYME\\]W?VM>H\GR>O6OUS_R&_NVP</WJYO5P\GLQU?I
-M9_/V;>[C>GES^9_E_</%`].[3/_AYO;N\N3U3___<_/N[\T/[WY_PVWP?O&E
-MD4O5R!CCF91G,C32O='AC;;-[;\N_OWQT\5-\X_UY^:'U^@3*A66;YH_RY)%
-M]6\+`"$#T#'<@B`6.BD2PH__83I9P)48E0J2YO7=ZN9#<W<OF_-&+$[6BZ^+
-M;[/%]><?7S>[RCY&R\SUVRV:CXL!*E.I8)?-Y]OKK\V5.&_6\Z_S;W-9"#%\
-MFY<2+W]3S;QQIVO\JT^_=K]_PXPRA=P3N3IOOG;D"N2M[ZAM]_%;H0Y$K8GY
-MILTW_-LVE11`?/7[Y<5ULSJ_DHLKM;C2_%()?OGI_$HL=@ED458!^S_N+N_?
-M=^-Z\O'VT^V'D]7BXVPA@?4O\M<WKS#`]!-_6K&4T7LMK%+26Q6EM"I$+:2*
-MUDBA.WK%]&(90O`^6.F,-D8[K[TR4>BHO!-!=N2Z(C=2FRB],,(&J81USAJ%
-M28LN@_*OB'4E4FKCC?!1ZA"LU58J%X-344`V(\.`1'CNHQ/66R.T=5J"UIL8
-MA3=V2R(HK""&U<9:Y4(T446=_EHEM58BO"+B2J23UBVALY86>@KA`(T+`A`H
-M;:.%]F;^[M0M#9!34AJ1%/!..>-\"#HZ;9Q2LRW!3R`*9!:`4-D$JD1;K:&Z
-MD,';J!28ZJ6$5M8$&0"DL]+C-V<,."L1E9UMJ7?BEM$!"N6U]!IHV:"DTE$;
-MC4=:=W):C?'6&`(EG(XQ8.2$LR+!XHV<O?K%/`.!]A@(M-\?@784`G8``;LT
-M7@43H;?T^(-9IH-T6#<&784T7&&I++K!!`_:A"2S$\Y%*?!$0X@=!/S2A>`L
-M]--8;!`:=%HZB?7E78"L9HE5Y8,727Y`[8)+N.)W`QVMVU$_+,$N*A,<-(_.
-M1FDP)B+B$;!PII,RF&[!`G/CA=#@CA7AH!N@LQBG7]PS]&^_N_[S(^C?CM+?
-M[^J/G=($C2F=I@TFF+$@UD``:F*[D7FPM$XH81Z+3E8KTP9H,<.<L3OJNZ70
-M$K):8Y2/WF'-`+F@C,9T]"*"IUA"=AUE,-)(,()&R@-=B6YL&H0=!+##^0"M
-M%/9S;(T0$M@#T8BEAMW.=:A"S)@6A(7V$ATZAZ&,V-?3%NV!0#@<@?D1$)@?
-M`X%V#`)D4N%Q?/K\/AG53Q</9%(_D4U]#X#./YY^N+PYD;.V^R%F<]L]"+/6
-M=+]`[?=0.M.IV7S=:^"H@3340LK97&4F<U>8:&*B9_.O/2:1F7AFHF9P33(3
-M79@88F)F\V\U$\6B2Y9=ZF%)[*_GZZS.IBUKH5@+Q5I`L]PX:48P,3-'$CG"
-MAO4C]JR?8OU@48B])TVKCA0IC2[1AZ<^//7!ZN<^-*NO6'W%Z@.2765TI1;Z
-M"+^>?\WB;SAJXJ@E2^A9+M6'(B06D<2,A`"+24P-,U4LIF7VH0*%.M(5*&G*
-MBE_/OV7>&Y:VUK+HEJ5+33#-%0UOIE`TE"[_[#"0BF:&(Z:*AZ=JS,/#;&+^
-MN9%1$QO/;%BUBHW>ED9E-"%_8F-H2%B:,A2*$5)J2Q73-;:\MBU-&AX63\-2
-M&/-ZJR3U+)_ESG0%0NK&T7#T5"T*9LD2*69Q[D-OP^8[`IZ"D831JM*<1+!;
-M8'5S3T82)%8Z5?+G_M)NABF4&:1/,G_*\*EN)BB5GV8)-]HJO7FJ<]>J&R=E
-M\M.L+G/J!D+Q;B.S%&D19*G2>Y=;6VZ=GOJM_CN$%"/$O$B2#@3%(-![U6FL
-M!<N=/LF^O+K36&>-23K=::QU7SK=::P-TZ9/EFG8\E11K++#0;4Z(*C>H67F
-M[NU^FBI[H,)V2%W(XD$!M1:'!-1:C@RHM7HBH-9Z3T"M*]RU[074JRF*GJ+H
-M*8J>HN@IBIZBZ"F*'A]%:]>+HE>?*'2NG="0W:,<T>:@6?7"QD!>+4<LBF/6
-M'""K7G#%;G!QTSG*R\%P'>WXS0^30]RZ:_(&<\!:8L$<)9586U&'ML3+V1<E
-MGS)2=YNHL6:587`Y&JQCFTC2M2R))$=\*YCT&QI+P5O/A?<<(K7]P"U#*IBN
-M"JL+KK8*>24CSG$<CY$L826#GJ,[TQ]ZAE%1W*7Z<5FLPV?%W#EODL.H7L04
-MMB.G'D?"P%+8E,.-?E#%<5$=E/!;E_$S6R%1E>N@O`M%49Q7Z<5-<C=KX>B1
-MYB"_%U1Q8):PT_T,C>MGGG0!QC%TF@(]ET//W,35X5@)M*ML`NL7J4V@($WU
-MHTO#`3''H$E52[.L"MV4V\T,2%\)3+B9LJE4,8E&3'+UX?H3.>H+A&E=('1S
-M\>FRN;UJ;B[_TP4Y;U*4\U-Z<[VZ?TAO[FYO'^[Q.'UF=HACN@>#_O[W=:[=
-MX<[UKK__G4.0@R.0`7=_KZE?'<'4KXYAZE=C3/V`N[_7U!\!@?DQ$&A'(3#D
-M[C\=\!A(^W2\H_TS(K[5]X_X5F/BG2%_?P\`[3$`:+\_`.TH``8<_GT!3P"T
-M3P<\*4'8'!3PK8X0\*W&!#P#[OY>_=OOKO_\"/JW8_3/QM.(8I>-7#;WEP^4
-M7N0DFU%O&SR]N/GPSS]KLO'\]+2YN_S]\FIUD_OYB?O1DR$_NB%_63'[<PSY
-MBXK9GV7(]R4NGV7(_ZK4[7,,^3$`^,LRM\\RY/LREX<;\K\L<_LL0_[=]?_+
-M,K=D/*MOPHQ]Q)`[-N17Q[7D?K+DDR6?+/EDR2=+/EGRR9(?9LE#9<GCL"6W
-M@BSY_QS5D%LY&?+)D$^&?#+DDR&?#/EDR`\RY%850V[UN-NYUI3;N?:1@\0Z
-M'_R5B[5:K/6^L\1#Y-Q%.4Y,9&(Q3%E]@6][AXKE?*WF:UU=U;7UR>)6;@X6
-MR^[@K\$OIVO5G3)>J^Y1Z!YI/)("S_*O>*U_*PZ/JT\?MR"2:*DV7.?-6FT^
-MJ=\R9\E=Z<UOBG_K<>V=4DZ-+`FZS@><.VDKYH&YLK3MKK1/'6IV^PXUNRJ5
-MX^S@+>&U>/2:\$GG`@EX95K!*`6?U@^,4PA&1;A#W4XCEEXZ>%_6QV0Q,<6#
-M4M@YG=31^G1N8VNER64RLU@U6#9:8K$%I05(C0[=\AW-4_<$U6G+]U9@"\6:
-MA1>(Y8[=%=LWUKO:>#%8L;#(6,$&5-AT8?(U["WV$=AT[`D#7N!^#-HC8#":
-MYR$8S,=A,'2$&QB(Y$_YF)QRA\TJ1(B3W%OL<<)VK.&^&D"#G=@%%:`3S)F'
-MM=5PHL2NVP6F,)S!6.S83F('A7$.`NZYQG:9-N#13'MN5S*C&"FT"Q@@N/L"
-MME^G8]8633<86)4B#8M1!<82J$H8W0!O`BJ&1SS/O1BTQ\!@--,#,&C'83#D
-M>Z9VL()1POKA;X"D+L+S2OZK3V%8AR_<'`1E$<XV_"]$<G#2$4<A)-)HN7N.
-M62Z!'Z;AIG,T3O(XI0)6!@!1HWGV%X-+J]5CB.#3(]`3-AJ;@@1$98@".Z9:
-MP9%(7CY"/&>2,PG8'$RTAV+V$?=S+P;M$3`8S?,0#-I1&`P>YT;PBLFGHH?7
-M#+_&)C]9IXT)LL7-#).(N!``IS@M:JP8!2+L2)AX"'O"T%)0`LXT-B-H'!'$
-M)U<=ZF/#3:F`.)II;RD(C(Q!].4!`181MD(K/"#&A@IG;@.!%)#9IMT5<$,A
-M_`M:A!0!@_K8<>ZG$9@?`X'13`]!8#X"`?(@W/"E:'(ANJ/=:Y$/NI:#R(J?
-MIDO0LGZ_?2\XY-/<F5Z#7O7H5;ENS?2&Z0WH=8]>TZUE6=_YW;G#:F:MI6.N
-M[=#%9\=].-:A2$=LU=9)85_N>F^=IQ:]L[J>N7OF7G0A[G1)LMS>G(<M;F'6
-MAL(V@"V=?F^W!5.[^E:WQ2-+%%G+(E%FE^X?;TG42K$CTCP_LW1R/7,!Z%(/
-M4%=BR.TKIF6@'*M@^M>QNZO(DL:J:U6N@K:/<(O,K9PT=]7Q[')#GVXI2QJO
-M#I!RF;3E<\[$L8R3J\XSEPO7><@R;\.#YOCB*%TV;;>T(4F+]#4JI2!`[TI\
-M.F=/J]3R="O#['F828!RK[7=4G9>K@X$%L40D#P9:KU+A0'26_$,R0(ZGB($
-MKR7^BF=*-]GT`/_`=P]D3^UTB7H;SQW\ZFOZ^89`AB66>_@$!BO/BL9JT`L.
-MU85\(E1TPV"M>]PM\^K8ZFU0>VR)6:6JHCL)U+8'&)-INH=`LY7G3>^B?[YY
-M0$2L79EZO0/\I0!$OG^0&VI>"XK7@N(QZUWKSZ.769C"0A,+S>4E*GEJ\:LZ
-M$;IF5JQ`NE>0V1IF6^[+\V16C+LJD[G2V%8JE,H1I$*9UED`5[3A^:QY>%29
-MSSULB%T9Y,S.T\6+@DU_A+C(0;[_3J:4[^>DN1R8A2%X6\:!=8[5`%:0<!F*
-MJL8!-5%TK9XL<NFV:,^XI>646^HR\:L!Z/4;N%_JK4)'T;W]0+T1NQ[83*_I
-M9G^[#6>YWM\R8"REKF9.P:Y46L@E`%I5I!"%B=Z&O<>$M+)4,H#;5LK4V+$R
-MELH*,%DI+>"JQ)L+PQE!<UA&<(B<NXAOQY#YZMRPEP/IP$*IOGLRT.MC)`.]
-M.4XRT-LGDH'>[4D&^FKX?1A3X6!*`$X)P"D!."4`IP3@E`"<$H!3`M#'1^HY
-MN.VP17`8WKM`+CG))7N))*KZ0$%&N?=-F3-+WC9'!([J,]3WY(O#783A._^N
-M3GH9DF3#BUSIG$\L4505/&=FQ$16.:L-K_RY5T;"]LI(R)Q+K'6C9%1.!+9<
-M\+"Z.Q^>$"*#&C90>@X03$X!5K%A*=!(H\2%&JH2E'V(J#YART4222Y5)66X
-M7@/7BZ@S@7G@)"5UZ@H6@CLLM3&D[%?`*'5`<GZO"E%+Q<8LU&X"C$I##*3Q
-M2FJ#M-*LU2!,)5-%B6A2*U#ZKF0]JL*%X0DQ2QZ'D]QR.V-'@MHJZ5?2BKN+
-M1%*V.N?A.:2F#%O)_.PF\097#"_>-C/F-4S9M5)IT3!O6L\\9\H6P7.&UVG.
-MN.T$ULISA;^6AVE@-O-:K<MWE`J&56$0+MOAN'553U'ULP&&YTA>`;O)IFI<
-M>TDPJML1^#UU5Y?H(,[$92#[-92<&A"GY$/H&XE6;F?!6BY.6M6=#$^,6)61
-MI"&C^>FW,UNJRLX1T\'1*[DQ^@Z!F0;*;U5IEY+JH#FVLP54@/"TR:DO=[KU
-M1G$22=2%6<N>->?-JOHB*S*G6(U\R5D.)'HE<PJT<')ZRFW+W\OU:=H=AK*\
-MDK;4G+ERVPN/OP=*`UJ*G9:!G)<!;//>D5-=;GOM1>;EA_)\14$9^.NNG/QR
-M6TM(LU^0!DOSYCB0Q2L5CBD%QAG;.:],2B,.SHHJ=TF8$/-2HBI4V:<@#Z@F
-M8_96DPGJJ1/O8V*IU1%BJ;$\#XJE5F/BB.'<RKY8Z@@8C.9Y4"PU"H-'<BM/
-MYY=61\@OC>5Y4'YI-2J_]$ANY>D\XQ$P&,WSH#SC.`P&<BM[(\K5,2+*L4P/
-MBBA7(V+J@<S*WJS",1`8S?2@K,(8!(:.]N_-,:Z.D6,<R_20'.-J5(YQZ'C_
-MWESS,3`8S?207/,H#,A;T)4C8NJ[>J5P=K"'E<]YPD<9N*MG^*Y><'_6<WE9
-M6>#G>2XO*PO\+,_EA7TS]BS/Y85]0_H<S^5%Y<*?Y;F\K.]#GN6YO+!O1Y_E
-MN;RL;\G)6ZC.E83PB.<2#ZP7]%S7)8K)=9E<E\EUF5R7R7697)?)=9E<EZ=<
-MEUC]+]I1#;LN41]6(.G9GHN9/)?)<YD\E\ESF3R7R7.9/)?)<WG2<[&5Y^+&
-M582*OE2$BH_<_W+T/\'NN_G5)V2VY<[7(($47'VI.6^D7:?_[;6[F=5=AY*B
-M$,(UN[[X\,?EW=UE]KNNJEM*8HG=-]5RL^PI=*.F-X7Y-E_G:9L*[LEB2&N2
-M=HLDVYE4N2]J83`R'07LC!8B_8?$M`M7%/,^!8E>JG7!C"QWU%A(,:2)\7%(
-M%QUTK8WP85`?D+4[9+LZ&5-KI:,;U,N8^385Z6,JW1ZI*O;O\^;D[O+B>J'$
-MXMULL=XSDX;(N8M25>Q),E_-JA-IEZFZG)V=KG]+\^M$V:6X;).A4>E9-=U.
-MWQ4>X<D)EZ#&TO7:PS53$EN_ER*:C5L`S%-MR>2*I-J3$JZBF?4&$WX%_`"+
-MK1_[1\`N)8WI-CWGX52F`G#P)[#)`/M87<+J;(<-7;$[#5N#F1)3H;BNUYB*
-MET8GDS<"[S05N.L/>JHK:5(UT1!L\I/A=VQVV@`W6F#G2J4IK;,:>XOM302H
-M:&!2L9-A]).FV$MS+("9"F]%XS4\6OSFJLD1R^208M2F)*5<EC8(P?)H^WQC
-MM+=Y2*YW]N5<NH58X(EW6$X&`(I%@$#`Q!5Z3-;5S</E'>;&Q0-FJ%XT7Q:-
-M27-1K4VKU%K-M6-R6XGO6)30E)WL]TH83\)\!H%:Z/(F%#$;N<"KA5G8A5OX
-M15A$B`NY%U(MI%Y(LY!V(2N1J>#=ZO-Y7_;/BR\+G23/E`H[Z0KBR#,#2V$0
-MBL!Y#*G"I#!BK;_J.;Q6F(UXAKF)J,+:1`#G-@2\5:U/M1#/I'$>HVE3\5T8
-MI`BV:Y7:(K;"%(??<I8*HUK$0?@L%9K.K?0.'@PFTQDF/MX%^"@:X8U+;54+
-MFV@Q+?R9==Z+Y/^B!TP<L4Z,%89,8S'(,WC-F$!.!(B+8<`+A65@(3`6(R:G
-M394;P;&MWTEX6)U#;BSVW#6ZJSC"M=)>P#7#T$N!WEB4KOQJDJ^MI$^5/!'Y
-MP7:OT4G16*=JKS#6$MK,,T[H3*Q;@E3#AD?SM94:&VT0<#,D8CWCS\`1@P%A
-J@6ET@@>K)!JD4N-6AM)E92BSV6KO'RX>_K@_D;,??WCU7R0P\``>CP``
+M'XL("$/8=4(``W-O;'9E7VPN<F5S`.U=6V_;2-)]SZ\@@@'6BDBY[Y<$]L->
+M'@+L?@\[BWT9S`2>1$Z$]26PG(R27_^=IKJKFQ1M49X(`V08!+%,%JNK3M].
+ME=B5'__S]]?_5U45/Z].3Y_]&'\3"_Q6K6^O/B_?K!?WZ_NJJ=8?;N_NJ_OE
+M^GY=7=[>520L%_FS6E3_?/W7ZCD>65RM?GW^BN[H\PH7WZQN5O<GLU?/PL_J
+M_#RV<;6X6?ZV6-]?W).\B?+O;V[OEB?/__;?'ZO7?Z]^>/WN)3V#^_7GBB]$
+MQ;WWIYR?<E=Q\U*ZEU)7M[]>O/UP?7%3_6/SL?KA.=J$2UGER^KWJB13[7D&
+MP$4`6H4]"'R6XRP@_/`?DN,97(Y>*2"IGM^M;MY7=VM>G56L/MG47^JOL_KJ
+MXZOGU:ZS#\F2<GG>D_E0#TBIP@6]J#[>7GVI+ME9M9E_F7^=\RR([MO>Y+CY
+MBZCFE7FQP;_RQ9?V\U>,*)7%;1(79]675EQ`O+&MM&Y__9JE79*62?GVF:_X
+MMZD**X#XZMWRXJI:G5WR^E+4EY)N"D8WK\\N6;TKP+.S`MA_NENNW[3]>O+A
+M]OKV_<FJ_C"K.;#^B?_\\ADZ./W$GX8MN+=6,BT$MUIXSK5P7C(NO%:<R59>
+MD#Q;..>L=9H;)962QDHKE&?2"VN8XZVX+,05E\ISRQ33C@NFC=%*8-"B22?L
+MLZ2Z,"D\8Q6SGDOGM)::"^.=$9[!-L7=@$6X;KUAVFK%I#:20]8J[YE5NF<1
+M'!8P0TNEM3#.*R^\#'^UX%(*YIXEX<*DD\8LX+/D&GXR9@"-<0P0"*F]AO=J
+M_OJ%62@@)SA7+#A@C3#*6.>D-U(9(68]PT]@"FQF@%#H`"K'LU+"=<:=U5X(
+M*)4+#J^T<MP!2*.YQ2>C%#0+YH6>]=P[,0MO`(6PDEL)M+037$@OE<0E*5L[
+MM41_2W2!8$9Z[]!SS&@68+&*SY[]I)Z`0',,!)IOCT`S"@$]@(!>*"N<\O";
+M6_S!*)..&\P;A:9<Z"ZW$!K-8(`[J5RPV3!C/&>X(F'$#@)V89PS&OY)3#88
+M#3G)#<?\LL;!5K7`K++.LF`_H#;.!%SQ6<%';7;<=PNH\T(Y`\^]T9XK]`GS
+MN`0LC&JM=*J=L,!<6<8DM&-&&/@&Z#3ZZ2?S!/^;;^[__`C^-Z/\M[O^8Z54
+M3F)(AV&#`:8TA"40@)M8;GCL+"D#2AC'K+55\[``:HPPH_2.^V;!)(>M6BEA
+MO368,T#."24Q'"WST,D6L%UZ[A17'(K@D;!`EZ,9'3IA!P&L<-;!*X'U'$LC
+MC`3V0-1CJF&U,RVJ,-.'":'A/4>#QJ`K/=;UL$1;(.`.1V!^!`3FQT"@&8-`
+MVE+!.*X_O@F;ZO7%?=I2K].>^@8`G7UX\7YY<\)G3?N#S>:ZO>!FC6H_P.TW
+M<#K*B=E\TWG`I`>X2D]P/IN+J&1NLA*9E,C9_$M'B2<EEI2(&:A)5"*S$I64
+MJ-G\:ZE$D.F<;.=RV!+]\]DFNK-]EKP0Y(4@+^!9?#AXEF`B92999!(VY%]2
+M3_X)\@\[2E)ODZ=%0R(YC2;1ADUMV-0&N1_;D.2^(/<%N0](=IV1A5MHP_U\
+M]B6:O]4HDT;)R4)+=HDN%"ZH\,E,GQ`@,Y-214H%F:E)O2M`20W)`I0P9-G/
+M9U^C[JU*77J9?8O6A4<PS$7JWB@A4E>:^+/%@(LT,DQ2*JA[BH>I>TB-CS^W
+M-LJDQI(:<JU0(_O6B(@F[`]J5.H2LB9WA2"$A.BYHMJ'-<UMG08-=8M-W9(5
+MTWPK++5DGZ;&9`%":,:D[NBXFAV,E@51C.+8ANS#9EL!&H(^&2-%X7DR0??`
+M:L<>]\D07_A4V!_;"ZL9AE!4$'[C\;<(GVA'@A#Q:K1PZZV0VZLR-BW:?A(J
+M7HWNDJ:V(P2M-CQ:$29!M"K<-_%I34^'J[;7?HN0((1(5[*D!4$0".F^:#V6
+MC.P.O_&NO;+U6$:/DW6R]5C*KG6R]5@JD@V_:9*AG:>(8H4>#JK%`4'UCBPI
+M-^?[98KL@7#]D#J+^8,":LD.":@E'QE02_%(0"WEGH!:%KA+W0FH5U,4/471
+M4Q0]1=%3%#U%T5,4/3Z*EJ831:^N4^A<DE`7Z5&,:&/0+#IAHTNLEB(603%K
+M#)!%)[@B&IQI.D5Y,1@NHQV[_:%BB%LVG=A@#%AS+!BCI!QKB]2@SO%RY**)
+M4_K4W#9J+%5%&$R,!LO8QB?K&K*$)R+>"R;M5D:GX*U#X2V%2$TW<(N0,I(K
+MPNJ,JRY"7DZ(4QQ'?<1S6$F@Q^A.=;N>8!0I[A+=N,R7X;,@[90WB6%4)V)R
+M_<BIHS%AH%/8%,.-;E!%<5$9E-!=$_%3O9"HR'6DO$N*HBBOTHF;^&[6PJ1+
+MDH+\3E!%@5G`3G8S-*:;>9(9&$/0R13HF1AZQD=,&8[E0+O()I!_/CWC4I`F
+MNM&EHH"88M#@JDZCK`C=A-G-#'!;&)QP4WE1*6(2B9CDW?(RQ#%_.[M\?W6=
+M&'N->.W5LQ`2_25?_DOU]FYY<;]\5UVTD4]=K6ZJWSZLWG[`A:O5^KZZ:_^]
+MO:QN/EW_NKQ;5R?W'Y9!R]O;ZX]7RTWX*O;3_>KV9CVK5NMJ?8](Z]VB"A+_
+MN:TNWKY=KM<5'JF2GIWGZNK^R\=E=;*Z;.5N+JZ7U;^KWR[6U<5ZC=`-QK6!
+MW&U[^VYY_^GNIOI\<?5I.7M9Q36ZJM;+^S9T^_>KK<FO,B((Q=+=@`K%-PI!
+MUU9V*);YMH&#.3QPV(UEOG%X=7!T-1#*[*4QJR/0F-4Q:,QJ#(T9"&7VTI@C
+M(#`_!@+-*`2&0IG'@SD%:Q^/Y:1]0C2[^O;1[&I,+#<4R^P!H#D&`,VW!Z`9
+M!<!`,+,OF'.`]O%@+B0_JX."V=41@MG5F&!N()39ZW_SS?V?'\'_9HS_:?,L
+MWK918I%WV+7(&ZP\K_ZWNKKJ;;OJ/#,4/'1Q\_Z?`R2E<^?/P%.4[O&4B9P<
+MFYQ\7SF6IY"3[RK'\B1RLB_1_"1R\D>EVI]"3HX!P!^6:7\2.=F7:3Z<G/QA
+MF?8GD9-O[O\?EFE/6ZDIR(E]@)RX07+B=\G)Y</LY/+/0T\TF^C)1$\F>C+1
+MDXF>3/1DHB>_@Y[H(G>B'\B=Z,'<B=[-G?SK07;RKS\1.9ER)Q,YF<C)1$XF
+M<C*1DXF<_"YR8@:)1_&*B7;C#L-KGP_#&S;\WKZ,[]GS>B/JC=SWZOZ0.#7!
+MS_MBK!Z6%-D9(\MW^/E\(^8;69R,-ZIXD;_AV_?X>?N>O<*'%QO1OM2_$>TE
+MUUZ2N,09KL6/N"U_R=3.Z.)E_P9"'$^*K=9YM1';W\0O43.GIN3VDZ!/':VF
+M/!00'M+)T$T\3]!:6RAWI)6L;7:MM8^<(3!NSQD"4Q11L&SP4/Z&/7@J_Z0E
+M1@Q<30IL5<Z&684MRSDE/$A2N_ZPA>4&G$Q;'_91#'PG!-93PZ77-KPFU9M_
+M?!$V7\PE3";),06=D`RB2KIV4H_6*3N&RK`16,VPL&(F@QMB$<":BT4=JX#8
+M<AO,8^S3F-<*4EB*000D=F&L+MCIL5(,<,/]&#1'P&"TSD,PF(_#8.C$!#!@
+M@659'ZBZP1+F/,P)I!<K'].M:I!:!6BP/ALG''S")F>Q!TM0*[9+QJ`4VZE3
+M&NNXX5A7L64[!M(NL8B&97FTT@X9"YLK>@K/.700@@`&1B##J0:-1[<8:!'B
+M#XU>!<8<J')LQ0X<`RZZ!_CH7@R:8V`P6ND!&#3C,!ABI.$Y[(V>8T_$7P=+
+MC0<?"ZS6AN"LQ1?D!Z&:!P4'*T-\!^J.Z`J!DL23N\<&^`+X81AN&\?#P1XC
+MA,/,`"!BM,[N9#!AMEIT$9@^PC^FO=(A=$"LAMBP52H%Z$7@_@C\C`H4$[`9
+M;-P6CND'2.E>#)HC8#!:YR$8-*,P&#P]@9`6@T]X"RX-MJ,#>Y9A88)M?CO"
+M..(PA,4A>O,2,T9`""L2!AZ"(3<T%00#Q<9B!(\]0OM`X.$^%MR0(/"CE7:F
+M`D//*,1D%A!@$F$IU,P"8BRHH'A;"#B#S3JLKH`;#N%?R"+0<.C4ATY//([`
+M_!@(C%9Z"`+S$0@D!L&':Q`D"M&>I-BP^%YY?N]?T-50<X"7]_O'\%T\/!'E
+M)>1%1U[DZ@8DKTA>05YVY&4J$L#+(_8[1\;5K-'IK?)FJ,Z`H38,^9"M2VI%
+M[\5\FTLK](XOL,ZK\9:T6]*>?4G:TYGD?%AZ[GK:W*QQ6:V#VG38I.D;)G;]
+M+8HS>++(DY?9HJ@N'/?O6=1PMF/2/%[3Z:!(U`+0N1R0+LS@_1/=N:,,N:"Z
+MU0_:D_\\]57[5#YYW3R@S9.V?+##%*<A<D&,5!2`I_YJ`<EGMQLZ5I`TYGXR
+MQ?&!7-\@=EG4K:C3#)W33F>[FYXWR=)L?8E*KK_1J4`1CK6D6:IIN.5NMM3-
+MR8!\C+SI.3O/)W4<F:(2D#082K]S08_DMZ`1$@TT-$02O#KI%S12VL$F!_0[
+M.NK#.VZ'F@5]/'?P*ZMBQ`,Y$1:?RUXD,,AY<M07G9YQ*.I?)$&1#O1L9$>[
+M)EVM6MD'M:,V*2M<%>D(4'JV`QB)R73L)XU6&C>=NAKQH$\2(N_RT.N<E\GU
+M5N)QG_B@I+D@:"X(ZK-.%8W8>U&%RBID4B&IFDMA3VE^499%ELKR+A".\42U
+MBM3F\A0TF`7A+O)@+CS6A0NY4$MR(0_K:(#)WM!XEM0](H_G#C9)7>[DJ,ZF
+M<TX9FVX/44V16&XB;:5T'"Z,94<J5(*W(1S(9U]T8`$)57TI2HJD1T2J8I%V
+MY-QL]IYP"],I/BGSP"\ZH-.NHW93:P4Z(I7)<*FUI*X#-LG+5$BCZ<.9JVDT
+M!!A9*8N1D['+A4UBQ8U&9"M85B+[L'>4)*]TJM!!SQ;.E-B1,SI5\2"Q7,G#
+M%HDW*X<S@NJPC."0.#6ASD>)Z<(J,Y`.S)+VFR<#K3M&,M#ZXR0#'7LD&>CX
+MGF2@*[K?R3$%1:8$X)0`G!*`4P)P2@!."<`I`3@E`)UZH'R*Z8<MC,+P3KT&
+M3DDNWDDDI2(K*<C(9192YDPGMDT1@4GE4,JR%)EP9V.HQ(8IDUXJ6;+5E:AT
+MS"?F**H(GJ.RI(07.:NMKOA[IVJ+[E1MX3&76/J6DE$Q$=A0?=&B5(5[Q(@(
+MJMM":2E`4#$%6,2&N1YJZB6JBU)4?.U"E,J!-E23--DEBJ0,E4>A\BQE)C!V
+M'$])G;)@#*,&<RD:SKL%9W+9G9C?*T+47"`U&K6;`$N56`;2>#FUD;R2Y-4@
+M3#E3E1+1R2V7TG<YZU'4"76/F)GS.)3DYOV,73)4%TF_G%;<G20\9:MC'IY"
+MZI1ARYF?W23>X(RAR=M$Q32'4W8M%S95I#O-9QHS>8F@,4/S-&;<=@)K8:F@
+M9D/=-#":::Z6U7)RP="B#@]5R3'T=%&^5'2S`8K&2)P!N\FFHE\[2;!4)L?1
+M_=1<61$G:4Y:!K)?0\FI`7-R/B1](]'P?A:LH5K`19E7]TB/%1G)U&5I?-I^
+M9DL4V;FD=+#W<FXL?8=`2EW*;Q5IEYSJ2&-L9PDH`*%A$U-?YD7OCJ`D$BOK
+M(.<U:TZ+5?%%EB=-ONCYG+,<2/1RTN32Q(GI*=.WOY/KDVEU&,KR\K2DQLR5
+MZ4\\^AXH=&BN+9P[<IX[L(EK1TQUF?[<\Z3+#N7YLH/<T===,?EE>E-($B\(
+MG25I<1S(XN6"XBD%1AG;.<W,E$8<'!5%[C)ADI3GBG"NR#XY,Q5OZK[8[^SX
+M%_O'!(>K(P2'8W4>%!RNQ@1&P\FB?<'A$3`8K?.@X'`4!@\DBQY/F*V.D#`;
+MJ_.@A-EJ5,+L@631XXG3(V`P6N=!B=-Q&`PDB_:&R*MCA,ACE1X4(J]&)`D&
+M4D5[TR3'0&"TTH/2)&,0&#K!L#=INCI&TG2LTD.2IJM12=.A4PQ[D^?'P&"T
+MTD.2YZ,P2-S!%<S*E\<L<^%]SX9..W@^E:@:8F->]-C8[R-CWU>F_FED[/O*
+MU#^)C'UGWUX^B8Q]9]]B/X6,?5??5SR)C'U?WUD]B8Q]9]]@/XF,?5]O,B3J
+M(#,9\^H!,J8'R9B92G(]0,?ZR;&)CDUT;*)C$QV;Z-A$QR8Z-M&Q1^A8D1OS
+MP[DQSH9R8]B!IA)D`V0,@V@B8Q,9F\C81,8F,C:1L8F,361L+!G#\G2>:80:
+M55P-@VJ1GS'#1RE-^C_,]QVB[`J26GN^1X#.+E9G%=>;\/^4MX<<VY.%G&5!
+M?UY=7;S_M+R[6T:N>%D<^&,+K+ZA6*(FIM#VFMQ6OMQ^D2QUJ&C)\T9:BC0]
+MD;C/A-*87C*%GFDEL,](QH3*JW`A,>]*1-,YRWW#^6+'C9JS(4^4]4.^2"=+
+M;YAU@_Y`K-D1V_5)J=(KZ<V@7TK-^U+)'U'X]L!QW+=GU0FX^U4M6/UZ5F_V
+MC*0A<6HB'\=]5$P7H^J$ZT4HWZAG+S:_A/%U(O2"+9NPT8APK1AN+UYG'>;1
+M`1>@QM2UTH*:"8ZEWV*,JBTM`.:A>&N@(J&X*P=55+-.9X)7@`=H+/U8/QQ6
+M*:Y4N^@9"U(9*BR"3V"1`?:^.,_8[AW:M=4D)?8:C!0?*C&VK?I0'=@;'M@(
+MV&FH(-GM]%"X585RO<[IP)/!.[8KK0.-9EBY0NU7;;3$VJ([`P$N*FRI6,G0
+M^\%3K*4Q%L!(!5N1N`U&BT^F&!RV&!SC*CYB9\V+DF"+U-LV'K[N+!Z"3@M_
+M/N.F9C6&H#683@H`LMK!(&!BLCP&Z^KF?GF'L8%0\J22=?6YKE08BV*C&B$V
+M8BX-B1=KJE!DBJOR2O:N,$8G8SY"0-0RWS'9S(K7N%6K6M>FMK6K/<R%W347
+M-9<U5S77-2],3L?%5Q_/NK9_K#_7,EB>)$,=19C#3Q5V"H50!.31A1*N3+&-
+M_"+G8*W8-OPIQB:B"JV#`,BM<[@K&AN*C9YR92QZ4X?JUMB0//I@(\*SB*TP
+MQ,%;3D/E88TX"+]S@4?GFEL#!H/!=(J!CWL.'$4BO#'A6=%@3]08%O94&VM9
+MX+]H`0.';8)B@2Z3F`S\%*P9`\@P!W/1#;@A,`TT#,8V@<&I0VE4:&S*>QP,
+MJR7D2F/-W:"Y0B.HE;0,U`P+!V=HC4QIZQL'^YK"^E`J%Y$?]NX-&LD>RU!.
+M&9LUAS?SB!,:8YLF02JQAWOUI>$2"ZUCH!D<L9ZRI]"(SH"QP-0;1IV5:UKB
+AD7$S0_(\,Z38+K7K^XO[3^L3/GOUP[/_!]4`6N?8E0``
 `
 end

Tst/Long/solve_l.stat

@@ -1 @@
-1 >> tst_memory_0 :: 1088445996:2004062311:2-1-2:ix86-Linux:nepomuck:895540
-1 >> tst_memory_1 :: 1088445996:2004062311:2-1-2:ix86-Linux:nepomuck:1372352
-1 >> tst_memory_2 :: 1088445996:2004062311:2-1-2:ix86-Linux:nepomuck:1372352
-1 >> tst_timer_1 :: 1088445996:2004062311:2-1-2:ix86-Linux:nepomuck:312
+1 >> tst_memory_0 :: 1115019332:2005043019:3-0-0:ix86-Linux:nepomuck:668828
+1 >> tst_memory_1 :: 1115019332:2005043019:3-0-0:ix86-Linux:nepomuck:1355220
+1 >> tst_memory_2 :: 1115019332:2005043019:3-0-0:ix86-Linux:nepomuck:1355220
+1 >> tst_timer_1 :: 1115019332:2005043019:3-0-0:ix86-Linux:nepomuck:338

Tst/Long/solve_l.tst

@@ -4 +4 @@
 LIB "tst.lib";
 tst_init();
-tst_ignore("CVS ID $Id: solve_l.tst,v 1.2 1999-11-18 16:38:35 obachman Exp $");
+tst_ignore("CVS ID $Id: solve_l.tst,v 1.3 2005-05-02 07:42:46 Singular Exp $");
 
 LIB "solve.lib";
@@ -36 +36 @@
 mp_res_mat(im);
 
-fglm_solve(i,30);
+def rinC=fglm_solve(i,30);
+setring rinC;
 rlist;
 
 setring rs2;
-triangL_solve(i,30);
-rlist;
+kill rinC;
+def rinC=triangL_solve(i,30);
+setring rinC; rlist;
 
 setring rs2;
-triangLf_solve(i,30);
-rlist;
+kill rinC;
+def rinC=triangLf_solve(i,30);
+setring rinC; rlist;
 
 setring rs2;
-triangM_solve(i,30);
-rlist;
+kill rinC;
+def rinC=triangM_solve(i,30);
+setring rinC; rlist;
+kill rinC;
 
 ////////////////////////////
@@ -79 +84 @@
 mp_res_mat(im);
 
-fglm_solve(i,30);
-rlist;
+def rinC=fglm_solve(i,30);
+setring rinC; rlist;
 
 setring rs4;
-triangL_solve(i,30);
-rlist;
+kill rinC;
+def rinC=triangL_solve(i,30);
+setring rinC;rlist;
 
 setring rs4;
-triangLf_solve(i,30);
-rlist;
+kill rinC;
+def rinC=triangLf_solve(i,30);
+setring rinC;rlist;
 
 setring rs4;
-triangM_solve(i,30);
-rlist;
+kill rinC;
+def rinC=triangM_solve(i,30);
+setring rinC;rlist;
 
 ////////////////////////////

Tst/Short/solve_s.res.gz.uu

@@ -1 +1 @@
 begin 640 solve_s.res.gz
-M'XL("#<1X$```W-O;'9E7W,N<F5S`.U<;6\;-Q+^[E]!!/T@1;MK<H:OSLG`
-M7=L/`=J[`W(X'%"D@=/*B0#+-B0EE?WK[^%JR:5>$K_41H!"@B&M=H?#F8?#
-MF7DVVKSYSP^O_RF$4*?B^/CH3?>-&GP3BZN+SY-WBV:Y6(I:+#Y>S9=B.5DL
-M%^+\:BZR,#?]L6[$3Z__(5Y@2',Q??_B5;YB3@5.OIM>3I>#X:NC^"E.3_,<
-MEY,_FL7R;)GE;2?_X?)J/AF\^/Z_;\3K'\1WKW\_*>VJ/@O5:$%2ZF-)QXJ$
-MTB<D3\B+-]/+#Y\NSN;BQ]6U^.X%YH1+O<H3\6=59E/=:0^`[P!H%6Y!$'HY
-M)2/"7WYE.=6#J[`J!23BQ1SFB/E"B;&0U6!5W52WP^KB^M4+L>OLEV2S<C[=
-MDOE8[9'2A0NF$==7%S?B7([%:G0SNAVI7A#+M[ZH</%7$B-A7Z[PSB]OVN-;
-M1)3NQ5T2I[&X:<4)XK5KI4W[];:7]DF:D_+UF%N\UZ*P`HA/?Y^<78CI^%Q5
-MYU2=<[Y(,E^<C<]EM2N@>F<)V'^:3Q;OVG4=?+R:77T83*N/PTH!ZU_4VY,C
-M+'#ZQ*N6C0K.L31$RAD*2AGR@:6B8+22W,I3EI>-]]XY;Y35K#5;QXYTD!S(
-M6>E5*\Z%N%:L@W)22^,526.MT:1"P)2>W%%279@4QS@M75#LO3%L%-G@+04)
-MV[3R>RS">1>L-,YHR<:R@JS3(4BGS99%<)A@AF%M#%D?=*#`\<^08B;ICY)P
-M8=*@M@U\9F7@IY06T%@O`0&Q"0;>Z]'KE[;10(Z4TC(ZX"Q9;9WW'"QK2S3<
-M,GP`4V"S!(1D(J@*8YGANE3>F4`$I=PH>&6T5QY`6J,<CJS6T$PRD!ENN3>P
-M3;"`@APKQT#+>%+$@37C%'-KIV&L-V,)2%H.P6/EI#4RPN*T&A[]HA^!0/T<
-M"-1/CT!]+P3,'@1,HQUY'>"W<G@ARM@KBWVC,96/R^4;,I@&`>Y9^VBSE=8&
-M)7&&8<0.`JZQWEL#_QB;#49#CI55V%_.>MBJ&^PJYYV,]@-JZVW$%<<:/AJ[
-MX[YOH"Z0]A:>!VN"TE@3&7`*6%C=6NEUNV&!N792,K1C1UCX!N@,UND7^PC_
-MZR?W?_0,_M?W\M_M^H],J3TCI&/8(,"T@3`#`;B)=*.ZQ6*.*"&.96NK43$!
-M&D28U6;'?=M(5K#5:$TN.(L]`^0\:48X.AF@4S:PG8/R6FD%1?"('-!5F,;$
-M1=A!`!G.>7A%R.=(C3`2V`/1@*V&;&=;5&%FB!O"P'N%":W%4@;D]9BB'1#P
-M#T=@]`P(C)X#@?H^"*22BHYC=OTN%M79V3*5U%FJJ>\`T/CCRP^3RX$:UNV'
-M'(Y,>\(/:]T>P.UW<+J3H^%HM3'`I@%*IQ%*#4?4*1G97@DG)3P<W6PH"5F)
-MRTIHB-:D4\*]$IV4Z.'HME1"V725;5>\WQ+S=KSJW%F/S5Y0]H*R%_"L&QP]
-M2S!E93999!,VV;^D/OM'V3]4E*3>)4^+B2@YC2DQATMSN#1'=K^;@[/[E-VG
-M[#X@V76&"[<PAW\[ONG,7VODI)%5MM!ENV@3"A]5A&1F2`AD,Y-2G952-M-D
-M];X`)4W$!2@Q9.7;\6VG>ZW2E%[VOG76Q2$(<TK+VTE06DK;?;88*$J189-2
-MRLM3#,[+D]6$[G-M(R<U+JO)KA5J>-L:ZM"$_5&-3DN2K>F7@C)"1%NNZ':P
-MR7O;I*#)R^+2LO2*\WXK+'79/I,GXP*$.(U-R['A:N]@9UD4111W<_`V;*X5
-MR"$8DC%,A>?)!+,%5AM[*B1#0N%387\W7\QF"*%.0?RFNF\=?-1&`E%WMK-P
-M[2WQ^BQW4U.[3J2[LYV[65.[$)2SC>JLB)N@LRI>M]UHDT?'LVYK_A8AR@AE
-M7<F2%@3*(*3KU'K,,ML=OZE->[GUF#N/DW7<>LR\:1VW'K/.LO&;R3*Y\A0L
-MELQ^4DT/(-4[LEFY/;U;IKA[0'Z;4O=BX4&$FN5#"#6K>Q)JIJ\0:N8["#47
-MN+/9(-33`XL^L.@#BSZPZ`.+/K#H`XN^/XMFN\&BI[-$G<LFU'?M4<=H.]),
-M&[31IZXV,Q;*G+4CR+1!KG(;W+?IF>5U9+AD.V[]H3N*6TZ=NL&.L/9<L&-)
-M/=>F-*'I^7+7BZ:>,J3IUJRQ5-7!8#LV6'*;D*RKLR4J->);9-*M94PB;QLM
-MO,L4J=XD;AVD,LL5M+K'U1245V7$,X_+:Z1Z6IE![]B=WESZ#",EWD6;O"R4
-M])FR]GS?I*-1&XS);S.G#8T)`Y-H4T<W-DE5YD4E*<E7;8>?WJ)$Q;V.=-\E
-ML:A\7V6#-ZG=NQ8VG>),\C=(529F$3O>O$-C-^\\<0^,S=!Q(GJVHY[=$%O2
-ML9YH%W<3LG\AC?&)I-$FN]29$&<.&ETU*<H*ZD9V]\Z`<H7!"3?=)Y6"DS`X
-MR?F'BUEJU"O0M)8(79[-)N+J7%Q._FA)SDED.=_'*Q?3Q3)>F5]=+1<X';]G
-M=>`Q[8F]_?[3-M?VX<WU;K__Q!3DP0QD3[M_9ZF?/D.IGSY'J9_>I]3O:??O
-M+/7/@,#H.1"H[X7`OG;_ZX1'P]JO\QUVCV!\TZ=G?-/[\)U]_?X=`-3/`4#]
-M]`#4]P)@3\-_%^'Q@/;KA"?>(!0/(GS39R!\T_L0GCWM_IW^UT_N_^@9_*_O
-MXW]7/+7LZ[)6C5A,ENGV8K[)INE4X.S9Y8>?_FS)QOF7+\5\\OOD?'K9S?-]
-MGH</A?S9"_E?B[,_II#_I3C[HPKY73<N'U7(O]6MV\<4\N<`X)O=N7U4(;_K
-MSN7#"_DWNW/[J$+^Y/Y_LSNWJ7@6_Q*FS1<*N<V%_/QY*[D[5/)#)3]4\D,E
-M/U3R0R4_5/*'57)?5/*POY(;F2KYS\]:R(TZ%/)#(3\4\D,A/Q3R0R$_%/('
-M%7)#?2$W?+^G<XWNG\XU7_@AL4V_^[WK5\2;@EEM_Q/B+PCD1V?%6"BSBK_M
-M77%\:W^Z*WM!="H79Q\^3>;S2=>&G!>_ND5M!6S8N297ZKAG':_3</NOGV@:
-M8GJ-FX9W1>HMD:ZVQ#R-DJZ1'UJ)@$60,O[\/.7>0F*T*9%,+YZ<MK+9<:-2
-M<I\G:%[V^<*>2V^D\WO]@5B]([;KD]:E5TA_>_W2>K0ME?PIGC*V7WC"^[>Q
-M&,PG9Q<5R>KUL%K=$4G[Q/,4_7/>7Q73150-%-(!]J<9OES]&N-K0*:1DSK6
-M+(KGBG![^;K78;X:<!%J]*%HX;![T212<$H&[=M>`)C'3@*E(<1.`\VAC@%3
-M+"9R`@J00<<1)"%1H%'0;2-ET;+:N-W1Y%GVP#YPL<#H,S0*4$QM*!0Q4D),
-M"^VL(;:JP2J'L^@J8CK;7/381>C8.Z*#MD$C`;)K)_7H,*5!@X%&Q%B#7!E_
-M_E0$`ES44FDV#JL?/47Y:><DA4BU$DY*90(2'=LB.&P1'.Y^2<GZ/BE9,))N
-MM5WW`,)&\G#Y&?C/8V4K6:$F.XOMA(+O9>5A$#"QO3R"=7JYG,P1&V=+1"A7
-MXG,E=(Q%6NF::$4CMEF\R*F.LRE>])GL]\(8G8RYA@!5_8,#SO1F"E7A4J4K
-M4]G*5;X*,!=V5XHJQ972E3*5*DQ._Q/!]'J\:?MU];GB:'F21":=PAQUK)V*
-M70>C5_"QGP"!6/$-CU#ZI/3A&+&)8H<R$MM=1)_'5:I=K'S'"LT*5M-$J@4F
-M%,`[5A3'>@+7<NBACF,;C*8Z?E>$H2,T.NB@8S`=(_!Q#>64.6ACXUBJR:`5
-M0[MZ;*P#FT'<8P8$CEQ%Q80E8VP&=:PX!A"8$,S%,N`"81L8&*Q063WJ*!1#
-M8UU>0Z>%[0#7-)HBO<)TA4;T:JB8(%EH])3$;-F4MMF.]M6%];%O0W--,`"3
-M]!YS[.W1?2EX,^IPPF1R52=(&<PLZ)L:?`*;2Z*'1]\1M#N&1BP&C`6F:/7R
-M8A6\VX7[[0PO^YWA52,FJ[/9]<5$+*;Q8_6O3\LVHU[/KWXKSHGS^=4,;/R]
-MR/^GQ]&/__O[S__^Z<>XN=<Q+5(N127*FPQ7H>ZWJ\L%@G<NEA\G8G:V:N($
-M[R\FLY/V^EH(+UR:SJ:W$R%6`S6,&75`P_8!G]6`ATBN2#\XU,-RV!_3Y<=V
-MAN7\#,&].!%Y>'[16D%^_6V,K2;SO%]\Q7%4C*N%:^>/"E!E[U8@UB[4[0$/
-MU\\@106GK8+&?$5%=J)#(:N(!U`AHHJ0H)B=+>?3E5C,D''CKXNC^@J9(OYQ
-M%:M%=;1G$L!0U1#!.\7W?3*MIB0@W%Z9J%^L5:DHN5]/B`+IKXT.K)BXA"?Z
-M50O$Y:?9>\3)U7FYHIW8;)_8Y[/Y]`RAE(44\N:V$%9KCSI"(MV6/-TKR7LD
-MQYN2$&WO5F&#C+N-,UC,*G%9";S/`,L,\,T8N584.VL`>9RZC8VK:]#A'ZWB
-M8W+<<#S4L4HT`4<<?6\<3N;=6Q06S^NF*?[O09\6")M7WQW]'T4)-U_62```
+M'XL(".;7=4(``W-O;'9E7W,N<F5S`.U<:V\;-Q;][E]!!`4J13-CDI=/9VU@
+M=]L/`=K=15,L%BC20$GD>+"2;4AR(OO7[^%HR*&D<?Q8&P%:"8$>,Y>7]QY>
+MDN<PDM_\^L/K?S#&Q`D[/#QXTWZ2%3ZQQ<7T\^3=HEHNEJQDB[.+^9(M)XOE
+M@IU>S%DRIJI[KRKVT^N_L1=H4DWK]R]>I3OZA.'BN_J\7@Z&KP["*SLY27V<
+M3[Y4B^5XF>Q-:__I_&(^&;SX^[_?L-<_L.]>?SS*XRH^,U$I)CE7AUP>"LF$
+M.I+\2#KVIC[_=#4=S]F/JTOVW0OTB90ZET?L_W690K4G'0"N!:!QN`6![^P$
+M#PC?_DAVH@-78%0R2-B+.<)A\X5@QXP7@U5Q7=P,B^GEJQ=L-]G;;)-S.MFR
+M.2MZK%26@J[8Y<7TFIWR8[8:78]N1J(SQ/"M;PK<_%VR$3,O5WBFE]?-^QM4
+ME.K,;327Q^RZ,9<P+VUCK9N/-YVUB]84G:_;W."Y9%D40+S^.!E/67U\*HI3
+M69Q2NBEYNCD[/N7%KH'HDI7`_FH^6;QKQG5P=C&[^#2HB[-A(8#U;^+MT0$&
+M.+[B4?)*>&N):RF%U=(+H:7SQ(7T6@E.C;U,]KQRSEGKM#"*E")CR4KE.7EI
+M#7>B,:?,7`E27EBNN'9"<FV,5E)XCRZ=M`?1=192:&,5MUZ0<UJ3%M)X9Z3G
+MB$T)UQ,1KEMON+9:<=*&!&RM\IY;I;<B0L(286A26DOCO/+24_BGI2"2W!U$
+MXRRD06DJY$Q"(T_.#:`QC@,"2=IK9*]&KU^:2@$Y*83B(0%KI%'&.D?>D#)2
+M#K<"'R`4Q,P!H=0!5(&V1$B="V>UEQ).J1+(2BLG'(`T6EB\,TK!L^1>ZN%6
+M>@-3>0,HI"5A"6AI)X4D3XIPB:B)4Q/&FS`$DAORWF'DN-$\P&*5&![\IAZ!
+M0/D<")1/CT!Y+P1T#P*Z4E8ZY9&WL'B@RL@)@WFCT)4+P^4JJ=$-"MR1<B%F
+MPXWQ@N,*(8@=!&QEG#,:^1$F&X*&'0DC,+^L<8A559A5UED>X@?4QIF`*]XK
+MY*C-3OJN@CLOE3/(W!OMA<*8<(]+P,*H)DJGF@D+S)7EG.`=,\(@-T"G,4Z_
+MF4?D7SYY_J-GR+^\5_YV-W^LE,H12CJ4#0I,:1@3$$":6&Y$.UA$`274,6]B
+MU2(L@!H59I3>2=]4G`1BU4I)ZZW!G`%R3BI".5KNX9-7B)V\<$HH`4?(2%J@
+M*]"-#H.P@P!6..N0E<1ZCJ4100)[(.HQU;#:F095A.G#A-#(7J!#8S"4'NMZ
+M6*(M$'`/1V#T#`B,G@.!\CX(Q"T5C&-V^2YLJK/Q,FZIL[BGO@-`QV<O/TW.
+M!V)8-B]\.-+-!3<L5?,&:;]#TJV='(Y6&PU,;"!4;"'$<"1;)R/3.:'HA(:C
+MZPTG/CFQR8D<@IJT3JASHJ(3-1S=Y$YD"EVDV`7U1Z+?'J_:=-9M4Q8R92%3
+M%LBL;1PRBS`E9R9&9"(V*;_H/N4G4W[84:)[&S/-.I(Q:72)/FSLP\8^4OIM
+M'Y32ERE]F=(')+O)4)86^G!OCZ_;\-<>*7HDD2*T*2ZY"84++GP,TT<$4IC1
+MJ4I.90I3)_<N`R5V1!DHH63YV^.;UO?:I<ZS[')KHPM-4.8R#F]K(>-0FO:U
+MP4#(6!DF.I5I>++&:7B2&]^^KF.DZ,8F-RFUS`UM1R-;-!%_<*/BD*1HNJ&0
+M"2$IMU)136.=YK:.19.&Q<9AZ1RG^99%:E-\.G5&&0BA&Q.'8R/5+L$VLF"*
+M*F[[H&W8;&.02M#'8$AFF<<0]!983>T)'P/Q64Y9_&U_835#";4.PB?1?FKA
+MDTTE2-E>;2-<9RMI?97:KF4S3E*U5]MTDZ=F(&1:;40;19@$;53AOFE;Z]0Z
+M7+5;_3<(R810\A4C:4"0"81X7S89$T]QAT]B,UYJ,J8VXQ@=-1D3;49'3<:D
+MDFWXI)--VGDR%2MUOZB6#Q#5.[;)N3FYVR8[/9!N6U)W9OY!@IKX0P0UB7L*
+M:I)?$=1$=PAJRG`GO2&HZ[V*WJOHO8K>J^B]BMZKZ+V*OK^*)K.AHNM9E,XY
+M"74M/6H5;2N:Y89L=)'5)L4BDV9M!;+<$%>)!G<T/:F\5@SG:L>N7U0K<?.N
+M(QML!6NG!5N5U&EM&3O4G5YNN6CDE#YVMU:-N:L6!M.JP5S;^!A=F2(1D8AO
+MB4F[MM%1O&U0>)LD4KDIW%I(>;++9'6'J\XDKTB()QV7QDATLC*!WJH[M3GT
+M"489=9?<U&4^E\\R>4_G)JV,VE!,;ELY;7B,&.@HFUJYL2FJDB[*14FZ:UK\
+MU)8DRLXZXKE+5%'I7&5#-XG=4PL3+U$2^1NB*@FS@!UMGM"8S9,GZH`Q"3J*
+M0L^TTK-M8G(YU@GM[#0AY>=C&Q=%FMQ4ERH)XJ1!0ZHZ5EDFW:39/1D0-@LX
+MXJ:Z1273)`1-\G%R&G3,WZ%A3C]-9Y&S%U!LKPZ"*/J^N_P]^S"?C)>3CVS<
+M:)^"U>?LRUG]X0P7IO5BR>;-\\4I.[^:O9_,%VRP/)L$+Q\N9I?3R2K\9^S5
+MLKXX7PQ9O6"+);36QXH%BU\OV/C#A\EBP="$13\[[0JVO+Z<L$%]VMB=CV<3
+M]@O[,EZP\6(!\8;@&BEWT=R>3Y97\W/V>3R]F@R/6+M*,[:8+!OQ]LNK=<BO
+M.DP@QN+=@$M2.`JR:VW;IV:>5CJ8ATN'737SQ`+KP?JJ1\S<263J9R`R]7,0
+MF?H^1*9'S-Q)9)X!@=%S(%#>"X$^,?-U.:<0[=?5'-E'Z-GZZ?5L?1\UUZ=F
+M[@"@?`X`RJ<'H+P7`#URYBXYYP#MU^5<./YD#Y*S]3/(V?H^<JY'S-R9?_GD
+M^8^>(?_R/OG'S3/[OHV25;?#+F2WP=()^V\]G6YMN^HDYRAH-C[_]%,/3=FX
+M\V=@*DK?QE3,GJD\.U/Y8QVY/(:I_*&.7![%5.XZ=WX44_E6)^^/82K/`<`W
+M.WA_%%.YZ^#YX4SEFQV\/XJI/'G^W^S@/6Z>V?F(<K<P%=_'5#3O8RJGMU.5
+MTS\/5]'B%JZBY9ZK[+G*GJOLN<J>J^RYRIZK/(BK:.JXBE;]7$7K7JYB>KC*
+MS[=2E9__1$S%WL94W)ZI[)G*GJGLF<J>J>R9RIZI/(RI])Z8&-[Q%R/N]ZMY
+M([M?S1OJ_X*_B=_'O^O;_9N&R:TZN<-`Q^_4@SL)O0K?N5]1>&J^4L\[0]"L
+MZ?C3U60^G[3DZC3[-CQV7(")^:S3_AUFLJ7UXMS\OSVH1%ATPU2B79-RRZ3=
+M<<+JC8U>8=5H+#R&AO/PLY"X(F<6HTV+&'IV#F9<M9-&(7A?)J`T?;F0HSP;
+M;EUO/C`K=\QV<U(JSPJ+8F]>2HVVK6(^V5]KL+R_ACX<LP'([K20O'@]+%9W
+M5%*?>>I"G-S+3&95-1!8)#!K]?#EZO=07P.I*SXIPTXFP[6LW%Z^[GS05PLN
+M0`UV"F*'.0WJ*+T5W"O7,`1@'O@%-@P?^`<HHPH%DPTF5@IL2QH\Q'.)Y0/T
+M037TRH#(FK`(@/H9<L#>4S;`8!\*VU)8\+!]A$KQ8;%H>O6!P'HC+*Z":X1%
+M;G/0`[=0@5&"5QNOL"R2;3IUX)U<@W:`GFBCL8*&KR5FA8`4%1>*M,7HATRQ
+M*35]2H%*-1Q)<J$]EC\R77'8[)<L5M]O4;*F6Y2LK>)HV_:'01N+AW7QIS2?
+MCX4I>(&=VAI,)]``QPN'@(")Z>S#'[HX7T[FJ`UHKP&C@GTNF`JU*%>JE'(E
+M1V2BN<O65"=2*(YU*]G'+AB7?O1S"0-9=#_H<=2%R42!6X4J=&$*6[C"(US$
+M70A9""J$*H0N1!>R4VTEUY?'F[%?%I\+"I%'2ZRD-<(1A\J*P$4(#,(%E@%9
+ML:)K&F%#Y-SY0]0FMD!L+H$$H_H<[LK2AOWP4(#"8#1U$&#01QYJ9"5#6R>A
+MP"R8U6$@QZ#:X;.0:#H"_0&O#L5TB,+'/6RR1%YI$]K*4FH0-)#80VTL-`[J
+M'CV@</@J.)88,L)D$(>"0@%!'R%<#`-N2$P#C8`%]EN'W16.X;',[X%_83H@
+M-06JI%;H+O,(!H=]%-(+]$]P])9":2AXB*_,H@]L#I1;(@!TTF5,@?&#DPED
+M,VIQ0F=\549("7K-J^L2*@.3BX/9@XUX90_A$8.!8($I"&`:+).5EKW?S'"N
+MFQG.5VRR&@=!SQ9UH^O_>;5L5M3+^<6'[!H[G5_,V+1^S]+?VCGX\3]__?E?
+M/_T8)O>ZIEE<2[$3I4F&N\UIP_D"Q3MOS@!FXU45.G@_G<R.FOMK(SQPJY[5
+M-Q/&5@,Q#"OJ0`Z;']ZM!C3$XHKE!V_5,&_VI5Z>-3TLYV,4]^*(I>;I(=<.
+MTN,OQUA7>.KWUD=H)[-V);--_\$!=MF[';!U"F7SAH;KWP8&!R>-@TI_Q45*
+MHD4AN0AOX((%%SY",1LOY_6*+698<<.W_H/[`BM%^$=%V"V*@YY.`$-1P@3/
+M,CSWV32>H@&SO3;!/UN[$L&RWX\/!O%?4QT8,7:.3-2K!HCU.=7ZI"F-:&LV
+MZS/[/)[78Y12,A)8-[>-,%H][B06TFW+DUY+ZK$\WK2$:7-&A@ERW$Z<P6)6
+ML/."X7D&6&:`;T98:UDVLP:PQZ6;0%QM!=Y_L`H_7Z6*PEL5=HG*XQV%W"N+
+>BW'V^FQC\6)-FL)?];I:H&Q>?7?P/THUEZ5N3```
 `
 end

Tst/Short/solve_s.stat

@@ -1 @@
-1 >> tst_memory_0 :: 1088426295:2004062311:2-1-2:ix86-Linux:nepomuck:577416
-1 >> tst_memory_1 :: 1088426295:2004062311:2-1-2:ix86-Linux:nepomuck:827584
-1 >> tst_memory_2 :: 1088426295:2004062311:2-1-2:ix86-Linux:nepomuck:827584
-1 >> tst_timer_1 :: 1088426295:2004062311:2-1-2:ix86-Linux:nepomuck:168
+1 >> tst_memory_0 :: 1115019239:2005043019:3-0-0:ix86-Linux:nepomuck:450864
+1 >> tst_memory_1 :: 1115019239:2005043019:3-0-0:ix86-Linux:nepomuck:830932
+1 >> tst_memory_2 :: 1115019239:2005043019:3-0-0:ix86-Linux:nepomuck:830932
+1 >> tst_timer_1 :: 1115019239:2005043019:3-0-0:ix86-Linux:nepomuck:157

Tst/Short/solve_s.tst

@@ -4 +4 @@
 LIB "tst.lib";
 tst_init();
-tst_ignore("CVS ID $Id: solve_s.tst,v 1.4 2004-02-12 14:20:28 Singular Exp $");
+tst_ignore("CVS ID $Id: solve_s.tst,v 1.5 2005-05-02 07:42:56 Singular Exp $");
 
 LIB "solve.lib";
@@ -36 +36 @@
 mp_res_mat(im);
 
-fglm_solve(i,30);
+def rinC = fglm_solve(i,30);
+setring rinC;
 rlist;
 
 setring rs2;
-triangL_solve(i,30);
+kill rinC;
+def rinC = triangL_solve(i,30);
+setring rinC;
 rlist;
 
 setring rs2;
-triangLf_solve(i,30);
+kill rinC;
+def rinC = triangLf_solve(i,30);
+setring rinC;
 rlist;
 
 setring rs2;
-triangM_solve(i,30);
+kill rinC;
+def rinC = triangM_solve(i,30);
+setring rinC;
 rlist;
+kill rinC;
 
 ////////////////////////////