]>
Book Contents Previous Section 0.4 Using Axiom as a Symbolic Calculator Next Section 0.6 Data Structures in Axiom Book Index

## 0.5 General Points about Axiom

### 0.5.1 Computation Without Output

It is sometimes desirable to enter an expression and prevent Axiom from displaying the result. To do this the expression should be terminated with a semicolon ``;''. In a previous section it was mentioned that a set of expressions separated by semicolons would be evaluated and the result of the last one displayed. Thus if a single expression is followed by a semicolon no output will be produced (except for its type):

2 + 4*5;
Type: PositiveInteger

### 0.5.2 Accessing Earlier Results

The ``%'' macro represents the result of the previous computation. The ``%%'' macro is available which takes a single integer argument. If the argument is positive then it refers to the step number of the calculation where the numbering begins from one and can be seen at the end of each prompt (the number in parentheses). If the argument is negative then it refers to previous results counting backwards from the last result. That is, ``%%(-1)'' is the same as ``%''. The value of ``%%(0)'' is not defined and will generate an error if requested.

### 0.5.3 Splitting Expressions Over Several Lines

Although Axiom will quite happily accept expressions that are longer than the width of the screen (just keep typing without pressing the Return key) it is often preferable to split the expression being entered at a point where it would result in more readable input. To do this the underscore ``_'' symbol is placed before the break point and then the Return key is pressed. The rest of the expression is typed on the next line, can be preceeded by any number of whitespace chars, for example:

2_
+_
3

5

Type: PositiveInteger

The underscore symbol is an escape character and its presence alters the meaning of the characters that follow it. As mentions above whitespace following an underscore is ignored (the Return key generates a whitespace character). Any other character following an underscore loses whatever special meaning it may have had. Thus one can create the identifier ``a+b'' by typing ``a_+b'' although this might lead to confusions. Also note the result of the following example:

ThisIsAVeryLong_ VariableName

ThisIsAVeryLongVariableName

Type: Variable ThisIsAVeryLongVariableName

### 0.5.4 Comments and Descriptions

Comments and descriptions are really only of use in files of Axiom code but can be used when the output of an interactive session is being spooled to a file (via the system command )spool). A comment begins with two dashes ``- -'' and continues until the end of the line. Multi-line comments are only possible if each individual line begins with two dashes.

Descriptions are the same as comments except that the Axiom compiler will include them in the object files produced and make them availabe to the end user for documentation purposes.

A description is placed before a calculation begins with three ``+++'' signs and a description placed after a calculation begins with two plus symbols ``+''. The so-called ``plus plus'' comments are used within the algebra files and are processed by the compiler to add to the documentation. The so-called ``minus minus'' comments are ignored everywhere.

### 0.5.5 Control of Result Types

In earlier sections the type of an expression was converted to another via the ``::'' operator. However, this is not the only method for converting between types and two other operators need to be introduced and explained.

The first operator is ``$'' and is used to specify the package to be used to calculate the result. Thus:

(2/3)$Float

0.6666666666 6666666667

Type: Float

tells Axiom to use the ``/'' operator from the Float package to evaluate the expression 2/3. This does not necessarily mean that the result will be of the same type as the domain from which the operator was taken. In the following example the sign operator is taken from the Float package but the result is of type Integer.

sign(2.3)$Float

1

Type: Integer

The other operator is ``@'' which is used to tell Axiom what the desired type of the result of the calculation is. In most situations all three operators yield the same results but the example below should help distinguish them.

(2 + 3)::String

"5"

Type: String
(2 + 3)@String
An expression involving @ String actually evaluated to one of
type PositiveInteger . Perhaps you should use :: String .
(2 + 3)$String
The function + is not implemented in String .

If an expression X is converted using one of the three operators to type T the interpretations are:

:: means explicitly convert X to type T if possible.

$ means use the available operators for type T to compute X.

@ means choose operators to compute X so that the result is of type T.

Book Contents Previous Section 0.4 Using Axiom as a Symbolic Calculator Next Section 0.6 Data Structures in Axiom Book Index