How to | Create and Use Rules

Transformation rules in

*Mathematica* let you set local values for symbols, functions, and all other types of expressions. Using rules provides a powerful and extensible method to replace all or part of another expression with the value you specify.

The short form for a rule uses a right arrow, which you get by typing

(with no space between - and >). The

*Mathematica* front end automatically converts

into

upon further typing. Either symbol is a short form for

Rule.

Create the following transformation rule, which can be thought of as "

goes to

":

Out[1]= | |

By looking at the output for

, you can see that this rule does not do anything: the output is simply the rule itself. This is because rules do not do anything when they are alone. You must use a rule with an expression for it to be of any use.

Rules can be applied to expressions by using

(the short form for

ReplaceAll). The general syntax for this is

.

Use

to use a rule with an expression:

Out[57]= | |

To use two or more rules with an expression, place them in a list

:

Out[58]= | |

If you give two rules for the same variable,

*Mathematica* will use only the first rule:

Out[59]= | |

You can replace variables with any expression, not just individual values.

Substitute

for

:

Out[60]= | |

You can also use a rule to replace larger parts of an expression:

Out[62]= | |

In fact, you can use rules with any expression, including functions.

Substitute

for

:

Out[65]= | |

Use a rule for

. Note that this rule matches

exactly and does not affect

:

Out[64]= | |

To replace the function

regardless of its argument, you must use a pattern in the rule.

The rule

can be read as "

goes to

":

Out[18]= | |

For more information on using patterns, see

"Introduction to Patterns."
Rules that are set up using

are immediate rules. That is, the right-hand side is evaluated at the same time as the rule:

Out[1]= | |

You may need to use delayed rules instead, which are not evaluated until they are used with an expression. Delayed rules are created by using

RuleDelayed.

The short form for a delayed rule is

(with no space between : and >). The

*Mathematica* front end automatically converts

into

upon typing. Either represents the short form for

RuleDelayed:

Out[2]= | |

Consider a problem where you want to use a rule to generate three random real numbers in the range of 0 to 1. Using an immediate rule results in the generation of the same three numbers:

Out[3]= | |

To generate three different numbers, use a delayed rule:

Out[4]= | |

Assignments set explicitly using

have a global effect, while rules only affect the expression with which they are used.

Use

to assign

to

, and then evaluate

to see the value:

Out[2]= | |

Use a rule to assign a value for

:

Evaluating

, you can see that the value assigned by the rule was not saved:

Out[4]= | |

You must use a rule with an expression for it to work. However, you can explicitly assign a rule to a symbol and then use that symbol as you would the rule.

Use

to assign the rule

to

, and then use

with an expression:

Out[69]= | |

Since

is now stored globally as the symbol

, you can continue to use

in place of

.

Similarly, you can explicitly assign an expression to a symbol and then use a rule on the symbol:

Out[6]= | |

This is especially convenient if you plan to use the expression in more than one computation.