# source:git/Singular/LIB/standard.lib@bfff18e

spielwiese
Last change on this file since bfff18e was bfff18e, checked in by Hans Schönemann <hannes@…>, 24 years ago
• Property mode set to `100644`
File size: 23.0 KB
Line
1// \$Id: standard.lib,v 1.30 1999-05-19 11:28:55 Singular Exp \$
2//////////////////////////////////////////////////////////////////////////////
3
4version="\$Id: standard.lib,v 1.30 1999-05-19 11:28:55 Singular Exp \$";
5info="
6LIBRARY: standard.lib   PROCEDURES WHICH ARE ALWAYS LOADED AT START-UP
7
8 stdfglm(ideal[,ord])   standard basis of the ideal via fglm [and ordering ord]
9 stdhilb(ideal)         standard basis of the ideal using the Hilbert function
10 groebner(ideal/module) standard basis of ideal or module using a
11                        heuristically choosen method
12 quot(any,any[,n])  a general quotient procedure calling several algorithms
13                  allows module/module, ideal/ideal, module/ideal and a
14                  pre-definition of the algorithm by the parameter n
15 quotient1(m1,m2) computes quotients by every vector of m2 and intersects them
16 quotient2(m1,m2) a heuristic variant: the quotient is just defined by a
17                  (not really) general element of m2 which has to be proved
18 quotient3(m1,m2) the homogeneous variant of quotient5(m1,m2)
19 quotient4(m1,m2) the same as quotient5(m1,m2) using the modulo-command
20                  instead of the quotient-command from the kernel
21 quotient5(m1,m2) computes with a real general element of m2 by adjoining
22                  a new variable
23 sprintf(fmt,...)     returns fomatted string
25 printf(fmt,...)      displays formatted string
26";
27
28//////////////////////////////////////////////////////////////////////////////
29
30proc stdfglm (ideal i, list #)
31"USAGE:   stdfglm(i[,s]); i ideal, s string (any allowed ordstr of a ring)
32RETURN:  stdfglm(i): standard basis of i in the basering, calculated via fglm
33                     from ordering \"dp\" to the ordering of the basering.
34         stdfglm(i,s): standard basis of i in the basering, calculated via
35                     fglm from ordering s to the ordering of the basering.
36EXAMPLE: example stdfglm; shows an example"
37{
38   string os;
39   def dr= basering;
40   if( (size(#)==0) or (typeof(#[1]) != "string") )
41   {
42     os = "dp(" + string( nvars(dr) ) + ")";
43     if ( (find( ordstr(dr), os ) != 0) and (find( ordstr(dr), "a") == 0) )
44     {
45       os= "Dp";
46     }
47     else
48     {
49       os= "dp";
50     }
51   }
52   else { os = #[1]; }
53   execute "ring sr=("+charstr(dr)+"),("+varstr(dr)+"),"+os+";";
54   ideal i= fetch(dr,i);
55   intvec opt= option(get);
56   option(redSB);
57   i=std(i);
58   option(set,opt);
59   setring dr;
60   return (fglm(sr,i));
61}
62example
63{ "EXAMPLE:"; echo = 2;
64   ring r  = 0,(x,y,z),lp;
65   ideal i = y3+x2, x2y+x2, x3-x2, z4-x2-y;
66   ideal i1= stdfglm(i);         //uses fglm from "dp" to "lp"
67   i1;
68   ideal i2= stdfglm(i,"Dp");    //uses fglm from "Dp" to "lp"
69   i2;
70}
71/////////////////////////////////////////////////////////////////////////////
72
73proc stdhilb(ideal i,list #)
74"USAGE:   stdhilb(i);  i ideal
75         stdhilb(i,v); i homogeneous ideal, v intvec (the Hilbert function)
76RETURN:  stdhilb(i): a standard basis of i (computing v internally)
77         stdhilb(i,v): standard basis of i, using the given Hilbert function
78EXAMPLE: example stdhilb; shows an example"
79{
80   def R=basering;
81
82   if((homog(i)==1)||(ordstr(basering)[1]=="d"))
83   {
84      if ((size(#)!=0)&&(homog(i)==1))
85      {
86         return(std(i,#[1]));
87      }
88      return(std(i));
89   }
90
91   execute "ring S = ("+charstr(R)+"),("+varstr(R)+",@t),dp;";
92   ideal i=homog(imap(R,i),@t);
93   intvec v=hilb(std(i),1);
94   execute "ring T = ("+charstr(R)+"),("+varstr(R)+",@t),("+ordstr(R)+");";
95   ideal i=fetch(S,i);
96   ideal a=std(i,v);
97   setring R;
98   map phi=T,maxideal(1),1;
99   ideal a=phi(a);
100
101   int k,j;
102   poly m;
103   int c=size(i);
104
105   for(j=1;j<c;j++)
106   {
107     if(deg(a[j])==0)
108     {
109       a=ideal(1);
110       attrib(a,"isSB",1);
111       return(a);
112     }
113     if(deg(a[j])>0)
114     {
116       for(k=j+1;k<=c;k++)
117       {
119          {
120            a[k]=0;
121          }
122       }
123     }
124   }
125   a=simplify(a,2);
126   attrib(a,"isSB",1);
127   return(a);
128}
129example
130{ "EXAMPLE:"; echo = 2;
131   ring  r = 0,(x,y,z),lp;
132   ideal i = y3+x2, x2y+x2, x3-x2, z4-x2-y;
133   ideal i1= stdhilb(i); i1;
134   // is in this case equivalent to:
135   intvec v=1,0,0,-3,0,1,0,3,-1,-1;
136   ideal i2=stdhilb(i,v);
137}
138//////////////////////////////////////////////////////////////////////////
139
140proc groebner(def i, list #)
141"USAGE: groebner(i[, wait]) i -- ideal/module; wait -- int
142RETURNS: Standard basis of ideal or module which is computed using a
143         heuristically choosen method:
144         If the ordering of the current ring is a local ordering, or
145         if it is a non-block ordering and the current ring has no
146         parameters, then std(i) is returned.
147         Otherwise, i is mapped into a ring with no parameters and
148         ordering dp, where its Hilbert series is computed. This is
149         followed by a Hilbert-series based std computation in the
150         original ring.
151NOTE: If a 2nd argument 'wait' is given, then the computation proceeds
152      at most 'wait' seconds. That is, if no result could be computed in
153      'wait' seconds, then the computation is interrupted, 0 is returned,
154      a warning message is displayed, and the global variable
155      'groebner_error' is defined.
156EXAMPLE: example groebner; shows an example"
157{
158  def P=basering;
159
160  // we have two arguments -- try to use MPfork links
161  if (size(#) > 0)
162  {
163    if (system("with", "MP"))
164    {
165      if (typeof(#[1]) == "int")
166      {
167        int wait = #[1];
168        int j = 10;
169
170        string bs = nameof(basering);
172        open(l_fork);
173        write(l_fork, quote(system("pid")));
175        write(l_fork, quote(groebner(eval(i))));
176
177        // sleep in small intervalls for appr. one second
178        if (wait > 0)
179        {
180          while(j < 1000000)
181          {
183            j = j + j;
184          }
185        }
186
187        // sleep in intervalls of one second from now on
188        j = 1;
189        while (j < wait)
190        {
192          j = j + 1;
193        }
194
196        {
198          if (bs != nameof(basering))
199          {
200            def PP = basering;
201            setring P;
202            def result = imap(PP, result);
203            kill PP;
204          }
205          if (defined(groebner_error))
206          {
207            kill(groebner_error);
208          }
209          kill (l_fork);
210        }
211        else
212        {
213          ideal result;
214          if (! defined(groebner_error))
215          {
216            int groebner_error = 1;
217            export groebner_error;
218          }
219          "// ** groebner did not finish";
220          j = system("sh", "kill " + string(pid));
221        }
222        return (result);
223      }
224      else
225      {
226        "// ** groebner needs int as 2nd arg";
227      }
228    }
229    else
230    {
231      "// ** groebner with two args is not supported in this configuration";
232    }
233  }
234
235  // we are still here -- do the actual computation
236  string ordstr_P = ordstr(P);
237  if (find(ordstr_P,"s") > 0)
238  {
239    //spaeter den lokalen fall ueber lp oder aehnlich behandeln
240    return(std(i));
241  }
242
243  int IsSimple_P;
244  if (system("nblocks") <= 2)
245  {
246    if (find(ordstr_P, "M") <= 0)
247    {
248      IsSimple_P = 1;
249    }
250  }
251  int npars_P = npars(P);
252
253  // return std if no parameters and (dp or wp)
254  if ((npars_P <= 1) && IsSimple_P)
255  {
256    if (find(ordstr_P, "d") > 0)
257    {
258      return (std(i));
259    }
260    if (find(ordstr_P,"w") > 0)
261    {
262      return (std(i));
263    }
264  }
265
266  // reset options
267  intvec opt=option(get);
268  int p_opt;
269  string s_opt = option();
270  option(none);
271  // turn on option(prot) and/or option(mem), if previously set
272  if (find(s_opt, "prot"))
273  {
274    option(prot);
275    p_opt = 1;
276  }
277  if (find(s_opt, "mem"))
278  {
279    option(mem);
280  }
281
282  // construct ring in which first std computation is done
283  string varstr_P = varstr(P);
284  string parstr_P = parstr(P);
285  int is_homog = (homog(i) && (npars_P <= 1));
287  string ri = "ring Phelp =";
288
289  // more than one parameters are converted to ring variables
290  if (npars_P > 1)
291  {
292    ri = ri + string(char(P)) + ",(" + varstr_P + "," + parstr_P;
294  }
295  else
296  {
297    ri = ri + "(" + charstr(P) + "),(" + varstr_P;
298  }
299
300  // a homogenizing variable is added, if necessary
301  if (! is_homog)
302  {
303    ri = ri + ",@t";
305  }
306  // ordering is set to (dp, C)
307  ri = ri + "),(dp,C);";
308
309  // change the ring
310  execute(ri);
311
312  // get ideal from previous ring
313  if (is_homog)
314  {
315    ideal qh = imap(P, i);
316  }
317  else
318  {
319    // and homogenize
320    ideal qh=homog(imap(P,i),@t);
321  }
322
323  // compute std and hilbert series
324  if (p_opt)
325  {
326    "std in " + ri[13, size(ri) - 13];
327  }
328  ideal qh1=std(qh);
329  intvec hi=hilb(qh1,1);
330
332  {
333    // no additional variables were introduced
334    setring P; // can immediately change to original ring
335    // simply compute std with hilbert series in original ring
336    if (p_opt)
337    {
338      "std with hilb in basering";
339    }
340    i = std(i, hi);
341  }
342  else
343  {
344    // additional variables were introduced
345    // need another intermediate ring
346    ri = "ring Phelp1 = (" + charstr(Phelp)
347      + "),(" + varstr(Phelp) + "),(" + ordstr_P;
348
349    // for lp wit at most one parameter, we do not need a block ordering
350    if ( ! (IsSimple_P && (add_vars <2) && find(ordstr_P, "l")))
351    {
352      // need block ordering
353      ri = ri + ", dp(" + string(add_vars) + ")";
354    }
355    ri = ri + ");";
356
357    // change to intermediate ring
358    execute(ri);
359    ideal qh = imap(Phelp, qh);
360    kill Phelp;
361    if (p_opt)
362    {
363      "std with hilb in " + ri[14,size(ri)-14];
364    }
365    // compute std with Hilbert series
366    qh = std(qh, hi);
367    // subst 1 for homogenizing var
368    if (!is_homog)
369    {
370      qh = subst(qh, @t, 1);
371    }
372
373    // go back to original ring
374    setring P;
375    // get ideal, delete zeros and clean SB
376    i = imap(Phelp1,qh);
377    i = simplify(i, 34);
378    kill Phelp1;
379  }
380
381  // clean-up time
382  option(set, opt);
383  if (find(s_opt, "redSB") > 0)
384  {
385    i=interred(i);
386  }
387  attrib(i, "isSB", 1);
388  return (i);
389}
390example
391{
392  "EXAMPLE: "; echo = 2;
393  ring r = 0, (a,b,c,d), lp;
394  option(prot);
395  ideal i = a+b+c+d, ab+ad+bc+cd, abc+abd+acd+bcd, abcd-1; // cyclic 4
396  groebner(i);
397  ring rp = (0, a, b), (c,d), lp;
398  ideal i = imap(r, i);
399  ideal j = groebner(i);
400  option(noprot);
401  j; simplify(j, 1); std(i);
402  if (system("with", "MP")) {groebner(i, 0);}
403  defined(groebner_error);
404}
405
406
407//////////////////////////////////////////////////////////////////////////
408proc res(list #)
409{
410   def P=basering;
411   def m=#[1]; //the ideal or module
412
413   int i=#[2]; //the length of the resolution
414               //if size(#)>2 a minimal resolution is computed
415
416   string varstr_P = varstr(P);
417
418   //LaScala for the homogeneous case
419   if(homog(m)==1)
420   {
421      resolution re;
422      if ((i==0) or (i>=nvars(basering)))
423      {
424        re=lres(m,i);
425        if(size(#)>2)
426        {
427           re=minres(re);
428        }
429      }
430      else
431      {
432        if(size(#)>2)
433        {
434          re=mres(m,i);
435        }
436        else
437        {
438          re=sres(std(m),i);
439        }
440      }
441      return(re);
442   }
443
444   //mres for the global non homogeneous case
445   if(find(ordstr(P),"s")==0)
446   {
447      string ri= "ring Phelp ="
448                  +string(char(P))+",("+varstr_P+"),(dp,C);";
449      execute(ri);
450      def m=imap(P,m);
451      list re=mres(m,i);
452      setring P;
453      resolution result=imap(Phelp,re);
454      return(result);
455   }
456
457   //sres for the local case and not minimal resolution
458   if(size(#)<=2)
459   {
460      string ri= "ring Phelp ="
461                  +string(char(P))+",("+varstr_P+"),(ls,c);";
462      execute(ri);
463      def m=imap(P,m);
464      m=std(m);
465      list re=sres(m,i);
466      setring P;
467      resolution result=imap(Phelp,re);
468      return(result);
469   }
470
471   //mres for the local case and minimal resolution
472   string ri= "ring Phelp ="
473                  +string(char(P))+",("+varstr_P+"),(ls,C);";
474   execute(ri);
475   def m=imap(P,m);
476   list re=mres(m,i);
477   setring P;
478   resolution result=imap(Phelp,re);
479   return(result);
480}
481
482proc quot (m1,m2,list #)
483"USAGE:   quot(m1, m2[, n]); m1, m2 two submodules of k^s,
484         n (optional) integer (1<= n <=5)
485RETURN:  the quotient of m1 and m2
486EXAMPLE: example quot; shows an example"
487{
488  if (((typeof(m1)!="ideal") and (typeof(m1)!="module"))
489     or ((typeof(m2)!="ideal") and (typeof(m2)!="module")))
490  {
491    "USAGE:   quot(m1, m2[, n]); m1, m2 two submodules of k^s,";
492    "         n (optional) integer (1<= n <=5)";
493    "RETURN:  the quotient of m1 and m2";
494    "EXAMPLE: example quot; shows an example";
495    return();
496  }
497  if (typeof(m1)!=typeof(m2))
498  {
499    return(quotient(m1,m2));
500  }
501  if (size(#)>0)
502  {
503    if (typeof(#[1])=="int" )
504    {
505      return(quot1(m1,m2,#[1]));
506    }
507  }
508  else
509  {
510    return(quot1(m1,m2,2));
511  }
512}
513example
514{ "EXAMPLE:"; echo = 2;
515  ring r=181,(x,y,z),(c,ls);
516  ideal id1=maxideal(4);
517  ideal id2=x2+xyz,y2-z3y,z3+y5xz;
518  option(prot);
519  ideal id6=quotient(id1,id2);
520  id6;
521  ideal id7=quot(id1,id2,1);
522  id7;
523  ideal id8=quot(id1,id2,2);
524  id8;
525}
526
527static proc quot1 (module m1, module m2,int n)
528"USAGE:   quot1(m1, m2, n); m1, m2 two submodules of k^s,
529         n integer (1<= n <=5)
530RETURN:  the quotient of m1 and m2
531EXAMPLE: example quot1; shows an example"
532{
533  if (n==1)
534  {
535    return(quotient1(m1,m2));
536  }
537  else
538  {
539    if (n==2)
540    {
541      return(quotient2(m1,m2));
542    }
543    else
544    {
545      if (n==3)
546      {
547        return(quotient3(m1,m2));
548      }
549      else
550      {
551        if (n==4)
552        {
553          return(quotient4(m1,m2));
554        }
555        else
556        {
557          if (n==5)
558          {
559            return(quotient5(m1,m2));
560          }
561          else
562          {
563            return(quotient(m1,m2));
564          }
565        }
566      }
567    }
568  }
569}
570example
571{ "EXAMPLE:"; echo = 2;
572  ring r=181,(x,y,z),(c,ls);
573  ideal id1=maxideal(4);
574  ideal id2=x2+xyz,y2-z3y,z3+y5xz;
575  option(prot);
576  ideal id6=quotient(id1,id2);
577  id6;
578  ideal id7=quot1(id1,id2,1);
579  id7;
580  ideal id8=quot1(id1,id2,2);
581  id8;
582}
583
584static proc quotient0(module a,module b)
585{
586  module mm=b+a;
587  resolution rs=lres(mm,0);
588  list I=list(rs);
589  matrix M=I[2];
590  matrix A[1][nrows(M)]=M[1..nrows(M),1];
591  ideal i=A;
592  return (i);
593}
594proc quotient1(module a,module b)  //17sec
595"USAGE:   quotient1(m1, m2); m1, m2 two submodules of k^s,
596RETURN:  the quotient of m1 and m2"
597{
598  int i;
599  a=std(a);
600  module dummy;
601  module B=NF(b,a)+dummy;
602  ideal re=quotient(a,module(B[1]));
603  for(i=2;i<=size(B);i++)
604  {
605     re=intersect1(re,quotient(a,module(B[i])));
606  }
607  return(re);
608}
609proc quotient2(module a,module b)    //13sec
610"USAGE:   quotient2(m1, m2); m1, m2 two submodules of k^s,
611RETURN:  the quotient of m1 and m2"
612{
613  a=std(a);
614  module dummy;
615  module bb=NF(b,a)+dummy;
616  int i=size(bb);
617  ideal re=quotient(a,module(bb[i]));
618  bb[i]=0;
619  module temp;
620  module temp1;
621  module bbb;
622  int mx;
623  i=i-1;
624  while (1)
625  {
626    if (i==0) break;
627    temp = a+bb*re;
629    mx=ncols(a);
630    if (ncols(temp1)>ncols(a))
631    {
632      mx=ncols(temp1);
633    }
635    temp1 = dummy+temp1;
636    if (deg(temp1[1])<0) break;
637    re=intersect1(re,quotient(a,module(bb[i])));
638    bb[i]=0;
639    i = i-1;
640  }
641  return(re);
642}
643proc quotient3(module a,module b)   //89sec
644"USAGE:   quotient3(m1, m2); m1, m2 two submodules of k^s,
645         only for global rings
646RETURN:  the quotient of m1 and m2"
647{
648  string s="ring @newr=("+charstr(basering)+
649           "),("+varstr(basering)+",@t,@w),dp;";
650  def @newP=basering;
651  execute s;
652  module b=imap(@newP,b);
653  module a=imap(@newP,a);
654  int i;
655  int j=size(b);
656  vector @b;
657  for(i=1;i<=j;i++)
658  {
659     @b=@b+@t^(i-1)*@w^(j-i+1)*b[i];
660  }
661  ideal re=quotient(a,module(@b));
662  setring @newP;
663  ideal re=imap(@newr,re);
664  return(re);
665}
666proc quotient5(module a,module b)   //89sec
667"USAGE:   quotient5(m1, m2); m1, m2 two submodules of k^s,
668         only for global rings
669RETURN:  the quotient of m1 and m2"
670{
671  string s="ring @newr=("+charstr(basering)+
672           "),("+varstr(basering)+",@t),dp;";
673  def @newP=basering;
674  execute s;
675  module b=imap(@newP,b);
676  module a=imap(@newP,a);
677  int i;
678  int j=size(b);
679  vector @b;
680  for(i=1;i<=j;i++)
681  {
682     @b=@b+@t^(i-1)*b[i];
683  }
684  @b=homog(@b,@w);
685  ideal re=quotient(a,module(@b));
686  setring @newP;
687  ideal re=imap(@newr,re);
688  return(re);
689}
690proc quotient4(module a,module b)   //95sec
691"USAGE:   quotient4(m1, m2); m1, m2 two submodules of k^s,
692         only for global rings
693RETURN:  the quotient of m1 and m2"
694{
695  string s="ring @newr=("+charstr(basering)+
696           "),("+varstr(basering)+",@t),dp;";
697  def @newP=basering;
698  execute s;
699  module b=imap(@newP,b);
700  module a=imap(@newP,a);
701  int i;
702  vector @b=b[1];
703  for(i=2;i<=size(b);i++)
704  {
705     @b=@b+@t^(i-1)*b[i];
706  }
707  matrix sy=modulo(@b,a);
708  ideal re=sy;
709  setring @newP;
710  ideal re=imap(@newr,re);
711  return(re);
712}
713static proc intersect1(ideal i,ideal j)
714{
715  def R=basering;
716  execute "ring gnir = ("+charstr(basering)+"),
717                       ("+varstr(basering)+",@t),(C,dp);";
718  ideal i=var(nvars(basering))*imap(R,i)+(var(nvars(basering))-1)*imap(R,j);
719  ideal j=eliminate(i,var(nvars(basering)));
720  setring R;
721  map phi=gnir,maxideal(1);
722  return(phi(j));
723}
724
725//////////////////////////////////////////////////////////////////
726///
727/// sprintf, fprintf printf
728///
729proc sprintf(string fmt, list #)
730"USAGE:    sprintf(fmt, ...) fmt string
731RETURN:   string
732PURPOSE:  sprintf performs output formatting. The first argument is a format
733          control string. Additional arguments may be required, depending on
734          the contents of the control string. A series of output characters is
735          generated as directed by the control string; these characters are
736          returned as a string. The control string is simply text to be copied,
737          except that the string may contain conversion specifications. Do
738          'help print:' for a listing of valid conversion specifications.
739          As an addition to the conversions of 'print', the '%n' and '%2'
740          conversion specification does not consume an additional argument,
741          but simply generates a newline character.
742NOTE:     If one of the additional arguments is a list, then it should be
743          enclosed once more into a list() command, since passing a list
744          as an argument flattens the list by one level.
746EXAMPLE : example sprintf; shows an example
747"
748{
749  if (size(fmt) <= 1)
750  {
751    return (fmt);
752  }
753  int next, l, nnext;
754  string ret;
755  list formats = "%l", "%s", "%2l", "%2s", "%t", "%;", "%p", "%b", "%n", "%2";
756  while (1)
757  {
758    if (size(#) <= 0)
759    {
760      return (ret + fmt);
761    }
762    nnext = 0;
763    while (1)
764    {
765      nnext = find(fmt, "%", nnext + 1);
766      if (nnext == 0)
767      {
768        next = 0;
769        break;
770      }
771      l = 1;
772      while (l <= size(formats))
773      {
774        next = find(fmt, formats[l], nnext);
775        if (next == nnext) break;
776        l++;
777      }
778      if (next == nnext) break;
779    }
780    if (next == 0)
781    {
782      return (ret + fmt);
783    }
784    if (formats[l] != "%2" && formats[l] != "%n")
785    {
786      ret = ret + fmt[1, next - 1] + print(#[1], formats[l]);
787      # = delete(#, 1);
788    }
789    else
790    {
791      ret = ret + fmt[1, next - 1] + print("", "%2s");
792    }
793    if (size(fmt) <= (next + size(formats[l]) - 1))
794    {
795      return (ret);
796    }
797    fmt = fmt[next + size(formats[l]), size(fmt)-next-size(formats[l]) + 1];
798  }
799}
800example
801{
802  ring r=0,(x,y,z),dp;
803  module m=[1,y],[0,x+z];
804  intmat M=betti(mres(m,0));
805  list l = r, m, M;
806  string s = sprintf("s:%s,%n l:%l", 1, 2); s;
807  s = sprintf("s:%n%s", l); s;
808  s = sprintf("s:%2%s", list(l)); s;
809  s = sprintf("2l:%n%2l", list(l)); s;
810  s = sprintf("%p", list(l)); s;
811  s = sprintf("%;", list(l)); s;
812  s = sprintf("%b", M); s;
813}
814
815proc printf(string fmt, list #)
816"USAGE:    printf(fmt, ...) fmt string
817RETURN:   none
818PURPOSE:  printf performs output formatting. The first argument is a format
819          control string. Additional arguments may be required, depending on
820          the contents of the control string. A series of output characters is
821          generated as directed by the control string; these characters are
822          displayed (i.e. printed to standard out).
823          The control string is simply text to be copied, except that the
824          string may contain conversion specifications.
825          Do 'help print:' for a listing of valid conversion specifications.
826          As an addition to the conversions of 'print', the '%n' and '%2'
827          conversion specification does not consume an additional argument,
828          but simply generates a newline character.
829
830NOTE:     If one of the additional arguments is a list, then it should be
831          enclosed once more into a list() command, since passing a list
832          as an argument flattens the list by one level.
834EXAMPLE : example printf; shows an example
835"
836{
837  write("", sprintf(fmt, #));
838}
839example
840{
841  ring r=0,(x,y,z),dp;
842  module m=[1,y],[0,x+z];
843  intmat M=betti(mres(m,0));
844  list l = r, m, M;
845  printf("s:%s, l:%l", 1, 2);
846  printf("s:%s", l);
847  printf("s:%s", list(l));
848  printf("2l:%2l", list(l));
849  printf("%p", list(l));
850  printf("%;", list(l));
851  printf("%b", M);
852}
853
854
855proc fprintf(link l, string fmt, list #)
856"USAGE:    fprintf(l, fmt, ...) l link; fmt string
857RETURN:   none
858PURPOSE:  fprintf performs output formatting. The second argument is a format
859          control string. Additional arguments may be required, depending on
860          the contents of the control string. A series of output characters is
861          generated as directed by the control string; these characters are
862          written to the link l.
863          The control string is simply text to be copied, except that the
864          string may contain conversion specifications.
865          Do 'help print:' for a listing of valid conversion specifications.
866          As an addition to the conversions of 'print', the '%n' and '%2'
867          conversion specification does not consume an additional argument,
868          but simply generates a newline character.
869
870NOTE:     If one of the additional arguments is a list, then it should be
871          enclosed once more into a list() command, since passing a list
872          as an argument flattens the list by one level.
874EXAMPLE : example fprintf; shows an example
875"
876{
877  write(l, sprintf(fmt, #));
878}
879example
880{
881  ring r=0,(x,y,z),dp;
882  module m=[1,y],[0,x+z];
883  intmat M=betti(mres(m,0));
884  list l = r, m, M;
886  fprintf(li, "s:%s, l:%l", 1, 2);
887  fprintf(li, "s:%s", l);
888  fprintf(li, "s:%s", list(l));
889  fprintf(li, "2l:%2l", list(l));
890  fprintf(li, "%p", list(l));
891  fprintf(li, "%;", list(l));
892  fprintf(li, "%b", M);
893}
894
895
896
897
898
899
900/*
901proc minres(list #)
902{
903  if (size(#) == 2)
904  {
905    if (typeof(#[1]) == "ideal" || typeof(#[1]) == "module")
906    {
907      if (typeof(#[2] == "int"))
908      {
909        return (res(#[1],#[2],1));
910      }
911    }
912  }
913
914  if (typeof(#[1]) == "resolution")
915  {
916    return minimizeres(#[1]);
917  }
918  else
919  {
920    return minimizeres(#);
921  }
922
923}
924
925*/
Note: See TracBrowser for help on using the repository browser.