When you want to refer to a variable that is not local to your function, use a ``free'' declaration. free Variables declared to be free free variable are assumed to be defined globally variable:free in the variable:global workspace. global variable
This is a global workspace variable.
This function refers to the global .
The global is incremented by .
Usually Axiom can tell that you mean to refer to a global variable and so free isn't always necessary. However, for clarity and the sake of self-documentation, we encourage you to use it.
Declare a variable to be ``local'' when you do not want to refer to variable:local a global variable by the same name. local variable
This function uses as a local variable.
Apply the function.
Check that the global value of is unchanged.
Parameters to a function are local variables in the function. Even if you issue a free declaration for a parameter, it is still local.
What happens if you do not declare that a variable in the body of your function is local or free? Well, Axiom decides on this basis:
Set two global variables to 1.
Refer to before it is assigned a value, but assign a value to before it is referenced.
Can you predict this result?
How about this one?
What happened? In the first line of the function body for , is referenced on the right-hand side of the assignment. Thus is a free variable. The variable is not referenced in that line, but it is assigned a value. Thus is a local variable and is given the value . In the second line, the free variable is assigned the value which equals This is the value returned by the function. Since was free in h, the global variable has value Since was local in h, the global variable is unchanged---it still has the value .
It is good programming practice always to declare global variables. However, by far the most common situation is to have local variables in your functions. No declaration is needed for this situation, but be sure to initialize their values.
Be careful if you use free variables and you cache the value of your function (see ugUserCache ). Caching only checks if the values of the function arguments are the same as in a function call previously seen. It does not check if any of the free variables on which the function depends have changed between function calls.
Turn on caching for p.
Define p to depend on the free variable .
Set the value of .
Evaluate p the first time.
Change the value of .
Evaluate p the second time.
If caching had been turned off, the second evaluation would have reflected the changed value of .
Turn off caching for p.
Axiom does not allow fluid variables, that is, variables variable:fluid bound by a function that can be referenced by functions called by . fluid variable
Values are passed to functions by reference: a pointer to the value is passed rather than a copy of the value or a pointer to a copy.
This is a global variable that is bound to a record object.
This function first modifies the one component of its record argument and then rebinds the parameter to another record.
Pass as an argument to resetRecord.
The value of was changed by the expression but not by .
To conclude this section, we give an iterative definition of Fibonacci numbers a function that computes Fibonacci numbers. This definition approximates the definition into which Axiom transforms the recurrence relation definition of fib in ugUserRecur .
Global variables past and present are used to hold the last computed Fibonacci numbers.
Global variable gives the current index of .
Here is a recurrence relation defined in terms of these three global variables.
Compute the infinite stream of Fibonacci numbers.
What is the 1000th Fibonacci number?
As an exercise, we suggest you write a function in an iterative style that computes the value of the recurrence relation having the initial values . How would you write the function using an element OneDimensionalArray or Vector to hold the previously computed values?