This document provides an introduction to Mathematica and its capabilities. It describes how to start Mathematica in both notebook and text-based interfaces on different platforms. It then covers basic numerical calculations, functions, equations, programming constructs, graphics, data visualization, and high performance computing in Mathematica including vectorization, GPU programming, and using CUDALink.

1. Introduction to Mathematica
Scientific Computing and Visualization
Boston University
Katia Oleinik
koleinik@bu.edu

2. Getting Started
Notebook and Text-Based Interfaces
To start Mathematica on SCC cluster, type mathematica (or Mathematica) at the prompt:
% mathematica
To start Mathematica Kernel ( text-base interface), type math at the prompt:
% math

3. Getting Started
Notebook and Text-Based Interfaces
To start Mathematica on Windows:
Start -> Wolfram Mathematica -> Wolfram Mathematica 9
To start Mathematica Kernel ( text-base interface) on Windows:
Start -> Wolfram Mathematica -> Wolfram Mathematica 9 Kernel

4. Getting Started
Notebook and Text-Based Interfaces
Notebook Interface Text-Based Interface
Start mathematica math
Execute command Shift-Enter Enter
Exit Choose the Quit menu item Cntr-D or Quit[]

5. Numerical Calculations
21.7 + 19.94
In[1] := 21.7 + 19.94
Out[1] := 41.64
Press Shift + Enter

6. Numerical Calculations
x+y+z add
x-y subtract
x/y divide
x y z or x*y*z multiply
x^y power
x*(y+z) control grouping by parentheses
Note: You can use space or a * sign for multiplication

7. Numerical Calculations
You get exact result with Mathematica unless you request otherwise.
In[1] := 2 ^ 100 (* get exact result *)
Out[1] := 1267650600228229401496703205376
In[2] := 2 ^ 100 //N (* get approximation *)
Out[2] := 1.26765x1030
In[3] := 1/3 + 2/7 (* get exact result *)
Out[3] :=
13
21
In[4] := 1/3 + 2/7 //N (* get approximation *)
Out[4] := 0.619048

8. Numerical Calculations
If an input number contains an explicit decimal point, Mathematica produces an
approximate numerical result.
In[5] := 11/3 + 2/7 (* exact result *)
Out[5] :=
83
21
In[6] := 1.1/3 + 2/7 (* approximation *)
Out[6] := 0.652381

9. Numerical Calculations
Sqrt[x] 𝑥
Exp[x] ex
Log[x] ln x
Log[b,x] logb x
Sin[x], Cos[x], Tan[x] trigonometric functions
ArcSin[x], ... inverse trigonometric functions
n! factorial
FactorInteger[n] prime factors of n
Abs[x] |x|
Round[x] closest integer to x
Max[x,y,...], Min[x,y,...] maximum and minimum of a set
Mod[n,m] remainder of division of n by m
Random[] random number between 0 and 1
Common Mathematical Functions

10. Numerical Calculations
Functions in Mathematica
• The arguments of ALL Mathematica functions are enclosed in square brackets;
• The names of built-in Mathematica functions begin with capital letters;
• Unless //N option or decimal point is present, Mathematica tries to output exact
value

11. Numerical Calculations
Pi π
E e
Degree π/180
I i = −1
Infinity ∞
Common Mathematical Constants
The names of all built-in constants begin with capital letters.

12. Numerical Calculations
Specify the degree of precision
In[1] := N[Pi, 30] (* approximation *)
Out[1] := 3.14159265358979323846264338328
In[2] := N[Sqrt[7], 10]
Out[2] := 2.645751311

13. Numerical Calculations
Using Previous Results - use with care!
In[1] := 7 + 3
Out[1] := 10
In[2] := % + 1
Out[2] := 11
• % the last result generated
• %% the next-to-last result
• %n the result on output line Out[n]
Note: % is always defined to be the last result that Mathematica generated. It can be
anywhere in the script!

14. Numerical Calculations
Variables definition
x = value assign a value to the variable x
x = y = value assign a value to both x and y
x = . or Clear[x] remove any value assigned to x
Notes:
• Mathematica is case-sensitive;
• To avoid confusion with built-in functions, choose names that start with lower-case
letters;
• x y means x times y;
• xy with no space means variable name xy;
• 5x means 5 times x;

