# Blocks and Local Values

Modules in *Mathematica* allow you to treat the *names* of variables as local. Sometimes, however, you want the names to be global, but *values* to be local. You can do this in *Mathematica* using Block.

Block[{x,y,...},body] | evaluate body using local values for |

Block[{x=x_{0},y=y_{0},...},body] | assign initial values to |

In[1]:= |

Out[1]= |

In[2]:= |

Out[2]= |

In[3]:= |

Out[3]= |

As described in "Modules and Local Variables", the variable x in a module such as Module[{x}, body] is always set up to refer to a unique symbol, different each time the module is used, and distinct from the global symbol x. The x in a block such as Block[{x}, body] is, however, taken to be the global symbol x. What the block does is to make the *value* of x local. The value x had when you entered the block is always restored when you exit the block. And during the execution of the block, x can take on any value.

In[4]:= |

Out[4]= |

In[7]:= |

Out[7]= |

In[8]:= |

Out[8]= |

Blocks in *Mathematica* effectively allow you to set up "environments" in which you can temporarily change the values of variables. Expressions you evaluate at any point during the execution of a block will use the values currently defined for variables in the block. This is true whether the expressions appear directly as part of the body of the block, or are produced at any point in its evaluation.

In[9]:= |

In[10]:= |

Out[10]= |

In[11]:= |

Out[11]= |

An important implicit use of Block in *Mathematica* is for iteration constructs such as Do, Sum, and Table. *Mathematica* effectively uses Block to set up local values for the iteration variables in all of these constructs.

In[12]:= |

Out[12]= |

In[13]:= |

Out[13]= |

When you set up functions in *Mathematica*, it is sometimes convenient to have "global variables" that can affect the functions without being given explicitly as arguments. Thus, for example, *Mathematica* itself has a global variable $RecursionLimit that affects the evaluation of all functions, but is never explicitly given as an argument.

*Mathematica* will usually keep any value you define for a global variable until you explicitly change it. Often, however, you want to set up values that last only for the duration of a particular computation, or part of a computation. You can do this by making the values local to a *Mathematica* block.

In[14]:= |

In[15]:= |

Out[15]= |

In[16]:= |

Out[16]= |

You can use global variables not only to set parameters in functions, but also to accumulate results from functions. By setting up such variables to be local to a block, you can arrange to accumulate results only from functions called during the execution of the block.

In[17]:= |

In[18]:= |

Out[18]= |

In[19]:= |

Out[19]= |

In[20]:= |

Out[20]= |

When you enter a block such as Block[{x}, body], any value for x is removed. This means that you can in principle treat x as a "symbolic variable" inside the block. However, if you explicitly return x from the block, it will be replaced by its value outside the block as soon as it is evaluated.

In[22]:= |

Out[22]= |