# Document Structure and Syntax¶

*Mathematica* largely lacks the kind of structures one might find in other languages. Instead of
having sections like \(\LaTeX\), it simply has blocks of code you can execute. And unlike
languages like *Python*, *C*, or *Java*, *Mathematica* will simply execute whatever block of code
is in focus. This eliminates the need for the “boilerplate” code that comes in many languages
of having to set up a particular “main” function to execute, by instead allowing the user
to essentially say “execute these lines”. To execute code in *Mathematica*, just hit
“Shift+Enter” with the code in focus (you’ll see sections as you type). You don’t need
to have the code highlighted to do so. You can have multiple lines to execute at once
by using just “Enter” between them, editing like normal text.

## Basic Constructs¶

As already seen, assignment of variables is quite easy, with the statement

```
x = 5
```

being read as “x is given the value 5”. Unlike mathematics where \(x=4\) is the same as
\(4=x\), in *Mathematica*, order matters. When we want to assign a variable, it must be
on the left-hand side, with the value on the right. We’ll look at solving equations later, but
for now, we’ll just allow variable assignment as written above.

Variables must start with a letter (or special character - see below), but can be as long as you’d like, including numbers after the first character. Punctuation generally cannot be used as a variable name.

Most statements in *Mathematica* produce some kind of output
(the above would output the value 5), but this can be hidden by ending the statement with a semicolon:

```
x = 5;
```

We can at any point redefine variables (just do another assignment) or “clear” them, which will
turn them into a symbol again, using the `Clear[x]` command, where `x` is the
variable we want to clear.

We can easily create functions and expressions of other variables:

```
f[x_] := x^2
e = x ^ 2
```

`f` is now the function \(f(x)=x^2\) and `e` is an expression. The difference is that if we have defined
a variable `x`, `e` will be that value squared. But `f` is still the function that squares its argument, rather
than giving the square of some pre-defined variable `x`. For example:

```
f[5]
e
x = 3;
e
f[4]
f[y]
f[x]
Clear[x];
f[x]
```

if executed sequentially will output:

```
25
x^2
9
16
y^2
9
x^2
```

One handy part of *Mathematica* is that it supports the use of variables as input to functions (as seen with
`f[y]` above). In that way, it can also handle function composition:

```
u[x_] := x^2;
v[x_] := x + 1;
u[v[y]]
```

has the output:

```
(y + 1)^2
```

Variable names can be any length, and can include numbers (after the first character). So the following are fine:

```
yankeeDoodle = 2
Fi5hF1ngersANDcustard = 16
```

Throughout the text, we frequently use single-character names for variables for length
(such as using `i` in a sum, or `f[x]` for functions). Just remember, we can
make variables as long as we want - these conventions are just for space.

## Order Matters¶

Although *Mathematica* allows the user to execute lines in any order, this can lead to complications.
For example:

```
x = 5;
x ^ 2
x = 2;
```

In the above example, if the statements are executed in the order above (as in most other programming languages), the value 25 would be printed. But, if we instead execute the last statement then the middle statement, the value 4 would be printed. As such, it is typically useful to not re-use variables within a program, or at the very least to separate the blocks of code such that you always fix the value before using it.

Fortunately, the *Mathematica* application shows you the order in which statements were run by indexing
each line of code with `In[EXEC_NUM]` and each line of output with `Out[EXEC_NUM]`. That way, when
using the language, you can backtrack what the values of variables/output should be.

However, in this textbook, unless otherwise noted, we will use the convention that all lines are executed and executed sequentially down the page.

## Building on Output¶

One construct that can be prone to errors, but can also make things easier to write if you’re careful
is similar to the “Ans” feature on many Texas Instruments graphing calculators, which allows you to
load previous results. In *Mathematica*, this is done with the `%` operator:

```
5
%^2
%%^3
%%%^3
```

This would print:

```
5
25
125
625
```

You can also use `%n`, which gives the output of the \(n^\textrm{th}\) execution, which is
even more prone to errors.

## Approximations¶

We will look at making physical approximations and solving problems numerically later on, but one useful
function to know about is the `N` function. The canonical example of the use of the N function is this:

```
pi_approx = N[Pi, 8]
```

which will take the built-in value \(\textrm{Pi}=\pi\) with 8 digit precision and assigns that value to “pi_approx”. It is a powerful tool to get down to actual values instead of more abstract expressions.

## Evaluating Symbolic Expressions¶

