# Some General Notations and Conventions

## Function Names

The names of built-in functions follow some general guidelines.

- The name consists of complete English words, or standard mathematical abbreviations. American spelling is used.

- The first letter of each word is capitalized.

- Functions whose names end with Q usually "ask a question", and return either True or False.

- Mathematical functions that are named after people usually have names in
*Mathematica* of the form PersonSymbol.

## Function Arguments

The main expression or object on which a built-in function acts is usually given as the first argument to the function. Subsidiary parameters appear as subsequent arguments.

The following are exceptions:

- In functions like Map and Apply, the function to apply comes before the expression it is to be applied to.

- In scoping constructs such as Module and Function, local variables and parameter names come before bodies.

- In functions like Write and Export, the name of the file is given before the objects to be written to it.

For mathematical functions, arguments that are written as subscripts in standard mathematical notation are given before those that are written as superscripts.

## Options

Some built-in functions can take

*options*. Each option has a name, represented as a symbol, or in some cases a string. Options are set by giving rules of the form

name->value or

name:>value. Such rules must appear after all the other arguments in a function. Rules for different options can be given in any order. If you do not explicitly give a rule for a particular option, a default setting for that option is used.

Options[f] | give the default rules for all options associated with f |

Options[expr] | give the options set in a particular expression |

Options[expr,name] | give the setting for the option name in an expression |

AbsoluteOptions[expr,name] | give the absolute setting for name, even if its actual setting is Automatic |

SetOptions[f,name->value,...] |

| set default rules for options associated with f |

CurrentValue[name] | give the option setting for the front end option name; can be used on the left-hand side of an assignment to set the option |

Operations on options.

## Part Numbering

n | element n (starting at 1) |

-n | element n from the end |

0 | head |

Numbering of parts.

## Sequence Specifications

All | all elements |

None | no elements |

n | elements 1 through n |

-n | last n elements |

{n} | element n only |

{m,n} | elements m through n (inclusive) |

{m,n,s} | elements m through n in steps of s |

Specifications for sequences of parts.

The sequence specification

{m, n, s} corresponds to elements

m,

m+s,

m+2s,

..., up to the largest element not greater than

n.

Sequence specifications are used in the functions

Drop,

Ordering,

StringDrop,

StringTake,

Take and

Thread.

## Level Specifications

n | levels 1 through n |

Infinity | levels 1 through Infinity |

{n} | level n only |

{n_{1},n_{2}} | levels n_{1} through n_{2} |

Heads->True | include heads of expressions |

Heads->False | do not include heads of expressions |

Level specifications.

The level in an expression corresponding to a non-negative integer

n is defined to consist of parts specified by

n indices. A negative level number

-n represents all parts of an expression that have depth

n. The depth of an expression,

Depth[expr], is the maximum number of indices needed to specify any part, plus one. Levels

*do not* include heads of expressions, except with the option setting

Heads->True. Level

0 is the whole expression. Level

-1 contains all symbols and other objects that have no subparts.

Ranges of levels specified by

{n_{1}, n_{2}} contain all parts that are neither above level

n_{1}, nor below level

n_{2} in the tree. The

n_{i} need not have the same sign. Thus, for example,

{2, -2} specifies subexpressions which occur anywhere below the top level, but above the leaves, of the expression tree.

Level specifications are used by functions such as

Apply,

Cases,

Count,

FreeQ,

Level,

Map,

MapIndexed,

Position,

Replace and

Scan. Note, however, that the default level specifications are not the same for all of these functions.

## Iterators

{i_{max}} | iterate i_{max} times |

{i,i_{max}} | i goes from 1 to i_{max} in steps of 1 |

{i,i_{min},i_{max}} | i goes from i_{min} to i_{max} in steps of 1 |

{i,i_{min},i_{max},di} | i goes from i_{min} to i_{max} in steps of di |

{i,list} | i takes on the successive values in list |

{i,i_{min},i_{max}},{j,j_{min},j_{max}},... | i goes from i_{min} to i_{max}, and for each value of i, j goes from j_{min} to j_{max}, etc. |

Iterator notation.

Iterators are used in such functions as

Sum,

Table,

Do and

Range.

The iteration parameters

i_{min}, i_{max} and

di do not need to be integers. The variable

i is given a sequence of values starting at

i_{min}, and increasing in steps of

di, stopping when the next value of

i would be greater than

i_{max}. The iteration parameters can be arbitrary symbolic expressions, so long as

(i_{max}-i_{min})/di is a number.

When several iteration variables are used, the limits for the later ones can depend on the values of earlier ones.

The variable

*i* can be any symbolic expression; it need not be a single symbol. The value of

*i* is automatically set up to be local to the iteration function. This is effectively done by wrapping a

Block construct containing

*i* around the iteration function.

The procedure for evaluating iteration functions is described in

