Changeset 6f2edc in git for Singular/LIB/ring.lib


Ignore:
Timestamp:
Apr 28, 1997, 9:27:25 PM (27 years ago)
Author:
Olaf Bachmann <obachman@…>
Branches:
(u'spielwiese', 'd1b01e9d51ade4b46b745d3bada5c5f3696be3a8')
Children:
8c5a578cc8481c8a133a58030c4c4c8227d82bb1
Parents:
6d09c564c80f079b501f7187cf6984d040603849
Message:
Mon Apr 28 21:00:07 1997  Olaf Bachmann
<obachman@ratchwum.mathematik.uni-kl.de (Olaf Bachmann)>

     * dunno why I am committing these libs -- have not modified any
       of them


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

Legend:

Unmodified
Added
Removed

  • Singular/LIB/ring.lib

    r6d09c56 r6f2edc  
    1 // $Id: ring.lib,v 1.1.1.1 1997-04-25 15:13:27 obachman Exp $
    2 //(GMG, 95/11/3)
    3 ///////////////////////////////////////////////////////////////////////////////
    4 
    5 LIBRARY:  ring.lib      PROCEDURES FOR MANIPULATING RINGS AND MAPS       
     1// $Id: ring.lib,v 1.2 1997-04-28 19:27:25 obachman Exp $
     2//(GMG, last modified 03.11.95)
     3///////////////////////////////////////////////////////////////////////////////
     4
     5LIBRARY:  ring.lib      PROCEDURES FOR MANIPULATING RINGS AND MAPS
    66
    77 changechar("R",c[,r]); make a copy R of basering [ring r] with new char c
    … …  
    2525USAGE:   changechar(newr,c[,r]);  newr,c=strings, r=ring
    2626CREATE:  create a new ring with name `newr` and make it the basering if r is
    27          an existing ring [default: r=basering]. 
     27         an existing ring [default: r=basering].
    2828         The new ring differs from the old ring only in the characteristic.
    29          If, say, (newr,c) = ("R","0,A") and the ring r exists, the new 
     29         If, say, (newr,c) = ("R","0,A") and the ring r exists, the new
    3030         basering will have name R characteristic 0 and one parameter A.
    3131RETURN:  No return value
    3232NOTE:    Works for qrings if map from old_char to new_char is implemented
    33          This proc uses 'execute' or calls a procedure using 'execute'. 
    34          If you use it in your own proc, let the local names of your proc 
     33         This proc uses 'execute' or calls a procedure using 'execute'.
     34         If you use it in your own proc, let the local names of your proc
    3535         start with @ (see the file HelpForProc)
    3636EXAMPLE: example changechar; shows an example
    … …  
    4040   setring @r;
    4141   ideal i = ideal(@r); int @q = size(i);
    42    if( @q!=0 ) 
     42   if( @q!=0 )
    4343      { string @s = "@newr1"; }
    44    else 
     44   else
    4545      { string @s = newr; }
    4646   string @newring = @s+"=("+c+"),("+varstr(@r)+"),("+ordstr(@r)+");";
    … …  
    5151      ideal i = phi(i);
    5252      attrib(i,"isSB",1);         //*** attrib funktioniert ?
    53       execute("qring "+newr+"=i;");   
     53      execute("qring "+newr+"=i;");
    5454   }
    5555   export(`newr`);
    … …  
    7070USAGE:   changeord(newr,o[,r]);  newr,o=strings, r=ring/qring
    7171CREATE:  create a new ring with name `newr` and make it the basering if r is
    72          an existing ring/qring [default: r=basering]. 
     72         an existing ring/qring [default: r=basering].
    7373         The new ring differs from the old ring only in the ordering. If, say,
    74          (newr,o) = ("R","wp(2,3),dp") and the ring r exists and has >=3 
     74         (newr,o) = ("R","wp(2,3),dp") and the ring r exists and has >=3
    7575         variables, the new basering will have name R and ordering wp(2,3),dp.
    7676RETURN:  No return value
    77 NOTE:    This proc uses 'execute' or calls a procedure using 'execute'. 
    78          If you use it in your own proc, let the local names of your proc 
     77NOTE:    This proc uses 'execute' or calls a procedure using 'execute'.
     78         If you use it in your own proc, let the local names of your proc
    7979         start with @ (see the file HelpForProc)
    8080EXAMPLE: example changeord; shows an example
    … …  
    8484   setring @r;
    8585   ideal i = ideal(@r); int @q = size(i);
    86    if( @q!=0 ) 
     86   if( @q!=0 )
    8787      { string @s = "@newr1"; }
    88    else 
     88   else
    8989      { string @s = newr; }
    9090   string @newring = @s+"=("+charstr(@r)+"),("+varstr(@r)+"),("+o+");";
    … …  
    9595      ideal i = phi(i);
    9696      attrib(i,"isSB",1);         //*** attrib funktioniert ?
    97       execute("qring "+newr+"=i;");   
     97      execute("qring "+newr+"=i;");
    9898   }
    9999   export(`newr`);
    … …  
    116116USAGE:   changevar(newr,vars[,r]);  newr,vars=strings, r=ring/qring
    117117CREATE:  creates a new ring with name `newr` and makes it the basering if r
    118          is an existing ring/qring [default: r=basering]. 
     118         is an existing ring/qring [default: r=basering].
    119119         The new ring differs from the old ring only in the variables. If,
    120          say, (newr,vars) = ("R","t()") and the ring r exists and has n 
    121          variables, the new basering will have name R and variables 
     120         say, (newr,vars) = ("R","t()") and the ring r exists and has n
     121         variables, the new basering will have name R and variables
    122122         t(1),...,t(n).
    123          If vars = "a,b,c,d", the new ring will have the variables a,b,c,d. 
     123         If vars = "a,b,c,d", the new ring will have the variables a,b,c,d.
    124124RETURN:  No return value
    125125NOTE:    This procedure is useful in connection with the procedure ringtensor,
    126126         when a conflict between variable names must be avoided.
    127          This proc uses 'execute' or calls a procedure using 'execute'. 
    128          If you use it in your own proc, let the local names of your proc 
     127         This proc uses 'execute' or calls a procedure using 'execute'.
     128         If you use it in your own proc, let the local names of your proc
    129129         start with @ (see the file HelpForProc)
    130130EXAMPLE: example changevar; shows an example
    … …  
    134134   setring @r;
    135135   ideal i = ideal(@r); int @q = size(i);
    136    if( @q!=0 ) 
     136   if( @q!=0 )
    137137      { string @s = "@newr1"; }
    138    else 
     138   else
    139139      { string @s = newr; }
    140140   string @newring = @s+"=("+charstr(@r)+"),(";
    141141   if( vars[size(vars)-1]=="(" and vars[size(vars)]==")" )
    142    { 
    143       @newring = @newring+vars[1,size(vars)-2]+"(1.."+string(nvars(@r))+")"; 
     142   {
     143      @newring = @newring+vars[1,size(vars)-2]+"(1.."+string(nvars(@r))+")";
    144144   }
    145145   else { @newring = @newring+vars; }
    … …  
    151151      ideal i = phi(i);
    152152      attrib(i,"isSB",1);         //*** attrib funktioniert ?
    153       execute("qring "+newr+"=i;");   
     153      execute("qring "+newr+"=i;");
    154154   }
    155155   export(`newr`);
    … …  
    174174CREATE:  Define a ring with name 's1', characteristic 's2', ordering 's4' and
    175175         n variables with names derived from s3 and make it the basering.
    176          If s3 is a single letter, say s3="a", and if n<=26 then a and the 
    177          following n-1 letters from the alphabeth (cyclic order) are taken as 
    178          variables. If n>26 or if s3 is a single letter followed by (, say 
    179          s3="T(", the variables are T(1),...,T(n). 
     176         If s3 is a single letter, say s3="a", and if n<=26 then a and the
     177         following n-1 letters from the alphabeth (cyclic order) are taken as
     178         variables. If n>26 or if s3 is a single letter followed by (, say
     179         s3="T(", the variables are T(1),...,T(n).
    180180RETURN:  No return value
    181181NOTE:    This proc is useful for defining a ring in a procedure.
    182          This proc uses 'execute' or calls a procedure using 'execute'. 
    183          If you use it in your own proc, let the local names of your proc 
     182         This proc uses 'execute' or calls a procedure using 'execute'.
     183         If you use it in your own proc, let the local names of your proc
    184184         start with @ (see the file HelpForProc)
    185185EXAMPLE: example defring; shows an example
    … …  
    258258   execute("keepring P"+string(n)+";");
    259259   //the next comment is only shown if defringp is not called by another proc
    260    if (voice==2) { "// basering is now:",s; }   
    261 }   
     260   if (voice==2) { "// basering is now:",s; }
     261}
    262262example
    263263{ "EXAMPLE:"; echo = 2;
    … …  
    269269
    270270proc extendring (string na, int n, string va, string o, list #)
    271 USAGE:   extendring(na,n,va,o[iv,i,r]);  na,va,o=strings, 
     271USAGE:   extendring(na,n,va,o[iv,i,r]);  na,va,o=strings,
    272272         n,i=integers, r=ring, iv=intvec of positive integers or iv=0
    273273CREATE:  Define a ring with name `na` which extends the ring r by adding n new
    … …  
    275275         the basering [default: (i,r)=(0,basering)]
    276276         -- The characteristic is the characteristic of r
    277          -- The new vars are derived from va. If va is a single letter, say 
    278             va="T", and if n<=26 then T and the following n-1 letters from 
    279             T..Z..T (resp. T(1..n) if n>26) are taken as additional variables. 
    280             If va is a single letter followed by (, say va="x(", the new 
     277         -- The new vars are derived from va. If va is a single letter, say
     278            va="T", and if n<=26 then T and the following n-1 letters from
     279            T..Z..T (resp. T(1..n) if n>26) are taken as additional variables.
     280            If va is a single letter followed by (, say va="x(", the new
    281281            variables are x(1),...,x(n)
    282282         -- The ordering is the product ordering between the ordering of r and
    283283            an ordering derived from `o` [and iv]
    284          -  If o contains a 'c' or a 'C' in front resp. at the end this is 
     284         -  If o contains a 'c' or a 'C' in front resp. at the end this is
    285285            taken for the whole ordering in front resp. at the end. If o does
    286286            not contain a 'c' or a 'C' the same rule applies to ordstr(r).
    287287         -  If no intvec iv is given, or if iv=0, o may be any allowed ordstr,
    288288            like "ds" or "dp(2),wp(1,2,3),Ds(2)" or "ds(a),dp(b),ls" if a and b
    289             are globally (!) defined integers and if a+b+1<=n 
    290             If, however, a and b are local to a proc calling extendring, the 
    291             intvec iv must be used to let extendring know the values of a and b 
     289            are globally (!) defined integers and if a+b+1<=n
     290            If, however, a and b are local to a proc calling extendring, the
     291            intvec iv must be used to let extendring know the values of a and b
    292292         -  If an intvec iv !=0 is given, iv[1],iv[2],... is taken for the 1st,
    293             2nd,... block of o, if o contains no substring "w" or "W" i.e. no 
    294             weighted ordering (in the above case o="ds,dp,ls" and iv=a,b). 
    295             If o contains a weighted ordering (only one (!) weighted block is 
    296             allowed) iv[1] is taken as size for the weight-vector, the next 
     293            2nd,... block of o, if o contains no substring "w" or "W" i.e. no
     294            weighted ordering (in the above case o="ds,dp,ls" and iv=a,b).
     295            If o contains a weighted ordering (only one (!) weighted block is
     296            allowed) iv[1] is taken as size for the weight-vector, the next
    297297            iv[1] values of iv are taken as weights and the remaining values of
    298             iv as block-size for the remaining non-weighted blocks. 
    299             e.g. o="dp,ws,Dp,ds", iv=3,2,3,4,2,5 creates the ordering 
     298            iv as block-size for the remaining non-weighted blocks.
     299            e.g. o="dp,ws,Dp,ds", iv=3,2,3,4,2,5 creates the ordering
    300300            dp(2),ws(2,3,4),Dp(5),ds
    301301RETURN:  No return value
    302302NOTE:    This proc is useful for adding deformation parameters.
    303          This proc uses 'execute' or calls a procedure using 'execute'. 
    304          If you use it in your own proc, let the local names of your proc 
     303         This proc uses 'execute' or calls a procedure using 'execute'.
     304         If you use it in your own proc, let the local names of your proc
    305305         start with @ (see the file HelpForProc)
    306306EXAMPLE: example extendring; shows an example
    307307{
    308308//--------------- initialization and place c/C of ordering properly -----------
    309    string @o1,@o2,@ro,@wstr,@v,@newring; 
     309   string @o1,@o2,@ro,@wstr,@v,@newring;
    310310   int @i,@w,@ii,@k;
    311311   intvec @iv,@iw;
    … …  
    331331   }
    332332   @ro=ordstr(@r);
    333    if( @ro[1]=="c" or @ro[1]=="C" ) 
     333   if( @ro[1]=="c" or @ro[1]=="C" )
    334334      { @v=@ro[1,2]; @ro=@ro[3..size(@ro)]; }
    335    else                         
     335   else
    336336      { @wstr=@ro[size(@ro)-1,2]; @ro=@ro[1..size(@ro)-2]; }
    337337   if( @k==0) { @o1=@v; @o2=@wstr; }
    … …  
    341341      @k=n;                               //@k counts no of vars not yet ordered
    342342      @w=find(o,"w")+find(o,"W");o=o+" ";
    343       if( @w!=0 ) 
    344       { 
    345          @wstr=o[@w..@w+1]; 
     343      if( @w!=0 )
     344      {
     345         @wstr=o[@w..@w+1];
    346346         o=o[1,@w-1]+"@"+o[@w+2,size(o)];
    347347         @iw=@iv[2..@iv[1]+1];
    348348         @wstr=@wstr+"("+string(@iw)+")";
    349          @k=@k-@iv[1];                     
     349         @k=@k-@iv[1];
    350350         @iv=@iv[@iv[1]+2..size(@iv)];
    351351         @w=0;
    352352      }
    353       for( @ii=1; @ii<=size(@iv); @ii++ )
     353      for( @ii=1; @ii<=size(@iv); @ii=@ii+1 )
    354354      {
    355355         if( find(o,",",@w+1)!=0 )
    … …  
    357357            @w=find(o,",",@w+1);
    358358            if( o[@w-1]!="@" )
    359             { 
    360                o=o[1,@w-1]+"("+string(@iv[@ii])+")"+o[@w,size(o)]; 
     359            {
     360               o=o[1,@w-1]+"("+string(@iv[@ii])+")"+o[@w,size(o)];
    361361               @w=find(o,",",@w+1);
    362362               @k=@k-@iv[@ii];
    … …  
    373373   if( n>26 or va[2]=="(" ) { @v = va[1]+"(1.."+string(n)+")"; }
    374374   else                     { @v = A_Z(va,n); }
    375    if( @i==0 ) 
    376    { 
    377       @v=@v+","+varstr(@r); 
    378       o=@o1+o+","+@ro+@o2; 
    379    }
    380    else 
    381    { 
    382       @v=varstr(@r)+","+@v; 
    383       o=@o1+@ro+","+o+@o2; 
     375   if( @i==0 )
     376   {
     377      @v=@v+","+varstr(@r);
     378      o=@o1+o+","+@ro+@o2;
     379   }
     380   else
     381   {
     382      @v=varstr(@r)+","+@v;
     383      o=@o1+@ro+","+o+@o2;
    384384   }
    385385   @newring=@newring+@v+"),("+o+");";
    … …  
    394394{ "EXAMPLE:"; echo = 2;
    395395   ring r=0,(x,y,z),ds;
    396    show(r);"";       
     396   show(r);"";
    397397   //no intvec given, no blocksize given: blocksize is derived from no of vars
    398    int t=5; 
     398   int t=5;
    399399   extendring("R1",t,"a","dp");         //t global: "dp" -> "dp(5)"
    400400   show(R1); "";
    … …  
    411411   //the remaining variables, if intvec has too many components, the last
    412412   //ones are ignored
    413    intvec v=3,2,3,4,1,3;           
    414    extendring("R4",10,"A","ds,ws,Dp,dp",v,0,r); 
    415          //v covers 3 blocks: v[1] (=3) : no of components of ws   
     413   intvec v=3,2,3,4,1,3;
     414   extendring("R4",10,"A","ds,ws,Dp,dp",v,0,r);
     415         //v covers 3 blocks: v[1] (=3) : no of components of ws
    416416         //next v[1] values (=v[2..4]) give weights
    417417         //remaining components of v are used for the remaining blocks
    … …  
    421421///////////////////////////////////////////////////////////////////////////////
    422422
    423 proc fetchall (R, list #) 
     423proc fetchall (R, list #)
    424424USAGE:   fetchall(R[,s]);  R=ring/qring, s=string
    425425CREATE:  fetch all objects of ring R (of type poly/ideal/vector/module/number/
    … …  
    427427         If no 3rd argument is present, the names are the same as in R. If,
    428428         say, f is a poly in R and the 3rd argument is the string "R", then f
    429          is maped to f_R etc. 
     429         is maped to f_R etc.
    430430RETURN:  no return value
    431431NOTE:    As fetch, this procedure maps the 1st, 2nd, ... variable of R to the
    432          1st, 2nd, ... variable of the basering. 
     432         1st, 2nd, ... variable of the basering.
    433433         The 3rd argument is useful in order to avoid conflicts of names, the
    434434         empty string is allowed
    435435CAUTION: fetchall does not work inside a procedure
    436          //***at the moment it does not work if R contains a map 
     436         //***at the moment it does not work if R contains a map
    437437EXAMPLE: example fetchall; shows an example
    438 { 
     438{
    439439   list @L@=names(R);
    440440   int @ii@; string @s@;
    441441   if( size(#) > 0 ) { @s@=@s@+"_"+#[1]; }
    442    for( @ii@=size(@L@); @ii@>0; @ii@-- )
    443    { 
     442   for( @ii@=size(@L@); @ii@>0; @ii@=@ii@-1 )
     443   {
    444444      execute("def "+@L@[@ii@]+@s@+"=fetch(R,`@L@[@ii@]`);");
    445445      execute("export "+@L@[@ii@]+@s@+";");
    … …  
    465465///////////////////////////////////////////////////////////////////////////////
    466466
    467 proc imapall (R, list #) 
     467proc imapall (R, list #)
    468468USAGE:   imapall(R[,s]);  R=ring/qring, s=string
    469469CREATE:  map all objects of ring R (of type poly/ideal/vector/module/number/
    … …  
    471471         If no 3rd argument is present, the names are the same as in R. If,
    472472         say, f is a poly in R and the 3rd argument is the string "R", then f
    473          is maped to f_R etc. 
     473         is maped to f_R etc.
    474474RETURN:  no return value
    475475NOTE:    As imap, this procedure maps the variables of R to the variables with
    … …  
    478478         empty string is allowed
    479479CAUTION: imapall does not work inside a procedure
    480          //***at the moment it does not work if R contains a map 
     480         //***at the moment it does not work if R contains a map
    481481EXAMPLE: example imapall; shows an example
    482 { 
     482{
    483483   list @L@=names(R);
    484484   int @ii@; string @s@;
    485485   if( size(#) > 0 ) { @s@=@s@+"_"+#[1]; }
    486    for( @ii@=size(@L@); @ii@>0; @ii@-- )
    487    { 
     486   for( @ii@=size(@L@); @ii@>0; @ii@=@ii@-1 )
     487   {
    488488         execute("def "+@L@[@ii@]+@s@+"=imap(R,`@L@[@ii@]`);");
    489489         execute("export "+@L@[@ii@]+@s@+";");
    … …  
    509509///////////////////////////////////////////////////////////////////////////////
    510510
    511 proc mapall (R, ideal i, list #) 
     511proc mapall (R, ideal i, list #)
    512512USAGE:   mapall(R,i[,s]);  R=ring/qring, i=ideal of basering, s=string
    513 CREATE:  map all objects of ring R (of type poly/ideal/vector/module/number/ 
     513CREATE:  map all objects of ring R (of type poly/ideal/vector/module/number/
    514514         matrix, map) into the basering, by mapping the jth variable of R to
    515515         the jth generator of the ideal i. If no 3rd argument is present, the
    516          names are the same as in R. If, say, f is a poly in R and the 3rd 
    517          argument is the string "R", then f is maped to f_R etc. 
     516         names are the same as in R. If, say, f is a poly in R and the 3rd
     517         argument is the string "R", then f is maped to f_R etc.
    518518RETURN:  no return value
    519519NOTE:    This procedure has the same effect as defining a map, say psi, by
    520520         map psi=R,i; and then applying psi to all objects of R. In particular,
    521521         maps from R to some ring S are composed with psi, creating thus a map
    522          from the basering to S. 
     522         from the basering to S.
    523523         mapall may be combined with copyring to change vars for all objects.
    524524         The 3rd argument is useful in order to avoid conflicts of names, the
    525525         empty string is allowed
    526 CAUTION: mapall does not work inside a procedure 
     526CAUTION: mapall does not work inside a procedure
    527527EXAMPLE: example mapall; shows an example
    528 { 
     528{
    529529   list @L@=names(R); map @psi@ = R,i;
    530530   int @ii@; string @s@;
    531531   if( size(#) > 0 ) { @s@=@s@+"_"+#[1]; }
    532    for( @ii@=size(@L@); @ii@>0; @ii@-- )
    533    { 
     532   for( @ii@=size(@L@); @ii@>0; @ii@=@ii@-1 )
     533   {
    534534      execute("def "+@L@[@ii@]+@s@+"=@psi@(`@L@[@ii@]`);");
    535535      execute("export "+@L@[@ii@]+@s@+";");
    … …  
    544544"   ideal j=x,y,z;";
    545545"   matrix M[2][3]=1,2,3,x,y,z;";
    546 "   map phi=R,x2,y2,z2; "; 
     546"   map phi=R,x2,y2,z2; ";
    547547"   ring S=0,(a,b,c),ds;";
    548548"   ideal i=c,a,b;";
    … …  
    565565USAGE:   ringtensor(s,r1,r2,...); s=string, r1,r2,...=rings
    566566CREATE:  A new base ring with name `s` if r1,r2,... are existing rings.
    567          If, say, s = "R" and the rings r1,r2,... exist, the new ring will 
    568          have name R, variables from all rings r1,r2,... and as monomial 
     567         If, say, s = "R" and the rings r1,r2,... exist, the new ring will
     568         have name R, variables from all rings r1,r2,... and as monomial
    569569         ordering the block (product) ordering of r1,r2,... . Hence, R
    570570         is the tensor product of the rings r1,r2,... with ordering matrix
    … …  
    576576         variable with name x in r1, there is no access to x in r2).
    577577         The procedure works also for quotient rings ri, if the characteristic
    578          of ri is compatible with the characteristic of r1 (i.e. if imap from 
     578         of ri is compatible with the characteristic of r1 (i.e. if imap from
    579579         ri to r1 is implemented)
    580          This proc uses 'execute' or calls a procedure using 'execute'. 
    581          If you use it in your own proc, let the local names of your proc 
     580         This proc uses 'execute' or calls a procedure using 'execute'.
     581         If you use it in your own proc, let the local names of your proc
    582582         start with @ (see the file HelpForProc)
    583583EXAMPLE: example ringtensor; shows an example
    … …  
    587587   string @vars,@order,@oi,@s1;
    588588//---- gather variables, orderings and ideals (of qrings) from given rings ----
    589    for(@ii=1; @ii<=@n; @ii++)
    590    {
    591       if( ordstr(#[@ii])[1]=="C" or ordstr(#[@ii])[1]=="c" ) 
     589   for(@ii=1; @ii<=@n; @ii=@ii+1)
     590   {
     591      if( ordstr(#[@ii])[1]=="C" or ordstr(#[@ii])[1]=="c" )
    592592           { @oi=ordstr(#[@ii])[3,size(ordstr(#[@ii]))-2]; }
    593593      else { @oi=ordstr(#[@ii])[1,size(ordstr(#[@ii]))-2]; }
    … …  
    596596      def @r(@ii)=#[@ii];
    597597      setring @r(@ii);
    598       ideal i(@ii)=ideal(@r(@ii)); 
     598      ideal i(@ii)=ideal(@r(@ii));
    599599      int @q(@ii)=size(i(@ii));
    600600      @q=@q+@q(@ii);
    … …  
    610610   {
    611611      ideal i;
    612       for(@ii=1; @ii<=@n; @ii++)
     612      for(@ii=1; @ii<=@n; @ii=@ii+1)
    613613      {
    614614         if( @q(@ii)!=0 )
    … …  
    618618      }
    619619      i=std(i);
    620       execute("qring "+s+"=i;");   
     620      execute("qring "+s+"=i;");
    621621   }
    622622//----------------------- export and keep created ring ------------------------
    … …  
    626626   return();
    627627}
    628 example 
     628example
    629629{ "EXAMPLE:"; echo = 2;
    630630   ring r=32003,(x,y,u,v),dp;
    631631   ring s=0,(a,b,c),wp(1,2,3);
    632632   ring t=0,x(1..5),(c,ls);
    633    ringtensor("R",r,s,t);   
     633   ringtensor("R",r,s,t);
    634634   type R;"";
    635635   setring s;
    … …  
    639639   changevar("T","d,e,f,g,h",t); //set T (change vars of t to d..h) the basering
    640640   qring qT=std(d2+e2-f3);       //create qring of T mod d2+e2-f3
    641    ringtensor("Q",s,qS,t,qT);     
     641   ringtensor("Q",s,qS,t,qT);
    642642   type Q;
    643643   kill R,Q,S,T;
Note: See TracChangeset for help on using the changeset viewer.