Changeset 3b77465 in git


Ignore:
Timestamp:
May 10, 2005, 7:56:17 PM (18 years ago)
Author:
Hans Schönemann <hannes@…>
Branches:
(u'jengelh-datetime', 'ceac47cbc86fe4a15902392bdbb9bd2ae0ea02c6')(u'spielwiese', '0604212ebb110535022efecad887940825b97c3f')
Children:
399ac9a269b92b84e7f2b0b5342627ad8bf48f3a
Parents:
edb4ff379c3c86523e0becd8fc67a508a03be6c3
Message:
*hannes: fixed kill


git-svn-id: file:///usr/local/Singular/svn/trunk@8136 2c84dea3-7e68-4137-9b89-c4e89433aadc
Location:
Singular/LIB
Files:
11 edited

Legend:

Unmodified
Added
Removed

  • Singular/LIB/general.lib

    redb4ff3 r3b77465  
    33//eric, added absValue 11.04.2002
    44///////////////////////////////////////////////////////////////////////////////
    5 version="$Id: general.lib,v 1.46 2005-05-06 14:38:31 hannes Exp $";
     5version="$Id: general.lib,v 1.47 2005-05-10 17:56:13 Singular Exp $";
    66category="General purpose";
    77info="
    … …  
    11771177        if(defined(watchdog_interrupt))
    11781178        {
    1179           kill (watchdog_interrupt);
     1179          kill watchdog_interrupt;
    11801180        }
    11811181        close(l_fork);
    … …  
    15651565            kill PP;
    15661566          }
    1567           kill (l_fork);
     1567          kill l_fork;
    15681568        }
    15691569        else
    … …  
    16391639            kill PP;
    16401640          }
    1641           kill (l_fork);
     1641          kill l_fork;
    16421642        }
    16431643        else

  • Singular/LIB/gmspoly.lib

    redb4ff3 r3b77465  
    11///////////////////////////////////////////////////////////////////////////////
    2 version="$Id: gmspoly.lib,v 1.11 2005-05-06 14:38:33 hannes Exp $";
     2version="$Id: gmspoly.lib,v 1.12 2005-05-10 17:56:13 Singular Exp $";
    33category="Singularities";
    44
    … …  
    8181
    8282  setring(@X);
    83   kill(@WX);
     83  kill @WX;
    8484
    8585  return(d>0&&d==D);
    … …  
    545545  A=imap(@S,A);
    546546  export(b,A);
    547   kill(@S);
     547  kill @S;
    548548
    549549  setring(@X);

  • Singular/LIB/groebnerwalk.lib

    redb4ff3 r3b77465  
    11///////////////////////////////////////////////////////////////
    2 // $Id: groebnerwalk.lib,v 1.3 2005-05-06 14:38:34 hannes Exp $   //
     2// $Id: groebnerwalk.lib,v 1.4 2005-05-10 17:56:13 Singular Exp $   //
    33///////////////////////////////////////////////////////////////
    44
    5 version="$Id: groebnerwalk.lib,v 1.3 2005-05-06 14:38:34 hannes Exp $";
     5version="$Id: groebnerwalk.lib,v 1.4 2005-05-10 17:56:13 Singular Exp $";
    66category="cc";
    77
    … …  
    236236   intvec curr_weight   =   OSCTW[3]; /* original weight vector */
    237237   intvec target_weight =   OSCTW[4]; /* terget weight vector */
    238    kill(OSCTW);
     238   kill OSCTW;
    239239   option(redSB);
    240240   def xR = basering;
    … …  
    248248
    249249   setring xR;
    250    //kill(Go);
     250   //kill Go;
    251251
    252252   keepring basering;
    … …  
    324324   intvec curr_weight   =   OSCTW[3]; /* original weight vector */
    325325   intvec target_weight =   OSCTW[4]; /* terget weight vector */
    326    kill(OSCTW);
     326   kill OSCTW;
    327327   option(redSB);
    328328
    … …  
    337337
    338338   setring xR;
    339    //kill(Go);
     339   //kill Go;
    340340
    341341   keepring basering;
    … …  
    361361   intvec curr_weight   =   OSCTW[3]; /* original weight vector */
    362362   intvec target_weight =   OSCTW[4]; /* terget weight vector */
    363    kill(OSCTW);
     363   kill OSCTW;
    364364   option(redSB);
    365365   def xR = basering;
    … …  
    373373
    374374   setring xR;
    375    //kill(Go);
     375   //kill Go;
    376376
    377377   keepring basering;
    … …  
    407407   intvec curr_weight   =   OSCTW[3]; /* original weight vector */
    408408   intvec target_weight =   OSCTW[4]; /* terget weight vector */
    409    kill(OSCTW);
     409   kill OSCTW;
    410410   option(redSB);   def xR = basering;
    411411
    … …  
    418418
    419419   setring xR;
    420    //kill(Go);
     420   //kill Go;
    421421
    422422   keepring basering;
    … …  
    462462  intvec curr_weight   =   OSCTW[3]; /* original weight vector */
    463463  intvec target_weight =   OSCTW[4]; /* terget weight vector */
    464   kill(OSCTW);
     464  kill OSCTW;
    465465  option(redSB);
    466466
    … …  
    474474
    475475  setring xR;
    476   //kill(Go);
     476  //kill Go;
    477477
    478478  keepring basering;
    … …  
    507507  intvec curr_weight   = L[3];
    508508  intvec target_weight =  L[4];
    509   kill(L);
     509  kill L;
    510510
    511511  option(redSB);
    … …  
    520520
    521521  setring xR;
    522    //kill(Go);
     522   //kill Go;
    523523
    524524   keepring basering;

  • Singular/LIB/latex.lib

    redb4ff3 r3b77465  
    11///////////////////////////////////////////////////////////////////////////////
    2 version="$Id: latex.lib,v 1.24 2005-05-09 15:55:10 Singular Exp $";
     2version="$Id: latex.lib,v 1.25 2005-05-10 17:56:13 Singular Exp $";
    33category="Visualization";
    44info="
    … …  
    30793079 texproc(fname,"milnor_number");
    30803080
    3081   kill(milnor_number);
     3081  kill milnor_number;
    30823082
    30833083// ------------------------------ closing the tex file -------------------

  • Singular/LIB/normal.lib

    redb4ff3 r3b77465  
    11///////////////////////////////////////////////////////////////////////////////
    2 version="$Id: normal.lib,v 1.44 2005-05-06 14:38:50 hannes Exp $";
     2version="$Id: normal.lib,v 1.45 2005-05-10 17:56:14 Singular Exp $";
    33category="Commutative Algebra";
    44info="
    … …  
    20902090  if (RS[2]==1)               // we've reached the integral closure
    20912091    {
    2092       kill(J);
     2092      kill J;
    20932093      return(L);
    20942094    }
    … …  
    20972097      if (n==1)               // In the first iteration: keep only the data
    20982098        {                     // needed later on.
    2099           kill (RR,SM);
     2099          kill RR,SM;
    21002100
    21012101          export(ker);
    … …  
    21082108      ideal norid=endid;
    21092109      export(norid);
    2110       kill(endid);
     2110      kill endid;
    21112111
    21122112      map phi=R0,endphi;      // fetch the singular locus
    … …  
    21222122      }
    21232123      export(normap);
    2124       kill(phi);              // we save phi as ideal, not as map, so that
     2124      kill phi;              // we save phi as ideal, not as map, so that
    21252125      ideal phi=endphi;       // we have more flexibility in the ring names
    2126       kill(endphi);           // later on.
     2126      kill endphi;           // later on.
    21272127      export(phi);
    21282128      L=insert(L,R1,n);       // Add the new ring R1 and go on with the
    … …  
    22392239
    22402240          if (j==2)
    2241             {
    2242               kill(phimap);
    2243             }
     2241          {
     2242            kill phimap;
     2243          }
    22442244
    22452245          if (j==1)
    … …  
    22622262              h=NF(imap(R(k),p),J);
    22632263              setring R(k);
    2264               kill(p);
     2264              kill p;
    22652265            }
    22662266
    … …  
    22802280          p=NF(backmap(h),std(ker));
    22812281          if (j==2)
    2282             {
    2283               kill(backmap);
    2284             }
     2282          {
     2283            kill backmap;
     2284          }
    22852285        }
    22862286
    … …  
    22892289          if (defined(fraction))
    22902290            {
    2291               kill(fraction);
     2291              kill fraction;
    22922292              list fraction=p;
    22932293            }
    … …  
    23142314  for (int i=1;i<=size(L);i++) { def R(i)=L[i]; }
    23152315  setring R(2);
    2316   kill(R);
     2316  kill R;
    23172317  phi;                             // The map R(1)-->R(2)
    23182318  poly f=T(2);                     // We will get a representation of f

  • Singular/LIB/qhmoduli.lib

    redb4ff3 r3b77465  
    9393    setring RME2;
    9494    export(RME2);
    95     kill(RME1);
     95    kill RME1;
    9696
    9797    if(size(actionid) == sizeOfAction) { nonLinearQ = 0;}
    … …  
    122122    }
    123123    export(RME3);
    124     kill(RME2);
     124    kill RME2;
    125125
    126126    // 6th step : compute the equations of the quotient T_/E_f
    127127
    128128                ideal G = groupid; ideal variety = embedid;
    129                 kill(groupid); kill(embedid);
     129                kill groupid,embedid;
    130130    def RME4 = QuotientEquations(G, actionid, variety, opt);
    131131    setring RME4;
    132132    poly mPoly = minpoly;
    133     kill(RME3);
     133    kill RME3;
    134134    export(RME4);
    135135
    … …  
    152152    }
    153153    export(modid);
    154     kill(RME4);
     154    kill RME4;
    155155  }
    156156  else {
    … …  
    250250    ideal embedid = imap(RQEB, variety);
    251251  }
    252   kill(RQER);
     252  kill RQER;
    253253  export(id);
    254254  export(embedid);
    … …  
    384384  export(actionid);
    385385  export(stabid);
    386   kill(RAAR);
     386  kill RAAR;
    387387dbprint(dbPrt, "
    388388// 'ArnoldAction' created a new ring.
    … …  
    508508        ringSTR1 = "ring RSTT = " + parString + ", (" + varString + ", " + varstr(basering) + "), dp;";
    509509
    510   if(defined(RSTR)) { kill(RSTR);}
    511         if(defined(RSTT)) { kill(RSTT);}
     510  if(defined(RSTR)) { kill RSTR;}
     511        if(defined(RSTT)) { kill RSTT;}
    512512        execute(ringSTR1);      // this ring is only used for the result, where the variables
    513513  export(RSTT);           // are s(1..m),t(1..n), as needed for Derksens algorithm (NullCone)
    … …  
    541541  dbprint(dbPrt, "  qhasihomogenous substituion =" + string(qhsubs));
    542542  map F = RSTR, qhsubs;
    543   kill(varSubsList);
     543  kill varSubsList;
    544544
    545545  // get the equations of the stabilizer by comparing coefficients
    … …  
    10551055    g = reduce(g + h, reduceIdeal);
    10561056  }
    1057    kill(computedPowers);
     1057  kill computedPowers;
    10581058  setring RASB;
    10591059  poly fnew = imap(RASR, g);
    1060   kill(RASR);
     1060  kill RASR;
    10611061  return(fnew);
    10621062}

  • Singular/LIB/resolve.lib

    redb4ff3 r3b77465  
    11///////////////////////////////////////////////////////////////////////////////
    2 version="$Id: resolve.lib,v 1.3 2005-05-06 14:39:06 hannes Exp $";
     2version="$Id: resolve.lib,v 1.4 2005-05-10 17:56:15 Singular Exp $";
    33category="Commutative Algebra";
    44info="
    … …  
    36413641   matrix intE;
    36423642   int extra,bm;
    3643    if(defined(BO)){kill(BO);}
    3644    if(defined(cent)){kill(cent);}
     3643   if(defined(BO)){kill BO;}
     3644   if(defined(cent)){kill cent;}
    36453645
    36463646   ideal Jrad=equiRadical(J);

  • Singular/LIB/rinvar.lib

    redb4ff3 r3b77465  
    11// Last change 10.12.2000 (TB)
    22///////////////////////////////////////////////////////////////////////////////
    3 version="$Id: rinvar.lib,v 1.13 2005-05-06 14:39:09 hannes Exp $";
     3version="$Id: rinvar.lib,v 1.14 2005-05-10 17:56:16 Singular Exp $";
    44category="Invariant theory";
    55info="
    … …  
    428428        str = charstr(basering) + ", (" + varstr(basering)
    429429                   + ",t(" + string(nrt) + ")),";
    430         if(defined(RLAB)) { kill(RLAB);}
     430        if(defined(RLAB)) { kill RLAB;}
    431431        def RLAB = basering;
    432         if(defined(RLAR)) { kill(RLAR);}
     432        if(defined(RLAR)) { kill RLAR;}
    433433        execute("ring RLAR = " + str + "(" + order + ");");
    434434        execute(mPoly);
    … …  
    631631
    632632  def IRB = basering;
    633   if(defined(RIRR)) { kill(RIRR);}
     633  if(defined(RIRR)) { kill RIRR;}
    634634  def RIRR = basering;
    635635  setring RIRR;
    … …  
    10421042      else { columnList[size(columnList) + 1] = j; }
    10431043    }
    1044     if(defined(auxM)) { kill(auxM);}
     1044    if(defined(auxM)) { kill auxM;}
    10451045    matrix auxM[2][size(columnList)];      // built new matrix and omit
    10461046    for(j = 1; j <= size(columnList); j++) {    // the linear dependent colums

  • Singular/LIB/standard.lib

    redb4ff3 r3b77465  
    11//////////////////////////////////////////////////////////////////////////////
    2 version="$Id: standard.lib,v 1.69 2005-05-02 13:28:14 Singular Exp $";
     2version="$Id: standard.lib,v 1.70 2005-05-10 17:56:16 Singular Exp $";
    33category="Miscellaneous";
    44info="
    … …  
    210210          if (defined(groebner_error))
    211211          {
    212             kill(groebner_error);
     212            kill groebner_error;
    213213          }
    214           kill (l_fork);
     214          kill l_fork;
    215215        }
    216216        else

  • Singular/LIB/triang.lib

    redb4ff3 r3b77465  
    11//last change: 13.02.2001 (Eric Westenberger)
    22//////////////////////////////////////////////////////////////////////////////
    3 version="$Id: triang.lib,v 1.8 2005-05-06 14:39:19 hannes Exp $";
     3version="$Id: triang.lib,v 1.9 2005-05-10 17:56:16 Singular Exp $";
    44category="Symbolic-numerical solving";
    55info="
    … …  
    403403        }
    404404    }
    405     kill(zerlegt);
     405    kill zerlegt;
    406406    return(toSave);
    407407}

  • Singular/LIB/zeroset.lib

    redb4ff3 r3b77465  
    11// Last change 12.02.2001 (Eric Westenberger)
    22///////////////////////////////////////////////////////////////////////////////
    3 version="$Id: zeroset.lib,v 1.13 2005-05-06 14:39:20 hannes Exp $";
     3version="$Id: zeroset.lib,v 1.14 2005-05-10 17:56:17 Singular Exp $";
    44category="Symbolic-numerical solving";
    55info="
    … …  
    128128  poly newA = imap(ROR, newA);
    129129  poly f = imap(ROR, fn);
    130   kill(ROR);
     130  kill ROR;
    131131  export(roots);
    132132  export(newA);
    … …  
    372372  poly newA = imap(ZSR, newA);
    373373  ideal id = imap(ZSR, id);
    374   kill(ZSR);
     374  kill ZSR;
    375375
    376376  export(id);
    … …  
    491491  setring(QUOB);
    492492  list result = imap(QUOR, result);
    493   kill(QUOR);
     493  kill QUOR;
    494494  return(result);
    495495}
    … …  
    549549  setring(REMB);
    550550  poly r = imap(REMR, h);
    551   kill(REMR);
     551  kill REMR;
    552552  return(r);
    553553}
    … …  
    602602  setring(GCDB);
    603603  poly h = imap(GCDR, h);
    604   kill(GCDR);
     604  kill GCDR;
    605605  return(h);
    606606}
    … …  
    669669  setring(@RGCDB);
    670670  poly h = imap(@RGCD, @h);
    671   kill(@RGCD);
     671  kill @RGCD;
    672672  return(h);
    673673}
    … …  
    784784  setring(FRB);
    785785  list result = imap(FRR, result);
    786   kill(FRR);
     786  kill FRR;
    787787  return(result);
    788788}
    … …  
    11731173      setring(NLZR);
    11741174      partSol = imap(RIS1, roots);
    1175       kill(RIS1);
     1175      kill RIS1;
    11761176      if(mpoly[1] != partSol[3]) {      // change minpoly
    11771177        mpoly = std(partSol[3]);
    … …  
    11951195  result[5] = std(generators);
    11961196
    1197   kill(NLZR);
     1197  kill NLZR;
    11981198  return(result);
    11991199}
Note: See TracChangeset for help on using the changeset viewer.