introducing mathematica

8/9/2019 Introducing Mathematica

1/19

Introducing athematica

John H. Lowenstein

Preface

This informal introduction toMathematica(a product of Wolfram Research, Inc.) is offered as a downloadable

resource for users of the textbookEssentials of Hamiltonian Dynamics(Cambridge University Press, 2012). The aim is

to familiarize the student with the core concepts and functions of Mathematicaprogramming, so that he or she can

very quickly become comfortable with computational methods in dealing with the illustrative examples and exercises

in the textbook. The scope ofMathematica obviously greatly exceeds what can be covered in these few pages, and soit is highly recommended that the student take full advantage of the excellent documentation which is included with

the software (accessible via the Help menu).

1. Getting started

Mathematicaconducts a dialogue with the user: you type in a mathematical expression, press Enter, andMathemat-

icaevaluates the expression according to rules which are either built-in or have been prescribed by you, displaying the

result as output. The input/output alternation continues until you quit the session, with all steps recorded in the cells of

your notebook.

The simplest expressions involve ordinary numbers (e.g. 1, 2, 3, . . . , 1/2, 2/3,

. . . , 3.14159), and the familiar operations and relations of arithmetic and logic.

Elementary numerical operations:

+ (plus), - (minus), * (times), / (divided by), ^ (to the power)

Elementary numerical relations:

== (is equal to), != (is not equal to),

< (is less than), > (is greater than),

= (is greater than or equal to)

Elementary logical relations:

|| (or), && (and), ! (not)

For example, 2+2 evaluates to 4 , 11) evaluates to False . Note that if

Mathematicacannot decide whether a relation is true or false (or more generally when there are no rules applicable to

the evaluation of an input expression), it simply outputs the expression unchanged. For instance, it is meaningless to

ask whether the complex number 2 + 3i is greater than 1 , and so evaluation of 2+3I > 1 yields the output 2+3i >

1 , together with a few words of friendly advice about he folly of trying to order the complex numbers.

This document was prepared as a Mathematica v.8 notebook.


2/19

Exercise 1. Evaluation of simple expressions.

Evaluate the following expressions "by hand" . Check your results using Mathematica.

1) 4 7 - 8 6

2) 4 (7 - 8) 6

3) 4 (7 - 8 6)

4) 3 3 3 27

5) (4 6 > 12 2) ||( -5/7 - 1 > -1/7

)

6) (4 < 5) && (5 < 6) && (6 < 7) && (7 < 4)

7) (3 9 - 35 5) (6 4 + 72 2)

8) 5/8 == 1/(1+1/(1+1/(1+1/(1+1))))

9) Is it possible to construct an expression involving only realnumbers whichMathematicawill be unable to evaluate

(except by cheating or simply outputting the input)?

10) Give an example of an expression which involves all three of the listed logical operations and which evaluates to

True .

In addition to numbers,Mathematicamanipulates abstract symbols ("unknowns") which you introduce. For this

purpose, you may use individual letters or strings of letters and numbers (i.e. words ), avoiding capitalization. Capital

ized words are used byMathematicafor its own built-in expressions (e.g. Pi for p, E for e , the base of natural

logarithms, I for i , the square-root of -1 , andAbs for the absolute-value function).

Numbers and abstract symbols are the simplest examples of whatMathematicarecognizes as legitimate expres

sions. They are elementary , in the sense that there are no rules which can be used to reduce them to simpler form. All

non-elementary expressions have the form

h[e1,e2,...en]

were h, e1, e2, ...,en are all expressions, which may or may not be elementary. The basicMathematica

operation (its part in the dialogue with you) is to evaluate expressions, i.e. to consult its stored list of rules to replace

the input expression by a well defined output expression. For example, the input expression 4*6 is actually short

hand for the more formal Times[4,6]. The sub-expressions Times, 4, and 6are all elementary, and cannotbe simplified. On the other hand,Mathematicahas built-in rules associated with expressions having Times as the

"head", namely the rules of multiplication, which allow Mathematica to replace Times[4,6] by the single number

24 . In the same way, the expression 3==5 is the shorthand form of Equal[3,5], which evaluates to False.

A compound expression

ex1;ex2;....;exn

is evaluated sequentially (left to right), with only the evaluated expression exn

displayed in the output. If exn is omitted, or replaced by Null , there is no output displayed, although the evalua

tion of ex1;ex2;....;ex(n-1); may have an effect on stored quantities. For example, the assignment

expression

a=3;

associates the rule "Replace a by 3" with the symbol a . Because of the semicolon, the evaluation of a=3;

creates no output , but of course, the effect of the evaluation is non-trivial. Henceforth, every time a appears in an

