Modules and Local Variables
Mathematica normally assumes that all your variables are
global. This means that every time you use a name like
,
Mathematica normally assumes that you are referring to the
same object.
Particularly when you write programs, however, you may not want all your variables to be global. You may, for example, want to use the name
to refer to two quite different variables in two different programs. In this case, you need the
in each program to be treated as a
local variable.
You can set up local variables in
Mathematica using
modules. Within each module, you can give a list of variables which are to be treated as local to the module.
| Module[{x,y,...},body] | a module with local variables x, y, ... |
Creating modules in Mathematica.
This defines the global variable
to have value 17.
| Out[1]= |  |
The
inside the module is local, so it can be treated independently of the global
.
The global
still has value 17.
| Out[3]= |  |
The most common way that modules are used is to set up temporary or intermediate variables inside functions you define. It is important to make sure that such variables are kept local. If they are not, then you will run into trouble whenever their names happen to coincide with the names of other variables.
The intermediate variable
is specified to be local to the module.
This runs the function
.
| Out[5]= |  |
The global
still has value 17.
| Out[6]= |  |
You can treat local variables in modules just like other symbols. Thus, for example, you can use them as names for local functions, you can assign attributes to them, and so on.
This sets up a module which defines a local function
.
In this case, the local function
is just an ordinary factorial.
| Out[8]= |  |
In this case,
is set up as a generalized factorial.
| Out[9]= |  |
When you set up a local variable in a module,
Mathematica initially assigns no value to the variable. This means that you can use the variable in a purely symbolic way, even if there was a global value defined for the variable outside the module.
This uses the global value of
defined above, and so yields a number.
| Out[10]= |  |
Here
Length simply receives a number as its argument.
| Out[11]= |  |
The local variable
has no value, so it acts as a symbol, and
Expand produces the anticipated algebraic result.
| Out[12]= |  |
| Module[{x=x0,y=y0,...},body] | a module with initial values for local variables |
Assigning initial values to local variables.
This specifies
to be a local variable, with initial value
.
This uses the definition of
.
| Out[14]= |  |
You can define initial values for any of the local variables in a module. The initial values are always evaluated before the module is executed. As a result, even if a variable
is defined as local to the module, the global
will be used if it appears in an expression for an initial value.
The initial value of
is taken to be the global value of
.
| Out[15]= |  |
| lhs:=Module[vars,rhs/;cond] | share local variables between rhs and cond |
Using local variables in definitions with conditions.
When you set up
conditions for definitions, you often need to introduce temporary variables. In many cases, you may want to share these temporary variables with the body of the right-hand side of the definition.
Mathematica allows you to enclose the whole right-hand side of your definition in a module, including the condition.
This defines a function with a condition attached.
Mathematica shares the value of the local variable
between the condition and the body of the right-hand side.
| Out[17]= |  |
