 |
Patterns and Transformation Rules
Patterns
Patterns stand for classes of expressions. They contain pattern objects that represent sets of possible expressions.
| _ | any expression |
| x_ | any expression, given the name x |
| x:pattern | a pattern, given the name x |
| pattern?test | a pattern that yields True when test is applied to its value |
| _h | any expression with head h |
| x_h | any expression with head h, given the name x |
| __ | any sequence of one or more expressions |
| ___ | any sequence of zero or more expressions |
| x__ and x___ | sequences of expressions, given the name x |
| __h and ___h | sequences of expressions, each with head h |
| x__h and x___h | sequences of expressions with head h, given the name x |
| PatternSequence[p1,p2,...] | a sequence of patterns |
| x_:v | an expression with default value v |
| x_h:v | an expression with head h and default value v |
| x_. | an expression with a globally defined default value |
| Optional[x_h] | an expression that must have head h, and has a globally defined default value |
| Except[c] | any expression except one that matches c |
| Except[c,pattern] | any expression matching pattern, except one that matches c |
| pattern.. | a pattern repeated one or more times |
| pattern... | a pattern repeated zero or more times |
| Repeated[pattern, spec] | a pattern repeated according to spec |
| pattern1|pattern2|... | a pattern which matches at least one of the  |
| pattern/;cond | a pattern for which cond evaluates to True |
| HoldPattern[pattern] | a pattern not evaluated |
| Verbatim[expr] | an expression to be matched verbatim |
| OptionsPattern[] | a sequence of options |
| Longest[pattern] | the longest sequence consistent with pattern |
| Shortest[pattern] | the shortest sequence consistent with pattern |
Pattern objects.
When several pattern objects with the same name occur in a single pattern, all the objects must stand for the same expression. Thus 
can stand for 
but not 
.
In a pattern object such as 
, the head h can be any expression, but cannot itself be a pattern.
A pattern object such as 
stands for a sequence of expressions. So, for example, 
can stand for 
, with 
being Sequence[a, b, c]. If you use 
, say in the result of a transformation rule, the sequence will be spliced into the function in which 
appears. Thus 
would become 
.
When the pattern objects 
and 
appear as arguments of functions, they represent arguments which may be omitted. When the argument corresponding to 
is omitted, x is taken to have value v. When the argument corresponding to 
is omitted, x is taken to have a default value that is associated with the function in which it appears. You can specify this default value by making assignments for Default[f] and so on.
| Default[f] | default value for  when it appears as any argument of the function f |
| Default[f,n] | default value for  when it appears as the n argument (negative n count from the end) |
| Default[f,n,tot] | default value for the n argument when there are a total of tot arguments |
Default values.
A pattern like 
can match an expression like 
with several different choices of 
, 
, and 
. The choices with 
and 
of minimum length are tried first. In general, when there are multiple 
or 
in a single function, the case that is tried first takes all the 
and 
to stand for sequences of minimum length, except the last one, which stands for "the rest" of the arguments.
When 
or 
are present, the case that is tried first is the one in which none of them correspond to omitted arguments. Cases in which later arguments are dropped are tried next.
The order in which the different cases are tried can be changed using Shortest and Longest.
| Orderless |  and  are equivalent |
| Flat |  and  are equivalent |
| OneIdentity |  and x are equivalent |
Attributes used in matching patterns.
Pattern objects like 
can represent any sequence of arguments in a function f with attribute Flat. The value of x in this case is f applied to the sequence of arguments. If f has the attribute OneIdentity, then e is used instead of 
when x corresponds to a sequence of just one argument.
Assignments
| lhs=rhs | immediate assignment: rhs is evaluated at the time of assignment |
| lhs:=rhs | delayed assignment: rhs is evaluated when the value of lhs is requested |
The two basic types of assignment in Mathematica.
Assignments in Mathematica specify transformation rules for expressions. Every assignment that you make must be associated with a particular Mathematica symbol.
| f[args]=rhs | assignment is associated with f (downvalue) |
| t/:f[args]=rhs | assignment is associated with t (upvalue) |
| f[g[args]]^=rhs | assignment is associated with g (upvalue) |
Assignments associated with different symbols.
In the case of an assignment like 
, Mathematica looks at f, then the head of f, then the head of that, and so on, until it finds a symbol with which to associate the assignment.
When you make an assignment like 
, Mathematica will set up transformation rules associated with each distinct symbol that occurs either as an argument of lhs, or as the head of an argument of lhs.
The transformation rules associated with a particular symbol s are always stored in a definite order, and are tested in that order when they are used. Each time you make an assignment, the corresponding transformation rule is inserted at the end of the list of transformation rules associated with s, except in the following cases:
conditions on the right-hand side are also identical. In this case, the new transformation rule is inserted in place of the old one.Types of Values
| Attributes[f] | attributes of f |
| DefaultValues[f] | default values for arguments of f |
| DownValues[f] | values for  ,  , etc. |
| FormatValues[f] | print forms associated with f |
| Messages[f] | messages associated with f |
| NValues[f] | numerical values associated with f |
| Options[f] | defaults for options associated with f |
| OwnValues[f] | values for f itself |
| UpValues[f] | values for  |
Types of values associated with symbols.
Clearing and Removing Objects
| expr=. | clear a value defined for expr |
| f/:expr=. | clear a value associated with f defined for expr |
| Clear[s1,s2,...] | clear all values for the symbols  , except for attributes, messages, and defaults |
| ClearAll[s1,s2,...] | clear all values for the  , including attributes, messages, and defaults |
| Remove[s1,s2,...] | clear all values, and then remove the names of the  |
Ways to clear and remove objects.
In Clear, ClearAll, and Remove, each argument can be either a symbol or the name of a symbol as a string. String arguments can contain the metacharacters * and @ to specify action on all symbols whose names match the pattern.
Clear, ClearAll, and Remove do nothing to symbols with the attribute Protected.
Transformation Rules
| lhs->rhs | immediate rule: rhs is evaluated when the rule is first given |
| lhs:>rhs | delayed rule: rhs is evaluated when the rule is used |
The two basic types of transformation rules in Mathematica.
Replacements for pattern variables that appear in transformation rules are effectively done using ReplaceAll (the 
operator).