expression, it will be replaced by 3. The value can be changed by a new assignment, or cleared by evaluating

Clear[a]. At any time during yourMathematicasession, you can check what rules, if any, pertain to a particular

symbol. Evaluating ?a reveals all of the rules associated with the symbol a .

2 Introducing Mathematica


3/19

Often it is desirable to evaluate an expression with certain values inserted for the sysmbols, but without storing those

values for future use. For example, suppose we want to evaluate Sin[a*b] with a set equal to 0.75 and b set

equal to 1.09, but without permanently assigning those numerical values to a and b. We would evaluate

In[1]:= Sin@a * bD . 8a 0.75, b 1.092

3) x=3.1; y=2.5; z=1.9; (x^2 + y^2 +z^2)^(1/2)

4) a=1; a=2; b=a^3

5) Clear[a]; b=a

6) b=(a+1)/.a->1; c=b+1; a=b+c

7) a=2; a*b^2/.b->10

2. Functions

Afunctionquite generally is a rule which assigns to each member of a certain set (domain) a unique member of a

certain other set (range). A function inMathematicahas, not surprisingly, the additional requirement that the domain

and range are sets of expressionsin the strict sense discussed above. To define a function f depending on n variable

arguments we write

f[x1_,x2_,....,xn_]:= expression depending explicitly on x1,x2,....,xn

where the lower dashes following the argument names indicate that these are not specific expressions, but rather are

dummy variables which can take on arbitrary values within their respective domains, and the delayed assignmentsymbol := indicates that all expressions appearing on the righthand side are to be evaluated only at the time that the

function is evaluated. The distinction between := and = is a bit subtle, but should become clear through examination

of a simple example. Define a function g[x_]via

g[x_]:= a*x^2 + 1

Now evaluate

a=3;x=9;g[2]

to obtain the value 13 . Note that assigning the symbol xthe value 9 has no effect on the evaluation of g[2]

since the x appearing in the function definition is a dummy variable which is replaced by the argument 2 rather thanbeing evaluated according to the stored rule x=9associated with the symbol x.

The concept of assignment is a bit tricky, and is made more mysterious by the use of the equals sign in a way quite

different from ordinary mathematical usage. Consider, for instance, the expression

a=a^2

In ordinary algebra this would be an equation with only two numerical solutions, 0 and 1. But suppose we have

already assigned the value 3 to the symbol a. What happens when Mathematica evaluates a=a^2? Answer: first,

Introducing Mathematica3


4/19


5/19

Machine precision floating-point numbers. This is the most efficient way of handling real numbers in most applica-

tions. If your input number contains an explicit decimal point, Mathematicawill interpret it as having a certain

number (the machine precision) of significant digits. You can learn your computer's machine precision by evaluating

the built-in constant $MachinePrecision. To approximate an exact number rby a machine-precision floating-

point number, evaluate N[r].

Minimum and maximum precision. Mathematica has two stored constants, $MinPrecision and$MaxPrecision, which specify the minimum and maximum precision with which approximate real numbers are

represented. In the evaluation of N[r,digits]or SetPrecision[r,digits], with ran exact real number, if

digits is less than $MinPrecision, the assigned precision will be upgraded to$MinPrecision; if digits

exceeds $MaxPrecision, the assigned precision will be downgraded to$MaxPrecision. Since normally

$MinPrecisionand $MaxPrecisionhave the values 0 and infinity, respectively, the user can safely forget

about them. However, there is a useful application of these bounds which deserves mention here. If you would like to

perform a calculation using uniformprecision n, then you should set

$MaxPrecision = $MinPrecision = n;

Repeating a calculation with several different values of nis often a good way of testing whether round-off error is

playing a significant role.

4. Transcendental functions

Mathematicaincludes a large supply of built-in mathematical functions, including those normally found on a good

scientific calculator, namely Sqrt[z_], Exp[z_], Log[z_], Log[base_,z_], Sin[z_],

ArcSin[z_], Sinh[z_], ArcSinh[z_], etc. , as well as a fairly complete collection of the special func-

tions of mathematical physics, such as BesselJ[z_], EllipticK[m_], JacobiSN[u_,m_], etc.

Important: a function whose arguments are all exact will evaluate to an exact (not floating-point) quantity, so, for

example, Sin[2]evaluates to itself. To get the machine-precision numerical value, you should use either Sin[2.0] or

N[Sin[2]].

5. Lists

One of the most common types of non-elementary expressions is a list of numbers or, more generally, expressions,

written {e1,e2,....,en} or, more fully, List[e1,e2,...en]. Given alistmylist, you can extract itskth member by evaluatingmylist[[k]](not to be confused withmylist[k] !). The number of elements in

