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.
In[1]:=
Click for copyable input
Out[1]=
The inside the module is local, so it can be treated independently of the global .
The global still has value 17.
In[3]:=
Click for copyable input
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.
In[4]:=
Click for copyable input
This runs the function .
In[5]:=
Click for copyable input
Out[5]=
The global still has value 17.
In[6]:=
Click for copyable input
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[7]:=
Click for copyable input
In this case, the local function is just an ordinary factorial.
In[8]:=
Click for copyable input
Out[8]=
In this case, is set up as a generalized factorial.
In[9]:=
Click for copyable input
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.
In[10]:=
Click for copyable input
Out[10]=
Here Length simply receives a number as its argument.
In[11]:=
Click for copyable input
Out[11]=
The local variable has no value, so it acts as a symbol, and Expand produces the anticipated algebraic result.
In[12]:=
Click for copyable input
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 .
In[13]:=
Click for copyable input
This uses the definition of .
In[14]:=
Click for copyable input
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 .
In[15]:=
Click for copyable input
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.
In[16]:=
Click for copyable input
Mathematica shares the value of the local variable between the condition and the body of the right-hand side.
In[17]:=
Click for copyable input
Out[17]=
New to Mathematica? Find your learning path »
Have a question? Ask support »