When we have an expression, such as `x^2`, we need not have `x` defined (as seen above) for *Mathematica*
to run. In fact, *Mathematica* gives us considerable flexibility if we choose not to define `x`, and
instead use the “replacement” operator (`/.`) instead:

```
g = x^2 + y
g/.x->5
g/.x->5/.y->2
g/.{x->5, y->2}
```

would output:

```
x^2 + y
25 + y
27
27
```

`/.` is telling *Mathematica* that you want to apply a particular set of values to variables in
the expression. The rule operator (`->`) is stating that the variable on the left hand side should take the value
on the right hand side. You can apply many such substitutions one after another (
`g/.x->5/.y->2`) or
apply many at once using curly braces (`g/.{x->5, y->2}`).

## Other Constructs¶

Two other constructs that will come in handy are comments and strings.

Comments are human-readable elements of the file that are not evaluated. They
are created by having a `(*` then as much text as you want until a `*)`. For example,

```
(*Here is some information about why I'm assigning x the value y...*)
x=y
(*It can span multiple
lines too.*)
```

Another useful consruct are strings. Strings are a way of passing text to *Mathematica*. We’ll
end up using strings for display purposes later, but the way we construct them is simple.

```
x = "This is a string, demarked by double-quotes on either side"
```

We can make a string from an expression `expr` with `ToString[expr]`, and
*concatenate*, or join together strings with `<>`. For example:

```
x = 5 ^ 2;
y = "5 ^ 2 is " <> ToString[x];
Print[y]
```

prints `5 ^ 2 is 25` as expected (the `Print` function prints the value, but
just as text, not as full output that could be used in another expression - to see the
same text as Output, we could have left off the semicolon on the definition for `y`).

Finally, we do have some options for what kinds of information we place in our Notebook file
in *Mathematica*. The default is Input (including comments), but we can use the “Format”
option from the menu bar then “Style” to make the current cell a different type, such as Title
or Text. These are great for longer comments, or for presenting your work directly from
*Mathematica* (rather than copying results to something like *PowerPoint*).

## Packages¶

On rare occasions, functions we’d like to have are part of *Mathematica* but not available
by default. To make them available, we can use the `Needs` function, which will
load a “package” (collection of functions) so that we can use them. For example,
to load the “ErrorBarPlots” package, we’ll use:

```
Needs["ErrorBarPlots`"]
```

Note that in addition to the double-quotes, we need the “backquote” or “backtick” character.
This is different from a single quote `'`, and is usually found at the upper-left
portion of a QWERTY keyboard with the tilde (`~`) character.

## Modules¶

After working with *Mathematica* for a while, you will notice that variables are
defined everywhere. If using complicated programming constructs, we might find it useful
to redefine values for a single function. In general, this is a topic in computer science
known as “scope”. This means that we can have a variable `x` in one section of code,
but have a variable defined elsewhere *also named* `x` with a different value.

To see this idea of “scope” in *Mathematica*, we can use a `Module`.
We define the local variables (where the scope is just in one function, not “global” for the
whole document) by placing all our code inside the module:

```
f[x_]:=x^2
g[x_]:= Module[{f}, f[y_]:=2^y;f[x]]
g[x]
g[3]
f[x]
f[3]
```

prints

```
2^x
8
x^2
9
```

What this shows is that no matter if `f` is already defined,
we can redefine it without affecting any of the externally defined versions by using a
`Module`. This is good for
shorthand when building complicated functions, and is necessary
for creating re-usable functions
for application to many projects (such as creating a package, which is not part of
this course, but can be found in *Mathematica* with the help URL
“tutorial/SettingUpMathematicaPackages”).

## Special Characters¶

Sometimes for readability, we may want to include a special character, such as
delta (\(\delta\)) in code to make things more readable. If we wanted
to look at the behavior of a function at \(f(x\pm\delta{x})\), wouldn’t it be
nice if we could just use \(\delta{x}\) as a variable? It turns out that we can.
*Mathematica* has Greek, Hebrew, extended Latin and other characters built in. We can access
them by name using `\[delta]`, for example, or by using the “Esc” key on the keyboard,
such as “Esc”+ `delta` +”Esc”. Most characters are just symbols to be used like any
other character, but some have additional properties. For example, `\[Transpose]`
can be used as

`{{1,2},{3,4}}\[Transpose]`

which, when copied into *Mathematica*, will look like \(\{\{1,2\},\{3,4\}\}^\top\).
For more, look at the *Mathematica* URL “tutorial/LettersAndLetterLikeForms”.