a listmylist is given by Length[mylist]. For use later on, we introduce a few of the built-inMathematica

functions pertaining to manipulation of lists.

JoinandAppendTo

The use of JoinandAppendTois obvious from the following examples:

In[2]:= Join[{1,2,3},{4,5,6}]

Out[2]= 81, 2, 3, 4, 5, 62,

Joined->True,PlotRange->{{-3,4},{-3,4}},

Axes->False,

Frame->True,

PlotStyle->PointSize[.1],

PlotStyle->Red

AxesStyle->RGBColor[0,1,0]

DisplayFunction->Identity

Exercise 5. Rootfinding using Plot[]

In this exercise we putMathematica's graphing power to use to solve a nontrivial mathematical problem. Define a

polynomial functionp(x) of the real variable x by

p@x_D := x^4 + 3 * x^3 - 2 * x^2 - 10 * x - 1 ;

We seek to find the largest real x for which p(x) = 0.

Very soon we shall develop a very elegant method for solving this class of problems, but for the time being we just

want to see how raw computational power can solve the problem without being very clever. To get a rough idea of the

solution we can make use ofMathematica's basic plotting function, Plot, to obtain the graph



9/19

In[24]:= Plot[p[x],{x,-3,3}]

Out[24]=

-3 -2 -1 1 2 3

10

20

30

The root of p(x) clearly lies between 1.6 and 1.8. To improve on our estimate, we "zoom in" and plot the function over

that small range of x values, centered about its midpoint:

In[25]:= Plot[p[1.7 + x],{x,-.1,.1}]

Out[25]= -0.10 -0.05 0.05 0.10

-3

-2

-1

1

2

Now we see that the function p(x) goes through zero between 1.71 and 1.73, and so we again use the Plot function to

zoom in on the relevant interval:

In[26]:= Plot[p[1.72 + x],{x,-.01,.01}]

Out[26]=

-0.010 -0.005 0.005 0.010

-0.4

-0.3

-0.2

-0.1

0.1

0.2

Continue in this fashion until you have determined the root with 12 significant figures.

Once you get the hang of it, you should be able to gain at least one digit of accuracy with each new plot.

Introducing Mathematica

9


10/19


11/19

2) The base of natural logarithms, e, can be approximated by the following sum:

e(n) =1

1!+

1

2!+L +

1

n!

Using Door Forand fac, define a Mathematicafunction e[n_] which, for any positive integer n, gives a

fractional approximation to e . Write this number as a decimal usingMathematica's built-in function N[x_,k_].

Calculate e(15) and compare withthe result of evaluating N[E,k] with the precision k appropriately chosen.

3) The natural logarithm of 2 has the following expansion as an infinite series:

ln 2 = (!1)k+1"

1

k

Define aMathematicafunction ln2[n_] which calculates the first n terms of the series and displays the result as a

decimal with 50 significant figures.

4) Repeat calculations (2) and (3) using the built-in function Sum. (Consult the documentation for the proper usage.)

Another useful application of iteration is to produce a table of values. For example, to create a table of the first 3

powers of the first 10 positive integers, we evaluate

In[13]:= powers={};Do[AppendTo[powers,{n,n^2,n^3}],{n,1,10}];powers

Out[15]= 881, 1, 1True.



12/19

It is often desirable to allow for an iterated evaluation to be interrupted under specific conditions, or for a particular

step to be omitted under specific conditions. These are accomplished by employing, together with Do and If , the

built-in functions Break[] and Continue[], respectively. If Break[] is encountered in any step, the

iteration sequence is immediately halted; if Continue[] is encountered, evaluation of the current step is halted

and the evaluation sequence proceeds to the next step. For, example, here is an expression which evaluates to thelargest integer whose square is less than 1000:

Do[ If[(n+1)^2>=1000,Break[]]; m=n , {n,1,50} ]; m

and here is one which evaluates to the sum of all elements of the list numlist which are greater than 5:

numlist={1,3,7,9,31,2,14,4,5,8};

sum=0;

