Basic Mathematica

Revised 2008-Jan-31

Full documentation is available from The Mathematica website.

Please tell the Professor if you have suggestions for improvements to this documentation.

Running mathematica
Under Unix-based operating systems, type math to get the "programmers" interface, mathematica to get the Notebook interface. Each command you type yields a result. If you finish the command with a semicolon then the result will not be printed. (NB: In the notebook, you have to type Shift+Return to finish an expression.) Much of the notation will be familiar if you know how to program in C.
Expressions.
The usual operators work as expected:
```
x = 2*(3+4/2)
  10
x^2
  100
y = 2 (3+4/2)   (* you can leave out the "*" operator *)
  10
```
Mathematica treats numbers without decimal points as exact, and does not numerically evaluate them. To force numerical evaluation, use the N function, or put a decimal point in a number somewhere:
```
x = 70/10
  7
x = 70/9    (* No decimal point, so not evaluated *)
  70/9
x = 70.0/9
  7.77778
x = N[70/9]
  7.77778
```
Exponential notation is done by the "*^" sumbol,
```
3.5*^15;
3.5 * 10^15; (* same thing *)
```
To print numbers and text, just use Print. The SetPrecision function controls the number of digits printed.
```
Print["The log of ",3.5*^15," is ",Log[3.5*^15] ];
                 15
The log of 3.5 10   is 35.7915

Print["The log of ",3.5*^15," is ",SetPrecision[Log[3.5*^15],8] ];
                 15
The log of 3.5 10   is 35.791539
```
If you don't like the way exponentials are printed, use the "CForm" function to get the more standard "e" notation:
```
Print[CForm[3.5*^15]];
  3.5e15
```

Built-in mathematical functions
These are as you would expect, but they always start with a capital letter, and use square brackets:

Sqrt[2]*Cos[2*Pi]
  1.4142
ArcTan[4]
  ArcTan[4]  (* No decimal points, so not evaluated! *)
ArcTan[4.0]
  1.32582    (* all trig functions are in radians *)
5!       (* factorial *)
  120
Gamma[6] (* gamma function *)
  120

Note that π is given by Pi, and e by E.

User-defined functions
```
phi[x_] := 1/(1+x^2);
psi[x_,a_] := 1/(1+(x/a)^2);
```
You can use letters, numbers, and the dollar symbol in function/variable names. Here is a more complicated function, with local variables:
```
bump$fn[x_,a_] := Module[{l1,l2},
 l1 = x/a;  
 l2 = 1/(1+l1^2);
 Return[l2];
];
```
Plotting

One function:
```
Plot[ Cos[x], {x,-Pi,Pi} ];
```
The plot is itself a "Graphics" object that can be stored in a variable:
```
plot1 = Plot[ Cosh[x], {x,-Pi,Pi} ];
```
Plotting multiple functions:
```
Plot[ {Sin[x],Cos[x]}, {x,-Pi,Pi} ];
```
To specify the y-limits of the plot as well as the x-limits:
```
Plot[ Cos[x], {x,-Pi,Pi}, PlotRange->{-0.5,0.5}];
```
To write the plot to an encapsulated PostScript file, create it as a Graphics object and then "Export" it:
```
Export["file.eps",plot1];
```
Mathematica infers the format from the dot-extension of the filename. Other possibilities include png, pdf, svg, etc.

Numerical Integration

NIntegrate[ 1-x^2,{x,0,1}]
  0.666667

or, using a previously-defined function,

NIntegrate[ phi[x],{x,0,Infinity}]
  1.5708
NIntegrate[ psi[x,1.0],{x,0,1}]
  0.785398

Complex numbers

The square root of -1 is written is written as I.
```
Exp[I*3.0]
  -0.989992 + 0.14112 I
```
You can obtain real and imaginary parts of any expression using the Re and Im functions. Functions can accept complex arguments, so you can write things like
```
NIntegrate[ Exp[3*I*x] * Exp[-(x-1)^2],{x,-Infinity,Infinity}]
  -0.184946 + 0.0263634 I
```
Complex conjugate is the Conjugate function:
```
Conjugate[ 3 + 4 I ]
  3 - 4 I
```
You can plot the real and/or imaginary parts of a complex function:
```
f[x_] := Exp[(-2+3*I)*x];
Plot[ Re[f[x]], {x,0,2}];
Plot[ {Re[f[x]],Im[f[x]]}, {x,0,2}];
```

Arrays and Matrices
A 1D array is a list

v = {2.0, -1.0, 0.0} ;

A matrix or 2D array is a list of lists:

M = {
 {1.3, -2.0, 0.9},
 {-2.2, 0.3, 1.1},
 {-1.4, 1.5, -0.2}
};

Matrix multiplication or dot product uses the dot operator. Scalar multiplication uses "*",

w = 0.5 * M.v
  {2.3, -2.35, -2.15}
w.v
  6.95

There are many useful built-in matrix functions:

Minv = Inverse[M];
MT = Transpose[M];

evals = Eigenvalues[M]
  {2.91742, -1.69075, 0.173336}
evecs = Eigenvectors[M]
  {{-0.512376, 0.661041, 0.548175}, 
   {-0.587781, -0.775991, 0.228806}, 
   {0.397766, 0.553388, 0.731809}}

Norm[v]   (* sqrt of sum of absolute value squared of elements *)
  2.23607
Norm[M]
  3.59095

User defined functions of matrices are just like any other function. Here are some useful ones:

Commutator[a_,b_]    := a.b - b.a;
Anticommutator[a_,b_]:= a.b + b.a;
Adjoint[m_] := Transpose[Conjugate[m]];

Subscripting uses double square brackets. Subscripts start at 1. This is one of the differences between Mathematica and C or Python. (The "zeroth" element of a list is its type, actually).

v[[3]]
  0.
M[[2,3]]   (* treat M like a matrix *)
  1.1
M[[2]][[3]] (* treat M like a list of lists *)
  1.1

Printing matrices in a more readable form:

Print[MatrixForm[M]];

Sum and product

s = Sum[ 1.0/n, {n,1,100}]
  5.18738
s = Sum[ 1.0/n^2, {n,1,Infinity}]
  1.64493
p = Product[ (1+1.0/n),{n,1,10}]
  11.0

Programming
To read in and run a file containing mathematica commands:

<< mydefinitions.m

Flow-of-control: "for" loop, and "if" test:

For[mu=1,mu<=4,mu++,  (* mu++ means mu=mu+1, same as mu+=1 *)
 For[nu=1,nu<=4,nu++,
  If[mu==nu,
   Print[mu,"  ",nu,"   equal!"]
  , (* else *)
   Print[mu,"  ",nu]
  ]
 ]
];

Flow-of-control: "while" loop:

n=0; sum=0; x=1.5;
While[n<10,
 n = n+1;
 sum = sum + x^n/(n!);
];