15. Numerical Calculations
Lists of Objects
List is a collection of several objects in Mathematica
In[1] := vec = {2, 4, 1.8}
Out[1] := {2, 4, 1.8}
In[2] := vec^2
Out[2] := {4, 16, 3.24}
In[3] := vec/(vec-1)
Out[3] := {1,
4
3
, 2.25}
In[4] := vec[[2]] (* extract second element *)
Out[4] := 4
In[5] := Part[vec,1] (* extract first element *)
Out[5] := 2

16. Graphics
Partial list of Mathematica’s graphs
• Graphics, Graphics3D
• Plot, Plot3D
• ListPlot, ListLinePlot, ListContourPlot, ListPlot3D
• ListLogPlot, ListPolarPlot, ListSurfacePlot3D, ListContourPlot3D
• PrarametricPlot, PolarPlot, RevolutionPlot3D, SphericalPlot3D,
• DensityPlot, ReliefPlot
• GraphPlot, ArrayPlot
• RegionPlot, ContourPlot, RegionPlot3D

17. Graphics
Partial List of Graphics Options
option name default value
AspectRatio 1/GoldenRatio the height-to-width ratio for the plot;
Axes True whether to include axes
AxesLabel None labels to be put on the axes
Frame False draw a frame around the plot
GridLines None what grid lines to include
PlotLabel None an expression to be printed as a label for the plot
PlotRange Automatic the range of coordinates to include in the plot
Ticks Automatic what tick marks to draw if there are axes

18. Graphics
Basic Features for Visualization Functions
Feature Classes:
• Styles
• Colors, thickness, pointsize, opacity, …
• Element appearance and shape
• Labels
• Textual labels and tooltips
• Legends
• Interactions
• Built-in highlighting effects
• Use elements for buttons, popup windows and other events
• Metadata
• Wrapper used to include additional information
• ChartElementFunction[] for custom appearances

19. Graphics
Feature Scope
Options:
• Specified globally and uniformly
• Examples: ChartStyle, CHartLabels, LabelingFunction, Background
Wrappers:
• Wrapped directly around data
• Can be used at any level, allows for targeted use
• Can be nested
• Examples: Tooltip, Style, Button, Labeled

20. Data Visualization
Basic Statistics Plots
Bar Chart, PieChart, BubbleChart
Histogram, SmoothHistogram, Density Histogram, Histogram3D
QuantilePlot,
ProbabilityPlot, ProbabilityScalePlot
BoxWhiskerChart,
DistributionChart

21. Functions
Function Definition
Use underscore _ after a variable name (function argument)
f([x_] := x^2 + 4 x + 4
To execute a function, simply call it with a given value:
f[1]
Mathematica’s built-in functions start with upper-case letter. Start with lower case letter for
the user defined function.

22. Functions
Using Functions
Show function definition: ?f
Expend function: Expand[f[x + y + 1]]
Find derivative of a function: D[f[x], x]
Find integral of a function: Integrate[f[x] ,x]
Find definite integral of a function: Integrate[f[x] ,{x,0,1}]
Clear the definition of a function: Clear[f]

23. Equations
Solving equations
Define equation using double equal sign ==
Solve[4 x^2 + 4 x + 1 == 0]
Mathematica can solve an equation for one variable in terms of another
Solve[5 x^2 -2 Log[y] == 3 x,y]
Solve system of equations:
Solve[{x + 2 y == 5, 7 x – 5 x == -3},{x,y}]

24. Equations
Solving equations
Mathematica can solve algebraic equations in one variable for power less than 5 and
sometimes even higher. But there are some equations for which it is impossible to find the
root(s) algebraically. Mathematica will use Root object to represent the solution. Use N[%]
to evaluate the solution numerically.
In some cases Mathematica can solve equations involving other functions:
In[1] := Solve[Sin[x] == a, x]
Out[1] := {{ x -> ArcSin[a]}}

25. Equations
Solving equations
You can also find an approximate numerical solution using FindRoot[]:
In[1] := FindRoot[Cos[x] == x, {x,0}]
Out[1] := { x -> 0.739085}
Mathematica can solve system of simultaneous equations.
It can eliminate a variable in a system, using Eliminate[] function, or
simplify the system using Reduce[] function.

26. Programs
Programming Constructs
Assignments: = += ++ *= AppendTo
Loops: Do While For Table Nest
Conditionals: If Which Switch And(&&) Equal(==) Less(<) …
Flow Control: Return Throw Catch TimeConstrained
Scope Constructs: Module With Block
I/O: Print Input Pause Import OpenRead …

27. Code Optimization
How to speedup Mathematica code
Use Timing and AbsoluteTiming commands to measure the time of execution:
In[1] := Module[{x = 1/Pi},
Do[x = 3.5 x (1 - x),
{10^6}]; x] //AbsoluteTiming

28. Code Optimization
How to speedup Mathematica code
1. Use floating point approximation if you can and as early in the
code as possible
2. Compile Functions
3. Use parallelization options if possible
4. Use built-in functions
5. Use CudaLink if possible

29. HPC: Vectorization
Making a Compiled Function run in parallel is simple - the user only has to pass the
option RuntimeAttributes->"Listable". From there, Compile will run in as
many threads as there are on the system.
Automatic parallelization
raySpheresIntersectionColor =
Compile[ . . . , CompilationTarget -> "C",
RuntimeAttributes -> Listable];
rayTraceCompile[ . . . , raySpheresIntersectionColor[] ];
width = height = 300;
. . .
imgc = rayTraceCompile[centers, radii, colors, x, y];
Image[imgc]

30. HPC: GPU Programming
• Programming languages/environments that allow to write to program GPU to
perform general computations.
• CUDA works only on NVIDIA hardware and is proprietary
• OpenCL works on AMD and NVIDIA hardware and is an open standard
CUDA and OpenCL

31. HPC: GPU Programming
Speed!
Modern GPUs are capable to perform 3 TFlops/sec, while high end CPUs – 80GFlops/sec
Fastest supercomputer at the end on 90s, clocked 1TFlop/sec and now you can buy GPU
with the same speed for less than $500.
Speed comes from the hardware design.
Why GPU

32. HPC: GPU Programming
A way to use the Graphical Processing Unit (GPU) from within Mathematica integrating
with the user’s workflow
A way to load GPU programs into Mathematica and use them as functions
It is NOT an attempt to make all Mathematica functions utilize the GPU
It is NOT meant to automatically speed up Mathematica code
Require :
1. NVIDIA hardware
2. Recent video card driver
3. Supported C – compiler
CUDALink

33. HPC: GPU Programming
CUDALink contains many built-in function for performing linear algebra, list and image
processing, and Fourier analysis.
CUDALink
In[1] := Needs["CUDALink`"] (* Load CUDALink *)
In[2] := CUDAQ[] (* Check if system compatible with CUDA *)
Out[2] := TRUE
In[3] := CUDAInformation[] (* Get information about detected GPU *)
Out[3] := {1 -> {"Name" -> "Tesla M2070", "Clock Rate" -> 1147000,
"Compute Capabilities" -> 2., "GPU Overlap" -> 1,
"Maximum Block Dimensions" -> {1024, 1024, 64},
"Maximum Grid Dimensions" -> {65535, 65535, 65535},

34. HPC: GPU Programming
Once CUDALink is loaded built-in functions can be used:
CUDALink
In[1] := m1 = {{1, 1, 1}, {2, 2, 2}, {3, 3, 3}}
In[2] := m2 = {{0, 1, 0}, {1, 1, 1}, {0, 1, 0}}
In[3] := CUDADot[m1,m2] (* Multiply matricies*)
Out[2] := {{1, 3, 1}, {2, 6, 2}, {3, 9, 3}}

35. HPC: GPU Programming
Image Processing
CUDALink
In[1] := swan = Import["swan.JPG"]
Out[1] :=
In[2] := CUDAImageConvolve[swan, GaussianMatrix[16]] (* Convolution *)
Out[2] :=

36. This tutorial has been made possible by
Scientific Computing and Visualization
group
at Boston University.
Katia Oleinik
koleinik@bu.edu
http://www.bu.edu/tech/research/training/tutorials/list/