For[n=1,n


13/19


14/19

Guessing the position of the largest root from Fig.2.1 to be 1.6, we apply f iteratively:

In[19]:= x = 1.6;TableForm@Table@x = f@xD, 86


15/19

Now let us construct Newton's map,

f(x) = x-p HxL

p' HxL =

x2+1

2 x,

which is graphed below.

-4 -2 2 4

-6

-4

-2

2

4

6

You can easily differentiate f(x) to get

f' (x) =x2-1

2 x2

, f !!(x) =1

x3

.

from which it follows (consistent with the appearance of the graph) that the function f(x) has a local maximum at x=

-1 and a local minimum at x = 1 . Let us zoom in on a small neighborhood of x = 1 to check the stability of the

fixed point of f(x) there. Since the function is behaving like (x-1)2 inear the fixed point x=1 , f(1.04) - 1 is

approximately (1/2) (.04)2 = .0008, and by the same reasoning, f(1.0008) -1 = 0.00000032, and f(1.00000032) -1 =

0.000 000 000 000 05 . It is clear that the secret of Newton's method's success lies in the vanishing of the derivative of

Newton's map at the fixed point. Each time the function f is applied, the already tiny error is squared, becoming

extremely tiny. That extremely tiny error is then squared, becoming absurdly tiny, etc.,etc. We can check that the

desired flatness of the Newton map is almost always true:

If f(x) = x-p(x)/p'(x), then f '(x)=p(x)p"(x)/p'(x)2 , which is equal to zero at any zero ofp(x), provided that it is a

simplezero where the slope of the graph p'(x) is not zero. A modified version of Newton's method can be used for

higher order zeroes, but we shall not pursue that issue here.

Exercise 11. Newton's method II

1) Calculate the zero of sinx near x = 3.0 with 15 significant figures using Newton's method, i.e. by calculating

the derivative of the function, defining Newton's mapping as aMathematicafunction, and applying the function



16/19

iteratively starting with a value of x known to be close to the exact root. See if you can automate the process using

the Do function, using Print to print out the result after each iteration. Use the built-in function Sin[x_].

Compare your result with N[Pi,18]. Plot the Newton mapping and see that it has a flat point at the expected value

ofx .

2) Calculate the natural logarithm of 1000 to 15 significant figures by finding the zero of the function ex-1000 . Again

you are to construct Newton's map and find the result by iteration. Use Plotto help you choose your initial value.Use the built-in function Exp[x_] or the built-in constant E. Compare your result with N[Log[1000],18]. Plot

the Newton mapping and see that it is flat at the expected value ofx.

9. Integrating differential equations

It is typical in the theoretical description of a moving particle to be given its initial state (position and velocity) and a

set of differential equationsof motion. Integration of the differential equations is generally not possible in exact form.

However, excellent approximation methods exist which, with the help of computers, make possible the numerical

integration of the equations. We will restrict our attention to a simple and reliable method of numerical integration,

namely the Runge-Kutta scheme, which works as follows.

We consider the case of a particle restricted to thex axis, with position at time t determined by the differential equation

dx

dt=f(x) , with x(0)=x0.

We want to approximate the continuous orbit x(t) by a sequencexn, n=0,1,2,... of approximate positions at times

tn = n dt, where dt is small and we want the differencexn+1-xnto coincide with the Taylor series expansion up to term

of order dt4:

xn+1 - xn = xHtn+1L - xHtnL = x HtnL dt +

1

2 !x..

HtnL dt2 +1

3 !x...

HtnL dt3 +1

4 !x....

HtnL dt4 +OIdt5M

where the dots denote time-differentiation. The Taylor coefficients can be expressed as known functions of x by

applying the differential equation:

x

= fHxL ,x..

= f' HxL fHxL ,

x

...

= f'' HxL HfHxL L2

+Hf' HxLL2

fHxL ,x....

= f''' HxL fHxL3 + 4 f'' HxL f' HxL fHxL2 + Hf' HxLL3 fHxL .

According to the Runge-Kutta prescription, we calculate the sequence of xnby iterating

xn+1 = RK4step@xnD

with RK4step defined by

In[22]:=RK4step[f_,dt_,z_]:= Module[{k1,k2,k3,k4}, k1=f[z]*dt;

k2=f[z+k1/2]*dt; k3=f[z+k2/2]*dt; k4=f[z+k3]*dt; z+(k1+2*k2+2*k3+k4)/6]

Here the functionModuleis used as a wrapper (instead of parentheses) for the function definition. The advantageis that the variables k1, k2, k3, k4are strictly localized within the definition, so that calling RK4step will not

disturb any assignments which you may previously have made to global variables with the same names. The same is

of course true of the dummy variables f, dt, and z.

Mathematicahas a very nice built-in function Seriesfor calculating Taylor series of functions. For example, to

compute the Taylor series of sin(e) about the point 0, to O(e18), we evaluate



17/19

In[23]:=Series@Sin@eD, 8e, 0, 18


18/19

In[30]:=ListPlot@xvorbit, AspectRatio Automatic,PlotStyle 8Black, [email protected]


19/19

In[33]:=TableForm@Table@z = 81, 0

introducing mathematica

Documents