SIMSCRIPT II.5 Programming Language

SIMSCRIPT II.5 Programming Language
Factorial(n) = n * (n-1) * (n-2) * ... * (2) * (1)
This recursive function routine may be used to compute the factorial of its given argument:
routine FACTORIAL(N)
if N eq 1
return with 1
otherwise
return with N * FACTORIAL(N-1)
end
The routine calls on itself repeatedly until it has reduced its argument to 1. If this function were
called with N = 4, the factorial would be evaluated in the following steps:
FACTORIAL(4) = 4 * FACTORIAL(3)
= 4 * ( 3 * FACTORIAL(2) )
= 4 * ( 3 * ( 2 * FACTORIAL(1) ) )
= 4 * ( 3 * ( 2 * ( 1 ) ) )
= 24
This may not be an efficient way to compute a factorial, but it does illustrate the concept of a recursive
call.
An important consequence of recursion is that local variables are unique to each routine call. Each
call has a separate "memory" that shares nothing with previous calls except their common routine
structure. Recall that local variables are reinitialized at every entry to a routine. Global variables
are defined across all levels of recursion, as their names represent the same values at all points in a
program. Using global variables and passing values in argument lists are two ways that separate
invocations of a recursive routine can communicate across different levels of recursion.
Program efficiency and inter-routine communication are two reasons why it might be desired to
have some routines behave nonrecursively. The mechanism for isolating variables and making
them local, not just to a routine but to each call of a routine, involves some computational overhead.
Isolating local variables of routines between routine calls also makes it impossible for a routine to
transmit information from one call to another through a local variable, or to "remember" values
across successive calls. In recursive routines, this can only be accomplished by using global variables
or explicitly passing values as arguments.
All the local variables of a program, or selected local variables in individual routines, can be defined
as saved or recursive. If a variable is saved, it is stored in a memory location associated with
a routine it is local to, but accessible by all references to it from any invocation of this routine. Unlike
a recursive variable, a saved variable is not released when control returns to a calling program,
and is not reinitialized at each new call, but retains any value assigned to it when the routine
was last executed. Saved variables are initialized to zero before their first use.
76