Mathematica

I created Mathematica to be an integrated language and environment for computing in general, and technical computing in particular. Following its release in 1988, Mathematica has become very widely used in science, technology, education and elsewhere. (It is now also increasingly used as a component inside other software systems.)

Mathematica is available from Wolfram Research for all standard computer systems; much more information about it can be found on the web, especially from www.wolfram.com. There are many books about Mathematica—the original one being my *The Mathematica Book*.

The core of Mathematica is its language—which is based on the concept of symbolic programming. This language supports most traditional programming paradigms, but considerably generalizes them with the ideas of symbolic programming that I developed for it. In recent years there has started to be increasing use of the language component of Mathematica for all sorts of applications outside the area of technical computing where Mathematica as a whole has traditionally been most widely used.

The programs in these notes were created for Mathematica 4.1 (released 2000). They should run without any change in all subsequent versions of Mathematica, and the majority will also run in prior versions, all the way back to Mathematica 1* *(released 1988) or Mathematica 2 (released 1990). Most of the programs require only the language component of Mathematica—and not its mathematical knowledge base—and so should run in all software systems powered by Mathematica, in which language capabilities are enabled.

Here are examples of how some of the basic Mathematica constructs used in the notes in this book work:

• Iteration

Nest[f, x, 3] ⟶ f[f[f[x]]]

NestList[f, x, 3] ⟶ {x, f[x], f[f[x]], f[f[f[x]]]}

Fold[f, x, {1, 2}] ⟶ f[f[x, 1], 2]

FoldList[f, x, {1, 2}] ⟶ {x, f[x, 1], f[f[x, 1], 2]}

• Functional operations

Function[x, x + k][a] ⟶ a + k

(# + k&)[a] ⟶ a + k

(r[#1] + s[#2]&)[a, b] ⟶ r[a] + s[b]

Map[f, {a, b, c}] ⟶ {f[a], f[b], f[c]}

Apply[f, {a, b, c}] ⟶ f[a, b, c]

Select[{1, 2, 3, 4, 5}, EvenQ] ⟶ {2, 4}

MapIndexed[f, {a, b, c}] ⟶ {f[a, {1}], f[b, {2}], f[c, {3}]}

• List manipulation

{a, b, c, d}〚3〛 ⟶ c

{a, b, c, d}〚{2, 4, 3, 2}〛 ⟶ {b, d, c, b}

Take[{a, b, c, d, e}, 2] ⟶ {a, b}

Drop[{a, b, c, d, e}, -2] ⟶ {a, b, c}

Rest[{a, b, c, d}] ⟶ {b, c, d}

ReplacePart[{a, b, c, d}, x, 3] ⟶ {a, b, x, d}

Length[{a, b, c}] ⟶ 3

Range[5] ⟶ {1, 2, 3, 4, 5}

Table[f[i], {i, 4}] ⟶ {f[1], f[2], f[3], f[4]}

Table[f[i, j], {i, 2}, {j, 3}] ⟶ {{f[1, 1], f[1, 2], f[1, 3]}, {f[2, 1], f[2, 2], f[2, 3]}}

Array[f, {2, 2}] ⟶ {{f[1, 1], f[1, 2]}, {f[2, 1], f[2, 2]}}

Flatten[{{a, b}, {c}, {d, e}}] ⟶ {a, b, c, d, e}

Flatten[{{a, {b, c}}, {{d}, e}}, 1] ⟶ {a, {b, c}, {d}, e}

Partition[{a, b, c, d}, 2, 1] ⟶ {{a, b}, {b, c}, {c, d}}

Split[{a, a, a, b, b, a, a}] ⟶ {{a, a, a}, {b, b}, {a, a}}

ListConvolve[{a, b}, {1, 2, 3, 4, 5}] ⟶ {2a + b, 3a + 2b, 4a + 3b, 5a + 4b}

Position[{a, b, c, a, a}, a] ⟶ {{1}, {4}, {5}}

RotateLeft[{a, b, c, d, e}, 2] ⟶ {c, d, e, a, b}

Join[{a, b, c}, {d, b}] ⟶ {a, b, c, d, b}

Union[{a, a, c, b, b}] ⟶ {a, b, c}

• Transformation rules

{a, b, c, d} /. b p ⟶ {a, p, c, d}

{f[a], f[b], f[c]} /. f[a] p ⟶ {p, f[b], f[c]}

{f[a], f[b], f[c]} /. f[x_] p[x] ⟶ {p[a], p[b], p[c]}

{f[1], f[b], f[2]} /. f[x_Integer] p[x] ⟶ {p[1], f[b], p[2]}

{f[1, 2], f[3], f[4, 5]} /. f[x_, y_] x + y ⟶ {3, f[3], 9}

{f[1], g[2], f[2], g[3]} /. f[1] | g[_] p ⟶ {p, p, f[2], p}

• Numerical functions

Quotient[207, 10] ⟶ 20

Mod[207, 10] ⟶ 7

Floor[1.45] ⟶ 1

Ceiling[1.45] ⟶ 2

IntegerDigits[13, 2] ⟶ {1, 1, 0, 1}

IntegerDigits[13, 2, 6] ⟶ {0, 0, 1, 1, 0, 1}

DigitCount[13, 2, 1] ⟶ 3

FromDigits[{1, 1, 0, 1}, 2] ⟶ 13

The Mathematica programs in these notes are formatted in Mathematica StandardForm. The following table specifies how to enter these programs in Mathematica InputForm, using only ordinary keyboard characters: