Example IO_fprintf (H3E6)

> p := 1000000000000000000000000000057;
> F := POpen("sort -n", "w");
> for i := 100 to 110 do
>    fprintf F, "%30o (2^%o mod p)\n", 2^i mod p, i;
> end for;
> // Close F and then see output on standard output:
> delete F;
 37107316853453566312041115519 (2^109 mod p)
 70602400912917605986812821219 (2^102 mod p)
 74214633706907132624082231038 (2^110 mod p)
129638414606681695789005139447 (2^106 mod p)
141204801825835211973625642438 (2^103 mod p)
259276829213363391578010278894 (2^107 mod p)
267650600228229401496703205319 (2^100 mod p)
282409603651670423947251284876 (2^104 mod p)
518553658426726783156020557788 (2^108 mod p)
535301200456458802993406410638 (2^101 mod p)
564819207303340847894502569752 (2^105 mod p)

Verbose Printing

The following statements allow convenient printing of information conditioned by whether an appropriate verbose flag is turned on.

vprint flag: expression, ..., expression;

vprint flag, n: expression, ..., expression;

If the verbose flag flag (see the function SetVerbose) has a level greater than or equal to n, print the expressions to the right of the colon exactly as in the print statement. If the flag has level 0 (i.e. is not turned on), do nothing. In the first form of this statement, where a specific level is not given, n is taken to be 1. This statement is useful in Magma code found in packages where one wants to print verbose information if an appropriate verbose flag is turned on.

vprintf flag: format, expression, ..., expression;

vprintf flag, n: format, expression, ..., expression;

If the verbose flag flag (see the function SetVerbose) has a level greater than or equal to n, print using the format and the expressions to the right of the colon exactly as in the printf statement. If the flag has level 0 (i.e. is not turned on), do nothing. In the first form of this statement, where a specific level is not given, n is taken to be 1. This statement is useful in Magma code found in packages where one wants to print verbose information if an appropriate verbose flag is turned on.

Automatic Printing

Magma allows automatic printing of expressions: basically, a statement consisting of an expression (or list of expressions) alone is taken as a shorthand for the print-statement.

Some subtleties are involved in understanding the precise behaviour of Magma in interpreting lone expressions as statements. The rules Magma follows are outlined here. In the following, a call-form means any expression of the form f((arguments)); that is, anything which could be a procedure call or a function call.

(a)

Any single expression followed by a semicolon which is not a call-form is printed, just as if you had `print' in front of it.

(b)

For a single call-form followed by a semicolon (which could be a function call or procedure call), the first signature which matches the input arguments is taken and if that is procedural, the whole call is taken as a procedure call, otherwise it is taken as function call and the results are printed.

(c)

A comma-separated list of any expressions is printed, just as if you had `print' in front of it. Here any call-form is taken as a function call only so procedure calls are impossible.

(d)

A print level modifier is allowed after an expression list (whether the list has length 1 or more). Again any call-form is taken as a function call only so procedure calls are impossible.

(e)

Any list of objects printed, whether by any of the above rules or by the `print' statement, is placed in the previous value buffer. $1 gives the last printed list, $2 the one before, etc. Note that multi-return values stay as a list of values in the previous value buffer. The only way to get at the individual values of such a list is by assignment to a list of identifiers, or by where (this is of course the only way to get the second result out of Quotrem, etc.). In other places, a $1 expression is evaluated with principal value semantics.

ShowPrevious() : ->

Show all the previous values stored. This does not change the contents of the previous value buffer.

ShowPrevious(i) : RngIntElt ->

Show the i-th previous value stored. This does not change the contents of the previous value buffer.

ClearPrevious() : ->

Clear all the previous values stored. This is useful for ensuring that no more memory is used than that referred to by the current identifiers.

SetPreviousSize(n) : RngIntElt ->

Set the size of the previous value buffer (this is not how many values are defined in it at the moment, but the maximum number that will be stored). The default size is 3.

GetPreviousSize() : -> RngIntElt

Return the size of the previous value buffer.

> 1;
1
> x := 3;
> x;
3

> 1 + 1;            // really function call '+'(1, 1)
2
> Q := [ 0 ];
> Append(~Q, 1);    // first (in fact only) match is procedure call
> Append(Q, 1);     // first (in fact only) match is function call
[ 0, 1, 1 ]
> // Assuming fp is assigned to a procedure or function:
> fp(x);            // whichever fp is at runtime
> SetVerbose("Meataxe", true);  // simple procedure call

> 1, 2;
1 2
> // Assuming f assigned:
> f(x), 1;                            // f only can be a function
> SetVerbose("Meataxe", true), 1;     // type error in 'SetVerbose'
> // (since no function form)

> 1: Magma;
1
> Sym(3), []: Maximal;
Symmetric group acting on a set of cardinality 3
Order = 6 = 2 * 3
[]
> SetVerbose("Meataxe", true): Magma; // type error as above

> 1;
1
> $1;
1
> 2, 3;
2 3
> $1;
2 3
> Quotrem(124124, 123);
1009 17
> $1;
1009 17
> a, b := $1;
> a;
1009

    Overwrite: BoolElt                  Default: false

    Overwrite: BoolElt                  Default: false

    Overwrite: BoolElt                  Default: false

    Overwrite: BoolElt                  Default: false

> Q := [Sprintf("{%4o<->%-4o}", x, x): x in [1,10,100,1000]];
> Q;
[ {   1<->1   }, {  10<->10  }, { 100<->100 }, {1000<->1000} ]

    Overwrite: BoolElt                  Default: false