"Evaluation".

## Scoping Constructs

Function[{x,...},body] | local parameters |

lhs->rhs and lhs:>rhs | local pattern names |

lhs=rhs and lhs:=rhs | local pattern names |

With[{x=x_{0},...},body] | local constants |

Module[{x,...},body] | local variables |

Block[{x,...},body] | local values of global variables |

DynamicModule[{x,...},body] | local variables in a Dynamic interface |

Scoping constructs in *Mathematica*. Functions in the first group scope variables lexically.

Scoping constructs allow the names or values of certain symbols to be local.

Some scoping contracts scope lexically, meaning that literal instances of the specified variables or patterns are replaced with appropriate values. When local variable names are required, symbols with names of the form

xxx are generally renamed to

xxx$. When nested scoping constructs are evaluated, new symbols are automatically generated in the inner scoping constructs so as to avoid name conflicts with symbols in outer scoping constructs.

When a transformation rule or definition is used,

ReplaceAll (

/.) is effectively used to replace the pattern names that appear on the right-hand side. Nevertheless, new symbols are generated when necessary to represent other objects that appear in scoping constructs on the right-hand side.

Each time it is evaluated,

Module generates symbols with unique names of the form

xxx$nnn as replacements for all local variables that appear in its body.

Block localizes the value of global variables. Any evaluations in the body of a block which rely on the global variable will use the locally specified value even if the variable does not explicitly appear in the body, but is only referenced through subsequent evaluation. The body of the

Block may also make changes to the global variable, but any such changes will only persist until the

Block has finished executing.

DynamicModule localizes its variables to each instance of the

DynamicModule output in a notebook. This means each copy of a

DynamicModule output created using copy and paste will use its own localized variables.

## Ordering of Expressions

The canonical ordering of expressions used automatically with the attribute

Orderless and in functions such as

Sort satisfies the following rules:

- Integers, rational and approximate real numbers are ordered by their numerical values.

- Complex numbers are ordered by their real parts, and in the event of a tie, by the absolute values of their imaginary parts.

- Symbols are ordered according to their names, and in the event of a tie, by their contexts.

- Expressions are usually ordered by comparing their parts in a depth-first manner. Shorter expressions come first.

- Powers and products are treated specially, and are ordered to correspond to terms in a polynomial.

- Strings are ordered as they would be in a dictionary, with the uppercase versions of letters coming after lowercase ones.

Ordinary letters appear first, followed in order by script, Gothic, double-struck, Greek and Hebrew. Mathematical operators appear in order of decreasing precedence.

## Mathematical Functions

The mathematical functions such as

Log[x] and

BesselJ[n, x] that are built into

*Mathematica* have a number of features in common.

- They carry the attribute Listable, so that they are automatically "threaded" over any lists that appear as arguments.

- They carry the attribute NumericFunction, so that they are assumed to give numerical values when their arguments are numerical.

- They give exact results in terms of integers, rational numbers and algebraic expressions in special cases.

- Except for functions whose arguments are always integers, mathematical functions in
*Mathematica* can be evaluated to any numerical precision, with any complex numbers as arguments. If a function is undefined for a particular set of arguments, it is returned in symbolic form in this case.

- Numerical evaluation leads to results of a precision no higher than can be justified on the basis of the precision of the arguments. Thus N[Gamma[27/10], 100] yields a high-precision result, but N[Gamma[2.7], 100] cannot.

- When possible, symbolic derivatives, integrals and series expansions of built-in mathematical functions are evaluated in terms of other built-in functions.

## Mathematical Constants

Mathematical constants such as

E and

Pi that are built into

*Mathematica* have the following properties:

- They do not have values as such.

- They have numerical values that can be found to any precision.

- They are treated as numeric quantities in NumericQ and elsewhere.

- They carry the attribute Constant, and so are treated as constants in derivatives.

## Protection

*Mathematica* allows you to make assignments that override the standard operation and meaning of built-in

*Mathematica* objects.

To make it difficult to make such assignments by mistake, most built-in

*Mathematica* objects have the attribute

Protected. If you want to make an assignment for a built-in object, you must first remove this attribute. You can do this by calling the function

Unprotect.

There are a few fundamental

*Mathematica* objects to which you absolutely cannot assign your own values. These objects carry the attribute

Locked, as well as

Protected. The

Locked attribute prevents you from changing any of the attributes, and thus from removing the

Protected attribute.

## Abbreviated String Patterns

Functions such as

StringMatchQ,

Names and

Remove allow you to give

*abbreviated string patterns*, as well as full string patterns specified by

StringExpression. Abbreviated string patterns can contain certain metacharacters, which can stand for sequences of ordinary characters.

* | zero or more characters |

@ | one or more characters excluding uppercase letters |

\\*, etc. | literal *, etc. |

Metacharacters used in abbreviated string patterns.