By now the reader should be able to construct simple one-line expressions involving variables and different data structures. This section builds on this knowledge and shows how to use iteration, make choices, and build functions in Axiom. At the moment it is assumed that the reader has a rough idea of how types are specified and constructed so that they can follow the examples given.
From this point on most examples will be taken from input files.
Input files contain code that will be fed to the command prompt. The primary difference between the command line and an input file is that indentation matters. In an input file you can specify ``piles'' of code by using indentation.
The names of all input files in Axiom should end in ``.input'' otherwise Axiom will refuse to read them.
If an input file is named foo.input you can feed the contents of the file to the command prompt (as though you typed them) by writing: )read foo.input.
It is good practice to start each input file with the )clear all command so that all functions and variables in the current environment are erased.
The Axiom constructs that provide looping, choices, and user-defined functions all rely on the notion of blocks. A block is a sequence of expressions which are evaluated in the order that they appear except when it is modified by control expressions such as loops. To leave a block prematurely use an expression of the form: BoolExpr=>Expr where BoolExpr is any Axiom expression that has type Boolean. The value and type of Expr determines the value and type returned by the block.
If blocks are entered at the keyboard (as opposed to reading them from a text file) then there is only one way of creating them. The syntax is:
In an input file a block can be constructed as above or by placing all the statements at the same indentation level. When indentation is used to indicate program structure the block is called a pile. As an example of a simple block a list of three integers can be constructed using parentheses:
Doing the same thing using piles in an input file you could type:
Since blocks have a type and a value they can be used as arguments to functions or as part of other expressions. It should be pointed out that the following example is not recommended practice but helps to illustrate the idea of blocks and their ability to return values:
Note that indentation is extremely important. If the example above had the pile starting at ``a:='' moved left by two spaces so that the ``a'' was under the ``('' of the first line then the interpreter would signal an error. Furthermore if the closing parenthesis ``)'' is moved up to give
then the parser will generate errors. If the parenthesis is shifted right by several spaces so that it is in line with the ``c'' thus:
a similar error will be raised. Finally, the ``)'' must be indented by at least one space relative to the sqrt thus:
or an error will be generated.
It can be seen that great care needs to be taken when constructing input files consisting of piles of expressions. It would seem prudent to add one pile at a time and check if it is acceptable before adding more, particularly if piles are nested. However, it should be pointed out that the use of piles as values for functions is not very readable and so perhaps the delicate nature of their interpretation should deter programmers from using them in these situations. Using piles should really be restricted to constructing functions, etc. and a small amount of rewriting can remove the need to use them as arguments. For example, the previous block could easily be implemented as:
which achieves the same result and is easier to understand. Note that this is still a pile but it is not as fragile as the previous version.
Definitions of functions in Axiom are quite simple providing two things are observed. First, the type of the function must either be completely specified or completely unspecified. Second, the body of the function is assigned to the function identifier using the delayed assignment operator ``==''.
To specify the type of something the ``:'' operator is used. Thus to define a variable x to be of type Fraction Integer we enter:
For functions the method is the same except that the arguments are placed in parentheses and the return type is placed after the symbol ``->''. Some examples of function definitions taking zero, one, two, or three arguments and returning a list of integers are:
Now the actual function definitions might be:
with some invocations of these functions:
The value returned by a function is either the value of the last expression evaluated or the result of a return statement. For example, the following are effectively the same:
Note that a block (pile) is assigned to the function identifier p and thus all the rules about blocks apply to function definitions. Also there was only one argument so the parenthese are not needed.
This is basically all that one needs to know about defining functions in Axiom -- first specify the complete type and then assign a block to the function name. The rest of this section is concerned with defining more complex blocks than those in this section and as a result function definitions will crop up continually particularly since they are a good way of testing examples. Since the block structure is more complex we will use the pile notation and thus have to use input files to read the piles.
Apart from the ``=>'' operator that allows a block to exit before the end Axiom provides the standard if-then-else construct. The general syntax is:
if BooleanExpr then Expr1 else Expr2
where ``else Expr2'' can be omitted. If the expression BooleanExpr evaluates to true then Expr1 is executed otherwise Expr2 (if present) will be executed. An example of piles and if-then-else is: (read from an input file)
Note the indentation -- the ``else'' must be indented relative to the ``if'' otherwise it will generate an error (Axiom will think there are two piles, the second one beginning with ``else'').
Any expression that has type Boolean can be used as BooleanExpr and the most common will be those involving the relational operators `` '', `` '', and ``=''. Usually the type of an expression involving the equality operator ``='' will be Boolean but in those situations when it isn't you may need to use the ``@'' operator to ensure that it is.
Loops in Axiom are regarded as expressions containing another expression called the loop body. The loop body is executed zero or more times depending on the kind of loop. Loops can be nested to any depth.
The simplest kind of loop provided by Axiom is the repeat loop. The general syntax of this is:
This will cause Axiom to execute loopBody repeatedly until either a break or return statement is encountered. If loopBody contains neither of these statements then it will loop forever. The following piece of code will display the numbers from to :
It was mentioned that loops will only be left when either a break or return statement is encountered so why can't one use the ``=>'' operator? The reason is that the ``=>'' operator tells Axiom to leave the current block whereas break leaves the current loop. The return statement leave the current function.
To skip the rest of a loop body and continue the next iteration of the loop use the iterate statement (the -- starts a comment in Axiom)
The while statement extends the basic repeat loop to place the control of leaving the loop at the start rather than have it buried in the middle. Since the body of the loop is still part of a repeat loop, break and ``=>'' work in the same way as in the previous section. The general syntax of a while loop is:
while BoolExpr repeat loopBody
As before, BoolExpr must be an expression of type Boolean. Before the body of the loop is executed BoolExpr is tested. If it evaluates to true then the loop body is entered otherwise the loop is terminated. Multiple conditions can be applied using the logical operators such as and or by using several while statements before the repeat.
We could use two parallel whiles
Note that the last example using two while statements is not a nested loop but the following one is:
Suppose we that, given a matrix of arbitrary size, find the position and value of the first negative element by examining the matrix in row-major order:
The last loop statement of interest is the for loop. There are two ways of creating a for loop. The first way uses either a list or a segment:
for var in seg repeat loopBody
for var in list repeat loopBody
where var is an index variable which is iterated over the values in seg or list. The value seg is a segment such as or and list is a list of some type. For example:
The second form of the for loop syntax includes a `` such that'' clause which must be of type Boolean:
for
var in
seg |
BoolExpr repeat
loopBody
for
var in
list |
BoolExpr repeat
loopBody
Some examples are:
You can also use a while clause:
Using the `` such that'' clause makes this appear simpler:
You can use multiple for clauses to iterate over several sequences in parallel:
As a general point it should be noted that any symbols referred to in the `` such that'' and while clauses must be pre-defined. This either means that the symbols must have been defined in an outer level (e.g. in an enclosing loop) or in a for clause appearing before the `` such that'' or while. For example:
Finally, the for statement has a by clause to specify the step size. This makes it possible to iterate over the segment in reverse order:
Note that without the ``by -1'' the segment 8..5 is empty so there is nothing to iterate over and the loop exits immediately.