Changeset 27d4bb in git


Ignore:
Timestamp:
Oct 18, 2010, 3:32:34 PM (13 years ago)
Author:
Hans Schoenemann <hannes@…>
Branches:
(u'spielwiese', 'd1b01e9d51ade4b46b745d3bada5c5f3696be3a8')
Children:
45d2830f44d33be662443953b983c65ea1f6c01a
Parents:
bb4a16850326367ce586be55d83be2ed7f7ed811
Message:
format

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

Legend:

Unmodified
Added
Removed
  • Singular/LIB/KVequiv.lib

    rbb4a16 r27d4bb  
    1 // $Id$
    2 // (anne, last modified 27.11.2001)
    3 /////////////////////////////////////////////////////////////////////////////
    4 // LIBRARY HEADER
    51/////////////////////////////////////////////////////////////////////////////
    62
  • Singular/LIB/ainvar.lib

    rbb4a16 r27d4bb  
    1 // $Id$
    21/////////////////////////////////////////////////////////////////////////////
    32version="$Id$";
  • Singular/LIB/aksaka.lib

    rbb4a16 r27d4bb  
    1 //CM, last modified 10.12.06
    21///////////////////////////////////////////////////////////////////////////////
    32version="$Id$";
  • Singular/LIB/all.lib

    rbb4a16 r27d4bb  
    1 // $Id$
    21///////////////////////////////////////////////////////////////////////////////
    32version="$Id$";
  • Singular/LIB/all.lib.tmpl

    rbb4a16 r27d4bb  
    1 // $Id$
    21///////////////////////////////////////////////////////////////////////////////
    32version="$Id$";
  • Singular/LIB/assprimeszerodim.lib

    rbb4a16 r27d4bb  
    2828
    2929proc zeroRadical(ideal I, list #)
    30 "USAGE:  zeroRadical(I,[n]); I ideal, optional: n number of processors (for 
     30"USAGE:  zeroRadical(I,[n]); I ideal, optional: n number of processors (for
    3131         parallel computing)
    3232ASSUME:  I is zero-dimensional in Q[variables]
     
    4949
    5050static proc zeroR(ideal I, list #)
    51 // compute the radical of I provided that I is zero-dimensional in Q[variables] 
     51// compute the radical of I provided that I is zero-dimensional in Q[variables]
    5252// and a standard basis
    5353{
  • Singular/LIB/cimonom.lib

    rbb4a16 r27d4bb  
    1 //////////////////////////////////////////////////////////////////////////////////////
     1///////////////////////////////////////////////////////////////////////////////
    22version = "$Id$";
    33category="Commutative Algebra";
  • Singular/LIB/curvepar.lib

    rbb4a16 r27d4bb  
    1 ////////////////////////////////////////////////////////////////////////////////////
     1///////////////////////////////////////////////////////////////////////////////
    22version="$Id$";
    33category="Singularities";
  • Singular/LIB/modstd.lib

    rbb4a16 r27d4bb  
    6767   def R = basering;
    6868   setring R;
    69    
     69
    7070   attrib(J,"isSB",1);
    7171   int i,j,k;
     
    8282            //link l(i) = "ssi:fork";
    8383            open(l(i));
    84            
     84
    8585            write(l(i), quote(redFork(eval(I[ncols(I)-i]), eval(J), 1)));
    8686         }
     
    106106            {
    107107               if(status(l(i), "read", "ready"))
    108                { 
     108               {
    109109                  if(read(l(i)) != 0)
    110110                  {
     
    252252proc deleteUnluckyPrimes(list T, list L, int ho, list #)
    253253"USAGE:  deleteUnluckyPrimes(T,L,ho,#); T/L list of polys/primes, ho integer
    254 RETURN:  lists T,L(,M),lT with T/L(/M) list of polys/primes(/type of #), 
     254RETURN:  lists T,L(,M),lT with T/L(/M) list of polys/primes(/type of #),
    255255         lT ideal
    256256NOTE:    - if ho = 1, the polynomials in T are homogeneous, else ho = 0,
     
    518518"USAGE:  modpStd(I,p,variant,#); I ideal, p integer, variant integer
    519519ASSUME:  If size(#) > 0, then #[1] is an intvec describing the Hilbert series.
    520 RETURN:  ideal - a standard basis of I mod p, integer - p 
     520RETURN:  ideal - a standard basis of I mod p, integer - p
    521521NOTE:    The procedure computes a standard basis of the ideal I modulo p and
    522522         fetches the result to the basering. If size(#) > 0 the Hilbert driven
     
    551551      }
    552552   }
    553    
     553
    554554   if((variant == 2) || (variant == 5))
    555555   {
     
    603603      kill HomR;
    604604   }
    605    
     605
    606606   setring R0;
    607607   return(list(fetch(@r,i),p));
     
    626626ASSUME:  If size(#) > 0, then # contains either 1, 2 or 4 integers such that
    627627@*       - #[1] is the number of available processors for the computation
    628                 (parallelization is just applicable using 32-bit Singular 
    629                 version since MP-links are not compatible with 64-bit Singular 
     628                (parallelization is just applicable using 32-bit Singular
     629                version since MP-links are not compatible with 64-bit Singular
    630630                version),
    631631@*       - #[2] is an optional parameter for the exactness of the computation,
     
    639639         result is a standard basis containing I and with high probability
    640640         a standard basis of I.
    641          By default the procedure computes a standard basis of I for sure, but 
    642          if the optional parameter #[2] = 0, it computes a standard basis of I 
     641         By default the procedure computes a standard basis of I for sure, but
     642         if the optional parameter #[2] = 0, it computes a standard basis of I
    643643         with high probability and a warning appears at the end.
    644644         The procedure distinguishes between different variants for the standard
     
    665665   if((npars(R0) > 0) || (rl[1] > 0))
    666666   {
    667       ERROR("Characteristic of basering should be zero, basering should 
     667      ERROR("Characteristic of basering should be zero, basering should
    668668             have no parameters.");
    669669   }
     
    737737//-------------------------  Save current options  -----------------------------
    738738   intvec opt = option(get);
    739    
     739
    740740   option(redSB);
    741741
     
    755755      if(h)
    756756      {
    757          if(exactness == 0) 
    758          { 
    759             variant = 1; 
    760             if(printlevel >= 10) { "variant = 1"; } 
    761          }
    762          if(exactness == 1) 
    763          { 
    764             variant = 4; 
    765             if(printlevel >= 10) { "variant = 4"; } 
     757         if(exactness == 0)
     758         {
     759            variant = 1;
     760            if(printlevel >= 10) { "variant = 1"; }
     761         }
     762         if(exactness == 1)
     763         {
     764            variant = 4;
     765            if(printlevel >= 10) { "variant = 4"; }
    766766         }
    767767         rl[1] = L[5];
     
    798798            if(system("nblocks") <= 2)
    799799            {
    800                if(find(ordstr_R0, "M") + find(ordstr_R0, "lp") 
     800               if(find(ordstr_R0, "M") + find(ordstr_R0, "lp")
    801801                                       + find(ordstr_R0, "rp") <= 0)
    802802               {
     
    830830                  if(printlevel >= 10) { "variant = 6"; }
    831831               }
    832        
     832
    833833               rl[1] = L[5];
    834834               def @r = ring(rl);
     
    861861      if(h)
    862862      {
    863          variant = 1; if(printlevel >= 10) { "variant = 1"; } 
     863         variant = 1; if(printlevel >= 10) { "variant = 1"; }
    864864         rl[1] = L[5];
    865865         def @r = ring(rl);
     
    887887            if(system("nblocks") <= 2)
    888888            {
    889                if(find(ordstr_R0, "M") + find(ordstr_R0, "lp") 
     889               if(find(ordstr_R0, "M") + find(ordstr_R0, "lp")
    890890                                       + find(ordstr_R0, "rp") <= 0)
    891891               {
     
    903903               variant = 3;
    904904               if(printlevel >= 10) { "variant = 3"; }
    905        
     905
    906906               rl[1] = L[5];
    907907               def @r = ring(rl);
     
    929929      }
    930930   }
    931  
     931
    932932   list P,T1,T2,T3,LL;
    933933
     
    949949         link l(i) = "MPtcp:fork";
    950950         open(l(i));
    951          if((variant == 1) || (variant == 3) || 
     951         if((variant == 1) || (variant == 3) ||
    952952            (variant == 4) || (variant == 6))
    953953         {
    954             write(l(i), quote(modpStd(I_for_fork, eval(L[i + 1]), 
     954            write(l(i), quote(modpStd(I_for_fork, eval(L[i + 1]),
    955955                                                  eval(variant), eval(hi))));
    956956         }
    957957         if((variant == 2) || (variant == 5))
    958958         {
    959             write(l(i), quote(modpStd(I_for_fork, eval(L[i + 1]), 
     959            write(l(i), quote(modpStd(I_for_fork, eval(L[i + 1]),
    960960                                                  eval(variant))));
    961961         }
     
    996996            {
    997997               //--- ask if link l(i) is ready otherwise sleep for t seconds ---
    998                if(status(l(i), "read", "ready"))                     
     998               if(status(l(i), "read", "ready"))
    999999               {
    10001000                  //--- read the result from l(i) ---
    1001                   P = read(l(i));                                     
     1001                  P = read(l(i));
    10021002                  T1[index] = P[1];
    10031003                  T2[index] = bigint(P[2]);
     
    10061006                  if(j <= size(L))
    10071007                  {
    1008                      if((variant == 1) || (variant == 3) || 
     1008                     if((variant == 1) || (variant == 3) ||
    10091009                        (variant == 4) || (variant == 6))
    10101010                     {
    1011                         write(l(i), quote(modpStd(I_for_fork, eval(L[j]), 
     1011                        write(l(i), quote(modpStd(I_for_fork, eval(L[j]),
    10121012                                                  eval(variant), eval(hi))));
    10131013                        j++;
     
    10151015                     if((variant == 2) || (variant == 5))
    10161016                     {
    1017                         write(l(i), quote(modpStd(I_for_fork, 
     1017                        write(l(i), quote(modpStd(I_for_fork,
    10181018                                                  eval(L[j]), eval(variant))));
    10191019                        j++;
     
    10281028            }
    10291029            //--- k describes the number of closed links ---
    1030             if(k == n1)                                               
     1030            if(k == n1)
    10311031            {
    10321032               j++;
     
    10391039         while(j <= size(L))
    10401040         {
    1041             if((variant == 1) || (variant == 3) || 
     1041            if((variant == 1) || (variant == 3) ||
    10421042               (variant == 4) || (variant == 6))
    10431043            {
     
    10831083      tt = timer; rt = rtimer;
    10841084      if(pd > 2) { "list of primes:"; L; "pTest"; }
    1085       if((variant == 1) || (variant == 3) || (variant == 4) || (variant == 6)) 
    1086       { 
    1087          pTest = pTestSB(I,J,L,variant,hi); 
    1088       }
    1089       if((variant == 2) || (variant == 5)) 
    1090       { 
    1091          pTest = pTestSB(I,J,L,variant); 
     1085      if((variant == 1) || (variant == 3) || (variant == 4) || (variant == 6))
     1086      {
     1087         pTest = pTestSB(I,J,L,variant,hi);
     1088      }
     1089      if((variant == 2) || (variant == 5))
     1090      {
     1091         pTest = pTestSB(I,J,L,variant);
    10921092      }
    10931093
     
    10971097         "Real-time for pTest is "+string(rtimer - rt)+" seconds.";
    10981098      }
    1099  
     1099
    11001100      if(pTest)
    11011101      {
     
    11041104            "CPU-time for computation without final tests is
    11051105            "+string(timer - TT)+" seconds.";
    1106             "Real-time for computation without final tests is 
     1106            "Real-time for computation without final tests is
    11071107            "+string(rtimer - RT)+" seconds.";
    11081108         }
     
    11141114         if(printlevel >= 10)
    11151115         {
    1116             "CPU-time for checking if I subset <G> is 
     1116            "CPU-time for checking if I subset <G> is
    11171117            "+string(timer - tt)+" seconds.";
    1118             "Real-time for checking if I subset <G> is 
     1118            "Real-time for checking if I subset <G> is
    11191119            "+string(rtimer - rt)+" seconds.";
    11201120         }
     
    11381138               if(printlevel >= 10)
    11391139               {
    1140                   "CPU-time for last std-computation is 
     1140                  "CPU-time for last std-computation is
    11411141                  "+string(timer - tt)+" seconds.";
    1142                   "Real-time for last std-computation is 
     1142                  "Real-time for last std-computation is
    11431143                  "+string(rtimer - rt)+" seconds.";
    11441144               }
     
    11711171         {
    11721172            open(l(i));
    1173             if((variant == 1) || (variant == 3) || 
     1173            if((variant == 1) || (variant == 3) ||
    11741174               (variant == 4) || (variant == 6))
    11751175            {
    1176                write(l(i), quote(modpStd(I_for_fork, eval(L[j+i-1]), 
     1176               write(l(i), quote(modpStd(I_for_fork, eval(L[j+i-1]),
    11771177                                                     eval(variant), eval(hi))));
    11781178            }
    11791179            if((variant == 2) || (variant == 5))
    11801180            {
    1181                write(l(i), quote(modpStd(I_for_fork, eval(L[j+i-1]), 
     1181               write(l(i), quote(modpStd(I_for_fork, eval(L[j+i-1]),
    11821182                                                     eval(variant))));
    11831183            }
     
    12091209   size(reduce(J1,J2));
    12101210   size(reduce(J2,J1));
    1211    
     1211
    12121212   /*
    12131213   ring R4 = 0,x(1..4),wp(1,-1,-1,1);
     
    12351235   list T;
    12361236   list rl = ringlist(R0);
    1237    if((npars(R0)>0) || (rl[1]>0)) 
    1238    { 
    1239       ERROR("Characteristic of basering should be zero."); 
     1237   if((npars(R0)>0) || (rl[1]>0))
     1238   {
     1239      ERROR("Characteristic of basering should be zero.");
    12401240   }
    12411241   for(j = 1; j <= size(L); j++)
     
    12581258      kill @r;
    12591259   }
    1260    L = deleteUnluckyPrimes(T,L,homog(I)); 
     1260   L = deleteUnluckyPrimes(T,L,homog(I));
    12611261   // unlucky if and only if the leading ideal is wrong
    12621262   J = farey(chinrem(L[1],L[2]),N);
  • Singular/LIB/resbin.lib

    rbb4a16 r27d4bb  
    1 // rocio, last modified 23.05.10
    21////////////////////////////////////////////////////////////////////////////
    32version="$Id: resbin.lib$";
  • Singular/LIB/standard.lib

    rbb4a16 r27d4bb  
    1616 qslimgb(i)             computes a standard basis with slimgb in a qring
    1717 par2varRing([i])       create a ring making pars to vars, together with i
    18  datetime()             return date and time as a string
     18 datetime()             return date and time as a string
    1919
    2020";
  • Singular/LIB/template.lib

    rbb4a16 r27d4bb  
    4747Help is in pure Texinfo.
    4848@*This help string is written in texinfo, which enables you to use,
    49 among others, the @@math command for mathematical typesetting 
     49among others, the @@math command for mathematical typesetting
    5050(for instance, to print @math{\alpha, \beta}).
    5151@*Texinfo also gives more control over the layout, but is, admittingly,
     
    7676         @* Use @math for simple math mode typesetting (e.g., @math{i_1}).
    7777         @* Warning: Parenthesis like } are not allowed inside @math and @code.
    78          @* Use @example for indented, preformatted text typesetting in 
     78         @* Use @example for indented, preformatted text typesetting in
    7979         typewriter font:
    8080@example
Note: See TracChangeset for help on using the changeset viewer.