# 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*.

In[1]:= |

Out[1]= |

In[3]:= |

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.

In[4]:= |

In[5]:= |

Out[5]= |

In[6]:= |

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.

In[7]:= |

In[8]:= |

Out[8]= |

In[9]:= |

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.

In[10]:= |

Out[10]= |

In[11]:= |

Out[11]= |

In[12]:= |

Out[12]= |

Module[{x=x_{0},y=y_{0},...},body] | a module with initial values for local variables |

Assigning initial values to local variables.

In[13]:= |

In[14]:= |

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.

In[15]:= |

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.

In[16]:= |

*Mathematica*shares the value of the local variable between the condition and the body of the right-hand side.

In[17]:= |

Out[17]= |